Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

32 files changed, 554 insertions, 554 deletions

diff --git a/library/cpp/streams/brotli/brotli.cpp b/library/cpp/streams/brotli/brotli.cpp
index 6e58341cbd6..38052cb6882 100644
--- a/library/cpp/streams/brotli/brotli.cpp
+++ b/library/cpp/streams/brotli/brotli.cpp
@@ -1,11 +1,11 @@
-#include "brotli.h" 
- 
+#include "brotli.h"
+
 #include <contrib/libs/brotli/include/brotli/decode.h>
 #include <contrib/libs/brotli/include/brotli/encode.h>
- 
+
 #include <util/generic/yexception.h>
-#include <util/memory/addstorage.h> 
- 
+#include <util/memory/addstorage.h>
+
 namespace {
     struct TAllocator {
         static void* Allocate(void* /* opaque */, size_t size) {
@@ -19,27 +19,27 @@ namespace {
 
 }
 
-class TBrotliCompress::TImpl { 
-public: 
+class TBrotliCompress::TImpl {
+public:
     TImpl(IOutputStream* slave, int quality)
-        : Slave_(slave) 
+        : Slave_(slave)
         , EncoderState_(BrotliEncoderCreateInstance(&TAllocator::Allocate, &TAllocator::Deallocate, nullptr))
-    { 
+    {
         if (!EncoderState_) {
             ythrow yexception() << "Brotli encoder initialization failed";
         }
- 
+
         auto res = BrotliEncoderSetParameter(
             EncoderState_,
             BROTLI_PARAM_QUALITY,
             quality);
- 
+
         if (!res) {
             BrotliEncoderDestroyInstance(EncoderState_);
             ythrow yexception() << "Failed to set brotli encoder quality to " << quality;
-        } 
-    } 
- 
+        }
+    }
+
     ~TImpl() {
         BrotliEncoderDestroyInstance(EncoderState_);
     }
@@ -48,18 +48,18 @@ public:
         DoWrite(buffer, size, BROTLI_OPERATION_PROCESS);
     }
 
-    void Flush() { 
+    void Flush() {
         DoWrite(nullptr, 0, BROTLI_OPERATION_FLUSH);
-    } 
- 
+    }
+
     void Finish() {
         Flush();
         DoWrite(nullptr, 0, BROTLI_OPERATION_FINISH);
         Y_VERIFY(BrotliEncoderIsFinished(EncoderState_));
     }
 
-private: 
-    IOutputStream* Slave_; 
+private:
+    IOutputStream* Slave_;
     BrotliEncoderState* EncoderState_;
 
     void DoWrite(const void* buffer, size_t size, BrotliEncoderOperation operation) {
@@ -89,68 +89,68 @@ private:
             }
         } while (size > 0 || BrotliEncoderHasMoreOutput(EncoderState_));
     }
-}; 
- 
-TBrotliCompress::TBrotliCompress(IOutputStream* slave, int quality) { 
+};
+
+TBrotliCompress::TBrotliCompress(IOutputStream* slave, int quality) {
     Impl_.Reset(new TImpl(slave, quality));
-} 
- 
-TBrotliCompress::~TBrotliCompress() { 
-    try { 
-        Finish(); 
-    } catch (...) { 
-    } 
-} 
- 
-void TBrotliCompress::DoWrite(const void* buffer, size_t size) { 
-    Impl_->Write(buffer, size); 
-} 
- 
-void TBrotliCompress::DoFlush() { 
-    if (Impl_) { 
-        Impl_->Flush(); 
-    } 
-} 
- 
-void TBrotliCompress::DoFinish() { 
-    THolder<TImpl> impl(Impl_.Release()); 
- 
-    if (impl) { 
+}
+
+TBrotliCompress::~TBrotliCompress() {
+    try {
+        Finish();
+    } catch (...) {
+    }
+}
+
+void TBrotliCompress::DoWrite(const void* buffer, size_t size) {
+    Impl_->Write(buffer, size);
+}
+
+void TBrotliCompress::DoFlush() {
+    if (Impl_) {
+        Impl_->Flush();
+    }
+}
+
+void TBrotliCompress::DoFinish() {
+    THolder<TImpl> impl(Impl_.Release());
+
+    if (impl) {
         impl->Finish();
-    } 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 class TBrotliDecompress::TImpl: public TAdditionalStorage<TImpl> {
-public: 
-    TImpl(IInputStream* slave) 
-        : Slave_(slave) 
-    { 
+public:
+    TImpl(IInputStream* slave)
+        : Slave_(slave)
+    {
         InitDecoder();
-    } 
- 
-    ~TImpl() { 
+    }
+
+    ~TImpl() {
         FreeDecoder();
-    } 
- 
-    size_t Read(void* buffer, size_t size) { 
+    }
+
+    size_t Read(void* buffer, size_t size) {
         Y_ASSERT(size > 0);
- 
+
         ui8* outBuffer = static_cast<ui8*>(buffer);
-        size_t availableOut = size; 
+        size_t availableOut = size;
         size_t decompressedSize = 0;
 
         BrotliDecoderResult result;
-        do { 
+        do {
             if (InputAvailable_ == 0 && !InputExhausted_) {
-                InputBuffer_ = TmpBuf(); 
+                InputBuffer_ = TmpBuf();
                 InputAvailable_ = Slave_->Read((void*)InputBuffer_, TmpBufLen());
                 if (InputAvailable_ == 0) {
                     InputExhausted_ = true;
-                } 
-            } 
- 
+                }
+            }
+
             if (SubstreamFinished_ && !InputExhausted_) {
                 ResetState();
             }
@@ -158,8 +158,8 @@ public:
             result = BrotliDecoderDecompressStream(
                 DecoderState_,
                 &InputAvailable_,
-                &InputBuffer_, 
-                &availableOut, 
+                &InputBuffer_,
+                &availableOut,
                 &outBuffer,
                 nullptr);
 
@@ -173,33 +173,33 @@ public:
             } else if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
                 Y_VERIFY(availableOut != size,
                          "Buffer passed to read in Brotli decoder is too small");
-                break; 
-            } 
+                break;
+            }
         } while (decompressedSize == 0 && result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT && !InputExhausted_);
- 
+
         if (!SubstreamFinished_ && decompressedSize == 0) {
             ythrow yexception() << "Input stream is incomplete";
         }
 
         return decompressedSize;
-    } 
- 
-private: 
-    IInputStream* Slave_; 
+    }
+
+private:
+    IInputStream* Slave_;
     BrotliDecoderState* DecoderState_;
- 
+
     bool SubstreamFinished_ = false;
     bool InputExhausted_ = false;
     const ui8* InputBuffer_ = nullptr;
     size_t InputAvailable_ = 0;
- 
-    unsigned char* TmpBuf() noexcept { 
-        return static_cast<unsigned char*>(AdditionalData()); 
-    } 
- 
-    size_t TmpBufLen() const noexcept { 
-        return AdditionalDataLength(); 
-    } 
+
+    unsigned char* TmpBuf() noexcept {
+        return static_cast<unsigned char*>(AdditionalData());
+    }
+
+    size_t TmpBufLen() const noexcept {
+        return AdditionalDataLength();
+    }
 
     void InitDecoder() {
         DecoderState_ = BrotliDecoderCreateInstance(&TAllocator::Allocate, &TAllocator::Deallocate, nullptr);
@@ -217,15 +217,15 @@ private:
         FreeDecoder();
         InitDecoder();
     }
-}; 
- 
-TBrotliDecompress::TBrotliDecompress(IInputStream* slave, size_t bufferSize) 
+};
+
+TBrotliDecompress::TBrotliDecompress(IInputStream* slave, size_t bufferSize)
     : Impl_(new (bufferSize) TImpl(slave))
-{ 
-} 
- 
-TBrotliDecompress::~TBrotliDecompress() = default; 
- 
-size_t TBrotliDecompress::DoRead(void* buffer, size_t size) { 
-    return Impl_->Read(buffer, size); 
-} 
+{
+}
+
+TBrotliDecompress::~TBrotliDecompress() = default;
+
+size_t TBrotliDecompress::DoRead(void* buffer, size_t size) {
+    return Impl_->Read(buffer, size);
+}
diff --git a/library/cpp/streams/brotli/brotli.h b/library/cpp/streams/brotli/brotli.h
index b7e4034b86d..b3af869e29c 100644
--- a/library/cpp/streams/brotli/brotli.h
+++ b/library/cpp/streams/brotli/brotli.h
@@ -1,52 +1,52 @@
-#pragma once 
- 
-#include <util/generic/ptr.h> 
-#include <util/stream/input.h> 
-#include <util/stream/output.h> 
- 
-/** 
- * @addtogroup Streams_Archs 
- * @{ 
- */ 
- 
+#pragma once
+
+#include <util/generic/ptr.h>
+#include <util/stream/input.h>
+#include <util/stream/output.h>
+
+/**
+ * @addtogroup Streams_Archs
+ * @{
+ */
+
 class TBrotliCompress: public IOutputStream {
-public: 
-    static constexpr int BEST_QUALITY = 11; 
- 
-    /** 
-      @param slave stream to write compressed data to 
-      @param quality the higher the quality, the slower and better the compression. Range is 0 to 11. 
-    */ 
-    explicit TBrotliCompress(IOutputStream* slave, int quality = BEST_QUALITY); 
-    ~TBrotliCompress() override; 
- 
-private: 
-    void DoWrite(const void* buffer, size_t size) override; 
-    void DoFlush() override; 
-    void DoFinish() override; 
- 
-public: 
-    class TImpl; 
-    THolder<TImpl> Impl_; 
-}; 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+public:
+    static constexpr int BEST_QUALITY = 11;
+
+    /**
+      @param slave stream to write compressed data to
+      @param quality the higher the quality, the slower and better the compression. Range is 0 to 11.
+    */
+    explicit TBrotliCompress(IOutputStream* slave, int quality = BEST_QUALITY);
+    ~TBrotliCompress() override;
+
+private:
+    void DoWrite(const void* buffer, size_t size) override;
+    void DoFlush() override;
+    void DoFinish() override;
+
+public:
+    class TImpl;
+    THolder<TImpl> Impl_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
 class TBrotliDecompress: public IInputStream {
-public: 
-    /** 
-      @param slave stream to read compressed data from 
-      @param bufferSize approximate size of buffer compressed data is read in 
-    */ 
-    explicit TBrotliDecompress(IInputStream* slave, size_t bufferSize = 8 * 1024); 
-    ~TBrotliDecompress() override; 
- 
-private: 
-    size_t DoRead(void* buffer, size_t size) override; 
- 
-private: 
-    class TImpl; 
-    THolder<TImpl> Impl_; 
-}; 
- 
-/** @} */ 
+public:
+    /**
+      @param slave stream to read compressed data from
+      @param bufferSize approximate size of buffer compressed data is read in
+    */
+    explicit TBrotliDecompress(IInputStream* slave, size_t bufferSize = 8 * 1024);
+    ~TBrotliDecompress() override;
+
+private:
+    size_t DoRead(void* buffer, size_t size) override;
+
+private:
+    class TImpl;
+    THolder<TImpl> Impl_;
+};
+
+/** @} */
diff --git a/library/cpp/streams/brotli/brotli_ut.cpp b/library/cpp/streams/brotli/brotli_ut.cpp
index 2d079432265..aeb2e284dc3 100644
--- a/library/cpp/streams/brotli/brotli_ut.cpp
+++ b/library/cpp/streams/brotli/brotli_ut.cpp
@@ -1,9 +1,9 @@
-#include "brotli.h" 
- 
+#include "brotli.h"
+
 #include <library/cpp/testing/unittest/registar.h>
- 
-#include <util/random/fast.h> 
- 
+
+#include <util/random/fast.h>
+
 Y_UNIT_TEST_SUITE(TBrotliTestSuite) {
     TString Compress(TString data) {
         TString compressed;
@@ -14,7 +14,7 @@ Y_UNIT_TEST_SUITE(TBrotliTestSuite) {
         output.Finish();
         return compressed;
     }
- 
+
     TString Decompress(TString data) {
         TStringInput input(data);
         TBrotliDecompress decompressStream(&input);
@@ -27,20 +27,20 @@ Y_UNIT_TEST_SUITE(TBrotliTestSuite) {
 
     TString GenerateRandomString(size_t size) {
         TReallyFastRng32 rng(42);
-        TString result; 
-        result.reserve(size + sizeof(ui64)); 
-        while (result.size() < size) { 
-            ui64 value = rng.GenRand64(); 
-            result += TStringBuf(reinterpret_cast<const char*>(&value), sizeof(value)); 
-        } 
-        result.resize(size); 
-        return result; 
-    } 
- 
+        TString result;
+        result.reserve(size + sizeof(ui64));
+        while (result.size() < size) {
+            ui64 value = rng.GenRand64();
+            result += TStringBuf(reinterpret_cast<const char*>(&value), sizeof(value));
+        }
+        result.resize(size);
+        return result;
+    }
+
     Y_UNIT_TEST(TestHelloWorld) {
         TestCase("hello world");
-    } 
- 
+    }
+
     Y_UNIT_TEST(TestFlush) {
         TStringStream ss;
         TBrotliCompress compressStream(&ss);
@@ -64,26 +64,26 @@ Y_UNIT_TEST_SUITE(TBrotliTestSuite) {
         auto c1 = Compress(s1);
         auto c2 = Compress(s2);
         UNIT_ASSERT_VALUES_EQUAL(s1 + s2, Decompress(c1 + c2));
-    } 
- 
+    }
+
     Y_UNIT_TEST(TestIncompleteStream) {
         TString manyAs(64 * 1024, 'a');
         auto compressed = Compress(manyAs);
         TString truncated(compressed.data(), compressed.size() - 1);
         UNIT_CHECK_GENERATED_EXCEPTION(Decompress(truncated), std::exception);
-    } 
- 
+    }
+
     Y_UNIT_TEST(Test64KB) {
         auto manyAs = TString(64 * 1024, 'a');
         TString str("Hello from the Matrix!@#% How are you?}{\n\t\a");
         TestCase(manyAs + str + manyAs);
-    } 
- 
+    }
+
     Y_UNIT_TEST(Test1MB) {
         TestCase(GenerateRandomString(1 * 1024 * 1024));
     }
 
     Y_UNIT_TEST(TestEmpty) {
         TestCase("");
-    } 
-} 
+    }
+}
diff --git a/library/cpp/streams/brotli/ut/ya.make b/library/cpp/streams/brotli/ut/ya.make
index 70c207ba7e2..243462f1b2b 100644
--- a/library/cpp/streams/brotli/ut/ya.make
+++ b/library/cpp/streams/brotli/ut/ya.make
@@ -1,12 +1,12 @@
 UNITTEST_FOR(library/cpp/streams/brotli)
- 
+
 OWNER(
     levysotsky
     g:util
 )
- 
-SRCS( 
-    brotli_ut.cpp 
-) 
- 
-END() 
+
+SRCS(
+    brotli_ut.cpp
+)
+
+END()
diff --git a/library/cpp/streams/brotli/ya.make b/library/cpp/streams/brotli/ya.make
index 108419e69e0..fa2bfec9cc5 100644
--- a/library/cpp/streams/brotli/ya.make
+++ b/library/cpp/streams/brotli/ya.make
@@ -1,17 +1,17 @@
-LIBRARY() 
- 
+LIBRARY()
+
 OWNER(
     levysotsky
     g:util
 )
- 
-PEERDIR( 
-    contrib/libs/brotli/enc 
-    contrib/libs/brotli/dec 
-) 
- 
-SRCS( 
-    brotli.cpp 
-) 
- 
-END() 
+
+PEERDIR(
+    contrib/libs/brotli/enc
+    contrib/libs/brotli/dec
+)
+
+SRCS(
+    brotli.cpp
+)
+
+END()
diff --git a/library/cpp/streams/ya.make b/library/cpp/streams/ya.make
index 474ecb051e9..7426a874ee4 100644
--- a/library/cpp/streams/ya.make
+++ b/library/cpp/streams/ya.make
@@ -2,7 +2,7 @@ RECURSE(
     brotli
     brotli/ut
     base64
-    brotli 
+    brotli
     bzip2
     bzip2/ut
     factory
diff --git a/library/cpp/testing/unittest/registar.h b/library/cpp/testing/unittest/registar.h
index 633be5ced9f..44517a00924 100644
--- a/library/cpp/testing/unittest/registar.h
+++ b/library/cpp/testing/unittest/registar.h
@@ -363,12 +363,12 @@ public:                       \
 
 #define UNIT_FAIL_IMPL(R, M)                                                                                                                     \
     do {                                                                                                                                         \
-        ::NUnitTest::NPrivate::RaiseError(R, ::TStringBuilder() << R << " at " << __LOCATION__ << ", " << __PRETTY_FUNCTION__ << ": " << M, true); \ 
+        ::NUnitTest::NPrivate::RaiseError(R, ::TStringBuilder() << R << " at " << __LOCATION__ << ", " << __PRETTY_FUNCTION__ << ": " << M, true); \
     } while (false)
 
 #define UNIT_FAIL_NONFATAL_IMPL(R, M)                                                                                                             \
     do {                                                                                                                                          \
-        ::NUnitTest::NPrivate::RaiseError(R, ::TStringBuilder() << R << " at " << __LOCATION__ << ", " << __PRETTY_FUNCTION__ << ": " << M, false); \ 
+        ::NUnitTest::NPrivate::RaiseError(R, ::TStringBuilder() << R << " at " << __LOCATION__ << ", " << __PRETTY_FUNCTION__ << ": " << M, false); \
     } while (false)
 
 #define UNIT_FAIL(M) UNIT_FAIL_IMPL("forced failure", M)
@@ -378,7 +378,7 @@ public:                       \
 #define UNIT_ASSERT_TYPES_EQUAL(A, B)                                                                                                                                  \
     do {                                                                                                                                                               \
         if (!std::is_same<A, B>::value) {                                                                                                                              \
-            UNIT_FAIL_IMPL("types equal assertion failed", (::TStringBuilder() << #A << " (" << TypeName<A>() << ") != " << #B << " (" << TypeName<B>() << ")").data()); \ 
+            UNIT_FAIL_IMPL("types equal assertion failed", (::TStringBuilder() << #A << " (" << TypeName<A>() << ") != " << #B << " (" << TypeName<B>() << ")").data()); \
         }                                                                                                                                                              \
     } while (false)
 
@@ -391,7 +391,7 @@ public:                       \
             const auto _es = ToString((long double)(E));                                                       \
             const auto _as = ToString((long double)(A));                                                       \
             const auto _ds = ToString((long double)(D));                                                       \
-            auto&& failMsg = Sprintf("std::abs(%s - %s) > %s %s", _es.data(), _as.data(), _ds.data(), (::TStringBuilder() << C).data()); \ 
+            auto&& failMsg = Sprintf("std::abs(%s - %s) > %s %s", _es.data(), _as.data(), _ds.data(), (::TStringBuilder() << C).data()); \
             UNIT_FAIL_IMPL("assertion failure", failMsg);                                                      \
         }                                                                                                      \
     } while (false)
@@ -405,19 +405,19 @@ public:                       \
         const auto _dd = (D);                                                                                                          \
         if (std::isnan((long double)_ed) && !std::isnan((long double)_ad)) {                                                           \
             const auto _as = ToString((long double)_ad);                                                                               \
-            auto&& failMsg = Sprintf("expected NaN, got %s %s", _as.data(), (::TStringBuilder() << C).data());                           \ 
+            auto&& failMsg = Sprintf("expected NaN, got %s %s", _as.data(), (::TStringBuilder() << C).data());                           \
             UNIT_FAIL_IMPL("assertion failure", failMsg);                                                                              \
         }                                                                                                                              \
         if (!std::isnan((long double)_ed) && std::isnan((long double)_ad)) {                                                           \
             const auto _es = ToString((long double)_ed);                                                                               \
-            auto&& failMsg = Sprintf("expected %s, got NaN %s", _es.data(), (::TStringBuilder() << C).data());                           \ 
+            auto&& failMsg = Sprintf("expected %s, got NaN %s", _es.data(), (::TStringBuilder() << C).data());                           \
             UNIT_FAIL_IMPL("assertion failure", failMsg);                                                                              \
         }                                                                                                                              \
         if (std::abs((_ed) - (_ad)) > (_dd)) {                                                                                         \
             const auto _es = ToString((long double)_ed);                                                                               \
             const auto _as = ToString((long double)_ad);                                                                               \
             const auto _ds = ToString((long double)_dd);                                                                               \
-            auto&& failMsg = Sprintf("std::abs(%s - %s) > %s %s", _es.data(), _as.data(), _ds.data(), (::TStringBuilder() << C).data()); \ 
+            auto&& failMsg = Sprintf("std::abs(%s - %s) > %s %s", _es.data(), _as.data(), _ds.data(), (::TStringBuilder() << C).data()); \
             UNIT_FAIL_IMPL("assertion failure", failMsg);                                                                              \
         }                                                                                                                              \
     } while (false)
@@ -430,7 +430,7 @@ public:                       \
         const TString _a(A);                                                                                 \
         const TString _b(B);                                                                                 \
         if (_a != _b) {                                                                                      \
-            auto&& failMsg = Sprintf("%s != %s %s", ToString(_a).data(), ToString(_b).data(), (::TStringBuilder() << C).data()); \ 
+            auto&& failMsg = Sprintf("%s != %s %s", ToString(_a).data(), ToString(_b).data(), (::TStringBuilder() << C).data()); \
             UNIT_FAIL_IMPL("strings equal assertion failed", failMsg);                                       \
         }                                                                                                    \
     } while (false)
@@ -442,7 +442,7 @@ public:                       \
         const TString _a(A);                                                                                                    \
         const TString _b(B);                                                                                                    \
         if (!_a.Contains(_b)) {                                                                                                 \
-            auto&& msg = Sprintf("\"%s\" does not contain \"%s\", %s", ToString(_a).data(), ToString(_b).data(), (::TStringBuilder() << C).data()); \ 
+            auto&& msg = Sprintf("\"%s\" does not contain \"%s\", %s", ToString(_a).data(), ToString(_b).data(), (::TStringBuilder() << C).data()); \
             UNIT_FAIL_IMPL("strings contains assertion failed", msg);                                                           \
         }                                                                                                                       \
     } while (false)
@@ -464,7 +464,7 @@ public:                       \
         const TString _a(A);                                                                             \
         const TString _b(B);                                                                             \
         if (_a == _b) {                                                                                  \
-            auto&& msg = Sprintf("%s == %s %s", ToString(_a).data(), ToString(_b).data(), (::TStringBuilder() << C).data()); \ 
+            auto&& msg = Sprintf("%s == %s %s", ToString(_a).data(), ToString(_b).data(), (::TStringBuilder() << C).data()); \
             UNIT_FAIL_IMPL("strings unequal assertion failed", msg);                                     \
         }                                                                                                \
     } while (false)
@@ -475,7 +475,7 @@ public:                       \
 #define UNIT_ASSERT_C(A, C)                                                                             \
     do {                                                                                                \
         if (!(A)) {                                                                                     \
-            UNIT_FAIL_IMPL("assertion failed", Sprintf("(%s) %s", #A, (::TStringBuilder() << C).data())); \ 
+            UNIT_FAIL_IMPL("assertion failed", Sprintf("(%s) %s", #A, (::TStringBuilder() << C).data())); \
         }                                                                                               \
     } while (false)
 
@@ -485,7 +485,7 @@ public:                       \
 #define UNIT_ASSERT_EQUAL_C(A, B, C)                                                                                  \
     do {                                                                                                              \
         if (!((A) == (B))) {                                                                                          \
-            UNIT_FAIL_IMPL("equal assertion failed", Sprintf("%s == %s %s", #A, #B, (::TStringBuilder() << C).data())); \ 
+            UNIT_FAIL_IMPL("equal assertion failed", Sprintf("%s == %s %s", #A, #B, (::TStringBuilder() << C).data())); \
         }                                                                                                             \
     } while (false)
 
@@ -494,7 +494,7 @@ public:                       \
 #define UNIT_ASSERT_UNEQUAL_C(A, B, C)                                                                                 \
     do {                                                                                                               \
         if ((A) == (B)) {                                                                                              \
-            UNIT_FAIL_IMPL("unequal assertion failed", Sprintf("%s != %s %s", #A, #B, (::TStringBuilder() << C).data()));\ 
+            UNIT_FAIL_IMPL("unequal assertion failed", Sprintf("%s != %s %s", #A, #B, (::TStringBuilder() << C).data()));\
         }                                                                                                              \
     } while (false)
 
@@ -503,7 +503,7 @@ public:                       \
 #define UNIT_ASSERT_LT_C(A, B, C)                                                                                        \
     do {                                                                                                                 \
         if (!((A) < (B))) {                                                                                              \
-            UNIT_FAIL_IMPL("less-than assertion failed", Sprintf("%s < %s %s", #A, #B, (::TStringBuilder() << C).data())); \ 
+            UNIT_FAIL_IMPL("less-than assertion failed", Sprintf("%s < %s %s", #A, #B, (::TStringBuilder() << C).data())); \
         }                                                                                                                \
     } while (false)
 
@@ -512,7 +512,7 @@ public:                       \
 #define UNIT_ASSERT_LE_C(A, B, C)                                                                                             \
     do {                                                                                                                      \
         if (!((A) <= (B))) {                                                                                                  \
-            UNIT_FAIL_IMPL("less-or-equal assertion failed", Sprintf("%s <= %s %s", #A, #B, (::TStringBuilder() << C).data())); \ 
+            UNIT_FAIL_IMPL("less-or-equal assertion failed", Sprintf("%s <= %s %s", #A, #B, (::TStringBuilder() << C).data())); \
         }                                                                                                                     \
     } while (false)
 
@@ -521,7 +521,7 @@ public:                       \
 #define UNIT_ASSERT_GT_C(A, B, C)                                                                                           \
     do {                                                                                                                    \
         if (!((A) > (B))) {                                                                                                 \
-            UNIT_FAIL_IMPL("greater-than assertion failed", Sprintf("%s > %s %s", #A, #B, (::TStringBuilder() << C).data())); \ 
+            UNIT_FAIL_IMPL("greater-than assertion failed", Sprintf("%s > %s %s", #A, #B, (::TStringBuilder() << C).data())); \
         }                                                                                                                   \
     } while (false)
 
@@ -530,7 +530,7 @@ public:                       \
 #define UNIT_ASSERT_GE_C(A, B, C)                                                                        \
     do { \
         if (!((A) >= (B))) {                                                                                    \
-            UNIT_FAIL_IMPL("greater-or-equal assertion failed", Sprintf("%s >= %s %s", #A, #B, (::TStringBuilder() << C).data())); \ 
+            UNIT_FAIL_IMPL("greater-or-equal assertion failed", Sprintf("%s >= %s %s", #A, #B, (::TStringBuilder() << C).data())); \
         } \
     } while (false)
 
@@ -651,7 +651,7 @@ public:                       \
         } catch (const ::NUnitTest::TAssertException&) {                                                                                                                 \
             throw;                                                                                                                                                       \
         } catch (...) {                                                                                                                                                  \
-            UNIT_FAIL_IMPL("exception-free assertion failed", Sprintf("%s throws %s\nException message: %s", #A, (::TStringBuilder() << C).data(), CurrentExceptionMessage().data())); \ 
+            UNIT_FAIL_IMPL("exception-free assertion failed", Sprintf("%s throws %s\nException message: %s", #A, (::TStringBuilder() << C).data(), CurrentExceptionMessage().data())); \
         }                                                                                                                                                                \
     } while (false)
 
@@ -712,7 +712,7 @@ public:                       \
         TString _bsInd;                                                                                                                \
         bool _usePlainDiff;                                                                                                            \
         if (!::NUnitTest::NPrivate::CompareAndMakeStrings(A, B, _as, _asInd, _bs, _bsInd, _usePlainDiff, EQflag)) {                    \
-            auto&& failMsg = Sprintf("(%s %s %s) failed: (%s %s %s) %s", #A, EQstr, #B, _as.data(), NEQstr, _bs.data(), (::TStringBuilder() << C).data()); \ 
+            auto&& failMsg = Sprintf("(%s %s %s) failed: (%s %s %s) %s", #A, EQstr, #B, _as.data(), NEQstr, _bs.data(), (::TStringBuilder() << C).data()); \
             if (EQflag && !_usePlainDiff) {                                                                                            \
                 failMsg += ", with diff:\n";                                                                                           \
                 failMsg += ::NUnitTest::ColoredDiff(_asInd, _bsInd);                                                                   \
diff --git a/library/cpp/ya.make b/library/cpp/ya.make
index 36aec001ef9..8c1193b0077 100644
--- a/library/cpp/ya.make
+++ b/library/cpp/ya.make
@@ -331,7 +331,7 @@ RECURSE(
     sighandler
     simhash
     simhash/ut
-    skiff 
+    skiff
     sliding_window
     sliding_window/ut
     solve_ambig
diff --git a/library/cpp/yson/detail.h b/library/cpp/yson/detail.h
index 1b0bd4c4497..27f5e8ffff2 100644
--- a/library/cpp/yson/detail.h
+++ b/library/cpp/yson/detail.h
@@ -453,7 +453,7 @@ namespace NYson {
                     default:
                         ythrow TYsonException() << "Incorrect %-literal prefix: '" << ch << "'";
                 }
- 
+
                 for (size_t i = 0; i < expectedString.size(); ++i) {
                     if (expectedString[i] != ch) {
                         ythrow TYsonException()
@@ -464,10 +464,10 @@ namespace NYson {
                     TBaseStream::Advance(1);
                     ch = TBaseStream::template GetChar<AllowFinish>();
                 }
- 
+
                 return expectedValue;
-            } 
- 
+            }
+
             void ReadQuotedString(TStringBuf* value) {
                 Buffer_.clear();
                 while (true) {
@@ -494,14 +494,14 @@ namespace NYson {
                     }
                     CheckMemoryLimit();
                 }
- 
+
                 auto unquotedValue = UnescapeC(Buffer_.data(), Buffer_.size());
                 Buffer_.clear();
                 Buffer_.insert(Buffer_.end(), unquotedValue.data(), unquotedValue.data() + unquotedValue.size());
                 CheckMemoryLimit();
                 *value = TStringBuf(Buffer_.data(), Buffer_.size());
             }
- 
+
             template <bool AllowFinish>
             void ReadUnquotedString(TStringBuf* value) {
                 Buffer_.clear();
diff --git a/library/cpp/yson/lexer_detail.h b/library/cpp/yson/lexer_detail.h
index c3d1d53fdb8..0bba30acdd2 100644
--- a/library/cpp/yson/lexer_detail.h
+++ b/library/cpp/yson/lexer_detail.h
@@ -230,7 +230,7 @@ namespace NYson {
                         TStringBuf value;
                         TBase::ReadBinaryString(&value);
                         *token = TToken(value);
-                    } 
+                    }
                 }
             }
 
diff --git a/library/cpp/yson/node/node.cpp b/library/cpp/yson/node/node.cpp
index db507c2bb8d..b39e0707187 100644
--- a/library/cpp/yson/node/node.cpp
+++ b/library/cpp/yson/node/node.cpp
@@ -148,10 +148,10 @@ TNode::TNode(bool b)
     : Value_(b)
 { }
 
-TNode::TNode(TMapType map) 
+TNode::TNode(TMapType map)
     : Value_(std::move(map))
-{ } 
- 
+{ }
+
 TNode::TNode(const TNode& rhs)
     : TNode()
 {
@@ -259,7 +259,7 @@ bool TNode::Empty() const
         case Map:
             return std::get<TMapType>(Value_).empty();
         default:
-            ythrow TTypeError() << "Empty() called for type " << GetType(); 
+            ythrow TTypeError() << "Empty() called for type " << GetType();
     }
 }
 
@@ -273,7 +273,7 @@ size_t TNode::Size() const
         case Map:
             return std::get<TMapType>(Value_).size();
         default:
-            ythrow TTypeError() << "Size() called for type " << GetType(); 
+            ythrow TTypeError() << "Size() called for type " << GetType();
     }
 }
 
@@ -822,7 +822,7 @@ void TNode::Move(TNode&& rhs)
 void TNode::CheckType(EType type) const
 {
     Y_ENSURE_EX(GetType() == type,
-        TTypeError() << "TNode type " << type <<  " expected, actual type " << GetType(); 
+        TTypeError() << "TNode type " << type <<  " expected, actual type " << GetType();
     );
 }
 
diff --git a/library/cpp/yson/node/node.h b/library/cpp/yson/node/node.h
index bbf36144f64..5f90f95df07 100644
--- a/library/cpp/yson/node/node.h
+++ b/library/cpp/yson/node/node.h
@@ -101,7 +101,7 @@ public:
     TNode(unsigned long long ui);
     TNode(double d);
     TNode(bool b);
-    TNode(TMapType map); 
+    TNode(TMapType map);
 
     TNode(const TNode& rhs);
     TNode& operator=(const TNode& rhs);
@@ -358,7 +358,7 @@ inline TString TNode::ConvertTo<TString>() const {
         case NYT::TNode::Map:
         case NYT::TNode::Null:
         case NYT::TNode::Undefined:
-            ythrow TTypeError() << "ConvertTo<TString>() called for type " << GetType(); 
+            ythrow TTypeError() << "ConvertTo<TString>() called for type " << GetType();
     }
     Y_UNREACHABLE();
 }
@@ -380,7 +380,7 @@ inline double TNode::ConvertTo<double>() const {
         case NYT::TNode::Map:
         case NYT::TNode::Null:
         case NYT::TNode::Undefined:
-            ythrow TTypeError() << "ConvertTo<double>() called for type " << GetType(); 
+            ythrow TTypeError() << "ConvertTo<double>() called for type " << GetType();
     }
 }
 
@@ -401,7 +401,7 @@ inline bool TNode::ConvertTo<bool>() const {
         case NYT::TNode::Map:
         case NYT::TNode::Null:
         case NYT::TNode::Undefined:
-            ythrow TTypeError() << "ConvertTo<bool>() called for type " << GetType(); 
+            ythrow TTypeError() << "ConvertTo<bool>() called for type " << GetType();
     }
 }
 
diff --git a/library/cpp/yson/node/node_io.cpp b/library/cpp/yson/node/node_io.cpp
index e7eb6555ef5..294a7f7217f 100644
--- a/library/cpp/yson/node/node_io.cpp
+++ b/library/cpp/yson/node/node_io.cpp
@@ -96,12 +96,12 @@ TString NodeToYsonString(const TNode& node, NYson::EYsonFormat format)
 }
 
 TString NodeToCanonicalYsonString(const TNode& node, NYson::EYsonFormat format)
-{ 
-    TStringStream stream; 
-    NodeToCanonicalYsonStream(node, &stream, format); 
-    return stream.Str(); 
-} 
- 
+{
+    TStringStream stream;
+    NodeToCanonicalYsonStream(node, &stream, format);
+    return stream.Str();
+}
+
 TNode NodeFromYsonStream(IInputStream* input, ::NYson::EYsonType type)
 {
     TNode result = CreateEmptyNodeByType(type);
@@ -120,12 +120,12 @@ void NodeToYsonStream(const TNode& node, IOutputStream* output, NYson::EYsonForm
 }
 
 void NodeToCanonicalYsonStream(const TNode& node, IOutputStream* output, NYson::EYsonFormat format)
-{ 
+{
     ::NYson::TYsonWriter writer(output, format);
-    TNodeVisitor visitor(&writer, /*sortMapKeys*/ true); 
-    visitor.Visit(node); 
-} 
- 
+    TNodeVisitor visitor(&writer, /*sortMapKeys*/ true);
+    visitor.Visit(node);
+}
+
 TNode NodeFromJsonString(const TStringBuf input)
 {
     TMemoryInput stream(input);
diff --git a/library/cpp/yson/node/node_io.h b/library/cpp/yson/node/node_io.h
index cdab5950449..2ad23b658f2 100644
--- a/library/cpp/yson/node/node_io.h
+++ b/library/cpp/yson/node/node_io.h
@@ -11,28 +11,28 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-// Parse TNode from string in YSON format 
+// Parse TNode from string in YSON format
 TNode NodeFromYsonString(const TStringBuf input, ::NYson::EYsonType type = ::NYson::EYsonType::Node);
- 
-// Serialize TNode to string in one of YSON formats with random order of maps' keys (don't use in tests) 
+
+// Serialize TNode to string in one of YSON formats with random order of maps' keys (don't use in tests)
 TString NodeToYsonString(const TNode& node, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
 
-// Same as the latter, but maps' keys are sorted lexicographically (to be used in tests) 
+// Same as the latter, but maps' keys are sorted lexicographically (to be used in tests)
 TString NodeToCanonicalYsonString(const TNode& node, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
- 
-// Parse TNode from stream in YSON format 
+
+// Parse TNode from stream in YSON format
 TNode NodeFromYsonStream(IInputStream* input, ::NYson::EYsonType type = ::NYson::EYsonType::Node);
- 
-// Serialize TNode to stream in one of YSON formats with random order of maps' keys (don't use in tests) 
+
+// Serialize TNode to stream in one of YSON formats with random order of maps' keys (don't use in tests)
 void NodeToYsonStream(const TNode& node, IOutputStream* output, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
 
-// Same as the latter, but maps' keys are sorted lexicographically (to be used in tests) 
+// Same as the latter, but maps' keys are sorted lexicographically (to be used in tests)
 void NodeToCanonicalYsonStream(const TNode& node, IOutputStream* output, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
- 
-// Parse TNode from string in JSON format 
+
+// Parse TNode from string in JSON format
 TNode NodeFromJsonString(const TStringBuf input);
- 
-// Convert TJsonValue to TNode 
+
+// Convert TJsonValue to TNode
 TNode NodeFromJsonValue(const NJson::TJsonValue& input);
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yson/node/node_ut.cpp b/library/cpp/yson/node/node_ut.cpp
index 0235364c391..448e99f5753 100644
--- a/library/cpp/yson/node/node_ut.cpp
+++ b/library/cpp/yson/node/node_ut.cpp
@@ -382,19 +382,19 @@ Y_UNIT_TEST_SUITE(YtNodeTest) {
         UNIT_ASSERT_EXCEPTION(TNode("random").ConvertTo<bool>(), TFromStringException);
         UNIT_ASSERT_EXCEPTION(TNode("").ConvertTo<bool>(), TFromStringException);
     }
- 
+
     Y_UNIT_TEST(TestCanonicalSerialization) {
-        auto node = TNode() 
-            ("ca", "ca")("c", "c")("a", "a")("b", "b") 
-            ("bb", TNode() 
-                ("ii", "ii")("i", "i")("jj", "jj")); 
-        node.Attributes() = TNode()("za", "za")("z", "z")("xxx", "xxx")("xx", "xx"); 
-        UNIT_ASSERT_VALUES_EQUAL(NodeToCanonicalYsonString(node), 
-            "<\"xx\"=\"xx\";\"xxx\"=\"xxx\";\"z\"=\"z\";\"za\"=\"za\">" 
-            "{\"a\"=\"a\";\"b\"=\"b\";\"bb\"=" 
-                "{\"i\"=\"i\";\"ii\"=\"ii\";\"jj\"=\"jj\"};" 
-            "\"c\"=\"c\";\"ca\"=\"ca\"}"); 
-    } 
+        auto node = TNode()
+            ("ca", "ca")("c", "c")("a", "a")("b", "b")
+            ("bb", TNode()
+                ("ii", "ii")("i", "i")("jj", "jj"));
+        node.Attributes() = TNode()("za", "za")("z", "z")("xxx", "xxx")("xx", "xx");
+        UNIT_ASSERT_VALUES_EQUAL(NodeToCanonicalYsonString(node),
+            "<\"xx\"=\"xx\";\"xxx\"=\"xxx\";\"z\"=\"z\";\"za\"=\"za\">"
+            "{\"a\"=\"a\";\"b\"=\"b\";\"bb\"="
+                "{\"i\"=\"i\";\"ii\"=\"ii\";\"jj\"=\"jj\"};"
+            "\"c\"=\"c\";\"ca\"=\"ca\"}");
+    }
 
     Y_UNIT_TEST(OperatorEqualSubnode) {
         TNode node;
diff --git a/library/cpp/yson/node/node_visitor.cpp b/library/cpp/yson/node/node_visitor.cpp
index 98b7c949d87..899fbfa02aa 100644
--- a/library/cpp/yson/node/node_visitor.cpp
+++ b/library/cpp/yson/node/node_visitor.cpp
@@ -1,38 +1,38 @@
 #include "node_visitor.h"
 
-#include <util/generic/algorithm.h> 
+#include <util/generic/algorithm.h>
 #include <util/string/printf.h>
 
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace { 
- 
-template <typename Fun> 
-void Iterate(const TNode::TMapType& nodeMap, bool sortByKey, Fun action) 
-{ 
-    if (sortByKey) { 
-        TVector<TNode::TMapType::const_iterator> iterators; 
-        for (auto it = nodeMap.begin(); it != nodeMap.end(); ++it) { 
-            iterators.push_back(it); 
-        } 
-        SortBy(iterators, [](TNode::TMapType::const_iterator it) { return it->first; }); 
-        for (const auto& it : iterators) { 
-            action(*it); 
-        } 
-    } else { 
-        ForEach(nodeMap.begin(), nodeMap.end(), action); 
-    } 
-} 
- 
-} // namespace 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+namespace {
+
+template <typename Fun>
+void Iterate(const TNode::TMapType& nodeMap, bool sortByKey, Fun action)
+{
+    if (sortByKey) {
+        TVector<TNode::TMapType::const_iterator> iterators;
+        for (auto it = nodeMap.begin(); it != nodeMap.end(); ++it) {
+            iterators.push_back(it);
+        }
+        SortBy(iterators, [](TNode::TMapType::const_iterator it) { return it->first; });
+        for (const auto& it : iterators) {
+            action(*it);
+        }
+    } else {
+        ForEach(nodeMap.begin(), nodeMap.end(), action);
+    }
+}
+
+} // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+
 TNodeVisitor::TNodeVisitor(NYson::IYsonConsumer* consumer, bool sortMapKeys)
     : Consumer_(consumer)
-    , SortMapKeys_(sortMapKeys) 
+    , SortMapKeys_(sortMapKeys)
 { }
 
 void TNodeVisitor::Visit(const TNode& node)
@@ -44,14 +44,14 @@ void TNodeVisitor::VisitAny(const TNode& node)
 {
     if (node.HasAttributes()) {
         Consumer_->OnBeginAttributes();
-        Iterate(node.GetAttributes().AsMap(), SortMapKeys_, [&](const std::pair<TString, TNode>& item) { 
+        Iterate(node.GetAttributes().AsMap(), SortMapKeys_, [&](const std::pair<TString, TNode>& item) {
             Consumer_->OnKeyedItem(item.first);
             if (item.second.IsUndefined()) {
-                ythrow TNode::TTypeError() << "unable to visit attribute value of type " 
-                    << TNode::EType::Undefined << "; attribute name: `" << item.first << '\'' ; 
+                ythrow TNode::TTypeError() << "unable to visit attribute value of type "
+                    << TNode::EType::Undefined << "; attribute name: `" << item.first << '\'' ;
             }
             VisitAny(item.second);
-        }); 
+        });
         Consumer_->OnEndAttributes();
     }
 
@@ -81,7 +81,7 @@ void TNodeVisitor::VisitAny(const TNode& node)
             VisitEntity();
             break;
         case TNode::Undefined:
-            ythrow TNode::TTypeError() << "unable to visit TNode of type " << node.GetType(); 
+            ythrow TNode::TTypeError() << "unable to visit TNode of type " << node.GetType();
         default:
             Y_FAIL("Unexpected type: %d", node.GetType());
     }
@@ -119,8 +119,8 @@ void TNodeVisitor::VisitList(const TNode::TListType& nodeList)
     for (const auto& item : nodeList) {
         Consumer_->OnListItem();
         if (item.IsUndefined()) {
-            ythrow TNode::TTypeError() << "unable to visit list node child of type " 
-                << TNode::EType::Undefined << "; list index: " << index; 
+            ythrow TNode::TTypeError() << "unable to visit list node child of type "
+                << TNode::EType::Undefined << "; list index: " << index;
         }
         VisitAny(item);
         ++index;
@@ -131,14 +131,14 @@ void TNodeVisitor::VisitList(const TNode::TListType& nodeList)
 void TNodeVisitor::VisitMap(const TNode::TMapType& nodeMap)
 {
     Consumer_->OnBeginMap();
-    Iterate(nodeMap, SortMapKeys_, [&](const std::pair<TString, TNode>& item) { 
+    Iterate(nodeMap, SortMapKeys_, [&](const std::pair<TString, TNode>& item) {
         Consumer_->OnKeyedItem(item.first);
         if (item.second.IsUndefined()) {
-            ythrow TNode::TTypeError() << "unable to visit map node child of type " 
-                << TNode::EType::Undefined << "; map key: `" << item.first << '\'' ; 
+            ythrow TNode::TTypeError() << "unable to visit map node child of type "
+                << TNode::EType::Undefined << "; map key: `" << item.first << '\'' ;
         }
         VisitAny(item.second);
-    }); 
+    });
     Consumer_->OnEndMap();
 }
 
diff --git a/library/cpp/yson/node/node_visitor.h b/library/cpp/yson/node/node_visitor.h
index 6dd4b8a5b46..db258323092 100644
--- a/library/cpp/yson/node/node_visitor.h
+++ b/library/cpp/yson/node/node_visitor.h
@@ -19,7 +19,7 @@ public:
 
 private:
     NYson::IYsonConsumer* Consumer_;
-    bool SortMapKeys_; 
+    bool SortMapKeys_;
 
 private:
     void VisitAny(const TNode& node);
diff --git a/library/cpp/yson/node/serialize.cpp b/library/cpp/yson/node/serialize.cpp
index f65c599186c..aeb467622bd 100644
--- a/library/cpp/yson/node/serialize.cpp
+++ b/library/cpp/yson/node/serialize.cpp
@@ -1,101 +1,101 @@
-#include "serialize.h" 
- 
+#include "serialize.h"
+
 #include "node_visitor.h"
- 
+
 #include <library/cpp/yson/consumer.h>
- 
-namespace NYT { 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
 void Serialize(const TString& value, NYson::IYsonConsumer* consumer)
-{ 
-    consumer->OnStringScalar(value); 
-} 
- 
+{
+    consumer->OnStringScalar(value);
+}
+
 void Serialize(const TStringBuf& value, NYson::IYsonConsumer* consumer)
-{ 
-    consumer->OnStringScalar(value); 
-} 
- 
+{
+    consumer->OnStringScalar(value);
+}
+
 void Serialize(const char* value, NYson::IYsonConsumer* consumer)
-{ 
-    consumer->OnStringScalar(value); 
-} 
- 
-void Deserialize(TString& value, const TNode& node) 
-{ 
-    value = node.AsString(); 
-} 
- 
-#define SERIALIZE_SIGNED(type) \ 
+{
+    consumer->OnStringScalar(value);
+}
+
+void Deserialize(TString& value, const TNode& node)
+{
+    value = node.AsString();
+}
+
+#define SERIALIZE_SIGNED(type) \
 void Serialize(type value, NYson::IYsonConsumer* consumer) \
-{ \ 
-    consumer->OnInt64Scalar(static_cast<i64>(value)); \ 
-} 
- 
-#define SERIALIZE_UNSIGNED(type) \ 
+{ \
+    consumer->OnInt64Scalar(static_cast<i64>(value)); \
+}
+
+#define SERIALIZE_UNSIGNED(type) \
 void Serialize(type value, NYson::IYsonConsumer* consumer) \
-{ \ 
-    consumer->OnUint64Scalar(static_cast<ui64>(value)); \ 
-} 
- 
-SERIALIZE_SIGNED(signed char); 
-SERIALIZE_SIGNED(short); 
-SERIALIZE_SIGNED(int); 
-SERIALIZE_SIGNED(long); 
-SERIALIZE_SIGNED(long long); 
- 
-SERIALIZE_UNSIGNED(unsigned char); 
-SERIALIZE_UNSIGNED(unsigned short); 
-SERIALIZE_UNSIGNED(unsigned int); 
-SERIALIZE_UNSIGNED(unsigned long); 
-SERIALIZE_UNSIGNED(unsigned long long); 
- 
-#undef SERIALIZE_SIGNED 
-#undef SERIALIZE_UNSIGNED 
- 
-void Deserialize(i64& value, const TNode& node) 
-{ 
-    value = node.AsInt64(); 
-} 
- 
-void Deserialize(ui64& value, const TNode& node) 
-{ 
-    value = node.AsUint64(); 
-} 
- 
+{ \
+    consumer->OnUint64Scalar(static_cast<ui64>(value)); \
+}
+
+SERIALIZE_SIGNED(signed char);
+SERIALIZE_SIGNED(short);
+SERIALIZE_SIGNED(int);
+SERIALIZE_SIGNED(long);
+SERIALIZE_SIGNED(long long);
+
+SERIALIZE_UNSIGNED(unsigned char);
+SERIALIZE_UNSIGNED(unsigned short);
+SERIALIZE_UNSIGNED(unsigned int);
+SERIALIZE_UNSIGNED(unsigned long);
+SERIALIZE_UNSIGNED(unsigned long long);
+
+#undef SERIALIZE_SIGNED
+#undef SERIALIZE_UNSIGNED
+
+void Deserialize(i64& value, const TNode& node)
+{
+    value = node.AsInt64();
+}
+
+void Deserialize(ui64& value, const TNode& node)
+{
+    value = node.AsUint64();
+}
+
 void Serialize(double value, NYson::IYsonConsumer* consumer)
-{ 
-    consumer->OnDoubleScalar(value); 
-} 
- 
-void Deserialize(double& value, const TNode& node) 
-{ 
-    value = node.AsDouble(); 
-} 
- 
+{
+    consumer->OnDoubleScalar(value);
+}
+
+void Deserialize(double& value, const TNode& node)
+{
+    value = node.AsDouble();
+}
+
 void Serialize(bool value, NYson::IYsonConsumer* consumer)
-{ 
-    consumer->OnBooleanScalar(value); 
-} 
- 
-void Deserialize(bool& value, const TNode& node) 
-{ 
-    value = node.AsBool(); 
-} 
- 
+{
+    consumer->OnBooleanScalar(value);
+}
+
+void Deserialize(bool& value, const TNode& node)
+{
+    value = node.AsBool();
+}
+
 void Serialize(const TNode& node, NYson::IYsonConsumer* consumer)
-{ 
-    TNodeVisitor visitor(consumer); 
-    visitor.Visit(node); 
-} 
- 
-void Deserialize(TNode& value, const TNode& node) 
-{ 
-    value = node; 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-} // namespace NYT 
+{
+    TNodeVisitor visitor(consumer);
+    visitor.Visit(node);
+}
+
+void Deserialize(TNode& value, const TNode& node)
+{
+    value = node;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yson/node/serialize.h b/library/cpp/yson/node/serialize.h
index 5fc72a0482b..99b598a44c3 100644
--- a/library/cpp/yson/node/serialize.h
+++ b/library/cpp/yson/node/serialize.h
@@ -1,45 +1,45 @@
-#pragma once 
- 
-#include "node.h" 
- 
+#pragma once
+
+#include "node.h"
+
 namespace NYT {
 
 namespace NYson {
 struct IYsonConsumer;
 } // namespace NYson
 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+////////////////////////////////////////////////////////////////////////////////
+
 void Serialize(const TString& value, NYson::IYsonConsumer* consumer);
 void Serialize(const TStringBuf& value, NYson::IYsonConsumer* consumer);
 void Serialize(const char* value, NYson::IYsonConsumer* consumer);
-void Deserialize(TString& value, const TNode& node); 
- 
+void Deserialize(TString& value, const TNode& node);
+
 void Serialize(signed char value, NYson::IYsonConsumer* consumer);
 void Serialize(short value, NYson::IYsonConsumer* consumer);
 void Serialize(int value, NYson::IYsonConsumer* consumer);
 void Serialize(long value, NYson::IYsonConsumer* consumer);
 void Serialize(long long value, NYson::IYsonConsumer* consumer);
-void Deserialize(i64& value, const TNode& node); 
- 
+void Deserialize(i64& value, const TNode& node);
+
 void Serialize(unsigned char value, NYson::IYsonConsumer* consumer);
 void Serialize(unsigned short value, NYson::IYsonConsumer* consumer);
 void Serialize(unsigned int value, NYson::IYsonConsumer* consumer);
 void Serialize(unsigned long value, NYson::IYsonConsumer* consumer);
 void Serialize(unsigned long long value, NYson::IYsonConsumer* consumer);
-void Deserialize(ui64& value, const TNode& node); 
- 
+void Deserialize(ui64& value, const TNode& node);
+
 void Serialize(double value, NYson::IYsonConsumer* consumer);
-void Deserialize(double& value, const TNode& node); 
- 
+void Deserialize(double& value, const TNode& node);
+
 void Serialize(bool value, NYson::IYsonConsumer* consumer);
-void Deserialize(bool& value, const TNode& node); 
- 
+void Deserialize(bool& value, const TNode& node);
+
 void Serialize(const TNode& node, NYson::IYsonConsumer* consumer);
-void Deserialize(TNode& value, const TNode& node); 
- 
+void Deserialize(TNode& value, const TNode& node);
+
 void Serialize(const THashMap<TString, TString>& renameColumns, NYson::IYsonConsumer* consumer);
 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-} // namespace NYT 
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yson/node/ya.make b/library/cpp/yson/node/ya.make
index 7b96a1e634a..a082b293c46 100644
--- a/library/cpp/yson/node/ya.make
+++ b/library/cpp/yson/node/ya.make
@@ -17,7 +17,7 @@ SRCS(
     node_io.cpp
     node_builder.cpp
     node_visitor.cpp
-    serialize.cpp 
+    serialize.cpp
 )
 
 END()
diff --git a/library/cpp/yson/parser_detail.h b/library/cpp/yson/parser_detail.h
index 806212e440d..44223caf125 100644
--- a/library/cpp/yson/parser_detail.h
+++ b/library/cpp/yson/parser_detail.h
@@ -209,9 +209,9 @@ namespace NYson {
                     ch = TBase::template SkipSpaceAndGetChar<AllowFinish>();
                     if (ch == KeyValueSeparatorSymbol) {
                         TBase::Advance(1);
-                    } else { 
+                    } else {
                         ythrow TYsonException() << "Expected '" << KeyValueSeparatorSymbol << "' but '" << ch << "' found";
-                    } 
+                    }
                     ParseNode<AllowFinish>();
                     ch = TBase::template SkipSpaceAndGetChar<AllowFinish>();
                     if (ch == KeyedItemSeparatorSymbol) {
diff --git a/library/cpp/yson/writer.cpp b/library/cpp/yson/writer.cpp
index 104a338f634..054459f9f5f 100644
--- a/library/cpp/yson/writer.cpp
+++ b/library/cpp/yson/writer.cpp
@@ -8,8 +8,8 @@
 
 #include <util/string/cast.h>
 
-#include <cmath> 
- 
+#include <cmath>
+
 namespace NYson {
     ////////////////////////////////////////////////////////////////////////////////
 
@@ -117,7 +117,7 @@ namespace NYson {
             static const TStringBuf nanLiteral = "%nan";
             static const TStringBuf infLiteral = "%inf";
             static const TStringBuf negativeInfLiteral = "%-inf";
- 
+
             TStringBuf str;
             if (std::isnan(value)) {
                 str = nanLiteral;
@@ -128,11 +128,11 @@ namespace NYson {
             }
             return TString(str.data(), str.size());
         }
- 
-    } 
+
+    }
 
     ////////////////////////////////////////////////////////////////////////////////
- 
+
     TYsonWriter::TYsonWriter(
         IOutputStream* stream,
         EYsonFormat format,
diff --git a/library/cpp/yt/memory/new-inl.h b/library/cpp/yt/memory/new-inl.h
index ce00d338f52..0a848185167 100644
--- a/library/cpp/yt/memory/new-inl.h
+++ b/library/cpp/yt/memory/new-inl.h
@@ -227,16 +227,16 @@ Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
     size_t extraSpaceSize,
     As&&... args)
 {
-    auto totalSize = NYT::NDetail::TConstructHelper<T>::Size + extraSpaceSize; 
+    auto totalSize = NYT::NDetail::TConstructHelper<T>::Size + extraSpaceSize;
     void* ptr = nullptr;
 
-    if (NYT::NDetail::TConstructHelper<T>::Alignment <= 16) { 
+    if (NYT::NDetail::TConstructHelper<T>::Alignment <= 16) {
         ptr = NYTAlloc::Allocate(totalSize);
     } else {
-        ptr = NYT::NDetail::AllignedMalloc(totalSize, NYT::NDetail::TConstructHelper<T>::Alignment); 
+        ptr = NYT::NDetail::AllignedMalloc(totalSize, NYT::NDetail::TConstructHelper<T>::Alignment);
     }
 
-    return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...); 
+    return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
 }
 
 template <class T, class... As, class>
@@ -245,12 +245,12 @@ Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
     size_t extraSpaceSize,
     As&&... args)
 {
-    auto totalSize = NYT::NDetail::TConstructHelper<T>::Size + extraSpaceSize; 
+    auto totalSize = NYT::NDetail::TConstructHelper<T>::Size + extraSpaceSize;
     auto* ptr = allocator->Allocate(totalSize);
     if (!ptr) {
         return nullptr;
     }
-    return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...); 
+    return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/misc/enum-inl.h b/library/cpp/yt/misc/enum-inl.h
index 0941e1fb634..59ef7047753 100644
--- a/library/cpp/yt/misc/enum-inl.h
+++ b/library/cpp/yt/misc/enum-inl.h
@@ -8,7 +8,7 @@
 #include <util/string/printf.h>
 #include <util/string/cast.h>
 
-#include <algorithm> 
+#include <algorithm>
 #include <stdexcept>
 
 namespace NYT {
@@ -36,25 +36,25 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace NDetail { 
- 
-template <typename TValues> 
-static constexpr bool AreValuesDistinct(const TValues& values) 
-{ 
-    for (int i = 0; i < static_cast<int>(values.size()); ++i) { 
-        for (int j = i + 1; j < static_cast<int>(values.size()); ++j) { 
-            if (values[i] == values[j]) { 
-                return false; 
-            } 
-        } 
-    } 
-    return true; 
-} 
- 
-} // namespace NDetail 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+namespace NDetail {
+
+template <typename TValues>
+static constexpr bool AreValuesDistinct(const TValues& values)
+{
+    for (int i = 0; i < static_cast<int>(values.size()); ++i) {
+        for (int j = i + 1; j < static_cast<int>(values.size()); ++j) {
+            if (values[i] == values[j]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
 #define ENUM__BEGIN_TRAITS(name, underlyingType, isBit, isStringSerializable, seq) \
     struct TEnumTraitsImpl_##name \
     { \
@@ -64,13 +64,13 @@ static constexpr bool AreValuesDistinct(const TValues& values)
         [[maybe_unused]] static constexpr bool IsStringSerializableEnum = isStringSerializable; \
         [[maybe_unused]] static constexpr int DomainSize = PP_COUNT(seq); \
         \
-        static constexpr std::array<TStringBuf, DomainSize> Names{{ \ 
-            PP_FOR_EACH(ENUM__GET_DOMAIN_NAMES_ITEM, seq) \ 
-        }}; \ 
-        static constexpr std::array<TType, DomainSize> Values{{ \ 
-            PP_FOR_EACH(ENUM__GET_DOMAIN_VALUES_ITEM, seq) \ 
-        }}; \ 
-        \ 
+        static constexpr std::array<TStringBuf, DomainSize> Names{{ \
+            PP_FOR_EACH(ENUM__GET_DOMAIN_NAMES_ITEM, seq) \
+        }}; \
+        static constexpr std::array<TType, DomainSize> Values{{ \
+            PP_FOR_EACH(ENUM__GET_DOMAIN_VALUES_ITEM, seq) \
+        }}; \
+        \
         static TStringBuf GetTypeName() \
         { \
             static constexpr TStringBuf typeName = PP_STRINGIZE(name); \
@@ -79,33 +79,33 @@ static constexpr bool AreValuesDistinct(const TValues& values)
         \
         static const TStringBuf* FindLiteralByValue(TType value) \
         { \
-            for (int i = 0; i < DomainSize; ++i) { \ 
-                if (Values[i] == value) { \ 
-                    return &Names[i]; \ 
-                } \ 
-            } \ 
+            for (int i = 0; i < DomainSize; ++i) { \
+                if (Values[i] == value) { \
+                    return &Names[i]; \
+                } \
+            } \
             return nullptr; \
         } \
         \
         static bool FindValueByLiteral(TStringBuf literal, TType* result) \
         { \
-            for (int i = 0; i < DomainSize; ++i) { \ 
-                if (Names[i] == literal) { \ 
-                    *result = Values[i]; \ 
-                    return true; \ 
-                } \ 
-            } \ 
+            for (int i = 0; i < DomainSize; ++i) { \
+                if (Names[i] == literal) { \
+                    *result = Values[i]; \
+                    return true; \
+                } \
+            } \
             return false; \
         } \
         \
         static const std::array<TStringBuf, DomainSize>& GetDomainNames() \
         { \
-            return Names; \ 
+            return Names; \
         } \
         \
         static const std::array<TType, DomainSize>& GetDomainValues() \
         { \
-            return Values; \ 
+            return Values; \
         } \
         \
         static TType FromString(TStringBuf str) \
@@ -145,34 +145,34 @@ static constexpr bool AreValuesDistinct(const TValues& values)
 #define ENUM__GET_DOMAIN_NAMES_ITEM_ATOMIC(item) \
     TStringBuf(PP_STRINGIZE(item)),
 
-#define ENUM__DECOMPOSE \ 
+#define ENUM__DECOMPOSE \
     static std::vector<TType> Decompose(TType value) \
     { \
         std::vector<TType> result; \
-        for (int i = 0; i < DomainSize; ++i) { \ 
-            if (static_cast<TUnderlying>(value) & static_cast<TUnderlying>(Values[i])) { \ 
-                result.push_back(Values[i]); \ 
-            } \ 
-        } \ 
+        for (int i = 0; i < DomainSize; ++i) { \
+            if (static_cast<TUnderlying>(value) & static_cast<TUnderlying>(Values[i])) { \
+                result.push_back(Values[i]); \
+            } \
+        } \
         return result; \
     }
 
-#define ENUM__MINMAX \ 
-    static constexpr TType GetMinValue() \ 
+#define ENUM__MINMAX \
+    static constexpr TType GetMinValue() \
     { \
-        static_assert(!Values.empty()); \ 
-        return *std::min_element(std::begin(Values), std::end(Values)); \ 
+        static_assert(!Values.empty()); \
+        return *std::min_element(std::begin(Values), std::end(Values)); \
     } \
     \
-    static constexpr TType GetMaxValue() \ 
+    static constexpr TType GetMaxValue() \
     { \
-        static_assert(!Values.empty()); \ 
-        return *std::max_element(std::begin(Values), std::end(Values)); \ 
+        static_assert(!Values.empty()); \
+        return *std::max_element(std::begin(Values), std::end(Values)); \
     }
 
-#define ENUM__VALIDATE_UNIQUE(name) \ 
-    static_assert(::NYT::NDetail::AreValuesDistinct(Values), \ 
-        "Enumeration " #name " contains duplicate values"); 
+#define ENUM__VALIDATE_UNIQUE(name) \
+    static_assert(::NYT::NDetail::AreValuesDistinct(Values), \
+        "Enumeration " #name " contains duplicate values");
 
 #define ENUM__END_TRAITS(name) \
     }; \
@@ -181,7 +181,7 @@ static constexpr bool AreValuesDistinct(const TValues& values)
     { \
         return TEnumTraitsImpl_##name(); \
     } \
-    \ 
+    \
     using ::ToString; \
     [[maybe_unused]] inline TString ToString(name value) \
     { \
diff --git a/library/cpp/yt/misc/enum.h b/library/cpp/yt/misc/enum.h
index 97c62cac934..894364aa43b 100644
--- a/library/cpp/yt/misc/enum.h
+++ b/library/cpp/yt/misc/enum.h
@@ -108,16 +108,16 @@ struct TEnumTraits<T, true>
 #define DEFINE_ENUM_WITH_UNDERLYING_TYPE(name, underlyingType, seq) \
     ENUM__CLASS(name, underlyingType, seq) \
     ENUM__BEGIN_TRAITS(name, underlyingType, false, false, seq) \
-    ENUM__MINMAX \ 
-    ENUM__VALIDATE_UNIQUE(name) \ 
-    ENUM__END_TRAITS(name) 
+    ENUM__MINMAX \
+    ENUM__VALIDATE_UNIQUE(name) \
+    ENUM__END_TRAITS(name)
 
 //! Defines a smart enumeration with a specific underlying type.
 //! Duplicate enumeration values are allowed.
 #define DEFINE_AMBIGUOUS_ENUM_WITH_UNDERLYING_TYPE(name, underlyingType, seq) \
     ENUM__CLASS(name, underlyingType, seq) \
     ENUM__BEGIN_TRAITS(name, underlyingType, false, false, seq) \
-    ENUM__MINMAX \ 
+    ENUM__MINMAX \
     ENUM__END_TRAITS(name)
 
 //! Defines a smart enumeration with the default |int| underlying type.
@@ -133,8 +133,8 @@ struct TEnumTraits<T, true>
 #define DEFINE_BIT_ENUM_WITH_UNDERLYING_TYPE(name, underlyingType, seq) \
     ENUM__CLASS(name, underlyingType, seq) \
     ENUM__BEGIN_TRAITS(name, underlyingType, true, false, seq) \
-    ENUM__DECOMPOSE \ 
-    ENUM__VALIDATE_UNIQUE(name) \ 
+    ENUM__DECOMPOSE \
+    ENUM__VALIDATE_UNIQUE(name) \
     ENUM__END_TRAITS(name) \
     ENUM__BITWISE_OPS(name)
 
@@ -148,7 +148,7 @@ struct TEnumTraits<T, true>
 #define DEFINE_AMBIGUOUS_BIT_ENUM_WITH_UNDERLYING_TYPE(name, underlyingType, seq) \
     ENUM__CLASS(name, underlyingType, seq) \
     ENUM__BEGIN_TRAITS(name, underlyingType, true, false, seq) \
-    ENUM__DECOMPOSE \ 
+    ENUM__DECOMPOSE \
     ENUM__END_TRAITS(name) \
     ENUM__BITWISE_OPS(name)
 
@@ -169,8 +169,8 @@ struct TEnumTraits<T, true>
 #define DEFINE_STRING_SERIALIZABLE_ENUM_WITH_UNDERLYING_TYPE(name, underlyingType, seq) \
     ENUM__CLASS(name, underlyingType, seq) \
     ENUM__BEGIN_TRAITS(name, underlyingType, false, true, seq) \
-    ENUM__MINMAX \ 
-    ENUM__VALIDATE_UNIQUE(name) \ 
+    ENUM__MINMAX \
+    ENUM__VALIDATE_UNIQUE(name) \
     ENUM__END_TRAITS(name) \
 
 //! Defines a smart enumeration with a specific underlying type and IsStringSerializable attribute.
@@ -178,7 +178,7 @@ struct TEnumTraits<T, true>
 #define DEFINE_AMBIGUOUS_STRING_SERIALIZABLE_ENUM_WITH_UNDERLYING_TYPE(name, underlyingType, seq) \
     ENUM__CLASS(name, underlyingType, seq) \
     ENUM__BEGIN_TRAITS(name, underlyingType, false, true, seq) \
-    ENUM__MINMAX \ 
+    ENUM__MINMAX \
     ENUM__END_TRAITS(name)
 
 //! Defines a smart enumeration with the default |int| underlying type and IsStringSerializable attribute.
diff --git a/library/cpp/yt/string/enum.cpp b/library/cpp/yt/string/enum.cpp
index aaff64f2df8..7cb8e5c6b6a 100644
--- a/library/cpp/yt/string/enum.cpp
+++ b/library/cpp/yt/string/enum.cpp
@@ -26,17 +26,17 @@ TString EncodeEnumValue(TStringBuf value)
 namespace NDetail {
 
 void ThrowMalformedEnumValueException(TStringBuf typeName, TStringBuf value)
-{ 
+{
     throw TSimpleException(Format("Error parsing %v value %Qv",
         typeName,
         value));
-} 
- 
+}
+
 void FormatUnknownEnumValue(TStringBuilderBase* builder, TStringBuf name, i64 value)
-{ 
-    builder->AppendFormat("%v(%v)", name, value); 
-} 
- 
+{
+    builder->AppendFormat("%v(%v)", name, value);
+}
+
 } // namespace NDetail
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/string/enum.h b/library/cpp/yt/string/enum.h
index 6490114bedf..10dc02610f7 100644
--- a/library/cpp/yt/string/enum.h
+++ b/library/cpp/yt/string/enum.h
@@ -5,7 +5,7 @@
 #include <library/cpp/yt/misc/enum.h>
 
 #include <optional>
- 
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -15,13 +15,13 @@ TString EncodeEnumValue(TStringBuf value);
 
 template <class T>
 T ParseEnum(TStringBuf value);
- 
-template <class T> 
+
+template <class T>
 void FormatEnum(TStringBuilderBase* builder, T value, bool lowerCase);
- 
+
 template <class T>
 TString FormatEnum(T value, typename TEnumTraits<T>::TType* = nullptr);
- 
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
diff --git a/library/cpp/yt/string/format-inl.h b/library/cpp/yt/string/format-inl.h
index ab08c58f553..5484d4a216c 100644
--- a/library/cpp/yt/string/format-inl.h
+++ b/library/cpp/yt/string/format-inl.h
@@ -4,7 +4,7 @@
 #include "format.h"
 #endif
 
-#include "enum.h" 
+#include "enum.h"
 #include "string.h"
 
 #include <library/cpp/yt/assert/assert.h>
@@ -180,12 +180,12 @@ struct TValueFormatter<TEnum, typename std::enable_if<TEnumTraits<TEnum>::IsEnum
                 lowercase = true;
             } else if (IsQuotationSpecSymbol(*current)) {
                 ++current;
-            } else { 
+            } else {
                 break;
-            } 
+            }
         }
 
-        FormatEnum(builder, value, lowercase); 
+        FormatEnum(builder, value, lowercase);
     }
 };
 
diff --git a/library/cpp/yt/string/string.cpp b/library/cpp/yt/string/string.cpp
index 1229359833e..7440ac3fdd1 100644
--- a/library/cpp/yt/string/string.cpp
+++ b/library/cpp/yt/string/string.cpp
@@ -1,5 +1,5 @@
 #include "string.h"
-#include "format.h" 
+#include "format.h"
 
 #include <library/cpp/yt/assert/assert.h>
 
diff --git a/library/cpp/yt/string/string.h b/library/cpp/yt/string/string.h
index c51b9ae4107..ae6c99caab0 100644
--- a/library/cpp/yt/string/string.h
+++ b/library/cpp/yt/string/string.h
@@ -8,8 +8,8 @@
 
 #include <util/generic/string.h>
 
-#include <util/string/strip.h> 
- 
+#include <util/string/strip.h>
+
 #include <vector>
 #include <set>
 #include <map>
diff --git a/library/cpp/yt/yson_string/string.cpp b/library/cpp/yt/yson_string/string.cpp
index c00aa98a501..99d45e86169 100644
--- a/library/cpp/yt/yson_string/string.cpp
+++ b/library/cpp/yt/yson_string/string.cpp
@@ -99,8 +99,8 @@ TYsonString::TYsonString(
     TStringBuf data,
     EYsonType type)
     : TYsonString(TYsonStringBuf(data, type))
-{ } 
- 
+{ }
+
 #ifdef TSTRING_IS_STD_STRING
 TYsonString::TYsonString(
     const TString& data,
@@ -120,7 +120,7 @@ TYsonString::TYsonString(
     Type_ = type;
 }
 #endif
- 
+
 TYsonString::TYsonString(
     const TSharedRef& data,
     EYsonType type)
@@ -134,22 +134,22 @@ TYsonString::TYsonString(
 TYsonString::operator bool() const
 {
     return !std::holds_alternative<TNullPayload>(Payload_);
-} 
- 
+}
+
 EYsonType TYsonString::GetType() const
-{ 
+{
     YT_VERIFY(*this);
     return Type_;
 }
 
 TStringBuf TYsonString::AsStringBuf() const
-{ 
+{
     YT_VERIFY(*this);
     return TStringBuf(Begin_, Begin_ + Size_);
-} 
- 
+}
+
 TString TYsonString::ToString() const
-{ 
+{
     return Visit(
         Payload_,
         [] (const TNullPayload&) -> TString {
@@ -161,13 +161,13 @@ TString TYsonString::ToString() const
         [] (const TString& payload) {
             return payload;
         });
-} 
- 
+}
+
 size_t TYsonString::ComputeHash() const
-{ 
+{
     return THash<TStringBuf>()(TStringBuf(Begin_, Begin_ + Size_));
-} 
- 
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 TString ToString(const TYsonString& yson)
@@ -175,11 +175,11 @@ TString ToString(const TYsonString& yson)
     return yson.ToString();
 }
 
-TString ToString(const TYsonStringBuf& yson) 
-{ 
+TString ToString(const TYsonStringBuf& yson)
+{
     return TString(yson.AsStringBuf());
-} 
- 
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT::NYson
diff --git a/library/cpp/yt/yson_string/string.h b/library/cpp/yt/yson_string/string.h
index b25223aa6c9..e13af37a6df 100644
--- a/library/cpp/yt/yson_string/string.h
+++ b/library/cpp/yt/yson_string/string.h
@@ -47,28 +47,28 @@ public:
     //! Returns type of YSON contained here. The instance must be non-null.
     EYsonType GetType() const;
 
-protected: 
+protected:
     TStringBuf Data_;
     EYsonType Type_;
-    bool Null_; 
-}; 
- 
+    bool Null_;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 
 //! An owning version of TYsonStringBuf.
 /*!
  *  Internally captures the data either via TString or a polymorphic ref-counted holder.
  */
-class TYsonString 
-{ 
-public: 
+class TYsonString
+{
+public:
     //! Constructs a null instance.
     TYsonString();
- 
+
     //! Constructs an instance from TYsonStringBuf.
     //! Copies the data into a ref-counted payload.
-    explicit TYsonString(const TYsonStringBuf& ysonStringBuf); 
- 
+    explicit TYsonString(const TYsonStringBuf& ysonStringBuf);
+
     //! Constructs an instance from TStringBuf.
     //! Copies the data into a ref-counted payload.
     explicit TYsonString(
@@ -108,7 +108,7 @@ private:
     { };
 
     using THolder = TRefCountedPtr;
- 
+
     std::variant<TNullPayload, THolder, TString> Payload_;
 
     const char* Begin_;
@@ -119,17 +119,17 @@ private:
 ////////////////////////////////////////////////////////////////////////////////
 
 bool operator == (const TYsonString& lhs, const TYsonString& rhs);
-bool operator == (const TYsonString& lhs, const TYsonStringBuf& rhs); 
-bool operator == (const TYsonStringBuf& lhs, const TYsonString& rhs); 
-bool operator == (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs); 
- 
+bool operator == (const TYsonString& lhs, const TYsonStringBuf& rhs);
+bool operator == (const TYsonStringBuf& lhs, const TYsonString& rhs);
+bool operator == (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs);
+
 bool operator != (const TYsonString& lhs, const TYsonString& rhs);
-bool operator != (const TYsonString& lhs, const TYsonStringBuf& rhs); 
-bool operator != (const TYsonStringBuf& lhs, const TYsonString& rhs); 
-bool operator != (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs); 
+bool operator != (const TYsonString& lhs, const TYsonStringBuf& rhs);
+bool operator != (const TYsonStringBuf& lhs, const TYsonString& rhs);
+bool operator != (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs);
 
 TString ToString(const TYsonString& yson);
-TString ToString(const TYsonStringBuf& yson); 
+TString ToString(const TYsonStringBuf& yson);
 
 ////////////////////////////////////////////////////////////////////////////////