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

21 files changed, 198 insertions, 198 deletions

diff --git a/library/cpp/yson/consumer.cpp b/library/cpp/yson/consumer.cpp
index 40ae452978..f34f862dda 100644
--- a/library/cpp/yson/consumer.cpp
+++ b/library/cpp/yson/consumer.cpp
@@ -1,13 +1,13 @@
 #include "consumer.h"
-#include "string.h"
+#include "string.h" 
 #include "parser.h"
 
 namespace NYson {
-
+ 
     ////////////////////////////////////////////////////////////////////////////////
 
-    void TYsonConsumerBase::OnRaw(TStringBuf str, NYT::NYson::EYsonType type) {
-        ParseYsonStringBuffer(str, this, type);
+    void TYsonConsumerBase::OnRaw(TStringBuf str, NYT::NYson::EYsonType type) { 
+        ParseYsonStringBuffer(str, this, type); 
     }
 
     ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yson/consumer.h b/library/cpp/yson/consumer.h
index d5a9d66335..6e37b0eb4e 100644
--- a/library/cpp/yson/consumer.h
+++ b/library/cpp/yson/consumer.h
@@ -1,13 +1,13 @@
 #pragma once
 
-#include <library/cpp/yt/yson/consumer.h>
+#include <library/cpp/yt/yson/consumer.h> 
 
 #include <util/generic/strbuf.h>
 #include <util/system/defaults.h>
 
 namespace NYson {
     struct TYsonConsumerBase
-       : public virtual NYT::NYson::IYsonConsumer {
-        void OnRaw(TStringBuf ysonNode, NYT::NYson::EYsonType type) override;
+       : public virtual NYT::NYson::IYsonConsumer { 
+        void OnRaw(TStringBuf ysonNode, NYT::NYson::EYsonType type) override; 
     };
 } // namespace NYson
diff --git a/library/cpp/yson/json/json_writer.cpp b/library/cpp/yson/json/json_writer.cpp
index 87481256ec..9058c53b07 100644
--- a/library/cpp/yson/json/json_writer.cpp
+++ b/library/cpp/yson/json/json_writer.cpp
@@ -13,7 +13,7 @@ namespace NYT {
 
     TJsonWriter::TJsonWriter(
         IOutputStream* output,
-        ::NYson::EYsonType type,
+        ::NYson::EYsonType type, 
         EJsonFormat format,
         EJsonAttributesMode attributesMode,
         ESerializedBoolFormat booleanFormat)
@@ -29,7 +29,7 @@ namespace NYT {
     TJsonWriter::TJsonWriter(
         IOutputStream* output,
         NJson::TJsonWriterConfig config,
-        ::NYson::EYsonType type,
+        ::NYson::EYsonType type, 
         EJsonAttributesMode attributesMode,
         ESerializedBoolFormat booleanFormat)
         : Output(output)
@@ -38,8 +38,8 @@ namespace NYT {
         , BooleanFormat(booleanFormat)
         , Depth(0)
     {
-        if (Type == ::NYson::EYsonType::MapFragment) {
-            ythrow ::NYson::TYsonException() << ("Map fragments are not supported by Json");
+        if (Type == ::NYson::EYsonType::MapFragment) { 
+            ythrow ::NYson::TYsonException() << ("Map fragments are not supported by Json"); 
         }
 
         UnderlyingJsonWriter.Reset(new NJson::TJsonWriter(
@@ -84,7 +84,7 @@ namespace NYT {
 
         Depth -= 1;
 
-        if (Depth == 0 && Type == ::NYson::EYsonType::ListFragment && InAttributesBalance == 0) {
+        if (Depth == 0 && Type == ::NYson::EYsonType::ListFragment && InAttributesBalance == 0) { 
             JsonWriter->Flush();
             Output->Write("\n");
         }
@@ -97,7 +97,7 @@ namespace NYT {
         return true;
     }
 
-    void TJsonWriter::OnStringScalar(TStringBuf value) {
+    void TJsonWriter::OnStringScalar(TStringBuf value) { 
         if (IsWriteAllowed()) {
             EnterNode();
             WriteStringScalar(value);
@@ -173,7 +173,7 @@ namespace NYT {
         }
     }
 
-    void TJsonWriter::OnKeyedItem(TStringBuf name) {
+    void TJsonWriter::OnKeyedItem(TStringBuf name) { 
         if (IsWriteAllowed()) {
             if (IsSpecialJsonKey(name)) {
                 WriteStringScalar(TString("$") + name);
diff --git a/library/cpp/yson/json/json_writer.h b/library/cpp/yson/json/json_writer.h
index d84ac0de53..41de326f7b 100644
--- a/library/cpp/yson/json/json_writer.h
+++ b/library/cpp/yson/json/json_writer.h
@@ -31,7 +31,7 @@ namespace NYT {
     public:
         TJsonWriter(
             IOutputStream* output,
-            ::NYson::EYsonType type = ::NYson::EYsonType::Node,
+            ::NYson::EYsonType type = ::NYson::EYsonType::Node, 
             EJsonFormat format = JF_TEXT,
             EJsonAttributesMode attributesMode = JAM_ON_DEMAND,
             ESerializedBoolFormat booleanFormat = SBF_STRING);
@@ -39,13 +39,13 @@ namespace NYT {
         TJsonWriter(
             IOutputStream* output,
             NJson::TJsonWriterConfig config,
-            ::NYson::EYsonType type = ::NYson::EYsonType::Node,
+            ::NYson::EYsonType type = ::NYson::EYsonType::Node, 
             EJsonAttributesMode attributesMode = JAM_ON_DEMAND,
             ESerializedBoolFormat booleanFormat = SBF_STRING);
 
         void Flush();
 
-        void OnStringScalar(TStringBuf value) override;
+        void OnStringScalar(TStringBuf value) override; 
         void OnInt64Scalar(i64 value) override;
         void OnUint64Scalar(ui64 value) override;
         void OnDoubleScalar(double value) override;
@@ -58,7 +58,7 @@ namespace NYT {
         void OnEndList() override;
 
         void OnBeginMap() override;
-        void OnKeyedItem(TStringBuf key) override;
+        void OnKeyedItem(TStringBuf key) override; 
         void OnEndMap() override;
 
         void OnBeginAttributes() override;
@@ -68,7 +68,7 @@ namespace NYT {
         THolder<NJson::TJsonWriter> UnderlyingJsonWriter;
         NJson::TJsonWriter* JsonWriter;
         IOutputStream* Output;
-        ::NYson::EYsonType Type;
+        ::NYson::EYsonType Type; 
         EJsonAttributesMode AttributesMode;
         ESerializedBoolFormat BooleanFormat;
 
diff --git a/library/cpp/yson/json/yson2json_adapter.cpp b/library/cpp/yson/json/yson2json_adapter.cpp
index b5e7c49d4d..391c3a4937 100644
--- a/library/cpp/yson/json/yson2json_adapter.cpp
+++ b/library/cpp/yson/json/yson2json_adapter.cpp
@@ -1,7 +1,7 @@
 #include "yson2json_adapter.h"
 
 namespace NYT {
-    TYson2JsonCallbacksAdapter::TYson2JsonCallbacksAdapter(::NYson::TYsonConsumerBase* impl, bool throwException)
+    TYson2JsonCallbacksAdapter::TYson2JsonCallbacksAdapter(::NYson::TYsonConsumerBase* impl, bool throwException) 
         : NJson::TJsonCallbacks(throwException)
         , Impl_(impl)
     {
diff --git a/library/cpp/yson/node/node.cpp b/library/cpp/yson/node/node.cpp
index b39e070718..c6c4b47971 100644
--- a/library/cpp/yson/node/node.cpp
+++ b/library/cpp/yson/node/node.cpp
@@ -852,13 +852,13 @@ void TNode::CreateAttributes()
 
 void TNode::Save(IOutputStream* out) const
 {
-    NodeToYsonStream(*this, out, NYson::EYsonFormat::Binary);
+    NodeToYsonStream(*this, out, NYson::EYsonFormat::Binary); 
 }
 
 void TNode::Load(IInputStream* in)
 {
     Clear();
-    *this = NodeFromYsonStream(in, ::NYson::EYsonType::Node);
+    *this = NodeFromYsonStream(in, ::NYson::EYsonType::Node); 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yson/node/node_builder.cpp b/library/cpp/yson/node/node_builder.cpp
index b4431bc77a..40807f5b12 100644
--- a/library/cpp/yson/node/node_builder.cpp
+++ b/library/cpp/yson/node/node_builder.cpp
@@ -9,7 +9,7 @@ TNodeBuilder::TNodeBuilder(TNode* node)
     Stack_.push(node);
 }
 
-void TNodeBuilder::OnStringScalar(TStringBuf value)
+void TNodeBuilder::OnStringScalar(TStringBuf value) 
 {
     AddNode(value, true);
 }
@@ -59,7 +59,7 @@ void TNodeBuilder::OnBeginMap()
     AddNode(TNode::CreateMap(), false);
 }
 
-void TNodeBuilder::OnKeyedItem(TStringBuf key)
+void TNodeBuilder::OnKeyedItem(TStringBuf key) 
 {
     Stack_.push(&(*Stack_.top())[TString(key)]);
 }
diff --git a/library/cpp/yson/node/node_builder.h b/library/cpp/yson/node/node_builder.h
index 69800016e0..8725298e25 100644
--- a/library/cpp/yson/node/node_builder.h
+++ b/library/cpp/yson/node/node_builder.h
@@ -18,7 +18,7 @@ class TNodeBuilder
 public:
     TNodeBuilder(TNode* node);
 
-    void OnStringScalar(TStringBuf) override;
+    void OnStringScalar(TStringBuf) override; 
     void OnInt64Scalar(i64) override;
     void OnUint64Scalar(ui64) override;
     void OnDoubleScalar(double) override;
@@ -28,7 +28,7 @@ public:
     void OnListItem() override;
     void OnEndList() override;
     void OnBeginMap() override;
-    void OnKeyedItem(TStringBuf) override;
+    void OnKeyedItem(TStringBuf) override; 
     void OnEndMap() override;
     void OnBeginAttributes() override;
     void OnEndAttributes() override;
diff --git a/library/cpp/yson/node/node_io.cpp b/library/cpp/yson/node/node_io.cpp
index 294a7f7217..6d581f9b81 100644
--- a/library/cpp/yson/node/node_io.cpp
+++ b/library/cpp/yson/node/node_io.cpp
@@ -66,14 +66,14 @@ static void WalkJsonTree(const NJson::TJsonValue& jsonValue, NJson::TJsonCallbac
     Y_UNREACHABLE();
 }
 
-static TNode CreateEmptyNodeByType(::NYson::EYsonType type)
+static TNode CreateEmptyNodeByType(::NYson::EYsonType type) 
 {
     TNode result;
     switch (type) {
-        case ::NYson::EYsonType::ListFragment:
+        case ::NYson::EYsonType::ListFragment: 
             result = TNode::CreateList();
             break;
-        case ::NYson::EYsonType::MapFragment:
+        case ::NYson::EYsonType::MapFragment: 
             result = TNode::CreateMap();
             break;
         default:
@@ -82,46 +82,46 @@ static TNode CreateEmptyNodeByType(::NYson::EYsonType type)
     return result;
 }
 
-TNode NodeFromYsonString(const TStringBuf input, ::NYson::EYsonType type)
+TNode NodeFromYsonString(const TStringBuf input, ::NYson::EYsonType type) 
 {
     TMemoryInput stream(input);
     return NodeFromYsonStream(&stream, type);
 }
 
-TString NodeToYsonString(const TNode& node, NYson::EYsonFormat format)
+TString NodeToYsonString(const TNode& node, NYson::EYsonFormat format) 
 {
     TStringStream stream;
     NodeToYsonStream(node, &stream, format);
     return stream.Str();
 }
 
-TString NodeToCanonicalYsonString(const TNode& node, NYson::EYsonFormat format)
+TString NodeToCanonicalYsonString(const TNode& node, NYson::EYsonFormat format) 
 {
     TStringStream stream;
     NodeToCanonicalYsonStream(node, &stream, format);
     return stream.Str();
 }
 
-TNode NodeFromYsonStream(IInputStream* input, ::NYson::EYsonType type)
+TNode NodeFromYsonStream(IInputStream* input, ::NYson::EYsonType type) 
 {
     TNode result = CreateEmptyNodeByType(type);
 
     TNodeBuilder builder(&result);
-    ::NYson::TYsonParser parser(&builder, input, type);
+    ::NYson::TYsonParser parser(&builder, input, type); 
     parser.Parse();
     return result;
 }
 
-void NodeToYsonStream(const TNode& node, IOutputStream* output, NYson::EYsonFormat format)
+void NodeToYsonStream(const TNode& node, IOutputStream* output, NYson::EYsonFormat format) 
 {
-    ::NYson::TYsonWriter writer(output, format);
+    ::NYson::TYsonWriter writer(output, format); 
     TNodeVisitor visitor(&writer);
     visitor.Visit(node);
 }
 
-void NodeToCanonicalYsonStream(const TNode& node, IOutputStream* output, NYson::EYsonFormat format)
+void NodeToCanonicalYsonStream(const TNode& node, IOutputStream* output, NYson::EYsonFormat format) 
 {
-    ::NYson::TYsonWriter writer(output, format);
+    ::NYson::TYsonWriter writer(output, format); 
     TNodeVisitor visitor(&writer, /*sortMapKeys*/ true);
     visitor.Visit(node);
 }
diff --git a/library/cpp/yson/node/node_io.h b/library/cpp/yson/node/node_io.h
index 2ad23b658f..d86b9f8bda 100644
--- a/library/cpp/yson/node/node_io.h
+++ b/library/cpp/yson/node/node_io.h
@@ -12,22 +12,22 @@ namespace NYT {
 ////////////////////////////////////////////////////////////////////////////////
 
 // Parse TNode from string in YSON format
-TNode NodeFromYsonString(const TStringBuf input, ::NYson::EYsonType type = ::NYson::EYsonType::Node);
+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)
-TString NodeToYsonString(const TNode& node, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
+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)
-TString NodeToCanonicalYsonString(const TNode& node, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
+TString NodeToCanonicalYsonString(const TNode& node, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text); 
 
 // Parse TNode from stream in YSON format
-TNode NodeFromYsonStream(IInputStream* input, ::NYson::EYsonType type = ::NYson::EYsonType::Node);
+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)
-void NodeToYsonStream(const TNode& node, IOutputStream* output, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
+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)
-void NodeToCanonicalYsonStream(const TNode& node, IOutputStream* output, ::NYson::EYsonFormat format = ::NYson::EYsonFormat::Text);
+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);
diff --git a/library/cpp/yson/node/node_visitor.h b/library/cpp/yson/node/node_visitor.h
index db25832309..45be709a76 100644
--- a/library/cpp/yson/node/node_visitor.h
+++ b/library/cpp/yson/node/node_visitor.h
@@ -11,14 +11,14 @@ namespace NYT {
 class TNodeVisitor
 {
 public:
-    TNodeVisitor(NYson::IYsonConsumer* consumer, bool sortMapKeys = false);
+    TNodeVisitor(NYson::IYsonConsumer* consumer, bool sortMapKeys = false); 
 
     void Visit(const TNode& node);
     void VisitMap(const TNode::TMapType& nodeMap);
     void VisitList(const TNode::TListType& nodeMap);
 
 private:
-    NYson::IYsonConsumer* Consumer_;
+    NYson::IYsonConsumer* Consumer_; 
     bool SortMapKeys_;
 
 private:
diff --git a/library/cpp/yson/node/serialize.cpp b/library/cpp/yson/node/serialize.cpp
index aeb467622b..50b836db9c 100644
--- a/library/cpp/yson/node/serialize.cpp
+++ b/library/cpp/yson/node/serialize.cpp
@@ -8,17 +8,17 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void Serialize(const TString& value, NYson::IYsonConsumer* consumer)
+void Serialize(const TString& value, NYson::IYsonConsumer* consumer) 
 {
     consumer->OnStringScalar(value);
 }
 
-void Serialize(const TStringBuf& value, NYson::IYsonConsumer* consumer)
+void Serialize(const TStringBuf& value, NYson::IYsonConsumer* consumer) 
 {
     consumer->OnStringScalar(value);
 }
 
-void Serialize(const char* value, NYson::IYsonConsumer* consumer)
+void Serialize(const char* value, NYson::IYsonConsumer* consumer) 
 {
     consumer->OnStringScalar(value);
 }
@@ -29,13 +29,13 @@ void Deserialize(TString& value, const TNode& node)
 }
 
 #define SERIALIZE_SIGNED(type) \
-void Serialize(type value, NYson::IYsonConsumer* consumer) \
+void Serialize(type value, NYson::IYsonConsumer* consumer) \ 
 { \
     consumer->OnInt64Scalar(static_cast<i64>(value)); \
 }
 
 #define SERIALIZE_UNSIGNED(type) \
-void Serialize(type value, NYson::IYsonConsumer* consumer) \
+void Serialize(type value, NYson::IYsonConsumer* consumer) \ 
 { \
     consumer->OnUint64Scalar(static_cast<ui64>(value)); \
 }
@@ -65,7 +65,7 @@ void Deserialize(ui64& value, const TNode& node)
     value = node.AsUint64();
 }
 
-void Serialize(double value, NYson::IYsonConsumer* consumer)
+void Serialize(double value, NYson::IYsonConsumer* consumer) 
 {
     consumer->OnDoubleScalar(value);
 }
@@ -75,7 +75,7 @@ void Deserialize(double& value, const TNode& node)
     value = node.AsDouble();
 }
 
-void Serialize(bool value, NYson::IYsonConsumer* consumer)
+void Serialize(bool value, NYson::IYsonConsumer* consumer) 
 {
     consumer->OnBooleanScalar(value);
 }
@@ -85,7 +85,7 @@ void Deserialize(bool& value, const TNode& node)
     value = node.AsBool();
 }
 
-void Serialize(const TNode& node, NYson::IYsonConsumer* consumer)
+void Serialize(const TNode& node, NYson::IYsonConsumer* consumer) 
 {
     TNodeVisitor visitor(consumer);
     visitor.Visit(node);
diff --git a/library/cpp/yson/node/serialize.h b/library/cpp/yson/node/serialize.h
index 99b598a44c..d8a48031a6 100644
--- a/library/cpp/yson/node/serialize.h
+++ b/library/cpp/yson/node/serialize.h
@@ -2,43 +2,43 @@
 
 #include "node.h"
 
-namespace NYT {
-
+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 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 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 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 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 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 Serialize(double value, NYson::IYsonConsumer* consumer);
+void Serialize(double value, NYson::IYsonConsumer* consumer); 
 void Deserialize(double& value, const TNode& node);
 
-void Serialize(bool value, NYson::IYsonConsumer* consumer);
+void Serialize(bool value, NYson::IYsonConsumer* consumer); 
 void Deserialize(bool& value, const TNode& node);
 
-void Serialize(const TNode& node, NYson::IYsonConsumer* consumer);
+void Serialize(const TNode& node, NYson::IYsonConsumer* consumer); 
 void Deserialize(TNode& value, const TNode& node);
 
-void Serialize(const THashMap<TString, TString>& renameColumns, NYson::IYsonConsumer* consumer);
+void Serialize(const THashMap<TString, TString>& renameColumns, NYson::IYsonConsumer* consumer); 
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/library/cpp/yson/parser.cpp b/library/cpp/yson/parser.cpp
index 783f9b9047..4290017e27 100644
--- a/library/cpp/yson/parser.cpp
+++ b/library/cpp/yson/parser.cpp
@@ -12,7 +12,7 @@ namespace NYson {
     class TYsonParser::TImpl {
     public:
         TImpl(
-            NYT::NYson::IYsonConsumer* consumer,
+            NYT::NYson::IYsonConsumer* consumer, 
             IInputStream* stream,
             EYsonType type,
             bool enableLinePositionInfo,
@@ -27,7 +27,7 @@ namespace NYson {
 
         void Parse() {
             TBuffer buffer(64 << 10);
-            ParseYsonStreamImpl<NYT::NYson::IYsonConsumer, TStreamReader>(
+            ParseYsonStreamImpl<NYT::NYson::IYsonConsumer, TStreamReader>( 
                 TStreamReader(Stream_, buffer.Data(), buffer.Capacity()),
                 Consumer_,
                 Type_,
@@ -36,7 +36,7 @@ namespace NYson {
         }
 
     private:
-        NYT::NYson::IYsonConsumer* Consumer_;
+        NYT::NYson::IYsonConsumer* Consumer_; 
         IInputStream* Stream_;
         EYsonType Type_;
         bool EnableLinePositionInfo_;
@@ -46,7 +46,7 @@ namespace NYson {
     ////////////////////////////////////////////////////////////////////////////////
 
     TYsonParser::TYsonParser(
-        NYT::NYson::IYsonConsumer* consumer,
+        NYT::NYson::IYsonConsumer* consumer, 
         IInputStream* stream,
         EYsonType type,
         bool enableLinePositionInfo,
@@ -70,17 +70,17 @@ namespace NYson {
 
     public:
         TImpl(
-            NYT::NYson::IYsonConsumer* consumer,
+            NYT::NYson::IYsonConsumer* consumer, 
             bool enableLinePositionInfo,
             TMaybe<ui64> memoryLimit)
             : Impl(
                   enableLinePositionInfo
-                      ? static_cast<TStatelessYsonParserImplBase*>(new TStatelessYsonParserImpl<NYT::NYson::IYsonConsumer, true>(consumer, memoryLimit))
-                      : static_cast<TStatelessYsonParserImplBase*>(new TStatelessYsonParserImpl<NYT::NYson::IYsonConsumer, false>(consumer, memoryLimit)))
+                      ? static_cast<TStatelessYsonParserImplBase*>(new TStatelessYsonParserImpl<NYT::NYson::IYsonConsumer, true>(consumer, memoryLimit)) 
+                      : static_cast<TStatelessYsonParserImplBase*>(new TStatelessYsonParserImpl<NYT::NYson::IYsonConsumer, false>(consumer, memoryLimit))) 
                   {
         }
 
-        void Parse(const TStringBuf& data, EYsonType type = ::NYson::EYsonType::Node) {
+        void Parse(const TStringBuf& data, EYsonType type = ::NYson::EYsonType::Node) { 
             Impl->Parse(data, type);
         }
     };
@@ -88,7 +88,7 @@ namespace NYson {
     ////////////////////////////////////////////////////////////////////////////////
 
     TStatelessYsonParser::TStatelessYsonParser(
-        NYT::NYson::IYsonConsumer* consumer,
+        NYT::NYson::IYsonConsumer* consumer, 
         bool enableLinePositionInfo,
         TMaybe<ui64> memoryLimit)
         : Impl(new TImpl(consumer, enableLinePositionInfo, memoryLimit))
@@ -106,11 +106,11 @@ namespace NYson {
 
     void ParseYsonStringBuffer(
         const TStringBuf& buffer,
-        NYT::NYson::IYsonConsumer* consumer,
+        NYT::NYson::IYsonConsumer* consumer, 
         EYsonType type,
         bool enableLinePositionInfo,
         TMaybe<ui64> memoryLimit) {
-        ParseYsonStreamImpl<NYT::NYson::IYsonConsumer, TStringReader>(
+        ParseYsonStreamImpl<NYT::NYson::IYsonConsumer, TStringReader>( 
             TStringReader(buffer.begin(), buffer.end()),
             consumer,
             type,
@@ -123,7 +123,7 @@ namespace NYson {
     class TYsonListParser::TImpl {
     public:
         TImpl(
-            NYT::NYson::IYsonConsumer* consumer,
+            NYT::NYson::IYsonConsumer* consumer, 
             IInputStream* stream,
             bool enableLinePositionInfo,
             TMaybe<ui64> memoryLimit = Nothing())
@@ -140,14 +140,14 @@ namespace NYson {
             if (!Impl_) {
                 Impl_.Reset(
                     EnableLinePositionInfo_
-                        ? static_cast<TYsonListParserImplBase*>(new TYsonListParserImpl<NYT::NYson::IYsonConsumer, TStreamReader, true>(Reader_, Consumer_, MemoryLimit_))
-                        : static_cast<TYsonListParserImplBase*>(new TYsonListParserImpl<NYT::NYson::IYsonConsumer, TStreamReader, false>(Reader_, Consumer_, MemoryLimit_)));
+                        ? static_cast<TYsonListParserImplBase*>(new TYsonListParserImpl<NYT::NYson::IYsonConsumer, TStreamReader, true>(Reader_, Consumer_, MemoryLimit_)) 
+                        : static_cast<TYsonListParserImplBase*>(new TYsonListParserImpl<NYT::NYson::IYsonConsumer, TStreamReader, false>(Reader_, Consumer_, MemoryLimit_))); 
             }
             return Impl_->Parse();
         }
 
     private:
-        NYT::NYson::IYsonConsumer* Consumer_;
+        NYT::NYson::IYsonConsumer* Consumer_; 
         IInputStream* Stream_;
         bool EnableLinePositionInfo_;
         TMaybe<ui64> MemoryLimit_;
@@ -159,7 +159,7 @@ namespace NYson {
     ////////////////////////////////////////////////////////////////////////////////
 
     TYsonListParser::TYsonListParser(
-        NYT::NYson::IYsonConsumer* consumer,
+        NYT::NYson::IYsonConsumer* consumer, 
         IInputStream* stream,
         bool enableLinePositionInfo,
         TMaybe<ui64> memoryLimit)
diff --git a/library/cpp/yson/parser.h b/library/cpp/yson/parser.h
index dce35a8cd4..f9d9423e3b 100644
--- a/library/cpp/yson/parser.h
+++ b/library/cpp/yson/parser.h
@@ -7,19 +7,19 @@
 
 class IInputStream;
 
-namespace NYT::NYson {
-struct IYsonConsumer;
-} // namespace NYT::NYson
-
+namespace NYT::NYson { 
+struct IYsonConsumer; 
+} // namespace NYT::NYson 
+ 
 namespace NYson {
     ////////////////////////////////////////////////////////////////////////////////
 
     class TYsonParser {
     public:
         TYsonParser(
-            NYT::NYson::IYsonConsumer* consumer,
+            NYT::NYson::IYsonConsumer* consumer, 
             IInputStream* stream,
-            EYsonType type = ::NYson::EYsonType::Node,
+            EYsonType type = ::NYson::EYsonType::Node, 
             bool enableLinePositionInfo = false,
             TMaybe<ui64> memoryLimit = Nothing());
 
@@ -37,13 +37,13 @@ namespace NYson {
     class TStatelessYsonParser {
     public:
         TStatelessYsonParser(
-            NYT::NYson::IYsonConsumer* consumer,
+            NYT::NYson::IYsonConsumer* consumer, 
             bool enableLinePositionInfo = false,
             TMaybe<ui64> memoryLimit = Nothing());
 
         ~TStatelessYsonParser();
 
-        void Parse(const TStringBuf& data, EYsonType type = ::NYson::EYsonType::Node);
+        void Parse(const TStringBuf& data, EYsonType type = ::NYson::EYsonType::Node); 
 
     private:
         class TImpl;
@@ -55,7 +55,7 @@ namespace NYson {
     class TYsonListParser {
     public:
         TYsonListParser(
-            NYT::NYson::IYsonConsumer* consumer,
+            NYT::NYson::IYsonConsumer* consumer, 
             IInputStream* stream,
             bool enableLinePositionInfo = false,
             TMaybe<ui64> memoryLimit = Nothing());
@@ -73,8 +73,8 @@ namespace NYson {
 
     void ParseYsonStringBuffer(
         const TStringBuf& buffer,
-        NYT::NYson::IYsonConsumer* consumer,
-        EYsonType type = ::NYson::EYsonType::Node,
+        NYT::NYson::IYsonConsumer* consumer, 
+        EYsonType type = ::NYson::EYsonType::Node, 
         bool enableLinePositionInfo = false,
         TMaybe<ui64> memoryLimit = Nothing());
 
diff --git a/library/cpp/yson/parser_detail.h b/library/cpp/yson/parser_detail.h
index 44223caf12..32c1f7fa84 100644
--- a/library/cpp/yson/parser_detail.h
+++ b/library/cpp/yson/parser_detail.h
@@ -22,15 +22,15 @@ namespace NYson {
 
             void DoParse(EYsonType ysonType) {
                 switch (ysonType) {
-                    case ::NYson::EYsonType::Node:
+                    case ::NYson::EYsonType::Node: 
                         ParseNode<true>();
                         break;
 
-                    case ::NYson::EYsonType::ListFragment:
+                    case ::NYson::EYsonType::ListFragment: 
                         ParseListFragment<true>(EndSymbol);
                         break;
 
-                    case ::NYson::EYsonType::MapFragment:
+                    case ::NYson::EYsonType::MapFragment: 
                         ParseMapFragment<true>(EndSymbol);
                         break;
 
@@ -305,7 +305,7 @@ namespace NYson {
     template <class TConsumer, class TBlockStream>
     void ParseYsonStreamImpl(
         const TBlockStream& blockStream,
-        NYT::NYson::IYsonConsumer* consumer,
+        NYT::NYson::IYsonConsumer* consumer, 
         EYsonType parsingMode,
         bool enableLinePositionInfo,
         TMaybe<ui64> memoryLimit) {
@@ -322,7 +322,7 @@ namespace NYson {
 
     class TStatelessYsonParserImplBase {
     public:
-        virtual void Parse(const TStringBuf& data, EYsonType type = ::NYson::EYsonType::Node) = 0;
+        virtual void Parse(const TStringBuf& data, EYsonType type = ::NYson::EYsonType::Node) = 0; 
 
         virtual ~TStatelessYsonParserImplBase() {
         }
@@ -341,7 +341,7 @@ namespace NYson {
         {
         }
 
-        void Parse(const TStringBuf& data, EYsonType type = ::NYson::EYsonType::Node) override {
+        void Parse(const TStringBuf& data, EYsonType type = ::NYson::EYsonType::Node) override { 
             Parser.SetBuffer(data.begin(), data.end());
             Parser.DoParse(type);
         }
diff --git a/library/cpp/yson/public.h b/library/cpp/yson/public.h
index 1ed793592b..284e72ad4f 100644
--- a/library/cpp/yson/public.h
+++ b/library/cpp/yson/public.h
@@ -3,18 +3,18 @@
 #include <library/cpp/yt/misc/enum.h>
 #include <util/generic/yexception.h>
 
-#include <library/cpp/yt/yson_string/public.h>
-#include <library/cpp/yt/yson/public.h>
-
+#include <library/cpp/yt/yson_string/public.h> 
+#include <library/cpp/yt/yson/public.h> 
+ 
 namespace NYson {
-
+ 
     ////////////////////////////////////////////////////////////////////////////////
 
-    using NYT::NYson::EYsonFormat;
-    using NYT::NYson::EYsonType;
-
-    class TYsonStringBuf;
+    using NYT::NYson::EYsonFormat; 
+    using NYT::NYson::EYsonType; 
 
+    class TYsonStringBuf; 
+ 
     struct TYsonConsumerBase;
 
     class TYsonWriter;
diff --git a/library/cpp/yson/string-inl.h b/library/cpp/yson/string-inl.h
index 92e9ab4531..a730079387 100644
--- a/library/cpp/yson/string-inl.h
+++ b/library/cpp/yson/string-inl.h
@@ -1,57 +1,57 @@
-#pragma once
-
-#ifndef STRING_INL_H_
-#error "Direct inclusion of this file is not allowed, include string.h"
-// For the sake of sane code completion.
-#include "string.h"
-#endif
-
-#include <util/str_stl.h>
-
-namespace NYson {
-
-////////////////////////////////////////////////////////////////////////////////
-
-namespace NDetail {
-
-template <typename TLeft, typename TRight>
-bool Equals(const TLeft& lhs, const TRight& rhs)
-{
-    auto lhsNull = !lhs.operator bool();
-    auto rhsNull = !rhs.operator bool();
-    if (lhsNull != rhsNull) {
-        return false;
-    }
-    if (lhsNull && rhsNull) {
-        return true;
-    }
-    return
-        lhs.AsStringBuf() == rhs.AsStringBuf() &&
-        lhs.GetType() == rhs.GetType();
-}
-
-} // namespace NDetail
-
-inline bool operator == (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs)
-{
-    return NDetail::Equals(lhs, rhs);
-}
-
-inline bool operator != (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs)
-{
-    return !(lhs == rhs);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYson
-
-//! A hasher for TYsonStringBuf
-template <>
-struct THash<NYson::TYsonStringBuf>
-{
-    size_t operator () (const NYson::TYsonStringBuf& str) const
-    {
-        return THash<TStringBuf>()(str.AsStringBuf());
-    }
-};
+#pragma once 
+ 
+#ifndef STRING_INL_H_ 
+#error "Direct inclusion of this file is not allowed, include string.h" 
+// For the sake of sane code completion. 
+#include "string.h" 
+#endif 
+ 
+#include <util/str_stl.h> 
+ 
+namespace NYson { 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+namespace NDetail { 
+ 
+template <typename TLeft, typename TRight> 
+bool Equals(const TLeft& lhs, const TRight& rhs) 
+{ 
+    auto lhsNull = !lhs.operator bool(); 
+    auto rhsNull = !rhs.operator bool(); 
+    if (lhsNull != rhsNull) { 
+        return false; 
+    } 
+    if (lhsNull && rhsNull) { 
+        return true; 
+    } 
+    return 
+        lhs.AsStringBuf() == rhs.AsStringBuf() && 
+        lhs.GetType() == rhs.GetType(); 
+} 
+ 
+} // namespace NDetail 
+ 
+inline bool operator == (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs) 
+{ 
+    return NDetail::Equals(lhs, rhs); 
+} 
+ 
+inline bool operator != (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs) 
+{ 
+    return !(lhs == rhs); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+} // namespace NYson 
+ 
+//! A hasher for TYsonStringBuf 
+template <> 
+struct THash<NYson::TYsonStringBuf> 
+{ 
+    size_t operator () (const NYson::TYsonStringBuf& str) const 
+    { 
+        return THash<TStringBuf>()(str.AsStringBuf()); 
+    } 
+}; 
diff --git a/library/cpp/yson/writer.cpp b/library/cpp/yson/writer.cpp
index 054459f9f5..f7b9a63225 100644
--- a/library/cpp/yson/writer.cpp
+++ b/library/cpp/yson/writer.cpp
@@ -155,17 +155,17 @@ namespace NYson {
     }
 
     bool TYsonWriter::IsTopLevelFragmentContext() const {
-        return Depth == 0 && (Type == ::NYson::EYsonType::ListFragment || Type == ::NYson::EYsonType::MapFragment);
+        return Depth == 0 && (Type == ::NYson::EYsonType::ListFragment || Type == ::NYson::EYsonType::MapFragment); 
     }
 
     void TYsonWriter::EndNode() {
         if (IsTopLevelFragmentContext()) {
             ETokenType separatorToken =
-                Type == ::NYson::EYsonType::ListFragment
+                Type == ::NYson::EYsonType::ListFragment 
                     ? ListItemSeparatorToken
                     : KeyedItemSeparatorToken;
             Stream->Write(TokenTypeToChar(separatorToken));
-            if (Format == EYsonFormat::Text || Format == EYsonFormat::Pretty) {
+            if (Format == EYsonFormat::Text || Format == EYsonFormat::Pretty) { 
                 Stream->Write('\n');
             }
         }
@@ -183,7 +183,7 @@ namespace NYson {
                 Stream->Write(TokenTypeToChar(separatorToken));
             }
 
-            if (Format == EYsonFormat::Pretty) {
+            if (Format == EYsonFormat::Pretty) { 
                 Stream->Write('\n');
                 WriteIndent();
             }
@@ -194,7 +194,7 @@ namespace NYson {
 
     void TYsonWriter::EndCollection(ETokenType endToken) {
         --Depth;
-        if (Format == EYsonFormat::Pretty && !BeforeFirstItem) {
+        if (Format == EYsonFormat::Pretty && !BeforeFirstItem) { 
             Stream->Write('\n');
             WriteIndent();
         }
@@ -203,7 +203,7 @@ namespace NYson {
     }
 
     void TYsonWriter::WriteStringScalar(const TStringBuf& value) {
-        if (Format == EYsonFormat::Binary) {
+        if (Format == EYsonFormat::Binary) { 
             Stream->Write(NDetail::StringMarker);
             WriteVarInt32(Stream, static_cast<i32>(value.length()));
             Stream->Write(value.begin(), value.length());
@@ -214,13 +214,13 @@ namespace NYson {
         }
     }
 
-    void TYsonWriter::OnStringScalar(TStringBuf value) {
+    void TYsonWriter::OnStringScalar(TStringBuf value) { 
         WriteStringScalar(value);
         EndNode();
     }
 
     void TYsonWriter::OnInt64Scalar(i64 value) {
-        if (Format == EYsonFormat::Binary) {
+        if (Format == EYsonFormat::Binary) { 
             Stream->Write(NDetail::Int64Marker);
             WriteVarInt64(Stream, value);
         } else {
@@ -230,7 +230,7 @@ namespace NYson {
     }
 
     void TYsonWriter::OnUint64Scalar(ui64 value) {
-        if (Format == EYsonFormat::Binary) {
+        if (Format == EYsonFormat::Binary) { 
             Stream->Write(NDetail::Uint64Marker);
             WriteVarUInt64(Stream, value);
         } else {
@@ -241,7 +241,7 @@ namespace NYson {
     }
 
     void TYsonWriter::OnDoubleScalar(double value) {
-        if (Format == EYsonFormat::Binary) {
+        if (Format == EYsonFormat::Binary) { 
             Stream->Write(NDetail::DoubleMarker);
             Stream->Write(&value, sizeof(double));
         } else {
@@ -255,7 +255,7 @@ namespace NYson {
     }
 
     void TYsonWriter::OnBooleanScalar(bool value) {
-        if (Format == EYsonFormat::Binary) {
+        if (Format == EYsonFormat::Binary) { 
             Stream->Write(value ? NDetail::TrueMarker : NDetail::FalseMarker);
         } else {
             Stream->Write(value ? "%true" : "%false");
@@ -285,16 +285,16 @@ namespace NYson {
         BeginCollection(BeginMapToken);
     }
 
-    void TYsonWriter::OnKeyedItem(TStringBuf key) {
+    void TYsonWriter::OnKeyedItem(TStringBuf key) { 
         CollectionItem(KeyedItemSeparatorToken);
 
         WriteStringScalar(key);
 
-        if (Format == NYson::EYsonFormat::Pretty) {
+        if (Format == NYson::EYsonFormat::Pretty) { 
             Stream->Write(' ');
         }
         Stream->Write(TokenTypeToChar(KeyValueSeparatorToken));
-        if (Format == NYson::EYsonFormat::Pretty) {
+        if (Format == NYson::EYsonFormat::Pretty) { 
             Stream->Write(' ');
         }
 
@@ -312,12 +312,12 @@ namespace NYson {
 
     void TYsonWriter::OnEndAttributes() {
         EndCollection(EndAttributesToken);
-        if (Format == NYson::EYsonFormat::Pretty) {
+        if (Format == NYson::EYsonFormat::Pretty) { 
             Stream->Write(' ');
         }
     }
 
-    void TYsonWriter::OnRaw(TStringBuf yson, EYsonType type) {
+    void TYsonWriter::OnRaw(TStringBuf yson, EYsonType type) { 
         if (EnableRaw) {
             Stream->Write(yson);
             BeforeFirstItem = false;
diff --git a/library/cpp/yson/writer.h b/library/cpp/yson/writer.h
index 40f5d7d501..7e61d783d4 100644
--- a/library/cpp/yson/writer.h
+++ b/library/cpp/yson/writer.h
@@ -27,11 +27,11 @@ namespace NYson {
     public:
         TYsonWriter(
             IOutputStream* stream,
-            EYsonFormat format = EYsonFormat::Binary,
-            EYsonType type = ::NYson::EYsonType::Node,
+            EYsonFormat format = EYsonFormat::Binary, 
+            EYsonType type = ::NYson::EYsonType::Node, 
             bool enableRaw = false);
 
-        void OnStringScalar(TStringBuf value) override;
+        void OnStringScalar(TStringBuf value) override; 
         void OnInt64Scalar(i64 value) override;
         void OnUint64Scalar(ui64 value) override;
         void OnDoubleScalar(double value) override;
@@ -43,13 +43,13 @@ namespace NYson {
         void OnEndList() override;
 
         void OnBeginMap() override;
-        void OnKeyedItem(TStringBuf key) override;
+        void OnKeyedItem(TStringBuf key) override; 
         void OnEndMap() override;
 
         void OnBeginAttributes() override;
         void OnEndAttributes() override;
 
-        void OnRaw(TStringBuf yson, EYsonType type = ::NYson::EYsonType::Node) override;
+        void OnRaw(TStringBuf yson, EYsonType type = ::NYson::EYsonType::Node) override; 
 
         TState State() const;
         void Reset(const TState& state);
@@ -81,8 +81,8 @@ namespace NYson {
     void ReformatYsonStream(
         IInputStream* input,
         IOutputStream* output,
-        EYsonFormat format = EYsonFormat::Binary,
-        EYsonType type = ::NYson::EYsonType::Node);
+        EYsonFormat format = EYsonFormat::Binary, 
+        EYsonType type = ::NYson::EYsonType::Node); 
 
     ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/library/cpp/yson/ya.make b/library/cpp/yson/ya.make
index c55a189b10..f5d00f564a 100644
--- a/library/cpp/yson/ya.make
+++ b/library/cpp/yson/ya.make
@@ -5,11 +5,11 @@ OWNER(
     g:yt
 )
 
-PEERDIR(
+PEERDIR( 
     library/cpp/yt/misc
-    library/cpp/yt/yson
-)
-
+    library/cpp/yt/yson 
+) 
+ 
 SRCS(
     consumer.cpp
     lexer.cpp