Restoring authorship annotation for Evgeny Grechnikov <diamondaz@yandex.ru>. Commit 2 of 2.

26 files changed, 367 insertions, 367 deletions

diff --git a/build/scripts/build_pln_header.py b/build/scripts/build_pln_header.py
index 96bafa99f8..c73693f444 100755
--- a/build/scripts/build_pln_header.py
+++ b/build/scripts/build_pln_header.py
@@ -23,10 +23,10 @@ def BuildPlnHeader():
         tmpFile.write('void {0}SSE(const float* const* factors, float* result);\n'.format(name))
     tmpFile.close()
     try:
-        os.remove(outPath) 
-    except: 
-        pass 
-    try: 
+        os.remove(outPath)
+    except:
+        pass
+    try:
         os.rename(tmpPath, outPath)
     except:
         print >>sys.stdout, 'Error: Failed to rename ' + tmpPath + ' to ' + outPath
diff --git a/contrib/restricted/boost/libs/random/ya.make b/contrib/restricted/boost/libs/random/ya.make
index be43020e61..5d319bcb88 100644
--- a/contrib/restricted/boost/libs/random/ya.make
+++ b/contrib/restricted/boost/libs/random/ya.make
@@ -19,5 +19,5 @@ SRCS(
 PEERDIR(
     contrib/restricted/boost/libs/system
 )
- 
+
 END()
diff --git a/library/cpp/charset/wide.h b/library/cpp/charset/wide.h
index d75cbd4473..32d30e849e 100644
--- a/library/cpp/charset/wide.h
+++ b/library/cpp/charset/wide.h
@@ -210,16 +210,16 @@ namespace NDetail {
 template <bool robust>
 inline TWtringBuf CharToWide(const TStringBuf src, TUtf16String& dst, ECharset encoding) {
     if (robust && CODES_UTF8 == encoding)
-        return ::NDetail::RecodeUTF8Robust(src, dst); 
-    return ::NDetail::Recode<char>(src, dst, encoding); 
+        return ::NDetail::RecodeUTF8Robust(src, dst);
+    return ::NDetail::Recode<char>(src, dst, encoding);
 }
 
 inline TWtringBuf CharToWide(const TStringBuf src, TUtf16String& dst, ECharset encoding) {
-    return ::NDetail::Recode<char>(src, dst, encoding); 
+    return ::NDetail::Recode<char>(src, dst, encoding);
 }
 
 inline TStringBuf WideToChar(const TWtringBuf src, TString& dst, ECharset encoding) {
-    return ::NDetail::Recode<wchar16>(src, dst, encoding); 
+    return ::NDetail::Recode<wchar16>(src, dst, encoding);
 }
 
 //! calls either to @c WideToUTF8 or @c WideToChar depending on the encoding type
diff --git a/library/cpp/deprecated/split/split_iterator.h b/library/cpp/deprecated/split/split_iterator.h
index 683ab11d5c..0eacc29228 100644
--- a/library/cpp/deprecated/split/split_iterator.h
+++ b/library/cpp/deprecated/split/split_iterator.h
@@ -61,7 +61,7 @@ private:
     bool Delims[256];
 
 public:
-    explicit TSplitDelimiters(const char* s); 
+    explicit TSplitDelimiters(const char* s);
 
     Y_FORCE_INLINE bool IsDelimiter(ui8 ch) const {
         return Delims[ch];
@@ -87,9 +87,9 @@ public:
     Y_FORCE_INLINE size_t GetLength() const {
         return Len;
     }
- 
-private: 
-    // we don't own Str, make sure that no one calls us with temporary object 
+
+private:
+    // we don't own Str, make sure that no one calls us with temporary object
     TSplitBase(TString&&) = delete;
 };
 
@@ -111,10 +111,10 @@ public:
     TIterator Iterator() const;
     TSizeTRegion Next(size_t& pos) const;
     size_t Begin() const;
- 
-private: 
-    // we don't own Delimiters, make sure that no one calls us with temporary object 
-    TDelimitersSplit(const char*, size_t, TSplitDelimiters&&) = delete; 
+
+private:
+    // we don't own Delimiters, make sure that no one calls us with temporary object
+    TDelimitersSplit(const char*, size_t, TSplitDelimiters&&) = delete;
     TDelimitersSplit(const TString&, TSplitDelimiters&&) = delete;
     TDelimitersSplit(TString&&, const TSplitDelimiters&) = delete;
 };
@@ -132,10 +132,10 @@ public:
     TIterator Iterator() const;
     TSizeTRegion Next(size_t& pos) const;
     size_t Begin() const;
- 
-private: 
-    // we don't own Delimiters, make sure that no one calls us with temporary object 
-    TDelimitersStrictSplit(const char*, size_t, TSplitDelimiters&&) = delete; 
+
+private:
+    // we don't own Delimiters, make sure that no one calls us with temporary object
+    TDelimitersStrictSplit(const char*, size_t, TSplitDelimiters&&) = delete;
     TDelimitersStrictSplit(const TString&, TSplitDelimiters&&) = delete;
     TDelimitersStrictSplit(TString&&, const TSplitDelimiters&) = delete;
 };
@@ -154,9 +154,9 @@ public:
     TIterator Iterator() const;
     TSizeTRegion Next(size_t& pos) const;
     size_t Begin() const;
- 
-private: 
-    // we don't own Delimiters and Screens, make sure that no one calls us with temporary object 
+
+private:
+    // we don't own Delimiters and Screens, make sure that no one calls us with temporary object
     TScreenedDelimitersSplit(TString&&, const TSplitDelimiters&, const TSplitDelimiters&) = delete;
     TScreenedDelimitersSplit(const TString&, TSplitDelimiters&&, const TSplitDelimiters&) = delete;
     TScreenedDelimitersSplit(const TString&, const TSplitDelimiters&, TSplitDelimiters&&) = delete;
@@ -177,10 +177,10 @@ public:
     TIterator Iterator() const;
     TSizeTRegion Next(size_t& pos) const;
     size_t Begin() const;
- 
-private: 
-    // we don't own Delimiters, make sure that no one calls us with temporary object 
-    TDelimitersSplitWithoutTags(const char*, size_t, TSplitDelimiters&&) = delete; 
+
+private:
+    // we don't own Delimiters, make sure that no one calls us with temporary object
+    TDelimitersSplitWithoutTags(const char*, size_t, TSplitDelimiters&&) = delete;
     TDelimitersSplitWithoutTags(const TString&, TSplitDelimiters&&) = delete;
     TDelimitersSplitWithoutTags(TString&&, const TSplitDelimiters&) = delete;
 };
@@ -195,9 +195,9 @@ public:
     TIterator Iterator() const;
     TSizeTRegion Next(size_t& pos) const;
     size_t Begin() const;
- 
-private: 
-    // we don't own Str, make sure that no one calls us with temporary object 
+
+private:
+    // we don't own Str, make sure that no one calls us with temporary object
     TCharSplit(TString&&) = delete;
 };
 
@@ -219,9 +219,9 @@ public:
     TIterator Iterator() const;
     TSizeTRegion Next(size_t& pos) const;
     size_t Begin() const;
- 
-private: 
-    // we don't own Str, make sure that no one calls us with temporary object 
+
+private:
+    // we don't own Str, make sure that no one calls us with temporary object
     TCharSplitWithoutTags(TString&&) = delete;
 };
 
@@ -246,9 +246,9 @@ public:
     TIterator Iterator() const;
     TSizeTRegion Next(size_t& pos) const;
     size_t Begin() const;
- 
-private: 
-    // we don't own Delimiters, make sure that no one calls us with temporary object 
+
+private:
+    // we don't own Delimiters, make sure that no one calls us with temporary object
     TSubstringSplit(TString&&, const TSubstringSplitDelimiter&) = delete;
     TSubstringSplit(const TString&, TSubstringSplitDelimiter&&) = delete;
 };
diff --git a/library/cpp/deprecated/split/split_iterator_ut.cpp b/library/cpp/deprecated/split/split_iterator_ut.cpp
index 5a803f5bdb..be5069c4be 100644
--- a/library/cpp/deprecated/split/split_iterator_ut.cpp
+++ b/library/cpp/deprecated/split/split_iterator_ut.cpp
@@ -34,8 +34,8 @@ void TSplitIteratorTest::TestDelimiters() {
 void TSplitIteratorTest::TestDelimitersSplit() {
     {
         TString s = "1a3b45cd";
-        TSplitDelimiters delims("abcd"); 
-        TDelimitersSplit split(s, delims); 
+        TSplitDelimiters delims("abcd");
+        TDelimitersSplit split(s, delims);
         TSplitTokens tokens;
         Split(split, &tokens);
         TSplitTokens pattern = {"1", "3", "45"};
@@ -43,8 +43,8 @@ void TSplitIteratorTest::TestDelimitersSplit() {
     }
     {
         TString s = "aaaaaa";
-        TSplitDelimiters delims("abcd"); 
-        TDelimitersSplit split(s, delims); 
+        TSplitDelimiters delims("abcd");
+        TDelimitersSplit split(s, delims);
         TSplitTokens tokens;
         Split(split, &tokens);
         TSplitTokens pattern = {};
@@ -55,8 +55,8 @@ void TSplitIteratorTest::TestDelimitersSplit() {
 void TSplitIteratorTest::TestDelimitersStrictSplit() {
     {
         TString s = "grp@2";
-        TSplitDelimiters delims("@"); 
-        TDelimitersStrictSplit split(s, delims); 
+        TSplitDelimiters delims("@");
+        TDelimitersStrictSplit split(s, delims);
         TSplitTokens tokens;
         Split(split, &tokens);
         TSplitTokens pattern = {"grp", "2"};
@@ -65,8 +65,8 @@ void TSplitIteratorTest::TestDelimitersStrictSplit() {
 
     {
         TString s = "@grp@2@@";
-        TSplitDelimiters delims("@"); 
-        TDelimitersStrictSplit split(s, delims); 
+        TSplitDelimiters delims("@");
+        TDelimitersStrictSplit split(s, delims);
         TSplitTokens tokens;
         Split(split, &tokens);
         TSplitTokens pattern = {"", "grp", "2", ""};
@@ -76,8 +76,8 @@ void TSplitIteratorTest::TestDelimitersStrictSplit() {
 
 void TSplitIteratorTest::TestTail() {
     TString s = "grp@2@4";
-    TSplitDelimiters delims("@"); 
-    TDelimitersSplit split(s, delims); 
+    TSplitDelimiters delims("@");
+    TDelimitersSplit split(s, delims);
     TDelimitersSplit::TIterator it = split.Iterator();
     UNIT_ASSERT_EQUAL(it.GetTail(), "grp@2@4");
     it.Next();
diff --git a/library/cpp/lfalloc/lf_allocX64.cpp b/library/cpp/lfalloc/lf_allocX64.cpp
index 696295663c..2eb90761fe 100644
--- a/library/cpp/lfalloc/lf_allocX64.cpp
+++ b/library/cpp/lfalloc/lf_allocX64.cpp
@@ -114,7 +114,7 @@ extern "C" void* realloc(void* old_ptr, size_t new_size) {
     LFFree(old_ptr);
     return new_ptr;
 }
- 
+
 extern "C" size_t malloc_usable_size(void* ptr) {
     if (ptr == nullptr) {
         return 0;
diff --git a/library/cpp/logger/log.cpp b/library/cpp/logger/log.cpp
index f5d556dc62..e1d70cc3d2 100644
--- a/library/cpp/logger/log.cpp
+++ b/library/cpp/logger/log.cpp
@@ -172,7 +172,7 @@ void TLog::AddLog(ELogPriority priority, const char* format, ...) const {
     Impl_->AddLog(priority, format, args);
 }
 
-void TLog::AddLogVAList(const char* format, va_list lst) { 
+void TLog::AddLogVAList(const char* format, va_list lst) {
     Impl_->AddLog(Impl_->DefaultPriority(), format, lst);
 }
 
diff --git a/library/cpp/packedtypes/longs.h b/library/cpp/packedtypes/longs.h
index 9440c95fba..084098d705 100644
--- a/library/cpp/packedtypes/longs.h
+++ b/library/cpp/packedtypes/longs.h
@@ -8,25 +8,25 @@
 #define GET_8_OR(x, buf, type, shift) (x) |= (type) * (buf)++ << (shift)
 
 #if defined(_big_endian_)
-#define LO_SHIFT 1 
-#define HI_SHIFT 0 
+#define LO_SHIFT 1
+#define HI_SHIFT 0
 #elif defined(_little_endian_)
-#define LO_SHIFT 0 
-#define HI_SHIFT 1 
+#define LO_SHIFT 0
+#define HI_SHIFT 1
 #endif
 
 #if !defined(_must_align2_)
 #define PUT_16(x, buf, shift) WriteUnaligned<ui16>(buf, (x) >> (shift)), (buf) += 2
 #define GET_16_OR(x, buf, type, shift) (x) |= (type)ReadUnaligned<ui16>(buf) << (shift), (buf) += 2
-#else 
+#else
 #define PUT_16(x, buf, shift) PUT_8(x, buf, shift + 8 * LO_SHIFT), PUT_8(x, buf, shift + 8 * HI_SHIFT)
 #define GET_16_OR(x, buf, type, shift) GET_8_OR(x, buf, type, shift + 8 * LO_SHIFT), GET_8_OR(x, buf, type, shift + 8 * HI_SHIFT)
-#endif 
- 
+#endif
+
 #if !defined(_must_align4_)
 #define PUT_32(x, buf, shift) WriteUnaligned<ui32>(buf, (x) >> (shift)), (buf) += 4
 #define GET_32_OR(x, buf, type, shift) (x) |= (type)ReadUnaligned<ui32>(buf) << (shift), (buf) += 4
-#else 
+#else
 #define PUT_32(x, buf, shift) PUT_16(x, buf, shift + 16 * LO_SHIFT), PUT_16(x, buf, shift + 16 * HI_SHIFT)
 #define GET_32_OR(x, buf, type, shift) GET_16_OR(x, buf, type, shift + 16 * LO_SHIFT), GET_16_OR(x, buf, type, shift + 16 * HI_SHIFT)
 #endif
@@ -34,39 +34,39 @@
 #if !defined(_must_align8_)
 #define PUT_64(x, buf, shift) WriteUnaligned<ui64>(buf, (x) >> (shift)), (buf) += 8
 #define GET_64_OR(x, buf, type, shift) (x) |= (type)ReadUnaligned<ui64>(buf) << (shift), (buf) += 8
-#else 
+#else
 #define PUT_64(x, buf, shift) PUT_32(x, buf, shift + 32 * LO_SHIFT), PUT_32(x, buf, shift + 32 * HI_SHIFT)
 #define GET_64_OR(x, buf, type, shift) GET_32_OR(x, buf, type, shift + 32 * LO_SHIFT), GET_32_OR(x, buf, type, shift + 32 * HI_SHIFT)
 #endif
 
 struct mem_traits {
-    static ui8 get_8(const char*& mem) { 
-        ui8 x = 0; 
-        GET_8_OR(x, mem, ui8, 0); 
-        return x; 
-    } 
-    static ui16 get_16(const char*& mem) { 
-        ui16 x = 0; 
-        GET_16_OR(x, mem, ui16, 0); 
-        return x; 
-    } 
-    static ui32 get_32(const char*& mem) { 
-        ui32 x = 0; 
-        GET_32_OR(x, mem, ui32, 0); 
-        return x; 
-    } 
-    static void put_8(ui8 x, char*& mem) { 
-        PUT_8(x, mem, 0); 
-    } 
-    static void put_16(ui16 x, char*& mem) { 
-        PUT_16(x, mem, 0); 
-    } 
-    static void put_32(ui32 x, char*& mem) { 
-        PUT_32(x, mem, 0); 
-    } 
+    static ui8 get_8(const char*& mem) {
+        ui8 x = 0;
+        GET_8_OR(x, mem, ui8, 0);
+        return x;
+    }
+    static ui16 get_16(const char*& mem) {
+        ui16 x = 0;
+        GET_16_OR(x, mem, ui16, 0);
+        return x;
+    }
+    static ui32 get_32(const char*& mem) {
+        ui32 x = 0;
+        GET_32_OR(x, mem, ui32, 0);
+        return x;
+    }
+    static void put_8(ui8 x, char*& mem) {
+        PUT_8(x, mem, 0);
+    }
+    static void put_16(ui16 x, char*& mem) {
+        PUT_16(x, mem, 0);
+    }
+    static void put_32(ui32 x, char*& mem) {
+        PUT_32(x, mem, 0);
+    }
     static int is_good(char*&) {
-        return 1; 
-    } 
+        return 1;
+    }
 };
 
 /*
@@ -80,21 +80,21 @@ struct mem_traits {
 |iiii|iii1|****|****|****|****|****|****|****|****|****|****|****|****|****|****
 */
 
-#define PACK1LIM 0x80u 
-#define PACK2LIM 0x4000u 
-#define PACK3LIM 0x200000u 
-#define PACK4LIM 0x10000000u 
-#define PACK5LIM 0x800000000ull 
-#define PACK6LIM 0x40000000000ull 
-#define PACK7LIM 0x2000000000000ull 
-#define PACK8LIM 0x100000000000000ull 
+#define PACK1LIM 0x80u
+#define PACK2LIM 0x4000u
+#define PACK3LIM 0x200000u
+#define PACK4LIM 0x10000000u
+#define PACK5LIM 0x800000000ull
+#define PACK6LIM 0x40000000000ull
+#define PACK7LIM 0x2000000000000ull
+#define PACK8LIM 0x100000000000000ull
 
-#define MY_14(x) ((ui16)(x) < PACK1LIM ? 1 : 2) 
-#define MY_28(x) ((ui32)(x) < PACK2LIM ? MY_14(x) : ((ui32)(x) < PACK3LIM ? 3 : 4)) 
+#define MY_14(x) ((ui16)(x) < PACK1LIM ? 1 : 2)
+#define MY_28(x) ((ui32)(x) < PACK2LIM ? MY_14(x) : ((ui32)(x) < PACK3LIM ? 3 : 4))
 
-#define MY_32(x) ((ui32)(x) < PACK4LIM ? MY_28(x) : 5) 
+#define MY_32(x) ((ui32)(x) < PACK4LIM ? MY_28(x) : 5)
 #define MY_64(x) ((ui64)(x) < PACK4LIM ? MY_28(x) : ((ui64)(x) < PACK6LIM ? ((ui64)(x) < PACK5LIM ? 5 : 6) : ((ui64)(x) < PACK7LIM ? 7 : ((ui64)(x) < PACK8LIM ? 8 : 9))))
- 
+
 #if !defined(MACRO_BEGIN)
 #define MACRO_BEGIN do {
 #define MACRO_END \
diff --git a/library/cpp/packedtypes/packed.h b/library/cpp/packedtypes/packed.h
index 2cfadcb4d6..88cff26ae2 100644
--- a/library/cpp/packedtypes/packed.h
+++ b/library/cpp/packedtypes/packed.h
@@ -10,28 +10,28 @@
 struct Stream_traits {
     template <typename T>
     static T get(IInputStream& in) {
-        T x; 
-        ::Load(&in, x); 
-        return x; 
-    } 
+        T x;
+        ::Load(&in, x);
+        return x;
+    }
     static ui8 get_8(IInputStream& in) {
-        return get<ui8>(in); 
-    } 
+        return get<ui8>(in);
+    }
     static ui16 get_16(IInputStream& in) {
-        return get<ui16>(in); 
-    } 
+        return get<ui16>(in);
+    }
     static ui32 get_32(IInputStream& in) {
-        return get<ui32>(in); 
-    } 
+        return get<ui32>(in);
+    }
     static void put_8(ui8 x, IOutputStream& out) {
-        ::Save(&out, x); 
-    } 
+        ::Save(&out, x);
+    }
     static void put_16(ui16 x, IOutputStream& out) {
-        ::Save(&out, x); 
-    } 
+        ::Save(&out, x);
+    }
     static void put_32(ui32 x, IOutputStream& out) {
-        ::Save(&out, x); 
-    } 
+        ::Save(&out, x);
+    }
     static int is_good(IInputStream& /*in*/) {
         return 1;
     }
@@ -42,24 +42,24 @@ struct Stream_traits {
 
 struct TZCMemoryInput_traits {
     template <typename T>
-    static T get(TZCMemoryInput& in) { 
-        T x; 
+    static T get(TZCMemoryInput& in) {
+        T x;
         in.ReadPOD(x);
-        return x; 
+        return x;
     }
 
     static ui8 Y_FORCE_INLINE get_8(TZCMemoryInput& in) {
-        return get<ui8>(in); 
+        return get<ui8>(in);
     }
 
     static ui16 Y_FORCE_INLINE get_16(TZCMemoryInput& in) {
-        return get<ui16>(in); 
+        return get<ui16>(in);
     }
 
     static ui32 Y_FORCE_INLINE get_32(TZCMemoryInput& in) {
-        return get<ui32>(in); 
-    } 
- 
+        return get<ui32>(in);
+    }
+
     static int Y_FORCE_INLINE is_good(TZCMemoryInput&) {
         return 1;
     }
diff --git a/util/charset/wide.h b/util/charset/wide.h
index 9c163517cf..04e6928aab 100644
--- a/util/charset/wide.h
+++ b/util/charset/wide.h
@@ -82,7 +82,7 @@ inline wchar32 ReadSymbol(const wchar16* begin, const wchar16* end) noexcept {
     Y_ASSERT(begin < end);
     if (IsW16SurrogateLead(*begin)) {
         if (begin + 1 < end && IsW16SurrogateTail(*(begin + 1)))
-            return ::NDetail::ReadSurrogatePair(begin); 
+            return ::NDetail::ReadSurrogatePair(begin);
 
         return BROKEN_RUNE;
     } else if (IsW16SurrogateTail(*begin)) {
@@ -103,7 +103,7 @@ inline wchar32 ReadSymbolAndAdvance(const wchar16*& begin) noexcept {
     if (IsW16SurrogateLead(begin[0])) {
         if (IsW16SurrogateTail(begin[1])) {
             Y_ASSERT(begin[1] != 0);
-            const wchar32 c = ::NDetail::ReadSurrogatePair(begin); 
+            const wchar32 c = ::NDetail::ReadSurrogatePair(begin);
             begin += 2;
             return c;
         }
@@ -126,7 +126,7 @@ inline wchar32 ReadSymbolAndAdvance(const wchar16*& begin, const wchar16* end) n
     Y_ASSERT(begin < end);
     if (IsW16SurrogateLead(begin[0])) {
         if (begin + 1 != end && IsW16SurrogateTail(begin[1])) {
-            const wchar32 c = ::NDetail::ReadSurrogatePair(begin); 
+            const wchar32 c = ::NDetail::ReadSurrogatePair(begin);
             begin += 2;
             return c;
         }
@@ -157,7 +157,7 @@ inline size_t WriteSymbol(wchar32 s, T& dest) noexcept {
             return WriteSymbol(static_cast<wchar16>(BROKEN_RUNE), dest);
         }
 
-        ::NDetail::WriteSurrogatePair(s, dest); 
+        ::NDetail::WriteSurrogatePair(s, dest);
         return 2;
     }
 
@@ -176,7 +176,7 @@ inline bool WriteSymbol(wchar32 s, wchar16*& dest, const wchar16* destEnd) noexc
         if (dest + 2 > destEnd)
             return false;
 
-        ::NDetail::WriteSurrogatePair(s, dest); 
+        ::NDetail::WriteSurrogatePair(s, dest);
     } else {
         *(dest++) = static_cast<wchar16>(s);
     }
diff --git a/util/generic/hash_set.h b/util/generic/hash_set.h
index 593d24ff51..e8088cf23b 100644
--- a/util/generic/hash_set.h
+++ b/util/generic/hash_set.h
@@ -161,10 +161,10 @@ public:
         return std::pair<iterator, bool>(p.first, p.second);
     }
     template <typename... Args>
-    std::pair<iterator, bool> emplace(Args&&... args) { 
-        std::pair<mutable_iterator, bool> p = rep.emplace_unique(std::forward<Args>(args)...); 
-        return std::pair<iterator, bool>(p.first, p.second); 
-    } 
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        std::pair<mutable_iterator, bool> p = rep.emplace_unique(std::forward<Args>(args)...);
+        return std::pair<iterator, bool>(p.first, p.second);
+    }
 
     iterator insert(const_iterator, const value_type& obj) { // insert_hint
         std::pair<mutable_iterator, bool> p = rep.insert_unique(obj);
@@ -176,10 +176,10 @@ public:
         return std::pair<iterator, bool>(p.first, p.second);
     }
     template <typename... Args>
-    std::pair<iterator, bool> emplace_noresize(Args&&... args) { 
-        std::pair<mutable_iterator, bool> p = rep.emplace_unique_noresize(std::forward<Args>(args)...); 
-        return std::pair<iterator, bool>(p.first, p.second); 
-    } 
+    std::pair<iterator, bool> emplace_noresize(Args&&... args) {
+        std::pair<mutable_iterator, bool> p = rep.emplace_unique_noresize(std::forward<Args>(args)...);
+        return std::pair<iterator, bool>(p.first, p.second);
+    }
 
     template <class TheObj>
     iterator insert_direct(const TheObj& obj, const insert_ctx& ins) {
diff --git a/util/generic/hash_ut.cpp b/util/generic/hash_ut.cpp
index de3cb3e588..0551d58770 100644
--- a/util/generic/hash_ut.cpp
+++ b/util/generic/hash_ut.cpp
@@ -45,7 +45,7 @@ class THashTest: public TTestBase {
     UNIT_TEST(TestHMMapEmplace);
     UNIT_TEST(TestHMMapEmplaceNoresize);
     UNIT_TEST(TestHMMapEmplaceDirect);
-    UNIT_TEST(TestHSetEmplace); 
+    UNIT_TEST(TestHSetEmplace);
     UNIT_TEST(TestHSetEmplaceNoresize);
     UNIT_TEST(TestHSetEmplaceDirect);
     UNIT_TEST(TestNonCopyable);
@@ -93,7 +93,7 @@ protected:
     void TestEmplaceDirect();
     void TestTryEmplace();
     void TestTryEmplaceCopyKey();
-    void TestHSetEmplace(); 
+    void TestHSetEmplace();
     void TestHSetEmplaceNoresize();
     void TestHSetEmplaceDirect();
     void TestHMMapEmplace();
@@ -1007,11 +1007,11 @@ void THashTest::TestHMMapEmplaceDirect() {
     UNIT_ASSERT_VALUES_EQUAL(static_cast<int>(it->second), 0);
 }
 
-void THashTest::TestHSetEmplace() { 
+void THashTest::TestHSetEmplace() {
     using hash_t = THashSet<TNonCopyableInt<0>, THash<int>, TEqualTo<int>>;
     hash_t hash;
     UNIT_ASSERT(!hash.contains(0));
-    hash.emplace(0); 
+    hash.emplace(0);
     UNIT_ASSERT(hash.contains(0));
     UNIT_ASSERT(!hash.contains(1));
 }
@@ -1021,11 +1021,11 @@ void THashTest::TestHSetEmplaceNoresize() {
     hash_t hash;
     hash.reserve(1);
     UNIT_ASSERT(!hash.contains(0));
-    hash.emplace_noresize(0); 
+    hash.emplace_noresize(0);
     UNIT_ASSERT(hash.contains(0));
     UNIT_ASSERT(!hash.contains(1));
-} 
- 
+}
+
 void THashTest::TestHSetEmplaceDirect() {
     using hash_t = THashSet<TNonCopyableInt<0>, THash<int>, TEqualTo<int>>;
     hash_t hash;
diff --git a/util/memory/pool.h b/util/memory/pool.h
index cc51e96e70..13c8b6b9ed 100644
--- a/util/memory/pool.h
+++ b/util/memory/pool.h
@@ -189,8 +189,8 @@ public:
         return ptr;
     }
 
-    template <typename T, typename... Args> 
-    inline T* New(Args&&... args) { 
+    template <typename T, typename... Args>
+    inline T* New(Args&&... args) {
         return new (Allocate<T>()) T(std::forward<Args>(args)...);
     }
 
diff --git a/util/memory/pool_ut.cpp b/util/memory/pool_ut.cpp
index aa4ff9ca6c..1158a8ca42 100644
--- a/util/memory/pool_ut.cpp
+++ b/util/memory/pool_ut.cpp
@@ -135,9 +135,9 @@ private:
         }
 
         alloc.CheckAtEnd();
- 
-        struct TConstructorTest { 
-            int ConstructorType; 
+
+        struct TConstructorTest {
+            int ConstructorType;
             TConstructorTest()
                 : ConstructorType(1)
             {
@@ -154,19 +154,19 @@ private:
                 : ConstructorType(4)
             {
             }
-        }; 
- 
-        { 
-            TMemoryPool pool(123, TMemoryPool::TExpGrow::Instance(), &alloc); 
+        };
+
+        {
+            TMemoryPool pool(123, TMemoryPool::TExpGrow::Instance(), &alloc);
             THolder<TConstructorTest, TDestructor> data1{pool.New<TConstructorTest>()};
             THolder<TConstructorTest, TDestructor> data2{pool.New<TConstructorTest>(42)};
             THolder<TConstructorTest, TDestructor> data3{pool.New<TConstructorTest>("hello", "world")};
-            UNIT_ASSERT_VALUES_EQUAL(data1->ConstructorType, 1); 
-            UNIT_ASSERT_VALUES_EQUAL(data2->ConstructorType, 2); 
-            UNIT_ASSERT_VALUES_EQUAL(data3->ConstructorType, 4); 
-        } 
- 
-        alloc.CheckAtEnd(); 
+            UNIT_ASSERT_VALUES_EQUAL(data1->ConstructorType, 1);
+            UNIT_ASSERT_VALUES_EQUAL(data2->ConstructorType, 2);
+            UNIT_ASSERT_VALUES_EQUAL(data3->ConstructorType, 4);
+        }
+
+        alloc.CheckAtEnd();
     }
 
     inline void TestAlign() {
diff --git a/util/random/fast.h b/util/random/fast.h
index f86b56c625..ddc5711641 100644
--- a/util/random/fast.h
+++ b/util/random/fast.h
@@ -73,10 +73,10 @@ public:
     }
 
     inline void Advance(ui64 delta) noexcept {
-        R1_.Advance(delta); 
-        R2_.Advance(delta); 
-    } 
- 
+        R1_.Advance(delta);
+        R2_.Advance(delta);
+    }
+
 private:
     TFastRng32Base R1_;
     TFastRng32Base R2_;
diff --git a/util/random/fast_ut.cpp b/util/random/fast_ut.cpp
index a641a30071..60994a98b0 100644
--- a/util/random/fast_ut.cpp
+++ b/util/random/fast_ut.cpp
@@ -42,34 +42,34 @@ Y_UNIT_TEST_SUITE(TTestFastRng) {
             UNIT_ASSERT_VALUES_EQUAL(rng.Uniform(100u), i);
         }
     }
- 
+
     Y_UNIT_TEST(TestAdvance) {
-        TReallyFastRng32 rng1(17); 
-        TReallyFastRng32 rng2(17); 
+        TReallyFastRng32 rng1(17);
+        TReallyFastRng32 rng2(17);
         for (size_t i = 0; i < 100; i++) {
-            rng1.GenRand(); 
+            rng1.GenRand();
         }
-        rng2.Advance(100); 
-        UNIT_ASSERT_VALUES_EQUAL(rng1.GenRand(), rng2.GenRand()); 
- 
-        TFastRng64 rng3(0, 1, 2, 3); 
-        TFastRng64 rng4(0, 1, 2, 3); 
+        rng2.Advance(100);
+        UNIT_ASSERT_VALUES_EQUAL(rng1.GenRand(), rng2.GenRand());
+
+        TFastRng64 rng3(0, 1, 2, 3);
+        TFastRng64 rng4(0, 1, 2, 3);
         for (size_t i = 0; i < 100; i++) {
-            rng3.GenRand(); 
+            rng3.GenRand();
         }
-        rng4.Advance(100); 
-        UNIT_ASSERT_VALUES_EQUAL(rng3.GenRand(), rng4.GenRand()); 
-    } 
- 
+        rng4.Advance(100);
+        UNIT_ASSERT_VALUES_EQUAL(rng3.GenRand(), rng4.GenRand());
+    }
+
     Y_UNIT_TEST(TestAdvanceBoundaries) {
-        TReallyFastRng32 rng1(17); 
-        TReallyFastRng32 rng2(17); 
-        TReallyFastRng32 rng3(17); 
-        rng2.Advance(0); 
-        rng3.Advance(1); 
-        UNIT_ASSERT_VALUES_EQUAL(rng1.GenRand(), rng2.GenRand()); 
-        UNIT_ASSERT_VALUES_EQUAL(rng1.GenRand(), rng3.GenRand()); 
-    } 
+        TReallyFastRng32 rng1(17);
+        TReallyFastRng32 rng2(17);
+        TReallyFastRng32 rng3(17);
+        rng2.Advance(0);
+        rng3.Advance(1);
+        UNIT_ASSERT_VALUES_EQUAL(rng1.GenRand(), rng2.GenRand());
+        UNIT_ASSERT_VALUES_EQUAL(rng1.GenRand(), rng3.GenRand());
+    }
 
     Y_UNIT_TEST(TestCopy) {
         TReallyFastRng32 r1(1);
diff --git a/util/random/lcg_engine.cpp b/util/random/lcg_engine.cpp
index e875705bcf..e1469104fa 100644
--- a/util/random/lcg_engine.cpp
+++ b/util/random/lcg_engine.cpp
@@ -1,30 +1,30 @@
 #include "lcg_engine.h"
- 
-namespace NPrivate { 
-    template <typename T> 
+
+namespace NPrivate {
+    template <typename T>
     T LcgAdvance(T seed, T lcgBase, T lcgAddend, T delta) noexcept {
-        // seed[n+1] = A * seed[n] + B, A = lcgBase, B = lcgAddend 
-        // seed[n] = A**n * seed[0] + (A**n - 1) / (A - 1) * B 
-        // (initial value of n) = m * 2**k + (lower bits of n) 
-        T mask = 1; 
-        while (mask != (1ULL << (8 * sizeof(T) - 1)) && (mask << 1) <= delta) { 
-            mask <<= 1; 
-        } 
-        T apow = 1; // A**m 
-        T adiv = 0; // (A**m-1)/(A-1) 
-        for (; mask; mask >>= 1) { 
-            // m *= 2 
-            adiv *= apow + 1; 
-            apow *= apow; 
-            if (delta & mask) { 
-                // m++ 
-                adiv += apow; 
-                apow *= lcgBase; 
-            } 
-        } 
-        return seed * apow + lcgAddend * adiv; 
-    } 
- 
+        // seed[n+1] = A * seed[n] + B, A = lcgBase, B = lcgAddend
+        // seed[n] = A**n * seed[0] + (A**n - 1) / (A - 1) * B
+        // (initial value of n) = m * 2**k + (lower bits of n)
+        T mask = 1;
+        while (mask != (1ULL << (8 * sizeof(T) - 1)) && (mask << 1) <= delta) {
+            mask <<= 1;
+        }
+        T apow = 1; // A**m
+        T adiv = 0; // (A**m-1)/(A-1)
+        for (; mask; mask >>= 1) {
+            // m *= 2
+            adiv *= apow + 1;
+            apow *= apow;
+            if (delta & mask) {
+                // m++
+                adiv += apow;
+                apow *= lcgBase;
+            }
+        }
+        return seed * apow + lcgAddend * adiv;
+    }
+
     template ui32 LcgAdvance<ui32>(ui32, ui32, ui32, ui32) noexcept;
     template ui64 LcgAdvance<ui64>(ui64, ui64, ui64, ui64) noexcept;
 }
diff --git a/util/random/lcg_engine.h b/util/random/lcg_engine.h
index 0de277cb66..08cc93c845 100644
--- a/util/random/lcg_engine.h
+++ b/util/random/lcg_engine.h
@@ -6,11 +6,11 @@
 // common engine for lcg-based RNG's
 // http://en.wikipedia.org/wiki/Linear_congruential_generator
 
-namespace NPrivate { 
-    template <typename T> 
+namespace NPrivate {
+    template <typename T>
     T LcgAdvance(T seed, T lcgBase, T lcgAddend, T delta) noexcept;
-}; 
- 
+};
+
 template <typename T, T A, T C>
 struct TFastLcgIterator {
     static_assert(C % 2 == 1, "C must be odd");
@@ -18,10 +18,10 @@ struct TFastLcgIterator {
     static constexpr T Iterate(T x) noexcept {
         return x * A + C;
     }
- 
+
     static inline T IterateMultiple(T x, T delta) noexcept {
-        return ::NPrivate::LcgAdvance(x, A, C, delta); 
-    } 
+        return ::NPrivate::LcgAdvance(x, A, C, delta);
+    }
 };
 
 template <typename T, T A>
@@ -36,9 +36,9 @@ struct TLcgIterator {
     }
 
     inline T IterateMultiple(T x, T delta) noexcept {
-        return ::NPrivate::LcgAdvance(x, A, C, delta); 
-    } 
- 
+        return ::NPrivate::LcgAdvance(x, A, C, delta);
+    }
+
     const T C;
 };
 
@@ -59,8 +59,8 @@ struct TLcgRngBase: public TIterator, public TMixer {
     }
 
     inline void Advance(TStateType delta) noexcept {
-        X = this->IterateMultiple(X, delta); 
-    } 
- 
+        X = this->IterateMultiple(X, delta);
+    }
+
     TStateType X;
 };
diff --git a/util/stream/format.h b/util/stream/format.h
index 057d5de71c..b033208a1b 100644
--- a/util/stream/format.h
+++ b/util/stream/format.h
@@ -38,11 +38,11 @@ namespace NFormatPrivate {
 
     template <typename T>
     struct TLeftPad {
-        T Value; 
+        T Value;
         size_t Width;
         char Padc;
 
-        inline TLeftPad(const T& value, size_t width, char padc) 
+        inline TLeftPad(const T& value, size_t width, char padc)
             : Value(value)
             , Width(width)
             , Padc(padc)
@@ -54,7 +54,7 @@ namespace NFormatPrivate {
     IOutputStream& operator<<(IOutputStream& o, const TLeftPad<T>& lp) {
         TTempBuf buf;
         TMemoryOutput ss(buf.Data(), buf.Size());
-        ss << lp.Value; 
+        ss << lp.Value;
         size_t written = buf.Size() - ss.Avail();
         if (lp.Width > written) {
             WriteChars(o, lp.Padc, lp.Width - written);
@@ -65,11 +65,11 @@ namespace NFormatPrivate {
 
     template <typename T>
     struct TRightPad {
-        T Value; 
+        T Value;
         size_t Width;
         char Padc;
 
-        inline TRightPad(const T& value, size_t width, char padc) 
+        inline TRightPad(const T& value, size_t width, char padc)
             : Value(value)
             , Width(width)
             , Padc(padc)
@@ -81,7 +81,7 @@ namespace NFormatPrivate {
     IOutputStream& operator<<(IOutputStream& o, const TRightPad<T>& lp) {
         TTempBuf buf;
         TMemoryOutput ss(buf.Data(), buf.Size());
-        ss << lp.Value; 
+        ss << lp.Value;
         size_t written = buf.Size() - ss.Avail();
         o.Write(buf.Data(), written);
         if (lp.Width > written) {
@@ -152,24 +152,24 @@ namespace NFormatPrivate {
         }
         return os;
     }
- 
+
     template <typename T>
-    struct TFloatPrecision { 
+    struct TFloatPrecision {
         using TdVal = std::remove_cv_t<T>;
         static_assert(std::is_floating_point<TdVal>::value, "expect std::is_floating_point<TdVal>::value");
- 
-        TdVal Value; 
-        EFloatToStringMode Mode; 
-        int NDigits; 
-    }; 
- 
+
+        TdVal Value;
+        EFloatToStringMode Mode;
+        int NDigits;
+    };
+
     template <typename T>
     IOutputStream& operator<<(IOutputStream& o, const TFloatPrecision<T>& prec) {
-        char buf[512]; 
-        size_t count = FloatToString(prec.Value, buf, sizeof(buf), prec.Mode, prec.NDigits); 
-        o << TStringBuf(buf, count); 
-        return o; 
-    } 
+        char buf[512];
+        size_t count = FloatToString(prec.Value, buf, sizeof(buf), prec.Mode, prec.NDigits);
+        o << TStringBuf(buf, count);
+        return o;
+    }
 
     struct THumanReadableDuration {
         TDuration Value;
@@ -205,14 +205,14 @@ namespace NFormatPrivate {
  */
 template <typename T>
 static constexpr ::NFormatPrivate::TLeftPad<T> LeftPad(const T& value, const size_t width, const char padc = ' ') noexcept {
-    return ::NFormatPrivate::TLeftPad<T>(value, width, padc); 
+    return ::NFormatPrivate::TLeftPad<T>(value, width, padc);
 }
 
 template <typename T, int N>
 static constexpr ::NFormatPrivate::TLeftPad<const T*> LeftPad(const T (&value)[N], const size_t width, const char padc = ' ') noexcept {
-    return ::NFormatPrivate::TLeftPad<const T*>(value, width, padc); 
-} 
- 
+    return ::NFormatPrivate::TLeftPad<const T*>(value, width, padc);
+}
+
 /**
  * Output manipulator similar to `std::setw` and `std::setfill`.
  *
@@ -231,14 +231,14 @@ static constexpr ::NFormatPrivate::TLeftPad<const T*> LeftPad(const T (&value)[N
  */
 template <typename T>
 static constexpr ::NFormatPrivate::TRightPad<T> RightPad(const T& value, const size_t width, const char padc = ' ') noexcept {
-    return ::NFormatPrivate::TRightPad<T>(value, width, padc); 
+    return ::NFormatPrivate::TRightPad<T>(value, width, padc);
 }
 
 template <typename T, int N>
 static constexpr ::NFormatPrivate::TRightPad<const T*> RightPad(const T (&value)[N], const size_t width, const char padc = ' ') noexcept {
-    return ::NFormatPrivate::TRightPad<const T*>(value, width, padc); 
-} 
- 
+    return ::NFormatPrivate::TRightPad<const T*>(value, width, padc);
+}
+
 /**
  * Output manipulator similar to `std::setbase(16)`.
  *
@@ -402,7 +402,7 @@ static constexpr ::NFormatPrivate::THumanReadableSize HumanReadableSize(const do
 
 void Time(IOutputStream& l);
 void TimeHumanReadable(IOutputStream& l);
- 
+
 /**
  * Output manipulator for adjusting precision of floating point values.
  *
@@ -419,11 +419,11 @@ void TimeHumanReadable(IOutputStream& l);
  * @param ndigits                       Number of significant digits (in `PREC_NDIGITS` and `PREC_POINT_DIGITS` mode).
  * @see EFloatToStringMode
  */
-template <typename T> 
+template <typename T>
 static constexpr ::NFormatPrivate::TFloatPrecision<T> Prec(const T& value, const EFloatToStringMode mode, const int ndigits = 0) noexcept {
-    return {value, mode, ndigits}; 
-} 
- 
+    return {value, mode, ndigits};
+}
+
 /**
  * Output manipulator for adjusting precision of floating point values.
  *
@@ -440,5 +440,5 @@ static constexpr ::NFormatPrivate::TFloatPrecision<T> Prec(const T& value, const
  */
 template <typename T>
 static constexpr ::NFormatPrivate::TFloatPrecision<T> Prec(const T& value, const int ndigits) noexcept {
-    return {value, PREC_NDIGITS, ndigits}; 
-} 
+    return {value, PREC_NDIGITS, ndigits};
+}
diff --git a/util/stream/format_ut.cpp b/util/stream/format_ut.cpp
index b58052e319..43245aeb48 100644
--- a/util/stream/format_ut.cpp
+++ b/util/stream/format_ut.cpp
@@ -30,21 +30,21 @@ Y_UNIT_TEST_SUITE(TOutputStreamFormattingTest) {
         ss << "[" << Time << "] "
            << "qwqw" << TimeHumanReadable << Endl;
     }
- 
+
     Y_UNIT_TEST(TestHexReference) {
-        /* 
-            One possible implementation of Hex() stores a reference to the given object. 
-            This can lead to wrong results if the given object is a temporary 
-            which is valid only during constructor call. The following code tries to 
-            demonstrate this. If the implementation stores a reference, 
-            the test fails if compiled with g++44 in debug build 
-            (without optimizations), but performs correctly in release build. 
-        */ 
-        THolder<TStringStream> ss(new TStringStream); 
-        THolder<int> ii(new int(0x1234567)); 
-        (*ss) << Hex(*ii); 
-        UNIT_ASSERT_VALUES_EQUAL("0x01234567", ss->Str()); 
-    } 
+        /*
+            One possible implementation of Hex() stores a reference to the given object.
+            This can lead to wrong results if the given object is a temporary
+            which is valid only during constructor call. The following code tries to
+            demonstrate this. If the implementation stores a reference,
+            the test fails if compiled with g++44 in debug build
+            (without optimizations), but performs correctly in release build.
+        */
+        THolder<TStringStream> ss(new TStringStream);
+        THolder<int> ii(new int(0x1234567));
+        (*ss) << Hex(*ii);
+        UNIT_ASSERT_VALUES_EQUAL("0x01234567", ss->Str());
+    }
 
     Y_UNIT_TEST(TestHexText) {
         {
@@ -59,7 +59,7 @@ Y_UNIT_TEST_SUITE(TOutputStreamFormattingTest) {
             UNIT_ASSERT_VALUES_EQUAL("0061 0062 0063 0438", ss.Str());
         }
     }
- 
+
     Y_UNIT_TEST(TestBin) {
         UNIT_ASSERT_VALUES_EQUAL(ToString(Bin(static_cast<ui32>(2), nullptr)), "10");
         UNIT_ASSERT_VALUES_EQUAL(ToString(SBin(static_cast<i32>(-2), nullptr)), "-10");
@@ -82,18 +82,18 @@ Y_UNIT_TEST_SUITE(TOutputStreamFormattingTest) {
     }
 
     Y_UNIT_TEST(TestPrec) {
-        TStringStream ss; 
-        ss << Prec(1.2345678901234567, PREC_AUTO); 
-        UNIT_ASSERT_VALUES_EQUAL("1.2345678901234567", ss.Str()); 
- 
-        ss.Clear(); 
-        ss << Prec(1.2345678901234567, 3); 
-        UNIT_ASSERT_VALUES_EQUAL("1.23", ss.Str()); 
- 
-        ss.Clear(); 
-        ss << Prec(1.2345678901234567, PREC_POINT_DIGITS, 3); 
-        UNIT_ASSERT_VALUES_EQUAL("1.235", ss.Str()); 
-    } 
+        TStringStream ss;
+        ss << Prec(1.2345678901234567, PREC_AUTO);
+        UNIT_ASSERT_VALUES_EQUAL("1.2345678901234567", ss.Str());
+
+        ss.Clear();
+        ss << Prec(1.2345678901234567, 3);
+        UNIT_ASSERT_VALUES_EQUAL("1.23", ss.Str());
+
+        ss.Clear();
+        ss << Prec(1.2345678901234567, PREC_POINT_DIGITS, 3);
+        UNIT_ASSERT_VALUES_EQUAL("1.235", ss.Str());
+    }
 
     Y_UNIT_TEST(TestHumanReadableSize1000) {
         UNIT_ASSERT_VALUES_EQUAL(ToString(HumanReadableSize(0, SF_QUANTITY)), "0");
diff --git a/util/string/cast.h b/util/string/cast.h
index f5ef2aa184..90e925c194 100644
--- a/util/string/cast.h
+++ b/util/string/cast.h
@@ -29,7 +29,7 @@ inline size_t ToString(const T& t, char* buf, size_t len) {
 /**
  * Floating point to string conversion mode, values are enforced by `dtoa_impl.cpp`.
  */
-enum EFloatToStringMode { 
+enum EFloatToStringMode {
     /** 0.1f -> "0.1", 0.12345678f -> "0.12345678", ignores ndigits. */
     PREC_AUTO = 0,
 
@@ -44,18 +44,18 @@ enum EFloatToStringMode {
     /** same as PREC_POINT_DIGITS, but stripping trailing zeroes:
      * 0.1f for ndgigits=6 -> "0.1" */
     PREC_POINT_DIGITS_STRIP_ZEROES = 4
-}; 
- 
-size_t FloatToString(float t, char* buf, size_t len, EFloatToStringMode mode = PREC_AUTO, int ndigits = 0); 
-size_t FloatToString(double t, char* buf, size_t len, EFloatToStringMode mode = PREC_AUTO, int ndigits = 0); 
- 
+};
+
+size_t FloatToString(float t, char* buf, size_t len, EFloatToStringMode mode = PREC_AUTO, int ndigits = 0);
+size_t FloatToString(double t, char* buf, size_t len, EFloatToStringMode mode = PREC_AUTO, int ndigits = 0);
+
 template <typename T>
 inline TString FloatToString(const T& t, EFloatToStringMode mode = PREC_AUTO, int ndigits = 0) {
-    char buf[512]; // Max<double>() with mode = PREC_POINT_DIGITS has 309 digits before the decimal point 
-    size_t count = FloatToString(t, buf, sizeof(buf), mode, ndigits); 
+    char buf[512]; // Max<double>() with mode = PREC_POINT_DIGITS has 309 digits before the decimal point
+    size_t count = FloatToString(t, buf, sizeof(buf), mode, ndigits);
     return TString(buf, count);
-} 
- 
+}
+
 namespace NPrivate {
     template <class T, bool isSimple>
     struct TToString {
diff --git a/util/string/cast_ut.cpp b/util/string/cast_ut.cpp
index 44905181b9..033450c38c 100644
--- a/util/string/cast_ut.cpp
+++ b/util/string/cast_ut.cpp
@@ -253,11 +253,11 @@ Y_UNIT_TEST_SUITE(TCastTest) {
     }
 
     Y_UNIT_TEST(TestFloats) {
-        // "%g" mode 
+        // "%g" mode
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(0.1f, PREC_NDIGITS, 6), "0.1"); // drop trailing zeroes
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(0.12345678f, PREC_NDIGITS, 6), "0.123457");
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(1e-20f, PREC_NDIGITS, 6), "1e-20");
-        // "%f" mode 
+        // "%f" mode
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(0.1f, PREC_POINT_DIGITS, 6), "0.100000");
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(0.12345678f, PREC_POINT_DIGITS, 6), "0.123457");
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(1e-20f, PREC_POINT_DIGITS, 6), "0.000000");
@@ -268,13 +268,13 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(1e-20f, PREC_POINT_DIGITS_STRIP_ZEROES, 6), "0");
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(12.34f, PREC_POINT_DIGITS_STRIP_ZEROES, 0), "12"); // rounding to integers drops '.'
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(10000.0f, PREC_POINT_DIGITS_STRIP_ZEROES, 0), "10000");
-        // automatic selection of ndigits 
+        // automatic selection of ndigits
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(0.1f), "0.1");               // drop trailing zeroes
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(0.12345678f), "0.12345678"); // 8 valid digits
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(1000.00006f), "1000.00006"); // 9 valid digits
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(1e-45f), "1e-45");           // denormalized: 1 valid digit
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(-0.0f), "-0");               // sign must be preserved
-        // version for double 
+        // version for double
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(1.0 / 10000), "0.0001");                    // trailing zeroes
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(1.2345678901234567), "1.2345678901234567"); // no truncation
         UNIT_ASSERT_VALUES_EQUAL(FloatToString(5e-324), "5e-324");                         // denormalized
diff --git a/util/system/env.h b/util/system/env.h
index d7313d4944..e2ccdd1e95 100644
--- a/util/system/env.h
+++ b/util/system/env.h
@@ -11,7 +11,7 @@
  * @return      String that is associated with the matched environment variable or empty string if
  *              such variable is missing.
  *
- * @note        Use it only in pair with `SetEnv` as there may be inconsistency in their behaviour 
+ * @note        Use it only in pair with `SetEnv` as there may be inconsistency in their behaviour
  *              otherwise.
  * @note        Calls to `GetEnv` and `SetEnv` from different threads must be synchronized.
  * @see         SetEnv
@@ -24,7 +24,7 @@ TString GetEnv(const TString& key, const TString& def = TString());
  * @key         String identifying the name of the environment variable to set or change
  * @value       Value to assign
 
- * @note        Use it only in pair with `GetEnv` as there may be inconsistency in their behaviour 
+ * @note        Use it only in pair with `GetEnv` as there may be inconsistency in their behaviour
  *              otherwise.
  * @note        Calls to `GetEnv` and `SetEnv` from different threads must be synchronized.
  * @see         GetEnv
diff --git a/util/system/mem_info.cpp b/util/system/mem_info.cpp
index 8a39a27393..aa51ae3b16 100644
--- a/util/system/mem_info.cpp
+++ b/util/system/mem_info.cpp
@@ -21,79 +21,79 @@
     #elif defined(__MACH__) && defined(__APPLE__)
         #include <mach/mach.h>
     #endif
-#elif defined(_win_) 
+#elif defined(_win_)
     #include <Windows.h>
     #include <util/generic/ptr.h>
- 
+
 using NTSTATUS = LONG;
     #define STATUS_INFO_LENGTH_MISMATCH 0xC0000004
     #define STATUS_BUFFER_TOO_SMALL 0xC0000023
- 
-typedef struct _UNICODE_STRING { 
-    USHORT Length; 
-    USHORT MaximumLength; 
-    PWSTR Buffer; 
-} UNICODE_STRING, *PUNICODE_STRING; 
+
+typedef struct _UNICODE_STRING {
+    USHORT Length;
+    USHORT MaximumLength;
+    PWSTR Buffer;
+} UNICODE_STRING, *PUNICODE_STRING;
 typedef struct _CLIENT_ID {
-    HANDLE UniqueProcess; 
-    HANDLE UniqueThread; 
-} CLIENT_ID, *PCLIENT_ID; 
+    HANDLE UniqueProcess;
+    HANDLE UniqueThread;
+} CLIENT_ID, *PCLIENT_ID;
 using KWAIT_REASON = ULONG;
 typedef struct _SYSTEM_THREAD_INFORMATION {
-    LARGE_INTEGER KernelTime; 
-    LARGE_INTEGER UserTime; 
-    LARGE_INTEGER CreateTime; 
-    ULONG WaitTime; 
-    PVOID StartAddress; 
-    CLIENT_ID ClientId; 
-    LONG Priority; 
-    LONG BasePriority; 
-    ULONG ContextSwitches; 
-    ULONG ThreadState; 
-    KWAIT_REASON WaitReason; 
-} SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION; 
+    LARGE_INTEGER KernelTime;
+    LARGE_INTEGER UserTime;
+    LARGE_INTEGER CreateTime;
+    ULONG WaitTime;
+    PVOID StartAddress;
+    CLIENT_ID ClientId;
+    LONG Priority;
+    LONG BasePriority;
+    ULONG ContextSwitches;
+    ULONG ThreadState;
+    KWAIT_REASON WaitReason;
+} SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION;
 typedef struct _SYSTEM_PROCESS_INFORMATION {
-    ULONG NextEntryOffset; 
-    ULONG NumberOfThreads; 
-    LARGE_INTEGER SpareLi1; 
-    LARGE_INTEGER SpareLi2; 
-    LARGE_INTEGER SpareLi3; 
-    LARGE_INTEGER CreateTime; 
-    LARGE_INTEGER UserTime; 
-    LARGE_INTEGER KernelTime; 
-    UNICODE_STRING ImageName; 
-    LONG BasePriority; 
-    HANDLE UniqueProcessId; 
-    HANDLE InheritedFromUniqueProcessId; 
-    ULONG HandleCount; 
-    ULONG SessionId; 
-    ULONG_PTR PageDirectoryBase; 
-    SIZE_T PeakVirtualSize; 
-    SIZE_T VirtualSize; 
-    DWORD PageFaultCount; 
-    SIZE_T PeakWorkingSetSize; 
-    SIZE_T WorkingSetSize; 
-    SIZE_T QuotaPeakPagedPoolUsage; 
-    SIZE_T QuotaPagedPoolUsage; 
-    SIZE_T QuotaPeakNonPagedPoolUsage; 
-    SIZE_T QuotaNonPagedPoolUsage; 
-    SIZE_T PagefileUsage; 
-    SIZE_T PeakPagefileUsage; 
-    SIZE_T PrivatePageCount; 
-    LARGE_INTEGER ReadOperationCount; 
-    LARGE_INTEGER WriteOperationCount; 
-    LARGE_INTEGER OtherOperationCount; 
-    LARGE_INTEGER ReadTransferCount; 
-    LARGE_INTEGER WriteTransferCount; 
-    LARGE_INTEGER OtherTransferCount; 
-    SYSTEM_THREAD_INFORMATION Threads[1]; 
-} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION; 
- 
-typedef enum _SYSTEM_INFORMATION_CLASS { 
-    SystemBasicInformation = 0, 
-    SystemProcessInformation = 5, 
-} SYSTEM_INFORMATION_CLASS; 
- 
+    ULONG NextEntryOffset;
+    ULONG NumberOfThreads;
+    LARGE_INTEGER SpareLi1;
+    LARGE_INTEGER SpareLi2;
+    LARGE_INTEGER SpareLi3;
+    LARGE_INTEGER CreateTime;
+    LARGE_INTEGER UserTime;
+    LARGE_INTEGER KernelTime;
+    UNICODE_STRING ImageName;
+    LONG BasePriority;
+    HANDLE UniqueProcessId;
+    HANDLE InheritedFromUniqueProcessId;
+    ULONG HandleCount;
+    ULONG SessionId;
+    ULONG_PTR PageDirectoryBase;
+    SIZE_T PeakVirtualSize;
+    SIZE_T VirtualSize;
+    DWORD PageFaultCount;
+    SIZE_T PeakWorkingSetSize;
+    SIZE_T WorkingSetSize;
+    SIZE_T QuotaPeakPagedPoolUsage;
+    SIZE_T QuotaPagedPoolUsage;
+    SIZE_T QuotaPeakNonPagedPoolUsage;
+    SIZE_T QuotaNonPagedPoolUsage;
+    SIZE_T PagefileUsage;
+    SIZE_T PeakPagefileUsage;
+    SIZE_T PrivatePageCount;
+    LARGE_INTEGER ReadOperationCount;
+    LARGE_INTEGER WriteOperationCount;
+    LARGE_INTEGER OtherOperationCount;
+    LARGE_INTEGER ReadTransferCount;
+    LARGE_INTEGER WriteTransferCount;
+    LARGE_INTEGER OtherTransferCount;
+    SYSTEM_THREAD_INFORMATION Threads[1];
+} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
+
+typedef enum _SYSTEM_INFORMATION_CLASS {
+    SystemBasicInformation = 0,
+    SystemProcessInformation = 5,
+} SYSTEM_INFORMATION_CLASS;
+
 #else
 
 #endif
@@ -173,15 +173,15 @@ namespace NMemInfo {
         Y_UNUSED(pid);
         ythrow yexception() << "arm is not supported";
     #endif
-#elif defined(_win_) 
+#elif defined(_win_)
         if (!pid) {
             pid = GetCurrentProcessId();
         }
- 
+
         NTSTATUS status;
         TArrayHolder<char> buffer;
         ULONG bufferSize;
- 
+
         // Query data for all processes and threads in the system.
         // This is probably an overkill if the target process is normal not-privileged one,
         // but allows to obtain information even about system processes that are not open-able directly.
@@ -201,7 +201,7 @@ namespace NMemInfo {
                 ythrow yexception() << "NtQuerySystemInformation failed with status code " << status;
             }
         }
- 
+
         SYSTEM_PROCESS_INFORMATION* process = (SYSTEM_PROCESS_INFORMATION*)buffer.Get();
         while (process->UniqueProcessId != (HANDLE)(size_t)(pid)) {
             if (!process->NextEntryOffset) {
@@ -210,7 +210,7 @@ namespace NMemInfo {
 
             process = (SYSTEM_PROCESS_INFORMATION*)((char*)process + process->NextEntryOffset);
         }
- 
+
         result.VMS = process->VirtualSize;
         result.RSS = process->WorkingSetSize;
 #endif
diff --git a/util/system/mlock.cpp b/util/system/mlock.cpp
index 2431ef73db..435338c98f 100644
--- a/util/system/mlock.cpp
+++ b/util/system/mlock.cpp
@@ -21,7 +21,7 @@ void LockMemory(const void* addr, size_t len) {
 #if defined(_unix_)
     const size_t pageSize = NSystemInfo::GetPageSize();
     if (mlock(AlignDown(addr, pageSize), AlignUp(len, pageSize))) {
-        ythrow yexception() << LastSystemErrorText(); 
+        ythrow yexception() << LastSystemErrorText();
     }
 #elif defined(_win_)
     HANDLE hndl = GetCurrentProcess();
diff --git a/util/system/thread.i b/util/system/thread.i
index e93a3f4d62..8cba505473 100644
--- a/util/system/thread.i
+++ b/util/system/thread.i
@@ -3,7 +3,7 @@
 #include "platform.h"
 
 #if defined(_win_)
-    #include "winint.h" 
+    #include "winint.h"
     #include <process.h>
 
     typedef HANDLE THREADHANDLE;