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

26 files changed, 1507 insertions, 1507 deletions

diff --git a/util/charset/wide.cpp b/util/charset/wide.cpp
index e71abf0cfe..a287438ddd 100644
--- a/util/charset/wide.cpp
+++ b/util/charset/wide.cpp
@@ -3,17 +3,17 @@
 #include <util/generic/mem_copy.h>
 #include <util/string/strip.h>
 
-namespace { 
-    //! the constants are not zero-terminated 
+namespace {
+    //! the constants are not zero-terminated
     const wchar16 LT[] = {'&', 'l', 't', ';'};
     const wchar16 GT[] = {'&', 'g', 't', ';'};
     const wchar16 AMP[] = {'&', 'a', 'm', 'p', ';'};
     const wchar16 BR[] = {'<', 'B', 'R', '>'};
     const wchar16 QUOT[] = {'&', 'q', 'u', 'o', 't', ';'};
- 
+
     template <bool insertBr>
-    inline size_t EscapedLen(wchar16 c) { 
-        switch (c) { 
+    inline size_t EscapedLen(wchar16 c) {
+        switch (c) {
             case '<':
                 return Y_ARRAY_SIZE(LT);
             case '>':
@@ -27,37 +27,37 @@ namespace {
                     return Y_ARRAY_SIZE(BR);
                 else
                     return 1;
-        } 
-    } 
-} 
- 
+        }
+    }
+}
+
 void Collapse(TUtf16String& w) {
     CollapseImpl(w, w, 0, IsWhitespace);
-} 
- 
-size_t Collapse(wchar16* s, size_t n) { 
+}
+
+size_t Collapse(wchar16* s, size_t n) {
     return CollapseImpl(s, n, IsWhitespace);
-} 
- 
+}
+
 TWtringBuf StripLeft(const TWtringBuf text) noexcept {
     const auto* p = text.data();
     const auto* const pe = text.data() + text.size();
- 
+
     for (; p != pe && IsWhitespace(*p); ++p) {
     }
- 
+
     return {p, pe};
 }
- 
+
 void StripLeft(TUtf16String& text) {
     const auto stripped = StripLeft(TWtringBuf(text));
     if (stripped.size() == text.size()) {
         return;
-    } 
- 
+    }
+
     text = stripped;
-} 
- 
+}
+
 TWtringBuf StripRight(const TWtringBuf text) noexcept {
     if (!text) {
         return {};
@@ -574,53 +574,53 @@ void EscapeHtmlChars(TUtf16String& str) {
     static const TUtf16String amp(AMP, Y_ARRAY_SIZE(AMP));
     static const TUtf16String br(BR, Y_ARRAY_SIZE(BR));
     static const TUtf16String quot(QUOT, Y_ARRAY_SIZE(QUOT));
- 
-    size_t escapedLen = 0; 
- 
+
+    size_t escapedLen = 0;
+
     const TUtf16String& cs = str;
- 
-    for (size_t i = 0; i < cs.size(); ++i) 
+
+    for (size_t i = 0; i < cs.size(); ++i)
         escapedLen += EscapedLen<insertBr>(cs[i]);
- 
-    if (escapedLen == cs.size()) 
-        return; 
- 
+
+    if (escapedLen == cs.size())
+        return;
+
     TUtf16String res;
-    res.reserve(escapedLen); 
- 
-    size_t start = 0; 
- 
+    res.reserve(escapedLen);
+
+    size_t start = 0;
+
     for (size_t i = 0; i < cs.size(); ++i) {
         const TUtf16String* ent = nullptr;
         switch (cs[i]) {
-            case '<': 
-                ent = &lt; 
-                break; 
-            case '>': 
-                ent = &gt; 
-                break; 
-            case '&': 
-                ent = &amp; 
-                break; 
+            case '<':
+                ent = &lt;
+                break;
+            case '>':
+                ent = &gt;
+                break;
+            case '&':
+                ent = &amp;
+                break;
             case '\"':
                 ent = &quot;
                 break;
-            default: 
+            default:
                 if (insertBr && (cs[i] == '\r' || cs[i] == '\n')) {
                     ent = &br;
                     break;
                 } else
                     continue;
-        } 
- 
-        res.append(cs.begin() + start, cs.begin() + i); 
-        res.append(ent->begin(), ent->end()); 
-        start = i + 1; 
-    } 
- 
-    res.append(cs.begin() + start, cs.end()); 
-    res.swap(str); 
-} 
- 
+        }
+
+        res.append(cs.begin() + start, cs.begin() + i);
+        res.append(ent->begin(), ent->end());
+        start = i + 1;
+    }
+
+    res.append(cs.begin() + start, cs.end());
+    res.swap(str);
+}
+
 template void EscapeHtmlChars<false>(TUtf16String& str);
 template void EscapeHtmlChars<true>(TUtf16String& str);
diff --git a/util/charset/wide.h b/util/charset/wide.h
index f8d63d4289..04e6928aab 100644
--- a/util/charset/wide.h
+++ b/util/charset/wide.h
@@ -23,7 +23,7 @@ template <class T>
 class TTempArray;
 using TCharTemp = TTempArray<wchar16>;
 
-namespace NDetail { 
+namespace NDetail {
     inline TString InStringMsg(const char* s, size_t len) {
         return (len <= 50) ? " in string " + TString(s, len).Quote() : TString();
     }
@@ -301,7 +301,7 @@ namespace NDetail {
 //! @return len if robust and position where encoding stopped if not
 template <bool robust, typename TCharType>
 inline size_t UTF8ToWideImpl(const char* text, size_t len, TCharType* dest, size_t& written) noexcept {
-    const unsigned char* cur = reinterpret_cast<const unsigned char*>(text); 
+    const unsigned char* cur = reinterpret_cast<const unsigned char*>(text);
     const unsigned char* last = cur + len;
     TCharType* p = dest;
 #ifdef _sse_ //can't check for sse4, as we build most of arcadia without sse4 support even on platforms that support it
@@ -311,10 +311,10 @@ inline size_t UTF8ToWideImpl(const char* text, size_t len, TCharType* dest, size
 #endif
 
     ::NDetail::UTF8ToWideImplScalar<robust>(cur, last, p);
-    written = p - dest; 
+    written = p - dest;
     return cur - reinterpret_cast<const unsigned char*>(text);
-} 
- 
+}
+
 template <typename TCharType>
 inline size_t UTF8ToWideImpl(const char* text, size_t len, TCharType* dest, size_t& written) {
     return UTF8ToWideImpl<false>(text, len, dest, written);
@@ -421,13 +421,13 @@ inline TStringBuf WideToUTF8(const TWtringBuf src, TString& dst) {
 
 inline TString WideToUTF8(const wchar16* text, size_t len) {
     TString s = TString::Uninitialized(WideToUTF8BufferSize(len));
-    size_t written = 0; 
-    WideToUTF8(text, len, s.begin(), written); 
+    size_t written = 0;
+    WideToUTF8(text, len, s.begin(), written);
     Y_ASSERT(s.size() >= written);
-    s.remove(written); 
-    return s; 
-} 
- 
+    s.remove(written);
+    return s;
+}
+
 inline TString WideToUTF8(const wchar32* text, size_t len) {
     TString s = TString::Uninitialized(WideToUTF8BufferSize(len));
     size_t written = 0;
@@ -439,8 +439,8 @@ inline TString WideToUTF8(const wchar32* text, size_t len) {
 
 inline TString WideToUTF8(const TWtringBuf w) {
     return WideToUTF8(w.data(), w.size());
-} 
- 
+}
+
 inline TString WideToUTF8(const TUtf32StringBuf w) {
     return WideToUTF8(w.data(), w.size());
 }
@@ -594,11 +594,11 @@ namespace NDetail {
 
 }
 
-//! returns @c true if character sequence has no symbols with value greater than 0x7F 
-template <typename TChar> 
-inline bool IsStringASCII(const TChar* first, const TChar* last) { 
+//! returns @c true if character sequence has no symbols with value greater than 0x7F
+template <typename TChar>
+inline bool IsStringASCII(const TChar* first, const TChar* last) {
     return ::NDetail::DoIsStringASCII(first, last);
-} 
+}
 
 #ifdef _sse2_
 template <>
@@ -618,76 +618,76 @@ inline void Copy(const TChar* first, size_t len, TChar* result) {
     memcpy(result, first, len * sizeof(TChar));
 }
 
-template <typename TChar1, typename TChar2> 
-inline void Copy(const TChar1* first, size_t len, TChar2* result) { 
-    Copy(first, first + len, result); 
-} 
+template <typename TChar1, typename TChar2>
+inline void Copy(const TChar1* first, size_t len, TChar2* result) {
+    Copy(first, first + len, result);
+}
 
-//! copies symbols from one character sequence to another without any conversion 
-//! @note this function can be used instead of the template constructor of @c std::basic_string: 
-//!       template <typename InputIterator> 
-//!       basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator()); 
-//!       and the family of template member functions: append, assign, insert, replace. 
+//! copies symbols from one character sequence to another without any conversion
+//! @note this function can be used instead of the template constructor of @c std::basic_string:
+//!       template <typename InputIterator>
+//!       basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
+//!       and the family of template member functions: append, assign, insert, replace.
 template <typename TStringType, typename TChar>
 inline TStringType CopyTo(const TChar* first, const TChar* last) {
     Y_ASSERT(first <= last);
     TStringType str = TStringType::Uninitialized(last - first);
-    Copy(first, last, str.begin()); 
-    return str; 
-} 
+    Copy(first, last, str.begin());
+    return str;
+}
 
 template <typename TStringType, typename TChar>
 inline TStringType CopyTo(const TChar* s, size_t n) {
     TStringType str = TStringType::Uninitialized(n);
-    Copy(s, n, str.begin()); 
-    return str; 
-} 
- 
+    Copy(s, n, str.begin());
+    return str;
+}
+
 inline TString WideToASCII(const TWtringBuf w) {
     Y_ASSERT(IsStringASCII(w.begin(), w.end()));
     return CopyTo<TString>(w.begin(), w.end());
-} 
- 
+}
+
 inline TUtf16String ASCIIToWide(const TStringBuf s) {
     Y_ASSERT(IsStringASCII(s.begin(), s.end()));
     return CopyTo<TUtf16String>(s.begin(), s.end());
-} 
- 
+}
+
 inline TUtf32String ASCIIToUTF32(const TStringBuf s) {
     Y_ASSERT(IsStringASCII(s.begin(), s.end()));
     return CopyTo<TUtf32String>(s.begin(), s.end());
 }
 
-//! returns @c true if string contains whitespace characters only 
+//! returns @c true if string contains whitespace characters only
 inline bool IsSpace(const wchar16* s, size_t n) {
     if (n == 0)
         return false;
 
     Y_ASSERT(s);
 
-    const wchar16* const e = s + n; 
-    for (const wchar16* p = s; p != e; ++p) { 
+    const wchar16* const e = s + n;
+    for (const wchar16* p = s; p != e; ++p) {
         if (!IsWhitespace(*p))
-            return false; 
-    } 
-    return true; 
-} 
- 
+            return false;
+    }
+    return true;
+}
+
 //! returns @c true if string contains whitespace characters only
 inline bool IsSpace(const TWtringBuf s) {
     return IsSpace(s.data(), s.length());
 }
 
-//! replaces multiple sequential whitespace characters with a single space character 
+//! replaces multiple sequential whitespace characters with a single space character
 void Collapse(TUtf16String& w);
- 
-//! @return new length 
-size_t Collapse(wchar16* s, size_t n); 
- 
+
+//! @return new length
+size_t Collapse(wchar16* s, size_t n);
+
 //! Removes leading whitespace characters
 TWtringBuf StripLeft(const TWtringBuf text) noexcept Y_WARN_UNUSED_RESULT;
 void StripLeft(TUtf16String& text);
- 
+
 //! Removes trailing whitespace characters
 TWtringBuf StripRight(const TWtringBuf text) noexcept Y_WARN_UNUSED_RESULT;
 void StripRight(TUtf16String& text);
@@ -807,7 +807,7 @@ TUtf32String ToLowerRet(const TUtf32StringBuf text, size_t pos = 0, size_t count
 TUtf32String ToUpperRet(const TUtf32StringBuf text, size_t pos = 0, size_t count = TWtringBuf::npos) Y_WARN_UNUSED_RESULT;
 TUtf32String ToTitleRet(const TUtf32StringBuf text, size_t pos = 0, size_t count = TWtringBuf::npos) Y_WARN_UNUSED_RESULT;
 
-//! replaces the '<', '>' and '&' characters in string with '&lt;', '&gt;' and '&amp;' respectively 
+//! replaces the '<', '>' and '&' characters in string with '&lt;', '&gt;' and '&amp;' respectively
 // insertBr=true - replace '\r' and '\n' with "<BR>"
 template <bool insertBr>
 void EscapeHtmlChars(TUtf16String& str);
diff --git a/util/charset/wide_ut.cpp b/util/charset/wide_ut.cpp
index 995d3d1d85..d8f3233e73 100644
--- a/util/charset/wide_ut.cpp
+++ b/util/charset/wide_ut.cpp
@@ -7,18 +7,18 @@
 
 #include <algorithm>
 
-namespace { 
-    //! three UTF8 encoded russian letters (A, B, V) 
+namespace {
+    //! three UTF8 encoded russian letters (A, B, V)
     const char utext[] = "\xd0\x90\xd0\x91\xd0\x92";
- 
-    const char asciiLatinAlphabet[] = "ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz"; 
-    const wchar16 wideLatinAlphabet[] = { 
-        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'G', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 
+
+    const char asciiLatinAlphabet[] = "ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz";
+    const wchar16 wideLatinAlphabet[] = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'G', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'g', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 0};
-    const wchar16 wideCyrillicAlphabet[] = { 
-        0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 
-        0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 
-        0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 
+    const wchar16 wideCyrillicAlphabet[] = {
+        0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+        0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+        0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
         0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0x00};
     const char utf8CyrillicAlphabet[] =
         "\xd0\x90\xd0\x91\xd0\x92\xd0\x93\xd0\x94\xd0\x95\xd0\x96\xd0\x97"
@@ -29,22 +29,22 @@ namespace {
         "\xd0\xb8\xd0\xb9\xd0\xba\xd0\xbb\xd0\xbc\xd0\xbd\xd0\xbe\xd0\xbf"
         "\xd1\x80\xd1\x81\xd1\x82\xd1\x83\xd1\x84\xd1\x85\xd1\x86\xd1\x87"
         "\xd1\x88\xd1\x89\xd1\x8a\xd1\x8b\xd1\x8c\xd1\x8d\xd1\x8e\xd1\x8f";
- 
-    const wchar32 LEAD_BITS_MASK_2_BYTES = 0x1F; 
-    const wchar32 LEAD_BITS_MASK_3_BYTES = 0x0F; 
+
+    const wchar32 LEAD_BITS_MASK_2_BYTES = 0x1F;
+    const wchar32 LEAD_BITS_MASK_3_BYTES = 0x0F;
     const wchar32 LEAD_BITS_MASK_4_BYTES = 0x07;
- 
-    wchar16 ws[] = { 
+
+    wchar16 ws[] = {
         0x0009,
         0x000A, 0x2028, 0x2029,
         0x000B,
         0x000C,
         0x000D,
         0x0020, 0x1680,
-        0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B, 
-        0x202F, 0x205F, 0x3000, 
+        0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B,
+        0x202F, 0x205F, 0x3000,
         0x00A0};
- 
+
     const size_t CaseTestDataSize = 10;
     wchar32 WideStringTestData[][CaseTestDataSize] = {
         {0x01C4, 0x10428, 0x10429, 0x10447, 0x10441, 0x1C03, 0x00A0, 0x10400, 0x10415, 0x10437}, // original
@@ -54,32 +54,32 @@ namespace {
     };
 
     TUtf16String CreateUnicodeText() {
-        const int len = 256; 
-        wchar16 text[len] = { 
-            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00 - 0x0F 
-            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10 - 0x1F 
-            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x20 - 0x2F 
-            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x30 - 0x3F 
-            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40 - 0x4F 
-            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x50 - 0x5F 
-            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x60 - 0x6F 
-            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x70 - 0x7F 
- 
-            0x0301, 0x00C4, 0x00D6, 0x00DC, 0x0104, 0x0106, 0x0118, 0x0141, 0x00E0, 0x00E2, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x0490, 0x00AD, // 0x80 - 0x8F 
-            0x00DF, 0x00E4, 0x00F6, 0x00FC, 0x0105, 0x0107, 0x0119, 0x0142, 0x00EB, 0x00EE, 0x00EF, 0x00F4, 0x00F9, 0x00FB, 0x0491, 0x92CF, // 0x90 - 0x9F 
-            0x00A0, 0x0143, 0x00D3, 0x015A, 0x017B, 0x0179, 0x046C, 0x00A7, 0x0401, 0x0462, 0x0472, 0x0474, 0x040E, 0x0406, 0x0404, 0x0407, // 0xA0 - 0xAF 
-            0x00B0, 0x0144, 0x00F3, 0x015B, 0x017C, 0x017A, 0x046D, 0x2116, 0x0451, 0x0463, 0x0473, 0x0475, 0x045E, 0x0456, 0x0454, 0x0457  // 0xB0 - 0xBF 
-        }; 
-        for (int i = 0; i < len; ++i) { 
-            if (i <= 0x7F) { // ASCII characters without 0x7 and 0x1B 
-                text[i] = static_cast<wchar16>(i); 
+        const int len = 256;
+        wchar16 text[len] = {
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00 - 0x0F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10 - 0x1F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x20 - 0x2F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x30 - 0x3F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40 - 0x4F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x50 - 0x5F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x60 - 0x6F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x70 - 0x7F
+
+            0x0301, 0x00C4, 0x00D6, 0x00DC, 0x0104, 0x0106, 0x0118, 0x0141, 0x00E0, 0x00E2, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x0490, 0x00AD, // 0x80 - 0x8F
+            0x00DF, 0x00E4, 0x00F6, 0x00FC, 0x0105, 0x0107, 0x0119, 0x0142, 0x00EB, 0x00EE, 0x00EF, 0x00F4, 0x00F9, 0x00FB, 0x0491, 0x92CF, // 0x90 - 0x9F
+            0x00A0, 0x0143, 0x00D3, 0x015A, 0x017B, 0x0179, 0x046C, 0x00A7, 0x0401, 0x0462, 0x0472, 0x0474, 0x040E, 0x0406, 0x0404, 0x0407, // 0xA0 - 0xAF
+            0x00B0, 0x0144, 0x00F3, 0x015B, 0x017C, 0x017A, 0x046D, 0x2116, 0x0451, 0x0463, 0x0473, 0x0475, 0x045E, 0x0456, 0x0454, 0x0457  // 0xB0 - 0xBF
+        };
+        for (int i = 0; i < len; ++i) {
+            if (i <= 0x7F) { // ASCII characters without 0x7 and 0x1B
+                text[i] = static_cast<wchar16>(i);
             } else if (i >= 0xC0 && i <= 0xFF) {            // russian characters (without YO and yo)
-                text[i] = static_cast<wchar16>(i + 0x0350); // 0x0410 - 0x044F 
-            } 
-        } 
+                text[i] = static_cast<wchar16>(i + 0x0350); // 0x0410 - 0x044F
+            }
+        }
         return TUtf16String(text, len);
-    } 
- 
+    }
+
     TString CreateUTF8Text() {
         char text[] = {
             '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f',
@@ -108,9 +108,9 @@ namespace {
             '\xd1', '\x87', '\xd1', '\x88', '\xd1', '\x89', '\xd1', '\x8a', '\xd1', '\x8b', '\xd1', '\x8c', '\xd1', '\x8d', '\xd1', '\x8e',
             '\xd1', '\x8f'};
         return TString(text, Y_ARRAY_SIZE(text));
-    } 
- 
-    //! use this function to dump UTF8 text into a file in case of any changes 
+    }
+
+    //! use this function to dump UTF8 text into a file in case of any changes
     //    void DumpUTF8Text() {
     //        TString s = WideToUTF8(UnicodeText);
     //        std::ofstream f("utf8.txt");
@@ -121,53 +121,53 @@ namespace {
     //                f << std::endl;
     //        }
     //    }
- 
-    void CheckRecodeOK(wchar32 expected, unsigned char* first, size_t n) { 
-        wchar32 w = 0; 
-        const unsigned char* p = first; 
- 
+
+    void CheckRecodeOK(wchar32 expected, unsigned char* first, size_t n) {
+        wchar32 w = 0;
+        const unsigned char* p = first;
+
         RECODE_RESULT r = ReadUTF8CharAndAdvance(w, p, first + n);
-        UNIT_ASSERT(w == expected); 
-        UNIT_ASSERT(size_t(p - first) == n); 
-        UNIT_ASSERT(r == RECODE_OK); 
-    } 
- 
-    void CheckBrokenSymbol(unsigned char* first, unsigned char* last) { 
-        wchar32 w = 0; 
-        const unsigned char* p = first; 
- 
+        UNIT_ASSERT(w == expected);
+        UNIT_ASSERT(size_t(p - first) == n);
+        UNIT_ASSERT(r == RECODE_OK);
+    }
+
+    void CheckBrokenSymbol(unsigned char* first, unsigned char* last) {
+        wchar32 w = 0;
+        const unsigned char* p = first;
+
         RECODE_RESULT r = ReadUTF8CharAndAdvance(w, p, last);
-        UNIT_ASSERT(w == BROKEN_RUNE); 
-        UNIT_ASSERT(p - first == 0); 
-        UNIT_ASSERT(r == RECODE_BROKENSYMBOL); 
-    } 
- 
-    void CheckEndOfInput(unsigned char* first, size_t n) { 
-        wchar32 w = 0; 
-        const unsigned char* p = first; 
- 
+        UNIT_ASSERT(w == BROKEN_RUNE);
+        UNIT_ASSERT(p - first == 0);
+        UNIT_ASSERT(r == RECODE_BROKENSYMBOL);
+    }
+
+    void CheckEndOfInput(unsigned char* first, size_t n) {
+        wchar32 w = 0;
+        const unsigned char* p = first;
+
         RECODE_RESULT r = ReadUTF8CharAndAdvance(w, p, first + n);
-        (void)w; 
-        UNIT_ASSERT(p - first == 0); 
-        UNIT_ASSERT(r == RECODE_EOINPUT); 
-    } 
- 
-    void CheckCharLen(unsigned char* first, unsigned char* last, size_t len, RECODE_RESULT result) { 
-        size_t n = 0; 
+        (void)w;
+        UNIT_ASSERT(p - first == 0);
+        UNIT_ASSERT(r == RECODE_EOINPUT);
+    }
+
+    void CheckCharLen(unsigned char* first, unsigned char* last, size_t len, RECODE_RESULT result) {
+        size_t n = 0;
         RECODE_RESULT r = GetUTF8CharLen(n, first, last);
-        UNIT_ASSERT(n == len); 
-        UNIT_ASSERT(r == result); 
-    } 
-} 
- 
+        UNIT_ASSERT(n == len);
+        UNIT_ASSERT(r == result);
+    }
+}
+
 class TConversionTest: public TTestBase {
-private: 
-    //! @note every of the text can have zeros in the middle 
+private:
+    //! @note every of the text can have zeros in the middle
     const TUtf16String UnicodeText_;
     const TString Utf8Text_;
- 
-private: 
-    UNIT_TEST_SUITE(TConversionTest); 
+
+private:
+    UNIT_TEST_SUITE(TConversionTest);
     UNIT_TEST(TestReadUTF8Char);
     UNIT_TEST(TestGetUTF8CharLen);
     UNIT_TEST(TestWriteUTF8Char);
@@ -178,29 +178,29 @@ private:
     UNIT_TEST(TestUnicodeCase);
     UNIT_TEST(TestUnicodeDetails);
     UNIT_TEST(TestHexConversion);
-    UNIT_TEST_SUITE_END(); 
- 
-public: 
-    TConversionTest() 
+    UNIT_TEST_SUITE_END();
+
+public:
+    TConversionTest()
         : UnicodeText_(CreateUnicodeText())
         , Utf8Text_(CreateUTF8Text())
-    { 
-    } 
- 
-    void TestReadUTF8Char(); 
-    void TestGetUTF8CharLen(); 
-    void TestWriteUTF8Char(); 
-    void TestUTF8ToWide(); 
-    void TestWideToUTF8(); 
-    void TestGetNumOfUTF8Chars(); 
+    {
+    }
+
+    void TestReadUTF8Char();
+    void TestGetUTF8CharLen();
+    void TestWriteUTF8Char();
+    void TestUTF8ToWide();
+    void TestWideToUTF8();
+    void TestGetNumOfUTF8Chars();
     void TestSubstrUTF8();
     void TestUnicodeCase();
     void TestUnicodeDetails();
     void TestHexConversion();
-}; 
- 
-UNIT_TEST_SUITE_REGISTRATION(TConversionTest); 
- 
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TConversionTest);
+
 void TConversionTest::TestHexConversion() {
     for (char ch = '0'; ch <= '9'; ++ch) {
         UNIT_ASSERT(isxdigit(ch));
@@ -224,25 +224,25 @@ void TConversionTest::TestHexConversion() {
     }
 }
 
-void TConversionTest::TestReadUTF8Char() { 
-    wchar32 e; // expected unicode char 
-    wchar32 c; 
-    unsigned long u; // single UTF8 encoded character 
-    unsigned char* const first = reinterpret_cast<unsigned char*>(&u); 
-    unsigned char* const last = first + sizeof(u); 
- 
-    // all ASCII characters are converted with no change (zero converted successfully as well) 
-    for (c = 0; c <= 0x7F; ++c) { 
-        u = c; 
-        CheckRecodeOK(c, first, 1); 
-    } 
- 
-    // broken symbols from the second half of ASCII table (1000 0000 - 1011 1111) 
-    for (c = 0x80; c <= 0xBF; ++c) { 
-        u = c; 
-        CheckBrokenSymbol(first, last); 
-    } 
- 
+void TConversionTest::TestReadUTF8Char() {
+    wchar32 e; // expected unicode char
+    wchar32 c;
+    unsigned long u; // single UTF8 encoded character
+    unsigned char* const first = reinterpret_cast<unsigned char*>(&u);
+    unsigned char* const last = first + sizeof(u);
+
+    // all ASCII characters are converted with no change (zero converted successfully as well)
+    for (c = 0; c <= 0x7F; ++c) {
+        u = c;
+        CheckRecodeOK(c, first, 1);
+    }
+
+    // broken symbols from the second half of ASCII table (1000 0000 - 1011 1111)
+    for (c = 0x80; c <= 0xBF; ++c) {
+        u = c;
+        CheckBrokenSymbol(first, last);
+    }
+
     // overlong encoding: leading byte of 2-byte symbol: 1100 0000 - 1100 0001
     for (c = 0xC0; c <= 0xC1; ++c) {
         u = c;
@@ -254,20 +254,20 @@ void TConversionTest::TestReadUTF8Char() {
         CheckEndOfInput(first, 1);
     }
 
-    // leading byte of 2-byte symbol: 1100 0000 - 1101 1111 
+    // leading byte of 2-byte symbol: 1100 0000 - 1101 1111
     for (c = 0xC2; c <= 0xDF; ++c) {
-        u = c; 
-        CheckBrokenSymbol(first, last); 
- 
-        u |= 0x8000; 
-        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000 
-        e = c & LEAD_BITS_MASK_2_BYTES; 
-        e <<= 6; 
-        CheckRecodeOK(e, first, 2); 
- 
-        CheckEndOfInput(first, 1); 
-    } 
- 
+        u = c;
+        CheckBrokenSymbol(first, last);
+
+        u |= 0x8000;
+        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000
+        e = c & LEAD_BITS_MASK_2_BYTES;
+        e <<= 6;
+        CheckRecodeOK(e, first, 2);
+
+        CheckEndOfInput(first, 1);
+    }
+
     // possible overlong encoding with leading byte 1110 0000
     {
         u = c = 0xE0;
@@ -286,19 +286,19 @@ void TConversionTest::TestReadUTF8Char() {
 
     // leading byte of 3-byte symbol: 1110 0001 - 1110 1111
     for (c = 0xE1; c <= 0xEF; ++c) {
-        u = c; 
-        CheckBrokenSymbol(first, last); 
- 
-        u |= 0x808000; 
-        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000 
-        e = c & LEAD_BITS_MASK_3_BYTES; 
-        e <<= 12; 
-        CheckRecodeOK(e, first, 3); 
- 
-        CheckEndOfInput(first, 2); 
-        CheckEndOfInput(first, 1); 
-    } 
- 
+        u = c;
+        CheckBrokenSymbol(first, last);
+
+        u |= 0x808000;
+        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000
+        e = c & LEAD_BITS_MASK_3_BYTES;
+        e <<= 12;
+        CheckRecodeOK(e, first, 3);
+
+        CheckEndOfInput(first, 2);
+        CheckEndOfInput(first, 1);
+    }
+
     // possible overlong encoding with leading byte 1111 0000
     {
         u = c = 0xF0;
@@ -318,20 +318,20 @@ void TConversionTest::TestReadUTF8Char() {
 
     // leading byte of 4-byte symbol: 1111 0001 - 1111 0111
     for (c = 0xF1; c <= 0xF3; ++c) {
-        u = c; 
-        CheckBrokenSymbol(first, last); 
- 
-        u |= 0x80808000; 
-        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000 
-        e = c & LEAD_BITS_MASK_4_BYTES; 
-        e <<= 18; 
-        CheckRecodeOK(e, first, 4); 
- 
-        CheckEndOfInput(first, 3); 
-        CheckEndOfInput(first, 2); 
-        CheckEndOfInput(first, 1); 
-    } 
- 
+        u = c;
+        CheckBrokenSymbol(first, last);
+
+        u |= 0x80808000;
+        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000
+        e = c & LEAD_BITS_MASK_4_BYTES;
+        e <<= 18;
+        CheckRecodeOK(e, first, 4);
+
+        CheckEndOfInput(first, 3);
+        CheckEndOfInput(first, 2);
+        CheckEndOfInput(first, 1);
+    }
+
     // possible invalid code points with leading byte 1111 0100
     {
         c = 0xF4;
@@ -352,108 +352,108 @@ void TConversionTest::TestReadUTF8Char() {
 
     // broken symbols: 1111 0101 - 1111 1111
     for (c = 0xF5; c <= 0xFF; ++c) {
-        u = c; 
-        CheckBrokenSymbol(first, last); 
-    } 
-} 
- 
-void TConversionTest::TestGetUTF8CharLen() { 
-    wchar32 c; 
-    unsigned long u; // single UTF8 encoded character 
-    unsigned char* const first = reinterpret_cast<unsigned char*>(&u); 
-    unsigned char* const last = first + sizeof(u); 
- 
-    // all ASCII characters are converted with no change (zero converted successfully as well) 
-    for (c = 0; c <= 0x7F; ++c) { 
-        u = c; 
-        CheckCharLen(first, last, 1, RECODE_OK); 
-    } 
- 
-    // broken symbols from the second half of ASCII table (1000 0000 - 1011 1111) 
-    for (c = 0x80; c <= 0xBF; ++c) { 
-        u = c; 
-        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL); 
-    } 
- 
-    // leading byte of 2-byte symbol: 1100 0000 - 1101 1111 
-    for (c = 0xC0; c <= 0xDF; ++c) { 
-        u = c; 
-        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL); 
- 
-        u |= 0x8000; 
-        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000 
-        CheckCharLen(first, last, 2, RECODE_OK); 
- 
-        CheckCharLen(first, first + 1, 0, RECODE_EOINPUT); 
-    } 
- 
-    // leading byte of 3-byte symbol: 1110 0000 - 1110 1111 
-    for (c = 0xE0; c <= 0xEF; ++c) { 
-        u = c; 
-        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL); 
- 
-        u |= 0x808000; 
-        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000 
-        CheckCharLen(first, last, 3, RECODE_OK); 
- 
-        CheckCharLen(first, first + 2, 0, RECODE_EOINPUT); 
-        CheckCharLen(first, first + 1, 0, RECODE_EOINPUT); 
-    } 
- 
-    // leading byte of 4-byte symbol: 1111 0000 - 1111 0111 
-    for (c = 0xF0; c <= 0xF3; ++c) { 
-        u = c; 
-        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL); 
- 
-        u |= 0x80808000; 
-        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000 
-        CheckCharLen(first, last, 4, RECODE_OK); 
- 
-        CheckCharLen(first, first + 3, 0, RECODE_EOINPUT); 
-        CheckCharLen(first, first + 2, 0, RECODE_EOINPUT); 
-        CheckCharLen(first, first + 1, 0, RECODE_EOINPUT); 
-    } 
- 
-    // broken symbols: 1111 1000 - 1111 1111 
-    for (c = 0xF8; c <= 0xFF; ++c) { 
-        u = c; 
-        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL); 
-    } 
-} 
- 
-void TConversionTest::TestWriteUTF8Char() { 
-    wchar32 w; 
-    unsigned long u; // single UTF8 encoded character 
-    size_t n; 
- 
-    for (w = 0x00; w < 0x80; ++w) { 
-        u = 0; 
+        u = c;
+        CheckBrokenSymbol(first, last);
+    }
+}
+
+void TConversionTest::TestGetUTF8CharLen() {
+    wchar32 c;
+    unsigned long u; // single UTF8 encoded character
+    unsigned char* const first = reinterpret_cast<unsigned char*>(&u);
+    unsigned char* const last = first + sizeof(u);
+
+    // all ASCII characters are converted with no change (zero converted successfully as well)
+    for (c = 0; c <= 0x7F; ++c) {
+        u = c;
+        CheckCharLen(first, last, 1, RECODE_OK);
+    }
+
+    // broken symbols from the second half of ASCII table (1000 0000 - 1011 1111)
+    for (c = 0x80; c <= 0xBF; ++c) {
+        u = c;
+        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL);
+    }
+
+    // leading byte of 2-byte symbol: 1100 0000 - 1101 1111
+    for (c = 0xC0; c <= 0xDF; ++c) {
+        u = c;
+        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL);
+
+        u |= 0x8000;
+        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000
+        CheckCharLen(first, last, 2, RECODE_OK);
+
+        CheckCharLen(first, first + 1, 0, RECODE_EOINPUT);
+    }
+
+    // leading byte of 3-byte symbol: 1110 0000 - 1110 1111
+    for (c = 0xE0; c <= 0xEF; ++c) {
+        u = c;
+        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL);
+
+        u |= 0x808000;
+        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000
+        CheckCharLen(first, last, 3, RECODE_OK);
+
+        CheckCharLen(first, first + 2, 0, RECODE_EOINPUT);
+        CheckCharLen(first, first + 1, 0, RECODE_EOINPUT);
+    }
+
+    // leading byte of 4-byte symbol: 1111 0000 - 1111 0111
+    for (c = 0xF0; c <= 0xF3; ++c) {
+        u = c;
+        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL);
+
+        u |= 0x80808000;
+        // w: 0000 0000  0000 0000 - 0000 0111  1100 0000
+        CheckCharLen(first, last, 4, RECODE_OK);
+
+        CheckCharLen(first, first + 3, 0, RECODE_EOINPUT);
+        CheckCharLen(first, first + 2, 0, RECODE_EOINPUT);
+        CheckCharLen(first, first + 1, 0, RECODE_EOINPUT);
+    }
+
+    // broken symbols: 1111 1000 - 1111 1111
+    for (c = 0xF8; c <= 0xFF; ++c) {
+        u = c;
+        CheckCharLen(first, last, 0, RECODE_BROKENSYMBOL);
+    }
+}
+
+void TConversionTest::TestWriteUTF8Char() {
+    wchar32 w;
+    unsigned long u; // single UTF8 encoded character
+    size_t n;
+
+    for (w = 0x00; w < 0x80; ++w) {
+        u = 0;
         WriteUTF8Char(w, n, reinterpret_cast<unsigned char*>(&u));
-        UNIT_ASSERT((u & 0xFFFFFF80) == 0x00000000); 
-        UNIT_ASSERT(n == 1); 
-    } 
- 
-    for (w = 0x80; w < 0x800; ++w) { 
-        u = 0; 
+        UNIT_ASSERT((u & 0xFFFFFF80) == 0x00000000);
+        UNIT_ASSERT(n == 1);
+    }
+
+    for (w = 0x80; w < 0x800; ++w) {
+        u = 0;
         WriteUTF8Char(w, n, reinterpret_cast<unsigned char*>(&u));
-        UNIT_ASSERT((u & 0xFFFFC000) == 0x00008000); // see constants in ReadUTF8Char 
-        UNIT_ASSERT(n == 2); 
-    } 
- 
-    for (w = 0x800; w < 0x10000; ++w) { 
-        u = 0; 
+        UNIT_ASSERT((u & 0xFFFFC000) == 0x00008000); // see constants in ReadUTF8Char
+        UNIT_ASSERT(n == 2);
+    }
+
+    for (w = 0x800; w < 0x10000; ++w) {
+        u = 0;
         WriteUTF8Char(w, n, reinterpret_cast<unsigned char*>(&u));
-        UNIT_ASSERT((u & 0xFFC0C000) == 0x00808000); // see constants in ReadUTF8Char 
-        UNIT_ASSERT(n == 3); 
-    } 
- 
-    for (w = 0x10000; w < 0x80; ++w) { 
+        UNIT_ASSERT((u & 0xFFC0C000) == 0x00808000); // see constants in ReadUTF8Char
+        UNIT_ASSERT(n == 3);
+    }
+
+    for (w = 0x10000; w < 0x80; ++w) {
         WriteUTF8Char(w, n, reinterpret_cast<unsigned char*>(&u));
-        UNIT_ASSERT((u & 0xC0C0C000) == 0x80808000); // see constants in ReadUTF8Char 
-        UNIT_ASSERT(n == 4); 
-    } 
-} 
- 
+        UNIT_ASSERT((u & 0xC0C0C000) == 0x80808000); // see constants in ReadUTF8Char
+        UNIT_ASSERT(n == 4);
+    }
+}
+
 static void TestSurrogates(const char* str, const wchar16* wide, size_t wideSize) {
     TUtf16String w = UTF8ToWide(str);
 
@@ -465,41 +465,41 @@ static void TestSurrogates(const char* str, const wchar16* wide, size_t wideSize
     UNIT_ASSERT(s == str);
 }
 
-void TConversionTest::TestUTF8ToWide() { 
+void TConversionTest::TestUTF8ToWide() {
     TUtf16String w = UTF8ToWide(Utf8Text_);
- 
-    UNIT_ASSERT(w.size() == 256); 
+
+    UNIT_ASSERT(w.size() == 256);
     UNIT_ASSERT(w.size() == UnicodeText_.size());
- 
-    for (int i = 0; i < 256; ++i) { 
+
+    for (int i = 0; i < 256; ++i) {
         UNIT_ASSERT_VALUES_EQUAL(w[i], UnicodeText_[i]);
-    } 
- 
+    }
+
     wchar16 buffer[4] = {0};
-    size_t written = 0; 
-    // the function must extract 2 symbols only 
+    size_t written = 0;
+    // the function must extract 2 symbols only
     bool result = UTF8ToWide(utext, 5, buffer, written);
-    UNIT_ASSERT(!result); 
-    UNIT_ASSERT(buffer[0] == 0x0410); 
-    UNIT_ASSERT(buffer[1] == 0x0411); 
-    UNIT_ASSERT(buffer[2] == 0x0000); 
-    UNIT_ASSERT(buffer[3] == 0x0000); 
-    UNIT_ASSERT(written == 2); 
- 
-    memset(buffer, 0, 4); 
-    written = 0; 
+    UNIT_ASSERT(!result);
+    UNIT_ASSERT(buffer[0] == 0x0410);
+    UNIT_ASSERT(buffer[1] == 0x0411);
+    UNIT_ASSERT(buffer[2] == 0x0000);
+    UNIT_ASSERT(buffer[3] == 0x0000);
+    UNIT_ASSERT(written == 2);
+
+    memset(buffer, 0, 4);
+    written = 0;
     result = UTF8ToWide(utext, 1, buffer, written);
-    UNIT_ASSERT(!result); 
-    UNIT_ASSERT(buffer[0] == 0x0000); 
-    UNIT_ASSERT(buffer[1] == 0x0000); 
-    UNIT_ASSERT(buffer[2] == 0x0000); 
-    UNIT_ASSERT(buffer[3] == 0x0000); 
-    UNIT_ASSERT(written == 0); 
+    UNIT_ASSERT(!result);
+    UNIT_ASSERT(buffer[0] == 0x0000);
+    UNIT_ASSERT(buffer[1] == 0x0000);
+    UNIT_ASSERT(buffer[2] == 0x0000);
+    UNIT_ASSERT(buffer[3] == 0x0000);
+    UNIT_ASSERT(written == 0);
 
     w = UTF8ToWide(asciiLatinAlphabet, strlen(asciiLatinAlphabet));
-    UNIT_ASSERT(w == wideLatinAlphabet); 
+    UNIT_ASSERT(w == wideLatinAlphabet);
     w = UTF8ToWide(utf8CyrillicAlphabet, strlen(utf8CyrillicAlphabet));
-    UNIT_ASSERT(w == wideCyrillicAlphabet); 
+    UNIT_ASSERT(w == wideCyrillicAlphabet);
 
     const char* utf8NonBMP = "\xf4\x80\x89\x84\xf4\x80\x89\x87\xf4\x80\x88\xba";
     wchar16 wNonBMPDummy[] = {0xDBC0, 0xDE44, 0xDBC0, 0xDE47, 0xDBC0, 0xDE3A};
@@ -513,42 +513,42 @@ void TConversionTest::TestUTF8ToWide() {
                                  "m\xFB\xB2\xA5\xAA\xAFyeuse.sexwebcamz.com")))),
                              TString(
                                  "m\xEF\xBF\xBD\xEF\xBF\xBD\xEF\xBF\xBD\xEF\xBF\xBD\xEF\xBF\xBDyeuse.sexwebcamz.com"));
-} 
- 
-void TConversionTest::TestWideToUTF8() { 
+}
+
+void TConversionTest::TestWideToUTF8() {
     TString s = WideToUTF8(UnicodeText_);
     size_t len = 0;
     for (TUtf16String::const_iterator i = UnicodeText_.begin(), ie = UnicodeText_.end(); i != ie; ++i) {
         len += UTF8RuneLenByUCS(*i);
     }
- 
+
     UNIT_ASSERT(s.size() == Utf8Text_.size());
     UNIT_ASSERT(s.size() == len);
- 
-    for (int i = 0; i < static_cast<int>(s.size()); ++i) { 
+
+    for (int i = 0; i < static_cast<int>(s.size()); ++i) {
         UNIT_ASSERT_VALUES_EQUAL(s[i], Utf8Text_[i]);
-    } 
-} 
- 
-void TConversionTest::TestGetNumOfUTF8Chars() { 
-    size_t n = 0; 
+    }
+}
+
+void TConversionTest::TestGetNumOfUTF8Chars() {
+    size_t n = 0;
     bool result = GetNumberOfUTF8Chars(Utf8Text_.c_str(), Utf8Text_.size(), n);
-    UNIT_ASSERT(result); 
-    UNIT_ASSERT(n == 256); 
- 
-    n = 0; 
+    UNIT_ASSERT(result);
+    UNIT_ASSERT(n == 256);
+
+    n = 0;
     result = GetNumberOfUTF8Chars(utext, 5, n);
-    UNIT_ASSERT(!result); 
-    UNIT_ASSERT(n == 2); 
- 
-    n = 0; 
+    UNIT_ASSERT(!result);
+    UNIT_ASSERT(n == 2);
+
+    n = 0;
     result = GetNumberOfUTF8Chars(utext, 1, n);
-    UNIT_ASSERT(!result); 
-    UNIT_ASSERT(n == 0); 
+    UNIT_ASSERT(!result);
+    UNIT_ASSERT(n == 0);
 
     UNIT_ASSERT_EQUAL(GetNumberOfUTF8Chars("привет!"), 7);
-} 
- 
+}
+
 void TConversionTest::TestSubstrUTF8() {
     TStringBuf utextBuf(utext, sizeof(utext));
     UNIT_ASSERT(SubstrUTF8(utextBuf, 0, 2) == utextBuf.substr(0, 4));
@@ -580,7 +580,7 @@ void TConversionTest::TestUnicodeDetails() {
 }
 
 class TWideUtilTest: public TTestBase {
-    UNIT_TEST_SUITE(TWideUtilTest); 
+    UNIT_TEST_SUITE(TWideUtilTest);
     UNIT_TEST(TestCollapse);
     UNIT_TEST(TestCollapseBuffer);
     UNIT_TEST(TestStrip);
@@ -600,148 +600,148 @@ class TWideUtilTest: public TTestBase {
     UNIT_TEST(TestToLowerStr);
     UNIT_TEST(TestToUpperStr);
     UNIT_TEST(TestToTitleStr);
-    UNIT_TEST_SUITE_END(); 
- 
-public: 
-    void TestCollapse() { 
+    UNIT_TEST_SUITE_END();
+
+public:
+    void TestCollapse() {
         TUtf16String s;
         s.append(ws, Y_ARRAY_SIZE(ws)).append(3, 'a').append(ws, Y_ARRAY_SIZE(ws)).append(3, 'b').append(ws, Y_ARRAY_SIZE(ws));
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide(" aaa bbb "));
-        { 
+        {
             const TUtf16String w(ASCIIToWide(" a b c "));
-            s = w; 
-            Collapse(s); 
-            UNIT_ASSERT(s == w); 
+            s = w;
+            Collapse(s);
+            UNIT_ASSERT(s == w);
 #ifndef TSTRING_IS_STD_STRING
-            UNIT_ASSERT(s.c_str() == w.c_str()); // Collapse() does not change the string at all 
+            UNIT_ASSERT(s.c_str() == w.c_str()); // Collapse() does not change the string at all
 #endif
-        } 
+        }
         s = ASCIIToWide("  123    456  ");
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide(" 123 456 "));
- 
+
         s = ASCIIToWide("  1\n\n\n23\t    4\f\f56  ");
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide(" 1 23 4 56 "));
- 
+
         s = ASCIIToWide(" 1\n\n\n\f\f56  ");
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide(" 1 56 "));
- 
+
         s = ASCIIToWide("  1\r\n,\n(\n23\t    4\f\f56  ");
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide(" 1 , ( 23 4 56 "));
- 
+
         s = ASCIIToWide("1 23  ");
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide("1 23 "));
-        { 
+        {
             const TUtf16String w = ASCIIToWide(" ");
-            s = w; 
-            Collapse(s); 
-            UNIT_ASSERT(s == w); 
+            s = w;
+            Collapse(s);
+            UNIT_ASSERT(s == w);
 #ifndef TSTRING_IS_STD_STRING
-            UNIT_ASSERT(s.c_str() == w.c_str()); // Collapse() does not change the string at all 
+            UNIT_ASSERT(s.c_str() == w.c_str()); // Collapse() does not change the string at all
 #endif
-        } 
+        }
         s = ASCIIToWide("   ");
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide(" "));
- 
+
         s = ASCIIToWide(",\r\n\"");
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide(", \""));
- 
+
         s = ASCIIToWide("-");
-        Collapse(s); 
+        Collapse(s);
         UNIT_ASSERT(s == ASCIIToWide("-"));
- 
-        s.clear(); 
-        Collapse(s); 
+
+        s.clear();
+        Collapse(s);
         UNIT_ASSERT(s == TUtf16String());
-    } 
- 
-    void TestCollapseBuffer() { 
+    }
+
+    void TestCollapseBuffer() {
         TUtf16String s;
         s.append(ws, Y_ARRAY_SIZE(ws)).append(3, 'a').append(ws, Y_ARRAY_SIZE(ws)).append(3, 'b').append(ws, Y_ARRAY_SIZE(ws));
-        size_t n = Collapse(s.begin(), s.size()); 
-        s.resize(n); 
+        size_t n = Collapse(s.begin(), s.size());
+        s.resize(n);
         UNIT_ASSERT(s == ASCIIToWide(" aaa bbb "));
- 
+
         s = ASCIIToWide(" a b c ");
-        n = Collapse(s.begin(), s.size()); 
-        UNIT_ASSERT(n == s.size()); // length was not changed 
+        n = Collapse(s.begin(), s.size());
+        UNIT_ASSERT(n == s.size()); // length was not changed
         UNIT_ASSERT(s == ASCIIToWide(" a b c "));
- 
+
         s = ASCIIToWide("  123    456  ");
-        n = Collapse(s.begin(), s.size()); 
-        s.resize(n); 
+        n = Collapse(s.begin(), s.size());
+        s.resize(n);
         UNIT_ASSERT(s == ASCIIToWide(" 123 456 "));
- 
+
         s = ASCIIToWide("  1\n\n\n23\t    4\f\f56  ");
-        n = Collapse(s.begin(), s.size()); 
-        s.resize(n); 
+        n = Collapse(s.begin(), s.size());
+        s.resize(n);
         UNIT_ASSERT(s == ASCIIToWide(" 1 23 4 56 "));
- 
+
         s = ASCIIToWide(" 1\n\n\n\f\f56  ");
-        n = Collapse(s.begin(), s.size()); 
-        s.resize(n); 
+        n = Collapse(s.begin(), s.size());
+        s.resize(n);
         UNIT_ASSERT(s == ASCIIToWide(" 1 56 "));
- 
+
         s = ASCIIToWide("  1\r\n,\n(\n23\t    4\f\f56  ");
-        n = Collapse(s.begin(), s.size()); 
-        s.resize(n); 
+        n = Collapse(s.begin(), s.size());
+        s.resize(n);
         UNIT_ASSERT(s == ASCIIToWide(" 1 , ( 23 4 56 "));
- 
+
         s = ASCIIToWide("1 23  ");
-        n = Collapse(s.begin(), s.size()); 
-        s.resize(n); 
+        n = Collapse(s.begin(), s.size());
+        s.resize(n);
         UNIT_ASSERT(s == ASCIIToWide("1 23 "));
- 
+
         s = ASCIIToWide(" ");
-        n = Collapse(s.begin(), s.size()); 
-        UNIT_ASSERT(n == 1); 
+        n = Collapse(s.begin(), s.size());
+        UNIT_ASSERT(n == 1);
         UNIT_ASSERT(s == ASCIIToWide(" "));
- 
+
         s = ASCIIToWide("   ");
-        n = Collapse(s.begin(), s.size()); 
-        s.resize(n); 
+        n = Collapse(s.begin(), s.size());
+        s.resize(n);
         UNIT_ASSERT(s == ASCIIToWide(" "));
- 
+
         s = ASCIIToWide(",\r\n\"");
-        n = Collapse(s.begin(), s.size()); 
-        s.resize(n); 
+        n = Collapse(s.begin(), s.size());
+        s.resize(n);
         UNIT_ASSERT(s == ASCIIToWide(", \""));
- 
+
         s = ASCIIToWide("-");
-        n = Collapse(s.begin(), s.size()); 
-        UNIT_ASSERT(n == 1); 
+        n = Collapse(s.begin(), s.size());
+        UNIT_ASSERT(n == 1);
         UNIT_ASSERT(s == ASCIIToWide("-"));
- 
+
         s = ASCIIToWide("\t");
-        n = Collapse(s.begin(), s.size()); 
-        UNIT_ASSERT(n == 1); 
+        n = Collapse(s.begin(), s.size());
+        UNIT_ASSERT(n == 1);
         UNIT_ASSERT(s == ASCIIToWide(" "));
- 
-        s.clear(); 
-        n = Collapse(s.begin(), s.size()); 
-        UNIT_ASSERT(n == 0); 
+
+        s.clear();
+        n = Collapse(s.begin(), s.size());
+        UNIT_ASSERT(n == 0);
         UNIT_ASSERT(s == TUtf16String());
-    } 
- 
-    void TestStrip() { 
+    }
+
+    void TestStrip() {
         TUtf16String s;
- 
-        Strip(s); 
+
+        Strip(s);
         UNIT_ASSERT(s == TUtf16String());
         StripLeft(s);
         UNIT_ASSERT(s == TUtf16String());
         StripRight(s);
         UNIT_ASSERT(s == TUtf16String());
- 
+
         s = ASCIIToWide(" \t\r\n");
-        Strip(s); 
+        Strip(s);
         UNIT_ASSERT(s == TUtf16String());
         s = ASCIIToWide(" \t\r\n");
         StripLeft(s);
@@ -749,9 +749,9 @@ public:
         s = ASCIIToWide(" \t\r\n");
         StripRight(s);
         UNIT_ASSERT(s == TUtf16String());
- 
+
         s = ASCIIToWide("\t\f\va \r\n");
-        Strip(s); 
+        Strip(s);
         UNIT_ASSERT(s == ASCIIToWide("a"));
         s = ASCIIToWide("\t\f\va \r\n");
         StripLeft(s);
@@ -759,9 +759,9 @@ public:
         s = ASCIIToWide("\t\f\va \r\n");
         StripRight(s);
         UNIT_ASSERT(s == ASCIIToWide("\t\f\va"));
- 
+
         s = ASCIIToWide("\r\na\r\nb\t\tc\r\n");
-        Strip(s); 
+        Strip(s);
         UNIT_ASSERT(s == ASCIIToWide("a\r\nb\t\tc"));
         s = ASCIIToWide("\r\na\r\nb\t\tc\r\n");
         StripLeft(s);
@@ -769,13 +769,13 @@ public:
         s = ASCIIToWide("\r\na\r\nb\t\tc\r\n");
         StripRight(s);
         UNIT_ASSERT(s == ASCIIToWide("\r\na\r\nb\t\tc"));
- 
+
         const TUtf16String w(ASCIIToWide("a  b"));
-        s = w; 
-        Strip(s); 
-        UNIT_ASSERT(s == w); 
+        s = w;
+        Strip(s);
+        UNIT_ASSERT(s == w);
 #ifndef TSTRING_IS_STD_STRING
-        UNIT_ASSERT(s.c_str() == w.c_str()); // Strip() does not change the string at all 
+        UNIT_ASSERT(s.c_str() == w.c_str()); // Strip() does not change the string at all
 #endif
         s = w;
         StripLeft(s);
@@ -789,31 +789,31 @@ public:
 #ifndef TSTRING_IS_STD_STRING
         UNIT_ASSERT(s.c_str() == w.c_str()); // Strip() does not change the string at all
 #endif
-    } 
- 
-    void TestIsSpace() { 
+    }
+
+    void TestIsSpace() {
         UNIT_ASSERT(!IsSpace(TUtf16String()));
 
         UNIT_ASSERT(IsSpace(ws, Y_ARRAY_SIZE(ws)));
- 
+
         TUtf16String w;
         w.assign(ws, Y_ARRAY_SIZE(ws)).append(TUtf16String(1, '!'));
-        UNIT_ASSERT(!IsSpace(w.c_str(), w.size())); 
- 
+        UNIT_ASSERT(!IsSpace(w.c_str(), w.size()));
+
         w.assign(TUtf16String(1, '_')).append(ws, Y_ARRAY_SIZE(ws));
-        UNIT_ASSERT(!IsSpace(w.c_str(), w.size())); 
- 
+        UNIT_ASSERT(!IsSpace(w.c_str(), w.size()));
+
         w.assign(ws, Y_ARRAY_SIZE(ws)).append(TUtf16String(1, '$')).append(ws, Y_ARRAY_SIZE(ws));
-        UNIT_ASSERT(!IsSpace(w.c_str(), w.size())); 
-    } 
- 
-    void TestEscapeHtmlChars() { 
-        // characters from the first half of the ASCII table 
+        UNIT_ASSERT(!IsSpace(w.c_str(), w.size()));
+    }
+
+    void TestEscapeHtmlChars() {
+        // characters from the first half of the ASCII table
         for (wchar16 c = 1; c < 0x7F; ++c) {
             TUtf16String w(1, c);
             EscapeHtmlChars<false>(w);
- 
-            switch (c) { 
+
+            switch (c) {
                 case '<':
                     UNIT_ASSERT(w == ASCIIToWide("&lt;"));
                     break;
@@ -829,8 +829,8 @@ public:
                 default:
                     UNIT_ASSERT(w == TUtf16String(1, c));
                     break;
-            } 
-        } 
+            }
+        }
 
         for (wchar16 c = 1; c < 0x7F; ++c) {
             TUtf16String w(1, c);
@@ -858,24 +858,24 @@ public:
                     break;
             }
         }
-    } 
+    }
 
-    void TestToLower() { 
-        const size_t n = 32; 
-        wchar16 upperCase[n]; 
+    void TestToLower() {
+        const size_t n = 32;
+        wchar16 upperCase[n];
         std::copy(wideCyrillicAlphabet, wideCyrillicAlphabet + n, upperCase);
-        ToLower(upperCase, n); 
+        ToLower(upperCase, n);
         UNIT_ASSERT(TWtringBuf(upperCase, n) == TWtringBuf(wideCyrillicAlphabet + n, n));
-    } 
- 
-    void TestToUpper() { 
-        const size_t n = 32; 
-        wchar16 lowerCase[n]; 
+    }
+
+    void TestToUpper() {
+        const size_t n = 32;
+        wchar16 lowerCase[n];
         std::copy(wideCyrillicAlphabet + n, wideCyrillicAlphabet + n * 2, lowerCase);
-        ToUpper(lowerCase, n); 
+        ToUpper(lowerCase, n);
         UNIT_ASSERT(TWtringBuf(lowerCase, n) == TWtringBuf(wideCyrillicAlphabet, n));
-    } 
- 
+    }
+
     void TestWideString() {
         const TUtf16String original = UTF32ToWide(WideStringTestData[0], CaseTestDataSize);
         const TUtf16String lower = UTF32ToWide(WideStringTestData[1], CaseTestDataSize);
@@ -1737,6 +1737,6 @@ public:
             UNIT_ASSERT(ToTitleRet(TWtringBuf(copy), 3, 100500) == title);
         }
     }
-}; 
- 
-UNIT_TEST_SUITE_REGISTRATION(TWideUtilTest); 
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TWideUtilTest);
diff --git a/util/datetime/parser.rl6 b/util/datetime/parser.rl6
index 993a0e4f75..931f09eae1 100644
--- a/util/datetime/parser.rl6
+++ b/util/datetime/parser.rl6
@@ -9,7 +9,7 @@
 #include <util/generic/ymath.h>
 
 
-%%{ 
+%%{
 
 machine DateTimeParserCommon;
 
@@ -49,7 +49,7 @@ int12 = (digit digit?)
     >clear_int
     $update_int;
 
-int24 = ( digit digit ( digit digit )? ) 
+int24 = ( digit digit ( digit digit )? )
     >clear_int
     $update_int;
 
@@ -98,21 +98,21 @@ dow_spec = ( wkday ',' )?;
 
 day  = int12 %set_day;
 year = int24 %set_year;
- 
-# actually it must be from 0 to 23 
+
+# actually it must be from 0 to 23
 hour = int2 %set_hour;
- 
-# actually it must be from 0 to 59 
+
+# actually it must be from 0 to 59
 min  = int2 %set_minute;
- 
-# actually it must be from 0 to 59 
+
+# actually it must be from 0 to 59
 sec  = int2 %set_second;
 
-sec_spec  = ( ':' . sec )?; 
- 
+sec_spec  = ( ':' . sec )?;
+
 # so called "military zone offset". I hardly believe someone uses it now, but we MUST respect RFc822
 action set_mil_offset {
-    char c = (char)toupper(fc); 
+    char c = (char)toupper(fc);
     if (c == 'Z')
         DateTimeFields.ZoneOffsetMinutes = 0;
     else {
@@ -135,10 +135,10 @@ action set_digit_offset {
 
 mil_zone = /[A-IK-Za-ik-z]/ $set_mil_offset;
 
-# actions % were replaced with @ (when the script was migrated to ragel 5.24) 
-# because ragel 5.24 does not call to the % action if it  be called at the very end of string. 
-# it is a bug in ragel 5 because ragel 6.2 works correctly with % at the end of string. 
-# see http://www.complang.org/ragel/ChangeLog. 
+# actions % were replaced with @ (when the script was migrated to ragel 5.24)
+# because ragel 5.24 does not call to the % action if it  be called at the very end of string.
+# it is a bug in ragel 5 because ragel 6.2 works correctly with % at the end of string.
+# see http://www.complang.org/ragel/ChangeLog.
 
 zone = 'UT' @{ DateTimeFields.ZoneOffsetMinutes = 0; }
     | 'GMT' @{ DateTimeFields.ZoneOffsetMinutes = 0; }
@@ -150,23 +150,23 @@ zone = 'UT' @{ DateTimeFields.ZoneOffsetMinutes = 0; }
     | 'MDT' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(6).Minutes(); }
     | 'PST' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(8).Minutes();}
     | 'PDT' @{ DateTimeFields.ZoneOffsetMinutes = -(i32)TDuration::Hours(7).Minutes(); };
- 
+
 digit_offset = ('+' | '-') > { Sign = fc == '+' ? 1 : -1; } . int4 @set_digit_offset;
- 
-offset = ( zone | mil_zone | digit_offset ); 
- 
+
+offset = ( zone | mil_zone | digit_offset );
+
 rfc822datetime = ws0 . dow_spec . ws0 . day . ws1 . month3 . ws1 . year . ws1 . hour . ':' . min . sec_spec . ws1 . offset . ws0;
 
 main := rfc822datetime;
 
-write data noerror; 
+write data noerror;
+
+}%%
 
-}%% 
- 
 TRfc822DateTimeParserDeprecated::TRfc822DateTimeParserDeprecated() {
     %% write init;
 }
- 
+
 bool TRfc822DateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
     const char* p = input;
     const char* pe = input + len;
@@ -174,7 +174,7 @@ bool TRfc822DateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
     %% write exec;
     return cs != %%{ write error; }%%;
 }
- 
+
 TRfc822DateTimeParser::TRfc822DateTimeParser() {
     %% write init;
 }
@@ -224,17 +224,17 @@ write data noerror;
 }%%
 
 TIso8601DateTimeParserDeprecated::TIso8601DateTimeParserDeprecated() {
-    %% write init; 
+    %% write init;
 }
 
 bool TIso8601DateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
     const char* p = input;
     const char* pe = input + len;
 
-    %% write exec; 
+    %% write exec;
     return cs != %%{ write error; }%%;
 }
- 
+
 TIso8601DateTimeParser::TIso8601DateTimeParser() {
     %% write init;
 }
@@ -687,7 +687,7 @@ bool ParseRFC822DateTime(const char* input, size_t inputLen, time_t& utcTime) {
 bool ParseISO8601DateTime(const char* input, size_t inputLen, time_t& utcTime) {
     try {
         utcTime = ParseUnsafe<TIso8601DateTimeParser, TInstant>(input, inputLen).TimeT();
-        return true; 
+        return true;
     } catch (const TDateTimeParseException&) {
         return false;
     }
diff --git a/util/datetime/parser_ut.cpp b/util/datetime/parser_ut.cpp
index 63498be95e..61364af997 100644
--- a/util/datetime/parser_ut.cpp
+++ b/util/datetime/parser_ut.cpp
@@ -2,68 +2,68 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-static const time_t SECONDS_PER_HOUR = 3600; 
-static const time_t SECONDS_PER_MINUTE = 60; 
- 
+static const time_t SECONDS_PER_HOUR = 3600;
+static const time_t SECONDS_PER_MINUTE = 60;
+
 Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
     Y_UNIT_TEST(TestRfc822Correct) {
-        bool r = false; 
-        time_t t = 0; 
- 
-        // predefined time zones 
+        bool r = false;
+        time_t t = 0;
+
+        // predefined time zones
 
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 UT", t);
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
- 
+
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 GMT", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
- 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
+
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 EST", t);
-        UNIT_ASSERT(r); 
+        UNIT_ASSERT(r);
         UNIT_ASSERT_VALUES_EQUAL(t, (time_t)1109964885 + 5 * SECONDS_PER_HOUR);
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 EDT", t);
-        UNIT_ASSERT(r); 
+        UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 4 * SECONDS_PER_HOUR);
- 
+
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 CST", t);
-        UNIT_ASSERT(r); 
+        UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 6 * SECONDS_PER_HOUR);
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 CDT", t);
-        UNIT_ASSERT(r); 
+        UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 5 * SECONDS_PER_HOUR);
- 
+
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 MST", t);
-        UNIT_ASSERT(r); 
+        UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 7 * SECONDS_PER_HOUR);
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 MDT", t);
-        UNIT_ASSERT(r); 
+        UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 6 * SECONDS_PER_HOUR);
- 
+
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 PST", t);
-        UNIT_ASSERT(r); 
+        UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 8 * SECONDS_PER_HOUR);
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 PDT", t);
-        UNIT_ASSERT(r); 
+        UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 7 * SECONDS_PER_HOUR);
- 
-        // optinal century 
+
+        // optinal century
         r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34:45 UT", t);
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
-        // + optional day of week 
+        // + optional day of week
         r = ParseRFC822DateTime("4 Mar 05 19:34:45 UT", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
-        // + optional seconds 
+        // + optional seconds
         r = ParseRFC822DateTime("4 Mar 05 19:34 UT", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964840); 
- 
-        // local differential hour+min 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964840);
+
+        // local differential hour+min
 
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 +0300", t);
         UNIT_ASSERT(r);
@@ -80,44 +80,44 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
         r = ParseRFC822DateTime("21 Apr 99 23:40 +0400", t);
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)924723600);
- 
+
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 -0300", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR); 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR);
 
         r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34 -0300", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR); 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR);
 
         r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34:45 -0330", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE); 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
 
         r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34 -0330", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE); 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
 
         r = ParseRFC822DateTime("4 Mar 2005 19:34:45 -1030", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE); 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
 
         r = ParseRFC822DateTime("4 Mar 2005 19:34 -1030", t);
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE); 
- 
-        // white spaces 
- 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
+
+        // white spaces
+
         r = ParseRFC822DateTime("Fri,4 Mar 2005 19:34:45 UT", t); // no space after comma
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
- 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
+
         r = ParseRFC822DateTime("   Fri,   4   Mar   2005   19:34:45   UT   ", t); // several spaces, leading and trailing
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
- 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
+
         r = ParseRFC822DateTime(" \t Fri, \t 4 \t Mar \t 2005 \t 19:34:45 \t UT \t ", t); // spaces with tabs
-        UNIT_ASSERT(r); 
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+        UNIT_ASSERT(r);
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
         r = ParseRFC822DateTime("Thu, 01 Jan 1970 03:00:00 +0300", t); // spaces with tabs
         UNIT_ASSERT(r);
@@ -129,36 +129,36 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
     }
 
     time_t GetOffset(char militaryZone) {
-        char ch = (char)toupper(militaryZone); 
-        if (ch == 'Z') { 
-            return 0; 
-        } else if (ch >= 'A' && ch < 'J') { 
-            return (ch - 'A' + 1) * SECONDS_PER_HOUR; 
-        } else if (ch > 'J' && ch <= 'M') { 
-            return (ch - 'A') * SECONDS_PER_HOUR; 
-        } else if (ch >= 'N' && ch <= 'Y') { 
-            return -(ch - 'N' + 1) * SECONDS_PER_HOUR; 
-        } else { 
+        char ch = (char)toupper(militaryZone);
+        if (ch == 'Z') {
+            return 0;
+        } else if (ch >= 'A' && ch < 'J') {
+            return (ch - 'A' + 1) * SECONDS_PER_HOUR;
+        } else if (ch > 'J' && ch <= 'M') {
+            return (ch - 'A') * SECONDS_PER_HOUR;
+        } else if (ch >= 'N' && ch <= 'Y') {
+            return -(ch - 'N' + 1) * SECONDS_PER_HOUR;
+        } else {
             ythrow yexception() << "Invalid military zone.";
-        } 
-    } 
- 
+        }
+    }
+
     void DoTestMilitaryZones(char firstChar, char lastChar) {
-        const time_t utcTime = 1109964885; // Fri, 4 Mar 2005 19:34:45 UT 
-        char text[] = "Fri, 4 Mar 2005 19:34:45 A"; 
-        const size_t zoneCharIndex = strlen(text) - 1; 
- 
+        const time_t utcTime = 1109964885; // Fri, 4 Mar 2005 19:34:45 UT
+        char text[] = "Fri, 4 Mar 2005 19:34:45 A";
+        const size_t zoneCharIndex = strlen(text) - 1;
+
         for (char militaryZone = firstChar; militaryZone <= lastChar; ++militaryZone) {
-            time_t t = 0; 
-            const time_t offset = GetOffset(militaryZone); 
-            // the last character is replaced with next zone symbol 
-            text[zoneCharIndex] = militaryZone; 
- 
+            time_t t = 0;
+            const time_t offset = GetOffset(militaryZone);
+            // the last character is replaced with next zone symbol
+            text[zoneCharIndex] = militaryZone;
+
             UNIT_ASSERT(ParseRFC822DateTime(text, t));
             UNIT_ASSERT_EQUAL(t, utcTime - offset);
-        } 
-    } 
- 
+        }
+    }
+
     Y_UNIT_TEST(TestRfc822MilitaryZones) {
         DoTestMilitaryZones('A', 'I');
         DoTestMilitaryZones('K', 'Z');
@@ -167,8 +167,8 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
     }
 
     Y_UNIT_TEST(TestRfc822IncorrectDates) {
-        bool r = true; 
-        time_t t = 0; 
+        bool r = true;
+        time_t t = 0;
 
         t = 12345;
         r = ParseRFC822DateTime("", t);
@@ -195,64 +195,64 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
 
         // r = ParseRFC822DateTime("31 Apr 2004 19:34:45 +0300", t);
         // UNIT_ASSERT_EQUAL(r, false);
- 
+
         r = ParseRFC822DateTime("17 Nov 2008 19:34:45", t); // no specified time zone
-        UNIT_ASSERT(!r); 
- 
+        UNIT_ASSERT(!r);
+
         r = ParseRFC822DateTime("17 Nov 200 19:34:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("17 Nov 8 19:34:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("17 Nov 20008 19:34:45 UT", t);
-        UNIT_ASSERT(!r); 
- 
+        UNIT_ASSERT(!r);
+
         r = ParseRFC822DateTime("17 Nov 2008 1:34:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("17 Nov 2008 123:34:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("17 Nov 2008 19:1:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("17 Nov 2008 19:123:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("17 Nov 2008 19:34:1 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("17 Nov 2008 19:34:123 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("17 Nov 2008 19:34:12.12 UT", t); // fractions of second are now allowed
         UNIT_ASSERT(!r);
- 
+
         r = ParseRFC822DateTime("Mon , 17 Nov 2005 19:34:45 UT", t); // space after day before the comma
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2005 19 :34:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2005 19: 34:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2005 19:34 :45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2005 19:34: 45 UT", t);
-        UNIT_ASSERT(!r); 
- 
+        UNIT_ASSERT(!r);
+
         r = ParseRFC822DateTime("Monday, 17 Nov 2005 19:34:45 UT", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 November 2008 19:34:45 UT", t);
-        UNIT_ASSERT(!r); 
- 
+        UNIT_ASSERT(!r);
+
         r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +3", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +03", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +030", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +03030", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -3", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -03", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -030", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
         r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -03030", t);
-        UNIT_ASSERT(!r); 
+        UNIT_ASSERT(!r);
     }
 
     Y_UNIT_TEST(TestRfc822Partial) {
@@ -357,8 +357,8 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
         UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
 
         ret = ParseISO8601DateTime("2010-03-28T04:27:00.000-07:00", t);
-        UNIT_ASSERT(ret); 
-        UNIT_ASSERT_VALUES_EQUAL(t, 1269775620); 
+        UNIT_ASSERT(ret);
+        UNIT_ASSERT_VALUES_EQUAL(t, 1269775620);
     }
 
     Y_UNIT_TEST(TestIso8601TimeZone) {
diff --git a/util/datetime/systime.cpp b/util/datetime/systime.cpp
index 9b1f693a70..6ee7e8fc6e 100644
--- a/util/datetime/systime.cpp
+++ b/util/datetime/systime.cpp
@@ -55,23 +55,23 @@ char* ctime_r(const time_t* clock, char* buf) {
 #define YEARSIZE(year) (LEAPYEAR(year) ? 366 : 365)
 #define FOURCENTURIES (400 * 365 + 100 - 3)
 
-//! Inverse of gmtime: converts struct tm to time_t, assuming the data 
-//! in tm is UTC rather than local timezone. This implementation 
-//! returns the number of seconds since 1970-01-01, converted to time_t. 
-//! @note this code adopted from 
-//!       http://osdir.com/ml/web.wget.patches/2005-07/msg00010.html 
-//!       Subject: A more robust timegm - msg#00010 
+//! Inverse of gmtime: converts struct tm to time_t, assuming the data
+//! in tm is UTC rather than local timezone. This implementation
+//! returns the number of seconds since 1970-01-01, converted to time_t.
+//! @note this code adopted from
+//!       http://osdir.com/ml/web.wget.patches/2005-07/msg00010.html
+//!       Subject: A more robust timegm - msg#00010
 time_t TimeGM(const struct tm* t) {
-    static const unsigned short int month_to_days[][13] = { 
+    static const unsigned short int month_to_days[][13] = {
         {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
         {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}};
- 
+
     // Only handles years after 1970
     if (t->tm_year < 70) {
         return (time_t)-1;
     }
- 
-    int days = 365 * (t->tm_year - 70); 
+
+    int days = 365 * (t->tm_year - 70);
     // Take into account the leap days between 1970 and YEAR-1
     days += (t->tm_year - 1 - 68) / 4 - ((t->tm_year - 1) / 100) + ((t->tm_year - 1 + 300) / 400);
 
@@ -79,8 +79,8 @@ time_t TimeGM(const struct tm* t) {
         return (time_t)-1;
     }
     days += month_to_days[LEAPYEAR(1900 + t->tm_year)][t->tm_mon];
-    days += t->tm_mday - 1; 
- 
+    days += t->tm_mday - 1;
+
     unsigned long secs = days * 86400ul + t->tm_hour * 3600 + t->tm_min * 60 + t->tm_sec;
     return (time_t)secs;
 }
diff --git a/util/folder/dirut.cpp b/util/folder/dirut.cpp
index 9f7f0ca8c3..ffc9b09f96 100644
--- a/util/folder/dirut.cpp
+++ b/util/folder/dirut.cpp
@@ -423,32 +423,32 @@ TString RealLocation(const TString& path) {
     ythrow TFileError() << "RealLocation failed \"" << path << "\"";
 }
 
-int MakeTempDir(char path[/*FILENAME_MAX*/], const char* prefix) { 
-    int ret; 
+int MakeTempDir(char path[/*FILENAME_MAX*/], const char* prefix) {
+    int ret;
 
     TString sysTmp;
 
-#ifdef _win32_ 
+#ifdef _win32_
     if (!prefix || *prefix == '/') {
-#else 
+#else
     if (!prefix) {
-#endif 
+#endif
         sysTmp = GetSystemTempDir();
         prefix = sysTmp.data();
     }
 
     if ((ret = ResolvePath(prefix, nullptr, path, 1)) != 0)
-        return ret; 
+        return ret;
     if (!TFileStat(path).IsDir())
         return ENOENT;
-    if ((strlcat(path, "tmpXXXXXX", FILENAME_MAX) > FILENAME_MAX - 100)) 
-        return EINVAL; 
-    if (!(mkdtemp(path))) 
-        return errno ? errno : EINVAL; 
-    strcat(path, LOCSLASH_S); 
-    return 0; 
-} 
- 
+    if ((strlcat(path, "tmpXXXXXX", FILENAME_MAX) > FILENAME_MAX - 100))
+        return EINVAL;
+    if (!(mkdtemp(path)))
+        return errno ? errno : EINVAL;
+    strcat(path, LOCSLASH_S);
+    return 0;
+}
+
 bool IsDir(const TString& path) {
     return TFileStat(path).IsDir();
 }
@@ -541,72 +541,72 @@ TString GetDirName(const TString& path) {
 
 #ifdef _win32_
 
-char* realpath(const char* pathname, char resolved_path[MAXPATHLEN]) { 
-    // partial implementation: no path existence check 
-    return _fullpath(resolved_path, pathname, MAXPATHLEN - 1); 
-} 
- 
-#endif 
- 
+char* realpath(const char* pathname, char resolved_path[MAXPATHLEN]) {
+    // partial implementation: no path existence check
+    return _fullpath(resolved_path, pathname, MAXPATHLEN - 1);
+}
+
+#endif
+
 TString GetBaseName(const TString& path) {
     return TFsPath(path).Basename();
-} 
- 
+}
+
 static bool IsAbsolutePath(const char* str) {
     return str && TPathSplitTraitsLocal::IsAbsolutePath(TStringBuf(str, NStringPrivate::GetStringLengthWithLimit(str, 3)));
 }
 
-int ResolvePath(const char* rel, const char* abs, char res[/*MAXPATHLEN*/], bool isdir) { 
+int ResolvePath(const char* rel, const char* abs, char res[/*MAXPATHLEN*/], bool isdir) {
     char t[MAXPATHLEN * 2 + 3];
-    size_t len; 
+    size_t len;
 
-    *res = 0; 
-    if (!rel || !*rel) 
-        return EINVAL; 
+    *res = 0;
+    if (!rel || !*rel)
+        return EINVAL;
     if (!IsAbsolutePath(rel) && IsAbsolutePath(abs)) {
-        len = strlcpy(t, abs, sizeof(t)); 
+        len = strlcpy(t, abs, sizeof(t));
         if (len >= sizeof(t) - 3)
-            return EINVAL; 
+            return EINVAL;
         if (t[len - 1] != LOCSLASH_C)
-            t[len++] = LOCSLASH_C; 
+            t[len++] = LOCSLASH_C;
         len += strlcpy(t + len, rel, sizeof(t) - len);
-    } else { 
-        len = strlcpy(t, rel, sizeof(t)); 
-    } 
+    } else {
+        len = strlcpy(t, rel, sizeof(t));
+    }
     if (len >= sizeof(t) - 3)
-        return EINVAL; 
+        return EINVAL;
     if (isdir && t[len - 1] != LOCSLASH_C) {
         t[len++] = LOCSLASH_C;
         t[len] = 0;
-    } 
-    if (!realpath(t, res)) { 
+    }
+    if (!realpath(t, res)) {
         if (!isdir && realpath(GetDirName(t).data(), res)) {
             len = strlen(res);
             if (res[len - 1] != LOCSLASH_C) {
                 res[len++] = LOCSLASH_C;
                 res[len] = 0;
-            } 
+            }
             strcpy(res + len, GetBaseName(t).data());
             return 0;
-        } 
-        return errno ? errno : ENOENT; 
-    } 
-    if (isdir) { 
-        len = strlen(res); 
+        }
+        return errno ? errno : ENOENT;
+    }
+    if (isdir) {
+        len = strlen(res);
         if (res[len - 1] != LOCSLASH_C) {
             res[len++] = LOCSLASH_C;
-            res[len] = 0; 
-        } 
-    } 
-    return 0; 
-} 
- 
+            res[len] = 0;
+        }
+    }
+    return 0;
+}
+
 TString ResolvePath(const char* rel, const char* abs, bool isdir) {
-    char buf[PATH_MAX]; 
+    char buf[PATH_MAX];
     if (ResolvePath(rel, abs, buf, isdir))
         ythrow yexception() << "cannot resolve path: \"" << rel << "\"";
-    return buf; 
-} 
+    return buf;
+}
 
 TString ResolvePath(const char* path, bool isDir) {
     return ResolvePath(path, nullptr, isDir);
diff --git a/util/folder/dirut.h b/util/folder/dirut.h
index d153a5cc90..2537027b12 100644
--- a/util/folder/dirut.h
+++ b/util/folder/dirut.h
@@ -73,14 +73,14 @@ TString RealLocation(const TString& path); /// throws; last file name component
 
 TString GetSystemTempDir();
 
-int MakeTempDir(char path[/*FILENAME_MAX*/], const char* prefix); 
- 
-int ResolvePath(const char* rel, const char* abs, char res[/*FILENAME_MAX*/], bool isdir = false); 
+int MakeTempDir(char path[/*FILENAME_MAX*/], const char* prefix);
+
+int ResolvePath(const char* rel, const char* abs, char res[/*FILENAME_MAX*/], bool isdir = false);
 TString ResolvePath(const char* rel, const char* abs, bool isdir = false);
 TString ResolvePath(const char* path, bool isDir = false);
- 
+
 TString ResolveDir(const char* path);
- 
+
 bool SafeResolveDir(const char* path, TString& result);
 
 TString GetDirName(const TString& path);
diff --git a/util/generic/strbase.h b/util/generic/strbase.h
index 0af08e21a3..ab39fc7537 100644
--- a/util/generic/strbase.h
+++ b/util/generic/strbase.h
@@ -39,7 +39,7 @@ class TStringBase {
     using TStringView = std::basic_string_view<TCharType>;
     using TStringViewWithTraits = std::basic_string_view<TCharType, TTraitsType>;
 
-public: 
+public:
     using TChar = TCharType;
     using TTraits = TTraitsType;
     using TSelf = TStringBase<TDerived, TChar, TTraits>;
@@ -47,7 +47,7 @@ public:
     using size_type = size_t;
     using difference_type = ptrdiff_t;
     static constexpr size_t npos = size_t(-1);
- 
+
     using const_iterator = const TCharType*;
     using const_reference = const TCharType&;
 
@@ -111,7 +111,7 @@ public:
             return TTraits::length(s);
         }
         return 0;
-    } 
+    }
 
     template <class TCharTraits>
     inline constexpr operator std::basic_string_view<TCharType, TCharTraits>() const {
@@ -121,27 +121,27 @@ public:
     template <class TCharTraits, class Allocator>
     inline explicit operator std::basic_string<TCharType, TCharTraits, Allocator>() const {
         return std::basic_string<TCharType, TCharTraits, Allocator>(Ptr(), Len());
-    } 
+    }
 
     /**
      * @param                           Pointer to character inside the string, or nullptr.
      * @return                          Offset from string beginning (in chars), or npos on nullptr.
      */
     inline size_t off(const TCharType* ret) const noexcept {
-        return ret ? (size_t)(ret - Ptr()) : npos; 
-    } 
+        return ret ? (size_t)(ret - Ptr()) : npos;
+    }
 
     inline size_t IterOff(const_iterator it) const noexcept {
         return begin() <= it && end() > it ? size_t(it - begin()) : npos;
     }
 
     inline const_iterator begin() const noexcept {
-        return Ptr(); 
-    } 
+        return Ptr();
+    }
 
     inline const_iterator end() const noexcept {
-        return Ptr() + size(); 
-    } 
+        return Ptr() + size();
+    }
 
     inline const_iterator cbegin() const noexcept {
         return begin();
@@ -169,8 +169,8 @@ public:
 
     inline TCharType back() const noexcept {
         Y_ASSERT(!this->empty());
-        return Ptr()[Len() - 1]; 
-    } 
+        return Ptr()[Len() - 1];
+    }
 
     inline TCharType front() const noexcept {
         Y_ASSERT(!empty());
@@ -182,20 +182,20 @@ public:
     }
 
     constexpr inline size_t size() const noexcept {
-        return Len(); 
-    } 
+        return Len();
+    }
 
     constexpr inline bool is_null() const noexcept {
-        return *Ptr() == 0; 
-    } 
+        return *Ptr() == 0;
+    }
 
     Y_PURE_FUNCTION constexpr inline bool empty() const noexcept {
-        return Len() == 0; 
-    } 
+        return Len() == 0;
+    }
 
     constexpr inline explicit operator bool() const noexcept {
         return !empty();
-    } 
+    }
 
 public: // style-guide compliant methods
     constexpr const TCharType* Data() const noexcept {
@@ -217,37 +217,37 @@ private:
     }
 
 public:
-    // ~~~ Comparison ~~~ : FAMILY0(int, compare) 
+    // ~~~ Comparison ~~~ : FAMILY0(int, compare)
     static int compare(const TSelf& s1, const TSelf& s2) noexcept {
         return s1.AsStringView().compare(s2.AsStringView());
-    } 
+    }
 
     static int compare(const TCharType* p, const TSelf& s2) noexcept {
         TCharType null{0};
         return TStringViewWithTraits(p ? p : &null).compare(s2.AsStringView());
-    } 
+    }
 
     static int compare(const TSelf& s1, const TCharType* p) noexcept {
         TCharType null{0};
         return s1.AsStringView().compare(p ? p : &null);
-    } 
+    }
 
     static int compare(const TStringView s1, const TStringView s2) noexcept {
         return TStringViewWithTraits(s1.data(), s1.size()).compare(TStringViewWithTraits(s2.data(), s2.size()));
-    } 
+    }
 
-    template <class T> 
+    template <class T>
     inline int compare(const T& t) const noexcept {
-        return compare(*this, t); 
-    } 
+        return compare(*this, t);
+    }
 
     inline int compare(size_t p, size_t n, const TStringView t) const noexcept {
         return compare(LegacySubString(*this, p, n), t);
-    } 
+    }
 
     inline int compare(size_t p, size_t n, const TStringView t, size_t p1, size_t n1) const noexcept {
         return compare(LegacySubString(*this, p, n), LegacySubString(t, p1, n1));
-    } 
+    }
 
     inline int compare(size_t p, size_t n, const TStringView t, size_t n1) const noexcept {
         return compare(LegacySubString(*this, p, n), LegacySubString(t, 0, n1));
@@ -277,10 +277,10 @@ public:
         return TStringViewWithTraits{s1.data(), s1.size()} == TStringViewWithTraits{s2.data(), s2.size()};
     }
 
-    template <class T> 
+    template <class T>
     inline bool equal(const T& t) const noexcept {
         return equal(*this, t);
-    } 
+    }
 
     inline bool equal(size_t p, size_t n, const TStringView t) const noexcept {
         return equal(LegacySubString(*this, p, n), t);
@@ -296,19 +296,19 @@ public:
 
     static inline bool StartsWith(const TCharType* what, size_t whatLen, const TCharType* with, size_t withLen) noexcept {
         return withLen <= whatLen && TStringViewWithTraits(what, withLen) == TStringViewWithTraits(with, withLen);
-    } 
+    }
 
     static inline bool EndsWith(const TCharType* what, size_t whatLen, const TCharType* with, size_t withLen) noexcept {
         return withLen <= whatLen && TStringViewWithTraits(what + whatLen - withLen, withLen) == TStringViewWithTraits(with, withLen);
-    } 
+    }
 
     inline bool StartsWith(const TCharType* s, size_t n) const noexcept {
         return StartsWith(Ptr(), Len(), s, n);
-    } 
+    }
 
     inline bool StartsWith(const TStringView s) const noexcept {
         return StartsWith(s.data(), s.length());
-    } 
+    }
 
     inline bool StartsWith(TCharType ch) const noexcept {
         return !empty() && TTraits::eq(*Ptr(), ch);
@@ -316,11 +316,11 @@ public:
 
     inline bool EndsWith(const TCharType* s, size_t n) const noexcept {
         return EndsWith(Ptr(), Len(), s, n);
-    } 
+    }
 
     inline bool EndsWith(const TStringView s) const noexcept {
         return EndsWith(s.data(), s.length());
-    } 
+    }
 
     inline bool EndsWith(TCharType ch) const noexcept {
         return !empty() && TTraits::eq(Ptr()[Len() - 1], ch);
@@ -329,7 +329,7 @@ public:
     template <typename TDerived2, typename TTraits2>
     bool operator==(const TStringBase<TDerived2, TChar, TTraits2>& s2) const noexcept {
         return equal(*this, s2);
-    } 
+    }
 
     bool operator==(TStringView s2) const noexcept {
         return equal(*this, s2);
@@ -337,17 +337,17 @@ public:
 
     bool operator==(const TCharType* pc) const noexcept {
         return equal(*this, pc);
-    } 
+    }
 
 #ifndef __cpp_impl_three_way_comparison
     friend bool operator==(const TCharType* pc, const TSelf& s) noexcept {
         return equal(pc, s);
-    } 
+    }
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator!=(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
         return !(s1 == s2);
-    } 
+    }
 
     friend bool operator!=(const TSelf& s1, TStringView s2) noexcept {
         return !(s1 == s2);
@@ -355,114 +355,114 @@ public:
 
     friend bool operator!=(const TSelf& s, const TCharType* pc) noexcept {
         return !(s == pc);
-    } 
+    }
 
     friend bool operator!=(const TCharType* pc, const TSelf& s) noexcept {
         return !(pc == s);
-    } 
+    }
 #endif
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator<(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
-        return compare(s1, s2) < 0; 
-    } 
+        return compare(s1, s2) < 0;
+    }
 
     friend bool operator<(const TSelf& s1, TStringView s2) noexcept {
         return compare(s1, s2) < 0;
     }
 
     friend bool operator<(const TSelf& s, const TCharType* pc) noexcept {
-        return compare(s, pc) < 0; 
-    } 
+        return compare(s, pc) < 0;
+    }
 
     friend bool operator<(const TCharType* pc, const TSelf& s) noexcept {
-        return compare(pc, s) < 0; 
-    } 
+        return compare(pc, s) < 0;
+    }
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator<=(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
-        return compare(s1, s2) <= 0; 
-    } 
+        return compare(s1, s2) <= 0;
+    }
 
     friend bool operator<=(const TSelf& s1, TStringView s2) noexcept {
         return compare(s1, s2) <= 0;
     }
 
     friend bool operator<=(const TSelf& s, const TCharType* pc) noexcept {
-        return compare(s, pc) <= 0; 
-    } 
+        return compare(s, pc) <= 0;
+    }
 
     friend bool operator<=(const TCharType* pc, const TSelf& s) noexcept {
-        return compare(pc, s) <= 0; 
-    } 
+        return compare(pc, s) <= 0;
+    }
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator>(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
-        return compare(s1, s2) > 0; 
-    } 
+        return compare(s1, s2) > 0;
+    }
 
     friend bool operator>(const TSelf& s1, TStringView s2) noexcept {
         return compare(s1, s2) > 0;
     }
 
     friend bool operator>(const TSelf& s, const TCharType* pc) noexcept {
-        return compare(s, pc) > 0; 
-    } 
+        return compare(s, pc) > 0;
+    }
 
     friend bool operator>(const TCharType* pc, const TSelf& s) noexcept {
-        return compare(pc, s) > 0; 
-    } 
+        return compare(pc, s) > 0;
+    }
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator>=(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
-        return compare(s1, s2) >= 0; 
-    } 
- 
+        return compare(s1, s2) >= 0;
+    }
+
     friend bool operator>=(const TSelf& s1, TStringView s2) noexcept {
         return compare(s1, s2) >= 0;
     }
 
     friend bool operator>=(const TSelf& s, const TCharType* pc) noexcept {
-        return compare(s, pc) >= 0; 
-    } 
- 
+        return compare(s, pc) >= 0;
+    }
+
     friend bool operator>=(const TCharType* pc, const TSelf& s) noexcept {
-        return compare(pc, s) >= 0; 
-    } 
- 
-    // ~~ Read access ~~ 
+        return compare(pc, s) >= 0;
+    }
+
+    // ~~ Read access ~~
     inline TCharType at(size_t pos) const noexcept {
         if (Y_LIKELY(pos < Len())) {
-            return (Ptr())[pos]; 
+            return (Ptr())[pos];
         }
-        return 0; 
-    } 
+        return 0;
+    }
 
     inline TCharType operator[](size_t pos) const noexcept {
         Y_ASSERT(pos < this->size());
 
         return Ptr()[pos];
-    } 
+    }
 
-    //~~~~Search~~~~ 
+    //~~~~Search~~~~
     /**
      * @return                          Position of the substring inside this string, or `npos` if not found.
      */
     inline size_t find(const TStringView s, size_t pos = 0) const noexcept {
         return find(s.data(), pos, s.size());
-    } 
- 
+    }
+
     inline size_t find(const TCharType* s, size_t pos, size_t count) const noexcept {
         return AsStringView().find(s, pos, count);
     }
 
     inline size_t find(TCharType c, size_t pos = 0) const noexcept {
         return AsStringView().find(c, pos);
-    } 
+    }
 
     inline size_t rfind(TCharType c) const noexcept {
         return AsStringView().rfind(c);
-    } 
+    }
 
     inline size_t rfind(TCharType c, size_t pos) const noexcept {
         if (pos == 0) {
@@ -491,11 +491,11 @@ public:
         return find(ui8(c), pos) != npos;
     }
 
-    //~~~~Character Set Search~~~ 
+    //~~~~Character Set Search~~~
     inline size_t find_first_of(TCharType c) const noexcept {
         return find_first_of(c, 0);
-    } 
- 
+    }
+
     inline size_t find_first_of(TCharType c, size_t pos) const noexcept {
         return find(c, pos);
     }
@@ -506,8 +506,8 @@ public:
 
     inline size_t find_first_of(const TStringView set, size_t pos) const noexcept {
         return AsStringView().find_first_of(set.data(), pos, set.size());
-    } 
- 
+    }
+
     inline size_t find_first_not_of(TCharType c) const noexcept {
         return find_first_not_of(c, 0);
     }
@@ -522,7 +522,7 @@ public:
 
     inline size_t find_first_not_of(const TStringView set, size_t pos) const noexcept {
         return AsStringView().find_first_not_of(set.data(), pos, set.size());
-    } 
+    }
 
     inline size_t find_last_of(TCharType c, size_t pos = npos) const noexcept {
         return find_last_of(&c, pos, 1);
@@ -534,7 +534,7 @@ public:
 
     inline size_t find_last_of(const TCharType* set, size_t pos, size_t n) const noexcept {
         return AsStringView().find_last_of(set, pos, n);
-    } 
+    }
 
     inline size_t find_last_not_of(TCharType c, size_t pos = npos) const noexcept {
         return AsStringView().find_last_not_of(c, pos);
@@ -548,37 +548,37 @@ public:
         return AsStringView().find_last_not_of(set, pos, n);
     }
 
-    inline size_t copy(TCharType* pc, size_t n, size_t pos) const { 
+    inline size_t copy(TCharType* pc, size_t n, size_t pos) const {
         if (pos > Len()) {
             throw std::out_of_range("TStringBase::copy");
         }
 
-        return CopyImpl(pc, n, pos); 
-    } 
+        return CopyImpl(pc, n, pos);
+    }
 
     inline size_t copy(TCharType* pc, size_t n) const noexcept {
         return CopyImpl(pc, n, 0);
-    } 
+    }
 
     inline size_t strcpy(TCharType* pc, size_t n) const noexcept {
-        if (n) { 
+        if (n) {
             n = copy(pc, n - 1);
             pc[n] = 0;
         }
 
         return n;
-    } 
+    }
 
     inline TDerived copy() const Y_WARN_UNUSED_RESULT {
-        return TDerived(Ptr(), Len()); 
-    } 
+        return TDerived(Ptr(), Len());
+    }
 
     // ~~~ Partial copy ~~~~
     TDerived substr(size_t pos, size_t n = npos) const Y_WARN_UNUSED_RESULT {
         return TDerived(*This(), pos, n);
     }
 
-private: 
+private:
     using GenericFinder = const TCharType* (*)(const TCharType*, size_t, const TCharType*, size_t);
 
     TStringViewWithTraits AsStringView() const {
@@ -586,22 +586,22 @@ private:
     }
 
     constexpr inline const TCharType* Ptr() const noexcept {
-        return This()->data(); 
-    } 
+        return This()->data();
+    }
 
     constexpr inline size_t Len() const noexcept {
-        return This()->length(); 
-    } 
- 
+        return This()->length();
+    }
+
     constexpr inline const TDerived* This() const noexcept {
-        return static_cast<const TDerived*>(this); 
-    } 
- 
+        return static_cast<const TDerived*>(this);
+    }
+
     inline size_t CopyImpl(TCharType* pc, size_t n, size_t pos) const noexcept {
-        const size_t toCopy = Min(Len() - pos, n); 
+        const size_t toCopy = Min(Len() - pos, n);
 
         TTraits::copy(pc, Ptr() + pos, toCopy);
 
-        return toCopy; 
-    } 
+        return toCopy;
+    }
 };
diff --git a/util/generic/string.cpp b/util/generic/string.cpp
index 07e7053cfc..3c655f1f66 100644
--- a/util/generic/string.cpp
+++ b/util/generic/string.cpp
@@ -4,12 +4,12 @@
 #include <util/system/sanitizers.h>
 #include <util/system/sys_alloc.h>
 #include <util/charset/wide.h>
- 
+
 #include <iostream>
 #include <cctype>
 
 alignas(32) const char NULL_STRING_REPR[128] = {0};
- 
+
 std::ostream& operator<<(std::ostream& os, const TString& s) {
     return os.write(s.data(), s.size());
 }
diff --git a/util/generic/string.h b/util/generic/string.h
index 04c9c08132..8cd8aa6917 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -8,7 +8,7 @@
 #include <string_view>
 
 #include <util/system/yassert.h>
-#include <util/system/atomic.h> 
+#include <util/system/atomic.h>
 
 #include "ptr.h"
 #include "utility.h"
@@ -61,11 +61,11 @@ public:
 };
 
 alignas(32) extern const char NULL_STRING_REPR[128];
- 
+
 struct TRefCountHolder {
     TAtomicCounter C = 1;
 };
- 
+
 template <class B>
 struct TStdString: public TRefCountHolder, public B {
     template <typename... Args>
@@ -73,7 +73,7 @@ struct TStdString: public TRefCountHolder, public B {
         : B(std::forward<Args>(args)...)
     {
     }
- 
+
     inline bool IsNull() const noexcept {
         return this == NullStr();
     }
@@ -97,12 +97,12 @@ private:
             delete this;
         }
     }
- 
+
     inline long RefCount() const noexcept {
         return C.Val();
     }
 };
- 
+
 template <class TStringType>
 class TBasicCharRef {
 public:
@@ -157,7 +157,7 @@ private:
 
 template <typename TCharType, typename TTraits>
 class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharType, TTraits> {
-public: 
+public:
     // TODO: Move to private section
     using TBase = TStringBase<TBasicString, TCharType, TTraits>;
     using TStringType = std::basic_string<TCharType, TTraits>;
@@ -172,13 +172,13 @@ public:
     using char_type = TCharType; // TODO: DROP
     using value_type = TCharType;
     using traits_type = TTraits;
- 
+
     using iterator = TCharType*;
     using reverse_iterator = typename TBase::template TReverseIteratorBase<iterator>;
     using typename TBase::const_iterator;
     using typename TBase::const_reference;
     using typename TBase::const_reverse_iterator;
- 
+
     struct TUninitialized {
         explicit TUninitialized(size_t size)
             : Size(size)
@@ -194,12 +194,12 @@ public:
         return res;
     }
 
-protected: 
+protected:
 #ifdef TSTRING_IS_STD_STRING
     TStorage Storage_;
 #else
     TStorage S_;
- 
+
     template <typename... A>
     static TStorage Construct(A&&... a) {
         return {new TStdStr(std::forward<A>(a)...), typename TStorage::TNoIncrement()};
@@ -222,7 +222,7 @@ protected:
      *
      * @throw std::length_error
      */
-    void Clone() { 
+    void Clone() {
         Construct(StdStr()).Swap(S_);
     }
 
@@ -331,7 +331,7 @@ public:
     using TBase::end;     //!< const_iterator TStringBase::end() const
     using TBase::rbegin;  //!< const_reverse_iterator TStringBase::rbegin() const
     using TBase::rend;    //!< const_reverse_iterator TStringBase::rend() const
- 
+
     inline size_t capacity() const noexcept {
 #ifdef TSTRING_IS_STD_STRING
         return Storage_.capacity();
@@ -369,7 +369,7 @@ public:
         MutRef().resize(n, c);
 
         return *this;
-    } 
+    }
 
     // ~~~ Constructor ~~~ : FAMILY0(,TBasicString)
     TBasicString() noexcept
@@ -409,7 +409,7 @@ public:
 #endif
     }
 
-    template <typename T, typename A> 
+    template <typename T, typename A>
     explicit inline TBasicString(const std::basic_string<TCharType, T, A>& s)
         : TBasicString(s.data(), s.size())
     {
@@ -432,12 +432,12 @@ public:
         : S_(n ? Construct(s, pos, n) : Construct())
 #endif
     {
-    } 
+    }
 
     TBasicString(const TCharType* pc)
         : TBasicString(pc, TBase::StrLen(pc))
     {
-    } 
+    }
     // TODO thegeorg@: uncomment and fix clients
     // TBasicString(std::nullptr_t) = delete;
 
@@ -448,14 +448,14 @@ public:
         : S_(n ? Construct(pc, n) : Construct())
 #endif
     {
-    } 
+    }
     TBasicString(std::nullptr_t, size_t) = delete;
- 
+
     TBasicString(const TCharType* pc, size_t pos, size_t n)
         : TBasicString(pc + pos, n)
     {
-    } 
- 
+    }
+
 #ifdef TSTRING_IS_STD_STRING
     explicit TBasicString(TExplicitType<TCharType> c) {
         Storage_.push_back(c);
@@ -464,7 +464,7 @@ public:
     explicit TBasicString(TExplicitType<TCharType> c)
         : TBasicString(&c.Value(), 1)
     {
-    } 
+    }
     explicit TBasicString(const reference& c)
         : TBasicString(&c, 1)
     {
@@ -478,8 +478,8 @@ public:
         : S_(Construct(n, c))
 #endif
     {
-    } 
- 
+    }
+
     /**
      * Constructs an uninitialized string of size `uninitialized.Size`. The proper
      * way to use this ctor is via `TBasicString::Uninitialized` factory function.
@@ -491,13 +491,13 @@ public:
         S_ = Construct();
 #endif
         ReserveAndResize(uninitialized.Size);
-    } 
- 
+    }
+
     TBasicString(const TCharType* b, const TCharType* e)
         : TBasicString(b, e - b)
     {
-    } 
- 
+    }
+
     explicit TBasicString(const TBasicStringBuf<TCharType, TTraits> s)
         : TBasicString(s.data(), s.size())
     {
@@ -534,7 +534,7 @@ private:
     template <typename... R>
     static size_t SumLength(const TBasicStringBuf<TCharType, TTraits> s1, const R&... r) noexcept {
         return s1.size() + SumLength(r...);
-    } 
+    }
 
     template <typename... R>
     static size_t SumLength(const TCharType /*s1*/, const R&... r) noexcept {
@@ -543,8 +543,8 @@ private:
 
     static constexpr size_t SumLength() noexcept {
         return 0;
-    } 
- 
+    }
+
     template <typename... R>
     static void CopyAll(TCharType* p, const TBasicStringBuf<TCharType, TTraits> s, const R&... r) {
         TTraits::copy(p, s.data(), s.size());
@@ -800,7 +800,7 @@ public:
 
     TBasicString& AppendUtf16(const ::TWtringBuf& s);
 
-    inline void push_back(TCharType c) { 
+    inline void push_back(TCharType c) {
         // TODO
         append(c);
     }
@@ -1047,11 +1047,11 @@ public:
     TBasicString& remove(size_t pos = 0) Y_NOEXCEPT {
         if (pos < length()) {
             MutRef().erase(pos);
-        } 
+        }
 
         return *this;
-    } 
- 
+    }
+
     TBasicString& erase(size_t pos = 0, size_t n = TBase::npos) Y_NOEXCEPT {
         MutRef().erase(pos, n);
 
@@ -1109,8 +1109,8 @@ public:
         MutRef().replace(pos, n1, n2, c);
 
         return *this;
-    } 
- 
+    }
+
     TBasicString& replace(size_t pos, size_t n, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_NOEXCEPT {
         MutRef().replace(pos, n, s, spos, sn);
 
@@ -1123,8 +1123,8 @@ public:
 #else
         S_.Swap(s.S_);
 #endif
-    } 
- 
+    }
+
     /**
      * @returns                         String suitable for debug printing (like Python's `repr()`).
      *                                  Format of the string is unspecified and may be changed over time.
@@ -1189,8 +1189,8 @@ public:
 
         return changed;
     }
-}; 
- 
+};
+
 std::ostream& operator<<(std::ostream&, const TString&);
 std::istream& operator>>(std::istream&, TString&);
 
diff --git a/util/generic/string_ut.cpp b/util/generic/string_ut.cpp
index 8fc87cc0a1..ac82e9091d 100644
--- a/util/generic/string_ut.cpp
+++ b/util/generic/string_ut.cpp
@@ -21,13 +21,13 @@ static_assert(sizeof(TString) == sizeof(const char*), "expect sizeof(TString) ==
 #endif
 
 class TStringTestZero: public TTestBase {
-    UNIT_TEST_SUITE(TStringTestZero); 
+    UNIT_TEST_SUITE(TStringTestZero);
     UNIT_TEST(TestZero);
     UNIT_TEST_SUITE_END();
 
 public:
     void TestZero() {
-        const char data[] = "abc\0def\0"; 
+        const char data[] = "abc\0def\0";
         TString s(data, sizeof(data));
         UNIT_ASSERT(s.size() == sizeof(data));
         UNIT_ASSERT(s.StartsWith(s));
@@ -49,60 +49,60 @@ public:
 
         TString copy = s;
         copy.replace(copy.size() - 1, 1, "z");
-        UNIT_ASSERT(s != copy); 
+        UNIT_ASSERT(s != copy);
         copy.replace(copy.size() - 1, 1, "\0", 0, 1);
-        UNIT_ASSERT(s == copy); 
+        UNIT_ASSERT(s == copy);
 
         TString prefix(data, 5);
         UNIT_ASSERT(s.StartsWith(prefix));
-        UNIT_ASSERT(s != prefix); 
-        UNIT_ASSERT(s > prefix); 
+        UNIT_ASSERT(s != prefix);
+        UNIT_ASSERT(s > prefix);
         UNIT_ASSERT(s > s.data());
         UNIT_ASSERT(s == TString(s.data(), s.size()));
-        UNIT_ASSERT(data < s); 
-
-        s.remove(5); 
-        UNIT_ASSERT(s == prefix); 
-    } 
-}; 
- 
-UNIT_TEST_SUITE_REGISTRATION(TStringTestZero); 
- 
+        UNIT_ASSERT(data < s);
+
+        s.remove(5);
+        UNIT_ASSERT(s == prefix);
+    }
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TStringTestZero);
+
 template <typename TStringType, typename TTestData>
-class TStringStdTestImpl { 
+class TStringStdTestImpl {
     using TChar = typename TStringType::char_type;
     using TTraits = typename TStringType::traits_type;
     using TView = std::basic_string_view<TChar, TTraits>;
- 
+
     TTestData Data_;
- 
-protected: 
+
+protected:
     void Constructor() {
-        // @todo use UNIT_TEST_EXCEPTION 
-        try { 
+        // @todo use UNIT_TEST_EXCEPTION
+        try {
             TStringType s((size_t)-1, *Data_.a());
-            UNIT_ASSERT(false); 
-        } catch (const std::length_error&) { 
-            UNIT_ASSERT(true); 
-        } catch (...) { 
-            //Expected exception is length_error: 
-            UNIT_ASSERT(false); 
-        } 
+            UNIT_ASSERT(false);
+        } catch (const std::length_error&) {
+            UNIT_ASSERT(true);
+        } catch (...) {
+            //Expected exception is length_error:
+            UNIT_ASSERT(false);
+        }
     }
 
-    void reserve() { 
+    void reserve() {
 #if 0
         TStringType s;
-        // @todo use UNIT_TEST_EXCEPTION 
-        try { 
-            s.reserve(s.max_size() + 1); 
-            UNIT_ASSERT(false); 
-        } catch (const std::length_error&) { 
-            UNIT_ASSERT(true); 
-        } catch (...) { 
-            //Expected exception is length_error: 
-            UNIT_ASSERT(false); 
-        } 
+        // @todo use UNIT_TEST_EXCEPTION
+        try {
+            s.reserve(s.max_size() + 1);
+            UNIT_ASSERT(false);
+        } catch (const std::length_error&) {
+            UNIT_ASSERT(true);
+        } catch (...) {
+            //Expected exception is length_error:
+            UNIT_ASSERT(false);
+        }
 
         // Non-shared behaviour - never shrink
 
@@ -150,149 +150,149 @@ protected:
 #endif
     }
 
-    void short_string() { 
+    void short_string() {
         TStringType const ref_short_str1(Data_.str1()), ref_short_str2(Data_.str2());
         TStringType short_str1(ref_short_str1), short_str2(ref_short_str2);
         TStringType const ref_long_str1(Data_.str__________________________________________________1());
         TStringType const ref_long_str2(Data_.str__________________________________________________2());
         TStringType long_str1(ref_long_str1), long_str2(ref_long_str2);
 
-        UNIT_ASSERT(short_str1 == ref_short_str1); 
-        UNIT_ASSERT(long_str1 == ref_long_str1); 
+        UNIT_ASSERT(short_str1 == ref_short_str1);
+        UNIT_ASSERT(long_str1 == ref_long_str1);
 
-        { 
+        {
             TStringType str1(short_str1);
-            str1 = long_str1; 
-            UNIT_ASSERT(str1 == ref_long_str1); 
-        } 
+            str1 = long_str1;
+            UNIT_ASSERT(str1 == ref_long_str1);
+        }
 
-        { 
+        {
             TStringType str1(long_str1);
-            str1 = short_str1; 
-            UNIT_ASSERT(str1 == ref_short_str1); 
-        } 
-
-        { 
-            short_str1.swap(short_str2); 
-            UNIT_ASSERT((short_str1 == ref_short_str2) && (short_str2 == ref_short_str1)); 
-            short_str1.swap(short_str2); 
-        } 
-
-        { 
-            long_str1.swap(long_str2); 
-            UNIT_ASSERT((long_str1 == ref_long_str2) && (long_str2 == ref_long_str1)); 
-            long_str1.swap(long_str2); 
-        } 
-
-        { 
-            short_str1.swap(long_str1); 
-            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1)); 
-            short_str1.swap(long_str1); 
-        } 
-
-        { 
-            long_str1.swap(short_str1); 
-            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1)); 
-            long_str1.swap(short_str1); 
-        } 
-
-        { 
-            //This is to test move constructor 
+            str1 = short_str1;
+            UNIT_ASSERT(str1 == ref_short_str1);
+        }
+
+        {
+            short_str1.swap(short_str2);
+            UNIT_ASSERT((short_str1 == ref_short_str2) && (short_str2 == ref_short_str1));
+            short_str1.swap(short_str2);
+        }
+
+        {
+            long_str1.swap(long_str2);
+            UNIT_ASSERT((long_str1 == ref_long_str2) && (long_str2 == ref_long_str1));
+            long_str1.swap(long_str2);
+        }
+
+        {
+            short_str1.swap(long_str1);
+            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
+            short_str1.swap(long_str1);
+        }
+
+        {
+            long_str1.swap(short_str1);
+            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
+            long_str1.swap(short_str1);
+        }
+
+        {
+            //This is to test move constructor
             TVector<TStringType> str_vect;
 
-            str_vect.push_back(short_str1); 
-            str_vect.push_back(long_str1); 
-            str_vect.push_back(short_str2); 
-            str_vect.push_back(long_str2); 
+            str_vect.push_back(short_str1);
+            str_vect.push_back(long_str1);
+            str_vect.push_back(short_str2);
+            str_vect.push_back(long_str2);
 
             UNIT_ASSERT(str_vect[0] == ref_short_str1);
             UNIT_ASSERT(str_vect[1] == ref_long_str1);
             UNIT_ASSERT(str_vect[2] == ref_short_str2);
             UNIT_ASSERT(str_vect[3] == ref_long_str2);
-        } 
+        }
     }
 
-    void erase() { 
+    void erase() {
         TChar const* c_str = Data_.Hello_World();
         TStringType str(c_str);
-        UNIT_ASSERT(str == c_str); 
+        UNIT_ASSERT(str == c_str);
 
-        str.erase(str.begin() + 1, str.end() - 1); // Erase all but first and last. 
+        str.erase(str.begin() + 1, str.end() - 1); // Erase all but first and last.
 
-        size_t i; 
-        for (i = 0; i < str.size(); ++i) { 
-            switch (i) { 
-                case 0: 
+        size_t i;
+        for (i = 0; i < str.size(); ++i) {
+            switch (i) {
+                case 0:
                     UNIT_ASSERT(str[i] == *Data_.H());
-                    break; 
+                    break;
 
-                case 1: 
+                case 1:
                     UNIT_ASSERT(str[i] == *Data_.d());
-                    break; 
+                    break;
 
-                default: 
-                    UNIT_ASSERT(false); 
-            } 
+                default:
+                    UNIT_ASSERT(false);
+            }
         }
 
-        str.insert(1, c_str); 
+        str.insert(1, c_str);
         str.erase(str.begin());   // Erase first element.
-        str.erase(str.end() - 1); // Erase last element. 
-        UNIT_ASSERT(str == c_str); 
-        str.clear(); // Erase all. 
-        UNIT_ASSERT(str.empty()); 
-
-        str = c_str; 
-        UNIT_ASSERT(str == c_str); 
-
-        str.erase(1, str.size() - 1); // Erase all but first and last. 
-        for (i = 0; i < str.size(); i++) { 
-            switch (i) { 
-                case 0: 
+        str.erase(str.end() - 1); // Erase last element.
+        UNIT_ASSERT(str == c_str);
+        str.clear(); // Erase all.
+        UNIT_ASSERT(str.empty());
+
+        str = c_str;
+        UNIT_ASSERT(str == c_str);
+
+        str.erase(1, str.size() - 1); // Erase all but first and last.
+        for (i = 0; i < str.size(); i++) {
+            switch (i) {
+                case 0:
                     UNIT_ASSERT(str[i] == *Data_.H());
-                    break; 
+                    break;
 
-                case 1: 
+                case 1:
                     UNIT_ASSERT(str[i] == *Data_.d());
-                    break; 
+                    break;
 
-                default: 
-                    UNIT_ASSERT(false); 
-            } 
+                default:
+                    UNIT_ASSERT(false);
+            }
         }
- 
-        str.erase(1); 
+
+        str.erase(1);
         UNIT_ASSERT(str == Data_.H());
     }
 
-    void data() { 
+    void data() {
         TStringType xx;
 
-        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 3 
+        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 3
         UNIT_ASSERT(xx.data() != nullptr);
-    } 
+    }
 
-    void c_str() { 
+    void c_str() {
         TStringType low(Data_._2004_01_01());
         TStringType xx;
         TStringType yy;
 
-        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 1 
-        UNIT_ASSERT(*(yy.c_str()) == 0); 
+        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 1
+        UNIT_ASSERT(*(yy.c_str()) == 0);
 
-        // Blocks A and B should follow each other. 
-        // Block A: 
+        // Blocks A and B should follow each other.
+        // Block A:
         xx = Data_._123456();
-        xx += low; 
+        xx += low;
         UNIT_ASSERT(xx.c_str() == TView(Data_._1234562004_01_01()));
-        // End of block A 
+        // End of block A
 
-        // Block B: 
+        // Block B:
         xx = Data_._1234();
         xx += Data_._5();
         UNIT_ASSERT(xx.c_str() == TView(Data_._12345()));
-        // End of block B 
-    } 
+        // End of block B
+    }
 
     void null_char_of_empty() {
         const TStringType s;
@@ -300,8 +300,8 @@ protected:
         UNIT_ASSERT(s[s.size()] == 0);
     }
 
-    void null_char() { 
-        // ISO/IEC 14882:1998(E), ISO/IEC 14882:2003(E), 21.3.4 ('... the const version') 
+    void null_char() {
+        // ISO/IEC 14882:1998(E), ISO/IEC 14882:2003(E), 21.3.4 ('... the const version')
         const TStringType s(Data_._123456());
 
         UNIT_ASSERT(s[s.size()] == 0);
@@ -315,11 +315,11 @@ protected:
         using reference = volatile typename TStringType::value_type&;
 #else
         using reference = typename TStringType::reference;
-#endif 
+#endif
         reference trailing_zero = s[s.size()];
         trailing_zero = 0;
         UNIT_ASSERT(trailing_zero == 0);
-    } 
+    }
 
     // Allowed since C++17, see http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2475
     void null_char_assignment_to_subscript_of_nonempty() {
@@ -355,45 +355,45 @@ protected:
     }
 #endif
 
-    void insert() { 
+    void insert() {
         TStringType strorg = Data_.This_is_test_string_for_string_calls();
         TStringType str;
 
-        // In case of reallocation there is no auto reference problem 
+        // In case of reallocation there is no auto reference problem
         // so we reserve a big enough TStringType to be sure to test this
-        // particular point. 
+        // particular point.
 
-        str.reserve(100); 
-        str = strorg; 
+        str.reserve(100);
+        str = strorg;
 
-        //test self insertion: 
-        str.insert(10, str.c_str() + 5, 15); 
+        //test self insertion:
+        str.insert(10, str.c_str() + 5, 15);
         UNIT_ASSERT(str == Data_.This_is_teis_test_string_st_string_for_string_calls());
 
-        str = strorg; 
-        str.insert(15, str.c_str() + 5, 25); 
+        str = strorg;
+        str.insert(15, str.c_str() + 5, 25);
         UNIT_ASSERT(str == Data_.This_is_test_stis_test_string_for_stringring_for_string_calls());
 
-        str = strorg; 
-        str.insert(0, str.c_str() + str.size() - 4, 4); 
+        str = strorg;
+        str.insert(0, str.c_str() + str.size() - 4, 4);
         UNIT_ASSERT(str == Data_.allsThis_is_test_string_for_string_calls());
 
-        str = strorg; 
-        str.insert(0, str.c_str() + str.size() / 2 - 1, str.size() / 2 + 1); 
+        str = strorg;
+        str.insert(0, str.c_str() + str.size() / 2 - 1, str.size() / 2 + 1);
         UNIT_ASSERT(str == Data_.ng_for_string_callsThis_is_test_string_for_string_calls());
 
-        str = strorg; 
+        str = strorg;
         typename TStringType::iterator b = str.begin();
         typename TStringType::const_iterator s = str.begin() + str.size() / 2 - 1;
         typename TStringType::const_iterator e = str.end();
-        str.insert(b, s, e); 
+        str.insert(b, s, e);
         UNIT_ASSERT(str == Data_.ng_for_string_callsThis_is_test_string_for_string_calls());
 
 #if 0
-        // AV 
-        str = strorg; 
-        str.insert(str.begin(), str.begin() + str.size() / 2 - 1, str.end()); 
-        UNIT_ASSERT(str == Data.ng_for_string_callsThis_is_test_string_for_string_calls()); 
+        // AV
+        str = strorg;
+        str.insert(str.begin(), str.begin() + str.size() / 2 - 1, str.end());
+        UNIT_ASSERT(str == Data.ng_for_string_callsThis_is_test_string_for_string_calls());
 #endif
 
         TStringType str0;
@@ -401,17 +401,17 @@ protected:
         UNIT_ASSERT(str0 == Data_._00000());
 
         TStringType str1;
-        { 
+        {
             typename TStringType::size_type pos = 0, nb = 2;
             str1.insert(pos, nb, *Data_._1());
-        } 
+        }
         UNIT_ASSERT(str1 == Data_._11());
 
-        str0.insert(0, str1); 
+        str0.insert(0, str1);
         UNIT_ASSERT(str0 == Data_._1100000());
 
         TStringType str2(Data_._2345());
-        str0.insert(str0.size(), str2, 1, 2); 
+        str0.insert(str0.size(), str2, 1, 2);
         UNIT_ASSERT(str0 == Data_._110000034());
 
         str1.insert(str1.begin() + 1, 2, *Data_._2());
@@ -425,40 +425,40 @@ protected:
 
         str1.insert(str1.begin() + 6, *Data_._5());
         UNIT_ASSERT(str1 == Data_._123344544321());
-    } 
+    }
 
-    void resize() { 
+    void resize() {
         TStringType s;
 
-        s.resize(0); 
+        s.resize(0);
 
-        UNIT_ASSERT(*s.c_str() == 0); 
+        UNIT_ASSERT(*s.c_str() == 0);
 
         s = Data_._1234567();
 
-        s.resize(0); 
-        UNIT_ASSERT(*s.c_str() == 0); 
+        s.resize(0);
+        UNIT_ASSERT(*s.c_str() == 0);
 
         s = Data_._1234567();
-        s.resize(1); 
-        UNIT_ASSERT(s.size() == 1); 
+        s.resize(1);
+        UNIT_ASSERT(s.size() == 1);
         UNIT_ASSERT(*s.c_str() == *Data_._1());
-        UNIT_ASSERT(*(s.c_str() + 1) == 0); 
+        UNIT_ASSERT(*(s.c_str() + 1) == 0);
 
         s = Data_._1234567();
 #if 0
-        s.resize(10); 
+        s.resize(10);
 #else
-        s.resize(10, 0); 
+        s.resize(10, 0);
 #endif
-        UNIT_ASSERT(s.size() == 10); 
+        UNIT_ASSERT(s.size() == 10);
         UNIT_ASSERT(s[6] == *Data_._7());
-        UNIT_ASSERT(s[7] == 0); 
-        UNIT_ASSERT(s[8] == 0); 
-        UNIT_ASSERT(s[9] == 0); 
-    } 
+        UNIT_ASSERT(s[7] == 0);
+        UNIT_ASSERT(s[8] == 0);
+        UNIT_ASSERT(s[9] == 0);
+    }
 
-    void find() { 
+    void find() {
         TStringType s(Data_.one_two_three_one_two_three());
 
         UNIT_ASSERT(s.find(Data_.one()) == 0);
@@ -469,33 +469,33 @@ protected:
         UNIT_ASSERT(s.find(Data_.one(), TStringType::npos) == TStringType::npos);
         UNIT_ASSERT(s.find_first_of(Data_.abcde()) == 2);
         UNIT_ASSERT(s.find_first_not_of(Data_.enotw_()) == 9);
-    } 
+    }
 
-    void capacity() { 
+    void capacity() {
         TStringType s;
 
         UNIT_ASSERT(s.capacity() < s.max_size());
         UNIT_ASSERT(s.capacity() >= s.size());
- 
-        for (int i = 0; i < 18; ++i) { 
-            s += ' '; 
- 
+
+        for (int i = 0; i < 18; ++i) {
+            s += ' ';
+
             UNIT_ASSERT(s.capacity() > 0);
             UNIT_ASSERT(s.capacity() < s.max_size());
             UNIT_ASSERT(s.capacity() >= s.size());
-        } 
+        }
     }
 
-    void assign() { 
+    void assign() {
         TStringType s;
         TChar const* cstr = Data_.test_string_for_assign();
 
-        s.assign(cstr, cstr + 22); 
+        s.assign(cstr, cstr + 22);
         UNIT_ASSERT(s == Data_.test_string_for_assign());
 
         TStringType s2(Data_.other_test_string());
-        s.assign(s2); 
-        UNIT_ASSERT(s == s2); 
+        s.assign(s2);
+        UNIT_ASSERT(s == s2);
 
         static TStringType str1;
         static TStringType str2;
@@ -507,34 +507,34 @@ protected:
 
         UNIT_ASSERT(str1[5] == *Data_._6());
         UNIT_ASSERT(str2[29] == *Data_._0());
-    } 
+    }
 
-    void copy() { 
+    void copy() {
         TStringType s(Data_.foo());
         TChar dest[4];
-        dest[0] = dest[1] = dest[2] = dest[3] = 1; 
-        s.copy(dest, 4); 
-        int pos = 0; 
+        dest[0] = dest[1] = dest[2] = dest[3] = 1;
+        s.copy(dest, 4);
+        int pos = 0;
         UNIT_ASSERT(dest[pos++] == *Data_.f());
         UNIT_ASSERT(dest[pos++] == *Data_.o());
         UNIT_ASSERT(dest[pos++] == *Data_.o());
-        UNIT_ASSERT(dest[pos++] == 1); 
+        UNIT_ASSERT(dest[pos++] == 1);
 
-        dest[0] = dest[1] = dest[2] = dest[3] = 1; 
-        s.copy(dest, 4, 2); 
-        pos = 0; 
+        dest[0] = dest[1] = dest[2] = dest[3] = 1;
+        s.copy(dest, 4, 2);
+        pos = 0;
         UNIT_ASSERT(dest[pos++] == *Data_.o());
-        UNIT_ASSERT(dest[pos++] == 1); 
-
-        // @todo use UNIT_TEST_EXCEPTION 
-        try { 
-            s.copy(dest, 4, 5); 
-            UNIT_ASSERT(!"expected std::out_of_range"); 
-        } catch (const std::out_of_range&) { 
-            UNIT_ASSERT(true); 
+        UNIT_ASSERT(dest[pos++] == 1);
+
+        // @todo use UNIT_TEST_EXCEPTION
+        try {
+            s.copy(dest, 4, 5);
+            UNIT_ASSERT(!"expected std::out_of_range");
+        } catch (const std::out_of_range&) {
+            UNIT_ASSERT(true);
         } catch (...) {
-            UNIT_ASSERT(!"expected std::out_of_range"); 
-        } 
+            UNIT_ASSERT(!"expected std::out_of_range");
+        }
     }
 
     void cbegin_cend() {
@@ -546,18 +546,18 @@ protected:
         }
     }
 
-    void compare() { 
+    void compare() {
         TStringType str1(Data_.abcdef());
         TStringType str2;
 
         str2 = Data_.abcdef();
-        UNIT_ASSERT(str1.compare(str2) == 0); 
+        UNIT_ASSERT(str1.compare(str2) == 0);
         UNIT_ASSERT(str1.compare(str2.data(), str2.size()) == 0);
         str2 = Data_.abcde();
-        UNIT_ASSERT(str1.compare(str2) > 0); 
+        UNIT_ASSERT(str1.compare(str2) > 0);
         UNIT_ASSERT(str1.compare(str2.data(), str2.size()) > 0);
         str2 = Data_.abcdefg();
-        UNIT_ASSERT(str1.compare(str2) < 0); 
+        UNIT_ASSERT(str1.compare(str2) < 0);
         UNIT_ASSERT(str1.compare(str2.data(), str2.size()) < 0);
 
         UNIT_ASSERT(str1.compare(Data_.abcdef()) == 0);
@@ -565,24 +565,24 @@ protected:
         UNIT_ASSERT(str1.compare(Data_.abcdefg()) < 0);
 
         str2 = Data_.cde();
-        UNIT_ASSERT(str1.compare(2, 3, str2) == 0); 
+        UNIT_ASSERT(str1.compare(2, 3, str2) == 0);
         str2 = Data_.cd();
-        UNIT_ASSERT(str1.compare(2, 3, str2) > 0); 
+        UNIT_ASSERT(str1.compare(2, 3, str2) > 0);
         str2 = Data_.cdef();
-        UNIT_ASSERT(str1.compare(2, 3, str2) < 0); 
+        UNIT_ASSERT(str1.compare(2, 3, str2) < 0);
 
         str2 = Data_.abcdef();
-        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 3) == 0); 
-        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 2) > 0); 
-        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 4) < 0); 
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 3) == 0);
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 2) > 0);
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 4) < 0);
 
         UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 3) == 0);
         UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 2) > 0);
         UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 4) < 0);
-    } 
+    }
 
-    void find_last_of() { 
-        // 21.3.6.4 
+    void find_last_of() {
+        // 21.3.6.4
         TStringType s(Data_.one_two_three_one_two_three());
 
         UNIT_ASSERT(s.find_last_of(Data_.abcde()) == 26);
@@ -597,16 +597,16 @@ protected:
         UNIT_ASSERT(test.find_last_of(*Data_.a(), 2) == 2);
         UNIT_ASSERT(test.find_last_of(*Data_.a(), 1) == 0);
         UNIT_ASSERT(test.find_last_of(*Data_.a(), 0) == 0);
-    } 
+    }
 #if 0
-    void rfind() { 
-        // 21.3.6.2 
+    void rfind() {
+        // 21.3.6.2
         TStringType s(Data.one_two_three_one_two_three());
 
-        UNIT_ASSERT(s.rfind(Data.two()) == 18); 
+        UNIT_ASSERT(s.rfind(Data.two()) == 18);
         UNIT_ASSERT(s.rfind(Data.two(), 0) == TStringType::npos);
-        UNIT_ASSERT(s.rfind(Data.two(), 11) == 4); 
-        UNIT_ASSERT(s.rfind(*Data.w()) == 19); 
+        UNIT_ASSERT(s.rfind(Data.two(), 11) == 4);
+        UNIT_ASSERT(s.rfind(*Data.w()) == 19);
 
         TStringType test(Data.aba());
 
@@ -617,10 +617,10 @@ protected:
         UNIT_ASSERT(test.rfind(*Data.a(), 2) == 2);
         UNIT_ASSERT(test.rfind(*Data.a(), 1) == 0);
         UNIT_ASSERT(test.rfind(*Data.a(), 0) == 0);
-    } 
+    }
 #endif
-    void find_last_not_of() { 
-        // 21.3.6.6 
+    void find_last_not_of() {
+        // 21.3.6.6
         TStringType s(Data_.one_two_three_one_two_three());
 
         UNIT_ASSERT(s.find_last_not_of(Data_.ehortw_()) == 15);
@@ -640,90 +640,90 @@ protected:
         UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 1) == 0);
         UNIT_ASSERT(test.find_last_not_of(*Data_.a(), 0) == TStringType::npos);
         UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 0) == 0);
-    } 
+    }
 #if 0
-    void replace() { 
+    void replace() {
         // This test case is for the non template basic_TString::replace method,
-        // this is why we play with the const iterators and reference to guaranty 
-        // that the right method is called. 
+        // this is why we play with the const iterators and reference to guaranty
+        // that the right method is called.
 
         const TStringType v(Data._78());
         TStringType s(Data._123456());
         TStringType const& cs = s;
 
         typename TStringType::iterator i = s.begin() + 1;
-        s.replace(i, i + 3, v.begin(), v.end()); 
+        s.replace(i, i + 3, v.begin(), v.end());
         UNIT_ASSERT(s == Data._17856());
 
-        s = Data._123456(); 
-        i = s.begin() + 1; 
-        s.replace(i, i + 1, v.begin(), v.end()); 
+        s = Data._123456();
+        i = s.begin() + 1;
+        s.replace(i, i + 1, v.begin(), v.end());
         UNIT_ASSERT(s == Data._1783456());
 
-        s = Data._123456(); 
-        i = s.begin() + 1; 
+        s = Data._123456();
+        i = s.begin() + 1;
         typename TStringType::const_iterator ci = s.begin() + 1;
-        s.replace(i, i + 3, ci + 3, cs.end()); 
+        s.replace(i, i + 3, ci + 3, cs.end());
         UNIT_ASSERT(s == Data._15656());
 
-        s = Data._123456(); 
-        i = s.begin() + 1; 
-        ci = s.begin() + 1; 
-        s.replace(i, i + 3, ci, ci + 2); 
+        s = Data._123456();
+        i = s.begin() + 1;
+        ci = s.begin() + 1;
+        s.replace(i, i + 3, ci, ci + 2);
         UNIT_ASSERT(s == Data._12356());
 
-        s = Data._123456(); 
-        i = s.begin() + 1; 
-        ci = s.begin() + 1; 
-        s.replace(i, i + 3, ci + 1, cs.end()); 
+        s = Data._123456();
+        i = s.begin() + 1;
+        ci = s.begin() + 1;
+        s.replace(i, i + 3, ci + 1, cs.end());
         UNIT_ASSERT(s == Data._1345656());
 
-        s = Data._123456(); 
-        i = s.begin(); 
-        ci = s.begin() + 1; 
-        s.replace(i, i, ci, ci + 1); 
+        s = Data._123456();
+        i = s.begin();
+        ci = s.begin() + 1;
+        s.replace(i, i, ci, ci + 1);
         UNIT_ASSERT(s == Data._2123456());
 
-        s = Data._123456(); 
-        s.replace(s.begin() + 4, s.end(), cs.begin(), cs.end()); 
+        s = Data._123456();
+        s.replace(s.begin() + 4, s.end(), cs.begin(), cs.end());
         UNIT_ASSERT(s == Data._1234123456());
 
-        // This is the test for the template replace method. 
+        // This is the test for the template replace method.
 
-        s = Data._123456(); 
+        s = Data._123456();
         typename TStringType::iterator b = s.begin() + 4;
         typename TStringType::iterator e = s.end();
         typename TStringType::const_iterator rb = s.begin();
         typename TStringType::const_iterator re = s.end();
-        s.replace(b, e, rb, re); 
+        s.replace(b, e, rb, re);
         UNIT_ASSERT(s == Data._1234123456());
 
-        s = Data._123456(); 
-        s.replace(s.begin() + 4, s.end(), s.begin(), s.end()); 
+        s = Data._123456();
+        s.replace(s.begin() + 4, s.end(), s.begin(), s.end());
         UNIT_ASSERT(s == Data._1234123456());
 
         TStringType strorg(Data.This_is_test_StringT_for_StringT_calls());
         TStringType str = strorg;
-        str.replace(5, 15, str.c_str(), 10); 
+        str.replace(5, 15, str.c_str(), 10);
         UNIT_ASSERT(str == Data.This_This_is_tefor_StringT_calls());
 
-        str = strorg; 
-        str.replace(5, 5, str.c_str(), 10); 
+        str = strorg;
+        str.replace(5, 5, str.c_str(), 10);
         UNIT_ASSERT(str == Data.This_This_is_test_StringT_for_StringT_calls());
 
     #if !defined(STLPORT) || defined(_STLP_MEMBER_TEMPLATES)
         deque<TChar> cdeque;
-        cdeque.push_back(*Data.I()); 
-        str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end()); 
+        cdeque.push_back(*Data.I());
+        str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end());
         UNIT_ASSERT(str == Data.Is_test_StringT_for_StringT_calls());
     #endif
-    } 
+    }
 #endif
-}; // TStringStdTestImpl 
- 
+}; // TStringStdTestImpl
+
 class TStringTest: public TTestBase, private TStringTestImpl<TString, TTestData<char>> {
-public: 
-    UNIT_TEST_SUITE(TStringTest); 
+public:
+    UNIT_TEST_SUITE(TStringTest);
     UNIT_TEST(TestMaxSize);
     UNIT_TEST(TestConstructors);
     UNIT_TEST(TestReplace);
@@ -752,7 +752,7 @@ public:
     UNIT_TEST(TestFillingAssign)
     UNIT_TEST(TestStdStreamApi)
     //UNIT_TEST(TestOperatorsCI); must fail
-    UNIT_TEST_SUITE_END(); 
+    UNIT_TEST_SUITE_END();
 
     void TestAppendUtf16() {
         TString appended = TString("А роза упала").AppendUtf16(u" на лапу Азора");
@@ -779,13 +779,13 @@ public:
         ss >> read;
         UNIT_ASSERT_VALUES_EQUAL(read, data);
     }
-}; 
- 
-UNIT_TEST_SUITE_REGISTRATION(TStringTest); 
- 
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TStringTest);
+
 class TWideStringTest: public TTestBase, private TStringTestImpl<TUtf16String, TTestData<wchar16>> {
-public: 
-    UNIT_TEST_SUITE(TWideStringTest); 
+public:
+    UNIT_TEST_SUITE(TWideStringTest);
     UNIT_TEST(TestConstructors);
     UNIT_TEST(TestReplace);
 #ifndef TSTRING_IS_STD_STRING
@@ -812,7 +812,7 @@ public:
     UNIT_TEST(TestIterators);
     UNIT_TEST(TestReverseIterators);
     UNIT_TEST(TestStringLiterals);
-    UNIT_TEST_SUITE_END(); 
+    UNIT_TEST_SUITE_END();
 
 private:
     void TestDecodingMethods() {
@@ -903,10 +903,10 @@ private:
         TUtf16String s2 = u"привет";
         UNIT_ASSERT_VALUES_EQUAL(s2, TUtf16String::FromUtf8("привет"));
     }
-}; 
- 
-UNIT_TEST_SUITE_REGISTRATION(TWideStringTest); 
- 
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TWideStringTest);
+
 class TUtf32StringTest: public TTestBase, private TStringTestImpl<TUtf32String, TTestData<wchar32>> {
 public:
     UNIT_TEST_SUITE(TUtf32StringTest);
@@ -1106,8 +1106,8 @@ private:
 UNIT_TEST_SUITE_REGISTRATION(TUtf32StringTest);
 
 class TStringStdTest: public TTestBase, private TStringStdTestImpl<TString, TTestData<char>> {
-public: 
-    UNIT_TEST_SUITE(TStringStdTest); 
+public:
+    UNIT_TEST_SUITE(TStringStdTest);
     UNIT_TEST(Constructor);
     UNIT_TEST(reserve);
     UNIT_TEST(short_string);
@@ -1131,19 +1131,19 @@ public:
     UNIT_TEST(cbegin_cend);
     UNIT_TEST(compare);
     UNIT_TEST(find_last_of);
-#if 0 
-        UNIT_TEST(rfind); 
-        UNIT_TEST(replace); 
-#endif 
+#if 0
+        UNIT_TEST(rfind);
+        UNIT_TEST(replace);
+#endif
     UNIT_TEST(find_last_not_of);
-    UNIT_TEST_SUITE_END(); 
-}; 
- 
-UNIT_TEST_SUITE_REGISTRATION(TStringStdTest); 
- 
+    UNIT_TEST_SUITE_END();
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TStringStdTest);
+
 class TWideStringStdTest: public TTestBase, private TStringStdTestImpl<TUtf16String, TTestData<wchar16>> {
-public: 
-    UNIT_TEST_SUITE(TWideStringStdTest); 
+public:
+    UNIT_TEST_SUITE(TWideStringStdTest);
     UNIT_TEST(Constructor);
     UNIT_TEST(reserve);
     UNIT_TEST(short_string);
@@ -1167,15 +1167,15 @@ public:
     UNIT_TEST(cbegin_cend);
     UNIT_TEST(compare);
     UNIT_TEST(find_last_of);
-#if 0 
-        UNIT_TEST(rfind); 
-        UNIT_TEST(replace); 
-#endif 
+#if 0
+        UNIT_TEST(rfind);
+        UNIT_TEST(replace);
+#endif
     UNIT_TEST(find_last_not_of);
-    UNIT_TEST_SUITE_END(); 
-}; 
- 
-UNIT_TEST_SUITE_REGISTRATION(TWideStringStdTest); 
+    UNIT_TEST_SUITE_END();
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TWideStringStdTest);
 
 Y_UNIT_TEST_SUITE(TStringConversionTest) {
     Y_UNIT_TEST(ConversionToStdStringTest) {
diff --git a/util/generic/string_ut.h b/util/generic/string_ut.h
index af517d8359..44bb10bdeb 100644
--- a/util/generic/string_ut.h
+++ b/util/generic/string_ut.h
@@ -514,9 +514,9 @@ protected:
     using char_type = typename TStringType::char_type;
     using traits_type = typename TStringType::traits_type;
 
-    TTestData Data; 
+    TTestData Data;
 
-public: 
+public:
     void TestMaxSize() {
         const size_t badMaxVal = TStringType{}.max_size() + 1;
 
@@ -532,7 +532,7 @@ public:
         TStringType s;
         TStringType s1(*Data._0());
         TStringType s2(Data._0());
-        UNIT_ASSERT(s1 == s2); 
+        UNIT_ASSERT(s1 == s2);
 
         TStringType fromZero(0);
         UNIT_ASSERT_VALUES_EQUAL(fromZero.size(), 0u);
@@ -547,21 +547,21 @@ public:
 #endif
 
         TStringType s4(Data._0123456(), 1, 3);
-        UNIT_ASSERT(s4 == Data._123()); 
+        UNIT_ASSERT(s4 == Data._123());
 
         TStringType s5(5, *Data._0());
-        UNIT_ASSERT(s5 == Data._00000()); 
+        UNIT_ASSERT(s5 == Data._00000());
 
         TStringType s6(Data._0123456());
-        UNIT_ASSERT(s6 == Data._0123456()); 
+        UNIT_ASSERT(s6 == Data._0123456());
         TStringType s7(s6);
-        UNIT_ASSERT(s7 == s6); 
+        UNIT_ASSERT(s7 == s6);
 #ifndef TSTRING_IS_STD_STRING
-        UNIT_ASSERT(s7.c_str() == s6.c_str()); 
+        UNIT_ASSERT(s7.c_str() == s6.c_str());
 #endif
 
         TStringType s8(s7, 1, 3);
-        UNIT_ASSERT(s8 == Data._123()); 
+        UNIT_ASSERT(s8 == Data._123());
 
         TStringType s9(*Data._1());
         UNIT_ASSERT(s9 == Data._1());
@@ -569,86 +569,86 @@ public:
         TStringType s10(Reserve(100));
         UNIT_ASSERT(s10.empty());
         UNIT_ASSERT(s10.capacity() >= 100);
-    } 
+    }
 
     void TestReplace() {
         TStringType s(Data._0123456());
-        UNIT_ASSERT(s.copy() == Data._0123456()); 
+        UNIT_ASSERT(s.copy() == Data._0123456());
 
-        // append family 
-        s.append(Data.x()); 
-        UNIT_ASSERT(s == Data._0123456x()); 
+        // append family
+        s.append(Data.x());
+        UNIT_ASSERT(s == Data._0123456x());
 
 #ifdef TSTRING_IS_STD_STRING
         s.append(Data.xyz() + 1, 1);
 #else
-        s.append(Data.xyz(), 1, 1); 
+        s.append(Data.xyz(), 1, 1);
 #endif
-        UNIT_ASSERT(s == Data._0123456xy()); 
+        UNIT_ASSERT(s == Data._0123456xy());
 
         s.append(TStringType(Data.z()));
-        UNIT_ASSERT(s == Data._0123456xyz()); 
+        UNIT_ASSERT(s == Data._0123456xyz());
 
         s.append(TStringType(Data.XYZ()), 2, 1);
-        UNIT_ASSERT(s == Data._0123456xyzZ()); 
+        UNIT_ASSERT(s == Data._0123456xyzZ());
 
-        s.append(*Data._0()); 
-        UNIT_ASSERT(s == Data._0123456xyzZ0()); 
+        s.append(*Data._0());
+        UNIT_ASSERT(s == Data._0123456xyzZ0());
 
-        // prepend family 
-        s = Data._0123456xyz(); 
+        // prepend family
+        s = Data._0123456xyz();
         s.prepend(TStringType(Data.abc()));
-        UNIT_ASSERT(s == Data.abc0123456xyz()); 
+        UNIT_ASSERT(s == Data.abc0123456xyz());
 
         s.prepend(TStringType(Data.ABC()), 1, 2);
-        UNIT_ASSERT(s == Data.BCabc0123456xyz()); 
+        UNIT_ASSERT(s == Data.BCabc0123456xyz());
 
-        s.prepend(Data.qwe()); 
-        UNIT_ASSERT(s == Data.qweBCabc0123456xyz()); 
+        s.prepend(Data.qwe());
+        UNIT_ASSERT(s == Data.qweBCabc0123456xyz());
 
-        s.prepend(*Data._1()); 
-        UNIT_ASSERT(s == Data._1qweBCabc0123456xyz()); 
+        s.prepend(*Data._1());
+        UNIT_ASSERT(s == Data._1qweBCabc0123456xyz());
 
-        // substr 
-        s = Data.abc0123456xyz(); 
-        s = s.substr(3, 7); 
-        UNIT_ASSERT(s == Data._0123456()); 
+        // substr
+        s = Data.abc0123456xyz();
+        s = s.substr(3, 7);
+        UNIT_ASSERT(s == Data._0123456());
 
-        // insert family 
-        s.insert(2, Data.abc()); 
-        UNIT_ASSERT(s == Data._01abc23456()); 
+        // insert family
+        s.insert(2, Data.abc());
+        UNIT_ASSERT(s == Data._01abc23456());
 
         s.insert(2, TStringType(Data.ABC()));
-        UNIT_ASSERT(s == Data._01ABCabc23456()); 
+        UNIT_ASSERT(s == Data._01ABCabc23456());
 
         s.insert(0, TStringType(Data.QWE()), 1, 1);
-        UNIT_ASSERT(s == Data.W01ABCabc23456()); 
+        UNIT_ASSERT(s == Data.W01ABCabc23456());
 
-        // replace family 
-        s = Data._01abc23456(); 
-        s.replace(0, 7, Data.abcd()); 
-        UNIT_ASSERT(s == Data.abcd456()); 
+        // replace family
+        s = Data._01abc23456();
+        s.replace(0, 7, Data.abcd());
+        UNIT_ASSERT(s == Data.abcd456());
 
         s.replace(4, 3, TStringType(Data.ABCD()));
-        UNIT_ASSERT(s == Data.abcdABCD()); 
+        UNIT_ASSERT(s == Data.abcdABCD());
 
         s.replace(7, 10, TStringType(Data._01234()), 1, 3);
-        UNIT_ASSERT(s == Data.abcdABC123()); 
-        UNIT_ASSERT(Data.abcdABC123() == s); 
-
-        // remove, erase 
-        s.remove(4); 
-        UNIT_ASSERT(s == Data.abcd()); 
-        s.erase(3); 
-        UNIT_ASSERT(s == Data.abc()); 
-
-        // Read access 
-        s = Data._012345(); 
-        UNIT_ASSERT(s.at(1) == *Data._1()); 
-        UNIT_ASSERT(s[1] == *Data._1()); 
+        UNIT_ASSERT(s == Data.abcdABC123());
+        UNIT_ASSERT(Data.abcdABC123() == s);
+
+        // remove, erase
+        s.remove(4);
+        UNIT_ASSERT(s == Data.abcd());
+        s.erase(3);
+        UNIT_ASSERT(s == Data.abc());
+
+        // Read access
+        s = Data._012345();
+        UNIT_ASSERT(s.at(1) == *Data._1());
+        UNIT_ASSERT(s[1] == *Data._1());
         UNIT_ASSERT(s.at(s.size()) == 0);
         UNIT_ASSERT(s[s.size()] == 0);
-    } 
+    }
 
 #ifndef TSTRING_IS_STD_STRING
     void TestRefCount() {
@@ -658,47 +658,47 @@ public:
             using TStr::TStr;
             // un-protect
             using TStr::RefCount;
-        }; 
-
-        TestStroka s1(Data.orig()); 
-        UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true); 
-        TestStroka s2(s1); 
-        UNIT_ASSERT_EQUAL(s1.RefCount() == 2, true); 
-        UNIT_ASSERT_EQUAL(s2.RefCount() == 2, true); 
-        UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), true); // the same pointer 
-        char_type* beg = s2.begin(); 
-        UNIT_ASSERT_EQUAL(s1 == beg, true); 
-        UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true); 
-        UNIT_ASSERT_EQUAL(s2.RefCount() == 1, true); 
-        UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), false); 
-    } 
+        };
+
+        TestStroka s1(Data.orig());
+        UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true);
+        TestStroka s2(s1);
+        UNIT_ASSERT_EQUAL(s1.RefCount() == 2, true);
+        UNIT_ASSERT_EQUAL(s2.RefCount() == 2, true);
+        UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), true); // the same pointer
+        char_type* beg = s2.begin();
+        UNIT_ASSERT_EQUAL(s1 == beg, true);
+        UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true);
+        UNIT_ASSERT_EQUAL(s2.RefCount() == 1, true);
+        UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), false);
+    }
 #endif
 
-    //  Find family 
+    //  Find family
 
     void TestFind() {
         const TStringType s(Data._0123456_12345());
         const TStringType s2(Data._0123());
 
-        UNIT_ASSERT(s.find(Data._345()) == 3); 
-        UNIT_ASSERT(s.find(Data._345(), 5) == 10); 
+        UNIT_ASSERT(s.find(Data._345()) == 3);
+        UNIT_ASSERT(s.find(Data._345(), 5) == 10);
 
         UNIT_ASSERT(s.find(Data._345(), 20) == TStringType::npos);
-        UNIT_ASSERT(s.find(*Data._3()) == 3); 
+        UNIT_ASSERT(s.find(*Data._3()) == 3);
         UNIT_ASSERT(s.find(TStringType(Data._345())) == 3);
         UNIT_ASSERT(s.find(TStringType(Data._345()), 2) == 3);
 
         UNIT_ASSERT(s.find_first_of(TStringType(Data._389())) == 3);
-        UNIT_ASSERT(s.find_first_of(Data._389()) == 3); 
+        UNIT_ASSERT(s.find_first_of(Data._389()) == 3);
         UNIT_ASSERT(s.find_first_of(Data._389(), s.size()) == TStringType::npos);
-        UNIT_ASSERT(s.find_first_not_of(Data._123()) == 0); 
+        UNIT_ASSERT(s.find_first_not_of(Data._123()) == 0);
         UNIT_ASSERT(s.find_first_of('6') == 6);
         UNIT_ASSERT(s.find_first_of('1', 2) == 8);
         UNIT_ASSERT(s.find_first_not_of('0') == 1);
         UNIT_ASSERT(s.find_first_not_of('1', 1) == 2);
 
         const TStringType rs = Data._0123401234();
-        UNIT_ASSERT(rs.rfind(*Data._3()) == 8); 
+        UNIT_ASSERT(rs.rfind(*Data._3()) == 8);
 
         const TStringType empty;
         UNIT_ASSERT(empty.find(empty) == 0);
@@ -739,58 +739,58 @@ public:
         UNIT_ASSERT(s.Contains(empty, s.length()));
     }
 
-    // Operators 
+    // Operators
 
     void TestOperators() {
         TStringType s(Data._0123456());
 
-        // operator += 
+        // operator +=
         s += TStringType(Data.x());
-        UNIT_ASSERT(s == Data._0123456x()); 
+        UNIT_ASSERT(s == Data._0123456x());
 
-        s += Data.y(); 
-        UNIT_ASSERT(s == Data._0123456xy()); 
+        s += Data.y();
+        UNIT_ASSERT(s == Data._0123456xy());
 
-        s += *Data.z(); 
-        UNIT_ASSERT(s == Data._0123456xyz()); 
+        s += *Data.z();
+        UNIT_ASSERT(s == Data._0123456xyz());
 
-        // operator + 
-        s = Data._0123456(); 
+        // operator +
+        s = Data._0123456();
         s = s + TStringType(Data.x());
-        UNIT_ASSERT(s == Data._0123456x()); 
+        UNIT_ASSERT(s == Data._0123456x());
 
-        s = s + Data.y(); 
-        UNIT_ASSERT(s == Data._0123456xy()); 
+        s = s + Data.y();
+        UNIT_ASSERT(s == Data._0123456xy());
 
-        s = s + *Data.z(); 
-        UNIT_ASSERT(s == Data._0123456xyz()); 
+        s = s + *Data.z();
+        UNIT_ASSERT(s == Data._0123456xyz());
 
-        // operator != 
-        s = Data._012345(); 
+        // operator !=
+        s = Data._012345();
         UNIT_ASSERT(s != TStringType(Data.xyz()));
-        UNIT_ASSERT(s != Data.xyz()); 
-        UNIT_ASSERT(Data.xyz() != s); 
+        UNIT_ASSERT(s != Data.xyz());
+        UNIT_ASSERT(Data.xyz() != s);
 
-        // operator < 
+        // operator <
         UNIT_ASSERT_EQUAL(s < TStringType(Data.xyz()), true);
-        UNIT_ASSERT_EQUAL(s < Data.xyz(), true); 
-        UNIT_ASSERT_EQUAL(Data.xyz() < s, false); 
+        UNIT_ASSERT_EQUAL(s < Data.xyz(), true);
+        UNIT_ASSERT_EQUAL(Data.xyz() < s, false);
 
-        // operator <= 
+        // operator <=
         UNIT_ASSERT_EQUAL(s <= TStringType(Data.xyz()), true);
-        UNIT_ASSERT_EQUAL(s <= Data.xyz(), true); 
-        UNIT_ASSERT_EQUAL(Data.xyz() <= s, false); 
+        UNIT_ASSERT_EQUAL(s <= Data.xyz(), true);
+        UNIT_ASSERT_EQUAL(Data.xyz() <= s, false);
 
-        // operator > 
+        // operator >
         UNIT_ASSERT_EQUAL(s > TStringType(Data.xyz()), false);
-        UNIT_ASSERT_EQUAL(s > Data.xyz(), false); 
-        UNIT_ASSERT_EQUAL(Data.xyz() > s, true); 
+        UNIT_ASSERT_EQUAL(s > Data.xyz(), false);
+        UNIT_ASSERT_EQUAL(Data.xyz() > s, true);
 
-        // operator >= 
+        // operator >=
         UNIT_ASSERT_EQUAL(s >= TStringType(Data.xyz()), false);
-        UNIT_ASSERT_EQUAL(s >= Data.xyz(), false); 
-        UNIT_ASSERT_EQUAL(Data.xyz() >= s, true); 
-    } 
+        UNIT_ASSERT_EQUAL(s >= Data.xyz(), false);
+        UNIT_ASSERT_EQUAL(Data.xyz() >= s, true);
+    }
 
     void TestOperatorsCI() {
         TStringType s(Data.ABCD());
@@ -805,132 +805,132 @@ public:
     }
 
     void TestMulOperators() {
-        { 
+        {
             TStringType s(Data._0());
-            s *= 10; 
+            s *= 10;
             UNIT_ASSERT_EQUAL(s, TStringType(Data._0000000000()));
-        } 
-        { 
+        }
+        {
             TStringType s = TStringType(Data._0()) * 2;
             UNIT_ASSERT_EQUAL(s, TStringType(Data._00()));
-        } 
-    } 
+        }
+    }
 
-    // Test any other functions 
+    // Test any other functions
 
     void TestFuncs() {
         TStringType s(Data._0123456());
         UNIT_ASSERT(s.c_str() == s.data());
 
-        // length() 
+        // length()
         UNIT_ASSERT(s.length() == s.size());
         UNIT_ASSERT(s.length() == traits_type::length(s.data()));
 
-        // is_null() 
+        // is_null()
         TStringType s1(Data.Empty());
-        UNIT_ASSERT(s1.is_null() == true); 
-        UNIT_ASSERT(s1.is_null() == s1.empty()); 
-        UNIT_ASSERT(s1.is_null() == !s1); 
+        UNIT_ASSERT(s1.is_null() == true);
+        UNIT_ASSERT(s1.is_null() == s1.empty());
+        UNIT_ASSERT(s1.is_null() == !s1);
 
         TStringType s2(s);
-        UNIT_ASSERT(s2 == s); 
+        UNIT_ASSERT(s2 == s);
 
-        // reverse() 
+        // reverse()
         ReverseInPlace(s2);
-        UNIT_ASSERT(s2 == Data._6543210()); 
+        UNIT_ASSERT(s2 == Data._6543210());
 
-        // to_upper() 
-        s2 = Data.asdf1234qwer(); 
-        s2.to_upper(); 
-        UNIT_ASSERT(s2 == Data.ASDF1234QWER()); 
+        // to_upper()
+        s2 = Data.asdf1234qwer();
+        s2.to_upper();
+        UNIT_ASSERT(s2 == Data.ASDF1234QWER());
 
-        // to_lower() 
-        s2.to_lower(); 
-        UNIT_ASSERT(s2 == Data.asdf1234qwer()); 
+        // to_lower()
+        s2.to_lower();
+        UNIT_ASSERT(s2 == Data.asdf1234qwer());
 
-        // to_title() 
-        s2 = Data.asDF1234qWEr(); 
-        s2.to_title(); 
-        UNIT_ASSERT(s2 == Data.Asdf1234qwer()); 
+        // to_title()
+        s2 = Data.asDF1234qWEr();
+        s2.to_title();
+        UNIT_ASSERT(s2 == Data.Asdf1234qwer());
 
-        s2 = Data.AsDF1234qWEr(); 
-        s2.to_title(); 
-        UNIT_ASSERT(s2 == Data.Asdf1234qwer()); 
+        s2 = Data.AsDF1234qWEr();
+        s2.to_title();
+        UNIT_ASSERT(s2 == Data.Asdf1234qwer());
 
-        // Friend functions 
-        s2 = Data.asdf1234qwer(); 
+        // Friend functions
+        s2 = Data.asdf1234qwer();
         TStringType s3 = to_upper(s2);
-        UNIT_ASSERT(s3 == Data.ASDF1234QWER()); 
-        s3 = to_lower(s2); 
-        UNIT_ASSERT(s3 == Data.asdf1234qwer()); 
-        s3 = to_title(s2); 
-        UNIT_ASSERT(s3 == Data.Asdf1234qwer()); 
-        s2 = s3; 
-
-        // resize family 
+        UNIT_ASSERT(s3 == Data.ASDF1234QWER());
+        s3 = to_lower(s2);
+        UNIT_ASSERT(s3 == Data.asdf1234qwer());
+        s3 = to_title(s2);
+        UNIT_ASSERT(s3 == Data.Asdf1234qwer());
+        s2 = s3;
+
+        // resize family
         s2.resize(s2.size()); // without length change
-        UNIT_ASSERT(s2 == Data.Asdf1234qwer()); 
+        UNIT_ASSERT(s2 == Data.Asdf1234qwer());
 
         s2.resize(s2.size() + 4, *Data.W());
-        UNIT_ASSERT(s2 == Data.Asdf1234qwerWWWW()); 
+        UNIT_ASSERT(s2 == Data.Asdf1234qwerWWWW());
 
-        s2.resize(4); 
-        UNIT_ASSERT(s2 == Data.Asdf()); 
+        s2.resize(4);
+        UNIT_ASSERT(s2 == Data.Asdf());
 
-        // assign family 
-        s2 = Data.asdf1234qwer(); 
-        s2.assign(s, 1, 3); 
-        UNIT_ASSERT(s2 == Data._123()); 
+        // assign family
+        s2 = Data.asdf1234qwer();
+        s2.assign(s, 1, 3);
+        UNIT_ASSERT(s2 == Data._123());
 
-        s2.assign(Data._0123456(), 4); 
-        UNIT_ASSERT(s2 == Data._0123()); 
+        s2.assign(Data._0123456(), 4);
+        UNIT_ASSERT(s2 == Data._0123());
 
         s2.assign('1');
         UNIT_ASSERT(s2 == Data._1());
 
-        s2.assign(Data._0123456()); 
-        UNIT_ASSERT(s2 == Data._0123456()); 
+        s2.assign(Data._0123456());
+        UNIT_ASSERT(s2 == Data._0123456());
 
-        // hash() 
+        // hash()
         TStringType sS = s2; // type 'TStringType' is used as is
 
         ComputeHash(sS); /*size_t hash_val = sS.hash();
 
         try {
             //UNIT_ASSERT(hash_val == Data.HashOf_0123456());
-        } catch (...) { 
-            Cerr << hash_val << Endl; 
-            throw; 
+        } catch (...) {
+            Cerr << hash_val << Endl;
+            throw;
         }*/
 
-        s2.assign(Data._0123456(), 2, 2); 
-        UNIT_ASSERT(s2 == Data._23()); 
+        s2.assign(Data._0123456(), 2, 2);
+        UNIT_ASSERT(s2 == Data._23());
 
-        //s2.reserve(); 
+        //s2.reserve();
 
         TStringType s5(Data.abcde());
         s5.clear();
-        UNIT_ASSERT(s5 == Data.Empty()); 
-    } 
+        UNIT_ASSERT(s5 == Data.Empty());
+    }
 
     void TestUtils() {
         TStringType s;
-        s = Data._01230123(); 
+        s = Data._01230123();
         TStringType from = Data._0();
         TStringType to = Data.z();
 
         SubstGlobal(s, from, to);
-        UNIT_ASSERT(s == Data.z123z123()); 
-    } 
+        UNIT_ASSERT(s == Data.z123z123());
+    }
 
     void TestEmpty() {
         TStringType s;
-        s = Data._2(); 
+        s = Data._2();
         s = TStringType(Data.fdfdsfds(), (size_t)0, (size_t)0);
-        UNIT_ASSERT(s.empty()); 
-    } 
+        UNIT_ASSERT(s.empty());
+    }
 
-    void TestJoin() { 
+    void TestJoin() {
         UNIT_ASSERT_EQUAL(TStringType::Join(Data._12(), Data._3456()), Data._123456());
         UNIT_ASSERT_EQUAL(TStringType::Join(Data._12(), TStringType(Data._3456())), Data._123456());
         UNIT_ASSERT_EQUAL(TStringType::Join(TStringType(Data._12()), Data._3456()), Data._123456());
@@ -941,43 +941,43 @@ public:
         UNIT_ASSERT_EQUAL(TStringType::Join(TStringType(Data.a()), static_cast<typename TStringType::char_type>('b'), TStringType(Data.cd()), TStringType(Data.e()), Data.fg(), TStringType(Data.h())), Data.abcdefgh());
     }
 
-    void TestCopy() { 
+    void TestCopy() {
         TStringType s(Data.abcd());
         TStringType c = s.copy();
 
-        UNIT_ASSERT_EQUAL(s, c); 
-        UNIT_ASSERT(s.end() != c.end()); 
-    } 
+        UNIT_ASSERT_EQUAL(s, c);
+        UNIT_ASSERT(s.end() != c.end());
+    }
 
-    void TestStrCpy() { 
-        { 
+    void TestStrCpy() {
+        {
             TStringType s(Data.abcd());
-            char_type data[5]; 
+            char_type data[5];
 
-            data[4] = 1; 
+            data[4] = 1;
 
-            s.strcpy(data, 4); 
+            s.strcpy(data, 4);
 
-            UNIT_ASSERT_EQUAL(data[0], *Data.a()); 
-            UNIT_ASSERT_EQUAL(data[1], *Data.b()); 
-            UNIT_ASSERT_EQUAL(data[2], *Data.c()); 
-            UNIT_ASSERT_EQUAL(data[3], 0); 
-            UNIT_ASSERT_EQUAL(data[4], 1); 
-        } 
+            UNIT_ASSERT_EQUAL(data[0], *Data.a());
+            UNIT_ASSERT_EQUAL(data[1], *Data.b());
+            UNIT_ASSERT_EQUAL(data[2], *Data.c());
+            UNIT_ASSERT_EQUAL(data[3], 0);
+            UNIT_ASSERT_EQUAL(data[4], 1);
+        }
 
-        { 
+        {
             TStringType s(Data.abcd());
-            char_type data[5]; 
- 
-            s.strcpy(data, 5); 
- 
-            UNIT_ASSERT_EQUAL(data[0], *Data.a()); 
-            UNIT_ASSERT_EQUAL(data[1], *Data.b()); 
-            UNIT_ASSERT_EQUAL(data[2], *Data.c()); 
-            UNIT_ASSERT_EQUAL(data[3], *Data.d()); 
-            UNIT_ASSERT_EQUAL(data[4], 0); 
-        } 
-    } 
+            char_type data[5];
+
+            s.strcpy(data, 5);
+
+            UNIT_ASSERT_EQUAL(data[0], *Data.a());
+            UNIT_ASSERT_EQUAL(data[1], *Data.b());
+            UNIT_ASSERT_EQUAL(data[2], *Data.c());
+            UNIT_ASSERT_EQUAL(data[3], *Data.d());
+            UNIT_ASSERT_EQUAL(data[4], 0);
+        }
+    }
 
     void TestPrefixSuffix() {
         const TStringType emptyStr;
@@ -1153,4 +1153,4 @@ public:
         *ritBegin = (ui8)'e';
         UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'e');
     }
-}; 
+};
diff --git a/util/generic/yexception_ut.c b/util/generic/yexception_ut.c
index a46ae5b783..3880c82e29 100644
--- a/util/generic/yexception_ut.c
+++ b/util/generic/yexception_ut.c
@@ -1,5 +1,5 @@
-#include "yexception_ut.h" 
- 
-void TestCallback(TCallbackFun f, int i) { 
-    f(i); 
-} 
+#include "yexception_ut.h"
+
+void TestCallback(TCallbackFun f, int i) {
+    f(i);
+}
diff --git a/util/generic/yexception_ut.cpp b/util/generic/yexception_ut.cpp
index 6feb5c65c0..cb3e29fed8 100644
--- a/util/generic/yexception_ut.cpp
+++ b/util/generic/yexception_ut.cpp
@@ -16,17 +16,17 @@ static inline void Throw2DontMove() {
 #include <util/stream/output.h>
 #include <util/string/subst.h>
 
-#include "yexception_ut.h" 
+#include "yexception_ut.h"
 #include "bt_exception.h"
- 
+
 #if defined(_MSC_VER)
     #pragma warning(disable : 4702) /*unreachable code*/
 #endif
 
-static void CallbackFun(int i) { 
-    throw i; 
-} 
- 
+static void CallbackFun(int i) {
+    throw i;
+}
+
 static IOutputStream* OUTS = nullptr;
 
 namespace NOuter::NInner {
@@ -247,7 +247,7 @@ private:
             throw;
         }
     }
- 
+
     //! tests propagation of an exception through C code
     //! @note on some platforms, for example GCC on 32-bit Linux without -fexceptions option,
     //!       throwing an exception from a C++ callback through C code aborts program
@@ -258,7 +258,7 @@ private:
             UNIT_ASSERT(false);
         } catch (int i) {
             UNIT_ASSERT_VALUES_EQUAL(i, N);
-        } 
+        }
     }
 
     void TestMacroOverload() {
diff --git a/util/generic/yexception_ut.h b/util/generic/yexception_ut.h
index 6b5ce34f34..acf6f27e99 100644
--- a/util/generic/yexception_ut.h
+++ b/util/generic/yexception_ut.h
@@ -1,14 +1,14 @@
 #pragma once
- 
-#ifdef __cplusplus 
-extern "C" { 
-#endif 
- 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
     typedef void (*TCallbackFun)(int);
- 
+
     //! just calls callback with parameter @c i
     void TestCallback(TCallbackFun f, int i);
- 
-#ifdef __cplusplus 
-} 
-#endif 
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/util/memory/pool.h b/util/memory/pool.h
index d24b9fdd85..13c8b6b9ed 100644
--- a/util/memory/pool.h
+++ b/util/memory/pool.h
@@ -360,12 +360,12 @@ public:
     using size_type = size_t;
     using difference_type = ptrdiff_t;
     using value_type = T;
- 
+
     inline TPoolAllocBase(TPool* pool)
         : Pool_(pool)
     {
     }
- 
+
     template <typename TOther>
     inline TPoolAllocBase(const TPoolAllocBase<TOther, TPool>& o)
         : Pool_(o.GetPool())
@@ -375,29 +375,29 @@ public:
     inline T* allocate(size_t n) {
         return (T*)Pool_->Allocate(n * sizeof(T), alignof(T));
     }
- 
+
     inline void deallocate(pointer /*p*/, size_t /*n*/) {
     }
- 
+
     template <class T1>
     struct rebind {
         using other = TPoolAllocBase<T1, TPool>;
     };
- 
+
     inline size_type max_size() const noexcept {
         return size_type(-1) / sizeof(T);
     }
- 
+
     template <typename... Args>
     inline void construct(pointer p, Args&&... args) {
         new (p) T(std::forward<Args>(args)...);
     }
- 
+
     inline void destroy(pointer p) noexcept {
         (void)p; /* Make MSVC happy. */
         p->~T();
     }
- 
+
     inline TPool* GetPool() const {
         return Pool_;
     }
@@ -412,20 +412,20 @@ public:
 
 private:
     TPool* Pool_;
-}; 
- 
+};
+
 template <class T>
 using TPoolAlloc = TPoolAllocBase<T, TMemoryPool>;
 
 // Any type since it is supposed to be rebound anyway.
 using TPoolAllocator = TPoolAlloc<int>;
- 
-template <class T> 
+
+template <class T>
 inline bool operator==(const TPoolAlloc<T>&, const TPoolAlloc<T>&) noexcept {
-    return true; 
-} 
- 
-template <class T> 
+    return true;
+}
+
+template <class T>
 inline bool operator!=(const TPoolAlloc<T>&, const TPoolAlloc<T>&) noexcept {
-    return false; 
-} 
+    return false;
+}
diff --git a/util/memory/segpool_alloc.h b/util/memory/segpool_alloc.h
index 016217b6b5..1a83b7a543 100644
--- a/util/memory/segpool_alloc.h
+++ b/util/memory/segpool_alloc.h
@@ -31,7 +31,7 @@
 template <class _Tp>
 struct segpool_alloc {
     using pool_type = segmented_pool<char>;
-    pool_type* pool; 
+    pool_type* pool;
     using pointer = _Tp*;
     using const_pointer = const _Tp*;
     using reference = _Tp&;
@@ -47,11 +47,11 @@ struct segpool_alloc {
     {
         Y_IF_DEBUG(pool_count = malloc_count = pool_free_count = malloc_free_count = 0);
     }
-    segpool_alloc(pool_type* p) 
+    segpool_alloc(pool_type* p)
         : pool(p)
     {
         Y_IF_DEBUG(pool_count = malloc_count = pool_free_count = malloc_free_count = 0);
-    } 
+    }
     segpool_alloc(const segpool_alloc& a)
         : pool(a.pool)
     {
diff --git a/util/str_stl.h b/util/str_stl.h
index 43ee50162a..f1e137181d 100644
--- a/util/str_stl.h
+++ b/util/str_stl.h
@@ -82,8 +82,8 @@ struct THash<TStringBuf>: ::NHashPrivate::TStringHash<char> {
 
 template <>
 struct hash<TString>: ::NHashPrivate::TStringHash<char> {
-}; 
- 
+};
+
 template <>
 struct hash<TUtf16String>: ::NHashPrivate::TStringHash<wchar16> {
 };
diff --git a/util/stream/input.cpp b/util/stream/input.cpp
index 9361be259e..6e8170f2f9 100644
--- a/util/stream/input.cpp
+++ b/util/stream/input.cpp
@@ -97,8 +97,8 @@ size_t IInputStream::ReadLine(TUtf16String& w) {
     }
 
     return result;
-} 
- 
+}
+
 TString IInputStream::ReadLine() {
     TString ret;
 
diff --git a/util/stream/ios_ut.cpp b/util/stream/ios_ut.cpp
index 10f337b3cf..139f4296e5 100644
--- a/util/stream/ios_ut.cpp
+++ b/util/stream/ios_ut.cpp
@@ -7,7 +7,7 @@
 #include <library/cpp/testing/unittest/registar.h>
 
 #include <util/string/cast.h>
-#include <util/memory/tempbuf.h> 
+#include <util/memory/tempbuf.h>
 #include <util/charset/wide.h>
 
 #include <string>
@@ -278,7 +278,7 @@ void TStreamsTest::TestBufferStream() {
     UNIT_ASSERT_EQUAL(0, bytesRead);
 }
 
-namespace { 
+namespace {
     class TStringListInput: public IWalkInput {
     public:
         TStringListInput(const TVector<TString>& data)
@@ -305,27 +305,27 @@ namespace {
     };
 
     const char Text[] =
-        // UTF8 encoded "one \ntwo\r\nthree\n\tfour\nfive\n" in russian and ... 
+        // UTF8 encoded "one \ntwo\r\nthree\n\tfour\nfive\n" in russian and ...
         "один \n"
         "два\r\n"
         "три\n"
         "\tчетыре\n"
         "пять\n"
-        // ... additional test cases 
+        // ... additional test cases
         "\r\n"
         "\n\r" // this char goes to the front of the next string
         "one two\n"
         "123\r\n"
         "\t\r ";
- 
+
     const char* Expected[] = {
-        // UTF8 encoded "one ", "two", "three", "\tfour", "five" in russian and ... 
+        // UTF8 encoded "one ", "two", "three", "\tfour", "five" in russian and ...
         "один ",
         "два",
         "три",
         "\tчетыре",
         "пять",
-        // ... additional test cases 
+        // ... additional test cases
         "",
         "",
         "\rone two",
@@ -394,8 +394,8 @@ namespace {
         TStringListInput sli(lst);
         test(sli, "IWalkInput");
     }
-} 
- 
+}
+
 void TStreamsTest::TestReadTo() {
     TestStreamReadTo("111a222b333c444d555e666f", TestStreamReadTo1);
     TestStreamReadTo(Text, TestStreamReadTo2);
@@ -415,41 +415,41 @@ void TStreamsTest::TestStrokaInput() {
     TestStreamReadTo(s, ::TestStrokaInput);
 }
 
-void TStreamsTest::TestWtrokaInput() { 
+void TStreamsTest::TestWtrokaInput() {
     const TString s(Text);
-    TStringInput is(s); 
+    TStringInput is(s);
     TUtf16String w;
     size_t i = 0;
- 
-    while (is.ReadLine(w)) { 
+
+    while (is.ReadLine(w)) {
         UNIT_ASSERT(i < Y_ARRAY_SIZE(Expected));
         UNIT_ASSERT_VALUES_EQUAL(w, UTF8ToWide(Expected[i]));
- 
-        ++i; 
-    } 
-} 
- 
-void TStreamsTest::TestWtrokaOutput() { 
+
+        ++i;
+    }
+}
+
+void TStreamsTest::TestWtrokaOutput() {
     TString s;
-    TStringOutput os(s); 
-    const size_t n = sizeof(Expected) / sizeof(Expected[0]); 
- 
-    for (size_t i = 0; i < n; ++i) { 
+    TStringOutput os(s);
+    const size_t n = sizeof(Expected) / sizeof(Expected[0]);
+
+    for (size_t i = 0; i < n; ++i) {
         TUtf16String w = UTF8ToWide(Expected[i]);
- 
-        os << w; 
+
+        os << w;
 
         if (i == 1 || i == 5 || i == 8) {
-            os << '\r'; 
+            os << '\r';
         }
 
         if (i < n - 1) {
-            os << '\n'; 
+            os << '\n';
         }
-    } 
- 
-    UNIT_ASSERT(s == Text); 
-} 
+    }
+
+    UNIT_ASSERT(s == Text);
+}
 
 void TStreamsTest::TestWchar16Output() {
     TString s;
diff --git a/util/stream/output.cpp b/util/stream/output.cpp
index 195e4cfdb2..db81b81b70 100644
--- a/util/stream/output.cpp
+++ b/util/stream/output.cpp
@@ -136,8 +136,8 @@ void Out<const wchar16*>(IOutputStream& o, const wchar16* w) {
     } else {
         o.Write("(null)");
     }
-} 
- 
+}
+
 template <>
 void Out<const wchar32*>(IOutputStream& o, const wchar32* w) {
     if (w) {
diff --git a/util/stream/output.h b/util/stream/output.h
index 8190c09707..00eef50b95 100644
--- a/util/stream/output.h
+++ b/util/stream/output.h
@@ -240,15 +240,15 @@ static inline std::enable_if_t<!std::is_scalar<T>::value, IOutputStream&> operat
 }
 
 static inline IOutputStream& operator<<(IOutputStream& o, const wchar16* t) {
-    Out<const wchar16*>(o, t); 
-    return o; 
-} 
- 
+    Out<const wchar16*>(o, t);
+    return o;
+}
+
 static inline IOutputStream& operator<<(IOutputStream& o, wchar16* t) {
-    Out<const wchar16*>(o, t); 
-    return o; 
-} 
- 
+    Out<const wchar16*>(o, t);
+    return o;
+}
+
 static inline IOutputStream& operator<<(IOutputStream& o, const wchar32* t) {
     Out<const wchar32*>(o, t);
     return o;
diff --git a/util/stream/zlib.cpp b/util/stream/zlib.cpp
index 4dbef9839e..60f4e9439f 100644
--- a/util/stream/zlib.cpp
+++ b/util/stream/zlib.cpp
@@ -204,7 +204,7 @@ public:
     inline TImpl(const TParams& p)
         : Stream_(p.Out)
     {
-        if (deflateInit2(Z(), Min<size_t>(9, p.CompressionLevel), Z_DEFLATED, opts[Type(p.Type)], 8, Z_DEFAULT_STRATEGY)) { 
+        if (deflateInit2(Z(), Min<size_t>(9, p.CompressionLevel), Z_DEFLATED, opts[Type(p.Type)], 8, Z_DEFAULT_STRATEGY)) {
             ythrow TZLibCompressorError() << "can not init inflate engine";
         }
 
diff --git a/util/string/cast.cpp b/util/string/cast.cpp
index 077c6765b3..aa1e65a8e9 100644
--- a/util/string/cast.cpp
+++ b/util/string/cast.cpp
@@ -521,7 +521,7 @@ TString FromStringImpl<TString>(const char* data, size_t len) {
     return TString(data, len);
 }
 
-template <> 
+template <>
 TStringBuf FromStringImpl<TStringBuf>(const char* data, size_t len) {
     return TStringBuf(data, len);
 }
@@ -534,8 +534,8 @@ std::string FromStringImpl<std::string>(const char* data, size_t len) {
 template <>
 TUtf16String FromStringImpl<TUtf16String>(const wchar16* data, size_t len) {
     return TUtf16String(data, len);
-} 
- 
+}
+
 template <>
 TWtringBuf FromStringImpl<TWtringBuf>(const wchar16* data, size_t len) {
     return TWtringBuf(data, len);
diff --git a/util/string/cast.h b/util/string/cast.h
index 9bf6ddc7f6..90e925c194 100644
--- a/util/string/cast.h
+++ b/util/string/cast.h
@@ -137,16 +137,16 @@ struct TFromStringException: public TBadCastException {
  *  double
  *  long double
  */
-template <typename T, typename TChar> 
-T FromStringImpl(const TChar* data, size_t len); 
+template <typename T, typename TChar>
+T FromStringImpl(const TChar* data, size_t len);
 
-template <typename T, typename TChar> 
-inline T FromString(const TChar* data, size_t len) { 
+template <typename T, typename TChar>
+inline T FromString(const TChar* data, size_t len) {
     return ::FromStringImpl<T>(data, len);
 }
 
-template <typename T, typename TChar> 
-inline T FromString(const TChar* data) { 
+template <typename T, typename TChar>
+inline T FromString(const TChar* data) {
     return ::FromString<T>(data, std::char_traits<TChar>::length(data));
 }
 
@@ -170,7 +170,7 @@ inline TString FromString<TString>(const TString& s) {
     return s;
 }
 
-template <class T> 
+template <class T>
 inline T FromString(const TWtringBuf& s) {
     return ::FromString<T, typename TWtringBuf::char_type>(s.data(), s.size());
 }
@@ -178,8 +178,8 @@ inline T FromString(const TWtringBuf& s) {
 template <class T>
 inline T FromString(const TUtf16String& s) {
     return ::FromString<T, wchar16>(s.data(), s.size());
-} 
- 
+}
+
 namespace NPrivate {
     template <typename TChar>
     class TFromString {