Restoring authorship annotation for <unril@yandex-team.ru>. Commit 2 of 2.

17 files changed, 918 insertions, 918 deletions

diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/DNS.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/DNS.cpp
index f0f01c0357..ce588150e2 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/DNS.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/DNS.cpp
@@ -4,7 +4,7 @@
  */
 
 #include <aws/core/utils/DNS.h>
-#include <aws/core/utils/StringUtils.h> 
+#include <aws/core/utils/StringUtils.h>
 
 namespace Aws
 {
@@ -24,32 +24,32 @@ namespace Aws
             if (label.size() > 63)
                 return false;
 
-            if (!StringUtils::IsAlnum(label.front())) 
+            if (!StringUtils::IsAlnum(label.front()))
                 return false; // '-' is not acceptable as the first character
 
-            if (!StringUtils::IsAlnum(label.back())) 
+            if (!StringUtils::IsAlnum(label.back()))
                 return false; // '-' is not acceptable as the last  character
 
             for (size_t i = 1, e = label.size() - 1; i < e; ++i)
             {
                 auto c = label[i];
-                if (c != '-' && !StringUtils::IsAlnum(c)) 
+                if (c != '-' && !StringUtils::IsAlnum(c))
                     return false;
             }
 
             return true;
         }
- 
-        bool IsValidHost(const Aws::String& host) 
-        { 
-            // Valid DNS hostnames are composed of valid DNS labels separated by a period. 
-            auto labels = StringUtils::Split(host, '.'); 
-            if (labels.empty())  
-            { 
-                return false; 
-            } 
- 
-            return !std::any_of(labels.begin(), labels.end(), [](const Aws::String& label){ return !IsValidDnsLabel(label); }); 
-        } 
+
+        bool IsValidHost(const Aws::String& host)
+        {
+            // Valid DNS hostnames are composed of valid DNS labels separated by a period.
+            auto labels = StringUtils::Split(host, '.');
+            if (labels.empty()) 
+            {
+                return false;
+            }
+
+            return !std::any_of(labels.begin(), labels.end(), [](const Aws::String& label){ return !IsValidDnsLabel(label); });
+        }
     }
 }
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/FileSystemUtils.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/FileSystemUtils.cpp
index e99dae04ce..c47f750960 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/FileSystemUtils.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/FileSystemUtils.cpp
@@ -17,7 +17,7 @@ Aws::String PathUtils::GetFileNameFromPathWithoutExt(const Aws::String& path)
     } 
     if (endPos == 0) // fileName is "."
     {
-        return {}; 
+        return {};
     }
 
     return fileName.substr(0, endPos);
@@ -33,7 +33,7 @@ Aws::String PathUtils::GetFileNameFromPathWithExt(const Aws::String& path)
     size_t startPos = path.find_last_of(Aws::FileSystem::PATH_DELIM);
     if (startPos == path.size() - 1)
     {
-        return {}; 
+        return {};
     }
 
     if (startPos == std::string::npos)
@@ -48,4 +48,4 @@ Aws::String PathUtils::GetFileNameFromPathWithExt(const Aws::String& path)
     size_t endPos = path.size() - 1;
     
     return path.substr(startPos, endPos - startPos + 1);
-} 
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/HashingUtils.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/HashingUtils.cpp
index ed4f3bf765..147bddf33e 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/HashingUtils.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/HashingUtils.cpp
@@ -5,7 +5,7 @@
 
 #include <aws/core/utils/logging/LogMacros.h>
 #include <aws/core/utils/HashingUtils.h>
-#include <aws/core/utils/StringUtils.h> 
+#include <aws/core/utils/StringUtils.h>
 #include <aws/core/utils/base64/Base64.h>
 #include <aws/core/utils/crypto/Sha256.h>
 #include <aws/core/utils/crypto/Sha256HMAC.h>
@@ -139,16 +139,16 @@ ByteBuffer HashingUtils::CalculateSHA256TreeHash(Aws::IOStream& stream)
 
 Aws::String HashingUtils::HexEncode(const ByteBuffer& message)
 {
-    Aws::String encoded; 
-    encoded.reserve(2 * message.GetLength()); 
+    Aws::String encoded;
+    encoded.reserve(2 * message.GetLength());
 
     for (unsigned i = 0; i < message.GetLength(); ++i)
     {
-        encoded.push_back("0123456789abcdef"[message[i] >> 4]); 
-        encoded.push_back("0123456789abcdef"[message[i] & 0x0f]); 
+        encoded.push_back("0123456789abcdef"[message[i] >> 4]);
+        encoded.push_back("0123456789abcdef"[message[i] & 0x0f]);
     }
 
-    return encoded; 
+    return encoded;
 }
 
 ByteBuffer HashingUtils::HexDecode(const Aws::String& str)
@@ -176,7 +176,7 @@ ByteBuffer HashingUtils::HexDecode(const Aws::String& str)
 
     for (size_t i = readIndex; i < str.length(); i += 2)
     {
-        if(!StringUtils::IsAlnum(str[i]) || !StringUtils::IsAlnum(str[i + 1])) 
+        if(!StringUtils::IsAlnum(str[i]) || !StringUtils::IsAlnum(str[i + 1]))
         {
             //contains non-hex characters
             assert(0);
@@ -226,7 +226,7 @@ int HashingUtils::HashString(const char* strToHash)
     if (!strToHash)
         return 0;
 
-    unsigned hash = 0; 
+    unsigned hash = 0;
     while (char charValue = *strToHash++)
     {
         hash = charValue + 31 * hash;    
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/StringUtils.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/StringUtils.cpp
index 22e3c8e973..e1deb3f046 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/StringUtils.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/StringUtils.cpp
@@ -155,8 +155,8 @@ Aws::String StringUtils::URLEncode(const char* unsafe)
     size_t unsafeLength = strlen(unsafe);
     for (auto i = unsafe, n = unsafe + unsafeLength; i != n; ++i)
     {
-        char c = *i; 
-        if (IsAlnum(c) || c == '-' || c == '_' || c == '.' || c == '~') 
+        char c = *i;
+        if (IsAlnum(c) || c == '-' || c == '_' || c == '.' || c == '~')
         {
             escaped << (char)c;
         }
@@ -209,77 +209,77 @@ Aws::String StringUtils::URLEncode(double unsafe)
 
 Aws::String StringUtils::URLDecode(const char* safe)
 {
-    Aws::String unescaped; 
+    Aws::String unescaped;
 
-    for (; *safe; safe++) 
+    for (; *safe; safe++)
     {
-        switch(*safe) 
+        switch(*safe)
         {
-            case '%': 
-            { 
-                int hex = 0; 
-                auto ch = *++safe; 
-                if (ch >= '0' && ch <= '9') 
-                { 
-                    hex = (ch - '0') * 16; 
-                } 
-                else if (ch >= 'A' && ch <= 'F') 
-                { 
-                    hex = (ch - 'A' + 10) * 16; 
-                } 
-                else if (ch >= 'a' && ch <= 'f') 
-                { 
-                    hex = (ch - 'a' + 10) * 16; 
-                } 
-                else 
-                { 
-                    unescaped.push_back('%'); 
-                    if (ch == 0) 
-                    { 
-                        return unescaped; 
-                    } 
-                    unescaped.push_back(ch); 
-                    break; 
-                } 
- 
-                ch = *++safe; 
-                if (ch >= '0' && ch <= '9') 
-                { 
-                    hex += (ch - '0'); 
-                } 
-                else if (ch >= 'A' && ch <= 'F') 
-                { 
-                    hex += (ch - 'A' + 10); 
-                } 
-                else if (ch >= 'a' && ch <= 'f') 
-                { 
-                    hex += (ch - 'a' + 10); 
-                } 
-                else 
-                { 
-                    unescaped.push_back('%'); 
-                    unescaped.push_back(*(safe - 1)); 
-                    if (ch == 0) 
-                    { 
-                        return unescaped; 
-                    } 
-                    unescaped.push_back(ch); 
-                    break; 
-                } 
- 
-                unescaped.push_back(char(hex)); 
-                break; 
-            } 
-            case '+': 
-                unescaped.push_back(' '); 
-                break; 
-            default: 
-                unescaped.push_back(*safe); 
-                break; 
+            case '%':
+            {
+                int hex = 0;
+                auto ch = *++safe;
+                if (ch >= '0' && ch <= '9')
+                {
+                    hex = (ch - '0') * 16;
+                }
+                else if (ch >= 'A' && ch <= 'F')
+                {
+                    hex = (ch - 'A' + 10) * 16;
+                }
+                else if (ch >= 'a' && ch <= 'f')
+                {
+                    hex = (ch - 'a' + 10) * 16;
+                }
+                else
+                {
+                    unescaped.push_back('%');
+                    if (ch == 0)
+                    {
+                        return unescaped;
+                    }
+                    unescaped.push_back(ch);
+                    break;
+                }
+
+                ch = *++safe;
+                if (ch >= '0' && ch <= '9')
+                {
+                    hex += (ch - '0');
+                }
+                else if (ch >= 'A' && ch <= 'F')
+                {
+                    hex += (ch - 'A' + 10);
+                }
+                else if (ch >= 'a' && ch <= 'f')
+                {
+                    hex += (ch - 'a' + 10);
+                }
+                else
+                {
+                    unescaped.push_back('%');
+                    unescaped.push_back(*(safe - 1));
+                    if (ch == 0)
+                    {
+                        return unescaped;
+                    }
+                    unescaped.push_back(ch);
+                    break;
+                }
+
+                unescaped.push_back(char(hex));
+                break;
+            }
+            case '+':
+                unescaped.push_back(' ');
+                break;
+            default:
+                unescaped.push_back(*safe);
+                break;
         }
     }
 
-    return unescaped; 
+    return unescaped;
 }
 
 static bool IsSpace(int ch)
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/UUID.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/UUID.cpp
index b1915ba144..862f3eacdd 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/UUID.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/UUID.cpp
@@ -14,7 +14,7 @@ namespace Aws
 {
     namespace Utils
     {
-        static const size_t UUID_STR_SIZE = 0x24u; // 36 characters 
+        static const size_t UUID_STR_SIZE = 0x24u; // 36 characters
         static const size_t VERSION_LOCATION = 0x06u;
         static const size_t VARIANT_LOCATION = 0x08u;
         static const unsigned char VERSION = 0x40u;
@@ -22,12 +22,12 @@ namespace Aws
         static const unsigned char VARIANT = 0x80u;
         static const unsigned char VARIANT_MASK = 0x3Fu;
 
-        static void hexify(Aws::String& ss, const unsigned char* toWrite, size_t min, size_t max) 
+        static void hexify(Aws::String& ss, const unsigned char* toWrite, size_t min, size_t max)
         {
             for (size_t i = min; i < max; ++i)
             {
-                ss.push_back("0123456789ABCDEF"[toWrite[i] >> 4]); 
-                ss.push_back("0123456789ABCDEF"[toWrite[i] & 0x0F]); 
+                ss.push_back("0123456789ABCDEF"[toWrite[i] >> 4]);
+                ss.push_back("0123456789ABCDEF"[toWrite[i] & 0x0F]);
             }
         }
 
@@ -50,23 +50,23 @@ namespace Aws
 
         UUID::operator Aws::String() const
         {
-            Aws::String ss; 
-            ss.reserve(UUID_STR_SIZE); 
-            hexify(ss, m_uuid, 0, 4); 
-            ss.push_back('-'); 
+            Aws::String ss;
+            ss.reserve(UUID_STR_SIZE);
+            hexify(ss, m_uuid, 0, 4);
+            ss.push_back('-');
 
-            hexify(ss, m_uuid, 4, 6); 
-            ss.push_back('-'); 
+            hexify(ss, m_uuid, 4, 6);
+            ss.push_back('-');
 
-            hexify(ss, m_uuid, 6, 8); 
-            ss.push_back('-'); 
+            hexify(ss, m_uuid, 6, 8);
+            ss.push_back('-');
 
-            hexify(ss, m_uuid, 8, 10); 
-            ss.push_back('-'); 
+            hexify(ss, m_uuid, 8, 10);
+            ss.push_back('-');
 
-            hexify(ss, m_uuid, 10, 16); 
+            hexify(ss, m_uuid, 10, 16);
 
-            return ss; 
+            return ss;
         }
 
         UUID UUID::RandomUUID()
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/base64/Base64.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/base64/Base64.cpp
index 9f92eae92a..2103d6d5a6 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/base64/Base64.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/base64/Base64.cpp
@@ -122,8 +122,8 @@ Aws::Utils::ByteBuffer Base64::Decode(const Aws::String& str) const
 
 size_t Base64::CalculateBase64DecodedLength(const Aws::String& b64input)
 {
-    const size_t len = b64input.length(); 
-    if(len < 2) 
+    const size_t len = b64input.length();
+    if(len < 2)
     {
         return 0;
     }
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp
index 6b5bf41441..c3c989bedb 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventHeader.cpp
@@ -1,107 +1,107 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
- 
-#include <aws/core/utils/event/EventHeader.h> 
-#include <aws/core/utils/HashingUtils.h> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            static const int HASH_BOOL_TRUE = HashingUtils::HashString("BOOL_TRUE"); 
-            static const int HASH_BOOL_FALSE = HashingUtils::HashString("BOOL_FALSE"); 
-            static const int HASH_BYTE = HashingUtils::HashString("BYTE"); 
-            static const int HASH_INT16 = HashingUtils::HashString("INT16"); 
-            static const int HASH_INT32 = HashingUtils::HashString("INT32"); 
-            static const int HASH_INT64 = HashingUtils::HashString("INT64"); 
-            static const int HASH_BYTE_BUF = HashingUtils::HashString("BYTE_BUFFER"); 
-            static const int HASH_STRING = HashingUtils::HashString("STRING"); 
-            static const int HASH_TIMESTAMP = HashingUtils::HashString("TIMESTAMP"); 
-            static const int HASH_UUID = HashingUtils::HashString("UUID"); 
- 
-            EventHeaderValue::EventHeaderType EventHeaderValue::GetEventHeaderTypeForName(const Aws::String& name) 
-            { 
-                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str()); 
-                if (hashCode == HASH_BOOL_TRUE) 
-                { 
-                    return EventHeaderType::BOOL_TRUE; 
-                } 
-                else if (hashCode == HASH_BOOL_FALSE) 
-                { 
-                    return EventHeaderType::BOOL_FALSE; 
-                } 
-                else if (hashCode == HASH_BYTE) 
-                { 
-                    return EventHeaderType::BYTE; 
-                } 
-                else if (hashCode == HASH_INT16) 
-                { 
-                    return EventHeaderType::INT16; 
-                } 
-                else if (hashCode == HASH_INT32) 
-                { 
-                    return EventHeaderType::INT32; 
-                } 
-                else if (hashCode == HASH_INT64) 
-                { 
-                    return EventHeaderType::INT64; 
-                } 
-                else if (hashCode == HASH_BYTE_BUF) 
-                { 
-                    return EventHeaderType::BYTE_BUF; 
-                } 
-                else if (hashCode == HASH_STRING) 
-                { 
-                    return EventHeaderType::STRING; 
-                } 
-                else if (hashCode == HASH_TIMESTAMP) 
-                { 
-                    return EventHeaderType::TIMESTAMP; 
-                } 
-                else if (hashCode == HASH_UUID) 
-                { 
-                    return EventHeaderType::UUID; 
-                } 
-                else 
-                { 
-                    return EventHeaderType::UNKNOWN; 
-                } 
-            } 
- 
-            Aws::String EventHeaderValue::GetNameForEventHeaderType(EventHeaderType value) 
-            { 
-                switch (value) 
-                { 
-                case EventHeaderType::BOOL_TRUE: 
-                    return "BOOL_TRUE"; 
-                case EventHeaderType::BOOL_FALSE: 
-                    return "BOOL_FALSE"; 
-                case EventHeaderType::BYTE: 
-                    return "BYTE"; 
-                case EventHeaderType::INT16: 
-                    return "INT16"; 
-                case EventHeaderType::INT32: 
-                    return "INT32"; 
-                case EventHeaderType::INT64: 
-                    return "INT64"; 
-                case EventHeaderType::BYTE_BUF: 
-                    return "BYTE_BUF"; 
-                case EventHeaderType::STRING: 
-                    return "STRING"; 
-                case EventHeaderType::TIMESTAMP: 
-                    return "TIMESTAMP"; 
-                case EventHeaderType::UUID: 
-                    return "UUID"; 
-                default: 
-                    return "UNKNOWN"; 
-                } 
-            } 
- 
-        } 
-    } 
-} 
- 
+ */
+
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/HashingUtils.h>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const int HASH_BOOL_TRUE = HashingUtils::HashString("BOOL_TRUE");
+            static const int HASH_BOOL_FALSE = HashingUtils::HashString("BOOL_FALSE");
+            static const int HASH_BYTE = HashingUtils::HashString("BYTE");
+            static const int HASH_INT16 = HashingUtils::HashString("INT16");
+            static const int HASH_INT32 = HashingUtils::HashString("INT32");
+            static const int HASH_INT64 = HashingUtils::HashString("INT64");
+            static const int HASH_BYTE_BUF = HashingUtils::HashString("BYTE_BUFFER");
+            static const int HASH_STRING = HashingUtils::HashString("STRING");
+            static const int HASH_TIMESTAMP = HashingUtils::HashString("TIMESTAMP");
+            static const int HASH_UUID = HashingUtils::HashString("UUID");
+
+            EventHeaderValue::EventHeaderType EventHeaderValue::GetEventHeaderTypeForName(const Aws::String& name)
+            {
+                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
+                if (hashCode == HASH_BOOL_TRUE)
+                {
+                    return EventHeaderType::BOOL_TRUE;
+                }
+                else if (hashCode == HASH_BOOL_FALSE)
+                {
+                    return EventHeaderType::BOOL_FALSE;
+                }
+                else if (hashCode == HASH_BYTE)
+                {
+                    return EventHeaderType::BYTE;
+                }
+                else if (hashCode == HASH_INT16)
+                {
+                    return EventHeaderType::INT16;
+                }
+                else if (hashCode == HASH_INT32)
+                {
+                    return EventHeaderType::INT32;
+                }
+                else if (hashCode == HASH_INT64)
+                {
+                    return EventHeaderType::INT64;
+                }
+                else if (hashCode == HASH_BYTE_BUF)
+                {
+                    return EventHeaderType::BYTE_BUF;
+                }
+                else if (hashCode == HASH_STRING)
+                {
+                    return EventHeaderType::STRING;
+                }
+                else if (hashCode == HASH_TIMESTAMP)
+                {
+                    return EventHeaderType::TIMESTAMP;
+                }
+                else if (hashCode == HASH_UUID)
+                {
+                    return EventHeaderType::UUID;
+                }
+                else
+                {
+                    return EventHeaderType::UNKNOWN;
+                }
+            }
+
+            Aws::String EventHeaderValue::GetNameForEventHeaderType(EventHeaderType value)
+            {
+                switch (value)
+                {
+                case EventHeaderType::BOOL_TRUE:
+                    return "BOOL_TRUE";
+                case EventHeaderType::BOOL_FALSE:
+                    return "BOOL_FALSE";
+                case EventHeaderType::BYTE:
+                    return "BYTE";
+                case EventHeaderType::INT16:
+                    return "INT16";
+                case EventHeaderType::INT32:
+                    return "INT32";
+                case EventHeaderType::INT64:
+                    return "INT64";
+                case EventHeaderType::BYTE_BUF:
+                    return "BYTE_BUF";
+                case EventHeaderType::STRING:
+                    return "STRING";
+                case EventHeaderType::TIMESTAMP:
+                    return "TIMESTAMP";
+                case EventHeaderType::UUID:
+                    return "UUID";
+                default:
+                    return "UNKNOWN";
+                }
+            }
+
+        }
+    }
+}
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp
index 811d116223..de8b904775 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventMessage.cpp
@@ -1,70 +1,70 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
- 
-#include <aws/core/utils/event/EventMessage.h> 
-#include <aws/core/utils/HashingUtils.h> 
-#include <algorithm> 
-#include <iterator> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            const char EVENT_TYPE_HEADER[] = ":event-type"; 
-            const char CONTENT_TYPE_HEADER[] = ":content-type"; 
-            const char MESSAGE_TYPE_HEADER[] = ":message-type"; 
-            const char ERROR_CODE_HEADER[] = ":error-code"; 
-            const char ERROR_MESSAGE_HEADER[] = ":error-message"; 
+ */
+
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <algorithm>
+#include <iterator>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            const char EVENT_TYPE_HEADER[] = ":event-type";
+            const char CONTENT_TYPE_HEADER[] = ":content-type";
+            const char MESSAGE_TYPE_HEADER[] = ":message-type";
+            const char ERROR_CODE_HEADER[] = ":error-code";
+            const char ERROR_MESSAGE_HEADER[] = ":error-message";
             const char EXCEPTION_TYPE_HEADER[] = ":exception-type";
- 
-            static const int EVENT_HASH = HashingUtils::HashString("event"); 
-            static const int ERROR_HASH = HashingUtils::HashString("error"); 
+
+            static const int EVENT_HASH = HashingUtils::HashString("event");
+            static const int ERROR_HASH = HashingUtils::HashString("error");
             static const int EXCEPTION_HASH = HashingUtils::HashString("exception");
- 
+
             static const int CONTENT_TYPE_APPLICATION_OCTET_STREAM_HASH = HashingUtils::HashString("application/octet-stream");
             static const int CONTENT_TYPE_APPLICATION_JSON_HASH = HashingUtils::HashString("application/json");
             static const int CONTENT_TYPE_TEXT_PLAIN_HASH = HashingUtils::HashString("text/plain");
 
-            Message::MessageType Message::GetMessageTypeForName(const Aws::String& name) 
-            { 
-                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str()); 
-                if (hashCode == EVENT_HASH) 
-                { 
-                    return MessageType::EVENT; 
-                } 
-                else if (hashCode == ERROR_HASH) 
-                { 
-                    return MessageType::REQUEST_LEVEL_ERROR; 
-                } 
+            Message::MessageType Message::GetMessageTypeForName(const Aws::String& name)
+            {
+                int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
+                if (hashCode == EVENT_HASH)
+                {
+                    return MessageType::EVENT;
+                }
+                else if (hashCode == ERROR_HASH)
+                {
+                    return MessageType::REQUEST_LEVEL_ERROR;
+                }
                 else if (hashCode == EXCEPTION_HASH)
                 {
                     return MessageType::REQUEST_LEVEL_EXCEPTION;
                 }
-                else 
-                { 
-                    return MessageType::UNKNOWN; 
-                } 
-            } 
- 
-            Aws::String Message::GetNameForMessageType(MessageType value) 
-            { 
-                switch (value) 
-                { 
-                case MessageType::EVENT: 
-                    return "event"; 
-                case MessageType::REQUEST_LEVEL_ERROR: 
-                    return "error"; 
+                else
+                {
+                    return MessageType::UNKNOWN;
+                }
+            }
+
+            Aws::String Message::GetNameForMessageType(MessageType value)
+            {
+                switch (value)
+                {
+                case MessageType::EVENT:
+                    return "event";
+                case MessageType::REQUEST_LEVEL_ERROR:
+                    return "error";
                 case MessageType::REQUEST_LEVEL_EXCEPTION:
                     return "exception";
-                default: 
-                    return "unknown"; 
-                } 
-            } 
- 
+                default:
+                    return "unknown";
+                }
+            }
+
             Message::ContentType Message::GetContentTypeForName(const Aws::String& name)
             {
                 int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
@@ -101,32 +101,32 @@ namespace Aws
                 }
             }
 
-            void Message::Reset() 
-            { 
-                m_totalLength = 0; 
-                m_headersLength = 0; 
-                m_payloadLength = 0; 
- 
-                m_eventHeaders.clear(); 
-                m_eventPayload.clear(); 
-            } 
- 
+            void Message::Reset()
+            {
+                m_totalLength = 0;
+                m_headersLength = 0;
+                m_payloadLength = 0;
+
+                m_eventHeaders.clear();
+                m_eventPayload.clear();
+            }
+
             void Message::WriteEventPayload(const unsigned char* data, size_t length)
             {
                 std::copy(data, data + length, std::back_inserter(m_eventPayload));
             }
 
-            void Message::WriteEventPayload(const Aws::Vector<unsigned char>& bits) 
-            { 
-                std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload)); 
-            } 
- 
+            void Message::WriteEventPayload(const Aws::Vector<unsigned char>& bits)
+            {
+                std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload));
+            }
+
             void Message::WriteEventPayload(const Aws::String& bits)
             {
                 std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload));
             }
 
-        } // namespace Event 
-    } // namespace Utils 
-} // namespace Aws 
- 
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp
index eb740d9ac0..6a1766bb9f 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamBuf.cpp
@@ -1,147 +1,147 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
-#include <aws/core/utils/event/EventStreamBuf.h> 
-#include <cassert> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
+ */
+#include <aws/core/utils/event/EventStreamBuf.h>
+#include <cassert>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
             const size_t DEFAULT_BUF_SIZE = 1024;
 
-            EventStreamBuf::EventStreamBuf(EventStreamDecoder& decoder, size_t bufferLength) : 
-                m_byteBuffer(bufferLength), 
-                m_bufferLength(bufferLength), 
-                m_decoder(decoder) 
-            { 
-                assert(decoder); 
-                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()); 
-                char* end = begin + bufferLength - 1; 
- 
-                setp(begin, end); 
-                setg(begin, begin, begin); 
-            } 
- 
-            EventStreamBuf::~EventStreamBuf() 
-            { 
-                if (m_decoder) 
-                { 
-                    writeToDecoder(); 
-                } 
-            } 
- 
-            void EventStreamBuf::writeToDecoder() 
-            { 
-                if (pptr() > pbase()) 
-                { 
-                    size_t length = static_cast<size_t>(pptr() - pbase()); 
-                    m_decoder.Pump(m_byteBuffer, length); 
- 
-                    if (!m_decoder) 
-                    { 
-                        m_err.write(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), length); 
-                    } 
-                    else 
-                    { 
-                        pbump(-static_cast<int>(length)); 
-                    } 
-                } 
-            } 
- 
-            std::streampos EventStreamBuf::seekoff(std::streamoff off, std::ios_base::seekdir dir, std::ios_base::openmode which) 
-            { 
-                if (dir == std::ios_base::beg) 
-                { 
-                    return seekpos(off, which); 
-                } 
-                else if (dir == std::ios_base::end) 
-                { 
-                    return seekpos(m_bufferLength - 1 - off, which); 
-                } 
-                else if (dir == std::ios_base::cur) 
-                { 
-                    if (which == std::ios_base::in) 
-                    { 
-                        return seekpos((gptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which); 
-                    } 
-                    if (which == std::ios_base::out) 
-                    { 
-                        return seekpos((pptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which); 
-                    } 
-                } 
- 
-                return std::streamoff(-1); 
-            } 
- 
-            std::streampos EventStreamBuf::seekpos(std::streampos pos, std::ios_base::openmode which) 
-            { 
-                assert(static_cast<size_t>(pos) <= m_bufferLength); 
-                if (static_cast<size_t>(pos) > m_bufferLength) 
-                { 
-                    return std::streampos(std::streamoff(-1)); 
-                } 
- 
-                if (which == std::ios_base::in) 
-                { 
-                    m_err.seekg(pos); 
-                    return m_err.tellg(); 
-                } 
- 
-                if (which == std::ios_base::out) 
-                { 
-                    return pos; 
-                } 
- 
-                return std::streampos(std::streamoff(-1)); 
-            } 
- 
-            int EventStreamBuf::underflow() 
-            { 
-                if (!m_err || m_err.eof() || m_decoder) 
-                { 
-                    return std::char_traits<char>::eof(); 
-                } 
- 
-                m_err.flush(); 
-                m_err.read(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), m_byteBuffer.GetLength()); 
- 
-                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()); 
-                setg(begin, begin, begin + m_err.gcount()); 
-                return std::char_traits<char>::to_int_type(*gptr()); 
-            } 
- 
-            int EventStreamBuf::overflow(int ch) 
-            { 
-                auto eof = std::char_traits<char>::eof(); 
- 
-                if (m_decoder) 
-                { 
-                    if (ch != eof) 
-                    { 
-                        *pptr() = (char)ch; 
-                        pbump(1); 
-                    } 
- 
-                    writeToDecoder(); 
-                    return ch; 
-                } 
- 
-                return eof; 
-            } 
- 
-            int EventStreamBuf::sync() 
-            { 
-                if (m_decoder) 
-                { 
-                    writeToDecoder(); 
-                } 
- 
-                return 0; 
-            } 
-        } 
-    } 
-} 
+            EventStreamBuf::EventStreamBuf(EventStreamDecoder& decoder, size_t bufferLength) :
+                m_byteBuffer(bufferLength),
+                m_bufferLength(bufferLength),
+                m_decoder(decoder)
+            {
+                assert(decoder);
+                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData());
+                char* end = begin + bufferLength - 1;
+
+                setp(begin, end);
+                setg(begin, begin, begin);
+            }
+
+            EventStreamBuf::~EventStreamBuf()
+            {
+                if (m_decoder)
+                {
+                    writeToDecoder();
+                }
+            }
+
+            void EventStreamBuf::writeToDecoder()
+            {
+                if (pptr() > pbase())
+                {
+                    size_t length = static_cast<size_t>(pptr() - pbase());
+                    m_decoder.Pump(m_byteBuffer, length);
+
+                    if (!m_decoder)
+                    {
+                        m_err.write(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), length);
+                    }
+                    else
+                    {
+                        pbump(-static_cast<int>(length));
+                    }
+                }
+            }
+
+            std::streampos EventStreamBuf::seekoff(std::streamoff off, std::ios_base::seekdir dir, std::ios_base::openmode which)
+            {
+                if (dir == std::ios_base::beg)
+                {
+                    return seekpos(off, which);
+                }
+                else if (dir == std::ios_base::end)
+                {
+                    return seekpos(m_bufferLength - 1 - off, which);
+                }
+                else if (dir == std::ios_base::cur)
+                {
+                    if (which == std::ios_base::in)
+                    {
+                        return seekpos((gptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which);
+                    }
+                    if (which == std::ios_base::out)
+                    {
+                        return seekpos((pptr() - (char*)m_byteBuffer.GetUnderlyingData()) + off, which);
+                    }
+                }
+
+                return std::streamoff(-1);
+            }
+
+            std::streampos EventStreamBuf::seekpos(std::streampos pos, std::ios_base::openmode which)
+            {
+                assert(static_cast<size_t>(pos) <= m_bufferLength);
+                if (static_cast<size_t>(pos) > m_bufferLength)
+                {
+                    return std::streampos(std::streamoff(-1));
+                }
+
+                if (which == std::ios_base::in)
+                {
+                    m_err.seekg(pos);
+                    return m_err.tellg();
+                }
+
+                if (which == std::ios_base::out)
+                {
+                    return pos;
+                }
+
+                return std::streampos(std::streamoff(-1));
+            }
+
+            int EventStreamBuf::underflow()
+            {
+                if (!m_err || m_err.eof() || m_decoder)
+                {
+                    return std::char_traits<char>::eof();
+                }
+
+                m_err.flush();
+                m_err.read(reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData()), m_byteBuffer.GetLength());
+
+                char* begin = reinterpret_cast<char*>(m_byteBuffer.GetUnderlyingData());
+                setg(begin, begin, begin + m_err.gcount());
+                return std::char_traits<char>::to_int_type(*gptr());
+            }
+
+            int EventStreamBuf::overflow(int ch)
+            {
+                auto eof = std::char_traits<char>::eof();
+
+                if (m_decoder)
+                {
+                    if (ch != eof)
+                    {
+                        *pptr() = (char)ch;
+                        pbump(1);
+                    }
+
+                    writeToDecoder();
+                    return ch;
+                }
+
+                return eof;
+            }
+
+            int EventStreamBuf::sync()
+            {
+                if (m_decoder)
+                {
+                    writeToDecoder();
+                }
+
+                return 0;
+            }
+        }
+    }
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp
index eeabf140b3..f70a6c88f6 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamDecoder.cpp
@@ -1,170 +1,170 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
- 
-#include <aws/common/common.h> 
-#include <aws/core/utils/event/EventHeader.h> 
-#include <aws/core/utils/event/EventMessage.h> 
-#include <aws/core/utils/event/EventStreamDecoder.h> 
-#include <aws/core/utils/logging/LogMacros.h> 
-#include <aws/core/utils/UnreferencedParam.h> 
+ */
+
+#include <aws/common/common.h>
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/event/EventStreamDecoder.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/utils/UnreferencedParam.h>
 #include <aws/core/utils/memory/AWSMemory.h>
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            static const char EVENT_STREAM_DECODER_CLASS_TAG[] = "Aws::Utils::Event::EventStreamDecoder"; 
- 
-            EventStreamDecoder::EventStreamDecoder(EventStreamHandler* handler) : m_eventStreamHandler(handler) 
-            { 
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const char EVENT_STREAM_DECODER_CLASS_TAG[] = "Aws::Utils::Event::EventStreamDecoder";
+
+            EventStreamDecoder::EventStreamDecoder(EventStreamHandler* handler) : m_eventStreamHandler(handler)
+            {
                 aws_event_stream_streaming_decoder_init(&m_decoder,
                     get_aws_allocator(),
-                    onPayloadSegment, 
-                    onPreludeReceived, 
-                    onHeaderReceived, 
-                    onError, 
-                    (void*)handler); 
-            } 
- 
-            EventStreamDecoder::~EventStreamDecoder() 
-            { 
-                aws_event_stream_streaming_decoder_clean_up(&m_decoder); 
-            } 
- 
-            void EventStreamDecoder::Pump(const ByteBuffer& data) 
-            { 
-                Pump(data, data.GetLength()); 
-            } 
- 
-            void EventStreamDecoder::Pump(const ByteBuffer& data, size_t length) 
-            { 
-                aws_byte_buf dataBuf = aws_byte_buf_from_array(static_cast<uint8_t*>(data.GetUnderlyingData()), length); 
-                aws_event_stream_streaming_decoder_pump(&m_decoder, &dataBuf); 
-            } 
- 
-            void EventStreamDecoder::Reset() 
-            { 
-                m_eventStreamHandler->Reset(); 
-            } 
- 
-            void EventStreamDecoder::ResetEventStreamHandler(EventStreamHandler* handler) 
-            { 
+                    onPayloadSegment,
+                    onPreludeReceived,
+                    onHeaderReceived,
+                    onError,
+                    (void*)handler);
+            }
+
+            EventStreamDecoder::~EventStreamDecoder()
+            {
+                aws_event_stream_streaming_decoder_clean_up(&m_decoder);
+            }
+
+            void EventStreamDecoder::Pump(const ByteBuffer& data)
+            {
+                Pump(data, data.GetLength());
+            }
+
+            void EventStreamDecoder::Pump(const ByteBuffer& data, size_t length)
+            {
+                aws_byte_buf dataBuf = aws_byte_buf_from_array(static_cast<uint8_t*>(data.GetUnderlyingData()), length);
+                aws_event_stream_streaming_decoder_pump(&m_decoder, &dataBuf);
+            }
+
+            void EventStreamDecoder::Reset()
+            {
+                m_eventStreamHandler->Reset();
+            }
+
+            void EventStreamDecoder::ResetEventStreamHandler(EventStreamHandler* handler)
+            {
                 aws_event_stream_streaming_decoder_init(&m_decoder, get_aws_allocator(),
-                    onPayloadSegment, 
-                    onPreludeReceived, 
-                    onHeaderReceived, 
-                    onError, 
-                    reinterpret_cast<void *>(handler)); 
-            } 
- 
-            void EventStreamDecoder::onPayloadSegment( 
-                aws_event_stream_streaming_decoder* decoder, 
-                aws_byte_buf* payload, 
-                int8_t isFinalSegment, 
-                void* context) 
-            { 
-                AWS_UNREFERENCED_PARAM(decoder); 
-                auto handler = static_cast<EventStreamHandler*>(context); 
-                assert(handler); 
-                if (!handler) 
-                { 
-                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before." 
-                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", " 
-                        "ErrorMessage: " << handler->GetEventPayloadAsString()); 
-                    return; 
-                } 
-                handler->WriteMessageEventPayload(static_cast<unsigned char*>(payload->buffer), payload->len); 
- 
-                // Complete payload received 
-                if (isFinalSegment == 1) 
-                { 
-                    assert(handler->IsMessageCompleted()); 
-                    handler->OnEvent(); 
-                    handler->Reset(); 
-                } 
-            } 
- 
-            void EventStreamDecoder::onPreludeReceived( 
-                aws_event_stream_streaming_decoder* decoder, 
-                aws_event_stream_message_prelude* prelude, 
-                void* context) 
-            { 
-                AWS_UNREFERENCED_PARAM(decoder); 
-                auto handler = static_cast<EventStreamHandler*>(context); 
-                handler->Reset(); 
-                 
-                //Encounter internal error in prelude received. 
-                //This error will be handled by OnError callback function later. 
-                if (prelude->total_len < prelude->headers_len + 16) 
-                { 
-                    return; 
-                } 
-                handler->SetMessageMetadata(prelude->total_len, prelude->headers_len, 
-                    prelude->total_len - prelude->headers_len - 4/*total byte-length*/ - 4/*headers byte-length*/ - 4/*prelude crc*/ - 4/*message crc*/); 
-                AWS_LOGSTREAM_TRACE(EVENT_STREAM_DECODER_CLASS_TAG, "Message received, the expected length of the message is: " << prelude->total_len << 
-                                                                    " bytes, and the expected length of the header is: " << prelude->headers_len << " bytes"); 
- 
-                //Handle empty message  
-                //if (handler->m_message.GetHeadersLength() == 0 && handler->m_message.GetPayloadLength() == 0) 
-                if (handler->IsMessageCompleted()) 
-                { 
-                    handler->OnEvent(); 
-                    handler->Reset(); 
-                } 
-            } 
- 
-            void EventStreamDecoder::onHeaderReceived( 
-                aws_event_stream_streaming_decoder* decoder, 
-                aws_event_stream_message_prelude* prelude, 
-                aws_event_stream_header_value_pair* header, 
-                void* context) 
-            { 
-                AWS_UNREFERENCED_PARAM(decoder); 
-                AWS_UNREFERENCED_PARAM(prelude); 
-                auto handler = static_cast<EventStreamHandler*>(context); 
-                assert(handler); 
-                if (!handler) 
-                { 
-                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before." 
-                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", " 
-                        "ErrorMessage: " << handler->GetEventPayloadAsString()); 
-                    return; 
-                } 
- 
-                // The length of a header = 1 byte (to represent the length of header name) + length of header name + 1 byte (to represent header type) 
-                //                          + 2 bytes (to represent length of header value) + length of header value 
-                handler->InsertMessageEventHeader(Aws::String(header->header_name, header->header_name_len), 
-                    1 + header->header_name_len + 1 + 2 + header->header_value_len, EventHeaderValue(header)); 
- 
-                // Handle messages only have headers, but without payload. 
-                //if (handler->m_message.GetHeadersLength() == handler->m_headersBytesReceived() && handler->m_message.GetPayloadLength() == 0) 
-                if (handler->IsMessageCompleted()) 
-                { 
-                    handler->OnEvent(); 
-                    handler->Reset(); 
-                } 
-            } 
- 
-            void EventStreamDecoder::onError( 
-                aws_event_stream_streaming_decoder* decoder, 
-                aws_event_stream_message_prelude* prelude, 
-                int error_code, 
-                const char* message, 
-                void* context) 
-            { 
-                AWS_UNREFERENCED_PARAM(decoder); 
-                AWS_UNREFERENCED_PARAM(prelude); 
-                auto handler = static_cast<EventStreamHandler*>(context); 
-                handler->SetFailure(); 
-                handler->SetInternalError(error_code); 
-                handler->WriteMessageEventPayload(reinterpret_cast<const unsigned char*>(message), strlen(message)); 
-                handler->OnEvent(); 
-            } 
-        } // namespace Event 
-    } // namespace Utils 
-} // namespace Aws 
- 
+                    onPayloadSegment,
+                    onPreludeReceived,
+                    onHeaderReceived,
+                    onError,
+                    reinterpret_cast<void *>(handler));
+            }
+
+            void EventStreamDecoder::onPayloadSegment(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_byte_buf* payload,
+                int8_t isFinalSegment,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                assert(handler);
+                if (!handler)
+                {
+                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before."
+                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", "
+                        "ErrorMessage: " << handler->GetEventPayloadAsString());
+                    return;
+                }
+                handler->WriteMessageEventPayload(static_cast<unsigned char*>(payload->buffer), payload->len);
+
+                // Complete payload received
+                if (isFinalSegment == 1)
+                {
+                    assert(handler->IsMessageCompleted());
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onPreludeReceived(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                handler->Reset();
+                
+                //Encounter internal error in prelude received.
+                //This error will be handled by OnError callback function later.
+                if (prelude->total_len < prelude->headers_len + 16)
+                {
+                    return;
+                }
+                handler->SetMessageMetadata(prelude->total_len, prelude->headers_len,
+                    prelude->total_len - prelude->headers_len - 4/*total byte-length*/ - 4/*headers byte-length*/ - 4/*prelude crc*/ - 4/*message crc*/);
+                AWS_LOGSTREAM_TRACE(EVENT_STREAM_DECODER_CLASS_TAG, "Message received, the expected length of the message is: " << prelude->total_len <<
+                                                                    " bytes, and the expected length of the header is: " << prelude->headers_len << " bytes");
+
+                //Handle empty message 
+                //if (handler->m_message.GetHeadersLength() == 0 && handler->m_message.GetPayloadLength() == 0)
+                if (handler->IsMessageCompleted())
+                {
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onHeaderReceived(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                aws_event_stream_header_value_pair* header,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                AWS_UNREFERENCED_PARAM(prelude);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                assert(handler);
+                if (!handler)
+                {
+                    AWS_LOGSTREAM_ERROR(EVENT_STREAM_DECODER_CLASS_TAG, "Payload received, but decoder encountered internal errors before."
+                        "ErrorCode: " << EventStreamErrorsMapper::GetNameForError(handler->GetInternalError()) << ", "
+                        "ErrorMessage: " << handler->GetEventPayloadAsString());
+                    return;
+                }
+
+                // The length of a header = 1 byte (to represent the length of header name) + length of header name + 1 byte (to represent header type)
+                //                          + 2 bytes (to represent length of header value) + length of header value
+                handler->InsertMessageEventHeader(Aws::String(header->header_name, header->header_name_len),
+                    1 + header->header_name_len + 1 + 2 + header->header_value_len, EventHeaderValue(header));
+
+                // Handle messages only have headers, but without payload.
+                //if (handler->m_message.GetHeadersLength() == handler->m_headersBytesReceived() && handler->m_message.GetPayloadLength() == 0)
+                if (handler->IsMessageCompleted())
+                {
+                    handler->OnEvent();
+                    handler->Reset();
+                }
+            }
+
+            void EventStreamDecoder::onError(
+                aws_event_stream_streaming_decoder* decoder,
+                aws_event_stream_message_prelude* prelude,
+                int error_code,
+                const char* message,
+                void* context)
+            {
+                AWS_UNREFERENCED_PARAM(decoder);
+                AWS_UNREFERENCED_PARAM(prelude);
+                auto handler = static_cast<EventStreamHandler*>(context);
+                handler->SetFailure();
+                handler->SetInternalError(error_code);
+                handler->WriteMessageEventPayload(reinterpret_cast<const unsigned char*>(message), strlen(message));
+                handler->OnEvent();
+            }
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp
index c7491a3e26..ef7104e839 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamEncoder.cpp
@@ -1,162 +1,162 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
- 
-#include <aws/core/utils/event/EventHeader.h> 
-#include <aws/core/utils/event/EventMessage.h> 
-#include <aws/core/utils/event/EventStreamEncoder.h> 
-#include <aws/core/utils/logging/LogMacros.h> 
-#include <aws/core/auth/AWSAuthSigner.h> 
-#include <aws/common/byte_order.h> 
+ */
+
+#include <aws/core/utils/event/EventHeader.h>
+#include <aws/core/utils/event/EventMessage.h>
+#include <aws/core/utils/event/EventStreamEncoder.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/auth/AWSAuthSigner.h>
+#include <aws/common/byte_order.h>
 #include <aws/core/utils/memory/AWSMemory.h>
- 
-#include <cassert> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            static const char TAG[] = "EventStreamEncoder"; 
- 
-            static void EncodeHeaders(const Aws::Utils::Event::Message& msg, aws_array_list* headers) 
-            { 
+
+#include <cassert>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            static const char TAG[] = "EventStreamEncoder";
+
+            static void EncodeHeaders(const Aws::Utils::Event::Message& msg, aws_array_list* headers)
+            {
                 aws_array_list_init_dynamic(headers, get_aws_allocator(), msg.GetEventHeaders().size(), sizeof(aws_event_stream_header_value_pair));
-                for (auto&& header : msg.GetEventHeaders()) 
-                { 
-                    const uint8_t headerKeyLen = static_cast<uint8_t>(header.first.length()); 
-                    switch(header.second.GetType()) 
-                    { 
-                        case EventHeaderValue::EventHeaderType::BOOL_TRUE: 
-                        case EventHeaderValue::EventHeaderType::BOOL_FALSE: 
-                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsBoolean()); 
-                            break; 
-                        case EventHeaderValue::EventHeaderType::BYTE: 
-                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsByte()); 
-                            break; 
-                        case EventHeaderValue::EventHeaderType::INT16: 
+                for (auto&& header : msg.GetEventHeaders())
+                {
+                    const uint8_t headerKeyLen = static_cast<uint8_t>(header.first.length());
+                    switch(header.second.GetType())
+                    {
+                        case EventHeaderValue::EventHeaderType::BOOL_TRUE:
+                        case EventHeaderValue::EventHeaderType::BOOL_FALSE:
+                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsBoolean());
+                            break;
+                        case EventHeaderValue::EventHeaderType::BYTE:
+                            aws_event_stream_add_bool_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsByte());
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT16:
                             aws_event_stream_add_int16_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt16());
-                            break; 
-                        case EventHeaderValue::EventHeaderType::INT32: 
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT32:
                             aws_event_stream_add_int32_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt32());
-                            break; 
-                        case EventHeaderValue::EventHeaderType::INT64: 
+                            break;
+                        case EventHeaderValue::EventHeaderType::INT64:
                             aws_event_stream_add_int64_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsInt64());
-                            break; 
-                        case EventHeaderValue::EventHeaderType::BYTE_BUF: 
-                            { 
-                                const auto& bytes = header.second.GetEventHeaderValueAsBytebuf(); 
+                            break;
+                        case EventHeaderValue::EventHeaderType::BYTE_BUF:
+                            {
+                                const auto& bytes = header.second.GetEventHeaderValueAsBytebuf();
                                 aws_event_stream_add_bytebuf_header(headers, header.first.c_str(), headerKeyLen, bytes.GetUnderlyingData(), static_cast<uint16_t>(bytes.GetLength()), 1 /*copy*/);
-                            } 
-                            break; 
-                        case EventHeaderValue::EventHeaderType::STRING: 
-                            { 
-                                const auto& bytes = header.second.GetUnderlyingBuffer(); 
-                                aws_event_stream_add_string_header(headers, header.first.c_str(), headerKeyLen, reinterpret_cast<char*>(bytes.GetUnderlyingData()), static_cast<uint16_t>(bytes.GetLength()), 0 /*copy*/); 
-                            } 
-                            break; 
-                        case EventHeaderValue::EventHeaderType::TIMESTAMP: 
+                            }
+                            break;
+                        case EventHeaderValue::EventHeaderType::STRING:
+                            {
+                                const auto& bytes = header.second.GetUnderlyingBuffer();
+                                aws_event_stream_add_string_header(headers, header.first.c_str(), headerKeyLen, reinterpret_cast<char*>(bytes.GetUnderlyingData()), static_cast<uint16_t>(bytes.GetLength()), 0 /*copy*/);
+                            }
+                            break;
+                        case EventHeaderValue::EventHeaderType::TIMESTAMP:
                             aws_event_stream_add_timestamp_header(headers, header.first.c_str(), headerKeyLen, header.second.GetEventHeaderValueAsTimestamp());
-                            break; 
-                        case EventHeaderValue::EventHeaderType::UUID: 
-                            { 
-                                ByteBuffer uuidBytes = header.second.GetEventHeaderValueAsUuid(); 
-                                aws_event_stream_add_uuid_header(headers, header.first.c_str(), headerKeyLen, uuidBytes.GetUnderlyingData()); 
-                            } 
-                            break; 
-                        default: 
-                            AWS_LOG_ERROR(TAG, "Encountered unknown type of header."); 
-                            break; 
-                    } 
-                } 
-            } 
- 
-            EventStreamEncoder::EventStreamEncoder(Client::AWSAuthSigner* signer) : m_signer(signer) 
-            { 
-            } 
- 
- 
-            Aws::Vector<unsigned char> EventStreamEncoder::EncodeAndSign(const Aws::Utils::Event::Message& msg) 
-            { 
-                aws_event_stream_message encoded = Encode(msg); 
-                aws_event_stream_message signedMessage = Sign(&encoded); 
- 
-                const auto signedMessageLength = signedMessage.message_buffer ? aws_event_stream_message_total_length(&signedMessage) : 0; 
- 
-                Aws::Vector<unsigned char> outputBits(signedMessage.message_buffer, signedMessage.message_buffer + signedMessageLength); 
-                aws_event_stream_message_clean_up(&encoded); 
-                aws_event_stream_message_clean_up(&signedMessage); 
-                return outputBits; 
-            } 
- 
-            aws_event_stream_message EventStreamEncoder::Encode(const Aws::Utils::Event::Message& msg) 
-            { 
-                aws_array_list headers; 
-                EncodeHeaders(msg, &headers); 
- 
-                aws_byte_buf payload; 
-                payload.len = msg.GetEventPayload().size(); 
-                // this const_cast is OK because aws_byte_buf will only be "read from" by the following functions. 
-                payload.buffer = const_cast<uint8_t*>(msg.GetEventPayload().data()); 
-                payload.capacity = 0; 
-                payload.allocator = nullptr; 
- 
-                aws_event_stream_message encoded; 
+                            break;
+                        case EventHeaderValue::EventHeaderType::UUID:
+                            {
+                                ByteBuffer uuidBytes = header.second.GetEventHeaderValueAsUuid();
+                                aws_event_stream_add_uuid_header(headers, header.first.c_str(), headerKeyLen, uuidBytes.GetUnderlyingData());
+                            }
+                            break;
+                        default:
+                            AWS_LOG_ERROR(TAG, "Encountered unknown type of header.");
+                            break;
+                    }
+                }
+            }
+
+            EventStreamEncoder::EventStreamEncoder(Client::AWSAuthSigner* signer) : m_signer(signer)
+            {
+            }
+
+
+            Aws::Vector<unsigned char> EventStreamEncoder::EncodeAndSign(const Aws::Utils::Event::Message& msg)
+            {
+                aws_event_stream_message encoded = Encode(msg);
+                aws_event_stream_message signedMessage = Sign(&encoded);
+
+                const auto signedMessageLength = signedMessage.message_buffer ? aws_event_stream_message_total_length(&signedMessage) : 0;
+
+                Aws::Vector<unsigned char> outputBits(signedMessage.message_buffer, signedMessage.message_buffer + signedMessageLength);
+                aws_event_stream_message_clean_up(&encoded);
+                aws_event_stream_message_clean_up(&signedMessage);
+                return outputBits;
+            }
+
+            aws_event_stream_message EventStreamEncoder::Encode(const Aws::Utils::Event::Message& msg)
+            {
+                aws_array_list headers;
+                EncodeHeaders(msg, &headers);
+
+                aws_byte_buf payload;
+                payload.len = msg.GetEventPayload().size();
+                // this const_cast is OK because aws_byte_buf will only be "read from" by the following functions.
+                payload.buffer = const_cast<uint8_t*>(msg.GetEventPayload().data());
+                payload.capacity = 0;
+                payload.allocator = nullptr;
+
+                aws_event_stream_message encoded;
                 if(aws_event_stream_message_init(&encoded, get_aws_allocator(), &headers, &payload) == AWS_OP_ERR)
-                { 
+                {
                     AWS_LOGSTREAM_ERROR(TAG, "Error creating event-stream message from payload.");
                     aws_event_stream_headers_list_cleanup(&headers);
-                    // GCC 4.9.4 issues a warning with -Wextra if we simply do 
-                    // return {}; 
-                    aws_event_stream_message empty{nullptr, nullptr, 0}; 
-                    return empty; 
-                } 
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
                 aws_event_stream_headers_list_cleanup(&headers);
-                return encoded; 
-            } 
- 
-            aws_event_stream_message EventStreamEncoder::Sign(aws_event_stream_message* msg) 
-            { 
-                const auto msglen = msg->message_buffer ? aws_event_stream_message_total_length(msg) : 0; 
-                Event::Message signedMessage; 
-                signedMessage.WriteEventPayload(msg->message_buffer, msglen); 
- 
-                assert(m_signer); 
-                if (!m_signer->SignEventMessage(signedMessage, m_signatureSeed)) 
-                { 
-                    AWS_LOGSTREAM_ERROR(TAG, "Failed to sign event message frame."); 
-                    // GCC 4.9.4 issues a warning with -Wextra if we simply do 
-                    // return {}; 
-                    aws_event_stream_message empty{nullptr, nullptr, 0}; 
-                    return empty; 
-                } 
- 
-                aws_array_list headers; 
-                EncodeHeaders(signedMessage, &headers); 
- 
-                aws_byte_buf payload; 
-                payload.len = signedMessage.GetEventPayload().size(); 
-                payload.buffer = signedMessage.GetEventPayload().data(); 
-                payload.capacity = 0; 
-                payload.allocator = nullptr; 
- 
-                aws_event_stream_message signedmsg; 
+                return encoded;
+            }
+
+            aws_event_stream_message EventStreamEncoder::Sign(aws_event_stream_message* msg)
+            {
+                const auto msglen = msg->message_buffer ? aws_event_stream_message_total_length(msg) : 0;
+                Event::Message signedMessage;
+                signedMessage.WriteEventPayload(msg->message_buffer, msglen);
+
+                assert(m_signer);
+                if (!m_signer->SignEventMessage(signedMessage, m_signatureSeed))
+                {
+                    AWS_LOGSTREAM_ERROR(TAG, "Failed to sign event message frame.");
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
+
+                aws_array_list headers;
+                EncodeHeaders(signedMessage, &headers);
+
+                aws_byte_buf payload;
+                payload.len = signedMessage.GetEventPayload().size();
+                payload.buffer = signedMessage.GetEventPayload().data();
+                payload.capacity = 0;
+                payload.allocator = nullptr;
+
+                aws_event_stream_message signedmsg;
                 if(aws_event_stream_message_init(&signedmsg, get_aws_allocator(), &headers, &payload))
-                { 
+                {
                     AWS_LOGSTREAM_ERROR(TAG, "Error creating event-stream message from payload.");
                     aws_event_stream_headers_list_cleanup(&headers);
-                    // GCC 4.9.4 issues a warning with -Wextra if we simply do 
-                    // return {}; 
-                    aws_event_stream_message empty{nullptr, nullptr, 0}; 
-                    return empty; 
-                } 
+                    // GCC 4.9.4 issues a warning with -Wextra if we simply do
+                    // return {};
+                    aws_event_stream_message empty{nullptr, nullptr, 0};
+                    return empty;
+                }
                 aws_event_stream_headers_list_cleanup(&headers);
-                return signedmsg; 
-            } 
- 
-        } // namespace Event 
-    } // namespace Utils 
-} // namespace Aws 
- 
+                return signedmsg;
+            }
+
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
+
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp
index df999b07b8..836d0b47c5 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/event/EventStreamErrors.cpp
@@ -1,66 +1,66 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
-#include <aws/core/client/AWSError.h> 
-#include <aws/core/utils/HashingUtils.h> 
-#include <aws/core/utils/event/EventStreamErrors.h> 
- 
- using namespace Aws::Client; 
-// using namespace Aws::S3; 
-// using namespace Aws::Utils; 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Event 
-        { 
-            namespace EventStreamErrorsMapper 
-            { 
-                /* 
-                static const int EVENT_STREAM_NO_ERROR_HASH = HashingUtils::HashString("EventStreamNoError"); 
-                static const int EVENT_STREAM_BUFFER_LENGTH_MISMATCH_HASH = HashingUtils::HashString("EventStreamBufferLengthMismatch"); 
-                static const int EVENT_STREAM_INSUFFICIENT_BUFFER_LEN_HASH = HashingUtils::HashString("EventStreamInsufficientBufferLen"); 
-                static const int EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED_HASH = HashingUtils::HashString("EventStreamMessageFieldSizeExceeded"); 
-                static const int EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamPreludeChecksumFailure"); 
-                static const int EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamMessageChecksumFailure"); 
-                static const int EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN_HASH = HashingUtils::HashString("EventStreamMessageInvalidHeadersLen"); 
-                static const int EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE_HASH = HashingUtils::HashString("EventStreamMessageUnknownHeaderType"); 
-                static const int EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE_HASH = HashingUtils::HashString("EventStreamMessageParserIllegalState"); 
-                */ 
-                const char* GetNameForError(EventStreamErrors error) 
-                { 
-                    switch (error) 
-                    { 
-                    case EventStreamErrors::EVENT_STREAM_NO_ERROR: 
-                        return "EventStreamNoError"; 
-                    case EventStreamErrors::EVENT_STREAM_BUFFER_LENGTH_MISMATCH: 
-                        return "EventStreamBufferLengthMismatch"; 
-                    case EventStreamErrors::EVENT_STREAM_INSUFFICIENT_BUFFER_LEN: 
-                        return "EventStreamInsufficientBufferLen"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED: 
-                        return "EventStreamMessageFieldSizeExceeded"; 
-                    case EventStreamErrors::EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE: 
-                        return "EventStreamPreludeChecksumFailure"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE: 
-                        return "EventStreamMessageChecksumFailure"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN: 
-                        return "EventStreamMessageInvalidHeadersLen"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE: 
-                        return "EventStreamMessageUnknownHeaderType"; 
-                    case EventStreamErrors::EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE: 
-                        return "EventStreamMessageParserIllegalState"; 
-                    default: 
-                        return "EventStreamUnknownError"; 
-                    } 
-                } 
- 
-                AWSError<CoreErrors> GetAwsErrorForEventStreamError(EventStreamErrors error) 
-                { 
-                    return AWSError<CoreErrors>(CoreErrors::UNKNOWN, GetNameForError(error), "", false); 
-                } 
-            } // namespace EventStreamErrorsMapper 
-        } // namespace Event 
-    } // namespace Utils 
-} // namespace Aws 
+ */
+#include <aws/core/client/AWSError.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/event/EventStreamErrors.h>
+
+ using namespace Aws::Client;
+// using namespace Aws::S3;
+// using namespace Aws::Utils;
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Event
+        {
+            namespace EventStreamErrorsMapper
+            {
+                /*
+                static const int EVENT_STREAM_NO_ERROR_HASH = HashingUtils::HashString("EventStreamNoError");
+                static const int EVENT_STREAM_BUFFER_LENGTH_MISMATCH_HASH = HashingUtils::HashString("EventStreamBufferLengthMismatch");
+                static const int EVENT_STREAM_INSUFFICIENT_BUFFER_LEN_HASH = HashingUtils::HashString("EventStreamInsufficientBufferLen");
+                static const int EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED_HASH = HashingUtils::HashString("EventStreamMessageFieldSizeExceeded");
+                static const int EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamPreludeChecksumFailure");
+                static const int EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE_HASH = HashingUtils::HashString("EventStreamMessageChecksumFailure");
+                static const int EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN_HASH = HashingUtils::HashString("EventStreamMessageInvalidHeadersLen");
+                static const int EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE_HASH = HashingUtils::HashString("EventStreamMessageUnknownHeaderType");
+                static const int EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE_HASH = HashingUtils::HashString("EventStreamMessageParserIllegalState");
+                */
+                const char* GetNameForError(EventStreamErrors error)
+                {
+                    switch (error)
+                    {
+                    case EventStreamErrors::EVENT_STREAM_NO_ERROR:
+                        return "EventStreamNoError";
+                    case EventStreamErrors::EVENT_STREAM_BUFFER_LENGTH_MISMATCH:
+                        return "EventStreamBufferLengthMismatch";
+                    case EventStreamErrors::EVENT_STREAM_INSUFFICIENT_BUFFER_LEN:
+                        return "EventStreamInsufficientBufferLen";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_FIELD_SIZE_EXCEEDED:
+                        return "EventStreamMessageFieldSizeExceeded";
+                    case EventStreamErrors::EVENT_STREAM_PRELUDE_CHECKSUM_FAILURE:
+                        return "EventStreamPreludeChecksumFailure";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_CHECKSUM_FAILURE:
+                        return "EventStreamMessageChecksumFailure";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_INVALID_HEADERS_LEN:
+                        return "EventStreamMessageInvalidHeadersLen";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_UNKNOWN_HEADER_TYPE:
+                        return "EventStreamMessageUnknownHeaderType";
+                    case EventStreamErrors::EVENT_STREAM_MESSAGE_PARSER_ILLEGAL_STATE:
+                        return "EventStreamMessageParserIllegalState";
+                    default:
+                        return "EventStreamUnknownError";
+                    }
+                }
+
+                AWSError<CoreErrors> GetAwsErrorForEventStreamError(EventStreamErrors error)
+                {
+                    return AWSError<CoreErrors>(CoreErrors::UNKNOWN, GetNameForError(error), "", false);
+                }
+            } // namespace EventStreamErrorsMapper
+        } // namespace Event
+    } // namespace Utils
+} // namespace Aws
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/json/JsonSerializer.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/json/JsonSerializer.cpp
index a0f5400612..9b785d1995 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/json/JsonSerializer.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/json/JsonSerializer.cpp
@@ -633,7 +633,7 @@ Aws::String JsonView::WriteCompact(bool treatAsObject) const
         {
             return "{}";
         }
-        return {}; 
+        return {};
     }
 
     auto temp = cJSON_PrintUnformatted(m_value);
@@ -650,7 +650,7 @@ Aws::String JsonView::WriteReadable(bool treatAsObject) const
         {
             return "{\n}\n";
         }
-        return {}; 
+        return {};
     }
 
     auto temp = cJSON_Print(m_value);
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/ConcurrentStreamBuf.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/ConcurrentStreamBuf.cpp
index 0ba47bd92c..3f59dbe96d 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/ConcurrentStreamBuf.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/ConcurrentStreamBuf.cpp
@@ -1,109 +1,109 @@
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
- */ 
-#include <aws/core/utils/stream/ConcurrentStreamBuf.h> 
-#include <aws/core/utils/logging/LogMacros.h> 
-#include <cstdint> 
-#include <cassert> 
- 
-namespace Aws 
-{ 
-    namespace Utils 
-    { 
-        namespace Stream 
-        { 
-            const char TAG[] = "ConcurrentStreamBuf"; 
-            ConcurrentStreamBuf::ConcurrentStreamBuf(size_t bufferLength) : 
-                m_putArea(bufferLength), // we access [0] of the put area below so we must initialize it. 
-                m_eof(false) 
-            { 
-                m_getArea.reserve(bufferLength); 
-                m_backbuf.reserve(bufferLength); 
- 
-                char* pbegin = reinterpret_cast<char*>(&m_putArea[0]); 
-                setp(pbegin, pbegin + bufferLength); 
-            } 
- 
-            void ConcurrentStreamBuf::SetEof() 
-            { 
-                { 
-                    std::unique_lock<std::mutex> lock(m_lock); 
-                    m_eof = true; 
-                } 
-                m_signal.notify_all(); 
-            } 
- 
-            void ConcurrentStreamBuf::FlushPutArea() 
-            { 
-                const size_t bitslen = pptr() - pbase(); 
-                if (bitslen) 
-                { 
-                    // scope the lock 
-                    { 
-                        std::unique_lock<std::mutex> lock(m_lock); 
+ */
+#include <aws/core/utils/stream/ConcurrentStreamBuf.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <cstdint>
+#include <cassert>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Stream
+        {
+            const char TAG[] = "ConcurrentStreamBuf";
+            ConcurrentStreamBuf::ConcurrentStreamBuf(size_t bufferLength) :
+                m_putArea(bufferLength), // we access [0] of the put area below so we must initialize it.
+                m_eof(false)
+            {
+                m_getArea.reserve(bufferLength);
+                m_backbuf.reserve(bufferLength);
+
+                char* pbegin = reinterpret_cast<char*>(&m_putArea[0]);
+                setp(pbegin, pbegin + bufferLength);
+            }
+
+            void ConcurrentStreamBuf::SetEof()
+            {
+                {
+                    std::unique_lock<std::mutex> lock(m_lock);
+                    m_eof = true;
+                }
+                m_signal.notify_all();
+            }
+
+            void ConcurrentStreamBuf::FlushPutArea()
+            {
+                const size_t bitslen = pptr() - pbase();
+                if (bitslen)
+                {
+                    // scope the lock
+                    {
+                        std::unique_lock<std::mutex> lock(m_lock);
                         m_signal.wait(lock, [this, bitslen]{ return m_eof || bitslen <= (m_backbuf.capacity() - m_backbuf.size()); });
                         if (m_eof)
                         {
                             return;
                         }
-                        std::copy(pbase(), pptr(), std::back_inserter(m_backbuf)); 
-                    } 
-                    m_signal.notify_one(); 
-                    char* pbegin = reinterpret_cast<char*>(&m_putArea[0]); 
-                    setp(pbegin, pbegin + m_putArea.size()); 
-                } 
-            } 
- 
-            std::streampos ConcurrentStreamBuf::seekoff(std::streamoff, std::ios_base::seekdir, std::ios_base::openmode) 
-            { 
-                return std::streamoff(-1); // Seeking is not supported. 
-            } 
- 
-            std::streampos ConcurrentStreamBuf::seekpos(std::streampos, std::ios_base::openmode) 
-            { 
-                return std::streamoff(-1); // Seeking is not supported. 
-            } 
- 
-            int ConcurrentStreamBuf::underflow() 
-            { 
-                { 
-                    std::unique_lock<std::mutex> lock(m_lock); 
-                    m_signal.wait(lock, [this]{ return m_backbuf.empty() == false || m_eof; }); 
- 
-                    if (m_eof && m_backbuf.empty()) 
-                    { 
-                        return std::char_traits<char>::eof(); 
-                    } 
- 
-                    m_getArea.clear(); // keep the get-area from growing unbounded. 
-                    std::copy(m_backbuf.begin(), m_backbuf.end(), std::back_inserter(m_getArea)); 
-                    m_backbuf.clear(); 
-                } 
-                m_signal.notify_one(); 
-                char* gbegin = reinterpret_cast<char*>(&m_getArea[0]); 
-                setg(gbegin, gbegin, gbegin + m_getArea.size()); 
-                return std::char_traits<char>::to_int_type(*gptr()); 
-            } 
- 
-            std::streamsize ConcurrentStreamBuf::showmanyc() 
-            { 
-                std::unique_lock<std::mutex> lock(m_lock); 
-                AWS_LOGSTREAM_TRACE(TAG, "stream how many character? " << m_backbuf.size()); 
-                return m_backbuf.size(); 
-            } 
- 
-            int ConcurrentStreamBuf::overflow(int ch) 
-            { 
-                const auto eof = std::char_traits<char>::eof(); 
- 
-                if (ch == eof) 
-                { 
-                    FlushPutArea(); 
-                    return eof; 
-                } 
- 
-                FlushPutArea(); 
+                        std::copy(pbase(), pptr(), std::back_inserter(m_backbuf));
+                    }
+                    m_signal.notify_one();
+                    char* pbegin = reinterpret_cast<char*>(&m_putArea[0]);
+                    setp(pbegin, pbegin + m_putArea.size());
+                }
+            }
+
+            std::streampos ConcurrentStreamBuf::seekoff(std::streamoff, std::ios_base::seekdir, std::ios_base::openmode)
+            {
+                return std::streamoff(-1); // Seeking is not supported.
+            }
+
+            std::streampos ConcurrentStreamBuf::seekpos(std::streampos, std::ios_base::openmode)
+            {
+                return std::streamoff(-1); // Seeking is not supported.
+            }
+
+            int ConcurrentStreamBuf::underflow()
+            {
+                {
+                    std::unique_lock<std::mutex> lock(m_lock);
+                    m_signal.wait(lock, [this]{ return m_backbuf.empty() == false || m_eof; });
+
+                    if (m_eof && m_backbuf.empty())
+                    {
+                        return std::char_traits<char>::eof();
+                    }
+
+                    m_getArea.clear(); // keep the get-area from growing unbounded.
+                    std::copy(m_backbuf.begin(), m_backbuf.end(), std::back_inserter(m_getArea));
+                    m_backbuf.clear();
+                }
+                m_signal.notify_one();
+                char* gbegin = reinterpret_cast<char*>(&m_getArea[0]);
+                setg(gbegin, gbegin, gbegin + m_getArea.size());
+                return std::char_traits<char>::to_int_type(*gptr());
+            }
+
+            std::streamsize ConcurrentStreamBuf::showmanyc()
+            {
+                std::unique_lock<std::mutex> lock(m_lock);
+                AWS_LOGSTREAM_TRACE(TAG, "stream how many character? " << m_backbuf.size());
+                return m_backbuf.size();
+            }
+
+            int ConcurrentStreamBuf::overflow(int ch)
+            {
+                const auto eof = std::char_traits<char>::eof();
+
+                if (ch == eof)
+                {
+                    FlushPutArea();
+                    return eof;
+                }
+
+                FlushPutArea();
                 {
                     std::unique_lock<std::mutex> lock(m_lock);
                     if (m_eof)
@@ -114,13 +114,13 @@ namespace Aws
                     pbump(1);
                     return ch;
                 }
-            } 
- 
-            int ConcurrentStreamBuf::sync() 
-            { 
-                FlushPutArea(); 
-                return 0; 
-            } 
-        } 
-    } 
-} 
+            }
+
+            int ConcurrentStreamBuf::sync()
+            {
+                FlushPutArea();
+                return 0;
+            }
+        }
+    }
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/PreallocatedStreamBuf.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/PreallocatedStreamBuf.cpp
index 7aaf9c82f3..f656fc8613 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/PreallocatedStreamBuf.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/PreallocatedStreamBuf.cpp
@@ -16,8 +16,8 @@ namespace Aws
             PreallocatedStreamBuf::PreallocatedStreamBuf(unsigned char* buffer, uint64_t lengthToRead) :
                 m_underlyingBuffer(buffer), m_lengthToRead(lengthToRead)
             {
-                char* end = reinterpret_cast<char*>(m_underlyingBuffer + m_lengthToRead); 
-                char* begin = reinterpret_cast<char*>(m_underlyingBuffer); 
+                char* end = reinterpret_cast<char*>(m_underlyingBuffer + m_lengthToRead);
+                char* begin = reinterpret_cast<char*>(m_underlyingBuffer);
                 setp(begin, end);
                 setg(begin, begin, end);
             }
@@ -55,12 +55,12 @@ namespace Aws
                     return pos_type(off_type(-1));
                 }
 
-                char* end = reinterpret_cast<char*>(m_underlyingBuffer + m_lengthToRead); 
-                char* begin = reinterpret_cast<char*>(m_underlyingBuffer); 
+                char* end = reinterpret_cast<char*>(m_underlyingBuffer + m_lengthToRead);
+                char* begin = reinterpret_cast<char*>(m_underlyingBuffer);
 
                 if (which == std::ios_base::in)
                 {
-                    setg(begin, begin + static_cast<size_t>(pos), end); 
+                    setg(begin, begin + static_cast<size_t>(pos), end);
                 }
 
                 if (which == std::ios_base::out)
@@ -72,4 +72,4 @@ namespace Aws
             }
         }
     }
-} 
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/SimpleStreamBuf.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/SimpleStreamBuf.cpp
index 91064590a8..6e42994744 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/SimpleStreamBuf.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/stream/SimpleStreamBuf.cpp
@@ -201,7 +201,7 @@ std::streamsize SimpleStreamBuf::xsputn(const char* s, std::streamsize n)
     return writeCount;
 }
 
-Aws::String SimpleStreamBuf::str() const 
+Aws::String SimpleStreamBuf::str() const
 {
     return Aws::String(m_buffer, pptr());
 }
@@ -236,4 +236,4 @@ void SimpleStreamBuf::str(const Aws::String& value)
 
 }
 }
-} 
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/xml/XmlSerializer.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/xml/XmlSerializer.cpp
index 59d259a911..c06befaf9b 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/xml/XmlSerializer.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/utils/xml/XmlSerializer.cpp
@@ -125,7 +125,7 @@ Aws::String XmlNode::GetText() const
         return printer.CStr();
     }
 
-    return {}; 
+    return {};
 }
 
 void XmlNode::SetText(const Aws::String& textValue)