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

5 files changed, 511 insertions, 511 deletions

diff --git a/library/cpp/yson/node/node.cpp b/library/cpp/yson/node/node.cpp
index 458b6438b63..b39e0707187 100644
--- a/library/cpp/yson/node/node.cpp
+++ b/library/cpp/yson/node/node.cpp
@@ -438,24 +438,24 @@ TNode& TNode::operator[](size_t index)
     return std::get<TListType>(Value_)[index];
 }
 
-const TNode& TNode::At(size_t index) const { 
-    CheckType(List); 
+const TNode& TNode::At(size_t index) const {
+    CheckType(List);
     const auto& list = std::get<TListType>(Value_);
-    if (index >= list.size()) { 
+    if (index >= list.size()) {
         ythrow TLookupError() << "List out-of-range: requested index=" << index << ", but size=" << list.size();
-    } 
-    return list[index]; 
-} 
- 
-TNode& TNode::At(size_t index) { 
-    CheckType(List); 
+    }
+    return list[index];
+}
+
+TNode& TNode::At(size_t index) {
+    CheckType(List);
     auto& list = std::get<TListType>(Value_);
-    if (index >= list.size()) { 
+    if (index >= list.size()) {
         ythrow TLookupError() << "List out-of-range: requested index=" << index << ", but size=" << list.size();
-    } 
-    return list[index]; 
-} 
- 
+    }
+    return list[index];
+}
+
 TNode& TNode::Add() &
 {
     AssureList();
@@ -551,233 +551,233 @@ const TNode& TNode::At(const TStringBuf key) const {
     }
 }
 
-TNode& TNode::At(const TStringBuf key) { 
-    CheckType(Map); 
+TNode& TNode::At(const TStringBuf key) {
+    CheckType(Map);
     auto& map = std::get<TMapType>(Value_);
-    TMapType::iterator i = map.find(key); 
-    if (i == map.end()) { 
+    TMapType::iterator i = map.find(key);
+    if (i == map.end()) {
         ythrow TLookupError() << "Cannot find key " << key;
-    } else { 
-        return i->second; 
-    } 
-} 
- 
-const TString& TNode::ChildAsString(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.AsString(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-i64 TNode::ChildAsInt64(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.AsInt64(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-ui64 TNode::ChildAsUint64(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.AsUint64(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-double TNode::ChildAsDouble(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.AsDouble(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-bool TNode::ChildAsBool(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.AsBool(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-const TNode::TListType& TNode::ChildAsList(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.AsList(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-const TNode::TMapType& TNode::ChildAsMap(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.AsMap(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-TNode::TListType& TNode::ChildAsList(const TStringBuf key) { 
-    auto& node = At(key); 
-    try { 
-        return node.AsList(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-TNode::TMapType& TNode::ChildAsMap(const TStringBuf key) { 
-    auto& node = At(key); 
-    try { 
-        return node.AsMap(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-const TString& TNode::ChildAsString(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.AsString(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-i64 TNode::ChildAsInt64(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.AsInt64(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-ui64 TNode::ChildAsUint64(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.AsUint64(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-double TNode::ChildAsDouble(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.AsDouble(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-bool TNode::ChildAsBool(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.AsBool(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-const TNode::TListType& TNode::ChildAsList(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.AsList(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-const TNode::TMapType& TNode::ChildAsMap(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.AsMap(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-TNode::TListType& TNode::ChildAsList(size_t index) { 
-    auto& node = At(index); 
-    try { 
-        return node.AsList(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-TNode::TMapType& TNode::ChildAsMap(size_t index) { 
-    auto& node = At(index); 
-    try { 
-        return node.AsMap(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
+    } else {
+        return i->second;
+    }
+}
+
+const TString& TNode::ChildAsString(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.AsString();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+i64 TNode::ChildAsInt64(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.AsInt64();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+ui64 TNode::ChildAsUint64(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.AsUint64();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+double TNode::ChildAsDouble(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.AsDouble();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+bool TNode::ChildAsBool(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.AsBool();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+const TNode::TListType& TNode::ChildAsList(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.AsList();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+const TNode::TMapType& TNode::ChildAsMap(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.AsMap();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+TNode::TListType& TNode::ChildAsList(const TStringBuf key) {
+    auto& node = At(key);
+    try {
+        return node.AsList();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+TNode::TMapType& TNode::ChildAsMap(const TStringBuf key) {
+    auto& node = At(key);
+    try {
+        return node.AsMap();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+const TString& TNode::ChildAsString(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.AsString();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+i64 TNode::ChildAsInt64(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.AsInt64();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+ui64 TNode::ChildAsUint64(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.AsUint64();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+double TNode::ChildAsDouble(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.AsDouble();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+bool TNode::ChildAsBool(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.AsBool();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+const TNode::TListType& TNode::ChildAsList(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.AsList();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+const TNode::TMapType& TNode::ChildAsMap(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.AsMap();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+TNode::TListType& TNode::ChildAsList(size_t index) {
+    auto& node = At(index);
+    try {
+        return node.AsList();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+TNode::TMapType& TNode::ChildAsMap(size_t index) {
+    auto& node = At(index);
+    try {
+        return node.AsMap();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
 bool TNode::HasAttributes() const
 {
     return Attributes_ && !Attributes_->Empty();
diff --git a/library/cpp/yson/node/node.h b/library/cpp/yson/node/node.h
index fe3eeceea87..5f90f95df07 100644
--- a/library/cpp/yson/node/node.h
+++ b/library/cpp/yson/node/node.h
@@ -7,11 +7,11 @@
 #include <util/generic/vector.h>
 #include <util/generic/yexception.h>
 #include <util/generic/ylimits.h>
-#include <util/string/cast.h> 
+#include <util/string/cast.h>
 
-#include <cmath> 
+#include <cmath>
 #include <variant>
- 
+
 class IInputStream;
 class IOutputStream;
 
@@ -160,16 +160,16 @@ public:
     TMapType& UncheckedAsMap() noexcept;
 
     // integer types cast
-    // makes overflow checks 
+    // makes overflow checks
     template<typename T>
-    T IntCast() const; 
- 
+    T IntCast() const;
+
     // integers <-> double <-> string
-    // makes overflow checks 
-    template<typename T> 
-    T ConvertTo() const; 
- 
-    template<typename T> 
+    // makes overflow checks
+    template<typename T>
+    T ConvertTo() const;
+
+    template<typename T>
     T& As();
 
     template<typename T>
@@ -183,8 +183,8 @@ public:
 
     const TNode& operator[](size_t index) const;
     TNode& operator[](size_t index);
-    const TNode& At(size_t index) const; 
-    TNode& At(size_t index); 
+    const TNode& At(size_t index) const;
+    TNode& At(size_t index);
 
     TNode& Add() &;
     TNode Add() &&;
@@ -203,53 +203,53 @@ public:
     const TNode& operator[](const TStringBuf key) const;
     TNode& operator[](const TStringBuf key);
     const TNode& At(const TStringBuf key) const;
-    TNode& At(const TStringBuf key); 
-
-    // map getters 
-    // works the same way like simple getters 
-    const TString& ChildAsString(const TStringBuf key) const; 
-    i64 ChildAsInt64(const TStringBuf key) const; 
-    ui64 ChildAsUint64(const TStringBuf key) const; 
-    double ChildAsDouble(const TStringBuf key) const; 
-    bool ChildAsBool(const TStringBuf key) const; 
-    const TListType& ChildAsList(const TStringBuf key) const; 
-    const TMapType& ChildAsMap(const TStringBuf key) const; 
-    TListType& ChildAsList(const TStringBuf key); 
-    TMapType& ChildAsMap(const TStringBuf key); 
- 
-    template<typename T> 
-    T ChildIntCast(const TStringBuf key) const; 
- 
-    template<typename T> 
-    T ChildConvertTo(const TStringBuf key) const; 
- 
+    TNode& At(const TStringBuf key);
+
+    // map getters
+    // works the same way like simple getters
+    const TString& ChildAsString(const TStringBuf key) const;
+    i64 ChildAsInt64(const TStringBuf key) const;
+    ui64 ChildAsUint64(const TStringBuf key) const;
+    double ChildAsDouble(const TStringBuf key) const;
+    bool ChildAsBool(const TStringBuf key) const;
+    const TListType& ChildAsList(const TStringBuf key) const;
+    const TMapType& ChildAsMap(const TStringBuf key) const;
+    TListType& ChildAsList(const TStringBuf key);
+    TMapType& ChildAsMap(const TStringBuf key);
+
+    template<typename T>
+    T ChildIntCast(const TStringBuf key) const;
+
+    template<typename T>
+    T ChildConvertTo(const TStringBuf key) const;
+
     template<typename T>
     const T& ChildAs(const TStringBuf key) const;
 
     template<typename T>
     T& ChildAs(const TStringBuf key);
 
-    // list getters 
-    // works the same way like simple getters 
-    const TString& ChildAsString(size_t index) const; 
-    i64 ChildAsInt64(size_t index) const; 
-    ui64 ChildAsUint64(size_t index) const; 
-    double ChildAsDouble(size_t index) const; 
-    bool ChildAsBool(size_t index) const; 
-    const TListType& ChildAsList(size_t index) const; 
-    const TMapType& ChildAsMap(size_t index) const; 
-    TListType& ChildAsList(size_t index); 
-    TMapType& ChildAsMap(size_t index); 
- 
-    template<typename T> 
-    T ChildIntCast(size_t index) const; 
- 
-    template<typename T> 
-    T ChildConvertTo(size_t index) const; 
- 
+    // list getters
+    // works the same way like simple getters
+    const TString& ChildAsString(size_t index) const;
+    i64 ChildAsInt64(size_t index) const;
+    ui64 ChildAsUint64(size_t index) const;
+    double ChildAsDouble(size_t index) const;
+    bool ChildAsBool(size_t index) const;
+    const TListType& ChildAsList(size_t index) const;
+    const TMapType& ChildAsMap(size_t index) const;
+    TListType& ChildAsList(size_t index);
+    TMapType& ChildAsMap(size_t index);
+
+    template<typename T>
+    T ChildIntCast(size_t index) const;
+
+    template<typename T>
+    T ChildConvertTo(size_t index) const;
+
     template<typename T>
     const T& ChildAs(size_t index) const;
- 
+
     template<typename T>
     T& ChildAs(size_t index);
 
@@ -295,7 +295,7 @@ inline bool TNode::IsArithmetic() const {
 }
 
 template<typename T>
-inline T TNode::IntCast() const { 
+inline T TNode::IntCast() const {
     if constexpr (std::is_integral<T>::value) {
         try {
             switch (GetType()) {
@@ -305,17 +305,17 @@ inline T TNode::IntCast() const {
                     return SafeIntegerCast<T>(AsInt64());
                 default:
                     ythrow TTypeError() << "IntCast() called for type " << GetType();
-            } 
+            }
         } catch(TBadCastException& exc) {
             ythrow TTypeError() << "TBadCastException during IntCast(): " << exc.what();
         }
     } else {
         static_assert(sizeof(T) != sizeof(T), "implemented only for std::is_integral types");
-    } 
-} 
- 
-template<typename T> 
-inline T TNode::ConvertTo() const { 
+    }
+}
+
+template<typename T>
+inline T TNode::ConvertTo() const {
     if constexpr (std::is_integral<T>::value) {
         switch (GetType()) {
             case NYT::TNode::String:
@@ -339,125 +339,125 @@ inline T TNode::ConvertTo() const {
     } else {
         static_assert(sizeof(T) != sizeof(T), "should have template specialization");
     }
-} 
- 
-template<> 
-inline TString TNode::ConvertTo<TString>() const { 
-    switch (GetType()) { 
+}
+
+template<>
+inline TString TNode::ConvertTo<TString>() const {
+    switch (GetType()) {
         case NYT::TNode::String:
-            return AsString(); 
+            return AsString();
         case NYT::TNode::Int64:
-            return ::ToString(AsInt64()); 
+            return ::ToString(AsInt64());
         case NYT::TNode::Uint64:
-            return ::ToString(AsUint64()); 
+            return ::ToString(AsUint64());
         case NYT::TNode::Double:
-            return ::ToString(AsDouble()); 
+            return ::ToString(AsDouble());
         case NYT::TNode::Bool:
-            return ::ToString(AsBool()); 
+            return ::ToString(AsBool());
         case NYT::TNode::List:
         case NYT::TNode::Map:
         case NYT::TNode::Null:
         case NYT::TNode::Undefined:
             ythrow TTypeError() << "ConvertTo<TString>() called for type " << GetType();
-    } 
+    }
     Y_UNREACHABLE();
-} 
- 
-template<> 
-inline double TNode::ConvertTo<double>() const { 
-    switch (GetType()) { 
+}
+
+template<>
+inline double TNode::ConvertTo<double>() const {
+    switch (GetType()) {
         case NYT::TNode::String:
-            return ::FromString(AsString()); 
+            return ::FromString(AsString());
         case NYT::TNode::Int64:
-            return AsInt64(); 
+            return AsInt64();
         case NYT::TNode::Uint64:
-            return AsUint64(); 
+            return AsUint64();
         case NYT::TNode::Double:
-            return AsDouble(); 
+            return AsDouble();
         case NYT::TNode::Bool:
-            return AsBool(); 
+            return AsBool();
         case NYT::TNode::List:
         case NYT::TNode::Map:
         case NYT::TNode::Null:
         case NYT::TNode::Undefined:
             ythrow TTypeError() << "ConvertTo<double>() called for type " << GetType();
-    } 
-} 
- 
-template<> 
-inline bool TNode::ConvertTo<bool>() const { 
-    switch (GetType()) { 
+    }
+}
+
+template<>
+inline bool TNode::ConvertTo<bool>() const {
+    switch (GetType()) {
         case NYT::TNode::String:
-            return ::FromString(AsString()); 
+            return ::FromString(AsString());
         case NYT::TNode::Int64:
-            return AsInt64(); 
+            return AsInt64();
         case NYT::TNode::Uint64:
-            return AsUint64(); 
+            return AsUint64();
         case NYT::TNode::Double:
-            return AsDouble(); 
+            return AsDouble();
         case NYT::TNode::Bool:
-            return AsBool(); 
+            return AsBool();
         case NYT::TNode::List:
         case NYT::TNode::Map:
         case NYT::TNode::Null:
         case NYT::TNode::Undefined:
             ythrow TTypeError() << "ConvertTo<bool>() called for type " << GetType();
-    } 
-} 
- 
-template<typename T> 
-inline T TNode::ChildIntCast(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.IntCast<T>(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-template<typename T> 
-inline T TNode::ChildIntCast(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.IntCast<T>(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-template<typename T> 
-inline T TNode::ChildConvertTo(const TStringBuf key) const { 
-    const auto& node = At(key); 
-    try { 
-        return node.ConvertTo<T>(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting key=" << key; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key; 
-    } 
-} 
- 
-template<typename T> 
-inline T TNode::ChildConvertTo(size_t index) const { 
-    const auto& node = At(index); 
-    try { 
-        return node.ConvertTo<T>(); 
-    } catch (TTypeError& e) { 
-        e << ", during getting index=" << index; 
-        throw e; 
-    } catch (...) { 
-        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index; 
-    } 
-} 
- 
-template<typename T> 
+    }
+}
+
+template<typename T>
+inline T TNode::ChildIntCast(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.IntCast<T>();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+template<typename T>
+inline T TNode::ChildIntCast(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.IntCast<T>();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+template<typename T>
+inline T TNode::ChildConvertTo(const TStringBuf key) const {
+    const auto& node = At(key);
+    try {
+        return node.ConvertTo<T>();
+    } catch (TTypeError& e) {
+        e << ", during getting key=" << key;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting key=" << key;
+    }
+}
+
+template<typename T>
+inline T TNode::ChildConvertTo(size_t index) const {
+    const auto& node = At(index);
+    try {
+        return node.ConvertTo<T>();
+    } catch (TTypeError& e) {
+        e << ", during getting index=" << index;
+        throw e;
+    } catch (...) {
+        ythrow TTypeError() << CurrentExceptionMessage() << ", during getting index=" << index;
+    }
+}
+
+template<typename T>
 inline const T& TNode::ChildAs(const TStringBuf key) const {
     const auto& node = At(key);
     try {
diff --git a/library/cpp/yson/node/node_io.cpp b/library/cpp/yson/node/node_io.cpp
index caaa3ac0ec2..294a7f7217f 100644
--- a/library/cpp/yson/node/node_io.cpp
+++ b/library/cpp/yson/node/node_io.cpp
@@ -14,7 +14,7 @@
 #include <util/stream/input.h>
 #include <util/stream/output.h>
 #include <util/stream/str.h>
-#include <util/stream/mem.h> 
+#include <util/stream/mem.h>
 
 namespace NYT {
 
@@ -84,7 +84,7 @@ static TNode CreateEmptyNodeByType(::NYson::EYsonType type)
 
 TNode NodeFromYsonString(const TStringBuf input, ::NYson::EYsonType type)
 {
-    TMemoryInput stream(input); 
+    TMemoryInput stream(input);
     return NodeFromYsonStream(&stream, type);
 }
 
@@ -126,9 +126,9 @@ void NodeToCanonicalYsonStream(const TNode& node, IOutputStream* output, NYson::
     visitor.Visit(node);
 }
 
-TNode NodeFromJsonString(const TStringBuf input) 
+TNode NodeFromJsonString(const TStringBuf input)
 {
-    TMemoryInput stream(input); 
+    TMemoryInput stream(input);
 
     TNode result;
 
diff --git a/library/cpp/yson/node/node_io.h b/library/cpp/yson/node/node_io.h
index c5d946fb8f5..2ad23b658f2 100644
--- a/library/cpp/yson/node/node_io.h
+++ b/library/cpp/yson/node/node_io.h
@@ -30,7 +30,7 @@ void NodeToYsonStream(const TNode& node, IOutputStream* output, ::NYson::EYsonFo
 void NodeToCanonicalYsonStream(const TNode& node, IOutputStream* output, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
 
 // Parse TNode from string in JSON format
-TNode NodeFromJsonString(const TStringBuf input); 
+TNode NodeFromJsonString(const TStringBuf input);
 
 // 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 6868953337d..448e99f5753 100644
--- a/library/cpp/yson/node/node_ut.cpp
+++ b/library/cpp/yson/node/node_ut.cpp
@@ -278,109 +278,109 @@ Y_UNIT_TEST_SUITE(YtNodeTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(node, nodeCopy);
     }
- 
+
     Y_UNIT_TEST(TestIntCast) {
-        TNode node = 1ull << 31; 
-        UNIT_ASSERT(node.IsUint64()); 
+        TNode node = 1ull << 31;
+        UNIT_ASSERT(node.IsUint64());
         UNIT_ASSERT_EXCEPTION(node.IntCast<i32>(), TNode::TTypeError);
         UNIT_ASSERT(node.IntCast<ui32>() == static_cast<ui32>(node.AsUint64()));
         UNIT_ASSERT(node.IntCast<i64>() == static_cast<i64>(node.AsUint64()));
-        UNIT_ASSERT(node.IntCast<ui64>() == node.AsUint64()); 
-
-        node = 1ull << 63; 
-        UNIT_ASSERT(node.IsUint64()); 
-        UNIT_ASSERT_EXCEPTION(node.IntCast<i64>(), TNode::TTypeError); 
-        UNIT_ASSERT(node.IntCast<ui64>() == node.AsUint64()); 
- 
-        node = 12345; 
-        UNIT_ASSERT(node.IsInt64()); 
+        UNIT_ASSERT(node.IntCast<ui64>() == node.AsUint64());
+
+        node = 1ull << 63;
+        UNIT_ASSERT(node.IsUint64());
+        UNIT_ASSERT_EXCEPTION(node.IntCast<i64>(), TNode::TTypeError);
+        UNIT_ASSERT(node.IntCast<ui64>() == node.AsUint64());
+
+        node = 12345;
+        UNIT_ASSERT(node.IsInt64());
         UNIT_ASSERT_EXCEPTION(node.IntCast<i8>(), TNode::TTypeError);
         UNIT_ASSERT_EXCEPTION(node.IntCast<ui8>(), TNode::TTypeError);
         UNIT_ASSERT(node.IntCast<i16>() == static_cast<i16>(node.AsInt64()));
         UNIT_ASSERT(node.IntCast<ui16>() == static_cast<ui16>(node.AsInt64()));
         UNIT_ASSERT(node.IntCast<i32>() == static_cast<i32>(node.AsInt64()));
         UNIT_ASSERT(node.IntCast<ui32>() == static_cast<ui32>(node.AsInt64()));
-        UNIT_ASSERT(node.IntCast<i64>() == node.AsInt64()); 
-        UNIT_ASSERT(node.IntCast<ui64>() == static_cast<ui64>(node.AsInt64())); 
+        UNIT_ASSERT(node.IntCast<i64>() == node.AsInt64());
+        UNIT_ASSERT(node.IntCast<ui64>() == static_cast<ui64>(node.AsInt64()));
 
-        node = -5; 
-        UNIT_ASSERT(node.IsInt64()); 
+        node = -5;
+        UNIT_ASSERT(node.IsInt64());
         UNIT_ASSERT(node.IntCast<i8>() == static_cast<i8>(node.AsInt64()));
         UNIT_ASSERT(node.IntCast<i16>() == static_cast<i16>(node.AsInt64()));
         UNIT_ASSERT(node.IntCast<i32>() == static_cast<i32>(node.AsInt64()));
-        UNIT_ASSERT(node.IntCast<i64>() == node.AsInt64()); 
+        UNIT_ASSERT(node.IntCast<i64>() == node.AsInt64());
         UNIT_ASSERT_EXCEPTION(node.IntCast<ui8>(), TNode::TTypeError);
         UNIT_ASSERT_EXCEPTION(node.IntCast<ui16>(), TNode::TTypeError);
         UNIT_ASSERT_EXCEPTION(node.IntCast<ui32>(), TNode::TTypeError);
-        UNIT_ASSERT_EXCEPTION(node.IntCast<ui64>(), TNode::TTypeError); 
-    } 
- 
+        UNIT_ASSERT_EXCEPTION(node.IntCast<ui64>(), TNode::TTypeError);
+    }
+
     Y_UNIT_TEST(TestConvertToString) {
-        UNIT_ASSERT_VALUES_EQUAL(TNode(5).ConvertTo<TString>(), "5"); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(123432423).ConvertTo<TString>(), "123432423"); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(123456789012345678ll).ConvertTo<TString>(), "123456789012345678"); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(123456789012345678ull).ConvertTo<TString>(), "123456789012345678"); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(-123456789012345678ll).ConvertTo<TString>(), "-123456789012345678"); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(true).ConvertTo<TString>(), "1"); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(false).ConvertTo<TString>(), "0"); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(5.3).ConvertTo<TString>(), "5.3"); 
-    } 
- 
+        UNIT_ASSERT_VALUES_EQUAL(TNode(5).ConvertTo<TString>(), "5");
+        UNIT_ASSERT_VALUES_EQUAL(TNode(123432423).ConvertTo<TString>(), "123432423");
+        UNIT_ASSERT_VALUES_EQUAL(TNode(123456789012345678ll).ConvertTo<TString>(), "123456789012345678");
+        UNIT_ASSERT_VALUES_EQUAL(TNode(123456789012345678ull).ConvertTo<TString>(), "123456789012345678");
+        UNIT_ASSERT_VALUES_EQUAL(TNode(-123456789012345678ll).ConvertTo<TString>(), "-123456789012345678");
+        UNIT_ASSERT_VALUES_EQUAL(TNode(true).ConvertTo<TString>(), "1");
+        UNIT_ASSERT_VALUES_EQUAL(TNode(false).ConvertTo<TString>(), "0");
+        UNIT_ASSERT_VALUES_EQUAL(TNode(5.3).ConvertTo<TString>(), "5.3");
+    }
+
     Y_UNIT_TEST(TestConvertFromString) {
-        UNIT_ASSERT_VALUES_EQUAL(TNode("123456789012345678").ConvertTo<ui64>(), 123456789012345678ull); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode("123456789012345678").ConvertTo<i64>(), 123456789012345678); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(ToString(1ull << 63)).ConvertTo<ui64>(), 1ull << 63); 
-        UNIT_ASSERT_EXCEPTION(TNode(ToString(1ull << 63)).ConvertTo<i64>(), TFromStringException); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode("5.34").ConvertTo<double>(), 5.34); 
-    } 
- 
+        UNIT_ASSERT_VALUES_EQUAL(TNode("123456789012345678").ConvertTo<ui64>(), 123456789012345678ull);
+        UNIT_ASSERT_VALUES_EQUAL(TNode("123456789012345678").ConvertTo<i64>(), 123456789012345678);
+        UNIT_ASSERT_VALUES_EQUAL(TNode(ToString(1ull << 63)).ConvertTo<ui64>(), 1ull << 63);
+        UNIT_ASSERT_EXCEPTION(TNode(ToString(1ull << 63)).ConvertTo<i64>(), TFromStringException);
+        UNIT_ASSERT_VALUES_EQUAL(TNode("5.34").ConvertTo<double>(), 5.34);
+    }
+
     Y_UNIT_TEST(TestConvertDoubleInt) {
         UNIT_ASSERT_VALUES_EQUAL(TNode(5.3).ConvertTo<i8>(), 5);
         UNIT_ASSERT_VALUES_EQUAL(TNode(5.3).ConvertTo<ui8>(), 5);
         UNIT_ASSERT_VALUES_EQUAL(TNode(5.3).ConvertTo<i64>(), 5);
-        UNIT_ASSERT_VALUES_EQUAL(TNode(5.3).ConvertTo<ui64>(), 5); 
+        UNIT_ASSERT_VALUES_EQUAL(TNode(5.3).ConvertTo<ui64>(), 5);
 
         UNIT_ASSERT_VALUES_EQUAL(TNode(-5.3).ConvertTo<i8>(), -5);
-        UNIT_ASSERT_VALUES_EQUAL(TNode(-5.3).ConvertTo<i64>(), -5); 
+        UNIT_ASSERT_VALUES_EQUAL(TNode(-5.3).ConvertTo<i64>(), -5);
         UNIT_ASSERT_EXCEPTION(TNode(-5.3).ConvertTo<ui8>(), TNode::TTypeError);
-        UNIT_ASSERT_EXCEPTION(TNode(-5.3).ConvertTo<ui64>(), TNode::TTypeError); 
+        UNIT_ASSERT_EXCEPTION(TNode(-5.3).ConvertTo<ui64>(), TNode::TTypeError);
 
         UNIT_ASSERT_VALUES_EQUAL(TNode(127.0).ConvertTo<i8>(), 127);
         UNIT_ASSERT_EXCEPTION(TNode(128.0).ConvertTo<i8>(), TNode::TTypeError);
         UNIT_ASSERT_VALUES_EQUAL(TNode(255.0).ConvertTo<ui8>(), 255);
         UNIT_ASSERT_EXCEPTION(TNode(256.0).ConvertTo<ui8>(), TNode::TTypeError);
-        UNIT_ASSERT_EXCEPTION(TNode(1e100).ConvertTo<i64>(), TNode::TTypeError); 
-        UNIT_ASSERT_EXCEPTION(TNode(1e100).ConvertTo<ui64>(), TNode::TTypeError); 
-        { 
+        UNIT_ASSERT_EXCEPTION(TNode(1e100).ConvertTo<i64>(), TNode::TTypeError);
+        UNIT_ASSERT_EXCEPTION(TNode(1e100).ConvertTo<ui64>(), TNode::TTypeError);
+        {
             double v = 1ull << 63;
-            TNode node = v; 
-            UNIT_ASSERT(node.IsDouble()); 
-            UNIT_ASSERT_EXCEPTION(node.ConvertTo<i64>(), TNode::TTypeError); 
-            UNIT_ASSERT_VALUES_EQUAL(node.ConvertTo<ui64>(), static_cast<ui64>(v)); 
-        } 
-        { 
-            double v = (double)(1ull << 63) + (1ull << 63); 
-            TNode node = v; 
-            UNIT_ASSERT(node.IsDouble()); 
-            UNIT_ASSERT_EXCEPTION(node.ConvertTo<i64>(), TNode::TTypeError); 
-            UNIT_ASSERT_EXCEPTION(node.ConvertTo<ui64>(), TNode::TTypeError); 
-        } 
-        UNIT_ASSERT_EXCEPTION(TNode(NAN).ConvertTo<ui64>(), TNode::TTypeError); 
-        UNIT_ASSERT_EXCEPTION(TNode(NAN).ConvertTo<i64>(), TNode::TTypeError); 
- 
-        UNIT_ASSERT_EXCEPTION(TNode(INFINITY).ConvertTo<ui64>(), TNode::TTypeError); 
-        UNIT_ASSERT_EXCEPTION(TNode(INFINITY).ConvertTo<i64>(), TNode::TTypeError); 
-    } 
- 
+            TNode node = v;
+            UNIT_ASSERT(node.IsDouble());
+            UNIT_ASSERT_EXCEPTION(node.ConvertTo<i64>(), TNode::TTypeError);
+            UNIT_ASSERT_VALUES_EQUAL(node.ConvertTo<ui64>(), static_cast<ui64>(v));
+        }
+        {
+            double v = (double)(1ull << 63) + (1ull << 63);
+            TNode node = v;
+            UNIT_ASSERT(node.IsDouble());
+            UNIT_ASSERT_EXCEPTION(node.ConvertTo<i64>(), TNode::TTypeError);
+            UNIT_ASSERT_EXCEPTION(node.ConvertTo<ui64>(), TNode::TTypeError);
+        }
+        UNIT_ASSERT_EXCEPTION(TNode(NAN).ConvertTo<ui64>(), TNode::TTypeError);
+        UNIT_ASSERT_EXCEPTION(TNode(NAN).ConvertTo<i64>(), TNode::TTypeError);
+
+        UNIT_ASSERT_EXCEPTION(TNode(INFINITY).ConvertTo<ui64>(), TNode::TTypeError);
+        UNIT_ASSERT_EXCEPTION(TNode(INFINITY).ConvertTo<i64>(), TNode::TTypeError);
+    }
+
     Y_UNIT_TEST(TestConvertToBool) {
-        UNIT_ASSERT_VALUES_EQUAL(TNode("true").ConvertTo<bool>(), true); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode("TRUE").ConvertTo<bool>(), true); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode("false").ConvertTo<bool>(), false); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode("FALSE").ConvertTo<bool>(), false); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(1).ConvertTo<bool>(), true); 
-        UNIT_ASSERT_VALUES_EQUAL(TNode(0).ConvertTo<bool>(), false); 
-        UNIT_ASSERT_EXCEPTION(TNode("random").ConvertTo<bool>(), TFromStringException); 
-        UNIT_ASSERT_EXCEPTION(TNode("").ConvertTo<bool>(), TFromStringException); 
+        UNIT_ASSERT_VALUES_EQUAL(TNode("true").ConvertTo<bool>(), true);
+        UNIT_ASSERT_VALUES_EQUAL(TNode("TRUE").ConvertTo<bool>(), true);
+        UNIT_ASSERT_VALUES_EQUAL(TNode("false").ConvertTo<bool>(), false);
+        UNIT_ASSERT_VALUES_EQUAL(TNode("FALSE").ConvertTo<bool>(), false);
+        UNIT_ASSERT_VALUES_EQUAL(TNode(1).ConvertTo<bool>(), true);
+        UNIT_ASSERT_VALUES_EQUAL(TNode(0).ConvertTo<bool>(), false);
+        UNIT_ASSERT_EXCEPTION(TNode("random").ConvertTo<bool>(), TFromStringException);
+        UNIT_ASSERT_EXCEPTION(TNode("").ConvertTo<bool>(), TFromStringException);
     }
 
     Y_UNIT_TEST(TestCanonicalSerialization) {
@@ -395,7 +395,7 @@ Y_UNIT_TEST_SUITE(YtNodeTest) {
                 "{\"i\"=\"i\";\"ii\"=\"ii\";\"jj\"=\"jj\"};"
             "\"c\"=\"c\";\"ca\"=\"ca\"}");
     }
- 
+
     Y_UNIT_TEST(OperatorEqualSubnode) {
         TNode node;
         node["a"]["b"] = "c";
@@ -406,79 +406,79 @@ Y_UNIT_TEST_SUITE(YtNodeTest) {
         UNIT_ASSERT_VALUES_EQUAL(node.AsString(), "c");
     }
 
-    Y_UNIT_TEST(TestMapGetters) { 
-        auto node = TNode::CreateMap() 
-            ("string", "7") 
-            ("int64", 3) 
-            ("uint64", 5u) 
-            ("double", -3.5) 
-            ("list", TNode::CreateList().Add(5)) 
-            ("map", TNode::CreateMap()("key", "value")); 
+    Y_UNIT_TEST(TestMapGetters) {
+        auto node = TNode::CreateMap()
+            ("string", "7")
+            ("int64", 3)
+            ("uint64", 5u)
+            ("double", -3.5)
+            ("list", TNode::CreateList().Add(5))
+            ("map", TNode::CreateMap()("key", "value"));
 
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<TString>("string"), "7");
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsString("string"), "7"); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<i64>("string"), 7); 
- 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsString("string"), "7");
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<i64>("string"), 7);
+
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<i64>("int64"), 3);
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsInt64("int64"), 3); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildIntCast<ui64>("int64"), 3u); 
- 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsInt64("int64"), 3);
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildIntCast<ui64>("int64"), 3u);
+
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<ui64>("uint64"), 5u);
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsUint64("uint64"), 5u); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildIntCast<i64>("uint64"), 5); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<TString>("uint64"), "5"); 
- 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsUint64("uint64"), 5u);
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildIntCast<i64>("uint64"), 5);
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<TString>("uint64"), "5");
+
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<double>("double"), -3.5);
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsDouble("double"), -3.5); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<TString>("double"), "-3.5"); 
- 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsDouble("double"), -3.5);
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<TString>("double"), "-3.5");
+
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<TNode::TListType>("list")[0].AsInt64(), 5);
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsList("list")[0].AsInt64(), 5); 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsList("list")[0].AsInt64(), 5);
 
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<TNode::TMapType>("map")["key"].AsString(), "value");
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsMap("map")["key"].AsString(), "value"); 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsMap("map")["key"].AsString(), "value");
 
         // mutable accessor
         auto& childString = node.ChildAs<TString>("string");
         childString = "yaddayadda";
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<TString>("string"), "yaddayadda");
-    } 
- 
-    Y_UNIT_TEST(TestListGetters) { 
-        auto node = TNode::CreateList() 
-            .Add("7") 
-            .Add(3) 
-            .Add(5u) 
-            .Add(-3.5) 
-            .Add(TNode::CreateList().Add(5)) 
-            .Add(TNode::CreateMap()("key", "value")); 
+    }
+
+    Y_UNIT_TEST(TestListGetters) {
+        auto node = TNode::CreateList()
+            .Add("7")
+            .Add(3)
+            .Add(5u)
+            .Add(-3.5)
+            .Add(TNode::CreateList().Add(5))
+            .Add(TNode::CreateMap()("key", "value"));
 
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<TString>(0), "7");
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsString(0), "7"); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<i64>(0), 7); 
- 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsString(0), "7");
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<i64>(0), 7);
+
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<i64>(1), 3);
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsInt64(1), 3); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildIntCast<ui64>(1), 3u); 
- 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsInt64(1), 3);
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildIntCast<ui64>(1), 3u);
+
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<ui64>(2), 5u);
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsUint64(2), 5u); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildIntCast<i64>(2), 5); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<TString>(2), "5"); 
- 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsUint64(2), 5u);
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildIntCast<i64>(2), 5);
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<TString>(2), "5");
+
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<double>(3), -3.5);
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsDouble(3), -3.5); 
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<TString>(3), "-3.5"); 
- 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsDouble(3), -3.5);
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildConvertTo<TString>(3), "-3.5");
+
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<TNode::TListType>(4)[0].AsInt64(), 5);
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsList(4)[0].AsInt64(), 5); 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsList(4)[0].AsInt64(), 5);
 
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<TNode::TMapType>(5)["key"].AsString(), "value");
-        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsMap(5)["key"].AsString(), "value"); 
+        UNIT_ASSERT_VALUES_EQUAL(node.ChildAsMap(5)["key"].AsString(), "value");
 
         // mutable accessor
         auto& childString = node.ChildAs<TString>(0);
         childString = "yaddayadda";
         UNIT_ASSERT_VALUES_EQUAL(node.ChildAs<TString>(0), "yaddayadda");
-    } 
+    }
 }