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

22 files changed, 630 insertions, 630 deletions

diff --git a/library/cpp/logger/thread.cpp b/library/cpp/logger/thread.cpp
index 8e2e89ff88..0ccf9e374b 100644
--- a/library/cpp/logger/thread.cpp
+++ b/library/cpp/logger/thread.cpp
@@ -106,10 +106,10 @@ public:
         Slave_->ReopenLogNoFlush();
     }
 
-    inline size_t QueueSize() const { 
-        return Queue_.Size(); 
-    } 
- 
+    inline size_t QueueSize() const {
+        return Queue_.Size();
+    }
+
 private:
     TLogBackend* Slave_;
     TThreadPool Queue_{"ThreadedLogBack"};
@@ -145,10 +145,10 @@ void TThreadedLogBackend::WriteEmergencyData(const TLogRecord& rec) {
     Impl_->WriteEmergencyData(rec);
 }
 
-size_t TThreadedLogBackend::QueueSize() const { 
-    return Impl_->QueueSize(); 
-} 
- 
+size_t TThreadedLogBackend::QueueSize() const {
+    return Impl_->QueueSize();
+}
+
 TOwningThreadedLogBackend::TOwningThreadedLogBackend(TLogBackend* slave)
     : THolder<TLogBackend>(slave)
     , TThreadedLogBackend(Get())
diff --git a/library/cpp/yt/memory/blob.h b/library/cpp/yt/memory/blob.h
index 2b275ed261..99441fb8c9 100644
--- a/library/cpp/yt/memory/blob.h
+++ b/library/cpp/yt/memory/blob.h
@@ -119,12 +119,12 @@ public:
     }
 
     //! Returns the size.
-    Y_FORCE_INLINE size_t size() const 
-    { 
-        return Size_; 
-    } 
- 
-    //! Returns the size. 
+    Y_FORCE_INLINE size_t size() const
+    {
+        return Size_;
+    }
+
+    //! Returns the size.
     Y_FORCE_INLINE size_t Size() const
     {
         return Size_;
diff --git a/library/cpp/yt/memory/range.h b/library/cpp/yt/memory/range.h
index 6fe43d4cf3..6c71aa9496 100644
--- a/library/cpp/yt/memory/range.h
+++ b/library/cpp/yt/memory/range.h
@@ -77,13 +77,13 @@ public:
         , Length_(end - begin)
     { }
 
-    //! Constructs a TRange from a TCompactVector. 
-    template <size_t N> 
-    TRange(const TCompactVector<T, N>& elements) 
-        : Data_(elements.data()) 
-        , Length_(elements.size()) 
-    { } 
- 
+    //! Constructs a TRange from a TCompactVector.
+    template <size_t N>
+    TRange(const TCompactVector<T, N>& elements)
+        : Data_(elements.data())
+        , Length_(elements.size())
+    { }
+
     //! Constructs a TRange from an std::vector.
     template <class A>
     TRange(const std::vector<T, A>& elements)
@@ -234,13 +234,13 @@ TRange<T> MakeRange(const T* begin, const T* end)
     return TRange<T>(begin, end);
 }
 
-//! Constructs a TRange from a TCompactVector. 
-template <class T, size_t N> 
-TRange<T> MakeRange(const TCompactVector<T, N>& elements) 
-{ 
-    return elements; 
-} 
- 
+//! Constructs a TRange from a TCompactVector.
+template <class T, size_t N>
+TRange<T> MakeRange(const TCompactVector<T, N>& elements)
+{
+    return elements;
+}
+
 //! "Copy-constructor".
 template <class T>
 TRange<T> MakeRange(TRange<T> range)
@@ -327,12 +327,12 @@ public:
         : TRange<T>(begin, end)
     { }
 
-    //! Constructs a TMutableRange from a TCompactVector. 
-    template <size_t N> 
-    TMutableRange(TCompactVector<T, N>& elements) 
-        : TRange<T>(elements) 
-    { } 
- 
+    //! Constructs a TMutableRange from a TCompactVector.
+    template <size_t N>
+    TMutableRange(TCompactVector<T, N>& elements)
+        : TRange<T>(elements)
+    { }
+
     //! Constructs a TMutableRange from an std::vector.
     TMutableRange(std::vector<T>& elements)
         : TRange<T>(elements)
@@ -445,13 +445,13 @@ TMutableRange<T> MakeMutableRange(T* begin, T* end)
     return TMutableRange<T>(begin, end);
 }
 
-//! Constructs a TMutableRange from a TCompactVector. 
-template <class T, size_t N> 
-TMutableRange<T> MakeMutableRange(TCompactVector<T, N>& elements) 
-{ 
-    return elements; 
-} 
- 
+//! Constructs a TMutableRange from a TCompactVector.
+template <class T, size_t N>
+TMutableRange<T> MakeMutableRange(TCompactVector<T, N>& elements)
+{
+    return elements;
+}
+
 //! "Copy-constructor".
 template <class T>
 TMutableRange<T> MakeMutableRange(TMutableRange<T> range)
diff --git a/library/cpp/yt/memory/ref-inl.h b/library/cpp/yt/memory/ref-inl.h
index 70fc8ae29d..79be8356c5 100644
--- a/library/cpp/yt/memory/ref-inl.h
+++ b/library/cpp/yt/memory/ref-inl.h
@@ -461,11 +461,11 @@ Y_FORCE_INLINE size_t TSharedRefArray::Size() const
     return Impl_ ? Impl_->Size() : 0;
 }
 
-Y_FORCE_INLINE size_t TSharedRefArray::size() const 
-{ 
-    return Impl_ ? Impl_->Size() : 0; 
-} 
- 
+Y_FORCE_INLINE size_t TSharedRefArray::size() const
+{
+    return Impl_ ? Impl_->Size() : 0;
+}
+
 Y_FORCE_INLINE bool TSharedRefArray::Empty() const
 {
     return Impl_ ? Impl_->Empty() : true;
diff --git a/library/cpp/yt/memory/ref.h b/library/cpp/yt/memory/ref.h
index 7d51df3bea..73d19d9013 100644
--- a/library/cpp/yt/memory/ref.h
+++ b/library/cpp/yt/memory/ref.h
@@ -278,7 +278,7 @@ public:
     void Reset();
 
     size_t Size() const;
-    size_t size() const; 
+    size_t size() const;
     i64 ByteSize() const;
     bool Empty() const;
     const TSharedRef& operator [] (size_t index) const;
diff --git a/library/cpp/yt/memory/shared_range.h b/library/cpp/yt/memory/shared_range.h
index 46c8936bed..9841d7a0df 100644
--- a/library/cpp/yt/memory/shared_range.h
+++ b/library/cpp/yt/memory/shared_range.h
@@ -10,9 +10,9 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, size_t N> 
-class TCompactVector; 
- 
+template <class T, size_t N>
+class TCompactVector;
+
 //! TRange with ownership semantics.
 template <class T>
 class TSharedRange
@@ -43,13 +43,13 @@ public:
         , Holder_(std::move(holder))
     { }
 
-    //! Constructs a TSharedRange from a TCompactVector. 
-    template <size_t N> 
-    TSharedRange(const TCompactVector<T, N>& elements, THolderPtr holder) 
-        : TRange<T>(elements) 
-        , Holder_(std::move(holder)) 
-    { } 
- 
+    //! Constructs a TSharedRange from a TCompactVector.
+    template <size_t N>
+    TSharedRange(const TCompactVector<T, N>& elements, THolderPtr holder)
+        : TRange<T>(elements)
+        , Holder_(std::move(holder))
+    { }
+
     //! Constructs a TSharedRange from an std::vector.
     TSharedRange(const std::vector<T>& elements, THolderPtr holder)
         : TRange<T>(elements)
@@ -143,13 +143,13 @@ TSharedRange<T> MakeSharedRange(std::vector<T>&& elements, THolders&&... holders
     return DoMakeSharedRange<T>(std::move(elements), std::forward<THolders>(holders)...);
 }
 
-//! Constructs a TSharedRange by taking ownership of an TCompactVector. 
-template <class T, size_t N, class... THolders> 
-TSharedRange<T> MakeSharedRange(TCompactVector<T, N>&& elements, THolders&&... holders) 
-{ 
-    return DoMakeSharedRange<T>(std::move(elements), std::forward<THolders>(holders)...); 
-} 
- 
+//! Constructs a TSharedRange by taking ownership of an TCompactVector.
+template <class T, size_t N, class... THolders>
+TSharedRange<T> MakeSharedRange(TCompactVector<T, N>&& elements, THolders&&... holders)
+{
+    return DoMakeSharedRange<T>(std::move(elements), std::forward<THolders>(holders)...);
+}
+
 //! Constructs a TSharedRange by copying an std::vector.
 template <class T, class... THolders>
 TSharedRange<T> MakeSharedRange(const std::vector<T>& elements, THolders&&... holders)
@@ -209,13 +209,13 @@ public:
         , Holder_(std::move(holder))
     { }
 
-    //! Constructs a TSharedMutableRange from a TCompactVector. 
-    template <size_t N> 
-    TSharedMutableRange(TCompactVector<T, N>& elements, THolderPtr holder) 
-        : TMutableRange<T>(elements) 
-        , Holder_(std::move(holder)) 
-    { } 
- 
+    //! Constructs a TSharedMutableRange from a TCompactVector.
+    template <size_t N>
+    TSharedMutableRange(TCompactVector<T, N>& elements, THolderPtr holder)
+        : TMutableRange<T>(elements)
+        , Holder_(std::move(holder))
+    { }
+
     //! Constructs a TSharedMutableRange from an std::vector.
     TSharedMutableRange(std::vector<T>& elements, THolderPtr holder)
         : TMutableRange<T>(elements)
diff --git a/library/cpp/yt/misc/enum-inl.h b/library/cpp/yt/misc/enum-inl.h
index c574761dd7..59ef704775 100644
--- a/library/cpp/yt/misc/enum-inl.h
+++ b/library/cpp/yt/misc/enum-inl.h
@@ -177,13 +177,13 @@ static constexpr bool AreValuesDistinct(const TValues& values)
 #define ENUM__END_TRAITS(name) \
     }; \
     \
-    [[maybe_unused]] inline TEnumTraitsImpl_##name GetEnumTraitsImpl(name) \ 
+    [[maybe_unused]] inline TEnumTraitsImpl_##name GetEnumTraitsImpl(name) \
     { \
         return TEnumTraitsImpl_##name(); \
     } \
     \
     using ::ToString; \
-    [[maybe_unused]] inline TString ToString(name value) \ 
+    [[maybe_unused]] inline TString ToString(name value) \
     { \
         return ::NYT::TEnumTraits<name>::ToString(value); \
     }
@@ -324,13 +324,13 @@ bool TEnumIndexedVector<E, T, Min, Max>::IsDomainValue(E value)
 ////////////////////////////////////////////////////////////////////////////////
 
 #define ENUM__BINARY_BITWISE_OPERATOR(T, assignOp, op) \
-    [[maybe_unused]] inline constexpr T operator op (T lhs, T rhs) \ 
+    [[maybe_unused]] inline constexpr T operator op (T lhs, T rhs) \
     { \
         using TUnderlying = typename TEnumTraits<T>::TUnderlying; \
         return T(static_cast<TUnderlying>(lhs) op static_cast<TUnderlying>(rhs)); \
     } \
     \
-    [[maybe_unused]] inline T& operator assignOp (T& lhs, T rhs) \ 
+    [[maybe_unused]] inline T& operator assignOp (T& lhs, T rhs) \
     { \
         using TUnderlying = typename TEnumTraits<T>::TUnderlying; \
         lhs = T(static_cast<TUnderlying>(lhs) op static_cast<TUnderlying>(rhs)); \
@@ -338,20 +338,20 @@ bool TEnumIndexedVector<E, T, Min, Max>::IsDomainValue(E value)
     }
 
 #define ENUM__UNARY_BITWISE_OPERATOR(T, op) \
-    [[maybe_unused]] inline constexpr T operator op (T value) \ 
+    [[maybe_unused]] inline constexpr T operator op (T value) \
     { \
         using TUnderlying = typename TEnumTraits<T>::TUnderlying; \
         return T(op static_cast<TUnderlying>(value)); \
     }
 
 #define ENUM__BIT_SHIFT_OPERATOR(T, assignOp, op) \
-    [[maybe_unused]] inline constexpr T operator op (T lhs, size_t rhs) \ 
+    [[maybe_unused]] inline constexpr T operator op (T lhs, size_t rhs) \
     { \
         using TUnderlying = typename TEnumTraits<T>::TUnderlying; \
         return T(static_cast<TUnderlying>(lhs) op rhs); \
     } \
     \
-    [[maybe_unused]] inline T& operator assignOp (T& lhs, size_t rhs) \ 
+    [[maybe_unused]] inline T& operator assignOp (T& lhs, size_t rhs) \
     { \
         using TUnderlying = typename TEnumTraits<T>::TUnderlying; \
         lhs = T(static_cast<TUnderlying>(lhs) op rhs); \
diff --git a/library/cpp/yt/small_containers/compact_flat_map-inl.h b/library/cpp/yt/small_containers/compact_flat_map-inl.h
index 7323815f09..45a4dd1de3 100644
--- a/library/cpp/yt/small_containers/compact_flat_map-inl.h
+++ b/library/cpp/yt/small_containers/compact_flat_map-inl.h
@@ -1,7 +1,7 @@
-#ifndef COMPACT_FLAT_MAP_INL_H_ 
-#error "Direct inclusion of this file is not allowed, include compact_flat_map.h" 
+#ifndef COMPACT_FLAT_MAP_INL_H_
+#error "Direct inclusion of this file is not allowed, include compact_flat_map.h"
 // For the sake of sane code completion.
-#include "compact_flat_map.h" 
+#include "compact_flat_map.h"
 #endif
 
 namespace NYT {
@@ -10,93 +10,93 @@ namespace NYT {
 
 template <class K, class V, unsigned N>
 template <class TInputIterator>
-TCompactFlatMap<K, V, N>::TCompactFlatMap(TInputIterator begin, TInputIterator end) 
+TCompactFlatMap<K, V, N>::TCompactFlatMap(TInputIterator begin, TInputIterator end)
 {
     insert(begin, end);
 }
 
 template <class K, class V, unsigned N>
-bool TCompactFlatMap<K, V, N>::operator==(const TCompactFlatMap& rhs) const 
+bool TCompactFlatMap<K, V, N>::operator==(const TCompactFlatMap& rhs) const
 {
     return Storage_ == rhs.Storage_;
 }
 
 template <class K, class V, unsigned N>
-bool TCompactFlatMap<K, V, N>::operator!=(const TCompactFlatMap& rhs) const 
+bool TCompactFlatMap<K, V, N>::operator!=(const TCompactFlatMap& rhs) const
 {
     return !(*this == rhs);
 }
 
 template <class K, class V, unsigned N>
-typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::begin() 
+typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::begin()
 {
     return Storage_.begin();
 }
 
 template <class K, class V, unsigned N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::begin() const 
+typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::begin() const
 {
     return Storage_.begin();
 }
 
 template <class K, class V, unsigned N>
-typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::end() 
+typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::end()
 {
     return Storage_.end();
 }
 
 template <class K, class V, unsigned N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::end() const 
+typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::end() const
 {
     return Storage_.end();
 }
 
 template <class K, class V, unsigned N>
-void TCompactFlatMap<K, V, N>::reserve(size_type n) 
+void TCompactFlatMap<K, V, N>::reserve(size_type n)
 {
     Storage_.reserve(n);
 }
 
 template <class K, class V, unsigned N>
-typename TCompactFlatMap<K, V, N>::size_type TCompactFlatMap<K, V, N>::size() const 
+typename TCompactFlatMap<K, V, N>::size_type TCompactFlatMap<K, V, N>::size() const
 {
     return Storage_.size();
 }
 
 template <class K, class V, unsigned N>
-int TCompactFlatMap<K, V, N>::ssize() const 
+int TCompactFlatMap<K, V, N>::ssize() const
 {
     return static_cast<int>(Storage_.size());
 }
 
 template <class K, class V, unsigned N>
-bool TCompactFlatMap<K, V, N>::empty() const 
+bool TCompactFlatMap<K, V, N>::empty() const
 {
     return Storage_.empty();
 }
 
 template <class K, class V, unsigned N>
-void TCompactFlatMap<K, V, N>::clear() 
+void TCompactFlatMap<K, V, N>::clear()
 {
     Storage_.clear();
 }
 
 template <class K, class V, unsigned N>
-typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::find(const K& k) 
+typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::find(const K& k)
 {
     auto [rangeBegin, rangeEnd] = EqualRange(k);
     return rangeBegin == rangeEnd ? end() : rangeBegin;
 }
 
 template <class K, class V, unsigned N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::find(const K& k) const 
+typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::find(const K& k) const
 {
     auto [rangeBegin, rangeEnd] = EqualRange(k);
     return rangeBegin == rangeEnd ? end() : rangeBegin;
 }
 
 template <class K, class V, unsigned N>
-bool TCompactFlatMap<K, V, N>::contains(const K& k) const 
+bool TCompactFlatMap<K, V, N>::contains(const K& k) const
 {
     return find(k) != end();
 }
@@ -115,7 +115,7 @@ auto TCompactFlatMap<K, V, N>::insert(const value_type& value) -> std::pair<iter
 
 template <class K, class V, unsigned N>
 template <class TInputIterator>
-void TCompactFlatMap<K, V, N>::insert(TInputIterator begin, TInputIterator end) 
+void TCompactFlatMap<K, V, N>::insert(TInputIterator begin, TInputIterator end)
 {
     for (auto it = begin; it != end; ++it) {
         insert(*it);
@@ -130,40 +130,40 @@ auto TCompactFlatMap<K, V, N>::emplace(TArgs&&... args) -> std::pair<iterator, b
 }
 
 template <class K, class V, unsigned N>
-V& TCompactFlatMap<K, V, N>::operator[](const K& k) 
+V& TCompactFlatMap<K, V, N>::operator[](const K& k)
 {
     auto [it, inserted] = insert({k, V()});
     return it->second;
 }
 
 template <class K, class V, unsigned N>
-void TCompactFlatMap<K, V, N>::erase(const K& k) 
+void TCompactFlatMap<K, V, N>::erase(const K& k)
 {
     auto [rangeBegin, rangeEnd] = EqualRange(k);
     erase(rangeBegin, rangeEnd);
 }
 
 template <class K, class V, unsigned N>
-void TCompactFlatMap<K, V, N>::erase(iterator pos) 
+void TCompactFlatMap<K, V, N>::erase(iterator pos)
 {
     Storage_.erase(pos);
- 
-    // Try to keep the storage inline. This is why erase doesn't return an iterator. 
-    Storage_.shrink_to_small(); 
+
+    // Try to keep the storage inline. This is why erase doesn't return an iterator.
+    Storage_.shrink_to_small();
 }
 
 template <class K, class V, unsigned N>
-void TCompactFlatMap<K, V, N>::erase(iterator b, iterator e) 
+void TCompactFlatMap<K, V, N>::erase(iterator b, iterator e)
 {
     Storage_.erase(b, e);
- 
-    // Try to keep the storage inline. This is why erase doesn't return an iterator. 
-    Storage_.shrink_to_small(); 
+
+    // Try to keep the storage inline. This is why erase doesn't return an iterator.
+    Storage_.shrink_to_small();
 }
 
 template <class K, class V, unsigned N>
-std::pair<typename TCompactFlatMap<K, V, N>::iterator, typename TCompactFlatMap<K, V, N>::iterator> 
-TCompactFlatMap<K, V, N>::EqualRange(const K& k) 
+std::pair<typename TCompactFlatMap<K, V, N>::iterator, typename TCompactFlatMap<K, V, N>::iterator>
+TCompactFlatMap<K, V, N>::EqualRange(const K& k)
 {
     auto result = std::equal_range(Storage_.begin(), Storage_.end(), k, TKeyComparer());
     YT_ASSERT(std::distance(result.first, result.second) <= 1);
@@ -171,8 +171,8 @@ TCompactFlatMap<K, V, N>::EqualRange(const K& k)
 }
 
 template <class K, class V, unsigned N>
-std::pair<typename TCompactFlatMap<K, V, N>::const_iterator, typename TCompactFlatMap<K, V, N>::const_iterator> 
-TCompactFlatMap<K, V, N>::EqualRange(const K& k) const 
+std::pair<typename TCompactFlatMap<K, V, N>::const_iterator, typename TCompactFlatMap<K, V, N>::const_iterator>
+TCompactFlatMap<K, V, N>::EqualRange(const K& k) const
 {
     auto result = std::equal_range(Storage_.begin(), Storage_.end(), k, TKeyComparer());
     YT_ASSERT(std::distance(result.first, result.second) <= 1);
diff --git a/library/cpp/yt/small_containers/compact_flat_map.h b/library/cpp/yt/small_containers/compact_flat_map.h
index 13a243c366..13bdc0e9da 100644
--- a/library/cpp/yt/small_containers/compact_flat_map.h
+++ b/library/cpp/yt/small_containers/compact_flat_map.h
@@ -1,12 +1,12 @@
 #pragma once
 
-#include "compact_vector.h" 
+#include "compact_vector.h"
 
 namespace NYT {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-//! A flat map implementation over TCompactVector that tries to keep data inline. 
+//! A flat map implementation over TCompactVector that tries to keep data inline.
 /*!
  *  Similarly to SmallSet, this is implemented via binary search over a sorted
  *  vector. Unlike SmallSet, however, this one never falls back to std::map (or
@@ -22,17 +22,17 @@ namespace NYT {
  *  any call to insert or erase may potentially invalidate all iterators.
  */
 template <class K, class V, unsigned N>
-class TCompactFlatMap 
+class TCompactFlatMap
 {
 public:
-    // NB: can't make this pair<const K, V> as TCompactVector requires its type 
+    // NB: can't make this pair<const K, V> as TCompactVector requires its type
     // parameter to be copy-assignable.
     using value_type = std::pair<K, V>;
     using key_type = K;
     using mapped_type = V;
 
 private:
-    using TStorage = TCompactVector<value_type, N>; 
+    using TStorage = TCompactVector<value_type, N>;
 
     struct TKeyComparer
     {
@@ -52,13 +52,13 @@ public:
     using const_iterator = typename TStorage::const_iterator;
     using size_type = size_t;
 
-    TCompactFlatMap() = default; 
+    TCompactFlatMap() = default;
 
     template <class TInputIterator>
-    TCompactFlatMap(TInputIterator begin, TInputIterator end); 
+    TCompactFlatMap(TInputIterator begin, TInputIterator end);
 
-    bool operator==(const TCompactFlatMap& rhs) const; 
-    bool operator!=(const TCompactFlatMap& rhs) const; 
+    bool operator==(const TCompactFlatMap& rhs) const;
+    bool operator!=(const TCompactFlatMap& rhs) const;
 
     iterator begin();
     const_iterator begin() const;
@@ -104,6 +104,6 @@ private:
 
 } // namespace NYT
 
-#define COMPACT_FLAT_MAP_INL_H_ 
-#include "compact_flat_map-inl.h" 
-#undef COMPACT_FLAT_MAP_INL_H_ 
+#define COMPACT_FLAT_MAP_INL_H_
+#include "compact_flat_map-inl.h"
+#undef COMPACT_FLAT_MAP_INL_H_
diff --git a/library/cpp/yt/small_containers/compact_heap-inl.h b/library/cpp/yt/small_containers/compact_heap-inl.h
index ac99ea7333..2c6b3507ba 100644
--- a/library/cpp/yt/small_containers/compact_heap-inl.h
+++ b/library/cpp/yt/small_containers/compact_heap-inl.h
@@ -1,152 +1,152 @@
-#ifndef COMPACT_HEAP_INL_H_ 
-#error "Direct inclusion of this file is not allowed, include compact_heap.h" 
-// For the sake of sane code completion. 
-#include "compact_heap.h" 
-#endif 
- 
-#include <library/cpp/yt/assert/assert.h> 
- 
-#include <algorithm> 
- 
-namespace NYT { 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-template <class T, size_t N, class C> 
-TCompactHeap<T, N, C>::TCompactHeap(C comparator) noexcept 
-    : Comparator_(TReverseComparator(std::move(comparator))) 
-{ } 
- 
-template <class T, size_t N, class C> 
-void TCompactHeap<T, N, C>::push(T value) 
-{ 
-    bool wasInline = IsInline(); 
-    Heap_.push_back(std::move(value)); 
-    if (Y_UNLIKELY(!IsInline())) { 
-        if (wasInline) { 
-            std::make_heap(Heap_.begin(), Heap_.end(), Comparator_); 
-        } else { 
-            std::push_heap(Heap_.begin(), Heap_.end(), Comparator_); 
-        } 
-    } 
-} 
- 
-template <class T, size_t N, class C> 
-void TCompactHeap<T, N, C>::pop() 
-{ 
-    YT_ASSERT(!empty()); 
- 
-    if (Y_LIKELY(IsInline())) { 
-        auto minIt = std::max_element(Heap_.begin(), Heap_.end(), Comparator_); 
-        std::swap(*minIt, Heap_.back()); 
-        Heap_.pop_back(); 
-    } else { 
-        std::pop_heap(Heap_.begin(), Heap_.end(), Comparator_); 
-        Heap_.pop_back(); 
-    } 
-} 
- 
-template <class T, size_t N, class C> 
-auto TCompactHeap<T, N, C>::get_min() const -> const_reference 
-{ 
-    YT_ASSERT(!empty()); 
- 
-    if (Y_LIKELY(IsInline())) { 
-        return *std::max_element(Heap_.begin(), Heap_.end(), Comparator_); 
-    } else { 
-        return Heap_.front(); 
-    } 
-} 
- 
-template <class T, size_t N, class C> 
-auto TCompactHeap<T, N, C>::extract_min() -> value_type 
-{ 
-    YT_ASSERT(!empty()); 
- 
-    if (Y_LIKELY(IsInline())) { 
-        auto minIt = std::max_element(Heap_.begin(), Heap_.end(), Comparator_); 
-        std::swap(*minIt, Heap_.back()); 
-        auto value = Heap_.back(); 
-        Heap_.pop_back(); 
- 
-        return value; 
-    } else { 
-        std::pop_heap(Heap_.begin(), Heap_.end(), Comparator_); 
-        auto value = std::move(Heap_.back()); 
-        Heap_.pop_back(); 
- 
-        return value; 
-    } 
-} 
- 
-template <class T, size_t N, class C> 
-auto TCompactHeap<T, N, C>::begin() const -> const_iterator 
-{ 
-    return Heap_.begin(); 
-} 
- 
-template <class T, size_t N, class C> 
-auto TCompactHeap<T, N, C>::end() const -> const_iterator 
-{ 
-    return Heap_.end(); 
-} 
- 
-template <class T, size_t N, class C> 
-void TCompactHeap<T, N, C>::swap(TCompactHeap<T, N, C>& other) 
-{ 
-    Heap_.swap(other.Heap_); 
-    std::swap(Comparator_, other.Comparator_); 
-} 
- 
-template <class T, size_t N, class C> 
-size_t TCompactHeap<T, N, C>::size() const 
-{ 
-    return Heap_.size(); 
-} 
- 
-template <class T, size_t N, class C> 
-size_t TCompactHeap<T, N, C>::capacity() const 
-{ 
-    return Heap_.capacity(); 
-} 
- 
-template <class T, size_t N, class C> 
-size_t TCompactHeap<T, N, C>::max_size() const 
-{ 
-    return Heap_.max_size(); 
-} 
- 
-template <class T, size_t N, class C> 
-bool TCompactHeap<T, N, C>::empty() const 
-{ 
-    return Heap_.empty(); 
-} 
- 
-template <class T, size_t N, class C> 
-void TCompactHeap<T, N, C>::shrink_to_small() 
-{ 
-    Heap_.shrink_to_small(); 
-} 
- 
-template <class T, size_t N, class C> 
-bool TCompactHeap<T, N, C>::IsInline() const 
-{ 
-    return Heap_.capacity() == N; 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-template <class T, size_t N, class C> 
-TCompactHeap<T, N, C>::TReverseComparator::TReverseComparator(C underlying) 
-    : Underlying_(std::move(underlying)) 
-{ } 
- 
-template <class T, size_t N, class C> 
-bool TCompactHeap<T, N, C>::TReverseComparator::operator()(const T& lhs, const T& rhs) const 
-{ 
-    return Underlying_(rhs, lhs); 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-} // namespace NYT 
+#ifndef COMPACT_HEAP_INL_H_
+#error "Direct inclusion of this file is not allowed, include compact_heap.h"
+// For the sake of sane code completion.
+#include "compact_heap.h"
+#endif
+
+#include <library/cpp/yt/assert/assert.h>
+
+#include <algorithm>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, size_t N, class C>
+TCompactHeap<T, N, C>::TCompactHeap(C comparator) noexcept
+    : Comparator_(TReverseComparator(std::move(comparator)))
+{ }
+
+template <class T, size_t N, class C>
+void TCompactHeap<T, N, C>::push(T value)
+{
+    bool wasInline = IsInline();
+    Heap_.push_back(std::move(value));
+    if (Y_UNLIKELY(!IsInline())) {
+        if (wasInline) {
+            std::make_heap(Heap_.begin(), Heap_.end(), Comparator_);
+        } else {
+            std::push_heap(Heap_.begin(), Heap_.end(), Comparator_);
+        }
+    }
+}
+
+template <class T, size_t N, class C>
+void TCompactHeap<T, N, C>::pop()
+{
+    YT_ASSERT(!empty());
+
+    if (Y_LIKELY(IsInline())) {
+        auto minIt = std::max_element(Heap_.begin(), Heap_.end(), Comparator_);
+        std::swap(*minIt, Heap_.back());
+        Heap_.pop_back();
+    } else {
+        std::pop_heap(Heap_.begin(), Heap_.end(), Comparator_);
+        Heap_.pop_back();
+    }
+}
+
+template <class T, size_t N, class C>
+auto TCompactHeap<T, N, C>::get_min() const -> const_reference
+{
+    YT_ASSERT(!empty());
+
+    if (Y_LIKELY(IsInline())) {
+        return *std::max_element(Heap_.begin(), Heap_.end(), Comparator_);
+    } else {
+        return Heap_.front();
+    }
+}
+
+template <class T, size_t N, class C>
+auto TCompactHeap<T, N, C>::extract_min() -> value_type
+{
+    YT_ASSERT(!empty());
+
+    if (Y_LIKELY(IsInline())) {
+        auto minIt = std::max_element(Heap_.begin(), Heap_.end(), Comparator_);
+        std::swap(*minIt, Heap_.back());
+        auto value = Heap_.back();
+        Heap_.pop_back();
+
+        return value;
+    } else {
+        std::pop_heap(Heap_.begin(), Heap_.end(), Comparator_);
+        auto value = std::move(Heap_.back());
+        Heap_.pop_back();
+
+        return value;
+    }
+}
+
+template <class T, size_t N, class C>
+auto TCompactHeap<T, N, C>::begin() const -> const_iterator
+{
+    return Heap_.begin();
+}
+
+template <class T, size_t N, class C>
+auto TCompactHeap<T, N, C>::end() const -> const_iterator
+{
+    return Heap_.end();
+}
+
+template <class T, size_t N, class C>
+void TCompactHeap<T, N, C>::swap(TCompactHeap<T, N, C>& other)
+{
+    Heap_.swap(other.Heap_);
+    std::swap(Comparator_, other.Comparator_);
+}
+
+template <class T, size_t N, class C>
+size_t TCompactHeap<T, N, C>::size() const
+{
+    return Heap_.size();
+}
+
+template <class T, size_t N, class C>
+size_t TCompactHeap<T, N, C>::capacity() const
+{
+    return Heap_.capacity();
+}
+
+template <class T, size_t N, class C>
+size_t TCompactHeap<T, N, C>::max_size() const
+{
+    return Heap_.max_size();
+}
+
+template <class T, size_t N, class C>
+bool TCompactHeap<T, N, C>::empty() const
+{
+    return Heap_.empty();
+}
+
+template <class T, size_t N, class C>
+void TCompactHeap<T, N, C>::shrink_to_small()
+{
+    Heap_.shrink_to_small();
+}
+
+template <class T, size_t N, class C>
+bool TCompactHeap<T, N, C>::IsInline() const
+{
+    return Heap_.capacity() == N;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, size_t N, class C>
+TCompactHeap<T, N, C>::TReverseComparator::TReverseComparator(C underlying)
+    : Underlying_(std::move(underlying))
+{ }
+
+template <class T, size_t N, class C>
+bool TCompactHeap<T, N, C>::TReverseComparator::operator()(const T& lhs, const T& rhs) const
+{
+    return Underlying_(rhs, lhs);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/small_containers/compact_heap.h b/library/cpp/yt/small_containers/compact_heap.h
index 34daf12e50..951b36962d 100644
--- a/library/cpp/yt/small_containers/compact_heap.h
+++ b/library/cpp/yt/small_containers/compact_heap.h
@@ -1,75 +1,75 @@
-#pragma once 
- 
-#include "compact_vector.h" 
- 
-namespace NYT { 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-//! A heap structure optimized for storing elements inline 
-//! and with little memory overhead. See TCompactVector. 
-/*! 
- *  When inline, uses linear search for selecting minimum 
- *  instead of storing heap. 
- */ 
-template <class T, size_t N, class C = std::less<T>> 
-class TCompactHeap 
-{ 
-public: 
-    static_assert(N <= 8, "TCompactHeap is not optimal for large N"); 
- 
-    explicit TCompactHeap(C comparator = C()) noexcept; 
- 
-    using value_type = T; 
- 
-    using const_reference = const T&; 
- 
-    using const_iterator = const T*; 
- 
-    using difference_type = ptrdiff_t; 
-    using size_type = size_t; 
- 
-    void push(T value); 
-    void pop(); 
- 
-    const_reference get_min() const; 
-    value_type extract_min(); 
- 
-    const_iterator begin() const; 
-    const_iterator end() const; 
- 
-    void swap(TCompactHeap<T, N, C>& other); 
- 
-    size_t size() const; 
-    size_t capacity() const; 
-    size_t max_size() const; 
- 
-    bool empty() const; 
- 
-    void shrink_to_small(); 
- 
-private: 
-    TCompactVector<T, N> Heap_; 
- 
-    class TReverseComparator 
-    { 
-    public: 
-        explicit TReverseComparator(C underlying); 
- 
-        bool operator()(const T& lhs, const T& rhs) const; 
- 
-    private: 
-        C Underlying_; 
-    }; 
-    TReverseComparator Comparator_; 
- 
-    bool IsInline() const; 
-}; 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-} // namespace NYT 
- 
-#define COMPACT_HEAP_INL_H_ 
-#include "compact_heap-inl.h" 
-#undef COMPACT_HEAP_INL_H_ 
+#pragma once
+
+#include "compact_vector.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! A heap structure optimized for storing elements inline
+//! and with little memory overhead. See TCompactVector.
+/*!
+ *  When inline, uses linear search for selecting minimum
+ *  instead of storing heap.
+ */
+template <class T, size_t N, class C = std::less<T>>
+class TCompactHeap
+{
+public:
+    static_assert(N <= 8, "TCompactHeap is not optimal for large N");
+
+    explicit TCompactHeap(C comparator = C()) noexcept;
+
+    using value_type = T;
+
+    using const_reference = const T&;
+
+    using const_iterator = const T*;
+
+    using difference_type = ptrdiff_t;
+    using size_type = size_t;
+
+    void push(T value);
+    void pop();
+
+    const_reference get_min() const;
+    value_type extract_min();
+
+    const_iterator begin() const;
+    const_iterator end() const;
+
+    void swap(TCompactHeap<T, N, C>& other);
+
+    size_t size() const;
+    size_t capacity() const;
+    size_t max_size() const;
+
+    bool empty() const;
+
+    void shrink_to_small();
+
+private:
+    TCompactVector<T, N> Heap_;
+
+    class TReverseComparator
+    {
+    public:
+        explicit TReverseComparator(C underlying);
+
+        bool operator()(const T& lhs, const T& rhs) const;
+
+    private:
+        C Underlying_;
+    };
+    TReverseComparator Comparator_;
+
+    bool IsInline() const;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define COMPACT_HEAP_INL_H_
+#include "compact_heap-inl.h"
+#undef COMPACT_HEAP_INL_H_
diff --git a/library/cpp/yt/small_containers/compact_set-inl.h b/library/cpp/yt/small_containers/compact_set-inl.h
index 92e79dd94b..75b8600175 100644
--- a/library/cpp/yt/small_containers/compact_set-inl.h
+++ b/library/cpp/yt/small_containers/compact_set-inl.h
@@ -1,7 +1,7 @@
-#ifndef COMPACT_SET_INL_H_ 
-#error "Direct inclusion of this file is not allowed, include compact_set.h" 
+#ifndef COMPACT_SET_INL_H_
+#error "Direct inclusion of this file is not allowed, include compact_set.h"
 // For the sake of sane code completion.
-#include "compact_set.h" 
+#include "compact_set.h"
 #endif
 
 namespace NYT {
@@ -9,10 +9,10 @@ namespace NYT {
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename T, unsigned N,  typename C>
-class TCompactSet<T, N, C>::const_iterator 
+class TCompactSet<T, N, C>::const_iterator
 {
 private:
-    friend class TCompactSet<T, N, C>; 
+    friend class TCompactSet<T, N, C>;
 
     union
     {
@@ -201,26 +201,26 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename T, unsigned N,  typename C>
-bool TCompactSet<T, N, C>::empty() const 
+bool TCompactSet<T, N, C>::empty() const
 {
     return Vector.empty() && Set.empty();
 }
 
 template <typename T, unsigned N,  typename C>
-typename TCompactSet<T, N, C>::size_type TCompactSet<T, N, C>::size() const 
+typename TCompactSet<T, N, C>::size_type TCompactSet<T, N, C>::size() const
 {
     return IsSmall() ? Vector.size() : Set.size();
 }
 
 template <typename T, unsigned N,  typename C>
-const T& TCompactSet<T, N, C>::front() const 
+const T& TCompactSet<T, N, C>::front() const
 {
     return IsSmall() ? Vector.front() : *Set.begin();
 }
 
 
 template <typename T, unsigned N,  typename C>
-typename TCompactSet<T, N, C>::size_type TCompactSet<T, N, C>::count(const T& v) const 
+typename TCompactSet<T, N, C>::size_type TCompactSet<T, N, C>::count(const T& v) const
 {
     if (IsSmall()) {
         return std::binary_search(Vector.begin(), Vector.end(), v, C()) ? 1 : 0;
@@ -230,7 +230,7 @@ typename TCompactSet<T, N, C>::size_type TCompactSet<T, N, C>::count(const T& v)
 }
 
 template <typename T, unsigned N,  typename C>
-std::pair<typename TCompactSet<T, N, C>::const_iterator, bool> TCompactSet<T, N, C>::insert(const T& v) 
+std::pair<typename TCompactSet<T, N, C>::const_iterator, bool> TCompactSet<T, N, C>::insert(const T& v)
 {
     if (!IsSmall()) {
         auto [it, inserted] = Set.insert(v);
@@ -257,7 +257,7 @@ std::pair<typename TCompactSet<T, N, C>::const_iterator, bool> TCompactSet<T, N,
 
 template <typename T, unsigned N,  typename C>
 template <typename TIter>
-void TCompactSet<T, N, C>::insert(TIter i, TIter e) 
+void TCompactSet<T, N, C>::insert(TIter i, TIter e)
 {
     for (; i != e; ++i) {
         insert(*i);
@@ -265,7 +265,7 @@ void TCompactSet<T, N, C>::insert(TIter i, TIter e)
 }
 
 template <typename T, unsigned N,  typename C>
-bool TCompactSet<T, N, C>::erase(const T& v) 
+bool TCompactSet<T, N, C>::erase(const T& v)
 {
     if (!IsSmall()) {
         return Set.erase(v);
@@ -281,38 +281,38 @@ bool TCompactSet<T, N, C>::erase(const T& v)
 }
 
 template <typename T, unsigned N,  typename C>
-void TCompactSet<T, N, C>::clear() 
+void TCompactSet<T, N, C>::clear()
 {
     Vector.clear();
     Set.clear();
 }
 
 template <typename T, unsigned N,  typename C>
-typename TCompactSet<T, N, C>::const_iterator TCompactSet<T, N, C>::begin() const 
+typename TCompactSet<T, N, C>::const_iterator TCompactSet<T, N, C>::begin() const
 {
     return IsSmall() ? const_iterator(Vector.begin()) : const_iterator(Set.begin());
 }
 
 template <typename T, unsigned N,  typename C>
-typename TCompactSet<T, N, C>::const_iterator TCompactSet<T, N, C>::cbegin() const 
+typename TCompactSet<T, N, C>::const_iterator TCompactSet<T, N, C>::cbegin() const
 {
     return begin();
 }
 
 template <typename T, unsigned N,  typename C>
-typename TCompactSet<T, N, C>::const_iterator TCompactSet<T, N, C>::end() const 
+typename TCompactSet<T, N, C>::const_iterator TCompactSet<T, N, C>::end() const
 {
     return IsSmall() ? const_iterator(Vector.end()) : const_iterator(Set.end());
 }
 
 template <typename T, unsigned N,  typename C>
-typename TCompactSet<T, N, C>::const_iterator TCompactSet<T, N, C>::cend() const 
+typename TCompactSet<T, N, C>::const_iterator TCompactSet<T, N, C>::cend() const
 {
     return end();
 }
 
 template <typename T, unsigned N,  typename C>
-bool TCompactSet<T, N, C>::IsSmall() const 
+bool TCompactSet<T, N, C>::IsSmall() const
 {
     return Set.empty();
 }
diff --git a/library/cpp/yt/small_containers/compact_set.h b/library/cpp/yt/small_containers/compact_set.h
index 8a5a694ea0..2ca8713ea7 100644
--- a/library/cpp/yt/small_containers/compact_set.h
+++ b/library/cpp/yt/small_containers/compact_set.h
@@ -7,13 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the TCompactSet class. 
+// This file defines the TCompactSet class.
 //
 //===----------------------------------------------------------------------===//
 
 #pragma once
 
-#include "compact_vector.h" 
+#include "compact_vector.h"
 
 #include <util/system/yassert.h>
 
@@ -24,30 +24,30 @@
 
 namespace NYT {
 
-/// TCompactSet - This maintains a set of unique values, optimizing for the case 
+/// TCompactSet - This maintains a set of unique values, optimizing for the case
 /// when the set is small (less than N).  In this case, the set can be
 /// maintained with no mallocs.  If the set gets large, we expand to using an
 /// std::set to maintain reasonable lookup times.
 ///
 /// Note that any modification of the set may invalidate *all* iterators.
 template <typename T, unsigned N, typename C = std::less<T>>
-class TCompactSet 
+class TCompactSet
 {
 private:
-    /// Use a CompactVector to hold the elements here (even though it will never 
+    /// Use a CompactVector to hold the elements here (even though it will never
     /// reach its 'large' stage) to avoid calling the default ctors of elements
     /// we will never use.
-    TCompactVector<T, N> Vector; 
+    TCompactVector<T, N> Vector;
     std::set<T, C> Set;
 
     using TSetConstIterator = typename std::set<T, C>::const_iterator;
-    using TVectorConstIterator = typename TCompactVector<T, N>::const_iterator; 
+    using TVectorConstIterator = typename TCompactVector<T, N>::const_iterator;
 
 public:
     class const_iterator;
     using size_type = std::size_t;
 
-    TCompactSet() {} 
+    TCompactSet() {}
 
     [[nodiscard]] bool empty() const;
 
@@ -80,7 +80,7 @@ private:
 
 } // namespace NYT
 
-#define COMPACT_SET_INL_H_ 
-#include "compact_set-inl.h" 
-#undef COMPACT_SET_INL_H_ 
+#define COMPACT_SET_INL_H_
+#include "compact_set-inl.h"
+#undef COMPACT_SET_INL_H_
 
diff --git a/library/cpp/yt/small_containers/compact_vector-inl.h b/library/cpp/yt/small_containers/compact_vector-inl.h
index c24b4e6d1e..52507e4768 100644
--- a/library/cpp/yt/small_containers/compact_vector-inl.h
+++ b/library/cpp/yt/small_containers/compact_vector-inl.h
@@ -22,9 +22,9 @@ namespace NYT {
 
 static_assert(sizeof(uintptr_t) == 8);
 
-// TODO(gritukan, babenko): Uncomment check below after DEVTOOLS-7870. 
-// static_assert(std::endian::native == std::endian::little); 
- 
+// TODO(gritukan, babenko): Uncomment check below after DEVTOOLS-7870.
+// static_assert(std::endian::native == std::endian::little);
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T>
@@ -44,7 +44,7 @@ public:
     TCompactVectorReallocationPtrAdjuster(TVector* vector, TPtr& ptr)
         : Vector_(vector)
         , Ptr_(ptr)
-        , Index_(ptr >= Vector_->begin() && ptr <= Vector_->end() 
+        , Index_(ptr >= Vector_->begin() && ptr <= Vector_->end()
             ? std::distance(Vector_->begin(), const_cast<typename TVector::iterator>(ptr))
             : -1)
     { }
@@ -94,7 +94,7 @@ TCompactVector<T, N>::TCompactVector(const TCompactVector<T, OtherN>& other)
 }
 
 template <class T, size_t N>
-TCompactVector<T, N>::TCompactVector(TCompactVector&& other) noexcept(std::is_nothrow_move_constructible_v<T>) 
+TCompactVector<T, N>::TCompactVector(TCompactVector&& other) noexcept(std::is_nothrow_move_constructible_v<T>)
     : TCompactVector()
 {
     swap(other);
@@ -689,26 +689,26 @@ auto TCompactVector<T, N>::insert(const_iterator pos, std::initializer_list<T> l
 }
 
 template <class T, size_t N>
-void TCompactVector<T, N>::shrink_to_small() 
-{ 
-    if (Y_LIKELY(IsInline())) { 
-        return; 
-    } 
- 
-    auto size = this->size(); 
-    if (size > N) { 
-        return; 
-    } 
- 
-    auto* storage = OnHeapMeta_.Storage; 
-    UninitializedMove(storage->Elements, storage->End, &InlineElements_[0]); 
-    Destroy(storage->Elements, storage->End); 
-    ::free(storage); 
- 
-    InlineMeta_.SizePlusOne = size + 1; 
-} 
- 
-template <class T, size_t N> 
+void TCompactVector<T, N>::shrink_to_small()
+{
+    if (Y_LIKELY(IsInline())) {
+        return;
+    }
+
+    auto size = this->size();
+    if (size > N) {
+        return;
+    }
+
+    auto* storage = OnHeapMeta_.Storage;
+    UninitializedMove(storage->Elements, storage->End, &InlineElements_[0]);
+    Destroy(storage->Elements, storage->End);
+    ::free(storage);
+
+    InlineMeta_.SizePlusOne = size + 1;
+}
+
+template <class T, size_t N>
 bool TCompactVector<T, N>::IsInline() const
 {
     return InlineMeta_.SizePlusOne != 0;
diff --git a/library/cpp/yt/small_containers/compact_vector.h b/library/cpp/yt/small_containers/compact_vector.h
index a42a1f0751..6c4a0b0e39 100644
--- a/library/cpp/yt/small_containers/compact_vector.h
+++ b/library/cpp/yt/small_containers/compact_vector.h
@@ -60,7 +60,7 @@ public:
     TCompactVector(const TCompactVector& other);
     template <size_t OtherN>
     TCompactVector(const TCompactVector<T, OtherN>& other);
-    TCompactVector(TCompactVector&& other) noexcept(std::is_nothrow_move_constructible_v<T>); 
+    TCompactVector(TCompactVector&& other) noexcept(std::is_nothrow_move_constructible_v<T>);
     template <size_t OtherN>
     TCompactVector(TCompactVector<T, OtherN>&& other);
     explicit TCompactVector(size_type count);
@@ -144,8 +144,8 @@ public:
     iterator insert(const_iterator pos, TIterator first, TIterator last);
     iterator insert(const_iterator pos, std::initializer_list<T> list);
 
-    void shrink_to_small(); 
- 
+    void shrink_to_small();
+
 private:
     template <class OtherT, size_t OtherN>
     friend class TCompactVector;
diff --git a/library/cpp/yt/small_containers/unittests/compact_flat_map_ut.cpp b/library/cpp/yt/small_containers/unittests/compact_flat_map_ut.cpp
index bbc03089bb..0b2f290692 100644
--- a/library/cpp/yt/small_containers/unittests/compact_flat_map_ut.cpp
+++ b/library/cpp/yt/small_containers/unittests/compact_flat_map_ut.cpp
@@ -1,7 +1,7 @@
 #include <yt/yt/core/test_framework/framework.h>
 
-#include <yt/yt/core/misc/compact_flat_map.h> 
- 
+#include <yt/yt/core/misc/compact_flat_map.h>
+
 #include <string>
 #include <vector>
 
@@ -10,7 +10,7 @@ namespace {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-using TMap = TCompactFlatMap<std::string, std::string, 2>; 
+using TMap = TCompactFlatMap<std::string, std::string, 2>;
 
 TMap CreateMap()
 {
@@ -18,15 +18,15 @@ TMap CreateMap()
     return {data.begin(), data.end()};
 }
 
-TEST(CompactFlatMapTest, DefaultEmpty) 
-{ 
+TEST(CompactFlatMapTest, DefaultEmpty)
+{
     TMap m;
     EXPECT_TRUE(m.empty());
     EXPECT_EQ(m.begin(), m.end());
 }
 
-TEST(CompactFlatMapTest, Reserve) 
-{ 
+TEST(CompactFlatMapTest, Reserve)
+{
     // No real way to test reserve - just use it and wiggle about.
     auto m1 = CreateMap();
     TMap m2;
@@ -35,26 +35,26 @@ TEST(CompactFlatMapTest, Reserve)
     EXPECT_EQ(m1.size(), m2.size());
 }
 
-TEST(CompactFlatMapTest, Size) 
-{ 
+TEST(CompactFlatMapTest, Size)
+{
     auto m = CreateMap();
 
-    EXPECT_EQ(m.size(), 4u); 
+    EXPECT_EQ(m.size(), 4u);
     EXPECT_EQ(m.ssize(), 4);
 
     m.insert({"Who", "said"});
 
-    EXPECT_EQ(m.size(), 5u); 
+    EXPECT_EQ(m.size(), 5u);
     EXPECT_EQ(m.ssize(), 5);
 
     m.erase("antique");
 
-    EXPECT_EQ(m.size(), 4u); 
+    EXPECT_EQ(m.size(), 4u);
     EXPECT_EQ(m.ssize(), 4);
 }
 
-TEST(CompactFlatMapTest, ClearAndEmpty) 
-{ 
+TEST(CompactFlatMapTest, ClearAndEmpty)
+{
     auto m = CreateMap();
 
     EXPECT_FALSE(m.empty());
@@ -71,8 +71,8 @@ TEST(CompactFlatMapTest, ClearAndEmpty)
     EXPECT_NE(m.begin(), m.end());
 }
 
-TEST(CompactFlatMapTest, FindMutable) 
-{ 
+TEST(CompactFlatMapTest, FindMutable)
+{
     auto m = CreateMap();
     {
         auto it = m.find("from");
@@ -91,8 +91,8 @@ TEST(CompactFlatMapTest, FindMutable)
     }
 }
 
-TEST(CompactFlatMapTest, FindConst) 
-{ 
+TEST(CompactFlatMapTest, FindConst)
+{
     const auto& m = CreateMap();
     {
         auto it = m.find("from");
@@ -105,26 +105,26 @@ TEST(CompactFlatMapTest, FindConst)
     }
 }
 
-TEST(CompactFlatMapTest, Insert) 
-{ 
+TEST(CompactFlatMapTest, Insert)
+{
     auto m = CreateMap();
 
     auto [it, inserted] = m.insert({"Who", "said"});
     EXPECT_TRUE(inserted);
-    EXPECT_EQ(m.ssize(), 5); 
+    EXPECT_EQ(m.ssize(), 5);
     EXPECT_NE(it, m.end());
     EXPECT_EQ(it, m.find("Who"));
     EXPECT_EQ(it->second, "said");
 
     auto [it2, inserted2] = m.insert({"Who", "told"});
     EXPECT_FALSE(inserted2);
-    EXPECT_EQ(m.ssize(), 5); 
+    EXPECT_EQ(m.ssize(), 5);
     EXPECT_EQ(it2, it);
     EXPECT_EQ(it->second, "said");
 
     std::vector<std::pair<std::string, std::string>> data = {{"Two", "vast"}, {"and", "trunkless"}, {"legs", "of"}, {"stone", "Stand"}, {"in", "the"}, {"desert", "..."}};
     m.insert(data.begin(), data.end());
-    EXPECT_EQ(m.ssize(), 11); 
+    EXPECT_EQ(m.ssize(), 11);
     EXPECT_NE(m.find("and"), m.end());
     EXPECT_EQ(m.find("and")->second, "trunkless");
 }
@@ -147,33 +147,33 @@ TEST(CompactFlatMapTest, Emplace)
     EXPECT_EQ(it->second, "place");
 }
 
-TEST(CompactFlatMapTest, Subscript) 
-{ 
+TEST(CompactFlatMapTest, Subscript)
+{
     auto m = CreateMap();
 
     EXPECT_EQ(m["antique"], "land");
-    EXPECT_EQ(m.ssize(), 4); 
+    EXPECT_EQ(m.ssize(), 4);
 
     EXPECT_EQ(m["Who"], "");
-    EXPECT_EQ(m.ssize(), 5); 
+    EXPECT_EQ(m.ssize(), 5);
 }
 
-TEST(CompactFlatMapTest, Erase) 
-{ 
+TEST(CompactFlatMapTest, Erase)
+{
     auto m = CreateMap();
 
     m.erase("antique");
-    EXPECT_EQ(m.ssize(), 3); 
+    EXPECT_EQ(m.ssize(), 3);
 
     m.erase("Who");
-    EXPECT_EQ(m.ssize(), 3); 
+    EXPECT_EQ(m.ssize(), 3);
 
     m.erase(m.begin(), m.end());
     EXPECT_TRUE(m.empty());
 }
 
-TEST(CompactFlatMapTest, GrowShrink) 
-{ 
+TEST(CompactFlatMapTest, GrowShrink)
+{
     TMap m;
     m.insert({"Two", "vast"});
     m.insert({"and", "trunkless"});
@@ -187,13 +187,13 @@ TEST(CompactFlatMapTest, GrowShrink)
     m.erase("in");
     m.erase("desert");
 
-    EXPECT_EQ(m.ssize(), 2); 
+    EXPECT_EQ(m.ssize(), 2);
 
     // Must not crash or trigger asan.
 }
 
-TEST(CompactFlatMapTest, GrowShrinkGrow) 
-{ 
+TEST(CompactFlatMapTest, GrowShrinkGrow)
+{
     TMap m;
     m.insert({"Two", "vast"});
     m.insert({"and", "trunkless"});
@@ -207,14 +207,14 @@ TEST(CompactFlatMapTest, GrowShrinkGrow)
     m.erase("in");
     m.erase("desert");
 
-    EXPECT_EQ(m.ssize(), 2); 
+    EXPECT_EQ(m.ssize(), 2);
 
     m.insert({"I", "met"});
     m.insert({"a", "traveller"});
     m.insert({"from", "an"});
     m.insert({"antique", "land"});
 
-    EXPECT_EQ(m.ssize(), 6); 
+    EXPECT_EQ(m.ssize(), 6);
 
     // Must not crash or trigger asan.
 }
diff --git a/library/cpp/yt/small_containers/unittests/compact_heap_ut.cpp b/library/cpp/yt/small_containers/unittests/compact_heap_ut.cpp
index 70f9622948..259c576e87 100644
--- a/library/cpp/yt/small_containers/unittests/compact_heap_ut.cpp
+++ b/library/cpp/yt/small_containers/unittests/compact_heap_ut.cpp
@@ -1,108 +1,108 @@
-#include <library/cpp/yt/small_containers/compact_heap.h> 
- 
-#include <library/cpp/testing/gtest/gtest.h> 
- 
-#include <random> 
- 
-namespace NYT { 
-namespace { 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-TEST(CompactHeapTest, Simple) 
-{ 
-    TCompactHeap<int, 2> heap; 
-    heap.push(3); 
-    heap.push(1); 
-    heap.push(2); 
- 
-    EXPECT_EQ(3u, heap.size()); 
-    EXPECT_EQ(1, heap.extract_min()); 
- 
-    EXPECT_EQ(2, heap.get_min()); 
-    EXPECT_EQ(2, heap.extract_min()); 
- 
-    EXPECT_EQ(3, heap.extract_min()); 
- 
-    EXPECT_TRUE(heap.empty()); 
-} 
- 
-TEST(CompactHeapTest, SimpleComparator) 
-{ 
-    TCompactHeap<int, 2, std::greater<int>> heap; 
-    heap.push(3); 
-    heap.push(1); 
-    heap.push(2); 
- 
-    EXPECT_EQ(3u, heap.size()); 
-    EXPECT_EQ(3, heap.extract_min()); 
-    EXPECT_EQ(2, heap.get_min()); 
-    EXPECT_EQ(2, heap.extract_min()); 
-    EXPECT_EQ(1, heap.extract_min()); 
-    EXPECT_TRUE(heap.empty()); 
-} 
- 
-TEST(CompactHeapTest, Capacity) 
-{ 
-    TCompactHeap<int, 2> heap; 
-    EXPECT_EQ(2u, heap.capacity()); 
-    EXPECT_EQ(0u, heap.size()); 
- 
-    for (int i = 0; i < 100; ++i) { 
-        heap.push(i); 
-    } 
-    EXPECT_LE(100u, heap.capacity()); 
-    EXPECT_EQ(100u, heap.size()); 
- 
-    for (int i = 0; i < 99; ++i) { 
-        heap.pop(); 
-    } 
-    EXPECT_LE(100u, heap.capacity()); 
-    EXPECT_EQ(1u, heap.size()); 
- 
-    heap.shrink_to_small(); 
- 
-    EXPECT_EQ(2u, heap.capacity()); 
-    EXPECT_EQ(1u, heap.size()); 
-} 
- 
-TEST(CompactHeapTest, Stress) 
-{ 
-    TCompactHeap<int, 3, std::greater<int>> heap; 
-    std::vector<int> values; 
- 
-    std::mt19937 rng(42); 
-    for (int iteration = 0; iteration < 1000; ++iteration) { 
-        EXPECT_EQ(values.size(), heap.size()); 
-        EXPECT_EQ(values.empty(), heap.empty()); 
- 
-        { 
-            std::vector<int> content(heap.begin(), heap.end()); 
-            std::sort(content.rbegin(), content.rend()); 
-            EXPECT_EQ(values, content); 
-        } 
- 
-        if (!values.empty()) { 
-            EXPECT_EQ(values[0], heap.get_min()); 
-        } 
- 
-        if (values.empty() || rng() % 2 == 0) { 
-            int x = rng() % 100; 
-            heap.push(x); 
-            values.push_back(x); 
-            std::sort(values.rbegin(), values.rend()); 
-        } else { 
-            if (rng() % 2 == 0) { 
-                EXPECT_EQ(values[0], heap.extract_min()); 
-            } else { 
-                heap.pop(); 
-            } 
-            values.erase(values.begin()); 
-        } 
-    } 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-} // namespace 
-} // namespace NYT 
+#include <library/cpp/yt/small_containers/compact_heap.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <random>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(CompactHeapTest, Simple)
+{
+    TCompactHeap<int, 2> heap;
+    heap.push(3);
+    heap.push(1);
+    heap.push(2);
+
+    EXPECT_EQ(3u, heap.size());
+    EXPECT_EQ(1, heap.extract_min());
+
+    EXPECT_EQ(2, heap.get_min());
+    EXPECT_EQ(2, heap.extract_min());
+
+    EXPECT_EQ(3, heap.extract_min());
+
+    EXPECT_TRUE(heap.empty());
+}
+
+TEST(CompactHeapTest, SimpleComparator)
+{
+    TCompactHeap<int, 2, std::greater<int>> heap;
+    heap.push(3);
+    heap.push(1);
+    heap.push(2);
+
+    EXPECT_EQ(3u, heap.size());
+    EXPECT_EQ(3, heap.extract_min());
+    EXPECT_EQ(2, heap.get_min());
+    EXPECT_EQ(2, heap.extract_min());
+    EXPECT_EQ(1, heap.extract_min());
+    EXPECT_TRUE(heap.empty());
+}
+
+TEST(CompactHeapTest, Capacity)
+{
+    TCompactHeap<int, 2> heap;
+    EXPECT_EQ(2u, heap.capacity());
+    EXPECT_EQ(0u, heap.size());
+
+    for (int i = 0; i < 100; ++i) {
+        heap.push(i);
+    }
+    EXPECT_LE(100u, heap.capacity());
+    EXPECT_EQ(100u, heap.size());
+
+    for (int i = 0; i < 99; ++i) {
+        heap.pop();
+    }
+    EXPECT_LE(100u, heap.capacity());
+    EXPECT_EQ(1u, heap.size());
+
+    heap.shrink_to_small();
+
+    EXPECT_EQ(2u, heap.capacity());
+    EXPECT_EQ(1u, heap.size());
+}
+
+TEST(CompactHeapTest, Stress)
+{
+    TCompactHeap<int, 3, std::greater<int>> heap;
+    std::vector<int> values;
+
+    std::mt19937 rng(42);
+    for (int iteration = 0; iteration < 1000; ++iteration) {
+        EXPECT_EQ(values.size(), heap.size());
+        EXPECT_EQ(values.empty(), heap.empty());
+
+        {
+            std::vector<int> content(heap.begin(), heap.end());
+            std::sort(content.rbegin(), content.rend());
+            EXPECT_EQ(values, content);
+        }
+
+        if (!values.empty()) {
+            EXPECT_EQ(values[0], heap.get_min());
+        }
+
+        if (values.empty() || rng() % 2 == 0) {
+            int x = rng() % 100;
+            heap.push(x);
+            values.push_back(x);
+            std::sort(values.rbegin(), values.rend());
+        } else {
+            if (rng() % 2 == 0) {
+                EXPECT_EQ(values[0], heap.extract_min());
+            } else {
+                heap.pop();
+            }
+            values.erase(values.begin());
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/small_containers/unittests/compact_set_ut.cpp b/library/cpp/yt/small_containers/unittests/compact_set_ut.cpp
index b9bc11c4d2..ebab5846e1 100644
--- a/library/cpp/yt/small_containers/unittests/compact_set_ut.cpp
+++ b/library/cpp/yt/small_containers/unittests/compact_set_ut.cpp
@@ -1,4 +1,4 @@
-//===- llvm/unittest/ADT/SmallSetTest.cpp ---------------------------------===// 
+//===- llvm/unittest/ADT/SmallSetTest.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// CompactSet unit tests. 
+// CompactSet unit tests.
 //
 //===----------------------------------------------------------------------===//
 
-#include <library/cpp/yt/small_containers/compact_set.h> 
+#include <library/cpp/yt/small_containers/compact_set.h>
 
 #include <library/cpp/testing/gtest/gtest.h>
 
@@ -21,9 +21,9 @@ namespace {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TEST(CompactSetTest, Insert) { 
+TEST(CompactSetTest, Insert) {
 
-  TCompactSet<int, 4> s1; 
+  TCompactSet<int, 4> s1;
 
   for (int i = 0; i < 4; i++)
     s1.insert(i);
@@ -39,8 +39,8 @@ TEST(CompactSetTest, Insert) {
   EXPECT_EQ(0u, s1.count(4));
 }
 
-TEST(CompactSetTest, Grow) { 
-  TCompactSet<int, 4> s1; 
+TEST(CompactSetTest, Grow) {
+  TCompactSet<int, 4> s1;
 
   for (int i = 0; i < 8; i++)
     s1.insert(i);
@@ -53,8 +53,8 @@ TEST(CompactSetTest, Grow) {
   EXPECT_EQ(0u, s1.count(8));
 }
 
-TEST(CompactSetTest, Erase) { 
-  TCompactSet<int, 4> s1; 
+TEST(CompactSetTest, Erase) {
+  TCompactSet<int, 4> s1;
 
   for (int i = 0; i < 8; i++)
     s1.insert(i);
@@ -74,8 +74,8 @@ TEST(CompactSetTest, Erase) {
   EXPECT_EQ(0u, s1.count(8));
 }
 
-TEST(CompactSetTest, IteratorInt) { 
-  TCompactSet<int, 4> s1; 
+TEST(CompactSetTest, IteratorInt) {
+  TCompactSet<int, 4> s1;
 
   // Test the 'small' case.
   for (int i = 0; i < 3; i++)
@@ -99,10 +99,10 @@ TEST(CompactSetTest, IteratorInt) {
     EXPECT_EQ(i, V[i]);
 }
 
-TEST(CompactSetTest, IteratorString) { 
-  // Test CompactSetIterator for TCompactSet with a type with non-trivial 
+TEST(CompactSetTest, IteratorString) {
+  // Test CompactSetIterator for TCompactSet with a type with non-trivial
   // ctors/dtors.
-  TCompactSet<std::string, 2> s1; 
+  TCompactSet<std::string, 2> s1;
 
   s1.insert("str 1");
   s1.insert("str 2");
@@ -128,10 +128,10 @@ TEST(CompactSetTest, IteratorString) {
   EXPECT_EQ("str 4", V[3]);
 }
 
-TEST(CompactSetTest, IteratorIncMoveCopy) { 
-  // Test CompactSetIterator for TCompactSet with a type with non-trivial 
+TEST(CompactSetTest, IteratorIncMoveCopy) {
+  // Test CompactSetIterator for TCompactSet with a type with non-trivial
   // ctors/dtors.
-  TCompactSet<std::string, 2> s1; 
+  TCompactSet<std::string, 2> s1;
 
   s1.insert("str 1");
   s1.insert("str 2");
@@ -150,8 +150,8 @@ TEST(CompactSetTest, IteratorIncMoveCopy) {
 
 // These test weren't taken from llvm.
 
-TEST(CompactSetTest, Empty) { 
-  TCompactSet<int, 10> v; 
+TEST(CompactSetTest, Empty) {
+  TCompactSet<int, 10> v;
   EXPECT_TRUE(v.empty());
 
   auto data = {1, 2, 3, 4, 5};
@@ -180,8 +180,8 @@ TEST(CompactSetTest, Empty) {
   EXPECT_TRUE(v.empty());
 }
 
-TEST(CompactSetTest, ForEach) { 
-  TCompactSet<int, 10> v; 
+TEST(CompactSetTest, ForEach) {
+  TCompactSet<int, 10> v;
 
   auto data = {10, 9, 3, 4, 1, 5, 6, 8};
 
diff --git a/library/cpp/yt/small_containers/unittests/compact_vector_ut.cpp b/library/cpp/yt/small_containers/unittests/compact_vector_ut.cpp
index 3c84933ccc..770d62b9fd 100644
--- a/library/cpp/yt/small_containers/unittests/compact_vector_ut.cpp
+++ b/library/cpp/yt/small_containers/unittests/compact_vector_ut.cpp
@@ -8,7 +8,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// TCompactVector unit tests. 
+// TCompactVector unit tests.
 //
 //===----------------------------------------------------------------------===//
 
@@ -267,43 +267,43 @@ TYPED_TEST(CompactVectorTest, PushPopTest) {
   }
 }
 
-TYPED_TEST(CompactVectorTest, InsertEnd) 
-{ 
-    SCOPED_TRACE("InsertEnd"); 
- 
-    TCompactVector<TString, 5> vector; 
-    for (int index = 0; index < 10; ++index) { 
-        vector.insert(vector.end(), ToString(index)); 
-    } 
-    for (int index = 0; index < 10; ++index) { 
-        EXPECT_EQ(vector[index], ToString(index)); 
-    } 
-} 
- 
-TYPED_TEST(CompactVectorTest, ShrinkToSmall) 
-{ 
-    SCOPED_TRACE("ShrinkToSmall"); 
- 
-    TCompactVector<TString, 5> vector; 
-    for (int index = 0; index < 10; ++index) { 
-        vector.shrink_to_small(); 
-        vector.push_back(ToString(index)); 
-    } 
- 
-    for (int index = 0; index < 6; ++index) { 
-        vector.pop_back(); 
-    } 
- 
-    EXPECT_EQ(std::ssize(vector), 4); 
-    EXPECT_GE(static_cast<int>(vector.capacity()), 10); 
-    vector.shrink_to_small(); 
-    EXPECT_EQ(std::ssize(vector), 4); 
-    EXPECT_EQ(static_cast<int>(vector.capacity()), 5); 
-    for (int index = 0; index < 4; ++index) { 
-        EXPECT_EQ(vector[index], ToString(index)); 
-    } 
-} 
- 
+TYPED_TEST(CompactVectorTest, InsertEnd)
+{
+    SCOPED_TRACE("InsertEnd");
+
+    TCompactVector<TString, 5> vector;
+    for (int index = 0; index < 10; ++index) {
+        vector.insert(vector.end(), ToString(index));
+    }
+    for (int index = 0; index < 10; ++index) {
+        EXPECT_EQ(vector[index], ToString(index));
+    }
+}
+
+TYPED_TEST(CompactVectorTest, ShrinkToSmall)
+{
+    SCOPED_TRACE("ShrinkToSmall");
+
+    TCompactVector<TString, 5> vector;
+    for (int index = 0; index < 10; ++index) {
+        vector.shrink_to_small();
+        vector.push_back(ToString(index));
+    }
+
+    for (int index = 0; index < 6; ++index) {
+        vector.pop_back();
+    }
+
+    EXPECT_EQ(std::ssize(vector), 4);
+    EXPECT_GE(static_cast<int>(vector.capacity()), 10);
+    vector.shrink_to_small();
+    EXPECT_EQ(std::ssize(vector), 4);
+    EXPECT_EQ(static_cast<int>(vector.capacity()), 5);
+    for (int index = 0; index < 4; ++index) {
+        EXPECT_EQ(vector[index], ToString(index));
+    }
+}
+
 // Clear test.
 TYPED_TEST(CompactVectorTest, ClearTest) {
   SCOPED_TRACE("ClearTest");
diff --git a/library/cpp/yt/small_containers/unittests/ya.make b/library/cpp/yt/small_containers/unittests/ya.make
index 2a95ccf594..6bd8e1d0ec 100644
--- a/library/cpp/yt/small_containers/unittests/ya.make
+++ b/library/cpp/yt/small_containers/unittests/ya.make
@@ -4,8 +4,8 @@ OWNER(g:yt)
 
 SRCS(
     compact_flat_map_ut.cpp
-    compact_heap_ut.cpp 
-    compact_set_ut.cpp 
+    compact_heap_ut.cpp
+    compact_set_ut.cpp
     compact_vector_ut.cpp
 )
 
diff --git a/library/cpp/yt/string/format-inl.h b/library/cpp/yt/string/format-inl.h
index 2d9e3184e2..5484d4a216 100644
--- a/library/cpp/yt/string/format-inl.h
+++ b/library/cpp/yt/string/format-inl.h
@@ -9,7 +9,7 @@
 
 #include <library/cpp/yt/assert/assert.h>
 
-#include <library/cpp/yt/small_containers/compact_vector.h> 
+#include <library/cpp/yt/small_containers/compact_vector.h>
 
 #include <library/cpp/yt/misc/enum.h>
 
@@ -297,16 +297,16 @@ struct TValueFormatter<std::vector<T, TAllocator>>
     }
 };
 
-// TCompactVector 
-template <class T, unsigned N> 
-struct TValueFormatter<TCompactVector<T, N>> 
-{ 
-    static void Do(TStringBuilderBase* builder, const TCompactVector<T, N>& collection, TStringBuf /*format*/) 
-    { 
-        FormatRange(builder, collection, TDefaultFormatter()); 
-    } 
-}; 
- 
+// TCompactVector
+template <class T, unsigned N>
+struct TValueFormatter<TCompactVector<T, N>>
+{
+    static void Do(TStringBuilderBase* builder, const TCompactVector<T, N>& collection, TStringBuf /*format*/)
+    {
+        FormatRange(builder, collection, TDefaultFormatter());
+    }
+};
+
 // std::set
 template <class T>
 struct TValueFormatter<std::set<T>>
diff --git a/library/cpp/yt/string/unittests/format_ut.cpp b/library/cpp/yt/string/unittests/format_ut.cpp
index 499775857f..ee069bb2c0 100644
--- a/library/cpp/yt/string/unittests/format_ut.cpp
+++ b/library/cpp/yt/string/unittests/format_ut.cpp
@@ -2,7 +2,7 @@
 
 #include <library/cpp/yt/string/format.h>
 
-#include <library/cpp/yt/small_containers/compact_vector.h> 
+#include <library/cpp/yt/small_containers/compact_vector.h>
 
 #include <limits>
 
@@ -71,7 +71,7 @@ TEST(TFormatTest, Strings)
     EXPECT_EQ("abc", Format("%-2s", TString("abc")));
     EXPECT_EQ("abc", Format("%0s", TString("abc")));
     EXPECT_EQ("abc", Format("%-0s", TString("abc")));
-    EXPECT_EQ(100, std::ssize(Format("%100v", "abc"))); 
+    EXPECT_EQ(100, std::ssize(Format("%100v", "abc")));
 }
 
 TEST(TFormatTest, Integers)
@@ -79,9 +79,9 @@ TEST(TFormatTest, Integers)
     EXPECT_EQ("123", Format("%d", 123));
     EXPECT_EQ("123", Format("%v", 123));
 
-    EXPECT_EQ("042", Format("%03d", 42)); 
-    EXPECT_EQ("42", Format("%01d", 42)); 
- 
+    EXPECT_EQ("042", Format("%03d", 42));
+    EXPECT_EQ("42", Format("%01d", 42));
+
     EXPECT_EQ("2147483647", Format("%d", std::numeric_limits<i32>::max()));
     EXPECT_EQ("-2147483648", Format("%d", std::numeric_limits<i32>::min()));