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

42 files changed, 1141 insertions, 1141 deletions

diff --git a/library/cpp/actors/core/log_settings.cpp b/library/cpp/actors/core/log_settings.cpp
index f52f2fc5d2..e49abf4717 100644
--- a/library/cpp/actors/core/log_settings.cpp
+++ b/library/cpp/actors/core/log_settings.cpp
@@ -6,11 +6,11 @@ namespace NActors {
     namespace NLog {
         TSettings::TSettings(const TActorId& loggerActorId, const EComponent loggerComponent,
                              EComponent minVal, EComponent maxVal, EComponentToStringFunc func,
-                             EPriority defPriority, EPriority defSamplingPriority,
-                             ui32 defSamplingRate, ui64 timeThresholdMs)
+                             EPriority defPriority, EPriority defSamplingPriority, 
+                             ui32 defSamplingRate, ui64 timeThresholdMs) 
             : LoggerActorId(loggerActorId)
             , LoggerComponent(loggerComponent)
-            , TimeThresholdMs(timeThresholdMs)
+            , TimeThresholdMs(timeThresholdMs) 
             , AllowDrop(true)
             , ThrottleDelay(TDuration::MilliSeconds(100))
             , MinVal(0)
@@ -28,11 +28,11 @@ namespace NActors {
         }
 
         TSettings::TSettings(const TActorId& loggerActorId, const EComponent loggerComponent,
-                             EPriority defPriority, EPriority defSamplingPriority,
-                             ui32 defSamplingRate, ui64 timeThresholdMs)
+                             EPriority defPriority, EPriority defSamplingPriority, 
+                             ui32 defSamplingRate, ui64 timeThresholdMs) 
             : LoggerActorId(loggerActorId)
             , LoggerComponent(loggerComponent)
-            , TimeThresholdMs(timeThresholdMs)
+            , TimeThresholdMs(timeThresholdMs) 
             , AllowDrop(true)
             , ThrottleDelay(TDuration::MilliSeconds(100))
             , MinVal(0)
diff --git a/library/cpp/actors/core/log_settings.h b/library/cpp/actors/core/log_settings.h
index 7fe4504edd..ebb689be09 100644
--- a/library/cpp/actors/core/log_settings.h
+++ b/library/cpp/actors/core/log_settings.h
@@ -100,12 +100,12 @@ namespace NActors {
             // YOURTYPE_Name for you.
             TSettings(const TActorId& loggerActorId, const EComponent loggerComponent,
                       EComponent minVal, EComponent maxVal, EComponentToStringFunc func,
-                      EPriority defPriority, EPriority defSamplingPriority = PRI_DEBUG,
-                      ui32 defSamplingRate = 0, ui64 timeThresholdMs = 1000);
+                      EPriority defPriority, EPriority defSamplingPriority = PRI_DEBUG, 
+                      ui32 defSamplingRate = 0, ui64 timeThresholdMs = 1000); 
 
             TSettings(const TActorId& loggerActorId, const EComponent loggerComponent,
-                      EPriority defPriority, EPriority defSamplingPriority = PRI_DEBUG,
-                      ui32 defSamplingRate = 0, ui64 timeThresholdMs = 1000);
+                      EPriority defPriority, EPriority defSamplingPriority = PRI_DEBUG, 
+                      ui32 defSamplingRate = 0, ui64 timeThresholdMs = 1000); 
 
             void Append(EComponent minVal, EComponent maxVal, EComponentToStringFunc func);
 
diff --git a/library/cpp/actors/core/log_ut.cpp b/library/cpp/actors/core/log_ut.cpp
index 09b5f88ea2..d742357e3f 100644
--- a/library/cpp/actors/core/log_ut.cpp
+++ b/library/cpp/actors/core/log_ut.cpp
@@ -22,19 +22,19 @@ namespace {
         return s;
     }
 
-    TIntrusivePtr<TSettings> DroppingSettings(ui64 timeThresholdMs) {
-        auto loggerId = TActorId{0, "Logger"};
-        auto s = MakeIntrusive<TSettings>(
-            loggerId,
-            0,
-            EPriority::PRI_TRACE,
-            EPriority::PRI_DEBUG,
-            (ui32)0,
-            timeThresholdMs);
-        s->Append(0, 1, ServiceToString);
-        return s;
-    }
-
+    TIntrusivePtr<TSettings> DroppingSettings(ui64 timeThresholdMs) { 
+        auto loggerId = TActorId{0, "Logger"}; 
+        auto s = MakeIntrusive<TSettings>( 
+            loggerId, 
+            0, 
+            EPriority::PRI_TRACE, 
+            EPriority::PRI_DEBUG, 
+            (ui32)0, 
+            timeThresholdMs); 
+        s->Append(0, 1, ServiceToString); 
+        return s; 
+    } 
+ 
     class TMockBackend: public TLogBackend {
     public:
         using TWriteImpl = std::function<void(const TLogRecord&)>;
@@ -68,30 +68,30 @@ namespace {
     };
 
     struct TFixture {
-        TFixture(
-            TIntrusivePtr<TSettings> settings,
-            TMockBackend::TWriteImpl writeImpl = ThrowAlways)
-        {
+        TFixture( 
+            TIntrusivePtr<TSettings> settings, 
+            TMockBackend::TWriteImpl writeImpl = ThrowAlways) 
+        { 
             Runtime.Initialize();
             LogBackend.reset(new TMockBackend{writeImpl});
-            LoggerActor = Runtime.Register(new TLoggerActor{settings, LogBackend, Counters});
+            LoggerActor = Runtime.Register(new TLoggerActor{settings, LogBackend, Counters}); 
             Runtime.SetScheduledEventFilter([] (auto&&, auto&&, auto&&, auto) {
                 return false;
             });
         }
 
-        TFixture(TMockBackend::TWriteImpl writeImpl = ThrowAlways)
-            : TFixture(DefaultSettings(), writeImpl)
-        {}
-
+        TFixture(TMockBackend::TWriteImpl writeImpl = ThrowAlways) 
+            : TFixture(DefaultSettings(), writeImpl) 
+        {} 
+ 
         void WriteLog() {
             Runtime.Send(new IEventHandle{LoggerActor, {}, new TEvLog(TInstant::Zero(), TLevel{EPrio::Emerg}, 0, "foo")});
         }
 
-        void WriteLog(TInstant ts) {
-            Runtime.Send(new IEventHandle{LoggerActor, {}, new TEvLog(ts, TLevel{EPrio::Emerg}, 0, "foo")});
-        }
-
+        void WriteLog(TInstant ts) { 
+            Runtime.Send(new IEventHandle{LoggerActor, {}, new TEvLog(ts, TLevel{EPrio::Emerg}, 0, "foo")}); 
+        } 
+ 
         void Wakeup() {
             Runtime.Send(new IEventHandle{LoggerActor, {}, new TEvents::TEvWakeup});
         }
@@ -152,34 +152,34 @@ Y_UNIT_TEST_SUITE(TLoggerActorTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(messages.size(), COUNT);
     }
-
-    Y_UNIT_TEST(ShouldObeyTimeThresholdMsWhenOverloaded) {
-        TFixture test{DroppingSettings(5000)};
-
-        TVector<TString> messages;
-        auto acceptWrites = [&] (const TLogRecord& r) {
-            messages.emplace_back(r.Data, r.Len);
-        };
-
-        test.LogBackend->SetWriteImpl(acceptWrites);
-        test.Wakeup();
-
-        const auto COUNT = 11;
-        for (auto i = 0; i < COUNT; ++i) {
-            test.WriteLog();
-        }
-
-        UNIT_ASSERT_VALUES_EQUAL(messages.size(), COUNT);
-
-        test.Runtime.AdvanceCurrentTime(TDuration::Seconds(20));
-        auto now = test.Runtime.GetCurrentTime();
-
-        test.WriteLog(now - TDuration::Seconds(5));
-
-        UNIT_ASSERT_VALUES_EQUAL(messages.size(), COUNT + 1);
-
-        test.WriteLog(now - TDuration::Seconds(6));
-
-        UNIT_ASSERT_VALUES_EQUAL(messages.size(), COUNT + 1);
-    }
+ 
+    Y_UNIT_TEST(ShouldObeyTimeThresholdMsWhenOverloaded) { 
+        TFixture test{DroppingSettings(5000)}; 
+ 
+        TVector<TString> messages; 
+        auto acceptWrites = [&] (const TLogRecord& r) { 
+            messages.emplace_back(r.Data, r.Len); 
+        }; 
+ 
+        test.LogBackend->SetWriteImpl(acceptWrites); 
+        test.Wakeup(); 
+ 
+        const auto COUNT = 11; 
+        for (auto i = 0; i < COUNT; ++i) { 
+            test.WriteLog(); 
+        } 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(messages.size(), COUNT); 
+ 
+        test.Runtime.AdvanceCurrentTime(TDuration::Seconds(20)); 
+        auto now = test.Runtime.GetCurrentTime(); 
+ 
+        test.WriteLog(now - TDuration::Seconds(5)); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(messages.size(), COUNT + 1); 
+ 
+        test.WriteLog(now - TDuration::Seconds(6)); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(messages.size(), COUNT + 1); 
+    } 
 }
diff --git a/library/cpp/actors/core/mon.h b/library/cpp/actors/core/mon.h
index c450f2338e..3854356fa8 100644
--- a/library/cpp/actors/core/mon.h
+++ b/library/cpp/actors/core/mon.h
@@ -88,14 +88,14 @@ namespace NActors {
             {
             }
 
-            TEvRemoteHttpInfo(const TString& query, HTTP_METHOD method)
-                : Query(query)
-                , Method(method)
-            {
-            }
-
+            TEvRemoteHttpInfo(const TString& query, HTTP_METHOD method) 
+                : Query(query) 
+                , Method(method) 
+            { 
+            } 
+ 
             TString Query;
-            HTTP_METHOD Method;
+            HTTP_METHOD Method; 
 
             TString PathInfo() const {
                 const size_t pos = Query.find('?');
@@ -126,11 +126,11 @@ namespace NActors {
             static IEventBase* Load(TEventSerializedData* bufs) {
                 return new TEvRemoteHttpInfo(bufs->GetString());
             }
-
-            HTTP_METHOD GetMethod() const
-            {
-                return Method;
-            }
+ 
+            HTTP_METHOD GetMethod() const 
+            { 
+                return Method; 
+            } 
         };
 
         struct TEvRemoteHttpInfoRes: public NActors::TEventBase<TEvRemoteHttpInfoRes, RemoteHttpInfoRes> {
diff --git a/library/cpp/logger/system.cpp b/library/cpp/logger/system.cpp
index 42233f63d2..172719c716 100644
--- a/library/cpp/logger/system.cpp
+++ b/library/cpp/logger/system.cpp
@@ -4,7 +4,7 @@
 #include <util/system/yassert.h>
 #include <util/system/defaults.h>
 #include <util/generic/singleton.h>
-#include <util/generic/utility.h>
+#include <util/generic/utility.h> 
 
 #if defined(_unix_)
 #include <syslog.h>
@@ -64,12 +64,12 @@ void TSysLogBackend::ReopenLog() {
 }
 
 int TSysLogBackend::ELogPriority2SyslogPriority(ELogPriority priority) {
-#if defined(_unix_)
-     return Min(int(priority), (int)LOG_PRIMASK);
-#else
+#if defined(_unix_) 
+     return Min(int(priority), (int)LOG_PRIMASK); 
+#else 
     // trivial conversion
     return int(priority);
-#endif
+#endif 
 }
 
 namespace {
diff --git a/library/cpp/lwtrace/control.cpp b/library/cpp/lwtrace/control.cpp
index d9404ff269..ffed939922 100644
--- a/library/cpp/lwtrace/control.cpp
+++ b/library/cpp/lwtrace/control.cpp
@@ -1,97 +1,97 @@
-#include "probes.h"
-
-#include <library/cpp/lwtrace/protos/lwtrace.pb.h>
-
-#include <util/generic/string.h>
-
-namespace NLWTrace {
-
-LWTRACE_USING(LWTRACE_INTERNAL_PROVIDER);
-
-TProbeMap TManager::GetProbesMap() {
-    class TProbeReader
-    {
-    private:
-        TProbeMap& Result;
-
-    public:
-        TProbeReader(TProbeMap& result)
-            : Result(result)
-        {}
-
-        void Push(NLWTrace::TProbe* probe)
-        {
-            Result[std::make_pair(probe->Event.Name, probe->Event.GetProvider())] = probe;
-        }
-    };
-
-    TProbeMap result;
-
-    auto reader = TProbeReader(result);
-    ReadProbes(reader);
-    return result;
-}
-
-void TManager::CreateTraceRequest(TTraceRequest& msg, TOrbit& orbit)
-{
-    msg.SetIsTraced(orbit.HasShuttles());
-}
-
-bool TManager::HandleTraceRequest(
-    const TTraceRequest& msg,
-    TOrbit& orbit)
-{
-    if (!msg.GetIsTraced()) {
-        return false;
-    }
-    TParams params;
-    SerializingExecutor->Execute(orbit, params);
-    return true;
-}
-
-TTraceDeserializeStatus TManager::HandleTraceResponse(
-    const TTraceResponse& msg,
-    const TProbeMap& probesMap,
-    TOrbit& orbit,
-    i64 timeOffset,
-    double timeScale)
-{
-    TTraceDeserializeStatus result;
-    if (!msg.GetTrace().GetEvents().size()) {
-        return result;
-    }
-
-    ui64 prev = EpochNanosecondsToCycles(
-        msg.GetTrace().GetEvents()[0].GetTimestampNanosec());
-
-    for (auto& v : msg.GetTrace().GetEvents()) {
-        auto it = probesMap.find(std::make_pair(v.GetName(), v.GetProvider()));
-        if (it != probesMap.end()) {
-            TProbe* probe = it->second;
-            TParams params;
-            if(!probe->Event.Signature.DeserializeFromPb(params, v.GetParams())) {
-                LWTRACK(DeserializationError, orbit, probe->Event.Name, probe->Event.GetProvider());
-                result.AddFailedEventName(v.GetName());
-            } else {
-                ui64 timestamp = EpochNanosecondsToCycles(v.GetTimestampNanosec());
-                orbit.AddProbe(
-                    probe,
-                    params,
-                    prev + (timestamp-prev)*timeScale + timeOffset);
-                probe->Event.Signature.DestroyParams(params);
-                prev = timestamp;
-            }
-        } else {
-            result.AddFailedEventName(v.GetName());
-        }
-    }
-    return result;
-}
-
-void TManager::CreateTraceResponse(TTraceResponse& msg, TOrbit& orbit)
-{
-    orbit.Serialize(0, *msg.MutableTrace());
-}
-
-}
-
+#include "probes.h" 
+ 
+#include <library/cpp/lwtrace/protos/lwtrace.pb.h> 
+ 
+#include <util/generic/string.h> 
+ 
+namespace NLWTrace { 
+ 
+LWTRACE_USING(LWTRACE_INTERNAL_PROVIDER); 
+ 
+TProbeMap TManager::GetProbesMap() { 
+    class TProbeReader 
+    { 
+    private: 
+        TProbeMap& Result; 
+ 
+    public: 
+        TProbeReader(TProbeMap& result) 
+            : Result(result) 
+        {} 
+ 
+        void Push(NLWTrace::TProbe* probe) 
+        { 
+            Result[std::make_pair(probe->Event.Name, probe->Event.GetProvider())] = probe; 
+        } 
+    }; 
+ 
+    TProbeMap result; 
+ 
+    auto reader = TProbeReader(result); 
+    ReadProbes(reader); 
+    return result; 
+} 
+ 
+void TManager::CreateTraceRequest(TTraceRequest& msg, TOrbit& orbit) 
+{ 
+    msg.SetIsTraced(orbit.HasShuttles()); 
+} 
+ 
+bool TManager::HandleTraceRequest( 
+    const TTraceRequest& msg, 
+    TOrbit& orbit) 
+{ 
+    if (!msg.GetIsTraced()) { 
+        return false; 
+    } 
+    TParams params; 
+    SerializingExecutor->Execute(orbit, params); 
+    return true; 
+} 
+ 
+TTraceDeserializeStatus TManager::HandleTraceResponse( 
+    const TTraceResponse& msg, 
+    const TProbeMap& probesMap, 
+    TOrbit& orbit, 
+    i64 timeOffset, 
+    double timeScale) 
+{ 
+    TTraceDeserializeStatus result; 
+    if (!msg.GetTrace().GetEvents().size()) { 
+        return result; 
+    } 
+ 
+    ui64 prev = EpochNanosecondsToCycles( 
+        msg.GetTrace().GetEvents()[0].GetTimestampNanosec()); 
+ 
+    for (auto& v : msg.GetTrace().GetEvents()) { 
+        auto it = probesMap.find(std::make_pair(v.GetName(), v.GetProvider())); 
+        if (it != probesMap.end()) { 
+            TProbe* probe = it->second; 
+            TParams params; 
+            if(!probe->Event.Signature.DeserializeFromPb(params, v.GetParams())) { 
+                LWTRACK(DeserializationError, orbit, probe->Event.Name, probe->Event.GetProvider()); 
+                result.AddFailedEventName(v.GetName()); 
+            } else { 
+                ui64 timestamp = EpochNanosecondsToCycles(v.GetTimestampNanosec()); 
+                orbit.AddProbe( 
+                    probe, 
+                    params, 
+                    prev + (timestamp-prev)*timeScale + timeOffset); 
+                probe->Event.Signature.DestroyParams(params); 
+                prev = timestamp; 
+            } 
+        } else { 
+            result.AddFailedEventName(v.GetName()); 
+        } 
+    } 
+    return result; 
+} 
+ 
+void TManager::CreateTraceResponse(TTraceResponse& msg, TOrbit& orbit) 
+{ 
+    orbit.Serialize(0, *msg.MutableTrace()); 
+} 
+ 
+} 
+ 
diff --git a/library/cpp/lwtrace/control.h b/library/cpp/lwtrace/control.h
index 16b24eafd2..b85e8468be 100644
--- a/library/cpp/lwtrace/control.h
+++ b/library/cpp/lwtrace/control.h
@@ -3,7 +3,7 @@
 #include "custom_action.h"
 #include "event.h"
 #include "log.h"
-#include "log_shuttle.h"
+#include "log_shuttle.h" 
 #include "probe.h"
 
 #include <library/cpp/lwtrace/protos/lwtrace.pb.h>
@@ -18,9 +18,9 @@
 #include <util/generic/vector.h>
 
 namespace NLWTrace {
-
-    using TProbeMap = THashMap<std::pair<TString, TString>, TProbe*>;
-
+ 
+    using TProbeMap = THashMap<std::pair<TString, TString>, TProbe*>; 
+ 
     // Interface for probe ownership management
     class IBox: public virtual TThrRefBase {
     private:
@@ -203,38 +203,38 @@ namespace NLWTrace {
         void ToProtobuf(TLogPb& pb) const;
     };
 
-    // Deserialization result.
-    // Either IsSuccess is true or FailedEventNames contains event names
-    // we were not able to deserialize.
-    struct TTraceDeserializeStatus
-    {
-        bool IsSuccess = true;
-        TVector<TString> FailedEventNames;
-
-        void AddFailedEventName(const TString& name)
-        {
-            IsSuccess = false;
-            FailedEventNames.emplace_back(name);
-        }
-    };
-
+    // Deserialization result. 
+    // Either IsSuccess is true or FailedEventNames contains event names 
+    // we were not able to deserialize. 
+    struct TTraceDeserializeStatus 
+    { 
+        bool IsSuccess = true; 
+        TVector<TString> FailedEventNames; 
+ 
+        void AddFailedEventName(const TString& name) 
+        { 
+            IsSuccess = false; 
+            FailedEventNames.emplace_back(name); 
+        } 
+    }; 
+ 
     // Just a registry of all active trace queries
     // Facade for all interactions with probes/traces
     class TManager: public TNonCopyable {
     private:
         TProbeRegistry& Registry;
         TMutex Mtx;
-        ui64 LastTraceIdx = 1;
+        ui64 LastTraceIdx = 1; 
         typedef THashMap<TString, TSession*> TTraces; // traceId -> TSession
         TTraces Traces;
         bool DestructiveActionsAllowed;
         TCustomActionFactory CustomActionFactory;
-        THolder<TRunLogShuttleActionExecutor<TCyclicDepot>> SerializingExecutor;
-
-    public:
-        static constexpr ui64 RemoteTraceIdx = 0;
+        THolder<TRunLogShuttleActionExecutor<TCyclicDepot>> SerializingExecutor; 
 
     public:
+        static constexpr ui64 RemoteTraceIdx = 0; 
+ 
+    public: 
         TManager(TProbeRegistry& registry, bool allowDestructiveActions);
         ~TManager();
         bool HasTrace(const TString& id) const;
@@ -324,28 +324,28 @@ namespace NLWTrace {
                 return new T(probe, action, trace);
             });
         }
-
-        TProbeMap GetProbesMap();
-
-        void CreateTraceRequest(TTraceRequest& msg, TOrbit& orbit);
-
-        bool HandleTraceRequest(
-            const TTraceRequest& msg,
-            TOrbit& orbit);
-
-        TTraceDeserializeStatus HandleTraceResponse(
-            const TTraceResponse& msg,
-            const TProbeMap& probesMap,
-            TOrbit& orbit,
-            i64 timeOffset = 0,
-            double timeScale = 1);
-
-        void CreateTraceResponse(
-            TTraceResponse& msg,
-            TOrbit& orbit);
-
-        bool IsTraced(TOrbit& orbit) {
-            return orbit.HasShuttle(TManager::RemoteTraceIdx);
-        }
+ 
+        TProbeMap GetProbesMap(); 
+ 
+        void CreateTraceRequest(TTraceRequest& msg, TOrbit& orbit); 
+ 
+        bool HandleTraceRequest( 
+            const TTraceRequest& msg, 
+            TOrbit& orbit); 
+ 
+        TTraceDeserializeStatus HandleTraceResponse( 
+            const TTraceResponse& msg, 
+            const TProbeMap& probesMap, 
+            TOrbit& orbit, 
+            i64 timeOffset = 0, 
+            double timeScale = 1); 
+ 
+        void CreateTraceResponse( 
+            TTraceResponse& msg, 
+            TOrbit& orbit); 
+ 
+        bool IsTraced(TOrbit& orbit) { 
+            return orbit.HasShuttle(TManager::RemoteTraceIdx); 
+        } 
     };
 }
diff --git a/library/cpp/lwtrace/log_shuttle.h b/library/cpp/lwtrace/log_shuttle.h
index 729a38615f..d3d5fe0bde 100644
--- a/library/cpp/lwtrace/log_shuttle.h
+++ b/library/cpp/lwtrace/log_shuttle.h
@@ -3,8 +3,8 @@
 #include "log.h"
 #include "probe.h"
 
-#include <library/cpp/lwtrace/protos/lwtrace.pb.h>
-
+#include <library/cpp/lwtrace/protos/lwtrace.pb.h> 
+ 
 #include <util/system/spinlock.h>
 
 namespace NLWTrace {
@@ -14,35 +14,35 @@ namespace NLWTrace {
     ////////////////////////////////////////////////////////////////////////////////
 
     struct THostTimeCalculator {
-        double K = 0;
-        ui64 B = 0;
-
+        double K = 0; 
+        ui64 B = 0; 
+ 
         THostTimeCalculator() {
-            TInstant now = TInstant::Now();
-            ui64 tsNow = GetCycleCount();
-            K = 1000000000 / NHPTimer::GetClockRate();
-            B = now.NanoSeconds() - K * tsNow;
-        }
-
+            TInstant now = TInstant::Now(); 
+            ui64 tsNow = GetCycleCount(); 
+            K = 1000000000 / NHPTimer::GetClockRate(); 
+            B = now.NanoSeconds() - K * tsNow; 
+        } 
+ 
         ui64 CyclesToEpochNanoseconds(ui64 cycles) const {
-            return K*cycles + B;
-        }
-
+            return K*cycles + B; 
+        } 
+ 
         ui64 EpochNanosecondsToCycles(ui64 ns) const {
-            return (ns - B) / K;
-        }
-    };
-
+            return (ns - B) / K; 
+        } 
+    }; 
+ 
     inline ui64 CyclesToEpochNanoseconds(ui64 cycles) {
-        return Singleton<THostTimeCalculator>()->CyclesToEpochNanoseconds(cycles);
-    }
-
+        return Singleton<THostTimeCalculator>()->CyclesToEpochNanoseconds(cycles); 
+    } 
+ 
     inline ui64 EpochNanosecondsToCycles(ui64 ns) {
-        return Singleton<THostTimeCalculator>()->EpochNanosecondsToCycles(ns);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////
-
+        return Singleton<THostTimeCalculator>()->EpochNanosecondsToCycles(ns); 
+    } 
+ 
+    //////////////////////////////////////////////////////////////////////////////// 
+ 
     template <class TDepot>
     class TLogShuttle: public IShuttle {
     private:
@@ -62,10 +62,10 @@ namespace NLWTrace {
         {
         }
 
-        bool DoAddProbe(TProbe* probe, const TParams& params, ui64 timestamp) override;
+        bool DoAddProbe(TProbe* probe, const TParams& params, ui64 timestamp) override; 
         void DoEndOfTrack() override;
         void DoDrop() override;
-        void DoSerialize(TShuttleTrace& msg) override;
+        void DoSerialize(TShuttleTrace& msg) override; 
         bool DoFork(TShuttlePtr& child) override;
         bool DoJoin(const TShuttlePtr& child) override;
 
@@ -155,7 +155,7 @@ namespace NLWTrace {
     ////////////////////////////////////////////////////////////////////////////////
 
     template <class TDepot>
-    bool TLogShuttle<TDepot>::DoAddProbe(TProbe* probe, const TParams& params, ui64 timestamp) {
+    bool TLogShuttle<TDepot>::DoAddProbe(TProbe* probe, const TParams& params, ui64 timestamp) { 
         with_lock (Lock) {
             if (TrackLog.Items.size() >= MaxTrackLength) {
                 TrackLog.Truncated = true;
@@ -168,7 +168,7 @@ namespace NLWTrace {
             if ((item->SavedParamsCount = probe->Event.Signature.ParamCount) > 0) {
                 probe->Event.Signature.CloneParams(item->Params, params);
             }
-            item->TimestampCycles = timestamp ? timestamp : GetCycleCount();
+            item->TimestampCycles = timestamp ? timestamp : GetCycleCount(); 
         }
 
         return true;
@@ -204,25 +204,25 @@ namespace NLWTrace {
     }
 
     template <class TDepot>
-    void TLogShuttle<TDepot>::DoSerialize(TShuttleTrace& msg)
-    {
-        with_lock (Lock)
-        {
-            if (!GetTrackLog().Items.size()) {
-                return ;
-            }
-            for (auto& record : GetTrackLog().Items) {
-                auto *rec = msg.AddEvents();
-                rec->SetName(record.Probe->Event.Name);
-                rec->SetProvider(record.Probe->Event.GetProvider());
-                rec->SetTimestampNanosec(
-                    CyclesToEpochNanoseconds(record.TimestampCycles));
-                record.Probe->Event.Signature.SerializeToPb(record.Params, *rec->MutableParams());
-            }
-        }
-    }
-
-    template <class TDepot>
+    void TLogShuttle<TDepot>::DoSerialize(TShuttleTrace& msg) 
+    { 
+        with_lock (Lock) 
+        { 
+            if (!GetTrackLog().Items.size()) { 
+                return ; 
+            } 
+            for (auto& record : GetTrackLog().Items) { 
+                auto *rec = msg.AddEvents(); 
+                rec->SetName(record.Probe->Event.Name); 
+                rec->SetProvider(record.Probe->Event.GetProvider()); 
+                rec->SetTimestampNanosec( 
+                    CyclesToEpochNanoseconds(record.TimestampCycles)); 
+                record.Probe->Event.Signature.SerializeToPb(record.Params, *rec->MutableParams()); 
+            } 
+        } 
+    } 
+ 
+    template <class TDepot> 
     TLogShuttle<TDepot>* TLogShuttleActionBase<TDepot>::Cast(const TShuttlePtr& shuttle) {
         return static_cast<TLogShuttle<TDepot>*>(shuttle.Get());
     }
@@ -247,7 +247,7 @@ namespace NLWTrace {
         , LastTrackId(lastTrackId)
         , LastSpanId(lastSpanId)
     {
-        ui64 size = Min<ui64>(Action.GetShuttlesCount() ? Action.GetShuttlesCount() : 1000, MaxShuttles); // Do not allow to allocate too much memory
+        ui64 size = Min<ui64>(Action.GetShuttlesCount() ? Action.GetShuttlesCount() : 1000, MaxShuttles); // Do not allow to allocate too much memory 
         AllShuttles.reserve(size);
         Parking.reserve(size);
         for (ui64 i = 0; i < size; i++) {
@@ -283,9 +283,9 @@ namespace NLWTrace {
 
     template <class TDepot>
     void TRunLogShuttleActionExecutor<TDepot>::RecordShuttle(TLogShuttle<TDepot>* shuttle) {
-        if (Depot == nullptr) {
-            return;
-        }
+        if (Depot == nullptr) { 
+            return; 
+        } 
         typename TDepot::TAccessor a(*Depot);
         if (TTrackLog* trackLog = a.Add()) {
             *trackLog = shuttle->GetTrackLog();
diff --git a/library/cpp/lwtrace/lwprobe.h b/library/cpp/lwtrace/lwprobe.h
index 801fc3861b..021a580b2e 100644
--- a/library/cpp/lwtrace/lwprobe.h
+++ b/library/cpp/lwtrace/lwprobe.h
@@ -61,8 +61,8 @@ namespace NLWTrace {
             signature.SerializeParamsFunc = &TUsrSign::SerializeParams;
             signature.CloneParamsFunc = &TUsrSign::CloneParams;
             signature.DestroyParamsFunc = &TUsrSign::DestroyParams;
-            signature.SerializeToPbFunc = &TUsrSign::SerializeToPb;
-            signature.DeserializeFromPbFunc = &TUsrSign::DeserializeFromPb;
+            signature.SerializeToPbFunc = &TUsrSign::SerializeToPb; 
+            signature.DeserializeFromPbFunc = &TUsrSign::DeserializeFromPb; 
 
             // register probe in global registry
             Register(*Singleton<NLWTrace::TProbeRegistry>());
diff --git a/library/cpp/lwtrace/mon/mon_lwtrace.cpp b/library/cpp/lwtrace/mon/mon_lwtrace.cpp
index a61ee9ce22..4ca9ff15f0 100644
--- a/library/cpp/lwtrace/mon/mon_lwtrace.cpp
+++ b/library/cpp/lwtrace/mon/mon_lwtrace.cpp
@@ -511,9 +511,9 @@ struct TAdHocTraceConfig {
             }
             auto block = Cfg.GetBlocks(blockIdx);
             auto pdesc = block.GetProbeDesc();
-            if (pdesc.GetProvider()) {
+            if (pdesc.GetProvider()) { 
                 ss << "." << pdesc.GetProvider() << "." << pdesc.GetName();
-            } else if (pdesc.GetGroup()) {
+            } else if (pdesc.GetGroup()) { 
                 ss << ".Group." << pdesc.GetGroup();
             }
             // TODO[serxa]: handle predicate
@@ -525,10 +525,10 @@ struct TAdHocTraceConfig {
                     if (ls.GetIgnore()) {
                         ss << "-i";
                     }
-                    if (ls.GetShuttlesCount()) {
+                    if (ls.GetShuttlesCount()) { 
                         ss << "-s" << ls.GetShuttlesCount();
                     }
-                    if (ls.GetMaxTrackLength()) {
+                    if (ls.GetMaxTrackLength()) { 
                         ss << "-t" << ls.GetMaxTrackLength();
                     }
                 } else if (action.HasEditLogShuttleAction()) {
@@ -542,10 +542,10 @@ struct TAdHocTraceConfig {
                 }
             }
         }
-        if (Cfg.GetPerThreadLogSize()) {
+        if (Cfg.GetPerThreadLogSize()) { 
             ss << ".l" << Cfg.GetPerThreadLogSize();
         }
-        if (Cfg.GetLogDurationUs()) {
+        if (Cfg.GetLogDurationUs()) { 
             ui64 logDurationUs = Cfg.GetLogDurationUs();
             if (logDurationUs % (60 * 1000 * 1000) == 0)
                 ss << ".d" << logDurationUs / (60 * 1000 * 1000) << "m";
diff --git a/library/cpp/lwtrace/preprocessor.h b/library/cpp/lwtrace/preprocessor.h
index 40865467b2..1945a55c18 100644
--- a/library/cpp/lwtrace/preprocessor.h
+++ b/library/cpp/lwtrace/preprocessor.h
@@ -172,9 +172,9 @@ namespace NLWTrace {
             /* ParamCount */ ::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::ParamCount,            \
             /* SerializeParams */ &::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::SerializeParams, \
             /* CloneParams */ &::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::CloneParams,         \
-            /* DestroyParams */ &::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::DestroyParams,     \
-            /* SerializeToPb */ &::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::SerializeToPb,     \
-            /* DeserializeFromPb */ &::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::DeserializeFromPb\
+            /* DestroyParams */ &::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::DestroyParams,     \ 
+            /* SerializeToPb */ &::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::SerializeToPb,     \ 
+            /* DeserializeFromPb */ &::NLWTrace::TUserSignature<LWTRACE_EXPAND(LWTRACE_UNROLL types)>::DeserializeFromPb\ 
     }
 
 // Macro for TEvent POD structure static initialization
diff --git a/library/cpp/lwtrace/probes.h b/library/cpp/lwtrace/probes.h
index 68810bd118..4adcf7d00d 100644
--- a/library/cpp/lwtrace/probes.h
+++ b/library/cpp/lwtrace/probes.h
@@ -7,8 +7,8 @@
           TYPES(double, double, double, double),                         \
           NAMES("probeShare", "probeMinMs", "probeMaxMs", "probeAvgMs")) \
     PROBE(DeserializationError, GROUPS("LWTraceError"),                  \
-          TYPES(TString, TString),                                       \
-          NAMES("probeName", "providerName"))                            \
+          TYPES(TString, TString),                                       \ 
+          NAMES("probeName", "providerName"))                            \ 
     PROBE(Fork, GROUPS(),                                                \
           TYPES(ui64),                                                   \
           NAMES("spanId"))                                               \
diff --git a/library/cpp/lwtrace/protos/lwtrace.proto b/library/cpp/lwtrace/protos/lwtrace.proto
index 0051095719..bdf6551a48 100644
--- a/library/cpp/lwtrace/protos/lwtrace.proto
+++ b/library/cpp/lwtrace/protos/lwtrace.proto
@@ -1,35 +1,35 @@
 /*
  * This file defines language for trace queries and serialization format for trace logs
  */
-syntax = "proto3";
-
+syntax = "proto3"; 
+ 
 package NLWTrace;
 
-option go_package = "a.yandex-team.ru/library/cpp/lwtrace/protos";
-
+option go_package = "a.yandex-team.ru/library/cpp/lwtrace/protos"; 
+ 
 message TProbeDesc {
-    string Name = 1; // Use either name+provider
-    string Provider = 3;
-    string Group = 2; // or group
+    string Name = 1; // Use either name+provider 
+    string Provider = 3; 
+    string Group = 2; // or group 
 }
 
 enum EOperatorType {
-    OT_EQ = 0;
-    OT_NE = 1;
-    OT_LT = 2;
-    OT_LE = 3;
-    OT_GT = 4;
-    OT_GE = 5;
+    OT_EQ = 0; 
+    OT_NE = 1; 
+    OT_LT = 2; 
+    OT_LE = 3; 
+    OT_GT = 4; 
+    OT_GE = 5; 
 }
 
 message TArgument {
-    string Param = 1;
+    string Param = 1; 
     bytes Value = 2;
-    string Variable = 3;
+    string Variable = 3; 
 }
 
 message TOperator {
-    EOperatorType Type = 1;
+    EOperatorType Type = 1; 
     repeated TArgument Argument = 8;
 }
 
@@ -39,9 +39,9 @@ message TPredicate {
 }
 
 message TLogAction {
-    bool DoNotLogParams = 2;
-    bool LogTimestamp = 3;
-    uint32 MaxRecords = 4; // Do not write more than MaxRecords records to the log (count from the trace beginning, not start)
+    bool DoNotLogParams = 2; 
+    bool LogTimestamp = 3; 
+    uint32 MaxRecords = 4; // Do not write more than MaxRecords records to the log (count from the trace beginning, not start) 
 }
 
 message TPrintToStderrAction {
@@ -51,72 +51,72 @@ message TKillAction {
 }
 
 message TSleepAction {
-    uint64 NanoSeconds = 1;
+    uint64 NanoSeconds = 1; 
 }
 
 message TCustomAction {
-    string Name = 1;
+    string Name = 1; 
     repeated string Opts = 2;
 }
 
 enum EStatementType {
-    ST_MOV = 0;
-    ST_ADD = 1;
-    ST_SUB = 2;
-    ST_MUL = 3;
-    ST_DIV = 4;
-    ST_MOD = 5;
-    ST_ADD_EQ = 6;
-    ST_SUB_EQ = 7;
-    ST_INC = 8;
-    ST_DEC = 9;
+    ST_MOV = 0; 
+    ST_ADD = 1; 
+    ST_SUB = 2; 
+    ST_MUL = 3; 
+    ST_DIV = 4; 
+    ST_MOD = 5; 
+    ST_ADD_EQ = 6; 
+    ST_SUB_EQ = 7; 
+    ST_INC = 8; 
+    ST_DEC = 9; 
 }
 
 message TStatementAction {
-    EStatementType Type = 1;
+    EStatementType Type = 1; 
     repeated TArgument Argument = 2;
 }
 
 message TRunLogShuttleAction {
-    bool Ignore = 1;
-    uint64 ShuttlesCount = 2;
-    uint64 MaxTrackLength = 3;
+    bool Ignore = 1; 
+    uint64 ShuttlesCount = 2; 
+    uint64 MaxTrackLength = 3; 
 }
 
 message TEditLogShuttleAction {
-    bool Ignore = 1;
+    bool Ignore = 1; 
 }
 
 message TDropLogShuttleAction {
 }
 
 message TAction {
-    TLogAction LogAction = 2;
-    TPrintToStderrAction PrintToStderrAction = 3;
-    TCustomAction CustomAction = 4;
-    TKillAction KillAction = 6;
-    TSleepAction SleepAction = 7;
-    TStatementAction StatementAction = 8;
-
-    TRunLogShuttleAction RunLogShuttleAction = 100;
-    TEditLogShuttleAction EditLogShuttleAction = 101;
-    TDropLogShuttleAction DropLogShuttleAction = 102;
+    TLogAction LogAction = 2; 
+    TPrintToStderrAction PrintToStderrAction = 3; 
+    TCustomAction CustomAction = 4; 
+    TKillAction KillAction = 6; 
+    TSleepAction SleepAction = 7; 
+    TStatementAction StatementAction = 8; 
+
+    TRunLogShuttleAction RunLogShuttleAction = 100; 
+    TEditLogShuttleAction EditLogShuttleAction = 101; 
+    TDropLogShuttleAction DropLogShuttleAction = 102; 
 }
 
 message TBlock {
-    TProbeDesc ProbeDesc = 1;
-    TPredicate Predicate = 2;
+    TProbeDesc ProbeDesc = 1; 
+    TPredicate Predicate = 2; 
     repeated TAction Action = 3;
 }
 
 message TQuery {
     // Number of events to hold for every thread in cyclic buffer
     // (Won't be used if LogDurationUs is set to non-zero value)
-    uint32 PerThreadLogSize = 1;
+    uint32 PerThreadLogSize = 1; 
 
     // Hold events for last Duration microseconds
     // (If zero, than per-thread cyclic buffer will be used to store events)
-    uint64 LogDurationUs = 2;
+    uint64 LogDurationUs = 2; 
 
     repeated TBlock Blocks = 3;
 }
@@ -153,114 +153,114 @@ enum EParamTypePb {
 }
 
 message TEventPb {
-    string Name = 1;
+    string Name = 1; 
     repeated string Groups = 2; // First group is provider
     repeated EParamTypePb ParamTypes = 3;
     repeated string ParamNames = 4;
 }
 
 message TLogItemPb {
-    uint64 Thread = 1;
-    string Name = 2;
-    string Provider = 3;
+    uint64 Thread = 1; 
+    string Name = 2; 
+    string Provider = 3; 
     repeated bytes Params = 4;
-    uint64 Timestamp = 5; // microseconds since epoch
-    uint64 TimestampCycles = 6; // cycles since machine boot
+    uint64 Timestamp = 5; // microseconds since epoch 
+    uint64 TimestampCycles = 6; // cycles since machine boot 
 }
 
 message TThreadLogPb {
-    uint64 ThreadId = 1;
+    uint64 ThreadId = 1; 
     repeated TLogItemPb LogItems = 2;
 }
 
 message TLogPb {
     // Trace info
-    string Name = 1;
-    string Description = 2;
-    uint64 EventsCount = 3;
-    uint64 CrtTime = 4; // Log creation time (seconds since epoch)
+    string Name = 1; 
+    string Description = 2; 
+    uint64 EventsCount = 3; 
+    uint64 CrtTime = 4; // Log creation time (seconds since epoch) 
 
     // Traced host info
-    string Hostname = 101;
+    string Hostname = 101; 
 
     // Traced process info
-    string ProcessName = 201;
+    string ProcessName = 201; 
     bytes CommandLine = 202;
-    uint64 ProcessStartTime = 203;
-    uint64 Pid = 204;
-    string VersionInfo = 205; // Svn info
+    uint64 ProcessStartTime = 203; 
+    uint64 Pid = 204; 
+    string VersionInfo = 205; // Svn info 
 
     // Trace query and results
-    TQuery Query = 301;
+    TQuery Query = 301; 
     repeated TEventPb Events = 302;
     repeated TThreadLogPb ThreadLogs = 303;
 }
 
 message TShuttlePb {
     repeated TLogPb Parts = 1;
-    TQuery Query = 2;
+    TQuery Query = 2; 
 }
 
 message TOrbitPb {
     repeated TShuttlePb Shuttles = 1;
 }
-
-////////////////////////////////////////////////////////////////////////////////
-// Trace parameter.
-
-message TTraceParam
-{
-    // Value.
-    oneof Value
-    {
-        int64  IntValue = 2;
-        uint64 UintValue = 3;
-        double DoubleValue = 4;
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// Trace parameter. 
+ 
+message TTraceParam 
+{ 
+    // Value. 
+    oneof Value 
+    { 
+        int64  IntValue = 2; 
+        uint64 UintValue = 3; 
+        double DoubleValue = 4; 
         bytes StrValue = 5;
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Trace Event .
-
-message TTraceEvent
-{
-    // Probe name.
-    string Name = 1;
-
-    // Provider name.
-    string Provider = 2;
-
-    // Probe parameters.
-    repeated TTraceParam Params = 3;
-
-    // Event timestamp in nanosec since epoch.
-    uint64 TimestampNanosec = 4;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Shuttle trace .
-
-message TShuttleTrace
-{
-    // Request events.
-    repeated TTraceEvent Events = 1;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Trace request.
-
-message TTraceRequest
-{
-    // trace id of remote trace session
-    bool IsTraced = 1;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Trace response.
-
-message TTraceResponse
-{
-    // traced events
-    TShuttleTrace Trace = 1;
-}
+    } 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// Trace Event . 
+ 
+message TTraceEvent 
+{ 
+    // Probe name. 
+    string Name = 1; 
+ 
+    // Provider name. 
+    string Provider = 2; 
+ 
+    // Probe parameters. 
+    repeated TTraceParam Params = 3; 
+ 
+    // Event timestamp in nanosec since epoch. 
+    uint64 TimestampNanosec = 4; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// Shuttle trace . 
+ 
+message TShuttleTrace 
+{ 
+    // Request events. 
+    repeated TTraceEvent Events = 1; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// Trace request. 
+ 
+message TTraceRequest 
+{ 
+    // trace id of remote trace session 
+    bool IsTraced = 1; 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// Trace response. 
+ 
+message TTraceResponse 
+{ 
+    // traced events 
+    TShuttleTrace Trace = 1; 
+} 
diff --git a/library/cpp/lwtrace/protos/ya.make b/library/cpp/lwtrace/protos/ya.make
index 503d5e515f..cefcadc853 100644
--- a/library/cpp/lwtrace/protos/ya.make
+++ b/library/cpp/lwtrace/protos/ya.make
@@ -2,8 +2,8 @@ PROTO_LIBRARY()
 
 OWNER(serxa)
 
-INCLUDE_TAGS(GO_PROTO)
-
+INCLUDE_TAGS(GO_PROTO) 
+ 
 SRCS(
     lwtrace.proto
 )
diff --git a/library/cpp/lwtrace/shuttle.h b/library/cpp/lwtrace/shuttle.h
index 85c6e4da61..14bf9e59f4 100644
--- a/library/cpp/lwtrace/shuttle.h
+++ b/library/cpp/lwtrace/shuttle.h
@@ -65,9 +65,9 @@ namespace NLWTrace {
                     AtomicSub(Status, 2);
                     return result;
                 }
-            }
-        }
-
+            } 
+        } 
+ 
         template <class F>
         void UnlessDead(F func) {
             while (true) {
@@ -91,7 +91,7 @@ namespace NLWTrace {
         }
 
         // Returns false iff shuttle should be destroyed
-        bool AddProbe(TProbe* probe, const TParams& params, ui64 timestamp = 0) {
+        bool AddProbe(TProbe* probe, const TParams& params, ui64 timestamp = 0) { 
             return UnlessDead([&] {
                 return DoAddProbe(probe, params, timestamp);
             }, false);
@@ -161,10 +161,10 @@ namespace NLWTrace {
         }
 
     protected:
-        virtual bool DoAddProbe(TProbe* probe, const TParams& params, ui64 timestamp) = 0;
+        virtual bool DoAddProbe(TProbe* probe, const TParams& params, ui64 timestamp) = 0; 
         virtual void DoEndOfTrack() = 0;
         virtual void DoDrop() = 0;
-        virtual void DoSerialize(TShuttleTrace& msg) = 0;
+        virtual void DoSerialize(TShuttleTrace& msg) = 0; 
         virtual bool DoFork(TShuttlePtr& child) = 0;
         virtual bool DoJoin(const TShuttlePtr& child) = 0;
     };
@@ -227,7 +227,7 @@ namespace NLWTrace {
             });
         }
 
-        void AddProbe(TProbe* probe, const TParams& params, ui64 timestamp = 0) {
+        void AddProbe(TProbe* probe, const TParams& params, ui64 timestamp = 0) { 
             NotConcurrent([&] (TShuttlePtr& head) {
                 TShuttlePtr* ref = &head;
                 while (IShuttle* s = ref->Get()) {
@@ -253,14 +253,14 @@ namespace NLWTrace {
                 }
             });
         }
-
+ 
         void Serialize(ui64 traceIdx, TShuttleTrace& msg) {
             ForEachShuttle(traceIdx, [&] (NLWTrace::IShuttle* shuttle) {
-                shuttle->Serialize(msg);
-                return false;
-            });
-        }
-
+                shuttle->Serialize(msg); 
+                return false; 
+            }); 
+        } 
+ 
         bool HasShuttle(ui64 traceIdx) {
             return NotConcurrent([=] (TShuttlePtr& head) {
                 TShuttlePtr ref = head;
@@ -270,10 +270,10 @@ namespace NLWTrace {
                     } else {
                         ref = s->GetNext();
                     }
-                }
+                } 
                 return false;
             });
-        }
+        } 
 
         bool Fork(TOrbit& child) {
             return NotConcurrent([&] (TShuttlePtr& head) {
diff --git a/library/cpp/lwtrace/signature.h b/library/cpp/lwtrace/signature.h
index 868bd9bcf2..f5415998a9 100644
--- a/library/cpp/lwtrace/signature.h
+++ b/library/cpp/lwtrace/signature.h
@@ -14,8 +14,8 @@
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/generated_enum_reflection.h>
 
-#include <library/cpp/lwtrace/protos/lwtrace.pb.h>
-
+#include <library/cpp/lwtrace/protos/lwtrace.pb.h> 
+ 
 #include <type_traits>
 
 namespace NLWTrace {
@@ -390,8 +390,8 @@ namespace NLWTrace {
         TParam Param[LWTRACE_MAX_PARAMS];
     };
 
-    using TSerializedParams = google::protobuf::RepeatedPtrField<NLWTrace::TTraceParam>;
-
+    using TSerializedParams = google::protobuf::RepeatedPtrField<NLWTrace::TTraceParam>; 
+ 
     // Represents a common class for all function "signatures" (parameter types and names).
     // Provides non-virtual interface to handle the signature and (emulated) virtual interface to handle TParams corresponding to the signature
     struct TSignature {
@@ -403,8 +403,8 @@ namespace NLWTrace {
         void (*SerializeParamsFunc)(const TParams& params, TString* values);
         void (*CloneParamsFunc)(TParams& newParams, const TParams& oldParams);
         void (*DestroyParamsFunc)(TParams& params);
-        void (*SerializeToPbFunc)(const TParams& params, TSerializedParams& arr);
-        bool (*DeserializeFromPbFunc)(TParams& params, const TSerializedParams& arr);
+        void (*SerializeToPbFunc)(const TParams& params, TSerializedParams& arr); 
+        bool (*DeserializeFromPbFunc)(TParams& params, const TSerializedParams& arr); 
 
         // Virtual calls emulation
         void SerializeParams(const TParams& params, TString* values) const {
@@ -419,16 +419,16 @@ namespace NLWTrace {
             (*DestroyParamsFunc)(params);
         }
 
-        void SerializeToPb(const TParams& params, TSerializedParams& arr) const
-        {
-            (*SerializeToPbFunc)(params, arr);
-        }
-
-        bool DeserializeFromPb(TParams& params, const TSerializedParams& arr) const
-        {
-            return (*DeserializeFromPbFunc)(params, arr);
-        }
-
+        void SerializeToPb(const TParams& params, TSerializedParams& arr) const 
+        { 
+            (*SerializeToPbFunc)(params, arr); 
+        } 
+ 
+        bool DeserializeFromPb(TParams& params, const TSerializedParams& arr) const 
+        { 
+            return (*DeserializeFromPbFunc)(params, arr); 
+        } 
+ 
         void ToProtobuf(TEventPb& pb) const;
 
         size_t FindParamIndex(const TString& param) const {
@@ -564,118 +564,118 @@ namespace NLWTrace {
         }
     };
 
-    inline EParamTypePb ParamTypeToProtobuf(const char* paramType) {
-#define FOREACH_PARAMTYPE_MACRO(n, t, v) \
-    if (strcmp(paramType, n) == 0) {     \
-        return PT_##v;                   \
-    }                                    \
-    /**/
-        FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO)
-#undef FOREACH_PARAMTYPE_MACRO
-        return PT_UNKNOWN;
-    }
-
-    template <typename T>
-    inline void SaveParamToPb(TSerializedParams& msg, const TParam& param);
-
-    template <>
-    inline void SaveParamToPb<TNil>(TSerializedParams& msg, const TParam& param)
-    {
-        Y_UNUSED(msg);
-        Y_UNUSED(param);
-    }
-
-    template <>
-    inline void SaveParamToPb<i64>(TSerializedParams& msg, const TParam& param)
-    {
-        msg.Add()->SetIntValue(param.Get<typename TParamTraits<i64>::TStoreType>());
-    }
-
-    template <>
-    inline void SaveParamToPb<ui64>(TSerializedParams& msg, const TParam& param)
-    {
-        msg.Add()->SetUintValue(param.Get<typename TParamTraits<ui64>::TStoreType>());
-    }
-
-    template <>
-    inline void SaveParamToPb<double>(TSerializedParams& msg, const TParam& param)
-    {
-        msg.Add()->SetDoubleValue(param.Get<typename TParamTraits<double>::TStoreType>());
-    }
-
-    template <>
-    inline void SaveParamToPb<TString>(TSerializedParams& msg, const TParam& param)
-    {
-        msg.Add()->SetStrValue(param.Get<typename TParamTraits<TString>::TStoreType>());
-    }
-
-    template <>
-    inline void SaveParamToPb<TSymbol>(TSerializedParams& msg, const TParam& param)
-    {
-        msg.Add()->SetStrValue(*param.Get<typename TParamTraits<TSymbol>::TStoreType>().Str);
-    }
-
-    template <>
-    inline void SaveParamToPb<TCheck>(TSerializedParams& msg, const TParam& param)
-    {
-        msg.Add()->SetIntValue(param.Get<typename TParamTraits<TCheck>::TStoreType>().Value);
-    }
-
-    template <typename T>
-    inline void LoadParamFromPb(const TTraceParam& msg, TParam& param);
-
-    template <>
-    inline void LoadParamFromPb<i64>(const TTraceParam& msg, TParam& param)
-    {
-        param.DefaultConstruct<i64>();
-        param.Get<i64>() = msg.GetIntValue();
-    }
-
-    template <>
-    inline void LoadParamFromPb<ui64>(const TTraceParam& msg, TParam& param)
-    {
-        param.DefaultConstruct<ui64>();
-        param.Get<ui64>() = msg.GetUintValue();
-    }
-
-    template <>
-    inline void LoadParamFromPb<double>(const TTraceParam& msg, TParam& param)
-    {
-        param.DefaultConstruct<double>();
-        param.Get<double>() = msg.GetDoubleValue();
-    }
-
-    template <>
-    inline void LoadParamFromPb<TCheck>(const TTraceParam& msg, TParam& param)
-    {
-        param.CopyConstruct<TCheck>(TCheck(msg.GetIntValue()));
-    }
-
-    template <>
-    inline void LoadParamFromPb<TSymbol>(const TTraceParam& msg, TParam& param)
-    {
-        Y_UNUSED(msg);
-        Y_UNUSED(param);
-        static TString unsupported("unsupported");
-        // so far TSymbol deserialization is not supported
-        // since it is not used for probes, it is ok
-        param.CopyConstruct<TSymbol>(TSymbol(&unsupported));
-    }
-
-    template <>
-    inline void LoadParamFromPb<TString>(const TTraceParam& msg, TParam& param)
-    {
-        param.DefaultConstruct<TString>();
-        param.Get<TString>() = msg.GetStrValue();
-    }
-
-    template <>
-    inline void LoadParamFromPb<TNil>(const TTraceParam& msg, TParam& param)
-    {
-        Y_UNUSED(msg);
-        Y_UNUSED(param);
-    }
-
+    inline EParamTypePb ParamTypeToProtobuf(const char* paramType) { 
+#define FOREACH_PARAMTYPE_MACRO(n, t, v) \ 
+    if (strcmp(paramType, n) == 0) {     \ 
+        return PT_##v;                   \ 
+    }                                    \ 
+    /**/ 
+        FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
+#undef FOREACH_PARAMTYPE_MACRO 
+        return PT_UNKNOWN; 
+    } 
+ 
+    template <typename T> 
+    inline void SaveParamToPb(TSerializedParams& msg, const TParam& param); 
+ 
+    template <> 
+    inline void SaveParamToPb<TNil>(TSerializedParams& msg, const TParam& param) 
+    { 
+        Y_UNUSED(msg); 
+        Y_UNUSED(param); 
+    } 
+ 
+    template <> 
+    inline void SaveParamToPb<i64>(TSerializedParams& msg, const TParam& param) 
+    { 
+        msg.Add()->SetIntValue(param.Get<typename TParamTraits<i64>::TStoreType>()); 
+    } 
+ 
+    template <> 
+    inline void SaveParamToPb<ui64>(TSerializedParams& msg, const TParam& param) 
+    { 
+        msg.Add()->SetUintValue(param.Get<typename TParamTraits<ui64>::TStoreType>()); 
+    } 
+ 
+    template <> 
+    inline void SaveParamToPb<double>(TSerializedParams& msg, const TParam& param) 
+    { 
+        msg.Add()->SetDoubleValue(param.Get<typename TParamTraits<double>::TStoreType>()); 
+    } 
+ 
+    template <> 
+    inline void SaveParamToPb<TString>(TSerializedParams& msg, const TParam& param) 
+    { 
+        msg.Add()->SetStrValue(param.Get<typename TParamTraits<TString>::TStoreType>()); 
+    } 
+ 
+    template <> 
+    inline void SaveParamToPb<TSymbol>(TSerializedParams& msg, const TParam& param) 
+    { 
+        msg.Add()->SetStrValue(*param.Get<typename TParamTraits<TSymbol>::TStoreType>().Str); 
+    } 
+ 
+    template <> 
+    inline void SaveParamToPb<TCheck>(TSerializedParams& msg, const TParam& param) 
+    { 
+        msg.Add()->SetIntValue(param.Get<typename TParamTraits<TCheck>::TStoreType>().Value); 
+    } 
+ 
+    template <typename T> 
+    inline void LoadParamFromPb(const TTraceParam& msg, TParam& param); 
+ 
+    template <> 
+    inline void LoadParamFromPb<i64>(const TTraceParam& msg, TParam& param) 
+    { 
+        param.DefaultConstruct<i64>(); 
+        param.Get<i64>() = msg.GetIntValue(); 
+    } 
+ 
+    template <> 
+    inline void LoadParamFromPb<ui64>(const TTraceParam& msg, TParam& param) 
+    { 
+        param.DefaultConstruct<ui64>(); 
+        param.Get<ui64>() = msg.GetUintValue(); 
+    } 
+ 
+    template <> 
+    inline void LoadParamFromPb<double>(const TTraceParam& msg, TParam& param) 
+    { 
+        param.DefaultConstruct<double>(); 
+        param.Get<double>() = msg.GetDoubleValue(); 
+    } 
+ 
+    template <> 
+    inline void LoadParamFromPb<TCheck>(const TTraceParam& msg, TParam& param) 
+    { 
+        param.CopyConstruct<TCheck>(TCheck(msg.GetIntValue())); 
+    } 
+ 
+    template <> 
+    inline void LoadParamFromPb<TSymbol>(const TTraceParam& msg, TParam& param) 
+    { 
+        Y_UNUSED(msg); 
+        Y_UNUSED(param); 
+        static TString unsupported("unsupported"); 
+        // so far TSymbol deserialization is not supported 
+        // since it is not used for probes, it is ok 
+        param.CopyConstruct<TSymbol>(TSymbol(&unsupported)); 
+    } 
+ 
+    template <> 
+    inline void LoadParamFromPb<TString>(const TTraceParam& msg, TParam& param) 
+    { 
+        param.DefaultConstruct<TString>(); 
+        param.Get<TString>() = msg.GetStrValue(); 
+    } 
+ 
+    template <> 
+    inline void LoadParamFromPb<TNil>(const TTraceParam& msg, TParam& param) 
+    { 
+        Y_UNUSED(msg); 
+        Y_UNUSED(param); 
+    } 
+ 
     // Class representing a specific signature
     template <LWTRACE_TEMPLATE_PARAMS>
     struct TUserSignature {
@@ -705,42 +705,42 @@ namespace NLWTrace {
             FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO);
 #undef FOREACH_PARAMNUM_MACRO
         }
-
-        // Implementation of virtual function (TSignature derived classes vtable emulation)
-        inline static void SerializeToPb(const TParams& params, TSerializedParams& arr)
-        {
-#define FOREACH_PARAMNUM_MACRO(i)                                              \
-    SaveParamToPb<typename TParamTraits<TP##i>::TStoreType>(                   \
-        arr,                                                                   \
-        params.Param[i]);                                                      \
-// FOREACH_PARAMNUM_MACRO
-            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO);
-#undef FOREACH_PARAMNUM_MACRO
-        }
-
-        // Implementation of virtual function (TSignature derived classes vtable emulation)
-        inline static bool DeserializeFromPb(TParams& params, const TSerializedParams& arr) {
-            if (arr.size() != ParamCount) {
-                return false;
-            }
-            if (!ParamCount) {
-                return true;
-            }
-
-            int paramIdx = 0;
-#define FOREACH_PARAMNUM_MACRO(i)                                              \
-    if (paramIdx >= arr.size()) {                                              \
-        return true;                                                           \
-    };                                                                         \
-    LoadParamFromPb<typename TParamTraits<TP##i>::TStoreType>(                 \
-        arr.Get(paramIdx),                                                     \
-        params.Param[paramIdx]);                                               \
-    ++paramIdx;                                                                \
-//  FOREACH_PARAMNUM_MACRO
-            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO);
-#undef FOREACH_PARAMNUM_MACRO
-            return true;
-        }
+ 
+        // Implementation of virtual function (TSignature derived classes vtable emulation) 
+        inline static void SerializeToPb(const TParams& params, TSerializedParams& arr) 
+        { 
+#define FOREACH_PARAMNUM_MACRO(i)                                              \ 
+    SaveParamToPb<typename TParamTraits<TP##i>::TStoreType>(                   \ 
+        arr,                                                                   \ 
+        params.Param[i]);                                                      \ 
+// FOREACH_PARAMNUM_MACRO 
+            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO); 
+#undef FOREACH_PARAMNUM_MACRO 
+        } 
+ 
+        // Implementation of virtual function (TSignature derived classes vtable emulation) 
+        inline static bool DeserializeFromPb(TParams& params, const TSerializedParams& arr) { 
+            if (arr.size() != ParamCount) { 
+                return false; 
+            } 
+            if (!ParamCount) { 
+                return true; 
+            } 
+ 
+            int paramIdx = 0; 
+#define FOREACH_PARAMNUM_MACRO(i)                                              \ 
+    if (paramIdx >= arr.size()) {                                              \ 
+        return true;                                                           \ 
+    };                                                                         \ 
+    LoadParamFromPb<typename TParamTraits<TP##i>::TStoreType>(                 \ 
+        arr.Get(paramIdx),                                                     \ 
+        params.Param[paramIdx]);                                               \ 
+    ++paramIdx;                                                                \ 
+//  FOREACH_PARAMNUM_MACRO 
+            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO); 
+#undef FOREACH_PARAMNUM_MACRO 
+            return true; 
+        } 
     };
 
     // Array of static strings pointers for names of parameter types in a specific signature
diff --git a/library/cpp/lwtrace/trace.cpp b/library/cpp/lwtrace/trace.cpp
index 3c974c85a0..1aee64a16f 100644
--- a/library/cpp/lwtrace/trace.cpp
+++ b/library/cpp/lwtrace/trace.cpp
@@ -432,9 +432,9 @@ namespace NLWTrace {
 
     public:
         TLogActionExecutor(TProbe* probe, const TLogAction& action, TLog* log)
-            : LogParams(!action.GetDoNotLogParams())
+            : LogParams(!action.GetDoNotLogParams()) 
             , LogTimestamp(action.GetLogTimestamp())
-            , MaxRecords(action.GetMaxRecords() ? new intptr_t(action.GetMaxRecords()) : nullptr)
+            , MaxRecords(action.GetMaxRecords() ? new intptr_t(action.GetMaxRecords()) : nullptr) 
             , Records(0)
             , Probe(probe)
             , Log(log)
@@ -475,11 +475,11 @@ namespace NLWTrace {
             const TArgument& arg = op.GetArgument(argumentIdx);
             TArgumentDescription operand;
             operand.ParamIdx = size_t(-1);
-            if (arg.GetVariable()) {
+            if (arg.GetVariable()) { 
                 operand.Type = OT_VARIABLE;
-            } else if (arg.GetValue()) {
+            } else if (arg.GetValue()) { 
                 operand.Type = OT_LITERAL;
-            } else if (arg.GetParam()) {
+            } else if (arg.GetParam()) { 
                 operand.Type = OT_PARAMETER;
                 operand.ParamIdx = signature.FindParamIndex(arg.GetParam());
                 if (operand.ParamIdx == size_t(-1)) {
@@ -672,7 +672,7 @@ namespace NLWTrace {
             } else if (action.HasSleepAction()) {
                 if (destructiveActionsAllowed) {
                     const TSleepAction& sleepAction = action.GetSleepAction();
-                    if (sleepAction.GetNanoSeconds()) {
+                    if (sleepAction.GetNanoSeconds()) { 
                         ui64 nanoSeconds = sleepAction.GetNanoSeconds();
                         actExec.Reset(new NPrivate::TSleepActionExecutor(probe, nanoSeconds));
                     } else {
@@ -858,9 +858,9 @@ namespace NLWTrace {
         , Registry(registry)
         , StoreDuration(TDuration::MicroSeconds(query.GetLogDurationUs() * 11 / 10)) // +10% to try avoid truncation while reading multiple threads/traces
         , ReadDuration(TDuration::MicroSeconds(query.GetLogDurationUs()))
-        , CyclicLog(query.GetPerThreadLogSize() ? query.GetPerThreadLogSize() : 1000)
+        , CyclicLog(query.GetPerThreadLogSize() ? query.GetPerThreadLogSize() : 1000) 
         , DurationLog(StoreDuration)
-        , CyclicDepot(query.GetPerThreadLogSize() ? query.GetPerThreadLogSize() : 1000)
+        , CyclicDepot(query.GetPerThreadLogSize() ? query.GetPerThreadLogSize() : 1000) 
         , DurationDepot(StoreDuration)
         , LastTrackId(0)
         , LastSpanId(0)
@@ -879,7 +879,7 @@ namespace NLWTrace {
                     ythrow yexception() << "block #" << bi + 1 << " has no action";
                 }
                 const NProtoBuf::RepeatedPtrField<TAction>& actions = block.action();
-                if (pdesc.GetName() && pdesc.GetProvider()) {
+                if (pdesc.GetName() && pdesc.GetProvider()) { 
                     TProbeRegistry::TProbesAccessor probes(Registry);
                     bool found = false;
                     for (auto& kv : probes) {
@@ -894,7 +894,7 @@ namespace NLWTrace {
                         ythrow yexception() << "block #" << bi + 1 << " has no matching probe with name '"
                                             << pdesc.GetName() << "' provider '" << pdesc.GetProvider() << "'";
                     }
-                } else if (pdesc.GetGroup()) {
+                } else if (pdesc.GetGroup()) { 
                     bool found = false;
                     TProbeRegistry::TProbesAccessor probes(Registry);
                     for (auto& kv : probes) {
diff --git a/library/cpp/lwtrace/trace_ut.cpp b/library/cpp/lwtrace/trace_ut.cpp
index cb03e4fbde..5e1256585e 100644
--- a/library/cpp/lwtrace/trace_ut.cpp
+++ b/library/cpp/lwtrace/trace_ut.cpp
@@ -16,17 +16,17 @@ enum class EEnumClass {
     ValueD,
 };
 
-#define LWTRACE_UT_PROVIDER(PROBE, EVENT, GROUPS, TYPES, NAMES)                                          \
-    PROBE(NoParam, GROUPS("Group"), TYPES(), NAMES())                                                    \
-    PROBE(IntParam, GROUPS("Group"), TYPES(ui32), NAMES("value"))                                        \
-    PROBE(StringParam, GROUPS("Group"), TYPES(TString), NAMES("value"))                                  \
-    PROBE(SymbolParam, GROUPS("Group"), TYPES(NLWTrace::TSymbol), NAMES("symbol"))                       \
-    PROBE(CheckParam, GROUPS("Group"), TYPES(NLWTrace::TCheck), NAMES("value"))                          \
+#define LWTRACE_UT_PROVIDER(PROBE, EVENT, GROUPS, TYPES, NAMES)                                          \ 
+    PROBE(NoParam, GROUPS("Group"), TYPES(), NAMES())                                                    \ 
+    PROBE(IntParam, GROUPS("Group"), TYPES(ui32), NAMES("value"))                                        \ 
+    PROBE(StringParam, GROUPS("Group"), TYPES(TString), NAMES("value"))                                  \ 
+    PROBE(SymbolParam, GROUPS("Group"), TYPES(NLWTrace::TSymbol), NAMES("symbol"))                       \ 
+    PROBE(CheckParam, GROUPS("Group"), TYPES(NLWTrace::TCheck), NAMES("value"))                          \ 
     PROBE(EnumParams, GROUPS("Group"), TYPES(ESimpleEnum, EEnumClass), NAMES("simpleEnum", "enumClass")) \
-    PROBE(InstantParam, GROUPS("Group"), TYPES(TInstant), NAMES("value"))                                \
-    PROBE(DurationParam, GROUPS("Group"), TYPES(TDuration), NAMES("value"))                              \
-    PROBE(ProtoEnum, GROUPS("Group"), TYPES(NLWTrace::EOperatorType), NAMES("value"))                    \
-    PROBE(IntIntParams, GROUPS("Group"), TYPES(ui32, ui64), NAMES("value1", "value2"))                   \
+    PROBE(InstantParam, GROUPS("Group"), TYPES(TInstant), NAMES("value"))                                \ 
+    PROBE(DurationParam, GROUPS("Group"), TYPES(TDuration), NAMES("value"))                              \ 
+    PROBE(ProtoEnum, GROUPS("Group"), TYPES(NLWTrace::EOperatorType), NAMES("value"))                    \ 
+    PROBE(IntIntParams, GROUPS("Group"), TYPES(ui32, ui64), NAMES("value1", "value2"))                   \ 
     /**/
 
 LWTRACE_DECLARE_PROVIDER(LWTRACE_UT_PROVIDER)
@@ -546,7 +546,7 @@ Y_UNIT_TEST_SUITE(LWTraceTrace) {
         using TPbEnumTraits = TParamTraits<EOperatorType>;
         TString str;
         TPbEnumTraits::ToString(TPbEnumTraits::ToStoreType(OT_EQ), &str);
-        UNIT_ASSERT_STRINGS_EQUAL(str, "OT_EQ (0)");
+        UNIT_ASSERT_STRINGS_EQUAL(str, "OT_EQ (0)"); 
     }
 
     Y_UNIT_TEST(Track) {
@@ -581,164 +581,164 @@ Y_UNIT_TEST_SUITE(LWTraceTrace) {
         } reader;
         mngr.ReadDepot("Query1", reader);
     }
-
-    Y_UNIT_TEST(ShouldSerializeTracks)
-    {
-        TManager manager(*Singleton<TProbeRegistry>(), false);
-
-        TOrbit orbit;
-        TTraceRequest req;
-        req.SetIsTraced(true);
-        manager.HandleTraceRequest(req, orbit);
-
-        LWTRACK(NoParam, orbit);
-        LWTRACK(IntParam, orbit, 1);
-        LWTRACK(StringParam, orbit, "str");
-        LWTRACK(EnumParams, orbit, ValueA, EEnumClass::ValueC);
-        LWTRACK(InstantParam, orbit, TInstant::Seconds(42));
-        LWTRACK(DurationParam, orbit, TDuration::MilliSeconds(146));
+ 
+    Y_UNIT_TEST(ShouldSerializeTracks) 
+    { 
+        TManager manager(*Singleton<TProbeRegistry>(), false); 
+ 
+        TOrbit orbit; 
+        TTraceRequest req; 
+        req.SetIsTraced(true); 
+        manager.HandleTraceRequest(req, orbit); 
+ 
+        LWTRACK(NoParam, orbit); 
+        LWTRACK(IntParam, orbit, 1); 
+        LWTRACK(StringParam, orbit, "str"); 
+        LWTRACK(EnumParams, orbit, ValueA, EEnumClass::ValueC); 
+        LWTRACK(InstantParam, orbit, TInstant::Seconds(42)); 
+        LWTRACK(DurationParam, orbit, TDuration::MilliSeconds(146)); 
         LWTRACK(ProtoEnum, orbit, OT_EQ);
-        LWTRACK(IntIntParams, orbit, 1, 2);
-
-        TTraceResponse resp;
-        orbit.Serialize(0, *resp.MutableTrace());
-        auto& r = resp.GetTrace();
-
-        UNIT_ASSERT_VALUES_EQUAL(8, r.EventsSize());
-
-        const auto& p0 = r.GetEvents(0);
-        UNIT_ASSERT_VALUES_EQUAL("NoParam", p0.GetName());
-        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p0.GetProvider());
-        UNIT_ASSERT_VALUES_EQUAL(0 , p0.ParamsSize());
-
-        const auto& p1 = r.GetEvents(1);
-        UNIT_ASSERT_VALUES_EQUAL("IntParam", p1.GetName());
-        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p1.GetProvider());
-        UNIT_ASSERT_VALUES_EQUAL(1, p1.GetParams(0).GetUintValue());
-
-        const auto& p2 = r.GetEvents(2);
-        UNIT_ASSERT_VALUES_EQUAL("StringParam", p2.GetName());
-        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p2.GetProvider());
-        UNIT_ASSERT_VALUES_EQUAL("str", p2.GetParams(0).GetStrValue());
-
-        const auto& p3 = r.GetEvents(3);
-        UNIT_ASSERT_VALUES_EQUAL("EnumParams", p3.GetName());
-        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p3.GetProvider());
-        UNIT_ASSERT_VALUES_EQUAL((ui32)ValueA, p3.GetParams(0).GetIntValue());
-        UNIT_ASSERT_VALUES_EQUAL((ui32)EEnumClass::ValueC, p3.GetParams(1).GetIntValue());
-
-        const auto& p4 = r.GetEvents(4);
-        UNIT_ASSERT_VALUES_EQUAL("InstantParam", p4.GetName());
-        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p4.GetProvider());
-        UNIT_ASSERT_VALUES_EQUAL(42, p4.GetParams(0).GetDoubleValue());
-
-        const auto& p5 = r.GetEvents(5);
-        UNIT_ASSERT_VALUES_EQUAL("DurationParam", p5.GetName());
-        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p5.GetProvider());
-        UNIT_ASSERT_VALUES_EQUAL(146, p5.GetParams(0).GetDoubleValue());
-
-        const auto& p6 = r.GetEvents(6);
-        UNIT_ASSERT_VALUES_EQUAL("ProtoEnum", p6.GetName());
-        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p6.GetProvider());
+        LWTRACK(IntIntParams, orbit, 1, 2); 
+ 
+        TTraceResponse resp; 
+        orbit.Serialize(0, *resp.MutableTrace()); 
+        auto& r = resp.GetTrace(); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(8, r.EventsSize()); 
+ 
+        const auto& p0 = r.GetEvents(0); 
+        UNIT_ASSERT_VALUES_EQUAL("NoParam", p0.GetName()); 
+        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p0.GetProvider()); 
+        UNIT_ASSERT_VALUES_EQUAL(0 , p0.ParamsSize()); 
+ 
+        const auto& p1 = r.GetEvents(1); 
+        UNIT_ASSERT_VALUES_EQUAL("IntParam", p1.GetName()); 
+        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p1.GetProvider()); 
+        UNIT_ASSERT_VALUES_EQUAL(1, p1.GetParams(0).GetUintValue()); 
+ 
+        const auto& p2 = r.GetEvents(2); 
+        UNIT_ASSERT_VALUES_EQUAL("StringParam", p2.GetName()); 
+        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p2.GetProvider()); 
+        UNIT_ASSERT_VALUES_EQUAL("str", p2.GetParams(0).GetStrValue()); 
+ 
+        const auto& p3 = r.GetEvents(3); 
+        UNIT_ASSERT_VALUES_EQUAL("EnumParams", p3.GetName()); 
+        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p3.GetProvider()); 
+        UNIT_ASSERT_VALUES_EQUAL((ui32)ValueA, p3.GetParams(0).GetIntValue()); 
+        UNIT_ASSERT_VALUES_EQUAL((ui32)EEnumClass::ValueC, p3.GetParams(1).GetIntValue()); 
+ 
+        const auto& p4 = r.GetEvents(4); 
+        UNIT_ASSERT_VALUES_EQUAL("InstantParam", p4.GetName()); 
+        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p4.GetProvider()); 
+        UNIT_ASSERT_VALUES_EQUAL(42, p4.GetParams(0).GetDoubleValue()); 
+ 
+        const auto& p5 = r.GetEvents(5); 
+        UNIT_ASSERT_VALUES_EQUAL("DurationParam", p5.GetName()); 
+        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p5.GetProvider()); 
+        UNIT_ASSERT_VALUES_EQUAL(146, p5.GetParams(0).GetDoubleValue()); 
+ 
+        const auto& p6 = r.GetEvents(6); 
+        UNIT_ASSERT_VALUES_EQUAL("ProtoEnum", p6.GetName()); 
+        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p6.GetProvider()); 
         UNIT_ASSERT_VALUES_EQUAL((int)OT_EQ, p6.GetParams(0).GetIntValue());
-
-        const auto& p7 = r.GetEvents(7);
-        UNIT_ASSERT_VALUES_EQUAL("IntIntParams", p7.GetName());
-        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p7.GetProvider());
-        UNIT_ASSERT_VALUES_EQUAL(1, p7.GetParams(0).GetUintValue());
-        UNIT_ASSERT_VALUES_EQUAL(2, p7.GetParams(1).GetUintValue());
-    }
-
-    Y_UNIT_TEST(ShouldDeserializeTracks)
-    {
-        TManager manager(*Singleton<TProbeRegistry>(), false);
-
-        TTraceResponse resp;
-        auto& r = *resp.MutableTrace()->MutableEvents();
-
-        auto& p0 = *r.Add();
-        p0.SetName("NoParam");
-        p0.SetProvider("LWTRACE_UT_PROVIDER");
-
-        auto& p1 = *r.Add();
-        p1.SetName("IntParam");
-        p1.SetProvider("LWTRACE_UT_PROVIDER");
-        auto& p1param = *p1.MutableParams()->Add();
-        p1param.SetUintValue(1);
-
-        auto& p2 = *r.Add();
-        p2.SetName("StringParam");
-        p2.SetProvider("LWTRACE_UT_PROVIDER");
-        auto& p2param = *p2.MutableParams()->Add();
-        p2param.SetStrValue("str");
-
-        auto& p3 = *r.Add();
-        p3.SetName("EnumParams");
-        p3.SetProvider("LWTRACE_UT_PROVIDER");
-        auto& p3param1 = *p3.MutableParams()->Add();
-        p3param1.SetUintValue((ui64)EEnumClass::ValueC);
-        auto& p3param2 = *p3.MutableParams()->Add();
-        p3param2.SetIntValue((ui64)EEnumClass::ValueC);
-
-        auto& p4 = *r.Add();
-        p4.SetName("InstantParam");
-        p4.SetProvider("LWTRACE_UT_PROVIDER");
-        auto& p4param = *p4.MutableParams()->Add();
-        p4param.SetDoubleValue(42);
-
-        auto& p5 = *r.Add();
-        p5.SetName("DurationParam");
-        p5.SetProvider("LWTRACE_UT_PROVIDER");
-        auto& p5param = *p5.MutableParams()->Add();
-        p5param.SetDoubleValue(146);
-
-        auto& p6 = *r.Add();
-        p6.SetName("ProtoEnum");
-        p6.SetProvider("LWTRACE_UT_PROVIDER");
-        auto& p6param = *p6.MutableParams()->Add();
+ 
+        const auto& p7 = r.GetEvents(7); 
+        UNIT_ASSERT_VALUES_EQUAL("IntIntParams", p7.GetName()); 
+        UNIT_ASSERT_VALUES_EQUAL("LWTRACE_UT_PROVIDER", p7.GetProvider()); 
+        UNIT_ASSERT_VALUES_EQUAL(1, p7.GetParams(0).GetUintValue()); 
+        UNIT_ASSERT_VALUES_EQUAL(2, p7.GetParams(1).GetUintValue()); 
+    } 
+ 
+    Y_UNIT_TEST(ShouldDeserializeTracks) 
+    { 
+        TManager manager(*Singleton<TProbeRegistry>(), false); 
+ 
+        TTraceResponse resp; 
+        auto& r = *resp.MutableTrace()->MutableEvents(); 
+ 
+        auto& p0 = *r.Add(); 
+        p0.SetName("NoParam"); 
+        p0.SetProvider("LWTRACE_UT_PROVIDER"); 
+ 
+        auto& p1 = *r.Add(); 
+        p1.SetName("IntParam"); 
+        p1.SetProvider("LWTRACE_UT_PROVIDER"); 
+        auto& p1param = *p1.MutableParams()->Add(); 
+        p1param.SetUintValue(1); 
+ 
+        auto& p2 = *r.Add(); 
+        p2.SetName("StringParam"); 
+        p2.SetProvider("LWTRACE_UT_PROVIDER"); 
+        auto& p2param = *p2.MutableParams()->Add(); 
+        p2param.SetStrValue("str"); 
+ 
+        auto& p3 = *r.Add(); 
+        p3.SetName("EnumParams"); 
+        p3.SetProvider("LWTRACE_UT_PROVIDER"); 
+        auto& p3param1 = *p3.MutableParams()->Add(); 
+        p3param1.SetUintValue((ui64)EEnumClass::ValueC); 
+        auto& p3param2 = *p3.MutableParams()->Add(); 
+        p3param2.SetIntValue((ui64)EEnumClass::ValueC); 
+ 
+        auto& p4 = *r.Add(); 
+        p4.SetName("InstantParam"); 
+        p4.SetProvider("LWTRACE_UT_PROVIDER"); 
+        auto& p4param = *p4.MutableParams()->Add(); 
+        p4param.SetDoubleValue(42); 
+ 
+        auto& p5 = *r.Add(); 
+        p5.SetName("DurationParam"); 
+        p5.SetProvider("LWTRACE_UT_PROVIDER"); 
+        auto& p5param = *p5.MutableParams()->Add(); 
+        p5param.SetDoubleValue(146); 
+ 
+        auto& p6 = *r.Add(); 
+        p6.SetName("ProtoEnum"); 
+        p6.SetProvider("LWTRACE_UT_PROVIDER"); 
+        auto& p6param = *p6.MutableParams()->Add(); 
         p6param.SetIntValue((i64)OT_EQ);
-
-        auto& p7 = *r.Add();
-        p7.SetName("IntIntParams");
-        p7.SetProvider("LWTRACE_UT_PROVIDER");
-        auto& p7param1 = *p7.MutableParams()->Add();
-        p7param1.SetIntValue(1);
-        auto& p7param2 = *p7.MutableParams()->Add();
-        p7param2.SetIntValue(2);
-
-        TOrbit orbit;
-        UNIT_ASSERT_VALUES_EQUAL(
-            manager.HandleTraceResponse(resp, manager.GetProbesMap(), orbit).IsSuccess,
-            true);
-    }
-
-    Y_UNIT_TEST(ShouldDeserializeWhatSerialized)
-    {
-        TManager manager(*Singleton<TProbeRegistry>(), false);
-
-        TOrbit orbit;
-        TTraceRequest req;
-        req.SetIsTraced(true);
-        manager.HandleTraceRequest(req, orbit);
-
-        LWTRACK(NoParam, orbit);
-        LWTRACK(IntParam, orbit, 1);
-        LWTRACK(StringParam, orbit, "str");
-        LWTRACK(EnumParams, orbit, ValueA, EEnumClass::ValueC);
-        LWTRACK(InstantParam, orbit, TInstant::Seconds(42));
-        LWTRACK(DurationParam, orbit, TDuration::MilliSeconds(146));
+ 
+        auto& p7 = *r.Add(); 
+        p7.SetName("IntIntParams"); 
+        p7.SetProvider("LWTRACE_UT_PROVIDER"); 
+        auto& p7param1 = *p7.MutableParams()->Add(); 
+        p7param1.SetIntValue(1); 
+        auto& p7param2 = *p7.MutableParams()->Add(); 
+        p7param2.SetIntValue(2); 
+ 
+        TOrbit orbit; 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            manager.HandleTraceResponse(resp, manager.GetProbesMap(), orbit).IsSuccess, 
+            true); 
+    } 
+ 
+    Y_UNIT_TEST(ShouldDeserializeWhatSerialized) 
+    { 
+        TManager manager(*Singleton<TProbeRegistry>(), false); 
+ 
+        TOrbit orbit; 
+        TTraceRequest req; 
+        req.SetIsTraced(true); 
+        manager.HandleTraceRequest(req, orbit); 
+ 
+        LWTRACK(NoParam, orbit); 
+        LWTRACK(IntParam, orbit, 1); 
+        LWTRACK(StringParam, orbit, "str"); 
+        LWTRACK(EnumParams, orbit, ValueA, EEnumClass::ValueC); 
+        LWTRACK(InstantParam, orbit, TInstant::Seconds(42)); 
+        LWTRACK(DurationParam, orbit, TDuration::MilliSeconds(146)); 
         LWTRACK(ProtoEnum, orbit, OT_EQ);
-        LWTRACK(IntIntParams, orbit, 1, 2);
-
-        TTraceResponse resp;
-        auto& r = *resp.MutableTrace();
-        orbit.Serialize(0, r);
-
-        TOrbit orbit1;
-        UNIT_ASSERT_VALUES_EQUAL(
-            manager.HandleTraceResponse(resp, manager.GetProbesMap(), orbit1).IsSuccess,
-            true);
-    }
+        LWTRACK(IntIntParams, orbit, 1, 2); 
+ 
+        TTraceResponse resp; 
+        auto& r = *resp.MutableTrace(); 
+        orbit.Serialize(0, r); 
+ 
+        TOrbit orbit1; 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            manager.HandleTraceResponse(resp, manager.GetProbesMap(), orbit1).IsSuccess, 
+            true); 
+    } 
 
     Y_UNIT_TEST(TrackForkJoin) {
         TManager mngr(*Singleton<TProbeRegistry>(), true);
diff --git a/library/cpp/lwtrace/ya.make b/library/cpp/lwtrace/ya.make
index d9accb3006..d863638b7d 100644
--- a/library/cpp/lwtrace/ya.make
+++ b/library/cpp/lwtrace/ya.make
@@ -8,7 +8,7 @@ PEERDIR(
 
 SRCS(
     check.cpp
-    control.cpp
+    control.cpp 
     custom_action.cpp
     kill_action.cpp
     log_shuttle.cpp
@@ -23,7 +23,7 @@ SRCS(
 )
 
 END()
-
+ 
 RECURSE(mon)
 
-RECURSE_FOR_TESTS(ut)
+RECURSE_FOR_TESTS(ut) 
diff --git a/ydb/core/base/tablet_types.h b/ydb/core/base/tablet_types.h
index f585819299..958ce144c9 100644
--- a/ydb/core/base/tablet_types.h
+++ b/ydb/core/base/tablet_types.h
@@ -31,7 +31,7 @@ public:
     static constexpr EType RTMR_PARTITION = RTMRPartition;
     static constexpr EType BLOCKSTORE_VOLUME = BlockStoreVolume;
     static constexpr EType BLOCKSTORE_PARTITION = BlockStorePartition;
-    static constexpr EType BLOCKSTORE_PARTITION2 = BlockStorePartition2;
+    static constexpr EType BLOCKSTORE_PARTITION2 = BlockStorePartition2; 
     static constexpr EType BLOCKSTORE_DISK_REGISTRY = BlockStoreDiskRegistry;
     static constexpr EType TENANT_SLOT_BROKER = TenantSlotBroker;
     static constexpr EType CONSOLE = Console;
diff --git a/ydb/core/driver_lib/run/run.cpp b/ydb/core/driver_lib/run/run.cpp
index a4f74aa4e0..b03d28f002 100644
--- a/ydb/core/driver_lib/run/run.cpp
+++ b/ydb/core/driver_lib/run/run.cpp
@@ -955,8 +955,8 @@ void TKikimrRunner::InitializeLogSettings(const TKikimrRunConfig& runConfig)
         NKikimrServices::LOGGER,
         (NActors::NLog::EPriority)logConfig.GetDefaultLevel(),
         (NActors::NLog::EPriority)logConfig.GetDefaultSamplingLevel(),
-        logConfig.GetDefaultSamplingRate(),
-        logConfig.GetTimeThresholdMs()));
+        logConfig.GetDefaultSamplingRate(), 
+        logConfig.GetTimeThresholdMs())); 
 
     LogSettings->Append(
         NActorsServices::EServiceCommon_MIN,
diff --git a/ydb/core/protos/blockstore_config.proto b/ydb/core/protos/blockstore_config.proto
index 5cba383bfd..e3298d1f14 100644
--- a/ydb/core/protos/blockstore_config.proto
+++ b/ydb/core/protos/blockstore_config.proto
@@ -35,17 +35,17 @@ message TVolumeConfig {
     optional uint32 Version = 6;
 
     // Volume private data
-    optional string DiskId = 7;
-    optional string ProjectId = 8;
-    optional string FolderId = 9;
-    optional string CloudId = 10;
+    optional string DiskId = 7; 
+    optional string ProjectId = 8; 
+    optional string FolderId = 9; 
+    optional string CloudId = 10; 
     optional uint32 TabletVersion = 11;
 
     // Binary data for private use by BlockStore implementation (legacy, unused)
     optional bytes Opaque = 12;
-
-    // Volume disk type
-    optional uint32 StorageMediaKind = 13;
+ 
+    // Volume disk type 
+    optional uint32 StorageMediaKind = 13; 
 
     // Performance profile fields, used for correct bs group allocation and iops/bandwidth throttling
     optional uint32 PerformanceProfileMaxReadBandwidth = 14;
@@ -81,9 +81,9 @@ message TVolumeConfig {
     // Placement group id.
     optional string PlacementGroupId = 34;
 
-    // Tags. Use TagsStr, because we need capability to pass empty set of tags.
-    optional string TagsStr = 35;   // ,-delimited string
-    repeated string Tags = 36;      // array of strings, do not use
+    // Tags. Use TagsStr, because we need capability to pass empty set of tags. 
+    optional string TagsStr = 35;   // ,-delimited string 
+    repeated string Tags = 36;      // array of strings, do not use 
 
     // Block count per stripe. Affects multipartition volumes.
     optional uint32 BlocksPerStripe = 37;
@@ -96,9 +96,9 @@ message TVolumeConfig {
 
     // Indicates that volume does not belong to user directly, but used for system needs
     optional bool IsSystem = 40;
-
-    // Channel descriptions for volume tablets
-    repeated TChannelProfile VolumeExplicitChannelProfiles = 41;
+ 
+    // Channel descriptions for volume tablets 
+    repeated TChannelProfile VolumeExplicitChannelProfiles = 41; 
 }
 
 message TUpdateVolumeConfig {
diff --git a/ydb/core/protos/config.proto b/ydb/core/protos/config.proto
index d64169d4fc..8668fb6317 100644
--- a/ydb/core/protos/config.proto
+++ b/ydb/core/protos/config.proto
@@ -287,7 +287,7 @@ message TLogConfig {
     optional string SysLogService = 11;
     optional bool SysLogToStdErr = 12; // writes logs to stderr as well as in syslog
     optional TUAClientConfig UAClientConfig = 13;
-    optional uint64 TimeThresholdMs = 14 [default = 1000];
+    optional uint64 TimeThresholdMs = 14 [default = 1000]; 
 }
 
 message TCompileServiceConfig {
diff --git a/ydb/core/protos/counters_schemeshard.proto b/ydb/core/protos/counters_schemeshard.proto
index a839915c98..45ff336aa8 100644
--- a/ydb/core/protos/counters_schemeshard.proto
+++ b/ydb/core/protos/counters_schemeshard.proto
@@ -63,7 +63,7 @@ enum ESimpleCounters {
     COUNTER_USER_ATTRIBUTES_COUNT = 50                    [(CounterOpts) = {Name: "UserAttributes"}];
     COUNTER_IN_FLIGHT_OPS_TxCreateTableIndex = 51         [(CounterOpts) = {Name: "InFlightOps/CreateTableIndex"}];
     COUNTER_TABLE_INDEXES_COUNT = 52                      [(CounterOpts) = {Name: "TableIndexes"}];
-    COUNTER_BLOCKSTORE_PARTITION2_SHARD_COUNT = 53        [(CounterOpts) = {Name: "BlockStorePartition2Shards"}];
+    COUNTER_BLOCKSTORE_PARTITION2_SHARD_COUNT = 53        [(CounterOpts) = {Name: "BlockStorePartition2Shards"}]; 
     COUNTER_IN_FLIGHT_OPS_TxDropTableIndex = 54           [(CounterOpts) = {Name: "InFlightOps/DropTableIndex"}];
 
     COUNTER_EXTSUB_DOMAIN_COUNT = 55                      [(CounterOpts) = {Name: "ExernalSubDomains"}];
diff --git a/ydb/core/protos/flat_scheme_op.proto b/ydb/core/protos/flat_scheme_op.proto
index 33e598c1c2..a2627f2b1a 100644
--- a/ydb/core/protos/flat_scheme_op.proto
+++ b/ydb/core/protos/flat_scheme_op.proto
@@ -945,7 +945,7 @@ message TBlockStoreVolumeDescription {
     optional uint64 VolumeTabletId = 5; // do not set
     optional uint64 AlterVersion = 6; // do not set
     optional string MountToken = 7; // do not set
-    optional uint64 TokenVersion = 8; // do not set
+    optional uint64 TokenVersion = 8; // do not set 
 }
 
 message TFileStoreDescription {
@@ -1005,7 +1005,7 @@ message TAlterSolomonVolume {
 message TBlockStoreAssignOp {
     optional string Name = 1; // mandatory
     optional string NewMountToken = 2; // unset to unassign
-    optional uint64 TokenVersion = 3;
+    optional uint64 TokenVersion = 3; 
 }
 
 message TModifyACL {
diff --git a/ydb/core/protos/services.proto b/ydb/core/protos/services.proto
index c17c8a7dc3..470062dacf 100644
--- a/ydb/core/protos/services.proto
+++ b/ydb/core/protos/services.proto
@@ -866,6 +866,6 @@ message TActivity {
         REPLICATION_CONTROLLER_STREAM_CREATOR = 561;
         YQ_TEST_CONNECTION_ACTOR = 560;
         REPLICATION_CONTROLLER_DST_CREATOR = 562;
-        BLOCKSTORE_STATS_SERVICE = 563;
+        BLOCKSTORE_STATS_SERVICE = 563; 
     };
 };
diff --git a/ydb/core/protos/tablet.proto b/ydb/core/protos/tablet.proto
index f0bec238e7..05dfb77324 100644
--- a/ydb/core/protos/tablet.proto
+++ b/ydb/core/protos/tablet.proto
@@ -37,7 +37,7 @@ message TTabletTypes {
         TenantSlotBroker = 27;
         Console = 28;
         Kesus = 29;
-        BlockStorePartition2 = 30;
+        BlockStorePartition2 = 30; 
         BlockStoreDiskRegistry = 31;
         SysViewProcessor = 32;
         FileStore = 33;
diff --git a/ydb/core/tablet/node_whiteboard.cpp b/ydb/core/tablet/node_whiteboard.cpp
index 783758e99d..a9e3191c4c 100644
--- a/ydb/core/tablet/node_whiteboard.cpp
+++ b/ydb/core/tablet/node_whiteboard.cpp
@@ -56,8 +56,8 @@ public:
             }
             version = branch + '.' + version;
             SystemStateInfo.SetVersion(version);
-            auto versionCounter = GetServiceCounters(AppData(ctx)->Counters, "utils")->GetSubgroup("revision", version);
-            *versionCounter->GetCounter("version", false) = 1;
+            auto versionCounter = GetServiceCounters(AppData(ctx)->Counters, "utils")->GetSubgroup("revision", version); 
+            *versionCounter->GetCounter("version", false) = 1; 
         }
         SystemStateInfo.SetStartTime(ctx.Now().MilliSeconds());
         ProcessStats.Fill(getpid());
diff --git a/ydb/core/tablet/tablet_counters.h b/ydb/core/tablet/tablet_counters.h
index a8cc27e9ed..e0cd1c474e 100644
--- a/ydb/core/tablet/tablet_counters.h
+++ b/ydb/core/tablet/tablet_counters.h
@@ -161,11 +161,11 @@ public:
         return *this;
     }
 
-    TTabletPercentileCounter& IncrementForRange(ui64 idx) {
-        Values[idx] += 1;
-        return *this;
-    }
-
+    TTabletPercentileCounter& IncrementForRange(ui64 idx) { 
+        Values[idx] += 1; 
+        return *this; 
+    } 
+ 
     TTabletPercentileCounter& DecrementFor(ui64 what) {
         Y_VERIFY(Integral);
         ui32 index = FindSlot(what);
@@ -186,10 +186,10 @@ public:
         return Values[index];
     }
 
-    ui64 GetRangeBound(ui32 index) const {
-        return Ranges[index].RangeVal;
-    }
-
+    ui64 GetRangeBound(ui32 index) const { 
+        return Ranges[index].RangeVal; 
+    } 
+ 
     TVector<TRangeDef> GetRanges() const {
         return TVector<TRangeDef>(Ranges, Ranges + RangeCount);
     }
@@ -198,10 +198,10 @@ public:
         return Integral;
     }
 
-    void PopulateFrom(const TTabletPercentileCounter& rp) {
-        Populate(rp);
-    }
-
+    void PopulateFrom(const TTabletPercentileCounter& rp) { 
+        Populate(rp); 
+    } 
+ 
     void OutputHtml(IOutputStream &os, const char* name) const;
 
 private:
diff --git a/ydb/core/tablet/tablet_monitoring_proxy.cpp b/ydb/core/tablet/tablet_monitoring_proxy.cpp
index a61a43b7e5..5064b661a0 100644
--- a/ydb/core/tablet/tablet_monitoring_proxy.cpp
+++ b/ydb/core/tablet/tablet_monitoring_proxy.cpp
@@ -24,19 +24,19 @@ public:
         return NKikimrServices::TActivity::TABLET_FORWARDING_ACTOR;
     }
 
-    TForwardingActor(const TTabletMonitoringProxyConfig& config, ui64 targetTablet, bool forceFollower, const TActorId& sender, const TString& query, HTTP_METHOD method)
+    TForwardingActor(const TTabletMonitoringProxyConfig& config, ui64 targetTablet, bool forceFollower, const TActorId& sender, const TString& query, HTTP_METHOD method) 
         : Config(config)
         , TargetTablet(targetTablet)
         , ForceFollower(forceFollower)
         , Sender(sender)
         , Query(query)
-        , Method(method)
-    {}
-
-    TForwardingActor(const TTabletMonitoringProxyConfig& config, ui64 targetTablet, bool forceFollower, const TActorId& sender, const TString& query)
-        : TForwardingActor(config, targetTablet, forceFollower, sender, query, HTTP_METHOD::HTTP_METHOD_GET)
+        , Method(method) 
     {}
 
+    TForwardingActor(const TTabletMonitoringProxyConfig& config, ui64 targetTablet, bool forceFollower, const TActorId& sender, const TString& query) 
+        : TForwardingActor(config, targetTablet, forceFollower, sender, query, HTTP_METHOD::HTTP_METHOD_GET) 
+    {} 
+ 
     void Bootstrap(const TActorContext& ctx) {
         NTabletPipe::TClientConfig config;
         config.AllowFollower = ForceFollower;
@@ -45,7 +45,7 @@ public:
         config.RetryPolicy = Config.RetryPolicy;
 
         PipeClient = ctx.ExecutorThread.RegisterActor(NTabletPipe::CreateClient(ctx.SelfID, TargetTablet, config));
-        NTabletPipe::SendData(ctx, PipeClient, new NMon::TEvRemoteHttpInfo(Query, Method));
+        NTabletPipe::SendData(ctx, PipeClient, new NMon::TEvRemoteHttpInfo(Query, Method)); 
 
         ctx.Schedule(TDuration::Seconds(60), new TEvents::TEvWakeup());
         Become(&TThis::StateWork);
@@ -116,7 +116,7 @@ private:
     const TActorId Sender;
     const TString Query;
     TActorId PipeClient;
-    const HTTP_METHOD Method;
+    const HTTP_METHOD Method; 
 };
 
 }
@@ -184,16 +184,16 @@ void
 TTabletMonitoringProxyActor::Handle(NMon::TEvHttpInfo::TPtr &ev, const TActorContext &ctx) {
     //
     NMon::TEvHttpInfo* msg = ev->Get();
-    const TCgiParameters* cgi;
-
-    if (msg->Request.GetMethod() == HTTP_METHOD_POST)  {
-        cgi = &msg->Request.GetPostParams();
-    } else {
-        cgi = &msg->Request.GetParams();
-    }
-
-    if (cgi->Has("KillTabletID")) {
-        const ui64 tabletId = TryParseTabletId(cgi->Get("KillTabletID"));
+    const TCgiParameters* cgi; 
+
+    if (msg->Request.GetMethod() == HTTP_METHOD_POST)  { 
+        cgi = &msg->Request.GetPostParams(); 
+    } else { 
+        cgi = &msg->Request.GetParams(); 
+    } 
+ 
+    if (cgi->Has("KillTabletID")) { 
+        const ui64 tabletId = TryParseTabletId(cgi->Get("KillTabletID")); 
         if (tabletId) {
             ctx.Register(CreateTabletKiller(tabletId));
             ctx.Send(ev->Sender, new NMon::TEvHttpInfoRes("<meta http-equiv=\"refresh\" content=\"0; tablets\" />"));
@@ -206,28 +206,28 @@ TTabletMonitoringProxyActor::Handle(NMon::TEvHttpInfo::TPtr &ev, const TActorCon
         const TString &tabletIdParam = cgi->Get("FollowerID");
         const ui64 tabletId = TryParseTabletId(tabletIdParam);
         if (tabletId) {
-            TString url = TStringBuilder() << msg->Request.GetPathInfo() << "?" << cgi->Print();
+            TString url = TStringBuilder() << msg->Request.GetPathInfo() << "?" << cgi->Print(); 
             ctx.ExecutorThread.RegisterActor(new TForwardingActor(Config, tabletId, true, ev->Sender, std::move(url)));
             return;
         }
     }
 
-    bool hasIdParam = cgi->Has("TabletID");
+    bool hasIdParam = cgi->Has("TabletID"); 
     if (hasIdParam) {
-        const TString &tabletIdParam = cgi->Get("TabletID");
+        const TString &tabletIdParam = cgi->Get("TabletID"); 
         const ui64 tabletId = TryParseTabletId(tabletIdParam);
         if (tabletId) {
-            TString url = TStringBuilder() << msg->Request.GetPathInfo() << "?" << cgi->Print();
-            ctx.ExecutorThread.RegisterActor(new TForwardingActor(Config, tabletId, false, ev->Sender, std::move(url), msg->Request.GetMethod()));
+            TString url = TStringBuilder() << msg->Request.GetPathInfo() << "?" << cgi->Print(); 
+            ctx.ExecutorThread.RegisterActor(new TForwardingActor(Config, tabletId, false, ev->Sender, std::move(url), msg->Request.GetMethod())); 
             return;
         }
     }
 
-    if (cgi->Has("SsId")) {
-        const TString &ssIdParam = cgi->Get("SsId");
+    if (cgi->Has("SsId")) { 
+        const TString &ssIdParam = cgi->Get("SsId"); 
         const ui64 tabletId = TryParseTabletId(ssIdParam);
         if (tabletId) {
-            TString url = TStringBuilder() << msg->Request.GetPathInfo() << "?" << cgi->Print();
+            TString url = TStringBuilder() << msg->Request.GetPathInfo() << "?" << cgi->Print(); 
             ctx.ExecutorThread.RegisterActor(CreateStateStorageMonitoringActor(tabletId, ev->Sender, std::move(url)));
             return;
         }
diff --git a/ydb/core/tx/schemeshard/schemeshard__init.cpp b/ydb/core/tx/schemeshard/schemeshard__init.cpp
index 650506549e..9394648bee 100644
--- a/ydb/core/tx/schemeshard/schemeshard__init.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__init.cpp
@@ -3683,9 +3683,9 @@ struct TSchemeShard::TTxInit : public TTransactionBase<TSchemeShard> {
             case ETabletType::BlockStorePartition:
                 Self->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION_SHARD_COUNT].Add(1);
                 break;
-            case ETabletType::BlockStorePartition2:
-                Self->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION2_SHARD_COUNT].Add(1);
-                break;
+            case ETabletType::BlockStorePartition2: 
+                Self->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION2_SHARD_COUNT].Add(1); 
+                break; 
             case ETabletType::FileStore:
                 Self->TabletCounters->Simple()[COUNTER_FILESTORE_COUNT].Add(1);
                 break;
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation_alter_bsv.cpp b/ydb/core/tx/schemeshard/schemeshard__operation_alter_bsv.cpp
index 27455e4627..2debfbe10b 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation_alter_bsv.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__operation_alter_bsv.cpp
@@ -78,7 +78,7 @@ public:
             TOperationId operationId, TPathElement::TPtr item,
             TBlockStoreVolumeInfo::TPtr volume,
             const TChannelsBindings& partitionChannels,
-            const TChannelsBindings& volumeChannels,
+            const TChannelsBindings& volumeChannels, 
             ui64 shardsToCreate,
             TOperationContext& context)
     {
@@ -98,15 +98,15 @@ public:
                     << " ExplicitChannelProfiles#" << volume->ExplicitChannelProfileCount
                     << "->" << volume->AlterData->ExplicitChannelProfileCount);
 
-        bool needMoreShards = ApplySharding(
-            operationId.GetTxId(),
-            item->PathId,
-            volume,
-            txState,
-            partitionChannels,
-            volumeChannels,
-            context);
-
+        bool needMoreShards = ApplySharding( 
+            operationId.GetTxId(), 
+            item->PathId, 
+            volume, 
+            txState, 
+            partitionChannels, 
+            volumeChannels, 
+            context); 
+ 
         if (needMoreShards) {
             context.SS->PersistUpdateNextShardIdx(db);
         }
@@ -153,7 +153,7 @@ public:
             TBlockStoreVolumeInfo::TPtr volume,
             TTxState& txState,
             const TChannelsBindings& partitionChannels,
-            const TChannelsBindings& volumeChannels,
+            const TChannelsBindings& volumeChannels, 
             TOperationContext& context)
     {
         Y_VERIFY(volume->AlterData->DefaultPartitionCount
@@ -181,11 +181,11 @@ public:
                 }
             }
 
-            if (volume->VolumeConfig.GetTabletVersion() == 2) {
+            if (volume->VolumeConfig.GetTabletVersion() == 2) { 
                 txState.Shards.emplace_back(shardIdx, ETabletType::BlockStorePartition2, partitionOp);
-            } else {
+            } else { 
                 txState.Shards.emplace_back(shardIdx, ETabletType::BlockStorePartition, partitionOp);
-            }
+            } 
         }
 
         // create new shards
@@ -193,11 +193,11 @@ public:
             TShardIdx shardIdx;
             if (volume->VolumeConfig.GetTabletVersion() == 2) {
                 shardIdx = context.SS->RegisterShardInfo(TShardInfo::BlockStorePartition2Info(txId, pathId));
-                context.SS->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION2_SHARD_COUNT].Add(1);
-            } else {
+                context.SS->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION2_SHARD_COUNT].Add(1); 
+            } else { 
                 shardIdx = context.SS->RegisterShardInfo(TShardInfo::BlockStorePartitionInfo(txId, pathId));
-                context.SS->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION_SHARD_COUNT].Add(1);
-            }
+                context.SS->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION_SHARD_COUNT].Add(1); 
+            } 
             auto& shardInfo = context.SS->ShardInfos.at(shardIdx);
             shardInfo.BindedChannels = partitionChannels;
             txState.Shards.emplace_back(shardIdx, shardInfo.TabletType, TTxState::CreateParts);
@@ -208,20 +208,20 @@ public:
             volume->Shards[shardIdx] = std::move(part);
         }
 
-        // update the volume shard if needed
-        auto volumeOp = TTxState::ConfigureParts;
-        auto shardIdx = volume->VolumeShardIdx;
-        auto& shardInfo = context.SS->ShardInfos[shardIdx];
-        for (ui32 i = 0; i < volumeChannels.size(); ++i) {
-            if (i >= shardInfo.BindedChannels.size()) {
-                shardInfo.BindedChannels.push_back(volumeChannels[i]);
-                volumeOp = TTxState::CreateParts;
-            } else if (!Compare(volumeChannels[i], shardInfo.BindedChannels[i])) {
-                shardInfo.BindedChannels[i] = volumeChannels[i];
-                volumeOp = TTxState::CreateParts;
-            }
+        // update the volume shard if needed 
+        auto volumeOp = TTxState::ConfigureParts; 
+        auto shardIdx = volume->VolumeShardIdx; 
+        auto& shardInfo = context.SS->ShardInfos[shardIdx]; 
+        for (ui32 i = 0; i < volumeChannels.size(); ++i) { 
+            if (i >= shardInfo.BindedChannels.size()) { 
+                shardInfo.BindedChannels.push_back(volumeChannels[i]); 
+                volumeOp = TTxState::CreateParts; 
+            } else if (!Compare(volumeChannels[i], shardInfo.BindedChannels[i])) { 
+                shardInfo.BindedChannels[i] = volumeChannels[i]; 
+                volumeOp = TTxState::CreateParts; 
+            } 
         }
-        txState.Shards.emplace_back(shardIdx, ETabletType::BlockStoreVolume, volumeOp);
+        txState.Shards.emplace_back(shardIdx, ETabletType::BlockStoreVolume, volumeOp); 
 
         return shardsToCreate > 0;
     }
@@ -272,60 +272,60 @@ public:
         return &volumeConfig;
     }
 
-    bool ProcessVolumeChannelProfiles(
-        const TPath& path,
-        const NKikimrBlockStore::TVolumeConfig& volumeConfig,
-        const NKikimrBlockStore::TVolumeConfig& alterVolumeConfig,
-        TOperationContext& context,
-        TProposeResponse& result,
-        TChannelsBindings* volumeChannelsBinding)
-    {
-        const auto& alterVolumeEcps = alterVolumeConfig.GetVolumeExplicitChannelProfiles();
-
-        if (alterVolumeEcps.size() &&
-            (ui32)alterVolumeEcps.size() != TBlockStoreVolumeInfo::NumVolumeTabletChannels)
-        {
-            auto errStr = Sprintf("Wrong number of channels %u , should be %lu",
-                                alterVolumeEcps.size(),
-                                TBlockStoreVolumeInfo::NumVolumeTabletChannels);
+    bool ProcessVolumeChannelProfiles( 
+        const TPath& path, 
+        const NKikimrBlockStore::TVolumeConfig& volumeConfig, 
+        const NKikimrBlockStore::TVolumeConfig& alterVolumeConfig, 
+        TOperationContext& context, 
+        TProposeResponse& result, 
+        TChannelsBindings* volumeChannelsBinding) 
+    { 
+        const auto& alterVolumeEcps = alterVolumeConfig.GetVolumeExplicitChannelProfiles(); 
+ 
+        if (alterVolumeEcps.size() && 
+            (ui32)alterVolumeEcps.size() != TBlockStoreVolumeInfo::NumVolumeTabletChannels) 
+        { 
+            auto errStr = Sprintf("Wrong number of channels %u , should be %lu", 
+                                alterVolumeEcps.size(), 
+                                TBlockStoreVolumeInfo::NumVolumeTabletChannels); 
             result.SetError(NKikimrScheme::StatusInvalidParameter, errStr);
-            return false;
-        }
-
-        if (alterVolumeEcps.size() || volumeConfig.VolumeExplicitChannelProfilesSize()) {
-            const auto& ecps = alterVolumeEcps.empty()
-                ? volumeConfig.GetVolumeExplicitChannelProfiles()
-                : alterVolumeEcps;
-
-            TVector<TStringBuf> poolKinds;
-            poolKinds.reserve(ecps.size());
-            for (const auto& ecp : ecps) {
-                poolKinds.push_back(ecp.GetPoolKind());
-            }
-
-            const auto volumeChannelsResolved = context.SS->ResolveChannelsByPoolKinds(
-                poolKinds,
-                path.DomainId(),
-                *volumeChannelsBinding);
-
-            if (!volumeChannelsResolved) {
+            return false; 
+        } 
+ 
+        if (alterVolumeEcps.size() || volumeConfig.VolumeExplicitChannelProfilesSize()) { 
+            const auto& ecps = alterVolumeEcps.empty() 
+                ? volumeConfig.GetVolumeExplicitChannelProfiles() 
+                : alterVolumeEcps; 
+ 
+            TVector<TStringBuf> poolKinds; 
+            poolKinds.reserve(ecps.size()); 
+            for (const auto& ecp : ecps) { 
+                poolKinds.push_back(ecp.GetPoolKind()); 
+            } 
+ 
+            const auto volumeChannelsResolved = context.SS->ResolveChannelsByPoolKinds( 
+                poolKinds, 
+                path.DomainId(), 
+                *volumeChannelsBinding); 
+ 
+            if (!volumeChannelsResolved) { 
                 result.SetError(NKikimrScheme::StatusInvalidParameter,
-                                "Unable to construct channel binding for volume with the storage pool");
-                return false;
-            }
-            context.SS->SetNbsChannelsParams(ecps, *volumeChannelsBinding);
-        } else {
-            const ui32 volumeProfileId = 0;
-            if (!context.SS->ResolveTabletChannels(volumeProfileId, path.DomainId(), *volumeChannelsBinding)) {
+                                "Unable to construct channel binding for volume with the storage pool"); 
+                return false; 
+            } 
+            context.SS->SetNbsChannelsParams(ecps, *volumeChannelsBinding); 
+        } else { 
+            const ui32 volumeProfileId = 0; 
+            if (!context.SS->ResolveTabletChannels(volumeProfileId, path.DomainId(), *volumeChannelsBinding)) { 
                 result.SetError(NKikimrScheme::StatusInvalidParameter,
-                                "Unable to construct channel binding for volume with the profile");
-                return false;
-            }
-        }
-
-        return true;
-    }
-
+                                "Unable to construct channel binding for volume with the profile"); 
+                return false; 
+            } 
+        } 
+ 
+        return true; 
+    } 
+ 
     bool ProcessChannelProfiles(
         const TPath& path,
         const NKikimrBlockStore::TVolumeConfig& volumeConfig,
@@ -500,19 +500,19 @@ public:
             }
         }
 
-        TChannelsBindings volumeChannelsBinding;
-        const auto channelProfilesProcessed = ProcessVolumeChannelProfiles(
-                path,
-                volume->VolumeConfig,
-                *alterVolumeConfig,
-                context,
-                *result,
-                &volumeChannelsBinding);
-
-        if (!channelProfilesProcessed) {
-            return result;
-        }
-
+        TChannelsBindings volumeChannelsBinding; 
+        const auto channelProfilesProcessed = ProcessVolumeChannelProfiles( 
+                path, 
+                volume->VolumeConfig, 
+                *alterVolumeConfig, 
+                context, 
+                *result, 
+                &volumeChannelsBinding); 
+ 
+        if (!channelProfilesProcessed) { 
+            return result; 
+        } 
+ 
         if (alterVolumeConfig->PartitionsSize()) {
             // Cannot delete individual partitions
             // Do we need to verify whether geometry changes make sense?
@@ -550,15 +550,15 @@ public:
             }
         }
 
-        if (alterVolumeConfig->HasVersion() &&
-            alterVolumeConfig->GetVersion() != volume->AlterVersion)
-        {
-            result->SetError(
+        if (alterVolumeConfig->HasVersion() && 
+            alterVolumeConfig->GetVersion() != volume->AlterVersion) 
+        { 
+            result->SetError( 
                 NKikimrScheme::StatusPreconditionFailed,
-                "Wrong version in VolumeConfig");
-            return result;
-        }
-
+                "Wrong version in VolumeConfig"); 
+            return result; 
+        } 
+ 
         if (!context.SS->CheckApplyIf(Transaction, errStr)) {
             result->SetError(NKikimrScheme::StatusPreconditionFailed, errStr);
             return result;
@@ -595,10 +595,10 @@ public:
             // MergeFrom will append explicit channel profiles, we want a replace operation instead
             alterData->VolumeConfig.ClearExplicitChannelProfiles();
         }
-        if (alterVolumeConfig->VolumeExplicitChannelProfilesSize() > 0) {
-            // MergeFrom will append explicit channel profiles, we want a replace operation instead
-            alterData->VolumeConfig.ClearVolumeExplicitChannelProfiles();
-        }
+        if (alterVolumeConfig->VolumeExplicitChannelProfilesSize() > 0) { 
+            // MergeFrom will append explicit channel profiles, we want a replace operation instead 
+            alterData->VolumeConfig.ClearVolumeExplicitChannelProfiles(); 
+        } 
         if (alterVolumeConfig->TagsSize() > 0) {
             // MergeFrom will append tags, we want a replace operation instead
             alterData->VolumeConfig.ClearTags();
@@ -626,14 +626,14 @@ public:
         // Increase in occupied space is applied immediately
         domainDir->ChangeVolumeSpaceBegin(newVolumeSpace, oldVolumeSpace);
 
-        const TTxState& txState = PrepareChanges(
-            OperationId,
-            path.Base(),
-            volume,
-            partitionChannelsBinding,
-            volumeChannelsBinding,
-            shardsToCreate,
-            context);
+        const TTxState& txState = PrepareChanges( 
+            OperationId, 
+            path.Base(), 
+            volume, 
+            partitionChannelsBinding, 
+            volumeChannelsBinding, 
+            shardsToCreate, 
+            context); 
 
         context.SS->ClearDescribePathCaches(path.Base());
         context.OnComplete.PublishToSchemeBoard(OperationId, path.Base()->PathId);
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation_assign_bsv.cpp b/ydb/core/tx/schemeshard/schemeshard__operation_assign_bsv.cpp
index de1576f2b1..61106c1182 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation_assign_bsv.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__operation_assign_bsv.cpp
@@ -71,16 +71,16 @@ public:
             return result;
         }
 
-
-        if (version &&
-            version != volume->TokenVersion)
-        {
-            result->SetError(
+ 
+        if (version && 
+            version != volume->TokenVersion) 
+        { 
+            result->SetError( 
                 NKikimrScheme::StatusPreconditionFailed,
-                "Wrong version in Assign Volume");
-            return result;
+                "Wrong version in Assign Volume"); 
+            return result; 
         }
-
+ 
         TString errStr;
         if (!context.SS->CheckApplyIf(Transaction, errStr)) {
             result->SetError(NKikimrScheme::StatusPreconditionFailed, errStr);
@@ -90,7 +90,7 @@ public:
         NIceDb::TNiceDb db(context.Txc.DB);
 
         volume->MountToken = mountToken;
-        ++volume->TokenVersion;
+        ++volume->TokenVersion; 
         context.SS->PersistBlockStoreVolumeMountToken(db, path.Base()->PathId, volume);
 
         context.OnComplete.PublishToSchemeBoard(OperationId, path.Base()->PathId);
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation_common.h b/ydb/core/tx/schemeshard/schemeshard__operation_common.h
index 5a3da32cad..8507bfdb5e 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation_common.h
+++ b/ydb/core/tx/schemeshard/schemeshard__operation_common.h
@@ -655,7 +655,7 @@ public:
         auto tablePartitionConfig = context.SS->GetTablePartitionConfigWithAlterData(targetPath->PathId);
         const auto& shard = context.SS->ShardInfos[shardIdx];
 
-        if (shard.TabletType == ETabletType::BlockStorePartition ||
+        if (shard.TabletType == ETabletType::BlockStorePartition || 
             shard.TabletType == ETabletType::BlockStorePartition2)
         {
             auto it = context.SS->BlockStoreVolumes.FindPtr(targetPath->PathId);
@@ -713,8 +713,8 @@ public:
             }
         }
 
-        if (shard.TabletType == ETabletType::BlockStorePartition   ||
-            shard.TabletType == ETabletType::BlockStorePartition2 ||
+        if (shard.TabletType == ETabletType::BlockStorePartition   || 
+            shard.TabletType == ETabletType::BlockStorePartition2 || 
             shard.TabletType == ETabletType::RTMRPartition) {
             // Partitions should never be booted by local
             ev->Record.SetTabletBootMode(NKikimrHive::TABLET_BOOT_MODE_EXTERNAL);
@@ -1272,8 +1272,8 @@ public:
         }
 
         for (auto shard : txState->Shards) {
-            if (shard.TabletType == ETabletType::BlockStorePartition ||
-                shard.TabletType == ETabletType::BlockStorePartition2) {
+            if (shard.TabletType == ETabletType::BlockStorePartition || 
+                shard.TabletType == ETabletType::BlockStorePartition2) { 
                 continue;
             }
 
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation_create_bsv.cpp b/ydb/core/tx/schemeshard/schemeshard__operation_create_bsv.cpp
index b32fb7d969..cca688f9d6 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation_create_bsv.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__operation_create_bsv.cpp
@@ -38,7 +38,7 @@ TBlockStoreVolumeInfo::TPtr CreateBlockStoreVolumeInfo(const NKikimrSchemeOp::TB
     }
 
     volume->AlterVersion = 1;
-    volume->TokenVersion = 0;
+    volume->TokenVersion = 0; 
     volume->DefaultPartitionCount =
         TBlockStoreVolumeInfo::CalculateDefaultPartitionCount(op.GetVolumeConfig());
     volume->VolumeConfig.CopyFrom(op.GetVolumeConfig());
@@ -49,25 +49,25 @@ TBlockStoreVolumeInfo::TPtr CreateBlockStoreVolumeInfo(const NKikimrSchemeOp::TB
 void ApplySharding(TTxId txId, TPathId pathId, TBlockStoreVolumeInfo::TPtr volume, TTxState& txState,
                    const TChannelsBindings& partitionChannels, const TChannelsBindings& volumeChannels,
                    TOperationContext& context) {
-    Y_VERIFY(volume->VolumeConfig.GetTabletVersion() <= 2);
+    Y_VERIFY(volume->VolumeConfig.GetTabletVersion() <= 2); 
     ui64 count = volume->DefaultPartitionCount;
     txState.Shards.reserve(count + 1);
 
     for (ui64 i = 0; i < count; ++i) {
         TShardIdx shardIdx;
-        if (volume->VolumeConfig.GetTabletVersion() == 2) {
+        if (volume->VolumeConfig.GetTabletVersion() == 2) { 
             shardIdx = context.SS->RegisterShardInfo(
                 TShardInfo::BlockStorePartition2Info(txId, pathId)
                     .WithBindedChannels(partitionChannels));
             context.SS->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION2_SHARD_COUNT].Add(1);
-            txState.Shards.emplace_back(shardIdx, ETabletType::BlockStorePartition2, TTxState::CreateParts);
-        } else {
+            txState.Shards.emplace_back(shardIdx, ETabletType::BlockStorePartition2, TTxState::CreateParts); 
+        } else { 
             shardIdx = context.SS->RegisterShardInfo(
                 TShardInfo::BlockStorePartitionInfo(txId, pathId)
                     .WithBindedChannels(partitionChannels));
             context.SS->TabletCounters->Simple()[COUNTER_BLOCKSTORE_PARTITION_SHARD_COUNT].Add(1);
-            txState.Shards.emplace_back(shardIdx, ETabletType::BlockStorePartition, TTxState::CreateParts);
-        }
+            txState.Shards.emplace_back(shardIdx, ETabletType::BlockStorePartition, TTxState::CreateParts); 
+        } 
 
         TBlockStorePartitionInfo::TPtr part = new TBlockStorePartitionInfo();
         part->PartitionId = i;
@@ -305,19 +305,19 @@ public:
             return result;
         }
 
-        auto resolveChannels = [&] (const auto& ecps, TChannelsBindings& binding)
-        {
-            TVector<TStringBuf> poolKinds;
-            poolKinds.reserve(ecps.size());
-            for (const auto& ecp : ecps) {
-                poolKinds.push_back(ecp.GetPoolKind());
-            }
-            return context.SS->ResolveChannelsByPoolKinds(
-                poolKinds,
-                dstPath.DomainId(),
-                binding);
-        };
-
+        auto resolveChannels = [&] (const auto& ecps, TChannelsBindings& binding) 
+        { 
+            TVector<TStringBuf> poolKinds; 
+            poolKinds.reserve(ecps.size()); 
+            for (const auto& ecp : ecps) { 
+                poolKinds.push_back(ecp.GetPoolKind()); 
+            } 
+            return context.SS->ResolveChannelsByPoolKinds( 
+                poolKinds, 
+                dstPath.DomainId(), 
+                binding); 
+        }; 
+ 
         TChannelsBindings partitionChannelsBinding;
         if (defaultPartitionCount) {
             const auto& ecps = operation.GetVolumeConfig().GetExplicitChannelProfiles();
@@ -330,7 +330,7 @@ public:
                 return result;
             }
 
-            if (!resolveChannels(ecps, partitionChannelsBinding)) {
+            if (!resolveChannels(ecps, partitionChannelsBinding)) { 
                 result->SetError(NKikimrScheme::StatusInvalidParameter,
                                 "Unable to construct channel binding for partition with the storage pool");
                 return result;
@@ -340,29 +340,29 @@ public:
         }
 
         TChannelsBindings volumeChannelsBinding;
-        const auto& ecps = operation.GetVolumeConfig().GetVolumeExplicitChannelProfiles();
-        if (ecps.size()) {
-            if ((ui32)ecps.size() != TBlockStoreVolumeInfo::NumVolumeTabletChannels) {
-                auto errStr = Sprintf("Wrong number of channels %u , should be %lu",
-                    ecps.size(),
-                    TBlockStoreVolumeInfo::NumVolumeTabletChannels);
+        const auto& ecps = operation.GetVolumeConfig().GetVolumeExplicitChannelProfiles(); 
+        if (ecps.size()) { 
+            if ((ui32)ecps.size() != TBlockStoreVolumeInfo::NumVolumeTabletChannels) { 
+                auto errStr = Sprintf("Wrong number of channels %u , should be %lu", 
+                    ecps.size(), 
+                    TBlockStoreVolumeInfo::NumVolumeTabletChannels); 
                 result->SetError(NKikimrScheme::StatusInvalidParameter, errStr);
-                return result;
-            }
-
-            if (!resolveChannels(ecps, volumeChannelsBinding)) {
+                return result; 
+            } 
+ 
+            if (!resolveChannels(ecps, volumeChannelsBinding)) { 
                 result->SetError(NKikimrScheme::StatusInvalidParameter,
-                                "Unable to construct channel binding for volume with the storage pool");
-                return result;
-            }
-            context.SS->SetNbsChannelsParams(ecps, volumeChannelsBinding);
-        } else {
-            const ui32 volumeProfileId = 0;
-            if (!context.SS->ResolveTabletChannels(volumeProfileId, dstPath.DomainId(), volumeChannelsBinding)) {
+                                "Unable to construct channel binding for volume with the storage pool"); 
+                return result; 
+            } 
+            context.SS->SetNbsChannelsParams(ecps, volumeChannelsBinding); 
+        } else { 
+            const ui32 volumeProfileId = 0; 
+            if (!context.SS->ResolveTabletChannels(volumeProfileId, dstPath.DomainId(), volumeChannelsBinding)) { 
                 result->SetError(NKikimrScheme::StatusInvalidParameter,
-                                "Unable to construct channel binding for volume with the profile");
-                return result;
-            }
+                                "Unable to construct channel binding for volume with the profile"); 
+                return result; 
+            } 
         }
 
         auto domainDir = context.SS->PathsById.at(dstPath.DomainId());
diff --git a/ydb/core/tx/schemeshard/schemeshard_impl.cpp b/ydb/core/tx/schemeshard/schemeshard_impl.cpp
index 0715543a22..6df2896f23 100644
--- a/ydb/core/tx/schemeshard/schemeshard_impl.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard_impl.cpp
@@ -2710,7 +2710,7 @@ void TSchemeShard::PersistBlockStoreVolumeMountToken(NIceDb::TNiceDb& db, TPathI
 {
     Y_VERIFY(IsLocalId(pathId));
     db.Table<Schema::BlockStoreVolumes>().Key(pathId.LocalPathId).Update(
-        NIceDb::TUpdate<Schema::BlockStoreVolumes::MountToken>(volume->MountToken),
+        NIceDb::TUpdate<Schema::BlockStoreVolumes::MountToken>(volume->MountToken), 
         NIceDb::TUpdate<Schema::BlockStoreVolumes::TokenVersion>(volume->TokenVersion));
 }
 
diff --git a/ydb/core/tx/schemeshard/schemeshard_info_types.h b/ydb/core/tx/schemeshard/schemeshard_info_types.h
index 2e5710c3d3..95e3178f1e 100644
--- a/ydb/core/tx/schemeshard/schemeshard_info_types.h
+++ b/ydb/core/tx/schemeshard/schemeshard_info_types.h
@@ -917,10 +917,10 @@ struct TShardInfo {
         return TShardInfo(txId, pathId, ETabletType::BlockStorePartition);
     }
 
-    static TShardInfo BlockStorePartition2Info(TTxId txId, TPathId pathId) {
-        return TShardInfo(txId, pathId, ETabletType::BlockStorePartition2);
-    }
-
+    static TShardInfo BlockStorePartition2Info(TTxId txId, TPathId pathId) { 
+        return TShardInfo(txId, pathId, ETabletType::BlockStorePartition2); 
+    } 
+ 
     static TShardInfo FileStoreInfo(TTxId txId, TPathId pathId) {
         return TShardInfo(txId, pathId, ETabletType::FileStore);
     }
@@ -1843,7 +1843,7 @@ struct TBlockStoreVolumeInfo : public TSimpleRefCount<TBlockStoreVolumeInfo> {
     };
 
     static constexpr size_t NumVolumeTabletChannels = 3;
-
+ 
     ui32 DefaultPartitionCount = 0;
     NKikimrBlockStore::TVolumeConfig VolumeConfig;
     ui64 AlterVersion = 0;
diff --git a/ydb/core/tx/schemeshard/schemeshard_path_describer.cpp b/ydb/core/tx/schemeshard/schemeshard_path_describer.cpp
index 3789d3af1b..0764f7e873 100644
--- a/ydb/core/tx/schemeshard/schemeshard_path_describer.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard_path_describer.cpp
@@ -674,7 +674,7 @@ void TPathDescriber::DescribeBlockStoreVolume(TPathId pathId, TPathElement::TPtr
     entry->SetVolumeTabletId(ui64(volume->VolumeTabletId));
     entry->SetAlterVersion(volume->AlterVersion);
     entry->SetMountToken(volume->MountToken);
-    entry->SetTokenVersion(volume->TokenVersion);
+    entry->SetTokenVersion(volume->TokenVersion); 
 
     const auto& tablets = volume->GetTablets(Self->ShardInfos);
     for (ui32 idx = 0; idx < tablets.size(); ++idx) {
diff --git a/ydb/core/tx/schemeshard/schemeshard_schema.h b/ydb/core/tx/schemeshard/schemeshard_schema.h
index f293136fe8..34884742bc 100644
--- a/ydb/core/tx/schemeshard/schemeshard_schema.h
+++ b/ydb/core/tx/schemeshard/schemeshard_schema.h
@@ -840,7 +840,7 @@ struct Schema : NIceDb::Schema {
         struct TokenVersion: Column<5, NScheme::NTypeIds::Uint64> {};
 
         using TKey = TableKey<PathId>;
-        using TColumns = TableColumns<PathId, VolumeConfig, AlterVersion, MountToken, TokenVersion>;
+        using TColumns = TableColumns<PathId, VolumeConfig, AlterVersion, MountToken, TokenVersion>; 
     };
 
     struct BlockStoreVolumeAlters : Table<24> {
diff --git a/ydb/core/tx/schemeshard/ut_base.cpp b/ydb/core/tx/schemeshard/ut_base.cpp
index a76dcf9d5b..5027b569fd 100644
--- a/ydb/core/tx/schemeshard/ut_base.cpp
+++ b/ydb/core/tx/schemeshard/ut_base.cpp
@@ -7200,36 +7200,36 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
                                    {NKikimrScheme::StatusAlreadyExists});
     }
 
-    Y_UNIT_TEST(CreateBlockStoreVolumeWithVolumeChannelsProfiles) { //+
-        TTestBasicRuntime runtime;
-        TTestEnv env(runtime);
-        ui64 txId = 100;
-
+    Y_UNIT_TEST(CreateBlockStoreVolumeWithVolumeChannelsProfiles) { //+ 
+        TTestBasicRuntime runtime; 
+        TTestEnv env(runtime); 
+        ui64 txId = 100; 
+ 
         NKikimrSchemeOp::TBlockStoreVolumeDescription vdescr;
-        vdescr.SetName("BSVolume");
-        auto& vc = *vdescr.MutableVolumeConfig();
-
-        vc.SetBlockSize(4096);
-        vc.AddPartitions()->SetBlockCount(16);
-        vc.AddExplicitChannelProfiles()->SetPoolKind("pool-kind-1");
-
-        // Too few volume channel profiles
-        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-2");
-        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-2");
-
-        TestCreateBlockStoreVolume(runtime, ++txId, "/MyRoot",
-                                   vdescr.DebugString(),
+        vdescr.SetName("BSVolume"); 
+        auto& vc = *vdescr.MutableVolumeConfig(); 
+ 
+        vc.SetBlockSize(4096); 
+        vc.AddPartitions()->SetBlockCount(16); 
+        vc.AddExplicitChannelProfiles()->SetPoolKind("pool-kind-1"); 
+ 
+        // Too few volume channel profiles 
+        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-2"); 
+        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-2"); 
+ 
+        TestCreateBlockStoreVolume(runtime, ++txId, "/MyRoot", 
+                                   vdescr.DebugString(), 
                                    {NKikimrScheme::StatusInvalidParameter});
-
-        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-2");
-
-        TestCreateBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString());
-        env.TestWaitNotification(runtime, txId);
-
-        TestDescribeResult(DescribePath(runtime, "/MyRoot/BSVolume"),
-                           {NLs::Finished, NLs::PathsInsideDomain(1), NLs::ShardsInsideDomain(2)});
-    }
-
+ 
+        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-2"); 
+ 
+        TestCreateBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString()); 
+        env.TestWaitNotification(runtime, txId); 
+ 
+        TestDescribeResult(DescribePath(runtime, "/MyRoot/BSVolume"), 
+                           {NLs::Finished, NLs::PathsInsideDomain(1), NLs::ShardsInsideDomain(2)}); 
+    } 
+ 
     Y_UNIT_TEST(CreateBlockStoreVolumeWithNonReplicatedPartitions) { //+
         TTestBasicRuntime runtime;
         TTestEnv env(runtime);
@@ -7402,14 +7402,14 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
                                   {NKikimrScheme::StatusInvalidParameter});
         vc.ClearExplicitChannelProfiles();
 
-        // Number of volume channel explicit profiles must be equal to 3
-        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-1");
-        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-2");
-        TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot",
-                                  vdescr.DebugString(),
+        // Number of volume channel explicit profiles must be equal to 3 
+        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-1"); 
+        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-2"); 
+        TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot", 
+                                  vdescr.DebugString(), 
                                   {NKikimrScheme::StatusInvalidParameter});
-        vc.ClearVolumeExplicitChannelProfiles();
-
+        vc.ClearVolumeExplicitChannelProfiles(); 
+ 
         // Changing PoolKind is not allowed
         vc.AddExplicitChannelProfiles()->SetPoolKind("pool-kind-1");
         vc.MutableExplicitChannelProfiles(0)->SetSize(128);
@@ -7503,7 +7503,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
         {
             NKikimrBlockStore::TVolumeConfig config;
             TestLs(runtime, "/MyRoot/BSVolume", false, NLs::ExtractVolumeConfig(&config));
-            UNIT_ASSERT_VALUES_EQUAL(config.GetDiskId(), "foo");
+            UNIT_ASSERT_VALUES_EQUAL(config.GetDiskId(), "foo"); 
             UNIT_ASSERT_VALUES_EQUAL(config.GetOpaque(), "binary data");
         }
 
@@ -7526,27 +7526,27 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
         *vc.AddTags() = "tag4";
         TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString());
         env.TestWaitNotification(runtime, txId);
-
-        vc.SetVersion(9);
-        // Set volume tablet channels
-
-        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-1");
-        vc.MutableVolumeExplicitChannelProfiles(0)->SetSize(128);
-        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-1");
-        vc.MutableVolumeExplicitChannelProfiles(1)->SetSize(128);
-        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-1");
-        vc.MutableVolumeExplicitChannelProfiles(2)->SetSize(128);
-        TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString());
-        env.TestWaitNotification(runtime, txId);
-
-        vc.SetVersion(10);
-        // Changing volume tablet channels
-
-        vc.MutableVolumeExplicitChannelProfiles(0)->SetPoolKind("pool-kind-2");
-        vc.MutableVolumeExplicitChannelProfiles(1)->SetPoolKind("pool-kind-2");
-        vc.MutableVolumeExplicitChannelProfiles(2)->SetPoolKind("pool-kind-2");
-        TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString());
-        env.TestWaitNotification(runtime, txId);
+ 
+        vc.SetVersion(9); 
+        // Set volume tablet channels 
+ 
+        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-1"); 
+        vc.MutableVolumeExplicitChannelProfiles(0)->SetSize(128); 
+        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-1"); 
+        vc.MutableVolumeExplicitChannelProfiles(1)->SetSize(128); 
+        vc.AddVolumeExplicitChannelProfiles()->SetPoolKind("pool-kind-1"); 
+        vc.MutableVolumeExplicitChannelProfiles(2)->SetSize(128); 
+        TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString()); 
+        env.TestWaitNotification(runtime, txId); 
+ 
+        vc.SetVersion(10); 
+        // Changing volume tablet channels 
+ 
+        vc.MutableVolumeExplicitChannelProfiles(0)->SetPoolKind("pool-kind-2"); 
+        vc.MutableVolumeExplicitChannelProfiles(1)->SetPoolKind("pool-kind-2"); 
+        vc.MutableVolumeExplicitChannelProfiles(2)->SetPoolKind("pool-kind-2"); 
+        TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString()); 
+        env.TestWaitNotification(runtime, txId); 
         vc.Clear();
 
         {
@@ -7554,7 +7554,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
             NLs::ExtractVolumeConfig(&config)(DescribePath(runtime, "/MyRoot/BSVolume"));
             UNIT_ASSERT_VALUES_EQUAL(config.GetBlockSize(), 4096u);
             UNIT_ASSERT_VALUES_EQUAL(config.PartitionsSize(), 2);
-            UNIT_ASSERT_VALUES_EQUAL(config.GetDiskId(), "foobaz");
+            UNIT_ASSERT_VALUES_EQUAL(config.GetDiskId(), "foobaz"); 
             UNIT_ASSERT_VALUES_EQUAL(config.GetFolderId(), "baz");
             UNIT_ASSERT_VALUES_EQUAL(config.GetOpaque(), "binary data");
 
@@ -7612,15 +7612,15 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
             UNIT_ASSERT_VALUES_EQUAL(config.GetExplicitChannelProfiles(5).GetWriteIops(), 601);
             UNIT_ASSERT_VALUES_EQUAL(config.GetExplicitChannelProfiles(5).GetWriteBandwidth(), 600501);
             UNIT_ASSERT_VALUES_EQUAL(config.GetExplicitChannelProfiles(5).GetDataKind(), 1);
-
-            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(0).GetPoolKind(), "pool-kind-2");
-            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(0).GetSize(), 128);
-
-            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(1).GetPoolKind(), "pool-kind-2");
-            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(1).GetSize(), 128);
-
-            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(2).GetPoolKind(), "pool-kind-2");
-            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(2).GetSize(), 128);
+ 
+            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(0).GetPoolKind(), "pool-kind-2"); 
+            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(0).GetSize(), 128); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(1).GetPoolKind(), "pool-kind-2"); 
+            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(1).GetSize(), 128); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(2).GetPoolKind(), "pool-kind-2"); 
+            UNIT_ASSERT_VALUES_EQUAL(config.GetVolumeExplicitChannelProfiles(2).GetSize(), 128); 
         }
     }
 
@@ -7793,7 +7793,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
         ui64 txId = 100;
 
         // Cannot assign non-existant volume
-        TestAssignBlockStoreVolume(runtime, ++txId, "/MyRoot", "BSVolume", "Owner123", 0,
+        TestAssignBlockStoreVolume(runtime, ++txId, "/MyRoot", "BSVolume", "Owner123", 0, 
                 {NKikimrScheme::StatusPathDoesNotExist});
 
         // Create volume with 1 partition
@@ -7820,22 +7820,22 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
         TestDescribeResult(DescribePath(runtime, "/MyRoot/BSVolume"),
                            {NLs::CheckMountToken("BSVolume", "Owner123")});
 
-        // AssignVolume to Owner124
-        TestAssignBlockStoreVolume(runtime, ++txId, "/MyRoot", "BSVolume", "Owner124");
-
-        TestDescribeResult(DescribePath(runtime, "/MyRoot/BSVolume"),
-                           {NLs::CheckMountToken("BSVolume", "Owner124")});
+        // AssignVolume to Owner124 
+        TestAssignBlockStoreVolume(runtime, ++txId, "/MyRoot", "BSVolume", "Owner124"); 
+ 
+        TestDescribeResult(DescribePath(runtime, "/MyRoot/BSVolume"), 
+                           {NLs::CheckMountToken("BSVolume", "Owner124")}); 
 
         // AssignVolume using TokenVersion
-        TestAssignBlockStoreVolume(runtime, ++txId, "/MyRoot", "BSVolume", "Owner125", 2);
-
-        TestDescribeResult(DescribePath(runtime, "/MyRoot/BSVolume"),
-                           {NLs::CheckMountToken("BSVolume", "Owner125")});
-
-        // AssignVolume using wrong TokenVersion
-        TestAssignBlockStoreVolume(runtime, ++txId, "/MyRoot", "BSVolume", "Owner126", 2,
+        TestAssignBlockStoreVolume(runtime, ++txId, "/MyRoot", "BSVolume", "Owner125", 2); 
+ 
+        TestDescribeResult(DescribePath(runtime, "/MyRoot/BSVolume"), 
+                           {NLs::CheckMountToken("BSVolume", "Owner125")}); 
+ 
+        // AssignVolume using wrong TokenVersion 
+        TestAssignBlockStoreVolume(runtime, ++txId, "/MyRoot", "BSVolume", "Owner126", 2, 
             {NKikimrScheme::StatusPreconditionFailed});
-
+ 
         // Alter is allowed
         vc.SetVersion(1);
         vc.AddPartitions()->SetBlockCount(32);
@@ -7886,10 +7886,10 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
     }
 
     Y_UNIT_TEST(AssignBlockStoreCheckVersionInAlter) { //+
-        TTestBasicRuntime runtime;
-        TTestEnv env(runtime);
-        ui64 txId = 100;
-
+        TTestBasicRuntime runtime; 
+        TTestEnv env(runtime); 
+        ui64 txId = 100; 
+ 
         NKikimrSchemeOp::TBlockStoreVolumeDescription vdescr;
         vdescr.SetName("BSVolume");
         auto& vc = *vdescr.MutableVolumeConfig();
@@ -7903,7 +7903,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
         TestCreateBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString());
         env.TestWaitNotification(runtime, txId);
         vc.Clear();
-
+ 
         vc.SetVersion(1);
         vc.AddPartitions()->SetBlockCount(24);
         vc.AddPartitions()->SetBlockCount(24);
@@ -7911,7 +7911,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
         TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString());
         env.TestWaitNotification(runtime, txId);
         vc.Clear();
-
+ 
         vc.SetVersion(0);
         vc.AddPartitions()->SetBlockCount(25);
         vc.AddPartitions()->SetBlockCount(25);
@@ -7921,7 +7921,7 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
                        {NKikimrScheme::StatusPreconditionFailed});
         env.TestWaitNotification(runtime, txId);
         vc.Clear();
-
+ 
         vc.SetVersion(1);
         vc.AddPartitions()->SetBlockCount(32);
         vc.AddPartitions()->SetBlockCount(32);
@@ -7931,15 +7931,15 @@ Y_UNIT_TEST_SUITE(TSchemeShardTest) {
                        {NKikimrScheme::StatusPreconditionFailed});
         env.TestWaitNotification(runtime, txId);
         vc.Clear();
-
+ 
         vc.SetVersion(2);
         vc.AddPartitions()->SetBlockCount(48);
         vc.AddPartitions()->SetBlockCount(48);
 
         TestAlterBlockStoreVolume(runtime, ++txId, "/MyRoot", vdescr.DebugString());
         env.TestWaitNotification(runtime, txId);
-    }
-
+    } 
+ 
     Y_UNIT_TEST(BlockStoreVolumeLimits) { //+
         TTestBasicRuntime runtime;
         TTestEnv env(runtime);
diff --git a/ydb/core/tx/schemeshard/ut_bsvolume_reboots.cpp b/ydb/core/tx/schemeshard/ut_bsvolume_reboots.cpp
index 5dbdecf8e6..c4e74a41b6 100644
--- a/ydb/core/tx/schemeshard/ut_bsvolume_reboots.cpp
+++ b/ydb/core/tx/schemeshard/ut_bsvolume_reboots.cpp
@@ -322,31 +322,31 @@ Y_UNIT_TEST_SUITE(TBSVWithReboots) {
             AsyncCreateBlockStoreVolume(runtime, txId, root, vdescr.DebugString());
         });
     }
-
-
-    Y_UNIT_TEST(CreateAssignWithVersion) {
-        TTestWithReboots t;
-        t.Run([&](TTestActorRuntime& runtime, bool& activeZone) {
-            Y_UNUSED(activeZone);
-
-            t.RestoreLogging();
-
+ 
+ 
+    Y_UNIT_TEST(CreateAssignWithVersion) { 
+        TTestWithReboots t; 
+        t.Run([&](TTestActorRuntime& runtime, bool& activeZone) { 
+            Y_UNUSED(activeZone); 
+ 
+            t.RestoreLogging(); 
+ 
             NKikimrSchemeOp::TBlockStoreVolumeDescription vdescr;
-            InitCreateVolumeConfig("BSVolume_4", vdescr);
-            TestCreateBlockStoreVolume(runtime, t.TxId++, "/MyRoot/DirA", vdescr.DebugString());
-
-            t.TestEnv->TestWaitNotification(runtime, t.TxId-1);
-            TestLs(runtime, "/MyRoot/DirA/BSVolume_4", false, NLs::Finished);
-
-            TestAssignBlockStoreVolume(runtime, t.TxId++, "/MyRoot/DirA", "BSVolume_4", "Owner123", 0);
-            t.TestEnv->TestWaitNotification(runtime, t.TxId-1);
-            TestLs(runtime, "/MyRoot/DirA/BSVolume_4", false, NLs::CheckMountToken("BSVolume_4", "Owner123"));
-
-
-           TestAssignBlockStoreVolume(runtime, t.TxId++, "/MyRoot/DirA", "BSVolume_4", "Owner124", 1);
-            t.TestEnv->TestWaitNotification(runtime, t.TxId-1);
-            TestLs(runtime, "/MyRoot/DirA/BSVolume_4", false, NLs::CheckMountToken("BSVolume_4", "Owner124"));
-
-        });
+            InitCreateVolumeConfig("BSVolume_4", vdescr); 
+            TestCreateBlockStoreVolume(runtime, t.TxId++, "/MyRoot/DirA", vdescr.DebugString()); 
+ 
+            t.TestEnv->TestWaitNotification(runtime, t.TxId-1); 
+            TestLs(runtime, "/MyRoot/DirA/BSVolume_4", false, NLs::Finished); 
+ 
+            TestAssignBlockStoreVolume(runtime, t.TxId++, "/MyRoot/DirA", "BSVolume_4", "Owner123", 0); 
+            t.TestEnv->TestWaitNotification(runtime, t.TxId-1); 
+            TestLs(runtime, "/MyRoot/DirA/BSVolume_4", false, NLs::CheckMountToken("BSVolume_4", "Owner123")); 
+ 
+ 
+           TestAssignBlockStoreVolume(runtime, t.TxId++, "/MyRoot/DirA", "BSVolume_4", "Owner124", 1); 
+            t.TestEnv->TestWaitNotification(runtime, t.TxId-1); 
+            TestLs(runtime, "/MyRoot/DirA/BSVolume_4", false, NLs::CheckMountToken("BSVolume_4", "Owner124")); 
+
+        }); 
     }
 }
diff --git a/ydb/core/tx/schemeshard/ut_helpers/helpers.cpp b/ydb/core/tx/schemeshard/ut_helpers/helpers.cpp
index 6f999b268b..fb16c58793 100644
--- a/ydb/core/tx/schemeshard/ut_helpers/helpers.cpp
+++ b/ydb/core/tx/schemeshard/ut_helpers/helpers.cpp
@@ -808,7 +808,7 @@ namespace NSchemeShardUT_Private {
     }
 
     void AsyncAssignBlockStoreVolume(TTestActorRuntime& runtime, ui64 txId, const TString& parentPath, const TString& name,
-            const TString& mountToken, ui64 tokenVersion)
+            const TString& mountToken, ui64 tokenVersion) 
     {
         TActorId sender = runtime.AllocateEdgeActor();
         auto evTx = new TEvSchemeShard::TEvModifySchemeTransaction(txId, TTestTxConfig::SchemeShard);
@@ -826,7 +826,7 @@ namespace NSchemeShardUT_Private {
     void TestAssignBlockStoreVolume(TTestActorRuntime& runtime, ui64 txId, const TString& parentPath, const TString& name,
             const TString& mountToken, ui64 tokenVersion, const TVector<TEvSchemeShard::EStatus>& expectedResults)
     {
-        AsyncAssignBlockStoreVolume(runtime, txId, parentPath, name, mountToken, tokenVersion);
+        AsyncAssignBlockStoreVolume(runtime, txId, parentPath, name, mountToken, tokenVersion); 
         TestModificationResults(runtime, txId, expectedResults);
     }