clang-format

ixwebsocket/IXSocketAppleSSL.cpp

@@ -105,7 +105,9 @@ namespace ix
         }
     }
 
-    OSStatus SocketAppleSSL::writeToSocket(SSLConnectionRef connection, const void* data, size_t* len)
+    OSStatus SocketAppleSSL::writeToSocket(SSLConnectionRef connection,
+                                           const void* data,
+                                           size_t* len)
     {
         int fd = (int) (long) connection;
         if (fd < 0) return errSSLInternal;
@@ -165,7 +167,8 @@ namespace ix
 
             _sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType);
 
-            SSLSetIOFuncs(_sslContext, SocketAppleSSL::readFromSocket, SocketAppleSSL::writeToSocket);
+            SSLSetIOFuncs(
+                _sslContext, SocketAppleSSL::readFromSocket, SocketAppleSSL::writeToSocket);
             SSLSetConnection(_sslContext, (SSLConnectionRef)(long) _sockfd);
             SSLSetProtocolVersionMin(_sslContext, kTLSProtocol12);
             SSLSetPeerDomainName(_sslContext, host.c_str(), host.size());

ixwebsocket/IXSocketServer.cpp

@@ -11,8 +11,8 @@
 #include "IXSocketConnect.h"
 #include "IXSocketFactory.h"
 #include <assert.h>
-#include <stdio.h>
 #include <sstream>
+#include <stdio.h>
 #include <string.h>
 
 namespace ix

test/IXCobraChatTest.cpp

@@ -37,9 +37,7 @@ namespace
     class CobraChat
     {
     public:
-        CobraChat(const std::string& user,
+        CobraChat(const std::string& user, const std::string& session, const std::string& endpoint);
-                   const std::string& session,
-                   const std::string& endpoint);
 
         void subscribe(const std::string& channel);
         void start();

ws/ws.cpp

@@ -269,7 +269,9 @@ int main(int argc, char** argv)
     cobra2sentry->add_option("--rolesecret", rolesecret, "Role secret")->required();
     cobra2sentry->add_option("--dsn", dsn, "Sentry DSN");
     cobra2sentry->add_option("--jobs", jobs, "Number of thread sending events to Sentry");
-    cobra2sentry->add_option("--queue_size", maxQueueSize, "Size of the queue to hold messages before they are sent to Sentry");
+    cobra2sentry->add_option("--queue_size",
+                             maxQueueSize,
+                             "Size of the queue to hold messages before they are sent to Sentry");
     cobra2sentry->add_option("channel", channel, "Channel")->required();
     cobra2sentry->add_flag("-v", verbose, "Verbose");
     cobra2sentry->add_flag("-s", strict, "Strict mode. Error out when sending to sentry fails");
@@ -474,8 +476,14 @@ int main(int argc, char** argv)
     }
     else if (app.got_subcommand("snake"))
     {
-        ret = ix::ws_snake_main(
+        ret = ix::ws_snake_main(port,
-            port, hostname, redisHosts, redisPort, redisPassword, verbose, appsConfigPath, tlsOptions);
+                                hostname,
+                                redisHosts,
+                                redisPort,
+                                redisPassword,
+                                verbose,
+                                appsConfigPath,
+                                tlsOptions);
     }
     else if (app.got_subcommand("httpd"))
     {

ws/ws_broadcast_server.cpp

@@ -5,8 +5,8 @@
  */
 
 #include <ixwebsocket/IXWebSocketServer.h>
-#include <sstream>
 #include <spdlog/spdlog.h>
+#include <sstream>
 
 
 namespace ix
@@ -38,7 +38,8 @@ namespace ix
                 else if (msg->type == ix::WebSocketMessageType::Close)
                 {
                     spdlog::info("Closed connection: code {} reason {}",
-                                 msg->closeInfo.code, msg->closeInfo.reason);
+                                 msg->closeInfo.code,
+                                 msg->closeInfo.reason);
                 }
                 else if (msg->type == ix::WebSocketMessageType::Error)
                 {

ws/ws_chat.cpp

@@ -14,8 +14,8 @@
 #include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <queue>
-#include <sstream>
 #include <spdlog/spdlog.h>
+#include <sstream>
 
 // for convenience
 using json = nlohmann::json;

ws/ws_cobra_to_sentry.cpp

@@ -9,23 +9,24 @@
 #include <condition_variable>
 #include <ixcobra/IXCobraConnection.h>
 #include <ixsentry/IXSentryClient.h>
+#include <map>
 #include <mutex>
 #include <queue>
 #include <spdlog/spdlog.h>
 #include <sstream>
 #include <thread>
 #include <vector>
-#include <map>
 
 namespace ix
 {
     class QueueManager
     {
     public:
-        QueueManager(size_t maxQueueSize,
+        QueueManager(size_t maxQueueSize, std::atomic<bool>& stop)
-                     std::atomic<bool> &stop) : 
+            : _maxQueueSize(maxQueueSize)
-            _maxQueueSize(maxQueueSize),
+            , _stop(stop)
-            _stop(stop) {}
+        {
+        }
 
         Json::Value pop();
         void add(Json::Value msg);
@@ -136,95 +137,90 @@ namespace ix
 
         std::thread t1(timer);
 
-        auto sentrySender = [&queueManager,
+        auto sentrySender =
-                             verbose,
+            [&queueManager, verbose, &errorSending, &sentCount, &stop, &throttled, &dsn] {
-                             &errorSending,
+                SentryClient sentryClient(dsn);
-                             &sentCount,
-                             &stop,
-                             &throttled,
-                             &dsn] {
-            SentryClient sentryClient(dsn);
 
-            while (true)
+                while (true)
-            {
-                Json::Value msg = queueManager.pop();
-
-                if (msg.isNull()) continue;
-                if (stop) return;
-
-                auto ret = sentryClient.send(msg, verbose);
-                HttpResponsePtr response = ret.first;
-
-                if (!response)
                 {
-                    spdlog::warn("Null HTTP Response");
+                    Json::Value msg = queueManager.pop();
-                    continue;
-                }
 
-                if (verbose)
+                    if (msg.isNull()) continue;
-                {
+                    if (stop) return;
-                    for (auto it : response->headers)
+
+                    auto ret = sentryClient.send(msg, verbose);
+                    HttpResponsePtr response = ret.first;
+
+                    if (!response)
                     {
-                        spdlog::info("{}: {}", it.first, it.second);
+                        spdlog::warn("Null HTTP Response");
+                        continue;
                     }
 
-                    spdlog::info("Upload size: {}", response->uploadSize);
+                    if (verbose)
-                    spdlog::info("Download size: {}", response->downloadSize);
-
-                    spdlog::info("Status: {}", response->statusCode);
-                    if (response->errorCode != HttpErrorCode::Ok)
                     {
-                        spdlog::info("error message: {}", response->errorMsg);
+                        for (auto it : response->headers)
-                    }
-
-                    if (response->headers["Content-Type"] != "application/octet-stream")
-                    {
-                        spdlog::info("payload: {}", response->payload);
-                    }
-                }
-
-                if (response->statusCode != 200)
-                {
-                    spdlog::error("Error sending data to sentry: {}", response->statusCode);
-                    spdlog::error("Body: {}", ret.second);
-                    spdlog::error("Response: {}", response->payload);
-                    errorSending = true;
-
-                    // Error 429 Too Many Requests
-                    if (response->statusCode == 429)
-                    {
-                        auto retryAfter = response->headers["Retry-After"];
-                        std::stringstream ss;
-                        ss << retryAfter;
-                        int seconds;
-                        ss >> seconds;
-
-                        if (!ss.eof() || ss.fail())
                         {
-                            seconds = 30;
+                            spdlog::info("{}: {}", it.first, it.second);
-                            spdlog::warn("Error parsing Retry-After header. "
-                                         "Using {} for the sleep duration",
-                                         seconds);
                         }
 
-                        spdlog::warn("Error 429 - Too Many Requests. ws will sleep "
+                        spdlog::info("Upload size: {}", response->uploadSize);
-                                     "and retry after {} seconds",
+                        spdlog::info("Download size: {}", response->downloadSize);
-                                     retryAfter);
 
-                        throttled = true;
+                        spdlog::info("Status: {}", response->statusCode);
-                        auto duration = std::chrono::seconds(seconds);
+                        if (response->errorCode != HttpErrorCode::Ok)
-                        std::this_thread::sleep_for(duration);
+                        {
-                        throttled = false;
+                            spdlog::info("error message: {}", response->errorMsg);
+                        }
+
+                        if (response->headers["Content-Type"] != "application/octet-stream")
+                        {
+                            spdlog::info("payload: {}", response->payload);
+                        }
                     }
-                }
-                else
-                {
-                    ++sentCount;
-                }
 
-                if (stop) return;
+                    if (response->statusCode != 200)
-            }
+                    {
-        };
+                        spdlog::error("Error sending data to sentry: {}", response->statusCode);
+                        spdlog::error("Body: {}", ret.second);
+                        spdlog::error("Response: {}", response->payload);
+                        errorSending = true;
+
+                        // Error 429 Too Many Requests
+                        if (response->statusCode == 429)
+                        {
+                            auto retryAfter = response->headers["Retry-After"];
+                            std::stringstream ss;
+                            ss << retryAfter;
+                            int seconds;
+                            ss >> seconds;
+
+                            if (!ss.eof() || ss.fail())
+                            {
+                                seconds = 30;
+                                spdlog::warn("Error parsing Retry-After header. "
+                                             "Using {} for the sleep duration",
+                                             seconds);
+                            }
+
+                            spdlog::warn("Error 429 - Too Many Requests. ws will sleep "
+                                         "and retry after {} seconds",
+                                         retryAfter);
+
+                            throttled = true;
+                            auto duration = std::chrono::seconds(seconds);
+                            std::this_thread::sleep_for(duration);
+                            throttled = false;
+                        }
+                    }
+                    else
+                    {
+                        ++sentCount;
+                    }
+
+                    if (stop) return;
+                }
+            };
 
         // Create a thread pool
         spdlog::info("Starting {} sentry sender jobs", jobs);
@@ -241,12 +237,11 @@ namespace ix
                                verbose,
                                &throttled,
                                &receivedCount,
-                               &queueManager](
+                               &queueManager](ix::CobraConnectionEventType eventType,
-                                        ix::CobraConnectionEventType eventType,
+                                              const std::string& errMsg,
-                                        const std::string& errMsg,
+                                              const ix::WebSocketHttpHeaders& headers,
-                                        const ix::WebSocketHttpHeaders& headers,
+                                              const std::string& subscriptionId,
-                                        const std::string& subscriptionId,
+                                              CobraConnection::MsgId msgId) {
-                                        CobraConnection::MsgId msgId) {
             if (eventType == ix::CobraConnection_EventType_Open)
             {
                 spdlog::info("Subscriber connected");
@@ -265,11 +260,8 @@ namespace ix
                 spdlog::info("Subscriber authenticated");
                 conn.subscribe(channel,
                                filter,
-                               [&jsonWriter,
+                               [&jsonWriter, verbose, &throttled, &receivedCount, &queueManager](
-                                verbose,
+                                   const Json::Value& msg) {
-                                &throttled,
-                                &receivedCount,
-                                &queueManager](const Json::Value& msg) {
                                    if (verbose)
                                    {
                                        spdlog::info(jsonWriter.write(msg));

ws/ws_cobra_to_statsd.cpp

@@ -22,10 +22,11 @@ namespace
     class QueueManager
     {
     public:
-        QueueManager(size_t maxQueueSize,
+        QueueManager(size_t maxQueueSize, std::atomic<bool>& stop)
-                     std::atomic<bool> &stop) : 
+            : _maxQueueSize(maxQueueSize)
-            _maxQueueSize(maxQueueSize),
+            , _stop(stop)
-            _stop(stop) {}
+        {
+        }
 
         Json::Value pop();
         void add(Json::Value msg);
@@ -67,7 +68,7 @@ namespace
             _condition.notify_one();
         }
     }
-}
+} // namespace
 
 namespace ix
 {
@@ -152,17 +153,11 @@ namespace ix
 
         std::thread t1(timer);
 
-        auto statsdSender = [&queueManager,
+        auto statsdSender = [&queueManager, &host, &port, &sentCount, &tokens, &prefix, &stop] {
-                             &host,
-                             &port,
-                             &sentCount,
-                             &tokens,
-                             &prefix,
-                             &stop] {
             // statsd client
             // test with netcat as a server: `nc -ul 8125`
             bool statsdBatch = true;
-#ifndef     _WIN32
+#ifndef _WIN32
             statsd::StatsdClient statsdClient(host, port, prefix, statsdBatch);
 #else
             int statsdClient;
@@ -191,69 +186,65 @@ namespace ix
 
         std::thread t2(statsdSender);
 
-        conn.setEventCallback([&conn,
+        conn.setEventCallback(
-                               &channel,
+            [&conn, &channel, &filter, &jsonWriter, verbose, &queueManager, &receivedCount](
-                               &filter,
+                ix::CobraConnectionEventType eventType,
-                               &jsonWriter,
+                const std::string& errMsg,
-                               verbose,
+                const ix::WebSocketHttpHeaders& headers,
-                               &queueManager,
+                const std::string& subscriptionId,
-                               &receivedCount](ix::CobraConnectionEventType eventType,
+                CobraConnection::MsgId msgId) {
-                                          const std::string& errMsg,
+                if (eventType == ix::CobraConnection_EventType_Open)
-                                          const ix::WebSocketHttpHeaders& headers,
-                                          const std::string& subscriptionId,
-                                          CobraConnection::MsgId msgId) {
-            if (eventType == ix::CobraConnection_EventType_Open)
-            {
-                spdlog::info("Subscriber connected");
-
-                for (auto it : headers)
                 {
-                    spdlog::info("{}: {}", it.first, it.second);
+                    spdlog::info("Subscriber connected");
+
+                    for (auto it : headers)
+                    {
+                        spdlog::info("{}: {}", it.first, it.second);
+                    }
                 }
-            }
+                if (eventType == ix::CobraConnection_EventType_Closed)
-            if (eventType == ix::CobraConnection_EventType_Closed)
+                {
-            {
+                    spdlog::info("Subscriber closed");
-                spdlog::info("Subscriber closed");
+                }
-            }
+                else if (eventType == ix::CobraConnection_EventType_Authenticated)
-            else if (eventType == ix::CobraConnection_EventType_Authenticated)
+                {
-            {
+                    spdlog::info("Subscriber authenticated");
-                spdlog::info("Subscriber authenticated");
+                    conn.subscribe(channel,
-                conn.subscribe(channel,
+                                   filter,
-                               filter,
+                                   [&jsonWriter, &queueManager, verbose, &receivedCount](
-                               [&jsonWriter, &queueManager, verbose, &receivedCount](
+                                       const Json::Value& msg) {
-                                   const Json::Value& msg) {
+                                       if (verbose)
-                                   if (verbose)
+                                       {
-                                   {
+                                           spdlog::info(jsonWriter.write(msg));
-                                       spdlog::info(jsonWriter.write(msg));
+                                       }
-                                   }
 
-                                   receivedCount++;
+                                       receivedCount++;
 
-                                   ++receivedCount;
+                                       ++receivedCount;
-                                   queueManager.add(msg);
+                                       queueManager.add(msg);
-                               });
+                                   });
-            }
+                }
-            else if (eventType == ix::CobraConnection_EventType_Subscribed)
+                else if (eventType == ix::CobraConnection_EventType_Subscribed)
-            {
+                {
-                spdlog::info("Subscriber: subscribed to channel {}", subscriptionId);
+                    spdlog::info("Subscriber: subscribed to channel {}", subscriptionId);
-            }
+                }
-            else if (eventType == ix::CobraConnection_EventType_UnSubscribed)
+                else if (eventType == ix::CobraConnection_EventType_UnSubscribed)
-            {
+                {
-                spdlog::info("Subscriber: unsubscribed from channel {}", subscriptionId);
+                    spdlog::info("Subscriber: unsubscribed from channel {}", subscriptionId);
-            }
+                }
-            else if (eventType == ix::CobraConnection_EventType_Error)
+                else if (eventType == ix::CobraConnection_EventType_Error)
-            {
+                {
-                spdlog::error("Subscriber: error {}", errMsg);
+                    spdlog::error("Subscriber: error {}", errMsg);
-            }
+                }
-            else if (eventType == ix::CobraConnection_EventType_Published)
+                else if (eventType == ix::CobraConnection_EventType_Published)
-            {
+                {
-                spdlog::error("Published message hacked: {}", msgId);
+                    spdlog::error("Published message hacked: {}", msgId);
-            }
+                }
-            else if (eventType == ix::CobraConnection_EventType_Pong)
+                else if (eventType == ix::CobraConnection_EventType_Pong)
-            {
+                {
-                spdlog::info("Received websocket pong");
+                    spdlog::info("Received websocket pong");
-            }
+                }
-        });
+            });
 
         while (true)
         {

ws/ws_ping_pong.cpp

@@ -4,12 +4,12 @@
  *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
  */
 
+#include <iostream>
 #include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <spdlog/spdlog.h>
 #include <sstream>
-#include <iostream>
 
 namespace ix
 {

ws/ws_proxy_server.cpp

@@ -61,7 +61,7 @@ namespace ix
 
             // Server connection
             state->webSocket().setOnMessageCallback([webSocket, state, verbose](
-                                                     const WebSocketMessagePtr& msg) {
+                                                        const WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     spdlog::info("New connection to remote server");
@@ -101,61 +101,61 @@ namespace ix
             });
 
             // Client connection
-            webSocket->setOnMessageCallback([state, remoteUrl, verbose](
+            webSocket->setOnMessageCallback(
-                                                const WebSocketMessagePtr& msg) {
+                [state, remoteUrl, verbose](const WebSocketMessagePtr& msg) {
-                if (msg->type == ix::WebSocketMessageType::Open)
+                    if (msg->type == ix::WebSocketMessageType::Open)
-                {
-                    spdlog::info("New connection from client");
-                    spdlog::info("id: {}", state->getId());
-                    spdlog::info("Uri: {}", msg->openInfo.uri);
-                    spdlog::info("Headers:");
-                    for (auto it : msg->openInfo.headers)
                     {
-                        spdlog::info("{}: {}", it.first, it.second);
+                        spdlog::info("New connection from client");
+                        spdlog::info("id: {}", state->getId());
+                        spdlog::info("Uri: {}", msg->openInfo.uri);
+                        spdlog::info("Headers:");
+                        for (auto it : msg->openInfo.headers)
+                        {
+                            spdlog::info("{}: {}", it.first, it.second);
+                        }
+
+                        // Connect to the 'real' server
+                        std::string url(remoteUrl);
+                        url += msg->openInfo.uri;
+                        state->webSocket().setUrl(url);
+                        state->webSocket().disableAutomaticReconnection();
+                        state->webSocket().start();
+
+                        // we should sleep here for a bit until we've established the
+                        // connection with the remote server
+                        while (state->webSocket().getReadyState() != ReadyState::Open)
+                        {
+                            spdlog::info("waiting for server connection establishment");
+                            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                        }
+                        spdlog::info("server connection established");
                     }
-
+                    else if (msg->type == ix::WebSocketMessageType::Close)
-                    // Connect to the 'real' server
-                    std::string url(remoteUrl);
-                    url += msg->openInfo.uri;
-                    state->webSocket().setUrl(url);
-                    state->webSocket().disableAutomaticReconnection();
-                    state->webSocket().start();
-
-                    // we should sleep here for a bit until we've established the
-                    // connection with the remote server
-                    while (state->webSocket().getReadyState() != ReadyState::Open)
                     {
-                        spdlog::info("waiting for server connection establishment");
+                        spdlog::info("Closed client connection: client id {} code {} reason {}",
-                        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                                     state->getId(),
+                                     msg->closeInfo.code,
+                                     msg->closeInfo.reason);
+                        state->webSocket().close(msg->closeInfo.code, msg->closeInfo.reason);
                     }
-                    spdlog::info("server connection established");
+                    else if (msg->type == ix::WebSocketMessageType::Error)
-                }
-                else if (msg->type == ix::WebSocketMessageType::Close)
-                {
-                    spdlog::info("Closed client connection: client id {} code {} reason {}",
-                                 state->getId(),
-                                 msg->closeInfo.code,
-                                 msg->closeInfo.reason);
-                    state->webSocket().close(msg->closeInfo.code, msg->closeInfo.reason);
-                }
-                else if (msg->type == ix::WebSocketMessageType::Error)
-                {
-                    spdlog::error("Connection error: {}", msg->errorInfo.reason);
-                    spdlog::error("#retries: {}", msg->errorInfo.retries);
-                    spdlog::error("Wait time(ms): {}", msg->errorInfo.wait_time);
-                    spdlog::error("HTTP Status: {}", msg->errorInfo.http_status);
-                }
-                else if (msg->type == ix::WebSocketMessageType::Message)
-                {
-                    spdlog::info("Received {} bytes from client", msg->wireSize);
-                    if (verbose)
                     {
-                        spdlog::info("payload {}", msg->str);
+                        spdlog::error("Connection error: {}", msg->errorInfo.reason);
+                        spdlog::error("#retries: {}", msg->errorInfo.retries);
+                        spdlog::error("Wait time(ms): {}", msg->errorInfo.wait_time);
+                        spdlog::error("HTTP Status: {}", msg->errorInfo.http_status);
                     }
+                    else if (msg->type == ix::WebSocketMessageType::Message)
+                    {
+                        spdlog::info("Received {} bytes from client", msg->wireSize);
+                        if (verbose)
+                        {
+                            spdlog::info("payload {}", msg->str);
+                        }
 
-                    state->webSocket().send(msg->str, msg->binary);
+                        state->webSocket().send(msg->str, msg->binary);
-                }
+                    }
-            });
+                });
         });
 
         auto res = server.listen();

ws/ws_receive.cpp

@@ -14,8 +14,8 @@
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <msgpack11/msgpack11.hpp>
-#include <spdlog/spdlog.h>
 #include <mutex>
+#include <spdlog/spdlog.h>
 #include <sstream>
 #include <vector>
 

ws/ws_send.cpp

@@ -14,8 +14,8 @@
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <msgpack11/msgpack11.hpp>
-#include <spdlog/spdlog.h>
 #include <mutex>
+#include <spdlog/spdlog.h>
 #include <sstream>
 #include <vector>
 

ws/ws_transfer.cpp

@@ -70,19 +70,23 @@ namespace ix
                             if (readyState == ReadyState::Open)
                             {
                                 ++receivers;
-                                client->send(msg->str,
+                                client->send(
-                                             msg->binary,
+                                    msg->str, msg->binary, [&id](int current, int total) -> bool {
-                                             [&id](int current, int total) -> bool {
+                                        spdlog::info("{}: [client {}]: Step {} out of {}",
-                                                 spdlog::info("{}: [client {}]: Step {} out of {}",
+                                                     "ws_transfer",
-                                                              "ws_transfer", id, current, total);
+                                                     id,
-                                                 return true;
+                                                     current,
-                                             });
+                                                     total);
+                                        return true;
+                                    });
                                 do
                                 {
                                     size_t bufferedAmount = client->bufferedAmount();
 
                                     spdlog::info("{}: [client {}]: {} bytes left to send",
-                                                 "ws_transfer", id, bufferedAmount);
+                                                 "ws_transfer",
+                                                 id,
+                                                 bufferedAmount);
 
                                     std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
@@ -97,8 +101,12 @@ namespace ix
                                         : readyState == ReadyState::Closing ? "Closing" : "Closed";
                                 size_t bufferedAmount = client->bufferedAmount();
 
-                                spdlog::info("{}: [client {}]: has readystate {} bytes left to be sent",
+                                spdlog::info(
-                                             "ws_transfer", id, readyStateString, bufferedAmount);
+                                    "{}: [client {}]: has readystate {} bytes left to be sent",
+                                    "ws_transfer",
+                                    id,
+                                    readyStateString,
+                                    bufferedAmount);
                             }
                         }
                     }