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

26 files changed, 219 insertions, 219 deletions

diff --git a/contrib/libs/ya.make b/contrib/libs/ya.make
index 26d4b391ee..9c4640fdcf 100644
--- a/contrib/libs/ya.make
+++ b/contrib/libs/ya.make
@@ -110,8 +110,8 @@ RECURSE(
     i18n/ut
     icu
     ImageMagick
-    inja 
-    inja/ut 
+    inja
+    inja/ut
     intel
     isa-l
     isa-l/ut
diff --git a/library/cpp/containers/flat_hash/flat_hash.h b/library/cpp/containers/flat_hash/flat_hash.h
index b938c94c8a..582b8ae8f5 100644
--- a/library/cpp/containers/flat_hash/flat_hash.h
+++ b/library/cpp/containers/flat_hash/flat_hash.h
@@ -11,31 +11,31 @@
 
 namespace NPrivate {
 
-template <class Key, class T, class Hash, class KeyEqual, class Probing, class Alloc> 
+template <class Key, class T, class Hash, class KeyEqual, class Probing, class Alloc>
 using TFlatHashMapImpl = NFlatHash::TMap<Key, T, Hash, KeyEqual,
-                                         NFlatHash::TFlatContainer<std::pair<const Key, T>, Alloc>, 
+                                         NFlatHash::TFlatContainer<std::pair<const Key, T>, Alloc>,
                                          Probing, NFlatHash::TAndSizeFitter,
                                          NFlatHash::TSimpleExpander>;
 
-template <class Key, class T, auto emptyMarker, class Hash, class KeyEqual, class Probing, class Alloc> 
+template <class Key, class T, auto emptyMarker, class Hash, class KeyEqual, class Probing, class Alloc>
 using TDenseHashMapImpl =
     NFlatHash::TMap<Key, T, Hash, KeyEqual,
                     NFlatHash::TDenseContainer<std::pair<const Key, T>,
-                                               NFlatHash::NMap::TStaticValueMarker<emptyMarker, T>, 
-                                               Alloc>, 
+                                               NFlatHash::NMap::TStaticValueMarker<emptyMarker, T>,
+                                               Alloc>,
                     Probing, NFlatHash::TAndSizeFitter, NFlatHash::TSimpleExpander>;
 
 
-template <class T, class Hash, class KeyEqual, class Probing, class Alloc> 
+template <class T, class Hash, class KeyEqual, class Probing, class Alloc>
 using TFlatHashSetImpl = NFlatHash::TSet<T, Hash, KeyEqual,
-                                         NFlatHash::TFlatContainer<T, Alloc>, 
+                                         NFlatHash::TFlatContainer<T, Alloc>,
                                          Probing, NFlatHash::TAndSizeFitter,
                                          NFlatHash::TSimpleExpander>;
 
-template <class T, auto emptyMarker, class Hash, class KeyEqual, class Probing, class Alloc> 
+template <class T, auto emptyMarker, class Hash, class KeyEqual, class Probing, class Alloc>
 using TDenseHashSetImpl =
     NFlatHash::TSet<T, Hash, KeyEqual,
-                    NFlatHash::TDenseContainer<T, NFlatHash::NSet::TStaticValueMarker<emptyMarker>, Alloc>, 
+                    NFlatHash::TDenseContainer<T, NFlatHash::NSet::TStaticValueMarker<emptyMarker>, Alloc>,
                     Probing, NFlatHash::TAndSizeFitter, NFlatHash::TSimpleExpander>;
 
 }  // namespace NPrivate
@@ -60,9 +60,9 @@ template <class Key,
           class T,
           class Hash = THash<Key>,
           class KeyEqual = std::equal_to<>,
-          class Probing = NFlatHash::TLinearProbing, 
-          class Alloc = std::allocator<std::pair<const Key, T>>> 
-using TFlatHashMap = NPrivate::TFlatHashMapImpl<Key, T, Hash, KeyEqual, Probing, Alloc>; 
+          class Probing = NFlatHash::TLinearProbing,
+          class Alloc = std::allocator<std::pair<const Key, T>>>
+using TFlatHashMap = NPrivate::TFlatHashMapImpl<Key, T, Hash, KeyEqual, Probing, Alloc>;
 
 /* Open addressing table with user specified marker for empty buckets.
  * Currently available probings:
@@ -75,10 +75,10 @@ template <class Key,
           auto emptyMarker,
           class Hash = THash<Key>,
           class KeyEqual = std::equal_to<>,
-          class Probing = NFlatHash::TDenseProbing, 
-          class Alloc = std::allocator<std::pair<const Key, T>>> 
+          class Probing = NFlatHash::TDenseProbing,
+          class Alloc = std::allocator<std::pair<const Key, T>>>
 using TDenseHashMapStaticMarker = NPrivate::TDenseHashMapImpl<Key, T, emptyMarker,
-                                                              Hash, KeyEqual, Probing, Alloc>; 
+                                                              Hash, KeyEqual, Probing, Alloc>;
 
 
 /* flat_set: Fast and highly customizable hash set.
@@ -98,9 +98,9 @@ using TDenseHashMapStaticMarker = NPrivate::TDenseHashMapImpl<Key, T, emptyMarke
 template <class T,
           class Hash = THash<T>,
           class KeyEqual = std::equal_to<>,
-          class Probing = NFlatHash::TLinearProbing, 
-          class Alloc = std::allocator<T>> 
-using TFlatHashSet = NPrivate::TFlatHashSetImpl<T, Hash, KeyEqual, Probing, Alloc>; 
+          class Probing = NFlatHash::TLinearProbing,
+          class Alloc = std::allocator<T>>
+using TFlatHashSet = NPrivate::TFlatHashSetImpl<T, Hash, KeyEqual, Probing, Alloc>;
 
 /* Open addressing table with user specified marker for empty buckets.
  * Currently available probings:
@@ -112,9 +112,9 @@ template <class T,
           auto emptyMarker,
           class Hash = THash<T>,
           class KeyEqual = std::equal_to<>,
-          class Probing = NFlatHash::TDenseProbing, 
-          class Alloc = std::allocator<T>> 
+          class Probing = NFlatHash::TDenseProbing,
+          class Alloc = std::allocator<T>>
 using TDenseHashSetStaticMarker = NPrivate::TDenseHashSetImpl<T, emptyMarker,
-                                                              Hash, KeyEqual, Probing, Alloc>; 
+                                                              Hash, KeyEqual, Probing, Alloc>;
 
 }  // namespace NFH
diff --git a/library/cpp/containers/flat_hash/lib/containers.h b/library/cpp/containers/flat_hash/lib/containers.h
index 485eb7ae4f..82008f2f9c 100644
--- a/library/cpp/containers/flat_hash/lib/containers.h
+++ b/library/cpp/containers/flat_hash/lib/containers.h
@@ -15,15 +15,15 @@ namespace NFlatHash {
 
 /* FLAT CONTAINER */
 
-template <class T, class Alloc = std::allocator<T>> 
+template <class T, class Alloc = std::allocator<T>>
 class TFlatContainer {
 public:
     using value_type = T;
     using size_type = size_t;
     using difference_type = ptrdiff_t;
-    using allocator_type = Alloc; 
-    using pointer = typename std::allocator_traits<allocator_type>::pointer; 
-    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer; 
+    using allocator_type = Alloc;
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
 
 private:
     class TCage {
@@ -98,8 +98,8 @@ private:
     };
 
 public:
-    explicit TFlatContainer(size_type initSize, const allocator_type& alloc = {}) 
-        : Buckets_(initSize, alloc) 
+    explicit TFlatContainer(size_type initSize, const allocator_type& alloc = {})
+        : Buckets_(initSize, alloc)
         , Taken_(0)
         , Empty_(initSize) {}
 
@@ -145,10 +145,10 @@ public:
         DoSwap(Empty_, rhs.Empty_);
     }
 
-    TFlatContainer Clone(size_type newSize) const { return TFlatContainer(newSize, Buckets_.get_allocator()); } 
+    TFlatContainer Clone(size_type newSize) const { return TFlatContainer(newSize, Buckets_.get_allocator()); }
 
 private:
-    TVector<TCage, allocator_type> Buckets_; 
+    TVector<TCage, allocator_type> Buckets_;
     size_type Taken_;
     size_type Empty_;
 };
@@ -158,7 +158,7 @@ static_assert(NConcepts::RemovalContainerV<TFlatContainer<int>>);
 
 /* DENSE CONTAINER */
 
-template <class T, class EmptyMarker = NSet::TEqValueMarker<T>, class Alloc = std::allocator<T>> 
+template <class T, class EmptyMarker = NSet::TEqValueMarker<T>, class Alloc = std::allocator<T>>
 class TDenseContainer {
     static_assert(NConcepts::ValueMarkerV<EmptyMarker>);
 
@@ -166,13 +166,13 @@ public:
     using value_type = T;
     using size_type = size_t;
     using difference_type = ptrdiff_t;
-    using allocator_type = Alloc; 
-    using pointer = typename std::allocator_traits<allocator_type>::pointer; 
-    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer; 
+    using allocator_type = Alloc;
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
 
 public:
-    TDenseContainer(size_type initSize,  EmptyMarker emptyMarker = {}, const allocator_type& alloc = {}) 
-        : Buckets_(initSize, emptyMarker.Create(), alloc) 
+    TDenseContainer(size_type initSize,  EmptyMarker emptyMarker = {}, const allocator_type& alloc = {})
+        : Buckets_(initSize, emptyMarker.Create(), alloc)
         , Taken_(0)
         , EmptyMarker_(std::move(emptyMarker)) {}
 
@@ -217,15 +217,15 @@ public:
         DoSwap(Taken_, rhs.Taken_);
     }
 
-    TDenseContainer Clone(size_type newSize) const { return { newSize, EmptyMarker_, GetAllocator() }; } 
+    TDenseContainer Clone(size_type newSize) const { return { newSize, EmptyMarker_, GetAllocator() }; }
 
 protected:
-    allocator_type GetAllocator() const { 
-        return Buckets_.get_allocator(); 
-    } 
- 
-protected: 
-    TVector<value_type, allocator_type> Buckets_; 
+    allocator_type GetAllocator() const {
+        return Buckets_.get_allocator();
+    }
+
+protected:
+    TVector<value_type, allocator_type> Buckets_;
     size_type Taken_;
     EmptyMarker EmptyMarker_;
 };
@@ -234,8 +234,8 @@ static_assert(NConcepts::ContainerV<TDenseContainer<int>>);
 static_assert(!NConcepts::RemovalContainerV<TDenseContainer<int>>);
 
 template <class T, class DeletedMarker = NSet::TEqValueMarker<T>,
-          class EmptyMarker = NSet::TEqValueMarker<T>, class Alloc = std::allocator<T>> 
-class TRemovalDenseContainer : private TDenseContainer<T, EmptyMarker, Alloc> { 
+          class EmptyMarker = NSet::TEqValueMarker<T>, class Alloc = std::allocator<T>>
+class TRemovalDenseContainer : private TDenseContainer<T, EmptyMarker, Alloc> {
 private:
     static_assert(NConcepts::ValueMarkerV<DeletedMarker>);
 
@@ -245,17 +245,17 @@ public:
     using typename TBase::value_type;
     using typename TBase::size_type;
     using typename TBase::difference_type;
-    using typename TBase::allocator_type; 
-    using typename TBase::pointer; 
-    using typename TBase::const_pointer; 
+    using typename TBase::allocator_type;
+    using typename TBase::pointer;
+    using typename TBase::const_pointer;
 
 public:
     TRemovalDenseContainer(
         size_type initSize,
         DeletedMarker deletedMarker = {},
-        EmptyMarker emptyMarker = {}, 
-        const allocator_type& alloc = {}) 
-        : TBase(initSize, std::move(emptyMarker), alloc) 
+        EmptyMarker emptyMarker = {},
+        const allocator_type& alloc = {})
+        : TBase(initSize, std::move(emptyMarker), alloc)
         , DeletedMarker_(std::move(deletedMarker))
         , Empty_(initSize) {}
 
@@ -300,7 +300,7 @@ public:
     }
 
     TRemovalDenseContainer Clone(size_type newSize) const {
-        return { newSize, DeletedMarker_, TBase::EmptyMarker_, TBase::GetAllocator() }; 
+        return { newSize, DeletedMarker_, TBase::EmptyMarker_, TBase::GetAllocator() };
     }
 
 private:
diff --git a/library/cpp/containers/flat_hash/lib/map.h b/library/cpp/containers/flat_hash/lib/map.h
index 14ce5f8c9b..f77c318a61 100644
--- a/library/cpp/containers/flat_hash/lib/map.h
+++ b/library/cpp/containers/flat_hash/lib/map.h
@@ -67,9 +67,9 @@ public:
     using typename TBase::const_reference;
     using typename TBase::iterator;
     using typename TBase::const_iterator;
-    using typename TBase::allocator_type; 
-    using typename TBase::pointer; 
-    using typename TBase::const_pointer; 
+    using typename TBase::allocator_type;
+    using typename TBase::pointer;
+    using typename TBase::const_pointer;
 
 private:
     static constexpr size_type INIT_SIZE = 8;
diff --git a/library/cpp/containers/flat_hash/lib/set.h b/library/cpp/containers/flat_hash/lib/set.h
index 2694711a35..5266293c6c 100644
--- a/library/cpp/containers/flat_hash/lib/set.h
+++ b/library/cpp/containers/flat_hash/lib/set.h
@@ -58,9 +58,9 @@ public:
     using typename TBase::const_reference;
     using typename TBase::iterator;
     using typename TBase::const_iterator;
-    using typename TBase::allocator_type; 
-    using typename TBase::pointer; 
-    using typename TBase::const_pointer; 
+    using typename TBase::allocator_type;
+    using typename TBase::pointer;
+    using typename TBase::const_pointer;
 
 private:
     static constexpr size_type INIT_SIZE = 8;
diff --git a/library/cpp/containers/flat_hash/lib/table.h b/library/cpp/containers/flat_hash/lib/table.h
index 2af81056a8..b84a052be7 100644
--- a/library/cpp/containers/flat_hash/lib/table.h
+++ b/library/cpp/containers/flat_hash/lib/table.h
@@ -57,9 +57,9 @@ public:
     using iterator = TIteratorImpl<typename IteratorModifier<Container>::type,
                                    typename IteratorModifier<value_type>::type>;
     using const_iterator = TIteratorImpl<const Container, const value_type>;
-    using allocator_type = typename Container::allocator_type; 
-    using pointer = typename Container::pointer; 
-    using const_pointer = typename Container::const_pointer; 
+    using allocator_type = typename Container::allocator_type;
+    using pointer = typename Container::pointer;
+    using const_pointer = typename Container::const_pointer;
 
 private:
     TTable(Container buckets)
diff --git a/library/cpp/containers/flat_hash/ut/flat_hash_ut.cpp b/library/cpp/containers/flat_hash/ut/flat_hash_ut.cpp
index 76004649c0..2b9d6a1dc2 100644
--- a/library/cpp/containers/flat_hash/ut/flat_hash_ut.cpp
+++ b/library/cpp/containers/flat_hash/ut/flat_hash_ut.cpp
@@ -20,8 +20,8 @@ const std::initializer_list<std::pair<const int, TString>> MAP_INPUT_SAMPLE{
 
 template <class Map>
 class TMapTest : public TTestBase {
-    void AllocatorTest(); 
- 
+    void AllocatorTest();
+
     void SmokingTest() {
         Map mp;
         mp.emplace(5, "abc");
@@ -123,7 +123,7 @@ class TMapTest : public TTestBase {
     }
 
     UNIT_TEST_SUITE_DEMANGLE(TMapTest);
-    UNIT_TEST(AllocatorTest); 
+    UNIT_TEST(AllocatorTest);
     UNIT_TEST(SmokingTest);
     UNIT_TEST(CopyConstructionTest);
     UNIT_TEST(MoveConstructionTest);
@@ -135,18 +135,18 @@ class TMapTest : public TTestBase {
     UNIT_TEST_SUITE_END();
 };
 
-template <> 
-void TMapTest<TFlatHashMap<int, TString>>::AllocatorTest() { 
-    using Map = TFlatHashMap<int, TString>; 
-    Map mp(3, typename Map::allocator_type()); 
-} 
- 
-template <> 
-void TMapTest<TDenseHashMapStaticMarker<int, TString, -1>>::AllocatorTest() { 
-    using Map = TDenseHashMapStaticMarker<int, TString, -1>; 
-    Map mp(3, NFlatHash::NMap::TStaticValueMarker<-1, TString>(), typename Map::allocator_type()); 
-} 
- 
+template <>
+void TMapTest<TFlatHashMap<int, TString>>::AllocatorTest() {
+    using Map = TFlatHashMap<int, TString>;
+    Map mp(3, typename Map::allocator_type());
+}
+
+template <>
+void TMapTest<TDenseHashMapStaticMarker<int, TString, -1>>::AllocatorTest() {
+    using Map = TDenseHashMapStaticMarker<int, TString, -1>;
+    Map mp(3, NFlatHash::NMap::TStaticValueMarker<-1, TString>(), typename Map::allocator_type());
+}
+
 using TFlatHashMapTest = TMapTest<TFlatHashMap<int, TString>>;
 using TDenseHashMapTest = TMapTest<TDenseHashMapStaticMarker<int, TString, -1>>;
 
@@ -156,7 +156,7 @@ UNIT_TEST_SUITE_REGISTRATION(TDenseHashMapTest);
 
 template <class Set>
 class TSetTest : public TTestBase {
-    void AllocatorTest(); 
+    void AllocatorTest();
     void DefaultConstructTest() {
         Set st;
 
@@ -241,7 +241,7 @@ class TSetTest : public TTestBase {
     }
 
     UNIT_TEST_SUITE_DEMANGLE(TSetTest);
-    UNIT_TEST(AllocatorTest); 
+    UNIT_TEST(AllocatorTest);
     UNIT_TEST(DefaultConstructTest);
     UNIT_TEST(InitCapacityConstructTest);
     UNIT_TEST(IteratorsConstructTest);
@@ -253,19 +253,19 @@ class TSetTest : public TTestBase {
     UNIT_TEST_SUITE_END();
 };
 
-template <> 
-void TSetTest<TFlatHashSet<int>>::AllocatorTest() { 
-    using Map = TFlatHashSet<int>; 
-    Map mp(3, typename Map::allocator_type()); 
-} 
- 
-template <> 
-void TSetTest<TDenseHashSetStaticMarker<int, -1>>::AllocatorTest() { 
-    using Map = TDenseHashSetStaticMarker<int, -1>; 
-    Map mp(3, NFlatHash::NSet::TStaticValueMarker<-1>(), typename Map::allocator_type()); 
-} 
- 
-using TFlatHashSetTest = TSetTest<TFlatHashSet<int, THash<int>>>; 
+template <>
+void TSetTest<TFlatHashSet<int>>::AllocatorTest() {
+    using Map = TFlatHashSet<int>;
+    Map mp(3, typename Map::allocator_type());
+}
+
+template <>
+void TSetTest<TDenseHashSetStaticMarker<int, -1>>::AllocatorTest() {
+    using Map = TDenseHashSetStaticMarker<int, -1>;
+    Map mp(3, NFlatHash::NSet::TStaticValueMarker<-1>(), typename Map::allocator_type());
+}
+
+using TFlatHashSetTest = TSetTest<TFlatHashSet<int, THash<int>>>;
 using TDenseHashSetTest = TSetTest<TDenseHashSetStaticMarker<int, -1>>;
 
 UNIT_TEST_SUITE_REGISTRATION(TFlatHashSetTest);
diff --git a/library/cpp/getopt/small/last_getopt_opts.h b/library/cpp/getopt/small/last_getopt_opts.h
index 1361ad6731..825b99c871 100644
--- a/library/cpp/getopt/small/last_getopt_opts.h
+++ b/library/cpp/getopt/small/last_getopt_opts.h
@@ -43,7 +43,7 @@ namespace NLastGetopt {
 
         typedef TVector<TSimpleSharedPtr<TOpt>> TOptsVector;
         TOptsVector Opts_; // infomation about named (short and long) options
-        TVector<std::function<void(TStringBuf)>> ArgBindings_; 
+        TVector<std::function<void(TStringBuf)>> ArgBindings_;
 
         EArgPermutation ArgPermutation_ = DEFAULT_ARG_PERMUTATION; // determines how to parse positions of named and free options. See information below.
         bool AllowSingleDashForLong_ = false;                      //
@@ -245,22 +245,22 @@ namespace NLastGetopt {
         TOpt& AddOption(const TOpt& option);
 
         /**
-         * Creates new free argument handling 
-         * @param name   name of free arg to show in help 
-         * @param target variable address to store parsing result into 
-         * @param help   help string to show in help 
-         */ 
-        template <typename T> 
-        void AddFreeArgBinding(const TString& name, T& target, const TString& help = "") { 
-            ArgBindings_.emplace_back([&target](TStringBuf value) { 
-                target = FromString<T>(value); 
-            }); 
- 
-            FreeArgsMax_ = Max<ui32>(FreeArgsMax_, ArgBindings_.size()); 
-            SetFreeArgTitle(ArgBindings_.size() - 1, name, help); 
-        } 
- 
-        /** 
+         * Creates new free argument handling
+         * @param name   name of free arg to show in help
+         * @param target variable address to store parsing result into
+         * @param help   help string to show in help
+         */
+        template <typename T>
+        void AddFreeArgBinding(const TString& name, T& target, const TString& help = "") {
+            ArgBindings_.emplace_back([&target](TStringBuf value) {
+                target = FromString<T>(value);
+            });
+
+            FreeArgsMax_ = Max<ui32>(FreeArgsMax_, ArgBindings_.size());
+            SetFreeArgTitle(ArgBindings_.size() - 1, name, help);
+        }
+
+        /**
          * Creates options list from string as in getopt(3)
          *
          * @param optstring   source
@@ -460,11 +460,11 @@ namespace NLastGetopt {
         /**
          * Set maximal number of free args
          *
-         * @param max        new value 
+         * @param max        new value
          */
         void SetFreeArgsMax(size_t max) {
             FreeArgsMax_ = ui32(max);
-            FreeArgsMax_ = Max<ui32>(FreeArgsMax_, ArgBindings_.size()); 
+            FreeArgsMax_ = Max<ui32>(FreeArgsMax_, ArgBindings_.size());
         }
 
         /**
diff --git a/library/cpp/getopt/small/last_getopt_parse_result.cpp b/library/cpp/getopt/small/last_getopt_parse_result.cpp
index d7230c2592..f4b5607a90 100644
--- a/library/cpp/getopt/small/last_getopt_parse_result.cpp
+++ b/library/cpp/getopt/small/last_getopt_parse_result.cpp
@@ -126,16 +126,16 @@ namespace NLastGetopt {
                 TOptParseResult& r = OptParseResult();
                 r.AddValue(Parser_->CurValOrOpt().data());
             }
- 
-            Y_ENSURE(options); 
-            const auto freeArgs = GetFreeArgs(); 
-            for (size_t i = 0; i < freeArgs.size(); ++i) { 
-                if (i >= options->ArgBindings_.size()) { 
-                    break; 
-                } 
- 
-                options->ArgBindings_[i](freeArgs[i]); 
-            } 
+
+            Y_ENSURE(options);
+            const auto freeArgs = GetFreeArgs();
+            for (size_t i = 0; i < freeArgs.size(); ++i) {
+                if (i >= options->ArgBindings_.size()) {
+                    break;
+                }
+
+                options->ArgBindings_[i](freeArgs[i]);
+            }
         } catch (...) {
             HandleError();
         }
diff --git a/library/cpp/getopt/ut/last_getopt_ut.cpp b/library/cpp/getopt/ut/last_getopt_ut.cpp
index 9b6dcbbc27..c99a1d053d 100644
--- a/library/cpp/getopt/ut/last_getopt_ut.cpp
+++ b/library/cpp/getopt/ut/last_getopt_ut.cpp
@@ -779,16 +779,16 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
             TOptsParseResultException(&opts, Y_ARRAY_SIZE(argv), argv),
             TUsageException);
     }
- 
-    Y_UNIT_TEST(TestFreeArgsStoreResult) { 
-        TOptsNoDefault opts; 
-        TString data; 
-        int number = 0; 
-        opts.AddFreeArgBinding("data", data); 
-        opts.AddFreeArgBinding("number", number); 
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "hello", "25"})); 
-        UNIT_ASSERT_VALUES_EQUAL("hello", data); 
-        UNIT_ASSERT_VALUES_EQUAL(25, number); 
-        UNIT_ASSERT_VALUES_EQUAL(2, r.GetFreeArgCount()); 
-    } 
+
+    Y_UNIT_TEST(TestFreeArgsStoreResult) {
+        TOptsNoDefault opts;
+        TString data;
+        int number = 0;
+        opts.AddFreeArgBinding("data", data);
+        opts.AddFreeArgBinding("number", number);
+        TOptsParseResultTestWrapper r(&opts, V({"cmd", "hello", "25"}));
+        UNIT_ASSERT_VALUES_EQUAL("hello", data);
+        UNIT_ASSERT_VALUES_EQUAL(25, number);
+        UNIT_ASSERT_VALUES_EQUAL(2, r.GetFreeArgCount());
+    }
 }
diff --git a/library/cpp/http/io/headers.cpp b/library/cpp/http/io/headers.cpp
index 2f6992100c..4ec27a29e8 100644
--- a/library/cpp/http/io/headers.cpp
+++ b/library/cpp/http/io/headers.cpp
@@ -60,16 +60,16 @@ THttpHeaders::THttpHeaders(IInputStream* stream) {
 }
 
 bool THttpHeaders::HasHeader(const TStringBuf header) const {
-    return FindHeader(header); 
-} 
- 
+    return FindHeader(header);
+}
+
 const THttpInputHeader* THttpHeaders::FindHeader(const TStringBuf header) const {
-    for (const auto& hdr : Headers_) { 
+    for (const auto& hdr : Headers_) {
         if (AsciiCompareIgnoreCase(hdr.Name(), header) == 0) {
-            return &hdr; 
+            return &hdr;
         }
     }
-    return nullptr; 
+    return nullptr;
 }
 
 void THttpHeaders::RemoveHeader(const TStringBuf header) {
diff --git a/library/cpp/http/io/headers.h b/library/cpp/http/io/headers.h
index 16e979236c..a71793d1c6 100644
--- a/library/cpp/http/io/headers.h
+++ b/library/cpp/http/io/headers.h
@@ -2,9 +2,9 @@
 
 #include <util/generic/string.h>
 #include <util/generic/strbuf.h>
-#include <util/generic/deque.h> 
+#include <util/generic/deque.h>
 #include <util/generic/vector.h>
-#include <util/string/cast.h> 
+#include <util/string/cast.h>
 
 class IInputStream;
 class IOutputStream;
@@ -105,10 +105,10 @@ public:
     /// Удаляет заголовок, если он есть.
     void RemoveHeader(TStringBuf header);
 
-    /// Ищет заголовок по указанному имени 
-    /// Возвращает nullptr, если не нашел 
+    /// Ищет заголовок по указанному имени
+    /// Возвращает nullptr, если не нашел
     const THttpInputHeader* FindHeader(TStringBuf header) const;
- 
+
     /// Записывает все заголовки контейнера в поток.
     /// @details Каждый заголовк записывается в виде "имя параметра: значение\r\n".
     void OutTo(IOutputStream* stream) const;
diff --git a/library/cpp/http/io/headers_ut.cpp b/library/cpp/http/io/headers_ut.cpp
index dd963d7fd1..1d23ef8fdc 100644
--- a/library/cpp/http/io/headers_ut.cpp
+++ b/library/cpp/http/io/headers_ut.cpp
@@ -49,7 +49,7 @@ class THttpHeadersTest: public TTestBase {
     UNIT_TEST(TestAddOrReplaceOperation1Arg);
     UNIT_TEST(TestAddOrReplaceOperation2Args);
     UNIT_TEST(TestAddHeaderTemplateness);
-    UNIT_TEST(TestFindHeader); 
+    UNIT_TEST(TestFindHeader);
     UNIT_TEST_SUITE_END();
 
 private:
@@ -62,7 +62,7 @@ public:
     void TestAddOrReplaceOperation1Arg();
     void TestAddOrReplaceOperation2Args();
     void TestAddHeaderTemplateness();
-    void TestFindHeader(); 
+    void TestFindHeader();
 
 private:
     static void AddHeaderImpl1Arg(THttpHeaders& headers, TStringBuf name, TStringBuf value) {
@@ -166,11 +166,11 @@ void THttpHeadersTest::TestAddHeaderTemplateness() {
 
     UNIT_ASSERT(h1 == h2);
 }
- 
-void THttpHeadersTest::TestFindHeader() { 
-    THttpHeaders sut; 
-    sut.AddHeader("NaMe", "Value"); 
- 
-    UNIT_ASSERT(sut.FindHeader("name")); 
-    UNIT_ASSERT(sut.FindHeader("name")->Value() == "Value"); 
-} 
+
+void THttpHeadersTest::TestFindHeader() {
+    THttpHeaders sut;
+    sut.AddHeader("NaMe", "Value");
+
+    UNIT_ASSERT(sut.FindHeader("name"));
+    UNIT_ASSERT(sut.FindHeader("name")->Value() == "Value");
+}
diff --git a/library/cpp/http/server/http.cpp b/library/cpp/http/server/http.cpp
index ef5bd5d6a3..128583bdd7 100644
--- a/library/cpp/http/server/http.cpp
+++ b/library/cpp/http/server/http.cpp
@@ -816,10 +816,10 @@ bool TryToBindAddresses(const THttpServerOptions& options, const std::function<v
 
             FixIPv6ListenSocket(socket);
 
-            if (options.ReuseAddress) { 
-                int yes = 1; 
-                ::setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes)); 
-            } 
+            if (options.ReuseAddress) {
+                int yes = 1;
+                ::setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes));
+            }
 
             if (options.ReusePort) {
                 SetReusePort(socket, true);
diff --git a/library/cpp/http/server/options.h b/library/cpp/http/server/options.h
index dfc2258493..38eda0e5e7 100644
--- a/library/cpp/http/server/options.h
+++ b/library/cpp/http/server/options.h
@@ -56,12 +56,12 @@ public:
         return *this;
     }
 
-    inline THttpServerOptions& EnableReuseAddress(bool enable) noexcept { 
-        ReuseAddress = enable; 
- 
-        return *this; 
-    } 
- 
+    inline THttpServerOptions& EnableReuseAddress(bool enable) noexcept {
+        ReuseAddress = enable;
+
+        return *this;
+    }
+
     inline THttpServerOptions& SetThreads(ui32 threads) noexcept {
         nThreads = threads;
 
@@ -150,7 +150,7 @@ public:
     bool CompressionEnabled = false;
     bool RejectExcessConnections = false;
     bool ReusePort = false; // set SO_REUSEPORT socket option
-    bool ReuseAddress = true; // set SO_REUSEADDR socket option 
+    bool ReuseAddress = true; // set SO_REUSEADDR socket option
     TAddrs BindSockaddr;
     ui16 Port = 17000;                  // The port on which to run the web server
     TString Host;                       // DNS entry
diff --git a/library/cpp/string_utils/base64/base64_decode_uneven_ut.cpp b/library/cpp/string_utils/base64/base64_decode_uneven_ut.cpp
index 07594a6ded..c3ed068a37 100644
--- a/library/cpp/string_utils/base64/base64_decode_uneven_ut.cpp
+++ b/library/cpp/string_utils/base64/base64_decode_uneven_ut.cpp
@@ -1,7 +1,7 @@
 #include <library/cpp/testing/unittest/registar.h>
 
 #include <library/cpp/string_utils/base64/base64.h>
- 
+
 Y_UNIT_TEST_SUITE(TBase64DecodeUneven) {
     Y_UNIT_TEST(Base64DecodeUneven) {
         const TString wikipedia_slogan =
diff --git a/util/datetime/parser.rl6 b/util/datetime/parser.rl6
index 05509d4356..931f09eae1 100644
--- a/util/datetime/parser.rl6
+++ b/util/datetime/parser.rl6
@@ -729,7 +729,7 @@ include DateTimeParserCommon;
 
 multiplier
     = '' #   >{ MultiplierPower =  6; } # work around Ragel bugs
-    | 'w'  @{ MultiplierPower =  6; Multiplier = 604800; } 
+    | 'w'  @{ MultiplierPower =  6; Multiplier = 604800; }
     | 'd'  @{ MultiplierPower =  6; Multiplier = 86400; }
     | 'h'  @{ MultiplierPower =  6; Multiplier = 3600; }
     | 'm'  @{ MultiplierPower =  6; Multiplier = 60; }
diff --git a/util/generic/maybe.h b/util/generic/maybe.h
index 2066f6bb7b..34d21aebcd 100644
--- a/util/generic/maybe.h
+++ b/util/generic/maybe.h
@@ -377,11 +377,11 @@ public:
         return Defined() ? *this : elseValue;
     }
 
-    template <typename U> 
+    template <typename U>
     TMaybe<U, Policy> Cast() const {
         return Defined() ? TMaybe<U, Policy>(*Data()) : TMaybe<U, Policy>();
-    } 
- 
+    }
+
     constexpr explicit operator bool() const noexcept {
         return Defined();
     }
diff --git a/util/generic/maybe_ut.cpp b/util/generic/maybe_ut.cpp
index 289824521a..2c1a425c5e 100644
--- a/util/generic/maybe_ut.cpp
+++ b/util/generic/maybe_ut.cpp
@@ -208,19 +208,19 @@ Y_UNIT_TEST_SUITE(TMaybeTest) {
         TMovable o6 = MakeMaybe<TMovable>(6).GetRef();
         UNIT_ASSERT_VALUES_EQUAL(o6.Flag, 6);
     }
- 
+
     Y_UNIT_TEST(TestCast) {
-        // Undefined maybe casts to undefined maybe 
-        TMaybe<short> shortMaybe; 
-        const auto undefinedMaybe = shortMaybe.Cast<long>(); 
-        UNIT_ASSERT(!undefinedMaybe.Defined()); 
- 
-        // Defined maybe casts to defined maybe of another type 
-        shortMaybe = 34; 
-        const auto longMaybe = shortMaybe.Cast<long>(); 
-        UNIT_ASSERT(longMaybe.Defined()); 
-        UNIT_ASSERT_VALUES_EQUAL(34, longMaybe.GetRef()); 
-    } 
+        // Undefined maybe casts to undefined maybe
+        TMaybe<short> shortMaybe;
+        const auto undefinedMaybe = shortMaybe.Cast<long>();
+        UNIT_ASSERT(!undefinedMaybe.Defined());
+
+        // Defined maybe casts to defined maybe of another type
+        shortMaybe = 34;
+        const auto longMaybe = shortMaybe.Cast<long>();
+        UNIT_ASSERT(longMaybe.Defined());
+        UNIT_ASSERT_VALUES_EQUAL(34, longMaybe.GetRef());
+    }
 
     Y_UNIT_TEST(TestGetOr) {
         UNIT_ASSERT_VALUES_EQUAL(TMaybe<TString>().GetOrElse("xxx"), TString("xxx"));
diff --git a/util/generic/ptr.h b/util/generic/ptr.h
index 4d652175d2..19db0e3ec5 100644
--- a/util/generic/ptr.h
+++ b/util/generic/ptr.h
@@ -818,9 +818,9 @@ public:
 
     template <class TT, class = TGuardConversion<T, TT>>
     inline TSharedPtr(THolder<TT>&& t) {
-        Init(t); 
-    } 
- 
+        Init(t);
+    }
+
     inline ~TSharedPtr() {
         UnRef();
     }
diff --git a/util/generic/typetraits.h b/util/generic/typetraits.h
index 9cb9527a8d..d165bd1a06 100644
--- a/util/generic/typetraits.h
+++ b/util/generic/typetraits.h
@@ -4,7 +4,7 @@
 
 #include <util/system/defaults.h>
 
-#include <iterator> 
+#include <iterator>
 #include <type_traits>
 #include <stlfwd>
 
@@ -300,21 +300,21 @@ using TEnableIfTuple = std::enable_if_t<::TDisjunction<::TIsSpecializationOf<std
                                                        ::TIsSpecializationOf<std::pair, std::decay_t<T>>>::value,
                                         R>;
 
-namespace NPrivate { 
-    // To allow ADL with custom begin/end 
-    using std::begin; 
-    using std::end; 
- 
-    template <typename T> 
+namespace NPrivate {
+    // To allow ADL with custom begin/end
+    using std::begin;
+    using std::end;
+
+    template <typename T>
     auto IsIterableImpl(int) -> decltype(
         begin(std::declval<T&>()) != end(std::declval<T&>()),   // begin/end and operator !=
-        ++std::declval<decltype(begin(std::declval<T&>()))&>(), // operator ++ 
+        ++std::declval<decltype(begin(std::declval<T&>()))&>(), // operator ++
         *begin(std::declval<T&>()),                             // operator*
         std::true_type{});
- 
-    template <typename T> 
-    std::false_type IsIterableImpl(...); 
-} 
- 
-template <typename T> 
-using TIsIterable = decltype(NPrivate::IsIterableImpl<T>(0)); 
+
+    template <typename T>
+    std::false_type IsIterableImpl(...);
+}
+
+template <typename T>
+using TIsIterable = decltype(NPrivate::IsIterableImpl<T>(0));
diff --git a/util/generic/typetraits_ut.cpp b/util/generic/typetraits_ut.cpp
index 4de0c5377f..e7571c75ec 100644
--- a/util/generic/typetraits_ut.cpp
+++ b/util/generic/typetraits_ut.cpp
@@ -456,11 +456,11 @@ static_assert(TIsSpecializationOf<std::vector, std::vector<int>>::value, "");
 static_assert(TIsSpecializationOf<std::tuple, std::tuple<int, double, char>>::value, "");
 static_assert(!TIsSpecializationOf<std::vector, std::tuple<int, double, char>>::value, "");
 static_assert(!TIsSpecializationOf<std::pair, std::vector<int>>::value, "");
- 
-// test for TIsIterable 
-static_assert(TIsIterable<std::vector<int>>::value, ""); 
-static_assert(!TIsIterable<int>::value, ""); 
-static_assert(TIsIterable<int[42]>::value, ""); 
+
+// test for TIsIterable
+static_assert(TIsIterable<std::vector<int>>::value, "");
+static_assert(!TIsIterable<int>::value, "");
+static_assert(TIsIterable<int[42]>::value, "");
 
 // test for TDependentFalse
 static_assert(TDependentFalse<int> == false);
diff --git a/util/generic/vector.h b/util/generic/vector.h
index d4ac69180d..a5b258955a 100644
--- a/util/generic/vector.h
+++ b/util/generic/vector.h
@@ -42,11 +42,11 @@ public:
     {
     }
 
-    inline explicit TVector(size_type count, const typename TBase::allocator_type& a) 
-        : TBase(count, a) 
-    { 
-    } 
- 
+    inline explicit TVector(size_type count, const typename TBase::allocator_type& a)
+        : TBase(count, a)
+    {
+    }
+
     inline TVector(size_type count, const T& val)
         : TBase(count, val)
     {
diff --git a/util/string/builder.h b/util/string/builder.h
index 1517e79ac0..7b54821151 100644
--- a/util/string/builder.h
+++ b/util/string/builder.h
@@ -12,12 +12,12 @@ namespace NPrivateStringBuilder {
         {
         }
 
-        TStringBuilder(TStringBuilder&& rhs) 
-            : TString(std::move(rhs)) 
-            , Out(*this) 
-        { 
-        } 
- 
+        TStringBuilder(TStringBuilder&& rhs)
+            : TString(std::move(rhs))
+            , Out(*this)
+        {
+        }
+
         TStringOutput Out;
     };
 
diff --git a/util/system/info.cpp b/util/system/info.cpp
index 4fd28c28cc..cf6681e89a 100644
--- a/util/system/info.cpp
+++ b/util/system/info.cpp
@@ -75,8 +75,8 @@ size_t NSystemInfo::NumberOfCpus() {
     GetSystemInfo(&info);
 
     return info.dwNumberOfProcessors;
-#elif defined(_SC_NPROCESSORS_ONLN) 
-    return sysconf(_SC_NPROCESSORS_ONLN); 
+#elif defined(_SC_NPROCESSORS_ONLN)
+    return sysconf(_SC_NPROCESSORS_ONLN);
 #elif defined(_linux_)
     unsigned ret;
     int fd, nread, column;
diff --git a/util/thread/pool.h b/util/thread/pool.h
index 1db151be8e..d1ea3a67cb 100644
--- a/util/thread/pool.h
+++ b/util/thread/pool.h
@@ -304,7 +304,7 @@ public:
 
     bool Add(IObjectInQueue* obj) override Y_WARN_UNUSED_RESULT;
     /** @param thrnum, @param maxque are ignored */
-    void Start(size_t thrnum = 0, size_t maxque = 0) override; 
+    void Start(size_t thrnum = 0, size_t maxque = 0) override;
     void Stop() noexcept override;
     size_t Size() const noexcept override;