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

46 files changed, 518 insertions, 518 deletions

diff --git a/util/charset/unidata.h b/util/charset/unidata.h
index 1be76c56f3..400d314186 100644
--- a/util/charset/unidata.h
+++ b/util/charset/unidata.h
@@ -301,7 +301,7 @@ inline wchar32 ToTitle(wchar32 ch) {
 
 inline int ToDigit(wchar32 ch) {
     ui32 i = NUnicode::NPrivate::CharInfo(ch);
-    return (i & IS_DIGIT) ? static_cast<int>(i >> SVAL_OFFSET) : -1; 
+    return (i & IS_DIGIT) ? static_cast<int>(i >> SVAL_OFFSET) : -1;
 }
 
 // BIDI properties
diff --git a/util/datetime/base_ut.cpp b/util/datetime/base_ut.cpp
index 4a41884b98..afc3f802eb 100644
--- a/util/datetime/base_ut.cpp
+++ b/util/datetime/base_ut.cpp
@@ -2,8 +2,8 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-#include <util/generic/utility.h> 
-#include <util/generic/ylimits.h> 
+#include <util/generic/utility.h>
+#include <util/generic/ylimits.h>
 #include <util/generic/ymath.h>
 #include <util/string/cast.h>
 #include <util/stream/output.h>
diff --git a/util/datetime/systime.cpp b/util/datetime/systime.cpp
index a17b50f510..6ee7e8fc6e 100644
--- a/util/datetime/systime.cpp
+++ b/util/datetime/systime.cpp
@@ -90,7 +90,7 @@ struct tm* GmTimeR(const time_t* timer, struct tm* tmbuf) {
         {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
         {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
 
-    i64 time = static_cast<i64>(*timer); 
+    i64 time = static_cast<i64>(*timer);
 
     ui64 dayclock, dayno;
     int year = EPOCH_YR;
diff --git a/util/digest/multi_ut.cpp b/util/digest/multi_ut.cpp
index bb6ea14bb5..dff64ff0cc 100644
--- a/util/digest/multi_ut.cpp
+++ b/util/digest/multi_ut.cpp
@@ -14,11 +14,11 @@ class TMultiHashTest: public TTestBase {
 
 private:
     inline void TestStrInt() {
-        UNIT_ASSERT_EQUAL(MultiHash(TString("1234567"), static_cast<int>(123)), static_cast<size_t>(ULL(17038203285960021630))); 
+        UNIT_ASSERT_EQUAL(MultiHash(TString("1234567"), static_cast<int>(123)), static_cast<size_t>(ULL(17038203285960021630)));
     }
 
     inline void TestIntStr() {
-        UNIT_ASSERT_EQUAL(MultiHash(static_cast<int>(123), TString("1234567")), static_cast<size_t>(ULL(9973288649881090712))); 
+        UNIT_ASSERT_EQUAL(MultiHash(static_cast<int>(123), TString("1234567")), static_cast<size_t>(ULL(9973288649881090712)));
     }
 
     inline void TestSimpleCollision() {
diff --git a/util/digest/sequence_ut.cpp b/util/digest/sequence_ut.cpp
index b12f72df9c..87d6102ee5 100644
--- a/util/digest/sequence_ut.cpp
+++ b/util/digest/sequence_ut.cpp
@@ -15,12 +15,12 @@ class TRangeHashTest: public TTestBase {
 
 private:
     inline void TestStrokaInt() {
-        const size_t canonicalHash = static_cast<size_t>(ULL(12727184940294366172)); 
+        const size_t canonicalHash = static_cast<size_t>(ULL(12727184940294366172));
         UNIT_ASSERT_EQUAL(canonicalHash, TRangeHash<>()(TString("12345")));
     }
 
     inline void TestIntVector() {
-        const size_t canonicalHash = static_cast<size_t>(ULL(1351128487744230578)); 
+        const size_t canonicalHash = static_cast<size_t>(ULL(1351128487744230578));
         TVector<int> testVec = {1, 2, 4, 3};
         UNIT_ASSERT_EQUAL(canonicalHash, TRangeHash<>()(testVec));
     }
@@ -52,7 +52,7 @@ class TSequenceHashTest: public TTestBase {
 private:
     inline void TestSimpleBuffer() {
         int arr[] = {1, 2, 3};
-        const size_t canonicalHash = static_cast<size_t>(ULL(3903918011533391876)); 
+        const size_t canonicalHash = static_cast<size_t>(ULL(3903918011533391876));
         TContiguousHash<TSimpleRangeHash> hasher;
         UNIT_ASSERT_EQUAL(canonicalHash, hasher(TArrayRef<int>(arr, arr + 3)));
     }
diff --git a/util/folder/dirut.cpp b/util/folder/dirut.cpp
index 690c980c8b..ffc9b09f96 100644
--- a/util/folder/dirut.cpp
+++ b/util/folder/dirut.cpp
@@ -425,17 +425,17 @@ TString RealLocation(const TString& path) {
 
 int MakeTempDir(char path[/*FILENAME_MAX*/], const char* prefix) {
     int ret;
- 
+
     TString sysTmp;
- 
+
 #ifdef _win32_
-    if (!prefix || *prefix == '/') { 
+    if (!prefix || *prefix == '/') {
 #else
-    if (!prefix) { 
+    if (!prefix) {
 #endif
-        sysTmp = GetSystemTempDir(); 
+        sysTmp = GetSystemTempDir();
         prefix = sysTmp.data();
-    } 
+    }
 
     if ((ret = ResolvePath(prefix, nullptr, path, 1)) != 0)
         return ret;
@@ -507,19 +507,19 @@ const char* GetFileNameComponent(const char* f) {
 
 TString GetSystemTempDir() {
 #ifdef _win_
-    char buffer[1024]; 
-    DWORD size = GetTempPath(1024, buffer); 
-    if (!size) { 
-        ythrow TSystemError() << "failed to get system temporary directory"; 
-    } 
+    char buffer[1024];
+    DWORD size = GetTempPath(1024, buffer);
+    if (!size) {
+        ythrow TSystemError() << "failed to get system temporary directory";
+    }
     return TString(buffer, size);
 #else
     const char* var = "TMPDIR";
     const char* def = "/tmp";
     const char* r = getenv(var);
     const char* result = r ? r : def;
-    return result[0] == '/' ? result : ResolveDir(result); 
-#endif 
+    return result[0] == '/' ? result : ResolveDir(result);
+#endif
 }
 
 TString ResolveDir(const char* path) {
diff --git a/util/folder/filelist.cpp b/util/folder/filelist.cpp
index 5345317556..b21fcdbf20 100644
--- a/util/folder/filelist.cpp
+++ b/util/folder/filelist.cpp
@@ -33,7 +33,7 @@ void TFileEntitiesList::Fill(const TString& dirname, TStringBuf prefix, TStringB
         if (((Mask & EM_FILES) && file->fts_info == FTS_F) || ((Mask & EM_DIRS) && file->fts_info == FTS_D) || ((Mask & EM_SLINKS) && file->fts_info == FTS_SL)) {
             ++FileNamesSize;
             FileNames.Append(filename.data(), filename.size() + 1);
-        } 
+        }
     }
 
     Restart();
diff --git a/util/folder/tempdir.cpp b/util/folder/tempdir.cpp
index e72b2a4fb0..6fdf8f753c 100644
--- a/util/folder/tempdir.cpp
+++ b/util/folder/tempdir.cpp
@@ -1,7 +1,7 @@
 #include "tempdir.h"
- 
+
 #include "dirut.h"
- 
+
 #include <util/system/fs.h>
 #include <util/system/maxlen.h>
 
@@ -12,7 +12,7 @@ TTempDir::TTempDir()
 
 TTempDir::TTempDir(const char* prefix, TCreationToken)
     : TempDir()
-    , Remove(true) 
+    , Remove(true)
 {
     char tempDir[MAX_PATH];
     if (MakeTempDir(tempDir, prefix) != 0) {
@@ -23,7 +23,7 @@ TTempDir::TTempDir(const char* prefix, TCreationToken)
 
 TTempDir::TTempDir(const TString& tempDir)
     : TempDir(tempDir)
-    , Remove(true) 
+    , Remove(true)
 {
     NFs::Remove(TempDir);
     MakeDirIfNotExist(TempDir.c_str());
@@ -33,12 +33,12 @@ TTempDir TTempDir::NewTempDir(const TString& root) {
     return {root.c_str(), TCreationToken{}};
 }
 
-void TTempDir::DoNotRemove() { 
-    Remove = false; 
-} 
- 
+void TTempDir::DoNotRemove() {
+    Remove = false;
+}
+
 TTempDir::~TTempDir() {
-    if (Remove) { 
-        RemoveDirWithContents(TempDir); 
-    } 
+    if (Remove) {
+        RemoveDirWithContents(TempDir);
+    }
 }
diff --git a/util/folder/tempdir.h b/util/folder/tempdir.h
index 8fed58245d..ff458f83b9 100644
--- a/util/folder/tempdir.h
+++ b/util/folder/tempdir.h
@@ -29,8 +29,8 @@ public:
         return TempDir;
     }
 
-    void DoNotRemove(); 
- 
+    void DoNotRemove();
+
 private:
     struct TCreationToken {};
 
@@ -39,5 +39,5 @@ private:
     TTempDir(const char* prefix, TCreationToken);
 
     TFsPath TempDir;
-    bool Remove; 
+    bool Remove;
 };
diff --git a/util/generic/cast.h b/util/generic/cast.h
index 6d273a9e43..0d4a41f385 100644
--- a/util/generic/cast.h
+++ b/util/generic/cast.h
@@ -124,7 +124,7 @@ inline std::enable_if_t<!::NPrivate::TSafelyConvertible<TSmall, TLarge>::Result,
         }
     }
 
-    TSmallInt smallInt = TSmallInt(largeInt); 
+    TSmallInt smallInt = TSmallInt(largeInt);
 
     if (std::is_signed<TSmallInt>::value && std::is_unsigned<TLargeInt>::value) {
         if (IsNegative(smallInt)) {
@@ -134,7 +134,7 @@ inline std::enable_if_t<!::NPrivate::TSafelyConvertible<TSmall, TLarge>::Result,
         }
     }
 
-    if (TLargeInt(smallInt) != largeInt) { 
+    if (TLargeInt(smallInt) != largeInt) {
         ythrow TBadCastException() << "Conversion '" << TypeName<TLarge>() << '{' << TLargeInt(largeInt) << "}' to '"
                                    << TypeName<TSmallInt>() << "', loss of data";
     }
diff --git a/util/generic/hash.h b/util/generic/hash.h
index 0a396f9b9e..e46db21fa9 100644
--- a/util/generic/hash.h
+++ b/util/generic/hash.h
@@ -494,7 +494,7 @@ private:
 
     /* This method is templated to postpone instantiation of key extraction functor. */
     template <class ValueL>
-    auto get_key(const ValueL& value) const -> decltype(ExtractKey()(value)) { 
+    auto get_key(const ValueL& value) const -> decltype(ExtractKey()(value)) {
         return this->_get_key_extract()(value);
     }
 
diff --git a/util/generic/hash_primes.h b/util/generic/hash_primes.h
index 15ffc3e484..4dc2da0b8f 100644
--- a/util/generic/hash_primes.h
+++ b/util/generic/hash_primes.h
@@ -24,7 +24,7 @@ namespace NPrivate {
     /// @see https://gmplib.org/~tege/divcnst-pldi94.pdf
     template <typename TDivisor, typename TDividend, typename MulUnsignedUpper>
     class TReciprocalDivisor {
-        static_assert(sizeof(TDivisor) <= sizeof(TDividend), "TDivisor and TDividend should have the same size"); 
+        static_assert(sizeof(TDivisor) <= sizeof(TDividend), "TDivisor and TDividend should have the same size");
 
     public:
         constexpr TReciprocalDivisor() noexcept = default;
diff --git a/util/generic/hide_ptr.cpp b/util/generic/hide_ptr.cpp
index 58837b6d90..74eac028aa 100644
--- a/util/generic/hide_ptr.cpp
+++ b/util/generic/hide_ptr.cpp
@@ -1,5 +1,5 @@
-#include "hide_ptr.h" 
- 
-void* HidePointerOrigin(void* ptr) { 
-    return ptr; 
-} 
+#include "hide_ptr.h"
+
+void* HidePointerOrigin(void* ptr) {
+    return ptr;
+}
diff --git a/util/generic/hide_ptr.h b/util/generic/hide_ptr.h
index ea415c46aa..c734894bd7 100644
--- a/util/generic/hide_ptr.h
+++ b/util/generic/hide_ptr.h
@@ -1,3 +1,3 @@
-#pragma once 
- 
-void* HidePointerOrigin(void*); 
+#pragma once
+
+void* HidePointerOrigin(void*);
diff --git a/util/generic/maybe.h b/util/generic/maybe.h
index f250a893f9..34d21aebcd 100644
--- a/util/generic/maybe.h
+++ b/util/generic/maybe.h
@@ -50,107 +50,107 @@ private:
                   "Instantiation of TMaybe with non-destructible type is ill-formed");
 
     template <class U>
-    struct TConstructibleFromMaybeSomehow { 
-    public: 
-        static constexpr bool value = std::is_constructible<T, TMaybe<U, Policy>&>::value || 
-                                      std::is_constructible<T, const TMaybe<U, Policy>&>::value || 
-                                      std::is_constructible<T, TMaybe<U, Policy>&&>::value || 
-                                      std::is_constructible<T, const TMaybe<U, Policy>&&>::value || 
-                                      std::is_convertible<TMaybe<U, Policy>&, T>::value || 
-                                      std::is_convertible<const TMaybe<U, Policy>&, T>::value || 
-                                      std::is_convertible<TMaybe<U, Policy>&&, T>::value || 
-                                      std::is_convertible<const TMaybe<U, Policy>&&, T>::value; 
-    }; 
+    struct TConstructibleFromMaybeSomehow {
+    public:
+        static constexpr bool value = std::is_constructible<T, TMaybe<U, Policy>&>::value ||
+                                      std::is_constructible<T, const TMaybe<U, Policy>&>::value ||
+                                      std::is_constructible<T, TMaybe<U, Policy>&&>::value ||
+                                      std::is_constructible<T, const TMaybe<U, Policy>&&>::value ||
+                                      std::is_convertible<TMaybe<U, Policy>&, T>::value ||
+                                      std::is_convertible<const TMaybe<U, Policy>&, T>::value ||
+                                      std::is_convertible<TMaybe<U, Policy>&&, T>::value ||
+                                      std::is_convertible<const TMaybe<U, Policy>&&, T>::value;
+    };
 
     template <class U>
-    struct TAssignableFromMaybeSomehow { 
-    public: 
-        static constexpr bool value = TConstructibleFromMaybeSomehow<U>::value || 
-                                      std::is_assignable<T&, TMaybe<U, Policy>&>::value || 
-                                      std::is_assignable<T&, const TMaybe<U, Policy>&>::value || 
-                                      std::is_assignable<T&, TMaybe<U, Policy>&&>::value || 
-                                      std::is_assignable<T&, const TMaybe<U, Policy>&&>::value; 
-    }; 
+    struct TAssignableFromMaybeSomehow {
+    public:
+        static constexpr bool value = TConstructibleFromMaybeSomehow<U>::value ||
+                                      std::is_assignable<T&, TMaybe<U, Policy>&>::value ||
+                                      std::is_assignable<T&, const TMaybe<U, Policy>&>::value ||
+                                      std::is_assignable<T&, TMaybe<U, Policy>&&>::value ||
+                                      std::is_assignable<T&, const TMaybe<U, Policy>&&>::value;
+    };
 
     template <class U>
-    struct TImplicitCopyCtor { 
-    public: 
-        static constexpr bool value = std::is_constructible<T, const U&>::value && 
-                                      std::is_convertible<const U&, T>::value && 
-                                      !TConstructibleFromMaybeSomehow<U>::value; 
-    }; 
+    struct TImplicitCopyCtor {
+    public:
+        static constexpr bool value = std::is_constructible<T, const U&>::value &&
+                                      std::is_convertible<const U&, T>::value &&
+                                      !TConstructibleFromMaybeSomehow<U>::value;
+    };
 
     template <class U>
-    struct TExplicitCopyCtor { 
-    public: 
-        static constexpr bool value = std::is_constructible<T, const U&>::value && 
-                                      !std::is_convertible<const U&, T>::value && 
-                                      !TConstructibleFromMaybeSomehow<U>::value; 
-    }; 
+    struct TExplicitCopyCtor {
+    public:
+        static constexpr bool value = std::is_constructible<T, const U&>::value &&
+                                      !std::is_convertible<const U&, T>::value &&
+                                      !TConstructibleFromMaybeSomehow<U>::value;
+    };
 
     template <class U>
-    struct TImplicitMoveCtor { 
-    public: 
-        static constexpr bool value = std::is_constructible<T, U&&>::value && 
-                                      std::is_convertible<U&&, T>::value && 
-                                      !TConstructibleFromMaybeSomehow<U>::value; 
-    }; 
+    struct TImplicitMoveCtor {
+    public:
+        static constexpr bool value = std::is_constructible<T, U&&>::value &&
+                                      std::is_convertible<U&&, T>::value &&
+                                      !TConstructibleFromMaybeSomehow<U>::value;
+    };
 
     template <class U>
-    struct TExplicitMoveCtor { 
-    public: 
-        static constexpr bool value = std::is_constructible<T, U&&>::value && 
-                                      !std::is_convertible<U&&, T>::value && 
-                                      !TConstructibleFromMaybeSomehow<U>::value; 
-    }; 
+    struct TExplicitMoveCtor {
+    public:
+        static constexpr bool value = std::is_constructible<T, U&&>::value &&
+                                      !std::is_convertible<U&&, T>::value &&
+                                      !TConstructibleFromMaybeSomehow<U>::value;
+    };
 
     template <class U>
-    struct TCopyAssignable { 
-    public: 
-        static constexpr bool value = std::is_constructible<T, const U&>::value && 
-                                      std::is_assignable<T&, const U&>::value && 
-                                      !TAssignableFromMaybeSomehow<U>::value; 
-    }; 
+    struct TCopyAssignable {
+    public:
+        static constexpr bool value = std::is_constructible<T, const U&>::value &&
+                                      std::is_assignable<T&, const U&>::value &&
+                                      !TAssignableFromMaybeSomehow<U>::value;
+    };
 
     template <class U>
-    struct TMoveAssignable { 
-    public: 
+    struct TMoveAssignable {
+    public:
         static constexpr bool value = std::is_constructible<T, U&&>::value &&
                                       std::is_assignable<T&, U&&>::value &&
                                       !TAssignableFromMaybeSomehow<U>::value;
-    }; 
+    };
 
-    template <class U> 
-    struct TImplicitAnyCtor { 
-    public: 
-        using UDec = std::decay_t<U>; 
+    template <class U>
+    struct TImplicitAnyCtor {
+    public:
+        using UDec = std::decay_t<U>;
+
+        static constexpr bool value = std::is_constructible<T, U>::value &&
+                                      std::is_convertible<U, T>::value &&
+                                      !std::is_same<UDec, TInPlace>::value &&
+                                      !std::is_same<UDec, TMaybe>::value;
+    };
 
-        static constexpr bool value = std::is_constructible<T, U>::value && 
-                                      std::is_convertible<U, T>::value && 
-                                      !std::is_same<UDec, TInPlace>::value && 
-                                      !std::is_same<UDec, TMaybe>::value; 
-    }; 
+    template <class U>
+    struct TExplicitAnyCtor {
+    public:
+        using UDec = std::decay_t<U>;
+        static constexpr bool value = std::is_constructible<T, U>::value &&
+                                      !std::is_convertible<U, T>::value &&
+                                      !std::is_same<UDec, TInPlace>::value &&
+                                      !std::is_same<UDec, TMaybe>::value;
+    };
 
     template <class U>
-    struct TExplicitAnyCtor { 
-    public: 
-        using UDec = std::decay_t<U>; 
-        static constexpr bool value = std::is_constructible<T, U>::value && 
-                                      !std::is_convertible<U, T>::value && 
-                                      !std::is_same<UDec, TInPlace>::value && 
-                                      !std::is_same<UDec, TMaybe>::value; 
-    }; 
-
-    template <class U> 
-    struct TAssignableFromAny { 
-    public: 
-        using UDec = std::decay_t<U>; 
-        static constexpr bool value = !std::is_same<UDec, TMaybe>::value && 
-                                      std::is_constructible<T, U>::value && 
-                                      std::is_assignable<T&, U>::value && 
-                                      (!std::is_scalar<T>::value || !std::is_same<UDec, T>::value); 
-    }; 
- 
+    struct TAssignableFromAny {
+    public:
+        using UDec = std::decay_t<U>;
+        static constexpr bool value = !std::is_same<UDec, TMaybe>::value &&
+                                      std::is_constructible<T, U>::value &&
+                                      std::is_assignable<T&, U>::value &&
+                                      (!std::is_scalar<T>::value || !std::is_same<UDec, T>::value);
+    };
+
     using TBase = TMaybeBase<T>;
 
 public:
diff --git a/util/generic/ptr.h b/util/generic/ptr.h
index 27b72cafdd..19db0e3ec5 100644
--- a/util/generic/ptr.h
+++ b/util/generic/ptr.h
@@ -303,7 +303,7 @@ public:
         DoSwap(T_, r.T_);
     }
 
-    inline T* Get() const noexcept { 
+    inline T* Get() const noexcept {
         return T_;
     }
 
diff --git a/util/generic/strbase.h b/util/generic/strbase.h
index 846db66785..ab39fc7537 100644
--- a/util/generic/strbase.h
+++ b/util/generic/strbase.h
@@ -523,7 +523,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);
     }
diff --git a/util/generic/string.h b/util/generic/string.h
index ae2f213dbd..8cd8aa6917 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -119,13 +119,13 @@ public:
     }
 
     TChar* operator&() {
-        return S_.begin() + Pos_; 
-    } 
- 
+        return S_.begin() + Pos_;
+    }
+
     const TChar* operator&() const {
-        return S_.cbegin() + Pos_; 
-    } 
- 
+        return S_.cbegin() + Pos_;
+    }
+
     TBasicCharRef& operator=(TChar c) {
         Y_ASSERT(Pos_ < S_.size() || (Pos_ == S_.size() && !c));
 
@@ -1215,15 +1215,15 @@ TBasicString<TCharType> to_title(const TBasicString<TCharType, TTraits>& s) {
     return ret;
 }
 
-namespace std { 
+namespace std {
     template <>
-    struct hash<TString> { 
-        using argument_type = TString; 
-        using result_type = size_t; 
-        inline result_type operator()(argument_type const& s) const noexcept { 
+    struct hash<TString> {
+        using argument_type = TString;
+        using result_type = size_t;
+        inline result_type operator()(argument_type const& s) const noexcept {
             return NHashPrivate::ComputeStringHash(s.data(), s.size());
-        } 
-    }; 
+        }
+    };
 }
 
 #undef Y_NOEXCEPT
diff --git a/util/generic/string_ut.cpp b/util/generic/string_ut.cpp
index 7e255c687a..ac82e9091d 100644
--- a/util/generic/string_ut.cpp
+++ b/util/generic/string_ut.cpp
@@ -584,16 +584,16 @@ protected:
     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);
         UNIT_ASSERT(s.find_last_of(TStringType(Data_.abcde())) == 26);
- 
+
         TStringType test(Data_.aba());
- 
+
         UNIT_ASSERT(test.find_last_of(Data_.a(), 2, 1) == 2);
         UNIT_ASSERT(test.find_last_of(Data_.a(), 1, 1) == 0);
         UNIT_ASSERT(test.find_last_of(Data_.a(), 0, 1) == 0);
- 
+
         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);
diff --git a/util/generic/typetraits.h b/util/generic/typetraits.h
index bd67c874c8..d165bd1a06 100644
--- a/util/generic/typetraits.h
+++ b/util/generic/typetraits.h
@@ -48,8 +48,8 @@ namespace NPrivate {
     }
 }
 
-#if _LIBCPP_STD_VER >= 17 && !defined(_MSC_VER) 
-// Disable std::conjunction for MSVC by analogy with std::disjunction. 
+#if _LIBCPP_STD_VER >= 17 && !defined(_MSC_VER)
+// Disable std::conjunction for MSVC by analogy with std::disjunction.
 template <class... Bs>
 using TConjunction = std::conjunction<Bs...>;
 #else
@@ -57,10 +57,10 @@ template <class... Bs>
 struct TConjunction: ::TBoolConstant<::NPrivate::ConjunctionImpl<Bs...>()> {};
 #endif
 
-#if _LIBCPP_STD_VER >= 17 && !defined(_MSC_VER) 
-// Disable std::disjunction for MSVC. 
-// It reduces build time (500 -> 20 seconds) and memory consumption (20 GB -> less than 1 GB) 
-// for some files (notably search/dssm_boosting/dssm_boosting_calcer.cpp). 
+#if _LIBCPP_STD_VER >= 17 && !defined(_MSC_VER)
+// Disable std::disjunction for MSVC.
+// It reduces build time (500 -> 20 seconds) and memory consumption (20 GB -> less than 1 GB)
+// for some files (notably search/dssm_boosting/dssm_boosting_calcer.cpp).
 template <class... Bs>
 using TDisjunction = std::disjunction<Bs...>;
 #else
diff --git a/util/generic/typetraits_ut.cpp b/util/generic/typetraits_ut.cpp
index f021f9e0b0..e7571c75ec 100644
--- a/util/generic/typetraits_ut.cpp
+++ b/util/generic/typetraits_ut.cpp
@@ -60,7 +60,7 @@ namespace {
     class TNonStdLayoutClass2 {
     public:
         virtual void Func() {
-        } 
+        }
     };
 
     class TNonStdLayoutClass3: public TNonStdLayoutClass2 {
diff --git a/util/generic/vector_ut.cpp b/util/generic/vector_ut.cpp
index 359bbcceb2..0f6b4037a0 100644
--- a/util/generic/vector_ut.cpp
+++ b/util/generic/vector_ut.cpp
@@ -27,7 +27,7 @@ class TYVectorTest: public TTestBase {
     UNIT_TEST(TestShrink)
     //UNIT_TEST(TestEbo)
     UNIT_TEST(TestFillInConstructor)
-    UNIT_TEST(TestYResize) 
+    UNIT_TEST(TestYResize)
     UNIT_TEST(TestCrop)
     UNIT_TEST(TestInitializeList)
     UNIT_TEST_SUITE_END();
@@ -470,45 +470,45 @@ private:
             }
         }
     }
- 
-    struct TPod { 
-        int x; 
+
+    struct TPod {
+        int x;
 
         operator int() {
             return x;
         }
-    }; 
- 
-    struct TNonPod { 
-        int x; 
-        TNonPod() { 
-            x = 0; 
-        } 
+    };
+
+    struct TNonPod {
+        int x;
+        TNonPod() {
+            x = 0;
+        }
 
         operator int() {
             return x;
         }
-    }; 
- 
+    };
+
     template <typename T>
     class TDebugAlloc: public std::allocator<T> {
-    public: 
-        using TBase = std::allocator<T>; 
- 
+    public:
+        using TBase = std::allocator<T>;
+
         T* allocate(typename TBase::size_type n) {
             auto p = TBase::allocate(n);
-            for (size_t i = 0; i < n; ++i) { 
-                memset(p + i, 0xab, sizeof(T)); 
-            } 
-            return p; 
-        } 
- 
+            for (size_t i = 0; i < n; ++i) {
+                memset(p + i, 0xab, sizeof(T));
+            }
+            return p;
+        }
+
         template <class TOther>
-        struct rebind { 
+        struct rebind {
             using other = TDebugAlloc<TOther>;
-        }; 
-    }; 
- 
+        };
+    };
+
     template <typename T>
     void TestYResize() {
 #ifdef _YNDX_LIBCXX_ENABLE_VECTOR_POD_RESIZE_UNINITIALIZED
@@ -518,23 +518,23 @@ private:
 #endif
 
         TVector<T, TDebugAlloc<T>> v;
- 
-        v.reserve(5); 
+
+        v.reserve(5);
         auto firstBegin = v.begin();
- 
+
         v.yresize(5); // No realloc, no initialization if allowed
-        UNIT_ASSERT(firstBegin == v.begin()); 
-        for (int i = 0; i < 5; ++i) { 
+        UNIT_ASSERT(firstBegin == v.begin());
+        for (int i = 0; i < 5; ++i) {
             UNIT_ASSERT_VALUES_EQUAL(bool(v[i]), ALLOW_UNINITIALIZED);
-        } 
- 
+        }
+
         v.yresize(20); // Realloc, still no initialization
-        UNIT_ASSERT(firstBegin != v.begin()); 
-        for (int i = 0; i < 20; ++i) { 
+        UNIT_ASSERT(firstBegin != v.begin());
+        for (int i = 0; i < 20; ++i) {
             UNIT_ASSERT_VALUES_EQUAL(bool(v[i]), ALLOW_UNINITIALIZED);
-        } 
-    } 
- 
+        }
+    }
+
     struct TNoDefaultConstructor {
         TNoDefaultConstructor() = delete;
         explicit TNoDefaultConstructor(int val)
@@ -558,11 +558,11 @@ private:
         UNIT_ASSERT(vec[0].Val == 42);
     }
 
-    void TestYResize() { 
+    void TestYResize() {
         TestYResize<int>();
         TestYResize<TPod>();
         TestYResize<TNonPod>();
-    } 
+    }
 
     void CheckInitializeList(const TVector<int>& v) {
         for (size_t i = 0; i < v.size(); ++i) {
diff --git a/util/generic/ymath.h b/util/generic/ymath.h
index 745d1c03a9..9ff9ae2abe 100644
--- a/util/generic/ymath.h
+++ b/util/generic/ymath.h
@@ -84,7 +84,7 @@ static inline bool IsNan(double f) {
 #if defined(_win_)
     return _isnan(f) != 0;
 #else
-    return std::isnan(f); 
+    return std::isnan(f);
 #endif
 }
 
diff --git a/util/memory/segpool_alloc.h b/util/memory/segpool_alloc.h
index 0723629921..1a83b7a543 100644
--- a/util/memory/segpool_alloc.h
+++ b/util/memory/segpool_alloc.h
@@ -84,7 +84,7 @@ struct segpool_alloc {
     }
     ~segpool_alloc() {
         //assert(pool_count == pool_free_count && malloc_count == malloc_free_count); <- uncomment when swap() problem is solved
-        //printf("in ~segpool_alloc: size = %u, pool_count = %" PRId64 ", malloc_count = %" PRId64 ", pool_free_count = %" PRId64 ", malloc_free_count = %" PRId64 "\n", 
+        //printf("in ~segpool_alloc: size = %u, pool_count = %" PRId64 ", malloc_count = %" PRId64 ", pool_free_count = %" PRId64 ", malloc_free_count = %" PRId64 "\n",
         //        sizeof(_Tp), pool_count, malloc_count, pool_free_count, malloc_free_count);
         //fflush(stdout);
     }
diff --git a/util/network/socket.cpp b/util/network/socket.cpp
index c8e500eb05..4f6e804346 100644
--- a/util/network/socket.cpp
+++ b/util/network/socket.cpp
@@ -74,101 +74,101 @@ const char* inet_ntop(int af, const void* src, char* dst, socklen_t size) {
     }
     return dst;
 }
- 
-struct evpair { 
-    int event; 
-    int winevent; 
-}; 
- 
-static const evpair evpairs_to_win[] = { 
+
+struct evpair {
+    int event;
+    int winevent;
+};
+
+static const evpair evpairs_to_win[] = {
     {POLLIN, FD_READ | FD_CLOSE | FD_ACCEPT},
     {POLLRDNORM, FD_READ | FD_CLOSE | FD_ACCEPT},
-    {POLLRDBAND, -1}, 
-    {POLLPRI, -1}, 
-    {POLLOUT, FD_WRITE | FD_CLOSE}, 
-    {POLLWRNORM, FD_WRITE | FD_CLOSE}, 
-    {POLLWRBAND, -1}, 
-    {POLLERR, 0}, 
-    {POLLHUP, 0}, 
+    {POLLRDBAND, -1},
+    {POLLPRI, -1},
+    {POLLOUT, FD_WRITE | FD_CLOSE},
+    {POLLWRNORM, FD_WRITE | FD_CLOSE},
+    {POLLWRBAND, -1},
+    {POLLERR, 0},
+    {POLLHUP, 0},
     {POLLNVAL, 0}};
- 
-static const size_t nevpairs_to_win = sizeof(evpairs_to_win) / sizeof(evpairs_to_win[0]); 
- 
-static const evpair evpairs_to_unix[] = { 
+
+static const size_t nevpairs_to_win = sizeof(evpairs_to_win) / sizeof(evpairs_to_win[0]);
+
+static const evpair evpairs_to_unix[] = {
     {FD_ACCEPT, POLLIN | POLLRDNORM},
-    {FD_READ, POLLIN | POLLRDNORM}, 
-    {FD_WRITE, POLLOUT | POLLWRNORM}, 
-    {FD_CLOSE, POLLHUP}, 
-}; 
- 
-static const size_t nevpairs_to_unix = sizeof(evpairs_to_unix) / sizeof(evpairs_to_unix[0]); 
- 
+    {FD_READ, POLLIN | POLLRDNORM},
+    {FD_WRITE, POLLOUT | POLLWRNORM},
+    {FD_CLOSE, POLLHUP},
+};
+
+static const size_t nevpairs_to_unix = sizeof(evpairs_to_unix) / sizeof(evpairs_to_unix[0]);
+
 static int convert_events(int events, const evpair* evpairs, size_t nevpairs, bool ignoreUnknown) noexcept {
-    int result = 0; 
-    for (size_t i = 0; i < nevpairs; ++i) { 
-        int event = evpairs[i].event; 
-        if (events & event) { 
-            events ^= event; 
-            long winEvent = evpairs[i].winevent; 
-            if (winEvent == -1) 
-                return -1; 
-            if (winEvent == 0) 
-                continue; 
-            result |= winEvent; 
-        } 
-    } 
+    int result = 0;
+    for (size_t i = 0; i < nevpairs; ++i) {
+        int event = evpairs[i].event;
+        if (events & event) {
+            events ^= event;
+            long winEvent = evpairs[i].winevent;
+            if (winEvent == -1)
+                return -1;
+            if (winEvent == 0)
+                continue;
+            result |= winEvent;
+        }
+    }
     if (events != 0 && !ignoreUnknown)
-        return -1; 
-    return result; 
-} 
- 
-class TWSAEventHolder { 
-private: 
-    HANDLE Event; 
- 
-public: 
+        return -1;
+    return result;
+}
+
+class TWSAEventHolder {
+private:
+    HANDLE Event;
+
+public:
     inline TWSAEventHolder(HANDLE event) noexcept
         : Event(event)
     {
-    } 
- 
+    }
+
     inline ~TWSAEventHolder() {
-        WSACloseEvent(Event); 
-    } 
- 
+        WSACloseEvent(Event);
+    }
+
     inline HANDLE Get() noexcept {
-        return Event; 
-    } 
-}; 
- 
+        return Event;
+    }
+};
+
 int poll(struct pollfd fds[], nfds_t nfds, int timeout) noexcept {
-    HANDLE rawEvent = WSACreateEvent(); 
-    if (rawEvent == WSA_INVALID_EVENT) { 
-        errno = EIO; 
-        return -1; 
-    } 
- 
-    TWSAEventHolder event(rawEvent); 
- 
+    HANDLE rawEvent = WSACreateEvent();
+    if (rawEvent == WSA_INVALID_EVENT) {
+        errno = EIO;
+        return -1;
+    }
+
+    TWSAEventHolder event(rawEvent);
+
     int checked_sockets = 0;
 
-    for (pollfd* fd = fds; fd < fds + nfds; ++fd) { 
-        int win_events = convert_events(fd->events, evpairs_to_win, nevpairs_to_win, false); 
-        if (win_events == -1) { 
-            errno = EINVAL; 
-            return -1; 
-        } 
-        fd->revents = 0; 
-        if (WSAEventSelect(fd->fd, event.Get(), win_events)) { 
-            int error = WSAGetLastError(); 
+    for (pollfd* fd = fds; fd < fds + nfds; ++fd) {
+        int win_events = convert_events(fd->events, evpairs_to_win, nevpairs_to_win, false);
+        if (win_events == -1) {
+            errno = EINVAL;
+            return -1;
+        }
+        fd->revents = 0;
+        if (WSAEventSelect(fd->fd, event.Get(), win_events)) {
+            int error = WSAGetLastError();
             if (error == WSAEINVAL || error == WSAENOTSOCK) {
-                fd->revents = POLLNVAL; 
+                fd->revents = POLLNVAL;
                 ++checked_sockets;
             } else {
-                errno = EIO; 
-                return -1; 
-            } 
-        } 
+                errno = EIO;
+                return -1;
+            }
+        }
         fd_set readfds;
         fd_set writefds;
         struct timeval timeout = {0, 0};
@@ -190,54 +190,54 @@ int poll(struct pollfd fds[], nfds_t nfds, int timeout) noexcept {
             }
             ++checked_sockets;
         }
-    } 
- 
+    }
+
     if (checked_sockets > 0) {
         // returns without wait since we already have sockets in desired conditions
         return checked_sockets;
     }
 
-    HANDLE events[] = {event.Get()}; 
-    DWORD wait_result = WSAWaitForMultipleEvents(1, events, TRUE, timeout, FALSE); 
-    if (wait_result == WSA_WAIT_TIMEOUT) 
-        return 0; 
+    HANDLE events[] = {event.Get()};
+    DWORD wait_result = WSAWaitForMultipleEvents(1, events, TRUE, timeout, FALSE);
+    if (wait_result == WSA_WAIT_TIMEOUT)
+        return 0;
     else if (wait_result == WSA_WAIT_EVENT_0) {
-        for (pollfd* fd = fds; fd < fds + nfds; ++fd) { 
-            if (fd->revents == POLLNVAL) 
-                continue; 
-            WSANETWORKEVENTS network_events; 
-            if (WSAEnumNetworkEvents(fd->fd, event.Get(), &network_events)) { 
-                errno = EIO; 
-                return -1; 
-            } 
-            fd->revents = 0; 
-            for (int i = 0; i < FD_MAX_EVENTS; ++i) { 
+        for (pollfd* fd = fds; fd < fds + nfds; ++fd) {
+            if (fd->revents == POLLNVAL)
+                continue;
+            WSANETWORKEVENTS network_events;
+            if (WSAEnumNetworkEvents(fd->fd, event.Get(), &network_events)) {
+                errno = EIO;
+                return -1;
+            }
+            fd->revents = 0;
+            for (int i = 0; i < FD_MAX_EVENTS; ++i) {
                 if ((network_events.lNetworkEvents & (1 << i)) != 0 && network_events.iErrorCode[i]) {
-                    fd->revents = POLLERR; 
-                    break; 
-                } 
-            } 
-            if (fd->revents == POLLERR) 
-                continue; 
-            if (network_events.lNetworkEvents) { 
-                fd->revents = static_cast<short>(convert_events(network_events.lNetworkEvents, evpairs_to_unix, nevpairs_to_unix, true)); 
-                if (fd->revents & POLLHUP) { 
-                    fd->revents &= POLLHUP | POLLIN | POLLRDNORM; 
-                } 
-            } 
-        } 
-        int chanded_sockets = 0; 
-        for (pollfd* fd = fds; fd < fds + nfds; ++fd) 
-            if (fd->revents != 0) 
-                ++chanded_sockets; 
-        return chanded_sockets; 
-    } else { 
-        errno = EIO; 
-        return -1; 
-    } 
-} 
+                    fd->revents = POLLERR;
+                    break;
+                }
+            }
+            if (fd->revents == POLLERR)
+                continue;
+            if (network_events.lNetworkEvents) {
+                fd->revents = static_cast<short>(convert_events(network_events.lNetworkEvents, evpairs_to_unix, nevpairs_to_unix, true));
+                if (fd->revents & POLLHUP) {
+                    fd->revents &= POLLHUP | POLLIN | POLLRDNORM;
+                }
+            }
+        }
+        int chanded_sockets = 0;
+        for (pollfd* fd = fds; fd < fds + nfds; ++fd)
+            if (fd->revents != 0)
+                ++chanded_sockets;
+        return chanded_sockets;
+    } else {
+        errno = EIO;
+        return -1;
+    }
+}
     #endif
- 
+
 #endif
 
 bool GetRemoteAddr(SOCKET Socket, char* str, socklen_t size) {
diff --git a/util/network/socket.h b/util/network/socket.h
index 76f46c542a..40c8648b40 100644
--- a/util/network/socket.h
+++ b/util/network/socket.h
@@ -29,7 +29,7 @@ struct pollfd {
     short events;
     short revents;
 };
- 
+
         #define POLLIN (1 << 0)
         #define POLLRDNORM (1 << 1)
         #define POLLRDBAND (1 << 2)
@@ -40,7 +40,7 @@ struct pollfd {
         #define POLLERR (1 << 7)
         #define POLLHUP (1 << 8)
         #define POLLNVAL (1 << 9)
- 
+
 const char* inet_ntop(int af, const void* src, char* dst, socklen_t size);
 int poll(struct pollfd fds[], nfds_t nfds, int timeout) noexcept;
     #else
diff --git a/util/network/socket_ut.cpp b/util/network/socket_ut.cpp
index f27a7a32dd..6b20e11f70 100644
--- a/util/network/socket_ut.cpp
+++ b/util/network/socket_ut.cpp
@@ -52,7 +52,7 @@ void TSockTest::TestSock() {
 
     UNIT_ASSERT(!si.ReadLine().empty());
 }
- 
+
 void TSockTest::TestTimeout() {
     static const int timeout = 1000;
     i64 startTime = millisec();
@@ -230,112 +230,112 @@ private:
     SOCKET StartServerSocket(ui16 port, int backlog);
     SOCKET StartClientSocket(ui32 ip, ui16 port);
     SOCKET AcceptConnection(SOCKET serverSocket);
-}; 
- 
+};
+
 UNIT_TEST_SUITE_REGISTRATION(TPollTest);
- 
-sockaddr_in TPollTest::GetAddress(ui32 ip, ui16 port) { 
-    struct sockaddr_in addr; 
-    memset(&addr, 0, sizeof(addr)); 
-    addr.sin_family = AF_INET; 
-    addr.sin_port = htons(port); 
-    addr.sin_addr.s_addr = htonl(ip); 
-    return addr; 
-} 
- 
-SOCKET TPollTest::CreateSocket() { 
-    SOCKET s = socket(AF_INET, SOCK_STREAM, 0); 
+
+sockaddr_in TPollTest::GetAddress(ui32 ip, ui16 port) {
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = htonl(ip);
+    return addr;
+}
+
+SOCKET TPollTest::CreateSocket() {
+    SOCKET s = socket(AF_INET, SOCK_STREAM, 0);
     if (s == INVALID_SOCKET) {
         ythrow yexception() << "Can not create socket (" << LastSystemErrorText() << ")";
     }
-    return s; 
-} 
- 
-SOCKET TPollTest::StartServerSocket(ui16 port, int backlog) { 
-    TSocketHolder s(CreateSocket()); 
-    sockaddr_in addr = GetAddress(ntohl(INADDR_ANY), port); 
+    return s;
+}
+
+SOCKET TPollTest::StartServerSocket(ui16 port, int backlog) {
+    TSocketHolder s(CreateSocket());
+    sockaddr_in addr = GetAddress(ntohl(INADDR_ANY), port);
     if (bind(s, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
         ythrow yexception() << "Can not bind server socket (" << LastSystemErrorText() << ")";
     }
     if (listen(s, backlog) == SOCKET_ERROR) {
         ythrow yexception() << "Can not listen on server socket (" << LastSystemErrorText() << ")";
     }
-    return s.Release(); 
-} 
- 
-SOCKET TPollTest::StartClientSocket(ui32 ip, ui16 port) { 
-    TSocketHolder s(CreateSocket()); 
-    sockaddr_in addr = GetAddress(ip, port); 
+    return s.Release();
+}
+
+SOCKET TPollTest::StartClientSocket(ui32 ip, ui16 port) {
+    TSocketHolder s(CreateSocket());
+    sockaddr_in addr = GetAddress(ip, port);
     if (connect(s, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
         ythrow yexception() << "Can not connect client socket (" << LastSystemErrorText() << ")";
     }
-    return s.Release(); 
-} 
- 
-SOCKET TPollTest::AcceptConnection(SOCKET serverSocket) { 
+    return s.Release();
+}
+
+SOCKET TPollTest::AcceptConnection(SOCKET serverSocket) {
     SOCKET connectedSocket = accept(serverSocket, nullptr, nullptr);
     if (connectedSocket == INVALID_SOCKET) {
         ythrow yexception() << "Can not accept connection on server socket (" << LastSystemErrorText() << ")";
     }
-    return connectedSocket; 
-} 
- 
-void TPollTest::TestPollInOut() { 
-#ifdef _win_ 
-    const size_t socketCount = 1000; 
- 
-    ui16 port = static_cast<ui16>(1300 + rand() % 97); 
-    TSocketHolder serverSocket = StartServerSocket(port, socketCount); 
- 
-    ui32 localIp = ntohl(inet_addr("127.0.0.1")); 
- 
+    return connectedSocket;
+}
+
+void TPollTest::TestPollInOut() {
+#ifdef _win_
+    const size_t socketCount = 1000;
+
+    ui16 port = static_cast<ui16>(1300 + rand() % 97);
+    TSocketHolder serverSocket = StartServerSocket(port, socketCount);
+
+    ui32 localIp = ntohl(inet_addr("127.0.0.1"));
+
     TVector<TSimpleSharedPtr<TSocketHolder>> clientSockets;
     TVector<TSimpleSharedPtr<TSocketHolder>> connectedSockets;
     TVector<pollfd> fds;
- 
-    for (size_t i = 0; i < socketCount; ++i) { 
+
+    for (size_t i = 0; i < socketCount; ++i) {
         TSimpleSharedPtr<TSocketHolder> clientSocket(new TSocketHolder(StartClientSocket(localIp, port)));
-        clientSockets.push_back(clientSocket); 
- 
-        if (i % 5 == 0 || i % 5 == 2) { 
-            char buffer = 'c'; 
-            if (send(*clientSocket, &buffer, 1, 0) == -1) 
+        clientSockets.push_back(clientSocket);
+
+        if (i % 5 == 0 || i % 5 == 2) {
+            char buffer = 'c';
+            if (send(*clientSocket, &buffer, 1, 0) == -1)
                 ythrow yexception() << "Can not send (" << LastSystemErrorText() << ")";
-        } 
- 
+        }
+
         TSimpleSharedPtr<TSocketHolder> connectedSocket(new TSocketHolder(AcceptConnection(serverSocket)));
-        connectedSockets.push_back(connectedSocket); 
- 
-        if (i % 5 == 2 || i % 5 == 3) { 
-            closesocket(*clientSocket); 
-            shutdown(*clientSocket, SD_BOTH); 
-        } 
-    } 
- 
+        connectedSockets.push_back(connectedSocket);
+
+        if (i % 5 == 2 || i % 5 == 3) {
+            closesocket(*clientSocket);
+            shutdown(*clientSocket, SD_BOTH);
+        }
+    }
+
     int expectedCount = 0;
     for (size_t i = 0; i < connectedSockets.size(); ++i) {
-        pollfd fd = {(i % 5 == 4) ? INVALID_SOCKET : static_cast<SOCKET>(*connectedSockets[i]), POLLIN | POLLOUT, 0}; 
-        fds.push_back(fd); 
+        pollfd fd = {(i % 5 == 4) ? INVALID_SOCKET : static_cast<SOCKET>(*connectedSockets[i]), POLLIN | POLLOUT, 0};
+        fds.push_back(fd);
         if (i % 5 != 4)
             ++expectedCount;
-    } 
- 
-    int polledCount = poll(&fds[0], fds.size(), INFTIM); 
+    }
+
+    int polledCount = poll(&fds[0], fds.size(), INFTIM);
     UNIT_ASSERT_EQUAL(expectedCount, polledCount);
- 
-    for (size_t i = 0; i < connectedSockets.size(); ++i) { 
+
+    for (size_t i = 0; i < connectedSockets.size(); ++i) {
         short revents = fds[i].revents;
-        if (i % 5 == 0) { 
+        if (i % 5 == 0) {
             UNIT_ASSERT_EQUAL(static_cast<short>(POLLRDNORM | POLLWRNORM), revents);
-        } else if (i % 5 == 1) { 
+        } else if (i % 5 == 1) {
             UNIT_ASSERT_EQUAL(static_cast<short>(POLLOUT | POLLWRNORM), revents);
-        } else if (i % 5 == 2) { 
+        } else if (i % 5 == 2) {
             UNIT_ASSERT_EQUAL(static_cast<short>(POLLHUP | POLLRDNORM | POLLWRNORM), revents);
-        } else if (i % 5 == 3) { 
+        } else if (i % 5 == 3) {
             UNIT_ASSERT_EQUAL(static_cast<short>(POLLHUP | POLLWRNORM), revents);
-        } else if (i % 5 == 4) { 
+        } else if (i % 5 == 4) {
             UNIT_ASSERT_EQUAL(static_cast<short>(POLLNVAL), revents);
-        } 
-    } 
-#endif 
+        }
+    }
+#endif
 }
diff --git a/util/stream/zlib.cpp b/util/stream/zlib.cpp
index 196d155b99..60f4e9439f 100644
--- a/util/stream/zlib.cpp
+++ b/util/stream/zlib.cpp
@@ -188,15 +188,15 @@ namespace {
 }
 
 class TZLibCompress::TImpl: public TAdditionalStorage<TImpl>, private TZLibCommon {
-    static inline ZLib::StreamType Type(ZLib::StreamType type) { 
+    static inline ZLib::StreamType Type(ZLib::StreamType type) {
         if (type == ZLib::Auto) {
             return ZLib::ZLib;
         }
 
-        if (type >= ZLib::Invalid) { 
-            ythrow TZLibError() << "invalid compression type: " << static_cast<unsigned long>(type); 
-        } 
- 
+        if (type >= ZLib::Invalid) {
+            ythrow TZLibError() << "invalid compression type: " << static_cast<unsigned long>(type);
+        }
+
         return type;
     }
 
diff --git a/util/stream/zlib.h b/util/stream/zlib.h
index 2d55bd4999..e7de7c81b7 100644
--- a/util/stream/zlib.h
+++ b/util/stream/zlib.h
@@ -28,8 +28,8 @@ namespace ZLib {
         Auto = 0, /**< Auto detect format. Can be used for decompression only. */
         ZLib = 1,
         GZip = 2,
-        Raw = 3, 
-        Invalid = 4 
+        Raw = 3,
+        Invalid = 4
     };
 
     enum {
diff --git a/util/string/cast.cpp b/util/string/cast.cpp
index 2823ad0e58..aa1e65a8e9 100644
--- a/util/string/cast.cpp
+++ b/util/string/cast.cpp
@@ -516,11 +516,11 @@ bool FromStringImpl<bool>(const char* data, size_t len) {
     return result;
 }
 
-template <> 
+template <>
 TString FromStringImpl<TString>(const char* data, size_t len) {
     return TString(data, len);
-} 
- 
+}
+
 template <>
 TStringBuf FromStringImpl<TStringBuf>(const char* data, size_t len) {
     return TStringBuf(data, len);
diff --git a/util/system/compat.cpp b/util/system/compat.cpp
index f1ea393ea7..18fbfa296a 100644
--- a/util/system/compat.cpp
+++ b/util/system/compat.cpp
@@ -23,15 +23,15 @@ const char* getprogname() {
 #endif
 
 #ifdef _win_
- 
-void sleep(i64 len) { 
-    Sleep((unsigned long)len * 1000); 
-} 
- 
-void usleep(i64 len) { 
-    Sleep((unsigned long)len / 1000); 
-} 
- 
+
+void sleep(i64 len) {
+    Sleep((unsigned long)len * 1000);
+}
+
+void usleep(i64 len) {
+    Sleep((unsigned long)len / 1000);
+}
+
     #include <fcntl.h>
 int ftruncate(int fd, i64 length) {
     return _chsize_s(fd, length);
diff --git a/util/system/compat.h b/util/system/compat.h
index ef91de58ae..c53dbcca17 100644
--- a/util/system/compat.h
+++ b/util/system/compat.h
@@ -62,14 +62,14 @@ extern "C" {
 #endif
 
 #ifdef _win_
- 
+
     #ifdef sleep // may be defined by perl
         #undef sleep
     #endif
- 
-void sleep(i64 len); 
-void usleep(i64 len); 
- 
+
+void sleep(i64 len);
+void usleep(i64 len);
+
 #endif
 
 #ifdef _win_
diff --git a/util/system/compiler.h b/util/system/compiler.h
index f473deab05..b373edcc46 100644
--- a/util/system/compiler.h
+++ b/util/system/compiler.h
@@ -307,26 +307,26 @@ _YandexAbort();
 #if defined(_MSC_VER)
     #define __PRETTY_FUNCTION__ __FUNCSIG__
 #endif
- 
-#if defined(__GNUC__) 
+
+#if defined(__GNUC__)
     #define Y_WEAK __attribute__((weak))
-#else 
+#else
     #define Y_WEAK
-#endif 
+#endif
 
-#if defined(__CUDACC_VER_MAJOR__) 
+#if defined(__CUDACC_VER_MAJOR__)
     #define Y_CUDA_AT_LEAST(x, y) (__CUDACC_VER_MAJOR__ > x || (__CUDACC_VER_MAJOR__ == x && __CUDACC_VER_MINOR__ >= y))
-#else 
+#else
     #define Y_CUDA_AT_LEAST(x, y) 0
 #endif
 
-// NVidia CUDA C++ Compiler did not know about noexcept keyword until version 9.0 
-#if !Y_CUDA_AT_LEAST(9, 0) 
+// NVidia CUDA C++ Compiler did not know about noexcept keyword until version 9.0
+#if !Y_CUDA_AT_LEAST(9, 0)
     #if defined(__CUDACC__) && !defined(noexcept)
         #define noexcept throw()
     #endif
-#endif 
- 
+#endif
+
 #if defined(__GNUC__)
     #define Y_COLD __attribute__((cold))
     #define Y_LEAF __attribute__((leaf))
diff --git a/util/system/context.h b/util/system/context.h
index 8bb2adaa32..d2a349bfc5 100644
--- a/util/system/context.h
+++ b/util/system/context.h
@@ -11,7 +11,7 @@
 
 #define STACK_ALIGN (8 * PLATFORM_DATA_ALIGN)
 
-#if defined(_x86_64_) || defined(_i386_) || defined(_arm_) || defined(_ppc64_) 
+#if defined(_x86_64_) || defined(_i386_) || defined(_arm_) || defined(_ppc64_)
     #define STACK_GROW_DOWN 1
 #else
     #error todo
@@ -26,7 +26,7 @@
     #define USE_UCONTEXT_CONT
 #elif defined(_win_)
     #define USE_FIBER_CONT
-#elif (defined(_i386_) || defined(_x86_64_) || defined(_arm64_)) && !defined(_k1om_) 
+#elif (defined(_i386_) || defined(_x86_64_) || defined(_arm64_)) && !defined(_k1om_)
     #define USE_JUMP_CONT
 #else
     #define USE_UCONTEXT_CONT
diff --git a/util/system/defaults.h b/util/system/defaults.h
index e889b71fce..dcd7abea38 100644
--- a/util/system/defaults.h
+++ b/util/system/defaults.h
@@ -19,16 +19,16 @@
     #include <sys/param.h>
 #endif
 
-#if defined(BSD) || defined(_android_) 
- 
+#if defined(BSD) || defined(_android_)
+
     #if defined(BSD)
         #include <machine/endian.h>
     #endif
- 
+
     #if defined(_android_)
         #include <endian.h>
     #endif
- 
+
     #if (BYTE_ORDER == LITTLE_ENDIAN)
         #define _little_endian_
     #elif (BYTE_ORDER == BIG_ENDIAN)
@@ -36,7 +36,7 @@
     #else
         #error unknown endian not supported
     #endif
- 
+
 #elif (defined(_sun_) && !defined(__i386__)) || defined(_hpux_) || defined(WHATEVER_THAT_HAS_BIG_ENDIAN)
     #define _big_endian_
 #else
diff --git a/util/system/file_ut.cpp b/util/system/file_ut.cpp
index df987972b7..941e6a50f3 100644
--- a/util/system/file_ut.cpp
+++ b/util/system/file_ut.cpp
@@ -194,8 +194,8 @@ void TFileTest::TestRW() {
     UNIT_ASSERT(!f1.IsOpen());
     UNIT_ASSERT(!f2.IsOpen());
     UNIT_ASSERT(unlink("f1.txt") == 0);
-} 
- 
+}
+
 #ifdef _unix_
     #include <locale.h>
 #endif
diff --git a/util/system/filemap.h b/util/system/filemap.h
index e28a37da4c..11be64bff4 100644
--- a/util/system/filemap.h
+++ b/util/system/filemap.h
@@ -265,11 +265,11 @@ public:
     }
     const T* Begin() const noexcept {
         return Ptr_;
-    } 
+    }
     /// for STL compatibility only, End() usage is recommended
     const T* end() const noexcept {
         return End_;
-    } 
+    }
     const T* End() const noexcept {
         return End_;
     }
@@ -367,11 +367,11 @@ public:
         return ((T*)Ptr())[pos];
     }
     T* begin() {
-        return (T*)Ptr(); 
-    } 
+        return (T*)Ptr();
+    }
     T* end() {
-        return (T*)((char*)Ptr() + MappedSize()); 
-    } 
+        return (T*)((char*)Ptr() + MappedSize());
+    }
     size_t size() const {
         return MappedSize() / sizeof(T);
     }
diff --git a/util/system/mktemp.cpp b/util/system/mktemp.cpp
index ab993d5f43..505b7b4a4b 100644
--- a/util/system/mktemp.cpp
+++ b/util/system/mktemp.cpp
@@ -1,7 +1,7 @@
 #include "tempfile.h"
 
-#include <util/folder/dirut.h> 
-#include <util/generic/yexception.h> 
+#include <util/folder/dirut.h>
+#include <util/generic/yexception.h>
 #include <util/stream/file.h>
 
 #include <cerrno>
@@ -21,11 +21,11 @@ TString MakeTempName(const char* wrkDir, const char* prefix, const char* extensi
 #ifndef _win32_
     TString filePath;
 
-    if (wrkDir && *wrkDir) { 
+    if (wrkDir && *wrkDir) {
         filePath += wrkDir;
-    } else { 
+    } else {
         filePath += GetSystemTempDir();
-    } 
+    }
 
     if (filePath.back() != '/') {
         filePath += '/';
diff --git a/util/system/platform.h b/util/system/platform.h
index 26010d8569..58f310ab34 100644
--- a/util/system/platform.h
+++ b/util/system/platform.h
@@ -69,7 +69,7 @@
     #define _win_
 #endif
 
-#if defined(__arm__) || defined(__ARM__) || defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM) 
+#if defined(__arm__) || defined(__ARM__) || defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM)
     #if defined(__arm64) || defined(__arm64__) || defined(__aarch64__)
         #define _arm64_
     #else
@@ -99,15 +99,15 @@
     #define _ia64_
 #endif
 
-#if defined(__powerpc__) 
+#if defined(__powerpc__)
     #define _ppc_
-#endif 
- 
-#if defined(__powerpc64__) 
+#endif
+
+#if defined(__powerpc64__)
     #define _ppc64_
-#endif 
- 
-#if !defined(sparc) && !defined(__sparc) && !defined(__hpux__) && !defined(__alpha__) && !defined(_ia64_) && !defined(_x86_64_) && !defined(_arm_) && !defined(_i386_) && !defined(_ppc_) && !defined(_ppc64_) 
+#endif
+
+#if !defined(sparc) && !defined(__sparc) && !defined(__hpux__) && !defined(__alpha__) && !defined(_ia64_) && !defined(_x86_64_) && !defined(_arm_) && !defined(_i386_) && !defined(_ppc_) && !defined(_ppc64_)
     #error "platform not defined, please, define one"
 #endif
 
@@ -115,11 +115,11 @@
     #define _x86_
 #endif
 
-#if defined(__MIC__) 
+#if defined(__MIC__)
     #define _mic_
     #define _k1om_
-#endif 
- 
+#endif
+
 // stdio or MessageBox
 #if defined(__CONSOLE__) || defined(_CONSOLE)
     #define _console_
@@ -183,7 +183,7 @@
 #endif
 
 // 16, 32 or 64
-#if defined(__sparc_v9__) || defined(_x86_64_) || defined(_ia64_) || defined(_arm64_) || defined(_ppc64_) 
+#if defined(__sparc_v9__) || defined(_x86_64_) || defined(_ia64_) || defined(_arm64_) || defined(_ppc64_)
     #define _64_
 #else
     #define _32_
@@ -214,11 +214,11 @@
 #endif
 
 #define SIZEOF_CHAR 1
-#define SIZEOF_UNSIGNED_CHAR 1 
+#define SIZEOF_UNSIGNED_CHAR 1
 #define SIZEOF_SHORT 2
-#define SIZEOF_UNSIGNED_SHORT 2 
+#define SIZEOF_UNSIGNED_SHORT 2
 #define SIZEOF_INT 4
-#define SIZEOF_UNSIGNED_INT 4 
+#define SIZEOF_UNSIGNED_INT 4
 
 #if defined(_32_)
     #define SIZEOF_LONG 4
@@ -238,7 +238,7 @@
 #endif
 
 #define SIZEOF_LONG_LONG 8
-#define SIZEOF_UNSIGNED_LONG_LONG 8 
+#define SIZEOF_UNSIGNED_LONG_LONG 8
 
 #undef SIZEOF_SIZE_T // in case we include <Python.h> which defines it, too
 #define SIZEOF_SIZE_T SIZEOF_PTR
diff --git a/util/system/sanitizers.cpp b/util/system/sanitizers.cpp
index 744ec6ce87..bb799a9e2e 100644
--- a/util/system/sanitizers.cpp
+++ b/util/system/sanitizers.cpp
@@ -114,15 +114,15 @@ void TFiberContext::BeforeSwitch(TFiberContext* old) noexcept {
 
 void TFiberContext::AfterSwitch() noexcept {
 #if defined(_asan_enabled_)
-    __sanitizer_finish_switch_fiber(Token_, nullptr, nullptr); 
+    __sanitizer_finish_switch_fiber(Token_, nullptr, nullptr);
+#endif
+}
+
+void TFiberContext::AfterStart() noexcept {
+#if defined(_asan_enabled_)
+    __sanitizer_finish_switch_fiber(nullptr, nullptr, nullptr);
 #endif
 }
- 
-void TFiberContext::AfterStart() noexcept { 
-#if defined(_asan_enabled_) 
-    __sanitizer_finish_switch_fiber(nullptr, nullptr, nullptr); 
-#endif 
-} 
 
 #if defined(_tsan_enabled_)
 extern "C" {
diff --git a/util/system/sanitizers.h b/util/system/sanitizers.h
index 94f7fff6ee..965e5c751e 100644
--- a/util/system/sanitizers.h
+++ b/util/system/sanitizers.h
@@ -28,8 +28,8 @@ namespace NSan {
         void BeforeSwitch(TFiberContext* old) noexcept;
         void AfterSwitch() noexcept;
 
-        static void AfterStart() noexcept; 
- 
+        static void AfterStart() noexcept;
+
     private:
         void* Token_;
         const void* Stack_;
diff --git a/util/system/shmat.cpp b/util/system/shmat.cpp
index 65fbf3a6da..07ff0d6caa 100644
--- a/util/system/shmat.cpp
+++ b/util/system/shmat.cpp
@@ -61,30 +61,30 @@ namespace {
     static int shmdt(const void* addr) {
         return syscall(__NR_shmdt, addr);
     }
- 
+
     #else
         #define IPCOP_shmat 21
         #define IPCOP_shmdt 22
         #define IPCOP_shmget 23
         #define IPCOP_shmctl 24
- 
-    static int shmget(key_t key, size_t size, int flag) { 
-        return syscall(__NR_ipc, IPCOP_shmget, key, size, flag, 0); 
-    } 
- 
-    static void* shmat(int id, const void* addr, int flag) { 
-        void* retval; 
-        long res = syscall(__NR_ipc, IPCOP_shmat, id, flag, (long)&retval, addr); 
+
+    static int shmget(key_t key, size_t size, int flag) {
+        return syscall(__NR_ipc, IPCOP_shmget, key, size, flag, 0);
+    }
+
+    static void* shmat(int id, const void* addr, int flag) {
+        void* retval;
+        long res = syscall(__NR_ipc, IPCOP_shmat, id, flag, (long)&retval, addr);
         return (res >= 0) ? retval : (void*)-1;
-    } 
- 
-    static int shmctl(int id, int cmd, void* buf) { 
-        return syscall(__NR_ipc, IPCOP_shmctl, id, cmd | IPC_64, 0, buf); 
-    } 
- 
-    static int shmdt(const void* addr) { 
-        return syscall(__NR_ipc, IPCOP_shmdt, 0, 0, 0, addr); 
-    } 
+    }
+
+    static int shmctl(int id, int cmd, void* buf) {
+        return syscall(__NR_ipc, IPCOP_shmctl, id, cmd | IPC_64, 0, buf);
+    }
+
+    static int shmdt(const void* addr) {
+        return syscall(__NR_ipc, IPCOP_shmdt, 0, 0, 0, addr);
+    }
     #endif
 }
 #endif
diff --git a/util/system/thread.cpp b/util/system/thread.cpp
index f10d79113f..6236746c2d 100644
--- a/util/system/thread.cpp
+++ b/util/system/thread.cpp
@@ -530,27 +530,27 @@ TCurrentThreadLimits::TCurrentThreadLimits() noexcept
     StackBegin = pthread_get_stackaddr_np(pthread_self());
     StackLength = pthread_get_stacksize_np(pthread_self());
 #elif defined(_MSC_VER)
- 
+
     #if _WIN32_WINNT >= _WIN32_WINNT_WIN8
     ULONG_PTR b = 0;
     ULONG_PTR e = 0;
 
-    GetCurrentThreadStackLimits(&b, &e); 
+    GetCurrentThreadStackLimits(&b, &e);
 
     StackBegin = (const void*)b;
     StackLength = e - b;
- 
+
     #else
-    // Copied from https://github.com/llvm-mirror/compiler-rt/blob/release_40/lib/sanitizer_common/sanitizer_win.cc#L91 
-    void* place_on_stack = alloca(16); 
-    MEMORY_BASIC_INFORMATION memory_info; 
-    Y_VERIFY(VirtualQuery(place_on_stack, &memory_info, sizeof(memory_info))); 
- 
-    StackBegin = memory_info.AllocationBase; 
-    StackLength = static_cast<const char*>(memory_info.BaseAddress) + memory_info.RegionSize - static_cast<const char*>(StackBegin); 
- 
+    // Copied from https://github.com/llvm-mirror/compiler-rt/blob/release_40/lib/sanitizer_common/sanitizer_win.cc#L91
+    void* place_on_stack = alloca(16);
+    MEMORY_BASIC_INFORMATION memory_info;
+    Y_VERIFY(VirtualQuery(place_on_stack, &memory_info, sizeof(memory_info)));
+
+    StackBegin = memory_info.AllocationBase;
+    StackLength = static_cast<const char*>(memory_info.BaseAddress) + memory_info.RegionSize - static_cast<const char*>(StackBegin);
+
     #endif
- 
+
 #else
     #error port me
 #endif
diff --git a/util/system/tls.h b/util/system/tls.h
index 542cdf31e8..3c4f56dbeb 100644
--- a/util/system/tls.h
+++ b/util/system/tls.h
@@ -15,10 +15,10 @@
     #define Y_DISABLE_THRKEY_OPTIMIZATION
 #endif
 
-#if defined(__GNUC__) && defined(__ANDROID__) && defined(__i686__) // https://st.yandex-team.ru/DEVTOOLS-3352 
+#if defined(__GNUC__) && defined(__ANDROID__) && defined(__i686__) // https://st.yandex-team.ru/DEVTOOLS-3352
     #define Y_DISABLE_THRKEY_OPTIMIZATION
-#endif 
- 
+#endif
+
 /**
     @def Y_THREAD(TType)
 
diff --git a/util/system/winint.h b/util/system/winint.h
index b9be6d0bdf..ebeaefb3d2 100644
--- a/util/system/winint.h
+++ b/util/system/winint.h
@@ -7,11 +7,11 @@
     #ifndef WIN32_LEAN_AND_MEAN
         #define WIN32_LEAN_AND_MEAN
     #endif
- 
+
     #ifndef NOMINMAX
         #define NOMINMAX
     #endif
- 
+
     #include <windows.h>
 
     #undef GetFreeSpace
diff --git a/util/system/yassert.h b/util/system/yassert.h
index bdd0f7b150..529823440c 100644
--- a/util/system/yassert.h
+++ b/util/system/yassert.h
@@ -22,10 +22,10 @@
     #include <cassert>
 #endif
 
-#if !defined(_MSC_VER) 
-    #if defined(__has_builtin) && __has_builtin(__debugbreak) 
+#if !defined(_MSC_VER)
+    #if defined(__has_builtin) && __has_builtin(__debugbreak)
     // Do nothing, use __debugbreak builtin
-    #else 
+    #else
 inline void __debugbreak() {
         #if defined(__x86_64__) || defined(__i386__)
     __asm__ volatile("int $3\n");
@@ -33,27 +33,27 @@ inline void __debugbreak() {
     assert(0);
         #endif
 }
-    #endif 
- 
+    #endif
+
 inline bool YaIsDebuggerPresent() {
     return false;
 }
 #else
 // __debugbreak is intrinsic in MSVC
- 
+
 extern "C" {
     __declspec(dllimport) int __stdcall IsDebuggerPresent();
 }
- 
+
 inline bool YaIsDebuggerPresent() {
     return IsDebuggerPresent() != 0;
 }
-#endif 
- 
-inline void YaDebugBreak() { 
-    __debugbreak(); 
+#endif
+
+inline void YaDebugBreak() {
+    __debugbreak();
 }
- 
+
 #undef Y_ASSERT
 
 #if !defined(NDEBUG) && !defined(__GCCXML__)