Restoring authorship annotation for Oleg Sidorkin <osidorkin@gmail.com>. Commit 1 of 2.

12 files changed, 265 insertions, 265 deletions

diff --git a/library/cpp/scheme/scheme.cpp b/library/cpp/scheme/scheme.cpp
index 3efd116d4f..b3d555e459 100644
--- a/library/cpp/scheme/scheme.cpp
+++ b/library/cpp/scheme/scheme.cpp
@@ -161,7 +161,7 @@ namespace NSc {
             return *this;
         }
 
-        CoreMutableForSet(); // trigger COW
+        CoreMutableForSet(); // trigger COW 
 
         TScCore& selfCore = *TheCore;
         const TScCore& otherCore = other.Core();
@@ -191,28 +191,28 @@ namespace NSc {
                 selfCore.SetNumber(otherCore.FloatNumber);
                 break;
             case EType::String:
-                if (selfCore.Pool.Get() == otherCore.Pool.Get()) {
-                    selfCore.SetOwnedString(otherCore.String);
-                } else {
-                    selfCore.SetString(otherCore.String);
-                }
+                if (selfCore.Pool.Get() == otherCore.Pool.Get()) { 
+                    selfCore.SetOwnedString(otherCore.String); 
+                } else { 
+                    selfCore.SetString(otherCore.String); 
+                } 
                 break;
             case EType::Array:
                 selfCore.SetArray();
                 for (const TValue& e : otherCore.GetArray()) {
-                    selfCore.Push().DoCopyFromImpl(e, otherLoopCtx, selfOverrideCtx);
+                    selfCore.Push().DoCopyFromImpl(e, otherLoopCtx, selfOverrideCtx); 
                 }
                 break;
             case EType::Dict: {
-                TCorePtr tmp = NewCore(selfCore.Pool);
-                auto& tmpCore = *tmp;
-                tmpCore.SetDict();
+                TCorePtr tmp = NewCore(selfCore.Pool); 
+                auto& tmpCore = *tmp; 
+                tmpCore.SetDict(); 
                 const TDict& d = otherCore.GetDict();
-                tmpCore.Dict.reserve(d.size());
+                tmpCore.Dict.reserve(d.size()); 
                 for (const TDict::value_type& e : d) {
-                    tmpCore.Add(e.first).DoCopyFromImpl(e.second, otherLoopCtx, selfOverrideCtx);
+                    tmpCore.Add(e.first).DoCopyFromImpl(e.second, otherLoopCtx, selfOverrideCtx); 
                 }
-                TheCore = std::move(tmp);
+                TheCore = std::move(tmp); 
                 break;
             }
         }
@@ -231,7 +231,7 @@ namespace NSc {
     }
 
     bool TValue::SamePool(const TValue& a, const TValue& b) {
-        return Same(a, b) || a.TheCore->Pool.Get() == b.TheCore->Pool.Get();
+        return Same(a, b) || a.TheCore->Pool.Get() == b.TheCore->Pool.Get(); 
     }
 
     bool TValue::Equal(const TValue& a, const TValue& b) {
@@ -323,7 +323,7 @@ namespace NSc {
             const TDict& ddelta = deltaCore.Dict;
 
             for (const auto& dit : ddelta) {
-                core.GetOrAdd(dit.first).DoMergeImpl(dit.second, lowPriorityDelta, otherLoopCtx, selfOverrideGuard);
+                core.GetOrAdd(dit.first).DoMergeImpl(dit.second, lowPriorityDelta, otherLoopCtx, selfOverrideGuard); 
             }
         } else if (!delta.IsNull() && (!lowPriorityDelta || IsNull())) {
             DoCopyFromImpl(delta, otherLoopCtx, selfOverrideGuard);
@@ -394,7 +394,7 @@ namespace NSc {
     }
 
     TValue& TValue::FromJsonValue(TValue& res, const NJson::TJsonValue& val) {
-        TScCore& core = res.CoreMutableForSet();
+        TScCore& core = res.CoreMutableForSet(); 
         core.SetNull();
 
         switch (val.GetType()) {
@@ -415,19 +415,19 @@ namespace NSc {
                 core.SetNumber(val.GetDouble());
                 break;
             case NJson::JSON_STRING:
-                core.SetString(val.GetString());
+                core.SetString(val.GetString()); 
                 break;
             case NJson::JSON_ARRAY: {
                 core.SetArray();
                 for (const auto& item : val.GetArray()) {
-                    FromJsonValue(core.Push(), item);
+                    FromJsonValue(core.Push(), item); 
                 }
                 break;
             }
             case NJson::JSON_MAP: {
                 core.SetDict();
                 for (const auto& item : val.GetMap()) {
-                    FromJsonValue(core.Add(item.first), item.second);
+                    FromJsonValue(core.Add(item.first), item.second); 
                 }
                 break;
             }
diff --git a/library/cpp/scheme/scheme.h b/library/cpp/scheme/scheme.h
index 3d7c59f3c9..1b6f5d8323 100644
--- a/library/cpp/scheme/scheme.h
+++ b/library/cpp/scheme/scheme.h
@@ -193,7 +193,7 @@ namespace NSc {
         inline bool Has(size_t idx) const;
 
         inline const TValue& Get(size_t idx) const; // returns child or default
-        inline TValue* GetNoAdd(size_t idx); // returns link to existing child or nullptr
+        inline TValue* GetNoAdd(size_t idx); // returns link to existing child or nullptr 
 
         inline TValue& Push(); // returns new child
 
@@ -260,7 +260,7 @@ namespace NSc {
         inline bool Has(TStringBuf idx) const;
 
         inline const TValue& Get(TStringBuf idx) const;
-        inline TValue* GetNoAdd(TStringBuf idx); // returns link to existing child or nullptr
+        inline TValue* GetNoAdd(TStringBuf idx); // returns link to existing child or nullptr 
 
         TValue& Add(TStringBuf idx) {
             return GetOrAdd(idx);
@@ -364,7 +364,7 @@ namespace NSc {
                                                         // if the path is syntactically valid and the target value exists
                                                         // otherwise returns NSc::Null()
 
-        TValue* TrySelectOrAdd(TStringBuf path); // returns the target value if it exists or creates if not
+        TValue* TrySelectOrAdd(TStringBuf path); // returns the target value if it exists or creates if not 
                                                 // if the path is syntactically valid
                                                 // otherwise returns NSc::Null()
 
@@ -413,7 +413,7 @@ namespace NSc {
         bool IsSameOrAncestorOfImpl(const TScCore& other, NImpl::TSelfLoopContext& loopCtx) const;
 
         inline TScCore& CoreMutable();
-        inline TScCore& CoreMutableForSet();
+        inline TScCore& CoreMutableForSet(); 
         inline const TScCore& Core() const;
 
         static inline TScCore* NewCore(TPoolPtr&);
diff --git a/library/cpp/scheme/scimpl.h b/library/cpp/scheme/scimpl.h
index 4f68f16290..ce9539dfa0 100644
--- a/library/cpp/scheme/scimpl.h
+++ b/library/cpp/scheme/scimpl.h
@@ -6,7 +6,7 @@
 
 namespace NSc {
     struct TValue::TScCore : TAtomicRefCount<TScCore, TDestructor>, TNonCopyable {
-        TPoolPtr Pool;
+        TPoolPtr Pool; 
         double FloatNumber = 0;
         i64 IntNumber = 0;
         TStringBuf String;
@@ -15,9 +15,9 @@ namespace NSc {
         TValue::EType ValueType = TValue::EType::Null;
 
         TScCore(TPoolPtr& p)
-            : Pool(p)
-            , Dict(Pool->Get())
-            , Array(Pool->Get())
+            : Pool(p) 
+            , Dict(Pool->Get()) 
+            , Array(Pool->Get()) 
         {
         }
 
@@ -90,13 +90,13 @@ namespace NSc {
             IntNumber = b;
         }
 
-        void SetString(TStringBuf s) {
-            SetOwnedString(Pool->AppendBuf(s));
-        }
-
-        void SetOwnedString(TStringBuf s) {
+        void SetString(TStringBuf s) { 
+            SetOwnedString(Pool->AppendBuf(s)); 
+        } 
+ 
+        void SetOwnedString(TStringBuf s) { 
             ValueType = TValue::EType::String;
-            String = s;
+            String = s; 
         }
 
         double& GetNumberMutable(double defaultnum) {
@@ -208,9 +208,9 @@ namespace NSc {
             a.back().CopyOnWrite = false;
         }
 
-        TValue& Push() {
+        TValue& Push() { 
             SetArray();
-            DoPush(Pool, Array);
+            DoPush(Pool, Array); 
             return Array.back();
         }
 
@@ -228,36 +228,36 @@ namespace NSc {
             return IsArray() && Array.size() > key ? Array[key] : TValue::DefaultValue();
         }
 
-        TValue* GetNoAdd(size_t key) {
-            return IsArray() && Array.size() > key ? &Array[key] : nullptr;
+        TValue* GetNoAdd(size_t key) { 
+            return IsArray() && Array.size() > key ? &Array[key] : nullptr; 
         }
 
-        TValue& GetOrAdd(size_t key) {
+        TValue& GetOrAdd(size_t key) { 
             SetArray();
             for (size_t i = Array.size(); i <= key; ++i) {
-                DoPush(Pool, Array);
+                DoPush(Pool, Array); 
             }
 
             return Array[key];
         }
 
-        TValue& Back() {
+        TValue& Back() { 
             SetArray();
 
             if (Array.empty()) {
-                DoPush(Pool, Array);
+                DoPush(Pool, Array); 
             }
 
             return Array.back();
         }
 
-        TValue& Insert(size_t key) {
+        TValue& Insert(size_t key) { 
             SetArray();
 
             if (Array.size() <= key) {
-                return GetOrAdd(key);
+                return GetOrAdd(key); 
             } else {
-                Array.insert(Array.begin() + key, TValue(Pool));
+                Array.insert(Array.begin() + key, TValue(Pool)); 
                 Array[key].CopyOnWrite = false;
                 return Array[key];
             }
@@ -282,28 +282,28 @@ namespace NSc {
             return it != Dict.end() ? it->second : TValue::DefaultValue();
         }
 
-        TValue* GetNoAdd(TStringBuf key) {
+        TValue* GetNoAdd(TStringBuf key) { 
             if (!IsDict()) {
-                return nullptr;
+                return nullptr; 
             }
 
-            return Dict.FindPtr(key);
+            return Dict.FindPtr(key); 
         }
 
-        TValue& Add(TStringBuf key) {
+        TValue& Add(TStringBuf key) { 
             SetDict();
-            TDict::iterator it = Dict.insert(std::make_pair(Pool->AppendBuf(key), TValue(Pool))).first;
+            TDict::iterator it = Dict.insert(std::make_pair(Pool->AppendBuf(key), TValue(Pool))).first; 
             it->second.CopyOnWrite = false;
             return it->second;
         }
 
-        TValue& GetOrAdd(TStringBuf key) {
+        TValue& GetOrAdd(TStringBuf key) { 
             SetDict();
             TDict::insert_ctx ctx;
             TDict::iterator it = Dict.find(key, ctx);
 
             if (it == Dict.end()) {
-                it = Dict.insert_direct(std::make_pair(Pool->AppendBuf(key), TValue(Pool)), ctx);
+                it = Dict.insert_direct(std::make_pair(Pool->AppendBuf(key), TValue(Pool)), ctx); 
                 it->second.CopyOnWrite = false;
             }
 
@@ -331,9 +331,9 @@ namespace NSc {
         return new (p->Pool.Allocate<TScCore>()) TScCore(p);
     }
 
-    TValue::TValue() {
-        auto p = TPoolPtr(new NDefinitions::TPool);
-        TheCore = NewCore(p);
+    TValue::TValue() { 
+        auto p = TPoolPtr(new NDefinitions::TPool); 
+        TheCore = NewCore(p); 
     }
 
     TValue::TValue(double t)
@@ -397,19 +397,19 @@ namespace NSc {
     }
 
     TValue::TValue(TValue& v)
-        : TheCore(v.TheCore)
+        : TheCore(v.TheCore) 
         , CopyOnWrite(v.CopyOnWrite)
     {
     }
 
     TValue::TValue(const TValue& v)
-        : TheCore(v.TheCore)
+        : TheCore(v.TheCore) 
         , CopyOnWrite(true)
     {
     }
 
     TValue::TValue(TValue&& v) noexcept
-        : TheCore(std::move(v.TheCore))
+        : TheCore(std::move(v.TheCore)) 
         , CopyOnWrite(v.CopyOnWrite)
     {}
 
@@ -529,8 +529,8 @@ namespace NSc {
 
     TValue& TValue::operator=(const TValue& v) & {
         if (!Same(*this, v)) {
-            //Extend TheCore lifetime not to trigger possible v deletion via parent-child chain
-            auto tmpCore = TheCore;
+            //Extend TheCore lifetime not to trigger possible v deletion via parent-child chain 
+            auto tmpCore = TheCore; 
             TheCore = v.TheCore;
             CopyOnWrite = true;
         }
@@ -539,8 +539,8 @@ namespace NSc {
 
     TValue& TValue::operator=(TValue&& v) & noexcept {
         if (!Same(*this, v)) {
-            //Extend TheCore lifetime not to trigger possible v deletion via parent-child chain
-            auto tmpCore = TheCore;
+            //Extend TheCore lifetime not to trigger possible v deletion via parent-child chain 
+            auto tmpCore = TheCore; 
             TheCore = std::move(v.TheCore);
             CopyOnWrite = v.CopyOnWrite;
         }
@@ -556,18 +556,18 @@ namespace NSc {
     }
 
     TValue& TValue::GetOrAddUnsafe(size_t idx) {
-        return CoreMutable().GetOrAdd(idx);
+        return CoreMutable().GetOrAdd(idx); 
     }
 
     TValue& TValue::GetOrAdd(TStringBuf idx) {
-        return CoreMutable().GetOrAdd(idx);
+        return CoreMutable().GetOrAdd(idx); 
     }
 
     const TValue& TValue::Get(size_t idx) const {
         return Core().Get(idx);
     }
 
-    TValue* TValue::GetNoAdd(size_t idx) {
+    TValue* TValue::GetNoAdd(size_t idx) { 
         return CoreMutable().GetNoAdd(idx);
     }
 
@@ -575,12 +575,12 @@ namespace NSc {
         return Core().Get(idx);
     }
 
-    TValue* TValue::GetNoAdd(TStringBuf key) {
+    TValue* TValue::GetNoAdd(TStringBuf key) { 
         return CoreMutable().GetNoAdd(key);
     }
 
     TValue& TValue::Back() {
-        return CoreMutable().Back();
+        return CoreMutable().Back(); 
     }
 
     const TValue& TValue::Back() const {
@@ -604,7 +604,7 @@ namespace NSc {
     }
 
     TValue& TValue::InsertUnsafe(size_t idx) {
-        return CoreMutable().Insert(idx);
+        return CoreMutable().Insert(idx); 
     }
 
     template <class TIt>
@@ -623,7 +623,7 @@ namespace NSc {
     }
 
     TValue& TValue::Push() {
-        return CoreMutable().Push();
+        return CoreMutable().Push(); 
     }
 
     TValue TValue::Pop() {
@@ -663,22 +663,22 @@ namespace NSc {
     }
 
     TValue& TValue::SetNumber(double i) {
-        CoreMutableForSet().SetNumber(i);
+        CoreMutableForSet().SetNumber(i); 
         return *this;
     }
 
     TValue& TValue::SetIntNumber(i64 n) {
-        CoreMutableForSet().SetIntNumber(n);
+        CoreMutableForSet().SetIntNumber(n); 
         return *this;
     }
 
     TValue& TValue::SetBool(bool val) {
-        CoreMutableForSet().SetBool(val);
+        CoreMutableForSet().SetBool(val); 
         return *this;
     }
 
     TValue& TValue::SetString(TStringBuf s) {
-        CoreMutableForSet().SetString(s);
+        CoreMutableForSet().SetString(s); 
         return *this;
     }
 
@@ -767,13 +767,13 @@ namespace NSc {
     }
 
     TValue::TValue(TPoolPtr& p)
-        : TheCore(NewCore(p))
+        : TheCore(NewCore(p)) 
     {
     }
 
     TValue::TScCore& TValue::CoreMutable() {
         if (Y_UNLIKELY(!TheCore)) {
-            *this = TValue();
+            *this = TValue(); 
         } else if (Y_UNLIKELY(CopyOnWrite) && Y_UNLIKELY(TheCore->RefCount() > 1)) {
             *this = Clone();
         }
@@ -783,22 +783,22 @@ namespace NSc {
         return *TheCore;
     }
 
-    TValue::TScCore& TValue::CoreMutableForSet() {
-        if (Y_UNLIKELY(!TheCore) || Y_UNLIKELY(CopyOnWrite) && Y_UNLIKELY(TheCore->RefCount() > 1)) {
-            *this = TValue();
-        }
-
-        CopyOnWrite = false;
-
-        return *TheCore;
-    }
-
+    TValue::TScCore& TValue::CoreMutableForSet() { 
+        if (Y_UNLIKELY(!TheCore) || Y_UNLIKELY(CopyOnWrite) && Y_UNLIKELY(TheCore->RefCount() > 1)) { 
+            *this = TValue(); 
+        } 
+ 
+        CopyOnWrite = false; 
+ 
+        return *TheCore; 
+    } 
+ 
     const TValue::TScCore& TValue::Core() const {
         return TheCore ? *TheCore : DefaultCore();
     }
 
     TValue& TValue::SetNull() {
-        CoreMutableForSet().SetNull();
+        CoreMutableForSet().SetNull(); 
         return *this;
     }
 
diff --git a/library/cpp/scheme/scimpl_protobuf.cpp b/library/cpp/scheme/scimpl_protobuf.cpp
index 0c99122c69..849428a7ef 100644
--- a/library/cpp/scheme/scimpl_protobuf.cpp
+++ b/library/cpp/scheme/scimpl_protobuf.cpp
@@ -23,7 +23,7 @@ namespace NSc {
             try {
                 if (field->is_repeated()) {
                     if (field->is_map() && mapAsDict) {
-                        auto& elem = v[field->name()];
+                        auto& elem = v[field->name()]; 
                         for (int i2 = 0; i2 < r->FieldSize(msg, field); ++i2) {
                             auto val = FromRepeatedField(msg, field, i2);
                             if (val.IsDict()) {
diff --git a/library/cpp/scheme/scimpl_select.rl6 b/library/cpp/scheme/scimpl_select.rl6
index 11aa549b78..20d2e4eb35 100644
--- a/library/cpp/scheme/scimpl_select.rl6
+++ b/library/cpp/scheme/scimpl_select.rl6
@@ -216,13 +216,13 @@ namespace NSc {
         return DefaultValue();
     }
 
-    TValue* TValue::TrySelectOrAdd(TStringBuf path) {
+    TValue* TValue::TrySelectOrAdd(TStringBuf path) { 
         TSelectorCtx<TSelector<TValue, TGetNext<false> > > ctx(*this, path);
 
         if (ctx.SelectPath()) {
-            return ctx.Selector.Current;
+            return ctx.Selector.Current; 
         } else {
-            return nullptr;
+            return nullptr; 
         }
     }
 
diff --git a/library/cpp/scheme/tests/fuzz_json/lib/fuzz_json.cpp b/library/cpp/scheme/tests/fuzz_json/lib/fuzz_json.cpp
index 7c16527c23..f34571d967 100644
--- a/library/cpp/scheme/tests/fuzz_json/lib/fuzz_json.cpp
+++ b/library/cpp/scheme/tests/fuzz_json/lib/fuzz_json.cpp
@@ -1,90 +1,90 @@
 #include "fuzz_json.h"
-#include "util/generic/fwd.h"
+#include "util/generic/fwd.h" 
 
 #include <library/cpp/scheme/scheme.h>
 #include <util/stream/null.h>
 
-namespace {
-    static constexpr size_t MAX_DEPTH = 4;
-    static constexpr size_t MAX_PATH_LEN = 256;
-    static constexpr size_t MAX_ITERATIONS = 4;
-
-    void SplitOnDepth(const TStringBuf src, const size_t depth, const size_t maxPathLen,
-        TStringBuf& left, TStringBuf& right)
-    {
-        size_t pos = 0;
-        size_t prevPos = 0;
-        for(size_t i = 0; i < depth; ++i) {
-            if (pos > maxPathLen) {
-                break;
-            }
-            prevPos = pos;
-            pos = src.find_first_of(TStringBuf("/]"), pos + 1);
-            if (pos == TStringBuf::npos) {
-                break;
-            }
-        }
-        if (pos == TStringBuf::npos && prevPos > 0) {
-            pos = prevPos;
-        }
-        if (src.length() > maxPathLen)  {
-            if (pos == TStringBuf::npos || pos > maxPathLen) {
-                pos = maxPathLen;
-            }
-        }
-        if (pos == TStringBuf::npos || pos == 0) {
-            left = src;
-            right = TStringBuf();
-        } else {
-            src.SplitAt(pos + 1, left, right);
-        }
-    }
-
-    TString tmp;
-    //Limit max array size in the path to 256
-    TStringBuf ProcessPath(TStringBuf path) {
-        size_t pos = 0;
-        while(pos != TStringBuf::npos) {
-            pos = path.find(']', pos + 1);
-            if (pos == TStringBuf::npos) {
-                continue;
-            }
-            size_t open = path.rfind('[', pos);
-            if (open == TStringBuf::npos) {
-                continue;
-            }
-            bool allDigit = true;
-            for(size_t i = open + 1; i < pos; ++i) {
-                if (path[i] < '0' || path[i] > '9') {
-                    allDigit = false;
-                    break;
-                }
-            }
-            if (!allDigit) {
-                continue;
-            }
-            if (pos - open > 4)  {
-                TString str = TString::Join(path.Head(open + 1), "256", path.Tail(pos));
-                tmp = std::move(str);
-                path = tmp;
-                pos = (open + 1) + 3;
-                continue;
-            }
-        }
-        return path;
-    }
-}
-
+namespace { 
+    static constexpr size_t MAX_DEPTH = 4; 
+    static constexpr size_t MAX_PATH_LEN = 256; 
+    static constexpr size_t MAX_ITERATIONS = 4; 
+ 
+    void SplitOnDepth(const TStringBuf src, const size_t depth, const size_t maxPathLen, 
+        TStringBuf& left, TStringBuf& right) 
+    { 
+        size_t pos = 0; 
+        size_t prevPos = 0; 
+        for(size_t i = 0; i < depth; ++i) { 
+            if (pos > maxPathLen) { 
+                break; 
+            } 
+            prevPos = pos; 
+            pos = src.find_first_of(TStringBuf("/]"), pos + 1); 
+            if (pos == TStringBuf::npos) { 
+                break; 
+            } 
+        } 
+        if (pos == TStringBuf::npos && prevPos > 0) { 
+            pos = prevPos; 
+        } 
+        if (src.length() > maxPathLen)  { 
+            if (pos == TStringBuf::npos || pos > maxPathLen) { 
+                pos = maxPathLen; 
+            } 
+        } 
+        if (pos == TStringBuf::npos || pos == 0) { 
+            left = src; 
+            right = TStringBuf(); 
+        } else { 
+            src.SplitAt(pos + 1, left, right); 
+        } 
+    } 
+ 
+    TString tmp; 
+    //Limit max array size in the path to 256 
+    TStringBuf ProcessPath(TStringBuf path) { 
+        size_t pos = 0; 
+        while(pos != TStringBuf::npos) { 
+            pos = path.find(']', pos + 1); 
+            if (pos == TStringBuf::npos) { 
+                continue; 
+            } 
+            size_t open = path.rfind('[', pos); 
+            if (open == TStringBuf::npos) { 
+                continue; 
+            } 
+            bool allDigit = true; 
+            for(size_t i = open + 1; i < pos; ++i) { 
+                if (path[i] < '0' || path[i] > '9') { 
+                    allDigit = false; 
+                    break; 
+                } 
+            } 
+            if (!allDigit) { 
+                continue; 
+            } 
+            if (pos - open > 4)  { 
+                TString str = TString::Join(path.Head(open + 1), "256", path.Tail(pos)); 
+                tmp = std::move(str); 
+                path = tmp; 
+                pos = (open + 1) + 3; 
+                continue; 
+            } 
+        } 
+        return path; 
+    } 
+} 
+ 
 namespace NSc::NUt {
-
-
+ 
+ 
     void FuzzJson(TStringBuf wire) {
         if (wire.size() < 2) {
             return;
         }
 
-
-        ProcessPath("[123][1234][12][2134][12312312][1][12]");
+ 
+        ProcessPath("[123][1234][12][2134][12312312][1][12]"); 
         ui8 len1 = wire[0];
         ui8 len2 = wire[1];
         wire.Skip(2);
@@ -94,22 +94,22 @@ namespace NSc::NUt {
         NSc::TValue val2 = NSc::TValue::FromJson(json2);
         NSc::TValue val3;
         val3.MergeUpdate(val1);
-
-        size_t i = 0;
-        while (!wire.empty()) {
-            TStringBuf path;
-            SplitOnDepth(wire, MAX_DEPTH, MAX_PATH_LEN, path, wire);
-            path = ProcessPath(path);
-            if (auto* target = val3.TrySelectOrAdd(path)) {
-                target->MergeUpdate(val2);
-            }
-            ++i;
-            // Release memory since there are up to MAX_DICT_SIZE * MAX_DEPTH elements
-            if (i > MAX_ITERATIONS) {
-                Cnull << val3.ToJson();
-                val3 = NSc::TValue();
-            }
-        }
+ 
+        size_t i = 0; 
+        while (!wire.empty()) { 
+            TStringBuf path; 
+            SplitOnDepth(wire, MAX_DEPTH, MAX_PATH_LEN, path, wire); 
+            path = ProcessPath(path); 
+            if (auto* target = val3.TrySelectOrAdd(path)) { 
+                target->MergeUpdate(val2); 
+            } 
+            ++i; 
+            // Release memory since there are up to MAX_DICT_SIZE * MAX_DEPTH elements 
+            if (i > MAX_ITERATIONS) { 
+                Cnull << val3.ToJson(); 
+                val3 = NSc::TValue(); 
+            } 
+        } 
         Cnull << val3.ToJson();
     }
 }
diff --git a/library/cpp/scheme/tests/fuzz_ops/lib/fuzz_ops.cpp b/library/cpp/scheme/tests/fuzz_ops/lib/fuzz_ops.cpp
index 8a7facba24..a100d3a631 100644
--- a/library/cpp/scheme/tests/fuzz_ops/lib/fuzz_ops.cpp
+++ b/library/cpp/scheme/tests/fuzz_ops/lib/fuzz_ops.cpp
@@ -29,9 +29,9 @@ namespace NSc::NUt {
             if (!ApplyNextAction(st, *act)) {
                 break;
             }
-            if (!NSc::TValue::DefaultValue().IsNull()) {
-                std::terminate();
-            }
+            if (!NSc::TValue::DefaultValue().IsNull()) { 
+                std::terminate(); 
+            } 
         }
     }
 }
diff --git a/library/cpp/scheme/tests/fuzz_ops/lib/vm_apply.cpp b/library/cpp/scheme/tests/fuzz_ops/lib/vm_apply.cpp
index ada7b8854f..563187f9f4 100644
--- a/library/cpp/scheme/tests/fuzz_ops/lib/vm_apply.cpp
+++ b/library/cpp/scheme/tests/fuzz_ops/lib/vm_apply.cpp
@@ -77,22 +77,22 @@ namespace NSc::NUt {
         Y_FAIL(); \
     }
 
-#define Y_GEN_PTR_OP(op, arg, st, act) \
-    if (auto* r = (op)) { \
-        switch (act.GetRef(arg).Type) { \
-        case TRef::T_CREATE_BACK: \
-            Y_GEN_TRY_OP(st.TryPushBack(*r)) \
-            break; \
-        case TRef::T_CREATE_FRONT: \
-            Y_GEN_TRY_OP(st.TryPushFront(*r)) \
-            break; \
-        case TRef::T_REF__POS: \
-            st.LRef(act.GetRef(arg).Pos) = *r; \
-            break; \
-        default: \
-            Y_FAIL(); \
-        } \
-    }
+#define Y_GEN_PTR_OP(op, arg, st, act) \ 
+    if (auto* r = (op)) { \ 
+        switch (act.GetRef(arg).Type) { \ 
+        case TRef::T_CREATE_BACK: \ 
+            Y_GEN_TRY_OP(st.TryPushBack(*r)) \ 
+            break; \ 
+        case TRef::T_CREATE_FRONT: \ 
+            Y_GEN_TRY_OP(st.TryPushFront(*r)) \ 
+            break; \ 
+        case TRef::T_REF__POS: \ 
+            st.LRef(act.GetRef(arg).Pos) = *r; \ 
+            break; \ 
+        default: \ 
+            Y_FAIL(); \ 
+        } \ 
+    } 
 
     bool ApplyNextAction(TVMState& st, TVMAction act) {
         switch (act.Type) {
@@ -228,7 +228,7 @@ namespace NSc::NUt {
             return true;
 
         case VMA_ARRAY_GET_NO_ADD__IDX_REF:
-            Y_GEN_PTR_OP(st.Current().GetNoAdd(act.GetIdx(0)), 1, st, act);
+            Y_GEN_PTR_OP(st.Current().GetNoAdd(act.GetIdx(0)), 1, st, act); 
             return true;
 
         case VMA_DICT_CLEAR:
@@ -260,7 +260,7 @@ namespace NSc::NUt {
             return true;
 
         case VMA_DICT_GET_NO_ADD__IDX_REF:
-            Y_GEN_PTR_OP(st.Current().GetNoAdd(act.GetKey(0)), 1, st, act);
+            Y_GEN_PTR_OP(st.Current().GetNoAdd(act.GetKey(0)), 1, st, act); 
             return true;
 
         case VMA_MERGE_UPDATE__POS:
@@ -288,7 +288,7 @@ namespace NSc::NUt {
             return true;
 
         case VMA_SELECT_OR_ADD__PATH_REF:
-            Y_GEN_PTR_OP(st.Current().TrySelectOrAdd(act.GetPath(0)), 1, st, act);
+            Y_GEN_PTR_OP(st.Current().TrySelectOrAdd(act.GetPath(0)), 1, st, act); 
             return true;
 
         case VMA_SELECT_AND_DELETE__PATH_REF:
diff --git a/library/cpp/scheme/tests/ut/scheme_merge_ut.cpp b/library/cpp/scheme/tests/ut/scheme_merge_ut.cpp
index 2a06cf110d..5376456540 100644
--- a/library/cpp/scheme/tests/ut/scheme_merge_ut.cpp
+++ b/library/cpp/scheme/tests/ut/scheme_merge_ut.cpp
@@ -164,7 +164,7 @@ Y_UNIT_TEST_SUITE(TSchemeMergeTest) {
         v["a"] = NSc::TValue::FromJson("[0.125,0.12,0.1,0.08,0.06]");
         UNIT_ASSERT_JSON_EQ_JSON(v, "{a:[0.125,0.12,0.1,0.08,0.06]}");
 
-        NSc::TValue a = v.TrySelectOrAdd("a")->MergeUpdateJson("[1,2,3]");
+        NSc::TValue a = v.TrySelectOrAdd("a")->MergeUpdateJson("[1,2,3]"); 
 
         UNIT_ASSERT_JSON_EQ_JSON(a, "[1,2,3]");
         UNIT_ASSERT_JSON_EQ_JSON(v, "{a:[1,2,3]}");
diff --git a/library/cpp/scheme/tests/ut/scheme_path_ut.cpp b/library/cpp/scheme/tests/ut/scheme_path_ut.cpp
index 0d4d79d483..9d9fd2cf63 100644
--- a/library/cpp/scheme/tests/ut/scheme_path_ut.cpp
+++ b/library/cpp/scheme/tests/ut/scheme_path_ut.cpp
@@ -15,7 +15,7 @@ Y_UNIT_TEST_SUITE(TSchemePathTest) {
         UNIT_ASSERT(!v.PathExists(path));
         UNIT_ASSERT(NSc::TValue::PathValid(path));
         UNIT_ASSERT(NSc::TValue::Same(v.TrySelect(path), NSc::Null()));
-        *v.TrySelectOrAdd(path) = 1;
+        *v.TrySelectOrAdd(path) = 1; 
         NSc::NUt::AssertSchemeJson(expected, v);
         UNIT_ASSERT(v.PathExists(path));
         UNIT_ASSERT(1 == v.TrySelectOrAdd(path)->GetNumber());
@@ -33,19 +33,19 @@ Y_UNIT_TEST_SUITE(TSchemePathTest) {
         UNIT_ASSERT(v.PathExists(""));
         UNIT_ASSERT(v.PathExists("//"));
 
-        UNIT_ASSERT(NSc::TValue::Same(v, *v.TrySelectOrAdd("//")));
+        UNIT_ASSERT(NSc::TValue::Same(v, *v.TrySelectOrAdd("//"))); 
         NSc::NUt::AssertSchemeJson("null", v);
         UNIT_ASSERT(NSc::TValue::Same(v.TrySelectAndDelete("//"), NSc::Null()));
         NSc::NUt::AssertSchemeJson("null", v);
 
         v.SetDict();
-        UNIT_ASSERT(NSc::TValue::Same(v, *v.TrySelectOrAdd("//")));
+        UNIT_ASSERT(NSc::TValue::Same(v, *v.TrySelectOrAdd("//"))); 
         NSc::NUt::AssertSchemeJson("{}", v);
         UNIT_ASSERT(NSc::TValue::Same(v.TrySelectAndDelete("//"), NSc::Null()));
         NSc::NUt::AssertSchemeJson("{}", v);
 
         v.SetArray();
-        UNIT_ASSERT(NSc::TValue::Same(v, *v.TrySelectOrAdd("//")));
+        UNIT_ASSERT(NSc::TValue::Same(v, *v.TrySelectOrAdd("//"))); 
         NSc::NUt::AssertSchemeJson("[]", v);
         UNIT_ASSERT(NSc::TValue::Same(v.TrySelectAndDelete("//"), NSc::Null()));
         NSc::NUt::AssertSchemeJson("[]", v);
@@ -63,7 +63,7 @@ Y_UNIT_TEST_SUITE(TSchemePathTest) {
 
     Y_UNIT_TEST(TestSelectAndMerge) {
         NSc::TValue v;
-        v.TrySelectOrAdd("blender/enabled")->MergeUpdateJson("1");
+        v.TrySelectOrAdd("blender/enabled")->MergeUpdateJson("1"); 
         UNIT_ASSERT_VALUES_EQUAL(NSc::TValue::FromJson("1").ToJson(), "1");
         UNIT_ASSERT_VALUES_EQUAL(v.ToJson(), "{\"blender\":{\"enabled\":1}}");
     }
@@ -97,61 +97,61 @@ Y_UNIT_TEST_SUITE(TSchemePathTest) {
 
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd("") = 100;
+            *val.TrySelectOrAdd("") = 100; 
             const TString res = R"=(100)=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd("a") = 100;
+            *val.TrySelectOrAdd("a") = 100; 
             const TString res = R"=({"a":100})=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd(R"=(////)=") = 100;
+            *val.TrySelectOrAdd(R"=(////)=") = 100; 
             const TString res = R"=(100)=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd(R"=()=") = 100;
+            *val.TrySelectOrAdd(R"=()=") = 100; 
             const TString res = R"=(100)=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd(R"=("")=") = 100;
+            *val.TrySelectOrAdd(R"=("")=") = 100; 
             const TString res = R"=({"":100})=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd(R"=("[1]")=") = 100;
+            *val.TrySelectOrAdd(R"=("[1]")=") = 100; 
             const TString res = R"=({"[1]":100})=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd(R"=("\"\"")=") = 100;
+            *val.TrySelectOrAdd(R"=("\"\"")=") = 100; 
             const TString res = R"=({"\"\"":100})=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd(R"=("/10/")=") = 100;
+            *val.TrySelectOrAdd(R"=("/10/")=") = 100; 
             const TString res = R"=({"/10/":100})=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd(R"=(/"[10]"//""/"\"/10/\""///)=") = 100;
+            *val.TrySelectOrAdd(R"=(/"[10]"//""/"\"/10/\""///)=") = 100; 
             const TString res = R"=({"[10]":{"":{"\"/10/\"":100}}})=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
         {
             NSc::TValue val;
-            *val.TrySelectOrAdd(R"=(/"[10]"//""/"\"/10/\""///)=") = 100;
+            *val.TrySelectOrAdd(R"=(/"[10]"//""/"\"/10/\""///)=") = 100; 
             const TString res = R"=({"[10]":{"":{"\"/10/\"":100}}})=";
             UNIT_ASSERT_VALUES_EQUAL(val.ToJson(), res);
         }
diff --git a/library/cpp/scheme/tests/ut/scheme_proto_ut.cpp b/library/cpp/scheme/tests/ut/scheme_proto_ut.cpp
index e711a0d092..5379ef6164 100644
--- a/library/cpp/scheme/tests/ut/scheme_proto_ut.cpp
+++ b/library/cpp/scheme/tests/ut/scheme_proto_ut.cpp
@@ -27,7 +27,7 @@ Y_UNIT_TEST_SUITE(TSchemeProtoTest) {
         if (mapAsDict) {
             v[key] = value;
         } else {
-            auto& newElement = v.Push();
+            auto& newElement = v.Push(); 
             newElement["key"] = key;
             newElement["value"] = value;
         }
diff --git a/library/cpp/scheme/tests/ut/scheme_ut.cpp b/library/cpp/scheme/tests/ut/scheme_ut.cpp
index 1a5d07c31b..0ddefa7fea 100644
--- a/library/cpp/scheme/tests/ut/scheme_ut.cpp
+++ b/library/cpp/scheme/tests/ut/scheme_ut.cpp
@@ -317,12 +317,12 @@ Y_UNIT_TEST_SUITE(TSchemeTest) {
     }
 
     Y_UNIT_TEST(TestAssignmentDictChild) {
-        {
-            NSc::TValue v;
-            {
-                NSc::TValue b;
-                v["a"] = b;
-            }
+        { 
+            NSc::TValue v; 
+            { 
+                NSc::TValue b; 
+                v["a"] = b; 
+            } 
             v = v["a"];
         }
         {
@@ -331,7 +331,7 @@ Y_UNIT_TEST_SUITE(TSchemeTest) {
                 NSc::TValue b;
                 v["a"] = b;
             }
-            v = v.Get("a");
+            v = v.Get("a"); 
         }
         {
             NSc::TValue v;
@@ -341,8 +341,8 @@ Y_UNIT_TEST_SUITE(TSchemeTest) {
             }
             v = std::move(v["a"]);
         }
-    }
-
+    } 
+ 
     Y_UNIT_TEST(TestInsert) {
         NSc::TValue v;
         v.Insert(0, "b");
@@ -767,18 +767,18 @@ Y_UNIT_TEST_SUITE(TSchemeTest) {
             UNIT_ASSERT(w.IsDict());
             UNIT_ASSERT_VALUES_EQUAL(w.Get("foo").GetString(), "baz");
         }
-        UNIT_ASSERT(NSc::TValue::DefaultValue().IsNull());
-    }
-
-    //SPI-25156
-    Y_UNIT_TEST(TestMoveNotCorruptingDefault) {
-        using namespace NSc;
-        TValue w = TValue::FromJson("{foo:bar}");
-        TValue v = std::move(w);
-        w["foo"] = "baz";  // no crash here
-        UNIT_ASSERT(NSc::TValue::DefaultValue().IsNull());
+        UNIT_ASSERT(NSc::TValue::DefaultValue().IsNull()); 
     }
 
+    //SPI-25156 
+    Y_UNIT_TEST(TestMoveNotCorruptingDefault) { 
+        using namespace NSc; 
+        TValue w = TValue::FromJson("{foo:bar}"); 
+        TValue v = std::move(w); 
+        w["foo"] = "baz";  // no crash here 
+        UNIT_ASSERT(NSc::TValue::DefaultValue().IsNull()); 
+    } 
+ 
     Y_UNIT_TEST(TestCopyFrom) {
         {
             TString sa = "[1,2]";
@@ -845,34 +845,34 @@ Y_UNIT_TEST_SUITE(TSchemeTest) {
         }
     }
 
-    Y_UNIT_TEST(TestCopyingDictIntoSelf) { //Found by fuzzing
-        NSc::TValue a;
-        NSc::TValue b = a.GetOrAdd("aa");
-        b.CopyFrom(a);
-        NSc::TValue target = NSc::TValue::FromJsonThrow("{\"aa\":null}");
-        UNIT_ASSERT_VALUES_EQUAL(b, target);
-        UNIT_ASSERT_VALUES_EQUAL(a, target);
-    }
-
-    Y_UNIT_TEST(TestCopyingDictIntoSelfByRef) { //Found by fuzzing
-        NSc::TValue a;
-        NSc::TValue& b = a.GetOrAdd("aa");
-        b.CopyFrom(a);
-        UNIT_ASSERT_VALUES_EQUAL(b, NSc::TValue::FromJsonThrow("{\"aa\":null}"));
-        UNIT_ASSERT_VALUES_EQUAL(a, NSc::TValue::FromJsonThrow("{\"aa\": {\"aa\": null}}"));
-    }
-
+    Y_UNIT_TEST(TestCopyingDictIntoSelf) { //Found by fuzzing 
+        NSc::TValue a; 
+        NSc::TValue b = a.GetOrAdd("aa"); 
+        b.CopyFrom(a); 
+        NSc::TValue target = NSc::TValue::FromJsonThrow("{\"aa\":null}"); 
+        UNIT_ASSERT_VALUES_EQUAL(b, target); 
+        UNIT_ASSERT_VALUES_EQUAL(a, target); 
+    } 
+ 
+    Y_UNIT_TEST(TestCopyingDictIntoSelfByRef) { //Found by fuzzing 
+        NSc::TValue a; 
+        NSc::TValue& b = a.GetOrAdd("aa"); 
+        b.CopyFrom(a); 
+        UNIT_ASSERT_VALUES_EQUAL(b, NSc::TValue::FromJsonThrow("{\"aa\":null}")); 
+        UNIT_ASSERT_VALUES_EQUAL(a, NSc::TValue::FromJsonThrow("{\"aa\": {\"aa\": null}}")); 
+    } 
+ 
     Y_UNIT_TEST(TestGetNoAdd) {
         NSc::TValue v = NSc::NUt::AssertFromJson("{a:[null,-1,2,3.4],b:3,c:{d:5}}");
-        UNIT_ASSERT(v.GetNoAdd("a") != nullptr);
-        UNIT_ASSERT(v.GetNoAdd("b") != nullptr);
-        UNIT_ASSERT(v.GetNoAdd("c") != nullptr);
-        UNIT_ASSERT(v.GetNoAdd("d") == nullptr);
-        UNIT_ASSERT(v.GetNoAdd("value") == nullptr);
-
-        NSc::TValue* child = v.GetNoAdd("c");
-        UNIT_ASSERT(child != nullptr);
-        (*child)["e"]["f"] = 42;
+        UNIT_ASSERT(v.GetNoAdd("a") != nullptr); 
+        UNIT_ASSERT(v.GetNoAdd("b") != nullptr); 
+        UNIT_ASSERT(v.GetNoAdd("c") != nullptr); 
+        UNIT_ASSERT(v.GetNoAdd("d") == nullptr); 
+        UNIT_ASSERT(v.GetNoAdd("value") == nullptr); 
+
+        NSc::TValue* child = v.GetNoAdd("c"); 
+        UNIT_ASSERT(child != nullptr); 
+        (*child)["e"]["f"] = 42; 
         const NSc::TValue expectedResult = NSc::NUt::AssertFromJson("{a:[null,-1,2,3.4],b:3,c:{d:5,e:{f:42}}}");
         UNIT_ASSERT_VALUES_EQUAL(v, expectedResult);
     }