Restoring authorship annotation for Ilnur Khuziev <ilnur.khuziev@yandex.ru>. Commit 2 of 2.

70 files changed, 462 insertions, 462 deletions

diff --git a/util/generic/adaptor_ut.cpp b/util/generic/adaptor_ut.cpp
index c36d035843..721f849f93 100644
--- a/util/generic/adaptor_ut.cpp
+++ b/util/generic/adaptor_ut.cpp
@@ -1,7 +1,7 @@
 #include "adaptor.h"
 #include "yexception.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 struct TOnCopy: yexception {
 };
diff --git a/util/generic/algorithm_ut.cpp b/util/generic/algorithm_ut.cpp
index dd9629da4d..8d732fcc0c 100644
--- a/util/generic/algorithm_ut.cpp
+++ b/util/generic/algorithm_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include "algorithm.h"
 #include "strbuf.h"
diff --git a/util/generic/array_ref_ut.cpp b/util/generic/array_ref_ut.cpp
index d1bc763c51..4c8eaf7135 100644
--- a/util/generic/array_ref_ut.cpp
+++ b/util/generic/array_ref_ut.cpp
@@ -1,6 +1,6 @@
 #include "array_ref.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(TestArrayRef) {
     Y_UNIT_TEST(TestDefaultConstructor) {
diff --git a/util/generic/array_size_ut.cpp b/util/generic/array_size_ut.cpp
index 369c23658b..13f45903c5 100644
--- a/util/generic/array_size_ut.cpp
+++ b/util/generic/array_size_ut.cpp
@@ -1,6 +1,6 @@
 #include "array_size.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(ArraySizeTest) {
     Y_UNIT_TEST(Test1) {
diff --git a/util/generic/benchmark/fastclp2/main.cpp b/util/generic/benchmark/fastclp2/main.cpp
index f4095b0c57..49277db077 100644
--- a/util/generic/benchmark/fastclp2/main.cpp
+++ b/util/generic/benchmark/fastclp2/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/benchmark/bench.h>
 
 #include <util/generic/bitops.h>
 #include <util/generic/vector.h>
diff --git a/util/generic/benchmark/log2/main.cpp b/util/generic/benchmark/log2/main.cpp
index 32b83e9538..969f09a309 100644
--- a/util/generic/benchmark/log2/main.cpp
+++ b/util/generic/benchmark/log2/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/benchmark/bench.h>
 
 #include <library/cpp/fast_log/fast_log.h>
 
diff --git a/util/generic/benchmark/rotate_bits/main.cpp b/util/generic/benchmark/rotate_bits/main.cpp
index 838c8cf869..057edbe864 100644
--- a/util/generic/benchmark/rotate_bits/main.cpp
+++ b/util/generic/benchmark/rotate_bits/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/benchmark/bench.h>
 
 #include <util/generic/vector.h>
 #include <util/generic/xrange.h>
diff --git a/util/generic/benchmark/singleton/main.cpp b/util/generic/benchmark/singleton/main.cpp
index 3a2a759370..2b06bd371d 100644
--- a/util/generic/benchmark/singleton/main.cpp
+++ b/util/generic/benchmark/singleton/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/benchmark/bench.h>
 
 #include <util/generic/singleton.h>
 #include <util/generic/xrange.h>
diff --git a/util/generic/benchmark/smart_pointers/main.cpp b/util/generic/benchmark/smart_pointers/main.cpp
index 1d04c00bf6..92c2f923bb 100644
--- a/util/generic/benchmark/smart_pointers/main.cpp
+++ b/util/generic/benchmark/smart_pointers/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/benchmark/bench.h>
 
 #include <util/generic/ptr.h>
 #include <util/generic/xrange.h>
diff --git a/util/generic/benchmark/sort/main.cpp b/util/generic/benchmark/sort/main.cpp
index 7f3b5a9b26..d58f491f4d 100644
--- a/util/generic/benchmark/sort/main.cpp
+++ b/util/generic/benchmark/sort/main.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/benchmark/bench.h>
 
 #include <util/generic/algorithm.h>
 #include <util/generic/vector.h>
diff --git a/util/generic/benchmark/vector_count_ctor/f.cpp b/util/generic/benchmark/vector_count_ctor/f.cpp
index 19ddc48781..b89e351ba7 100644
--- a/util/generic/benchmark/vector_count_ctor/f.cpp
+++ b/util/generic/benchmark/vector_count_ctor/f.cpp
@@ -1,6 +1,6 @@
 #include "f.h"
 
-#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/benchmark/bench.h>
 
 #include <util/generic/vector.h>
 #include <util/generic/ptr.h>
diff --git a/util/generic/benchmark/vector_count_ctor/main.cpp b/util/generic/benchmark/vector_count_ctor/main.cpp
index 78ac40ffc3..6fb1fda9c9 100644
--- a/util/generic/benchmark/vector_count_ctor/main.cpp
+++ b/util/generic/benchmark/vector_count_ctor/main.cpp
@@ -1,6 +1,6 @@
 #include "f.h"
 
-#include <library/cpp/testing/benchmark/bench.h> 
+#include <library/cpp/testing/benchmark/bench.h>
 
 #define DEFINE_BENCHMARK(N)                   \
     Y_CPU_BENCHMARK(Yvector_##N, iface) {     \
diff --git a/util/generic/bitmap_ut.cpp b/util/generic/bitmap_ut.cpp
index 4e90309c74..087d34a8dc 100644
--- a/util/generic/bitmap_ut.cpp
+++ b/util/generic/bitmap_ut.cpp
@@ -1,6 +1,6 @@
 #include "bitmap.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #define INIT_BITMAP(bitmap, bits)                                \
     for (size_t i = 0; i < sizeof(bits) / sizeof(size_t); ++i) { \
diff --git a/util/generic/bitops.h b/util/generic/bitops.h
index 0de23f0be9..2db15fc59b 100644
--- a/util/generic/bitops.h
+++ b/util/generic/bitops.h
@@ -430,8 +430,8 @@ constexpr T RotateBitsRightCT(T value, const ui8 shift) noexcept {
  */
 template <size_t Offset, size_t Size, class T>
 Y_FORCE_INLINE T SelectBits(T value) {
-    static_assert(Size < sizeof(T) * 8, "violated: Size < sizeof(T) * 8"); 
-    static_assert(Offset < sizeof(T) * 8, "violated: Offset < sizeof(T) * 8"); 
+    static_assert(Size < sizeof(T) * 8, "violated: Size < sizeof(T) * 8");
+    static_assert(Offset < sizeof(T) * 8, "violated: Offset < sizeof(T) * 8");
     T id = 1;
     return (value >> Offset) & ((id << Size) - id);
 }
@@ -441,8 +441,8 @@ Y_FORCE_INLINE T SelectBits(T value) {
  */
 template <size_t Offset, size_t Size, class T>
 void SetBits(T& value, T bits) {
-    static_assert(Size < sizeof(T) * 8, "violated: Size < sizeof(T) * 8"); 
-    static_assert(Offset < sizeof(T) * 8, "violated: Offset < sizeof(T) * 8"); 
+    static_assert(Size < sizeof(T) * 8, "violated: Size < sizeof(T) * 8");
+    static_assert(Offset < sizeof(T) * 8, "violated: Offset < sizeof(T) * 8");
     T id = 1;
     T maxValue = ((id << Size) - id);
     Y_ASSERT(bits <= maxValue);
diff --git a/util/generic/bitops_ut.cpp b/util/generic/bitops_ut.cpp
index a2a4539300..d23c2b5c27 100644
--- a/util/generic/bitops_ut.cpp
+++ b/util/generic/bitops_ut.cpp
@@ -1,6 +1,6 @@
 #include "bitops.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/string/builder.h>
 
diff --git a/util/generic/buffer.cpp b/util/generic/buffer.cpp
index 71931aa467..b92697e1d0 100644
--- a/util/generic/buffer.cpp
+++ b/util/generic/buffer.cpp
@@ -4,7 +4,7 @@
 #include "ymath.h"
 
 #include <util/system/sys_alloc.h>
-#include <util/system/sanitizers.h> 
+#include <util/system/sanitizers.h>
 
 TBuffer::TBuffer(size_t len)
     : Data_(nullptr)
@@ -44,20 +44,20 @@ TBuffer& TBuffer::operator=(TBuffer&& b) noexcept {
     return *this;
 }
 
-void TBuffer::Append(const char* buf, size_t len) { 
-    if (len > Avail()) { 
-        Reserve(Pos_ + len); 
-    } 
- 
-    Y_ASSERT(len <= Avail()); 
- 
+void TBuffer::Append(const char* buf, size_t len) {
+    if (len > Avail()) {
+        Reserve(Pos_ + len);
+    }
+
+    Y_ASSERT(len <= Avail());
+
     MemCopy(Data() + Pos_, buf, len);
-    NSan::Unpoison(Data() + Pos_, len); 
-    Pos_ += len; 
- 
-    Y_ASSERT(Pos_ <= Len_); 
-} 
- 
+    NSan::Unpoison(Data() + Pos_, len);
+    Pos_ += len;
+
+    Y_ASSERT(Pos_ <= Len_);
+}
+
 void TBuffer::Fill(char ch, size_t len) {
     if (len > Avail()) {
         Reserve(Pos_ + len);
diff --git a/util/generic/buffer.h b/util/generic/buffer.h
index 8bc3d9e8fe..9576467404 100644
--- a/util/generic/buffer.h
+++ b/util/generic/buffer.h
@@ -92,7 +92,7 @@ public:
         return Len_ - Pos_;
     }
 
-    void Append(const char* buf, size_t len); 
+    void Append(const char* buf, size_t len);
 
     inline void Append(const char* b, const char* e) {
         Append(b, e - b);
diff --git a/util/generic/buffer_ut.cpp b/util/generic/buffer_ut.cpp
index b824798641..437d7122ec 100644
--- a/util/generic/buffer_ut.cpp
+++ b/util/generic/buffer_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/system/datetime.h>
 #include "string.h"
diff --git a/util/generic/cast_ut.cpp b/util/generic/cast_ut.cpp
index 7b51fb3ced..718a8de79d 100644
--- a/util/generic/cast_ut.cpp
+++ b/util/generic/cast_ut.cpp
@@ -1,6 +1,6 @@
 #include "cast.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 class TGenericCastsTest: public TTestBase {
     UNIT_TEST_SUITE(TGenericCastsTest);
diff --git a/util/generic/deque_ut.cpp b/util/generic/deque_ut.cpp
index 80adaef4b9..93bf50fa92 100644
--- a/util/generic/deque_ut.cpp
+++ b/util/generic/deque_ut.cpp
@@ -1,6 +1,6 @@
 #include "deque.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <utility>
 #include "yexception.h"
diff --git a/util/generic/explicit_type_ut.cpp b/util/generic/explicit_type_ut.cpp
index 09e839b77e..50a745f090 100644
--- a/util/generic/explicit_type_ut.cpp
+++ b/util/generic/explicit_type_ut.cpp
@@ -1,6 +1,6 @@
 #include "explicit_type.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 struct TCallableBase {
 public:
diff --git a/util/generic/flags_ut.cpp b/util/generic/flags_ut.cpp
index 1ca01e4006..5377c6a058 100644
--- a/util/generic/flags_ut.cpp
+++ b/util/generic/flags_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include "flags.h"
 
diff --git a/util/generic/function_ut.cpp b/util/generic/function_ut.cpp
index 8c754ec9db..3880295a9f 100644
--- a/util/generic/function_ut.cpp
+++ b/util/generic/function_ut.cpp
@@ -1,7 +1,7 @@
 #include "function.h"
 #include "typetraits.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(TestFunctionSignature) {
     int FF(double x) {
diff --git a/util/generic/guid_ut.cpp b/util/generic/guid_ut.cpp
index 607ab75adc..048354ff39 100644
--- a/util/generic/guid_ut.cpp
+++ b/util/generic/guid_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include "guid.h"
 
diff --git a/util/generic/hash.h b/util/generic/hash.h
index d9312fb860..e46db21fa9 100644
--- a/util/generic/hash.h
+++ b/util/generic/hash.h
@@ -621,7 +621,7 @@ public:
     size_type max_size() const noexcept {
         return size_type(-1);
     }
- 
+
     Y_PURE_FUNCTION bool empty() const noexcept {
         return size() == 0;
     }
@@ -1530,7 +1530,7 @@ public:
     size_type max_size() const noexcept {
         return rep.max_size();
     }
- 
+
     Y_PURE_FUNCTION bool empty() const noexcept {
         return rep.empty();
     }
@@ -1855,7 +1855,7 @@ public:
     size_type max_size() const {
         return rep.max_size();
     }
- 
+
     Y_PURE_FUNCTION bool empty() const {
         return rep.empty();
     }
diff --git a/util/generic/hash_primes_ut.cpp b/util/generic/hash_primes_ut.cpp
index 3cde6e69a0..7b5bf8b5c9 100644
--- a/util/generic/hash_primes_ut.cpp
+++ b/util/generic/hash_primes_ut.cpp
@@ -1,6 +1,6 @@
 #include "hash_primes.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/generic/vector.h>
 #include <util/string/builder.h>
diff --git a/util/generic/hash_set.h b/util/generic/hash_set.h
index 8df4e0db79..e8088cf23b 100644
--- a/util/generic/hash_set.h
+++ b/util/generic/hash_set.h
@@ -122,7 +122,7 @@ public:
     size_type max_size() const {
         return rep.max_size();
     }
- 
+
     Y_PURE_FUNCTION bool empty() const {
         return rep.empty();
     }
@@ -371,7 +371,7 @@ public:
     size_type max_size() const {
         return rep.max_size();
     }
- 
+
     Y_PURE_FUNCTION bool empty() const {
         return rep.empty();
     }
diff --git a/util/generic/hash_ut.cpp b/util/generic/hash_ut.cpp
index ee66b668d7..0551d58770 100644
--- a/util/generic/hash_ut.cpp
+++ b/util/generic/hash_ut.cpp
@@ -3,7 +3,7 @@
 #include "hash_set.h"
 
 #include <library/cpp/testing/common/probe.h>
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <utility>
 #include <util/str_stl.h>
diff --git a/util/generic/intrlist_ut.cpp b/util/generic/intrlist_ut.cpp
index a2c42448db..eff7cdf2ee 100644
--- a/util/generic/intrlist_ut.cpp
+++ b/util/generic/intrlist_ut.cpp
@@ -1,6 +1,6 @@
 #include "intrlist.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/stream/output.h>
 
diff --git a/util/generic/is_in_ut.cpp b/util/generic/is_in_ut.cpp
index 9e8a82d6fa..c668bce807 100644
--- a/util/generic/is_in_ut.cpp
+++ b/util/generic/is_in_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include "algorithm.h"
 #include "hash.h"
diff --git a/util/generic/iterator_range_ut.cpp b/util/generic/iterator_range_ut.cpp
index ebd6633e33..a7e3670ae1 100644
--- a/util/generic/iterator_range_ut.cpp
+++ b/util/generic/iterator_range_ut.cpp
@@ -1,6 +1,6 @@
 #include "iterator_range.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 #include <util/generic/algorithm.h>
 #include <util/generic/vector.h>
 
diff --git a/util/generic/iterator_ut.cpp b/util/generic/iterator_ut.cpp
index 96ecb8f899..00be19e10e 100644
--- a/util/generic/iterator_ut.cpp
+++ b/util/generic/iterator_ut.cpp
@@ -1,6 +1,6 @@
 #include "iterator.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(TIterator) {
     Y_UNIT_TEST(ToForwardIteratorTest) {
diff --git a/util/generic/lazy_value_ut.cpp b/util/generic/lazy_value_ut.cpp
index 033b68c8ef..f6135880c3 100644
--- a/util/generic/lazy_value_ut.cpp
+++ b/util/generic/lazy_value_ut.cpp
@@ -1,6 +1,6 @@
 #include "lazy_value.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(TLazyValueTestSuite) {
     Y_UNIT_TEST(TestLazyValue) {
diff --git a/util/generic/list_ut.cpp b/util/generic/list_ut.cpp
index 2542358dfa..9e60ecf01b 100644
--- a/util/generic/list_ut.cpp
+++ b/util/generic/list_ut.cpp
@@ -1,6 +1,6 @@
 #include "list.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(TYListSuite) {
     Y_UNIT_TEST(TestInitializerList) {
diff --git a/util/generic/map_ut.cpp b/util/generic/map_ut.cpp
index d13bc3ae84..79e832b024 100644
--- a/util/generic/map_ut.cpp
+++ b/util/generic/map_ut.cpp
@@ -1,6 +1,6 @@
 #include "map.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 #include <util/memory/pool.h>
 #include <algorithm>
 
diff --git a/util/generic/mapfindptr_ut.cpp b/util/generic/mapfindptr_ut.cpp
index 74f8ad6b67..613da7a96b 100644
--- a/util/generic/mapfindptr_ut.cpp
+++ b/util/generic/mapfindptr_ut.cpp
@@ -1,7 +1,7 @@
 #include "string.h"
 #include "hash.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <map>
 
diff --git a/util/generic/maybe_ut.cpp b/util/generic/maybe_ut.cpp
index f63b6362dc..2c1a425c5e 100644
--- a/util/generic/maybe_ut.cpp
+++ b/util/generic/maybe_ut.cpp
@@ -1,7 +1,7 @@
 #include <util/generic/string.h>
 #include <util/generic/vector.h>
 #include <util/stream/str.h>
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include "maybe.h"
 
@@ -150,11 +150,11 @@ Y_UNIT_TEST_SUITE(TMaybeTest) {
 
         UNIT_ASSERT(m == 1);
 
-        auto& x = m.ConstructInPlace(2); 
+        auto& x = m.ConstructInPlace(2);
 
         UNIT_ASSERT(m == 2);
-        x = 7; 
-        UNIT_ASSERT(m == 7); 
+        x = 7;
+        UNIT_ASSERT(m == 7);
     }
 
     Y_UNIT_TEST(TestMove) {
diff --git a/util/generic/mem_copy_ut.cpp b/util/generic/mem_copy_ut.cpp
index 114181d27a..8b55a11cf6 100644
--- a/util/generic/mem_copy_ut.cpp
+++ b/util/generic/mem_copy_ut.cpp
@@ -1,6 +1,6 @@
 #include "mem_copy.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 namespace {
     class TAssignBCalled: public yexception {
diff --git a/util/generic/objects_counter_ut.cpp b/util/generic/objects_counter_ut.cpp
index 0578decc62..4d5da37a56 100644
--- a/util/generic/objects_counter_ut.cpp
+++ b/util/generic/objects_counter_ut.cpp
@@ -1,6 +1,6 @@
 #include "object_counter.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(ObjectsCounter) {
     struct TObject: public TObjectCounter<TObject> {
diff --git a/util/generic/overloaded_ut.cpp b/util/generic/overloaded_ut.cpp
index 68ddba94cf..f3d73895ad 100644
--- a/util/generic/overloaded_ut.cpp
+++ b/util/generic/overloaded_ut.cpp
@@ -1,6 +1,6 @@
 #include <util/generic/overloaded.h>
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/generic/variant.h>
 #include <util/generic/algorithm.h>
diff --git a/util/generic/ptr.h b/util/generic/ptr.h
index 8a4fcc3da9..19db0e3ec5 100644
--- a/util/generic/ptr.h
+++ b/util/generic/ptr.h
@@ -185,7 +185,7 @@ public:
         return *this;
     }
 
-    inline T* Release() const noexcept Y_WARN_UNUSED_RESULT { 
+    inline T* Release() const noexcept Y_WARN_UNUSED_RESULT {
         return this->DoRelease(T_);
     }
 
@@ -280,7 +280,7 @@ public:
         Reset(nullptr);
     }
 
-    inline T* Release() noexcept Y_WARN_UNUSED_RESULT { 
+    inline T* Release() noexcept Y_WARN_UNUSED_RESULT {
         return this->DoRelease(T_);
     }
 
@@ -566,7 +566,7 @@ public:
         TIntrusivePtr(nullptr).Swap(*this);
     }
 
-    inline T* Release() const noexcept Y_WARN_UNUSED_RESULT { 
+    inline T* Release() const noexcept Y_WARN_UNUSED_RESULT {
         T* res = T_;
         if (T_) {
             Ops::DecRef(T_);
@@ -1011,7 +1011,7 @@ public:
         return *this;
     }
 
-    inline T* Release() noexcept Y_WARN_UNUSED_RESULT { 
+    inline T* Release() noexcept Y_WARN_UNUSED_RESULT {
         return DoRelease(T_);
     }
 
diff --git a/util/generic/ptr_ut.cpp b/util/generic/ptr_ut.cpp
index 306646d12d..c2dcff23f6 100644
--- a/util/generic/ptr_ut.cpp
+++ b/util/generic/ptr_ut.cpp
@@ -2,7 +2,7 @@
 #include "vector.h"
 #include "noncopyable.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/generic/hash_set.h>
 #include <util/generic/is_in.h>
diff --git a/util/generic/queue_ut.cpp b/util/generic/queue_ut.cpp
index 7bee07699d..a33399e104 100644
--- a/util/generic/queue_ut.cpp
+++ b/util/generic/queue_ut.cpp
@@ -2,7 +2,7 @@
 #include "list.h"
 #include "vector.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <utility>
 
diff --git a/util/generic/reserve.h b/util/generic/reserve.h
index 72fb466018..81ceed19dc 100644
--- a/util/generic/reserve.h
+++ b/util/generic/reserve.h
@@ -1,11 +1,11 @@
-#pragma once 
- 
-namespace NDetail { 
-    struct TReserveTag { 
-        size_t Capacity; 
-    }; 
-} 
- 
+#pragma once
+
+namespace NDetail {
+    struct TReserveTag {
+        size_t Capacity;
+    };
+}
+
 constexpr ::NDetail::TReserveTag Reserve(size_t capacity) {
     return ::NDetail::TReserveTag{capacity};
-} 
+}
diff --git a/util/generic/scope_ut.cpp b/util/generic/scope_ut.cpp
index d1742ab444..bdb434d487 100644
--- a/util/generic/scope_ut.cpp
+++ b/util/generic/scope_ut.cpp
@@ -1,7 +1,7 @@
 #include "scope.h"
 
 #include <util/generic/ptr.h>
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(ScopeToolsTest) {
     Y_UNIT_TEST(OnScopeExitTest) {
diff --git a/util/generic/serialized_enum_ut.cpp b/util/generic/serialized_enum_ut.cpp
index ab85b65961..3a94e1d471 100644
--- a/util/generic/serialized_enum_ut.cpp
+++ b/util/generic/serialized_enum_ut.cpp
@@ -1,6 +1,6 @@
 #include "serialized_enum.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/generic/deque.h>
 #include <util/generic/map.h>
diff --git a/util/generic/set_ut.cpp b/util/generic/set_ut.cpp
index e11453c8e8..d2769d327f 100644
--- a/util/generic/set_ut.cpp
+++ b/util/generic/set_ut.cpp
@@ -1,6 +1,6 @@
 #include "set.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <utility>
 
diff --git a/util/generic/singleton.cpp b/util/generic/singleton.cpp
index 687b2b3f64..eb5a0662f8 100644
--- a/util/generic/singleton.cpp
+++ b/util/generic/singleton.cpp
@@ -2,7 +2,7 @@
 
 #include <util/system/spinlock.h>
 #include <util/system/thread.h>
-#include <util/system/sanitizers.h> 
+#include <util/system/sanitizers.h>
 
 #include <cstring>
 
@@ -32,12 +32,12 @@ void NPrivate::FillWithTrash(void* ptr, size_t len) {
     Y_UNUSED(ptr);
     Y_UNUSED(len);
 #else
-    if constexpr (NSan::TSanIsOn()) { 
-        Y_UNUSED(ptr); 
-        Y_UNUSED(len); 
-    } else { 
-        memset(ptr, 0xBA, len); 
-    } 
+    if constexpr (NSan::TSanIsOn()) {
+        Y_UNUSED(ptr);
+        Y_UNUSED(len);
+    } else {
+        memset(ptr, 0xBA, len);
+    }
 #endif
 }
 
diff --git a/util/generic/singleton_ut.cpp b/util/generic/singleton_ut.cpp
index 2d50855677..35ba90cd76 100644
--- a/util/generic/singleton_ut.cpp
+++ b/util/generic/singleton_ut.cpp
@@ -1,6 +1,6 @@
 #include "singleton.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(TestSingleton) {
     struct THuge {
diff --git a/util/generic/stack_ut.cpp b/util/generic/stack_ut.cpp
index 1c9dd7ed89..248127d326 100644
--- a/util/generic/stack_ut.cpp
+++ b/util/generic/stack_ut.cpp
@@ -1,6 +1,6 @@
 #include "stack.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(TYStackTest) {
     Y_UNIT_TEST(ExplicitBool) {
diff --git a/util/generic/store_policy_ut.cpp b/util/generic/store_policy_ut.cpp
index c867a853f5..c9722203aa 100644
--- a/util/generic/store_policy_ut.cpp
+++ b/util/generic/store_policy_ut.cpp
@@ -1,6 +1,6 @@
 #include "store_policy.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 #include <util/generic/algorithm.h>
 #include <util/generic/vector.h>
 
diff --git a/util/generic/strbase.h b/util/generic/strbase.h
index e8bc89569a..ab39fc7537 100644
--- a/util/generic/strbase.h
+++ b/util/generic/strbase.h
@@ -483,14 +483,14 @@ public:
         return !s.length() || find(s, pos) != npos;
     }
 
-    inline bool Contains(TChar c, size_t pos = 0) const noexcept { 
+    inline bool Contains(TChar c, size_t pos = 0) const noexcept {
         return find(c, pos) != npos;
     }
 
-    inline void Contains(std::enable_if<std::is_unsigned<TCharType>::value, char> c, size_t pos = 0) const noexcept { 
-        return find(ui8(c), pos) != npos; 
-    } 
- 
+    inline void Contains(std::enable_if<std::is_unsigned<TCharType>::value, char> c, size_t pos = 0) const noexcept {
+        return find(ui8(c), pos) != npos;
+    }
+
     //~~~~Character Set Search~~~
     inline size_t find_first_of(TCharType c) const noexcept {
         return find_first_of(c, 0);
@@ -569,12 +569,12 @@ public:
         return n;
     }
 
-    inline TDerived copy() const Y_WARN_UNUSED_RESULT { 
+    inline TDerived copy() const Y_WARN_UNUSED_RESULT {
         return TDerived(Ptr(), Len());
     }
 
     // ~~~ Partial copy ~~~~
-    TDerived substr(size_t pos, size_t n = npos) const Y_WARN_UNUSED_RESULT { 
+    TDerived substr(size_t pos, size_t n = npos) const Y_WARN_UNUSED_RESULT {
         return TDerived(*This(), pos, n);
     }
 
diff --git a/util/generic/strbuf_ut.cpp b/util/generic/strbuf_ut.cpp
index 20c284d352..69cde785af 100644
--- a/util/generic/strbuf_ut.cpp
+++ b/util/generic/strbuf_ut.cpp
@@ -1,6 +1,6 @@
 #include "strbuf.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <string_view>
 
diff --git a/util/generic/string.cpp b/util/generic/string.cpp
index 6242c45685..3c655f1f66 100644
--- a/util/generic/string.cpp
+++ b/util/generic/string.cpp
@@ -80,7 +80,7 @@ template <>
 bool TBasicString<wchar16, std::char_traits<wchar16>>::to_title(size_t pos, size_t n) {
     return ToTitle(*this, pos, n);
 }
- 
+
 template <>
 TUtf32String&
 TBasicString<wchar32, std::char_traits<wchar32>>::AppendAscii(const ::TStringBuf& s) {
@@ -112,9 +112,9 @@ TBasicString<char, std::char_traits<char>>::AppendUtf16(const ::TWtringBuf& s) {
 template <>
 TUtf32String&
 TBasicString<wchar32, std::char_traits<wchar32>>::AppendUtf8(const ::TStringBuf& s) {
-    size_t oldSize = size(); 
+    size_t oldSize = size();
     ReserveAndResize(size() + s.size() * 4);
-    size_t written = 0; 
+    size_t written = 0;
     size_t pos = UTF8ToWideImpl(s.data(), s.size(), begin() + oldSize, written);
     if (pos != s.size()) {
         ythrow yexception() << "failed to decode UTF-8 string at pos " << pos << ::NDetail::InStringMsg(s.data(), s.size());
@@ -122,35 +122,35 @@ TBasicString<wchar32, std::char_traits<wchar32>>::AppendUtf8(const ::TStringBuf&
     resize(oldSize + written);
 
     return *this;
-} 
- 
+}
+
 template <>
 TUtf32String&
 TBasicString<wchar32, std::char_traits<wchar32>>::AppendUtf16(const ::TWtringBuf& s) {
-    size_t oldSize = size(); 
+    size_t oldSize = size();
     ReserveAndResize(size() + s.size() * 2);
- 
-    wchar32* oldEnd = begin() + oldSize; 
-    wchar32* end = oldEnd; 
+
+    wchar32* oldEnd = begin() + oldSize;
+    wchar32* end = oldEnd;
     NDetail::UTF16ToUTF32ImplScalar(s.data(), s.data() + s.size(), end);
-    size_t written = end - oldEnd; 
- 
+    size_t written = end - oldEnd;
+
     resize(oldSize + written);
- 
+
     return *this;
-} 
- 
+}
+
 template <>
 bool TBasicString<wchar32, std::char_traits<wchar32>>::to_lower(size_t pos, size_t n) {
     return ToLower(*this, pos, n);
-} 
- 
+}
+
 template <>
 bool TBasicString<wchar32, std::char_traits<wchar32>>::to_upper(size_t pos, size_t n) {
     return ToUpper(*this, pos, n);
-} 
- 
+}
+
 template <>
 bool TBasicString<wchar32, std::char_traits<wchar32>>::to_title(size_t pos, size_t n) {
     return ToTitle(*this, pos, n);
-} 
+}
diff --git a/util/generic/string.h b/util/generic/string.h
index 543c494eda..8cd8aa6917 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -14,7 +14,7 @@
 #include "utility.h"
 #include "bitops.h"
 #include "explicit_type.h"
-#include "reserve.h" 
+#include "reserve.h"
 #include "singleton.h"
 #include "strbase.h"
 #include "strbuf.h"
@@ -379,7 +379,7 @@ public:
     {
     }
 
-    inline explicit TBasicString(::NDetail::TReserveTag rt) 
+    inline explicit TBasicString(::NDetail::TReserveTag rt)
 #ifndef TSTRING_IS_STD_STRING
         : S_(Construct())
 #endif
diff --git a/util/generic/string_transparent_hash_ut.cpp b/util/generic/string_transparent_hash_ut.cpp
index cf1170c3ac..b87fa2843e 100644
--- a/util/generic/string_transparent_hash_ut.cpp
+++ b/util/generic/string_transparent_hash_ut.cpp
@@ -2,7 +2,7 @@
 #include "vector.h"
 #include "strbuf.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/containers/absl_flat_hash/flat_hash_set.h>
 
 #include <util/str_stl.h>
diff --git a/util/generic/string_ut.cpp b/util/generic/string_ut.cpp
index 93b9be3387..ac82e9091d 100644
--- a/util/generic/string_ut.cpp
+++ b/util/generic/string_ut.cpp
@@ -908,191 +908,191 @@ private:
 UNIT_TEST_SUITE_REGISTRATION(TWideStringTest);
 
 class TUtf32StringTest: public TTestBase, private TStringTestImpl<TUtf32String, TTestData<wchar32>> {
-public: 
-    UNIT_TEST_SUITE(TUtf32StringTest); 
-    UNIT_TEST(TestConstructors); 
-    UNIT_TEST(TestReplace); 
+public:
+    UNIT_TEST_SUITE(TUtf32StringTest);
+    UNIT_TEST(TestConstructors);
+    UNIT_TEST(TestReplace);
 #ifndef TSTRING_IS_STD_STRING
-    UNIT_TEST(TestRefCount); 
+    UNIT_TEST(TestRefCount);
 #endif
-    UNIT_TEST(TestFind); 
-    UNIT_TEST(TestContains); 
-    UNIT_TEST(TestOperators); 
-    UNIT_TEST(TestLetOperator) 
-    UNIT_TEST(TestMulOperators); 
-    UNIT_TEST(TestFuncs); 
-    UNIT_TEST(TestUtils); 
-    UNIT_TEST(TestEmpty); 
-    UNIT_TEST(TestJoin); 
-    UNIT_TEST(TestCopy); 
-    UNIT_TEST(TestStrCpy); 
-    UNIT_TEST(TestPrefixSuffix); 
+    UNIT_TEST(TestFind);
+    UNIT_TEST(TestContains);
+    UNIT_TEST(TestOperators);
+    UNIT_TEST(TestLetOperator)
+    UNIT_TEST(TestMulOperators);
+    UNIT_TEST(TestFuncs);
+    UNIT_TEST(TestUtils);
+    UNIT_TEST(TestEmpty);
+    UNIT_TEST(TestJoin);
+    UNIT_TEST(TestCopy);
+    UNIT_TEST(TestStrCpy);
+    UNIT_TEST(TestPrefixSuffix);
 #ifndef TSTRING_IS_STD_STRING
-    UNIT_TEST(TestCharRef); 
+    UNIT_TEST(TestCharRef);
 #endif
-    UNIT_TEST(TestBack); 
-    UNIT_TEST(TestFront) 
-    UNIT_TEST(TestDecodingMethods); 
-    UNIT_TEST(TestDecodingMethodsMixedStr); 
+    UNIT_TEST(TestBack);
+    UNIT_TEST(TestFront)
+    UNIT_TEST(TestDecodingMethods);
+    UNIT_TEST(TestDecodingMethodsMixedStr);
     UNIT_TEST(TestIterators);
     UNIT_TEST(TestReverseIterators);
     UNIT_TEST(TestStringLiterals);
-    UNIT_TEST_SUITE_END(); 
- 
-private: 
-    void TestDecodingMethods() { 
-        UNIT_ASSERT(TUtf32String::FromAscii("").empty()); 
-        UNIT_ASSERT(TUtf32String::FromAscii("abc") == ASCIIToUTF32("abc")); 
- 
-        const char* text = "123kx83abcd ej)#$%ddja&%J&"; 
-        TUtf32String wtext = ASCIIToUTF32(text); 
- 
-        UNIT_ASSERT(wtext == TUtf32String::FromAscii(text)); 
- 
-        TString strtext(text); 
-        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strtext)); 
- 
-        TStringBuf strbuftext(text); 
-        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strbuftext)); 
- 
-        UNIT_ASSERT(wtext.substr(5) == TUtf32String::FromAscii(text + 5)); 
- 
-        const wchar32 wideCyrillicAlphabet[] = { 
-            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 
-            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 
-            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 
-            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 
-            0x00}; 
- 
-        TUtf32String strWide(wideCyrillicAlphabet); 
-        TString strUtf8 = WideToUTF8(strWide); 
- 
-        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8.c_str())); 
-        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8)); 
-        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(TStringBuf(strUtf8))); 
- 
-        // assign 
- 
-        TUtf32String s1; 
-        s1.AssignAscii("1234"); 
-        UNIT_ASSERT(s1 == ASCIIToUTF32("1234")); 
- 
-        s1.AssignUtf8(strUtf8); 
-        UNIT_ASSERT(s1 == strWide); 
- 
-        s1.AssignAscii(text); 
-        UNIT_ASSERT(s1 == wtext); 
- 
-        // append 
- 
-        TUtf32String s2; 
-        TUtf32String testAppend = strWide; 
-        s2.AppendUtf8(strUtf8); 
-        UNIT_ASSERT(testAppend == s2); 
- 
-        testAppend += ' '; 
-        s2.AppendAscii(" "); 
-        UNIT_ASSERT(testAppend == s2); 
- 
-        testAppend += '_'; 
-        s2.AppendUtf8("_"); 
-        UNIT_ASSERT(testAppend == s2); 
- 
-        testAppend += wtext; 
-        s2.AppendAscii(text); 
-        UNIT_ASSERT(testAppend == s2); 
- 
-        testAppend += wtext; 
-        s2.AppendUtf8(text); 
- 
-        UNIT_ASSERT(testAppend == s2); 
-    } 
- 
-    void TestDecodingMethodsMixedStr() { 
-        UNIT_ASSERT(TUtf32String::FromAscii("").empty()); 
-        UNIT_ASSERT(TUtf32String::FromAscii("abc") == ASCIIToUTF32("abc")); 
- 
-        const char* text = "123kx83abcd ej)#$%ddja&%J&"; 
-        TUtf32String wtext = ASCIIToUTF32(text); 
- 
-        UNIT_ASSERT(wtext == TUtf32String::FromAscii(text)); 
- 
-        TString strtext(text); 
-        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strtext)); 
- 
-        TStringBuf strbuftext(text); 
-        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strbuftext)); 
- 
-        UNIT_ASSERT(wtext.substr(5) == TUtf32String::FromAscii(text + 5)); 
- 
-        const wchar32 cyrilicAndLatinWide[] = { 
-            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 
-            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 
-            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 
-            wchar32('z'), 
-            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 
-            wchar32('z'), 
-            0x00}; 
- 
-        TUtf32String strWide(cyrilicAndLatinWide); 
-        TString strUtf8 = WideToUTF8(strWide); 
- 
-        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8.c_str())); 
-        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8)); 
-        UNIT_ASSERT(strWide == UTF8ToUTF32<true>(strUtf8)); 
-        UNIT_ASSERT(strWide == UTF8ToUTF32<false>(strUtf8)); 
-        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(TStringBuf(strUtf8))); 
- 
-        // assign 
- 
-        TUtf32String s1; 
-        s1.AssignAscii("1234"); 
-        UNIT_ASSERT(s1 == ASCIIToUTF32("1234")); 
- 
-        s1.AssignUtf8(strUtf8); 
-        UNIT_ASSERT(s1 == strWide); 
- 
-        s1.AssignAscii(text); 
-        UNIT_ASSERT(s1 == wtext); 
- 
-        // append 
- 
-        TUtf32String s2; 
-        TUtf32String testAppend = strWide; 
-        s2.AppendUtf16(UTF8ToWide(strUtf8)); 
-        UNIT_ASSERT(testAppend == s2); 
- 
-        testAppend += ' '; 
-        s2.AppendAscii(" "); 
-        UNIT_ASSERT(testAppend == s2); 
- 
-        testAppend += '_'; 
-        s2.AppendUtf8("_"); 
-        UNIT_ASSERT(testAppend == s2); 
- 
-        testAppend += wtext; 
-        s2.AppendAscii(text); 
-        UNIT_ASSERT(testAppend == s2); 
- 
-        testAppend += wtext; 
-        s2.AppendUtf8(text); 
- 
-        UNIT_ASSERT(testAppend == s2); 
-    } 
- 
-    void TestLetOperator() { 
-        TUtf32String str; 
- 
+    UNIT_TEST_SUITE_END();
+
+private:
+    void TestDecodingMethods() {
+        UNIT_ASSERT(TUtf32String::FromAscii("").empty());
+        UNIT_ASSERT(TUtf32String::FromAscii("abc") == ASCIIToUTF32("abc"));
+
+        const char* text = "123kx83abcd ej)#$%ddja&%J&";
+        TUtf32String wtext = ASCIIToUTF32(text);
+
+        UNIT_ASSERT(wtext == TUtf32String::FromAscii(text));
+
+        TString strtext(text);
+        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strtext));
+
+        TStringBuf strbuftext(text);
+        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strbuftext));
+
+        UNIT_ASSERT(wtext.substr(5) == TUtf32String::FromAscii(text + 5));
+
+        const wchar32 wideCyrillicAlphabet[] = {
+            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+            0x00};
+
+        TUtf32String strWide(wideCyrillicAlphabet);
+        TString strUtf8 = WideToUTF8(strWide);
+
+        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8.c_str()));
+        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8));
+        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(TStringBuf(strUtf8)));
+
+        // assign
+
+        TUtf32String s1;
+        s1.AssignAscii("1234");
+        UNIT_ASSERT(s1 == ASCIIToUTF32("1234"));
+
+        s1.AssignUtf8(strUtf8);
+        UNIT_ASSERT(s1 == strWide);
+
+        s1.AssignAscii(text);
+        UNIT_ASSERT(s1 == wtext);
+
+        // append
+
+        TUtf32String s2;
+        TUtf32String testAppend = strWide;
+        s2.AppendUtf8(strUtf8);
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += ' ';
+        s2.AppendAscii(" ");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += '_';
+        s2.AppendUtf8("_");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendAscii(text);
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendUtf8(text);
+
+        UNIT_ASSERT(testAppend == s2);
+    }
+
+    void TestDecodingMethodsMixedStr() {
+        UNIT_ASSERT(TUtf32String::FromAscii("").empty());
+        UNIT_ASSERT(TUtf32String::FromAscii("abc") == ASCIIToUTF32("abc"));
+
+        const char* text = "123kx83abcd ej)#$%ddja&%J&";
+        TUtf32String wtext = ASCIIToUTF32(text);
+
+        UNIT_ASSERT(wtext == TUtf32String::FromAscii(text));
+
+        TString strtext(text);
+        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strtext));
+
+        TStringBuf strbuftext(text);
+        UNIT_ASSERT(wtext == TUtf32String::FromAscii(strbuftext));
+
+        UNIT_ASSERT(wtext.substr(5) == TUtf32String::FromAscii(text + 5));
+
+        const wchar32 cyrilicAndLatinWide[] = {
+            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+            wchar32('z'),
+            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+            wchar32('z'),
+            0x00};
+
+        TUtf32String strWide(cyrilicAndLatinWide);
+        TString strUtf8 = WideToUTF8(strWide);
+
+        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8.c_str()));
+        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(strUtf8));
+        UNIT_ASSERT(strWide == UTF8ToUTF32<true>(strUtf8));
+        UNIT_ASSERT(strWide == UTF8ToUTF32<false>(strUtf8));
+        UNIT_ASSERT(strWide == TUtf32String::FromUtf8(TStringBuf(strUtf8)));
+
+        // assign
+
+        TUtf32String s1;
+        s1.AssignAscii("1234");
+        UNIT_ASSERT(s1 == ASCIIToUTF32("1234"));
+
+        s1.AssignUtf8(strUtf8);
+        UNIT_ASSERT(s1 == strWide);
+
+        s1.AssignAscii(text);
+        UNIT_ASSERT(s1 == wtext);
+
+        // append
+
+        TUtf32String s2;
+        TUtf32String testAppend = strWide;
+        s2.AppendUtf16(UTF8ToWide(strUtf8));
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += ' ';
+        s2.AppendAscii(" ");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += '_';
+        s2.AppendUtf8("_");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendAscii(text);
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendUtf8(text);
+
+        UNIT_ASSERT(testAppend == s2);
+    }
+
+    void TestLetOperator() {
+        TUtf32String str;
+
         str = wchar32('X');
-        UNIT_ASSERT(str == TUtf32String::FromAscii("X")); 
- 
-        const TUtf32String hello = TUtf32String::FromAscii("hello"); 
+        UNIT_ASSERT(str == TUtf32String::FromAscii("X"));
+
+        const TUtf32String hello = TUtf32String::FromAscii("hello");
         str = hello.data();
-        UNIT_ASSERT(str == hello); 
- 
-        str = hello; 
-        UNIT_ASSERT(str == hello); 
-    } 
+        UNIT_ASSERT(str == hello);
+
+        str = hello;
+        UNIT_ASSERT(str == hello);
+    }
 
     void TestStringLiterals() {
         TUtf32String s1 = U"hello";
@@ -1101,10 +1101,10 @@ private:
         TUtf32String s2 = U"привет";
         UNIT_ASSERT_VALUES_EQUAL(s2, TUtf32String::FromUtf8("привет"));
     }
-}; 
- 
-UNIT_TEST_SUITE_REGISTRATION(TUtf32StringTest); 
- 
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TUtf32StringTest);
+
 class TStringStdTest: public TTestBase, private TStringStdTestImpl<TString, TTestData<char>> {
 public:
     UNIT_TEST_SUITE(TStringStdTest);
diff --git a/util/generic/string_ut.h b/util/generic/string_ut.h
index 55cd378e01..44bb10bdeb 100644
--- a/util/generic/string_ut.h
+++ b/util/generic/string_ut.h
@@ -2,7 +2,7 @@
 
 #include "string.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/string/reverse.h>
 
@@ -565,9 +565,9 @@ public:
 
         TStringType s9(*Data._1());
         UNIT_ASSERT(s9 == Data._1());
- 
+
         TStringType s10(Reserve(100));
-        UNIT_ASSERT(s10.empty()); 
+        UNIT_ASSERT(s10.empty());
         UNIT_ASSERT(s10.capacity() >= 100);
     }
 
@@ -1011,14 +1011,14 @@ public:
         UNIT_ASSERT(!s1.IsDetached());
 
         /* Read access shouldn't detach. */
-        UNIT_ASSERT_VALUES_EQUAL(s0[0], (ui8)'a'); 
+        UNIT_ASSERT_VALUES_EQUAL(s0[0], (ui8)'a');
         UNIT_ASSERT(!s0.IsDetached());
         UNIT_ASSERT(!s1.IsDetached());
 
         /* Writing should detach. */
-        s1[0] = (ui8)'b'; 
+        s1[0] = (ui8)'b';
         TStringType s2 = s0;
-        s0[0] = (ui8)'c'; 
+        s0[0] = (ui8)'c';
 
         UNIT_ASSERT_VALUES_EQUAL(s0, cbc);
         UNIT_ASSERT_VALUES_EQUAL(s1, bbc);
@@ -1028,9 +1028,9 @@ public:
         UNIT_ASSERT(s2.IsDetached());
 
         /* Accessing null terminator is OK. Note that writing into it is UB. */
-        UNIT_ASSERT_VALUES_EQUAL(s0[3], (ui8)'\0'); 
-        UNIT_ASSERT_VALUES_EQUAL(s1[3], (ui8)'\0'); 
-        UNIT_ASSERT_VALUES_EQUAL(s2[3], (ui8)'\0'); 
+        UNIT_ASSERT_VALUES_EQUAL(s0[3], (ui8)'\0');
+        UNIT_ASSERT_VALUES_EQUAL(s1[3], (ui8)'\0');
+        UNIT_ASSERT_VALUES_EQUAL(s2[3], (ui8)'\0');
 
         /* Assignment one char reference to another results in modification of underlying character */
         {
@@ -1053,12 +1053,12 @@ public:
         TStringType str = chars;
         const TStringType constStr = str;
 
-        UNIT_ASSERT_VALUES_EQUAL(constStr.back(), (ui8)'o'); 
-        UNIT_ASSERT_VALUES_EQUAL(str.back(), (ui8)'o'); 
+        UNIT_ASSERT_VALUES_EQUAL(constStr.back(), (ui8)'o');
+        UNIT_ASSERT_VALUES_EQUAL(str.back(), (ui8)'o');
 
         str.back() = 'r';
-        UNIT_ASSERT_VALUES_EQUAL(constStr.back(), (ui8)'o'); 
-        UNIT_ASSERT_VALUES_EQUAL(str.back(), (ui8)'r'); 
+        UNIT_ASSERT_VALUES_EQUAL(constStr.back(), (ui8)'o');
+        UNIT_ASSERT_VALUES_EQUAL(str.back(), (ui8)'r');
     }
 
     void TestFront() {
@@ -1067,12 +1067,12 @@ public:
         TStringType str = chars;
         const TStringType constStr = str;
 
-        UNIT_ASSERT_VALUES_EQUAL(constStr.front(), (ui8)'f'); 
-        UNIT_ASSERT_VALUES_EQUAL(str.front(), (ui8)'f'); 
+        UNIT_ASSERT_VALUES_EQUAL(constStr.front(), (ui8)'f');
+        UNIT_ASSERT_VALUES_EQUAL(str.front(), (ui8)'f');
 
         str.front() = 'r';
-        UNIT_ASSERT_VALUES_EQUAL(constStr.front(), (ui8)'f'); 
-        UNIT_ASSERT_VALUES_EQUAL(str.front(), (ui8)'r'); 
+        UNIT_ASSERT_VALUES_EQUAL(constStr.front(), (ui8)'f');
+        UNIT_ASSERT_VALUES_EQUAL(str.front(), (ui8)'r');
     }
 
     void TestIterators() {
@@ -1086,31 +1086,31 @@ public:
         typename TStringType::const_iterator citBegin = constStr.begin();
         typename TStringType::const_iterator citEnd = constStr.end();
 
-        UNIT_ASSERT_VALUES_EQUAL(*itBegin, (ui8)'f'); 
-        UNIT_ASSERT_VALUES_EQUAL(*citBegin, (ui8)'f'); 
+        UNIT_ASSERT_VALUES_EQUAL(*itBegin, (ui8)'f');
+        UNIT_ASSERT_VALUES_EQUAL(*citBegin, (ui8)'f');
 
         str.front() = 'r';
-        UNIT_ASSERT_VALUES_EQUAL(*itBegin, (ui8)'r'); 
-        UNIT_ASSERT_VALUES_EQUAL(*citBegin, (ui8)'f'); 
+        UNIT_ASSERT_VALUES_EQUAL(*itBegin, (ui8)'r');
+        UNIT_ASSERT_VALUES_EQUAL(*citBegin, (ui8)'f');
 
         UNIT_ASSERT_VALUES_EQUAL(2, itEnd - itBegin);
         UNIT_ASSERT_VALUES_EQUAL(2, citEnd - citBegin);
 
-        UNIT_ASSERT_VALUES_EQUAL(*(++itBegin), (ui8)'o'); 
-        UNIT_ASSERT_VALUES_EQUAL(*(++citBegin), (ui8)'o'); 
+        UNIT_ASSERT_VALUES_EQUAL(*(++itBegin), (ui8)'o');
+        UNIT_ASSERT_VALUES_EQUAL(*(++citBegin), (ui8)'o');
 
-        UNIT_ASSERT_VALUES_EQUAL(*(--itBegin), (ui8)'r'); 
-        UNIT_ASSERT_VALUES_EQUAL(*(--citBegin), (ui8)'f'); 
+        UNIT_ASSERT_VALUES_EQUAL(*(--itBegin), (ui8)'r');
+        UNIT_ASSERT_VALUES_EQUAL(*(--citBegin), (ui8)'f');
 
-        UNIT_ASSERT_VALUES_EQUAL(*(itBegin++), (ui8)'r'); 
-        UNIT_ASSERT_VALUES_EQUAL(*(citBegin++), (ui8)'f'); 
-        UNIT_ASSERT_VALUES_EQUAL(*itBegin, (ui8)'o'); 
-        UNIT_ASSERT_VALUES_EQUAL(*citBegin, (ui8)'o'); 
+        UNIT_ASSERT_VALUES_EQUAL(*(itBegin++), (ui8)'r');
+        UNIT_ASSERT_VALUES_EQUAL(*(citBegin++), (ui8)'f');
+        UNIT_ASSERT_VALUES_EQUAL(*itBegin, (ui8)'o');
+        UNIT_ASSERT_VALUES_EQUAL(*citBegin, (ui8)'o');
 
-        UNIT_ASSERT_VALUES_EQUAL(*(itBegin--), (ui8)'o'); 
-        UNIT_ASSERT_VALUES_EQUAL(*(citBegin--), (ui8)'o'); 
-        UNIT_ASSERT_VALUES_EQUAL(*itBegin, (ui8)'r'); 
-        UNIT_ASSERT_VALUES_EQUAL(*citBegin, (ui8)'f'); 
+        UNIT_ASSERT_VALUES_EQUAL(*(itBegin--), (ui8)'o');
+        UNIT_ASSERT_VALUES_EQUAL(*(citBegin--), (ui8)'o');
+        UNIT_ASSERT_VALUES_EQUAL(*itBegin, (ui8)'r');
+        UNIT_ASSERT_VALUES_EQUAL(*citBegin, (ui8)'f');
     }
 
     void TestReverseIterators() {
@@ -1124,33 +1124,33 @@ public:
         typename TStringType::const_reverse_iterator critBegin = constStr.rbegin();
         typename TStringType::const_reverse_iterator critEnd = constStr.rend();
 
-        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'o'); 
-        UNIT_ASSERT_VALUES_EQUAL(*critBegin, (ui8)'o'); 
+        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'o');
+        UNIT_ASSERT_VALUES_EQUAL(*critBegin, (ui8)'o');
 
-        str.back() = (ui8)'r'; 
-        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'r'); 
-        UNIT_ASSERT_VALUES_EQUAL(*critBegin, (ui8)'o'); 
+        str.back() = (ui8)'r';
+        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'r');
+        UNIT_ASSERT_VALUES_EQUAL(*critBegin, (ui8)'o');
 
         UNIT_ASSERT_VALUES_EQUAL(2, ritEnd - ritBegin);
         UNIT_ASSERT_VALUES_EQUAL(2, critEnd - critBegin);
 
-        UNIT_ASSERT_VALUES_EQUAL(*(++ritBegin), (ui8)'f'); 
-        UNIT_ASSERT_VALUES_EQUAL(*(++critBegin), (ui8)'f'); 
+        UNIT_ASSERT_VALUES_EQUAL(*(++ritBegin), (ui8)'f');
+        UNIT_ASSERT_VALUES_EQUAL(*(++critBegin), (ui8)'f');
 
-        UNIT_ASSERT_VALUES_EQUAL(*(--ritBegin), (ui8)'r'); 
-        UNIT_ASSERT_VALUES_EQUAL(*(--critBegin), (ui8)'o'); 
+        UNIT_ASSERT_VALUES_EQUAL(*(--ritBegin), (ui8)'r');
+        UNIT_ASSERT_VALUES_EQUAL(*(--critBegin), (ui8)'o');
 
-        UNIT_ASSERT_VALUES_EQUAL(*(ritBegin++), (ui8)'r'); 
-        UNIT_ASSERT_VALUES_EQUAL(*(critBegin++), (ui8)'o'); 
-        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'f'); 
-        UNIT_ASSERT_VALUES_EQUAL(*critBegin, (ui8)'f'); 
+        UNIT_ASSERT_VALUES_EQUAL(*(ritBegin++), (ui8)'r');
+        UNIT_ASSERT_VALUES_EQUAL(*(critBegin++), (ui8)'o');
+        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'f');
+        UNIT_ASSERT_VALUES_EQUAL(*critBegin, (ui8)'f');
 
-        UNIT_ASSERT_VALUES_EQUAL(*(ritBegin--), (ui8)'f'); 
-        UNIT_ASSERT_VALUES_EQUAL(*(critBegin--), (ui8)'f'); 
-        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'r'); 
-        UNIT_ASSERT_VALUES_EQUAL(*critBegin, (ui8)'o'); 
+        UNIT_ASSERT_VALUES_EQUAL(*(ritBegin--), (ui8)'f');
+        UNIT_ASSERT_VALUES_EQUAL(*(critBegin--), (ui8)'f');
+        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'r');
+        UNIT_ASSERT_VALUES_EQUAL(*critBegin, (ui8)'o');
 
-        *ritBegin = (ui8)'e'; 
-        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'e'); 
+        *ritBegin = (ui8)'e';
+        UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'e');
     }
 };
diff --git a/util/generic/typelist_ut.cpp b/util/generic/typelist_ut.cpp
index 6216d5e0a0..eeabfa97b1 100644
--- a/util/generic/typelist_ut.cpp
+++ b/util/generic/typelist_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 #include <util/system/type_name.h>
 
 #include "typelist.h"
diff --git a/util/generic/typetraits.h b/util/generic/typetraits.h
index e8ad545631..d165bd1a06 100644
--- a/util/generic/typetraits.h
+++ b/util/generic/typetraits.h
@@ -235,7 +235,7 @@ struct TPodTraits<std::pair<T1, T2>> {
     };
 };
 
-template <class T> 
+template <class T>
 struct TIsPointerToConstMemberFunction: std::false_type {
 };
 
diff --git a/util/generic/typetraits_ut.cpp b/util/generic/typetraits_ut.cpp
index afad5cc4d2..e7571c75ec 100644
--- a/util/generic/typetraits_ut.cpp
+++ b/util/generic/typetraits_ut.cpp
@@ -1,6 +1,6 @@
 #include "typetraits.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <vector>
 #include <tuple>
diff --git a/util/generic/utility_ut.cpp b/util/generic/utility_ut.cpp
index 3226322cc5..8e9d5afff9 100644
--- a/util/generic/utility_ut.cpp
+++ b/util/generic/utility_ut.cpp
@@ -1,7 +1,7 @@
 #include "utility.h"
 #include "ymath.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 // DO_NOT_STYLE
 
diff --git a/util/generic/va_args_ut.cpp b/util/generic/va_args_ut.cpp
index 3ea47b43ea..a9c96a0f55 100644
--- a/util/generic/va_args_ut.cpp
+++ b/util/generic/va_args_ut.cpp
@@ -1,6 +1,6 @@
 #include "va_args.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 Y_UNIT_TEST_SUITE(TMacroVarargMapTest) {
     Y_UNIT_TEST(TestMapArgs) {
diff --git a/util/generic/vector.h b/util/generic/vector.h
index 935e9c0c59..a5b258955a 100644
--- a/util/generic/vector.h
+++ b/util/generic/vector.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "fwd.h"
-#include "reserve.h" 
+#include "reserve.h"
 
 #include <util/memory/alloc.h>
 
@@ -26,17 +26,17 @@ public:
     }
 
     inline explicit TVector(::NDetail::TReserveTag rt)
-        : TBase() 
-    { 
-        this->reserve(rt.Capacity); 
-    } 
- 
+        : TBase()
+    {
+        this->reserve(rt.Capacity);
+    }
+
     inline explicit TVector(::NDetail::TReserveTag rt, const typename TBase::allocator_type& a)
-        : TBase(a) 
-    { 
-        this->reserve(rt.Capacity); 
-    } 
- 
+        : TBase(a)
+    {
+        this->reserve(rt.Capacity);
+    }
+
     inline explicit TVector(size_type count)
         : TBase(count)
     {
@@ -103,9 +103,9 @@ public:
     }
 
     Y_PURE_FUNCTION inline bool empty() const noexcept {
-        return TBase::empty(); 
-    } 
- 
+        return TBase::empty();
+    }
+
     inline yssize_t ysize() const noexcept {
         return (yssize_t)TBase::size();
     }
diff --git a/util/generic/vector_ut.cpp b/util/generic/vector_ut.cpp
index be3cd24828..0f6b4037a0 100644
--- a/util/generic/vector_ut.cpp
+++ b/util/generic/vector_ut.cpp
@@ -1,6 +1,6 @@
 #include "vector.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <utility>
 #include "yexception.h"
@@ -279,13 +279,13 @@ private:
         UNIT_ASSERT(v[5] == 25);
         UNIT_ASSERT(v[6] == 36);
 
-        size_t curCapacity = v.capacity(); 
+        size_t curCapacity = v.capacity();
         v.clear();
         UNIT_ASSERT(v.empty());
 
-        //check that clear save reserved data 
-        UNIT_ASSERT_EQUAL(curCapacity, v.capacity()); 
- 
+        //check that clear save reserved data
+        UNIT_ASSERT_EQUAL(curCapacity, v.capacity());
+
         v.insert(v.begin(), 5, 10);
         UNIT_ASSERT(v.size() == 5);
         UNIT_ASSERT(v[0] == 10);
@@ -312,12 +312,12 @@ private:
 
         {
             TVector<int> v(Reserve(100));
- 
-            UNIT_ASSERT(v.capacity() >= 100); 
-            UNIT_ASSERT(v.size() == 0); 
-        } 
- 
-        { 
+
+            UNIT_ASSERT(v.capacity() >= 100);
+            UNIT_ASSERT(v.size() == 0);
+        }
+
+        {
             //Test that used to generate an assertion when using __debug_alloc.
             TVector<TestStruct> va;
             va.reserve(1);
diff --git a/util/generic/xrange.h b/util/generic/xrange.h
index 578605f356..5fc8c82912 100644
--- a/util/generic/xrange.h
+++ b/util/generic/xrange.h
@@ -13,16 +13,16 @@
  *  for (auto i: xrange(MyVector.size())) { // instead for (size_t i = 0; i < MyVector.size(); ++i)
  *      DoSomething(i, MyVector[i]);
  *  }
- * 
+ *
  * TVector<int> arithmeticSeq = xrange(10); // instead: TVector<int> arithmeticSeq; for(size_t i = 0; i < 10; ++i) { arithmeticSeq.push_back(i); }
- * 
+ *
  */
 
 namespace NPrivate {
     template <typename T>
     class TSimpleXRange {
-        using TDiff = decltype(T() - T()); 
- 
+        using TDiff = decltype(T() - T());
+
     public:
         constexpr TSimpleXRange(T start, T finish) noexcept
             : Start(start)
@@ -52,12 +52,12 @@ namespace NPrivate {
             }
 
             constexpr bool operator==(const TIterator& other) const noexcept {
-                return Value == other.Value; 
-            } 
- 
-            TIterator& operator++() noexcept { 
+                return Value == other.Value;
+            }
+
+            TIterator& operator++() noexcept {
                 ++Value;
-                return *this; 
+                return *this;
             }
 
             TIterator& operator--() noexcept {
@@ -66,25 +66,25 @@ namespace NPrivate {
             }
 
             constexpr TDiff operator-(const TIterator& b) const noexcept {
-                return Value - b.Value; 
-            } 
- 
+                return Value - b.Value;
+            }
+
             template <typename IntType>
             constexpr TIterator operator+(const IntType& b) const noexcept {
-                return TIterator(Value + b); 
-            } 
- 
+                return TIterator(Value + b);
+            }
+
             template <typename IntType>
             TIterator& operator+=(const IntType& b) noexcept {
-                Value += b; 
-                return *this; 
-            } 
- 
+                Value += b;
+                return *this;
+            }
+
             template <typename IntType>
             constexpr TIterator operator-(const IntType& b) const noexcept {
-                return TIterator(Value - b); 
-            } 
- 
+                return TIterator(Value - b);
+            }
+
             template <typename IntType>
             TIterator& operator-=(const IntType& b) noexcept {
                 Value -= b;
@@ -100,9 +100,9 @@ namespace NPrivate {
         };
 
         using value_type = T;
-        using iterator = TIterator; 
-        using const_iterator = TIterator; 
- 
+        using iterator = TIterator;
+        using const_iterator = TIterator;
+
         constexpr TIterator begin() const noexcept {
             return TIterator(Start);
         }
@@ -112,14 +112,14 @@ namespace NPrivate {
         }
 
         constexpr T size() const noexcept {
-            return Finish - Start; 
-        } 
- 
-        template <class Container> 
+            return Finish - Start;
+        }
+
+        template <class Container>
         operator Container() const {
-            return Container(begin(), end()); 
-        } 
- 
+            return Container(begin(), end());
+        }
+
     private:
         T Start;
         T Finish;
@@ -161,12 +161,12 @@ namespace NPrivate {
             }
 
             constexpr bool operator==(const TIterator& other) const noexcept {
-                return Value_ == other.Value_; 
-            } 
- 
-            TIterator& operator++() noexcept { 
+                return Value_ == other.Value_;
+            }
+
+            TIterator& operator++() noexcept {
                 Value_ += Parent_->Step_;
-                return *this; 
+                return *this;
             }
 
             TIterator& operator--() noexcept {
@@ -176,23 +176,23 @@ namespace NPrivate {
 
             constexpr TDiff operator-(const TIterator& b) const noexcept {
                 return (Value_ - b.Value_) / Parent_->Step_;
-            } 
- 
+            }
+
             template <typename IntType>
             constexpr TIterator operator+(const IntType& b) const noexcept {
                 return TIterator(*this) += b;
-            } 
- 
+            }
+
             template <typename IntType>
             TIterator& operator+=(const IntType& b) noexcept {
                 Value_ += b * Parent_->Step_;
-                return *this; 
-            } 
- 
+                return *this;
+            }
+
             template <typename IntType>
             constexpr TIterator operator-(const IntType& b) const noexcept {
                 return TIterator(*this) -= b;
-            } 
+            }
 
             template <typename IntType>
             TIterator& operator-=(const IntType& b) noexcept {
@@ -206,9 +206,9 @@ namespace NPrivate {
         };
 
         using value_type = T;
-        using iterator = TIterator; 
-        using const_iterator = TIterator; 
- 
+        using iterator = TIterator;
+        using const_iterator = TIterator;
+
         constexpr TIterator begin() const noexcept {
             return TIterator(Start_, *this);
         }
@@ -229,14 +229,14 @@ namespace NPrivate {
         }
 
         constexpr T size() const noexcept {
-            return (Finish_ - Start_) / Step_; 
-        } 
- 
-        template <class Container> 
+            return (Finish_ - Start_) / Step_;
+        }
+
+        template <class Container>
         operator Container() const {
-            return Container(begin(), end()); 
-        } 
- 
+            return Container(begin(), end());
+        }
+
     private:
         const T Start_;
         const TDiff Step_;
diff --git a/util/generic/xrange_ut.cpp b/util/generic/xrange_ut.cpp
index f8ba3c6f1f..8106da03e7 100644
--- a/util/generic/xrange_ut.cpp
+++ b/util/generic/xrange_ut.cpp
@@ -3,7 +3,7 @@
 #include "algorithm.h"
 #include "maybe.h"
 #include "vector.h"
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 #include <util/string/builder.h>
 
 Y_UNIT_TEST_SUITE(XRange) {
@@ -78,40 +78,40 @@ Y_UNIT_TEST_SUITE(XRange) {
         }
         UNIT_ASSERT_VALUES_EQUAL(digSumByPtr, digSumExpected);
     }
- 
+
     Y_UNIT_TEST(SizeMethodCheck) {
-        UNIT_ASSERT_VALUES_EQUAL(xrange(5).size(), 5); 
-        UNIT_ASSERT_VALUES_EQUAL(xrange(0, 5, 2).size(), 3); 
-        UNIT_ASSERT_VALUES_EQUAL(xrange(0, 6, 2).size(), 3); 
-    } 
- 
+        UNIT_ASSERT_VALUES_EQUAL(xrange(5).size(), 5);
+        UNIT_ASSERT_VALUES_EQUAL(xrange(0, 5, 2).size(), 3);
+        UNIT_ASSERT_VALUES_EQUAL(xrange(0, 6, 2).size(), 3);
+    }
+
     class TVectorChild: public TVector<size_t> {
-    public: 
+    public:
         template <typename TIterator>
         TVectorChild(TIterator a, TIterator b)
             : TVector<size_t>(a, b)
         {
         }
-    }; 
- 
+    };
+
     Y_UNIT_TEST(ConvertionWorks) {
         TVector<size_t> data = {0, 1, 2, 3, 4, 5, 6, 7, 8};
- 
+
         TVector<size_t> convertionResults[] = {xrange<size_t>(9),
                                                xrange<ui32>(0, 9),
                                                xrange(0, 9, 1)};
- 
-        for (const auto& arr : convertionResults) { 
-            UNIT_ASSERT(arr == data); 
-        } 
- 
-        TVectorChild sons[] = {xrange(0, 9), 
+
+        for (const auto& arr : convertionResults) {
+            UNIT_ASSERT(arr == data);
+        }
+
+        TVectorChild sons[] = {xrange(0, 9),
                                xrange(0, 9, 1)};
- 
-        for (const auto& arr : sons) { 
-            UNIT_ASSERT(arr == data); 
-        } 
-    } 
+
+        for (const auto& arr : sons) {
+            UNIT_ASSERT(arr == data);
+        }
+    }
 
     template <class XRangeContainer>
     void TestEmptyRanges(const XRangeContainer& c) {
diff --git a/util/generic/yexception_ut.cpp b/util/generic/yexception_ut.cpp
index 3b3a66eb73..cb3e29fed8 100644
--- a/util/generic/yexception_ut.cpp
+++ b/util/generic/yexception_ut.cpp
@@ -8,7 +8,7 @@ static inline void Throw2DontMove() {
     ythrow yexception() << 1 << " qw " << 12.1; // don't move this line
 }
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/generic/algorithm.h>
 #include <util/memory/tempbuf.h>
diff --git a/util/generic/ylimits_ut.cpp b/util/generic/ylimits_ut.cpp
index a77fb0c74c..f1b3c6858c 100644
--- a/util/generic/ylimits_ut.cpp
+++ b/util/generic/ylimits_ut.cpp
@@ -1,7 +1,7 @@
 #include "cast.h"
 #include "ylimits.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/string/cast.h>
 #include <util/system/valgrind.h>
diff --git a/util/generic/ymath_ut.cpp b/util/generic/ymath_ut.cpp
index 270ab5d1b1..29190b55eb 100644
--- a/util/generic/ymath_ut.cpp
+++ b/util/generic/ymath_ut.cpp
@@ -1,7 +1,7 @@
 #include "bitops.h"
 #include "ymath.h"
 
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <util/stream/output.h>
 #include <util/datetime/cputimer.h>