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

185 files changed, 18847 insertions, 18847 deletions

diff --git a/library/cpp/actors/core/actor.h b/library/cpp/actors/core/actor.h
index dad2bc59c1..ed29bd14b9 100644
--- a/library/cpp/actors/core/actor.h
+++ b/library/cpp/actors/core/actor.h
@@ -207,8 +207,8 @@ namespace NActors {
         virtual TActorId RegisterWithSameMailbox(IActor*) const noexcept = 0;
     };
 
-    class TDecorator; 
- 
+    class TDecorator;
+
     class IActor : protected IActorOps {
     public:
         typedef void (IActor::*TReceiveFunc)(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx);
@@ -220,7 +220,7 @@ namespace NActors {
         ui64 HandledEvents;
 
         friend void DoActorInit(TActorSystem*, IActor*, const TActorId&, const TActorId&);
-        friend class TDecorator; 
+        friend class TDecorator;
 
     public:
         /// @sa services.proto NKikimrServices::TActivity::EType
@@ -376,11 +376,11 @@ namespace NActors {
         TActorId RegisterWithSameMailbox(IActor* actor) const noexcept final;
 
         std::pair<ui32, ui32> CountMailboxEvents(ui32 maxTraverse = Max<ui32>()) const;
- 
-    private: 
-        void ChangeSelfId(TActorId actorId) { 
-            SelfActorId = actorId; 
-        } 
+
+    private:
+        void ChangeSelfId(TActorId actorId) {
+            SelfActorId = actorId;
+        }
     };
 
     struct TActorActivityTag {};
@@ -458,63 +458,63 @@ namespace NActors {
         auto& tls = *TlsActivationContext;
         return TActorContext(tls.Mailbox, tls.ExecutorThread, tls.EventStart, id);
     }
- 
-    class TDecorator : public IActor { 
-    protected: 
-        THolder<IActor> Actor; 
- 
-    public: 
-        TDecorator(THolder<IActor>&& actor) 
-            : IActor(static_cast<TReceiveFunc>(&TDecorator::State), actor->GetActivityType()) 
-            , Actor(std::move(actor)) 
-        { 
-        } 
- 
-        void Registered(TActorSystem* sys, const TActorId& owner) override { 
-            Actor->ChangeSelfId(SelfId()); 
-            Actor->Registered(sys, owner); 
-        } 
- 
-        virtual bool DoBeforeReceiving(TAutoPtr<IEventHandle>& /*ev*/, const TActorContext& /*ctx*/) { 
-            return true; 
-        } 
-
-        virtual void DoAfterReceiving(const TActorContext& /*ctx*/) 
-        { 
-        } 
- 
-        STFUNC(State) { 
-            if (DoBeforeReceiving(ev, ctx)) { 
-                Actor->Receive(ev, ctx); 
-                DoAfterReceiving(ctx); 
-            } 
-        } 
-    }; 
- 
-    // TTestDecorator doesn't work with the real actor system 
-    struct TTestDecorator : public TDecorator { 
-        TTestDecorator(THolder<IActor>&& actor) 
-            : TDecorator(std::move(actor)) 
-        { 
-        } 
- 
-        virtual ~TTestDecorator() = default; 
- 
-        // This method must be called in the test actor system 
-        bool BeforeSending(TAutoPtr<IEventHandle>& ev) 
-        { 
-            bool send = true; 
-            TTestDecorator *decorator = dynamic_cast<TTestDecorator*>(Actor.Get()); 
-            if (decorator) { 
-                send = decorator->BeforeSending(ev); 
-            } 
-            return send && ev && DoBeforeSending(ev); 
-        } 
- 
-        virtual bool DoBeforeSending(TAutoPtr<IEventHandle>& /*ev*/) { 
-            return true; 
-        } 
-    }; 
+
+    class TDecorator : public IActor {
+    protected:
+        THolder<IActor> Actor;
+
+    public:
+        TDecorator(THolder<IActor>&& actor)
+            : IActor(static_cast<TReceiveFunc>(&TDecorator::State), actor->GetActivityType())
+            , Actor(std::move(actor))
+        {
+        }
+
+        void Registered(TActorSystem* sys, const TActorId& owner) override {
+            Actor->ChangeSelfId(SelfId());
+            Actor->Registered(sys, owner);
+        }
+
+        virtual bool DoBeforeReceiving(TAutoPtr<IEventHandle>& /*ev*/, const TActorContext& /*ctx*/) {
+            return true;
+        }
+
+        virtual void DoAfterReceiving(const TActorContext& /*ctx*/)
+        {
+        }
+
+        STFUNC(State) {
+            if (DoBeforeReceiving(ev, ctx)) {
+                Actor->Receive(ev, ctx);
+                DoAfterReceiving(ctx);
+            }
+        }
+    };
+
+    // TTestDecorator doesn't work with the real actor system
+    struct TTestDecorator : public TDecorator {
+        TTestDecorator(THolder<IActor>&& actor)
+            : TDecorator(std::move(actor))
+        {
+        }
+
+        virtual ~TTestDecorator() = default;
+
+        // This method must be called in the test actor system
+        bool BeforeSending(TAutoPtr<IEventHandle>& ev)
+        {
+            bool send = true;
+            TTestDecorator *decorator = dynamic_cast<TTestDecorator*>(Actor.Get());
+            if (decorator) {
+                send = decorator->BeforeSending(ev);
+            }
+            return send && ev && DoBeforeSending(ev);
+        }
+
+        virtual bool DoBeforeSending(TAutoPtr<IEventHandle>& /*ev*/) {
+            return true;
+        }
+    };
 }
 
 template <>
diff --git a/library/cpp/actors/core/actor_ut.cpp b/library/cpp/actors/core/actor_ut.cpp
index a0a703e297..e1b765ec72 100644
--- a/library/cpp/actors/core/actor_ut.cpp
+++ b/library/cpp/actors/core/actor_ut.cpp
@@ -1,24 +1,24 @@
-#include "actor.cpp" 
-#include "events.h" 
-#include "actorsystem.h" 
-#include "executor_pool_basic.h" 
-#include "scheduler_basic.h" 
-#include "actor_bootstrapped.h" 
- 
+#include "actor.cpp"
+#include "events.h"
+#include "actorsystem.h"
+#include "executor_pool_basic.h"
+#include "scheduler_basic.h"
+#include "actor_bootstrapped.h"
+
 #include <library/cpp/actors/util/threadparkpad.h>
-#include <library/cpp/testing/unittest/registar.h> 
- 
+#include <library/cpp/testing/unittest/registar.h>
+
 #include <util/generic/algorithm.h>
 #include <util/system/atomic.h>
 #include <util/system/rwlock.h>
 #include <util/system/hp_timer.h>
- 
-using namespace NActors; 
- 
+
+using namespace NActors;
+
 struct TTestEndDecorator : TDecorator {
     TThreadParkPad* Pad;
     TAtomic* ActorsAlive;
- 
+
     TTestEndDecorator(THolder<IActor>&& actor, TThreadParkPad* pad, TAtomic* actorsAlive)
         : TDecorator(std::move(actor))
         , Pad(pad)
@@ -57,7 +57,7 @@ Y_UNIT_TEST_SUITE(ActorBenchmark) {
     public:
         static constexpr auto ActorActivityType() {
             return ACTORLIB_COMMON;
-        } 
+        }
 
         TSendReceiveActor(double* elapsedTime, TActorId receiver, bool allocation, ERole role, ui32 neighbours = 0)
             : EventsCounter(TotalEventsAmount)
@@ -108,8 +108,8 @@ Y_UNIT_TEST_SUITE(ActorBenchmark) {
         bool AllocatesMemory;
         ERole Role;
         ui32 MailboxNeighboursCount;
-    }; 
- 
+    };
+
     void AddBasicPool(THolder<TActorSystemSetup>& setup, ui32 threads, bool activateEveryEvent) {
         TBasicExecutorPoolConfig basic;
         basic.PoolId = setup->GetExecutorsCount();
@@ -482,90 +482,90 @@ Y_UNIT_TEST_SUITE(ActorBenchmark) {
 }
 
 Y_UNIT_TEST_SUITE(TestDecorator) {
-    struct TPingDecorator : TDecorator { 
-        TAutoPtr<IEventHandle> SavedEvent = nullptr; 
+    struct TPingDecorator : TDecorator {
+        TAutoPtr<IEventHandle> SavedEvent = nullptr;
         ui64* Counter;
- 
+
         TPingDecorator(THolder<IActor>&& actor, ui64* counter)
-            : TDecorator(std::move(actor)) 
-            , Counter(counter) 
-        { 
-        } 
- 
+            : TDecorator(std::move(actor))
+            , Counter(counter)
+        {
+        }
+
         bool DoBeforeReceiving(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) override {
-            *Counter += 1; 
-            if (ev->Type != TEvents::THelloWorld::Pong) { 
-                TAutoPtr<IEventHandle> pingEv = new IEventHandle(SelfId(), SelfId(), new TEvents::TEvPing()); 
-                SavedEvent = ev; 
-                Actor->Receive(pingEv, ctx); 
-            } else { 
-                Actor->Receive(SavedEvent, ctx); 
-            } 
-            return false; 
-        } 
-    }; 
- 
-    struct TPongDecorator : TDecorator { 
+            *Counter += 1;
+            if (ev->Type != TEvents::THelloWorld::Pong) {
+                TAutoPtr<IEventHandle> pingEv = new IEventHandle(SelfId(), SelfId(), new TEvents::TEvPing());
+                SavedEvent = ev;
+                Actor->Receive(pingEv, ctx);
+            } else {
+                Actor->Receive(SavedEvent, ctx);
+            }
+            return false;
+        }
+    };
+
+    struct TPongDecorator : TDecorator {
         ui64* Counter;
- 
+
         TPongDecorator(THolder<IActor>&& actor, ui64* counter)
-            : TDecorator(std::move(actor)) 
-            , Counter(counter) 
-        { 
-        } 
+            : TDecorator(std::move(actor))
+            , Counter(counter)
+        {
+        }
 
         bool DoBeforeReceiving(TAutoPtr<IEventHandle>& ev, const TActorContext&) override {
-            *Counter += 1; 
-            if (ev->Type == TEvents::THelloWorld::Ping) { 
-                TAutoPtr<IEventHandle> pongEv = new IEventHandle(SelfId(), SelfId(), new TEvents::TEvPong()); 
-                Send(SelfId(), new TEvents::TEvPong()); 
-                return false; 
-            } 
-            return true; 
-        } 
-    }; 
- 
+            *Counter += 1;
+            if (ev->Type == TEvents::THelloWorld::Ping) {
+                TAutoPtr<IEventHandle> pongEv = new IEventHandle(SelfId(), SelfId(), new TEvents::TEvPong());
+                Send(SelfId(), new TEvents::TEvPong());
+                return false;
+            }
+            return true;
+        }
+    };
+
     struct TTestActor : TActorBootstrapped<TTestActor> {
         static constexpr char ActorName[] = "TestActor";
 
-        void Bootstrap() 
-        { 
+        void Bootstrap()
+        {
             const auto& activityTypeIndex = GetActivityType();
             Y_ENSURE(activityTypeIndex < GetActivityTypeCount());
             Y_ENSURE(GetActivityTypeName(activityTypeIndex) == "TestActor");
-            PassAway(); 
-        } 
-    }; 
-
-    Y_UNIT_TEST(Basic) { 
-        THolder<TActorSystemSetup> setup = MakeHolder<TActorSystemSetup>(); 
-        setup->NodeId = 0; 
-        setup->ExecutorsCount = 1; 
-        setup->Executors.Reset(new TAutoPtr<IExecutorPool>[setup->ExecutorsCount]); 
-        for (ui32 i = 0; i < setup->ExecutorsCount; ++i) { 
-            setup->Executors[i] = new TBasicExecutorPool(i, 1, 10, "basic"); 
-        } 
-        setup->Scheduler = new TBasicSchedulerThread; 
- 
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
+            PassAway();
+        }
+    };
+
+    Y_UNIT_TEST(Basic) {
+        THolder<TActorSystemSetup> setup = MakeHolder<TActorSystemSetup>();
+        setup->NodeId = 0;
+        setup->ExecutorsCount = 1;
+        setup->Executors.Reset(new TAutoPtr<IExecutorPool>[setup->ExecutorsCount]);
+        for (ui32 i = 0; i < setup->ExecutorsCount; ++i) {
+            setup->Executors[i] = new TBasicExecutorPool(i, 1, 10, "basic");
+        }
+        setup->Scheduler = new TBasicSchedulerThread;
+
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
         THolder<IActor> innerActor = MakeHolder<TTestActor>();
-        ui64 pongCounter = 0; 
+        ui64 pongCounter = 0;
         THolder<IActor> pongActor = MakeHolder<TPongDecorator>(std::move(innerActor), &pongCounter);
-        ui64 pingCounter = 0; 
+        ui64 pingCounter = 0;
         THolder<IActor> pingActor = MakeHolder<TPingDecorator>(std::move(pongActor), &pingCounter);
 
         TThreadParkPad pad;
         TAtomic actorsAlive = 0;
- 
+
         THolder<IActor> endActor = MakeHolder<TTestEndDecorator>(std::move(pingActor), &pad, &actorsAlive);
         actorSystem.Register(endActor.Release(), TMailboxType::HTSwap);
 
         pad.Park();
-        actorSystem.Stop(); 
-        UNIT_ASSERT(pongCounter == 2 && pingCounter == 2); 
-    } 
+        actorSystem.Stop();
+        UNIT_ASSERT(pongCounter == 2 && pingCounter == 2);
+    }
 
     Y_UNIT_TEST(LocalProcessKey) {
         static constexpr char ActorName[] = "TestActor";
@@ -575,4 +575,4 @@ Y_UNIT_TEST_SUITE(TestDecorator) {
         UNIT_ASSERT((TLocalProcessKey<TActorActivityTag, ActorName>::GetName() == ActorName));
         UNIT_ASSERT((TEnumProcessKey<TActorActivityTag, IActor::EActorActivity>::GetIndex(IActor::INTERCONNECT_PROXY_TCP) == IActor::INTERCONNECT_PROXY_TCP));
     }
-} 
+}
diff --git a/library/cpp/actors/core/executor_pool_basic.cpp b/library/cpp/actors/core/executor_pool_basic.cpp
index f7a9418a82..4dce16939a 100644
--- a/library/cpp/actors/core/executor_pool_basic.cpp
+++ b/library/cpp/actors/core/executor_pool_basic.cpp
@@ -34,7 +34,7 @@ namespace NActors {
         , ThreadUtilization(0)
         , MaxUtilizationCounter(0)
         , MaxUtilizationAccumulator(0)
-        , ThreadCount(threads) 
+        , ThreadCount(threads)
     {
     }
 
@@ -62,26 +62,26 @@ namespace NActors {
 
         NHPTimer::STime elapsed = 0;
         NHPTimer::STime parked = 0;
-        NHPTimer::STime blocked = 0; 
+        NHPTimer::STime blocked = 0;
         NHPTimer::STime hpstart = GetCycleCountFast();
         NHPTimer::STime hpnow;
 
         TThreadCtx& threadCtx = Threads[workerId];
-        AtomicSet(threadCtx.WaitingFlag, TThreadCtx::WS_NONE); 
- 
-        if (Y_UNLIKELY(AtomicGet(threadCtx.BlockedFlag) != TThreadCtx::BS_NONE)) { 
-            do { 
-                if (AtomicCas(&threadCtx.BlockedFlag, TThreadCtx::BS_BLOCKED, TThreadCtx::BS_BLOCKING)) { 
+        AtomicSet(threadCtx.WaitingFlag, TThreadCtx::WS_NONE);
+
+        if (Y_UNLIKELY(AtomicGet(threadCtx.BlockedFlag) != TThreadCtx::BS_NONE)) {
+            do {
+                if (AtomicCas(&threadCtx.BlockedFlag, TThreadCtx::BS_BLOCKED, TThreadCtx::BS_BLOCKING)) {
                     hpnow = GetCycleCountFast();
-                    elapsed += hpnow - hpstart; 
-                    if (threadCtx.BlockedPad.Park()) // interrupted 
-                        return 0; 
+                    elapsed += hpnow - hpstart;
+                    if (threadCtx.BlockedPad.Park()) // interrupted
+                        return 0;
                     hpstart = GetCycleCountFast();
-                    blocked += hpstart - hpnow; 
-                } 
-            } while (AtomicGet(threadCtx.BlockedFlag) != TThreadCtx::BS_NONE && !AtomicLoad(&StopFlag)); 
-        } 
- 
+                    blocked += hpstart - hpnow;
+                }
+            } while (AtomicGet(threadCtx.BlockedFlag) != TThreadCtx::BS_NONE && !AtomicLoad(&StopFlag));
+        }
+
         const TAtomic x = AtomicDecrement(Semaphore);
 
         if (x < 0) {
@@ -101,7 +101,7 @@ namespace NActors {
             }
 #endif
 
-            Y_VERIFY(AtomicLoad(&threadCtx.WaitingFlag) == TThreadCtx::WS_NONE); 
+            Y_VERIFY(AtomicLoad(&threadCtx.WaitingFlag) == TThreadCtx::WS_NONE);
 
             if (SpinThreshold > 0) {
                 // spin configured period
@@ -155,7 +155,7 @@ namespace NActors {
                 } while (AtomicLoad(&threadCtx.WaitingFlag) == TThreadCtx::WS_BLOCKED);
             }
 
-            Y_VERIFY_DEBUG(AtomicLoad(&StopFlag) || AtomicLoad(&threadCtx.WaitingFlag) == TThreadCtx::WS_RUNNING); 
+            Y_VERIFY_DEBUG(AtomicLoad(&StopFlag) || AtomicLoad(&threadCtx.WaitingFlag) == TThreadCtx::WS_RUNNING);
 
 #if defined ACTORSLIB_COLLECT_EXEC_STATS
             if (AtomicDecrement(ThreadUtilization) == 0) {
@@ -176,8 +176,8 @@ namespace NActors {
                     AtomicStore(&MaxUtilizationAccumulator, x);
             }
 #endif
-        } else { 
-            AtomicSet(threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING); 
+        } else {
+            AtomicSet(threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING);
         }
 
         // ok, has work suggested, must dequeue
@@ -189,9 +189,9 @@ namespace NActors {
                 if (parked > 0) {
                     wctx.AddParkedCycles(parked);
                 }
-                if (blocked > 0) { 
+                if (blocked > 0) {
                     wctx.AddBlockedCycles(blocked);
-                } 
+                }
                 return activation;
             }
             SpinLockPause();
@@ -202,30 +202,30 @@ namespace NActors {
     }
 
     inline void TBasicExecutorPool::WakeUpLoop() {
-        for (ui32 i = 0;;) { 
-            TThreadCtx& threadCtx = Threads[i % PoolThreads]; 
-            switch (AtomicLoad(&threadCtx.WaitingFlag)) { 
-                case TThreadCtx::WS_NONE: 
-                case TThreadCtx::WS_RUNNING: 
-                    ++i; 
-                    break; 
-                case TThreadCtx::WS_ACTIVE: // in active spin-lock, just set flag 
-                    if (AtomicCas(&threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING, TThreadCtx::WS_ACTIVE)) { 
-                        return; 
-                    } 
-                    break; 
-                case TThreadCtx::WS_BLOCKED: 
-                    if (AtomicCas(&threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING, TThreadCtx::WS_BLOCKED)) { 
-                        threadCtx.Pad.Unpark(); 
-                        return; 
-                    } 
-                    break; 
-                default: 
-                    Y_FAIL(); 
-            } 
-        } 
-    } 
- 
+        for (ui32 i = 0;;) {
+            TThreadCtx& threadCtx = Threads[i % PoolThreads];
+            switch (AtomicLoad(&threadCtx.WaitingFlag)) {
+                case TThreadCtx::WS_NONE:
+                case TThreadCtx::WS_RUNNING:
+                    ++i;
+                    break;
+                case TThreadCtx::WS_ACTIVE: // in active spin-lock, just set flag
+                    if (AtomicCas(&threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING, TThreadCtx::WS_ACTIVE)) {
+                        return;
+                    }
+                    break;
+                case TThreadCtx::WS_BLOCKED:
+                    if (AtomicCas(&threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING, TThreadCtx::WS_BLOCKED)) {
+                        threadCtx.Pad.Unpark();
+                        return;
+                    }
+                    break;
+                default:
+                    Y_FAIL();
+            }
+        }
+    }
+
     void TBasicExecutorPool::ScheduleActivationEx(ui32 activation, ui64 revolvingCounter) {
         Activations.Push(activation, revolvingCounter);
         const TAtomic x = AtomicIncrement(Semaphore);
@@ -286,10 +286,10 @@ namespace NActors {
 
     void TBasicExecutorPool::PrepareStop() {
         AtomicStore(&StopFlag, true);
-        for (ui32 i = 0; i != PoolThreads; ++i) { 
+        for (ui32 i = 0; i != PoolThreads; ++i) {
             Threads[i].Pad.Interrupt();
-            Threads[i].BlockedPad.Interrupt(); 
-        } 
+            Threads[i].BlockedPad.Interrupt();
+        }
     }
 
     void TBasicExecutorPool::Shutdown() {
@@ -335,97 +335,97 @@ namespace NActors {
         Y_UNUSED(RealtimePriority);
 #endif
     }
- 
-    ui32 TBasicExecutorPool::GetThreadCount() const { 
-        return AtomicGet(ThreadCount); 
-    } 
- 
-    void TBasicExecutorPool::SetThreadCount(ui32 threads) { 
-        threads = Max(1u, Min(PoolThreads, threads)); 
-        with_lock (ChangeThreadsLock) { 
-            size_t prevCount = GetThreadCount(); 
-            AtomicSet(ThreadCount, threads); 
-            if (prevCount < threads) { 
-                for (size_t i = prevCount; i < threads; ++i) { 
-                    bool repeat = true; 
-                    while (repeat) { 
-                        switch (AtomicGet(Threads[i].BlockedFlag)) { 
-                        case TThreadCtx::BS_BLOCKING: 
-                            if (AtomicCas(&Threads[i].BlockedFlag, TThreadCtx::BS_NONE, TThreadCtx::BS_BLOCKING)) { 
-                                // thread not entry to blocked loop 
-                                repeat = false; 
-                            } 
-                            break; 
-                        case TThreadCtx::BS_BLOCKED: 
-                            // thread entry to blocked loop and we wake it 
-                            AtomicSet(Threads[i].BlockedFlag, TThreadCtx::BS_NONE); 
-                            Threads[i].BlockedPad.Unpark(); 
-                            repeat = false; 
-                            break; 
-                        default: 
-                            // thread mustn't has TThreadCtx::BS_NONE because last time it was started to block 
-                            Y_FAIL("BlockedFlag is not TThreadCtx::BS_BLOCKING and TThreadCtx::BS_BLOCKED when thread was waked up"); 
-                        } 
-                    } 
-                } 
-            } else if (prevCount > threads) { 
-                // at first, start to block 
-                for (size_t i = threads; i < prevCount; ++i) { 
-                    Y_VERIFY(AtomicGet(Threads[i].BlockedFlag) == TThreadCtx::BS_NONE); 
-                    AtomicSet(Threads[i].BlockedFlag, TThreadCtx::BS_BLOCKING); 
-                } 
-                // after check need to wake up threads 
-                for (size_t idx = threads; idx < prevCount; ++idx) { 
-                    TThreadCtx& threadCtx = Threads[idx]; 
-                    auto waitingFlag = AtomicGet(threadCtx.WaitingFlag); 
-                    auto blockedFlag = AtomicGet(threadCtx.BlockedFlag); 
-                    // while thread has this states (WS_NONE and BS_BLOCKING) we can't guess which way thread will go. 
-                    // Either go to sleep and it will have to wake up, 
-                    // or go to execute task and after completion will be blocked. 
-                    while (waitingFlag == TThreadCtx::WS_NONE && blockedFlag == TThreadCtx::BS_BLOCKING) { 
-                        waitingFlag = AtomicGet(threadCtx.WaitingFlag); 
-                        blockedFlag = AtomicGet(threadCtx.BlockedFlag); 
-                    } 
-                    // next states: 
-                    // 1) WS_ACTIVE  BS_BLOCKING - waiting and start spinig | need wake up to block 
-                    // 2) WS_BLOCKED BS_BLOCKING - waiting and start sleep  | need wake up to block 
-                    // 3) WS_RUNNING BS_BLOCKING - start execute | not need wake up, will block after executing 
-                    // 4) WS_NONE    BS_BLOCKED  - blocked       | not need wake up, already blocked 
- 
-                    if (waitingFlag == TThreadCtx::WS_ACTIVE || waitingFlag == TThreadCtx::WS_BLOCKED) { 
-                        // need wake up 
-                        Y_VERIFY(blockedFlag == TThreadCtx::BS_BLOCKING); 
- 
-                        // creaty empty mailBoxHint, where LineIndex == 1 and LineHint == 0, and activations will be ignored 
-                        constexpr auto emptyMailBoxHint = TMailboxTable::LineIndexMask & -TMailboxTable::LineIndexMask; 
-                        ui64 revolvingCounter = AtomicGet(ActivationsRevolvingCounter); 
- 
-                        Activations.Push(emptyMailBoxHint, revolvingCounter); 
- 
-                        auto x = AtomicIncrement(Semaphore); 
-                        if (x <= 0) { 
-                            // try wake up. if success then go to next thread 
-                            switch (waitingFlag){ 
-                                case TThreadCtx::WS_ACTIVE: // in active spin-lock, just set flag 
-                                    if (AtomicCas(&threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING, TThreadCtx::WS_ACTIVE)) { 
-                                        continue; 
-                                    } 
-                                    break; 
-                                case TThreadCtx::WS_BLOCKED: 
-                                    if (AtomicCas(&threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING, TThreadCtx::WS_BLOCKED)) { 
-                                        threadCtx.Pad.Unpark(); 
-                                        continue; 
-                                    } 
-                                    break; 
-                                default: 
-                                    ; // other thread woke this sleeping thread 
-                            } 
-                            // if thread has already been awakened then we must awaken the other 
+
+    ui32 TBasicExecutorPool::GetThreadCount() const {
+        return AtomicGet(ThreadCount);
+    }
+
+    void TBasicExecutorPool::SetThreadCount(ui32 threads) {
+        threads = Max(1u, Min(PoolThreads, threads));
+        with_lock (ChangeThreadsLock) {
+            size_t prevCount = GetThreadCount();
+            AtomicSet(ThreadCount, threads);
+            if (prevCount < threads) {
+                for (size_t i = prevCount; i < threads; ++i) {
+                    bool repeat = true;
+                    while (repeat) {
+                        switch (AtomicGet(Threads[i].BlockedFlag)) {
+                        case TThreadCtx::BS_BLOCKING:
+                            if (AtomicCas(&Threads[i].BlockedFlag, TThreadCtx::BS_NONE, TThreadCtx::BS_BLOCKING)) {
+                                // thread not entry to blocked loop
+                                repeat = false;
+                            }
+                            break;
+                        case TThreadCtx::BS_BLOCKED:
+                            // thread entry to blocked loop and we wake it
+                            AtomicSet(Threads[i].BlockedFlag, TThreadCtx::BS_NONE);
+                            Threads[i].BlockedPad.Unpark();
+                            repeat = false;
+                            break;
+                        default:
+                            // thread mustn't has TThreadCtx::BS_NONE because last time it was started to block
+                            Y_FAIL("BlockedFlag is not TThreadCtx::BS_BLOCKING and TThreadCtx::BS_BLOCKED when thread was waked up");
+                        }
+                    }
+                }
+            } else if (prevCount > threads) {
+                // at first, start to block
+                for (size_t i = threads; i < prevCount; ++i) {
+                    Y_VERIFY(AtomicGet(Threads[i].BlockedFlag) == TThreadCtx::BS_NONE);
+                    AtomicSet(Threads[i].BlockedFlag, TThreadCtx::BS_BLOCKING);
+                }
+                // after check need to wake up threads
+                for (size_t idx = threads; idx < prevCount; ++idx) {
+                    TThreadCtx& threadCtx = Threads[idx];
+                    auto waitingFlag = AtomicGet(threadCtx.WaitingFlag);
+                    auto blockedFlag = AtomicGet(threadCtx.BlockedFlag);
+                    // while thread has this states (WS_NONE and BS_BLOCKING) we can't guess which way thread will go.
+                    // Either go to sleep and it will have to wake up,
+                    // or go to execute task and after completion will be blocked.
+                    while (waitingFlag == TThreadCtx::WS_NONE && blockedFlag == TThreadCtx::BS_BLOCKING) {
+                        waitingFlag = AtomicGet(threadCtx.WaitingFlag);
+                        blockedFlag = AtomicGet(threadCtx.BlockedFlag);
+                    }
+                    // next states:
+                    // 1) WS_ACTIVE  BS_BLOCKING - waiting and start spinig | need wake up to block
+                    // 2) WS_BLOCKED BS_BLOCKING - waiting and start sleep  | need wake up to block
+                    // 3) WS_RUNNING BS_BLOCKING - start execute | not need wake up, will block after executing
+                    // 4) WS_NONE    BS_BLOCKED  - blocked       | not need wake up, already blocked
+
+                    if (waitingFlag == TThreadCtx::WS_ACTIVE || waitingFlag == TThreadCtx::WS_BLOCKED) {
+                        // need wake up
+                        Y_VERIFY(blockedFlag == TThreadCtx::BS_BLOCKING);
+
+                        // creaty empty mailBoxHint, where LineIndex == 1 and LineHint == 0, and activations will be ignored
+                        constexpr auto emptyMailBoxHint = TMailboxTable::LineIndexMask & -TMailboxTable::LineIndexMask;
+                        ui64 revolvingCounter = AtomicGet(ActivationsRevolvingCounter);
+
+                        Activations.Push(emptyMailBoxHint, revolvingCounter);
+
+                        auto x = AtomicIncrement(Semaphore);
+                        if (x <= 0) {
+                            // try wake up. if success then go to next thread
+                            switch (waitingFlag){
+                                case TThreadCtx::WS_ACTIVE: // in active spin-lock, just set flag
+                                    if (AtomicCas(&threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING, TThreadCtx::WS_ACTIVE)) {
+                                        continue;
+                                    }
+                                    break;
+                                case TThreadCtx::WS_BLOCKED:
+                                    if (AtomicCas(&threadCtx.WaitingFlag, TThreadCtx::WS_RUNNING, TThreadCtx::WS_BLOCKED)) {
+                                        threadCtx.Pad.Unpark();
+                                        continue;
+                                    }
+                                    break;
+                                default:
+                                    ; // other thread woke this sleeping thread
+                            }
+                            // if thread has already been awakened then we must awaken the other
                             WakeUpLoop();
-                        } 
-                    } 
-                } 
-            } 
-        } 
-    } 
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/library/cpp/actors/core/executor_pool_basic.h b/library/cpp/actors/core/executor_pool_basic.h
index 0169fe4fd8..023190f7fe 100644
--- a/library/cpp/actors/core/executor_pool_basic.h
+++ b/library/cpp/actors/core/executor_pool_basic.h
@@ -8,40 +8,40 @@
 #include <library/cpp/actors/util/threadparkpad.h>
 #include <library/cpp/monlib/dynamic_counters/counters.h>
 
-#include <util/system/mutex.h> 
- 
+#include <util/system/mutex.h>
+
 namespace NActors {
     class TBasicExecutorPool: public TExecutorPoolBase {
         struct TThreadCtx {
             TAutoPtr<TExecutorThread> Thread;
             TThreadParkPad Pad;
-            TThreadParkPad BlockedPad; 
+            TThreadParkPad BlockedPad;
             TAtomic WaitingFlag;
-            TAtomic BlockedFlag; 
+            TAtomic BlockedFlag;
 
             // different threads must spin/block on different cache-lines.
             // we add some padding bytes to enforce this rule
-            static const size_t SizeWithoutPadding = sizeof(TAutoPtr<TExecutorThread>) + 2 * sizeof(TThreadParkPad) + 2 * sizeof(TAtomic); 
-            ui8 Padding[64 - SizeWithoutPadding]; 
-            static_assert(64 >= SizeWithoutPadding); 
+            static const size_t SizeWithoutPadding = sizeof(TAutoPtr<TExecutorThread>) + 2 * sizeof(TThreadParkPad) + 2 * sizeof(TAtomic);
+            ui8 Padding[64 - SizeWithoutPadding];
+            static_assert(64 >= SizeWithoutPadding);
 
             enum EWaitState {
                 WS_NONE,
                 WS_ACTIVE,
-                WS_BLOCKED, 
-                WS_RUNNING 
+                WS_BLOCKED,
+                WS_RUNNING
+            };
+
+            enum EBlockedState {
+                BS_NONE,
+                BS_BLOCKING,
+                BS_BLOCKED
             };
 
-            enum EBlockedState { 
-                BS_NONE, 
-                BS_BLOCKING, 
-                BS_BLOCKED 
-            }; 
- 
-            TThreadCtx() 
-                : WaitingFlag(WS_NONE) 
-                , BlockedFlag(BS_NONE) 
-            { 
+            TThreadCtx()
+                : WaitingFlag(WS_NONE)
+                , BlockedFlag(BS_NONE)
+            {
             }
         };
 
@@ -63,9 +63,9 @@ namespace NActors {
         TAtomic MaxUtilizationCounter;
         TAtomic MaxUtilizationAccumulator;
 
-        TAtomic ThreadCount; 
-        TMutex ChangeThreadsLock; 
- 
+        TAtomic ThreadCount;
+        TMutex ChangeThreadsLock;
+
     public:
         static constexpr TDuration DEFAULT_TIME_PER_MAILBOX = TBasicExecutorPoolConfig::DEFAULT_TIME_PER_MAILBOX;
         static constexpr ui32 DEFAULT_EVENTS_PER_MAILBOX = TBasicExecutorPoolConfig::DEFAULT_EVENTS_PER_MAILBOX;
@@ -101,11 +101,11 @@ namespace NActors {
         }
 
         void SetRealTimeMode() const override;
- 
-        ui32 GetThreadCount() const; 
-        void SetThreadCount(ui32 threads); 
- 
-    private: 
+
+        ui32 GetThreadCount() const;
+        void SetThreadCount(ui32 threads);
+
+    private:
         void WakeUpLoop();
     };
 }
diff --git a/library/cpp/actors/core/executor_pool_basic_ut.cpp b/library/cpp/actors/core/executor_pool_basic_ut.cpp
index 3a6ec8f9db..76dff693af 100644
--- a/library/cpp/actors/core/executor_pool_basic_ut.cpp
+++ b/library/cpp/actors/core/executor_pool_basic_ut.cpp
@@ -1,382 +1,382 @@
-#include "actorsystem.h" 
-#include "executor_pool_basic.h" 
-#include "hfunc.h" 
-#include "scheduler_basic.h" 
- 
+#include "actorsystem.h"
+#include "executor_pool_basic.h"
+#include "hfunc.h"
+#include "scheduler_basic.h"
+
 #include <library/cpp/actors/util/should_continue.h>
- 
+
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/actors/protos/unittests.pb.h>
- 
-using namespace NActors; 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-struct TEvMsg : public NActors::TEventBase<TEvMsg, 10347> { 
-    DEFINE_SIMPLE_LOCAL_EVENT(TEvMsg, "ExecutorPoolTest: Msg"); 
-}; 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-class TTestSenderActor : public IActor { 
-private: 
-    using EActivityType = IActor::EActivityType ; 
-    using EActorActivity = IActor::EActorActivity; 
- 
-private: 
-    TAtomic Counter; 
+
+using namespace NActors;
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TEvMsg : public NActors::TEventBase<TEvMsg, 10347> {
+    DEFINE_SIMPLE_LOCAL_EVENT(TEvMsg, "ExecutorPoolTest: Msg");
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TTestSenderActor : public IActor {
+private:
+    using EActivityType = IActor::EActivityType ;
+    using EActorActivity = IActor::EActorActivity;
+
+private:
+    TAtomic Counter;
     TActorId Receiver;
- 
-    std::function<void(void)> Action; 
- 
-public: 
-    TTestSenderActor(std::function<void(void)> action = [](){}, 
-                     EActivityType activityType =  EActorActivity::OTHER) 
-        : IActor(static_cast<TReceiveFunc>(&TTestSenderActor::Execute), activityType) 
-        , Action(action) 
-    {} 
- 
+
+    std::function<void(void)> Action;
+
+public:
+    TTestSenderActor(std::function<void(void)> action = [](){},
+                     EActivityType activityType =  EActorActivity::OTHER)
+        : IActor(static_cast<TReceiveFunc>(&TTestSenderActor::Execute), activityType)
+        , Action(action)
+    {}
+
     void Start(TActorId receiver, size_t count)
-    { 
-        AtomicSet(Counter, count); 
-        Receiver = receiver; 
-    } 
- 
-    void Stop() { 
-        while (true) { 
-            if (GetCounter() == 0) { 
-                break; 
-            } 
+    {
+        AtomicSet(Counter, count);
+        Receiver = receiver;
+    }
+
+    void Stop() {
+        while (true) {
+            if (GetCounter() == 0) {
+                break;
+            }
 
             Sleep(TDuration::MilliSeconds(1));
-        } 
-    } 
- 
-    size_t GetCounter() const { 
-        return AtomicGet(Counter); 
-    } 
- 
-private: 
-    STFUNC(Execute) 
-    { 
-        Y_UNUSED(ctx); 
-        switch (ev->GetTypeRewrite()) { 
-            hFunc(TEvMsg, Handle); 
-        } 
-    } 
- 
-    void Handle(TEvMsg::TPtr &ev) 
-    { 
-        Y_UNUSED(ev); 
-        Action(); 
+        }
+    }
+
+    size_t GetCounter() const {
+        return AtomicGet(Counter);
+    }
+
+private:
+    STFUNC(Execute)
+    {
+        Y_UNUSED(ctx);
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvMsg, Handle);
+        }
+    }
+
+    void Handle(TEvMsg::TPtr &ev)
+    {
+        Y_UNUSED(ev);
+        Action();
         TAtomicBase count = AtomicDecrement(Counter);
         Y_VERIFY(count != Max<TAtomicBase>());
-        if (count) { 
-            Send(Receiver, new TEvMsg()); 
-        } 
-    } 
-}; 
- 
-THolder<TActorSystemSetup> GetActorSystemSetup(TBasicExecutorPool* pool) 
-{ 
-    auto setup = MakeHolder<NActors::TActorSystemSetup>(); 
-    setup->NodeId = 1; 
-    setup->ExecutorsCount = 1; 
+        if (count) {
+            Send(Receiver, new TEvMsg());
+        }
+    }
+};
+
+THolder<TActorSystemSetup> GetActorSystemSetup(TBasicExecutorPool* pool)
+{
+    auto setup = MakeHolder<NActors::TActorSystemSetup>();
+    setup->NodeId = 1;
+    setup->ExecutorsCount = 1;
     setup->Executors.Reset(new TAutoPtr<NActors::IExecutorPool>[1]);
-    setup->Executors[0] = pool; 
-    setup->Scheduler = new TBasicSchedulerThread(NActors::TSchedulerConfig(512, 0)); 
-    return setup; 
-} 
- 
-Y_UNIT_TEST_SUITE(BasicExecutorPool) { 
- 
-    Y_UNIT_TEST(DecreaseIncreaseThreadsCount) { 
-        const size_t msgCount = 1e4; 
-        const size_t size = 4; 
-        const size_t halfSize = size / 2; 
-        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50); 
- 
-        auto setup = GetActorSystemSetup(executorPool); 
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
-        executorPool->SetThreadCount(halfSize); 
-        TTestSenderActor* actors[size]; 
+    setup->Executors[0] = pool;
+    setup->Scheduler = new TBasicSchedulerThread(NActors::TSchedulerConfig(512, 0));
+    return setup;
+}
+
+Y_UNIT_TEST_SUITE(BasicExecutorPool) {
+
+    Y_UNIT_TEST(DecreaseIncreaseThreadsCount) {
+        const size_t msgCount = 1e4;
+        const size_t size = 4;
+        const size_t halfSize = size / 2;
+        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50);
+
+        auto setup = GetActorSystemSetup(executorPool);
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
+        executorPool->SetThreadCount(halfSize);
+        TTestSenderActor* actors[size];
         TActorId actorIds[size];
-        for (size_t i = 0; i < size; ++i) { 
-            actors[i] = new TTestSenderActor(); 
-            actorIds[i] = actorSystem.Register(actors[i]); 
-        } 
- 
-        const int testCount = 2; 
- 
-        TExecutorPoolStats poolStats[testCount]; 
-        TVector<TExecutorThreadStats> statsCopy[testCount]; 
- 
-        for (size_t testIdx = 0; testIdx < testCount; ++testIdx) { 
-            for (size_t i = 0; i < size; ++i) { 
-                actors[i]->Start(actors[i]->SelfId(), msgCount); 
+        for (size_t i = 0; i < size; ++i) {
+            actors[i] = new TTestSenderActor();
+            actorIds[i] = actorSystem.Register(actors[i]);
+        }
+
+        const int testCount = 2;
+
+        TExecutorPoolStats poolStats[testCount];
+        TVector<TExecutorThreadStats> statsCopy[testCount];
+
+        for (size_t testIdx = 0; testIdx < testCount; ++testIdx) {
+            for (size_t i = 0; i < size; ++i) {
+                actors[i]->Start(actors[i]->SelfId(), msgCount);
             }
             for (size_t i = 0; i < size; ++i) {
-                actorSystem.Send(actorIds[i], new TEvMsg()); 
-            } 
- 
-            Sleep(TDuration::MilliSeconds(100)); 
- 
-            for (size_t i = 0; i < size; ++i) { 
-                actors[i]->Stop(); 
-            } 
- 
-            executorPool->GetCurrentStats(poolStats[testIdx], statsCopy[testIdx]); 
-        } 
- 
-        for (size_t i = 1; i <= halfSize; ++i) { 
-            UNIT_ASSERT_UNEQUAL(statsCopy[0][i].ReceivedEvents, statsCopy[1][i].ReceivedEvents); 
-        } 
- 
-        for (size_t i = halfSize + 1; i <= size; ++i) { 
-            UNIT_ASSERT_EQUAL(statsCopy[0][i].ReceivedEvents, statsCopy[1][i].ReceivedEvents); 
-        } 
- 
-        executorPool->SetThreadCount(size); 
- 
-        for (size_t testIdx = 0; testIdx < testCount; ++testIdx) { 
-            for (size_t i = 0; i < size; ++i) { 
-                actors[i]->Start(actors[i]->SelfId(), msgCount); 
+                actorSystem.Send(actorIds[i], new TEvMsg());
             }
+
+            Sleep(TDuration::MilliSeconds(100));
+
             for (size_t i = 0; i < size; ++i) {
-                actorSystem.Send(actorIds[i], new TEvMsg()); 
-            } 
- 
-            Sleep(TDuration::MilliSeconds(100)); 
- 
-            for (size_t i = 0; i < size; ++i) { 
-                actors[i]->Stop(); 
-            } 
- 
-            executorPool->GetCurrentStats(poolStats[testIdx], statsCopy[testIdx]); 
-        } 
- 
-        for (size_t i = 1; i <= size; ++i) { 
-            UNIT_ASSERT_UNEQUAL(statsCopy[0][i].ReceivedEvents, statsCopy[1][i].ReceivedEvents); 
-        } 
-    } 
- 
-    Y_UNIT_TEST(ChangeCount) { 
-        const size_t msgCount = 1e3; 
-        const size_t size = 4; 
-        const size_t halfSize = size / 2; 
-        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50); 
- 
-        auto begin = TInstant::Now(); 
- 
-        auto setup = GetActorSystemSetup(executorPool); 
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
-        executorPool->SetThreadCount(halfSize); 
- 
-        TTestSenderActor* actors[size]; 
+                actors[i]->Stop();
+            }
+
+            executorPool->GetCurrentStats(poolStats[testIdx], statsCopy[testIdx]);
+        }
+
+        for (size_t i = 1; i <= halfSize; ++i) {
+            UNIT_ASSERT_UNEQUAL(statsCopy[0][i].ReceivedEvents, statsCopy[1][i].ReceivedEvents);
+        }
+
+        for (size_t i = halfSize + 1; i <= size; ++i) {
+            UNIT_ASSERT_EQUAL(statsCopy[0][i].ReceivedEvents, statsCopy[1][i].ReceivedEvents);
+        }
+
+        executorPool->SetThreadCount(size);
+
+        for (size_t testIdx = 0; testIdx < testCount; ++testIdx) {
+            for (size_t i = 0; i < size; ++i) {
+                actors[i]->Start(actors[i]->SelfId(), msgCount);
+            }
+            for (size_t i = 0; i < size; ++i) {
+                actorSystem.Send(actorIds[i], new TEvMsg());
+            }
+
+            Sleep(TDuration::MilliSeconds(100));
+
+            for (size_t i = 0; i < size; ++i) {
+                actors[i]->Stop();
+            }
+
+            executorPool->GetCurrentStats(poolStats[testIdx], statsCopy[testIdx]);
+        }
+
+        for (size_t i = 1; i <= size; ++i) {
+            UNIT_ASSERT_UNEQUAL(statsCopy[0][i].ReceivedEvents, statsCopy[1][i].ReceivedEvents);
+        }
+    }
+
+    Y_UNIT_TEST(ChangeCount) {
+        const size_t msgCount = 1e3;
+        const size_t size = 4;
+        const size_t halfSize = size / 2;
+        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50);
+
+        auto begin = TInstant::Now();
+
+        auto setup = GetActorSystemSetup(executorPool);
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+        executorPool->SetThreadCount(halfSize);
+
+        TTestSenderActor* actors[size];
         TActorId actorIds[size];
-        for (size_t i = 0; i < size; ++i) { 
-            actors[i] = new TTestSenderActor(); 
-            actorIds[i] = actorSystem.Register(actors[i]); 
-        } 
- 
-        for (size_t i = 0; i < size; ++i) { 
-            actors[i]->Start(actorIds[i], msgCount); 
+        for (size_t i = 0; i < size; ++i) {
+            actors[i] = new TTestSenderActor();
+            actorIds[i] = actorSystem.Register(actors[i]);
+        }
+
+        for (size_t i = 0; i < size; ++i) {
+            actors[i]->Start(actorIds[i], msgCount);
         }
         for (size_t i = 0; i < size; ++i) {
-            actorSystem.Send(actorIds[i], new TEvMsg()); 
-        } 
- 
-        const i32 N = 6; 
-        const i32 threadsCouns[N] = { 1, 3, 2, 3, 1, 4 }; 
- 
-        ui64 counter = 0; 
- 
-        TTestSenderActor* changerActor = new TTestSenderActor([&]{ 
-            executorPool->SetThreadCount(threadsCouns[counter]); 
-            counter++; 
-            if (counter == N) { 
-                counter = 0; 
-            } 
-        }); 
+            actorSystem.Send(actorIds[i], new TEvMsg());
+        }
+
+        const i32 N = 6;
+        const i32 threadsCouns[N] = { 1, 3, 2, 3, 1, 4 };
+
+        ui64 counter = 0;
+
+        TTestSenderActor* changerActor = new TTestSenderActor([&]{
+            executorPool->SetThreadCount(threadsCouns[counter]);
+            counter++;
+            if (counter == N) {
+                counter = 0;
+            }
+        });
         TActorId changerActorId = actorSystem.Register(changerActor);
-        changerActor->Start(changerActorId, msgCount); 
-        actorSystem.Send(changerActorId, new TEvMsg()); 
- 
-        while (true) { 
+        changerActor->Start(changerActorId, msgCount);
+        actorSystem.Send(changerActorId, new TEvMsg());
+
+        while (true) {
             size_t maxCounter = 0;
-            for (size_t i = 0; i < size; ++i) { 
+            for (size_t i = 0; i < size; ++i) {
                 maxCounter = Max(maxCounter, actors[i]->GetCounter());
-            } 
- 
+            }
+
             if (maxCounter == 0) {
                 break;
             }
 
-            auto now = TInstant::Now(); 
+            auto now = TInstant::Now();
             UNIT_ASSERT_C(now - begin < TDuration::Seconds(5), "Max counter is " << maxCounter);
- 
+
             Sleep(TDuration::MilliSeconds(1));
-        } 
- 
-        changerActor->Stop(); 
-    } 
- 
-    Y_UNIT_TEST(CheckCompleteOne) { 
-        const size_t size = 4; 
-        const size_t msgCount = 1e4; 
-        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50); 
- 
-        auto setup = GetActorSystemSetup(executorPool); 
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
-        auto begin = TInstant::Now(); 
- 
-        auto actor = new TTestSenderActor(); 
-        auto actorId = actorSystem.Register(actor); 
-        actor->Start(actor->SelfId(), msgCount); 
-        actorSystem.Send(actorId, new TEvMsg()); 
- 
-        while (actor->GetCounter()) { 
-            auto now = TInstant::Now(); 
+        }
+
+        changerActor->Stop();
+    }
+
+    Y_UNIT_TEST(CheckCompleteOne) {
+        const size_t size = 4;
+        const size_t msgCount = 1e4;
+        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50);
+
+        auto setup = GetActorSystemSetup(executorPool);
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
+        auto begin = TInstant::Now();
+
+        auto actor = new TTestSenderActor();
+        auto actorId = actorSystem.Register(actor);
+        actor->Start(actor->SelfId(), msgCount);
+        actorSystem.Send(actorId, new TEvMsg());
+
+        while (actor->GetCounter()) {
+            auto now = TInstant::Now();
             UNIT_ASSERT_C(now - begin < TDuration::Seconds(5), "Counter is " << actor->GetCounter());
 
             Sleep(TDuration::MilliSeconds(1));
-        } 
-    } 
- 
-    Y_UNIT_TEST(CheckCompleteAll) { 
-        const size_t size = 4; 
-        const size_t msgCount = 1e4; 
-        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50); 
- 
-        auto setup = GetActorSystemSetup(executorPool); 
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
-        auto begin = TInstant::Now(); 
- 
-        TTestSenderActor* actors[size]; 
+        }
+    }
+
+    Y_UNIT_TEST(CheckCompleteAll) {
+        const size_t size = 4;
+        const size_t msgCount = 1e4;
+        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50);
+
+        auto setup = GetActorSystemSetup(executorPool);
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
+        auto begin = TInstant::Now();
+
+        TTestSenderActor* actors[size];
         TActorId actorIds[size];
- 
-        for (size_t i = 0; i < size; ++i) { 
-            actors[i] = new TTestSenderActor(); 
-            actorIds[i] = actorSystem.Register(actors[i]); 
-        } 
-        for (size_t i = 0; i < size; ++i) { 
-            actors[i]->Start(actors[i]->SelfId(), msgCount); 
+
+        for (size_t i = 0; i < size; ++i) {
+            actors[i] = new TTestSenderActor();
+            actorIds[i] = actorSystem.Register(actors[i]);
         }
         for (size_t i = 0; i < size; ++i) {
-            actorSystem.Send(actorIds[i], new TEvMsg()); 
-        } 
- 
- 
-        while (true) { 
+            actors[i]->Start(actors[i]->SelfId(), msgCount);
+        }
+        for (size_t i = 0; i < size; ++i) {
+            actorSystem.Send(actorIds[i], new TEvMsg());
+        }
+
+
+        while (true) {
             size_t maxCounter = 0;
-            for (size_t i = 0; i < size; ++i) { 
+            for (size_t i = 0; i < size; ++i) {
                 maxCounter = Max(maxCounter, actors[i]->GetCounter());
-            } 
- 
+            }
+
             if (maxCounter == 0) {
                 break;
             }
 
-            auto now = TInstant::Now(); 
+            auto now = TInstant::Now();
             UNIT_ASSERT_C(now - begin < TDuration::Seconds(5), "Max counter is " << maxCounter);
- 
+
             Sleep(TDuration::MilliSeconds(1));
-        } 
-    } 
- 
-    Y_UNIT_TEST(CheckCompleteOver) { 
-        const size_t size = 4; 
-        const size_t actorsCount = size * 2; 
-        const size_t msgCount = 1e4; 
-        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50); 
- 
-        auto setup = GetActorSystemSetup(executorPool); 
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
-        auto begin = TInstant::Now(); 
- 
-        TTestSenderActor* actors[actorsCount]; 
+        }
+    }
+
+    Y_UNIT_TEST(CheckCompleteOver) {
+        const size_t size = 4;
+        const size_t actorsCount = size * 2;
+        const size_t msgCount = 1e4;
+        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50);
+
+        auto setup = GetActorSystemSetup(executorPool);
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
+        auto begin = TInstant::Now();
+
+        TTestSenderActor* actors[actorsCount];
         TActorId actorIds[actorsCount];
- 
-        for (size_t i = 0; i < actorsCount; ++i) { 
-            actors[i] = new TTestSenderActor(); 
-            actorIds[i] = actorSystem.Register(actors[i]); 
-        } 
-        for (size_t i = 0; i < actorsCount; ++i) { 
-            actors[i]->Start(actors[i]->SelfId(), msgCount); 
+
+        for (size_t i = 0; i < actorsCount; ++i) {
+            actors[i] = new TTestSenderActor();
+            actorIds[i] = actorSystem.Register(actors[i]);
+        }
+        for (size_t i = 0; i < actorsCount; ++i) {
+            actors[i]->Start(actors[i]->SelfId(), msgCount);
         }
         for (size_t i = 0; i < actorsCount; ++i) {
-            actorSystem.Send(actorIds[i], new TEvMsg()); 
-        } 
- 
- 
-        while (true) { 
+            actorSystem.Send(actorIds[i], new TEvMsg());
+        }
+
+
+        while (true) {
             size_t maxCounter = 0;
-            for (size_t i = 0; i < actorsCount; ++i) { 
+            for (size_t i = 0; i < actorsCount; ++i) {
                 maxCounter = Max(maxCounter, actors[i]->GetCounter());
-            } 
- 
+            }
+
             if (maxCounter == 0) {
                 break;
             }
 
-            auto now = TInstant::Now(); 
+            auto now = TInstant::Now();
             UNIT_ASSERT_C(now - begin < TDuration::Seconds(5), "Max counter is " << maxCounter);
- 
+
             Sleep(TDuration::MilliSeconds(1));
-        } 
-    } 
- 
-    Y_UNIT_TEST(CheckCompleteRoundRobinOver) { 
-        const size_t size = 4; 
-        const size_t actorsCount = size * 2; 
-        const size_t msgCount = 1e2; 
-        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50); 
- 
-        auto setup = GetActorSystemSetup(executorPool); 
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
-        auto begin = TInstant::Now(); 
- 
-        TTestSenderActor* actors[actorsCount]; 
+        }
+    }
+
+    Y_UNIT_TEST(CheckCompleteRoundRobinOver) {
+        const size_t size = 4;
+        const size_t actorsCount = size * 2;
+        const size_t msgCount = 1e2;
+        TBasicExecutorPool* executorPool = new TBasicExecutorPool(0, size, 50);
+
+        auto setup = GetActorSystemSetup(executorPool);
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
+        auto begin = TInstant::Now();
+
+        TTestSenderActor* actors[actorsCount];
         TActorId actorIds[actorsCount];
- 
-        for (size_t i = 0; i < actorsCount; ++i) { 
-            actors[i] = new TTestSenderActor(); 
-            actorIds[i] = actorSystem.Register(actors[i]); 
-        } 
-        for (size_t i = 0; i < actorsCount; ++i) { 
-            actors[i]->Start(actorIds[(i + 1) % actorsCount], msgCount); 
+
+        for (size_t i = 0; i < actorsCount; ++i) {
+            actors[i] = new TTestSenderActor();
+            actorIds[i] = actorSystem.Register(actors[i]);
+        }
+        for (size_t i = 0; i < actorsCount; ++i) {
+            actors[i]->Start(actorIds[(i + 1) % actorsCount], msgCount);
         }
         for (size_t i = 0; i < actorsCount; ++i) {
-            actorSystem.Send(actorIds[i], new TEvMsg()); 
-        } 
- 
-        while (true) { 
+            actorSystem.Send(actorIds[i], new TEvMsg());
+        }
+
+        while (true) {
             size_t maxCounter = 0;
-            for (size_t i = 0; i < actorsCount; ++i) { 
+            for (size_t i = 0; i < actorsCount; ++i) {
                 maxCounter = Max(maxCounter, actors[i]->GetCounter());
-            } 
- 
+            }
+
             if (maxCounter == 0) {
                 break;
             }
 
-            auto now = TInstant::Now(); 
+            auto now = TInstant::Now();
             UNIT_ASSERT_C(now - begin < TDuration::Seconds(5), "Max counter is " << maxCounter);
- 
+
             Sleep(TDuration::MilliSeconds(1));
-        } 
-    } 
+        }
+    }
 
     Y_UNIT_TEST(CheckStats) {
         const size_t size = 4;
@@ -432,4 +432,4 @@ Y_UNIT_TEST_SUITE(BasicExecutorPool) {
         UNIT_ASSERT(stats[0].MailboxPushedOutByTime + stats[0].MailboxPushedOutByEventCount >= msgCount / TBasicExecutorPoolConfig::DEFAULT_EVENTS_PER_MAILBOX);
         UNIT_ASSERT_VALUES_EQUAL(stats[0].MailboxPushedOutBySoftPreemption, 0);
     }
-} 
+}
diff --git a/library/cpp/actors/core/executor_pool_united.cpp b/library/cpp/actors/core/executor_pool_united.cpp
index 3c76643366..dac6245635 100644
--- a/library/cpp/actors/core/executor_pool_united.cpp
+++ b/library/cpp/actors/core/executor_pool_united.cpp
@@ -34,7 +34,7 @@ namespace NActors {
         TAtomic Active = 0; // Number of mailboxes ready for execution or currently executing
         TAtomic Tokens = 0; // Pending tokens (token is required for worker to start execution, guarantees concurrency limit and activation availability)
         volatile bool StopFlag = false;
- 
+
         // Configuration
         TPoolId PoolId;
         TAtomicBase Concurrency; // Max concurrent workers running this pool
@@ -78,7 +78,7 @@ namespace NActors {
                     value = RelaxedLoad(tokens);
                 } else {
                     value = AtomicLoad(tokens);
-                } 
+                }
                 if (value > 0) {
                     if (AtomicCas(tokens, value - 1, value)) {
                         return true; // token acquired
@@ -87,8 +87,8 @@ namespace NActors {
                     return false; // no more tokens
                 }
             }
-        } 
- 
+        }
+
         // Try acquire pending token. Must be done before execution
         bool TryAcquireToken() {
             return TryAcquireTokenImpl<false>(&Tokens);
@@ -739,7 +739,7 @@ namespace NActors {
 #else
                     NanoSleep(timeoutNs); // non-linux wake is not supported, cpu will go idle on slow -> fast switch
 #endif
-                } 
+                }
             }
         }
 
@@ -985,7 +985,7 @@ namespace NActors {
                     if (pool->TryAcquireTokenRelaxed()) {
                         result = WakeWithTokenAcquired(united, pool->PoolId);
                         return true; // token acquired or stop
-                    } 
+                    }
                 }
             } else {
                 if (assignedPool->TryAcquireTokenRelaxed()) {
@@ -1009,12 +1009,12 @@ namespace NActors {
                     } else {
                         result = current;
                         return true; // wakeup
-                    } 
+                    }
                 }
-            } 
+            }
             return false; // spin threshold exceeded, no wakeups
-        } 
- 
+        }
+
         bool StartBlocking(TPoolId& result) {
             // Switch into blocked state
             if (State.StartBlocking()) {
@@ -1210,7 +1210,7 @@ namespace NActors {
         AtomicStore(&StopFlag, true);
         for (TPoolId pool = 0; pool < PoolCount; pool++) {
             Pools[pool].Stop();
-        } 
+        }
         for (TCpuId cpuId = 0; cpuId < CpuCount; cpuId++) {
             Cpus[cpuId].Stop();
         }
@@ -1320,7 +1320,7 @@ namespace NActors {
         wctx.AddElapsedCycles(IActor::ACTOR_SYSTEM, timeTracker.Elapsed());
         return result;
     }
- 
+
     TPoolId TUnitedWorkers::WaitSequence(TCpu& cpu, TWorkerContext& wctx, TTimeTracker& timeTracker) {
         TPoolId result;
         if (cpu.ActiveWait(Us2Ts(Config.SpinThresholdUs), result)) {
@@ -1338,8 +1338,8 @@ namespace NActors {
             wctx.AddParkedCycles(timeTracker.Elapsed());
         } while (!wakeup);
         return result;
-    } 
- 
+    }
+
     void TUnitedWorkers::GetCurrentStats(TPoolId pool, TVector<TExecutorThreadStats>& statsCopy) const {
         size_t idx = 1;
         statsCopy.resize(idx + Pools[pool].WakeOrderCpus.size());
@@ -1349,7 +1349,7 @@ namespace NActors {
             s.Aggregate(cpu->PoolStats[pool]);
         }
     }
- 
+
     TUnitedExecutorPool::TUnitedExecutorPool(const TUnitedExecutorPoolConfig& cfg, TUnitedWorkers* united)
         : TExecutorPoolBaseMailboxed(cfg.PoolId, cfg.MaxActivityType)
         , United(united)
@@ -1357,10 +1357,10 @@ namespace NActors {
     {
         United->SetupPool(TPoolId(cfg.PoolId), this, MailboxTable.Get());
     }
- 
+
     void TUnitedExecutorPool::Prepare(TActorSystem* actorSystem, NSchedulerQueue::TReader** scheduleReaders, ui32* scheduleSz) {
         ActorSystem = actorSystem;
- 
+
         // Schedule readers are initialized through TUnitedWorkers::Prepare
         *scheduleReaders = nullptr;
         *scheduleSz = 0;
@@ -1406,9 +1406,9 @@ namespace NActors {
         const auto current = ActorSystem->Monotonic();
         if (deadline < current) {
             deadline = current;
-        } 
+        }
         United->GetScheduleWriter(workerId)->Push(deadline.MicroSeconds(), ev.Release(), cookie);
-    } 
+    }
 
     void TUnitedExecutorPool::Schedule(TDuration delta, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie, TWorkerId workerId) {
         Y_VERIFY_DEBUG(workerId < United->GetWorkerCount());
diff --git a/library/cpp/actors/core/executor_pool_united.h b/library/cpp/actors/core/executor_pool_united.h
index 65ee3be265..a090ba2466 100644
--- a/library/cpp/actors/core/executor_pool_united.h
+++ b/library/cpp/actors/core/executor_pool_united.h
@@ -32,7 +32,7 @@ namespace NActors {
 
         TUnitedWorkersConfig Config;
         TCpuAllocationConfig Allocation;
- 
+
         volatile bool StopFlag = false;
 
     public:
@@ -66,7 +66,7 @@ namespace NActors {
 
         // Add activation of newly scheduled mailbox and wake cpu to execute it if required
         void PushActivation(TPoolId pool, ui32 activation, ui64 revolvingCounter);
- 
+
         // Try acquire pending token. Must be done before execution
         bool TryAcquireToken(TPoolId pool);
 
diff --git a/library/cpp/actors/core/executor_pool_united_ut.cpp b/library/cpp/actors/core/executor_pool_united_ut.cpp
index 1a301ff645..d4df17f1b8 100644
--- a/library/cpp/actors/core/executor_pool_united_ut.cpp
+++ b/library/cpp/actors/core/executor_pool_united_ut.cpp
@@ -1,23 +1,23 @@
-#include "actorsystem.h" 
-#include "executor_pool_basic.h" 
-#include "hfunc.h" 
-#include "scheduler_basic.h" 
- 
+#include "actorsystem.h"
+#include "executor_pool_basic.h"
+#include "hfunc.h"
+#include "scheduler_basic.h"
+
 #include <library/cpp/actors/util/should_continue.h>
- 
+
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/actors/protos/unittests.pb.h>
- 
-using namespace NActors; 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-struct TEvMsg : public NActors::TEventBase<TEvMsg, 10347> { 
-    DEFINE_SIMPLE_LOCAL_EVENT(TEvMsg, "ExecutorPoolTest: Msg"); 
-}; 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
+
+using namespace NActors;
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TEvMsg : public NActors::TEventBase<TEvMsg, 10347> {
+    DEFINE_SIMPLE_LOCAL_EVENT(TEvMsg, "ExecutorPoolTest: Msg");
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
 inline ui64 DoTimedWork(ui64 workUs) {
     ui64 startUs = ThreadCPUTime();
     ui64 endUs = startUs + workUs;
@@ -30,62 +30,62 @@ inline ui64 DoTimedWork(ui64 workUs) {
     return nowUs - startUs;
 }
 
-class TTestSenderActor : public IActor { 
-private: 
-    using EActivityType = IActor::EActivityType ; 
-    using EActorActivity = IActor::EActorActivity; 
- 
-private: 
-    TAtomic Counter; 
+class TTestSenderActor : public IActor {
+private:
+    using EActivityType = IActor::EActivityType ;
+    using EActorActivity = IActor::EActorActivity;
+
+private:
+    TAtomic Counter;
     TActorId Receiver;
- 
-    std::function<void(void)> Action; 
- 
-public: 
-    TTestSenderActor(std::function<void(void)> action = [](){}, 
-                     EActivityType activityType =  EActorActivity::OTHER) 
-        : IActor(static_cast<TReceiveFunc>(&TTestSenderActor::Execute), activityType) 
-        , Action(action) 
-    {} 
- 
+
+    std::function<void(void)> Action;
+
+public:
+    TTestSenderActor(std::function<void(void)> action = [](){},
+                     EActivityType activityType =  EActorActivity::OTHER)
+        : IActor(static_cast<TReceiveFunc>(&TTestSenderActor::Execute), activityType)
+        , Action(action)
+    {}
+
     void Start(TActorId receiver, size_t count) {
-        AtomicSet(Counter, count); 
-        Receiver = receiver; 
-    } 
- 
-    void Stop() { 
-        while (true) { 
-            if (GetCounter() == 0) { 
-                break; 
-            } 
+        AtomicSet(Counter, count);
+        Receiver = receiver;
+    }
+
+    void Stop() {
+        while (true) {
+            if (GetCounter() == 0) {
+                break;
+            }
 
             Sleep(TDuration::MilliSeconds(1));
-        } 
-    } 
- 
-    size_t GetCounter() const { 
-        return AtomicGet(Counter); 
-    } 
- 
-private: 
+        }
+    }
+
+    size_t GetCounter() const {
+        return AtomicGet(Counter);
+    }
+
+private:
     STFUNC(Execute) {
-        Y_UNUSED(ctx); 
-        switch (ev->GetTypeRewrite()) { 
-            hFunc(TEvMsg, Handle); 
-        } 
-    } 
- 
+        Y_UNUSED(ctx);
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvMsg, Handle);
+        }
+    }
+
     void Handle(TEvMsg::TPtr &ev) {
-        Y_UNUSED(ev); 
-        Action(); 
+        Y_UNUSED(ev);
+        Action();
         TAtomicBase count = AtomicDecrement(Counter);
         Y_VERIFY(count != Max<TAtomicBase>());
-        if (count) { 
-            Send(Receiver, new TEvMsg()); 
-        } 
-    } 
-}; 
- 
+        if (count) {
+            Send(Receiver, new TEvMsg());
+        }
+    }
+};
+
 // Single cpu balancer that switches pool on every activation; not thread-safe
 struct TRoundRobinBalancer: public IBalancer {
     TCpuState* State;
@@ -121,38 +121,38 @@ void AddUnitedPool(THolder<TActorSystemSetup>& setup, ui32 concurrency = 0) {
 }
 
 THolder<TActorSystemSetup> GetActorSystemSetup(ui32 cpuCount) {
-    auto setup = MakeHolder<NActors::TActorSystemSetup>(); 
-    setup->NodeId = 1; 
+    auto setup = MakeHolder<NActors::TActorSystemSetup>();
+    setup->NodeId = 1;
     setup->CpuManager.UnitedWorkers.CpuCount = cpuCount;
     setup->CpuManager.UnitedWorkers.NoRealtime = true; // unavailable in test environment
-    setup->Scheduler = new TBasicSchedulerThread(NActors::TSchedulerConfig(512, 0)); 
-    return setup; 
-} 
- 
+    setup->Scheduler = new TBasicSchedulerThread(NActors::TSchedulerConfig(512, 0));
+    return setup;
+}
+
 Y_UNIT_TEST_SUITE(UnitedExecutorPool) {
- 
+
 #ifdef _linux_
- 
+
     Y_UNIT_TEST(OnePoolManyCpus) {
-        const size_t msgCount = 1e4; 
+        const size_t msgCount = 1e4;
         auto setup = GetActorSystemSetup(4);
         AddUnitedPool(setup);
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
-        auto begin = TInstant::Now(); 
- 
-        auto actor = new TTestSenderActor(); 
-        auto actorId = actorSystem.Register(actor); 
-        actor->Start(actor->SelfId(), msgCount); 
-        actorSystem.Send(actorId, new TEvMsg()); 
- 
-        while (actor->GetCounter()) { 
-            auto now = TInstant::Now(); 
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
+        auto begin = TInstant::Now();
+
+        auto actor = new TTestSenderActor();
+        auto actorId = actorSystem.Register(actor);
+        actor->Start(actor->SelfId(), msgCount);
+        actorSystem.Send(actorId, new TEvMsg());
+
+        while (actor->GetCounter()) {
+            auto now = TInstant::Now();
             UNIT_ASSERT_C(now - begin < TDuration::Seconds(5), "Counter is " << actor->GetCounter());
 
             Sleep(TDuration::MilliSeconds(1));
-        } 
+        }
 
         TVector<TExecutorThreadStats> stats;
         TExecutorPoolStats poolStats;
@@ -183,20 +183,20 @@ Y_UNIT_TEST_SUITE(UnitedExecutorPool) {
         UNIT_ASSERT_VALUES_EQUAL(stats[0].PoolDestroyedActors, 0);
         UNIT_ASSERT_VALUES_EQUAL(stats[0].PoolAllocatedMailboxes, 4095); // one line
         UNIT_ASSERT(stats[0].MailboxPushedOutByTime + stats[0].MailboxPushedOutByEventCount + stats[0].MailboxPushedOutBySoftPreemption >= msgCount / TBasicExecutorPoolConfig::DEFAULT_EVENTS_PER_MAILBOX);
-    } 
- 
+    }
+
     Y_UNIT_TEST(ManyPoolsOneSharedCpu) {
-        const size_t msgCount = 1e4; 
+        const size_t msgCount = 1e4;
         const size_t pools = 4;
         auto setup = GetActorSystemSetup(1);
         for (size_t pool = 0; pool < pools; pool++) {
             AddUnitedPool(setup);
         }
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
-        auto begin = TInstant::Now(); 
- 
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
+        auto begin = TInstant::Now();
+
         TVector<TTestSenderActor*> actors;
         for (size_t pool = 0; pool < pools; pool++) {
             auto actor = new TTestSenderActor();
@@ -204,20 +204,20 @@ Y_UNIT_TEST_SUITE(UnitedExecutorPool) {
             actor->Start(actor->SelfId(), msgCount);
             actorSystem.Send(actorId, new TEvMsg());
             actors.push_back(actor);
-        } 
- 
-        while (true) { 
+        }
+
+        while (true) {
             size_t left = 0;
             for (auto actor : actors) {
                 left += actor->GetCounter();
-            } 
+            }
             if (left == 0) {
                 break;
             }
-            auto now = TInstant::Now(); 
+            auto now = TInstant::Now();
             UNIT_ASSERT_C(now - begin < TDuration::Seconds(5), "left " << left);
             Sleep(TDuration::MilliSeconds(1));
-        } 
+        }
 
         for (size_t pool = 0; pool < pools; pool++) {
             TVector<TExecutorThreadStats> stats;
@@ -231,8 +231,8 @@ Y_UNIT_TEST_SUITE(UnitedExecutorPool) {
             UNIT_ASSERT_VALUES_EQUAL(stats[0].ReceivedEvents, msgCount);
             UNIT_ASSERT_VALUES_EQUAL(stats[0].PoolActorRegistrations, 1);
         }
-    } 
- 
+    }
+
     Y_UNIT_TEST(ManyPoolsOneAssignedCpu) {
         const size_t msgCount = 1e4;
         const size_t pools = 4;
@@ -289,11 +289,11 @@ Y_UNIT_TEST_SUITE(UnitedExecutorPool) {
         for (size_t pool = 0; pool < pools; pool++) {
             AddUnitedPool(setup);
         }
-        TActorSystem actorSystem(setup); 
-        actorSystem.Start(); 
- 
-        auto begin = TInstant::Now(); 
- 
+        TActorSystem actorSystem(setup);
+        actorSystem.Start();
+
+        auto begin = TInstant::Now();
+
         TVector<TTestSenderActor*> actors;
         for (size_t pool = 0; pool < pools; pool++) {
             auto actor = new TTestSenderActor([]() {
@@ -303,21 +303,21 @@ Y_UNIT_TEST_SUITE(UnitedExecutorPool) {
             actor->Start(actor->SelfId(), msgCount);
             actorSystem.Send(actorId, new TEvMsg());
             actors.push_back(actor);
-        } 
- 
-        while (true) { 
+        }
+
+        while (true) {
             size_t left = 0;
             for (auto actor : actors) {
                 left += actor->GetCounter();
-            } 
+            }
             if (left == 0) {
                 break;
             }
-            auto now = TInstant::Now(); 
+            auto now = TInstant::Now();
             UNIT_ASSERT_C(now - begin < TDuration::Seconds(15), "left " << left);
             Sleep(TDuration::MilliSeconds(1));
-        } 
- 
+        }
+
         for (size_t pool = 0; pool < pools; pool++) {
             TVector<TExecutorThreadStats> stats;
             TExecutorPoolStats poolStats;
@@ -326,13 +326,13 @@ Y_UNIT_TEST_SUITE(UnitedExecutorPool) {
             for (ui32 idx = 1; idx < stats.size(); ++idx) {
                 stats[0].Aggregate(stats[idx]);
             }
- 
+
             UNIT_ASSERT_VALUES_EQUAL(stats[0].ReceivedEvents, msgCount);
             UNIT_ASSERT_VALUES_EQUAL(stats[0].PreemptedEvents, msgCount); // every 100ms event should be preempted
             UNIT_ASSERT_VALUES_EQUAL(stats[0].PoolActorRegistrations, 1);
-        } 
+        }
     }
- 
+
 #endif
- 
-} 
+
+}
diff --git a/library/cpp/actors/core/executor_thread.h b/library/cpp/actors/core/executor_thread.h
index fd9cde789f..9d3c573f0d 100644
--- a/library/cpp/actors/core/executor_thread.h
+++ b/library/cpp/actors/core/executor_thread.h
@@ -80,7 +80,7 @@ namespace NActors {
         IExecutorPool* const ExecutorPool;
 
         // Event-specific (currently executing)
-        TVector<THolder<IActor>> DyingActors; 
+        TVector<THolder<IActor>> DyingActors;
         TActorId CurrentRecipient;
         ui64 CurrentActorScheduledEventsCounter = 0;
 
diff --git a/library/cpp/actors/core/log.cpp b/library/cpp/actors/core/log.cpp
index 888eb804fc..5f63b5af58 100644
--- a/library/cpp/actors/core/log.cpp
+++ b/library/cpp/actors/core/log.cpp
@@ -228,7 +228,7 @@ namespace NActors {
             Sleep(settings.ThrottleDelay);
     }
 
-    void TLoggerActor::LogIgnoredCount(TInstant now) { 
+    void TLoggerActor::LogIgnoredCount(TInstant now) {
         TString message = Sprintf("Ignored IgnoredCount# %" PRIu64 " log records due to logger overflow!", IgnoredCount);
         if (!OutputRecord(now, NActors::NLog::EPrio::Error, Settings->LoggerComponent, message)) {
             BecomeDefunct();
@@ -237,7 +237,7 @@ namespace NActors {
 
     void TLoggerActor::HandleIgnoredEvent(TLogIgnored::TPtr& ev, const NActors::TActorContext& ctx) {
         Y_UNUSED(ev);
-        LogIgnoredCount(ctx.Now()); 
+        LogIgnoredCount(ctx.Now());
         IgnoredCount = 0;
         PassedCount = 0;
     }
diff --git a/library/cpp/actors/core/log.h b/library/cpp/actors/core/log.h
index d380ed56e5..c11a7cf3c1 100644
--- a/library/cpp/actors/core/log.h
+++ b/library/cpp/actors/core/log.h
@@ -253,7 +253,7 @@ namespace NActors {
         void HandleWakeup();
         [[nodiscard]] bool OutputRecord(TInstant time, NLog::EPrio priority, NLog::EComponent component, const TString& formatted) noexcept;
         void RenderComponentPriorities(IOutputStream& str);
-        void LogIgnoredCount(TInstant now); 
+        void LogIgnoredCount(TInstant now);
         void WriteMessageStat(const NLog::TEvLog& ev);
         static const char* FormatLocalTimestamp(TInstant time, char* buf);
     };
diff --git a/library/cpp/actors/core/mon_stats.h b/library/cpp/actors/core/mon_stats.h
index 7fdc202aad..d55552af0c 100644
--- a/library/cpp/actors/core/mon_stats.h
+++ b/library/cpp/actors/core/mon_stats.h
@@ -113,7 +113,7 @@ namespace NActors {
             CpuNs += RelaxedLoad(&other.CpuNs);
             ElapsedTicks += RelaxedLoad(&other.ElapsedTicks);
             ParkedTicks += RelaxedLoad(&other.ParkedTicks);
-            BlockedTicks += RelaxedLoad(&other.BlockedTicks); 
+            BlockedTicks += RelaxedLoad(&other.BlockedTicks);
             MailboxPushedOutBySoftPreemption += RelaxedLoad(&other.MailboxPushedOutBySoftPreemption);
             MailboxPushedOutByTime += RelaxedLoad(&other.MailboxPushedOutByTime);
             MailboxPushedOutByEventCount += RelaxedLoad(&other.MailboxPushedOutByEventCount);
diff --git a/library/cpp/actors/core/ut/ya.make b/library/cpp/actors/core/ut/ya.make
index bfb4928f53..3ee28d5850 100644
--- a/library/cpp/actors/core/ut/ya.make
+++ b/library/cpp/actors/core/ut/ya.make
@@ -36,7 +36,7 @@ SRCS(
     balancer_ut.cpp
     event_pb_payload_ut.cpp
     event_pb_ut.cpp
-    executor_pool_basic_ut.cpp 
+    executor_pool_basic_ut.cpp
     executor_pool_united_ut.cpp
     log_ut.cpp
     memory_tracker_ut.cpp
diff --git a/library/cpp/actors/core/ya.make b/library/cpp/actors/core/ya.make
index bbeb7d4899..880a9d00db 100644
--- a/library/cpp/actors/core/ya.make
+++ b/library/cpp/actors/core/ya.make
@@ -117,7 +117,7 @@ PEERDIR(
 )
 
 END()
- 
-RECURSE_FOR_TESTS( 
-    ut 
-) 
+
+RECURSE_FOR_TESTS(
+    ut
+)
diff --git a/library/cpp/actors/helpers/selfping_actor.cpp b/library/cpp/actors/helpers/selfping_actor.cpp
index 50df38e972..f9bfaf8dc0 100644
--- a/library/cpp/actors/helpers/selfping_actor.cpp
+++ b/library/cpp/actors/helpers/selfping_actor.cpp
@@ -67,8 +67,8 @@ private:
     NSlidingWindow::TSlidingWindow<NSlidingWindow::TMaxOperation<ui64>> SlidingWindow;
     NSlidingWindow::TSlidingWindow<TAvgOperation<ui64>> CalculationSlidingWindow;
 
-    THPTimer Timer; 
- 
+    THPTimer Timer;
+
 public:
     static constexpr auto ActorActivityType() {
         return SELF_PING_ACTOR;
@@ -87,7 +87,7 @@ public:
     void Bootstrap(const TActorContext& ctx)
     {
         Become(&TSelfPingActor::RunningState);
-        SchedulePing(ctx, Timer.Passed()); 
+        SchedulePing(ctx, Timer.Passed());
     }
 
     STFUNC(RunningState)
@@ -148,23 +148,23 @@ public:
 
     void HandlePing(TEvPing::TPtr &ev, const TActorContext &ctx)
     {
-        const auto now = ctx.Now(); 
-        const double hpNow = Timer.Passed(); 
+        const auto now = ctx.Now();
+        const double hpNow = Timer.Passed();
         const auto& e = *ev->Get();
-        const double passedTime = hpNow - e.TimeStart; 
-        const ui64 delayUs = passedTime > 0.0 ? static_cast<ui64>(passedTime * 1e6) : 0; 
+        const double passedTime = hpNow - e.TimeStart;
+        const ui64 delayUs = passedTime > 0.0 ? static_cast<ui64>(passedTime * 1e6) : 0;
 
-        *Counter = SlidingWindow.Update(delayUs, now); 
+        *Counter = SlidingWindow.Update(delayUs, now);
 
         ui64 d = MeasureTaskDurationNs();
-        auto res = CalculationSlidingWindow.Update({1, d}, now); 
+        auto res = CalculationSlidingWindow.Update({1, d}, now);
         *CalculationTimeCounter = double(res.Sum) / double(res.Count + 1);
 
-        SchedulePing(ctx, hpNow); 
+        SchedulePing(ctx, hpNow);
     }
 
 private:
-    void SchedulePing(const TActorContext &ctx, double hpNow) const 
+    void SchedulePing(const TActorContext &ctx, double hpNow) const
     {
         ctx.Schedule(SendInterval, new TEvPing(hpNow));
     }
diff --git a/library/cpp/actors/testlib/decorator_ut.cpp b/library/cpp/actors/testlib/decorator_ut.cpp
index cc937080da..e9a2fa3560 100644
--- a/library/cpp/actors/testlib/decorator_ut.cpp
+++ b/library/cpp/actors/testlib/decorator_ut.cpp
@@ -1,327 +1,327 @@
-#include "test_runtime.h" 
- 
-#include <library/cpp/actors/core/actor_bootstrapped.h> 
-#include <library/cpp/testing/unittest/registar.h> 
- 
- 
-using namespace NActors; 
- 
- 
-Y_UNIT_TEST_SUITE(TesTTestDecorator) { 
- 
-    bool IsVerbose = false; 
-    void Write(TString msg) { 
-        if (IsVerbose) { 
-            Cerr << (TStringBuilder() << msg << Endl); 
-        } 
-    } 
- 
-    struct TDyingChecker : TTestDecorator { 
-        TActorId MasterId; 
- 
-        TDyingChecker(THolder<IActor> &&actor, TActorId masterId) 
-            : TTestDecorator(std::move(actor)) 
-            , MasterId(masterId) 
-        { 
-            Write("TDyingChecker::Construct\n"); 
-        } 
- 
-        virtual ~TDyingChecker() { 
-            Write("TDyingChecker::~TDyingChecker"); 
-            TActivationContext::Send(new IEventHandle(MasterId, SelfId(), new TEvents::TEvPing())); 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TDyingChecker::DoBeforeReceiving"); 
-            return true; 
-        } 
-         
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            Write("TDyingChecker::DoAfterReceiving"); 
-        } 
-    }; 
- 
-    struct TTestMasterActor : TActorBootstrapped<TTestMasterActor> { 
-        friend TActorBootstrapped<TTestMasterActor>; 
- 
-        TSet<TActorId> ActorIds; 
-        TVector<THolder<IActor>> Actors; 
-        TActorId EdgeActor; 
-         
-        TTestMasterActor(TVector<THolder<IActor>> &&actors, TActorId edgeActor) 
-            : TActorBootstrapped() 
-            , Actors(std::move(actors)) 
-            , EdgeActor(edgeActor) 
-        { 
-        } 
- 
-        void Bootstrap() 
-        { 
-            Write("Start master actor"); 
-            for (auto &actor : Actors) { 
+#include "test_runtime.h"
+
+#include <library/cpp/actors/core/actor_bootstrapped.h>
+#include <library/cpp/testing/unittest/registar.h>
+
+
+using namespace NActors;
+
+
+Y_UNIT_TEST_SUITE(TesTTestDecorator) {
+
+    bool IsVerbose = false;
+    void Write(TString msg) {
+        if (IsVerbose) {
+            Cerr << (TStringBuilder() << msg << Endl);
+        }
+    }
+
+    struct TDyingChecker : TTestDecorator {
+        TActorId MasterId;
+
+        TDyingChecker(THolder<IActor> &&actor, TActorId masterId)
+            : TTestDecorator(std::move(actor))
+            , MasterId(masterId)
+        {
+            Write("TDyingChecker::Construct\n");
+        }
+
+        virtual ~TDyingChecker() {
+            Write("TDyingChecker::~TDyingChecker");
+            TActivationContext::Send(new IEventHandle(MasterId, SelfId(), new TEvents::TEvPing()));
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TDyingChecker::DoBeforeReceiving");
+            return true;
+        }
+        
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            Write("TDyingChecker::DoAfterReceiving");
+        }
+    };
+
+    struct TTestMasterActor : TActorBootstrapped<TTestMasterActor> {
+        friend TActorBootstrapped<TTestMasterActor>;
+
+        TSet<TActorId> ActorIds;
+        TVector<THolder<IActor>> Actors;
+        TActorId EdgeActor;
+        
+        TTestMasterActor(TVector<THolder<IActor>> &&actors, TActorId edgeActor)
+            : TActorBootstrapped()
+            , Actors(std::move(actors))
+            , EdgeActor(edgeActor)
+        {
+        }
+
+        void Bootstrap()
+        {
+            Write("Start master actor");
+            for (auto &actor : Actors) {
                 THolder<IActor> decaratedActor = MakeHolder<TDyingChecker>(std::move(actor), SelfId());
-                TActorId id = Register(decaratedActor.Release()); 
-                Write("Register test actor"); 
-                UNIT_ASSERT(ActorIds.insert(id).second); 
-            } 
-            Become(&TTestMasterActor::State); 
-        } 
- 
-        STATEFN(State) { 
-            auto it = ActorIds.find(ev->Sender); 
-            UNIT_ASSERT(it != ActorIds.end()); 
-            Write("End test actor"); 
-            ActorIds.erase(it); 
-            if (!ActorIds) { 
-                Send(EdgeActor, new TEvents::TEvPing()); 
-                PassAway(); 
-            } 
-        } 
-    }; 
- 
-    enum { 
-        Begin = EventSpaceBegin(TEvents::ES_USERSPACE), 
-        EvWords 
-    }; 
- 
-    struct TEvWords : TEventLocal<TEvWords, EvWords> { 
-        TVector<TString> Words; 
- 
-        TEvWords() 
-            : TEventLocal() 
-        { 
-        } 
-    }; 
- 
-    struct TFizzBuzzToFooBar : TTestDecorator { 
-        TFizzBuzzToFooBar(THolder<IActor> &&actor) 
-            : TTestDecorator(std::move(actor)) 
-        { 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (ev->Type == TEvents::TSystem::Bootstrap) { 
-                return true; 
-            } 
-            Write("TFizzBuzzToFooBar::DoBeforeSending"); 
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get()); 
-            UNIT_ASSERT(handle); 
-            TEvWords *event = handle->Get(); 
-            TVector<TString> &words = event->Words; 
-            TStringBuilder wordsMsg; 
-            for (auto &word : words) { 
-                wordsMsg << word << ';'; 
-            } 
-            Write(TStringBuilder() << "Send# " << wordsMsg); 
-            if (words.size() == 2 && words[0] == "Fizz" && words[1] == "Buzz") { 
-                words[0] = "Foo"; 
-                words[1] = "Bar"; 
-            } 
-            return true; 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TFizzBuzzToFooBar::DoBeforeReceiving"); 
-            return true; 
-        } 
-         
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            Write("TFizzBuzzToFooBar::DoAfterReceiving"); 
-        } 
-    };     
-     
-    struct TWordEraser : TTestDecorator { 
-        TString ErasingWord; 
- 
-        TWordEraser(THolder<IActor> &&actor, TString word) 
-            : TTestDecorator(std::move(actor)) 
-            , ErasingWord(word) 
-        { 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (ev->Type == TEvents::TSystem::Bootstrap) { 
-                return true; 
-            } 
-            Write("TWordEraser::DoBeforeSending"); 
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get()); 
-            UNIT_ASSERT(handle); 
-            TEvWords *event = handle->Get(); 
-            TVector<TString> &words = event->Words; 
-            auto it = Find(words.begin(), words.end(), ErasingWord); 
-            if (it != words.end()) { 
-                words.erase(it); 
-            } 
-            return true; 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TWordEraser::DoBeforeReceiving"); 
-            return true; 
-        } 
-         
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            Write("TWordEraser::DoAfterReceiving"); 
-        } 
-    }; 
- 
-    struct TWithoutWordsDroper : TTestDecorator { 
-        TWithoutWordsDroper(THolder<IActor> &&actor) 
-            : TTestDecorator(std::move(actor)) 
-        { 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (ev->Type == TEvents::TSystem::Bootstrap) { 
-                return true; 
-            } 
-            Write("TWithoutWordsDroper::DoBeforeSending"); 
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get()); 
-            UNIT_ASSERT(handle); 
-            TEvWords *event = handle->Get(); 
-            return bool(event->Words); 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TWithoutWordsDroper::DoBeforeReceiving"); 
-            return true; 
-        } 
-         
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            Write("TWithoutWordsDroper::DoAfterReceiving"); 
-        } 
-    }; 
- 
-    struct TFooBarReceiver : TActorBootstrapped<TFooBarReceiver> { 
-        TActorId MasterId; 
-        ui64 Counter = 0; 
- 
-        TFooBarReceiver(TActorId masterId) 
-            : TActorBootstrapped() 
-            , MasterId(masterId) 
-        { 
-        } 
- 
-        void Bootstrap() 
-        { 
-            Become(&TFooBarReceiver::State); 
-        } 
- 
-        STATEFN(State) { 
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get()); 
-            UNIT_ASSERT(handle); 
-            UNIT_ASSERT(handle->Sender == MasterId); 
-            TEvWords *event = handle->Get(); 
-            TVector<TString> &words = event->Words; 
-            UNIT_ASSERT(words.size() == 2 && words[0] == "Foo" && words[1] == "Bar"); 
-            Write(TStringBuilder() << "Receive# " << Counter + 1 << '/' << 2); 
-            if (++Counter == 2) { 
-                PassAway(); 
-            } 
-        } 
-    }; 
- 
-    struct TFizzBuzzSender : TActorBootstrapped<TFizzBuzzSender> { 
-        TActorId SlaveId; 
- 
-        TFizzBuzzSender() 
-            : TActorBootstrapped() 
-        { 
-            Write("TFizzBuzzSender::Construct"); 
-        } 
- 
-        void Bootstrap() { 
-            Write("TFizzBuzzSender::Bootstrap"); 
+                TActorId id = Register(decaratedActor.Release());
+                Write("Register test actor");
+                UNIT_ASSERT(ActorIds.insert(id).second);
+            }
+            Become(&TTestMasterActor::State);
+        }
+
+        STATEFN(State) {
+            auto it = ActorIds.find(ev->Sender);
+            UNIT_ASSERT(it != ActorIds.end());
+            Write("End test actor");
+            ActorIds.erase(it);
+            if (!ActorIds) {
+                Send(EdgeActor, new TEvents::TEvPing());
+                PassAway();
+            }
+        }
+    };
+
+    enum {
+        Begin = EventSpaceBegin(TEvents::ES_USERSPACE),
+        EvWords
+    };
+
+    struct TEvWords : TEventLocal<TEvWords, EvWords> {
+        TVector<TString> Words;
+
+        TEvWords()
+            : TEventLocal()
+        {
+        }
+    };
+
+    struct TFizzBuzzToFooBar : TTestDecorator {
+        TFizzBuzzToFooBar(THolder<IActor> &&actor)
+            : TTestDecorator(std::move(actor))
+        {
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (ev->Type == TEvents::TSystem::Bootstrap) {
+                return true;
+            }
+            Write("TFizzBuzzToFooBar::DoBeforeSending");
+            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            UNIT_ASSERT(handle);
+            TEvWords *event = handle->Get();
+            TVector<TString> &words = event->Words;
+            TStringBuilder wordsMsg;
+            for (auto &word : words) {
+                wordsMsg << word << ';';
+            }
+            Write(TStringBuilder() << "Send# " << wordsMsg);
+            if (words.size() == 2 && words[0] == "Fizz" && words[1] == "Buzz") {
+                words[0] = "Foo";
+                words[1] = "Bar";
+            }
+            return true;
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TFizzBuzzToFooBar::DoBeforeReceiving");
+            return true;
+        }
+        
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            Write("TFizzBuzzToFooBar::DoAfterReceiving");
+        }
+    };    
+    
+    struct TWordEraser : TTestDecorator {
+        TString ErasingWord;
+
+        TWordEraser(THolder<IActor> &&actor, TString word)
+            : TTestDecorator(std::move(actor))
+            , ErasingWord(word)
+        {
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (ev->Type == TEvents::TSystem::Bootstrap) {
+                return true;
+            }
+            Write("TWordEraser::DoBeforeSending");
+            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            UNIT_ASSERT(handle);
+            TEvWords *event = handle->Get();
+            TVector<TString> &words = event->Words;
+            auto it = Find(words.begin(), words.end(), ErasingWord);
+            if (it != words.end()) {
+                words.erase(it);
+            }
+            return true;
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TWordEraser::DoBeforeReceiving");
+            return true;
+        }
+        
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            Write("TWordEraser::DoAfterReceiving");
+        }
+    };
+
+    struct TWithoutWordsDroper : TTestDecorator {
+        TWithoutWordsDroper(THolder<IActor> &&actor)
+            : TTestDecorator(std::move(actor))
+        {
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (ev->Type == TEvents::TSystem::Bootstrap) {
+                return true;
+            }
+            Write("TWithoutWordsDroper::DoBeforeSending");
+            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            UNIT_ASSERT(handle);
+            TEvWords *event = handle->Get();
+            return bool(event->Words);
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TWithoutWordsDroper::DoBeforeReceiving");
+            return true;
+        }
+        
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            Write("TWithoutWordsDroper::DoAfterReceiving");
+        }
+    };
+
+    struct TFooBarReceiver : TActorBootstrapped<TFooBarReceiver> {
+        TActorId MasterId;
+        ui64 Counter = 0;
+
+        TFooBarReceiver(TActorId masterId)
+            : TActorBootstrapped()
+            , MasterId(masterId)
+        {
+        }
+
+        void Bootstrap()
+        {
+            Become(&TFooBarReceiver::State);
+        }
+
+        STATEFN(State) {
+            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            UNIT_ASSERT(handle);
+            UNIT_ASSERT(handle->Sender == MasterId);
+            TEvWords *event = handle->Get();
+            TVector<TString> &words = event->Words;
+            UNIT_ASSERT(words.size() == 2 && words[0] == "Foo" && words[1] == "Bar");
+            Write(TStringBuilder() << "Receive# " << Counter + 1 << '/' << 2);
+            if (++Counter == 2) {
+                PassAway();
+            }
+        }
+    };
+
+    struct TFizzBuzzSender : TActorBootstrapped<TFizzBuzzSender> {
+        TActorId SlaveId;
+
+        TFizzBuzzSender()
+            : TActorBootstrapped()
+        {
+            Write("TFizzBuzzSender::Construct");
+        }
+
+        void Bootstrap() {
+            Write("TFizzBuzzSender::Bootstrap");
             THolder<IActor> actor = MakeHolder<TFooBarReceiver>(SelfId());
             THolder<IActor> decoratedActor = MakeHolder<TDyingChecker>(std::move(actor), SelfId());
-            SlaveId = Register(decoratedActor.Release()); 
-            for (ui64 idx = 1; idx <= 30; ++idx) { 
+            SlaveId = Register(decoratedActor.Release());
+            for (ui64 idx = 1; idx <= 30; ++idx) {
                 THolder<TEvWords> ev = MakeHolder<TEvWords>();
-                if (idx % 3 == 0) { 
-                    ev->Words.push_back("Fizz"); 
-                } 
-                if (idx % 5 == 0) { 
-                    ev->Words.push_back("Buzz"); 
-                } 
-                Send(SlaveId, ev.Release()); 
-                Write("TFizzBuzzSender::Send words"); 
-            } 
-            Become(&TFizzBuzzSender::State); 
-        } 
- 
-        STATEFN(State) { 
-            UNIT_ASSERT(ev->Sender == SlaveId); 
-            PassAway(); 
-        } 
-    }; 
- 
-    struct TCounters { 
-        ui64 SendedCount = 0; 
-        ui64 RecievedCount = 0; 
-    }; 
- 
-    struct TCountingDecorator : TTestDecorator { 
-        TCounters *Counters; 
- 
-        TCountingDecorator(THolder<IActor> &&actor, TCounters *counters) 
-            : TTestDecorator(std::move(actor)) 
-            , Counters(counters) 
-        { 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (ev->Type == TEvents::TSystem::Bootstrap) { 
-                return true; 
-            } 
-            Write("TCountingDecorator::DoBeforeSending"); 
-            Counters->SendedCount++; 
-            return true; 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TCountingDecorator::DoBeforeReceiving"); 
-            Counters->RecievedCount++; 
-            return true; 
-        } 
-    }; 
-     
-    bool ScheduledFilterFunc(NActors::TTestActorRuntimeBase& runtime, TAutoPtr<NActors::IEventHandle>& event, 
-            TDuration delay, TInstant& deadline) { 
-        if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) { 
-            deadline = runtime.GetTimeProvider()->Now() + delay; 
-            return false; 
-        } 
-        return true; 
-    } 
- 
-    THolder<IActor> CreateFizzBuzzSender() { 
+                if (idx % 3 == 0) {
+                    ev->Words.push_back("Fizz");
+                }
+                if (idx % 5 == 0) {
+                    ev->Words.push_back("Buzz");
+                }
+                Send(SlaveId, ev.Release());
+                Write("TFizzBuzzSender::Send words");
+            }
+            Become(&TFizzBuzzSender::State);
+        }
+
+        STATEFN(State) {
+            UNIT_ASSERT(ev->Sender == SlaveId);
+            PassAway();
+        }
+    };
+
+    struct TCounters {
+        ui64 SendedCount = 0;
+        ui64 RecievedCount = 0;
+    };
+
+    struct TCountingDecorator : TTestDecorator {
+        TCounters *Counters;
+
+        TCountingDecorator(THolder<IActor> &&actor, TCounters *counters)
+            : TTestDecorator(std::move(actor))
+            , Counters(counters)
+        {
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (ev->Type == TEvents::TSystem::Bootstrap) {
+                return true;
+            }
+            Write("TCountingDecorator::DoBeforeSending");
+            Counters->SendedCount++;
+            return true;
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TCountingDecorator::DoBeforeReceiving");
+            Counters->RecievedCount++;
+            return true;
+        }
+    };
+    
+    bool ScheduledFilterFunc(NActors::TTestActorRuntimeBase& runtime, TAutoPtr<NActors::IEventHandle>& event,
+            TDuration delay, TInstant& deadline) {
+        if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) {
+            deadline = runtime.GetTimeProvider()->Now() + delay;
+            return false;
+        }
+        return true;
+    }
+
+    THolder<IActor> CreateFizzBuzzSender() {
         THolder<IActor> actor = MakeHolder<TFizzBuzzSender>();
         THolder<IActor> foobar = MakeHolder<TFizzBuzzToFooBar>(std::move(actor));
         THolder<IActor> fizzEraser = MakeHolder<TWordEraser>(std::move(foobar), "Fizz");
         THolder<IActor> buzzEraser = MakeHolder<TWordEraser>(std::move(fizzEraser), "Buzz");
         return MakeHolder<TWithoutWordsDroper>(std::move(buzzEraser));
-    } 
- 
-    Y_UNIT_TEST(Basic) { 
-        TTestActorRuntimeBase runtime(1, false); 
- 
-        runtime.SetScheduledEventFilter(&ScheduledFilterFunc); 
-        runtime.SetEventFilter([](NActors::TTestActorRuntimeBase&, TAutoPtr<NActors::IEventHandle>&) { 
-            return false; 
-        }); 
-        runtime.Initialize(); 
- 
-        TActorId edgeActor = runtime.AllocateEdgeActor(); 
-        TVector<THolder<IActor>> actors(1); 
-        actors[0] = CreateFizzBuzzSender(); 
-        //actors[1] = CreateFizzBuzzSender(); 
+    }
+
+    Y_UNIT_TEST(Basic) {
+        TTestActorRuntimeBase runtime(1, false);
+
+        runtime.SetScheduledEventFilter(&ScheduledFilterFunc);
+        runtime.SetEventFilter([](NActors::TTestActorRuntimeBase&, TAutoPtr<NActors::IEventHandle>&) {
+            return false;
+        });
+        runtime.Initialize();
+
+        TActorId edgeActor = runtime.AllocateEdgeActor();
+        TVector<THolder<IActor>> actors(1);
+        actors[0] = CreateFizzBuzzSender();
+        //actors[1] = CreateFizzBuzzSender();
         THolder<IActor> testActor = MakeHolder<TTestMasterActor>(std::move(actors), edgeActor);
-        Write("Start test"); 
-        runtime.Register(testActor.Release()); 
- 
-        TAutoPtr<IEventHandle> handle; 
-        auto ev = runtime.GrabEdgeEventRethrow<TEvents::TEvPing>(handle); 
-        UNIT_ASSERT(ev); 
-        Write("Stop test"); 
-    } 
-} 
+        Write("Start test");
+        runtime.Register(testActor.Release());
+
+        TAutoPtr<IEventHandle> handle;
+        auto ev = runtime.GrabEdgeEventRethrow<TEvents::TEvPing>(handle);
+        UNIT_ASSERT(ev);
+        Write("Stop test");
+    }
+}
diff --git a/library/cpp/actors/testlib/test_runtime.cpp b/library/cpp/actors/testlib/test_runtime.cpp
index 1fc7b1e9ea..6fa25b9965 100644
--- a/library/cpp/actors/testlib/test_runtime.cpp
+++ b/library/cpp/actors/testlib/test_runtime.cpp
@@ -358,12 +358,12 @@ namespace NActors {
             if (!Runtime->EventFilterFunc(*Runtime, ev)) {
                 ui32 nodeId = ev->GetRecipientRewrite().NodeId();
                 Y_VERIFY(nodeId != 0);
-                TNodeDataBase* node = Runtime->Nodes[nodeId].Get(); 
- 
-                if (!AllowSendFrom(node, ev)) { 
-                    return true; 
-                } 
- 
+                TNodeDataBase* node = Runtime->Nodes[nodeId].Get();
+
+                if (!AllowSendFrom(node, ev)) {
+                    return true;
+                }
+
                 ui32 mailboxHint = ev->GetRecipientRewrite().Hint();
                 if (ev->GetTypeRewrite() == ui32(NActors::NLog::EEv::Log)) {
                     const NActors::TActorId loggerActorId = NActors::TActorId(nodeId, "logger");
@@ -373,10 +373,10 @@ namespace NActors {
                         IActor* recipientActor = mailbox->FindActor(ev->GetRecipientRewrite().LocalId());
                         if (recipientActor) {
                             TActorContext ctx(*mailbox, *node->ExecutorThread, GetCycleCountFast(), ev->GetRecipientRewrite());
-                            TActivationContext *prevTlsActivationContext = TlsActivationContext; 
-                            TlsActivationContext = &ctx; 
+                            TActivationContext *prevTlsActivationContext = TlsActivationContext;
+                            TlsActivationContext = &ctx;
                             recipientActor->Receive(ev, ctx);
-                            TlsActivationContext = prevTlsActivationContext; 
+                            TlsActivationContext = prevTlsActivationContext;
                             // we expect the logger to never die in tests
                         }
                     }
@@ -515,18 +515,18 @@ namespace NActors {
         node->ActorSystem->Start();
     }
 
-    bool TTestActorRuntimeBase::AllowSendFrom(TNodeDataBase* node, TAutoPtr<IEventHandle>& ev) { 
-        ui64 senderLocalId = ev->Sender.LocalId(); 
-        ui64 senderMailboxHint = ev->Sender.Hint(); 
-        TMailboxHeader* senderMailbox = node->MailboxTable->Get(senderMailboxHint); 
-        if (senderMailbox) { 
-            IActor* senderActor = senderMailbox->FindActor(senderLocalId); 
-            TTestDecorator *decorator = dynamic_cast<TTestDecorator*>(senderActor); 
-            return !decorator || decorator->BeforeSending(ev); 
-        } 
-        return true; 
-    } 
- 
+    bool TTestActorRuntimeBase::AllowSendFrom(TNodeDataBase* node, TAutoPtr<IEventHandle>& ev) {
+        ui64 senderLocalId = ev->Sender.LocalId();
+        ui64 senderMailboxHint = ev->Sender.Hint();
+        TMailboxHeader* senderMailbox = node->MailboxTable->Get(senderMailboxHint);
+        if (senderMailbox) {
+            IActor* senderActor = senderMailbox->FindActor(senderLocalId);
+            TTestDecorator *decorator = dynamic_cast<TTestDecorator*>(senderActor);
+            return !decorator || decorator->BeforeSending(ev);
+        }
+        return true;
+    }
+
     TTestActorRuntimeBase::TTestActorRuntimeBase(ui32 nodeCount, ui32 dataCenterCount)
         : TTestActorRuntimeBase(nodeCount, dataCenterCount, false) {
     }
@@ -1547,10 +1547,10 @@ namespace NActors {
         Y_VERIFY(!ev->GetRecipientRewrite().IsService() && (targetNodeIndex == nodeIndex));
         TAutoPtr<IEventHandle> evHolder(ev);
 
-        if (!AllowSendFrom(node, evHolder)) { 
-            return; 
-        } 
- 
+        if (!AllowSendFrom(node, evHolder)) {
+            return;
+        }
+
         ui32 mailboxHint = ev->GetRecipientRewrite().Hint();
         TEventMailBox& mbox = GetMailbox(nodeId, mailboxHint);
         if (!mbox.IsActive(TInstant::MicroSeconds(CurrentTimestamp))) {
@@ -1774,15 +1774,15 @@ namespace NActors {
         }
 
         TStrandingActorDecorator(const TActorId& delegatee, bool isSync, const TVector<TActorId>& additionalActors,
-            TSimpleSharedPtr<TStrandingActorDecoratorContext> context, TTestActorRuntimeBase* runtime, 
-            TReplyCheckerCreator createReplyChecker) 
+            TSimpleSharedPtr<TStrandingActorDecoratorContext> context, TTestActorRuntimeBase* runtime,
+            TReplyCheckerCreator createReplyChecker)
             : Delegatee(delegatee)
             , IsSync(isSync)
             , AdditionalActors(additionalActors)
             , Context(context)
             , HasReply(false)
             , Runtime(runtime)
-            , ReplyChecker(createReplyChecker()) 
+            , ReplyChecker(createReplyChecker())
         {
             if (IsSync) {
                 Y_VERIFY(!runtime->IsRealThreads());
@@ -1812,12 +1812,12 @@ namespace NActors {
 
         STFUNC(Reply) {
             Y_VERIFY(!HasReply);
-            IEventHandle *requestEv = Context->Queue->Head(); 
+            IEventHandle *requestEv = Context->Queue->Head();
             TActorId originalSender = requestEv->Sender;
-            HasReply = !ReplyChecker->IsWaitingForMoreResponses(ev.Get()); 
-            if (HasReply) { 
-                delete Context->Queue->Pop(); 
-            } 
+            HasReply = !ReplyChecker->IsWaitingForMoreResponses(ev.Get());
+            if (HasReply) {
+                delete Context->Queue->Pop();
+            }
             ctx.ExecutorThread.Send(ev->Forward(originalSender));
             if (!IsSync && Context->Queue->Head()) {
                 SendHead(ctx);
@@ -1849,7 +1849,7 @@ namespace NActors {
 
         TAutoPtr<IEventHandle> GetForwardedEvent() {
             IEventHandle* ev = Context->Queue->Head();
-            ReplyChecker->OnRequest(ev); 
+            ReplyChecker->OnRequest(ev);
             TAutoPtr<IEventHandle> forwardedEv = ev->HasEvent()
                 ? new IEventHandle(Delegatee, ReplyId, ev->ReleaseBase().Release(), ev->Flags, ev->Cookie)
                 : new IEventHandle(ev->GetTypeRewrite(), ev->Flags, Delegatee, ReplyId, ev->ReleaseChainBuffer(), ev->Cookie);
@@ -1865,7 +1865,7 @@ namespace NActors {
         bool HasReply;
         TDispatchOptions DelegateeOptions;
         TTestActorRuntimeBase* Runtime;
-        THolder<IReplyChecker> ReplyChecker; 
+        THolder<IReplyChecker> ReplyChecker;
     };
 
     void TStrandingActorDecorator::TReplyActor::StateFunc(STFUNC_SIG) {
@@ -1874,28 +1874,28 @@ namespace NActors {
 
     class TStrandingDecoratorFactory : public IStrandingDecoratorFactory {
     public:
-        TStrandingDecoratorFactory(TTestActorRuntimeBase* runtime, 
-            TReplyCheckerCreator createReplyChecker) 
+        TStrandingDecoratorFactory(TTestActorRuntimeBase* runtime,
+            TReplyCheckerCreator createReplyChecker)
             : Context(new TStrandingActorDecoratorContext())
             , Runtime(runtime)
-            , CreateReplyChecker(createReplyChecker) 
+            , CreateReplyChecker(createReplyChecker)
         {
         }
 
         IActor* Wrap(const TActorId& delegatee, bool isSync, const TVector<TActorId>& additionalActors) override {
-            return new TStrandingActorDecorator(delegatee, isSync, additionalActors, Context, Runtime, 
-                CreateReplyChecker); 
+            return new TStrandingActorDecorator(delegatee, isSync, additionalActors, Context, Runtime,
+                CreateReplyChecker);
         }
 
     private:
         TSimpleSharedPtr<TStrandingActorDecoratorContext> Context;
         TTestActorRuntimeBase* Runtime;
-        TReplyCheckerCreator CreateReplyChecker; 
+        TReplyCheckerCreator CreateReplyChecker;
     };
 
-    TAutoPtr<IStrandingDecoratorFactory> CreateStrandingDecoratorFactory(TTestActorRuntimeBase* runtime, 
-            TReplyCheckerCreator createReplyChecker) { 
-        return TAutoPtr<IStrandingDecoratorFactory>(new TStrandingDecoratorFactory(runtime, createReplyChecker)); 
+    TAutoPtr<IStrandingDecoratorFactory> CreateStrandingDecoratorFactory(TTestActorRuntimeBase* runtime,
+            TReplyCheckerCreator createReplyChecker) {
+        return TAutoPtr<IStrandingDecoratorFactory>(new TStrandingDecoratorFactory(runtime, createReplyChecker));
     }
 
     ui64 DefaultRandomSeed = 9999;
diff --git a/library/cpp/actors/testlib/test_runtime.h b/library/cpp/actors/testlib/test_runtime.h
index 95ac8b0aa4..26e3b45c98 100644
--- a/library/cpp/actors/testlib/test_runtime.h
+++ b/library/cpp/actors/testlib/test_runtime.h
@@ -593,8 +593,8 @@ namespace NActors {
         void CleanupNodes();
         virtual void InitNodeImpl(TNodeDataBase*, size_t);
 
-        static bool AllowSendFrom(TNodeDataBase* node, TAutoPtr<IEventHandle>& ev); 
- 
+        static bool AllowSendFrom(TNodeDataBase* node, TAutoPtr<IEventHandle>& ev);
+
     protected:
         THolder<INodeFactory> NodeFactory{new TDefaultNodeFactory};
 
@@ -689,28 +689,28 @@ namespace NActors {
         virtual IActor* Wrap(const TActorId& delegatee, bool isSync, const TVector<TActorId>& additionalActors) = 0;
     };
 
-    struct IReplyChecker { 
-        virtual ~IReplyChecker() {} 
-        virtual void OnRequest(IEventHandle *request) = 0; 
-        virtual bool IsWaitingForMoreResponses(IEventHandle *response) = 0; 
-    }; 
- 
-    struct TNoneReplyChecker : IReplyChecker { 
-        void OnRequest(IEventHandle*) override { 
-        } 
- 
-        bool IsWaitingForMoreResponses(IEventHandle*) override { 
-            return false; 
-        } 
-    }; 
- 
-    using TReplyCheckerCreator = std::function<THolder<IReplyChecker>(void)>; 
- 
-    inline THolder<IReplyChecker> CreateNoneReplyChecker() { 
+    struct IReplyChecker {
+        virtual ~IReplyChecker() {}
+        virtual void OnRequest(IEventHandle *request) = 0;
+        virtual bool IsWaitingForMoreResponses(IEventHandle *response) = 0;
+    };
+
+    struct TNoneReplyChecker : IReplyChecker {
+        void OnRequest(IEventHandle*) override {
+        }
+
+        bool IsWaitingForMoreResponses(IEventHandle*) override {
+            return false;
+        }
+    };
+
+    using TReplyCheckerCreator = std::function<THolder<IReplyChecker>(void)>;
+
+    inline THolder<IReplyChecker> CreateNoneReplyChecker() {
         return MakeHolder<TNoneReplyChecker>();
-    } 
- 
-    TAutoPtr<IStrandingDecoratorFactory> CreateStrandingDecoratorFactory(TTestActorRuntimeBase* runtime, 
-            TReplyCheckerCreator createReplyChecker = CreateNoneReplyChecker); 
+    }
+
+    TAutoPtr<IStrandingDecoratorFactory> CreateStrandingDecoratorFactory(TTestActorRuntimeBase* runtime,
+            TReplyCheckerCreator createReplyChecker = CreateNoneReplyChecker);
     extern ui64 DefaultRandomSeed;
 }
diff --git a/library/cpp/actors/testlib/ut/ya.make b/library/cpp/actors/testlib/ut/ya.make
index ef16812aed..1d4aec06ff 100644
--- a/library/cpp/actors/testlib/ut/ya.make
+++ b/library/cpp/actors/testlib/ut/ya.make
@@ -1,20 +1,20 @@
-UNITTEST_FOR(library/cpp/actors/testlib) 
- 
-OWNER( 
-    kruall 
-    g:kikimr 
-) 
- 
-FORK_SUBTESTS() 
-SIZE(SMALL) 
- 
- 
-PEERDIR( 
-    library/cpp/actors/core 
-) 
- 
-SRCS( 
-    decorator_ut.cpp 
-) 
- 
-END() 
+UNITTEST_FOR(library/cpp/actors/testlib)
+
+OWNER(
+    kruall
+    g:kikimr
+)
+
+FORK_SUBTESTS()
+SIZE(SMALL)
+
+
+PEERDIR(
+    library/cpp/actors/core
+)
+
+SRCS(
+    decorator_ut.cpp
+)
+
+END()
diff --git a/library/cpp/actors/testlib/ya.make b/library/cpp/actors/testlib/ya.make
index 8818f10458..1afb3f6059 100644
--- a/library/cpp/actors/testlib/ya.make
+++ b/library/cpp/actors/testlib/ya.make
@@ -21,7 +21,7 @@ IF (GCC)
 ENDIF()
 
 END()
- 
-RECURSE_FOR_TESTS( 
-    ut 
-) 
+
+RECURSE_FOR_TESTS(
+    ut
+)
diff --git a/library/cpp/actors/util/threadparkpad.cpp b/library/cpp/actors/util/threadparkpad.cpp
index ece5484459..74069ff15b 100644
--- a/library/cpp/actors/util/threadparkpad.cpp
+++ b/library/cpp/actors/util/threadparkpad.cpp
@@ -48,7 +48,7 @@ namespace NActors {
 
 namespace NActors {
     class TThreadParkPad::TImpl {
-        TAtomic Interrupted; 
+        TAtomic Interrupted;
         HANDLE EvHandle;
 
     public:
@@ -66,7 +66,7 @@ namespace NActors {
 
         bool Park() noexcept {
             ::WaitForSingleObject(EvHandle, INFINITE);
-            return AtomicGet(Interrupted); 
+            return AtomicGet(Interrupted);
         }
 
         void Unpark() noexcept {
@@ -74,12 +74,12 @@ namespace NActors {
         }
 
         void Interrupt() noexcept {
-            AtomicSet(Interrupted, true); 
+            AtomicSet(Interrupted, true);
             Unpark();
         }
 
         bool IsInterrupted() const noexcept {
-            return AtomicGet(Interrupted); 
+            return AtomicGet(Interrupted);
         }
     };
 
@@ -89,7 +89,7 @@ namespace NActors {
 
 namespace NActors {
     class TThreadParkPad::TImpl {
-        TAtomic Interrupted; 
+        TAtomic Interrupted;
         TSystemEvent Ev;
 
     public:
@@ -103,7 +103,7 @@ namespace NActors {
 
         bool Park() noexcept {
             Ev.Wait();
-            return AtomicGet(Interrupted); 
+            return AtomicGet(Interrupted);
         }
 
         void Unpark() noexcept {
@@ -111,12 +111,12 @@ namespace NActors {
         }
 
         void Interrupt() noexcept {
-            AtomicSet(Interrupted, true); 
+            AtomicSet(Interrupted, true);
             Unpark();
         }
 
         bool IsInterrupted() const noexcept {
-            return AtomicGet(Interrupted); 
+            return AtomicGet(Interrupted);
         }
     };
 #endif
diff --git a/ydb/core/base/blobstorage.cpp b/ydb/core/base/blobstorage.cpp
index b15cfb1c35..60bef7f4df 100644
--- a/ydb/core/base/blobstorage.cpp
+++ b/ydb/core/base/blobstorage.cpp
@@ -73,20 +73,20 @@ std::unique_ptr<TEvBlobStorage::TEvBlockResult> TEvBlobStorage::TEvBlock::MakeEr
     return res;
 }
 
-std::unique_ptr<TEvBlobStorage::TEvPatchResult> TEvBlobStorage::TEvPatch::MakeErrorResponse( 
-        NKikimrProto::EReplyStatus status, const TString& errorReason, ui32 groupId) { 
-    auto res = std::make_unique<TEvPatchResult>(status, PatchedId, TStorageStatusFlags(), groupId, 0.0f); 
-    res->ErrorReason = errorReason; 
-    return res; 
-} 
- 
-std::unique_ptr<TEvBlobStorage::TEvInplacePatchResult> TEvBlobStorage::TEvInplacePatch::MakeErrorResponse( 
-        NKikimrProto::EReplyStatus status, const TString& errorReason) { 
-    auto res = std::make_unique<TEvInplacePatchResult>(status, PatchedId, TStorageStatusFlags(), 0.0f); 
-    res->ErrorReason = errorReason; 
-    return res; 
-} 
- 
+std::unique_ptr<TEvBlobStorage::TEvPatchResult> TEvBlobStorage::TEvPatch::MakeErrorResponse(
+        NKikimrProto::EReplyStatus status, const TString& errorReason, ui32 groupId) {
+    auto res = std::make_unique<TEvPatchResult>(status, PatchedId, TStorageStatusFlags(), groupId, 0.0f);
+    res->ErrorReason = errorReason;
+    return res;
+}
+
+std::unique_ptr<TEvBlobStorage::TEvInplacePatchResult> TEvBlobStorage::TEvInplacePatch::MakeErrorResponse(
+        NKikimrProto::EReplyStatus status, const TString& errorReason) {
+    auto res = std::make_unique<TEvInplacePatchResult>(status, PatchedId, TStorageStatusFlags(), 0.0f);
+    res->ErrorReason = errorReason;
+    return res;
+}
+
 std::unique_ptr<TEvBlobStorage::TEvDiscoverResult> TEvBlobStorage::TEvDiscover::MakeErrorResponse(
         NKikimrProto::EReplyStatus status, const TString& errorReason, ui32 /*groupId*/) {
     auto res = std::make_unique<TEvDiscoverResult>(status, MinGeneration, 0);
diff --git a/ydb/core/base/blobstorage.h b/ydb/core/base/blobstorage.h
index 5375e56ca5..a2faee326e 100644
--- a/ydb/core/base/blobstorage.h
+++ b/ydb/core/base/blobstorage.h
@@ -453,8 +453,8 @@ struct TEvBlobStorage {
         EvCollectGarbage,
         EvStatus,
         EvVBaldSyncLog,
-        EvPatch, 
-        EvInplacePatch, 
+        EvPatch,
+        EvInplacePatch,
 
         //
         EvPutResult = EvPut + 512,                              /// 268 632 576
@@ -466,8 +466,8 @@ struct TEvBlobStorage {
         EvCollectGarbageResult,
         EvStatusResult,
         EvVBaldSyncLogResult,
-        EvPatchResult, 
-        EvInplacePatchResult, 
+        EvPatchResult,
+        EvInplacePatchResult,
 
         // proxy <-> vdisk interface
         EvVPut = EvPut + 2 * 512,                               /// 268 633 088
@@ -481,13 +481,13 @@ struct TEvBlobStorage {
         EvVDbStat,
         EvVCheckReadiness,
         EvVCompact,                                             /// 268 633 098
-        EvVMultiPut, 
-        EvVMovedPatch, 
-        EvVPatchStart, 
-        EvVPatchDiff, 
-        EvVPatchXorDiff, 
+        EvVMultiPut,
+        EvVMovedPatch,
+        EvVPatchStart,
+        EvVPatchDiff,
+        EvVPatchXorDiff,
         EvVDefrag,
-        EvVInplacePatch, 
+        EvVInplacePatch,
 
         EvVPutResult = EvPut + 3 * 512,                         /// 268 633 600
         EvVGetResult,
@@ -500,13 +500,13 @@ struct TEvBlobStorage {
         EvVWindowChange,
         EvVCheckReadinessResult,
         EvVCompactResult,
-        EvVMultiPutResult, 
-        EvVMovedPatchResult, 
-        EvVPatchFoundParts, 
-        EvVPatchXorDiffResult, 
-        EvVPatchResult, 
+        EvVMultiPutResult,
+        EvVMovedPatchResult,
+        EvVPatchFoundParts,
+        EvVPatchXorDiffResult,
+        EvVPatchResult,
         EvVDefragResult,
-        EvVInplacePatchResult, 
+        EvVInplacePatchResult,
 
         // vdisk <-> vdisk interface
         EvVDisk = EvPut + 4 * 512,                              /// 268 634 112
@@ -644,8 +644,8 @@ struct TEvBlobStorage {
         EvMonStreamQuery,                                       // 268 636 270
         EvMonStreamActorDeathNote,
         EvPDiskErrorStateChange,
-        EvMultiLog, 
-        EvVMultiPutItemResult, 
+        EvMultiLog,
+        EvVMultiPutItemResult,
         EvEnrichNotYet,
         EvCommenceRepl, // for debugging purposes
         EvRecoverBlob,
@@ -666,8 +666,8 @@ struct TEvBlobStorage {
         EvCompactVDisk,
         EvCompactVDiskResult,
         EvDefragRewritten,
-        EvVPatchDyingRequest, 
-        EvVPatchDyingConfirm, 
+        EvVPatchDyingRequest,
+        EvVPatchDyingConfirm,
         EvNonrestoredCorruptedBlobNotify,
         EvHugeLockChunks,
         EvHugeStat,
@@ -739,9 +739,9 @@ struct TEvBlobStorage {
         EvGroupStatReport,
         EvAccelerateGet,
         EvAcceleratePut,
-        EvRequestProxyQueueState, 
-        EvRequestProxySessionsState, 
-        EvProxySessionsState, 
+        EvRequestProxyQueueState,
+        EvRequestProxySessionsState,
+        EvProxySessionsState,
         EvBunchOfEvents,
 
         // blobstorage controller interface
@@ -855,15 +855,15 @@ struct TEvBlobStorage {
     struct TEvRangeResult;
     struct TEvCollectGarbageResult;
     struct TEvStatusResult;
-    struct TEvPatchResult; 
-    struct TEvInplacePatchResult; 
+    struct TEvPatchResult;
+    struct TEvInplacePatchResult;
 
     struct TEvPut : public TEventLocal<TEvPut, EvPut> {
         enum ETactic {
-            TacticMaxThroughput = 0, 
+            TacticMaxThroughput = 0,
             TacticMinLatency,
-            TacticDefault, // Default depends on the erasure type 
-            TacticCount // This is not a tactic, but a number of tactics. Add new tactics before this line. 
+            TacticDefault, // Default depends on the erasure type
+            TacticCount // This is not a tactic, but a number of tactics. Add new tactics before this line.
         };
         static const char* TacticName(ETactic tactic) {
             switch (tactic) {
@@ -873,8 +873,8 @@ struct TEvBlobStorage {
                     return "MinLatency";
                 case TacticDefault:
                     return "Default";
-                default: 
-                    return "unknown"; 
+                default:
+                    return "unknown";
             }
         };
 
@@ -1268,293 +1268,293 @@ struct TEvBlobStorage {
         }
     };
 
-    struct TEvPatch : public TEventLocal<TEvPatch, EvPatch> { 
-    private: 
-        static constexpr ui32 BaseDomainsCount = 8; 
-        static constexpr ui32 MaxStepsForFindingId = 128; 
- 
-    public: 
-        struct TDiff { 
-            TString Buffer; 
-            ui32 Offset; 
- 
-            TDiff() 
-                : Offset(0) 
-            { 
-            } 
- 
-            void Set(const TString &buffer, ui32 offset) { 
-                Buffer = buffer; 
-                Offset = offset; 
-                Y_VERIFY_S(buffer.Size(), "EvPatchDiff invalid: Diff size must be non-zero"); 
-            } 
- 
-            template <typename TOStream> 
-            void Output(TOStream &os) const { 
-                os << "TDiff {Offset# " << Offset << " Size# " << Buffer.Size() << '}'; 
-            } 
- 
-            TString ToString() const { 
-                TStringBuilder str; 
-                Output(str); 
-                return str; 
-            } 
-        }; 
- 
-        const ui32 OriginalGroupId; 
-        const TLogoBlobID OriginalId; 
-        const TLogoBlobID PatchedId; 
-        const ui32 MaskForCookieBruteForcing = 0; 
- 
-        TArrayHolder<TDiff> Diffs; 
-        const ui64 DiffCount; 
-        const TInstant Deadline; 
-        mutable NLWTrace::TOrbit Orbit; 
-        ui32 RestartCounter = 0; 
- 
-        TEvPatch(ui32 originalGroupId, const TLogoBlobID &originalId, const TLogoBlobID &patchedId, 
-                ui32 maskForCookieBruteForcing, TArrayHolder<TDiff> &&diffs, ui64 diffCount, TInstant deadline) 
-            : OriginalGroupId(originalGroupId) 
-            , OriginalId(originalId) 
-            , PatchedId(patchedId) 
-            , MaskForCookieBruteForcing(maskForCookieBruteForcing) 
-            , Diffs(std::move(diffs)) 
-            , DiffCount(diffCount) 
-            , Deadline(deadline) 
-        { 
-            CheckContructorArgs(originalId, patchedId, Diffs, DiffCount); 
-        } 
- 
+    struct TEvPatch : public TEventLocal<TEvPatch, EvPatch> {
+    private:
+        static constexpr ui32 BaseDomainsCount = 8;
+        static constexpr ui32 MaxStepsForFindingId = 128;
+
+    public:
+        struct TDiff {
+            TString Buffer;
+            ui32 Offset;
+
+            TDiff()
+                : Offset(0)
+            {
+            }
+
+            void Set(const TString &buffer, ui32 offset) {
+                Buffer = buffer;
+                Offset = offset;
+                Y_VERIFY_S(buffer.Size(), "EvPatchDiff invalid: Diff size must be non-zero");
+            }
+
+            template <typename TOStream>
+            void Output(TOStream &os) const {
+                os << "TDiff {Offset# " << Offset << " Size# " << Buffer.Size() << '}';
+            }
+
+            TString ToString() const {
+                TStringBuilder str;
+                Output(str);
+                return str;
+            }
+        };
+
+        const ui32 OriginalGroupId;
+        const TLogoBlobID OriginalId;
+        const TLogoBlobID PatchedId;
+        const ui32 MaskForCookieBruteForcing = 0;
+
+        TArrayHolder<TDiff> Diffs;
+        const ui64 DiffCount;
+        const TInstant Deadline;
+        mutable NLWTrace::TOrbit Orbit;
+        ui32 RestartCounter = 0;
+
+        TEvPatch(ui32 originalGroupId, const TLogoBlobID &originalId, const TLogoBlobID &patchedId,
+                ui32 maskForCookieBruteForcing, TArrayHolder<TDiff> &&diffs, ui64 diffCount, TInstant deadline)
+            : OriginalGroupId(originalGroupId)
+            , OriginalId(originalId)
+            , PatchedId(patchedId)
+            , MaskForCookieBruteForcing(maskForCookieBruteForcing)
+            , Diffs(std::move(diffs))
+            , DiffCount(diffCount)
+            , Deadline(deadline)
+        {
+            CheckContructorArgs(originalId, patchedId, Diffs, DiffCount);
+        }
+
         static void CheckContructorArgs(const TLogoBlobID &originalId, const TLogoBlobID &patchedId,
-                const TArrayHolder<TDiff> &diffs, ui64 diffCount) 
-        { 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&originalId, sizeof(originalId)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&patchedId, sizeof(patchedId)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(diffs.Get(), sizeof(*diffs.Get()) * diffCount); 
- 
-            Y_VERIFY_S(originalId, "EvPatch invalid: LogoBlobId must have non-zero tablet field," 
-                    << " OriginalId# " << originalId); 
-            Y_VERIFY_S(patchedId, "EvPatch invalid: LogoBlobId must have non-zero tablet field," 
-                    << " PatchedId# " << patchedId); 
-            Y_VERIFY_S(originalId != patchedId, "EvPatch invalid: OriginalId and PatchedId mustn't be equal" 
-                    << " OriginalId# " << originalId 
-                    << " PatchedId# " << patchedId); 
-            Y_VERIFY_S(originalId.BlobSize() == patchedId.BlobSize(), 
-                    "EvPatch invalid: LogoBlobId must have non-zero tablet field," 
-                    << " OriginalId# " << originalId 
-                    << " PatchedId# " << patchedId); 
- 
-            for (ui32 idx = 0; idx < diffCount; ++idx) { 
-                REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(diffs[idx].Buffer.Data(), diffs[idx].Buffer.size()); 
- 
-                if (idx) { 
-                    Y_VERIFY_S(diffs[idx - 1].Offset + diffs[idx].Buffer.Size() <= diffs[idx].Offset, 
-                            "EvPatch invalid: Diffs mustn't be re-covered," 
-                            << " [" << idx - 1 << "].Offset# " << diffs[idx - 1].Offset 
-                            << " [" << idx - 1 << "].Size# " << diffs[idx - 1].Buffer.Size() 
-                            << " [" << idx << "].Offset# " << diffs[idx].Offset 
-                            << " [" << idx << "].Size# " << diffs[idx].Buffer.Size()); 
-                } 
-                Y_VERIFY_S(diffs[idx].Offset + diffs[idx].Buffer.Size() <= originalId.BlobSize(), 
-                        "EvPatch invalid: Blob size bound was overflow by diff," 
-                        << " [" << idx << "].Offset# " << diffs[idx].Offset 
-                        << " [" << idx << "].Size# " << diffs[idx].Buffer.Size() 
-                        << " [" << idx << "].EndIdx# " << diffs[idx].Offset + diffs[idx].Buffer.Size() 
-                        << " BlobSize# " << originalId.BlobSize()); 
-                Y_VERIFY_S(diffs[idx].Buffer.Size(), 
-                        "EvPatch invalid: Diff size must be non-zero," 
-                        << " [" << idx << "].Size# " << diffs[idx].Buffer.Size()); 
-            } 
-        } 
- 
-        static bool GetBlobIdWithSamePlacement(const TLogoBlobID &originalId, TLogoBlobID *patchedId, 
-                ui32 bitsForBruteForce, ui32 originalGroupId, ui32 currentGroupId) 
-        { 
-            if (originalGroupId != currentGroupId) { 
-                return false; 
-            } 
- 
-            ui32 expectedValue = originalId.Hash() % BaseDomainsCount; 
-            Y_VERIFY(patchedId); 
-            if (patchedId->Hash() % BaseDomainsCount == expectedValue) { 
-                return true; 
-            } 
- 
-            Y_VERIFY(bitsForBruteForce <= TLogoBlobID::MaxCookie); 
-            ui32 baseCookie = ~bitsForBruteForce & patchedId->Cookie(); 
-            ui32 extraCookie = TLogoBlobID::MaxCookie + 1; 
-            ui32 steps = 0; 
-            do { 
-                extraCookie = (extraCookie - 1) & bitsForBruteForce; 
-                ui32 cookie = baseCookie | (extraCookie ^ bitsForBruteForce); 
-                steps++; 
- 
-                TLogoBlobID id(patchedId->TabletID(), patchedId->Generation(), patchedId->Step(), patchedId->Channel(), 
-                        patchedId->BlobSize(), cookie, 0, patchedId->CrcMode()); 
-                if (id.Hash() % BaseDomainsCount == expectedValue) { 
-                    *patchedId = id; 
-                    return true; 
-                } 
- 
-            } while(extraCookie && steps < MaxStepsForFindingId); 
- 
-            return false; 
-        } 
- 
-        TString Print(bool isFull) const { 
-            Y_UNUSED(isFull); 
-            TStringBuilder str; 
-            str << "TEvPatch {OriginalGroupId# " << OriginalGroupId; 
-            str << " OriginalId# " << OriginalId; 
-            str << " PatchedId# " << PatchedId; 
-            str << " Deadline# " << Deadline.MilliSeconds(); 
-            str << " DiffCount# " << DiffCount; 
-            for (ui32 idx = 0; idx < DiffCount; ++idx) { 
-                str << ' '; 
-                Diffs[idx].Output(str); 
-            } 
-            str << '}'; 
-            return str; 
-        } 
- 
-        TString ToString() const { 
-            return Print(false); 
-        } 
- 
-        ui32 CalculateSize() const { 
-            return sizeof(*this) + sizeof(TDiff) * DiffCount; 
-        } 
- 
-        std::unique_ptr<TEvPatchResult> MakeErrorResponse(NKikimrProto::EReplyStatus status, 
-                const TString& errorReason, ui32 groupId); 
-    }; 
- 
-    struct TEvPatchResult : public TEventLocal<TEvPatchResult, EvPatchResult> { 
-        NKikimrProto::EReplyStatus Status; 
-        const TLogoBlobID Id; 
-        const TStorageStatusFlags StatusFlags; 
-        const ui32 GroupId; 
-        const float ApproximateFreeSpaceShare; // 0.f has special meaning 'data could not be obtained' 
-        TString ErrorReason; 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvPatchResult(NKikimrProto::EReplyStatus status, const TLogoBlobID &id, TStorageStatusFlags statusFlags, 
-                ui32 groupId, float approximateFreeSpaceShare) 
-            : Status(status) 
-            , Id(id) 
-            , StatusFlags(statusFlags) 
-            , GroupId(groupId) 
-            , ApproximateFreeSpaceShare(approximateFreeSpaceShare) 
-        { 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&id, sizeof(id)); 
-        } 
- 
-        TString Print(bool isFull) const { 
-            Y_UNUSED(isFull); 
-            TStringBuilder str; 
-            str << "TEvPatchResult {Id# " << Id; 
-            str << " Status# " << NKikimrProto::EReplyStatus_Name(Status).data(); 
-            str << " StatusFlags# " << StatusFlags; 
-            if (ErrorReason.size()) { 
-                str << " ErrorReason# \"" << ErrorReason << "\""; 
-            } 
-            str << " ApproximateFreeSpaceShare# " << ApproximateFreeSpaceShare; 
-            str << "}"; 
-            return str; 
-        } 
- 
-        TString ToString() const { 
-            return Print(false); 
-        } 
-    }; 
- 
-    struct TEvInplacePatch : public TEventLocal<TEvInplacePatch, EvInplacePatch> { 
-        using TDiff = TEvPatch::TDiff; 
- 
-        const TLogoBlobID OriginalId; 
-        const TLogoBlobID PatchedId; 
- 
-        TArrayHolder<TDiff> Diffs; 
-        const ui64 DiffCount; 
-        const TInstant Deadline; 
-        mutable NLWTrace::TOrbit Orbit; 
-        ui32 RestartCounter = 0; 
- 
-        TEvInplacePatch(const TLogoBlobID &originalId, const TLogoBlobID &patchedId, TArrayHolder<TDiff> &&diffs, 
-                ui64 diffCount, TInstant deadline) 
-            : OriginalId(originalId) 
-            , PatchedId(patchedId) 
-            , Diffs(std::move(diffs)) 
-            , DiffCount(diffCount) 
-            , Deadline(deadline) 
-        { 
-            TEvPatch::CheckContructorArgs(originalId, patchedId, Diffs, DiffCount); 
-        } 
- 
-        TString Print(bool isFull) const { 
-            Y_UNUSED(isFull); 
-            TStringBuilder str; 
-            str << "TEvInplacePatch {OriginalId# " << OriginalId; 
-            str << " PatchedId# " << PatchedId; 
-            str << " Deadline# " << Deadline.MilliSeconds(); 
-            str << " DiffCount# " << DiffCount; 
-            for (ui32 idx = 0; idx < DiffCount; ++idx) { 
-                str << ' '; 
-                Diffs[idx].Output(str); 
-            } 
-            str << '}'; 
-            return str; 
-        } 
- 
-        TString ToString() const { 
-            return Print(false); 
-        } 
- 
-        ui32 CalculateSize() const { 
-            return sizeof(*this) + sizeof(TDiff) * DiffCount; 
-        } 
- 
-        std::unique_ptr<TEvInplacePatchResult> MakeErrorResponse(NKikimrProto::EReplyStatus status, 
-                const TString& errorReason); 
-    }; 
- 
-    struct TEvInplacePatchResult : public TEventLocal<TEvInplacePatchResult, EvInplacePatchResult> { 
-        NKikimrProto::EReplyStatus Status; 
-        const TLogoBlobID Id; 
-        const TStorageStatusFlags StatusFlags; 
-        const float ApproximateFreeSpaceShare; // 0.f has special meaning 'data could not be obtained' 
-        TString ErrorReason; 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvInplacePatchResult(NKikimrProto::EReplyStatus status, const TLogoBlobID &id, TStorageStatusFlags statusFlags, 
-                float approximateFreeSpaceShare) 
-            : Status(status) 
-            , Id(id) 
-            , StatusFlags(statusFlags) 
-            , ApproximateFreeSpaceShare(approximateFreeSpaceShare) 
-        { 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&id, sizeof(id)); 
-        } 
- 
-        TString Print(bool isFull) const { 
-            Y_UNUSED(isFull); 
-            TStringBuilder str; 
-            str << "TEvPatchResult {Id# " << Id; 
-            str << " Status# " << NKikimrProto::EReplyStatus_Name(Status).data(); 
-            str << " StatusFlags# " << StatusFlags; 
-            if (ErrorReason.size()) { 
-                str << " ErrorReason# \"" << ErrorReason << "\""; 
-            } 
-            str << " ApproximateFreeSpaceShare# " << ApproximateFreeSpaceShare; 
-            str << "}"; 
-            return str; 
-        } 
- 
-        TString ToString() const { 
-            return Print(false); 
-        } 
-    }; 
- 
+                const TArrayHolder<TDiff> &diffs, ui64 diffCount)
+        {
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&originalId, sizeof(originalId));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&patchedId, sizeof(patchedId));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(diffs.Get(), sizeof(*diffs.Get()) * diffCount);
+
+            Y_VERIFY_S(originalId, "EvPatch invalid: LogoBlobId must have non-zero tablet field,"
+                    << " OriginalId# " << originalId);
+            Y_VERIFY_S(patchedId, "EvPatch invalid: LogoBlobId must have non-zero tablet field,"
+                    << " PatchedId# " << patchedId);
+            Y_VERIFY_S(originalId != patchedId, "EvPatch invalid: OriginalId and PatchedId mustn't be equal"
+                    << " OriginalId# " << originalId
+                    << " PatchedId# " << patchedId);
+            Y_VERIFY_S(originalId.BlobSize() == patchedId.BlobSize(),
+                    "EvPatch invalid: LogoBlobId must have non-zero tablet field,"
+                    << " OriginalId# " << originalId
+                    << " PatchedId# " << patchedId);
+
+            for (ui32 idx = 0; idx < diffCount; ++idx) {
+                REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(diffs[idx].Buffer.Data(), diffs[idx].Buffer.size());
+
+                if (idx) {
+                    Y_VERIFY_S(diffs[idx - 1].Offset + diffs[idx].Buffer.Size() <= diffs[idx].Offset,
+                            "EvPatch invalid: Diffs mustn't be re-covered,"
+                            << " [" << idx - 1 << "].Offset# " << diffs[idx - 1].Offset
+                            << " [" << idx - 1 << "].Size# " << diffs[idx - 1].Buffer.Size()
+                            << " [" << idx << "].Offset# " << diffs[idx].Offset
+                            << " [" << idx << "].Size# " << diffs[idx].Buffer.Size());
+                }
+                Y_VERIFY_S(diffs[idx].Offset + diffs[idx].Buffer.Size() <= originalId.BlobSize(),
+                        "EvPatch invalid: Blob size bound was overflow by diff,"
+                        << " [" << idx << "].Offset# " << diffs[idx].Offset
+                        << " [" << idx << "].Size# " << diffs[idx].Buffer.Size()
+                        << " [" << idx << "].EndIdx# " << diffs[idx].Offset + diffs[idx].Buffer.Size()
+                        << " BlobSize# " << originalId.BlobSize());
+                Y_VERIFY_S(diffs[idx].Buffer.Size(),
+                        "EvPatch invalid: Diff size must be non-zero,"
+                        << " [" << idx << "].Size# " << diffs[idx].Buffer.Size());
+            }
+        }
+
+        static bool GetBlobIdWithSamePlacement(const TLogoBlobID &originalId, TLogoBlobID *patchedId,
+                ui32 bitsForBruteForce, ui32 originalGroupId, ui32 currentGroupId)
+        {
+            if (originalGroupId != currentGroupId) {
+                return false;
+            }
+
+            ui32 expectedValue = originalId.Hash() % BaseDomainsCount;
+            Y_VERIFY(patchedId);
+            if (patchedId->Hash() % BaseDomainsCount == expectedValue) {
+                return true;
+            }
+
+            Y_VERIFY(bitsForBruteForce <= TLogoBlobID::MaxCookie);
+            ui32 baseCookie = ~bitsForBruteForce & patchedId->Cookie();
+            ui32 extraCookie = TLogoBlobID::MaxCookie + 1;
+            ui32 steps = 0;
+            do {
+                extraCookie = (extraCookie - 1) & bitsForBruteForce;
+                ui32 cookie = baseCookie | (extraCookie ^ bitsForBruteForce);
+                steps++;
+
+                TLogoBlobID id(patchedId->TabletID(), patchedId->Generation(), patchedId->Step(), patchedId->Channel(),
+                        patchedId->BlobSize(), cookie, 0, patchedId->CrcMode());
+                if (id.Hash() % BaseDomainsCount == expectedValue) {
+                    *patchedId = id;
+                    return true;
+                }
+
+            } while(extraCookie && steps < MaxStepsForFindingId);
+
+            return false;
+        }
+
+        TString Print(bool isFull) const {
+            Y_UNUSED(isFull);
+            TStringBuilder str;
+            str << "TEvPatch {OriginalGroupId# " << OriginalGroupId;
+            str << " OriginalId# " << OriginalId;
+            str << " PatchedId# " << PatchedId;
+            str << " Deadline# " << Deadline.MilliSeconds();
+            str << " DiffCount# " << DiffCount;
+            for (ui32 idx = 0; idx < DiffCount; ++idx) {
+                str << ' ';
+                Diffs[idx].Output(str);
+            }
+            str << '}';
+            return str;
+        }
+
+        TString ToString() const {
+            return Print(false);
+        }
+
+        ui32 CalculateSize() const {
+            return sizeof(*this) + sizeof(TDiff) * DiffCount;
+        }
+
+        std::unique_ptr<TEvPatchResult> MakeErrorResponse(NKikimrProto::EReplyStatus status,
+                const TString& errorReason, ui32 groupId);
+    };
+
+    struct TEvPatchResult : public TEventLocal<TEvPatchResult, EvPatchResult> {
+        NKikimrProto::EReplyStatus Status;
+        const TLogoBlobID Id;
+        const TStorageStatusFlags StatusFlags;
+        const ui32 GroupId;
+        const float ApproximateFreeSpaceShare; // 0.f has special meaning 'data could not be obtained'
+        TString ErrorReason;
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvPatchResult(NKikimrProto::EReplyStatus status, const TLogoBlobID &id, TStorageStatusFlags statusFlags,
+                ui32 groupId, float approximateFreeSpaceShare)
+            : Status(status)
+            , Id(id)
+            , StatusFlags(statusFlags)
+            , GroupId(groupId)
+            , ApproximateFreeSpaceShare(approximateFreeSpaceShare)
+        {
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&id, sizeof(id));
+        }
+
+        TString Print(bool isFull) const {
+            Y_UNUSED(isFull);
+            TStringBuilder str;
+            str << "TEvPatchResult {Id# " << Id;
+            str << " Status# " << NKikimrProto::EReplyStatus_Name(Status).data();
+            str << " StatusFlags# " << StatusFlags;
+            if (ErrorReason.size()) {
+                str << " ErrorReason# \"" << ErrorReason << "\"";
+            }
+            str << " ApproximateFreeSpaceShare# " << ApproximateFreeSpaceShare;
+            str << "}";
+            return str;
+        }
+
+        TString ToString() const {
+            return Print(false);
+        }
+    };
+
+    struct TEvInplacePatch : public TEventLocal<TEvInplacePatch, EvInplacePatch> {
+        using TDiff = TEvPatch::TDiff;
+
+        const TLogoBlobID OriginalId;
+        const TLogoBlobID PatchedId;
+
+        TArrayHolder<TDiff> Diffs;
+        const ui64 DiffCount;
+        const TInstant Deadline;
+        mutable NLWTrace::TOrbit Orbit;
+        ui32 RestartCounter = 0;
+
+        TEvInplacePatch(const TLogoBlobID &originalId, const TLogoBlobID &patchedId, TArrayHolder<TDiff> &&diffs,
+                ui64 diffCount, TInstant deadline)
+            : OriginalId(originalId)
+            , PatchedId(patchedId)
+            , Diffs(std::move(diffs))
+            , DiffCount(diffCount)
+            , Deadline(deadline)
+        {
+            TEvPatch::CheckContructorArgs(originalId, patchedId, Diffs, DiffCount);
+        }
+
+        TString Print(bool isFull) const {
+            Y_UNUSED(isFull);
+            TStringBuilder str;
+            str << "TEvInplacePatch {OriginalId# " << OriginalId;
+            str << " PatchedId# " << PatchedId;
+            str << " Deadline# " << Deadline.MilliSeconds();
+            str << " DiffCount# " << DiffCount;
+            for (ui32 idx = 0; idx < DiffCount; ++idx) {
+                str << ' ';
+                Diffs[idx].Output(str);
+            }
+            str << '}';
+            return str;
+        }
+
+        TString ToString() const {
+            return Print(false);
+        }
+
+        ui32 CalculateSize() const {
+            return sizeof(*this) + sizeof(TDiff) * DiffCount;
+        }
+
+        std::unique_ptr<TEvInplacePatchResult> MakeErrorResponse(NKikimrProto::EReplyStatus status,
+                const TString& errorReason);
+    };
+
+    struct TEvInplacePatchResult : public TEventLocal<TEvInplacePatchResult, EvInplacePatchResult> {
+        NKikimrProto::EReplyStatus Status;
+        const TLogoBlobID Id;
+        const TStorageStatusFlags StatusFlags;
+        const float ApproximateFreeSpaceShare; // 0.f has special meaning 'data could not be obtained'
+        TString ErrorReason;
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvInplacePatchResult(NKikimrProto::EReplyStatus status, const TLogoBlobID &id, TStorageStatusFlags statusFlags,
+                float approximateFreeSpaceShare)
+            : Status(status)
+            , Id(id)
+            , StatusFlags(statusFlags)
+            , ApproximateFreeSpaceShare(approximateFreeSpaceShare)
+        {
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&id, sizeof(id));
+        }
+
+        TString Print(bool isFull) const {
+            Y_UNUSED(isFull);
+            TStringBuilder str;
+            str << "TEvPatchResult {Id# " << Id;
+            str << " Status# " << NKikimrProto::EReplyStatus_Name(Status).data();
+            str << " StatusFlags# " << StatusFlags;
+            if (ErrorReason.size()) {
+                str << " ErrorReason# \"" << ErrorReason << "\"";
+            }
+            str << " ApproximateFreeSpaceShare# " << ApproximateFreeSpaceShare;
+            str << "}";
+            return str;
+        }
+
+        TString ToString() const {
+            return Print(false);
+        }
+    };
+
     // special kind of request, strictly used for tablet discovery
     // returns logoblobid of last known control-channel (zero) entry.
     struct TEvDiscover : public TEventLocal<TEvDiscover, EvDiscover> {
@@ -1978,22 +1978,22 @@ struct TEvBlobStorage {
     struct TEvConfigureProxy;
     struct TEvUpdateGroupInfo;
 
-    struct TEvVMovedPatch; 
-    struct TEvVMovedPatchResult; 
-    struct TEvVInplacePatch; 
-    struct TEvVInplacePatchResult; 
+    struct TEvVMovedPatch;
+    struct TEvVMovedPatchResult;
+    struct TEvVInplacePatch;
+    struct TEvVInplacePatchResult;
     struct TEvVPut;
     struct TEvVPutResult;
-    struct TEvVMultiPut; 
-    struct TEvVMultiPutResult; 
+    struct TEvVMultiPut;
+    struct TEvVMultiPutResult;
     struct TEvVGet;
     struct TEvVGetResult;
-    struct TEvVPatchStart; 
-    struct TEvVPatchFoundParts; 
-    struct TEvVPatchDiff; 
-    struct TEvVPatchResult; 
-    struct TEvVPatchXorDiff; 
-    struct TEvVPatchXorDiffResult; 
+    struct TEvVPatchStart;
+    struct TEvVPatchFoundParts;
+    struct TEvVPatchDiff;
+    struct TEvVPatchResult;
+    struct TEvVPatchXorDiff;
+    struct TEvVPatchXorDiffResult;
     struct TEvVBlock;
     struct TEvVBlockResult;
     struct TEvVGetBlock;
diff --git a/ydb/core/base/blobstorage_grouptype.cpp b/ydb/core/base/blobstorage_grouptype.cpp
index c89afcbf17..66c79ba42c 100644
--- a/ydb/core/base/blobstorage_grouptype.cpp
+++ b/ydb/core/base/blobstorage_grouptype.cpp
@@ -10,7 +10,7 @@
 #if IS_VERBOSE
 #   include <util/stream/str.h>
 #   define VERBOSE_COUT(a) \
-       Cerr << a 
+       Cerr << a
 
 static TString DebugFormatBits(ui64 value) {
     TStringStream s;
@@ -96,7 +96,7 @@ ui32 ReverseMask(ui32 mask) {
 }
 
 bool TBlobStorageGroupType::CorrectLayout(const TPartLayout &layout, TPartPlacement &outCorrection) const {
-    VERBOSE_COUT("Start CorrectLayout" << Endl); 
+    VERBOSE_COUT("Start CorrectLayout" << Endl);
     // TODO: produce 'properly hosted part idx' for each VDisk available
     TReorderablePartLayout remaining;
     TStackVec<ui8, 8> missingParts;
@@ -107,33 +107,33 @@ bool TBlobStorageGroupType::CorrectLayout(const TPartLayout &layout, TPartPlacem
     const ui32 lastBit = 0x80000000;
 
     ui32 vDiskMask = layout.VDiskMask;
-    ui32 slowVDiskMask = layout.SlowVDiskMask; 
+    ui32 slowVDiskMask = layout.SlowVDiskMask;
+
+    VERBOSE_COUT("reverseVDiskMask# " << DebugFormatBits(vDiskMask) << Endl);
 
-    VERBOSE_COUT("reverseVDiskMask# " << DebugFormatBits(vDiskMask) << Endl); 
- 
     ui32 handoffDestinedPartMaskInv = 0;
     for (ui32 i = 0; i < totalPartCount; ++i) {
-        ui32 bit = (1 << i); 
-        if (vDiskMask & bit) { 
-            VERBOSE_COUT("layout.VDiskPartMask[" << i << "]# " << DebugFormatBits(layout.VDiskPartMask[i]) << Endl); 
+        ui32 bit = (1 << i);
+        if (vDiskMask & bit) {
+            VERBOSE_COUT("layout.VDiskPartMask[" << i << "]# " << DebugFormatBits(layout.VDiskPartMask[i]) << Endl);
             if (!(layout.VDiskPartMask[i] & (1 << i))) {
-                if (slowVDiskMask & bit) { 
-                    missingParts.push_back(i); 
-                    handoffDestinedPartMaskInv |= (lastBit >> i); 
-                } else { 
-                    outCorrection.Records.push_back(TPartPlacement::TVDiskPart(i, i)); 
-                } 
+                if (slowVDiskMask & bit) {
+                    missingParts.push_back(i);
+                    handoffDestinedPartMaskInv |= (lastBit >> i);
+                } else {
+                    outCorrection.Records.push_back(TPartPlacement::TVDiskPart(i, i));
+                }
             }
         } else {
             missingParts.push_back(i);
             handoffDestinedPartMaskInv |= (lastBit >> i);
         }
     }
-    VERBOSE_COUT("handoffDestinedPartMaskInv# " << DebugFormatBits(ReverseMask(handoffDestinedPartMaskInv)) << Endl); 
+    VERBOSE_COUT("handoffDestinedPartMaskInv# " << DebugFormatBits(ReverseMask(handoffDestinedPartMaskInv)) << Endl);
 
     for (ui32 i = totalPartCount; i < blobSubgroupSize; ++i) {
-        if (vDiskMask & ~slowVDiskMask & (1 << i)) { 
-            VERBOSE_COUT("layout.VDiskPartMask[" << i << "]# " << DebugFormatBits(layout.VDiskPartMask[i]) << Endl); 
+        if (vDiskMask & ~slowVDiskMask & (1 << i)) {
+            VERBOSE_COUT("layout.VDiskPartMask[" << i << "]# " << DebugFormatBits(layout.VDiskPartMask[i]) << Endl);
             remaining.Records.push_back(TReorderablePartLayout::TVDiskParts(i, handoffDestinedPartMaskInv &
                 ReverseMask(layout.VDiskPartMask[i]) ));
         }
@@ -174,14 +174,14 @@ bool TBlobStorageGroupType::CorrectLayout(const TPartLayout &layout, TPartPlacem
             }
         } else {
             if (missingParts.size()) {
-                VERBOSE_COUT(missingParts.size() << " missing part " << (ui64)missingParts[0] << Endl); 
+                VERBOSE_COUT(missingParts.size() << " missing part " << (ui64)missingParts[0] << Endl);
                 outCorrection.Records.push_back(
                     TPartPlacement::TVDiskPart(disk.VDiskIdx, missingParts[0]));
                 missingParts.erase(missingParts.begin());
             }
         }
     }
-    VERBOSE_COUT("End CorrectLayout" << Endl); 
+    VERBOSE_COUT("End CorrectLayout" << Endl);
     return (missingParts.size() == 0);
 }
 
diff --git a/ydb/core/base/blobstorage_grouptype.h b/ydb/core/base/blobstorage_grouptype.h
index 58af450732..cd38dfcfa8 100644
--- a/ydb/core/base/blobstorage_grouptype.h
+++ b/ydb/core/base/blobstorage_grouptype.h
@@ -25,11 +25,11 @@ struct TBlobStorageGroupType : public TErasureType {
     struct TPartLayout {
         TStackVec<ui32, 32> VDiskPartMask;
         ui32 VDiskMask;
-        ui32 SlowVDiskMask; 
+        ui32 SlowVDiskMask;
 
         TPartLayout()
             : VDiskMask(0)
-            , SlowVDiskMask(0) 
+            , SlowVDiskMask(0)
         {}
 
         TString ToString() const {
@@ -51,10 +51,10 @@ struct TBlobStorageGroupType : public TErasureType {
                 bool isPresent = (VDiskMask & (1 << i));
                 if (isPresent) {
                     str << (isFirst ? "" : ", ") << "VDiskPartMask[" << i << "]# {";
-                    bool isSlow = (SlowVDiskMask & (1 << i)); 
-                    if (isSlow) { 
-                        str << "SlowDisk "; 
-                    } 
+                    bool isSlow = (SlowVDiskMask & (1 << i));
+                    if (isSlow) {
+                        str << "SlowDisk ";
+                    }
                     bool isFirstPart = true;
                     for (ui32 partIdx = 0; partIdx < 32; ++partIdx) {
                         bool isPartPresent = (VDiskPartMask[i] & (1 << partIdx));
diff --git a/ydb/core/base/statestorage.cpp b/ydb/core/base/statestorage.cpp
index 9920e51179..de39a327ae 100644
--- a/ydb/core/base/statestorage.cpp
+++ b/ydb/core/base/statestorage.cpp
@@ -41,9 +41,9 @@ static const ui32 Primes[128] = {
     106013, 106303, 106591, 106823,
 };
 
-constexpr ui64 MaxRingCount = 1024; 
-constexpr ui64 MaxNodeCount = 1024; 
- 
+constexpr ui64 MaxRingCount = 1024;
+constexpr ui64 MaxNodeCount = 1024;
+
 class TStateStorageRingWalker {
     const ui32 Sz;
     const ui32 Delta;
@@ -195,7 +195,7 @@ static void CopyStateStorageRingInfo(
 
     if (hasRings) { // has explicitely defined rings, use them as info rings
         Y_VERIFY(!hasNodes);
-        Y_VERIFY(source.RingSize() < MaxRingCount); 
+        Y_VERIFY(source.RingSize() < MaxRingCount);
         info->Rings.resize(source.RingSize());
 
         for (ui32 iring = 0, ering = source.RingSize(); iring != ering; ++iring) {
@@ -227,7 +227,7 @@ static void CopyStateStorageRingInfo(
 
     if (hasNodes) { // has explicitely defined replicas, use nodes as 1-node rings
         Y_VERIFY(!hasRings);
-        Y_VERIFY(source.NodeSize() < MaxNodeCount); 
+        Y_VERIFY(source.NodeSize() < MaxNodeCount);
 
         info->Rings.resize(source.NodeSize());
         for (ui32 inode = 0, enode = source.NodeSize(); inode != enode; ++inode) {
diff --git a/ydb/core/blobstorage/backpressure/event.h b/ydb/core/blobstorage/backpressure/event.h
index efd0e8adbe..7b8ea72d4c 100644
--- a/ydb/core/blobstorage/backpressure/event.h
+++ b/ydb/core/blobstorage/backpressure/event.h
@@ -6,10 +6,10 @@
 namespace NKikimr::NBsQueue {
 
 template<typename T> struct TMatchingResultType;
-template<> struct TMatchingResultType<TEvBlobStorage::TEvVMovedPatch> { using Type = TEvBlobStorage::TEvVMovedPatchResult; }; 
-template<> struct TMatchingResultType<TEvBlobStorage::TEvVPatchStart> { using Type = TEvBlobStorage::TEvVPatchFoundParts; }; 
-template<> struct TMatchingResultType<TEvBlobStorage::TEvVPatchDiff> { using Type = TEvBlobStorage::TEvVPatchResult; }; 
-template<> struct TMatchingResultType<TEvBlobStorage::TEvVPatchXorDiff> { using Type = TEvBlobStorage::TEvVPatchXorDiffResult; }; 
+template<> struct TMatchingResultType<TEvBlobStorage::TEvVMovedPatch> { using Type = TEvBlobStorage::TEvVMovedPatchResult; };
+template<> struct TMatchingResultType<TEvBlobStorage::TEvVPatchStart> { using Type = TEvBlobStorage::TEvVPatchFoundParts; };
+template<> struct TMatchingResultType<TEvBlobStorage::TEvVPatchDiff> { using Type = TEvBlobStorage::TEvVPatchResult; };
+template<> struct TMatchingResultType<TEvBlobStorage::TEvVPatchXorDiff> { using Type = TEvBlobStorage::TEvVPatchXorDiffResult; };
 template<> struct TMatchingResultType<TEvBlobStorage::TEvVPut> { using Type = TEvBlobStorage::TEvVPutResult; };
 template<> struct TMatchingResultType<TEvBlobStorage::TEvVMultiPut> { using Type = TEvBlobStorage::TEvVMultiPutResult; };
 template<> struct TMatchingResultType<TEvBlobStorage::TEvVGet> { using Type = TEvBlobStorage::TEvVGetResult; };
@@ -98,10 +98,10 @@ public:
     auto Apply(TCallable&& callable) {
         switch (Type) {
 #define CASE(T) case TEvBlobStorage::T::EventType: return callable(static_cast<TEvBlobStorage::T*>(LocalEvent.get()))
-            CASE(TEvVMovedPatch); 
-            CASE(TEvVPatchStart); 
-            CASE(TEvVPatchDiff); 
-            CASE(TEvVPatchXorDiff); 
+            CASE(TEvVMovedPatch);
+            CASE(TEvVPatchStart);
+            CASE(TEvVPatchDiff);
+            CASE(TEvVPatchXorDiff);
             CASE(TEvVPut);
             CASE(TEvVMultiPut);
             CASE(TEvVGet);
diff --git a/ydb/core/blobstorage/backpressure/queue.cpp b/ydb/core/blobstorage/backpressure/queue.cpp
index 9102d77296..c573b7b16b 100644
--- a/ydb/core/blobstorage/backpressure/queue.cpp
+++ b/ydb/core/blobstorage/backpressure/queue.cpp
@@ -4,14 +4,14 @@ namespace NKikimr::NBsQueue {
 
 TBlobStorageQueue::TBlobStorageQueue(const TIntrusivePtr<NMonitoring::TDynamicCounters>& counters, TString& logPrefix,
         const TBSProxyContextPtr& bspctx, const NBackpressure::TQueueClientId& clientId, ui32 interconnectChannel,
-        const TBlobStorageGroupType& gType, NMonitoring::TCountableBase::EVisibility visibility) 
+        const TBlobStorageGroupType& gType, NMonitoring::TCountableBase::EVisibility visibility)
     : Queues(bspctx)
     , WindowSize(0)
     , InFlightCost(0)
     , NextMsgId(0)
     , CurrentSequenceId(1)
     , LogPrefix(logPrefix)
-    , CostModel(2000, 100000000, 50000000, 540000, 540000, 500000, gType) // default cost model 
+    , CostModel(2000, 100000000, 50000000, 540000, 540000, 500000, gType) // default cost model
     , BSProxyCtx(bspctx)
     , ClientId(clientId)
     , BytesWaiting(0)
@@ -49,9 +49,9 @@ TBlobStorageQueue::~TBlobStorageQueue() {
     }
 }
 
-void TBlobStorageQueue::UpdateCostModel(TInstant now, const NKikimrBlobStorage::TVDiskCostSettings& settings, 
-        const TBlobStorageGroupType& type) { 
-    TCostModel newCostModel(settings, type); 
+void TBlobStorageQueue::UpdateCostModel(TInstant now, const NKikimrBlobStorage::TVDiskCostSettings& settings,
+        const TBlobStorageGroupType& type) {
+    TCostModel newCostModel(settings, type);
     if (newCostModel != CostModel) {
         CostModel = std::move(newCostModel);
         InvalidateCosts();
@@ -146,7 +146,7 @@ void TBlobStorageQueue::SendToVDisk(const TActorContext& ctx, const TActorId& re
         auto getTypeName = [&]() -> TString {
             switch (item.Event.GetType()) {
 #define TYPE_CASE(X) case X::EventType: return #X;
-                TYPE_CASE(TEvBlobStorage::TEvVMovedPatch) 
+                TYPE_CASE(TEvBlobStorage::TEvVMovedPatch)
                 TYPE_CASE(TEvBlobStorage::TEvVPut)
                 TYPE_CASE(TEvBlobStorage::TEvVMultiPut)
                 TYPE_CASE(TEvBlobStorage::TEvVGet)
diff --git a/ydb/core/blobstorage/backpressure/queue.h b/ydb/core/blobstorage/backpressure/queue.h
index 52e3c8c6b7..209346cc2d 100644
--- a/ydb/core/blobstorage/backpressure/queue.h
+++ b/ydb/core/blobstorage/backpressure/queue.h
@@ -156,7 +156,7 @@ public:
 public:
     TBlobStorageQueue(const TIntrusivePtr<NMonitoring::TDynamicCounters>& counters, TString& logPrefix,
             const TBSProxyContextPtr& bspctx, const NBackpressure::TQueueClientId& clientId, ui32 interconnectChannel,
-            const TBlobStorageGroupType &gType, 
+            const TBlobStorageGroupType &gType,
             NMonitoring::TCountableBase::EVisibility visibility = NMonitoring::TCountableBase::EVisibility::Public);
 
     ~TBlobStorageQueue();
@@ -183,8 +183,8 @@ public:
         return Queues.InFlight.size();
     }
 
-    void UpdateCostModel(TInstant now, const NKikimrBlobStorage::TVDiskCostSettings& settings, 
-            const TBlobStorageGroupType& type); 
+    void UpdateCostModel(TInstant now, const NKikimrBlobStorage::TVDiskCostSettings& settings,
+            const TBlobStorageGroupType& type);
     void InvalidateCosts();
     bool SetMaxWindowSize(ui64 maxWindowSize);
 
diff --git a/ydb/core/blobstorage/backpressure/queue_backpressure_client.cpp b/ydb/core/blobstorage/backpressure/queue_backpressure_client.cpp
index 11c1992c6d..200b85f616 100644
--- a/ydb/core/blobstorage/backpressure/queue_backpressure_client.cpp
+++ b/ydb/core/blobstorage/backpressure/queue_backpressure_client.cpp
@@ -77,8 +77,8 @@ public:
         : BSProxyCtx(bspctx)
         , QueueName(queueName)
         , Counters(counters->GetSubgroup("queue", queueName))
-        , Queue(Counters, LogPrefix, bspctx, clientId, interconnectChannel, 
-                (info ? info->Type : TErasureType::ErasureNone), visibility) 
+        , Queue(Counters, LogPrefix, bspctx, clientId, interconnectChannel,
+                (info ? info->Type : TErasureType::ErasureNone), visibility)
         , VDiskIdShort(vdiskId)
         , QueueId(queueId)
         , QueueWatchdogTimeout(watchdogTimeout)
@@ -218,10 +218,10 @@ private:
         if (ev->InterconnectSession) { // analyze only messages coming through IC
             ui32 expected = -1;
             switch (const ui32 type = ev->GetTypeRewrite()) {
-                case TEvBlobStorage::EvVMovedPatchResult: 
-                case TEvBlobStorage::EvVPatchFoundParts: 
-                case TEvBlobStorage::EvVPatchXorDiffResult: 
-                case TEvBlobStorage::EvVPatchResult: 
+                case TEvBlobStorage::EvVMovedPatchResult:
+                case TEvBlobStorage::EvVPatchFoundParts:
+                case TEvBlobStorage::EvVPatchXorDiffResult:
+                case TEvBlobStorage::EvVPatchResult:
                 case TEvBlobStorage::EvVPutResult:
                 case TEvBlobStorage::EvVMultiPutResult:
                 case TEvBlobStorage::EvVBlockResult:
@@ -339,7 +339,7 @@ private:
                         throw TExFatal() << "window Status# " << NKikimrBlobStorage::TWindowFeedback_EStatus_Name(ws)
                             << " != expected Status# " << NKikimrBlobStorage::TWindowFeedback_EStatus_Name(expected);
                     }
- 
+
                     ////////////////////////////////////////////////////////////////////////////////////////////////////
                     // check that the failed message id is correct
                     ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -431,7 +431,7 @@ private:
     }
 
     void Handle(TEvBlobStorage::TEvVWindowChange::TPtr &ev, const TActorContext &ctx) {
-        QLOG_DEBUG_S("BSQ09", "WindowChange# " << ev->Get()->ToString()); 
+        QLOG_DEBUG_S("BSQ09", "WindowChange# " << ev->Get()->ToString());
         auto record = ev->Get()->Record;
         if (record.GetDropConnection()) {
             ResetConnection(ctx, NKikimrProto::VDISK_ERROR_STATE, "VDisk disconnected due to error", TDuration::Seconds(10));
@@ -738,27 +738,27 @@ private:
         SessionId = {};
     }
 
-    void Handle(TEvRequestProxyQueueState::TPtr &ev, const TActorContext &ctx) { 
-        bool isConnected = State == EState::READY; 
-        QLOG_DEBUG_S("BSQ35", "RequestProxyQueueState" 
-            << " RemoteVDisk# " << RemoteVDisk 
-            << " VDiskId# " << VDiskId 
-            << " IsConnected# " << isConnected); 
-        ctx.Send(ev->Sender, new TEvProxyQueueState(VDiskId, QueueId, isConnected)); 
-    } 
- 
+    void Handle(TEvRequestProxyQueueState::TPtr &ev, const TActorContext &ctx) {
+        bool isConnected = State == EState::READY;
+        QLOG_DEBUG_S("BSQ35", "RequestProxyQueueState"
+            << " RemoteVDisk# " << RemoteVDisk
+            << " VDiskId# " << VDiskId
+            << " IsConnected# " << isConnected);
+        ctx.Send(ev->Sender, new TEvProxyQueueState(VDiskId, QueueId, isConnected));
+    }
+
 #define QueueRequestHFunc(TEvType) \
     case TEvType::EventType: { \
         TEvType::TPtr *x = reinterpret_cast<TEvType::TPtr *>(&ev); \
         HandleRequest<TEvType::TPtr, TEvType, TEvType##Result>(*x, ctx); \
         break; \
     }
-#define QueueRequestSpecialHFunc(TEvType, TEvResult) \ 
-    case TEvType::EventType: { \ 
-        TEvType::TPtr *x = reinterpret_cast<TEvType::TPtr *>(&ev); \ 
-        HandleRequest<TEvType::TPtr, TEvType, TEvResult>(*x, ctx); \ 
-        break; \ 
-    } 
+#define QueueRequestSpecialHFunc(TEvType, TEvResult) \
+    case TEvType::EventType: { \
+        TEvType::TPtr *x = reinterpret_cast<TEvType::TPtr *>(&ev); \
+        HandleRequest<TEvType::TPtr, TEvType, TEvResult>(*x, ctx); \
+        break; \
+    }
 
     void ChangeGroupInfo(const TBlobStorageGroupInfo& info, const TActorContext& ctx) {
         if (info.GroupGeneration > VDiskId.GroupGeneration) { // ignore any possible races with old generations
@@ -787,7 +787,7 @@ private:
 #if BSQUEUE_EVENT_COUNTERS
 
 #define DEFINE_EVENTS(XX) \
-    XX(TEvBlobStorage::EvVMovedPatch, EvVMovedPatch) \ 
+    XX(TEvBlobStorage::EvVMovedPatch, EvVMovedPatch) \
     XX(TEvBlobStorage::EvVPut, EvVPut) \
     XX(TEvBlobStorage::EvVMultiPut, EvVMultiPut) \
     XX(TEvBlobStorage::EvVGet, EvVGet) \
@@ -795,7 +795,7 @@ private:
     XX(TEvBlobStorage::EvVGetBlock, EvVGetBlock) \
     XX(TEvBlobStorage::EvVCollectGarbage, EvVCollectGarbage) \
     XX(TEvBlobStorage::EvVGetBarrier, EvVGetBarrier) \
-    XX(TEvBlobStorage::EvVMovedPatchResult, EvVMovedPatchResult) \ 
+    XX(TEvBlobStorage::EvVMovedPatchResult, EvVMovedPatchResult) \
     XX(TEvBlobStorage::EvVPutResult, EvVPutResult) \
     XX(TEvBlobStorage::EvVMultiPutResult, EvVMultiPutResult) \
     XX(TEvBlobStorage::EvVGetResult, EvVGetResult) \
@@ -850,10 +850,10 @@ private:
         }
 #endif
         switch (type) {
-            QueueRequestHFunc(TEvBlobStorage::TEvVMovedPatch) 
-            QueueRequestSpecialHFunc(TEvBlobStorage::TEvVPatchStart, TEvBlobStorage::TEvVPatchFoundParts) 
-            QueueRequestSpecialHFunc(TEvBlobStorage::TEvVPatchDiff, TEvBlobStorage::TEvVPatchResult) 
-            QueueRequestHFunc(TEvBlobStorage::TEvVPatchXorDiff) 
+            QueueRequestHFunc(TEvBlobStorage::TEvVMovedPatch)
+            QueueRequestSpecialHFunc(TEvBlobStorage::TEvVPatchStart, TEvBlobStorage::TEvVPatchFoundParts)
+            QueueRequestSpecialHFunc(TEvBlobStorage::TEvVPatchDiff, TEvBlobStorage::TEvVPatchResult)
+            QueueRequestHFunc(TEvBlobStorage::TEvVPatchXorDiff)
             QueueRequestHFunc(TEvBlobStorage::TEvVPut)
             QueueRequestHFunc(TEvBlobStorage::TEvVMultiPut)
             QueueRequestHFunc(TEvBlobStorage::TEvVGet)
@@ -862,10 +862,10 @@ private:
             QueueRequestHFunc(TEvBlobStorage::TEvVCollectGarbage)
             QueueRequestHFunc(TEvBlobStorage::TEvVGetBarrier)
 
-            HFunc(TEvBlobStorage::TEvVMovedPatchResult, HandleResponse) 
-            HFunc(TEvBlobStorage::TEvVPatchFoundParts, HandleResponse) 
-            HFunc(TEvBlobStorage::TEvVPatchXorDiffResult, HandleResponse) 
-            HFunc(TEvBlobStorage::TEvVPatchResult, HandleResponse) 
+            HFunc(TEvBlobStorage::TEvVMovedPatchResult, HandleResponse)
+            HFunc(TEvBlobStorage::TEvVPatchFoundParts, HandleResponse)
+            HFunc(TEvBlobStorage::TEvVPatchXorDiffResult, HandleResponse)
+            HFunc(TEvBlobStorage::TEvVPatchResult, HandleResponse)
             HFunc(TEvBlobStorage::TEvVPutResult, HandleResponse)
             HFunc(TEvBlobStorage::TEvVMultiPutResult, HandleResponse)
             HFunc(TEvBlobStorage::TEvVGetResult, HandleResponse)
diff --git a/ydb/core/blobstorage/backpressure/queue_backpressure_client.h b/ydb/core/blobstorage/backpressure/queue_backpressure_client.h
index 60fcdbfd0b..e6cc006a7a 100644
--- a/ydb/core/blobstorage/backpressure/queue_backpressure_client.h
+++ b/ydb/core/blobstorage/backpressure/queue_backpressure_client.h
@@ -33,10 +33,10 @@ namespace NKikimr {
         }
     };
 
-    struct TEvRequestProxyQueueState 
-        : public TEventLocal<TEvRequestProxyQueueState, TEvBlobStorage::EvRequestProxyQueueState> 
-    {}; 
- 
+    struct TEvRequestProxyQueueState
+        : public TEventLocal<TEvRequestProxyQueueState, TEvBlobStorage::EvRequestProxyQueueState>
+    {};
+
     IActor* CreateVDiskBackpressureClient(const TIntrusivePtr<TBlobStorageGroupInfo>& info, TVDiskIdShort vdiskId,
         NKikimrBlobStorage::EVDiskQueueId queueId,const TIntrusivePtr<NMonitoring::TDynamicCounters>& counters,
         const TBSProxyContextPtr& bspctx, const NBackpressure::TQueueClientId& clientId, const TString& queueName,
diff --git a/ydb/core/blobstorage/backpressure/ut_client/skeleton_front_mock.h b/ydb/core/blobstorage/backpressure/ut_client/skeleton_front_mock.h
index 5a06c04018..290c529ea5 100644
--- a/ydb/core/blobstorage/backpressure/ut_client/skeleton_front_mock.h
+++ b/ydb/core/blobstorage/backpressure/ut_client/skeleton_front_mock.h
@@ -33,7 +33,7 @@ public:
     void Bootstrap() {
         NKikimrBlobStorage::TVDiskCostSettings settings;
         FillInCostSettings(&settings);
-        CostModel.emplace(settings, TErasureType::ErasureNone); 
+        CostModel.emplace(settings, TErasureType::ErasureNone);
 
         Become(&TThis::StateFunc, TDuration::Seconds(10), new TEvents::TEvWakeup);
     }
diff --git a/ydb/core/blobstorage/base/batched_vec.h b/ydb/core/blobstorage/base/batched_vec.h
index 670ba5e994..f582e9d821 100644
--- a/ydb/core/blobstorage/base/batched_vec.h
+++ b/ydb/core/blobstorage/base/batched_vec.h
@@ -1,40 +1,40 @@
-#pragma once 
- 
-#include "defs.h" 
-#include "utility.h" 
- 
-#include <library/cpp/containers/stack_vector/stack_vec.h> 
- 
-namespace NKikimr { 
- 
-    constexpr ui64 MaxBatchedPutRequests = 16; 
- 
-    template <typename T> 
-    class TBatchedVec : public TStackVec<T, MaxBatchedPutRequests> { 
-    public: 
-        using TBase = TStackVec<T, MaxBatchedPutRequests>; 
-        using TSelf = TBatchedVec<T>; 
- 
-        using typename TBase::const_iterator; 
-        using typename TBase::const_reverse_iterator; 
-        using typename TBase::iterator; 
-        using typename TBase::reverse_iterator; 
-        using typename TBase::size_type; 
-        using typename TBase::value_type; 
- 
-        using TBase::TBase; 
-        using TBase::operator=; 
- 
-        static TString ToString(const TSelf &self) { 
-            return FormatList(self); 
-        } 
- 
-        TString ToString() const { 
-            return ToString(*this); 
-        } 
- 
-        void Output(IOutputStream &os) const { 
-            FormatList(os, *this); 
-        } 
-    }; 
-} 
+#pragma once
+
+#include "defs.h"
+#include "utility.h"
+
+#include <library/cpp/containers/stack_vector/stack_vec.h>
+
+namespace NKikimr {
+
+    constexpr ui64 MaxBatchedPutRequests = 16;
+
+    template <typename T>
+    class TBatchedVec : public TStackVec<T, MaxBatchedPutRequests> {
+    public:
+        using TBase = TStackVec<T, MaxBatchedPutRequests>;
+        using TSelf = TBatchedVec<T>;
+
+        using typename TBase::const_iterator;
+        using typename TBase::const_reverse_iterator;
+        using typename TBase::iterator;
+        using typename TBase::reverse_iterator;
+        using typename TBase::size_type;
+        using typename TBase::value_type;
+
+        using TBase::TBase;
+        using TBase::operator=;
+
+        static TString ToString(const TSelf &self) {
+            return FormatList(self);
+        }
+
+        TString ToString() const {
+            return ToString(*this);
+        }
+
+        void Output(IOutputStream &os) const {
+            FormatList(os, *this);
+        }
+    };
+}
diff --git a/ydb/core/blobstorage/base/batched_vec_ut.cpp b/ydb/core/blobstorage/base/batched_vec_ut.cpp
index 97c7623021..2cbcd98a66 100644
--- a/ydb/core/blobstorage/base/batched_vec_ut.cpp
+++ b/ydb/core/blobstorage/base/batched_vec_ut.cpp
@@ -1,30 +1,30 @@
-#include "batched_vec.h" 
- 
+#include "batched_vec.h"
+
 #include <library/cpp/testing/unittest/registar.h>
- 
- 
-namespace NKikimr { 
- 
-    Y_UNIT_TEST_SUITE(TBatchedVecTest) { 
-        Y_UNIT_TEST(TestToStringInt) { 
-            TBatchedVec<ui64> vec {0, 1, 2, 3}; 
-            UNIT_ASSERT_C(vec.ToString() == "[0 1 2 3]", "given string: " << vec.ToString()); 
-        } 
- 
-        struct TOutputType { 
-            char c; 
- 
-            void Output(IOutputStream &os) const { 
-                os << c; 
-            } 
-        }; 
- 
-        Y_UNIT_TEST(TestOutputTOutputType) { 
-            TBatchedVec<TOutputType> vec { {'a'}, {'b'}, {'c'}, {'d'} }; 
-            TStringStream str; 
-            vec.Output(str); 
-            UNIT_ASSERT_C(str.Str() == "[a b c d]", "given string: " << str.Str()); 
-        } 
-    } 
- 
-} 
+
+
+namespace NKikimr {
+
+    Y_UNIT_TEST_SUITE(TBatchedVecTest) {
+        Y_UNIT_TEST(TestToStringInt) {
+            TBatchedVec<ui64> vec {0, 1, 2, 3};
+            UNIT_ASSERT_C(vec.ToString() == "[0 1 2 3]", "given string: " << vec.ToString());
+        }
+
+        struct TOutputType {
+            char c;
+
+            void Output(IOutputStream &os) const {
+                os << c;
+            }
+        };
+
+        Y_UNIT_TEST(TestOutputTOutputType) {
+            TBatchedVec<TOutputType> vec { {'a'}, {'b'}, {'c'}, {'d'} };
+            TStringStream str;
+            vec.Output(str);
+            UNIT_ASSERT_C(str.Str() == "[a b c d]", "given string: " << str.Str());
+        }
+    }
+
+}
diff --git a/ydb/core/blobstorage/base/ut/ya.make b/ydb/core/blobstorage/base/ut/ya.make
index 4f80e3cb89..3e223c0bfd 100644
--- a/ydb/core/blobstorage/base/ut/ya.make
+++ b/ydb/core/blobstorage/base/ut/ya.make
@@ -21,7 +21,7 @@ PEERDIR(
 )
 
 SRCS(
-    batched_vec_ut.cpp 
+    batched_vec_ut.cpp
     bufferwithgaps_ut.cpp
     ptr_ut.cpp
 )
diff --git a/ydb/core/blobstorage/base/ya.make b/ydb/core/blobstorage/base/ya.make
index c4e0999b94..a5345d772a 100644
--- a/ydb/core/blobstorage/base/ya.make
+++ b/ydb/core/blobstorage/base/ya.make
@@ -14,7 +14,7 @@ PEERDIR(
 )
 
 SRCS(
-    batched_vec.h 
+    batched_vec.h
     blobstorage_events.h
     blobstorage_oos_defs.h
     blobstorage_vdiskid.cpp
diff --git a/ydb/core/blobstorage/docs/blob_patching.drawio b/ydb/core/blobstorage/docs/blob_patching.drawio
index 2e36f8bd60..527f1c8708 100644
--- a/ydb/core/blobstorage/docs/blob_patching.drawio
+++ b/ydb/core/blobstorage/docs/blob_patching.drawio
@@ -1 +1 @@
-<mxfile host="drawio.yandex-team.ru" modified="2020-11-13T11:22:48.503Z" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 YaBrowser/20.9.0.1697 Yowser/2.5 Safari/537.36" etag="Vvx8akMHjgNF9RnE2p6e" version="12.7.0" type="device" pages="4"><diagram id="oeXZIZbNdJ13JvgRRL20" name="General">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</diagram><diagram id="uKXmrOIFqc6csMLveKSW" name="Block-4-2">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</diagram><diagram id="XSTu3f3XB3Kw2yURKv7b" name="Mirror-3of4">7V1bd9rI0v01PDpLat0f7eA5k5PJZcaZZOa8nIVBdvgGGwfkxDm//pNADairW0KAuqtFZdYacxXQe6tUXbWrauC9fnj512L09PXdfJLOBsyZvAy84YAx143D/E/xyM/1I7EXrR+4X0wn5Yu2D9xM/5eWDzrlo8/TSbqsvDCbz2fZ9Kn64Hj++JiOs8pjo8Vi/qP6srv5rPqpT6P7FDxwMx7N4KNfppPsa/krWLR9/Nd0ev+Vf7IbJutnHkb8xeUvWX4dTeY/dh7yrgfe68V8nq1vPby8TmfF4vF1ufv4z3+uP7++fljETx+YfxUs3z9crA/2S5u3bH7CIn3MDj608+1q+vfw5Yu3vHqfffhl8fvfsy8Xfnns76PZc7lgw5uPi/nLz/I3Zz/5Qi7mz4+TtDiYO/CufnydZunN02hcPPsjp07+2NfsYVY+vVkrJ79TfkS6yNIXAZSGX+RuljnnZzp/SLNF/sWc8iieH6yP85Njx6H6sUV689jXHZTD8rFRSa77zbG3C5jfKNewzXp6YD0HLBw9FMvzeLss/nweTpf/uGB58xV7Km6Of86m+Tovmtf4dg3Ib7ebB0bjf+5XMH14zvKjpOXjd9PZ7PV8Nl+sPsm7C4r/CpCyxfyfdOeZcPWveMf8Mdt5fP1PF6wuE2BlAYQ1lKAadIZqAFBdocgIRTWKCToUQwBXOsmvFeXddHY7/3G9feBqa/CKdZovsq/z+/njaPbbfP5UYvJ/aZb9LK95o+dsXoU2fZlmfxVvfxWU9/4uD1bcHr7s3vnJ7zzmP/Wv3Tur97yKAn5/+77VPf7GNQ34JY6V8JffzXUggSZBGk98GYFiduutCCQhSrFiFZos58+LcVq37OWVNhst7tNsj2vRocRbpLNRNv1e/XoyFq3eerlYjH7uvOBpPn3MljtH/lg8sOUzA3x2HYGS60NuCbr5bkdwNpJbHo8sj9LysBCd5YktsDx4DUii0y6AE98T6eTGAk/Wlq1825YqbS0M+CDBwsA3ROIbHB0mKZGbJJ9Mknqn4mEzSfzAqE3S1hna8X/+5ge00RkKeAgEjTN0HItg+GBlCwKyBUpb4DvobAEMWqxQhPslQnGDIrj2GkcRXoARW/SNBf97ewQrDXqAzaAf5HsGRlzJQBFXi8jwKA1PIAa9zRseq+JqguFh9lqefsTVQpDESXRYHkVcDQZqyPJskHLRWZ4YoKjE7+Hlvkhwv7p9enh8VT64i1qxXtNxboVGt+ns43w5zabzx/y523mWzR/yF8yKJ642UO4Ct/q3c4zL2fS+eG9WGLSrUXlvnC/+ij9P6WKaL0BxO7eOs+nTMv24fehqvibJ601C3Nk+WBz062L+Y/p4X8D+8+F2XvyAh+ciob6yrhUqQCaN4/T2Dpg1CRsnozS+G2vdByWQTp6ETl5ndIKRLaKTLXSCUX/TdOKmkOhkIZ1gxNY4nWCsrf90Go+y8dce0Anu2ozTiRGdrKUTdMWN08nHTaeH6WSywhgToyZRcuvAIINsb3iXhuNOGYXPQMHgIDHKIkYFkY+NUSFuRuFzyBHRycfnkMMYItHJFjpBsZVxOlEw0146sQTbxS6C1smeyh435lU7P7kzobGyJ777PXz46fyW/eIMkz8//JFObrwLZoWIV1U+0JzmrJ5po0UlxZk+Tnbvts6J7pHaWi8uSIPuR6Q90qVRCV9junR94uhOg7qhV2V8GGhIg0ayaw6Vq7WzVaFTRS5yoK3qKi2qMFVQQIPPVJ3Y4qgsX5PhQ2ipEq2WCpqiKBBMUSQw9UQFD24knDmhr8PmKeoX1N422Th3QwE8Ni6xwMYdXs3ZqTu2h0StayPHa6iwumORQPgw1GCa+KJQtWcL0xT52EyTFbVV/bcw+5ZaHW1hjorT8K9J5ZRtwkMuunMebpHP7ZxHsHWKmR3nPJOf81rLJitkOJ0B6O6cj9Gd83DLiO+cVxW+GN6CYDAWHu4tSBLLwzDdbkGoFviQVlfoTBPcMtpjmig44qO2TMwRA8RagiNQYUrFwk2yBIehs0w2tykwnEbHYJr27XdgyDS5AuG1pNFjRR8DrdXElu3nmJOYM01yFEkebG9FDEwD+JBOWgV4McmDLaYTiDAbp9M5yoP7Uq8H/XDTdEpgvmLFmXezN8P87mNYeAv5I5Np/ruH00WOzpoj6WiZrZdeTbUG0Gs9Fa7U3lvt/apKmdzpfpyMFpNdytynj+liNOsOXTH+YxxdGP4hdA++FGDzLBK4hSZ0D/YbRWWbRnSlERJZ15BwlpVbtArs4bfnOX/iYrmKG1zmL3D9p5ftk/mt++LvTZY+5U8Ortkg9gdJ6K5ffJM+TvI/f4we79P875vlm3y7+fLhcVYs0ud/5Xt89nq9zMVnuxch/zb5j1t/ofXhASVzoLKq2wGcA2VJ7SLNf83odnWogiLltj8/bnA1CIbFsZ6z+bKMlGiLpnHNYUkVJilK8WRFKawrrhhLQO5G0sqo2D5dnCtNnLfRs7077yncthrXb49Oe4fExqRo8C3DbmxM/kIjnfZcocTfO3GjPelPNZaHqjCUCNqSoMwEQZlrgKDG0hEVgkbE0JYM9YwwNK4y1D9xl2TpT4WqMF0JM7abMXOJoe0Y6ptgqBcIDD3xlCrpTzXXADoihh7B0OBIhh61dzFVo+oO6MJ7DGlCE2bNTwy4hqYaPlQZSgRtSVAjwpMgNEBQUyWwVYJS+KctQ2MTDA2FBmperIGhLoxm29OFSOwB7bkw3qu3CZEr6wFN/VraZXyEKJMvSfholcS6DIBKDSkak7LYQFTUzVDpfk0+TYxVGAdRUWJAtdg1F0mGDUSFGJtmktaAmGADEWqxqQyxqUNyiA1ExZA1qthSgxh42ECEumOalNc0TMFBBiIjxeDpzKx4rYwhuFoFgwx6NgTuoWeuaH6Ngws9HgL30KCBjw1c6AkRuIc6TqL3axxc6CERuIdec8Ugg3FwYeqNwD00+CCGAU2Dyw9M4J4gxisG6o2DS4WPpwNXTKUZBxdp3eM+UgVs4II8qXFwkQYxrAQXnVlGGsSwEVyQVzUOLtIgho3ggnyrcXCRBjGsBFcYI2geXKRBDBvBBflZ4+AiDWLYCC7I25oGl6ccCdwTZIXEfK5xcOEMM4tk1UI/HfOzXSNzBYw02rWBRnsUXnDZRGPhxfq00V144Yrdsk/ckrZ2TahS4IggCbbm2ZG5VgDH2ykyUy5qM8XEztknbupfuyZU+9Jm3Ag2s2RVS3/BLJ3VKFb5Ochw26XEhF1icrtE5Vw1aYcQm10y1WIEz0xGDOZFMmatG/NyFFkCRQEn1f7VFchjO+NNtWw5zBPZcT42/avO2hORzD3DaCoUZcJUYVqT/HKwmQpTzXNoeOtJTIVkDhmiTUvgmNi0KCrfqWi6xi6J7f9N2yWeWrTSLlEsJcRtlgS260lFKXo5UBuAGjmJOHPGuFmCiUJ7zNJZjW2Vn4MRarsUCnTn97u1S4r2JNTZokYJJY5FNG2XAqQaRhvLucSz0PgorJBq9U7nUWCbcxbCHD+Be+guVgzEGwcXaSGmjeB6Yl7VOLhICzFtBFdUNxgHN6aBWJiaynN6NG7cEjMDsYRmaImnYeMWm5PB0kSsYyhqZiKWUHaX6IgtxDQSy06KGh2JFdPEIStJY2biUCTYNabDrplSTdDIoeMoambkkNBwM9ExjJKviaW1sdUViyXbQb21sQmNHDpBIaFwHkgqnrVmTRIGQKWyq8ayK2wg0sihA2pUsIFII4eOnstnHkQaOXSAIBwbiDRy6AD1LDYQaeTQAVpDbCDSyKEDhFnYQIQtqpTwSRPBO6AVyzUdj2a/jW7T2cf5clrmk2/nWTZ/yF8wK5642iBZyQkX/3aOcTmb3hfvzYoA1NWovDfO135Fn4b0c5krfj1/fEzHWYnpNoGcfV3Mf0wf7wc7CeSH51k2fVpFwwSZ6Z79z2rCULouzq4jGX2sNS3tOjCsQ3yyhU/itgsDn2RxLeKTHXwSd4AY+ARDav3n03iUjb/2gE+iC4yBTzC6R3yyhU+iN46BT0gHLNgo2hTzmhjgRdqF30Z4RWUFBnhhSGTAwllWhh0qwIffnuf8iYvlSlhxmb/AZU8v2yfzW/fF35ssfcqfHFyzQewPkpCtX3yTPk7yP5+uv38sTLKY8eWfnf+Y9cevDwYomAOTVS9F4IIhXlceppPJWjqS5t99dLs6VEGJUmyQHze4GgTD4ljP2XxZll0OYBWmmYS9hCqbBsC7XGHdcYVK4k4Gr49vo8G/AMF7grMXX1zCpZrHk8ErVidggPcct3V9CTuBJmami7VcF8pHiE620Ak0zDVPJyhkITrZQifQjdU8naCkpv906ksME7SgMk8nKO4hOtlCJ9A5yDydYEzNnkKRhFdi8a2N68H11Fsp4royyQ+VirTCNQoFXDd4mRJybUhExSL7wxh7+GC0qoPj5s6+Da87aMqotZTT5c5MYy1neeHSXcyZAErrKDjeLAtVObVwDhx81gfihc/69MCInKTFChxh6oiM2gyh4wdZm63yfVu2tB6WCj5JMDOSd7jiO3SUmZdLTZV7rQxThM8w2TVTte3IoNajPeJxKk/z3caBHyh0FV1atH076h/vFh1JJEX9oNEi0IPQ7KB23vHxnfiKUkGq96zB0QXXWvM4WjXzre3AFPs90kSb/T7M4WSG3EcYLKVK5UbzI0a9zZsfHna30vw0D0ax3v54Lnb7Azjt6LA/fF2oyL5VHy989ocEhfYmxUGg1pPM09GbFfdIUWgxn8T4GgI+naOksC+iHehwIyAUiQotJhTwoBAQCrmscFMRiYlTqqIfiVPPC4e64xRCIyWr1yVOWcQprg7FwykumMXKKXyeOSZCAV0DAkJRCyx7CZV4+AxUi1DU3Sx9uVwsiqUu5muXN4fj2Wi5nI4HakF9c0R6cExIGa73znLK+jjwx45UWEVCFmrTv5MfYh3pBvoqKNPkcu2NUkuMPSqUWieLLPuyCFLLXiW+rFfJ5+Gbm7f5s18ub/L/X/3x4e31eys6kXRlA2KhHlla3+7K4tHddR+JjMnMBzrmR1ZN0WhRwTk3ZJUGNK2TZ83jhY4ybvvky3g/m+Z8mW9k7FUc+VXO+5GOdJkPw5gWFYslwpp5sfFiMV8WxqNisXbFYuK5EEjsv950pK9Q1ak9QYIx9vHBqFAnUdVNjZV10cEYKEQeVKNQV1mND0bFpC+Slhd7ngAfXorSIJKW16WaGT4cFSUdpNGtw1HcbCDAkQYKHZABC/HhKGswQgkLO6Qf0D0OIJ/0Jiw4e4lPNvIJ+Onm+XSOCdXeSNOg42KeUIwIZS+hoAdlnlDIq0VIl9bEKYRGCnnFCHGqiVO8ORMiTp1j1UhfpGmug3Crd45VI30hVOKjM1BcnkdjWo6HF0h6EMAL/WSb5D6C1Dw03xs6kopCSe7TTu4j4BoZ7z6QwKvortpzK+fsqAVKXOmB8sppUH3md3YMKSYl6Ph58X1jRNrb9DUKHcpCo71loZERWWgiSqEjr23bUOEdHQlJI7izIYFco0AOneGLFNIAEsjVZQDxwaiQq5JAri7xhg9GhcCDBHIrgRw+vBTyYhLI1Qrk0OHIy0hIINcqz4wPR2oGeEh6Fx+ODOCoRJCi3ENcegHgHsfGK/pj5HIB4lMbPx0Bn5BLBUjP1MpxQUCoc9QJ9IZQwINCQCjkOgESMzUK5PBxihpMWs4pFqPjFPIGk/g8c0yEArlHBISi2jp7CZX46AwUnw9KArnj4Y1F4Y95eENoLi7HWb6UKpvx/DBbv6BL87Bjg6Rnfv0J/csvjqM6oXV19BNLhiJJ0bUM6e6Ue4nNUkjXcYQFjSO4oJq1kAlpIY/XQgrVv8yRmETNWkiFJEjtRxGMcYAPRoUkiJRdNf4nwwejQhJEyq66wgF8MCqUQqTsKpybEBtefHYlKbtaJdY8fDgqFEGk7KqLEzv4cGRyHEnZVYdjhA9HUuLYm+iG7rG/X1Sns/jdxlIRn2zkE/DTzfOJhDj28kniuJgnFHIhDhGqnQdlnlCkwrE6x+16CI0UchUOcarJTnkeNk65MELd3FKj0j7ihP01dttr8GfaTVRzB2c+UY3xwa+NrTOYq2Brt60zXMerykuKrPkuj+EMtqT+Dd20ztgsJFZri2/PisnUOviCIFxbQ4SykFBJgO/SDRU7pHk8EN4YCHzMwwtzKaR5PAHSYhVYsmf7x84UesyF8gIUJ/Ie7iy+ExlMtzTd3ZO5UI1A8B4MLzZtOnOhSIHgPRReINA0fxmGQTebBOlca77ZOxtvzstc2caaBOntThShAekWL2OaER/itRtJTGe38x8d9eWttOXdM264GzXcCSKaiRsGaTzxZWyL2a23Ytug67ghtwF7xA1jOTX1ttxl/Bt3GwXky0JlFm0KCNEZJ/7LqMyiTZkvPhhhTITKLJrL//HhSCPma/CK8eFFI+YPqLMI8OGoGAdAdRa1/Xjw4ago/qU6i9peXfhwRK4SxJcSRiQ7Bf6xZzwWzZArBIlPrRx1BIQ6RxFUf3TxoudinlD8yEQoKwklulAICAUje6gIRaL4pkILhEYKhhmJUzZxigkyEQycohJoiwnl4NvreedYA90XQiUhPgMFY1GkNz4e6ZgPDdlEHU33WGXeOW7q+xIliqNCrYTMdvjnuKvvy7UoThKEjGqxBbubpS+Xi0Wx2IUUr7w5HM9Gy+V0PFDLbpuFeuvPPFB2B1d8ZzkDyXLyx9op6YBULkyq/fl9JsC0VgOW79oiBWt1g9B75e3+qxw3SITjrrWD4LgnE+P5srZk4SwrgauwI/z2POdPXCxXkF7mL3D9p5ftk/mt++Lv8PJT8eTHyz8+5X++XN7k///tw80nfvT8664/YP1ywMT8jMyqPAO2RrmHX6T5txvdrg5VUK4UQubHDa4GwbA41nM2X5ak1Oi5uI5Q8+hL8qVuJOGxyLcTmoVz3EX3JXzMHCF8HBmv7vCRlt7ZWEO7rSNBA28M9b2aahIGOxUJryJeoNCumcm2DOFcm5kE5enZXJQQmmlmEglaTV5M3G1RQlzftKfLUhu2f48eoucOPT0j9IwFCSqXLHVMT3hR1UNPd7Brdcnods7qxASrmRMaYTUUu5tgNSNad03ryIgvsS3N5rTWUuAYwDSiRfXtsbBmsaTbh+by9kCm6aby9na4hoIUNokhrnql+oFiNJA6/kQwumHsIoMxpELg9jBG4jbCPIyKAlIqBK67WDJ0MCrqEbXWAdfGYQ/HtDsYE3QwKoZYUnlwDYyJuIs1D6PCxaHq4LqclrhrMw5jpHBxtBYHW2ZUNz3FEcHIAIxKAHuT6u6LSg+4zNtOfMaSoREN9bOYUKLzjoFQJMaxl1DAccFAKFLjnBDfEB++SDth24gvyO1jwBdpK2wr8RWlRRjwPcf2Mr254ItbXAyESshgnA5ffA4dN2GE7ykuCC46fBMYUrBKPBIIC5rABdWsHklke2pSj7RVjwjAMsmZojeamygynWoHinB0Q665RIOjJ5n2Y8+Ui4jGXCQlo5pVoIkZyX4k9ItweYVltzLQRNFRmHRRtUkefNcZhRSDhFG1uRV8OMJQCymjmpVR+HBUaGpIGlUrjcKGo+dC9Qw+v6/37lvZl+ZYpwx6XYl4Jd9s+xt6mxxQvCZ+UqLBv9s09CFtX6sUOT47BCPm+OzQZv/pVvef7Oz3n55TvhLr/pO5Iue17D8360Ki1VYZPXT2yWEARyWCvUkR90ZkCAMakpZfWlNMnkOqVYsJBSMr5glFqlV7CSVxyc0TilRRFhMK+lDGCcV1HqSaOYVLA7QA5vGFex3qtH8KZ0MY0rHZuhprte+557gd6ssYIRirRWA7znE71BtCgeAaAkKd43aoL6MboFrIPKEk/NnNUGxTEBrSFPUNalW9EjdZCz1ZivHz4vtGGI2vcaLn7ts4sdy4aJfMxZHg93leJWUhEdmJpRLCOzpKcrhQBEy21hpbG+MLjjOkkYI9zBa+SEGI8Fpqd32NuB/3ZANktNbXeIzqa05wpoi9SHxJ4ZTevHMAAdPqdcYVdcwrp6FLd35nx5aK3qhbbd1dHq3GI13dEw+o001FoKxhe7upzEjbejfiM+02Z03Y4KbGfFKn4h0duamMatUOsImJO0BmE5miFoRqeuoiKmLbHAQ4KmoIqKantrgbHY78G1FNT5taELFrCQIcFVpVqumpw1EM0iHAUdFEnmoi6nKi4qYeAY4Kf5W043WpSLGbDAIcYQ26EkEKjw9xCemg4xx4kFB6w6eebBQTEcoSQgEPHgGhSOprL6Gg64KAUHBrT4SyhlDAhzJPKJ+0xR3lMoXksL/ncPvuUpk8nUC2w0I1CXPEeAgC20HaYosJ5eLzbnzSFttLKDdK8BGKIkQWEyrGFyHyz3FD35sIEdBcICDUOW7oe2OhIoaOUJKZK/ZIgD0fzByRbJs1S4Aj2SlKEuB2wLridCJZrbXe9CH/RiRbbIEjC1x0ONZLuZG1ONzcoRb7HL/yhGsWYq+vbbqF2J4nTs7jF6BuZdV8XUiO28I+eWKpCQL7BAHDZ5/OwMz42szMkXyBUVCSbzee92LwEcF5r5AZkny7bgMoxvwQ4KgYdUPy7RocA1GMpRPHD5/fzt9///bl8vrv/7z+cZ1/ztWPC0aX4bt4nMob8t3GgR9sCdHlZThG7u2HgLl6vH3FAB+jxQXNfNFjTUIxLIjgqkCDFQ62Qxi2A9xfRGuHIsB5LXYoUURFqTimzj6J4izz9omnOimxaGGmGoaxmAsJpTexmMBwJBHKHkKJ8REEhDpHtV9fahngJQ8BoWBkDUV3Oxv74HtMTNgjwBcG4qhW5RQxV3GkhSsZC6a3VkUyzpiuDbbI4uDWFYHtIJ2lxYQCCgzjhNoIFalteT/alvt7T1ot/UztAUEfDIOIKwFB+A4G5ttX39FNCNGXzGYlW2uNrfXRhZ58B/IHxcbOxrblHjN5LZVn5qGySU8qjd/eleK2voxuL5xGUmlar5xS+CSJNOnrzKTRAnEml3/i0R11a2JrEY6wZJ7OIhzpeso8CirBaVuCI54JpiVZ9Yos6sHfox78Uvwlimzp60IjVw7PiYTzxW/Yb/l8VrjiHd1caxRycfWei2xh7gSHyGyhQixOxT61KglsVzSFVJxKN2qlCdhQVMzBoMKN2sINbCgqBNVUtlFbtoENRcUsE5LFr2Tx2NByYeCD1MPNUip0MFIGx2JpHnCLA9MRfpcRnyzmk+igm+cTSYct5hO43pnnE4y+kLL0FJtCMDRIo7JUjvQ5jnjpkbAUneU4R6Fyb7ROXoCOT6RTtphPPrqdF4MBGeKTNZ4ySFOa5xNFhiy2TyxGxyeq2TwdvEDraB5emG1DAa+Vym2QnDMPr93N5sXoRChZT706V0a95k8gdBV7XUQS/bJeoSvMf5BGr9FZCV1sMMKBdyTSa4yxiP0UdcL47uLH8Nd319/+/dfN9fTu+/Ttn6PRhQ99zg7qjVaHye/yHcpgj0Lejei89z265efXvoJwZqaWyAdUdjTouz2FwJtEpbU1TOh8AGoHfgCMYpcp4zAG0Gezp+/rWU2bkZ+FIe5LTAAIr+USQy3uDwjHiAOUjdsmT1G4QGLpQnUkRnvMw6WoUCCxdB2MYl9C8zBSyt7iFCsMT8SQT1qD6pzPxCcb+QQ3nsb5dI4p+/6IpcH1zjifYBSc+GSNBCQCbrBxPp1jMUdvJEWeOLDPPJ9goJX4ZA2fYI7FOJ9gcIz4ZI3/BFUExvl0jiVIvbFPLMHGp+Ac4wW92d/BLIJxPlG8wGL7BBOIxvnUIl5wN0tfLheLYqmLbHN5cziejZbL6XigFgk356LXn3lgZhmu985qBpLV5I+1SxeDfHD+rwpnIsK0zniXb9siJWlnKRoaxxEOtc6Jg0OdKskcyPb54SwrsaoQIvz2POdPXCxXKF7mL3D9p5ftk/mt++Lv8M3N2/zJL28+/Zr/ef9hePmpePHHyz8+FQ9f3uT/v/rjw9vr9/zz8u+//sj1AQAd85Myq5INmBvRKj1MJ5O14CPNv+/odnWogndlyj8/bnA1CIbFsZ6z+bJkppKopzcNLBB00YkDLQNLJGRmJzAN4+niV/bJeZtdsOX/vv3u/37/+dum+sfK+gEGLt2ezvoB+YLK9qpUP9AOVzB81deYYpbDCiUB1ClbW6fsPSQsRzkXVdmanAClxmBXtiZ9oafgdreyNeb7TDhl3IpsDb4j4LIJxTuOFrrVriOqQhwkCinmiaEN43bPg6ENKrhpgtEXMzLmYYQRBapgaPQuxUSIeRiZHEaqYKiBMRT1QOZhVFQxkti7DkYxrGYeRkVZmFGxN3YYI3HLbh5GRVkYicBrYIxBX0njMJJIwN4knMRl1pg0kfOJRAIW8wn67sb5dI59SvsiEpC4Lcb5dI5FT73hE/SfTPNJUvREHdhPcSXyxVm+yX5Id5aipHIki+VFLAJxEOOWA0YliU/W8ClG59mcZXlbX+TZzBd7P5rnE5W3WcynAF1kSFI+YpVmTuxhLJl1qFcz58tCI6SZa6uZE3CNJOJSrRF5SVkMSX22Up8QG1wKjQhJfWrzFujOOrgbI6lPc7oAHYwKjQhJfWqlPuhgVGhESOpTK/VBB6NCI0JSn9qcGToYFV1WSepTm6pCByNJMyxOfUKXWSId0xrQCc5RmtEbPkHf3TifSJphMZ+g22KaTyEMpBGfrOET9J+M8wlG+kjqc4orEfd4N+MMg/2Q7iyzEsJgIFkOa1KfEYiDGLcc5yjN6A2fYnyeDUkzLOaTn6Djk+E2LbtdWvgzDQPCyjfxbiybeWF65oPVdV3ZY0T3erW767rCQ0WNXVfCUE7VjruuBOJsgLip64onyndjHV1XQurIbbGdDdBFTEOYv1yR5t3szTC/+xgWNi1/ZDLNf/hwusjhWZMkHS2z9dqrudaAem3+hGOxN56vqpzJLerjZLSY7HLmPn1MF6NZZ/B6ATp4YV4TBbx7XJEQwguEecbhhfFpmwSsYpQllkRZ9ApYedsu6g5oojug3qG2UgJwp67RT408I36qFwuN5ZKgwU8N/KT2Hd34qXwdSQl+zAVH7H2QSComtAo2IoW0WL0JOSMluO+I56ZxuGDWgJTgjTCKG3vzMCokxKQEry2PQgejQkJMSvA6CbHYX8M8jAoJMSnB62AU46vmYVRIiEkJXpfIFrfs5mGEEmJSgjfmj8WxDOZhJOWuxco40WVmDoN80hoZjc5RudsbPom+u3k+cft4VnzqjXJXdFsQ8Ilat1nMJ9F/QsAnGOkjJfgprkRiSn8zNdKUEjwm5a7FCqAoRmc5zlG52xs+xfg8G1IoWsynwEHHJ+oRYDOf0EWGEugpE5+s2Xl5fAAiHj6doz/eG/vkhej41MIfv5ulL5eLRbHUhRKzvDkcz0bL5XQ8UGt6m3Wa6888UGgJ13tnNQPJavLH2qknodgx359X4HRdXkjGD7JWgJbv20IlmcMs5sg8XzjUWiMKDnUqCWUic6TDWVaCVWFE+O15zp+4WK5gvMxf4PpPL9sn81v3xd/Pwzc3b/Nnv1ze5P+/+uPD2+v3/Mj5N10ffP1SwLz8/MuqvAKWRTRAD9PJZK2TTvNvNrpdHaqgWCl2zY8bXA2CYXGs52y+LEmoM8rjiZNFmRMDK+DKEqLsBGbgz//+Pr++80fx4tfwIfntz//8NwdRqp9tBz6TgX+TpU/5k4NrNsh3/knI1i++yc1H/ufT9fePxdZY1OpaQQ8tEgg3FqpANgOAdqkis3GnoMq7ix/DX99df/v3XzfX07vv07d/jkYSqthTBOKCUvZQtp5dFYFI11OWmiHpejtYw31qpbpSmEhRVWho1c4VoeiGoLe5aRQVEloStNegGO1TdawVRQZt526ZXTq7nf/Q0NhhU1Anra47ceGb0Vo3KQqSlgxq/+KISrejqKIQW1PpQ51PtU8jTa0nvEJrTZUPNSgmoAe+aRQVUmsqfKhDcZ/Wb1pRhEprqntoChA5+zRc04oi1DdT2UMTiu4+DVy1oujC2I0SQEoeDXElIyUbK40TDeV8OkdZcW/4BP1243xiZ8in3sjUoddinE/nKJboDZ+g/2ScTzAeTGUPp7gSgQb4yX5Id5eUO0dZcW9k6g6Ighi3HDAkSXyyhk8uPs+GZOr28smNQAN843yihhgW8ynGFxmihhj27rwkQhzTfGIUubbYPkUMHZ9gpNEeFStoE7BVrBpTsTJZHQnJWNuWmwm4MkmLer3SOYUgSm19z6oDc4gNLoXyiQSrte3ksJ11PsSLBKtAsLpahvwx7osNutewsjLs0ihiXfsXR6hYV29tP1cMULkMZJ9q+kLtqpBqtlXTQWxWhymkeiSbrYExdNHBqNDqkW62DsYYG4wejHiQcLa58yY6GBUjbEg5W9dmjKGDEcaLlABS/HGIK54t2eHtqS/pLP7onaMyrTd8gr67cT5RW02L+QTdFuN8Iv2bxXyC/pNxPsHANClnT3El4l7wBmlnP6Q7SwR656hM643SMQJxEOOW4xyVab3hU4zPsyFlmsV8ChxsfPJhnJb4ZA+f0EWGfKqptnjn5XmiJMg4nyhybbF9KpQuyPhENbBdIO35YrVzhzWw+d3FvOjTvHnuX8V5/24+SYtX/D8=</diagram><diagram id="3A1HNBjYupDa6VtS3OM_" name="Mirror-3dc">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</diagram></mxfile> 
\ No newline at end of file
+<mxfile host="drawio.yandex-team.ru" modified="2020-11-13T11:22:48.503Z" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 YaBrowser/20.9.0.1697 Yowser/2.5 Safari/537.36" etag="Vvx8akMHjgNF9RnE2p6e" version="12.7.0" type="device" pages="4"><diagram id="oeXZIZbNdJ13JvgRRL20" name="General">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</diagram><diagram id="uKXmrOIFqc6csMLveKSW" name="Block-4-2">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</diagram><diagram id="XSTu3f3XB3Kw2yURKv7b" name="Mirror-3of4">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</diagram><diagram id="3A1HNBjYupDa6VtS3OM_" name="Mirror-3dc">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</diagram></mxfile>
\ No newline at end of file
diff --git a/ydb/core/blobstorage/docs/vpatch_actor_protocol.drawio b/ydb/core/blobstorage/docs/vpatch_actor_protocol.drawio
index a1e5344132..d3fec9c423 100644
--- a/ydb/core/blobstorage/docs/vpatch_actor_protocol.drawio
+++ b/ydb/core/blobstorage/docs/vpatch_actor_protocol.drawio
@@ -1 +1 @@
-<mxfile host="drawio.yandex-team.ru" modified="2021-05-13T12:45:24.063Z" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.86 YaBrowser/21.3.0.740 Yowser/2.5 Safari/537.36" etag="wJ5mePPJEHiOP22e9T2I" version="12.7.0" type="device" pages="5"><diagram name="VPatch (datapart)" id="13e1069c-82ec-6db2-03f1-153e76fe0fe0">7V1dc+K4Ev01VO19COVvm8cQJtmtndTNhsnszH25ZUABT4xFbDOB/fUrG8kYSVgmtmyTYR4ytmgJ0zrqPmq15J5+s9zche5qcQ9nwO9pymzT00c9TVNVx0L/JSXbXYk9GOwK5qE3w0L7grH3D8CFCi5dezMQHQjGEPqxtzosnMIgANP4oMwNQ/h2KPYM/cNvXblzwBSMp67Plv7tzeIF+V2Ksv/gd+DNF/irHRN/MHGnL/MQrgP8fT1Nf07/7T5euqQtLB8t3Bl8yxXpn3r6TQhhvLtabm6An+iWqG1X7/bIp9lzhyCIy1SwJ+7EVafGZKrZz8ZEudJ2Lfx0/TXWRU+/vp7GMMQPHG+JktCzr5LL9dL/7D0D3wvQ3XAFQm8JYhCiT3xc/LAvG74tvBiMV+40qfqG4IPKFvHSR3cqukQ9GruoSpjd+767irxJ+q0KKgnBdB1G3k/wCKIdcJJSuI6Tb7rJAJGKJh0BZripTNdK2u7Sm+Jr350Af5j13A30YfL1AUx/UBSH8CWDQdLQM3rGW3fp+Qm6v4Jw5gYuLsZQVpHWhq7vzQN0M0V9kf50tnNwf/0EYQw2uSLcWXcAIrWFWySCP9UMDBw8sBx8+5ZDKQHpIg9QIujikTHPmt6jA11ggPDBMvkR/Plmju7ju+1LaLzOh/+/ur3SWcDQQNl3gyIGAKukoxgtrTXDPFCaqvK0xipNk6Uz0vA5KU3X2laac4ZK447PBpVm2OenNKttpRGyck5Kc4zmlMY8PMcHXEhDd0iDqXWNNLRglfRTtUaTBrNlq6Ra56c0rSRpMKWx0xboaVWlGSWVpktT2hkOT2NQTmmGNKalnp/STLs5pTEPb1xIQ5dJg2V1jTSoGosY2SPMOFVtNGsoOcKkOUC1hVlzVaVpbStNN89PaUZJfirNAeotzJqrKs3U22YNZ4g0q2T41JaltIHK6AjM5mCMb2EYL+AcBq7/aV86PNTiXuYzhCusux8gjrfYr7rrGB5qFmy8+Fvu+nvSVN/Ed6MNbjm92ZKbAP3erFJy8z3/yb5Sekdqle/DCK7DKSjhM2M3nIO4SKe4xUSRhZgIge/GiBMd0ApeF+OqD9BDvyLDkk2xCnpk7R4UV9rj5DoM3W1ObJUIRMe/xuS74dsj4tmKwDvl7YFJoXr3wHuMZxqsAHsOY+66rSCKERpYs7qtYB6eQ30uM4zuzDCy6UN3ZhjNDzDnVK3RA6xlAqO1EGCrqjO95FqJNKVZLUzKqgOtufi3/mTe+NvxS/TtQZ1/eRuOx+aXcxycjtWczljXzSYZjMYPIdxsH9x4ujjqAgMYA7H2sLtSDXSd6Mebuv41dhJxwqgzl+GD5zipgJrygvmXlG1fWQwjb9aj1e+9uDNJXtReBtPhBJ9H47/WAN1curnWhKt2u1ljunn8AnwQw+DSz/Wukbfbzyyp+poa7eLJy6Wr37Wy0WRX8zk009tfPv3kO+lcP9J9N4FxDJepYt0wvk6yoFEpRK2SslvPz4JZwYxITHw4fSEiWM9OPnal9DWzWviKpHCLglBYThiDyvUU6cuKYSnKyqv00sIu0MaEpdjAEMUKVDoIeiS+VVeMiA0RISjtbMc46d+eZvnJmJ4gK2LN43R0hW9uOGOQ1kBENbUPDzDyYg8eBBcItD9TAktvNku/mglH0IMhkzwwXsq+YIhHy0g3iyArDrCWhLZeEtqn4fjUsGi2ZEbgOSiOcwrk5cQ52cmxCMMheF2DKG4Dw1w47U1nLXZTCEKdBeHb/G76v9dX/4cy8r8bYz1+XPxOHE3LINSpNQAyJT4GQoH8IQhZy67xa0uwyCqInsb2Qt0at+HC/iuY3HzXrtgFvj+Ce7B8BC4iRBzMIhITH0KsvLELkyiyuw8v455A7ZrDnjk6Tsn225R2dCtXPkj/ceFZOHppOpZt1sLP18tveOLRNKWvKqZ60HcEwBWd/ZXVt7WDhu3+wD5sBT4/R0CKi1ZZcn8TAhdRd03h8/sWzJhWzSDZZQlfNyySRdE/4vaOWSSBvBy3qLJZmYlfvEtQqvz26AbzBEF/IBxs/tN9CImhYXUDGjY9WRRAo1he4KxsxeTWFs1DasMYm8ODMfYIorXfCYZV0TQRXIkB6HQDgHQA8kTbpDdhmzQ2/pxx9tsEAA+It0c84h6tYBCxUeq2mHsFXDklcUX4aMdYuCEwbAJ5SbgqiGcU4arFoEbNsCJoEcOqGxEGEiGgN7McDZgVy0uCFd/NpbAaeclhDR8YUJxgQeF+67ZDVjRArAYAohfYHT5AOheC4mSrkmtBrmpDQSuN4zC5USs5mamV/aVzor90TpkIaAMqUZ3ORZI8EdDZzaZnZiEbj8GWtatkGbHteQW1UkW2QhydVxTLCye2/NpNrYvp/EUFHDxRd30edyduUtfGgdLoNcui1+4GeqlZrilI2BfIC9BrOvzaja3qsql8Hy0so5cNGZNtZm0DkIKEJVjEEsjLobGcfLHUi687avUqwGdQEj4kU7Jt+FAbiCxRVK9YXhJ8jpDA9ccxOwQOYtx0hLVRswpLkMAhkJeEm4IMDoKcDxwJNspyKaMbXIqeqdrWaTNbu4mIDMkEuGzm6+ZmPqdzm/lM+acYFSP13fvrG9w1xN+eJn+jsRzN2W2fUWqyjOmyD6eWpH3avrSetG8WkJxvMOxckPR98dC2qJHZDWrkUMmjtlFMjQTycqiRdWSWX4jEFterTl+aqhmFksDFoGFg8Yly3YedOM5pBF4gLwmlbNrr+yeFDW6DOgqzFnYp0YBySqYHsggwBQ1JDmhbdpuGRylteN5vYwiHbtmB2dRQJw7qGDAE8sJVvkHf5NZvDFgFmT3HrEzXVq4r0KuyiyhWN3J76OQvW5BTIZCX47gGLL36230BTysuktjC2Rb1MAMuudt8EqSRKWM98R1b5RsGnpdr5mBT4rJOGeo9pK+hk/4l14zM2SUuW/l8ryZ8W+mzArOdXJal2e9hQFWTBQcnua9jtUXOa99QA7vHFHZDYXOw37nKVmeN5QFenBbWUGINeZdM3iUXHW9VfkxpJlmfzXZHmo2MMcoTDAQxEYG8YEyqBk0pByoV0hOOSvIg1F52anDXMma5CayXpatOL13p9JynyaWron36EtdfCnH67sPuS56mXcfyS1Gm+LnpzWjwaEXuGQXy3ywkRW/8kSpHb/+dPZjT6Tfvnyfj4T5avejrp69NvJFCiuKcBl+Ayf0B7NI8OcfuNoQByy8vi6WVPFqTi6VcA8OOkw4fS9WprVNF/EAY5iu7zkXORVH6ikW23BIb+66Vi1PnFAZ9xI9gM4pA/ticolaqzwU6a9g2bUC4FLRKb2Mv4gxt58PSZzkKlj4F8pUjyHyawLV+Iy96ydu9HESs1zWMsV+42nmzaySgqqtN2rnkc2IsH3eL+TdwuUJOFLBWk402510ON/pcgxsyqJk/9xXSDs8PySJsBWvQHyBNgu7Tpt2SUdIt6WWPKshiXYZu02+7asItmdQyuSk4I0MgLwh1XTGnSh3+nFq8FndYyM+UPd12aFRqZ4NTFq6OSryyoaUoODmfV8JKDy9frwhB0t8epRs0KvqK5pi2auz+HjZ4JB3m5CQKhY9FqaSBn8jw65EGi/eGm0ZJA+fAxl9g6A843rwwCCZ97NPJ/qrdpzykpPHu1Lxpjq9G/pEzv96Ad4xB39HbHvNsSHx3Wi+ztI5LZt5Pbuew3UBqRCs3IGXJVv5d++gHIQkl2WSLv9BdJuwqmESrXGX0o/L1c8Xpg5DS6h1c/jTg06OU1JYOgxfOr+nF9+g2hEk37IcsYq2LezgDicS/</diagram><diagram id="fr3X5ynE2yK5susw7VPl" name="VPatch (paritypart)">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</diagram><diagram id="d-BzQ9OEiXnQBmiWa_16" name="Patch (moved patch)">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</diagram><diagram id="6wJrspvL4pc4MqzzIFbO" name="VPatch(leaked requests)">7Vxbc5s4FP41ntl9SIY7zmNsJ+3utt1s0rRJXzqKkW0ajKiQG3t//QqQuAkjnBqDu85Mp3B8EObo06dzwwN9vFy/wSBYvEcO9Aaa4qwH+mSgaap+YdL/IskmkVwYSiKYY9dhSpngzv0XMiFXW7kODAuKBCGPuEFROEW+D6ekIAMYo5ei2gx5xbsGYA4Fwd0UeKL0s+uQRSIdanYmfwvd+YLfWbUukk+WgCuzJwkXwEEvOZF+NdDHGCGSHC3XY+hFxuN2+aIGK/oP338wV+RWAeNv3vwsGex6l0vSR8DQJ68e+sFfuvefvj7dL6e3f/79dqPdfH1hlyg/gLdi9hrol5dTgjB7ZrLhhqSPH0SHq6X3zp1Bz/Xp2SiA2F1CAjH9xGPim0w2elm4BN4FYBpd+kIhRmULsvTomUoP6awTQC/B6bnngSB0n+K7KlSC4XSFQ/cHvIVhAq5IilYkutM4BU2sila+Ax02VDpdSjzu0p2yYw88QW8Eps/z+IIx8lB0ex/FDxQSjJ5TqEQDzeh3vAZL14tWwCeIHeADJmZwV6nVRsBz5z49mdJJih+dmRZiAtclLEomUk3RRZclRNSWeEOvY6NofAWyFTlkpy8ZvFWFyRY5aJtcEbAlNU+HzmBDDxhydkCRKqKojJ5sbhQ5KhpZbjuet1rOMAuGU9Uqy4mG09qym3acdtO1ju1mV9DWURiucqmKhkuBuXfLWSe+Pzq+N7W+8b3dm+Vn7cT3Zse8NTxOu2kN+d5sDW/GcRrO7NrBUCs8jBPf95zvLatvfG81IHzo0LCbnSJMFmiOfOBdZdJRcYVmOu8QCthUfIOEbJjRwYqgIpioUfHmIX/yGA12bvLTyZoNnpxt2FnyXaMvuNta56snRCs8hXWKeqJIAJ7DWvbYQh8YeoDQNVD4flXTGF96iTHY5BQC5PokzI18EwkyQKklB0JlOZ3rhvr60CxBKPkGGaDSR/kJqtJ7w/HJvDf2KuyOd0erwqk/CsvpVseWU/vjV+xmOa1rzHGGODkWR+RYpF5DbxwLrT+Zw1xKv8ECbLj+jNYMV+HYH4XhdKNry5mC5SZ3NxitNzeATBdb2ctHBMrNyJiGbiz6KDKmOwXeJVvfJHJz09XuwRmJLqBDuf78Y+wC0+iy7CYflowORDx6Q+LRzbZAILpMk7t/VpCenOa//YpV9/MvBrR3z9CDBPknABwghd09AMRU7KeY/+td2BMG9pfW6h4DFwIGPl79qPYCcrNbntEnRAhaxuYGmFxGLStUiuioXHbtelkKy+EaTx6aPnMVZv1hPsulnGtpZutxkE9svTrNVddeIk1eaVvmNzeBfIp3y2cJCajSdqGWw9gkIccuqktklfyONFXDB0qeWRhoXzktXYySKcISormLpn2gWV5EAE+Ucqw5iZcifgHYEQB4gPRqTCY3KHSJiwrxKEf8u5LC0nWc+NZCBFteI6lmgemUTDBii2iimz+PZGm+VmsK+S2Ibzddm2Zt0nStUotyiX476VpdjNxl0Mbw+wqGpAtoV6IsI9oDsqy8ltAQmmYn2NTtItZ47L4NmxL9IjbFfUCrvvpg/C3WJMYYAuoDakq1o9gBlrVDoNJuSph6F6i0Sg4DZ8RtqJTot8SYYrEhYsw3MPpiv90Cfx7B6g8KjvXvvwqupHgZdgIXuxyJSOBSry8hMVsxK6+WebN7w52Y8GS4u4XhyuvFfnwQDhs25TCjDxym78hh+kE4TMybpl7fdQSKG+r5hVWuXxggPxSzq135fq17cUZDsGl98OIMCQFK9FvCmpijbYS1DiPoboLZpkjrBGo8GE2ho9VDTaLfDtQMEWqfwTO8DyrRJQqdDZ11AXAErkkRH83zJDjqWQBZMwMzMx3XHA3MSTQWRR9PNA/a6xmwteqlX5X1O0jnCR/41HlyRJ0n6Ysvvek8MfvTeWLu9tJaZd1ENF1rPeVmfxo1d7NcNeoOaDlbO1LLGRddY06MYXm9/hojX4xhTwXb/ZN25wVbsyb67F85Da5d8pA7fswdZ7WF6ISXFvpZkDCb5vLsWjSdKeeKpRlFRn5VuXjXEMQo1yD0+hBEor8t3ce/DprNQthKJs8Uw5R1F8huG3GNkydmN9WGciOLJcnU1eu3E9KaYoNTxJUTN3zOs2QOOdb3FSJsbzlLdsRLqqCqwTqec/45p9bbpJw7RsuAbsRQ5Fgx/s1vW5XxcFtbmaGWpqDqjdZh1V7Wmi9YUz+fuLNZr7aythc894PlW0y926qcG5ZafsfoEFtMuQXDkFCCRF9SUUr7inhIaBUfp70dyBZjPwlqO2z6aBu13E2Qo1brJ2r1Uq7VtCVlgHr9/qK2ugL6/+RanoSQo3ZLGfSwvnvJdzIlvXAS/YP47n8/uO8/2KO/zNB5/Lh8Aydfxt/OaiD4gPBu3NlFM/L+X7lv2jdSac4t79HvvxX5olT/sMotaE17kYdmNTIP1ctm1yRPekeCe8udtA1UOd1WxLK7ILoYBjHsnKncY/5JdNtDCbq3gHJXGt92n4aeg/ADForWgu+wfVokv3zieW4QQnmaGYRBUvmbuetodYxmlIt5CngQNYZFf2keOPeJFf+xCDonT/7aLP+WJ66i/KtVxM37qARUzof4zs7IA9Nnkb3eIk9sN/o1SvKl/KTFX2nOzYlRMSevyGXQ0+z3bZMllf1KsH71Hw==</diagram><diagram id="znj-D5QoGOLx2BGCd-4G" name="Solution# 1 (Current fix)">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</diagram></mxfile> 
\ No newline at end of file
+<mxfile host="drawio.yandex-team.ru" modified="2021-05-13T12:45:24.063Z" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.86 YaBrowser/21.3.0.740 Yowser/2.5 Safari/537.36" etag="wJ5mePPJEHiOP22e9T2I" version="12.7.0" type="device" pages="5"><diagram name="VPatch (datapart)" id="13e1069c-82ec-6db2-03f1-153e76fe0fe0">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</diagram><diagram id="fr3X5ynE2yK5susw7VPl" name="VPatch (paritypart)">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</diagram><diagram id="d-BzQ9OEiXnQBmiWa_16" name="Patch (moved patch)">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</diagram><diagram id="6wJrspvL4pc4MqzzIFbO" name="VPatch(leaked requests)">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</diagram><diagram id="znj-D5QoGOLx2BGCd-4G" name="Solution# 1 (Current fix)">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</diagram></mxfile>
\ No newline at end of file
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy.h b/ydb/core/blobstorage/dsproxy/dsproxy.h
index 85406ecf3e..27592e971f 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy.h
@@ -28,7 +28,7 @@ LWTRACE_USING(BLOBSTORAGE_PROVIDER);
 constexpr ui32 TypicalPartsInBlob = 6;
 constexpr ui32 TypicalDisksInSubring = 8;
 
-constexpr ui32 MaxBatchedPutSize = 64 * 1024 - 512 - 5; // (MinREALHugeBlobInBytes - 1 - TDiskBlob::HugeBlobOverhead) for ssd and nvme 
+constexpr ui32 MaxBatchedPutSize = 64 * 1024 - 512 - 5; // (MinREALHugeBlobInBytes - 1 - TDiskBlob::HugeBlobOverhead) for ssd and nvme
 
 const TDuration ProxyConfigurationTimeout = TDuration::Seconds(20);
 const ui32 ProxyRetryConfigurationInitialTimeout = 200;
@@ -51,11 +51,11 @@ const ui32 MaxRequestSize = 1000;
 
 const ui32 MaskSizeBits = 32;
 
-constexpr bool DefaultEnablePutBatching = true; 
-constexpr bool DefaultEnableVPatch = false; 
- 
-constexpr bool WithMovingPatchRequestToStaticNode = true; 
- 
+constexpr bool DefaultEnablePutBatching = true;
+constexpr bool DefaultEnableVPatch = false;
+
+constexpr bool WithMovingPatchRequestToStaticNode = true;
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Common types
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -302,17 +302,17 @@ public:
     void CountPuts(const TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>>& q) {
         for (const auto& item : q) {
             ++GeneratedSubrequests;
-            GeneratedSubrequestBytes += item->GetBufferBytes(); 
+            GeneratedSubrequestBytes += item->GetBufferBytes();
         }
     }
 
     void CountPuts(const TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>>& q) {
-        for (const auto& item : q) { 
-            ++GeneratedSubrequests; 
-            GeneratedSubrequestBytes += item->GetBufferBytes(); 
-        } 
-    } 
- 
+        for (const auto& item : q) {
+            ++GeneratedSubrequests;
+            GeneratedSubrequestBytes += item->GetBufferBytes();
+        }
+    }
+
     template<typename T>
     void SendToQueue(std::unique_ptr<T> event, ui64 cookie, NWilson::TTraceId traceId, bool timeStatsEnabled = false) {
         const TActorId queueId = GroupQueues->Send(*this, Info->GetTopology(), std::move(event), cookie, std::move(traceId),
@@ -346,31 +346,31 @@ public:
     }
 
     TLogoBlobID GetBlobId(std::unique_ptr<TEvBlobStorage::TEvVPut> &ev) {
-        Y_VERIFY(ev->Record.HasBlobID()); 
-        return LogoBlobIDFromLogoBlobID(ev->Record.GetBlobID()); 
-    } 
- 
+        Y_VERIFY(ev->Record.HasBlobID());
+        return LogoBlobIDFromLogoBlobID(ev->Record.GetBlobID());
+    }
+
     TLogoBlobID GetBlobId(std::unique_ptr<TEvBlobStorage::TEvVMultiPut> &ev) {
-        Y_VERIFY(ev->Record.ItemsSize()); 
-        return LogoBlobIDFromLogoBlobID(ev->Record.GetItems(0).GetBlobID()); 
-    } 
- 
+        Y_VERIFY(ev->Record.ItemsSize());
+        return LogoBlobIDFromLogoBlobID(ev->Record.GetItems(0).GetBlobID());
+    }
+
     TLogoBlobID GetBlobId(std::unique_ptr<TEvBlobStorage::TEvVMovedPatch> &ev) {
-        Y_VERIFY(ev->Record.HasPatchedBlobId()); 
-        return LogoBlobIDFromLogoBlobID(ev->Record.GetPatchedBlobId()); 
-    } 
- 
+        Y_VERIFY(ev->Record.HasPatchedBlobId());
+        return LogoBlobIDFromLogoBlobID(ev->Record.GetPatchedBlobId());
+    }
+
     TLogoBlobID GetBlobId(std::unique_ptr<TEvBlobStorage::TEvVPatchStart> &ev) {
-        Y_VERIFY(ev->Record.HasOriginalBlobId()); 
-        return LogoBlobIDFromLogoBlobID(ev->Record.GetOriginalBlobId()); 
-    } 
- 
+        Y_VERIFY(ev->Record.HasOriginalBlobId());
+        return LogoBlobIDFromLogoBlobID(ev->Record.GetOriginalBlobId());
+    }
+
     TLogoBlobID GetBlobId(std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> &ev) {
-        Y_VERIFY(ev->Record.HasPatchedPartBlobId()); 
-        return LogoBlobIDFromLogoBlobID(ev->Record.GetPatchedPartBlobId()); 
-    } 
- 
-    template <typename TEvent> 
+        Y_VERIFY(ev->Record.HasPatchedPartBlobId());
+        return LogoBlobIDFromLogoBlobID(ev->Record.GetPatchedPartBlobId());
+    }
+
+    template <typename TEvent>
     void SendToQueues(TDeque<std::unique_ptr<TEvent>> &events, bool timeStatsEnabled) {
         for (auto& request : events) {
             WILSON_TRACE_FROM_ACTOR(*TlsActivationContext, *this, &TraceId, EvVPutSent);
@@ -379,7 +379,7 @@ public:
             CountEvent(*request);
             const ui64 cyclesPerUs = NHPTimer::GetCyclesPerSecond() / 1000000;
             request->Record.MutableTimestamps()->SetSentByDSProxyUs(GetCycleCountFast() / cyclesPerUs);
-            TLogoBlobID id = GetBlobId(request); 
+            TLogoBlobID id = GetBlobId(request);
             TVDiskID vDiskId = VDiskIDFromVDiskID(request->Record.GetVDiskID());
             LWTRACK(DSProxyPutVPutIsSent, request->Orbit, Info->GetFailDomainOrderNumber(vDiskId),
                     Info->GroupID, id.Channel(), id.PartId(), id.ToString(), id.BlobSize());
@@ -408,7 +408,7 @@ public:
         Derived().Send(GetProxyActorId(), new TEvDeathNote(Responsiveness));
         for (const auto& [queueId, numUnrepliedRequests] : InvolvedQueues) {
             Derived().Send(queueId, new TEvPruneQueue);
-        } 
+        }
         TActorBootstrapped<TDerived>::PassAway();
     }
 
@@ -429,14 +429,14 @@ public:
             XX(Range)
             XX(CollectGarbage)
             XX(Status)
-            XX(Patch) 
+            XX(Patch)
             default:
                 Y_FAIL();
 #undef XX
         }
 
-        // ensure that we are dying for the first time 
-        Y_VERIFY(!Dead); 
+        // ensure that we are dying for the first time
+        Y_VERIFY(!Dead);
         if (RequestHandleClass && PoolCounters) {
             PoolCounters->GetItem(*RequestHandleClass, RequestBytes).Register(
                 RequestBytes, GeneratedSubrequests, GeneratedSubrequestBytes, Timer.Passed());
@@ -446,7 +446,7 @@ public:
         if (timeStats) {
             Derived().Send(proxyId, new TEvTimeStats(std::move(*timeStats)));
         }
- 
+
         if (LatencyQueueKind) {
             Derived().Send(proxyId, new TEvLatencyReport(*LatencyQueueKind, now - RequestStartTime));
         }
@@ -456,14 +456,14 @@ public:
             static_cast<TEvBlobStorage::TEvGetResult&>(*ev).Sent = now;
         }
 
-        // send the reply to original request sender 
+        // send the reply to original request sender
         Derived().Send(source, ev.release(), 0, cookie, std::move(traceId));
     };
 
     void SendResponse(std::unique_ptr<IEventBase>&& ev, TBlobStorageGroupProxyTimeStats *timeStats = nullptr) {
         SendResponse(std::move(ev), timeStats, Source, Cookie, std::move(TraceId));
-    } 
- 
+    }
+
     static double GetStartTime(const NKikimrBlobStorage::TTimestamps& timestamps) {
         return timestamps.GetSentByDSProxyUs() / 1e6;
     }
@@ -533,32 +533,32 @@ IActor* CreateBlobStorageGroupPutRequest(const TIntrusivePtr<TBlobStorageGroupIn
     const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvPut *ev,
     ui64 cookie, NWilson::TTraceId traceId, bool timeStatsEnabled,
     TDiskResponsivenessTracker::TPerDiskStatsPtr stats,
-    TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-    bool enableRequestMod3x3ForMinLatecy); 
+    TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+    bool enableRequestMod3x3ForMinLatecy);
 
-IActor* CreateBlobStorageGroupPutRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info, 
+IActor* CreateBlobStorageGroupPutRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info,
     const TIntrusivePtr<TGroupQueues> &state,
-    const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, 
-    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &ev, 
-    bool timeStatsEnabled, 
-    TDiskResponsivenessTracker::TPerDiskStatsPtr stats, 
-    TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-    NKikimrBlobStorage::EPutHandleClass handleClass, TEvBlobStorage::TEvPut::ETactic tactic, 
-    bool enableRequestMod3x3ForMinLatecy); 
- 
+    const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon,
+    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &ev,
+    bool timeStatsEnabled,
+    TDiskResponsivenessTracker::TPerDiskStatsPtr stats,
+    TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+    NKikimrBlobStorage::EPutHandleClass handleClass, TEvBlobStorage::TEvPut::ETactic tactic,
+    bool enableRequestMod3x3ForMinLatecy);
+
 IActor* CreateBlobStorageGroupGetRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info,
     const TIntrusivePtr<TGroupQueues> &state, const TActorId &source,
     const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvGet *ev,
     ui64 cookie, NWilson::TTraceId traceId, TNodeLayoutInfoPtr&& nodeLayout,
-    TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-    bool isVMultiPutMode); 
-
-IActor* CreateBlobStorageGroupPatchRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info, 
-    const TIntrusivePtr<TGroupQueues> &state, const TActorId &source, 
-    const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvPatch *ev, 
-    ui64 cookie, NWilson::TTraceId traceId, TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-    const TActorId &proxyId, bool useVPatch); 
- 
+    TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+    bool isVMultiPutMode);
+
+IActor* CreateBlobStorageGroupPatchRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info,
+    const TIntrusivePtr<TGroupQueues> &state, const TActorId &source,
+    const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvPatch *ev,
+    ui64 cookie, NWilson::TTraceId traceId, TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+    const TActorId &proxyId, bool useVPatch);
+
 IActor* CreateBlobStorageGroupMultiGetRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info,
     const TIntrusivePtr<TGroupQueues> &state, const TActorId &source,
     const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvGet *ev,
@@ -612,9 +612,9 @@ IActor* CreateBlobStorageGroupEjectedProxy(ui32 groupId, TIntrusivePtr<TDsProxyN
 IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
     bool forceWaitAllDrives, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
     TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters, const TControlWrapper &enablePutBatching,
-    const TControlWrapper &enableVPatch); 
+    const TControlWrapper &enableVPatch);
 
 IActor* CreateBlobStorageGroupProxyUnconfigured(ui32 groupId, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
-    const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch); 
+    const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch);
 
 }//NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_blackboard.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_blackboard.cpp
index a10c48ec0b..eb6d8394f0 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_blackboard.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_blackboard.cpp
@@ -35,28 +35,28 @@ void TBlobState::Init(const TLogoBlobID &id, const TBlobStorageGroupInfo &info)
         Disks[i].OrderNumber = info.GetOrderNumber(vdisksId[i]);
         Disks[i].DiskParts.resize(info.Type.TotalPartCount());
     }
-    IsChanged = true; 
+    IsChanged = true;
 }
 
 void TBlobState::AddNeeded(ui64 begin, ui64 size) {
     Y_VERIFY(bool(Id));
     Whole.Needed.Add(begin, begin + size);
     Whole.NotHere.Add(begin, begin + size);
-    IsChanged = true; 
+    IsChanged = true;
 }
 
 void TBlobState::AddPartToPut(ui32 partIdx, TString &partData) {
     Y_VERIFY(bool(Id));
     Y_VERIFY(partIdx < Parts.size());
     Parts[partIdx].AddPartToPut(partData);
-    IsChanged = true; 
+    IsChanged = true;
 }
 
-void TBlobState::MarkBlobReadyToPut(ui8 blobIdx) { 
+void TBlobState::MarkBlobReadyToPut(ui8 blobIdx) {
     Y_VERIFY(WholeSituation == ESituation::Unknown || WholeSituation == ESituation::Present);
     WholeSituation = ESituation::Present;
-    BlobIdx = blobIdx; 
-    IsChanged = true; 
+    BlobIdx = blobIdx;
+    IsChanged = true;
 }
 
 bool TBlobState::Restore(const TBlobStorageGroupInfo &info) {
@@ -110,7 +110,7 @@ void TBlobState::AddResponseData(const TBlobStorageGroupInfo &info, const TLogoB
     if (partSize) {
         Parts[partIdx].AddResponseData(partSize, shift, data);
     }
-    IsChanged = true; 
+    IsChanged = true;
     // Mark part as present for the disk
     bool isFound = false;
     for (ui32 diskIdx = 0; diskIdx < Disks.size(); ++diskIdx) {
@@ -135,7 +135,7 @@ void TBlobState::AddNoDataResponse(const TBlobStorageGroupInfo &info, const TLog
     Y_UNUSED(info);
     Y_VERIFY(id.PartId() != 0);
     ui32 partIdx = id.PartId() - 1;
-    IsChanged = true; 
+    IsChanged = true;
     // Mark part as absent for the disk
     bool isFound = false;
     for (ui32 diskIdx = 0; diskIdx < Disks.size(); ++diskIdx) {
@@ -157,7 +157,7 @@ void TBlobState::AddPutOkResponse(const TBlobStorageGroupInfo &info, const TLogo
     Y_UNUSED(info);
     Y_VERIFY(id.PartId() != 0);
     ui32 partIdx = id.PartId() - 1;
-    IsChanged = true; 
+    IsChanged = true;
     // Mark part as put ok for the disk
     bool isFound = false;
     for (ui32 diskIdx = 0; diskIdx < Disks.size(); ++diskIdx) {
@@ -178,7 +178,7 @@ void TBlobState::AddErrorResponse(const TBlobStorageGroupInfo &info, const TLogo
     Y_UNUSED(info);
     Y_VERIFY(id.PartId() != 0);
     ui32 partIdx = id.PartId() - 1;
-    IsChanged = true; 
+    IsChanged = true;
     // Mark part as error for the disk
     bool isFound = false;
     for (ui32 diskIdx = 0; diskIdx < Disks.size(); ++diskIdx) {
@@ -200,7 +200,7 @@ void TBlobState::AddNotYetResponse(const TBlobStorageGroupInfo &info, const TLog
     Y_UNUSED(info);
     Y_VERIFY(id.PartId() != 0);
     ui32 partIdx = id.PartId() - 1;
-    IsChanged = true; 
+    IsChanged = true;
     // Mark part as error for the disk
     bool isFound = false;
     for (ui32 diskIdx = 0; diskIdx < Disks.size(); ++diskIdx) {
@@ -260,8 +260,8 @@ TString TBlobState::ToString() const {
         str << " Disks[" << i << "]# " << Disks[i].ToString();
     str << Endl;
     }
-    str << " BlobIdx# " << (ui32)BlobIdx; 
-    str << Endl; 
+    str << " BlobIdx# " << (ui32)BlobIdx;
+    str << Endl;
     str << "}";
     return str.Str();
 }
@@ -346,9 +346,9 @@ void TGroupDiskRequests::AddGet(const ui32 diskOrderNumber, const TLogoBlobID &i
 }
 
 void TGroupDiskRequests::AddPut(const ui32 diskOrderNumber, const TLogoBlobID &id, TString buffer,
-        TDiskPutRequest::EPutReason putReason, bool isHandoff, ui8 blobIdx) { 
+        TDiskPutRequest::EPutReason putReason, bool isHandoff, ui8 blobIdx) {
     Y_VERIFY(diskOrderNumber < DiskRequestsForOrderNumber.size());
-    DiskRequestsForOrderNumber[diskOrderNumber].PutsToSend.emplace_back(id, buffer, putReason, isHandoff, blobIdx); 
+    DiskRequestsForOrderNumber[diskOrderNumber].PutsToSend.emplace_back(id, buffer, putReason, isHandoff, blobIdx);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -365,7 +365,7 @@ void TBlackboard::AddNeeded(const TLogoBlobID &id, ui32 inShift, ui32 inSize) {
     ui64 size = (inSize ? Min(ui64(inSize), maxSize) : maxSize);
     //Cerr << "size " << size << " shift " << shift << Endl;
     if (size > 0) {
-        TBlobState &state = BlobStates[id];; 
+        TBlobState &state = BlobStates[id];;
         if (!bool(state.Id)) {
             state.Init(id, *Info);
         }
@@ -389,90 +389,90 @@ void TBlackboard::AddPartToPut(const TLogoBlobID &id, ui32 partIdx, TString &par
     state.AddPartToPut(partIdx, partData);
 }
 
-void TBlackboard::MarkBlobReadyToPut(const TLogoBlobID &id, ui8 blobIdx) { 
+void TBlackboard::MarkBlobReadyToPut(const TLogoBlobID &id, ui8 blobIdx) {
     Y_VERIFY(bool(id));
     Y_VERIFY(id.PartId() == 0);
     Y_VERIFY(id.BlobSize() != 0);
-    TBlobState &state = BlobStates[id];; 
+    TBlobState &state = BlobStates[id];;
     if (!bool(state.Id)) {
         state.Init(id, *Info);
     }
-    state.MarkBlobReadyToPut(blobIdx); 
-}
-
-void TBlackboard::MoveBlobStateToDone(const TLogoBlobID &id) { 
-    Y_VERIFY(bool(id)); 
-    Y_VERIFY(id.PartId() == 0); 
-    Y_VERIFY(id.BlobSize() != 0); 
-    auto it = BlobStates.find(id); 
-    if (it == BlobStates.end()) { 
-        auto doneIt = DoneBlobStates.find(id); 
-        const char *errorMsg = doneIt == DoneBlobStates.end() ? 
-                "This blobId is not in BlobStates or in DoneBlobStates" : 
-                "This blobId is already in DoneBlobStates"; 
-        Y_VERIFY_S(false, errorMsg << " BlobId# " << id << " Blackboard# " << ToString()); 
-    } else { 
-        if (!it->second.IsDone) { 
-            DoneCount++; 
-            it->second.IsDone = true; 
-        } 
-        auto node = BlobStates.extract(it); 
-        DoneBlobStates.insert(std::move(node)); 
-    } 
-} 
- 
+    state.MarkBlobReadyToPut(blobIdx);
+}
+
+void TBlackboard::MoveBlobStateToDone(const TLogoBlobID &id) {
+    Y_VERIFY(bool(id));
+    Y_VERIFY(id.PartId() == 0);
+    Y_VERIFY(id.BlobSize() != 0);
+    auto it = BlobStates.find(id);
+    if (it == BlobStates.end()) {
+        auto doneIt = DoneBlobStates.find(id);
+        const char *errorMsg = doneIt == DoneBlobStates.end() ?
+                "This blobId is not in BlobStates or in DoneBlobStates" :
+                "This blobId is already in DoneBlobStates";
+        Y_VERIFY_S(false, errorMsg << " BlobId# " << id << " Blackboard# " << ToString());
+    } else {
+        if (!it->second.IsDone) {
+            DoneCount++;
+            it->second.IsDone = true;
+        }
+        auto node = BlobStates.extract(it);
+        DoneBlobStates.insert(std::move(node));
+    }
+}
+
 void TBlackboard::AddPutOkResponse(const TLogoBlobID &id, ui32 orderNumber) {
     Y_VERIFY(bool(id));
     Y_VERIFY(id.PartId() != 0);
-    TBlobState &state = GetState(id); 
+    TBlobState &state = GetState(id);
     state.AddPutOkResponse(*Info, id, orderNumber);
 }
 
 void TBlackboard::AddResponseData(const TLogoBlobID &id, ui32 orderNumber, ui32 shift, TString &data) {
     Y_VERIFY(bool(id));
     Y_VERIFY(id.PartId() != 0);
-    TBlobState &state = GetState(id); 
+    TBlobState &state = GetState(id);
     state.AddResponseData(*Info, id, orderNumber, shift, data);
 }
 
 void TBlackboard::AddNoDataResponse(const TLogoBlobID &id, ui32 orderNumber) {
     Y_VERIFY(bool(id));
     Y_VERIFY(id.PartId() != 0);
-    TBlobState &state = GetState(id); 
+    TBlobState &state = GetState(id);
     state.AddNoDataResponse(*Info, id, orderNumber);
 }
 
 void TBlackboard::AddNotYetResponse(const TLogoBlobID &id, ui32 orderNumber) {
     Y_VERIFY(bool(id));
     Y_VERIFY(id.PartId() != 0);
-    TBlobState &state = GetState(id); 
+    TBlobState &state = GetState(id);
     state.AddNotYetResponse(*Info, id, orderNumber);
 }
 
 void TBlackboard::AddErrorResponse(const TLogoBlobID &id, ui32 orderNumber) {
     Y_VERIFY(bool(id));
     Y_VERIFY(id.PartId() != 0);
-    TBlobState &state = GetState(id); 
+    TBlobState &state = GetState(id);
     state.AddErrorResponse(*Info, id, orderNumber);
 }
 
 EStrategyOutcome TBlackboard::RunStrategy(TLogContext &logCtx, const IStrategy& s, TBatchedVec<TBlobStates::value_type*> *finished) {
     IStrategy& temp = const_cast<IStrategy&>(s); // better UX
-    Y_VERIFY(BlobStates.size()); 
-    EStrategyOutcome outcome = EStrategyOutcome::IN_PROGRESS; 
+    Y_VERIFY(BlobStates.size());
+    EStrategyOutcome outcome = EStrategyOutcome::IN_PROGRESS;
     for (auto it = BlobStates.begin(); it != BlobStates.end(); ++it) {
         auto& blob = it->second;
-        if (!blob.IsChanged) { 
-            continue; 
-        } 
-        blob.IsChanged = false; 
+        if (!blob.IsChanged) {
+            continue;
+        }
+        blob.IsChanged = false;
         // recalculate blob outcome if it is not yet determined
         switch (auto res = temp.Process(logCtx, blob, *Info, *this, GroupDiskRequests)) {
             case EStrategyOutcome::IN_PROGRESS:
-                if (blob.IsDone) { 
-                    DoneCount--; 
-                    blob.IsDone = false; 
-                } 
+                if (blob.IsDone) {
+                    DoneCount--;
+                    blob.IsDone = false;
+                }
                 outcome = EStrategyOutcome::IN_PROGRESS;
                 break;
 
@@ -484,17 +484,17 @@ EStrategyOutcome TBlackboard::RunStrategy(TLogContext &logCtx, const IStrategy&
                     if (finished) {
                         finished->push_back(&*it);
                     }
-                    if (outcome.ErrorReason) { 
+                    if (outcome.ErrorReason) {
                         outcome.ErrorReason += " && ";
                         outcome.ErrorReason += res.ErrorReason;
-                    } else { 
-                        outcome.ErrorReason = res.ErrorReason; 
+                    } else {
+                        outcome.ErrorReason = res.ErrorReason;
                     }
                 }
-                if (!blob.IsDone) { 
-                    DoneCount++; 
-                    blob.IsDone = true; 
-                } 
+                if (!blob.IsDone) {
+                    DoneCount++;
+                    blob.IsDone = true;
+                }
                 break;
 
             case EStrategyOutcome::DONE:
@@ -504,36 +504,36 @@ EStrategyOutcome TBlackboard::RunStrategy(TLogContext &logCtx, const IStrategy&
                         finished->push_back(&*it);
                     }
                 }
-                if (!blob.IsDone) { 
-                    DoneCount++; 
-                    blob.IsDone = true; 
-                } 
+                if (!blob.IsDone) {
+                    DoneCount++;
+                    blob.IsDone = true;
+                }
                 break;
-        } 
+        }
+    }
+    if (DoneCount == (BlobStates.size() + DoneBlobStates.size())) {
+        outcome = EStrategyOutcome::DONE;
     }
-    if (DoneCount == (BlobStates.size() + DoneBlobStates.size())) { 
-        outcome = EStrategyOutcome::DONE; 
-    } 
     return outcome;
 }
 
-TBlobState& TBlackboard::GetState(const TLogoBlobID &id) { 
+TBlobState& TBlackboard::GetState(const TLogoBlobID &id) {
     Y_VERIFY(bool(id));
-    TLogoBlobID fullId = id.FullID(); 
-    auto it = BlobStates.find(fullId); 
-    if (it == BlobStates.end()) { 
-        it = DoneBlobStates.find(fullId); 
-        Y_VERIFY_S(it != DoneBlobStates.end(), "The blob was not found in BlobStates and DoneBlobStates" 
-                << " blobId# " << fullId 
-                << " BlackBoard# " << ToString()); 
-    } 
-    TBlobState &state = it->second; 
+    TLogoBlobID fullId = id.FullID();
+    auto it = BlobStates.find(fullId);
+    if (it == BlobStates.end()) {
+        it = DoneBlobStates.find(fullId);
+        Y_VERIFY_S(it != DoneBlobStates.end(), "The blob was not found in BlobStates and DoneBlobStates"
+                << " blobId# " << fullId
+                << " BlackBoard# " << ToString());
+    }
+    TBlobState &state = it->second;
     return state;
 }
 
 ssize_t TBlackboard::AddPartMap(const TLogoBlobID &id, ui32 diskOrderNumber, ui32 requestIndex) {
     Y_VERIFY(id);
-    TBlobState &state = GetState(id); 
+    TBlobState &state = GetState(id);
     ssize_t ret = state.PartMap.size();
     state.PartMap.emplace_back(TEvBlobStorage::TEvGetResult::TPartMapItem{
             diskOrderNumber,
@@ -548,7 +548,7 @@ ssize_t TBlackboard::AddPartMap(const TLogoBlobID &id, ui32 diskOrderNumber, ui3
 void TBlackboard::ReportPartMapStatus(const TLogoBlobID &id, ssize_t partMapIndex, ui32 responseIndex, NKikimrProto::EReplyStatus status) {
     Y_VERIFY(id);
     Y_VERIFY(partMapIndex >= 0);
-    TBlobState &state = GetState(id); 
+    TBlobState &state = GetState(id);
     Y_VERIFY(static_cast<size_t>(partMapIndex) < state.PartMap.size());
     TEvBlobStorage::TEvGetResult::TPartMapItem &item = state.PartMap[partMapIndex];
     Y_VERIFY(item.ResponseIndex == responseIndex || item.ResponseIndex == Max<ui32>());
@@ -579,7 +579,7 @@ TString TBlackboard::ToString() const {
     TStringStream str;
     str << "{BlobStates size# " << BlobStates.size();
     str << Endl;
-    str << " Data# {"; 
+    str << " Data# {";
     str << Endl;
     for (auto it = BlobStates.begin(); it != BlobStates.end(); ++it) {
         str << "{id# " << it->first.ToString() << " state# {" << it->second.ToString() << "}}";
@@ -587,15 +587,15 @@ TString TBlackboard::ToString() const {
     }
     str << "}";
     str << Endl;
-    str << " DoneBlobStates size # " << DoneBlobStates.size(); 
-    str << Endl; 
-    str << " DoneData# {"; 
-    for (auto &kv : DoneBlobStates) { 
-        str << "{id# " << kv.first.ToString() << " state# {" << kv.second.ToString() << "}}"; 
-        str << Endl; 
-    } 
-    str << "}"; 
-    str << Endl; 
+    str << " DoneBlobStates size # " << DoneBlobStates.size();
+    str << Endl;
+    str << " DoneData# {";
+    for (auto &kv : DoneBlobStates) {
+        str << "{id# " << kv.first.ToString() << " state# {" << kv.second.ToString() << "}}";
+        str << Endl;
+    }
+    str << "}";
+    str << Endl;
     // ...
     str << " PutHandleClass# " << EPutHandleClass_Name(PutHandleClass);
     str << Endl;
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_blackboard.h b/ydb/core/blobstorage/dsproxy/dsproxy_blackboard.h
index f0ae439442..fe926648a8 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_blackboard.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_blackboard.h
@@ -2,7 +2,7 @@
 #include "defs.h"
 
 #include "dsproxy.h"
- 
+
 #include <ydb/core/blobstorage/base/batched_vec.h>
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h>
 #include <ydb/core/util/fragmented_buffer.h>
@@ -77,15 +77,15 @@ struct TBlobState {
     TStackVec<TState, TypicalPartsInBlob> Parts;
     TStackVec<TDisk, TypicalDisksInSubring> Disks;
     TVector<TEvBlobStorage::TEvGetResult::TPartMapItem> PartMap;
-    ui8 BlobIdx; 
-    NKikimrProto::EReplyStatus Status = NKikimrProto::UNKNOWN; 
-    bool IsChanged = false; 
-    bool IsDone = false; 
+    ui8 BlobIdx;
+    NKikimrProto::EReplyStatus Status = NKikimrProto::UNKNOWN;
+    bool IsChanged = false;
+    bool IsDone = false;
 
     void Init(const TLogoBlobID &id, const TBlobStorageGroupInfo &Info);
     void AddNeeded(ui64 begin, ui64 size);
     void AddPartToPut(ui32 partIdx, TString &partData);
-    void MarkBlobReadyToPut(ui8 blobIdx = 0); 
+    void MarkBlobReadyToPut(ui8 blobIdx = 0);
     bool Restore(const TBlobStorageGroupInfo &info);
     void AddResponseData(const TBlobStorageGroupInfo &info, const TLogoBlobID &id, ui32 diskIdxInSubring,
             ui32 shift, TString &data);
@@ -126,14 +126,14 @@ struct TDiskPutRequest {
     TString Buffer;
     EPutReason Reason;
     bool IsHandoff;
-    ui8 BlobIdx; 
+    ui8 BlobIdx;
 
-    TDiskPutRequest(const TLogoBlobID &id, TString buffer, EPutReason reason, bool isHandoff, ui8 blobIdx = 0) 
+    TDiskPutRequest(const TLogoBlobID &id, TString buffer, EPutReason reason, bool isHandoff, ui8 blobIdx = 0)
         : Id(id)
         , Buffer(std::move(buffer))
         , Reason(reason)
         , IsHandoff(isHandoff)
-        , BlobIdx(blobIdx) 
+        , BlobIdx(blobIdx)
     {}
 };
 
@@ -151,7 +151,7 @@ struct TGroupDiskRequests {
     void AddGet(const ui32 diskOrderNumber, const TLogoBlobID &id, const TIntervalSet<i32> &intervalSet);
     void AddGet(const ui32 diskOrderNumber, const TLogoBlobID &id, const ui32 shift, const ui32 size);
     void AddPut(const ui32 diskOrderNumber, const TLogoBlobID &id, TString buffer,
-        TDiskPutRequest::EPutReason putReason, bool isHandoff, ui8 blobIdx = 0); 
+        TDiskPutRequest::EPutReason putReason, bool isHandoff, ui8 blobIdx = 0);
 };
 
 struct TBlackboard;
@@ -171,50 +171,50 @@ struct TBlackboard {
 
     using TBlobStates = TMap<TLogoBlobID, TBlobState>;
     TBlobStates BlobStates;
-    TBlobStates DoneBlobStates; 
+    TBlobStates DoneBlobStates;
     TGroupDiskRequests GroupDiskRequests;
     TIntrusivePtr<TBlobStorageGroupInfo> Info;
     TIntrusivePtr<TGroupQueues> GroupQueues; // To obtain FlowRecords only
     EAccelerationMode AccelerationMode;
     const NKikimrBlobStorage::EPutHandleClass PutHandleClass;
     const NKikimrBlobStorage::EGetHandleClass GetHandleClass;
-    const bool IsAllRequestsTogether; 
-    ui64 DoneCount = 0; 
+    const bool IsAllRequestsTogether;
+    ui64 DoneCount = 0;
 
     TBlackboard(const TIntrusivePtr<TBlobStorageGroupInfo> &info, const TIntrusivePtr<TGroupQueues> &groupQueues,
-            NKikimrBlobStorage::EPutHandleClass putHandleClass, NKikimrBlobStorage::EGetHandleClass getHandleClass, 
-            bool isAllRequestsTogether = true) 
+            NKikimrBlobStorage::EPutHandleClass putHandleClass, NKikimrBlobStorage::EGetHandleClass getHandleClass,
+            bool isAllRequestsTogether = true)
         : GroupDiskRequests(info->GetTotalVDisksNum())
         , Info(info)
         , GroupQueues(groupQueues)
         , AccelerationMode(AccelerationModeSkipOneSlowest)
         , PutHandleClass(putHandleClass)
         , GetHandleClass(getHandleClass)
-        , IsAllRequestsTogether(isAllRequestsTogether) 
+        , IsAllRequestsTogether(isAllRequestsTogether)
     {}
 
     void AddNeeded(const TLogoBlobID &id, ui32 inShift, ui32 inSize);
     void AddPartToPut(const TLogoBlobID &id, ui32 partIdx, TString &partData);
-    void MarkBlobReadyToPut(const TLogoBlobID &id, ui8 blobIdx = 0); 
-    void MoveBlobStateToDone(const TLogoBlobID &id); 
+    void MarkBlobReadyToPut(const TLogoBlobID &id, ui8 blobIdx = 0);
+    void MoveBlobStateToDone(const TLogoBlobID &id);
     void AddResponseData(const TLogoBlobID &id, ui32 orderNumber, ui32 shift, TString &data);
     void AddPutOkResponse(const TLogoBlobID &id, ui32 orderNumber);
     void AddNoDataResponse(const TLogoBlobID &id, ui32 orderNumber);
     void AddErrorResponse(const TLogoBlobID &id, ui32 orderNumber);
     void AddNotYetResponse(const TLogoBlobID &id, ui32 orderNumber);
     EStrategyOutcome RunStrategy(TLogContext &logCtx, const IStrategy& s, TBatchedVec<TBlobStates::value_type*> *finished = nullptr);
-    TBlobState& GetState(const TLogoBlobID &id); 
+    TBlobState& GetState(const TLogoBlobID &id);
     ssize_t AddPartMap(const TLogoBlobID &id, ui32 diskOrderNumber, ui32 requestIndex);
     void ReportPartMapStatus(const TLogoBlobID &id, ssize_t partMapIndex, ui32 responseIndex, NKikimrProto::EReplyStatus status);
     void GetWorstPredictedDelaysNs(const TBlobStorageGroupInfo &info, TGroupQueues &groupQueues,
             NKikimrBlobStorage::EVDiskQueueId queueId,
             ui64 *outWorstNs, ui64 *outNextToWorstNs, i32 *outWorstOrderNumber) const;
     TString ToString() const;
-    void ChangeAll() { 
-        for (auto &[id, blob] : BlobStates) { 
-            blob.IsChanged = true; 
-        } 
-    } 
+    void ChangeAll() {
+        for (auto &[id, blob] : BlobStates) {
+            blob.IsChanged = true;
+        }
+    }
 };
 
 }//NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_block.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_block.cpp
index 58130fdb1a..dba0a2fd43 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_block.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_block.cpp
@@ -148,7 +148,7 @@ public:
     {}
 
     void Bootstrap() {
-        A_LOG_DEBUG_S("DSPB05", "bootstrap" 
+        A_LOG_DEBUG_S("DSPB05", "bootstrap"
             << " ActorId# " << SelfId()
             << " Group# " << Info->GroupID
             << " TabletId# " << TabletId
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_get.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_get.cpp
index 0f5c32e24b..9b08b41861 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_get.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_get.cpp
@@ -57,8 +57,8 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
     bool IsPutAccelerated = false;
     bool IsPutAccelerateScheduled = false;
 
-    const bool IsVMultiPutMode = false; 
- 
+    const bool IsVMultiPutMode = false;
+
     void Handle(TEvAccelerateGet::TPtr &ev) {
         RootCauseTrack.OnAccelerate(ev->Get()->CauseIdx);
         AccelerateGet();
@@ -76,19 +76,19 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
         IsGetAccelerated = true;
 
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> vGets;
-        if (IsVMultiPutMode) { 
+        if (IsVMultiPutMode) {
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> vMultiPuts;
-            GetImpl.AccelerateGet(LogCtx, GetUnresponsiveDiskOrderNumber(), vGets, vMultiPuts); 
+            GetImpl.AccelerateGet(LogCtx, GetUnresponsiveDiskOrderNumber(), vGets, vMultiPuts);
             *Mon->NodeMon->AccelerateEvVMultiPutCount += vMultiPuts.size();
             *Mon->NodeMon->AccelerateEvVGetCount += vGets.size();
             SendVGetsAndVPuts(vGets, vMultiPuts);
-        } else { 
+        } else {
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-            GetImpl.AccelerateGet(LogCtx, GetUnresponsiveDiskOrderNumber(), vGets, vPuts); 
+            GetImpl.AccelerateGet(LogCtx, GetUnresponsiveDiskOrderNumber(), vGets, vPuts);
             *Mon->NodeMon->AccelerateEvVPutCount += vPuts.size();
             *Mon->NodeMon->AccelerateEvVGetCount += vGets.size();
             SendVGetsAndVPuts(vGets, vPuts);
-        } 
+        }
     }
 
     void AcceleratePut() {
@@ -98,19 +98,19 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
         IsPutAccelerated = true;
 
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> vGets;
-        if (IsVMultiPutMode) { 
+        if (IsVMultiPutMode) {
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> vMultiPuts;
-            GetImpl.AcceleratePut(LogCtx, GetUnresponsiveDiskOrderNumber(), vGets, vMultiPuts); 
+            GetImpl.AcceleratePut(LogCtx, GetUnresponsiveDiskOrderNumber(), vGets, vMultiPuts);
             *Mon->NodeMon->AccelerateEvVMultiPutCount += vMultiPuts.size();
             *Mon->NodeMon->AccelerateEvVGetCount += vGets.size();
             SendVGetsAndVPuts(vGets, vMultiPuts);
-        } else { 
+        } else {
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-            GetImpl.AcceleratePut(LogCtx, GetUnresponsiveDiskOrderNumber(), vGets, vPuts); 
+            GetImpl.AcceleratePut(LogCtx, GetUnresponsiveDiskOrderNumber(), vGets, vPuts);
             *Mon->NodeMon->AccelerateEvVPutCount += vPuts.size();
             *Mon->NodeMon->AccelerateEvVGetCount += vGets.size();
             SendVGetsAndVPuts(vGets, vPuts);
-        } 
+        }
     }
 
     template <typename TPutEvent>
@@ -237,16 +237,16 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> vGets;
         TAutoPtr<TEvBlobStorage::TEvGetResult> getResult;
         ResponsesReceived++;
-        if (IsVMultiPutMode) { 
+        if (IsVMultiPutMode) {
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> vMultiPuts;
-            GetImpl.OnVGetResult(LogCtx, *ev->Get(), vGets, vMultiPuts, getResult); 
+            GetImpl.OnVGetResult(LogCtx, *ev->Get(), vGets, vMultiPuts, getResult);
             SendVGetsAndVPuts(vGets, vMultiPuts);
-        } else { 
+        } else {
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-            GetImpl.OnVGetResult(LogCtx, *ev->Get(), vGets, vPuts, getResult); 
+            GetImpl.OnVGetResult(LogCtx, *ev->Get(), vGets, vPuts, getResult);
             SendVGetsAndVPuts(vGets, vPuts);
-        } 
- 
+        }
+
         if (getResult) {
             SendReplyAndDie(getResult);
             return;
@@ -254,7 +254,7 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
         Y_VERIFY(RequestsSent > ResponsesReceived, "RequestsSent# %" PRIu32 " ResponsesReceived# %" PRIu32
                 " GetImpl.DumpFullState# %s", RequestsSent, ResponsesReceived, GetImpl.DumpFullState().c_str());
 
-        TryScheduleGetAcceleration(); 
+        TryScheduleGetAcceleration();
         if (IsPutStarted) {
             TrySchedulePutAcceleration();
         }
@@ -274,80 +274,80 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
         ReplyAndDie(NKikimrProto::ERROR);
     }
 
-    TLogoBlobID GetFirstBlobId(TEvBlobStorage::TEvVPutResult::TPtr &ev) { 
-        return LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetBlobID()); 
-    } 
- 
-    TLogoBlobID GetFirstBlobId(TEvBlobStorage::TEvVMultiPutResult::TPtr &ev) { 
-        Y_VERIFY(ev->Get()->Record.ItemsSize()); 
-        return LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetItems(0).GetBlobID()); 
-    } 
- 
-    ui64 SumBlobSize(TEvBlobStorage::TEvVPutResult::TPtr &ev) { 
-        return GetFirstBlobId(ev).BlobSize(); 
-    } 
- 
-    ui64 SumBlobSize(TEvBlobStorage::TEvVMultiPutResult::TPtr &ev) { 
-        ui64 sum = 0; 
-        for (auto &item : ev->Get()->Record.GetItems()) { 
-            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-            sum += blobId.BlobSize(); 
-        } 
-        return sum; 
-    } 
- 
+    TLogoBlobID GetFirstBlobId(TEvBlobStorage::TEvVPutResult::TPtr &ev) {
+        return LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetBlobID());
+    }
+
+    TLogoBlobID GetFirstBlobId(TEvBlobStorage::TEvVMultiPutResult::TPtr &ev) {
+        Y_VERIFY(ev->Get()->Record.ItemsSize());
+        return LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetItems(0).GetBlobID());
+    }
+
+    ui64 SumBlobSize(TEvBlobStorage::TEvVPutResult::TPtr &ev) {
+        return GetFirstBlobId(ev).BlobSize();
+    }
+
+    ui64 SumBlobSize(TEvBlobStorage::TEvVMultiPutResult::TPtr &ev) {
+        ui64 sum = 0;
+        for (auto &item : ev->Get()->Record.GetItems()) {
+            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+            sum += blobId.BlobSize();
+        }
+        return sum;
+    }
+
     void Handle(TEvBlobStorage::TEvVPutResult::TPtr &ev) {
         ProcessReplyFromQueue(ev);
         HandleVPutResult<TEvBlobStorage::TEvVPut, TEvBlobStorage::TEvVPutResult>(ev);
-    } 
- 
+    }
+
     void Handle(TEvBlobStorage::TEvVMultiPutResult::TPtr &ev) {
         ProcessReplyFromQueue(ev);
         HandleVPutResult<TEvBlobStorage::TEvVMultiPut, TEvBlobStorage::TEvVMultiPutResult>(ev);
-    } 
- 
+    }
+
     bool HandleVPutInnerErrorStatuses(TEvBlobStorage::TEvVPutResult::TPtr &ev,
-            TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult) 
-    { 
+            TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult)
+    {
         Y_UNUSED(ev, outGetResult);
-        return false; 
-    } 
- 
+        return false;
+    }
+
     bool HandleVPutInnerErrorStatuses(TEvBlobStorage::TEvVMultiPutResult::TPtr &ev,
-            TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult) 
-    { 
-        const auto &record = ev->Get()->Record; 
-        const NKikimrProto::EReplyStatus status = record.GetStatus(); 
-        const TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
+            TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult)
+    {
+        const auto &record = ev->Get()->Record;
+        const NKikimrProto::EReplyStatus status = record.GetStatus();
+        const TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
 
         for (auto &item : record.GetItems()) {
-            Y_VERIFY(item.HasStatus()); 
-            Y_VERIFY(item.HasBlobID()); 
-            Y_VERIFY(item.HasCookie()); 
-            NKikimrProto::EReplyStatus itemStatus = item.GetStatus(); 
-            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
+            Y_VERIFY(item.HasStatus());
+            Y_VERIFY(item.HasBlobID());
+            Y_VERIFY(item.HasCookie());
+            NKikimrProto::EReplyStatus itemStatus = item.GetStatus();
+            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
             Y_VERIFY(itemStatus != NKikimrProto::RACE); // we should get RACE for the whole request and handle it in CheckForTermErrors
             if (itemStatus == NKikimrProto::BLOCKED || itemStatus == NKikimrProto::DEADLINE) {
-                R_LOG_ERROR_S("BPG26", "Handle TEvVMultiPutResultItem" 
-                    << " blobId# " << blobId.ToString() 
-                    << " status# " << NKikimrProto::EReplyStatus_Name(status) 
-                    << " itemStatus# " << NKikimrProto::EReplyStatus_Name(itemStatus)); 
-                TStringStream errorReason; 
-                errorReason << "Got VMultiPutResult itemStatus# " << itemStatus << " from VDiskId# " << vDiskId; 
-                ErrorReason = errorReason.Str(); 
-                GetImpl.PrepareReply(itemStatus, LogCtx, outGetResult); 
-                return true; 
-            } else { 
-                R_LOG_DEBUG_S("BPG27", "Handle TEvVMultiPutResultItem" 
-                    << " blobId# " << blobId.ToString() 
-                    << " status# " << NKikimrProto::EReplyStatus_Name(status) 
-                    << " itemStatus# " << NKikimrProto::EReplyStatus_Name(itemStatus)); 
-            } 
-        } 
-        return false; 
-    } 
- 
-    template <typename TPutEvent, typename TPutEventResult> 
+                R_LOG_ERROR_S("BPG26", "Handle TEvVMultiPutResultItem"
+                    << " blobId# " << blobId.ToString()
+                    << " status# " << NKikimrProto::EReplyStatus_Name(status)
+                    << " itemStatus# " << NKikimrProto::EReplyStatus_Name(itemStatus));
+                TStringStream errorReason;
+                errorReason << "Got VMultiPutResult itemStatus# " << itemStatus << " from VDiskId# " << vDiskId;
+                ErrorReason = errorReason.Str();
+                GetImpl.PrepareReply(itemStatus, LogCtx, outGetResult);
+                return true;
+            } else {
+                R_LOG_DEBUG_S("BPG27", "Handle TEvVMultiPutResultItem"
+                    << " blobId# " << blobId.ToString()
+                    << " status# " << NKikimrProto::EReplyStatus_Name(status)
+                    << " itemStatus# " << NKikimrProto::EReplyStatus_Name(itemStatus));
+            }
+        }
+        return false;
+    }
+
+    template <typename TPutEvent, typename TPutEventResult>
     void HandleVPutResult(typename TPutEventResult::TPtr &ev) {
         Y_VERIFY(ev->Get()->Record.HasStatus());
 
@@ -355,18 +355,18 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
 
         const ui64 cyclesPerUs = NHPTimer::GetCyclesPerSecond() / 1000000;
         ev->Get()->Record.MutableTimestamps()->SetReceivedByDSProxyUs(GetCycleCountFast() / cyclesPerUs);
-        const auto &record = ev->Get()->Record; 
+        const auto &record = ev->Get()->Record;
         const TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
         TVDiskIdShort shortId(vDiskId);
         const NKikimrProto::EReplyStatus status = record.GetStatus();
         NActors::NLog::EPriority priority = PriorityForStatusInbound(status);
-        A_LOG_LOG_S(priority != NActors::NLog::PRI_DEBUG, priority, "BPG30", "Handle VPuEventResult" 
+        A_LOG_LOG_S(priority != NActors::NLog::PRI_DEBUG, priority, "BPG30", "Handle VPuEventResult"
             << " status# " << NKikimrProto::EReplyStatus_Name(status).data()
             << " node# " << GetVDiskActorId(shortId).NodeId());
 
-        const TLogoBlobID blob = GetFirstBlobId(ev); 
-        ui64 sumBlobSize = SumBlobSize(ev); 
-        LWPROBE(DSProxyVDiskRequestDuration, TEvBlobStorage::EvVPut, sumBlobSize, blob.TabletID(), 
+        const TLogoBlobID blob = GetFirstBlobId(ev);
+        ui64 sumBlobSize = SumBlobSize(ev);
+        LWPROBE(DSProxyVDiskRequestDuration, TEvBlobStorage::EvVPut, sumBlobSize, blob.TabletID(),
                 Info->GroupID, blob.Channel(), Info->GetFailDomainOrderNumber(shortId),
                 GetStartTime(record.GetTimestamps()),
                 GetTotalTimeMs(record.GetTimestamps()),
@@ -395,10 +395,10 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
         ResponsesReceived++;
 
         if (HandleVPutInnerErrorStatuses(ev, getResult)) {
-            Y_VERIFY(getResult); 
+            Y_VERIFY(getResult);
             SendReplyAndDie(getResult);
-            return; 
-        } 
+            return;
+        }
         GetImpl.OnVPutResult(LogCtx, *ev->Get(), vGets, vPuts, getResult);
         SendVGetsAndVPuts(vGets, vPuts);
         if (getResult) {
@@ -412,25 +412,25 @@ class TBlobStorageGroupGetRequest : public TBlobStorageGroupRequestActor<TBlobSt
         SanityCheck(); // May Die
     }
 
-    void TryScheduleGetAcceleration() { 
-        if (!IsGetAccelerateScheduled && !IsGetAccelerated) { 
-            // Count VDisks that have requests in flight, if there is exactly one such VDisk, Accelerate 
-            if (CountDisksWithActiveRequests() <= 1) { 
-                ui64 timeToAccelerateUs = GetImpl.GetTimeToAccelerateGetNs(LogCtx) / 1000; 
-                TInstant now = TActivationContext::Now(); 
-                TDuration timeSinceStart = (now > StartTime) ? (now - StartTime) : TDuration::MilliSeconds(0); 
-                if (timeSinceStart.MicroSeconds() < timeToAccelerateUs) { 
-                    ui64 causeIdx = RootCauseTrack.RegisterAccelerate(); 
-                    Schedule(TDuration::MicroSeconds(timeToAccelerateUs - timeSinceStart.MicroSeconds()), 
-                            new TEvAccelerateGet(causeIdx)); 
-                    IsGetAccelerateScheduled = true; 
-                } else { 
-                    AccelerateGet(); 
-                } 
-            } 
-        } 
-    } 
- 
+    void TryScheduleGetAcceleration() {
+        if (!IsGetAccelerateScheduled && !IsGetAccelerated) {
+            // Count VDisks that have requests in flight, if there is exactly one such VDisk, Accelerate
+            if (CountDisksWithActiveRequests() <= 1) {
+                ui64 timeToAccelerateUs = GetImpl.GetTimeToAccelerateGetNs(LogCtx) / 1000;
+                TInstant now = TActivationContext::Now();
+                TDuration timeSinceStart = (now > StartTime) ? (now - StartTime) : TDuration::MilliSeconds(0);
+                if (timeSinceStart.MicroSeconds() < timeToAccelerateUs) {
+                    ui64 causeIdx = RootCauseTrack.RegisterAccelerate();
+                    Schedule(TDuration::MicroSeconds(timeToAccelerateUs - timeSinceStart.MicroSeconds()),
+                            new TEvAccelerateGet(causeIdx));
+                    IsGetAccelerateScheduled = true;
+                } else {
+                    AccelerateGet();
+                }
+            }
+        }
+    }
+
     void TrySchedulePutAcceleration() {
         if (!IsPutAccelerateScheduled && !IsPutAccelerated) {
             // Count VDisks that have requests in flight, if there is exactly one such VDisk, Accelerate
@@ -499,7 +499,7 @@ public:
             const TIntrusivePtr<TGroupQueues> &state, const TActorId &source,
             const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvGet *ev, ui64 cookie,
             NWilson::TTraceId traceId, TNodeLayoutInfoPtr&& nodeLayout, TMaybe<TGroupStat::EKind> latencyQueueKind,
-            TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, bool isVMultiPutMode) 
+            TInstant now, TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, bool isVMultiPutMode)
         : TBlobStorageGroupRequestActor(info, state, mon, source, cookie, std::move(traceId),
                 NKikimrServices::BS_PROXY_GET, ev->IsVerboseNoDataEnabled || ev->CollectDebugInfo,
                 latencyQueueKind, now, storagePoolCounters, ev->RestartCounter)
@@ -511,7 +511,7 @@ public:
         , RequestsSent(0)
         , ResponsesReceived(0)
         , ReportedBytes(0)
-        , IsVMultiPutMode(isVMultiPutMode) 
+        , IsVMultiPutMode(isVMultiPutMode)
     {
         ReportBytes(sizeof(*this));
         MaxSaneRequests = ev->QuerySize * info->Type.TotalPartCount() * (1 + info->Type.Handoff()) * 3;
@@ -543,7 +543,7 @@ public:
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
         GetImpl.GenerateInitialRequests(LogCtx, vGets);
         SendVGetsAndVPuts(vGets, vPuts);
-        TryScheduleGetAcceleration(); 
+        TryScheduleGetAcceleration();
 
         Y_VERIFY(RequestsSent > ResponsesReceived);
         Become(&TThis::StateWait);
@@ -578,9 +578,9 @@ IActor* CreateBlobStorageGroupGetRequest(const TIntrusivePtr<TBlobStorageGroupIn
         const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvGet *ev,
         ui64 cookie, NWilson::TTraceId traceId, TNodeLayoutInfoPtr&& nodeLayout,
         TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now,
-        TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, bool isVMultiPutMode) { 
+        TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, bool isVMultiPutMode) {
     return new TBlobStorageGroupGetRequest(info, state, source, mon, ev, cookie, std::move(traceId),
-            std::move(nodeLayout), latencyQueueKind, now, storagePoolCounters, isVMultiPutMode); 
+            std::move(nodeLayout), latencyQueueKind, now, storagePoolCounters, isVMultiPutMode);
 }
 
 }//NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_get_impl.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_get_impl.cpp
index ac8c9b66e3..0583b454df 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_get_impl.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_get_impl.cpp
@@ -1,5 +1,5 @@
 #include "dsproxy_get_impl.h"
-#include "dsproxy_put_impl.h" 
+#include "dsproxy_put_impl.h"
 
 #include "dsproxy_strategy_base.h"
 #include "dsproxy_blackboard.h"
@@ -211,10 +211,10 @@ TString TGetImpl::DumpFullState() const {
     str << Endl;
     str << " VPutResponses# " << VPutResponses;
     str << Endl;
-    str << " VMultiPutRequests# " << VMultiPutRequests; 
-    str << Endl; 
-    str << " VMultiPutResponses# " << VMultiPutResponses; 
-    str << Endl; 
+    str << " VMultiPutRequests# " << VMultiPutRequests;
+    str << Endl;
+    str << " VMultiPutResponses# " << VMultiPutResponses;
+    str << Endl;
 
     str << " IsNoData# " << IsNoData;
     str << Endl;
@@ -304,71 +304,71 @@ void TGetImpl::PrepareVPuts(TLogContext &logCtx,
             TVDiskID vDiskId = Info->GetVDiskId(diskOrderNumber);
             for (ui32 idx = beginIdx; idx < endIdx; ++idx) {
                 const TDiskPutRequest &put = requests.PutsToSend[idx];
-                ui64 cookie = TBlobCookie(diskOrderNumber, put.BlobIdx, put.Id.PartId(), 
-                        VPutRequests); 
+                ui64 cookie = TBlobCookie(diskOrderNumber, put.BlobIdx, put.Id.PartId(),
+                        VPutRequests);
                 auto vPut = std::make_unique<TEvBlobStorage::TEvVPut>(put.Id, put.Buffer, vDiskId, true, &cookie,
                     Deadline, Blackboard.PutHandleClass);
                 R_LOG_DEBUG_SX(logCtx, "BPG15", "Send put to orderNumber# " << diskOrderNumber << " idx# " << idx
                         << " vPut# " << vPut->ToString());
                 outVPuts.push_back(std::move(vPut));
                 ++VPutRequests;
-                ReceivedVPutResponses.push_back(false); 
+                ReceivedVPutResponses.push_back(false);
             }
             Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber].FirstUnsentPutIdx = endIdx;
         }
     }
 }
 
-void TGetImpl::PrepareVPuts(TLogContext &logCtx, 
+void TGetImpl::PrepareVPuts(TLogContext &logCtx,
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> &outVMultiPuts) {
-    for (ui32 diskOrderNumber = 0; diskOrderNumber < Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber.size(); 
-            ++diskOrderNumber) { 
-        const TDiskRequests &requests = Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber]; 
-        ui32 endIdx = requests.PutsToSend.size(); 
-        ui32 beginIdx = requests.FirstUnsentPutIdx; 
-        if (beginIdx < endIdx) { 
-            TVDiskID vDiskId = Info->GetVDiskId(diskOrderNumber); 
-            // set cookie after adding items 
+    for (ui32 diskOrderNumber = 0; diskOrderNumber < Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber.size();
+            ++diskOrderNumber) {
+        const TDiskRequests &requests = Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber];
+        ui32 endIdx = requests.PutsToSend.size();
+        ui32 beginIdx = requests.FirstUnsentPutIdx;
+        if (beginIdx < endIdx) {
+            TVDiskID vDiskId = Info->GetVDiskId(diskOrderNumber);
+            // set cookie after adding items
             auto vMultiPut = std::make_unique<TEvBlobStorage::TEvVMultiPut>(vDiskId, Deadline, Blackboard.PutHandleClass,
                 true, nullptr);
-            ui64 bytes = 0; 
-            ui64 lastItemCount = 0; 
-            for (ui32 idx = beginIdx; idx < endIdx; ++idx) { 
-                const TDiskPutRequest &put = requests.PutsToSend[idx]; 
-                ui64 cookie = TBlobCookie(diskOrderNumber, put.BlobIdx, put.Id.PartId(), VMultiPutRequests); 
-                ui64 itemSize = vMultiPut->Record.ItemsSize(); 
-                if (itemSize == MaxBatchedPutRequests || bytes + put.Buffer.size() > MaxBatchedPutSize) { 
-                    vMultiPut->Record.SetCookie(TVMultiPutCookie(diskOrderNumber, lastItemCount, VMultiPutRequests)); 
-                    ++VMultiPutRequests; 
-                    ReceivedVMultiPutResponses.push_back(false); 
-                    R_LOG_DEBUG_SX(logCtx, "BPG16", "Send multiPut to orderNumber# " << diskOrderNumber << " count# " 
-                            << vMultiPut->Record.ItemsSize() << " vMultiPut# " << vMultiPut->ToString()); 
+            ui64 bytes = 0;
+            ui64 lastItemCount = 0;
+            for (ui32 idx = beginIdx; idx < endIdx; ++idx) {
+                const TDiskPutRequest &put = requests.PutsToSend[idx];
+                ui64 cookie = TBlobCookie(diskOrderNumber, put.BlobIdx, put.Id.PartId(), VMultiPutRequests);
+                ui64 itemSize = vMultiPut->Record.ItemsSize();
+                if (itemSize == MaxBatchedPutRequests || bytes + put.Buffer.size() > MaxBatchedPutSize) {
+                    vMultiPut->Record.SetCookie(TVMultiPutCookie(diskOrderNumber, lastItemCount, VMultiPutRequests));
+                    ++VMultiPutRequests;
+                    ReceivedVMultiPutResponses.push_back(false);
+                    R_LOG_DEBUG_SX(logCtx, "BPG16", "Send multiPut to orderNumber# " << diskOrderNumber << " count# "
+                            << vMultiPut->Record.ItemsSize() << " vMultiPut# " << vMultiPut->ToString());
                     outVMultiPuts.push_back(std::move(vMultiPut));
-                    // set cookie after adding items 
+                    // set cookie after adding items
                     vMultiPut = std::make_unique<TEvBlobStorage::TEvVMultiPut>(vDiskId, Deadline,
                         Blackboard.PutHandleClass, true, nullptr);
-                    bytes = 0; 
-                    lastItemCount = 0; 
-                } 
-                bytes += put.Buffer.size(); 
-                lastItemCount++; 
-                vMultiPut->AddVPut(put.Id, put.Buffer, &cookie); 
-            } 
-            vMultiPut->Record.SetCookie(TVMultiPutCookie(diskOrderNumber, lastItemCount, VMultiPutRequests)); 
-            ++VMultiPutRequests; 
-            ReceivedVMultiPutResponses.push_back(false); 
-            R_LOG_DEBUG_SX(logCtx, "BPG17", "Send multiPut to orderNumber# " << diskOrderNumber << " count# " 
-                    << vMultiPut->Record.ItemsSize() << " vMultiPut# " << vMultiPut->ToString()); 
+                    bytes = 0;
+                    lastItemCount = 0;
+                }
+                bytes += put.Buffer.size();
+                lastItemCount++;
+                vMultiPut->AddVPut(put.Id, put.Buffer, &cookie);
+            }
+            vMultiPut->Record.SetCookie(TVMultiPutCookie(diskOrderNumber, lastItemCount, VMultiPutRequests));
+            ++VMultiPutRequests;
+            ReceivedVMultiPutResponses.push_back(false);
+            R_LOG_DEBUG_SX(logCtx, "BPG17", "Send multiPut to orderNumber# " << diskOrderNumber << " count# "
+                    << vMultiPut->Record.ItemsSize() << " vMultiPut# " << vMultiPut->ToString());
             outVMultiPuts.push_back(std::move(vMultiPut));
-            Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber].FirstUnsentPutIdx = endIdx; 
-        } 
-    } 
-} 
- 
+            Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber].FirstUnsentPutIdx = endIdx;
+        }
+    }
+}
+
 EStrategyOutcome TGetImpl::RunBoldStrategy(TLogContext &logCtx) {
     EStrategyOutcome outcome = Blackboard.RunStrategy(logCtx, TBoldStrategy(PhantomCheck));
     if (outcome == EStrategyOutcome::DONE && MustRestoreFirst) {
-        Blackboard.ChangeAll(); 
+        Blackboard.ChangeAll();
         outcome = Blackboard.RunStrategy(logCtx, TRestoreStrategy());
     }
     return outcome;
@@ -384,7 +384,7 @@ EStrategyOutcome TGetImpl::RunMirror3of4Strategy(TLogContext &logCtx) {
     // run basic get strategy and, if blob restoration is required and we have successful get, restore the blob to full amount of parts
     EStrategyOutcome outcome = Blackboard.RunStrategy(logCtx, TMirror3of4GetStrategy());
     if (outcome == EStrategyOutcome::DONE && MustRestoreFirst) {
-        Blackboard.ChangeAll(); 
+        Blackboard.ChangeAll();
         outcome = Blackboard.RunStrategy(logCtx, TPut3of4Strategy(TEvBlobStorage::TEvPut::TacticMaxThroughput));
     }
     return outcome;
@@ -416,17 +416,17 @@ void TGetImpl::OnVPutResult(TLogContext &logCtx, TEvBlobStorage::TEvVPutResult &
     ui32 orderNumber = Info->GetOrderNumber(shortId);
     const TLogoBlobID blob = LogoBlobIDFromLogoBlobID(record.GetBlobID());
 
-    Y_VERIFY(record.HasCookie()); 
-    TBlobCookie cookie(record.GetCookie()); 
-    Y_VERIFY(cookie.GetVDiskOrderNumber() == orderNumber); 
-    Y_VERIFY(cookie.GetPartId() == blob.PartId()); 
- 
-    ui64 requestIdx = cookie.GetRequestIdx(); 
-    Y_VERIFY_S(!ReceivedVPutResponses[requestIdx], "the response is received twice" 
-            << " Event# " << ev.ToString() 
-            << " State# " << DumpFullState()); 
-    ReceivedVPutResponses[requestIdx] = true; 
- 
+    Y_VERIFY(record.HasCookie());
+    TBlobCookie cookie(record.GetCookie());
+    Y_VERIFY(cookie.GetVDiskOrderNumber() == orderNumber);
+    Y_VERIFY(cookie.GetPartId() == blob.PartId());
+
+    ui64 requestIdx = cookie.GetRequestIdx();
+    Y_VERIFY_S(!ReceivedVPutResponses[requestIdx], "the response is received twice"
+            << " Event# " << ev.ToString()
+            << " State# " << DumpFullState());
+    ReceivedVPutResponses[requestIdx] = true;
+
     const NKikimrProto::EReplyStatus status = record.GetStatus();
     ++VPutResponses;
     switch (status) {
@@ -445,50 +445,50 @@ void TGetImpl::OnVPutResult(TLogContext &logCtx, TEvBlobStorage::TEvVPutResult &
     Step(logCtx, outVGets, outVPuts, outGetResult);
 }
 
-void TGetImpl::OnVPutResult(TLogContext &logCtx, TEvBlobStorage::TEvVMultiPutResult &ev, 
+void TGetImpl::OnVPutResult(TLogContext &logCtx, TEvBlobStorage::TEvVMultiPutResult &ev,
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets,
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> &outVMultiPuts,
-        TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult) { 
-    const NKikimrBlobStorage::TEvVMultiPutResult &record = ev.Record; 
-    Y_VERIFY(record.HasVDiskID()); 
-    TVDiskID vdisk = VDiskIDFromVDiskID(record.GetVDiskID()); 
-    TVDiskIdShort shortId(vdisk); 
-    ui32 orderNumber = Info->GetOrderNumber(shortId); 
- 
-    Y_VERIFY(record.HasCookie()); 
-    TVMultiPutCookie cookie(record.GetCookie()); 
-    Y_VERIFY(cookie.GetVDiskOrderNumber() == orderNumber); 
-    Y_VERIFY(cookie.GetItemCount() == record.ItemsSize()); 
- 
-    ui64 requestIdx = cookie.GetRequestIdx(); 
-    Y_VERIFY_S(!ReceivedVMultiPutResponses[requestIdx], "the response is received twice" 
-            << " Event# " << ev.ToString() 
-            << " State# " << DumpFullState()); 
-    ReceivedVMultiPutResponses[requestIdx] = true; 
- 
-    ++VMultiPutResponses; 
-    for (auto &item : record.GetItems()) { 
-        const NKikimrProto::EReplyStatus status = item.GetStatus(); 
-        const TLogoBlobID blob = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-        Y_VERIFY(item.HasCookie()); 
-        TBlobCookie itemCookie(item.GetCookie()); 
-        Y_VERIFY(itemCookie.GetVDiskOrderNumber() == orderNumber); 
-        Y_VERIFY(itemCookie.GetPartId() == blob.PartId()); 
-        switch (status) { 
-            case NKikimrProto::ERROR: 
-            case NKikimrProto::VDISK_ERROR_STATE: 
-            case NKikimrProto::OUT_OF_SPACE: 
-                Blackboard.AddErrorResponse(blob, orderNumber); 
-                break; 
-            case NKikimrProto::OK: 
-            case NKikimrProto::ALREADY: 
-                Blackboard.AddPutOkResponse(blob, orderNumber); 
-                break; 
-            default: 
-            Y_FAIL("Unexpected status# %s", NKikimrProto::EReplyStatus_Name(status).data()); 
-        } 
-    } 
-    Step(logCtx, outVGets, outVMultiPuts, outGetResult); 
-} 
- 
+        TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult) {
+    const NKikimrBlobStorage::TEvVMultiPutResult &record = ev.Record;
+    Y_VERIFY(record.HasVDiskID());
+    TVDiskID vdisk = VDiskIDFromVDiskID(record.GetVDiskID());
+    TVDiskIdShort shortId(vdisk);
+    ui32 orderNumber = Info->GetOrderNumber(shortId);
+
+    Y_VERIFY(record.HasCookie());
+    TVMultiPutCookie cookie(record.GetCookie());
+    Y_VERIFY(cookie.GetVDiskOrderNumber() == orderNumber);
+    Y_VERIFY(cookie.GetItemCount() == record.ItemsSize());
+
+    ui64 requestIdx = cookie.GetRequestIdx();
+    Y_VERIFY_S(!ReceivedVMultiPutResponses[requestIdx], "the response is received twice"
+            << " Event# " << ev.ToString()
+            << " State# " << DumpFullState());
+    ReceivedVMultiPutResponses[requestIdx] = true;
+
+    ++VMultiPutResponses;
+    for (auto &item : record.GetItems()) {
+        const NKikimrProto::EReplyStatus status = item.GetStatus();
+        const TLogoBlobID blob = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+        Y_VERIFY(item.HasCookie());
+        TBlobCookie itemCookie(item.GetCookie());
+        Y_VERIFY(itemCookie.GetVDiskOrderNumber() == orderNumber);
+        Y_VERIFY(itemCookie.GetPartId() == blob.PartId());
+        switch (status) {
+            case NKikimrProto::ERROR:
+            case NKikimrProto::VDISK_ERROR_STATE:
+            case NKikimrProto::OUT_OF_SPACE:
+                Blackboard.AddErrorResponse(blob, orderNumber);
+                break;
+            case NKikimrProto::OK:
+            case NKikimrProto::ALREADY:
+                Blackboard.AddPutOkResponse(blob, orderNumber);
+                break;
+            default:
+            Y_FAIL("Unexpected status# %s", NKikimrProto::EReplyStatus_Name(status).data());
+        }
+    }
+    Step(logCtx, outVGets, outVMultiPuts, outGetResult);
+}
+
 }//NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_get_impl.h b/ydb/core/blobstorage/dsproxy/dsproxy_get_impl.h
index 809900c34a..4908ae9bda 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_get_impl.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_get_impl.h
@@ -32,8 +32,8 @@ class TGetImpl {
     ui32 BlockedGeneration = 0;
     ui32 VPutRequests = 0;
     ui32 VPutResponses = 0;
-    ui32 VMultiPutRequests = 0; 
-    ui32 VMultiPutResponses = 0; 
+    ui32 VMultiPutRequests = 0;
+    ui32 VMultiPutResponses = 0;
 
     bool IsNoData = false;
     bool IsReplied = false;
@@ -44,9 +44,9 @@ class TGetImpl {
     ui32 RequestIndex = 0;
     ui32 ResponseIndex = 0;
 
-    TStackVec<bool, MaxBatchedPutRequests * TypicalDisksInSubring> ReceivedVPutResponses; 
-    TStackVec<bool, MaxBatchedPutRequests * TypicalDisksInSubring> ReceivedVMultiPutResponses; 
- 
+    TStackVec<bool, MaxBatchedPutRequests * TypicalDisksInSubring> ReceivedVPutResponses;
+    TStackVec<bool, MaxBatchedPutRequests * TypicalDisksInSubring> ReceivedVMultiPutResponses;
+
     const TString RequestPrefix;
 
     const bool PhantomCheck;
@@ -128,155 +128,155 @@ public:
         return str.Str();
     }
 
-    ui64 GetVPutRequests() const { 
-        return VPutRequests; 
-    } 
- 
-    ui64 GetVPutResponses() const { 
-        return VPutResponses; 
-    } 
- 
-    ui64 GetVMultiPutRequests() const { 
-        return VMultiPutRequests; 
-    } 
- 
-    ui64 GetVMultiPutResponses() const { 
-        return VMultiPutResponses; 
-    } 
- 
-    ui64 GetRequestIndex() const { 
-        return RequestIndex; 
-    } 
- 
-    ui64 GetResponseIndex() const { 
-        return ResponseIndex; 
-    } 
- 
- 
+    ui64 GetVPutRequests() const {
+        return VPutRequests;
+    }
+
+    ui64 GetVPutResponses() const {
+        return VPutResponses;
+    }
+
+    ui64 GetVMultiPutRequests() const {
+        return VMultiPutRequests;
+    }
+
+    ui64 GetVMultiPutResponses() const {
+        return VMultiPutResponses;
+    }
+
+    ui64 GetRequestIndex() const {
+        return RequestIndex;
+    }
+
+    ui64 GetResponseIndex() const {
+        return ResponseIndex;
+    }
+
+
     void GenerateInitialRequests(TLogContext &logCtx, TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets);
 
-    template <typename TVPutEvent> 
+    template <typename TVPutEvent>
     void OnVGetResult(TLogContext &logCtx, TEvBlobStorage::TEvVGetResult &ev,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets, TDeque<std::unique_ptr<TVPutEvent>> &outVPuts,
-            TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult) { 
-        const NKikimrBlobStorage::TEvVGetResult &record = ev.Record; 
-        Y_VERIFY(record.HasStatus()); 
-        const NKikimrProto::EReplyStatus status = record.GetStatus(); 
-        Y_VERIFY(status != NKikimrProto::RACE && status != NKikimrProto::BLOCKED && status != NKikimrProto::DEADLINE); 
-        R_LOG_DEBUG_SX(logCtx, "BPG57", "handle result# " << ev.ToString()); 
-
-        Y_VERIFY(record.HasVDiskID()); 
-        TVDiskID vdisk = VDiskIDFromVDiskID(record.GetVDiskID()); 
-        TVDiskIdShort shortId(vdisk); 
-        ui32 orderNumber = Info->GetOrderNumber(shortId); 
-        { 
-            NActors::NLog::EPriority priority = PriorityForStatusInbound(record.GetStatus()); 
-            A_LOG_LOG_SX(logCtx, priority != NActors::NLog::PRI_DEBUG, priority, "BPG12", "Handle TEvVGetResult" 
-                << " status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()).data() 
-                << " From# " << vdisk.ToString() 
-                << " orderNumber# " << orderNumber 
-                << " ev " << ev.ToString()); 
-        } 
- 
-        BlockedGeneration = Max(BlockedGeneration, record.GetBlockedGeneration()); 
- 
-        Y_VERIFY(record.ResultSize() > 0, "ev# %s vdisk# %s", ev.ToString().data(), vdisk.ToString().data()); 
-        for (ui32 i = 0, e = (ui32)record.ResultSize(); i != e; ++i) { 
-            const NKikimrBlobStorage::TQueryResult &result = record.GetResult(i); 
-            Y_VERIFY(result.HasStatus()); 
-            const NKikimrProto::EReplyStatus replyStatus = result.GetStatus(); 
-            Y_VERIFY(result.HasCookie()); 
-            const ui64 cookie = result.GetCookie(); 
-            Y_VERIFY(result.HasBlobID()); 
-            const TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(result.GetBlobID()); 
- 
-            if (ReportDetailedPartMap) { 
-                Blackboard.ReportPartMapStatus(blobId, 
-                    Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[orderNumber].GetsToSend[cookie].PartMapIndex, 
-                    ResponseIndex, 
-                    replyStatus); 
-            } 
- 
-            TString resultBuffer = result.HasBuffer() ? result.GetBuffer() : TString(); 
-            ui32 resultShift = result.HasShift() ? result.GetShift() : 0; 
- 
-            // Currently CRC can be checked only if blob part is fully read 
-            if (resultShift == 0 && resultBuffer.size() == Info->Type.PartSize(blobId)) { 
-                bool isCrcOk = CheckCrcAtTheEnd((TErasureType::ECrcMode)blobId.CrcMode(), resultBuffer); 
-                if (!isCrcOk) { 
-                    R_LOG_ERROR_SX(logCtx, "BPG66", "Error in CheckCrcAtTheEnd on TEvVGetResult, blobId# " << blobId 
-                            << " resultShift# " << resultShift << " resultBuffer.Size()# " << resultBuffer.size()); 
-                    NKikimrBlobStorage::TQueryResult *mutableResult = ev.Record.MutableResult(i); 
-                    mutableResult->SetStatus(NKikimrProto::ERROR); 
-                } 
-            } 
- 
-            if (replyStatus == NKikimrProto::OK) { 
-                // TODO(cthulhu): Verify shift and response size, and cookie 
-                R_LOG_DEBUG_SX(logCtx, "BPG58", "Got# OK orderNumber# " << orderNumber << " vDiskId# " << vdisk.ToString()); 
-                Blackboard.AddResponseData(blobId, orderNumber, resultShift, resultBuffer); 
-            } else if (replyStatus == NKikimrProto::NODATA) { 
-                R_LOG_DEBUG_SX(logCtx, "BPG59", "Got# NODATA orderNumber# " << orderNumber 
-                        << " vDiskId# " << vdisk.ToString()); 
-                Blackboard.AddNoDataResponse(blobId, orderNumber); 
-            } else if (replyStatus == NKikimrProto::ERROR 
-                    || replyStatus == NKikimrProto::VDISK_ERROR_STATE 
-                    || replyStatus == NKikimrProto::CORRUPTED) { 
-                R_LOG_DEBUG_SX(logCtx, "BPG60", "Got# " << NKikimrProto::EReplyStatus_Name(replyStatus).data() 
-                    << " orderNumber# " << orderNumber << " vDiskId# " << vdisk.ToString()); 
-                Blackboard.AddErrorResponse(blobId, orderNumber); 
-            } else if (replyStatus == NKikimrProto::NOT_YET) { 
+            TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult) {
+        const NKikimrBlobStorage::TEvVGetResult &record = ev.Record;
+        Y_VERIFY(record.HasStatus());
+        const NKikimrProto::EReplyStatus status = record.GetStatus();
+        Y_VERIFY(status != NKikimrProto::RACE && status != NKikimrProto::BLOCKED && status != NKikimrProto::DEADLINE);
+        R_LOG_DEBUG_SX(logCtx, "BPG57", "handle result# " << ev.ToString());
+
+        Y_VERIFY(record.HasVDiskID());
+        TVDiskID vdisk = VDiskIDFromVDiskID(record.GetVDiskID());
+        TVDiskIdShort shortId(vdisk);
+        ui32 orderNumber = Info->GetOrderNumber(shortId);
+        {
+            NActors::NLog::EPriority priority = PriorityForStatusInbound(record.GetStatus());
+            A_LOG_LOG_SX(logCtx, priority != NActors::NLog::PRI_DEBUG, priority, "BPG12", "Handle TEvVGetResult"
+                << " status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()).data()
+                << " From# " << vdisk.ToString()
+                << " orderNumber# " << orderNumber
+                << " ev " << ev.ToString());
+        }
+
+        BlockedGeneration = Max(BlockedGeneration, record.GetBlockedGeneration());
+
+        Y_VERIFY(record.ResultSize() > 0, "ev# %s vdisk# %s", ev.ToString().data(), vdisk.ToString().data());
+        for (ui32 i = 0, e = (ui32)record.ResultSize(); i != e; ++i) {
+            const NKikimrBlobStorage::TQueryResult &result = record.GetResult(i);
+            Y_VERIFY(result.HasStatus());
+            const NKikimrProto::EReplyStatus replyStatus = result.GetStatus();
+            Y_VERIFY(result.HasCookie());
+            const ui64 cookie = result.GetCookie();
+            Y_VERIFY(result.HasBlobID());
+            const TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(result.GetBlobID());
+
+            if (ReportDetailedPartMap) {
+                Blackboard.ReportPartMapStatus(blobId,
+                    Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[orderNumber].GetsToSend[cookie].PartMapIndex,
+                    ResponseIndex,
+                    replyStatus);
+            }
+
+            TString resultBuffer = result.HasBuffer() ? result.GetBuffer() : TString();
+            ui32 resultShift = result.HasShift() ? result.GetShift() : 0;
+
+            // Currently CRC can be checked only if blob part is fully read
+            if (resultShift == 0 && resultBuffer.size() == Info->Type.PartSize(blobId)) {
+                bool isCrcOk = CheckCrcAtTheEnd((TErasureType::ECrcMode)blobId.CrcMode(), resultBuffer);
+                if (!isCrcOk) {
+                    R_LOG_ERROR_SX(logCtx, "BPG66", "Error in CheckCrcAtTheEnd on TEvVGetResult, blobId# " << blobId
+                            << " resultShift# " << resultShift << " resultBuffer.Size()# " << resultBuffer.size());
+                    NKikimrBlobStorage::TQueryResult *mutableResult = ev.Record.MutableResult(i);
+                    mutableResult->SetStatus(NKikimrProto::ERROR);
+                }
+            }
+
+            if (replyStatus == NKikimrProto::OK) {
+                // TODO(cthulhu): Verify shift and response size, and cookie
+                R_LOG_DEBUG_SX(logCtx, "BPG58", "Got# OK orderNumber# " << orderNumber << " vDiskId# " << vdisk.ToString());
+                Blackboard.AddResponseData(blobId, orderNumber, resultShift, resultBuffer);
+            } else if (replyStatus == NKikimrProto::NODATA) {
+                R_LOG_DEBUG_SX(logCtx, "BPG59", "Got# NODATA orderNumber# " << orderNumber
+                        << " vDiskId# " << vdisk.ToString());
+                Blackboard.AddNoDataResponse(blobId, orderNumber);
+            } else if (replyStatus == NKikimrProto::ERROR
+                    || replyStatus == NKikimrProto::VDISK_ERROR_STATE
+                    || replyStatus == NKikimrProto::CORRUPTED) {
+                R_LOG_DEBUG_SX(logCtx, "BPG60", "Got# " << NKikimrProto::EReplyStatus_Name(replyStatus).data()
+                    << " orderNumber# " << orderNumber << " vDiskId# " << vdisk.ToString());
+                Blackboard.AddErrorResponse(blobId, orderNumber);
+            } else if (replyStatus == NKikimrProto::NOT_YET) {
                 R_LOG_DEBUG_SX(logCtx, "BPG67", "Got# NOT_YET orderNumber# " << orderNumber
-                        << " vDiskId# " << vdisk.ToString()); 
-                Blackboard.AddNotYetResponse(blobId, orderNumber); 
-            } else { 
-                Y_VERIFY(false, "Unexpected reply status# %s", NKikimrProto::EReplyStatus_Name(replyStatus).data()); 
-            } 
-        } 
- 
-        ++ResponseIndex; 
- 
-        Step(logCtx, outVGets, outVPuts, outGetResult); 
-    } 
- 
+                        << " vDiskId# " << vdisk.ToString());
+                Blackboard.AddNotYetResponse(blobId, orderNumber);
+            } else {
+                Y_VERIFY(false, "Unexpected reply status# %s", NKikimrProto::EReplyStatus_Name(replyStatus).data());
+            }
+        }
+
+        ++ResponseIndex;
+
+        Step(logCtx, outVGets, outVPuts, outGetResult);
+    }
+
     void OnVPutResult(TLogContext &logCtx, TEvBlobStorage::TEvVPutResult &ev,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> &outVPuts,
             TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult);
 
-    void OnVPutResult(TLogContext &logCtx, TEvBlobStorage::TEvVMultiPutResult &ev, 
+    void OnVPutResult(TLogContext &logCtx, TEvBlobStorage::TEvVMultiPutResult &ev,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> &outVMultiPuts,
-            TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult); 
- 
+            TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult);
+
     void PrepareReply(NKikimrProto::EReplyStatus status, TLogContext &logCtx,
             TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult);
 
-    template <typename TVPutEvent> 
+    template <typename TVPutEvent>
     void AccelerateGet(TLogContext &logCtx, i32 slowDiskOrderNumber,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets, TDeque<std::unique_ptr<TVPutEvent>> &outVPuts) {
-        TAutoPtr<TEvBlobStorage::TEvGetResult> outGetResult; 
-        TBlackboard::EAccelerationMode prevMode = Blackboard.AccelerationMode; 
-        Blackboard.AccelerationMode = TBlackboard::AccelerationModeSkipMarked; 
-        for (auto it = Blackboard.BlobStates.begin(); it != Blackboard.BlobStates.end(); ++it) { 
-            TStackVec<TBlobState::TDisk, TypicalDisksInSubring> &disks = it->second.Disks; 
-            for (ui32 i = 0; i < disks.size(); ++i) { 
-                TBlobState::TDisk &disk = disks[i]; 
-                disk.IsSlow = ((i32)disk.OrderNumber == slowDiskOrderNumber); 
-            } 
-        } 
+        TAutoPtr<TEvBlobStorage::TEvGetResult> outGetResult;
+        TBlackboard::EAccelerationMode prevMode = Blackboard.AccelerationMode;
+        Blackboard.AccelerationMode = TBlackboard::AccelerationModeSkipMarked;
+        for (auto it = Blackboard.BlobStates.begin(); it != Blackboard.BlobStates.end(); ++it) {
+            TStackVec<TBlobState::TDisk, TypicalDisksInSubring> &disks = it->second.Disks;
+            for (ui32 i = 0; i < disks.size(); ++i) {
+                TBlobState::TDisk &disk = disks[i];
+                disk.IsSlow = ((i32)disk.OrderNumber == slowDiskOrderNumber);
+            }
+        }
         Blackboard.ChangeAll();
-        Step(logCtx, outVGets, outVPuts, outGetResult); 
-        Blackboard.AccelerationMode = prevMode; 
+        Step(logCtx, outVGets, outVPuts, outGetResult);
+        Blackboard.AccelerationMode = prevMode;
         Y_VERIFY(!outGetResult, "%s Unexpected get result in AccelerateGet, outGetResult# %s, DumpFullState# %s",
             RequestPrefix.data(), outGetResult->Print(false).c_str(), DumpFullState().c_str());
-    } 
+    }
 
-    template <typename TVPutEvent> 
+    template <typename TVPutEvent>
     void AcceleratePut(TLogContext &logCtx, i32 slowDiskOrderNumber,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets, TDeque<std::unique_ptr<TVPutEvent>> &outVPuts) {
-        AccelerateGet(logCtx, slowDiskOrderNumber, outVGets, outVPuts); 
-    } 
+        AccelerateGet(logCtx, slowDiskOrderNumber, outVGets, outVPuts);
+    }
 
     ui64 GetTimeToAccelerateGetNs(TLogContext &logCtx);
     ui64 GetTimeToAcceleratePutNs(TLogContext &logCtx);
@@ -289,8 +289,8 @@ protected:
     EStrategyOutcome RunMirror3of4Strategy(TLogContext &logCtx);
     EStrategyOutcome RunStrategies(TLogContext &logCtx);
 
-    // Returns true if there are additional requests to send 
-    template <typename TVPutEvent> 
+    // Returns true if there are additional requests to send
+    template <typename TVPutEvent>
     bool Step(TLogContext &logCtx, TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets,
             TDeque<std::unique_ptr<TVPutEvent>> &outVPuts, TAutoPtr<TEvBlobStorage::TEvGetResult> &outGetResult) {
         switch (auto outcome = RunStrategies(logCtx)) {
@@ -309,14 +309,14 @@ protected:
             case EStrategyOutcome::DONE:
                 PrepareReply(NKikimrProto::OK, logCtx, outGetResult);
                 return false;
-        } 
-    } 
- 
+        }
+    }
+
     void PrepareRequests(TLogContext &logCtx,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &outVGets);
     void PrepareVPuts(TLogContext &logCtx,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> &outVPuts);
-    void PrepareVPuts(TLogContext &logCtx, 
+    void PrepareVPuts(TLogContext &logCtx,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> &outVMultiPuts);
 
     ui64 GetTimeToAccelerateNs(TLogContext &logCtx, NKikimrBlobStorage::EVDiskQueueId queueId);
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_impl.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_impl.cpp
index c74b0bcc9a..dbf547ae74 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_impl.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_impl.cpp
@@ -4,7 +4,7 @@ namespace NKikimr {
 
     TBlobStorageGroupProxy::TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
             TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
-            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch) 
+            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch)
         : GroupId(info->GroupID)
         , Info(std::move(info))
         , Topology(Info->PickTopology())
@@ -12,36 +12,36 @@ namespace NKikimr {
         , StoragePoolCounters(std::move(storagePoolCounters))
         , IsEjected(false)
         , ForceWaitAllDrives(forceWaitAllDrives)
-        , EnablePutBatching(enablePutBatching) 
-        , EnableVPatch(enableVPatch) 
+        , EnablePutBatching(enablePutBatching)
+        , EnableVPatch(enableVPatch)
     {}
 
     TBlobStorageGroupProxy::TBlobStorageGroupProxy(ui32 groupId, bool isEjected, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
-            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch) 
+            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch)
         : GroupId(groupId)
         , NodeMon(nodeMon)
         , IsEjected(isEjected)
         , ForceWaitAllDrives(false)
-        , EnablePutBatching(enablePutBatching) 
-        , EnableVPatch(enableVPatch) 
+        , EnablePutBatching(enablePutBatching)
+        , EnableVPatch(enableVPatch)
     {}
 
     IActor* CreateBlobStorageGroupEjectedProxy(ui32 groupId, TIntrusivePtr<TDsProxyNodeMon> &nodeMon) {
-        return new TBlobStorageGroupProxy(groupId, true, nodeMon, TControlWrapper(false, false, true), 
-                TControlWrapper(false, false, true)); 
+        return new TBlobStorageGroupProxy(groupId, true, nodeMon, TControlWrapper(false, false, true),
+                TControlWrapper(false, false, true));
     }
 
     IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
             TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
-            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch) { 
+            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch) {
         Y_VERIFY(info);
         return new TBlobStorageGroupProxy(std::move(info), forceWaitAllDrives, nodeMon, std::move(storagePoolCounters),
-                enablePutBatching, enableVPatch); 
+                enablePutBatching, enableVPatch);
     }
 
     IActor* CreateBlobStorageGroupProxyUnconfigured(ui32 groupId, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
-            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch) { 
-        return new TBlobStorageGroupProxy(groupId, false, nodeMon, enablePutBatching, enableVPatch); 
+            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch) {
+        return new TBlobStorageGroupProxy(groupId, false, nodeMon, enablePutBatching, enableVPatch);
     }
 
     NActors::NLog::EPriority PriorityForStatusOutbound(NKikimrProto::EReplyStatus status) {
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_impl.h b/ydb/core/blobstorage/dsproxy/dsproxy_impl.h
index 22c7736bb3..508eb10a05 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_impl.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_impl.h
@@ -101,8 +101,8 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
     TBatchedQueue<TEvBlobStorage::TEvGet::TPtr> BatchedGets[GetHandleClassCount];
     TStackVec<NKikimrBlobStorage::EGetHandleClass, GetHandleClassCount> GetBatchedBucketQueue;
 
-    TMemorizableControlWrapper EnablePutBatching; 
-    TMemorizableControlWrapper EnableVPatch; 
+    TMemorizableControlWrapper EnablePutBatching;
+    TMemorizableControlWrapper EnableVPatch;
 
     TInstant EstablishingSessionStartTime;
 
@@ -300,10 +300,10 @@ public:
 
     TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
             TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
-            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch); 
+            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch);
 
     TBlobStorageGroupProxy(ui32 groupId, bool isEjected, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
-            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch); 
+            const TControlWrapper &enablePutBatching, const TControlWrapper &enableVPatch);
 
     void Bootstrap();
 
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_mon.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_mon.cpp
index 50bfb3e3eb..73afac8121 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_mon.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_mon.cpp
@@ -44,13 +44,13 @@ TBlobStorageGroupProxyMon::TBlobStorageGroupProxyMon(const TIntrusivePtr<NMonito
     EventIndexRestoreGet = EventGroup->GetCounter("EvIndexRestoreGet", true);
     EventMultiCollect = EventGroup->GetCounter("EvMultiCollect", true);
     EventStatus = EventGroup->GetCounter("EvStatus", true);
-    EventStopPutBatching = EventGroup->GetCounter("EvStopPutBatching", true); 
-    EventStopGetBatching = EventGroup->GetCounter("EvStopGetBatching", true); 
-    EventPatch = EventGroup->GetCounter("EvPatch", true); 
+    EventStopPutBatching = EventGroup->GetCounter("EvStopPutBatching", true);
+    EventStopGetBatching = EventGroup->GetCounter("EvStopGetBatching", true);
+    EventPatch = EventGroup->GetCounter("EvPatch", true);
+
+    PutsSentViaPutBatching = EventGroup->GetCounter("PutsSentViaPutBatching", true);
+    PutBatchesSent = EventGroup->GetCounter("PutBatchesSent", true);
 
-    PutsSentViaPutBatching = EventGroup->GetCounter("PutsSentViaPutBatching", true); 
-    PutBatchesSent = EventGroup->GetCounter("PutBatchesSent", true); 
- 
     auto buckets = EventGroup->GetSubgroup("sensor", "EvPutBytesBuckets");
     for (ui32 size : {0, 256, 4096, 65536, 250000, 1000000, 4000000}) {
         EventPutBytesBuckets.emplace(size, buckets->GetNamedCounter("size", Sprintf("%" PRIu32, (ui32)size), true));
@@ -71,13 +71,13 @@ TBlobStorageGroupProxyMon::TBlobStorageGroupProxyMon(const TIntrusivePtr<NMonito
     ActiveRange = ActiveRequestsGroup->GetCounter("ActiveRange");
     ActiveCollectGarbage = ActiveRequestsGroup->GetCounter("ActiveCollectGarbage");
     ActiveStatus = ActiveRequestsGroup->GetCounter("ActiveStatus");
-    ActivePatch = ActiveRequestsGroup->GetCounter("ActivePatch"); 
+    ActivePatch = ActiveRequestsGroup->GetCounter("ActivePatch");
+
+    // special patch counters
+    VPatchContinueFailed = ActiveRequestsGroup->GetCounter("VPatchContinueFailed");
+    VPatchPartPlacementVerifyFailed = ActiveRequestsGroup->GetCounter("VPatchPartPlacementVerifyFailed");
+    PatchesWithFallback = ActiveRequestsGroup->GetCounter("PatchesWithFallback");
 
-    // special patch counters 
-    VPatchContinueFailed = ActiveRequestsGroup->GetCounter("VPatchContinueFailed"); 
-    VPatchPartPlacementVerifyFailed = ActiveRequestsGroup->GetCounter("VPatchPartPlacementVerifyFailed"); 
-    PatchesWithFallback = ActiveRequestsGroup->GetCounter("PatchesWithFallback"); 
- 
     // subevents
     {
         auto group = Counters->GetSubgroup("subsystem", "subevents");
@@ -85,7 +85,7 @@ TBlobStorageGroupProxyMon::TBlobStorageGroupProxyMon(const TIntrusivePtr<NMonito
         PutGroup.Init(group->GetSubgroup("request", "put"));
         DiscoverGroup.Init(group->GetSubgroup("request", "discover"));
         RangeGroup.Init(group->GetSubgroup("request", "range"));
-        PatchGroup.Init(group->GetSubgroup("request", "patch")); 
+        PatchGroup.Init(group->GetSubgroup("request", "patch"));
     }
 
     ActiveMultiGet = ActiveRequestsGroup->GetCounter("ActiveMultiGet");
@@ -100,7 +100,7 @@ TBlobStorageGroupProxyMon::TBlobStorageGroupProxyMon(const TIntrusivePtr<NMonito
     RespStatRange.emplace(respStatGroup->GetSubgroup("request", "range"));
     RespStatCollectGarbage.emplace(respStatGroup->GetSubgroup("request", "collectGarbage"));
     RespStatStatus.emplace(respStatGroup->GetSubgroup("request", "status"));
-    RespStatPatch.emplace(respStatGroup->GetSubgroup("request", "patch")); 
+    RespStatPatch.emplace(respStatGroup->GetSubgroup("request", "patch"));
 }
 
 void TBlobStorageGroupProxyMon::BecomeFull() {
@@ -130,7 +130,7 @@ void TBlobStorageGroupProxyMon::BecomeFull() {
         IndexRestoreGetResponseTime.Initialize(ResponseGroup, "event", "indexRestoreGet", "Response in millisec",
                 Percentiles1);
         RangeResponseTime.Initialize(ResponseGroup, "event", "range", "Response in millisec", Percentiles1);
-        PatchResponseTime.Initialize(ResponseGroup, "event", "patch", "Response in millisec", Percentiles1); 
+        PatchResponseTime.Initialize(ResponseGroup, "event", "patch", "Response in millisec", Percentiles1);
     }
     IsLimitedMon = false;
 }
@@ -190,7 +190,7 @@ void TBlobStorageGroupProxyMon::Update() {
         DiscoverResponseTime.Update();
         IndexRestoreGetResponseTime.Update();
         RangeResponseTime.Update();
-        PatchResponseTime.Update(); 
+        PatchResponseTime.Update();
     }
 
     BlockResponseTime.Update();
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_mon.h b/ydb/core/blobstorage/dsproxy/dsproxy_mon.h
index a6c031b88c..941bea6664 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_mon.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_mon.h
@@ -25,7 +25,7 @@ enum class ERequestType {
     Put,
     Discover,
     Range,
-    Patch, 
+    Patch,
 };
 
 struct TRequestMonGroup {
@@ -35,7 +35,7 @@ struct TRequestMonGroup {
     NMonitoring::TDynamicCounters::TCounterPtr VGetBlobsReturnedWithNoData;
     NMonitoring::TDynamicCounters::TCounterPtr VGetBlobsReturnedWithErrors;
     NMonitoring::TDynamicCounters::TCounterPtr VPutBlobsIssued;
-    NMonitoring::TDynamicCounters::TCounterPtr VMovedPatchBlobsIssued; 
+    NMonitoring::TDynamicCounters::TCounterPtr VMovedPatchBlobsIssued;
 
     void Init(const TIntrusivePtr<NMonitoring::TDynamicCounters> &group) {
         VGetBlobsIssued = group->GetCounter("VGetBlobsIssued", true);
@@ -44,27 +44,27 @@ struct TRequestMonGroup {
         VGetBlobsReturnedWithNoData = group->GetCounter("VGetBlobsReturnedWithNoData", true);
         VGetBlobsReturnedWithErrors = group->GetCounter("VGetBlobsReturnedWithErrors", true);
         VPutBlobsIssued = group->GetCounter("VPutBlobsIssued", true);
-        VMovedPatchBlobsIssued = group->GetCounter("VMovedPatchBlobsIssued", true); 
+        VMovedPatchBlobsIssued = group->GetCounter("VMovedPatchBlobsIssued", true);
     }
 
     void CountEvent(const TEvBlobStorage::TEvVPut& /*ev*/) {
         VPutBlobsIssued->Inc();
     }
 
-    void CountEvent(const TEvBlobStorage::TEvVMultiPut& ev) { 
-        *VPutBlobsIssued += ev.Record.ItemsSize(); 
-    } 
- 
-    void CountEvent(const TEvBlobStorage::TEvVMovedPatch& /*ev*/) { 
-        VPutBlobsIssued->Inc(); 
-    } 
- 
-    void CountEvent(const TEvBlobStorage::TEvVPatchStart& /*ev*/) { 
-    } 
- 
-    void CountEvent(const TEvBlobStorage::TEvVPatchDiff& /*ev*/) { 
-    } 
- 
+    void CountEvent(const TEvBlobStorage::TEvVMultiPut& ev) {
+        *VPutBlobsIssued += ev.Record.ItemsSize();
+    }
+
+    void CountEvent(const TEvBlobStorage::TEvVMovedPatch& /*ev*/) {
+        VPutBlobsIssued->Inc();
+    }
+
+    void CountEvent(const TEvBlobStorage::TEvVPatchStart& /*ev*/) {
+    }
+
+    void CountEvent(const TEvBlobStorage::TEvVPatchDiff& /*ev*/) {
+    }
+
     void CountEvent(const TEvBlobStorage::TEvVGet &ev) {
         *VGetBlobsIssued += ev.Record.ExtremeQueriesSize();
         if (ev.Record.HasRangeQuery()) {
@@ -169,7 +169,7 @@ protected:
     NMonitoring::TPercentileTrackerLg<3, 4, 3> DiscoverResponseTime;
     NMonitoring::TPercentileTrackerLg<3, 4, 3> IndexRestoreGetResponseTime;
     NMonitoring::TPercentileTrackerLg<3, 4, 3> RangeResponseTime;
-    NMonitoring::TPercentileTrackerLg<3, 4, 3> PatchResponseTime; 
+    NMonitoring::TPercentileTrackerLg<3, 4, 3> PatchResponseTime;
 
     // event counters
     TIntrusivePtr<NMonitoring::TDynamicCounters> EventGroup;
@@ -187,7 +187,7 @@ protected:
     TRequestMonGroup PutGroup;
     TRequestMonGroup DiscoverGroup;
     TRequestMonGroup RangeGroup;
-    TRequestMonGroup PatchGroup; 
+    TRequestMonGroup PatchGroup;
 
 public:
     TBlobStorageGroupProxyTimeStats TimeStats;
@@ -209,13 +209,13 @@ public:
     NMonitoring::TDynamicCounters::TCounterPtr EventIndexRestoreGet;
     NMonitoring::TDynamicCounters::TCounterPtr EventMultiCollect;
     NMonitoring::TDynamicCounters::TCounterPtr EventStatus;
-    NMonitoring::TDynamicCounters::TCounterPtr EventStopPutBatching; 
-    NMonitoring::TDynamicCounters::TCounterPtr EventStopGetBatching; 
-    NMonitoring::TDynamicCounters::TCounterPtr EventPatch; 
+    NMonitoring::TDynamicCounters::TCounterPtr EventStopPutBatching;
+    NMonitoring::TDynamicCounters::TCounterPtr EventStopGetBatching;
+    NMonitoring::TDynamicCounters::TCounterPtr EventPatch;
+
+    NMonitoring::TDynamicCounters::TCounterPtr PutsSentViaPutBatching;
+    NMonitoring::TDynamicCounters::TCounterPtr PutBatchesSent;
 
-    NMonitoring::TDynamicCounters::TCounterPtr PutsSentViaPutBatching; 
-    NMonitoring::TDynamicCounters::TCounterPtr PutBatchesSent; 
- 
     // active event counters
     TIntrusivePtr<NMonitoring::TDynamicCounters> ActiveRequestsGroup;
     NMonitoring::TDynamicCounters::TCounterPtr ActivePut;
@@ -230,7 +230,7 @@ public:
     NMonitoring::TDynamicCounters::TCounterPtr ActiveIndexRestoreGet;
     NMonitoring::TDynamicCounters::TCounterPtr ActiveMultiCollect;
     NMonitoring::TDynamicCounters::TCounterPtr ActiveStatus;
-    NMonitoring::TDynamicCounters::TCounterPtr ActivePatch; 
+    NMonitoring::TDynamicCounters::TCounterPtr ActivePatch;
 
     std::optional<TResponseStatusGroup> RespStatPut;
     std::optional<TResponseStatusGroup> RespStatGet;
@@ -239,20 +239,20 @@ public:
     std::optional<TResponseStatusGroup> RespStatRange;
     std::optional<TResponseStatusGroup> RespStatCollectGarbage;
     std::optional<TResponseStatusGroup> RespStatStatus;
-    std::optional<TResponseStatusGroup> RespStatPatch; 
+    std::optional<TResponseStatusGroup> RespStatPatch;
 
-    // special patch counters 
-    NMonitoring::TDynamicCounters::TCounterPtr VPatchContinueFailed; 
-    NMonitoring::TDynamicCounters::TCounterPtr VPatchPartPlacementVerifyFailed; 
+    // special patch counters
+    NMonitoring::TDynamicCounters::TCounterPtr VPatchContinueFailed;
+    NMonitoring::TDynamicCounters::TCounterPtr VPatchPartPlacementVerifyFailed;
     NMonitoring::TDynamicCounters::TCounterPtr PatchesWithFallback;
- 
+
     TRequestMonGroup& GetRequestMonGroup(ERequestType request) {
         switch (request) {
             case ERequestType::Get: return GetGroup;
             case ERequestType::Put: return PutGroup;
             case ERequestType::Discover: return DiscoverGroup;
             case ERequestType::Range: return RangeGroup;
-            case ERequestType::Patch: return PatchGroup; 
+            case ERequestType::Patch: return PatchGroup;
         }
         Y_FAIL();
     }
@@ -351,11 +351,11 @@ public:
         NodeMon->RangeResponseTime.Increment(duration.MilliSeconds());
     }
 
-    void CountPatchResponseTime(TPDiskCategory::EDeviceType type, TDuration duration) { 
-        PatchResponseTime.Increment(duration.MilliSeconds()); 
-        NodeMon->CountPatchResponseTime(type, duration); 
-    } 
- 
+    void CountPatchResponseTime(TPDiskCategory::EDeviceType type, TDuration duration) {
+        PatchResponseTime.Increment(duration.MilliSeconds());
+        NodeMon->CountPatchResponseTime(type, duration);
+    }
+
     void Update();
     void ThroughputUpdate();
 };
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_multiget.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_multiget.cpp
index 3ae7ede0e7..02d7849855 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_multiget.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_multiget.cpp
@@ -1,9 +1,9 @@
 #include "dsproxy.h"
 #include "dsproxy_mon.h"
- 
+
 #include <ydb/core/blobstorage/base/wilson_events.h>
 #include <ydb/core/blobstorage/vdisk/query/query_spacetracker.h>
- 
+
 #include <util/generic/set.h>
 
 namespace NKikimr {
@@ -162,22 +162,22 @@ public:
         Y_VERIFY(QuerySize != 0); // reply with error?
         ui32 beginIdx = 0;
         TLogoBlobID lastBlobId;
-        TQueryResultSizeTracker resultSize; 
-        resultSize.Init(); 
- 
+        TQueryResultSizeTracker resultSize;
+        resultSize.Init();
+
         for (ui32 queryIdx = 0; queryIdx < QuerySize; ++queryIdx) {
             const TEvBlobStorage::TEvGet::TQuery &query = Queries[queryIdx];
             if (lastBlobId == query.Id && queryIdx != 0) {
                 continue;
             }
-            resultSize.AddAllPartsOfLogoBlob(Info->Type, query.Id); 
+            resultSize.AddAllPartsOfLogoBlob(Info->Type, query.Id);
 
             if (queryIdx != beginIdx) {
                 if (resultSize.IsOverflow() || queryIdx - beginIdx == 10000) {
                     PrepareRequest(beginIdx, queryIdx);
                     beginIdx = queryIdx;
-                    resultSize.Init(); 
-                    resultSize.AddAllPartsOfLogoBlob(Info->Type, query.Id); 
+                    resultSize.Init();
+                    resultSize.AddAllPartsOfLogoBlob(Info->Type, query.Id);
                 }
             }
         }
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_nodemon.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_nodemon.cpp
index 6b0fdd2eb0..addca8c533 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_nodemon.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_nodemon.cpp
@@ -36,7 +36,7 @@ TDsProxyNodeMon::TDsProxyNodeMon(TIntrusivePtr<NMonitoring::TDynamicCounters> &c
     IndexRestoreGetResponseTime.Initialize(Group, "event", "indexRestoreGet", "latency",
             percentiles1);
     RangeResponseTime.Initialize(Group, "event", "range", "latency", percentiles1);
-    PatchResponseTime.Initialize(Group, "event", "patch", "latency", percentiles4); 
+    PatchResponseTime.Initialize(Group, "event", "patch", "latency", percentiles4);
 
     IsCountersPresentedForIdx.fill(false);
     if (initForAllDeviceTypes) {
@@ -51,7 +51,7 @@ TDsProxyNodeMon::TDsProxyNodeMon(TIntrusivePtr<NMonitoring::TDynamicCounters> &c
         auto group = Group->GetSubgroup("subsystem", "restart");
         RestartPut = group->GetCounter("EvPut", true);
         RestartGet = group->GetCounter("EvGet", true);
-        RestartPatch = group->GetCounter("EvPatch", true); 
+        RestartPatch = group->GetCounter("EvPatch", true);
         RestartBlock = group->GetCounter("EvBlock", true);
         RestartDiscover = group->GetCounter("EvDiscover", true);
         RestartRange = group->GetCounter("EvRange", true);
@@ -170,15 +170,15 @@ void TDsProxyNodeMon::CountGetResponseTime(TPDiskCategory::EDeviceType type, NKi
     }
 }
 
-void TDsProxyNodeMon::CountPatchResponseTime(TPDiskCategory::EDeviceType type, TDuration duration) { 
-    const ui32 durationMs = duration.MilliSeconds(); 
-    const double durationMsFloat = duration.MicroSeconds() / 1000.0; 
-    PatchResponseTime.Increment(durationMs); 
-    const ui32 idx = IdxForType(type); 
-    Y_VERIFY(IsCountersPresentedForIdx[idx]); 
-    PatchResponseTimeHist[idx]->Collect(durationMsFloat); 
-} 
- 
+void TDsProxyNodeMon::CountPatchResponseTime(TPDiskCategory::EDeviceType type, TDuration duration) {
+    const ui32 durationMs = duration.MilliSeconds();
+    const double durationMsFloat = duration.MicroSeconds() / 1000.0;
+    PatchResponseTime.Increment(durationMs);
+    const ui32 idx = IdxForType(type);
+    Y_VERIFY(IsCountersPresentedForIdx[idx]);
+    PatchResponseTimeHist[idx]->Collect(durationMsFloat);
+}
+
 void TDsProxyNodeMon::CheckNodeMonCountersForDeviceType(TPDiskCategory::EDeviceType type) {
     const ui32 idx = IdxForType(type);
 
@@ -201,7 +201,7 @@ void TDsProxyNodeMon::CheckNodeMonCountersForDeviceType(TPDiskCategory::EDeviceT
         GetFastReadResponseTimeHistInf[idx] = getNamedHisto("getFastReadInfMs");
         GetDiscoverResponseTimeHist[idx] = getNamedHisto("getDiscoverMs");
         GetLowReadResponseTimeHist[idx] = getNamedHisto("getLowReadMs");
-        PatchResponseTimeHist[idx] = getNamedHisto("patchMs"); 
+        PatchResponseTimeHist[idx] = getNamedHisto("patchMs");
     }
 }
 } // NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_nodemon.h b/ydb/core/blobstorage/dsproxy/dsproxy_nodemon.h
index f593d35394..150da172fb 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_nodemon.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_nodemon.h
@@ -55,9 +55,9 @@ struct TDsProxyNodeMon : public TThrRefBase {
     NMonitoring::TPercentileTracker<16, 512, 15> GetLowReadResponseTime;
     THistoPtrForDeviceType GetLowReadResponseTimeHist;
 
-    NMonitoring::TPercentileTracker<16, 512, 15> PatchResponseTime; 
-    THistoPtrForDeviceType PatchResponseTimeHist; 
- 
+    NMonitoring::TPercentileTracker<16, 512, 15> PatchResponseTime;
+    THistoPtrForDeviceType PatchResponseTimeHist;
+
     NMonitoring::TPercentileTracker<16, 512, 15> BlockResponseTime;
     NMonitoring::TPercentileTracker<16, 512, 15> DiscoverResponseTime;
     NMonitoring::TPercentileTracker<16, 512, 15> IndexRestoreGetResponseTime;
@@ -74,7 +74,7 @@ struct TDsProxyNodeMon : public TThrRefBase {
     NMonitoring::TDynamicCounters::TCounterPtr RestartCollectGarbage;
     NMonitoring::TDynamicCounters::TCounterPtr RestartIndexRestoreGet;
     NMonitoring::TDynamicCounters::TCounterPtr RestartStatus;
-    NMonitoring::TDynamicCounters::TCounterPtr RestartPatch; 
+    NMonitoring::TDynamicCounters::TCounterPtr RestartPatch;
 
     std::array<NMonitoring::TDynamicCounters::TCounterPtr, 4> RestartHisto;
 
@@ -95,7 +95,7 @@ struct TDsProxyNodeMon : public TThrRefBase {
             TDuration duration);
     void CountGetResponseTime(TPDiskCategory::EDeviceType type, NKikimrBlobStorage::EGetHandleClass cls, ui32 size,
             TDuration duration);
-    void CountPatchResponseTime(TPDiskCategory::EDeviceType type, TDuration duration); 
+    void CountPatchResponseTime(TPDiskCategory::EDeviceType type, TDuration duration);
 
     // Called only from NodeWarder
     void CheckNodeMonCountersForDeviceType(TPDiskCategory::EDeviceType type);
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_nodemonactor.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_nodemonactor.cpp
index db723d6d5e..5bf4b09836 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_nodemonactor.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_nodemonactor.cpp
@@ -67,7 +67,7 @@ public:
         Mon->DiscoverResponseTime.Update();
         Mon->IndexRestoreGetResponseTime.Update();
         Mon->RangeResponseTime.Update();
-        Mon->PatchResponseTime.Update(); 
+        Mon->PatchResponseTime.Update();
     }
 
     void Handle(NMon::TEvHttpInfo::TPtr &ev) {
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_patch.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_patch.cpp
index 3b63445a3b..fcced0b6f8 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_patch.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_patch.cpp
@@ -1,835 +1,835 @@
-#include "dsproxy.h" 
-#include "dsproxy_mon.h" 
-#include "root_cause.h" 
+#include "dsproxy.h"
+#include "dsproxy_mon.h"
+#include "root_cause.h"
 #include <ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.h>
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_partlayout.h>
- 
-#include <util/generic/ymath.h> 
-#include <util/system/datetime.h> 
-#include <util/system/hp_timer.h> 
- 
-LWTRACE_USING(BLOBSTORAGE_PROVIDER); 
- 
-namespace NKikimr { 
- 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
-// PATCH request 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
- 
-class TBlobStorageGroupPatchRequest : public TBlobStorageGroupRequestActor<TBlobStorageGroupPatchRequest> { 
-    friend class TBlobStorageGroupRequestActor<TBlobStorageGroupPatchRequest>; 
- 
-    struct TPartPlacement { 
-        ui8 VDiskIdxInSubgroup = 0; 
-        ui8 PartId = 0; 
- 
-        TString ToString() const { 
-            return TStringBuilder() << "{VDiskIdxInSubgroup# " << (ui32)VDiskIdxInSubgroup << " PartId# " << (ui32)PartId << "}"; 
-        } 
-    }; 
- 
-    static constexpr ui32 TypicalHandoffCount = 2; 
-    static constexpr ui32 TypicalPartPlacementCount = 1 + TypicalHandoffCount; 
-    static constexpr ui32 TypicalMaxPartsCount = TypicalPartPlacementCount * TypicalPartsInBlob; 
- 
-    TString Buffer; 
-    TActorId ProxyActorId; 
- 
-    ui32 OriginalGroupId; 
-    TLogoBlobID OriginalId; 
-    TLogoBlobID PatchedId; 
-    ui32 MaskForCookieBruteForcing; 
- 
-    ui32 DiffCount = 0; 
-    TArrayHolder<TEvBlobStorage::TEvPatch::TDiff> Diffs; 
- 
-    TStorageStatusFlags StatusFlags = 0; 
-    float ApproximateFreeSpaceShare = 0; 
- 
-    TInstant StartTime; 
-    TInstant Deadline; 
- 
-    NLWTrace::TOrbit Orbit; 
-    TString ErrorReason; 
- 
-    ui32 SendedGetRequests = 0; 
-    ui32 ReceivedGetResponses = 0; 
-    ui32 SendedPutRequests = 0; 
-    ui32 ReceivedPutResponses = 0; 
- 
-    TVector<ui32> OkVDisksWithParts; 
- 
-    ui32 SendedStarts = 0; 
-    ui32 ReceivedFoundParts = 0; 
-    ui32 ErrorResponses = 0; 
-    ui32 ReceivedResults = 0; 
- 
-    TStackVec<TPartPlacement, TypicalMaxPartsCount> FoundParts; 
-    TStackVec<bool, TypicalDisksInSubring> ReceivedResponseFlags; 
-    TStackVec<bool, TypicalDisksInSubring> EmptyResponseFlags; 
-    TStackVec<bool, TypicalDisksInSubring> ErrorResponseFlags; 
-    TBlobStorageGroupInfo::TVDiskIds VDisks; 
- 
-    bool UseVPatch = false; 
- 
-public: 
-    static constexpr NKikimrServices::TActivity::EType ActorActivityType() { 
-        return NKikimrServices::TActivity::BS_PROXY_PATCH_ACTOR; 
-    } 
- 
-    static const auto& ActiveCounter(const TIntrusivePtr<TBlobStorageGroupProxyMon>& mon) { 
-        return mon->ActivePatch; 
-    } 
- 
-    static constexpr ERequestType RequestType() { 
-        return ERequestType::Patch; 
-    } 
- 
-    TBlobStorageGroupPatchRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info, 
-            const TIntrusivePtr<TGroupQueues> &state, const TActorId &source, 
-            const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvPatch *ev, 
-            ui64 cookie, NWilson::TTraceId traceId, TInstant now, 
-            TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-            const TActorId &proxyId, bool useVPatch = false) 
-        : TBlobStorageGroupRequestActor(info, state, mon, source, cookie, std::move(traceId), 
-                NKikimrServices::BS_PROXY_PATCH, false, {}, now, storagePoolCounters, 
-                ev->RestartCounter) 
-        , ProxyActorId(proxyId) 
-        , OriginalGroupId(ev->OriginalGroupId) 
-        , OriginalId(ev->OriginalId) 
-        , PatchedId(ev->PatchedId) 
-        , MaskForCookieBruteForcing(ev->MaskForCookieBruteForcing) 
-        , DiffCount(ev->DiffCount) 
-        , Diffs(ev->Diffs.Release()) 
-        , StartTime(now) 
-        , Deadline(ev->Deadline) 
-        , Orbit(std::move(ev->Orbit)) 
-        , UseVPatch(useVPatch) 
-    { 
-    } 
- 
-    void ReplyAndDie(NKikimrProto::EReplyStatus status) { 
+
+#include <util/generic/ymath.h>
+#include <util/system/datetime.h>
+#include <util/system/hp_timer.h>
+
+LWTRACE_USING(BLOBSTORAGE_PROVIDER);
+
+namespace NKikimr {
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// PATCH request
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+class TBlobStorageGroupPatchRequest : public TBlobStorageGroupRequestActor<TBlobStorageGroupPatchRequest> {
+    friend class TBlobStorageGroupRequestActor<TBlobStorageGroupPatchRequest>;
+
+    struct TPartPlacement {
+        ui8 VDiskIdxInSubgroup = 0;
+        ui8 PartId = 0;
+
+        TString ToString() const {
+            return TStringBuilder() << "{VDiskIdxInSubgroup# " << (ui32)VDiskIdxInSubgroup << " PartId# " << (ui32)PartId << "}";
+        }
+    };
+
+    static constexpr ui32 TypicalHandoffCount = 2;
+    static constexpr ui32 TypicalPartPlacementCount = 1 + TypicalHandoffCount;
+    static constexpr ui32 TypicalMaxPartsCount = TypicalPartPlacementCount * TypicalPartsInBlob;
+
+    TString Buffer;
+    TActorId ProxyActorId;
+
+    ui32 OriginalGroupId;
+    TLogoBlobID OriginalId;
+    TLogoBlobID PatchedId;
+    ui32 MaskForCookieBruteForcing;
+
+    ui32 DiffCount = 0;
+    TArrayHolder<TEvBlobStorage::TEvPatch::TDiff> Diffs;
+
+    TStorageStatusFlags StatusFlags = 0;
+    float ApproximateFreeSpaceShare = 0;
+
+    TInstant StartTime;
+    TInstant Deadline;
+
+    NLWTrace::TOrbit Orbit;
+    TString ErrorReason;
+
+    ui32 SendedGetRequests = 0;
+    ui32 ReceivedGetResponses = 0;
+    ui32 SendedPutRequests = 0;
+    ui32 ReceivedPutResponses = 0;
+
+    TVector<ui32> OkVDisksWithParts;
+
+    ui32 SendedStarts = 0;
+    ui32 ReceivedFoundParts = 0;
+    ui32 ErrorResponses = 0;
+    ui32 ReceivedResults = 0;
+
+    TStackVec<TPartPlacement, TypicalMaxPartsCount> FoundParts;
+    TStackVec<bool, TypicalDisksInSubring> ReceivedResponseFlags;
+    TStackVec<bool, TypicalDisksInSubring> EmptyResponseFlags;
+    TStackVec<bool, TypicalDisksInSubring> ErrorResponseFlags;
+    TBlobStorageGroupInfo::TVDiskIds VDisks;
+
+    bool UseVPatch = false;
+
+public:
+    static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
+        return NKikimrServices::TActivity::BS_PROXY_PATCH_ACTOR;
+    }
+
+    static const auto& ActiveCounter(const TIntrusivePtr<TBlobStorageGroupProxyMon>& mon) {
+        return mon->ActivePatch;
+    }
+
+    static constexpr ERequestType RequestType() {
+        return ERequestType::Patch;
+    }
+
+    TBlobStorageGroupPatchRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info,
+            const TIntrusivePtr<TGroupQueues> &state, const TActorId &source,
+            const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvPatch *ev,
+            ui64 cookie, NWilson::TTraceId traceId, TInstant now,
+            TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+            const TActorId &proxyId, bool useVPatch = false)
+        : TBlobStorageGroupRequestActor(info, state, mon, source, cookie, std::move(traceId),
+                NKikimrServices::BS_PROXY_PATCH, false, {}, now, storagePoolCounters,
+                ev->RestartCounter)
+        , ProxyActorId(proxyId)
+        , OriginalGroupId(ev->OriginalGroupId)
+        , OriginalId(ev->OriginalId)
+        , PatchedId(ev->PatchedId)
+        , MaskForCookieBruteForcing(ev->MaskForCookieBruteForcing)
+        , DiffCount(ev->DiffCount)
+        , Diffs(ev->Diffs.Release())
+        , StartTime(now)
+        , Deadline(ev->Deadline)
+        , Orbit(std::move(ev->Orbit))
+        , UseVPatch(useVPatch)
+    {
+    }
+
+    void ReplyAndDie(NKikimrProto::EReplyStatus status) {
         std::unique_ptr<TEvBlobStorage::TEvPatchResult> result = std::make_unique<TEvBlobStorage::TEvPatchResult>(status, PatchedId,
-                StatusFlags, Info->GroupID, ApproximateFreeSpaceShare); 
-        result->ErrorReason = ErrorReason; 
-        result->Orbit = std::move(Orbit); 
-        TDuration duration = TActivationContext::Now() - StartTime; 
-        Mon->CountPatchResponseTime(Info->GetDeviceType(), duration); 
-        SendResponseAndDie(std::move(result)); 
-    } 
- 
-    std::unique_ptr<IEventBase> RestartQuery(ui32 counter) { 
-        ++*Mon->NodeMon->RestartPatch; 
-        TEvBlobStorage::TEvPatch *patch; 
-        std::unique_ptr<IEventBase> ev(patch = new TEvBlobStorage::TEvPatch(OriginalGroupId, OriginalId, PatchedId, 
+                StatusFlags, Info->GroupID, ApproximateFreeSpaceShare);
+        result->ErrorReason = ErrorReason;
+        result->Orbit = std::move(Orbit);
+        TDuration duration = TActivationContext::Now() - StartTime;
+        Mon->CountPatchResponseTime(Info->GetDeviceType(), duration);
+        SendResponseAndDie(std::move(result));
+    }
+
+    std::unique_ptr<IEventBase> RestartQuery(ui32 counter) {
+        ++*Mon->NodeMon->RestartPatch;
+        TEvBlobStorage::TEvPatch *patch;
+        std::unique_ptr<IEventBase> ev(patch = new TEvBlobStorage::TEvPatch(OriginalGroupId, OriginalId, PatchedId,
                 MaskForCookieBruteForcing, std::move(Diffs), DiffCount, Deadline));
-        patch->RestartCounter = counter; 
-        patch->Orbit = std::move(Orbit); 
-        return std::move(ev); 
-    } 
- 
-    void ApplyDiffs() { 
-        for (ui32 idx = 0; idx < DiffCount; ++idx) { 
-            const TEvBlobStorage::TEvPatch::TDiff &diff = Diffs[idx]; 
-            Copy(diff.Buffer.begin(), diff.Buffer.end(), Buffer.begin() + diff.Offset); 
-        } 
-    } 
- 
-    void Handle(TEvBlobStorage::TEvGetResult::TPtr &ev) { 
-        TEvBlobStorage::TEvGetResult *result = ev->Get(); 
-        Orbit = std::move(result->Orbit); 
-        TraceId = std::move(ev->TraceId); 
- 
-        ui32 patchedIdHash = PatchedId.Hash(); 
-        bool incorrectCookie = ev->Cookie != patchedIdHash; 
-        bool fail = incorrectCookie 
-                || result->Status != NKikimrProto::OK 
-                || result->ResponseSz != 1 
-                || result->Responses[0].Status != NKikimrProto::OK; 
-        if (fail) { 
-            if (ev->Cookie != patchedIdHash) { 
-                ErrorReason = "Couldn't get the original blob; Received TEvGetResult with wrong cookie"; 
-            } else if (result->ResponseSz > 1) { 
-                ErrorReason = "Couldn't get the original blob; Received TEvGetResult with more responses than needed"; 
-            } else { 
-                TString getResponseStatus; 
-                if (result->ResponseSz == 1) { 
-                    getResponseStatus = TStringBuilder() << " GetResponseStatus# " 
-                            << NKikimrProto::EReplyStatus_Name(result->Responses[0].Status); 
-                } 
-                ErrorReason = TStringBuilder() << "Couldn't get the original blob;" 
-                        << " GetStatus# " << NKikimrProto::EReplyStatus_Name(result->Status) 
-                        << getResponseStatus 
-                        << " GetErrorReason# " << result->ErrorReason; 
-            } 
-            R_LOG_ERROR_S("BPPA04", ErrorReason); 
-            ReplyAndDie(NKikimrProto::ERROR); 
-            return; 
-        } 
- 
-        Buffer = result->Responses[0].Buffer; 
-        ApplyDiffs(); 
- 
+        patch->RestartCounter = counter;
+        patch->Orbit = std::move(Orbit);
+        return std::move(ev);
+    }
+
+    void ApplyDiffs() {
+        for (ui32 idx = 0; idx < DiffCount; ++idx) {
+            const TEvBlobStorage::TEvPatch::TDiff &diff = Diffs[idx];
+            Copy(diff.Buffer.begin(), diff.Buffer.end(), Buffer.begin() + diff.Offset);
+        }
+    }
+
+    void Handle(TEvBlobStorage::TEvGetResult::TPtr &ev) {
+        TEvBlobStorage::TEvGetResult *result = ev->Get();
+        Orbit = std::move(result->Orbit);
+        TraceId = std::move(ev->TraceId);
+
+        ui32 patchedIdHash = PatchedId.Hash();
+        bool incorrectCookie = ev->Cookie != patchedIdHash;
+        bool fail = incorrectCookie
+                || result->Status != NKikimrProto::OK
+                || result->ResponseSz != 1
+                || result->Responses[0].Status != NKikimrProto::OK;
+        if (fail) {
+            if (ev->Cookie != patchedIdHash) {
+                ErrorReason = "Couldn't get the original blob; Received TEvGetResult with wrong cookie";
+            } else if (result->ResponseSz > 1) {
+                ErrorReason = "Couldn't get the original blob; Received TEvGetResult with more responses than needed";
+            } else {
+                TString getResponseStatus;
+                if (result->ResponseSz == 1) {
+                    getResponseStatus = TStringBuilder() << " GetResponseStatus# "
+                            << NKikimrProto::EReplyStatus_Name(result->Responses[0].Status);
+                }
+                ErrorReason = TStringBuilder() << "Couldn't get the original blob;"
+                        << " GetStatus# " << NKikimrProto::EReplyStatus_Name(result->Status)
+                        << getResponseStatus
+                        << " GetErrorReason# " << result->ErrorReason;
+            }
+            R_LOG_ERROR_S("BPPA04", ErrorReason);
+            ReplyAndDie(NKikimrProto::ERROR);
+            return;
+        }
+
+        Buffer = result->Responses[0].Buffer;
+        ApplyDiffs();
+
         std::unique_ptr<TEvBlobStorage::TEvPut> put = std::make_unique<TEvBlobStorage::TEvPut>(PatchedId, Buffer, Deadline,
-                NKikimrBlobStorage::AsyncBlob, TEvBlobStorage::TEvPut::TacticDefault); 
-        put->Orbit = std::move(Orbit); 
+                NKikimrBlobStorage::AsyncBlob, TEvBlobStorage::TEvPut::TacticDefault);
+        put->Orbit = std::move(Orbit);
         Send(ProxyActorId, put.release(), 0, OriginalId.Hash(), std::move(TraceId));
-    } 
- 
-    void Handle(TEvBlobStorage::TEvPutResult::TPtr &ev) { 
-        TEvBlobStorage::TEvPutResult *result = ev->Get(); 
-        Orbit = std::move(result->Orbit); 
-        TraceId = std::move(ev->TraceId); 
- 
-        StatusFlags = result->StatusFlags; 
-        ApproximateFreeSpaceShare = result->ApproximateFreeSpaceShare; 
- 
-        ui32 originalIdHash = OriginalId.Hash(); 
-        bool incorrectCookie = ev->Cookie != originalIdHash; 
-        bool fail = incorrectCookie 
-            || result->Status != NKikimrProto::OK; 
-        if (fail) { 
-            if (incorrectCookie) { 
-                ErrorReason = "Couldn't put the patched blob; Received TEvPutResult with wrong cookie"; 
-            } else { 
-                ErrorReason = TStringBuilder() << "Couldn't put the patched blob;" 
-                        << " PutStatus# " << NKikimrProto::EReplyStatus_Name(result->Status) 
-                        << " PutErrorReason# " << result->ErrorReason; 
-            } 
-            R_LOG_ERROR_S("BPPA03", ErrorReason); 
-            ReplyAndDie(NKikimrProto::ERROR); 
-            return; 
-        } 
- 
-        ReplyAndDie(NKikimrProto::OK); 
-    } 
- 
-    template <typename TEventResultRecord> 
-    void PullOutStatusFlagsAndFressSpace(const TEventResultRecord &record){ 
-        if (record.HasStatusFlags()) { 
-            StatusFlags.Merge(record.GetStatusFlags()); 
-        } 
-        if (record.HasApproximateFreeSpaceShare()) { 
-            float share = record.GetApproximateFreeSpaceShare(); 
-            if (ApproximateFreeSpaceShare == 0.0 || share < ApproximateFreeSpaceShare) { 
-                ApproximateFreeSpaceShare = share; 
-            } 
-        } 
-    } 
- 
-    void Handle(TEvBlobStorage::TEvVMovedPatchResult::TPtr &ev) { 
-        TEvBlobStorage::TEvVMovedPatchResult *result = ev->Get(); 
-        A_LOG_DEBUG_S("BPPA02", "received " << ev->Get()->ToString() 
-            << " from# " << VDiskIDFromVDiskID(ev->Get()->Record.GetVDiskID())); 
-        NKikimrBlobStorage::TEvVMovedPatchResult &record = result->Record; 
-        PullOutStatusFlagsAndFressSpace(record); 
-        Orbit = std::move(result->Orbit); 
-        TraceId = std::move(ev->TraceId); 
- 
-        ui64 expectedCookie = ((ui64)OriginalId.Hash() << 32) | PatchedId.Hash(); 
-        bool incorrectCookie = ev->Cookie != expectedCookie; 
-        Y_VERIFY(record.HasStatus()); 
-        bool fail = incorrectCookie 
-            || record.GetStatus() != NKikimrProto::OK; 
-        if (fail) { 
-            if (incorrectCookie) { 
-                ErrorReason = "Couldn't put the patched blob; Received TEvVMovedPatchResult with wrong cookie"; 
-            } else { 
-                TString subErrorReason; 
-                if (record.HasErrorReason()) { 
-                    subErrorReason = TStringBuilder() << " VMovedPatchErrorReason# " << record.GetErrorReason(); 
-                } 
-                ErrorReason = TStringBuilder() << "Couldn't complete patch;" 
-                        << " VMovedPatchStatus# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()) 
-                        << subErrorReason; 
-            } 
-            A_LOG_INFO_S("BPPA05", "VMovedPatch failed, NaivePatch started;" 
-                    << " OriginalId# " << OriginalId 
-                    << " PatchedId# " << PatchedId 
-                    << " ErrorReason# " << ErrorReason); 
-            StartNaivePatch(); 
-            return; 
-        } 
- 
-        ReplyAndDie(NKikimrProto::OK); 
-    } 
- 
-    void Handle(TEvBlobStorage::TEvVPatchFoundParts::TPtr &ev) { 
-        ReceivedFoundParts++; 
- 
-        NKikimrBlobStorage::TEvVPatchFoundParts &record = ev->Get()->Record; 
- 
-        Y_VERIFY(record.HasCookie()); 
-        ui8 subgroupIdx = record.GetCookie(); 
- 
-        Y_VERIFY(record.HasStatus()); 
-        NKikimrProto::EReplyStatus status = record.GetStatus(); 
- 
-        TString errorReason; 
-        if (record.HasErrorReason()) { 
-            errorReason = record.GetErrorReason(); 
-        } 
- 
-        bool wasReceived = std::exchange(ReceivedResponseFlags[subgroupIdx], true); 
-        Y_VERIFY(!wasReceived); 
- 
-        if (status == NKikimrProto::ERROR) { 
-            ErrorResponses++; 
-            ErrorResponseFlags[subgroupIdx] = true; 
-        } 
- 
-        EmptyResponseFlags[subgroupIdx] = !record.OriginalPartsSize(); 
-        for (auto &partId : record.GetOriginalParts()) { 
-            FoundParts.push_back({subgroupIdx, (ui8)partId}); 
-        } 
- 
-        if (record.OriginalPartsSize()) { 
-            OkVDisksWithParts.push_back(subgroupIdx); 
-        } 
- 
-        A_LOG_INFO_S("BPPA07", "received VPatchFoundParts" 
-                << " Status# " << status 
-                << " ActorId# " << SelfId() 
-                << " Group# " << Info->GroupID 
-                << " OriginalBlob# " << OriginalId 
-                << " PatchedBlob# " << PatchedId 
-                << " Deadline# " << Deadline 
-                << " SubgroupIdx# " << (ui32)subgroupIdx 
-                << " PartsCount# " << record.OriginalPartsSize() 
-                << " ReceivedFoundParts# " << ReceivedFoundParts << '/' << SendedStarts 
-                << " ErrorReason# " << errorReason); 
- 
-        if (ReceivedFoundParts == SendedStarts) { 
-            bool continueVPatch = VerifyPartPlacement(); 
-            if (continueVPatch) { 
-                continueVPatch = ContinueVPatch(); 
-            } else { 
-                Mon->VPatchPartPlacementVerifyFailed->Inc(); 
-            } 
-            if (!continueVPatch) { 
-                StopVPatch(); 
-                StartFallback(); 
-            } 
-        } 
-    } 
- 
-    void Handle(TEvBlobStorage::TEvVPatchResult::TPtr &ev) { 
-        ReceivedResults++; 
-        NKikimrBlobStorage::TEvVPatchResult &record = ev->Get()->Record; 
-        PullOutStatusFlagsAndFressSpace(record); 
-        Y_VERIFY(record.HasStatus()); 
-        NKikimrProto::EReplyStatus status = record.GetStatus(); 
-        TString errorReason; 
-        if (record.HasErrorReason()) { 
-            errorReason = record.GetErrorReason(); 
-        } 
- 
-        A_LOG_INFO_S("BPPA06", "received VPatchResult" 
-                << " Status# " << status 
-                << " ActorId# " << SelfId() 
-                << " Group# " << Info->GroupID 
-                << " OriginalBlob# " << OriginalId 
-                << " PatchedBlob# " << PatchedId 
-                << " Deadline# " << Deadline 
-                << " ReceivedResults# " << ReceivedResults << '/' << Info->Type.TotalPartCount() 
-                << " ErrorReason# " << errorReason); 
- 
-        Y_VERIFY(record.HasCookie()); 
-        ui8 subgroupIdx = record.GetCookie(); 
- 
-        bool wasReceived = std::exchange(ReceivedResponseFlags[subgroupIdx], true); 
-        Y_VERIFY(!wasReceived); 
- 
-        if (status != NKikimrProto::OK) { 
-            StartFallback(); 
-            return; 
-        } 
- 
-        if (ReceivedResults == Info->Type.TotalPartCount()) { 
-            ReplyAndDie(NKikimrProto::OK); 
-        } 
-    } 
- 
-    bool VerifyPartPlacementForMirror3dc() const { 
-        constexpr ui32 DCCount = 3; 
-        constexpr ui32 VDiskByDC = 3; 
-        ui32 countByDC[DCCount] = {0, 0, 0}; 
- 
-        for (auto &[subgroupIdx, partId] : FoundParts) { 
-            countByDC[subgroupIdx / VDiskByDC]++; 
-        } 
- 
-        if (countByDC[0] && countByDC[1] && countByDC[2]) { 
-            return true; 
-        } 
- 
-        ui32 x2Count = 0; 
-        for (ui32 dcIdx = 0; dcIdx < DCCount; ++dcIdx) { 
-            if (countByDC[dcIdx] >= 2) { 
-                x2Count++; 
-            } 
-        } 
-        return x2Count >= 2; 
-    } 
- 
-    bool VerifyPartPlacement() const { 
-        if (Info->Type.GetErasure() == TErasureType::ErasureMirror3dc) { 
-            return VerifyPartPlacementForMirror3dc(); 
-        } else { 
-            TSubgroupPartLayout layout; 
- 
-            for (auto &[subgroupIdx, partId] : FoundParts) { 
-                layout.AddItem(subgroupIdx, partId - 1, Info->Type); 
-            } 
-            return layout.CountEffectiveReplicas(Info->Type) == Info->Type.TotalPartCount(); 
-        } 
-    } 
- 
-    void SendStopDiffs() { 
+    }
+
+    void Handle(TEvBlobStorage::TEvPutResult::TPtr &ev) {
+        TEvBlobStorage::TEvPutResult *result = ev->Get();
+        Orbit = std::move(result->Orbit);
+        TraceId = std::move(ev->TraceId);
+
+        StatusFlags = result->StatusFlags;
+        ApproximateFreeSpaceShare = result->ApproximateFreeSpaceShare;
+
+        ui32 originalIdHash = OriginalId.Hash();
+        bool incorrectCookie = ev->Cookie != originalIdHash;
+        bool fail = incorrectCookie
+            || result->Status != NKikimrProto::OK;
+        if (fail) {
+            if (incorrectCookie) {
+                ErrorReason = "Couldn't put the patched blob; Received TEvPutResult with wrong cookie";
+            } else {
+                ErrorReason = TStringBuilder() << "Couldn't put the patched blob;"
+                        << " PutStatus# " << NKikimrProto::EReplyStatus_Name(result->Status)
+                        << " PutErrorReason# " << result->ErrorReason;
+            }
+            R_LOG_ERROR_S("BPPA03", ErrorReason);
+            ReplyAndDie(NKikimrProto::ERROR);
+            return;
+        }
+
+        ReplyAndDie(NKikimrProto::OK);
+    }
+
+    template <typename TEventResultRecord>
+    void PullOutStatusFlagsAndFressSpace(const TEventResultRecord &record){
+        if (record.HasStatusFlags()) {
+            StatusFlags.Merge(record.GetStatusFlags());
+        }
+        if (record.HasApproximateFreeSpaceShare()) {
+            float share = record.GetApproximateFreeSpaceShare();
+            if (ApproximateFreeSpaceShare == 0.0 || share < ApproximateFreeSpaceShare) {
+                ApproximateFreeSpaceShare = share;
+            }
+        }
+    }
+
+    void Handle(TEvBlobStorage::TEvVMovedPatchResult::TPtr &ev) {
+        TEvBlobStorage::TEvVMovedPatchResult *result = ev->Get();
+        A_LOG_DEBUG_S("BPPA02", "received " << ev->Get()->ToString()
+            << " from# " << VDiskIDFromVDiskID(ev->Get()->Record.GetVDiskID()));
+        NKikimrBlobStorage::TEvVMovedPatchResult &record = result->Record;
+        PullOutStatusFlagsAndFressSpace(record);
+        Orbit = std::move(result->Orbit);
+        TraceId = std::move(ev->TraceId);
+
+        ui64 expectedCookie = ((ui64)OriginalId.Hash() << 32) | PatchedId.Hash();
+        bool incorrectCookie = ev->Cookie != expectedCookie;
+        Y_VERIFY(record.HasStatus());
+        bool fail = incorrectCookie
+            || record.GetStatus() != NKikimrProto::OK;
+        if (fail) {
+            if (incorrectCookie) {
+                ErrorReason = "Couldn't put the patched blob; Received TEvVMovedPatchResult with wrong cookie";
+            } else {
+                TString subErrorReason;
+                if (record.HasErrorReason()) {
+                    subErrorReason = TStringBuilder() << " VMovedPatchErrorReason# " << record.GetErrorReason();
+                }
+                ErrorReason = TStringBuilder() << "Couldn't complete patch;"
+                        << " VMovedPatchStatus# " << NKikimrProto::EReplyStatus_Name(record.GetStatus())
+                        << subErrorReason;
+            }
+            A_LOG_INFO_S("BPPA05", "VMovedPatch failed, NaivePatch started;"
+                    << " OriginalId# " << OriginalId
+                    << " PatchedId# " << PatchedId
+                    << " ErrorReason# " << ErrorReason);
+            StartNaivePatch();
+            return;
+        }
+
+        ReplyAndDie(NKikimrProto::OK);
+    }
+
+    void Handle(TEvBlobStorage::TEvVPatchFoundParts::TPtr &ev) {
+        ReceivedFoundParts++;
+
+        NKikimrBlobStorage::TEvVPatchFoundParts &record = ev->Get()->Record;
+
+        Y_VERIFY(record.HasCookie());
+        ui8 subgroupIdx = record.GetCookie();
+
+        Y_VERIFY(record.HasStatus());
+        NKikimrProto::EReplyStatus status = record.GetStatus();
+
+        TString errorReason;
+        if (record.HasErrorReason()) {
+            errorReason = record.GetErrorReason();
+        }
+
+        bool wasReceived = std::exchange(ReceivedResponseFlags[subgroupIdx], true);
+        Y_VERIFY(!wasReceived);
+
+        if (status == NKikimrProto::ERROR) {
+            ErrorResponses++;
+            ErrorResponseFlags[subgroupIdx] = true;
+        }
+
+        EmptyResponseFlags[subgroupIdx] = !record.OriginalPartsSize();
+        for (auto &partId : record.GetOriginalParts()) {
+            FoundParts.push_back({subgroupIdx, (ui8)partId});
+        }
+
+        if (record.OriginalPartsSize()) {
+            OkVDisksWithParts.push_back(subgroupIdx);
+        }
+
+        A_LOG_INFO_S("BPPA07", "received VPatchFoundParts"
+                << " Status# " << status
+                << " ActorId# " << SelfId()
+                << " Group# " << Info->GroupID
+                << " OriginalBlob# " << OriginalId
+                << " PatchedBlob# " << PatchedId
+                << " Deadline# " << Deadline
+                << " SubgroupIdx# " << (ui32)subgroupIdx
+                << " PartsCount# " << record.OriginalPartsSize()
+                << " ReceivedFoundParts# " << ReceivedFoundParts << '/' << SendedStarts
+                << " ErrorReason# " << errorReason);
+
+        if (ReceivedFoundParts == SendedStarts) {
+            bool continueVPatch = VerifyPartPlacement();
+            if (continueVPatch) {
+                continueVPatch = ContinueVPatch();
+            } else {
+                Mon->VPatchPartPlacementVerifyFailed->Inc();
+            }
+            if (!continueVPatch) {
+                StopVPatch();
+                StartFallback();
+            }
+        }
+    }
+
+    void Handle(TEvBlobStorage::TEvVPatchResult::TPtr &ev) {
+        ReceivedResults++;
+        NKikimrBlobStorage::TEvVPatchResult &record = ev->Get()->Record;
+        PullOutStatusFlagsAndFressSpace(record);
+        Y_VERIFY(record.HasStatus());
+        NKikimrProto::EReplyStatus status = record.GetStatus();
+        TString errorReason;
+        if (record.HasErrorReason()) {
+            errorReason = record.GetErrorReason();
+        }
+
+        A_LOG_INFO_S("BPPA06", "received VPatchResult"
+                << " Status# " << status
+                << " ActorId# " << SelfId()
+                << " Group# " << Info->GroupID
+                << " OriginalBlob# " << OriginalId
+                << " PatchedBlob# " << PatchedId
+                << " Deadline# " << Deadline
+                << " ReceivedResults# " << ReceivedResults << '/' << Info->Type.TotalPartCount()
+                << " ErrorReason# " << errorReason);
+
+        Y_VERIFY(record.HasCookie());
+        ui8 subgroupIdx = record.GetCookie();
+
+        bool wasReceived = std::exchange(ReceivedResponseFlags[subgroupIdx], true);
+        Y_VERIFY(!wasReceived);
+
+        if (status != NKikimrProto::OK) {
+            StartFallback();
+            return;
+        }
+
+        if (ReceivedResults == Info->Type.TotalPartCount()) {
+            ReplyAndDie(NKikimrProto::OK);
+        }
+    }
+
+    bool VerifyPartPlacementForMirror3dc() const {
+        constexpr ui32 DCCount = 3;
+        constexpr ui32 VDiskByDC = 3;
+        ui32 countByDC[DCCount] = {0, 0, 0};
+
+        for (auto &[subgroupIdx, partId] : FoundParts) {
+            countByDC[subgroupIdx / VDiskByDC]++;
+        }
+
+        if (countByDC[0] && countByDC[1] && countByDC[2]) {
+            return true;
+        }
+
+        ui32 x2Count = 0;
+        for (ui32 dcIdx = 0; dcIdx < DCCount; ++dcIdx) {
+            if (countByDC[dcIdx] >= 2) {
+                x2Count++;
+            }
+        }
+        return x2Count >= 2;
+    }
+
+    bool VerifyPartPlacement() const {
+        if (Info->Type.GetErasure() == TErasureType::ErasureMirror3dc) {
+            return VerifyPartPlacementForMirror3dc();
+        } else {
+            TSubgroupPartLayout layout;
+
+            for (auto &[subgroupIdx, partId] : FoundParts) {
+                layout.AddItem(subgroupIdx, partId - 1, Info->Type);
+            }
+            return layout.CountEffectiveReplicas(Info->Type) == Info->Type.TotalPartCount();
+        }
+    }
+
+    void SendStopDiffs() {
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPatchDiff>> events;
-        for (ui32 vdiskIdx = 0; vdiskIdx < VDisks.size(); ++vdiskIdx) { 
-            if (!ErrorResponseFlags[vdiskIdx] && !EmptyResponseFlags[vdiskIdx] && ReceivedResponseFlags[vdiskIdx]) { 
+        for (ui32 vdiskIdx = 0; vdiskIdx < VDisks.size(); ++vdiskIdx) {
+            if (!ErrorResponseFlags[vdiskIdx] && !EmptyResponseFlags[vdiskIdx] && ReceivedResponseFlags[vdiskIdx]) {
                 std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> ev = std::make_unique<TEvBlobStorage::TEvVPatchDiff>(
-                        OriginalId, PatchedId, VDisks[vdiskIdx], 0, Deadline, vdiskIdx); 
-                ev->SetForceEnd(); 
+                        OriginalId, PatchedId, VDisks[vdiskIdx], 0, Deadline, vdiskIdx);
+                ev->SetForceEnd();
                 events.emplace_back(std::move(ev));
-            } 
-        } 
-        SendToQueues(events, false); 
-    } 
- 
-    bool WithXorDiffs() const { 
-        return Info->Type.ErasureFamily() != TErasureType::ErasureMirror; 
-    } 
- 
-    void SendDiffs(const TStackVec<TPartPlacement, TypicalPartsInBlob> &placement) { 
+            }
+        }
+        SendToQueues(events, false);
+    }
+
+    bool WithXorDiffs() const {
+        return Info->Type.ErasureFamily() != TErasureType::ErasureMirror;
+    }
+
+    void SendDiffs(const TStackVec<TPartPlacement, TypicalPartsInBlob> &placement) {
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPatchDiff>> events;
- 
-        TPartDiffSet diffSet; 
-        TVector<TDiff> diffs; 
-        diffs.reserve(DiffCount); 
-        for (ui32 diffIdx = 0; diffIdx < DiffCount; ++diffIdx) { 
-            diffs.emplace_back(Diffs[diffIdx].Buffer, Diffs[diffIdx].Offset, false, false); 
-        } 
-        Info->Type.SplitDiffs(TErasureType::CrcModeNone, OriginalId.BlobSize(), diffs, diffSet); 
- 
-        ui32 dataParts = Info->Type.DataParts(); 
-        ui32 dataPartCount = 0; 
-        TStackVec<TPartPlacement, TypicalPartsInBlob> parityPlacements; 
-        if (Info->Type.ErasureFamily() != TErasureType::ErasureMirror) { 
-            for (const TPartPlacement &partPlacement : placement) { 
-                if (partPlacement.PartId <= dataParts) { 
-                    dataPartCount++; 
-                } else { 
-                    parityPlacements.emplace_back(partPlacement); 
-                } 
-            } 
-        } 
- 
-        for (const TPartPlacement &partPlacement : placement) { 
-            ui32 idxInSubgroup = partPlacement.VDiskIdxInSubgroup; 
-            ui32 patchedPartId = partPlacement.PartId; 
-            Y_VERIFY_S(idxInSubgroup < VDisks.size(), "vdisidxInSubgroupkIdx# " << idxInSubgroup << "/" << VDisks.size()); 
- 
-            Y_VERIFY(Info->GetIdxInSubgroup(VDisks[idxInSubgroup], OriginalId.Hash()) == idxInSubgroup); 
-            ui32 patchedIdxInSubgroup = Info->GetIdxInSubgroup(VDisks[idxInSubgroup], PatchedId.Hash()); 
-            if (patchedIdxInSubgroup != idxInSubgroup) { 
-                // now only mirror3dc has this case (has 9 vdisks instead of 4 or 8) 
-                Y_VERIFY(Info->Type.GetErasure() == TErasureType::ErasureMirror3dc); 
-                patchedPartId = 1 + patchedIdxInSubgroup / 3;; 
-            } 
- 
-            ReceivedResponseFlags[idxInSubgroup] = false; 
-            TLogoBlobID originalPartBlobId(OriginalId, partPlacement.PartId); 
-            TLogoBlobID partchedPartBlobId(PatchedId, partPlacement.PartId); 
- 
-            ui32 waitedXorDiffs = (partPlacement.PartId > dataParts)  ? dataPartCount : 0; 
+
+        TPartDiffSet diffSet;
+        TVector<TDiff> diffs;
+        diffs.reserve(DiffCount);
+        for (ui32 diffIdx = 0; diffIdx < DiffCount; ++diffIdx) {
+            diffs.emplace_back(Diffs[diffIdx].Buffer, Diffs[diffIdx].Offset, false, false);
+        }
+        Info->Type.SplitDiffs(TErasureType::CrcModeNone, OriginalId.BlobSize(), diffs, diffSet);
+
+        ui32 dataParts = Info->Type.DataParts();
+        ui32 dataPartCount = 0;
+        TStackVec<TPartPlacement, TypicalPartsInBlob> parityPlacements;
+        if (Info->Type.ErasureFamily() != TErasureType::ErasureMirror) {
+            for (const TPartPlacement &partPlacement : placement) {
+                if (partPlacement.PartId <= dataParts) {
+                    dataPartCount++;
+                } else {
+                    parityPlacements.emplace_back(partPlacement);
+                }
+            }
+        }
+
+        for (const TPartPlacement &partPlacement : placement) {
+            ui32 idxInSubgroup = partPlacement.VDiskIdxInSubgroup;
+            ui32 patchedPartId = partPlacement.PartId;
+            Y_VERIFY_S(idxInSubgroup < VDisks.size(), "vdisidxInSubgroupkIdx# " << idxInSubgroup << "/" << VDisks.size());
+
+            Y_VERIFY(Info->GetIdxInSubgroup(VDisks[idxInSubgroup], OriginalId.Hash()) == idxInSubgroup);
+            ui32 patchedIdxInSubgroup = Info->GetIdxInSubgroup(VDisks[idxInSubgroup], PatchedId.Hash());
+            if (patchedIdxInSubgroup != idxInSubgroup) {
+                // now only mirror3dc has this case (has 9 vdisks instead of 4 or 8)
+                Y_VERIFY(Info->Type.GetErasure() == TErasureType::ErasureMirror3dc);
+                patchedPartId = 1 + patchedIdxInSubgroup / 3;;
+            }
+
+            ReceivedResponseFlags[idxInSubgroup] = false;
+            TLogoBlobID originalPartBlobId(OriginalId, partPlacement.PartId);
+            TLogoBlobID partchedPartBlobId(PatchedId, partPlacement.PartId);
+
+            ui32 waitedXorDiffs = (partPlacement.PartId > dataParts)  ? dataPartCount : 0;
             auto ev = std::make_unique<TEvBlobStorage::TEvVPatchDiff>(originalPartBlobId, partchedPartBlobId,
                 VDisks[idxInSubgroup], waitedXorDiffs, Deadline, idxInSubgroup);
- 
-            ui32 diffForPartIdx = 0; 
-            if (Info->Type.ErasureFamily() != TErasureType::ErasureMirror) { 
-                diffForPartIdx = partPlacement.PartId - 1; 
-            } 
-            auto &diffsForPart = diffSet.PartDiffs[diffForPartIdx].Diffs; 
-            for (auto &diff : diffsForPart) { 
-                ev->AddDiff(diff.Offset, diff.Buffer); 
-            } 
- 
-            for (const TPartPlacement &parity : parityPlacements) { 
-                ev->AddXorReceiver(VDisks[parity.VDiskIdxInSubgroup], parity.PartId); 
-            } 
- 
+
+            ui32 diffForPartIdx = 0;
+            if (Info->Type.ErasureFamily() != TErasureType::ErasureMirror) {
+                diffForPartIdx = partPlacement.PartId - 1;
+            }
+            auto &diffsForPart = diffSet.PartDiffs[diffForPartIdx].Diffs;
+            for (auto &diff : diffsForPart) {
+                ev->AddDiff(diff.Offset, diff.Buffer);
+            }
+
+            for (const TPartPlacement &parity : parityPlacements) {
+                ev->AddXorReceiver(VDisks[parity.VDiskIdxInSubgroup], parity.PartId);
+            }
+
             events.push_back(std::move(ev));
-        } 
-        SendToQueues(events, false); 
-        SendStopDiffs(); 
-        ReceivedResponseFlags.assign(VDisks.size(), false); 
-    } 
- 
-    void SendDiffs(const TStackVec<bool, TypicalPartsInBlob> &inPrimary, 
-            const TStackVec<ui32, TypicalHandoffCount> &choosenHandoffForParts) 
-    { 
-        ui32 handoffPartIdx = 0; 
-        TStackVec<ui32, TypicalPartsInBlob> vdiskIdxForParts(Info->Type.TotalPartCount()); 
-        for (ui32 partIdx = 0; partIdx < Info->Type.TotalPartCount(); ++partIdx) { 
-            vdiskIdxForParts[partIdx] = partIdx; 
-            if (!inPrimary[partIdx]) { 
-                vdiskIdxForParts[partIdx] = choosenHandoffForParts[handoffPartIdx]; 
-                handoffPartIdx++; 
-            } 
-        } 
-        TStackVec<TPartPlacement, TypicalPartsInBlob> placements; 
-        ui32 dataParts = Info->Type.DataParts(); 
-        for (ui32 partIdx = 0; partIdx < Info->Type.TotalPartCount(); ++partIdx) { 
-            ui32 vdiskIdx = vdiskIdxForParts[partIdx]; 
-            Y_VERIFY_S(vdiskIdx == partIdx || vdiskIdx >= dataParts, "vdiskIdx# " << vdiskIdx << " partIdx# " << partIdx); 
-            placements.push_back(TPartPlacement{static_cast<ui8>(vdiskIdx), static_cast<ui8>(partIdx + 1)}); 
-        } 
-        SendDiffs(placements); 
-    } 
- 
-    void StartMovedPatch() { 
-        A_LOG_DEBUG_S("BPPA12", "StartMovedPatch" 
-            << " ActorId# " << SelfId() 
-            << " Group# " << Info->GroupID 
-            << " OriginalBlob# " << OriginalId 
-            << " PatchedBlob# " << PatchedId 
-            << " Deadline# " << Deadline); 
-        Become(&TThis::MovedPatchState); 
- 
-        ui32 subgroupIdx = 0; 
-        if (OkVDisksWithParts) { 
-            ui32 okVDiskIdx = RandomNumber<ui32>(OkVDisksWithParts.size()); 
-            subgroupIdx = OkVDisksWithParts[okVDiskIdx]; 
-        } else { 
-            subgroupIdx = RandomNumber<ui32>(Info->Type.TotalPartCount()); 
-        } 
-        TVDiskID vDisk = Info->GetVDiskInSubgroup(subgroupIdx, OriginalId.Hash()); 
+        }
+        SendToQueues(events, false);
+        SendStopDiffs();
+        ReceivedResponseFlags.assign(VDisks.size(), false);
+    }
+
+    void SendDiffs(const TStackVec<bool, TypicalPartsInBlob> &inPrimary,
+            const TStackVec<ui32, TypicalHandoffCount> &choosenHandoffForParts)
+    {
+        ui32 handoffPartIdx = 0;
+        TStackVec<ui32, TypicalPartsInBlob> vdiskIdxForParts(Info->Type.TotalPartCount());
+        for (ui32 partIdx = 0; partIdx < Info->Type.TotalPartCount(); ++partIdx) {
+            vdiskIdxForParts[partIdx] = partIdx;
+            if (!inPrimary[partIdx]) {
+                vdiskIdxForParts[partIdx] = choosenHandoffForParts[handoffPartIdx];
+                handoffPartIdx++;
+            }
+        }
+        TStackVec<TPartPlacement, TypicalPartsInBlob> placements;
+        ui32 dataParts = Info->Type.DataParts();
+        for (ui32 partIdx = 0; partIdx < Info->Type.TotalPartCount(); ++partIdx) {
+            ui32 vdiskIdx = vdiskIdxForParts[partIdx];
+            Y_VERIFY_S(vdiskIdx == partIdx || vdiskIdx >= dataParts, "vdiskIdx# " << vdiskIdx << " partIdx# " << partIdx);
+            placements.push_back(TPartPlacement{static_cast<ui8>(vdiskIdx), static_cast<ui8>(partIdx + 1)});
+        }
+        SendDiffs(placements);
+    }
+
+    void StartMovedPatch() {
+        A_LOG_DEBUG_S("BPPA12", "StartMovedPatch"
+            << " ActorId# " << SelfId()
+            << " Group# " << Info->GroupID
+            << " OriginalBlob# " << OriginalId
+            << " PatchedBlob# " << PatchedId
+            << " Deadline# " << Deadline);
+        Become(&TThis::MovedPatchState);
+
+        ui32 subgroupIdx = 0;
+        if (OkVDisksWithParts) {
+            ui32 okVDiskIdx = RandomNumber<ui32>(OkVDisksWithParts.size());
+            subgroupIdx = OkVDisksWithParts[okVDiskIdx];
+        } else {
+            subgroupIdx = RandomNumber<ui32>(Info->Type.TotalPartCount());
+        }
+        TVDiskID vDisk = Info->GetVDiskInSubgroup(subgroupIdx, OriginalId.Hash());
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVMovedPatch>> events;
- 
-        ui64 cookie = ((ui64)OriginalId.Hash() << 32) | PatchedId.Hash(); 
-        events.emplace_back(new TEvBlobStorage::TEvVMovedPatch(OriginalGroupId, Info->GroupID, 
-                OriginalId, PatchedId, vDisk, false, cookie, Deadline)); 
-        events.back()->Orbit = std::move(Orbit); 
-        for (ui64 diffIdx = 0; diffIdx < DiffCount; ++diffIdx) { 
-            auto &diff = Diffs[diffIdx]; 
-            events.back()->AddDiff(diff.Offset, diff.Buffer); 
-        } 
-        SendToQueues(events, false); 
-    } 
- 
-    void StartNaivePatch() { 
-        A_LOG_DEBUG_S("BPPA11", "StartNaivePatch" 
-            << " ActorId# " << SelfId() 
-            << " Group# " << Info->GroupID 
-            << " OriginalBlob# " << OriginalId 
-            << " PatchedBlob# " << PatchedId 
-            << " Deadline# " << Deadline); 
-        Become(&TThis::NaiveState); 
+
+        ui64 cookie = ((ui64)OriginalId.Hash() << 32) | PatchedId.Hash();
+        events.emplace_back(new TEvBlobStorage::TEvVMovedPatch(OriginalGroupId, Info->GroupID,
+                OriginalId, PatchedId, vDisk, false, cookie, Deadline));
+        events.back()->Orbit = std::move(Orbit);
+        for (ui64 diffIdx = 0; diffIdx < DiffCount; ++diffIdx) {
+            auto &diff = Diffs[diffIdx];
+            events.back()->AddDiff(diff.Offset, diff.Buffer);
+        }
+        SendToQueues(events, false);
+    }
+
+    void StartNaivePatch() {
+        A_LOG_DEBUG_S("BPPA11", "StartNaivePatch"
+            << " ActorId# " << SelfId()
+            << " Group# " << Info->GroupID
+            << " OriginalBlob# " << OriginalId
+            << " PatchedBlob# " << PatchedId
+            << " Deadline# " << Deadline);
+        Become(&TThis::NaiveState);
         auto get = std::make_unique<TEvBlobStorage::TEvGet>(OriginalId, 0, OriginalId.BlobSize(), Deadline,
             NKikimrBlobStorage::AsyncRead);
-        get->Orbit = std::move(Orbit); 
-        if (OriginalGroupId == Info->GroupID) { 
+        get->Orbit = std::move(Orbit);
+        if (OriginalGroupId == Info->GroupID) {
             Send(ProxyActorId, get.release(), 0, PatchedId.Hash(), std::move(TraceId));
-        } else { 
+        } else {
             SendToBSProxy(SelfId(), OriginalGroupId, get.release(), PatchedId.Hash(), std::move(TraceId));
-        } 
-    } 
- 
-    void StartFallback() { 
-        Mon->PatchesWithFallback->Inc(); 
-        if (WithMovingPatchRequestToStaticNode && UseVPatch) { 
-            StartMovedPatch(); 
-        } else { 
-            StartNaivePatch(); 
-        } 
-    } 
- 
-    void StartVPatch() { 
-        Become(&TThis::VPatchState); 
- 
-        Info->PickSubgroup(OriginalId.Hash(), &VDisks, nullptr); 
-        ReceivedResponseFlags.assign(VDisks.size(), false); 
-        ErrorResponseFlags.assign(VDisks.size(), false); 
-        EmptyResponseFlags.assign(VDisks.size(), false); 
- 
+        }
+    }
+
+    void StartFallback() {
+        Mon->PatchesWithFallback->Inc();
+        if (WithMovingPatchRequestToStaticNode && UseVPatch) {
+            StartMovedPatch();
+        } else {
+            StartNaivePatch();
+        }
+    }
+
+    void StartVPatch() {
+        Become(&TThis::VPatchState);
+
+        Info->PickSubgroup(OriginalId.Hash(), &VDisks, nullptr);
+        ReceivedResponseFlags.assign(VDisks.size(), false);
+        ErrorResponseFlags.assign(VDisks.size(), false);
+        EmptyResponseFlags.assign(VDisks.size(), false);
+
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPatchStart>> events;
- 
-        for (ui32 idx = 0; idx < VDisks.size(); ++idx) { 
+
+        for (ui32 idx = 0; idx < VDisks.size(); ++idx) {
             std::unique_ptr<TEvBlobStorage::TEvVPatchStart> ev = std::make_unique<TEvBlobStorage::TEvVPatchStart>(
-                    OriginalId, PatchedId, VDisks[idx], Deadline, idx, true); 
-            events.emplace_back(std::move(ev)); 
-            SendedStarts++; 
-        } 
- 
-        A_LOG_DEBUG_S("BPPA08", "StartVPatcn" 
-            << " ActorId# " << SelfId() 
-            << " Group# " << Info->GroupID 
-            << " OriginalBlob# " << OriginalId 
-            << " PatchedBlob# " << PatchedId 
-            << " Deadline# " << Deadline 
-            << " SendedStarts# " << SendedStarts); 
- 
-        SendToQueues(events, false); 
-    } 
- 
-    bool FindHandoffs(const TStackVec<TStackVec<ui32, TypicalHandoffCount>, TypicalPartsInBlob>& handoffForParts, 
-            const TStackVec<ui32, TypicalPartsInBlob> &handoffParts, 
-            TStackVec<ui32, TypicalHandoffCount> *choosenHandoffForParts, ui8 depth = 0) 
-    { 
-        auto &choosen = *choosenHandoffForParts; 
-        Y_VERIFY_DEBUG(choosen.size() == handoffParts.size()); 
-        if (depth >= handoffParts.size()) { 
-            return true; 
-        } 
-        ui32 partIdx = handoffParts[depth]; 
-        for (ui32 idx = 0; idx < handoffForParts[partIdx].size(); ++idx) { 
-            Y_VERIFY_DEBUG(depth < choosen.size()); 
-            choosen[depth] = handoffForParts[partIdx][idx]; 
-            bool isCorrect = true; 
-            for (ui32 prevDepth = 0; prevDepth < depth; ++prevDepth) { 
-                Y_VERIFY_DEBUG(prevDepth < choosen.size()); 
-                isCorrect &= (choosen[depth] != choosen[prevDepth]); 
-            } 
-            bool hasAnswer = false; 
-            if (isCorrect) { 
-                hasAnswer = FindHandoffs(handoffForParts, handoffParts, choosenHandoffForParts, depth + 1); 
-            } 
-            if (hasAnswer) { 
-                return true; 
-            } 
-        } 
-        return false; 
-    } 
- 
-    TString ConvertFoundPartsToString() const { 
-        TStringBuilder str; 
-        str << "["; 
-        for (auto &a : FoundParts) { 
-            str << a.ToString() << ' '; 
-        } 
-        str << ']'; 
-        return str; 
-    } 
- 
-    bool ContinueVPatchForMirror3dc() { 
-        constexpr ui32 DCCount = 3; 
-        constexpr ui32 VDiskByDC = 3; 
-        ui32 countByDC[DCCount] = {0, 0, 0}; 
-        TPartPlacement diskByDC[DCCount][VDiskByDC]; 
- 
-        for (auto &[subgroupIdx, partId] : FoundParts) { 
-            ui32 dc = subgroupIdx / VDiskByDC; 
-            ui32 idx = countByDC[dc]; 
-            diskByDC[dc][idx] = TPartPlacement{subgroupIdx, partId}; 
-            countByDC[dc]++; 
-        } 
- 
-        if (countByDC[0] && countByDC[1] && countByDC[2]) { 
-            SendDiffs({diskByDC[0][0], diskByDC[1][0], diskByDC[2][0]}); 
-            return true; 
-        } 
- 
-        ui32 x2Count = 0; 
-        for (ui32 dcIdx = 0; dcIdx < DCCount; ++dcIdx) { 
-            if (countByDC[dcIdx] >= 2) { 
-                x2Count++; 
-            } 
-        } 
-        if (x2Count < 2) { 
-            return false; 
-        } 
-        TStackVec<TPartPlacement, TypicalPartsInBlob> placements; 
-        for (ui32 dcIdx = 0; dcIdx < DCCount; ++dcIdx) { 
-            if (countByDC[dcIdx] >= 2) { 
-                placements.push_back(diskByDC[dcIdx][0]); 
-                placements.push_back(diskByDC[dcIdx][1]); 
-            } 
-        } 
-        SendDiffs(placements); 
-        return true; 
-    } 
- 
-    bool ContinueVPatch() { 
-        A_LOG_DEBUG_S("BPPA09", "ContinueVPatch" 
-            << " ActorId# " << SelfId() 
-            << " Group# " << Info->GroupID 
-            << " OriginalBlob# " << OriginalId 
-            << " PatchedBlob# " << PatchedId 
-            << " FoundParts# " << ConvertFoundPartsToString() 
-            << " Deadline# " << Deadline); 
- 
-        if (Info->Type.GetErasure() == TErasureType::ErasureMirror3dc) { 
-            return ContinueVPatchForMirror3dc(); 
-        } 
- 
-        TStackVec<bool, TypicalPartsInBlob> inPrimary; 
-        TStackVec<TStackVec<ui32, TypicalHandoffCount>, TypicalPartsInBlob> handoffForParts; 
- 
-        inPrimary.resize(Info->Type.TotalPartCount()); 
-        handoffForParts.resize(inPrimary.size()); 
- 
-        for (auto &[subgroupIdx, partId] : FoundParts) { 
-            if (subgroupIdx == partId) { 
-                inPrimary[subgroupIdx] = true; 
-            } else { 
-                handoffForParts[partId - 1].push_back(subgroupIdx); 
-            } 
-        } 
- 
-        TStackVec<ui32, TypicalPartsInBlob> handoffParts; 
-        for (ui32 idx = 0; idx < inPrimary.size(); ++idx) { 
-            if (!inPrimary[idx]) { 
-                handoffParts.push_back(idx); 
-            } 
-        } 
- 
-        TStackVec<ui32, TypicalHandoffCount> choosenHandoffForParts(handoffParts.size()); 
-        if (handoffParts.size()) { 
-            bool find = FindHandoffs(handoffForParts, handoffParts, &choosenHandoffForParts); 
-            Y_VERIFY_DEBUG_S(find, "handoffParts# " << FormatList(handoffParts) 
-                    << " FoundParts# " << ConvertFoundPartsToString() 
-                    << " choosenHandoffForParts# " << FormatList(choosenHandoffForParts) 
-                    << " inPrimary# " << FormatList(inPrimary)); 
-            if (!find) { 
-                Mon->VPatchContinueFailed->Inc(); 
-                return false; 
-            } 
-        } 
- 
-        SendDiffs(inPrimary, choosenHandoffForParts); 
-        return true; 
-    } 
- 
-    void StopVPatch() { 
-        A_LOG_DEBUG_S("BPPA10", "StopVPatch" 
-            << " ActorId# " << SelfId() 
-            << " Group# " << Info->GroupID 
-            << " OriginalBlob# " << OriginalId 
-            << " PatchedBlob# " << PatchedId 
-            << " Deadline# " << Deadline); 
-        SendStopDiffs(); 
-        ReceivedResponseFlags.assign(VDisks.size(), false); 
-    } 
- 
-    bool CheckDiffs() { 
-        for (ui32 diffIdx = 0; diffIdx < DiffCount; ++diffIdx) { 
-            bool ok = Diffs[diffIdx].Offset < OriginalId.BlobSize(); 
-            ok &= Diffs[diffIdx].Offset + Diffs[diffIdx].Buffer.size() <= OriginalId.BlobSize(); 
-            if (!ok) { 
-                TStringBuilder str; 
-                str << "Diff at index " << diffIdx << " went beyound the blob;" 
-                    << " BlobSize# " << OriginalId.BlobSize() 
-                    << " DiffStart# " << Diffs[diffIdx].Offset 
-                    << " DiffEnd# " << Diffs[diffIdx].Offset + Diffs[diffIdx].Buffer.size() << Endl; 
-                ErrorReason = str; 
-                return false; 
-            } 
-        } 
-        for (ui32 diffIdx = 1; diffIdx < DiffCount; ++diffIdx) { 
-            ui32 prevIdx = diffIdx - 1; 
-            bool ok = Diffs[prevIdx].Offset + Diffs[prevIdx].Buffer.size() <= Diffs[diffIdx].Offset; 
-            if (!ok) { 
-                TStringBuilder str; 
-                str << "the end of the diff at index " << prevIdx << " righter than" 
-                    << " the start of the diff at index " << prevIdx << ';' 
-                    << " PrevDiffEnd# " << Diffs[prevIdx].Offset + Diffs[prevIdx].Buffer.size() 
-                    << " DiffStart# " << Diffs[diffIdx].Offset << Endl; 
-                ErrorReason = str; 
-                return false; 
-            } 
-        } 
-        return true; 
-    } 
- 
-    void Bootstrap() { 
-        A_LOG_INFO_S("BPPA01", "bootstrap" 
-            << " ActorId# " << SelfId() 
-            << " Group# " << Info->GroupID 
-            << " DiffCount# " << DiffCount 
-            << " OriginalBlob# " << OriginalId 
-            << " PatchedBlob# " << PatchedId 
-            << " Deadline# " << Deadline 
-            << " RestartCounter# " << RestartCounter); 
-        TLogoBlobID truePatchedBlobId = PatchedId; 
-        bool result = true; 
-        if (Info->Type.ErasureFamily() == TErasureType::ErasureParityBlock) { 
-            result = TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(OriginalId, &truePatchedBlobId, 
-                    MaskForCookieBruteForcing, OriginalGroupId, Info->GroupID); 
-            if (result && PatchedId != truePatchedBlobId) { 
-                TStringBuilder str; 
-                str << "PatchedId wasn't from TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement;"; 
-                str << " OriginalId# " << OriginalId; 
-                str << " PatchedId# " << PatchedId; 
-                ErrorReason = str; 
-                ReplyAndDie(NKikimrProto::ERROR); 
-                return; 
-            } 
-        } 
- 
-        if (!CheckDiffs()) { 
-            ReplyAndDie(NKikimrProto::ERROR); 
-            return; 
-        } 
- 
-        bool isAllowedErasure = Info->Type.ErasureFamily() == TErasureType::ErasureParityBlock 
-                || Info->Type.GetErasure() == TErasureType::ErasureNone 
-                || Info->Type.GetErasure() == TErasureType::ErasureMirror3 
-                || Info->Type.GetErasure() == TErasureType::ErasureMirror3dc; 
-        if (result && isAllowedErasure && UseVPatch && OriginalGroupId == Info->GroupID) { 
-            StartVPatch(); 
-        } else { 
-            StartFallback(); 
-        } 
-    } 
- 
-    STATEFN(NaiveState) { 
-        if (ProcessEvent(ev)) { 
-            return; 
-        } 
-        switch (ev->GetTypeRewrite()) { 
-            hFunc(TEvBlobStorage::TEvGetResult, Handle); 
-            hFunc(TEvBlobStorage::TEvPutResult, Handle); 
-            IgnoreFunc(TEvBlobStorage::TEvVPatchResult); 
-        default: 
-            Y_FAIL("Received unknown event"); 
-        }; 
-    } 
- 
-    STATEFN(MovedPatchState) { 
-        if (ProcessEvent(ev)) { 
-            return; 
-        } 
-        switch (ev->GetTypeRewrite()) { 
-            hFunc(TEvBlobStorage::TEvVMovedPatchResult, Handle); 
-            IgnoreFunc(TEvBlobStorage::TEvVPatchResult); 
-        default: 
-            Y_FAIL("Received unknown event"); 
-        }; 
-    } 
- 
-    STATEFN(VPatchState) { 
-        if (ProcessEvent(ev)) { 
-            return; 
-        } 
-        switch (ev->GetTypeRewrite()) { 
-            hFunc(TEvBlobStorage::TEvVPatchFoundParts, Handle); 
-            hFunc(TEvBlobStorage::TEvVPatchResult, Handle); 
-        default: 
-            Y_FAIL("Received unknown event"); 
-        }; 
-    } 
-}; 
- 
-IActor* CreateBlobStorageGroupPatchRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info, 
-        const TIntrusivePtr<TGroupQueues> &state, const TActorId &source, 
-        const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvPatch *ev, 
-        ui64 cookie, NWilson::TTraceId traceId, TInstant now, 
-        TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-        const TActorId &proxyId, bool useVPatch) { 
-    return new TBlobStorageGroupPatchRequest(info, state, source, mon, ev, cookie, std::move(traceId), 
-            now, storagePoolCounters, proxyId, useVPatch); 
-} 
- 
-}//NKikimr 
+                    OriginalId, PatchedId, VDisks[idx], Deadline, idx, true);
+            events.emplace_back(std::move(ev));
+            SendedStarts++;
+        }
+
+        A_LOG_DEBUG_S("BPPA08", "StartVPatcn"
+            << " ActorId# " << SelfId()
+            << " Group# " << Info->GroupID
+            << " OriginalBlob# " << OriginalId
+            << " PatchedBlob# " << PatchedId
+            << " Deadline# " << Deadline
+            << " SendedStarts# " << SendedStarts);
+
+        SendToQueues(events, false);
+    }
+
+    bool FindHandoffs(const TStackVec<TStackVec<ui32, TypicalHandoffCount>, TypicalPartsInBlob>& handoffForParts,
+            const TStackVec<ui32, TypicalPartsInBlob> &handoffParts,
+            TStackVec<ui32, TypicalHandoffCount> *choosenHandoffForParts, ui8 depth = 0)
+    {
+        auto &choosen = *choosenHandoffForParts;
+        Y_VERIFY_DEBUG(choosen.size() == handoffParts.size());
+        if (depth >= handoffParts.size()) {
+            return true;
+        }
+        ui32 partIdx = handoffParts[depth];
+        for (ui32 idx = 0; idx < handoffForParts[partIdx].size(); ++idx) {
+            Y_VERIFY_DEBUG(depth < choosen.size());
+            choosen[depth] = handoffForParts[partIdx][idx];
+            bool isCorrect = true;
+            for (ui32 prevDepth = 0; prevDepth < depth; ++prevDepth) {
+                Y_VERIFY_DEBUG(prevDepth < choosen.size());
+                isCorrect &= (choosen[depth] != choosen[prevDepth]);
+            }
+            bool hasAnswer = false;
+            if (isCorrect) {
+                hasAnswer = FindHandoffs(handoffForParts, handoffParts, choosenHandoffForParts, depth + 1);
+            }
+            if (hasAnswer) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    TString ConvertFoundPartsToString() const {
+        TStringBuilder str;
+        str << "[";
+        for (auto &a : FoundParts) {
+            str << a.ToString() << ' ';
+        }
+        str << ']';
+        return str;
+    }
+
+    bool ContinueVPatchForMirror3dc() {
+        constexpr ui32 DCCount = 3;
+        constexpr ui32 VDiskByDC = 3;
+        ui32 countByDC[DCCount] = {0, 0, 0};
+        TPartPlacement diskByDC[DCCount][VDiskByDC];
+
+        for (auto &[subgroupIdx, partId] : FoundParts) {
+            ui32 dc = subgroupIdx / VDiskByDC;
+            ui32 idx = countByDC[dc];
+            diskByDC[dc][idx] = TPartPlacement{subgroupIdx, partId};
+            countByDC[dc]++;
+        }
+
+        if (countByDC[0] && countByDC[1] && countByDC[2]) {
+            SendDiffs({diskByDC[0][0], diskByDC[1][0], diskByDC[2][0]});
+            return true;
+        }
+
+        ui32 x2Count = 0;
+        for (ui32 dcIdx = 0; dcIdx < DCCount; ++dcIdx) {
+            if (countByDC[dcIdx] >= 2) {
+                x2Count++;
+            }
+        }
+        if (x2Count < 2) {
+            return false;
+        }
+        TStackVec<TPartPlacement, TypicalPartsInBlob> placements;
+        for (ui32 dcIdx = 0; dcIdx < DCCount; ++dcIdx) {
+            if (countByDC[dcIdx] >= 2) {
+                placements.push_back(diskByDC[dcIdx][0]);
+                placements.push_back(diskByDC[dcIdx][1]);
+            }
+        }
+        SendDiffs(placements);
+        return true;
+    }
+
+    bool ContinueVPatch() {
+        A_LOG_DEBUG_S("BPPA09", "ContinueVPatch"
+            << " ActorId# " << SelfId()
+            << " Group# " << Info->GroupID
+            << " OriginalBlob# " << OriginalId
+            << " PatchedBlob# " << PatchedId
+            << " FoundParts# " << ConvertFoundPartsToString()
+            << " Deadline# " << Deadline);
+
+        if (Info->Type.GetErasure() == TErasureType::ErasureMirror3dc) {
+            return ContinueVPatchForMirror3dc();
+        }
+
+        TStackVec<bool, TypicalPartsInBlob> inPrimary;
+        TStackVec<TStackVec<ui32, TypicalHandoffCount>, TypicalPartsInBlob> handoffForParts;
+
+        inPrimary.resize(Info->Type.TotalPartCount());
+        handoffForParts.resize(inPrimary.size());
+
+        for (auto &[subgroupIdx, partId] : FoundParts) {
+            if (subgroupIdx == partId) {
+                inPrimary[subgroupIdx] = true;
+            } else {
+                handoffForParts[partId - 1].push_back(subgroupIdx);
+            }
+        }
+
+        TStackVec<ui32, TypicalPartsInBlob> handoffParts;
+        for (ui32 idx = 0; idx < inPrimary.size(); ++idx) {
+            if (!inPrimary[idx]) {
+                handoffParts.push_back(idx);
+            }
+        }
+
+        TStackVec<ui32, TypicalHandoffCount> choosenHandoffForParts(handoffParts.size());
+        if (handoffParts.size()) {
+            bool find = FindHandoffs(handoffForParts, handoffParts, &choosenHandoffForParts);
+            Y_VERIFY_DEBUG_S(find, "handoffParts# " << FormatList(handoffParts)
+                    << " FoundParts# " << ConvertFoundPartsToString()
+                    << " choosenHandoffForParts# " << FormatList(choosenHandoffForParts)
+                    << " inPrimary# " << FormatList(inPrimary));
+            if (!find) {
+                Mon->VPatchContinueFailed->Inc();
+                return false;
+            }
+        }
+
+        SendDiffs(inPrimary, choosenHandoffForParts);
+        return true;
+    }
+
+    void StopVPatch() {
+        A_LOG_DEBUG_S("BPPA10", "StopVPatch"
+            << " ActorId# " << SelfId()
+            << " Group# " << Info->GroupID
+            << " OriginalBlob# " << OriginalId
+            << " PatchedBlob# " << PatchedId
+            << " Deadline# " << Deadline);
+        SendStopDiffs();
+        ReceivedResponseFlags.assign(VDisks.size(), false);
+    }
+
+    bool CheckDiffs() {
+        for (ui32 diffIdx = 0; diffIdx < DiffCount; ++diffIdx) {
+            bool ok = Diffs[diffIdx].Offset < OriginalId.BlobSize();
+            ok &= Diffs[diffIdx].Offset + Diffs[diffIdx].Buffer.size() <= OriginalId.BlobSize();
+            if (!ok) {
+                TStringBuilder str;
+                str << "Diff at index " << diffIdx << " went beyound the blob;"
+                    << " BlobSize# " << OriginalId.BlobSize()
+                    << " DiffStart# " << Diffs[diffIdx].Offset
+                    << " DiffEnd# " << Diffs[diffIdx].Offset + Diffs[diffIdx].Buffer.size() << Endl;
+                ErrorReason = str;
+                return false;
+            }
+        }
+        for (ui32 diffIdx = 1; diffIdx < DiffCount; ++diffIdx) {
+            ui32 prevIdx = diffIdx - 1;
+            bool ok = Diffs[prevIdx].Offset + Diffs[prevIdx].Buffer.size() <= Diffs[diffIdx].Offset;
+            if (!ok) {
+                TStringBuilder str;
+                str << "the end of the diff at index " << prevIdx << " righter than"
+                    << " the start of the diff at index " << prevIdx << ';'
+                    << " PrevDiffEnd# " << Diffs[prevIdx].Offset + Diffs[prevIdx].Buffer.size()
+                    << " DiffStart# " << Diffs[diffIdx].Offset << Endl;
+                ErrorReason = str;
+                return false;
+            }
+        }
+        return true;
+    }
+
+    void Bootstrap() {
+        A_LOG_INFO_S("BPPA01", "bootstrap"
+            << " ActorId# " << SelfId()
+            << " Group# " << Info->GroupID
+            << " DiffCount# " << DiffCount
+            << " OriginalBlob# " << OriginalId
+            << " PatchedBlob# " << PatchedId
+            << " Deadline# " << Deadline
+            << " RestartCounter# " << RestartCounter);
+        TLogoBlobID truePatchedBlobId = PatchedId;
+        bool result = true;
+        if (Info->Type.ErasureFamily() == TErasureType::ErasureParityBlock) {
+            result = TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(OriginalId, &truePatchedBlobId,
+                    MaskForCookieBruteForcing, OriginalGroupId, Info->GroupID);
+            if (result && PatchedId != truePatchedBlobId) {
+                TStringBuilder str;
+                str << "PatchedId wasn't from TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement;";
+                str << " OriginalId# " << OriginalId;
+                str << " PatchedId# " << PatchedId;
+                ErrorReason = str;
+                ReplyAndDie(NKikimrProto::ERROR);
+                return;
+            }
+        }
+
+        if (!CheckDiffs()) {
+            ReplyAndDie(NKikimrProto::ERROR);
+            return;
+        }
+
+        bool isAllowedErasure = Info->Type.ErasureFamily() == TErasureType::ErasureParityBlock
+                || Info->Type.GetErasure() == TErasureType::ErasureNone
+                || Info->Type.GetErasure() == TErasureType::ErasureMirror3
+                || Info->Type.GetErasure() == TErasureType::ErasureMirror3dc;
+        if (result && isAllowedErasure && UseVPatch && OriginalGroupId == Info->GroupID) {
+            StartVPatch();
+        } else {
+            StartFallback();
+        }
+    }
+
+    STATEFN(NaiveState) {
+        if (ProcessEvent(ev)) {
+            return;
+        }
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvBlobStorage::TEvGetResult, Handle);
+            hFunc(TEvBlobStorage::TEvPutResult, Handle);
+            IgnoreFunc(TEvBlobStorage::TEvVPatchResult);
+        default:
+            Y_FAIL("Received unknown event");
+        };
+    }
+
+    STATEFN(MovedPatchState) {
+        if (ProcessEvent(ev)) {
+            return;
+        }
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvBlobStorage::TEvVMovedPatchResult, Handle);
+            IgnoreFunc(TEvBlobStorage::TEvVPatchResult);
+        default:
+            Y_FAIL("Received unknown event");
+        };
+    }
+
+    STATEFN(VPatchState) {
+        if (ProcessEvent(ev)) {
+            return;
+        }
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvBlobStorage::TEvVPatchFoundParts, Handle);
+            hFunc(TEvBlobStorage::TEvVPatchResult, Handle);
+        default:
+            Y_FAIL("Received unknown event");
+        };
+    }
+};
+
+IActor* CreateBlobStorageGroupPatchRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info,
+        const TIntrusivePtr<TGroupQueues> &state, const TActorId &source,
+        const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TEvBlobStorage::TEvPatch *ev,
+        ui64 cookie, NWilson::TTraceId traceId, TInstant now,
+        TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+        const TActorId &proxyId, bool useVPatch) {
+    return new TBlobStorageGroupPatchRequest(info, state, source, mon, ev, cookie, std::move(traceId),
+            now, storagePoolCounters, proxyId, useVPatch);
+}
+
+}//NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_put.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_put.cpp
index 1a0be7f70e..d9e0e2b320 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_put.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_put.cpp
@@ -21,7 +21,7 @@ struct TEvResume : public TEventLocal<TEvResume, TEvBlobStorage::EvResume> {
     double WaitSec;
     double SplitSec;
     size_t Count;
-    TBatchedVec<TDataPartSet> PartSets; 
+    TBatchedVec<TDataPartSet> PartSets;
 };
 
 struct TEvAccelerate : public TEventLocal<TEvAccelerate, TEvBlobStorage::EvAccelerate> {
@@ -37,43 +37,43 @@ struct TEvAccelerate : public TEventLocal<TEvAccelerate, TEvBlobStorage::EvAccel
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobStorageGroupPutRequest> {
-    struct TMultiPutItemInfo { 
-        TLogoBlobID BlobId; 
-        TString Buffer; 
-        ui64 BufferSize; 
+    struct TMultiPutItemInfo {
+        TLogoBlobID BlobId;
+        TString Buffer;
+        ui64 BufferSize;
         TActorId Recipient;
-        ui64 Cookie; 
-        NWilson::TTraceId TraceId; 
+        ui64 Cookie;
+        NWilson::TTraceId TraceId;
         NLWTrace::TOrbit Orbit;
         bool Replied = false;
- 
+
         TMultiPutItemInfo(TLogoBlobID id, const TString& buffer, TActorId recipient, ui64 cookie,
                 NWilson::TTraceId traceId, NLWTrace::TOrbit &&orbit)
-            : BlobId(id) 
-            , Buffer(buffer) 
-            , BufferSize(buffer.size()) 
+            : BlobId(id)
+            , Buffer(buffer)
+            , BufferSize(buffer.size())
             , Recipient(recipient)
-            , Cookie(cookie) 
-            , TraceId(std::move(traceId)) 
+            , Cookie(cookie)
+            , TraceId(std::move(traceId))
             , Orbit(std::move(orbit))
-        {} 
-    }; 
- 
+        {}
+    };
+
     TPutImpl PutImpl;
     TRootCause RootCauseTrack;
 
-    TStackVec<ui64, TypicalDisksInGroup> WaitingVDiskResponseCount; 
-    ui64 WaitingVDiskCount = 0; 
- 
-    TBatchedVec<TMultiPutItemInfo> ItemsInfo; 
- 
-    bool IsManyPuts = false; 
- 
+    TStackVec<ui64, TypicalDisksInGroup> WaitingVDiskResponseCount;
+    ui64 WaitingVDiskCount = 0;
+
+    TBatchedVec<TMultiPutItemInfo> ItemsInfo;
+
+    bool IsManyPuts = false;
+
     TInstant Deadline;
     ui64 RequestsSent = 0;
     ui64 ResponsesReceived = 0;
     ui64 MaxSaneRequests = 0;
-    ui64 ResponsesSent = 0; 
+    ui64 ResponsesSent = 0;
 
     TInstant StartTime;
     NKikimrBlobStorage::EPutHandleClass HandleClass;
@@ -91,8 +91,8 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
     bool IsAccelerated;
     bool IsAccelerateScheduled;
 
-    const bool IsMultiPutMode; 
- 
+    const bool IsMultiPutMode;
+
     void SanityCheck() {
         if (RequestsSent <= MaxSaneRequests) {
             return;
@@ -118,23 +118,23 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
         }
         IsAccelerated = true;
 
-        if (IsMultiPutMode) { 
+        if (IsMultiPutMode) {
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> vMultiPuts;
-            PutImpl.Accelerate(LogCtx, vMultiPuts); 
-            UpdatePengingVDiskResponseCount<TEvBlobStorage::TEvVMultiPut, TVMultiPutCookie>(vMultiPuts); 
-            RequestsSent += vMultiPuts.size(); 
+            PutImpl.Accelerate(LogCtx, vMultiPuts);
+            UpdatePengingVDiskResponseCount<TEvBlobStorage::TEvVMultiPut, TVMultiPutCookie>(vMultiPuts);
+            RequestsSent += vMultiPuts.size();
             *Mon->NodeMon->AccelerateEvVMultiPutCount += vMultiPuts.size();
-            CountPuts(vMultiPuts); 
+            CountPuts(vMultiPuts);
             SendToQueues(vMultiPuts, TimeStatsEnabled);
-        } else { 
+        } else {
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-            PutImpl.Accelerate(LogCtx, vPuts); 
-            UpdatePengingVDiskResponseCount<TEvBlobStorage::TEvVPut, TBlobCookie>(vPuts); 
-            RequestsSent += vPuts.size(); 
+            PutImpl.Accelerate(LogCtx, vPuts);
+            UpdatePengingVDiskResponseCount<TEvBlobStorage::TEvVPut, TBlobCookie>(vPuts);
+            RequestsSent += vPuts.size();
             *Mon->NodeMon->AccelerateEvVPutCount += vPuts.size();
-            CountPuts(vPuts); 
+            CountPuts(vPuts);
             SendToQueues(vPuts, TimeStatsEnabled);
-        } 
+        }
     }
 
     void Handle(TEvBlobStorage::TEvVPutResult::TPtr &ev) {
@@ -149,24 +149,24 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
         const ui64 cyclesPerUs = NHPTimer::GetCyclesPerSecond() / 1000000;
         ev->Get()->Record.MutableTimestamps()->SetReceivedByDSProxyUs(GetCycleCountFast() / cyclesPerUs);
         const NKikimrBlobStorage::TEvVPutResult &record = ev->Get()->Record;
-        const TLogoBlobID blob = LogoBlobIDFromLogoBlobID(record.GetBlobID()); 
-        const TLogoBlobID origBlobId = TLogoBlobID(blob, 0); 
-        Y_VERIFY(record.HasCookie()); 
-        TBlobCookie cookie(record.GetCookie()); 
-        const ui64 idx = cookie.GetBlobIdx(); 
-        const ui64 vdisk = cookie.GetVDiskOrderNumber(); 
+        const TLogoBlobID blob = LogoBlobIDFromLogoBlobID(record.GetBlobID());
+        const TLogoBlobID origBlobId = TLogoBlobID(blob, 0);
+        Y_VERIFY(record.HasCookie());
+        TBlobCookie cookie(record.GetCookie());
+        const ui64 idx = cookie.GetBlobIdx();
+        const ui64 vdisk = cookie.GetVDiskOrderNumber();
         const NKikimrProto::EReplyStatus status = record.GetStatus();
- 
-        Y_VERIFY(vdisk < WaitingVDiskResponseCount.size(), "blobIdx# %" PRIu64 " vdisk# %" PRIu64, idx, vdisk); 
-        if (WaitingVDiskResponseCount[vdisk] == 1) { 
-            WaitingVDiskCount--; 
-        } 
-        WaitingVDiskResponseCount[vdisk]--; 
- 
-        Y_VERIFY(idx < ItemsInfo.size()); 
-        Y_VERIFY(origBlobId == ItemsInfo[idx].BlobId); 
+
+        Y_VERIFY(vdisk < WaitingVDiskResponseCount.size(), "blobIdx# %" PRIu64 " vdisk# %" PRIu64, idx, vdisk);
+        if (WaitingVDiskResponseCount[vdisk] == 1) {
+            WaitingVDiskCount--;
+        }
+        WaitingVDiskResponseCount[vdisk]--;
+
+        Y_VERIFY(idx < ItemsInfo.size());
+        Y_VERIFY(origBlobId == ItemsInfo[idx].BlobId);
         if (TimeStatsEnabled && record.GetMsgQoS().HasExecTimeStats()) {
-            TimeStats.ApplyPut(ItemsInfo[idx].BufferSize, record.GetMsgQoS().GetExecTimeStats()); 
+            TimeStats.ApplyPut(ItemsInfo[idx].BufferSize, record.GetMsgQoS().GetExecTimeStats());
         }
 
         Y_VERIFY(record.HasVDiskID());
@@ -174,7 +174,7 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
         const TVDiskIdShort shortId(vDiskId);
 
         LWPROBE(DSProxyVDiskRequestDuration, TEvBlobStorage::EvVPut, blob.BlobSize(), blob.TabletID(),
-                Info->GroupID, blob.Channel(), Info->GetFailDomainOrderNumber(shortId), 
+                Info->GroupID, blob.Channel(), Info->GetFailDomainOrderNumber(shortId),
                 GetStartTime(record.GetTimestamps()),
                 GetTotalTimeMs(record.GetTimestamps()),
                 GetVDiskTimeMs(record.GetTimestamps()),
@@ -188,9 +188,9 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
         }
 
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-        TPutImpl::TPutResultVec putResults; 
-        PutImpl.OnVPutEventResult(LogCtx, ev->Sender, *ev->Get(), vPuts, putResults); 
-        UpdatePengingVDiskResponseCount<TEvBlobStorage::TEvVPut, TBlobCookie>(vPuts); 
+        TPutImpl::TPutResultVec putResults;
+        PutImpl.OnVPutEventResult(LogCtx, ev->Sender, *ev->Get(), vPuts, putResults);
+        UpdatePengingVDiskResponseCount<TEvBlobStorage::TEvVPut, TBlobCookie>(vPuts);
         RequestsSent += vPuts.size();
         CountPuts(vPuts);
         SendToQueues(vPuts, TimeStatsEnabled);
@@ -201,7 +201,7 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
                 ui64(RequestsSent), ui64(ResponsesReceived));
 
         if (!IsAccelerateScheduled && !IsAccelerated) {
-            if (WaitingVDiskCount == 1 && RequestsSent > 1) { 
+            if (WaitingVDiskCount == 1 && RequestsSent > 1) {
                 ui64 timeToAccelerateUs = PutImpl.GetTimeToAccelerateNs(LogCtx) / 1000;
                 TDuration timeSinceStart = TActivationContext::Now() - StartTime;
                 if (timeSinceStart.MicroSeconds() < timeToAccelerateUs) {
@@ -220,27 +220,27 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
 
     void Handle(TEvBlobStorage::TEvVMultiPutResult::TPtr &ev) {
         ProcessReplyFromQueue(ev);
-        // generate wilson event about request completion 
+        // generate wilson event about request completion
         WILSON_TRACE_FROM_ACTOR(*TlsActivationContext, *this, &TraceId, EvVPutResultReceived, MergedNode = std::move(ev->TraceId));
-        ResponsesReceived++; 
- 
-        const ui64 cyclesPerUs = NHPTimer::GetCyclesPerSecond() / 1000000; 
+        ResponsesReceived++;
+
+        const ui64 cyclesPerUs = NHPTimer::GetCyclesPerSecond() / 1000000;
         ev->Get()->Record.MutableTimestamps()->SetReceivedByDSProxyUs(GetCycleCountFast() / cyclesPerUs);
-        const NKikimrBlobStorage::TEvVMultiPutResult &record = ev->Get()->Record; 
- 
-        if (TimeStatsEnabled && record.GetMsgQoS().HasExecTimeStats()) { 
+        const NKikimrBlobStorage::TEvVMultiPutResult &record = ev->Get()->Record;
+
+        if (TimeStatsEnabled && record.GetMsgQoS().HasExecTimeStats()) {
             TimeStats.ApplyPut(RequestBytes, record.GetMsgQoS().GetExecTimeStats());
-        } 
- 
-        Y_VERIFY(record.HasVDiskID()); 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
-        const TVDiskIdShort shortId(vDiskId); 
- 
-        Y_VERIFY(record.HasCookie()); 
-        TVMultiPutCookie cookie(record.GetCookie()); 
-        const ui64 vdisk = cookie.GetVDiskOrderNumber(); 
+        }
+
+        Y_VERIFY(record.HasVDiskID());
+        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
+        const TVDiskIdShort shortId(vDiskId);
+
+        Y_VERIFY(record.HasCookie());
+        TVMultiPutCookie cookie(record.GetCookie());
+        const ui64 vdisk = cookie.GetVDiskOrderNumber();
         const NKikimrProto::EReplyStatus status = record.GetStatus();
- 
+
         auto prio = NLog::PRI_DEBUG;
         if (status != NKikimrProto::OK) {
             prio = NLog::PRI_INFO;
@@ -253,12 +253,12 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
         A_LOG_LOG_S(false, prio, "BPP02", "received " << ev->Get()->ToString()
                 << " from# " << VDiskIDFromVDiskID(ev->Get()->Record.GetVDiskID()));
 
-        Y_VERIFY(vdisk < WaitingVDiskResponseCount.size(), " vdisk# %" PRIu64, vdisk); 
-        if (WaitingVDiskResponseCount[vdisk] == 1) { 
-            WaitingVDiskCount--; 
-        } 
-        WaitingVDiskResponseCount[vdisk]--; 
- 
+        Y_VERIFY(vdisk < WaitingVDiskResponseCount.size(), " vdisk# %" PRIu64, vdisk);
+        if (WaitingVDiskResponseCount[vdisk] == 1) {
+            WaitingVDiskCount--;
+        }
+        WaitingVDiskResponseCount[vdisk]--;
+
         // Trace put request duration
         if (LWPROBE_ENABLED(DSProxyVDiskRequestDuration)) {
             for (auto &item : record.GetItems()) {
@@ -278,67 +278,67 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
         // Handle put results
         bool isCauseRegistered = !RootCauseTrack.IsOn;
         TPutImpl::TPutResultVec putResults;
-        for (auto &item : record.GetItems()) { 
+        for (auto &item : record.GetItems()) {
             if (!isCauseRegistered) {
                 isCauseRegistered = RootCauseTrack.OnReply(cookie.GetCauseIdx(),
                     GetTotalTimeMs(record.GetTimestamps()) - GetVDiskTimeMs(record.GetTimestamps()),
                     GetVDiskTimeMs(record.GetTimestamps()));
             }
- 
-            Y_VERIFY(item.HasStatus()); 
-            Y_VERIFY(item.HasBlobID()); 
-            Y_VERIFY(item.HasCookie()); 
+
+            Y_VERIFY(item.HasStatus());
+            Y_VERIFY(item.HasBlobID());
+            Y_VERIFY(item.HasCookie());
             ui64 blobIdx = TBlobCookie(item.GetCookie()).GetBlobIdx();
-            NKikimrProto::EReplyStatus itemStatus = item.GetStatus(); 
-            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
+            NKikimrProto::EReplyStatus itemStatus = item.GetStatus();
+            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
             Y_VERIFY(itemStatus != NKikimrProto::RACE); // we should get RACE for the whole request and handle it in CheckForTermErrors
             if (itemStatus == NKikimrProto::BLOCKED || itemStatus == NKikimrProto::DEADLINE) {
-                TStringStream errorReason; 
-                errorReason << "Got VMultiPutResult itemStatus# " << itemStatus << " from VDiskId# " << vDiskId; 
-                ErrorReason = errorReason.Str(); 
-                PutImpl.PrepareOneReply(itemStatus, TLogoBlobID(blobId, 0), blobIdx, LogCtx, ErrorReason, putResults); 
-            } 
-        } 
+                TStringStream errorReason;
+                errorReason << "Got VMultiPutResult itemStatus# " << itemStatus << " from VDiskId# " << vDiskId;
+                ErrorReason = errorReason.Str();
+                PutImpl.PrepareOneReply(itemStatus, TLogoBlobID(blobId, 0), blobIdx, LogCtx, ErrorReason, putResults);
+            }
+        }
         if (ReplyAndDieWithLastResponse(putResults)) {
-            return; 
-        } 
-        putResults.clear(); 
- 
+            return;
+        }
+        putResults.clear();
+
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> vMultiPuts;
-        PutImpl.OnVPutEventResult(LogCtx, ev->Sender, *ev->Get(), vMultiPuts, putResults); 
-        UpdatePengingVDiskResponseCount<TEvBlobStorage::TEvVMultiPut, TVMultiPutCookie>(vMultiPuts); 
-        RequestsSent += vMultiPuts.size(); 
-        CountPuts(vMultiPuts); 
+        PutImpl.OnVPutEventResult(LogCtx, ev->Sender, *ev->Get(), vMultiPuts, putResults);
+        UpdatePengingVDiskResponseCount<TEvBlobStorage::TEvVMultiPut, TVMultiPutCookie>(vMultiPuts);
+        RequestsSent += vMultiPuts.size();
+        CountPuts(vMultiPuts);
         SendToQueues(vMultiPuts, TimeStatsEnabled);
         if (ReplyAndDieWithLastResponse(putResults)) {
-            return; 
-        } 
-        Y_VERIFY(RequestsSent > ResponsesReceived, "RequestsSent# %" PRIu64 " ResponsesReceived# %" PRIu64 
-                " ResponsesSent# %" PRIu64 " BlobsCount# %" PRIu64 " TPutImpl# %s", ui64(RequestsSent), ui64(ResponsesReceived), 
-                (ui64)ResponsesSent, (ui64)ItemsInfo.size(), PutImpl.DumpFullState().data()); 
- 
-        if (!IsAccelerateScheduled && !IsAccelerated) { 
-            if (WaitingVDiskCount == 1 && RequestsSent > 1) { 
-                ui64 timeToAccelerateUs = PutImpl.GetTimeToAccelerateNs(LogCtx) / 1000; 
+            return;
+        }
+        Y_VERIFY(RequestsSent > ResponsesReceived, "RequestsSent# %" PRIu64 " ResponsesReceived# %" PRIu64
+                " ResponsesSent# %" PRIu64 " BlobsCount# %" PRIu64 " TPutImpl# %s", ui64(RequestsSent), ui64(ResponsesReceived),
+                (ui64)ResponsesSent, (ui64)ItemsInfo.size(), PutImpl.DumpFullState().data());
+
+        if (!IsAccelerateScheduled && !IsAccelerated) {
+            if (WaitingVDiskCount == 1 && RequestsSent > 1) {
+                ui64 timeToAccelerateUs = PutImpl.GetTimeToAccelerateNs(LogCtx) / 1000;
                 TDuration timeSinceStart = TActivationContext::Now() - StartTime;
-                if (timeSinceStart.MicroSeconds() < timeToAccelerateUs) { 
+                if (timeSinceStart.MicroSeconds() < timeToAccelerateUs) {
                     ui64 causeIdx = RootCauseTrack.RegisterAccelerate();
                     Schedule(TDuration::MicroSeconds(timeToAccelerateUs - timeSinceStart.MicroSeconds()),
                             new TEvAccelerate(causeIdx));
-                    IsAccelerateScheduled = true; 
-                } else { 
+                    IsAccelerateScheduled = true;
+                } else {
                     Accelerate();
-                } 
-            } 
-        } 
+                }
+            }
+        }
         SanityCheck(); // May Die
-    } 
- 
+    }
+
     friend class TBlobStorageGroupRequestActor<TBlobStorageGroupPutRequest>;
 
     void ReplyAndDie(NKikimrProto::EReplyStatus status) {
-        TPutImpl::TPutResultVec putResults; 
-        PutImpl.PrepareReply(status, LogCtx, ErrorReason, putResults); 
+        TPutImpl::TPutResultVec putResults;
+        PutImpl.PrepareReply(status, LogCtx, ErrorReason, putResults);
         Y_VERIFY(ReplyAndDieWithLastResponse(putResults));
     }
 
@@ -346,14 +346,14 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
         for (auto& [blobIdx, result] : putResults) {
             Y_VERIFY(ResponsesSent != ItemsInfo.size());
             SendReply(result, blobIdx);
-        } 
+        }
         if (ResponsesSent == ItemsInfo.size()) {
             PassAway();
             return true;
         }
-        return false; 
-    } 
- 
+        return false;
+    }
+
     void SendReply(std::unique_ptr<TEvBlobStorage::TEvPutResult> &putResult, ui64 blobIdx) {
         NKikimrProto::EReplyStatus status = putResult->Status;
         A_LOG_LOG_S(false, status == NKikimrProto::OK ? NLog::PRI_DEBUG : NLog::PRI_NOTICE, "BPP21",
@@ -361,47 +361,47 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
             << " ItemsInfo.size# " << ItemsInfo.size()
             << " Last# " << (ResponsesSent + 1 == ItemsInfo.size() ? "true" : "false"));
         const TDuration duration = TActivationContext::Now() - StartTime;
-        TLogoBlobID blobId = putResult->Id; 
-        TLogoBlobID origBlobId = TLogoBlobID(blobId, 0); 
+        TLogoBlobID blobId = putResult->Id;
+        TLogoBlobID origBlobId = TLogoBlobID(blobId, 0);
         WILSON_TRACE_FROM_ACTOR(*TlsActivationContext, *this, &ItemsInfo[blobIdx].TraceId, EvPutResultSent, ReplyStatus = status);
-        Mon->CountPutPesponseTime(Info->GetDeviceType(), HandleClass, ItemsInfo[blobIdx].BufferSize, duration); 
+        Mon->CountPutPesponseTime(Info->GetDeviceType(), HandleClass, ItemsInfo[blobIdx].BufferSize, duration);
         *Mon->ActivePutCapacity -= ReportedBytes;
-        Y_VERIFY(PutImpl.GetHandoffPartsSent() <= Info->Type.TotalPartCount() * MaxHandoffNodes * ItemsInfo.size()); 
+        Y_VERIFY(PutImpl.GetHandoffPartsSent() <= Info->Type.TotalPartCount() * MaxHandoffNodes * ItemsInfo.size());
         ++*Mon->HandoffPartsSent[Min(Mon->HandoffPartsSent.size() - 1, (size_t)PutImpl.GetHandoffPartsSent())];
         ReportedBytes = 0;
         const bool success = (status == NKikimrProto::OK);
         LWPROBE(DSProxyRequestDuration, TEvBlobStorage::EvPut,
-                blobId.BlobSize(), 
+                blobId.BlobSize(),
                 duration.SecondsFloat() * 1000.0,
-                blobId.TabletID(), Info->GroupID, blobId.Channel(), 
-                NKikimrBlobStorage::EPutHandleClass_Name(HandleClass), success); 
-        ResponsesSent++; 
-        Y_VERIFY(ResponsesSent <= ItemsInfo.size()); 
+                blobId.TabletID(), Info->GroupID, blobId.Channel(),
+                NKikimrBlobStorage::EPutHandleClass_Name(HandleClass), success);
+        ResponsesSent++;
+        Y_VERIFY(ResponsesSent <= ItemsInfo.size());
         RootCauseTrack.RenderTrack(ItemsInfo[blobIdx].Orbit);
         LWTRACK(DSProxyPutReply, ItemsInfo[blobIdx].Orbit);
         putResult->Orbit = std::move(ItemsInfo[blobIdx].Orbit);
-        if (!IsManyPuts) { 
+        if (!IsManyPuts) {
             SendResponse(std::move(putResult), TimeStatsEnabled ? &TimeStats : nullptr);
-        } else { 
+        } else {
             SendResponse(std::move(putResult), TimeStatsEnabled ? &TimeStats : nullptr,
                 ItemsInfo[blobIdx].Recipient, ItemsInfo[blobIdx].Cookie,
-                std::move(ItemsInfo[blobIdx].TraceId)); 
+                std::move(ItemsInfo[blobIdx].TraceId));
             ItemsInfo[blobIdx].Replied = true;
-        } 
+        }
     }
 
-    TString BlobIdSequenceToString() const { 
-        TStringBuilder blobIdsStr; 
-        blobIdsStr << '['; 
-        for (ui64 blobIdx = 0; blobIdx < ItemsInfo.size(); ++blobIdx) { 
-            if (blobIdx) { 
-                blobIdsStr << ' '; 
-            } 
-            blobIdsStr << ItemsInfo[blobIdx].BlobId.ToString(); 
-        } 
+    TString BlobIdSequenceToString() const {
+        TStringBuilder blobIdsStr;
+        blobIdsStr << '[';
+        for (ui64 blobIdx = 0; blobIdx < ItemsInfo.size(); ++blobIdx) {
+            if (blobIdx) {
+                blobIdsStr << ' ';
+            }
+            blobIdsStr << ItemsInfo[blobIdx].BlobId.ToString();
+        }
         return blobIdsStr << ']';
-    } 
- 
+    }
+
     std::unique_ptr<IEventBase> RestartQuery(ui32 counter) {
         ++*Mon->NodeMon->RestartPut;
         auto ev = std::make_unique<TEvBlobStorage::TEvBunchOfEvents>();
@@ -448,13 +448,13 @@ public:
             ui64 cookie, NWilson::TTraceId traceId, bool timeStatsEnabled,
             TDiskResponsivenessTracker::TPerDiskStatsPtr stats,
             TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now,
-            TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-            bool enableRequestMod3x3ForMinLatecy) 
+            TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+            bool enableRequestMod3x3ForMinLatecy)
         : TBlobStorageGroupRequestActor(info, state, mon, source, cookie, std::move(traceId),
                 NKikimrServices::BS_PROXY_PUT, false, latencyQueueKind, now, storagePoolCounters,
                 ev->RestartCounter)
-        , PutImpl(info, state, ev, mon, enableRequestMod3x3ForMinLatecy) 
-        , WaitingVDiskResponseCount(info->GetTotalVDisksNum()) 
+        , PutImpl(info, state, ev, mon, enableRequestMod3x3ForMinLatecy)
+        , WaitingVDiskResponseCount(info->GetTotalVDisksNum())
         , Deadline(ev->Deadline)
         , StartTime(now)
         , HandleClass(ev->HandleClass)
@@ -464,15 +464,15 @@ public:
         , Stats(std::move(stats))
         , IsAccelerated(false)
         , IsAccelerateScheduled(false)
-        , IsMultiPutMode(false) 
+        , IsMultiPutMode(false)
     {
         if (ev->Orbit.HasShuttles()) {
             RootCauseTrack.IsOn = true;
         }
         ItemsInfo.emplace_back(ev->Id, ev->Buffer, source, cookie, NWilson::TTraceId(), std::move(ev->Orbit));
-        LWPROBE(DSProxyBlobPutTactics, ItemsInfo[0].BlobId.TabletID(), Info->GroupID, ItemsInfo[0].BlobId.ToString(), 
-                Tactic, NKikimrBlobStorage::EPutHandleClass_Name(HandleClass)); 
-        ReportBytes(ItemsInfo[0].Buffer.capacity() + sizeof(*this)); 
+        LWPROBE(DSProxyBlobPutTactics, ItemsInfo[0].BlobId.TabletID(), Info->GroupID, ItemsInfo[0].BlobId.ToString(),
+                Tactic, NKikimrBlobStorage::EPutHandleClass_Name(HandleClass));
+        ReportBytes(ItemsInfo[0].Buffer.capacity() + sizeof(*this));
 
         RequestBytes = ev->Buffer.size();
         RequestHandleClass = HandleClassToHandleClass(HandleClass);
@@ -487,59 +487,59 @@ public:
         return res;
     }
 
-    TBlobStorageGroupPutRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info, 
+    TBlobStorageGroupPutRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info,
             const TIntrusivePtr<TGroupQueues> &state,
-            const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &events, 
-            bool timeStatsEnabled, TDiskResponsivenessTracker::TPerDiskStatsPtr stats, 
-            TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now, 
-            TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-            NKikimrBlobStorage::EPutHandleClass handleClass, TEvBlobStorage::TEvPut::ETactic tactic, 
-            bool enableRequestMod3x3ForMinLatecy) 
+            const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &events,
+            bool timeStatsEnabled, TDiskResponsivenessTracker::TPerDiskStatsPtr stats,
+            TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now,
+            TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+            NKikimrBlobStorage::EPutHandleClass handleClass, TEvBlobStorage::TEvPut::ETactic tactic,
+            bool enableRequestMod3x3ForMinLatecy)
         : TBlobStorageGroupRequestActor(info, state, mon, TActorId(), 0, NWilson::TTraceId(),
                 NKikimrServices::BS_PROXY_PUT, false, latencyQueueKind, now, storagePoolCounters,
                 MaxRestartCounter(events))
-        , PutImpl(info, state, events, mon, handleClass, tactic, enableRequestMod3x3ForMinLatecy) 
-        , WaitingVDiskResponseCount(info->GetTotalVDisksNum()) 
-        , IsManyPuts(true) 
-        , Deadline(TInstant::Zero()) 
+        , PutImpl(info, state, events, mon, handleClass, tactic, enableRequestMod3x3ForMinLatecy)
+        , WaitingVDiskResponseCount(info->GetTotalVDisksNum())
+        , IsManyPuts(true)
+        , Deadline(TInstant::Zero())
         , StartTime(now)
-        , HandleClass(handleClass) 
-        , ReportedBytes(0) 
-        , TimeStatsEnabled(timeStatsEnabled) 
-        , Tactic(tactic) 
-        , Stats(std::move(stats)) 
-        , IsAccelerated(false) 
-        , IsAccelerateScheduled(false) 
-        , IsMultiPutMode(true) 
-    { 
-        Y_VERIFY_DEBUG(events.size() <= MaxBatchedPutRequests); 
-        for (auto &ev : events) { 
-            Deadline = Max(Deadline, ev->Get()->Deadline); 
+        , HandleClass(handleClass)
+        , ReportedBytes(0)
+        , TimeStatsEnabled(timeStatsEnabled)
+        , Tactic(tactic)
+        , Stats(std::move(stats))
+        , IsAccelerated(false)
+        , IsAccelerateScheduled(false)
+        , IsMultiPutMode(true)
+    {
+        Y_VERIFY_DEBUG(events.size() <= MaxBatchedPutRequests);
+        for (auto &ev : events) {
+            Deadline = Max(Deadline, ev->Get()->Deadline);
             if (ev->Get()->Orbit.HasShuttles()) {
                 RootCauseTrack.IsOn = true;
             }
             ItemsInfo.emplace_back(
-                ev->Get()->Id, 
-                ev->Get()->Buffer, 
-                ev->Sender, 
-                ev->Cookie, 
+                ev->Get()->Id,
+                ev->Get()->Buffer,
+                ev->Sender,
+                ev->Cookie,
                 std::move(ev->TraceId),
                 std::move(ev->Get()->Orbit)
             );
-            LWPROBE(DSProxyBlobPutTactics, ItemsInfo.back().BlobId.TabletID(), Info->GroupID, 
-                    ItemsInfo.back().BlobId.ToString(), Tactic, NKikimrBlobStorage::EPutHandleClass_Name(HandleClass)); 
-        } 
- 
-        RequestBytes = 0; 
-        for (auto &item: ItemsInfo) { 
-            ReportBytes(item.Buffer.capacity()); 
-            RequestBytes += item.BufferSize; 
-        } 
-        ReportBytes(sizeof(*this)); 
-        RequestHandleClass = HandleClassToHandleClass(HandleClass); 
+            LWPROBE(DSProxyBlobPutTactics, ItemsInfo.back().BlobId.TabletID(), Info->GroupID,
+                    ItemsInfo.back().BlobId.ToString(), Tactic, NKikimrBlobStorage::EPutHandleClass_Name(HandleClass));
+        }
+
+        RequestBytes = 0;
+        for (auto &item: ItemsInfo) {
+            ReportBytes(item.Buffer.capacity());
+            RequestBytes += item.BufferSize;
+        }
+        ReportBytes(sizeof(*this));
+        RequestHandleClass = HandleClassToHandleClass(HandleClass);
         MaxSaneRequests = info->Type.TotalPartCount() * (1ull + info->Type.Handoff()) * 2;
-    } 
- 
+    }
+
     void ReportBytes(i64 bytes) {
         *Mon->ActivePutCapacity += bytes;
         ReportedBytes += bytes;
@@ -549,8 +549,8 @@ public:
         A_LOG_INFO_S("BPP13", "bootstrap"
             << " ActorId# " << SelfId()
             << " Group# " << Info->GroupID
-            << " BlobCount# " << ItemsInfo.size() 
-            << " BlobIDs# " << BlobIdSequenceToString() 
+            << " BlobCount# " << ItemsInfo.size()
+            << " BlobIDs# " << BlobIdSequenceToString()
             << " HandleClass# " << NKikimrBlobStorage::EPutHandleClass_Name(HandleClass)
             << " Tactic# " << TEvBlobStorage::TEvPut::TacticName(Tactic)
             << " Deadline# " << Deadline
@@ -564,33 +564,33 @@ public:
 
         Timer.Reset();
 
-        // TODO: how correct rewrite this? 
+        // TODO: how correct rewrite this?
         WILSON_TRACE_FROM_ACTOR(*TlsActivationContext, *this, &TraceId, EvPutReceived, Size = RequestBytes,
-                LogoBlobId = ItemsInfo[0].BlobId); 
+                LogoBlobId = ItemsInfo[0].BlobId);
 
         double wilsonSec = Timer.PassedReset();
 
         const ui32 totalParts = Info->Type.TotalPartCount();
 
         TAutoPtr<TEvResume> resume(new TEvResume());
-        resume->PartSets.resize(ItemsInfo.size()); 
+        resume->PartSets.resize(ItemsInfo.size());
 
-        for (ui64 idx = 0; idx < ItemsInfo.size(); ++idx) { 
-            TLogoBlobID blobId = ItemsInfo[idx].BlobId; 
+        for (ui64 idx = 0; idx < ItemsInfo.size(); ++idx) {
+            TLogoBlobID blobId = ItemsInfo[idx].BlobId;
 
-            const ui64 partSize = Info->Type.PartSize(blobId); 
+            const ui64 partSize = Info->Type.PartSize(blobId);
             ui64 bufferSize = ItemsInfo[idx].BufferSize;
- 
-            char *data = ItemsInfo[idx].Buffer.Detach(); 
-            Encrypt(data, data, 0, bufferSize, blobId, *Info); 
-            TDataPartSet &partSet = resume->PartSets[idx]; 
- 
-            partSet.Parts.resize(totalParts); 
-            if (Info->Type.ErasureFamily() != TErasureType::ErasureMirror) { 
-                for (ui32 i = 0; i < totalParts; ++i) { 
-                    partSet.Parts[i].UninitializedOwnedWhole(partSize); 
- 
-                } 
+
+            char *data = ItemsInfo[idx].Buffer.Detach();
+            Encrypt(data, data, 0, bufferSize, blobId, *Info);
+            TDataPartSet &partSet = resume->PartSets[idx];
+
+            partSet.Parts.resize(totalParts);
+            if (Info->Type.ErasureFamily() != TErasureType::ErasureMirror) {
+                for (ui32 i = 0; i < totalParts; ++i) {
+                    partSet.Parts[i].UninitializedOwnedWhole(partSize);
+
+                }
             }
         }
         double allocateSec = Timer.PassedReset();
@@ -629,7 +629,7 @@ public:
         A_LOG_WARN_S("BPP14", "Wakeup "
             << " ActorId# " << SelfId()
             << " Group# " << Info->GroupID
-            << " BlobIDs# " << BlobIdSequenceToString() 
+            << " BlobIDs# " << BlobIdSequenceToString()
             << " Not answered in "
             << (TActivationContext::Now() - StartTime).Seconds() << " seconds");
         if (TInstant::Now() > Deadline) {
@@ -640,41 +640,41 @@ public:
         Schedule(TDuration::MilliSeconds(DsPutWakeupMs), new TKikimrEvents::TEvWakeup);
     }
 
-    template <typename TPutEvent, typename TCookie> 
+    template <typename TPutEvent, typename TCookie>
     void UpdatePengingVDiskResponseCount(const TDeque<std::unique_ptr<TPutEvent>> &putEvents) {
-        for (auto &event : putEvents) { 
-            Y_VERIFY(event->Record.HasCookie()); 
-            TCookie cookie(event->Record.GetCookie()); 
+        for (auto &event : putEvents) {
+            Y_VERIFY(event->Record.HasCookie());
+            TCookie cookie(event->Record.GetCookie());
             if (RootCauseTrack.IsOn) {
                 cookie.SetCauseIdx(RootCauseTrack.RegisterCause());
                 event->Record.SetCookie(cookie);
             }
-            ui64 vdisk = cookie.GetVDiskOrderNumber(); 
-            Y_VERIFY(vdisk < WaitingVDiskResponseCount.size()); 
-            if (!WaitingVDiskResponseCount[vdisk]) { 
-                WaitingVDiskCount++; 
-            } 
-            WaitingVDiskResponseCount[vdisk]++; 
-        } 
-    } 
- 
+            ui64 vdisk = cookie.GetVDiskOrderNumber();
+            Y_VERIFY(vdisk < WaitingVDiskResponseCount.size());
+            if (!WaitingVDiskResponseCount[vdisk]) {
+                WaitingVDiskCount++;
+            }
+            WaitingVDiskResponseCount[vdisk]++;
+        }
+    }
+
     void ResumeBootstrap(TAutoPtr<TEvResume> resume) {
         double waitSec = Timer.PassedReset();
         resume->WaitSec += waitSec;
 
         Y_VERIFY(ItemsInfo.size() == resume->PartSets.size());
         bool splitDone = true;
-        for (ui64 idx = 0; idx < ItemsInfo.size(); ++idx) { 
+        for (ui64 idx = 0; idx < ItemsInfo.size(); ++idx) {
             TDataPartSet &partSet = resume->PartSets[idx];
-            TString &buffer = ItemsInfo[idx].Buffer; 
-            TLogoBlobID blobId = ItemsInfo[idx].BlobId; 
+            TString &buffer = ItemsInfo[idx].Buffer;
+            TLogoBlobID blobId = ItemsInfo[idx].BlobId;
             Info->Type.IncrementalSplitData((TErasureType::ECrcMode)blobId.CrcMode(), buffer, partSet);
             if (partSet.IsSplitDone()) {
                 ReportBytes(partSet.MemoryConsumed - ItemsInfo[idx].BufferSize);
             } else {
                 splitDone = false;
             }
-        } 
+        }
         double splitSec = Timer.PassedReset();
         resume->SplitSec += splitSec;
         resume->Count++;
@@ -701,9 +701,9 @@ public:
                 CountPuts(vPuts);
                 SendToQueues(vPuts, TimeStatsEnabled);
             }
-        } else { 
+        } else {
             Send(SelfId(), resume.Release());
-        } 
+        }
     }
 
     STATEFN(StateWait) {
@@ -726,24 +726,24 @@ IActor* CreateBlobStorageGroupPutRequest(const TIntrusivePtr<TBlobStorageGroupIn
         ui64 cookie, NWilson::TTraceId traceId, bool timeStatsEnabled,
         TDiskResponsivenessTracker::TPerDiskStatsPtr stats,
         TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now,
-        TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-        bool enableRequestMod3x3ForMinLatecy) { 
+        TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+        bool enableRequestMod3x3ForMinLatecy) {
     return new TBlobStorageGroupPutRequest(info, state, source, mon, ev, cookie, std::move(traceId), timeStatsEnabled,
-            std::move(stats), latencyQueueKind, now, storagePoolCounters, enableRequestMod3x3ForMinLatecy); 
+            std::move(stats), latencyQueueKind, now, storagePoolCounters, enableRequestMod3x3ForMinLatecy);
 }
 
-IActor* CreateBlobStorageGroupPutRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info, 
+IActor* CreateBlobStorageGroupPutRequest(const TIntrusivePtr<TBlobStorageGroupInfo> &info,
         const TIntrusivePtr<TGroupQueues> &state,
-        const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &ev, 
-        bool timeStatsEnabled, 
-        TDiskResponsivenessTracker::TPerDiskStatsPtr stats, 
-        TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now, 
-        TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters, 
-        NKikimrBlobStorage::EPutHandleClass handleClass, TEvBlobStorage::TEvPut::ETactic tactic, 
-        bool enableRequestMod3x3ForMinLatecy) { 
-    return new TBlobStorageGroupPutRequest(info, state, mon, ev, timeStatsEnabled, 
-            std::move(stats), latencyQueueKind, now, storagePoolCounters, handleClass, tactic, 
-            enableRequestMod3x3ForMinLatecy); 
-} 
- 
+        const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &ev,
+        bool timeStatsEnabled,
+        TDiskResponsivenessTracker::TPerDiskStatsPtr stats,
+        TMaybe<TGroupStat::EKind> latencyQueueKind, TInstant now,
+        TIntrusivePtr<TStoragePoolCounters> &storagePoolCounters,
+        NKikimrBlobStorage::EPutHandleClass handleClass, TEvBlobStorage::TEvPut::ETactic tactic,
+        bool enableRequestMod3x3ForMinLatecy) {
+    return new TBlobStorageGroupPutRequest(info, state, mon, ev, timeStatsEnabled,
+            std::move(stats), latencyQueueKind, now, storagePoolCounters, handleClass, tactic,
+            enableRequestMod3x3ForMinLatecy);
+}
+
 }//NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_put_impl.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_put_impl.cpp
index cd3c55e561..70b774636c 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_put_impl.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_put_impl.cpp
@@ -9,12 +9,12 @@ LWTRACE_USING(BLOBSTORAGE_PROVIDER);
 
 namespace NKikimr {
 
-using TPutResultVec = TPutImpl::TPutResultVec; 
+using TPutResultVec = TPutImpl::TPutResultVec;
 
-bool TPutImpl::RunStrategies(TLogContext &logCtx, TPutResultVec &outPutResults) { 
+bool TPutImpl::RunStrategies(TLogContext &logCtx, TPutResultVec &outPutResults) {
     switch (Info->Type.GetErasure()) {
         case TBlobStorageGroupType::ErasureMirror3dc:
-            return RunStrategy(logCtx, TPut3dcStrategy(Tactic, EnableRequestMod3x3ForMinLatecy), outPutResults); 
+            return RunStrategy(logCtx, TPut3dcStrategy(Tactic, EnableRequestMod3x3ForMinLatecy), outPutResults);
         case TBlobStorageGroupType::ErasureMirror3of4:
             return RunStrategy(logCtx, TPut3of4Strategy(Tactic), outPutResults);
         default:
@@ -32,90 +32,90 @@ bool TPutImpl::RunStrategy(TLogContext &logCtx, const IStrategy& strategy, TPutR
     return false;
 }
 
-NLog::EPriority GetPriorityForReply(TAtomicLogPriorityMuteChecker<NLog::PRI_ERROR, NLog::PRI_DEBUG> &checker, 
-        NKikimrProto::EReplyStatus status) { 
-    NLog::EPriority priority = PriorityForStatusOutbound(status); 
-    if (priority == NLog::PRI_ERROR) { 
-        return checker.Register(TActivationContext::Now(), TDuration::Seconds(5)); 
-    } else { 
-        checker.Unmute(); 
-        return priority; 
-    } 
-} 
- 
-void TPutImpl::PrepareOneReply(NKikimrProto::EReplyStatus status, TLogoBlobID blobId, ui64 blobIdx, TLogContext &logCtx, 
-        TString errorReason, TPutResultVec &outPutResults) { 
-    Y_VERIFY(IsInitialized); 
-    if (!IsDone[blobIdx]) { 
-        outPutResults.emplace_back(blobIdx, new TEvBlobStorage::TEvPutResult(status, blobId, StatusFlags, Info->GroupID, 
-                    ApproximateFreeSpaceShare)); 
-        outPutResults.back().second->ErrorReason = errorReason; 
-        NLog::EPriority priority = GetPriorityForReply(Info->PutErrorMuteChecker, status); 
-        A_LOG_LOG_SX(logCtx, true, priority, "BPP12", "Result# " << outPutResults.back().second->Print(false)); 
-        MarkBlobAsSent(blobIdx); 
-    } 
-} 
- 
+NLog::EPriority GetPriorityForReply(TAtomicLogPriorityMuteChecker<NLog::PRI_ERROR, NLog::PRI_DEBUG> &checker,
+        NKikimrProto::EReplyStatus status) {
+    NLog::EPriority priority = PriorityForStatusOutbound(status);
+    if (priority == NLog::PRI_ERROR) {
+        return checker.Register(TActivationContext::Now(), TDuration::Seconds(5));
+    } else {
+        checker.Unmute();
+        return priority;
+    }
+}
+
+void TPutImpl::PrepareOneReply(NKikimrProto::EReplyStatus status, TLogoBlobID blobId, ui64 blobIdx, TLogContext &logCtx,
+        TString errorReason, TPutResultVec &outPutResults) {
+    Y_VERIFY(IsInitialized);
+    if (!IsDone[blobIdx]) {
+        outPutResults.emplace_back(blobIdx, new TEvBlobStorage::TEvPutResult(status, blobId, StatusFlags, Info->GroupID,
+                    ApproximateFreeSpaceShare));
+        outPutResults.back().second->ErrorReason = errorReason;
+        NLog::EPriority priority = GetPriorityForReply(Info->PutErrorMuteChecker, status);
+        A_LOG_LOG_SX(logCtx, true, priority, "BPP12", "Result# " << outPutResults.back().second->Print(false));
+        MarkBlobAsSent(blobIdx);
+    }
+}
+
 void TPutImpl::PrepareReply(NKikimrProto::EReplyStatus status, TLogContext &logCtx, TString errorReason,
-        TPutResultVec &outPutResults) { 
-    A_LOG_DEBUG_SX(logCtx, "BPP34", "PrepareReply status# " << status << " errorReason# " << errorReason); 
-    for (ui64 idx = 0; idx < BlobIds.size(); ++idx) { 
-        if (IsDone[idx]) { 
-            A_LOG_DEBUG_SX(logCtx, "BPP35", "blob# " << BlobIds[idx].ToString() << 
-                " idx# " << idx << " is sent, skipped"); 
-            continue; 
-        } 
-
-        outPutResults.emplace_back(idx, new TEvBlobStorage::TEvPutResult(status, BlobIds[idx], StatusFlags, Info->GroupID, 
-                    ApproximateFreeSpaceShare)); 
-        outPutResults.back().second->ErrorReason = errorReason; 
-
-        NLog::EPriority priority = GetPriorityForReply(Info->PutErrorMuteChecker, status); 
-        A_LOG_LOG_SX(logCtx, true, priority, "BPP38", 
-                "PrepareReply Result# " << outPutResults.back().second->Print(false)); 
- 
-        if (IsInitialized) { 
-            MarkBlobAsSent(idx); 
-        } 
-    } 
+        TPutResultVec &outPutResults) {
+    A_LOG_DEBUG_SX(logCtx, "BPP34", "PrepareReply status# " << status << " errorReason# " << errorReason);
+    for (ui64 idx = 0; idx < BlobIds.size(); ++idx) {
+        if (IsDone[idx]) {
+            A_LOG_DEBUG_SX(logCtx, "BPP35", "blob# " << BlobIds[idx].ToString() <<
+                " idx# " << idx << " is sent, skipped");
+            continue;
+        }
+
+        outPutResults.emplace_back(idx, new TEvBlobStorage::TEvPutResult(status, BlobIds[idx], StatusFlags, Info->GroupID,
+                    ApproximateFreeSpaceShare));
+        outPutResults.back().second->ErrorReason = errorReason;
+
+        NLog::EPriority priority = GetPriorityForReply(Info->PutErrorMuteChecker, status);
+        A_LOG_LOG_SX(logCtx, true, priority, "BPP38",
+                "PrepareReply Result# " << outPutResults.back().second->Print(false));
+
+        if (IsInitialized) {
+            MarkBlobAsSent(idx);
+        }
+    }
 }
 
-void TPutImpl::PrepareReply(TLogContext &logCtx, TString errorReason, 
+void TPutImpl::PrepareReply(TLogContext &logCtx, TString errorReason,
         TBatchedVec<TBlackboard::TBlobStates::value_type*>& finished, TPutResultVec &outPutResults) {
-    A_LOG_DEBUG_SX(logCtx, "BPP36", "PrepareReply errorReason# " << errorReason); 
-    Y_VERIFY(IsInitialized); 
+    A_LOG_DEBUG_SX(logCtx, "BPP36", "PrepareReply errorReason# " << errorReason);
+    Y_VERIFY(IsInitialized);
     for (auto item : finished) {
         auto &[blobId, state] = *item;
         const ui64 idx = state.BlobIdx;
-        Y_VERIFY(blobId == BlobIds[idx], "BlobIdx# %" PRIu64 " BlobState# %s Blackboard# %s", 
-            idx, state.ToString().c_str(), Blackboard.ToString().c_str()); 
-        Y_VERIFY(!IsDone[idx]); 
+        Y_VERIFY(blobId == BlobIds[idx], "BlobIdx# %" PRIu64 " BlobState# %s Blackboard# %s",
+            idx, state.ToString().c_str(), Blackboard.ToString().c_str());
+        Y_VERIFY(!IsDone[idx]);
         Y_VERIFY(state.Status != NKikimrProto::UNKNOWN);
-        outPutResults.emplace_back(idx, new TEvBlobStorage::TEvPutResult(state.Status, blobId, StatusFlags, 
-            Info->GroupID, ApproximateFreeSpaceShare)); 
-        outPutResults.back().second->ErrorReason = errorReason; 
- 
-        NLog::EPriority priority = GetPriorityForReply(Info->PutErrorMuteChecker, state.Status); 
-        A_LOG_LOG_SX(logCtx, true, priority, "BPP37", 
-                "PrepareReply Result# " << outPutResults.back().second->Print(false)); 
+        outPutResults.emplace_back(idx, new TEvBlobStorage::TEvPutResult(state.Status, blobId, StatusFlags,
+            Info->GroupID, ApproximateFreeSpaceShare));
+        outPutResults.back().second->ErrorReason = errorReason;
+
+        NLog::EPriority priority = GetPriorityForReply(Info->PutErrorMuteChecker, state.Status);
+        A_LOG_LOG_SX(logCtx, true, priority, "BPP37",
+                "PrepareReply Result# " << outPutResults.back().second->Print(false));
         MarkBlobAsSent(idx);
-    } 
-} 
- 
+    }
+}
+
 ui64 TPutImpl::GetTimeToAccelerateNs(TLogContext &logCtx) {
     Y_UNUSED(logCtx);
-    Y_VERIFY(!Blackboard.BlobStates.empty()); 
-    TBatchedVec<ui64> nextToWorstPredictedNsVec(Blackboard.BlobStates.size()); 
-    ui64 idx = 0; 
-    for (auto &[_, state] : Blackboard.BlobStates) { 
-        // Find the slowest disk 
-        i32 worstSubgroupIdx = -1; 
-        ui64 worstPredictedNs = 0; 
+    Y_VERIFY(!Blackboard.BlobStates.empty());
+    TBatchedVec<ui64> nextToWorstPredictedNsVec(Blackboard.BlobStates.size());
+    ui64 idx = 0;
+    for (auto &[_, state] : Blackboard.BlobStates) {
+        // Find the slowest disk
+        i32 worstSubgroupIdx = -1;
+        ui64 worstPredictedNs = 0;
         state.GetWorstPredictedDelaysNs(*Info, *Blackboard.GroupQueues, HandleClassToQueueId(Blackboard.PutHandleClass),
-                &worstPredictedNs, &nextToWorstPredictedNsVec[idx], &worstSubgroupIdx); 
-        idx++; 
+                &worstPredictedNs, &nextToWorstPredictedNsVec[idx], &worstSubgroupIdx);
+        idx++;
     }
-    return *MaxElement(nextToWorstPredictedNsVec.begin(), nextToWorstPredictedNsVec.end()); 
+    return *MaxElement(nextToWorstPredictedNsVec.begin(), nextToWorstPredictedNsVec.end());
 }
 
 TString TPutImpl::DumpFullState() const {
@@ -126,33 +126,33 @@ TString TPutImpl::DumpFullState() const {
     str << Endl;
     str << " Blackboard# " << Blackboard.ToString();
     str << Endl;
-    str << " BlobIds# " << BlobIds.ToString(); 
+    str << " BlobIds# " << BlobIds.ToString();
+    str << Endl;
+    str << "IsDone# " << IsDone.ToString();
     str << Endl;
-    str << "IsDone# " << IsDone.ToString(); 
-    str << Endl; 
     str << " HandoffPartsSent# " << HandoffPartsSent;
     str << Endl;
     str << " VPutRequests# " << VPutRequests;
     str << Endl;
     str << " VPutResponses# " << VPutResponses;
     str << Endl;
-    str << " VMultiPutRequests# " << VMultiPutRequests; 
-    str << Endl; 
-    str << " VMultiPutResponses# " << VMultiPutResponses; 
-    str << Endl; 
+    str << " VMultiPutRequests# " << VMultiPutRequests;
+    str << Endl;
+    str << " VMultiPutResponses# " << VMultiPutResponses;
+    str << Endl;
     str << " Tactic# " << TEvBlobStorage::TEvPut::TacticName(Tactic);
     str << Endl;
     str << "}";
     return str.Str();
 }
 
-bool TPutImpl::MarkBlobAsSent(ui64 idx) { 
-    Y_VERIFY(idx < BlobIds.size()); 
-    Y_VERIFY(!IsDone[idx]); 
-    Blackboard.MoveBlobStateToDone(BlobIds[idx]); 
-    IsDone[idx] = true; 
-    DoneBlobs++; 
-    return true; 
-} 
- 
+bool TPutImpl::MarkBlobAsSent(ui64 idx) {
+    Y_VERIFY(idx < BlobIds.size());
+    Y_VERIFY(!IsDone[idx]);
+    Blackboard.MoveBlobStateToDone(BlobIds[idx]);
+    IsDone[idx] = true;
+    DoneBlobs++;
+    return true;
+}
+
 }//NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_put_impl.h b/ydb/core/blobstorage/dsproxy/dsproxy_put_impl.h
index a922d1b91b..34f675032b 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_put_impl.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_put_impl.h
@@ -4,10 +4,10 @@
 #include "dsproxy_blackboard.h"
 #include "dsproxy_cookies.h"
 #include "dsproxy_mon.h"
-#include "dsproxy_strategy_accelerate_put.h" 
-#include "dsproxy_strategy_accelerate_put_m3dc.h" 
-#include "dsproxy_strategy_restore.h" 
-#include "dsproxy_strategy_put_m3dc.h" 
+#include "dsproxy_strategy_accelerate_put.h"
+#include "dsproxy_strategy_accelerate_put_m3dc.h"
+#include "dsproxy_strategy_restore.h"
+#include "dsproxy_strategy_put_m3dc.h"
 #include "dsproxy_strategy_put_m3of4.h"
 #include <ydb/core/blobstorage/vdisk/common/vdisk_events.h>
 #include <ydb/core/blobstorage/base/wilson_events.h>
@@ -18,86 +18,86 @@ namespace NKikimr {
 class TStrategyBase;
 
 class TPutImpl {
-public: 
+public:
     using TPutResultVec = TBatchedVec<std::pair<ui64, std::unique_ptr<TEvBlobStorage::TEvPutResult>>>;
- 
-private: 
+
+private:
     TBlobStorageGroupInfo::TServiceIds VDisksSvc;
     TBlobStorageGroupInfo::TVDiskIds VDisksId;
 
-    TInstant Deadline; 
+    TInstant Deadline;
     const TIntrusivePtr<TBlobStorageGroupInfo> Info;
 
     TBlackboard Blackboard;
-    TBatchedVec<bool> IsDone; 
+    TBatchedVec<bool> IsDone;
     TStorageStatusFlags StatusFlags;
     float ApproximateFreeSpaceShare;
     TIntrusivePtr<TBlobStorageGroupProxyMon> Mon;
     ui32 HandoffPartsSent = 0;
     ui32 VPutRequests = 0;
     ui32 VPutResponses = 0;
-    ui32 VMultiPutRequests = 0; 
-    ui32 VMultiPutResponses = 0; 
+    ui32 VMultiPutRequests = 0;
+    ui32 VMultiPutResponses = 0;
     bool AtLeastOneResponseWasNotOk = false;
-    bool EnableRequestMod3x3ForMinLatecy = false; 
+    bool EnableRequestMod3x3ForMinLatecy = false;
+
+    ui64 DoneBlobs = 0;
 
-    ui64 DoneBlobs = 0; 
- 
     const TEvBlobStorage::TEvPut::ETactic Tactic;
 
-    TBatchedVec<TLogoBlobID> BlobIds; 
- 
-    TStackVec<bool, MaxBatchedPutRequests * TypicalDisksInSubring> ReceivedVPutResponses; 
-    TStackVec<bool, MaxBatchedPutRequests * TypicalDisksInSubring> ReceivedVMultiPutResponses; 
- 
-    bool IsInitialized = false; 
- 
-    TString ErrorDescription; 
- 
+    TBatchedVec<TLogoBlobID> BlobIds;
+
+    TStackVec<bool, MaxBatchedPutRequests * TypicalDisksInSubring> ReceivedVPutResponses;
+    TStackVec<bool, MaxBatchedPutRequests * TypicalDisksInSubring> ReceivedVMultiPutResponses;
+
+    bool IsInitialized = false;
+
+    TString ErrorDescription;
+
 public:
     TPutImpl(const TIntrusivePtr<TBlobStorageGroupInfo> &info, const TIntrusivePtr<TGroupQueues> &state,
-            TEvBlobStorage::TEvPut *ev, const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, 
-            bool enableRequestMod3x3ForMinLatecy) 
+            TEvBlobStorage::TEvPut *ev, const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon,
+            bool enableRequestMod3x3ForMinLatecy)
         : Deadline(ev->Deadline)
         , Info(info)
-        , Blackboard(info, state, ev->HandleClass, NKikimrBlobStorage::EGetHandleClass::AsyncRead, false) 
-        , IsDone(1) 
+        , Blackboard(info, state, ev->HandleClass, NKikimrBlobStorage::EGetHandleClass::AsyncRead, false)
+        , IsDone(1)
         , StatusFlags(0)
         , ApproximateFreeSpaceShare(0.f)
         , Mon(mon)
-        , EnableRequestMod3x3ForMinLatecy(enableRequestMod3x3ForMinLatecy) 
+        , EnableRequestMod3x3ForMinLatecy(enableRequestMod3x3ForMinLatecy)
         , Tactic(ev->Tactic)
-        , BlobIds({ev->Id}) 
+        , BlobIds({ev->Id})
     {
-        Y_VERIFY(BlobIds.size()); 
-        Y_VERIFY(BlobIds.size() <= MaxBatchedPutRequests); 
+        Y_VERIFY(BlobIds.size());
+        Y_VERIFY(BlobIds.size() <= MaxBatchedPutRequests);
     }
 
     TPutImpl(const TIntrusivePtr<TBlobStorageGroupInfo> &info, const TIntrusivePtr<TGroupQueues> &state,
-            TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &events, const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon, 
-            NKikimrBlobStorage::EPutHandleClass putHandleClass, TEvBlobStorage::TEvPut::ETactic tactic, 
-            bool enableRequestMod3x3ForMinLatecy) 
-        : Deadline(TInstant::Zero()) 
-        , Info(info) 
-        , Blackboard(info, state, putHandleClass, NKikimrBlobStorage::EGetHandleClass::AsyncRead, false) 
-        , IsDone(events.size()) 
-        , StatusFlags(0) 
-        , ApproximateFreeSpaceShare(0.f) 
-        , Mon(mon) 
-        , EnableRequestMod3x3ForMinLatecy(enableRequestMod3x3ForMinLatecy) 
-        , Tactic(tactic) 
-    { 
-        Y_VERIFY(events.size(), "TEvPut vector is empty"); 
-        for (auto &ev : events) { 
-            Y_VERIFY(ev->Get()->HandleClass == putHandleClass); 
-            Y_VERIFY(ev->Get()->Tactic == tactic); 
-            BlobIds.push_back(ev->Get()->Id); 
-            Deadline = Max(Deadline, ev->Get()->Deadline); 
-        } 
-        Y_VERIFY(BlobIds.size()); 
-        Y_VERIFY(BlobIds.size() <= MaxBatchedPutRequests); 
-    } 
- 
+            TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &events, const TIntrusivePtr<TBlobStorageGroupProxyMon> &mon,
+            NKikimrBlobStorage::EPutHandleClass putHandleClass, TEvBlobStorage::TEvPut::ETactic tactic,
+            bool enableRequestMod3x3ForMinLatecy)
+        : Deadline(TInstant::Zero())
+        , Info(info)
+        , Blackboard(info, state, putHandleClass, NKikimrBlobStorage::EGetHandleClass::AsyncRead, false)
+        , IsDone(events.size())
+        , StatusFlags(0)
+        , ApproximateFreeSpaceShare(0.f)
+        , Mon(mon)
+        , EnableRequestMod3x3ForMinLatecy(enableRequestMod3x3ForMinLatecy)
+        , Tactic(tactic)
+    {
+        Y_VERIFY(events.size(), "TEvPut vector is empty");
+        for (auto &ev : events) {
+            Y_VERIFY(ev->Get()->HandleClass == putHandleClass);
+            Y_VERIFY(ev->Get()->Tactic == tactic);
+            BlobIds.push_back(ev->Get()->Id);
+            Deadline = Max(Deadline, ev->Get()->Deadline);
+        }
+        Y_VERIFY(BlobIds.size());
+        Y_VERIFY(BlobIds.size() <= MaxBatchedPutRequests);
+    }
+
     NKikimrBlobStorage::EPutHandleClass GetPutHandleClass() const {
         return Blackboard.PutHandleClass;
     }
@@ -106,247 +106,247 @@ public:
         return HandoffPartsSent;
     }
 
-    template <typename TVPutEvent> 
-    void GenerateInitialRequests(TLogContext &logCtx, TBatchedVec<TDataPartSet> &partSets, 
+    template <typename TVPutEvent>
+    void GenerateInitialRequests(TLogContext &logCtx, TBatchedVec<TDataPartSet> &partSets,
             TDeque<std::unique_ptr<TVPutEvent>> &outVPuts) {
-        Y_UNUSED(logCtx); 
-        Y_VERIFY_S(partSets.size() == BlobIds.size(), "partSets.size# " << partSets.size() 
-                << " BlobIds.size# " << BlobIds.size()); 
-        const ui32 totalParts = Info->Type.TotalPartCount(); 
-        for (ui64 blobIdx = 0; blobIdx < BlobIds.size(); ++blobIdx) { 
-            TLogoBlobID &blobId = BlobIds[blobIdx]; 
-            for (ui32 i = 0; i < totalParts; ++i) { 
-                REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(partSets[blobIdx].Parts[i].OwnedString.Data(), 
-                        partSets[blobIdx].Parts[i].OwnedString.Size()); 
-                Blackboard.AddPartToPut(blobId, i, partSets[blobIdx].Parts[i].OwnedString); 
-            } 
-            Blackboard.MarkBlobReadyToPut(blobId, blobIdx); 
-        } 
- 
-        TPutResultVec putResults; 
-        bool workDone = Step(logCtx, outVPuts, putResults); 
-        IsInitialized = true; 
-        Y_VERIFY(!outVPuts.empty()); 
-        Y_VERIFY(putResults.empty()); 
-        Y_VERIFY(workDone); 
-    } 
- 
-    template <typename TEvent> 
-    bool MarkRequest(const TEvent &event, ui32 orderNumber) { 
-        constexpr bool isVPut = std::is_same_v<TEvent, TEvBlobStorage::TEvVPutResult>; 
-        constexpr bool isVMultiPut = std::is_same_v<TEvent, TEvBlobStorage::TEvVMultiPutResult>; 
+        Y_UNUSED(logCtx);
+        Y_VERIFY_S(partSets.size() == BlobIds.size(), "partSets.size# " << partSets.size()
+                << " BlobIds.size# " << BlobIds.size());
+        const ui32 totalParts = Info->Type.TotalPartCount();
+        for (ui64 blobIdx = 0; blobIdx < BlobIds.size(); ++blobIdx) {
+            TLogoBlobID &blobId = BlobIds[blobIdx];
+            for (ui32 i = 0; i < totalParts; ++i) {
+                REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(partSets[blobIdx].Parts[i].OwnedString.Data(),
+                        partSets[blobIdx].Parts[i].OwnedString.Size());
+                Blackboard.AddPartToPut(blobId, i, partSets[blobIdx].Parts[i].OwnedString);
+            }
+            Blackboard.MarkBlobReadyToPut(blobId, blobIdx);
+        }
+
+        TPutResultVec putResults;
+        bool workDone = Step(logCtx, outVPuts, putResults);
+        IsInitialized = true;
+        Y_VERIFY(!outVPuts.empty());
+        Y_VERIFY(putResults.empty());
+        Y_VERIFY(workDone);
+    }
+
+    template <typename TEvent>
+    bool MarkRequest(const TEvent &event, ui32 orderNumber) {
+        constexpr bool isVPut = std::is_same_v<TEvent, TEvBlobStorage::TEvVPutResult>;
+        constexpr bool isVMultiPut = std::is_same_v<TEvent, TEvBlobStorage::TEvVMultiPutResult>;
         static_assert(isVPut || isVMultiPut);
 
-        using TCookie = std::conditional_t<isVPut, TBlobCookie, TVMultiPutCookie>; 
- 
-        auto responses = isVPut ? ReceivedVPutResponses : ReceivedVMultiPutResponses; 
+        using TCookie = std::conditional_t<isVPut, TBlobCookie, TVMultiPutCookie>;
+
+        auto responses = isVPut ? ReceivedVPutResponses : ReceivedVMultiPutResponses;
         auto putType = std::is_same_v<TCookie, TBlobCookie> ? "TEvVPut" : "TEvVMultiPut";
- 
-        const auto &record = event.Record; 
-        if (!record.HasCookie()) { 
-            ErrorDescription = TStringBuilder() << putType << " doesn't have cookie"; 
-            return true; 
-        } 
-        TCookie cookie(record.GetCookie()); 
-        if (cookie.GetVDiskOrderNumber() != orderNumber) { 
-            ErrorDescription = TStringBuilder() << putType << " has wrong cookie; unexpected orderNumber;" 
-                    << " expected# " << orderNumber 
-                    << " received# " << cookie.GetVDiskOrderNumber() 
-                    << " cookie# " << ui64(cookie); 
-            return true; 
-        } 
-
-        ui64 requestIdx = cookie.GetRequestIdx(); 
-        if (responses[requestIdx]) { 
-            ErrorDescription =  TStringBuilder() << putType << "is recieved twice" 
-                    << " Event# " << event.ToString() 
-                    << " State# " << DumpFullState(); 
-            return true; 
-        } 
-        responses[requestIdx] = true; 
-        return false; 
-    } 
- 
-    void PackToStringImpl(TStringBuilder &) { 
-    } 
- 
-    template <typename TArg, typename... TArgs> 
-    void PackToStringImpl(TStringBuilder &builder, TArg arg, TArgs... args) { 
-        builder << arg; 
-        PackToStringImpl(builder, args...); 
-    } 
- 
-    template <typename... TArgs> 
-    TString PackToString(TArgs... args) { 
-        TStringBuilder builder; 
-        PackToStringImpl(builder, args...); 
-        return builder; 
-    } 
- 
-    template <typename TPutRecord, typename ...TArgs> 
-    bool ProcessOneVPutResult(TLogContext &logCtx, const TPutRecord &record, TVDiskID vDiskId, ui32 orderNumber, 
-            TArgs ...resultTypeArgs) 
-    { 
-        Y_VERIFY(record.HasStatus()); 
-        Y_VERIFY(record.HasBlobID()); 
-        Y_VERIFY(record.HasCookie()); 
-        NKikimrProto::EReplyStatus status = record.GetStatus(); 
-        TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID()); 
-        ui32 diskIdx = Info->GetTopology().GetIdxInSubgroup(vDiskId, blobId.Hash()); 
- 
-        TBlobCookie cookie(record.GetCookie()); 
-        if (cookie.GetPartId() != blobId.PartId()) { 
-            ErrorDescription = TStringBuilder() 
-                    << PackToString(resultTypeArgs...) << " has wrong cookie; unexpected PartId;" 
-                    << " expected# " << blobId.PartId() 
-                    << " received# " << cookie.GetPartId() 
-                    << " cookie# " << ui64(cookie); 
-            return true; 
-        } 
-        if (cookie.GetVDiskOrderNumber() != orderNumber) { 
-            ErrorDescription = TStringBuilder() 
-                    << PackToString(resultTypeArgs...) << " has wrong cookie; unexpected orderNumber;" 
-                    << " expected# " << orderNumber 
-                    << " received# " << cookie.GetVDiskOrderNumber() 
-                    << " cookie# " << ui64(cookie); 
-            return true; 
-        } 
- 
-        ui64 blobIdx = cookie.GetBlobIdx(); 
-        ui32 partIdx = blobId.PartId() - 1; 
- 
-        A_LOG_LOG_SX(logCtx, false, PriorityForStatusInbound(status), "BPP11", 
-            "Got " << PackToString(resultTypeArgs...) 
-            << " part# " << partIdx 
-            << " diskIdx# " << diskIdx 
-            << " vDiskId# " << vDiskId 
-            << " blob# " << blobId 
-            << " status# " << status); 
- 
-        if (IsDone.size() <= blobIdx) { 
-            ErrorDescription = TStringBuilder() 
-                    << PackToString(resultTypeArgs...) << " has wrong cookie; unexpected blobIdx;" 
-                    << " received# " << cookie.GetVDiskOrderNumber() 
-                    << " blobCount# " << IsDone.size() 
-                    << " cookie# " << ui64(cookie); 
-            return true; 
-        } 
-
-        if (IsDone[blobIdx]) { 
-            return false; 
-        } 
-        switch (status) { 
-            case NKikimrProto::ERROR: 
-            case NKikimrProto::VDISK_ERROR_STATE: 
-            case NKikimrProto::OUT_OF_SPACE: 
-                Blackboard.AddErrorResponse(blobId, orderNumber); 
-                AtLeastOneResponseWasNotOk = true; 
-                break; 
-            case NKikimrProto::OK: 
-            case NKikimrProto::ALREADY: 
-                Blackboard.AddPutOkResponse(blobId, orderNumber); 
-                break; 
-            default: 
-                ErrorDescription = TStringBuilder() << "Unexpected status# " << status; 
-                return true; 
-        } 
-        return false; 
-    } 
- 
-    template <typename TVPutEvent, typename TVPutEventResult> 
+
+        const auto &record = event.Record;
+        if (!record.HasCookie()) {
+            ErrorDescription = TStringBuilder() << putType << " doesn't have cookie";
+            return true;
+        }
+        TCookie cookie(record.GetCookie());
+        if (cookie.GetVDiskOrderNumber() != orderNumber) {
+            ErrorDescription = TStringBuilder() << putType << " has wrong cookie; unexpected orderNumber;"
+                    << " expected# " << orderNumber
+                    << " received# " << cookie.GetVDiskOrderNumber()
+                    << " cookie# " << ui64(cookie);
+            return true;
+        }
+
+        ui64 requestIdx = cookie.GetRequestIdx();
+        if (responses[requestIdx]) {
+            ErrorDescription =  TStringBuilder() << putType << "is recieved twice"
+                    << " Event# " << event.ToString()
+                    << " State# " << DumpFullState();
+            return true;
+        }
+        responses[requestIdx] = true;
+        return false;
+    }
+
+    void PackToStringImpl(TStringBuilder &) {
+    }
+
+    template <typename TArg, typename... TArgs>
+    void PackToStringImpl(TStringBuilder &builder, TArg arg, TArgs... args) {
+        builder << arg;
+        PackToStringImpl(builder, args...);
+    }
+
+    template <typename... TArgs>
+    TString PackToString(TArgs... args) {
+        TStringBuilder builder;
+        PackToStringImpl(builder, args...);
+        return builder;
+    }
+
+    template <typename TPutRecord, typename ...TArgs>
+    bool ProcessOneVPutResult(TLogContext &logCtx, const TPutRecord &record, TVDiskID vDiskId, ui32 orderNumber,
+            TArgs ...resultTypeArgs)
+    {
+        Y_VERIFY(record.HasStatus());
+        Y_VERIFY(record.HasBlobID());
+        Y_VERIFY(record.HasCookie());
+        NKikimrProto::EReplyStatus status = record.GetStatus();
+        TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID());
+        ui32 diskIdx = Info->GetTopology().GetIdxInSubgroup(vDiskId, blobId.Hash());
+
+        TBlobCookie cookie(record.GetCookie());
+        if (cookie.GetPartId() != blobId.PartId()) {
+            ErrorDescription = TStringBuilder()
+                    << PackToString(resultTypeArgs...) << " has wrong cookie; unexpected PartId;"
+                    << " expected# " << blobId.PartId()
+                    << " received# " << cookie.GetPartId()
+                    << " cookie# " << ui64(cookie);
+            return true;
+        }
+        if (cookie.GetVDiskOrderNumber() != orderNumber) {
+            ErrorDescription = TStringBuilder()
+                    << PackToString(resultTypeArgs...) << " has wrong cookie; unexpected orderNumber;"
+                    << " expected# " << orderNumber
+                    << " received# " << cookie.GetVDiskOrderNumber()
+                    << " cookie# " << ui64(cookie);
+            return true;
+        }
+
+        ui64 blobIdx = cookie.GetBlobIdx();
+        ui32 partIdx = blobId.PartId() - 1;
+
+        A_LOG_LOG_SX(logCtx, false, PriorityForStatusInbound(status), "BPP11",
+            "Got " << PackToString(resultTypeArgs...)
+            << " part# " << partIdx
+            << " diskIdx# " << diskIdx
+            << " vDiskId# " << vDiskId
+            << " blob# " << blobId
+            << " status# " << status);
+
+        if (IsDone.size() <= blobIdx) {
+            ErrorDescription = TStringBuilder()
+                    << PackToString(resultTypeArgs...) << " has wrong cookie; unexpected blobIdx;"
+                    << " received# " << cookie.GetVDiskOrderNumber()
+                    << " blobCount# " << IsDone.size()
+                    << " cookie# " << ui64(cookie);
+            return true;
+        }
+
+        if (IsDone[blobIdx]) {
+            return false;
+        }
+        switch (status) {
+            case NKikimrProto::ERROR:
+            case NKikimrProto::VDISK_ERROR_STATE:
+            case NKikimrProto::OUT_OF_SPACE:
+                Blackboard.AddErrorResponse(blobId, orderNumber);
+                AtLeastOneResponseWasNotOk = true;
+                break;
+            case NKikimrProto::OK:
+            case NKikimrProto::ALREADY:
+                Blackboard.AddPutOkResponse(blobId, orderNumber);
+                break;
+            default:
+                ErrorDescription = TStringBuilder() << "Unexpected status# " << status;
+                return true;
+        }
+        return false;
+    }
+
+    template <typename TVPutEvent, typename TVPutEventResult>
     void OnVPutEventResult(TLogContext &logCtx, TActorId sender, TVPutEventResult &ev,
-            TDeque<std::unique_ptr<TVPutEvent>> &outVPutEvents, TPutResultVec &outPutResults) 
-    { 
-        constexpr bool isVPut = std::is_same_v<TVPutEvent, TEvBlobStorage::TEvVPut>; 
-        constexpr bool isVMultiPut = std::is_same_v<TVPutEvent, TEvBlobStorage::TEvVMultiPut>; 
-        static_assert(isVPut || isVMultiPut); 
+            TDeque<std::unique_ptr<TVPutEvent>> &outVPutEvents, TPutResultVec &outPutResults)
+    {
+        constexpr bool isVPut = std::is_same_v<TVPutEvent, TEvBlobStorage::TEvVPut>;
+        constexpr bool isVMultiPut = std::is_same_v<TVPutEvent, TEvBlobStorage::TEvVMultiPut>;
+        static_assert(isVPut || isVMultiPut);
         auto putType = isVPut ? "TEvVPut" : "TEvVMultiPut";
- 
-        auto &record = ev.Record; 
-        Y_VERIFY(record.HasStatus()); 
-        NKikimrProto::EReplyStatus status = record.GetStatus(); 
-        Y_VERIFY(status != NKikimrProto::BLOCKED && status != NKikimrProto::RACE && status != NKikimrProto::DEADLINE); 
-        if (record.HasStatusFlags()) { 
-            StatusFlags.Merge(record.GetStatusFlags()); 
-        } 
-        if (record.HasApproximateFreeSpaceShare()) { 
-            float share = record.GetApproximateFreeSpaceShare(); 
-            if (ApproximateFreeSpaceShare == 0.f || share < ApproximateFreeSpaceShare) { 
-                ApproximateFreeSpaceShare = share; 
-            } 
-        } 
- 
-        Y_VERIFY(record.HasVDiskID()); 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
-        TVDiskIdShort shortId(vDiskId); 
-        ui32 orderNumber = Info->GetOrderNumber(shortId); 
- 
-        Y_VERIFY_S(!MarkRequest(ev, orderNumber), ErrorDescription); 
- 
-        if constexpr (isVPut) { 
-            VPutResponses++; 
-            bool error = ProcessOneVPutResult(logCtx, ev.Record, vDiskId, orderNumber, "TEvVPutResult"); 
-            Y_VERIFY_S(!error, ErrorDescription); 
-        } else { 
-            TVMultiPutCookie cookie(record.GetCookie()); 
-            if (cookie.GetItemCount() != record.ItemsSize()) { 
-                ErrorDescription = TStringBuilder() << putType << " has wrong cookie; unexpected ItemCount;" 
-                        << " expected# " << record.ItemsSize() 
-                        << " received# " << cookie.GetItemCount() 
-                        << " cookie# " << ui64(cookie); 
-                Y_VERIFY_S(false, ErrorDescription); 
-                return; 
-            } 
- 
-            VMultiPutResponses++; 
-            for (ui32 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) { 
-                bool error = ProcessOneVPutResult(logCtx, ev.Record.GetItems(itemIdx), vDiskId, orderNumber, 
-                        "TEvVMultiPutResult item# ", itemIdx); 
-                Y_VERIFY_S(!error, ErrorDescription); 
-            } 
-            A_LOG_LOG_SX(logCtx, false, PriorityForStatusInbound(status), "BPP23", "Got VMultiPutResult " 
-                << " vDiskId# " << vDiskId 
-                << " from# " << sender 
-                << " status# " << status 
-                << " vMultiPutResult# " << ev.ToString()); 
-        } 
- 
-        const auto &requests = isVPut ? VPutRequests : VMultiPutRequests; 
-        const auto &responses = isVPut ? VPutResponses : VMultiPutResponses; 
- 
-        if (Info->Type.GetErasure() == TBlobStorageGroupType::Erasure4Plus2Block 
-                && !AtLeastOneResponseWasNotOk 
-                && requests >= 6 && responses <= 4) { 
-            // 6 == Info->Type.TotalPartCount() 
-            // There is no need to run strategy since no new information is recieved 
-            return; 
-        } 
- 
-        Step(logCtx, outVPutEvents, outPutResults); 
-        Y_VERIFY_S(DoneBlobs == BlobIds.size() || requests > responses, 
-                "No put result while" 
-                << " Type# " << putType 
-                << " DoneBlobs# " << DoneBlobs 
-                << " requests# " << requests 
-                << " responses# " << responses 
-                << " Blackboard# " << Blackboard.ToString()); 
-    } 
- 
+
+        auto &record = ev.Record;
+        Y_VERIFY(record.HasStatus());
+        NKikimrProto::EReplyStatus status = record.GetStatus();
+        Y_VERIFY(status != NKikimrProto::BLOCKED && status != NKikimrProto::RACE && status != NKikimrProto::DEADLINE);
+        if (record.HasStatusFlags()) {
+            StatusFlags.Merge(record.GetStatusFlags());
+        }
+        if (record.HasApproximateFreeSpaceShare()) {
+            float share = record.GetApproximateFreeSpaceShare();
+            if (ApproximateFreeSpaceShare == 0.f || share < ApproximateFreeSpaceShare) {
+                ApproximateFreeSpaceShare = share;
+            }
+        }
+
+        Y_VERIFY(record.HasVDiskID());
+        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
+        TVDiskIdShort shortId(vDiskId);
+        ui32 orderNumber = Info->GetOrderNumber(shortId);
+
+        Y_VERIFY_S(!MarkRequest(ev, orderNumber), ErrorDescription);
+
+        if constexpr (isVPut) {
+            VPutResponses++;
+            bool error = ProcessOneVPutResult(logCtx, ev.Record, vDiskId, orderNumber, "TEvVPutResult");
+            Y_VERIFY_S(!error, ErrorDescription);
+        } else {
+            TVMultiPutCookie cookie(record.GetCookie());
+            if (cookie.GetItemCount() != record.ItemsSize()) {
+                ErrorDescription = TStringBuilder() << putType << " has wrong cookie; unexpected ItemCount;"
+                        << " expected# " << record.ItemsSize()
+                        << " received# " << cookie.GetItemCount()
+                        << " cookie# " << ui64(cookie);
+                Y_VERIFY_S(false, ErrorDescription);
+                return;
+            }
+
+            VMultiPutResponses++;
+            for (ui32 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) {
+                bool error = ProcessOneVPutResult(logCtx, ev.Record.GetItems(itemIdx), vDiskId, orderNumber,
+                        "TEvVMultiPutResult item# ", itemIdx);
+                Y_VERIFY_S(!error, ErrorDescription);
+            }
+            A_LOG_LOG_SX(logCtx, false, PriorityForStatusInbound(status), "BPP23", "Got VMultiPutResult "
+                << " vDiskId# " << vDiskId
+                << " from# " << sender
+                << " status# " << status
+                << " vMultiPutResult# " << ev.ToString());
+        }
+
+        const auto &requests = isVPut ? VPutRequests : VMultiPutRequests;
+        const auto &responses = isVPut ? VPutResponses : VMultiPutResponses;
+
+        if (Info->Type.GetErasure() == TBlobStorageGroupType::Erasure4Plus2Block
+                && !AtLeastOneResponseWasNotOk
+                && requests >= 6 && responses <= 4) {
+            // 6 == Info->Type.TotalPartCount()
+            // There is no need to run strategy since no new information is recieved
+            return;
+        }
+
+        Step(logCtx, outVPutEvents, outPutResults);
+        Y_VERIFY_S(DoneBlobs == BlobIds.size() || requests > responses,
+                "No put result while"
+                << " Type# " << putType
+                << " DoneBlobs# " << DoneBlobs
+                << " requests# " << requests
+                << " responses# " << responses
+                << " Blackboard# " << Blackboard.ToString());
+    }
+
     void PrepareReply(NKikimrProto::EReplyStatus status, TLogContext &logCtx, TString errorReason,
-            TPutResultVec &outPutResults); 
+            TPutResultVec &outPutResults);
     void PrepareReply(TLogContext &logCtx, TString errorReason, TBatchedVec<TBlackboard::TBlobStates::value_type*>& finished,
             TPutResultVec &outPutResults);
-    void PrepareOneReply(NKikimrProto::EReplyStatus status, TLogoBlobID blobId, ui64 blobIdx, TLogContext &logCtx, 
-            TString errorReason, TPutResultVec &outPutResults); 
+    void PrepareOneReply(NKikimrProto::EReplyStatus status, TLogoBlobID blobId, ui64 blobIdx, TLogContext &logCtx,
+            TString errorReason, TPutResultVec &outPutResults);
 
     ui64 GetTimeToAccelerateNs(TLogContext &logCtx);
- 
-    template <typename TVPutEvent> 
+
+    template <typename TVPutEvent>
     void Accelerate(TLogContext &logCtx, TDeque<std::unique_ptr<TVPutEvent>> &outVPuts) {
         Blackboard.ChangeAll();
         switch (Info->Type.GetErasure()) {
             case TBlobStorageGroupType::ErasureMirror3dc:
-                Blackboard.RunStrategy(logCtx, TAcceleratePut3dcStrategy(Tactic, EnableRequestMod3x3ForMinLatecy)); 
+                Blackboard.RunStrategy(logCtx, TAcceleratePut3dcStrategy(Tactic, EnableRequestMod3x3ForMinLatecy));
                 break;
             case TBlobStorageGroupType::ErasureMirror3of4:
                 Blackboard.RunStrategy(logCtx, TPut3of4Strategy(Tactic, true));
@@ -354,103 +354,103 @@ public:
             default:
                 Blackboard.RunStrategy(logCtx, TAcceleratePutStrategy());
                 break;
-        } 
-        PrepareVPuts(logCtx, outVPuts); 
-    } 
- 
+        }
+        PrepareVPuts(logCtx, outVPuts);
+    }
+
     TString DumpFullState() const;
 
-    bool MarkBlobAsSent(ui64 blobIdx); 
-    bool MarkBlobAsSent(TMap<TLogoBlobID, TBlobState>::iterator it); 
- 
-    TString ToString() const; 
- 
+    bool MarkBlobAsSent(ui64 blobIdx);
+    bool MarkBlobAsSent(TMap<TLogoBlobID, TBlobState>::iterator it);
+
+    TString ToString() const;
+
 protected:
-    bool RunStrategies(TLogContext &logCtx, TPutResultVec &outPutResults); 
+    bool RunStrategies(TLogContext &logCtx, TPutResultVec &outPutResults);
     bool RunStrategy(TLogContext &logCtx, const IStrategy& strategy, TPutResultVec &outPutResults);
- 
-    // Returns true if there are additional requests to send 
-    template <typename TVPutEvent> 
+
+    // Returns true if there are additional requests to send
+    template <typename TVPutEvent>
     bool Step(TLogContext &logCtx, TDeque<std::unique_ptr<TVPutEvent>> &outVPuts,
-            TPutResultVec &outPutResults) { 
-        if (!RunStrategies(logCtx, outPutResults)) { 
-            const ui32 numRequests = outVPuts.size(); 
-            PrepareVPuts(logCtx, outVPuts); 
-            return outVPuts.size() > numRequests; 
-        } else { 
-            Y_VERIFY(outPutResults.size()); 
-            PrepareVPuts(logCtx, outVPuts); 
-            return false; 
-        } 
-    } 
- 
- 
-    template <typename TVPutEvent> 
-    void PrepareVPuts(TLogContext &logCtx, TDeque<std::unique_ptr<TVPutEvent>> &outVPutEvents) { 
-        constexpr bool isVPut = std::is_same_v<TEvBlobStorage::TEvVPut, TVPutEvent>; 
-        constexpr bool isVMultiPut = std::is_same_v<TEvBlobStorage::TEvVMultiPut, TVPutEvent>; 
-        static_assert(isVPut || isVMultiPut); 
- 
-        const ui32 diskCount = Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber.size(); 
-        for (ui32 diskOrderNumber = 0; diskOrderNumber < diskCount; ++diskOrderNumber) { 
-            const TDiskRequests &requests = Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber]; 
-            ui32 endIdx = requests.PutsToSend.size(); 
-            ui32 beginIdx = requests.FirstUnsentPutIdx; 
- 
-            if (beginIdx >= endIdx) { 
-                continue; 
-            } 
- 
-            TVDiskID vDiskId = Info->GetVDiskId(diskOrderNumber); 
- 
-            if constexpr (isVMultiPut) { 
-                ui64 cookie = TVMultiPutCookie(diskOrderNumber, endIdx - beginIdx, VMultiPutRequests); 
-                auto vMultiPut = std::make_unique<TEvBlobStorage::TEvVMultiPut>(vDiskId, Deadline, Blackboard.PutHandleClass, 
-                    false, &cookie); 
-                vMultiPut->ReservePayload(endIdx - beginIdx); 
-                outVPutEvents.push_back(std::move(vMultiPut)); 
-                ++VMultiPutRequests; 
-                ReceivedVMultiPutResponses.push_back(false); 
-            } 
- 
-            for (ui32 idx = beginIdx; idx < endIdx; ++idx) { 
-                const TDiskPutRequest &put = requests.PutsToSend[idx]; 
-                ui32 counter = isVPut ? VPutRequests : VMultiPutRequests; 
-                ui64 cookie = TBlobCookie(diskOrderNumber, put.BlobIdx, put.Id.PartId(), counter); 
- 
-                if constexpr (isVPut) { 
-                    auto vPut = std::make_unique<TEvBlobStorage::TEvVPut>(put.Id, put.Buffer, vDiskId, false, &cookie, 
-                            Deadline, Blackboard.PutHandleClass); 
-                    R_LOG_DEBUG_SX(logCtx, "BPP20", "Send put to orderNumber# " << diskOrderNumber << " idx# " << idx 
-                            << " vPut# " << vPut->ToString()); 
-                    outVPutEvents.push_back(std::move(vPut)); 
-                    ++VPutRequests; 
-                    ReceivedVPutResponses.push_back(false); 
-                } else if constexpr (isVMultiPut) { 
-                    outVPutEvents.back()->AddVPut(put.Id, put.Buffer, &cookie); 
-                } 
-
-                if (put.IsHandoff) { 
-                    ++HandoffPartsSent; 
-                } 
- 
-                LWPROBE(DSProxyPutVPut, put.Id.TabletID(), Info->GroupID, put.Id.Channel(), put.Id.PartId(), 
-                        put.Id.ToString(), Tactic, 
-                        NKikimrBlobStorage::EPutHandleClass_Name(Blackboard.PutHandleClass), 
-                        put.Id.BlobSize(), put.Buffer.size(), Info->GetFailDomainOrderNumber(vDiskId), 
-                        NKikimrBlobStorage::EVDiskQueueId_Name(TGroupQueues::TVDisk::TQueues::VDiskQueueId(*outVPutEvents.back())), 
-                        Blackboard.GroupQueues->GetPredictedDelayNsForEvent(*outVPutEvents.back(), Info->GetTopology()) * 0.000001); 
-            } 
- 
-            if constexpr (isVMultiPut) { 
-                R_LOG_DEBUG_SX(logCtx, "BPP39", "Send put to orderNumber# " << diskOrderNumber 
-                        << " count# " << outVPutEvents.back()->Record.ItemsSize() 
-                        << " vMultiPut# " << outVPutEvents.back()->ToString()); 
-            } 
- 
-            Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber].FirstUnsentPutIdx = endIdx; 
-        } 
-    } 
+            TPutResultVec &outPutResults) {
+        if (!RunStrategies(logCtx, outPutResults)) {
+            const ui32 numRequests = outVPuts.size();
+            PrepareVPuts(logCtx, outVPuts);
+            return outVPuts.size() > numRequests;
+        } else {
+            Y_VERIFY(outPutResults.size());
+            PrepareVPuts(logCtx, outVPuts);
+            return false;
+        }
+    }
+
+
+    template <typename TVPutEvent>
+    void PrepareVPuts(TLogContext &logCtx, TDeque<std::unique_ptr<TVPutEvent>> &outVPutEvents) {
+        constexpr bool isVPut = std::is_same_v<TEvBlobStorage::TEvVPut, TVPutEvent>;
+        constexpr bool isVMultiPut = std::is_same_v<TEvBlobStorage::TEvVMultiPut, TVPutEvent>;
+        static_assert(isVPut || isVMultiPut);
+
+        const ui32 diskCount = Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber.size();
+        for (ui32 diskOrderNumber = 0; diskOrderNumber < diskCount; ++diskOrderNumber) {
+            const TDiskRequests &requests = Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber];
+            ui32 endIdx = requests.PutsToSend.size();
+            ui32 beginIdx = requests.FirstUnsentPutIdx;
+
+            if (beginIdx >= endIdx) {
+                continue;
+            }
+
+            TVDiskID vDiskId = Info->GetVDiskId(diskOrderNumber);
+
+            if constexpr (isVMultiPut) {
+                ui64 cookie = TVMultiPutCookie(diskOrderNumber, endIdx - beginIdx, VMultiPutRequests);
+                auto vMultiPut = std::make_unique<TEvBlobStorage::TEvVMultiPut>(vDiskId, Deadline, Blackboard.PutHandleClass,
+                    false, &cookie);
+                vMultiPut->ReservePayload(endIdx - beginIdx);
+                outVPutEvents.push_back(std::move(vMultiPut));
+                ++VMultiPutRequests;
+                ReceivedVMultiPutResponses.push_back(false);
+            }
+
+            for (ui32 idx = beginIdx; idx < endIdx; ++idx) {
+                const TDiskPutRequest &put = requests.PutsToSend[idx];
+                ui32 counter = isVPut ? VPutRequests : VMultiPutRequests;
+                ui64 cookie = TBlobCookie(diskOrderNumber, put.BlobIdx, put.Id.PartId(), counter);
+
+                if constexpr (isVPut) {
+                    auto vPut = std::make_unique<TEvBlobStorage::TEvVPut>(put.Id, put.Buffer, vDiskId, false, &cookie,
+                            Deadline, Blackboard.PutHandleClass);
+                    R_LOG_DEBUG_SX(logCtx, "BPP20", "Send put to orderNumber# " << diskOrderNumber << " idx# " << idx
+                            << " vPut# " << vPut->ToString());
+                    outVPutEvents.push_back(std::move(vPut));
+                    ++VPutRequests;
+                    ReceivedVPutResponses.push_back(false);
+                } else if constexpr (isVMultiPut) {
+                    outVPutEvents.back()->AddVPut(put.Id, put.Buffer, &cookie);
+                }
+
+                if (put.IsHandoff) {
+                    ++HandoffPartsSent;
+                }
+
+                LWPROBE(DSProxyPutVPut, put.Id.TabletID(), Info->GroupID, put.Id.Channel(), put.Id.PartId(),
+                        put.Id.ToString(), Tactic,
+                        NKikimrBlobStorage::EPutHandleClass_Name(Blackboard.PutHandleClass),
+                        put.Id.BlobSize(), put.Buffer.size(), Info->GetFailDomainOrderNumber(vDiskId),
+                        NKikimrBlobStorage::EVDiskQueueId_Name(TGroupQueues::TVDisk::TQueues::VDiskQueueId(*outVPutEvents.back())),
+                        Blackboard.GroupQueues->GetPredictedDelayNsForEvent(*outVPutEvents.back(), Info->GetTopology()) * 0.000001);
+            }
+
+            if constexpr (isVMultiPut) {
+                R_LOG_DEBUG_SX(logCtx, "BPP39", "Send put to orderNumber# " << diskOrderNumber
+                        << " count# " << outVPutEvents.back()->Record.ItemsSize()
+                        << " vMultiPut# " << outVPutEvents.back()->ToString());
+            }
+
+            Blackboard.GroupDiskRequests.DiskRequestsForOrderNumber[diskOrderNumber].FirstUnsentPutIdx = endIdx;
+        }
+    }
 }; //TPutImpl
 
 }//NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_range.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_range.cpp
index c7e734120a..e234f8c18e 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_range.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_range.cpp
@@ -15,7 +15,7 @@ namespace NKikimr {
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 class TBlobStorageGroupRangeRequest : public TBlobStorageGroupRequestActor<TBlobStorageGroupRangeRequest> {
-    static constexpr ui32 MaxBlobsToQueryAtOnce = 8096; 
+    static constexpr ui32 MaxBlobsToQueryAtOnce = 8096;
 
     const ui64 TabletId;
     const TLogoBlobID From;
@@ -180,7 +180,7 @@ class TBlobStorageGroupRangeRequest : public TBlobStorageGroupRequestActor<TBlob
                         }
                     }
 
-                    from = TLogoBlobID(TabletId, generation, step, channel, TLogoBlobID::MaxBlobSize, cookie); 
+                    from = TLogoBlobID(TabletId, generation, step, channel, TLogoBlobID::MaxBlobSize, cookie);
                     send = send && to < from;
                 }
 
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_request.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_request.cpp
index b50f81aeb3..49986464a2 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_request.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_request.cpp
@@ -14,7 +14,7 @@ namespace NKikimr {
             TActivationContext::Send(StopGetBatchingEvent.Release());
         }
         BatchedGetRequestCount++;
- 
+
         EnsureMonitoring(true);
         LWTRACK(DSProxyGetHandle, ev->Get()->Orbit);
         EnableWilsonTracing(ev, Mon->GetSamplePPM);
@@ -107,7 +107,7 @@ namespace NKikimr {
         Send(MonActor, new TEvThroughputAddRequest(ev->Get()->HandleClass, bytes));
         EnableWilsonTracing(ev, Mon->PutSamplePPM);
 
-        if (EnablePutBatching && bytes < MaxBatchedPutSize) { 
+        if (EnablePutBatching && bytes < MaxBatchedPutSize) {
             NKikimrBlobStorage::EPutHandleClass handleClass = ev->Get()->HandleClass;
             TEvBlobStorage::TEvPut::ETactic tactic = ev->Get()->Tactic;
             Y_VERIFY((ui64)handleClass <= PutHandleClassCount);
@@ -119,8 +119,8 @@ namespace NKikimr {
             }
 
             if (batchedPuts.Queue.size() == MaxBatchedPutRequests || batchedPuts.Bytes + bytes > MaxBatchedPutSize) {
-                *Mon->PutsSentViaPutBatching += batchedPuts.Queue.size(); 
-                ++*Mon->PutBatchesSent; 
+                *Mon->PutsSentViaPutBatching += batchedPuts.Queue.size();
+                ++*Mon->PutBatchesSent;
                 ProcessBatchedPutRequests(batchedPuts, handleClass, tactic);
             }
 
@@ -129,14 +129,14 @@ namespace NKikimr {
         } else {
             TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(ev->Get()->HandleClass);
 
-            TAppData *app = NKikimr::AppData(TActivationContext::AsActorContext()); 
-            bool enableRequestMod3x3ForMinLatency = app->FeatureFlags.GetEnable3x3RequestsForMirror3DCMinLatencyPut(); 
+            TAppData *app = NKikimr::AppData(TActivationContext::AsActorContext());
+            bool enableRequestMod3x3ForMinLatency = app->FeatureFlags.GetEnable3x3RequestsForMirror3DCMinLatencyPut();
             // TODO(alexvru): MinLatency support
             const TActorId reqID = Register(
                     CreateBlobStorageGroupPutRequest(Info, Sessions->GroupQueues, ev->Sender, Mon,
                         ev->Get(), ev->Cookie, std::move(ev->TraceId), Mon->TimeStats.IsEnabled(),
-                        PerDiskStats, kind, TActivationContext::Now(), StoragePoolCounters, 
-                        enableRequestMod3x3ForMinLatency)); 
+                        PerDiskStats, kind, TActivationContext::Now(), StoragePoolCounters,
+                        enableRequestMod3x3ForMinLatency));
             ActiveRequests.insert(reqID);
         }
     }
@@ -158,11 +158,11 @@ namespace NKikimr {
         }
         EnsureMonitoring(true);
         Mon->EventPatch->Inc();
-        TInstant now = TActivationContext::Now(); 
+        TInstant now = TActivationContext::Now();
         const TActorId reqId = Register(
                 CreateBlobStorageGroupPatchRequest(Info, Sessions->GroupQueues, ev->Sender, Mon,
-                        ev->Get(), ev->Cookie, std::move(ev->TraceId), now, 
-                        StoragePoolCounters, SelfId(), EnableVPatch.Update(now))); 
+                        ev->Get(), ev->Cookie, std::move(ev->TraceId), now,
+                        StoragePoolCounters, SelfId(), EnableVPatch.Update(now)));
         ActiveRequests.insert(reqId);
     }
 
@@ -257,21 +257,21 @@ namespace NKikimr {
         TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(handleClass);
 
         if (Info) {
-            TAppData *app = NKikimr::AppData(TActivationContext::AsActorContext()); 
-            bool enableRequestMod3x3ForMinLatency = app->FeatureFlags.GetEnable3x3RequestsForMirror3DCMinLatencyPut(); 
+            TAppData *app = NKikimr::AppData(TActivationContext::AsActorContext());
+            bool enableRequestMod3x3ForMinLatency = app->FeatureFlags.GetEnable3x3RequestsForMirror3DCMinLatencyPut();
             // TODO(alexvru): MinLatency support
             if (batchedPuts.Queue.size() == 1) {
                 const TActorId reqID = Register(
                     CreateBlobStorageGroupPutRequest(Info, Sessions->GroupQueues, batchedPuts.Queue.front()->Sender,
                         Mon, batchedPuts.Queue.front()->Get(), batchedPuts.Queue.front()->Cookie,
                         std::move(batchedPuts.Queue.front()->TraceId), Mon->TimeStats.IsEnabled(), PerDiskStats, kind,
-                        TActivationContext::Now(), StoragePoolCounters, enableRequestMod3x3ForMinLatency)); 
+                        TActivationContext::Now(), StoragePoolCounters, enableRequestMod3x3ForMinLatency));
                 ActiveRequests.insert(reqID);
             } else {
                 const TActorId reqID = Register(
                     CreateBlobStorageGroupPutRequest(Info, Sessions->GroupQueues,
                         Mon, batchedPuts.Queue, Mon->TimeStats.IsEnabled(), PerDiskStats, kind, TActivationContext::Now(),
-                        StoragePoolCounters, handleClass, tactic, enableRequestMod3x3ForMinLatency)); 
+                        StoragePoolCounters, handleClass, tactic, enableRequestMod3x3ForMinLatency));
                 ActiveRequests.insert(reqID);
             }
         } else {
@@ -289,15 +289,15 @@ namespace NKikimr {
         for (auto &bucket : PutBatchedBucketQueue) {
             auto &batchedPuts = BatchedPuts[bucket.HandleClass][bucket.Tactic];
             Y_VERIFY(!batchedPuts.Queue.empty());
-            *Mon->PutsSentViaPutBatching += batchedPuts.Queue.size(); 
-            ++*Mon->PutBatchesSent; 
+            *Mon->PutsSentViaPutBatching += batchedPuts.Queue.size();
+            ++*Mon->PutBatchesSent;
             ProcessBatchedPutRequests(batchedPuts, bucket.HandleClass, bucket.Tactic);
         }
         PutBatchedBucketQueue.clear();
         ++*Mon->EventStopPutBatching;
         LWPROBE(DSProxyBatchedPutRequest, BatchedPutRequestCount, GroupId);
         BatchedPutRequestCount = 0;
-        EnablePutBatching.Update(TActivationContext::Now()); 
+        EnablePutBatching.Update(TActivationContext::Now());
     }
 
     void TBlobStorageGroupProxy::Handle(TEvStopBatchingGetRequests::TPtr& ev) {
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_state.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_state.cpp
index 6a8f38d00f..af2739699d 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_state.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_state.cpp
@@ -296,8 +296,8 @@ namespace NKikimr {
     }
 
     void TBlobStorageGroupProxy::Handle(TEvRequestProxySessionsState::TPtr &ev) {
-        LOG_DEBUG_S(*TlsActivationContext, NKikimrServices::BS_PROXY, "RequestProxySessionsState Group# " << GroupId 
-                << " Marker# DSP59"); 
+        LOG_DEBUG_S(*TlsActivationContext, NKikimrServices::BS_PROXY, "RequestProxySessionsState Group# " << GroupId
+                << " Marker# DSP59");
         Send(ev->Sender, new TEvProxySessionsState(Sessions ? Sessions->GroupQueues : nullptr));
     }
 
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_accelerate_put_m3dc.h b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_accelerate_put_m3dc.h
index c207098fa7..a9e36aa68b 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_accelerate_put_m3dc.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_accelerate_put_m3dc.h
@@ -14,19 +14,19 @@ public:
     static constexpr size_t NumFailDomainsPerFailRealm = 3;
 
     const TEvBlobStorage::TEvPut::ETactic Tactic;
-    const bool EnableRequestMod3x3ForMinLatecy; 
+    const bool EnableRequestMod3x3ForMinLatecy;
 
-    TAcceleratePut3dcStrategy(TEvBlobStorage::TEvPut::ETactic tactic, bool enableRequestMod3x3ForMinLatecy) 
+    TAcceleratePut3dcStrategy(TEvBlobStorage::TEvPut::ETactic tactic, bool enableRequestMod3x3ForMinLatecy)
         : Tactic(tactic)
-        , EnableRequestMod3x3ForMinLatecy(enableRequestMod3x3ForMinLatecy) 
+        , EnableRequestMod3x3ForMinLatecy(enableRequestMod3x3ForMinLatecy)
     {}
 
     ui8 PreferredReplicasPerRealm(bool isDegraded) const {
         // calculate the least number of replicas we have to provide per each realm
-        if (Tactic == TEvBlobStorage::TEvPut::TacticMinLatency) { 
-            return EnableRequestMod3x3ForMinLatecy ? 3 : 2; 
-        } 
-        return isDegraded ? 2 : 1; 
+        if (Tactic == TEvBlobStorage::TEvPut::TacticMinLatency) {
+            return EnableRequestMod3x3ForMinLatecy ? 3 : 2;
+        }
+        return isDegraded ? 2 : 1;
     }
 
     EStrategyOutcome Process(TLogContext &logCtx, TBlobState &state, const TBlobStorageGroupInfo &info,
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_base.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_base.cpp
index f09f3eb6a8..c73c20712e 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_base.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_base.cpp
@@ -212,7 +212,7 @@ bool TStrategyBase::VerifyTheWholeSituation(TBlobState &state) {
 }
 
 void TStrategyBase::PreparePartLayout(const TBlobState &state, const TBlobStorageGroupInfo &info,
-        TBlobStorageGroupType::TPartLayout *layout, ui32 slowDiskIdx) { 
+        TBlobStorageGroupType::TPartLayout *layout, ui32 slowDiskIdx) {
     Y_VERIFY(layout);
     const ui32 totalPartCount = info.Type.TotalPartCount();
     const ui32 blobSubringSize = info.Type.BlobSubgroupSize();
@@ -235,19 +235,19 @@ void TStrategyBase::PreparePartLayout(const TBlobState &state, const TBlobStorag
             for (ui32 partIdx = beginPartIdx; partIdx < endPartIdx; ++partIdx) {
                 TBlobState::ESituation partSituation = disk.DiskParts[partIdx].Situation;
                 if (partSituation == TBlobState::ESituation::Present ||
-                        (diskIdx != slowDiskIdx && partSituation == TBlobState::ESituation::Sent)) { 
+                        (diskIdx != slowDiskIdx && partSituation == TBlobState::ESituation::Sent)) {
                     layout->VDiskPartMask[diskIdx] |= (1ul << partIdx);
                 }
                 layout->VDiskMask |= (1ul << diskIdx);
             }
         }
     }
-    if (slowDiskIdx == InvalidVDiskIdx) { 
-        layout->SlowVDiskMask = 0; 
-    } else { 
-        Y_VERIFY_DEBUG(slowDiskIdx < sizeof(layout->SlowVDiskMask) * 8); 
-        layout->SlowVDiskMask = (1ull << slowDiskIdx); 
-    } 
+    if (slowDiskIdx == InvalidVDiskIdx) {
+        layout->SlowVDiskMask = 0;
+    } else {
+        Y_VERIFY_DEBUG(slowDiskIdx < sizeof(layout->SlowVDiskMask) * 8);
+        layout->SlowVDiskMask = (1ull << slowDiskIdx);
+    }
 }
 
 bool TStrategyBase::IsPutNeeded(const TBlobState &state, const TBlobStorageGroupType::TPartPlacement &partPlacement) {
@@ -307,9 +307,9 @@ void TStrategyBase::PreparePutsForPartPlacement(TLogContext &logCtx, TBlobState
         // send record.PartIdx to record.VDiskIdx if needed
         TBlobState::TDisk &disk = state.Disks[record.VDiskIdx];
         TBlobState::ESituation partSituation = disk.DiskParts[record.PartIdx].Situation;
-        A_LOG_DEBUG_SX(logCtx, "BPG33 ", "partPlacement record partSituation# " << TBlobState::SituationToString(partSituation) 
-                << " to# " << (ui32)record.VDiskIdx 
-                << " blob Id# " << TLogoBlobID(state.Id, record.PartIdx + 1).ToString()); 
+        A_LOG_DEBUG_SX(logCtx, "BPG33 ", "partPlacement record partSituation# " << TBlobState::SituationToString(partSituation)
+                << " to# " << (ui32)record.VDiskIdx
+                << " blob Id# " << TLogoBlobID(state.Id, record.PartIdx + 1).ToString());
         bool isNeeded = false;
         switch (partSituation) {
             case TBlobState::ESituation::Unknown:
@@ -333,7 +333,7 @@ void TStrategyBase::PreparePutsForPartPlacement(TLogContext &logCtx, TBlobState
                     << " blob Id# " << partId.ToString());
             Y_VERIFY(state.Parts[record.PartIdx].Data.IsMonolith());
             groupDiskRequests.AddPut(disk.OrderNumber, partId, state.Parts[record.PartIdx].Data.GetMonolith(),
-                    TDiskPutRequest::ReasonInitial, info.Type.IsHandoffInSubgroup(record.VDiskIdx), state.BlobIdx); 
+                    TDiskPutRequest::ReasonInitial, info.Type.IsHandoffInSubgroup(record.VDiskIdx), state.BlobIdx);
             disk.DiskParts[record.PartIdx].Situation = TBlobState::ESituation::Sent;
         }
     }
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_base.h b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_base.h
index 6dc97f822c..ca005dc936 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_base.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_base.h
@@ -15,8 +15,8 @@ protected:
         EDE_NORMAL
     };
 
-    static constexpr ui32 InvalidVDiskIdx = Max<ui32>(); 
- 
+    static constexpr ui32 InvalidVDiskIdx = Max<ui32>();
+
     void Finish(NKikimrProto::EReplyStatus status);
     // Altruistic - suppose all ERROR and non-responding disks have all the data
     // Optimistic - suppose all non-responding disks have the data, but ERROR disks are wiped
@@ -35,7 +35,7 @@ protected:
             TBlobState::TDisk &disk, TIntervalSet<i32> &intervalSet, const char *logMarker);
     bool VerifyTheWholeSituation(TBlobState &state);
     void PreparePartLayout(const TBlobState &state, const TBlobStorageGroupInfo &info,
-            TBlobStorageGroupType::TPartLayout *layout, ui32 slowDiskIdx); 
+            TBlobStorageGroupType::TPartLayout *layout, ui32 slowDiskIdx);
     bool IsPutNeeded(const TBlobState &state, const TBlobStorageGroupType::TPartPlacement &partPlacement);
     void PreparePutsForPartPlacement(TLogContext &logCtx, TBlobState &state,
             const TBlobStorageGroupInfo &info, TGroupDiskRequests &groupDiskRequests,
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_get_m3dc_restore.h b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_get_m3dc_restore.h
index 70fc5e0238..161a1b3f9f 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_get_m3dc_restore.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_get_m3dc_restore.h
@@ -55,7 +55,7 @@ namespace NKikimr {
                     "Blob Id# %s unexpected whole situation %" PRIu32,
                     state.Id.ToString().c_str(), ui32(state.WholeSituation));
             state.WholeSituation = TBlobState::ESituation::Present;
-            const EStrategyOutcome outcome = TPut3dcStrategy(TEvBlobStorage::TEvPut::TacticMaxThroughput, false).Process(logCtx, 
+            const EStrategyOutcome outcome = TPut3dcStrategy(TEvBlobStorage::TEvPut::TacticMaxThroughput, false).Process(logCtx,
                 state, info, blackboard, groupDiskRequests);
             switch (outcome) {
                 case EStrategyOutcome::IN_PROGRESS:
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_get_min_iops_block.h b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_get_min_iops_block.h
index 36d95f6adb..d191f11006 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_get_min_iops_block.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_get_min_iops_block.h
@@ -53,7 +53,7 @@ public:
         const ui32 totalPartCount = info.Type.TotalPartCount();
         const i32 handoff = info.Type.Handoff();
         ui32 partsMissing = 0;
-        ui32 responsesPending = 0; 
+        ui32 responsesPending = 0;
         for (ui32 partIdx = 0; partIdx < totalPartCount; ++partIdx) {
             bool isMissing = true;
             for (i32 niche = -1; niche < handoff; ++niche) {
@@ -64,16 +64,16 @@ public:
                 if (partSituation == TBlobState::ESituation::Present) {
                     isMissing = false;
                 }
-                if (!requested.IsEmpty()) { 
-                    responsesPending++; 
-                } 
+                if (!requested.IsEmpty()) {
+                    responsesPending++;
+                }
             }
             if (isMissing) {
                 partsMissing++;
             }
         }
 
-        if (partsMissing > info.Type.ParityParts() && responsesPending > 0) { 
+        if (partsMissing > info.Type.ParityParts() && responsesPending > 0) {
             return std::nullopt;
         }
 
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_put_m3dc.h b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_put_m3dc.h
index 603dd957e5..77cc752960 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_put_m3dc.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_put_m3dc.h
@@ -14,18 +14,18 @@ public:
     static constexpr size_t NumFailDomainsPerFailRealm = 3;
 
     const TEvBlobStorage::TEvPut::ETactic Tactic;
-    const bool EnableRequestMod3x3ForMinLatecy; 
+    const bool EnableRequestMod3x3ForMinLatecy;
 
-    TPut3dcStrategy(TEvBlobStorage::TEvPut::ETactic tactic, bool enableRequestMod3x3ForMinLatecy) 
-        : Tactic(tactic) 
-        , EnableRequestMod3x3ForMinLatecy(enableRequestMod3x3ForMinLatecy) 
-    {} 
+    TPut3dcStrategy(TEvBlobStorage::TEvPut::ETactic tactic, bool enableRequestMod3x3ForMinLatecy)
+        : Tactic(tactic)
+        , EnableRequestMod3x3ForMinLatecy(enableRequestMod3x3ForMinLatecy)
+    {}
 
     ui8 PreferredReplicasPerRealm(bool isDegraded) const {
         // calculate the least number of replicas we have to provide per each realm
         ui8 preferredReplicasPerRealm = (isDegraded ? 2 : 1);
         if (Tactic == TEvBlobStorage::TEvPut::TacticMinLatency) {
-            preferredReplicasPerRealm = (EnableRequestMod3x3ForMinLatecy ? 3 : 2); 
+            preferredReplicasPerRealm = (EnableRequestMod3x3ForMinLatecy ? 3 : 2);
         }
         return preferredReplicasPerRealm;
     }
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_restore.h b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_restore.h
index 827bea4a6d..97c8fe3e84 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_strategy_restore.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_strategy_restore.h
@@ -149,7 +149,7 @@ public:
         if (slowDiskSubgroupIdx >= 0) {
             // If there is an exceptionally slow disk, try not touching it, mark isDone
             TBlobStorageGroupType::TPartLayout layout;
-            PreparePartLayout(state, info, &layout, slowDiskSubgroupIdx); 
+            PreparePartLayout(state, info, &layout, slowDiskSubgroupIdx);
 
             TBlobStorageGroupType::TPartPlacement partPlacement;
             bool isCorrectable = info.Type.CorrectLayout(layout, partPlacement);
@@ -163,7 +163,7 @@ public:
         if (!isDone) {
             // Fill in the part layout
             TBlobStorageGroupType::TPartLayout layout;
-            PreparePartLayout(state, info, &layout, InvalidVDiskIdx); 
+            PreparePartLayout(state, info, &layout, InvalidVDiskIdx);
             TBlobStorageGroupType::TPartPlacement partPlacement;
             bool isCorrectable = info.Type.CorrectLayout(layout, partPlacement);
             Y_VERIFY(isCorrectable);
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_counters_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_counters_ut.cpp
index ffb87f1b44..bb64b2711a 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_counters_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_counters_ut.cpp
@@ -1,146 +1,146 @@
-#include "defs.h" 
- 
-#include "dsproxy_env_mock_ut.h" 
-#include "dsproxy_test_state_ut.h" 
-#include "dsproxy_vdisk_mock_ut.h" 
- 
+#include "defs.h"
+
+#include "dsproxy_env_mock_ut.h"
+#include "dsproxy_test_state_ut.h"
+#include "dsproxy_vdisk_mock_ut.h"
+
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_partlayout.h>
 #include <ydb/core/util/stlog.h>
- 
-#include <cstring> 
- 
- 
-namespace NKikimr { 
- 
-namespace NDSProxyCountersTest { 
- 
- 
-void SetLogPriorities(TTestBasicRuntime &runtime) { 
-    bool IsVerbose = false; 
-    if (IsVerbose) { 
-        runtime.SetLogPriority(NKikimrServices::BS_PROXY_PATCH, NLog::PRI_DEBUG); 
-        runtime.SetLogPriority(NKikimrServices::BS_PROXY_GET, NLog::PRI_DEBUG); 
-        runtime.SetLogPriority(NKikimrServices::BS_PROXY_PUT, NLog::PRI_DEBUG); 
-        runtime.SetLogPriority(NActorsServices::TEST, NLog::PRI_DEBUG); 
-    } 
-    runtime.SetLogPriority(NKikimrServices::BS_PROXY, NLog::PRI_CRIT); 
-    runtime.SetLogPriority(NKikimrServices::BS_QUEUE, NLog::PRI_CRIT); 
-} 
- 
- 
-Y_UNIT_TEST_SUITE(DSProxyCounters) { 
- 
-Y_UNIT_TEST(PutGeneratedSubrequestBytes) { 
-    NKikimr::TBlobStorageGroupType erasure = TErasureType::Erasure4Plus2Block; 
-    TTestBasicRuntime runtime(1, false); 
-    SetLogPriorities(runtime); 
-    SetupRuntime(runtime); 
-    TDSProxyEnv env; 
-    env.Configure(runtime, erasure, 1, 0); 
-    TTestState testState(runtime, erasure, env.Info); 
- 
-    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault; 
-    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog; 
- 
- 
-    TLogoBlobID blobId = TLogoBlobID(72075186224047637, 1, 863, 1, 254, 24576); 
-    ui32 requestBytes = blobId.BlobSize(); 
- 
-    TRequestMonItem &requestMonItem = env.StoragePoolCounters->GetItem(HandleClassToHandleClass(handleClass), requestBytes); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.RequestBytes->Val(), 0); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequests->Val(), 0); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequestBytes->Val(), 0); 
- 
-    TString buffer = TString::Uninitialized(blobId.BlobSize()); 
-    for (char &ch : buffer) { 
-        ch = 'a'; 
-    } 
-    TVector<TBlobTestSet::TBlob> blobs { 
-        TBlobTestSet::TBlob(blobId, buffer) 
-    }; 
- 
-    TEvBlobStorage::TEvPut::TPtr put = testState.CreatePutRequest(blobs[0], tactic, handleClass); 
+
+#include <cstring>
+
+
+namespace NKikimr {
+
+namespace NDSProxyCountersTest {
+
+
+void SetLogPriorities(TTestBasicRuntime &runtime) {
+    bool IsVerbose = false;
+    if (IsVerbose) {
+        runtime.SetLogPriority(NKikimrServices::BS_PROXY_PATCH, NLog::PRI_DEBUG);
+        runtime.SetLogPriority(NKikimrServices::BS_PROXY_GET, NLog::PRI_DEBUG);
+        runtime.SetLogPriority(NKikimrServices::BS_PROXY_PUT, NLog::PRI_DEBUG);
+        runtime.SetLogPriority(NActorsServices::TEST, NLog::PRI_DEBUG);
+    }
+    runtime.SetLogPriority(NKikimrServices::BS_PROXY, NLog::PRI_CRIT);
+    runtime.SetLogPriority(NKikimrServices::BS_QUEUE, NLog::PRI_CRIT);
+}
+
+
+Y_UNIT_TEST_SUITE(DSProxyCounters) {
+
+Y_UNIT_TEST(PutGeneratedSubrequestBytes) {
+    NKikimr::TBlobStorageGroupType erasure = TErasureType::Erasure4Plus2Block;
+    TTestBasicRuntime runtime(1, false);
+    SetLogPriorities(runtime);
+    SetupRuntime(runtime);
+    TDSProxyEnv env;
+    env.Configure(runtime, erasure, 1, 0);
+    TTestState testState(runtime, erasure, env.Info);
+
+    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault;
+    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog;
+
+
+    TLogoBlobID blobId = TLogoBlobID(72075186224047637, 1, 863, 1, 254, 24576);
+    ui32 requestBytes = blobId.BlobSize();
+
+    TRequestMonItem &requestMonItem = env.StoragePoolCounters->GetItem(HandleClassToHandleClass(handleClass), requestBytes);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.RequestBytes->Val(), 0);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequests->Val(), 0);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequestBytes->Val(), 0);
+
+    TString buffer = TString::Uninitialized(blobId.BlobSize());
+    for (char &ch : buffer) {
+        ch = 'a';
+    }
+    TVector<TBlobTestSet::TBlob> blobs {
+        TBlobTestSet::TBlob(blobId, buffer)
+    };
+
+    TEvBlobStorage::TEvPut::TPtr put = testState.CreatePutRequest(blobs[0], tactic, handleClass);
     runtime.Register(env.CreatePutRequestActor(put).release());
- 
-    TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses; 
-    for (ui64 part = 1; part <= env.Info->Type.TotalPartCount(); ++part) { 
-        TLogoBlobID partBlobId(blobId, part); 
-        TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId); 
-        specialStatuses[id] = NKikimrProto::OK; 
-    } 
- 
-    TGroupMock &groupMock = testState.GetGroupMock(); 
-    groupMock.SetSpecialStatuses(specialStatuses); 
- 
-    testState.HandleVPutsWithMock(env.Info->Type.TotalPartCount()); 
- 
-    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> expectedStatus; 
-    expectedStatus[blobId] = NKikimrProto::OK; 
-    testState.ReceivePutResults(expectedStatus.size(), expectedStatus); 
- 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.RequestBytes->Val(), 254); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequests->Val(), 6); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequestBytes->Val(), 64 * 6); 
-} 
- 
-Y_UNIT_TEST(MultiPutGeneratedSubrequestBytes) { 
-    NKikimr::TBlobStorageGroupType erasure = TErasureType::Erasure4Plus2Block; 
-    TTestBasicRuntime runtime(1, false); 
-    SetLogPriorities(runtime); 
-    SetupRuntime(runtime); 
-    TDSProxyEnv env; 
-    env.Configure(runtime, erasure, 1, 0); 
-    TTestState testState(runtime, erasure, env.Info); 
- 
-    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault; 
-    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog; 
- 
- 
-    TLogoBlobID blobId = TLogoBlobID(72075186224047637, 1, 863, 1, 254, 24576); 
-    ui32 requestBytes = blobId.BlobSize(); 
- 
-    TRequestMonItem &requestMonItem = env.StoragePoolCounters->GetItem(HandleClassToHandleClass(handleClass), requestBytes); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.RequestBytes->Val(), 0); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequests->Val(), 0); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequestBytes->Val(), 0); 
- 
-    TString buffer = TString::Uninitialized(blobId.BlobSize()); 
-    for (char &ch : buffer) { 
-        ch = 'a'; 
-    } 
-    TVector<TBlobTestSet::TBlob> blobs { 
-        TBlobTestSet::TBlob(blobId, buffer) 
-    }; 
- 
-    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched; 
-    testState.CreatePutRequests(blobs, std::back_inserter(batched), tactic, handleClass); 
+
+    TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses;
+    for (ui64 part = 1; part <= env.Info->Type.TotalPartCount(); ++part) {
+        TLogoBlobID partBlobId(blobId, part);
+        TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId);
+        specialStatuses[id] = NKikimrProto::OK;
+    }
+
+    TGroupMock &groupMock = testState.GetGroupMock();
+    groupMock.SetSpecialStatuses(specialStatuses);
+
+    testState.HandleVPutsWithMock(env.Info->Type.TotalPartCount());
+
+    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> expectedStatus;
+    expectedStatus[blobId] = NKikimrProto::OK;
+    testState.ReceivePutResults(expectedStatus.size(), expectedStatus);
+
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.RequestBytes->Val(), 254);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequests->Val(), 6);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequestBytes->Val(), 64 * 6);
+}
+
+Y_UNIT_TEST(MultiPutGeneratedSubrequestBytes) {
+    NKikimr::TBlobStorageGroupType erasure = TErasureType::Erasure4Plus2Block;
+    TTestBasicRuntime runtime(1, false);
+    SetLogPriorities(runtime);
+    SetupRuntime(runtime);
+    TDSProxyEnv env;
+    env.Configure(runtime, erasure, 1, 0);
+    TTestState testState(runtime, erasure, env.Info);
+
+    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault;
+    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog;
+
+
+    TLogoBlobID blobId = TLogoBlobID(72075186224047637, 1, 863, 1, 254, 24576);
+    ui32 requestBytes = blobId.BlobSize();
+
+    TRequestMonItem &requestMonItem = env.StoragePoolCounters->GetItem(HandleClassToHandleClass(handleClass), requestBytes);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.RequestBytes->Val(), 0);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequests->Val(), 0);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequestBytes->Val(), 0);
+
+    TString buffer = TString::Uninitialized(blobId.BlobSize());
+    for (char &ch : buffer) {
+        ch = 'a';
+    }
+    TVector<TBlobTestSet::TBlob> blobs {
+        TBlobTestSet::TBlob(blobId, buffer)
+    };
+
+    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched;
+    testState.CreatePutRequests(blobs, std::back_inserter(batched), tactic, handleClass);
     runtime.Register(env.CreatePutRequestActor(batched, tactic, handleClass).release());
- 
-    TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses; 
-    for (ui64 part = 1; part <= env.Info->Type.TotalPartCount(); ++part) { 
-        TLogoBlobID partBlobId(blobId, part); 
-        TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId); 
-        specialStatuses[id] = NKikimrProto::OK; 
-    } 
- 
-    TGroupMock &groupMock = testState.GetGroupMock(); 
-    groupMock.SetSpecialStatuses(specialStatuses); 
- 
-    testState.HandleVMultiPutsWithMock(env.Info->Type.TotalPartCount()); 
- 
-    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> expectedStatus; 
-    expectedStatus[blobId] = NKikimrProto::OK; 
-    testState.ReceivePutResults(expectedStatus.size(), expectedStatus); 
- 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.RequestBytes->Val(), 254); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequests->Val(), 6); 
-    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequestBytes->Val(), 64 * 6); 
-} 
- 
- 
-} 
- 
- 
-} // NDSProxyPatchTest 
- 
-} // NKikimr 
+
+    TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses;
+    for (ui64 part = 1; part <= env.Info->Type.TotalPartCount(); ++part) {
+        TLogoBlobID partBlobId(blobId, part);
+        TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId);
+        specialStatuses[id] = NKikimrProto::OK;
+    }
+
+    TGroupMock &groupMock = testState.GetGroupMock();
+    groupMock.SetSpecialStatuses(specialStatuses);
+
+    testState.HandleVMultiPutsWithMock(env.Info->Type.TotalPartCount());
+
+    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> expectedStatus;
+    expectedStatus[blobId] = NKikimrProto::OK;
+    testState.ReceivePutResults(expectedStatus.size(), expectedStatus);
+
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.RequestBytes->Val(), 254);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequests->Val(), 6);
+    UNIT_ASSERT_VALUES_EQUAL(requestMonItem.GeneratedSubrequestBytes->Val(), 64 * 6);
+}
+
+
+}
+
+
+} // NDSProxyPatchTest
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h b/ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h
index 5deb47a575..0f2350daf8 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h
@@ -1,162 +1,162 @@
-#pragma once 
- 
-#include "defs.h" 
- 
+#pragma once
+
+#include "defs.h"
+
 #include <ydb/core/blobstorage/dsproxy/dsproxy.h>
 #include <ydb/core/blobstorage/dsproxy/dsproxy_nodemon.h>
- 
+
 #include <ydb/core/blobstorage/base/utility.h>
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h>
- 
+
 #include <ydb/core/testlib/basics/runtime.h>
 #include <ydb/core/testlib/basics/appdata.h>
- 
-#include <library/cpp/testing/unittest/registar.h> 
- 
-namespace NKikimr { 
- 
-inline TMaybe<TGroupStat::EKind> PutHandleClassToGroupStatKind(NKikimrBlobStorage::EPutHandleClass handleClass) { 
-    switch (handleClass) { 
-    case NKikimrBlobStorage::TabletLog: 
-        return  TGroupStat::EKind::PUT_TABLET_LOG; 
- 
-    case NKikimrBlobStorage::UserData: 
-        return TGroupStat::EKind::PUT_USER_DATA; 
- 
-    default: 
-        return {}; 
-    } 
-} 
- 
-struct TDSProxyEnv { 
-    TVector<TActorId> VDisks; 
-    TIntrusivePtr<TBlobStorageGroupInfo> Info; 
-    TIntrusivePtr<TBlobStorageGroupProxyMon> Mon; 
-    TBSProxyContextPtr BSProxyCtxPtr; 
-    TIntrusivePtr<NMonitoring::TDynamicCounters> DynCounters; 
-    TIntrusivePtr<NKikimr::TStoragePoolCounters> StoragePoolCounters; 
-    TDiskResponsivenessTracker::TPerDiskStatsPtr PerDiskStatsPtr; 
-    TNodeLayoutInfoPtr NodeLayoutInfo; 
-    TIntrusivePtr<TGroupQueues> GroupQueues; 
-    ui64 GroupId; 
-    ui64 NodeIdx; 
-    TActorId RealProxyActorId; 
-    TActorId FakeProxyActorId; 
- 
-    TActorId MakeVDiskId(ui32 failDomainIdx, ui32 driveIdx, ui32 drivesPerFailDomain) const { 
-        ui32 i = failDomainIdx * drivesPerFailDomain + driveIdx; 
-        return VDisks[i]; 
-    } 
- 
-    void Configure(TTestActorRuntime& runtime, TBlobStorageGroupType type, ui64 groupId, ui64 nodeIndex) { 
-        GroupId = groupId; 
-        NodeIdx = nodeIndex; 
- 
-        ui32 vDiskCount = type.BlobSubgroupSize(); 
-        VDisks.clear(); 
-        for (ui32 i = 0; i < vDiskCount; ++i) { 
-            VDisks.push_back(runtime.AllocateEdgeActor(nodeIndex)); 
-        } 
- 
-        if (type.GetErasure() == TErasureType::ErasureMirror3dc) { 
-            Info = new TBlobStorageGroupInfo(type.GetErasure(), 1, 3, 3, &VDisks); 
-        } else { 
-            Info = new TBlobStorageGroupInfo(type.GetErasure(), 1, type.BlobSubgroupSize(), 1, &VDisks); 
-        } 
- 
-        RealProxyActorId = MakeBlobStorageProxyID(groupId); 
-        TIntrusivePtr<TDsProxyNodeMon> nodeMon = new TDsProxyNodeMon(runtime.GetAppData(nodeIndex).Counters, true); 
-        TString name = Sprintf("%09" PRIu64, groupId); 
-        TIntrusivePtr<NMonitoring::TDynamicCounters> group = GetServiceCounters( 
-                runtime.GetAppData(0).Counters, "dsproxy")->GetSubgroup("blobstorageproxy", name); 
-        TIntrusivePtr<NMonitoring::TDynamicCounters> percentileGroup = GetServiceCounters( 
-                runtime.GetAppData(0).Counters, "dsproxy_percentile")->GetSubgroup("blobstorageproxy", name); 
-        TIntrusivePtr<NMonitoring::TDynamicCounters> overviewGroup = GetServiceCounters( 
-                runtime.GetAppData(0).Counters, "dsproxy_overview"); 
-        BSProxyCtxPtr.Reset(new TBSProxyContext(group->GetSubgroup("subsystem", "memproxy"))); 
-        Mon = new TBlobStorageGroupProxyMon(group, percentileGroup, overviewGroup, Info, nodeMon, false); 
-        TDsProxyPerPoolCounters perPoolCounters(runtime.GetAppData(nodeIndex).Counters); 
-        TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name"); 
-        TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true); 
-        TControlWrapper enableVPatch(DefaultEnableVPatch, false, true); 
+
+#include <library/cpp/testing/unittest/registar.h>
+
+namespace NKikimr {
+
+inline TMaybe<TGroupStat::EKind> PutHandleClassToGroupStatKind(NKikimrBlobStorage::EPutHandleClass handleClass) {
+    switch (handleClass) {
+    case NKikimrBlobStorage::TabletLog:
+        return  TGroupStat::EKind::PUT_TABLET_LOG;
+
+    case NKikimrBlobStorage::UserData:
+        return TGroupStat::EKind::PUT_USER_DATA;
+
+    default:
+        return {};
+    }
+}
+
+struct TDSProxyEnv {
+    TVector<TActorId> VDisks;
+    TIntrusivePtr<TBlobStorageGroupInfo> Info;
+    TIntrusivePtr<TBlobStorageGroupProxyMon> Mon;
+    TBSProxyContextPtr BSProxyCtxPtr;
+    TIntrusivePtr<NMonitoring::TDynamicCounters> DynCounters;
+    TIntrusivePtr<NKikimr::TStoragePoolCounters> StoragePoolCounters;
+    TDiskResponsivenessTracker::TPerDiskStatsPtr PerDiskStatsPtr;
+    TNodeLayoutInfoPtr NodeLayoutInfo;
+    TIntrusivePtr<TGroupQueues> GroupQueues;
+    ui64 GroupId;
+    ui64 NodeIdx;
+    TActorId RealProxyActorId;
+    TActorId FakeProxyActorId;
+
+    TActorId MakeVDiskId(ui32 failDomainIdx, ui32 driveIdx, ui32 drivesPerFailDomain) const {
+        ui32 i = failDomainIdx * drivesPerFailDomain + driveIdx;
+        return VDisks[i];
+    }
+
+    void Configure(TTestActorRuntime& runtime, TBlobStorageGroupType type, ui64 groupId, ui64 nodeIndex) {
+        GroupId = groupId;
+        NodeIdx = nodeIndex;
+
+        ui32 vDiskCount = type.BlobSubgroupSize();
+        VDisks.clear();
+        for (ui32 i = 0; i < vDiskCount; ++i) {
+            VDisks.push_back(runtime.AllocateEdgeActor(nodeIndex));
+        }
+
+        if (type.GetErasure() == TErasureType::ErasureMirror3dc) {
+            Info = new TBlobStorageGroupInfo(type.GetErasure(), 1, 3, 3, &VDisks);
+        } else {
+            Info = new TBlobStorageGroupInfo(type.GetErasure(), 1, type.BlobSubgroupSize(), 1, &VDisks);
+        }
+
+        RealProxyActorId = MakeBlobStorageProxyID(groupId);
+        TIntrusivePtr<TDsProxyNodeMon> nodeMon = new TDsProxyNodeMon(runtime.GetAppData(nodeIndex).Counters, true);
+        TString name = Sprintf("%09" PRIu64, groupId);
+        TIntrusivePtr<NMonitoring::TDynamicCounters> group = GetServiceCounters(
+                runtime.GetAppData(0).Counters, "dsproxy")->GetSubgroup("blobstorageproxy", name);
+        TIntrusivePtr<NMonitoring::TDynamicCounters> percentileGroup = GetServiceCounters(
+                runtime.GetAppData(0).Counters, "dsproxy_percentile")->GetSubgroup("blobstorageproxy", name);
+        TIntrusivePtr<NMonitoring::TDynamicCounters> overviewGroup = GetServiceCounters(
+                runtime.GetAppData(0).Counters, "dsproxy_overview");
+        BSProxyCtxPtr.Reset(new TBSProxyContext(group->GetSubgroup("subsystem", "memproxy")));
+        Mon = new TBlobStorageGroupProxyMon(group, percentileGroup, overviewGroup, Info, nodeMon, false);
+        TDsProxyPerPoolCounters perPoolCounters(runtime.GetAppData(nodeIndex).Counters);
+        TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name");
+        TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true);
+        TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
         IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), true, nodeMon,
             std::move(storagePoolCounters), enablePutBatching, enableVPatch);
-        TActorId actorId = runtime.Register(dsproxy, nodeIndex); 
-        runtime.RegisterService(RealProxyActorId, actorId, nodeIndex); 
- 
-        FakeProxyActorId = runtime.AllocateEdgeActor(0); 
-        TAutoPtr <IEventHandle> handle; 
-        runtime.Send(new IEventHandle(RealProxyActorId, FakeProxyActorId, new TEvRequestProxySessionsState)); 
-        auto queues = runtime.GrabEdgeEventRethrow<TEvProxySessionsState>(handle); 
-        GroupQueues = queues->GroupQueues; 
-        NodeLayoutInfo = nullptr; 
-        DynCounters = new NMonitoring::TDynamicCounters(); 
-        StoragePoolCounters = new NKikimr::TStoragePoolCounters(DynCounters, "", {}); 
-        PerDiskStatsPtr = new TDiskResponsivenessTracker::TPerDiskStats; 
-    } 
- 
-    void SetGroupGeneration(ui32 generation) { 
-        Info = new TBlobStorageGroupInfo(Info, TVDiskID(Info->GroupID, generation, 0, 0, 0), VDisks[0]); 
-    } 
- 
+        TActorId actorId = runtime.Register(dsproxy, nodeIndex);
+        runtime.RegisterService(RealProxyActorId, actorId, nodeIndex);
+
+        FakeProxyActorId = runtime.AllocateEdgeActor(0);
+        TAutoPtr <IEventHandle> handle;
+        runtime.Send(new IEventHandle(RealProxyActorId, FakeProxyActorId, new TEvRequestProxySessionsState));
+        auto queues = runtime.GrabEdgeEventRethrow<TEvProxySessionsState>(handle);
+        GroupQueues = queues->GroupQueues;
+        NodeLayoutInfo = nullptr;
+        DynCounters = new NMonitoring::TDynamicCounters();
+        StoragePoolCounters = new NKikimr::TStoragePoolCounters(DynCounters, "", {});
+        PerDiskStatsPtr = new TDiskResponsivenessTracker::TPerDiskStats;
+    }
+
+    void SetGroupGeneration(ui32 generation) {
+        Info = new TBlobStorageGroupInfo(Info, TVDiskID(Info->GroupID, generation, 0, 0, 0), VDisks[0]);
+    }
+
     std::unique_ptr<IActor> CreatePutRequestActor(TEvBlobStorage::TEvPut::TPtr &ev) {
-        TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(ev->Get()->HandleClass); 
+        TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(ev->Get()->HandleClass);
         return std::unique_ptr<IActor>(CreateBlobStorageGroupPutRequest(Info, GroupQueues, ev->Sender, Mon, ev->Get(),
-                ev->Cookie, std::move(ev->TraceId), Mon->TimeStats.IsEnabled(), PerDiskStatsPtr, kind, 
+                ev->Cookie, std::move(ev->TraceId), Mon->TimeStats.IsEnabled(), PerDiskStatsPtr, kind,
                 TInstant::Now(), StoragePoolCounters, false));
-    } 
- 
+    }
+
     std::unique_ptr<IActor> CreatePutRequestActor(TBatchedVec<TEvBlobStorage::TEvPut::TPtr> &batched,
-            TEvBlobStorage::TEvPut::ETactic tactic, NKikimrBlobStorage::EPutHandleClass handleClass) 
-    { 
-        TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(handleClass); 
+            TEvBlobStorage::TEvPut::ETactic tactic, NKikimrBlobStorage::EPutHandleClass handleClass)
+    {
+        TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(handleClass);
         return std::unique_ptr<IActor>(CreateBlobStorageGroupPutRequest(Info, GroupQueues,
-                Mon, batched, Mon->TimeStats.IsEnabled(), PerDiskStatsPtr, kind,TInstant::Now(), 
+                Mon, batched, Mon->TimeStats.IsEnabled(), PerDiskStatsPtr, kind,TInstant::Now(),
                 StoragePoolCounters, handleClass, tactic, false));
-    } 
- 
+    }
+
     std::unique_ptr<IActor> CreateGetRequestActor(TEvBlobStorage::TEvGet::TPtr &ev,
-            NKikimrBlobStorage::EPutHandleClass handleClass, bool withMultiPut) 
-    { 
-        TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(handleClass); 
+            NKikimrBlobStorage::EPutHandleClass handleClass, bool withMultiPut)
+    {
+        TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(handleClass);
         return std::unique_ptr<IActor>(CreateBlobStorageGroupGetRequest(Info, GroupQueues, ev->Sender, Mon,
-                ev->Get(), ev->Cookie, std::move(ev->TraceId), TNodeLayoutInfoPtr(NodeLayoutInfo), 
+                ev->Get(), ev->Cookie, std::move(ev->TraceId), TNodeLayoutInfoPtr(NodeLayoutInfo),
                 kind, TInstant::Now(), StoragePoolCounters, withMultiPut));
-    } 
- 
+    }
+
     std::unique_ptr<IActor> CreatePatchRequestActor(TEvBlobStorage::TEvPatch::TPtr &ev, bool useVPatch = false) {
         return std::unique_ptr<IActor>(CreateBlobStorageGroupPatchRequest(Info, GroupQueues, ev->Sender, Mon,
-                ev->Get(), ev->Cookie, std::move(ev->TraceId), TInstant::Now(), StoragePoolCounters, 
+                ev->Get(), ev->Cookie, std::move(ev->TraceId), TInstant::Now(), StoragePoolCounters,
                 FakeProxyActorId, useVPatch));
-    } 
-}; 
- 
- 
-inline bool ScheduledFilterFunc(TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& event, 
-        TDuration delay, TInstant& deadline) { 
-    if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) { 
-        deadline = runtime.GetTimeProvider()->Now() + delay; 
-        return false; 
-    } 
-    return true; 
-} 
- 
-inline void SetupRuntime(TTestActorRuntime& runtime) { 
-    TAppPrepare app; 
-    app.ClearDomainsAndHive(); 
-    runtime.SetScheduledEventFilter(&ScheduledFilterFunc); 
- 
-    runtime.SetEventFilter([](TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& ev) { 
-        if (ev->GetTypeRewrite() == TEvBlobStorage::EvVCheckReadiness) { 
-            runtime.Send(new IEventHandle( 
-                    ev->Sender, ev->Recipient, new TEvBlobStorage::TEvVCheckReadinessResult(NKikimrProto::OK), 0, 
-                    ev->Cookie), 0, true); 
-            return true; 
-        } 
-        return false; 
-    }); 
- 
-    runtime.Initialize(app.Unwrap()); 
-} 
- 
-} // NKikimr 
+    }
+};
+
+
+inline bool ScheduledFilterFunc(TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& event,
+        TDuration delay, TInstant& deadline) {
+    if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) {
+        deadline = runtime.GetTimeProvider()->Now() + delay;
+        return false;
+    }
+    return true;
+}
+
+inline void SetupRuntime(TTestActorRuntime& runtime) {
+    TAppPrepare app;
+    app.ClearDomainsAndHive();
+    runtime.SetScheduledEventFilter(&ScheduledFilterFunc);
+
+    runtime.SetEventFilter([](TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& ev) {
+        if (ev->GetTypeRewrite() == TEvBlobStorage::EvVCheckReadiness) {
+            runtime.Send(new IEventHandle(
+                    ev->Sender, ev->Recipient, new TEvBlobStorage::TEvVCheckReadinessResult(NKikimrProto::OK), 0,
+                    ev->Cookie), 0, true);
+            return true;
+        }
+        return false;
+    });
+
+    runtime.Initialize(app.Unwrap());
+}
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut.cpp
index fdd7d01500..6a8fbff0e2 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut.cpp
@@ -56,14 +56,14 @@ Y_UNIT_TEST_SUITE(TBsProxyFaultToleranceTest) {
     FAULT_TOLERANCE_TEST(ERASURE, TDiscoverFaultToleranceTest) \
     FAULT_TOLERANCE_TEST(ERASURE, TPutFaultToleranceTest)
 
-    //ERASURE_TEST(ErasureMirror3) 
-    //ERASURE_TEST(Erasure3Plus1Block) 
-    //ERASURE_TEST(Erasure3Plus1Stripe) 
+    //ERASURE_TEST(ErasureMirror3)
+    //ERASURE_TEST(Erasure3Plus1Block)
+    //ERASURE_TEST(Erasure3Plus1Stripe)
     ERASURE_TEST(Erasure4Plus2Block)
-    //ERASURE_TEST(Erasure3Plus2Block) 
-    //ERASURE_TEST(Erasure4Plus2Stripe) 
-    //ERASURE_TEST(Erasure3Plus2Stripe) 
-    //ERASURE_TEST(ErasureMirror3Plus2) 
+    //ERASURE_TEST(Erasure3Plus2Block)
+    //ERASURE_TEST(Erasure4Plus2Stripe)
+    //ERASURE_TEST(Erasure3Plus2Stripe)
+    //ERASURE_TEST(ErasureMirror3Plus2)
     ERASURE_TEST(ErasureMirror3dc)
     ERASURE_TEST(ErasureMirror3of4)
 
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_base.h b/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_base.h
index a6da8445f6..c4b5c76f39 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_base.h
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_base.h
@@ -185,8 +185,8 @@ public:
             }
         }
         while (responsesPending--) {
-            auto resp = WaitForSpecificEvent<TEvVMockCtlResponse>(); 
-            // Cerr << (TStringBuilder() << "]] SpecEventDelete(wipe=" << wipe << "): " << resp->Get()->ToString() << Endl); 
+            auto resp = WaitForSpecificEvent<TEvVMockCtlResponse>();
+            // Cerr << (TStringBuilder() << "]] SpecEventDelete(wipe=" << wipe << "): " << resp->Get()->ToString() << Endl);
         }
     }
 
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_range.h b/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_range.h
index 61b43711f5..c055d68eab 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_range.h
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_range.h
@@ -15,7 +15,7 @@ public:
 
     void Check(ui64 tabletId, const TBlobStorageGroupInfo::TGroupVDisks& disks,
             NKikimrProto::EReplyStatus defaultExpectedStatus = NKikimrProto::OK) {
-        // Cerr << (TStringBuilder() << "]] " << disks.ToString() << Endl); 
+        // Cerr << (TStringBuilder() << "]] " << disks.ToString() << Endl);
         for (ui32 generation = 1; generation <= 4; ++generation) {
             NKikimrProto::EReplyStatus expectedStatus = defaultExpectedStatus;
             TVector<TEvBlobStorage::TEvRangeResult::TResponse> expectedResponse;
@@ -26,11 +26,11 @@ public:
 
             for (ui32 step = 1; step <= 2; ++step) {
                 TString buffer = Sprintf("%256s/%" PRIu64 "/%" PRIu32 "/%" PRIu32, "kikimr", tabletId, generation, step);
-                TStringBuilder b; 
-                for (int i = 0; i < 1024; ++i) { 
-                    b << 'a'; 
-                } 
-                buffer += b; 
+                TStringBuilder b;
+                for (int i = 0; i < 1024; ++i) {
+                    b << 'a';
+                }
+                buffer += b;
                 TLogoBlobID id(tabletId, generation, step, 0 /*channel*/, buffer.size(), 0);
                 if (defaultExpectedStatus == NKikimrProto::OK) {
                     UNIT_ASSERT_VALUES_EQUAL(NKikimrProto::OK, PutWithResult(id, buffer, TEvBlobStorage::TEvPut::TacticMaxThroughput));
@@ -77,7 +77,7 @@ public:
                 }
                 for (ui32 i = 0; i < vdisks.size(); ++i) {
                     auto event = WaitForSpecificEvent<TEvBlobStorage::TEvVGetResult>();
-                    // Cerr << (TStringBuilder() << "]] Get: " << event->Get()->ToString() << Endl); 
+                    // Cerr << (TStringBuilder() << "]] Get: " << event->Get()->ToString() << Endl);
                     if (event->Get()->Record.GetStatus() == NKikimrProto::OK) {
                         for (const auto& item : event->Get()->Record.GetResult()) {
                             if (item.GetStatus() == NKikimrProto::OK) {
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_runtime.h b/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_runtime.h
index 53ff008cca..bc33af4b86 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_runtime.h
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_fault_tolerance_ut_runtime.h
@@ -85,12 +85,12 @@ public:
         TIntrusivePtr<TDsProxyNodeMon> nodeMon(new TDsProxyNodeMon(Counters, true));
         TDsProxyPerPoolCounters perPoolCounters(Counters);
         TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name");
-        TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true); 
-        TControlWrapper enableVPatch(DefaultEnableVPatch, false, true); 
+        TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true);
+        TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
         IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(GroupInfo), false, nodeMon,
             std::move(storagePoolCounters), enablePutBatching, enableVPatch);
-        setup->LocalServices.emplace_back(MakeBlobStorageProxyID(GroupInfo->GroupID), 
-                TActorSetupCmd(dsproxy, TMailboxType::Simple, 0)); 
+        setup->LocalServices.emplace_back(MakeBlobStorageProxyID(GroupInfo->GroupID),
+                TActorSetupCmd(dsproxy, TMailboxType::Simple, 0));
 
         ActorSystem.reset(new TActorSystem(setup, AppData.get(), logSettings));
         LOG_NOTICE(*ActorSystem, NActorsServices::TEST, "Actor system created");
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_get_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_get_ut.cpp
index 13c0704989..85e16c2aef 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_get_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_get_ut.cpp
@@ -1,5 +1,5 @@
 #include "defs.h"
-#include "dsproxy_vdisk_mock_ut.h" 
+#include "dsproxy_vdisk_mock_ut.h"
 
 #include <ydb/core/testlib/basics/runtime.h>
 #include <ydb/core/testlib/actor_helpers.h>
@@ -153,309 +153,309 @@ Y_UNIT_TEST(TestMirror32GetBlobCrcCheck) {
     TestIntervalsAndCrcAllOk(TErasureType::ErasureMirror3Plus2, false, true);
 }
 
-class TTestWipedAllOkStep { 
-    enum ETVPutEventKind { 
-        TVPEK_VPUT, 
-        TVPEK_VMULTIPUT 
-    }; 
- 
-public: 
-    struct TVPutInfo { 
-        TVDiskID VDiskId; 
-        TLogoBlobID BlobId; 
-        ui64 BlobIdx; 
- 
-        bool operator<(const TVPutInfo &other) const { 
-            return std::tie(VDiskId, BlobId, BlobIdx) < std::tie(other.VDiskId, other.BlobId, other.BlobIdx); 
-        } 
- 
-        bool operator==(const TVPutInfo &other) const { 
-            return std::tie(VDiskId, BlobId, BlobIdx) == std::tie(other.VDiskId, other.BlobId, other.BlobIdx); 
-        } 
-    }; 
- 
-    ui32 GroupId; 
-    TErasureType::EErasureSpecies ErasureSpecies; 
-    ui32 DomainCount; 
-    ui32 GenerateBlobsMode = 0; 
-    const TVector<ui64> &QueryCounts; 
-    ui64 MaxQueryCount; 
- 
-    const TVector<TBlobTestSet::TBlob> *Blobs = nullptr; 
- 
-    bool IsVerboseNoDataEnabled; 
-    bool IsRestore; 
- 
-    TVector<TVPutInfo> SendVPuts; 
- 
-private: 
-    TMaybe<TGroupMock> Group; 
+class TTestWipedAllOkStep {
+    enum ETVPutEventKind {
+        TVPEK_VPUT,
+        TVPEK_VMULTIPUT
+    };
+
+public:
+    struct TVPutInfo {
+        TVDiskID VDiskId;
+        TLogoBlobID BlobId;
+        ui64 BlobIdx;
+
+        bool operator<(const TVPutInfo &other) const {
+            return std::tie(VDiskId, BlobId, BlobIdx) < std::tie(other.VDiskId, other.BlobId, other.BlobIdx);
+        }
+
+        bool operator==(const TVPutInfo &other) const {
+            return std::tie(VDiskId, BlobId, BlobIdx) == std::tie(other.VDiskId, other.BlobId, other.BlobIdx);
+        }
+    };
+
+    ui32 GroupId;
+    TErasureType::EErasureSpecies ErasureSpecies;
+    ui32 DomainCount;
+    ui32 GenerateBlobsMode = 0;
+    const TVector<ui64> &QueryCounts;
+    ui64 MaxQueryCount;
+
+    const TVector<TBlobTestSet::TBlob> *Blobs = nullptr;
+
+    bool IsVerboseNoDataEnabled;
+    bool IsRestore;
+
+    TVector<TVPutInfo> SendVPuts;
+
+private:
+    TMaybe<TGroupMock> Group;
     TIntrusivePtr<TGroupQueues> GroupQueues;
-    TMaybe<TBlobTestSet> BlobSet; 
- 
-    ui64 VPutRequests = 0; 
-    ui64 VPutResponses = 0; 
-    ui64 VMultiPutRequests = 0; 
-    ui64 VMultiPutResponses = 0; 
-    ui64 RequestIndex = 0; 
-    ui64 ResponseIndex = 0; 
- 
-public: 
-    TTestWipedAllOkStep(ui32 groupId, TErasureType::EErasureSpecies erasureSpecies, ui32 domainCount, 
-            const TVector<ui64> &queryCounts, bool isVerboseNoDataEnabled, bool isRestore) 
-        : GroupId(groupId) 
-        , ErasureSpecies(erasureSpecies) 
-        , DomainCount(domainCount) 
-        , QueryCounts(queryCounts) 
-        , MaxQueryCount(*MaxElement(QueryCounts.begin(), QueryCounts.end())) 
-        , IsVerboseNoDataEnabled(isVerboseNoDataEnabled) 
-        , IsRestore(isRestore) 
-    { 
-    } 
- 
-    void SetGenerateBlobsMode(ui64 generateBlobsMode) { 
-        GenerateBlobsMode = generateBlobsMode; 
-    } 
- 
-    void SetBlobs(const TVector<TBlobTestSet::TBlob> &blobs) { 
-        Blobs = &blobs; 
-    } 
- 
-    void AddWipedVDisk(ui64 idx, ui64 error) { 
-        switch (error) { 
-        case 0: 
-            Group->Wipe(idx); 
-            break; 
-        case 1: 
-            Group->SetError(idx, NKikimrProto::ERROR); 
-            break; 
-        case 2: 
-            Group->SetError(idx, NKikimrProto::CORRUPTED); 
-            break; 
-        case 3: 
-            Group->SetError(idx, NKikimrProto::VDISK_ERROR_STATE); 
-            break; 
-        case 4: 
-            Group->SetError(idx, NKikimrProto::NOT_YET); 
-            break; 
-        } 
-    } 
- 
-    void Run(bool useVMultiPut) { 
-        for (ui64 qci = 0; qci < QueryCounts.size(); ++qci) { 
-            ui64 queryCount = QueryCounts[qci]; 
-            for (ui64 bci = 0; bci < QueryCounts.size(); ++bci) { 
-                ui64 blobCount = QueryCounts[bci]; 
-                if (useVMultiPut) { 
-                    SubStep<TVPEK_VMULTIPUT>(queryCount, blobCount); 
-                } else { 
-                    SubStep<TVPEK_VPUT>(queryCount, blobCount); 
-                } 
-            } 
-        } 
-    } 
- 
-    void Init() { 
-        SendVPuts.clear(); 
-        Group.Clear(); 
-        Group.ConstructInPlace(GroupId, ErasureSpecies, DomainCount, 1); 
+    TMaybe<TBlobTestSet> BlobSet;
+
+    ui64 VPutRequests = 0;
+    ui64 VPutResponses = 0;
+    ui64 VMultiPutRequests = 0;
+    ui64 VMultiPutResponses = 0;
+    ui64 RequestIndex = 0;
+    ui64 ResponseIndex = 0;
+
+public:
+    TTestWipedAllOkStep(ui32 groupId, TErasureType::EErasureSpecies erasureSpecies, ui32 domainCount,
+            const TVector<ui64> &queryCounts, bool isVerboseNoDataEnabled, bool isRestore)
+        : GroupId(groupId)
+        , ErasureSpecies(erasureSpecies)
+        , DomainCount(domainCount)
+        , QueryCounts(queryCounts)
+        , MaxQueryCount(*MaxElement(QueryCounts.begin(), QueryCounts.end()))
+        , IsVerboseNoDataEnabled(isVerboseNoDataEnabled)
+        , IsRestore(isRestore)
+    {
+    }
+
+    void SetGenerateBlobsMode(ui64 generateBlobsMode) {
+        GenerateBlobsMode = generateBlobsMode;
+    }
+
+    void SetBlobs(const TVector<TBlobTestSet::TBlob> &blobs) {
+        Blobs = &blobs;
+    }
+
+    void AddWipedVDisk(ui64 idx, ui64 error) {
+        switch (error) {
+        case 0:
+            Group->Wipe(idx);
+            break;
+        case 1:
+            Group->SetError(idx, NKikimrProto::ERROR);
+            break;
+        case 2:
+            Group->SetError(idx, NKikimrProto::CORRUPTED);
+            break;
+        case 3:
+            Group->SetError(idx, NKikimrProto::VDISK_ERROR_STATE);
+            break;
+        case 4:
+            Group->SetError(idx, NKikimrProto::NOT_YET);
+            break;
+        }
+    }
+
+    void Run(bool useVMultiPut) {
+        for (ui64 qci = 0; qci < QueryCounts.size(); ++qci) {
+            ui64 queryCount = QueryCounts[qci];
+            for (ui64 bci = 0; bci < QueryCounts.size(); ++bci) {
+                ui64 blobCount = QueryCounts[bci];
+                if (useVMultiPut) {
+                    SubStep<TVPEK_VMULTIPUT>(queryCount, blobCount);
+                } else {
+                    SubStep<TVPEK_VPUT>(queryCount, blobCount);
+                }
+            }
+        }
+    }
+
+    void Init() {
+        SendVPuts.clear();
+        Group.Clear();
+        Group.ConstructInPlace(GroupId, ErasureSpecies, DomainCount, 1);
         GroupQueues = Group->MakeGroupQueues();
-        BlobSet.Clear(); 
-        BlobSet.ConstructInPlace(); 
-        if (Blobs) { 
-            BlobSet->AddBlobs(*Blobs); 
-        } else { 
-            BlobSet->GenerateSet(GenerateBlobsMode, MaxQueryCount); 
-        } 
-        Group->PutBlobSet(*BlobSet); 
-    } 
- 
-private: 
-    void ClearCounters() { 
-        VPutRequests = 0; 
-        VPutResponses = 0; 
-        VMultiPutRequests = 0; 
-        VMultiPutResponses = 0; 
-        RequestIndex = 0; 
-        ResponseIndex = 0; 
-    } 
- 
-    void AssertCounters(TGetImpl &getImpl) { 
-        UNIT_ASSERT_C(VPutResponses == getImpl.GetVPutResponses() 
-                && VPutRequests == getImpl.GetVPutRequests() 
-                && VMultiPutResponses == getImpl.GetVMultiPutResponses() 
-                && VMultiPutRequests == getImpl.GetVMultiPutRequests() 
-                && RequestIndex == getImpl.GetRequestIndex() 
-                && ResponseIndex == getImpl.GetResponseIndex(), 
-                "Not equal expected VPutRequest and VPutResponse with given" 
-                << " VPutRequests# " << VPutRequests 
-                << " VPutResponses# " << VPutResponses 
-                << " getImpl.VPutRequests# " << getImpl.GetVPutRequests() 
-                << " getImpl.VPutResponses# " << getImpl.GetVPutResponses() 
-                << " VMultiPutRequests# " << VMultiPutRequests 
-                << " VMultiPutResponses# " << VMultiPutResponses 
-                << " getImpl.VMultiPutRequests# " << getImpl.GetVMultiPutRequests() 
-                << " getImpl.VMultiPutResponses# " << getImpl.GetVMultiPutResponses() 
-                << " RequestIndex# " << RequestIndex 
-                << " ResponseIndex# " << ResponseIndex 
-                << " getImpl.RequestIndex# " << getImpl.GetRequestIndex() 
-                << " getImpl.ResponseIndex# " << getImpl.GetResponseIndex()); 
-    } 
- 
-    void ProcessVPuts(TLogContext &logCtx, TGetImpl &getImpl, 
+        BlobSet.Clear();
+        BlobSet.ConstructInPlace();
+        if (Blobs) {
+            BlobSet->AddBlobs(*Blobs);
+        } else {
+            BlobSet->GenerateSet(GenerateBlobsMode, MaxQueryCount);
+        }
+        Group->PutBlobSet(*BlobSet);
+    }
+
+private:
+    void ClearCounters() {
+        VPutRequests = 0;
+        VPutResponses = 0;
+        VMultiPutRequests = 0;
+        VMultiPutResponses = 0;
+        RequestIndex = 0;
+        ResponseIndex = 0;
+    }
+
+    void AssertCounters(TGetImpl &getImpl) {
+        UNIT_ASSERT_C(VPutResponses == getImpl.GetVPutResponses()
+                && VPutRequests == getImpl.GetVPutRequests()
+                && VMultiPutResponses == getImpl.GetVMultiPutResponses()
+                && VMultiPutRequests == getImpl.GetVMultiPutRequests()
+                && RequestIndex == getImpl.GetRequestIndex()
+                && ResponseIndex == getImpl.GetResponseIndex(),
+                "Not equal expected VPutRequest and VPutResponse with given"
+                << " VPutRequests# " << VPutRequests
+                << " VPutResponses# " << VPutResponses
+                << " getImpl.VPutRequests# " << getImpl.GetVPutRequests()
+                << " getImpl.VPutResponses# " << getImpl.GetVPutResponses()
+                << " VMultiPutRequests# " << VMultiPutRequests
+                << " VMultiPutResponses# " << VMultiPutResponses
+                << " getImpl.VMultiPutRequests# " << getImpl.GetVMultiPutRequests()
+                << " getImpl.VMultiPutResponses# " << getImpl.GetVMultiPutResponses()
+                << " RequestIndex# " << RequestIndex
+                << " ResponseIndex# " << ResponseIndex
+                << " getImpl.RequestIndex# " << getImpl.GetRequestIndex()
+                << " getImpl.ResponseIndex# " << getImpl.GetResponseIndex());
+    }
+
+    void ProcessVPuts(TLogContext &logCtx, TGetImpl &getImpl,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &vGets, TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> &vPuts,
-            TAutoPtr<TEvBlobStorage::TEvGetResult> &getResult) { 
-        for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) { 
-            auto &putRequest = vPuts[vPutIdx]->Record; 
-            Y_VERIFY(putRequest.HasCookie()); 
-            auto vdisk = VDiskIDFromVDiskID(putRequest.GetVDiskID()); 
-            auto blobId = LogoBlobIDFromLogoBlobID(putRequest.GetBlobID()); 
-            TBlobCookie cookie(putRequest.GetCookie()); 
-            SendVPuts.push_back({vdisk, blobId, cookie.GetBlobIdx()}); 
-            TEvBlobStorage::TEvVPutResult vPutResult; 
+            TAutoPtr<TEvBlobStorage::TEvGetResult> &getResult) {
+        for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) {
+            auto &putRequest = vPuts[vPutIdx]->Record;
+            Y_VERIFY(putRequest.HasCookie());
+            auto vdisk = VDiskIDFromVDiskID(putRequest.GetVDiskID());
+            auto blobId = LogoBlobIDFromLogoBlobID(putRequest.GetBlobID());
+            TBlobCookie cookie(putRequest.GetCookie());
+            SendVPuts.push_back({vdisk, blobId, cookie.GetBlobIdx()});
+            TEvBlobStorage::TEvVPutResult vPutResult;
             vPutResult.MakeError(NKikimrProto::OK, TString(), putRequest);
- 
+
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> nextVPuts;
-            getImpl.OnVPutResult(logCtx, vPutResult, nextVGets, nextVPuts, getResult); 
-            VPutResponses++; 
-            RequestIndex += nextVGets.size(); 
-            VPutRequests += nextVPuts.size(); 
-            AssertCounters(getImpl); 
- 
+            getImpl.OnVPutResult(logCtx, vPutResult, nextVGets, nextVPuts, getResult);
+            VPutResponses++;
+            RequestIndex += nextVGets.size();
+            VPutRequests += nextVPuts.size();
+            AssertCounters(getImpl);
+
             std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
             std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-            if (getResult) { 
-                break; 
-            } 
-        } 
-        vPuts.clear(); 
-    } 
- 
-    void ProcessVPuts(TLogContext &logCtx, TGetImpl &getImpl, 
+            if (getResult) {
+                break;
+            }
+        }
+        vPuts.clear();
+    }
+
+    void ProcessVPuts(TLogContext &logCtx, TGetImpl &getImpl,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> &vGets, TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> &vPuts,
-            TAutoPtr<TEvBlobStorage::TEvGetResult> &getResult) { 
-        for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) { 
-            auto &multiPutRequest = vPuts[vPutIdx]->Record; 
-            Y_VERIFY(multiPutRequest.HasCookie()); 
- 
-            auto vdisk = VDiskIDFromVDiskID(multiPutRequest.GetVDiskID()); 
-            UNIT_ASSERT(multiPutRequest.ItemsSize() <= MaxBatchedPutRequests); 
-            ui64 sendBytes = 0; 
-            for (auto &item : multiPutRequest.GetItems()) { 
-                Y_VERIFY(item.HasCookie()); 
-                TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-                TString buffer = item.GetBuffer(); 
-                sendBytes += buffer.size(); 
-                TBlobCookie cookie(item.GetCookie()); 
-                SendVPuts.push_back({vdisk, blobId, cookie.GetBlobIdx()}); 
-            } 
-            UNIT_ASSERT(sendBytes <= MaxBatchedPutSize); 
- 
-            TEvBlobStorage::TEvVMultiPutResult vMultiPutResult; 
+            TAutoPtr<TEvBlobStorage::TEvGetResult> &getResult) {
+        for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) {
+            auto &multiPutRequest = vPuts[vPutIdx]->Record;
+            Y_VERIFY(multiPutRequest.HasCookie());
+
+            auto vdisk = VDiskIDFromVDiskID(multiPutRequest.GetVDiskID());
+            UNIT_ASSERT(multiPutRequest.ItemsSize() <= MaxBatchedPutRequests);
+            ui64 sendBytes = 0;
+            for (auto &item : multiPutRequest.GetItems()) {
+                Y_VERIFY(item.HasCookie());
+                TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+                TString buffer = item.GetBuffer();
+                sendBytes += buffer.size();
+                TBlobCookie cookie(item.GetCookie());
+                SendVPuts.push_back({vdisk, blobId, cookie.GetBlobIdx()});
+            }
+            UNIT_ASSERT(sendBytes <= MaxBatchedPutSize);
+
+            TEvBlobStorage::TEvVMultiPutResult vMultiPutResult;
             vMultiPutResult.MakeError(NKikimrProto::OK, TString(), multiPutRequest);
- 
+
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> nextVPuts;
-            getImpl.OnVPutResult(logCtx, vMultiPutResult, 
-                                nextVGets, nextVPuts, getResult); 
-            VMultiPutResponses++; 
-            RequestIndex += nextVGets.size(); 
-            VMultiPutRequests += nextVPuts.size(); 
-            AssertCounters(getImpl); 
- 
+            getImpl.OnVPutResult(logCtx, vMultiPutResult,
+                                nextVGets, nextVPuts, getResult);
+            VMultiPutResponses++;
+            RequestIndex += nextVGets.size();
+            VMultiPutRequests += nextVPuts.size();
+            AssertCounters(getImpl);
+
             std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
             std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-            if (getResult) { 
-                break; 
-            } 
-        } 
-        vPuts.clear(); 
-    } 
- 
-    template <ETVPutEventKind TVPutEventKind> 
-    void SubStep(ui64 queryCount, ui64 blobCount) { 
-        using TVPutEvent = std::conditional_t<TVPutEventKind == TVPEK_VPUT, TEvBlobStorage::TEvVPut, 
-                TEvBlobStorage::TEvVMultiPut>; 
-        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesA( 
-                new TEvBlobStorage::TEvGet::TQuery[MaxQueryCount]); 
-        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesB( 
-                new TEvBlobStorage::TEvGet::TQuery[MaxQueryCount]); 
-        for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) { 
-            TEvBlobStorage::TEvGet::TQuery &q = queriesA[queryIdx]; 
-            q.Id = BlobSet->Get(queryIdx % blobCount).Id; 
-            q.Shift = (queryIdx * 177) % q.Id.BlobSize(); 
-            q.Size = Min((ui64)70, (ui64)q.Id.BlobSize() - (ui64)q.Shift); 
-            queriesB[queryIdx] = q; 
-        } 
-        TEvBlobStorage::TEvGet ev(queriesA, queryCount, TInstant::Max(), 
-                NKikimrBlobStorage::EGetHandleClass::FastRead, IsRestore, false); 
-        ev.IsVerboseNoDataEnabled = IsVerboseNoDataEnabled; 
+            if (getResult) {
+                break;
+            }
+        }
+        vPuts.clear();
+    }
+
+    template <ETVPutEventKind TVPutEventKind>
+    void SubStep(ui64 queryCount, ui64 blobCount) {
+        using TVPutEvent = std::conditional_t<TVPutEventKind == TVPEK_VPUT, TEvBlobStorage::TEvVPut,
+                TEvBlobStorage::TEvVMultiPut>;
+        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesA(
+                new TEvBlobStorage::TEvGet::TQuery[MaxQueryCount]);
+        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesB(
+                new TEvBlobStorage::TEvGet::TQuery[MaxQueryCount]);
+        for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) {
+            TEvBlobStorage::TEvGet::TQuery &q = queriesA[queryIdx];
+            q.Id = BlobSet->Get(queryIdx % blobCount).Id;
+            q.Shift = (queryIdx * 177) % q.Id.BlobSize();
+            q.Size = Min((ui64)70, (ui64)q.Id.BlobSize() - (ui64)q.Shift);
+            queriesB[queryIdx] = q;
+        }
+        TEvBlobStorage::TEvGet ev(queriesA, queryCount, TInstant::Max(),
+                NKikimrBlobStorage::EGetHandleClass::FastRead, IsRestore, false);
+        ev.IsVerboseNoDataEnabled = IsVerboseNoDataEnabled;
         TGetImpl getImpl(Group->GetInfo(), GroupQueues, &ev, nullptr);
-        ClearCounters(); 
+        ClearCounters();
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> vGets;
         TDeque<std::unique_ptr<TVPutEvent>> vPuts;
-        TLogContext logCtx(NKikimrServices::BS_PROXY_GET, false); 
-        logCtx.LogAcc.IsLogEnabled = false; 
-        getImpl.GenerateInitialRequests(logCtx, vGets); 
-        RequestIndex += vGets.size(); 
-        AssertCounters(getImpl); 
- 
-        TAutoPtr<TEvBlobStorage::TEvGetResult> getResult; 
-        for (ui64 vGetIdx = 0; vGetIdx < vGets.size(); ++vGetIdx) { 
- 
-            bool isLast = (vGetIdx == vGets.size() - 1); 
-            auto &request = vGets[vGetIdx]->Record; 
-            Y_VERIFY(request.HasCookie()); 
-            //ui64 messageCookie = request->Record.GetCookie(); 
-            TEvBlobStorage::TEvVGetResult vGetResult; 
-            Group->OnVGet(*vGets[vGetIdx], vGetResult); 
- 
-            // TODO: generate result 
+        TLogContext logCtx(NKikimrServices::BS_PROXY_GET, false);
+        logCtx.LogAcc.IsLogEnabled = false;
+        getImpl.GenerateInitialRequests(logCtx, vGets);
+        RequestIndex += vGets.size();
+        AssertCounters(getImpl);
+
+        TAutoPtr<TEvBlobStorage::TEvGetResult> getResult;
+        for (ui64 vGetIdx = 0; vGetIdx < vGets.size(); ++vGetIdx) {
+
+            bool isLast = (vGetIdx == vGets.size() - 1);
+            auto &request = vGets[vGetIdx]->Record;
+            Y_VERIFY(request.HasCookie());
+            //ui64 messageCookie = request->Record.GetCookie();
+            TEvBlobStorage::TEvVGetResult vGetResult;
+            Group->OnVGet(*vGets[vGetIdx], vGetResult);
+
+            // TODO: generate result
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
             TDeque<std::unique_ptr<TVPutEvent>> nextVPuts;
-            getImpl.OnVGetResult(logCtx, vGetResult, nextVGets, nextVPuts, getResult); 
-            ResponseIndex++; 
-            RequestIndex += nextVGets.size(); 
-            if constexpr (TVPutEventKind == TVPEK_VPUT) { 
-                VPutRequests += nextVPuts.size(); 
-            } else { 
-                VMultiPutRequests += nextVPuts.size(); 
-            } 
-            AssertCounters(getImpl); 
- 
+            getImpl.OnVGetResult(logCtx, vGetResult, nextVGets, nextVPuts, getResult);
+            ResponseIndex++;
+            RequestIndex += nextVGets.size();
+            if constexpr (TVPutEventKind == TVPEK_VPUT) {
+                VPutRequests += nextVPuts.size();
+            } else {
+                VMultiPutRequests += nextVPuts.size();
+            }
+            AssertCounters(getImpl);
+
             std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
-            if (IsRestore) { 
+            if (IsRestore) {
                 std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-            } else { 
-                UNIT_ASSERT_VALUES_EQUAL(nextVPuts.size(), 0); 
-            } 
-            if (getResult) { 
-                break; 
-            } 
-            ProcessVPuts(logCtx, getImpl, vGets, vPuts, getResult); 
-            if (getResult) { 
-                break; 
-            } 
-            if (!isLast) { 
-                UNIT_ASSERT_VALUES_EQUAL(getResult, nullptr); 
-            } 
-        } 
-        UNIT_ASSERT(getResult); 
-        UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, queryCount); 
-        // TODO: check the data vs queriesB 
-        for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) { 
-            TEvBlobStorage::TEvGetResult::TResponse &a = getResult->Responses[queryIdx]; 
-            TEvBlobStorage::TEvGet::TQuery &q = queriesB[queryIdx]; 
-            UNIT_ASSERT_VALUES_EQUAL(q.Id, a.Id); 
-            UNIT_ASSERT_VALUES_EQUAL(a.Status, NKikimrProto::OK); 
-            UNIT_ASSERT_VALUES_EQUAL(q.Shift, a.Shift); 
-            UNIT_ASSERT_VALUES_EQUAL(q.Size, a.RequestedSize); 
-            BlobSet->Check(queryIdx % blobCount, q.Id, q.Shift, q.Size, a.Buffer); 
-        } 
-    } 
-}; 
- 
+            } else {
+                UNIT_ASSERT_VALUES_EQUAL(nextVPuts.size(), 0);
+            }
+            if (getResult) {
+                break;
+            }
+            ProcessVPuts(logCtx, getImpl, vGets, vPuts, getResult);
+            if (getResult) {
+                break;
+            }
+            if (!isLast) {
+                UNIT_ASSERT_VALUES_EQUAL(getResult, nullptr);
+            }
+        }
+        UNIT_ASSERT(getResult);
+        UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, queryCount);
+        // TODO: check the data vs queriesB
+        for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) {
+            TEvBlobStorage::TEvGetResult::TResponse &a = getResult->Responses[queryIdx];
+            TEvBlobStorage::TEvGet::TQuery &q = queriesB[queryIdx];
+            UNIT_ASSERT_VALUES_EQUAL(q.Id, a.Id);
+            UNIT_ASSERT_VALUES_EQUAL(a.Status, NKikimrProto::OK);
+            UNIT_ASSERT_VALUES_EQUAL(q.Shift, a.Shift);
+            UNIT_ASSERT_VALUES_EQUAL(q.Size, a.RequestedSize);
+            BlobSet->Check(queryIdx % blobCount, q.Id, q.Shift, q.Size, a.Buffer);
+        }
+    }
+};
+
 void TestIntervalsWipedAllOk(TErasureType::EErasureSpecies erasureSpecies, bool isVerboseNoDataEnabled = false) {
     TActorSystemStub actorSystemStub;
 
@@ -463,113 +463,113 @@ void TestIntervalsWipedAllOk(TErasureType::EErasureSpecies erasureSpecies, bool
     TBlobStorageGroupType groupType(erasureSpecies);
     const ui32 domainCount = groupType.BlobSubgroupSize();
 
-    TVector<ui64> queryCounts = {1, 2, 3, 13, 34}; 
+    TVector<ui64> queryCounts = {1, 2, 3, 13, 34};
 
-    for (bool isRestore : {false, true}) { 
-        for (ui32 generateMode = 0; generateMode < 2; ++generateMode) { 
+    for (bool isRestore : {false, true}) {
+        for (ui32 generateMode = 0; generateMode < 2; ++generateMode) {
             for (ui64 wiped1 = 0; wiped1 < domainCount; ++wiped1) {
                 for (ui64 wiped2 = 0; wiped2 <= wiped1; ++wiped2) {
                     ui64 maxErrorMask = (wiped1 == wiped2 ? 4 : 24);
                     for (ui64 errorMask = 0; errorMask <= maxErrorMask; ++errorMask) {
                         ui64 error1 = errorMask % 5;
                         ui64 error2 = errorMask / 5;
-                        TTestWipedAllOkStep testStep( 
-                                groupId, erasureSpecies, domainCount, queryCounts, 
-                                isVerboseNoDataEnabled, isRestore); 
-                        testStep.SetGenerateBlobsMode(generateMode); 
-                        testStep.Init(); 
-                        testStep.AddWipedVDisk(wiped1, error1); 
-                        testStep.AddWipedVDisk(wiped2, error2); 
-                        testStep.Run(false); 
-                    } 
-                } 
-            } 
-        } 
-    } 
-} 
-
-void TestIntervalsWipedAllOkVMultiPut(TErasureType::EErasureSpecies erasureSpecies, bool isVerboseNoDataEnabled = false) { 
-    TActorSystemStub actorSystemStub; 
- 
-    const ui32 groupId = 0; 
-    TBlobStorageGroupType groupType(erasureSpecies); 
+                        TTestWipedAllOkStep testStep(
+                                groupId, erasureSpecies, domainCount, queryCounts,
+                                isVerboseNoDataEnabled, isRestore);
+                        testStep.SetGenerateBlobsMode(generateMode);
+                        testStep.Init();
+                        testStep.AddWipedVDisk(wiped1, error1);
+                        testStep.AddWipedVDisk(wiped2, error2);
+                        testStep.Run(false);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void TestIntervalsWipedAllOkVMultiPut(TErasureType::EErasureSpecies erasureSpecies, bool isVerboseNoDataEnabled = false) {
+    TActorSystemStub actorSystemStub;
+
+    const ui32 groupId = 0;
+    TBlobStorageGroupType groupType(erasureSpecies);
     const ui32 domainCount = groupType.BlobSubgroupSize();
- 
-    TVector<ui64> queryCounts = {1, 2, 3, 13, 34, 55}; 
- 
-    for (bool isRestore : {false, true}) { 
-        for (ui32 generateMode = 0; generateMode < 2; ++generateMode) { 
-            for (ui64 wiped1 = 0; wiped1 < domainCount; ++wiped1) { 
-                for (ui64 wiped2 = 0; wiped2 <= wiped1; ++wiped2) { 
-                    ui64 maxErrorMask = (wiped1 == wiped2 ? 4 : 24); 
-                    for (ui64 errorMask = 0; errorMask <= maxErrorMask; ++errorMask) { 
-                        ui64 error1 = errorMask % 5; 
-                        ui64 error2 = errorMask / 5; 
-                        TTestWipedAllOkStep testStep( 
-                                groupId, erasureSpecies, domainCount, queryCounts, 
-                                isVerboseNoDataEnabled, isRestore); 
-                        testStep.SetGenerateBlobsMode(generateMode); 
-                        testStep.Init(); 
-                        testStep.AddWipedVDisk(wiped1, error1); 
-                        testStep.AddWipedVDisk(wiped2, error2); 
-                        testStep.Run(true); 
-                    } 
-                } 
-            } 
-        } 
-    } 
-} 
- 
-void TestIntervalsWipedAllOkComparisonVMultiPutAndVPut(TErasureType::EErasureSpecies erasureSpecies, 
-        bool isVerboseNoDataEnabled = false) { 
-    TActorSystemStub actorSystemStub; 
-
-    const ui32 groupId = 0; 
-    TBlobStorageGroupType groupType(erasureSpecies); 
+
+    TVector<ui64> queryCounts = {1, 2, 3, 13, 34, 55};
+
+    for (bool isRestore : {false, true}) {
+        for (ui32 generateMode = 0; generateMode < 2; ++generateMode) {
+            for (ui64 wiped1 = 0; wiped1 < domainCount; ++wiped1) {
+                for (ui64 wiped2 = 0; wiped2 <= wiped1; ++wiped2) {
+                    ui64 maxErrorMask = (wiped1 == wiped2 ? 4 : 24);
+                    for (ui64 errorMask = 0; errorMask <= maxErrorMask; ++errorMask) {
+                        ui64 error1 = errorMask % 5;
+                        ui64 error2 = errorMask / 5;
+                        TTestWipedAllOkStep testStep(
+                                groupId, erasureSpecies, domainCount, queryCounts,
+                                isVerboseNoDataEnabled, isRestore);
+                        testStep.SetGenerateBlobsMode(generateMode);
+                        testStep.Init();
+                        testStep.AddWipedVDisk(wiped1, error1);
+                        testStep.AddWipedVDisk(wiped2, error2);
+                        testStep.Run(true);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void TestIntervalsWipedAllOkComparisonVMultiPutAndVPut(TErasureType::EErasureSpecies erasureSpecies,
+        bool isVerboseNoDataEnabled = false) {
+    TActorSystemStub actorSystemStub;
+
+    const ui32 groupId = 0;
+    TBlobStorageGroupType groupType(erasureSpecies);
     const ui32 domainCount = groupType.BlobSubgroupSize();
 
-    const TVector<ui64> queryCounts = {1, 2}; 
-
-    TVector<TLogoBlobID> blobIDs = { 
-        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576), 
-        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288) 
-    }; 
-
-    TVector<TBlobTestSet::TBlob> blobs; 
-    for (const auto& id : blobIDs) { 
-        TStringBuilder builder; 
-        for (size_t i = 0; i < id.BlobSize(); ++i) { 
-            builder << 'a'; 
-        } 
-        blobs.emplace_back(id, builder); 
-    } 
- 
-    for (ui64 wiped1 = 0; wiped1 < domainCount; ++wiped1) { 
-        for (ui64 wiped2 = 0; wiped2 <= wiped1; ++wiped2) { 
-            ui64 maxErrorMask = (wiped1 == wiped2 ? 4 : 24); 
-            for (ui64 errorMask = 0; errorMask <= maxErrorMask; ++errorMask) { 
-                ui64 error1 = errorMask % 5; 
-                ui64 error2 = errorMask / 5; 
-                TTestWipedAllOkStep testStep( 
-                        groupId, erasureSpecies, domainCount, queryCounts, 
-                        isVerboseNoDataEnabled, true); 
-                testStep.SetBlobs(blobs); 
- 
-                testStep.Init(); 
-                testStep.AddWipedVDisk(wiped1, error1); 
-                testStep.AddWipedVDisk(wiped2, error2); 
-                testStep.Run(false); 
-                auto sendVPuts = std::move(testStep.SendVPuts); 
- 
-                testStep.Init(); 
-                testStep.AddWipedVDisk(wiped1, error1); 
-                testStep.AddWipedVDisk(wiped2, error2); 
-                testStep.Run(true); 
-                auto sendVMultiPuts = std::move(testStep.SendVPuts); 
- 
-                Sort(sendVPuts.begin(), sendVPuts.end()); 
-                Sort(sendVMultiPuts.begin(), sendVMultiPuts.end()); 
-                UNIT_ASSERT(sendVPuts == sendVMultiPuts); 
+    const TVector<ui64> queryCounts = {1, 2};
+
+    TVector<TLogoBlobID> blobIDs = {
+        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576),
+        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288)
+    };
+
+    TVector<TBlobTestSet::TBlob> blobs;
+    for (const auto& id : blobIDs) {
+        TStringBuilder builder;
+        for (size_t i = 0; i < id.BlobSize(); ++i) {
+            builder << 'a';
+        }
+        blobs.emplace_back(id, builder);
+    }
+
+    for (ui64 wiped1 = 0; wiped1 < domainCount; ++wiped1) {
+        for (ui64 wiped2 = 0; wiped2 <= wiped1; ++wiped2) {
+            ui64 maxErrorMask = (wiped1 == wiped2 ? 4 : 24);
+            for (ui64 errorMask = 0; errorMask <= maxErrorMask; ++errorMask) {
+                ui64 error1 = errorMask % 5;
+                ui64 error2 = errorMask / 5;
+                TTestWipedAllOkStep testStep(
+                        groupId, erasureSpecies, domainCount, queryCounts,
+                        isVerboseNoDataEnabled, true);
+                testStep.SetBlobs(blobs);
+
+                testStep.Init();
+                testStep.AddWipedVDisk(wiped1, error1);
+                testStep.AddWipedVDisk(wiped2, error2);
+                testStep.Run(false);
+                auto sendVPuts = std::move(testStep.SendVPuts);
+
+                testStep.Init();
+                testStep.AddWipedVDisk(wiped1, error1);
+                testStep.AddWipedVDisk(wiped2, error2);
+                testStep.Run(true);
+                auto sendVMultiPuts = std::move(testStep.SendVPuts);
+
+                Sort(sendVPuts.begin(), sendVPuts.end());
+                Sort(sendVMultiPuts.begin(), sendVMultiPuts.end());
+                UNIT_ASSERT(sendVPuts == sendVMultiPuts);
             }
         }
     }
@@ -592,23 +592,23 @@ public:
         Group.PutBlobSet(BlobSet);
     }
 
-    void SetBlobSet(const TVector<TBlobTestSet::TBlob>& blobs) { 
-        BlobSet.AddBlobs(blobs); 
-        Group.PutBlobSet(BlobSet); 
-    } 
- 
+    void SetBlobSet(const TVector<TBlobTestSet::TBlob>& blobs) {
+        BlobSet.AddBlobs(blobs);
+        Group.PutBlobSet(BlobSet);
+    }
+
     void SetError(ui32 domainIdx, NKikimrProto::EReplyStatus status) {
         Group.SetError(domainIdx, status);
     }
 
-    void SetPredictedDelayNs(ui32 domainIdx, ui64 predictedDelayNs) { 
-        Group.SetPredictedDelayNs(domainIdx, predictedDelayNs); 
-    } 
- 
+    void SetPredictedDelayNs(ui32 domainIdx, ui64 predictedDelayNs) {
+        Group.SetPredictedDelayNs(domainIdx, predictedDelayNs);
+    }
+
     TIntrusivePtr<TGroupQueues> GetSessionsState() const {
         return GroupQueues;
-    } 
- 
+    }
+
     TAutoPtr<TEvBlobStorage::TEvGetResult> Simulate(TEvBlobStorage::TEvGet *ev) {
         TAutoPtr<TEvBlobStorage::TEvGetResult> getResult;
 
@@ -669,291 +669,291 @@ public:
 
 };
 
-Y_UNIT_TEST(TestBlock42VGetCountWithErasure) { 
-    bool isVerboseNoDataEnabled = false; 
-    TErasureType::EErasureSpecies erasureSpecies = TErasureType::Erasure4Plus2Block; 
-    TActorSystemStub actorSystemStub; 
- 
-    TVector<TLogoBlobID> blobIDs = { 
-        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576), 
-    }; 
- 
-    TVector<TBlobTestSet::TBlob> blobs; 
-    for (const auto& id : blobIDs) { 
-        TStringBuilder builder; 
-        for (size_t i = 0; i < id.BlobSize(); ++i) { 
-            builder << 'a'; 
-        } 
-        blobs.emplace_back(id, builder); 
-    } 
- 
-    const ui32 groupId = 0; 
-    TBlobStorageGroupType groupType(erasureSpecies); 
-    const ui32 domainCount = groupType.BlobSubgroupSize(); 
- 
-    const ui64 queryCount = 1; 
- 
-    const ui32 isRestore = 0; 
- 
-    TGroupMock group(groupId, erasureSpecies, domainCount, 1); 
+Y_UNIT_TEST(TestBlock42VGetCountWithErasure) {
+    bool isVerboseNoDataEnabled = false;
+    TErasureType::EErasureSpecies erasureSpecies = TErasureType::Erasure4Plus2Block;
+    TActorSystemStub actorSystemStub;
+
+    TVector<TLogoBlobID> blobIDs = {
+        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576),
+    };
+
+    TVector<TBlobTestSet::TBlob> blobs;
+    for (const auto& id : blobIDs) {
+        TStringBuilder builder;
+        for (size_t i = 0; i < id.BlobSize(); ++i) {
+            builder << 'a';
+        }
+        blobs.emplace_back(id, builder);
+    }
+
+    const ui32 groupId = 0;
+    TBlobStorageGroupType groupType(erasureSpecies);
+    const ui32 domainCount = groupType.BlobSubgroupSize();
+
+    const ui64 queryCount = 1;
+
+    const ui32 isRestore = 0;
+
+    TGroupMock group(groupId, erasureSpecies, domainCount, 1);
     TIntrusivePtr<TGroupQueues> groupQueues = group.MakeGroupQueues();
-    TBlobTestSet blobSet; 
-    blobSet.AddBlobs(blobs); 
-    group.PutBlobSet(blobSet); 
- 
-    for (ui32 idx = 0; idx < domainCount; ++idx) { 
-        group.SetPredictedDelayNs(idx, 1); 
-    } 
-    group.SetPredictedDelayNs(7, 10); 
- 
-    group.SetNotYetBlob(0, TLogoBlobID(blobIDs[0], 1)); 
- 
-    ui64 blobCount = queryCount; 
-    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesA( 
-            new TEvBlobStorage::TEvGet::TQuery[queryCount]); 
-    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesB( 
-            new TEvBlobStorage::TEvGet::TQuery[queryCount]); 
-    for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) { 
-        TEvBlobStorage::TEvGet::TQuery &q = queriesA[queryIdx]; 
-        q.Id = blobSet.Get(queryIdx % blobCount).Id; 
-        q.Shift = 0; 
-        q.Size = (ui64)q.Id.BlobSize(); 
-        queriesB[queryIdx] = q; 
-    } 
-    TEvBlobStorage::TEvGet ev(queriesA, queryCount, TInstant::Max(), 
-            NKikimrBlobStorage::EGetHandleClass::FastRead, isRestore, false); 
-    ev.IsVerboseNoDataEnabled = isVerboseNoDataEnabled; 
- 
-    TAutoPtr<TEvBlobStorage::TEvGetResult> getResult; 
- 
+    TBlobTestSet blobSet;
+    blobSet.AddBlobs(blobs);
+    group.PutBlobSet(blobSet);
+
+    for (ui32 idx = 0; idx < domainCount; ++idx) {
+        group.SetPredictedDelayNs(idx, 1);
+    }
+    group.SetPredictedDelayNs(7, 10);
+
+    group.SetNotYetBlob(0, TLogoBlobID(blobIDs[0], 1));
+
+    ui64 blobCount = queryCount;
+    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesA(
+            new TEvBlobStorage::TEvGet::TQuery[queryCount]);
+    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesB(
+            new TEvBlobStorage::TEvGet::TQuery[queryCount]);
+    for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) {
+        TEvBlobStorage::TEvGet::TQuery &q = queriesA[queryIdx];
+        q.Id = blobSet.Get(queryIdx % blobCount).Id;
+        q.Shift = 0;
+        q.Size = (ui64)q.Id.BlobSize();
+        queriesB[queryIdx] = q;
+    }
+    TEvBlobStorage::TEvGet ev(queriesA, queryCount, TInstant::Max(),
+            NKikimrBlobStorage::EGetHandleClass::FastRead, isRestore, false);
+    ev.IsVerboseNoDataEnabled = isVerboseNoDataEnabled;
+
+    TAutoPtr<TEvBlobStorage::TEvGetResult> getResult;
+
     TGetImpl getImpl(group.GetInfo(), groupQueues, &ev, nullptr);
     TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> vGets;
     TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-    TLogContext logCtx(NKikimrServices::BS_PROXY_GET, false); 
-    logCtx.LogAcc.IsLogEnabled = false; 
-    getImpl.GenerateInitialRequests(logCtx, vGets); 
- 
-    for (ui64 vGetIdx = 0; vGetIdx < vGets.size(); ++vGetIdx) { 
-        if (vGetIdx == 3) { 
+    TLogContext logCtx(NKikimrServices::BS_PROXY_GET, false);
+    logCtx.LogAcc.IsLogEnabled = false;
+    getImpl.GenerateInitialRequests(logCtx, vGets);
+
+    for (ui64 vGetIdx = 0; vGetIdx < vGets.size(); ++vGetIdx) {
+        if (vGetIdx == 3) {
             vGets.push_back(std::move(vGets[3]));
-            continue; 
-        } 
-        bool isLast = (vGetIdx == vGets.size() - 1); 
-        auto &request = vGets[vGetIdx]->Record; 
- 
-        Y_VERIFY(request.HasCookie()); 
-        TEvBlobStorage::TEvVGetResult vGetResult; 
-        group.OnVGet(*vGets[vGetIdx], vGetResult); 
- 
-        // TODO: generate result 
+            continue;
+        }
+        bool isLast = (vGetIdx == vGets.size() - 1);
+        auto &request = vGets[vGetIdx]->Record;
+
+        Y_VERIFY(request.HasCookie());
+        TEvBlobStorage::TEvVGetResult vGetResult;
+        group.OnVGet(*vGets[vGetIdx], vGetResult);
+
+        // TODO: generate result
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> nextVPuts;
- 
-        getImpl.OnVGetResult(logCtx, vGetResult, nextVGets, nextVPuts, getResult); 
- 
+
+        getImpl.OnVGetResult(logCtx, vGetResult, nextVGets, nextVPuts, getResult);
+
         std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
-        if (ev.MustRestoreFirst) { 
+        if (ev.MustRestoreFirst) {
             std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-        } else { 
-            UNIT_ASSERT_VALUES_EQUAL(nextVPuts.size(), 0); 
-        } 
-        if (getResult) { 
-            break; 
-        } 
-        for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) { 
-            auto &putRequest = vPuts[vPutIdx]->Record; 
-            Y_VERIFY(putRequest.HasCookie()); 
-            TEvBlobStorage::TEvVPutResult vPutResult; 
+        } else {
+            UNIT_ASSERT_VALUES_EQUAL(nextVPuts.size(), 0);
+        }
+        if (getResult) {
+            break;
+        }
+        for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) {
+            auto &putRequest = vPuts[vPutIdx]->Record;
+            Y_VERIFY(putRequest.HasCookie());
+            TEvBlobStorage::TEvVPutResult vPutResult;
             vPutResult.MakeError(NKikimrProto::OK, TString(), putRequest);
- 
+
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> nextVPuts;
-            getImpl.OnVPutResult(logCtx, vPutResult, nextVGets, nextVPuts, getResult); 
+            getImpl.OnVPutResult(logCtx, vPutResult, nextVGets, nextVPuts, getResult);
             std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
             std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-            if (getResult) { 
-                break; 
-            } 
-        } 
-        vPuts.clear(); 
-        if (getResult) { 
-            break; 
-        } 
-        if (!isLast) { 
-            UNIT_ASSERT_VALUES_EQUAL(getResult, nullptr); 
-        } 
-    } 
- 
+            if (getResult) {
+                break;
+            }
+        }
+        vPuts.clear();
+        if (getResult) {
+            break;
+        }
+        if (!isLast) {
+            UNIT_ASSERT_VALUES_EQUAL(getResult, nullptr);
+        }
+    }
+
     UNIT_ASSERT_VALUES_EQUAL(vGets.size(), 8);
- 
-    UNIT_ASSERT(getResult); 
-    UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, queryCount); 
-    // TODO: check the data vs queriesB 
-    for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) { 
-        TEvBlobStorage::TEvGetResult::TResponse &a = getResult->Responses[queryIdx]; 
-        TEvBlobStorage::TEvGet::TQuery &q = queriesB[queryIdx]; 
-        UNIT_ASSERT_VALUES_EQUAL(q.Id, a.Id); 
-        if (a.Status != NKikimrProto::ERROR) { 
-            if (a.Status == NKikimrProto::OK) { 
-                UNIT_ASSERT_VALUES_EQUAL(q.Shift, a.Shift); 
-                UNIT_ASSERT_VALUES_EQUAL(q.Size, a.RequestedSize); 
-                blobSet.Check(queryIdx % blobCount, q.Id, q.Shift, q.Size, a.Buffer); 
-            } else { 
-                TStringStream str; 
-                str << " isRestore# " << isRestore 
-                    << " status# " << a.Status; 
-                UNIT_ASSERT_C(false, str.Str()); 
-            } 
-        } 
-    } // for queryIdx 
- 
-    return; 
-} 
- 
-Y_UNIT_TEST(TestBlock42WipedOneDiskAndErrorDurringGet) { 
-    bool isVerboseNoDataEnabled = false; 
-    TErasureType::EErasureSpecies erasureSpecies = TErasureType::Erasure4Plus2Block; 
-    TActorSystemStub actorSystemStub; 
- 
-    TVector<TLogoBlobID> blobIDs = { 
-        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576), 
-        // TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288) 
-    }; 
- 
-    TVector<TBlobTestSet::TBlob> blobs; 
-    for (const auto& id : blobIDs) { 
-        TStringBuilder builder; 
-        for (size_t i = 0; i < id.BlobSize(); ++i) { 
-            builder << 'a'; 
-        } 
- 
-        blobs.emplace_back(id, builder); 
-    } 
- 
-    const ui32 groupId = 0; 
-    TBlobStorageGroupType groupType(erasureSpecies); 
-    const ui32 domainCount = groupType.BlobSubgroupSize(); 
- 
-    const ui64 queryCount = 1; 
- 
-    const ui32 isRestore = 0; 
- 
-    TGroupMock group(groupId, erasureSpecies, domainCount, 1); 
+
+    UNIT_ASSERT(getResult);
+    UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, queryCount);
+    // TODO: check the data vs queriesB
+    for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) {
+        TEvBlobStorage::TEvGetResult::TResponse &a = getResult->Responses[queryIdx];
+        TEvBlobStorage::TEvGet::TQuery &q = queriesB[queryIdx];
+        UNIT_ASSERT_VALUES_EQUAL(q.Id, a.Id);
+        if (a.Status != NKikimrProto::ERROR) {
+            if (a.Status == NKikimrProto::OK) {
+                UNIT_ASSERT_VALUES_EQUAL(q.Shift, a.Shift);
+                UNIT_ASSERT_VALUES_EQUAL(q.Size, a.RequestedSize);
+                blobSet.Check(queryIdx % blobCount, q.Id, q.Shift, q.Size, a.Buffer);
+            } else {
+                TStringStream str;
+                str << " isRestore# " << isRestore
+                    << " status# " << a.Status;
+                UNIT_ASSERT_C(false, str.Str());
+            }
+        }
+    } // for queryIdx
+
+    return;
+}
+
+Y_UNIT_TEST(TestBlock42WipedOneDiskAndErrorDurringGet) {
+    bool isVerboseNoDataEnabled = false;
+    TErasureType::EErasureSpecies erasureSpecies = TErasureType::Erasure4Plus2Block;
+    TActorSystemStub actorSystemStub;
+
+    TVector<TLogoBlobID> blobIDs = {
+        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576),
+        // TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288)
+    };
+
+    TVector<TBlobTestSet::TBlob> blobs;
+    for (const auto& id : blobIDs) {
+        TStringBuilder builder;
+        for (size_t i = 0; i < id.BlobSize(); ++i) {
+            builder << 'a';
+        }
+
+        blobs.emplace_back(id, builder);
+    }
+
+    const ui32 groupId = 0;
+    TBlobStorageGroupType groupType(erasureSpecies);
+    const ui32 domainCount = groupType.BlobSubgroupSize();
+
+    const ui64 queryCount = 1;
+
+    const ui32 isRestore = 0;
+
+    TGroupMock group(groupId, erasureSpecies, domainCount, 1);
     TIntrusivePtr<TGroupQueues> groupQueues = group.MakeGroupQueues();
-    TBlobTestSet blobSet; 
-    blobSet.AddBlobs(blobs); 
-    group.PutBlobSet(blobSet); 
- 
-    for (ui32 idx = 0; idx < domainCount; ++idx) { 
-        group.SetPredictedDelayNs(idx, 1); 
-    } 
-    group.SetPredictedDelayNs(7, 10); 
- 
-    group.SetNotYetBlob(0, TLogoBlobID(blobIDs[0], 1)); 
- 
-    ui64 blobCount = queryCount; 
-    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesA( 
-            new TEvBlobStorage::TEvGet::TQuery[queryCount]); 
-    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesB( 
-            new TEvBlobStorage::TEvGet::TQuery[queryCount]); 
-    for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) { 
-        TEvBlobStorage::TEvGet::TQuery &q = queriesA[queryIdx]; 
-        q.Id = blobSet.Get(queryIdx % blobCount).Id; 
-        q.Shift = 0; 
-        q.Size = (ui64)q.Id.BlobSize(); 
-        queriesB[queryIdx] = q; 
-    } 
-    TEvBlobStorage::TEvGet ev(queriesA, queryCount, TInstant::Max(), 
-            NKikimrBlobStorage::EGetHandleClass::FastRead, isRestore, false); 
-    ev.IsVerboseNoDataEnabled = isVerboseNoDataEnabled; 
- 
-    TAutoPtr<TEvBlobStorage::TEvGetResult> getResult; 
- 
+    TBlobTestSet blobSet;
+    blobSet.AddBlobs(blobs);
+    group.PutBlobSet(blobSet);
+
+    for (ui32 idx = 0; idx < domainCount; ++idx) {
+        group.SetPredictedDelayNs(idx, 1);
+    }
+    group.SetPredictedDelayNs(7, 10);
+
+    group.SetNotYetBlob(0, TLogoBlobID(blobIDs[0], 1));
+
+    ui64 blobCount = queryCount;
+    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesA(
+            new TEvBlobStorage::TEvGet::TQuery[queryCount]);
+    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesB(
+            new TEvBlobStorage::TEvGet::TQuery[queryCount]);
+    for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) {
+        TEvBlobStorage::TEvGet::TQuery &q = queriesA[queryIdx];
+        q.Id = blobSet.Get(queryIdx % blobCount).Id;
+        q.Shift = 0;
+        q.Size = (ui64)q.Id.BlobSize();
+        queriesB[queryIdx] = q;
+    }
+    TEvBlobStorage::TEvGet ev(queriesA, queryCount, TInstant::Max(),
+            NKikimrBlobStorage::EGetHandleClass::FastRead, isRestore, false);
+    ev.IsVerboseNoDataEnabled = isVerboseNoDataEnabled;
+
+    TAutoPtr<TEvBlobStorage::TEvGetResult> getResult;
+
     TGetImpl getImpl(group.GetInfo(), groupQueues, &ev, nullptr);
     TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> vGets;
     TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-    TLogContext logCtx(NKikimrServices::BS_PROXY_GET, false); 
-    logCtx.LogAcc.IsLogEnabled = false; 
-    getImpl.GenerateInitialRequests(logCtx, vGets); 
- 
-    for (ui64 vGetIdx = 0; vGetIdx < vGets.size(); ++vGetIdx) { 
-        if (vGetIdx == 3) { 
+    TLogContext logCtx(NKikimrServices::BS_PROXY_GET, false);
+    logCtx.LogAcc.IsLogEnabled = false;
+    getImpl.GenerateInitialRequests(logCtx, vGets);
+
+    for (ui64 vGetIdx = 0; vGetIdx < vGets.size(); ++vGetIdx) {
+        if (vGetIdx == 3) {
             vGets.push_back(std::move(vGets[3]));
-            continue; 
-        } 
-        if (vGetIdx == 5) { 
-            group.SetError(2, NKikimrProto::ERROR); 
-            group.SetPredictedDelayNs(7, 1); 
-        } 
-        bool isLast = (vGetIdx == vGets.size() - 1); 
-        auto &request = vGets[vGetIdx]->Record; 
- 
-        Y_VERIFY(request.HasCookie()); 
-        TEvBlobStorage::TEvVGetResult vGetResult; 
-        group.OnVGet(*vGets[vGetIdx], vGetResult); 
- 
+            continue;
+        }
+        if (vGetIdx == 5) {
+            group.SetError(2, NKikimrProto::ERROR);
+            group.SetPredictedDelayNs(7, 1);
+        }
+        bool isLast = (vGetIdx == vGets.size() - 1);
+        auto &request = vGets[vGetIdx]->Record;
+
+        Y_VERIFY(request.HasCookie());
+        TEvBlobStorage::TEvVGetResult vGetResult;
+        group.OnVGet(*vGets[vGetIdx], vGetResult);
+
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> nextVPuts;
- 
-        getImpl.OnVGetResult(logCtx, vGetResult, nextVGets, nextVPuts, getResult); 
- 
+
+        getImpl.OnVGetResult(logCtx, vGetResult, nextVGets, nextVPuts, getResult);
+
         std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
-        if (ev.MustRestoreFirst) { 
+        if (ev.MustRestoreFirst) {
             std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-        } else { 
-            UNIT_ASSERT_VALUES_EQUAL(nextVPuts.size(), 0); 
-        } 
-        if (getResult) { 
-            break; 
-        } 
-        for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) { 
-            auto &putRequest = vPuts[vPutIdx]->Record; 
-            Y_VERIFY(putRequest.HasCookie()); 
-            TEvBlobStorage::TEvVPutResult vPutResult; 
+        } else {
+            UNIT_ASSERT_VALUES_EQUAL(nextVPuts.size(), 0);
+        }
+        if (getResult) {
+            break;
+        }
+        for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) {
+            auto &putRequest = vPuts[vPutIdx]->Record;
+            Y_VERIFY(putRequest.HasCookie());
+            TEvBlobStorage::TEvVPutResult vPutResult;
             vPutResult.MakeError(NKikimrProto::OK, TString(), putRequest);
- 
+
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> nextVPuts;
-            getImpl.OnVPutResult(logCtx, vPutResult, nextVGets, nextVPuts, getResult); 
+            getImpl.OnVPutResult(logCtx, vPutResult, nextVGets, nextVPuts, getResult);
             std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
             std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-            if (getResult) { 
-                break; 
-            } 
-        } 
-        vPuts.clear(); 
-        if (getResult) { 
-            break; 
-        } 
-        if (!isLast) { 
-            UNIT_ASSERT_VALUES_EQUAL(getResult, nullptr); 
-        } 
-    } 
- 
-    UNIT_ASSERT(getResult); 
-    UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, queryCount); 
-    // TODO: check the data vs queriesB 
-    for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) { 
-        TEvBlobStorage::TEvGetResult::TResponse &a = getResult->Responses[queryIdx]; 
-        TEvBlobStorage::TEvGet::TQuery &q = queriesB[queryIdx]; 
-        UNIT_ASSERT_VALUES_EQUAL(q.Id, a.Id); 
-        if (a.Status != NKikimrProto::ERROR) { 
-            if (a.Status == NKikimrProto::OK) { 
-                UNIT_ASSERT_VALUES_EQUAL(q.Shift, a.Shift); 
-                UNIT_ASSERT_VALUES_EQUAL(q.Size, a.RequestedSize); 
-                blobSet.Check(queryIdx % blobCount, q.Id, q.Shift, q.Size, a.Buffer); 
-            } else { 
-                TStringStream str; 
-                str << " isRestore# " << isRestore 
-                    << " status# " << a.Status; 
-                UNIT_ASSERT_C(false, str.Str()); 
-            } 
-        } 
-    } // for queryIdx 
- 
-    return; 
-} 
- 
+            if (getResult) {
+                break;
+            }
+        }
+        vPuts.clear();
+        if (getResult) {
+            break;
+        }
+        if (!isLast) {
+            UNIT_ASSERT_VALUES_EQUAL(getResult, nullptr);
+        }
+    }
+
+    UNIT_ASSERT(getResult);
+    UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, queryCount);
+    // TODO: check the data vs queriesB
+    for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) {
+        TEvBlobStorage::TEvGetResult::TResponse &a = getResult->Responses[queryIdx];
+        TEvBlobStorage::TEvGet::TQuery &q = queriesB[queryIdx];
+        UNIT_ASSERT_VALUES_EQUAL(q.Id, a.Id);
+        if (a.Status != NKikimrProto::ERROR) {
+            if (a.Status == NKikimrProto::OK) {
+                UNIT_ASSERT_VALUES_EQUAL(q.Shift, a.Shift);
+                UNIT_ASSERT_VALUES_EQUAL(q.Size, a.RequestedSize);
+                blobSet.Check(queryIdx % blobCount, q.Id, q.Shift, q.Size, a.Buffer);
+            } else {
+                TStringStream str;
+                str << " isRestore# " << isRestore
+                    << " status# " << a.Status;
+                UNIT_ASSERT_C(false, str.Str());
+            }
+        }
+    } // for queryIdx
+
+    return;
+}
+
 void ApplyError(TGetSimulator &simulator, ui64 idx, ui64 error) {
     switch (error) {
         case 0:
@@ -1065,173 +1065,173 @@ void TestIntervalsWipedError(TErasureType::EErasureSpecies erasureSpecies, bool
     return;
 }
 
-void TestWipedErrorWithTwoBlobs(TErasureType::EErasureSpecies erasureSpecies, bool isVerboseNoDataEnabled = false) { 
-    TActorSystemStub actorSystemStub; 
- 
-    TVector<TLogoBlobID> blobIDs = { 
-        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576), 
-        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288) 
-    }; 
- 
-    TVector<TBlobTestSet::TBlob> blobs; 
-    for (const auto& id : blobIDs) { 
-        TStringBuilder builder; 
-        for (size_t i = 0; i < id.BlobSize(); ++i) { 
-            builder << 'a'; 
-        } 
- 
-        blobs.emplace_back(id, builder); 
-    } 
- 
-    const ui32 groupId = 0; 
-    TBlobStorageGroupType groupType(erasureSpecies); 
-    const ui32 domainCount = groupType.BlobSubgroupSize(); 
- 
-    const ui64 queryCount = 1; 
-    const ui32 isRestore = 0; 
-    ui64 seed = 0; 
- 
-    for (i32 slowDisk = -1; slowDisk < (i32)domainCount; ++slowDisk) { 
-        for (i32 wipedDisk = -1; wipedDisk < (i32) domainCount; ++wipedDisk) { 
-            if (wipedDisk == slowDisk && slowDisk != -1) { 
-                continue; 
-            } 
-            i32 endMayErrorSendIteration = domainCount; 
-            for (i32 errorIteration = -1; errorIteration < endMayErrorSendIteration; ++errorIteration) { 
-                for (ui32 errorDisk = 0; errorDisk < domainCount; ++errorDisk) { 
-                    if (errorIteration == -1 && errorDisk > 0) { 
-                        break; 
-                    } 
-                    if (errorIteration != -1 && (errorDisk == (ui32)slowDisk || errorDisk == (ui32)wipedDisk)) { 
-                        continue; 
-                    } 
- 
-                    for (ui64 it = 0; it < 100; ++it, ++seed) { 
-                        SetRandomSeed(seed); 
-                        TGroupMock group(groupId, erasureSpecies, domainCount, 1); 
+void TestWipedErrorWithTwoBlobs(TErasureType::EErasureSpecies erasureSpecies, bool isVerboseNoDataEnabled = false) {
+    TActorSystemStub actorSystemStub;
+
+    TVector<TLogoBlobID> blobIDs = {
+        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576),
+        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288)
+    };
+
+    TVector<TBlobTestSet::TBlob> blobs;
+    for (const auto& id : blobIDs) {
+        TStringBuilder builder;
+        for (size_t i = 0; i < id.BlobSize(); ++i) {
+            builder << 'a';
+        }
+
+        blobs.emplace_back(id, builder);
+    }
+
+    const ui32 groupId = 0;
+    TBlobStorageGroupType groupType(erasureSpecies);
+    const ui32 domainCount = groupType.BlobSubgroupSize();
+
+    const ui64 queryCount = 1;
+    const ui32 isRestore = 0;
+    ui64 seed = 0;
+
+    for (i32 slowDisk = -1; slowDisk < (i32)domainCount; ++slowDisk) {
+        for (i32 wipedDisk = -1; wipedDisk < (i32) domainCount; ++wipedDisk) {
+            if (wipedDisk == slowDisk && slowDisk != -1) {
+                continue;
+            }
+            i32 endMayErrorSendIteration = domainCount;
+            for (i32 errorIteration = -1; errorIteration < endMayErrorSendIteration; ++errorIteration) {
+                for (ui32 errorDisk = 0; errorDisk < domainCount; ++errorDisk) {
+                    if (errorIteration == -1 && errorDisk > 0) {
+                        break;
+                    }
+                    if (errorIteration != -1 && (errorDisk == (ui32)slowDisk || errorDisk == (ui32)wipedDisk)) {
+                        continue;
+                    }
+
+                    for (ui64 it = 0; it < 100; ++it, ++seed) {
+                        SetRandomSeed(seed);
+                        TGroupMock group(groupId, erasureSpecies, domainCount, 1);
                         TIntrusivePtr<TGroupQueues> groupQueues = group.MakeGroupQueues();
-                        TBlobTestSet blobSet; 
-                        blobSet.AddBlobs(blobs); 
-                        group.PutBlobSet(blobSet); 
- 
-                        for (ui32 idx = 0; idx < domainCount; ++idx) { 
-                            group.SetPredictedDelayNs(idx, 1); 
-                        } 
-                        if (slowDisk != -1) { 
-                            group.SetPredictedDelayNs(slowDisk, 10); 
-                        } 
- 
-                        if (wipedDisk != -1) { 
-                            group.SetError(wipedDisk, NKikimrProto::NOT_YET); 
-                        } 
- 
-                        ui64 blobCount = queryCount; 
-                        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesA( 
-                                new TEvBlobStorage::TEvGet::TQuery[queryCount]); 
-                        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesB( 
-                                new TEvBlobStorage::TEvGet::TQuery[queryCount]); 
-                        for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) { 
-                            TEvBlobStorage::TEvGet::TQuery &q = queriesA[queryIdx]; 
-                            q.Id = blobSet.Get(queryIdx % blobCount).Id; 
-                            q.Shift = 0; 
-                            q.Size = (ui64)q.Id.BlobSize(); 
-                            queriesB[queryIdx] = q; 
-                        } 
-                        TEvBlobStorage::TEvGet ev(queriesA, queryCount, TInstant::Max(), 
-                                NKikimrBlobStorage::EGetHandleClass::FastRead, isRestore, false); 
-                        ev.IsVerboseNoDataEnabled = isVerboseNoDataEnabled; 
- 
-                        TAutoPtr<TEvBlobStorage::TEvGetResult> getResult; 
- 
+                        TBlobTestSet blobSet;
+                        blobSet.AddBlobs(blobs);
+                        group.PutBlobSet(blobSet);
+
+                        for (ui32 idx = 0; idx < domainCount; ++idx) {
+                            group.SetPredictedDelayNs(idx, 1);
+                        }
+                        if (slowDisk != -1) {
+                            group.SetPredictedDelayNs(slowDisk, 10);
+                        }
+
+                        if (wipedDisk != -1) {
+                            group.SetError(wipedDisk, NKikimrProto::NOT_YET);
+                        }
+
+                        ui64 blobCount = queryCount;
+                        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesA(
+                                new TEvBlobStorage::TEvGet::TQuery[queryCount]);
+                        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queriesB(
+                                new TEvBlobStorage::TEvGet::TQuery[queryCount]);
+                        for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) {
+                            TEvBlobStorage::TEvGet::TQuery &q = queriesA[queryIdx];
+                            q.Id = blobSet.Get(queryIdx % blobCount).Id;
+                            q.Shift = 0;
+                            q.Size = (ui64)q.Id.BlobSize();
+                            queriesB[queryIdx] = q;
+                        }
+                        TEvBlobStorage::TEvGet ev(queriesA, queryCount, TInstant::Max(),
+                                NKikimrBlobStorage::EGetHandleClass::FastRead, isRestore, false);
+                        ev.IsVerboseNoDataEnabled = isVerboseNoDataEnabled;
+
+                        TAutoPtr<TEvBlobStorage::TEvGetResult> getResult;
+
                         TGetImpl getImpl(group.GetInfo(), groupQueues, &ev, nullptr);
                         TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> vGets;
                         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-                        TLogContext logCtx(NKikimrServices::BS_PROXY_GET, false); 
-                        logCtx.LogAcc.IsLogEnabled = false; 
-                        getImpl.GenerateInitialRequests(logCtx, vGets); 
- 
-                        for (ui64 vGetIdx = 0; vGetIdx < vGets.size(); ++vGetIdx) { 
-                            ui32 needIdx = RandomNumber<ui32>(vGets.size() - vGetIdx); 
-                            std::swap(vGets[vGetIdx], vGets[vGetIdx + needIdx]); 
- 
-                            bool isLast = (vGetIdx == vGets.size() - 1); 
-                            auto &request = vGets[vGetIdx]->Record; 
- 
-                            if ((ui32)errorIteration == vGetIdx) { 
-                                group.SetError(errorDisk, NKikimrProto::ERROR); 
-                            } 
- 
-                            Y_VERIFY(request.HasCookie()); 
-                            TEvBlobStorage::TEvVGetResult vGetResult; 
-                            group.OnVGet(*vGets[vGetIdx], vGetResult); 
- 
-                            // TODO: generate result 
+                        TLogContext logCtx(NKikimrServices::BS_PROXY_GET, false);
+                        logCtx.LogAcc.IsLogEnabled = false;
+                        getImpl.GenerateInitialRequests(logCtx, vGets);
+
+                        for (ui64 vGetIdx = 0; vGetIdx < vGets.size(); ++vGetIdx) {
+                            ui32 needIdx = RandomNumber<ui32>(vGets.size() - vGetIdx);
+                            std::swap(vGets[vGetIdx], vGets[vGetIdx + needIdx]);
+
+                            bool isLast = (vGetIdx == vGets.size() - 1);
+                            auto &request = vGets[vGetIdx]->Record;
+
+                            if ((ui32)errorIteration == vGetIdx) {
+                                group.SetError(errorDisk, NKikimrProto::ERROR);
+                            }
+
+                            Y_VERIFY(request.HasCookie());
+                            TEvBlobStorage::TEvVGetResult vGetResult;
+                            group.OnVGet(*vGets[vGetIdx], vGetResult);
+
+                            // TODO: generate result
                             TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
                             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> nextVPuts;
- 
-                            getImpl.OnVGetResult(logCtx, vGetResult, nextVGets, nextVPuts, getResult); 
- 
+
+                            getImpl.OnVGetResult(logCtx, vGetResult, nextVGets, nextVPuts, getResult);
+
                             std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
-                            if (ev.MustRestoreFirst) { 
+                            if (ev.MustRestoreFirst) {
                                 std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-                            } else { 
-                                UNIT_ASSERT_VALUES_EQUAL(nextVPuts.size(), 0); 
-                            } 
-                            if (getResult) { 
-                                break; 
-                            } 
-                            for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) { 
-                                auto &putRequest = vPuts[vPutIdx]->Record; 
-                                Y_VERIFY(putRequest.HasCookie()); 
-                                TEvBlobStorage::TEvVPutResult vPutResult; 
+                            } else {
+                                UNIT_ASSERT_VALUES_EQUAL(nextVPuts.size(), 0);
+                            }
+                            if (getResult) {
+                                break;
+                            }
+                            for (ui64 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) {
+                                auto &putRequest = vPuts[vPutIdx]->Record;
+                                Y_VERIFY(putRequest.HasCookie());
+                                TEvBlobStorage::TEvVPutResult vPutResult;
                                 vPutResult.MakeError(NKikimrProto::OK, TString(), putRequest);
- 
+
                                 TDeque<std::unique_ptr<TEvBlobStorage::TEvVGet>> nextVGets;
                                 TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> nextVPuts;
-                                getImpl.OnVPutResult(logCtx, vPutResult, nextVGets, nextVPuts, getResult); 
+                                getImpl.OnVPutResult(logCtx, vPutResult, nextVGets, nextVPuts, getResult);
                                 std::move(nextVGets.begin(), nextVGets.end(), std::back_inserter(vGets));
                                 std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-                                if (getResult) { 
-                                    break; 
-                                } 
-                            } 
-                            vPuts.clear(); 
-                            if (getResult) { 
-                                break; 
-                            } 
-                            if (!isLast) { 
-                                UNIT_ASSERT_VALUES_EQUAL(getResult, nullptr); 
-                            } 
-                        } 
- 
-                        UNIT_ASSERT(getResult); 
-                        UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, queryCount); 
-                        // TODO: check the data vs queriesB 
-                        for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) { 
-                            TEvBlobStorage::TEvGetResult::TResponse &a = getResult->Responses[queryIdx]; 
-                            TEvBlobStorage::TEvGet::TQuery &q = queriesB[queryIdx]; 
-                            UNIT_ASSERT_VALUES_EQUAL(q.Id, a.Id); 
-                            if (a.Status != NKikimrProto::ERROR) { 
-                                if (a.Status == NKikimrProto::OK) { 
-                                    UNIT_ASSERT_VALUES_EQUAL(q.Shift, a.Shift); 
-                                    UNIT_ASSERT_VALUES_EQUAL(q.Size, a.RequestedSize); 
-                                    blobSet.Check(queryIdx % blobCount, q.Id, q.Shift, q.Size, a.Buffer); 
-                                } else { 
-                                    TStringStream str; 
-                                    str << " isRestore# " << isRestore 
-                                        << " status# " << a.Status; 
-                                    UNIT_ASSERT_C(false, str.Str()); 
-                                } 
-                            } 
-                        } // for queryIdx 
-                    } 
-                } 
-            } 
-        } 
-    } 
-    return; 
-} 
- 
+                                if (getResult) {
+                                    break;
+                                }
+                            }
+                            vPuts.clear();
+                            if (getResult) {
+                                break;
+                            }
+                            if (!isLast) {
+                                UNIT_ASSERT_VALUES_EQUAL(getResult, nullptr);
+                            }
+                        }
+
+                        UNIT_ASSERT(getResult);
+                        UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, queryCount);
+                        // TODO: check the data vs queriesB
+                        for (ui64 queryIdx = 0; queryIdx < queryCount; ++queryIdx) {
+                            TEvBlobStorage::TEvGetResult::TResponse &a = getResult->Responses[queryIdx];
+                            TEvBlobStorage::TEvGet::TQuery &q = queriesB[queryIdx];
+                            UNIT_ASSERT_VALUES_EQUAL(q.Id, a.Id);
+                            if (a.Status != NKikimrProto::ERROR) {
+                                if (a.Status == NKikimrProto::OK) {
+                                    UNIT_ASSERT_VALUES_EQUAL(q.Shift, a.Shift);
+                                    UNIT_ASSERT_VALUES_EQUAL(q.Size, a.RequestedSize);
+                                    blobSet.Check(queryIdx % blobCount, q.Id, q.Shift, q.Size, a.Buffer);
+                                } else {
+                                    TStringStream str;
+                                    str << " isRestore# " << isRestore
+                                        << " status# " << a.Status;
+                                    UNIT_ASSERT_C(false, str.Str());
+                                }
+                            }
+                        } // for queryIdx
+                    }
+                }
+            }
+        }
+    }
+    return;
+}
+
 Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOk) {
     TestIntervalsWipedAllOk(TErasureType::Erasure4Plus2Block);
 }
@@ -1240,42 +1240,42 @@ Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkVerbose) {
     TestIntervalsWipedAllOk(TErasureType::Erasure4Plus2Block, true);
 }
 
-Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkVMultiPut) { 
-    TestIntervalsWipedAllOkVMultiPut(TErasureType::Erasure4Plus2Block); 
-} 
- 
-Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkVerboseVMultiPut) { 
-    TestIntervalsWipedAllOkVMultiPut(TErasureType::Erasure4Plus2Block, true); 
-} 
- 
-Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkComparisonVMultiPutAndVPut) { 
-    TestIntervalsWipedAllOkComparisonVMultiPutAndVPut(TErasureType::Erasure4Plus2Block); 
-} 
- 
-Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkVerboseComparisonVMultiPutAndVPut) { 
-    TestIntervalsWipedAllOkComparisonVMultiPutAndVPut(TErasureType::Erasure4Plus2Block, true); 
-} 
- 
+Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkVMultiPut) {
+    TestIntervalsWipedAllOkVMultiPut(TErasureType::Erasure4Plus2Block);
+}
+
+Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkVerboseVMultiPut) {
+    TestIntervalsWipedAllOkVMultiPut(TErasureType::Erasure4Plus2Block, true);
+}
+
+Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkComparisonVMultiPutAndVPut) {
+    TestIntervalsWipedAllOkComparisonVMultiPutAndVPut(TErasureType::Erasure4Plus2Block);
+}
+
+Y_UNIT_TEST(TestBlock42GetIntervalsWipedAllOkVerboseComparisonVMultiPutAndVPut) {
+    TestIntervalsWipedAllOkComparisonVMultiPutAndVPut(TErasureType::Erasure4Plus2Block, true);
+}
+
 Y_UNIT_TEST(TestBlock42GetIntervalsWipedError) {
     TestIntervalsWipedError(TErasureType::Erasure4Plus2Block);
 }
 
-Y_UNIT_TEST(TestBlock42WipedErrorWithTwoBlobs) { 
-    TestWipedErrorWithTwoBlobs(TErasureType::Erasure4Plus2Block); 
-} 
- 
+Y_UNIT_TEST(TestBlock42WipedErrorWithTwoBlobs) {
+    TestWipedErrorWithTwoBlobs(TErasureType::Erasure4Plus2Block);
+}
+
 Y_UNIT_TEST(TestMirror32GetIntervalsWipedAllOk) {
     TestIntervalsWipedAllOk(TErasureType::ErasureMirror3Plus2);
 }
 
-Y_UNIT_TEST(TestMirror32GetIntervalsWipedAllOkVMultiPut) { 
-    TestIntervalsWipedAllOkVMultiPut(TErasureType::ErasureMirror3Plus2); 
-} 
+Y_UNIT_TEST(TestMirror32GetIntervalsWipedAllOkVMultiPut) {
+    TestIntervalsWipedAllOkVMultiPut(TErasureType::ErasureMirror3Plus2);
+}
+
+Y_UNIT_TEST(TestMirror32GetIntervalsWipedAllOkComparisonVMultiPutAndVPut) {
+    TestIntervalsWipedAllOkComparisonVMultiPutAndVPut(TErasureType::ErasureMirror3Plus2);
+}
 
-Y_UNIT_TEST(TestMirror32GetIntervalsWipedAllOkComparisonVMultiPutAndVPut) { 
-    TestIntervalsWipedAllOkComparisonVMultiPutAndVPut(TErasureType::ErasureMirror3Plus2); 
-} 
- 
 void SpecificTest(ui32 badA, ui32 badB, ui32 blobSize, TMap<i64, i64> sizeForOffset) {
     TActorSystemStub actorSystemStub;
     TErasureType::EErasureSpecies erasureSpecies = TErasureType::Erasure4Plus2Block;
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_patch_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_patch_ut.cpp
index f9b4eed80d..74bd0ed7ee 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_patch_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_patch_ut.cpp
@@ -1,825 +1,825 @@
-#include "defs.h" 
- 
-#include "dsproxy_env_mock_ut.h" 
-#include "dsproxy_test_state_ut.h" 
-#include "dsproxy_vdisk_mock_ut.h" 
- 
+#include "defs.h"
+
+#include "dsproxy_env_mock_ut.h"
+#include "dsproxy_test_state_ut.h"
+#include "dsproxy_vdisk_mock_ut.h"
+
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_partlayout.h>
 #include <ydb/core/util/stlog.h>
- 
-#include <cstring> 
- 
-namespace NKikimr { 
-namespace NDSProxyPatchTest { 
- 
-struct TVDiskPointer { 
-    ui32 VDiskIdx; 
- 
-    static TVDiskPointer GetVDiskIdx(ui32 vdiskIdx) { 
-        return {vdiskIdx}; 
-    } 
- 
-    std::pair<ui32, ui32> GetIndecies(const TDSProxyEnv &env, ui64 hash) const { 
-        TVDiskID vdisk = env.Info->GetVDiskId(VDiskIdx); 
-        ui32 idxInSubgroup = env.Info->GetIdxInSubgroup(vdisk, hash); 
-        return {VDiskIdx, idxInSubgroup}; 
-    } 
-}; 
- 
-struct TTestArgs { 
-    TLogoBlobID OriginalId; 
-    TLogoBlobID PatchedId; 
-    ui64 OriginalGroupId; 
-    ui64 CurrentGroupId; 
-    TString Buffer; 
-    TVector<TDiff> Diffs; 
-    TBlobStorageGroupType GType; 
-    ui32 MaskForCookieBruteForcing; 
- 
-    ui32 StatusFlags = 1; 
-    float ApproximateFreeSpaceShare = 0.1; 
-    TVector<TVector<ui64>> PartPlacement; 
-    TVector<bool> ErrorVDisks; 
- 
-    void MakeDefaultPartPlacement() { 
-        for (TVector<ui64> &pl : PartPlacement) { 
-            pl.clear(); 
-        } 
-        switch (GType.GetErasure()) { 
-        case TErasureType::Erasure4Plus2Block: 
-            for (ui64 idx = 0; idx < GType.TotalPartCount(); ++idx) { 
-                PartPlacement[idx].push_back(idx + 1); 
-            } 
-            break; 
-        case TErasureType::ErasureNone: 
-            PartPlacement[0].push_back(1); 
-            break; 
-        case TErasureType::ErasureMirror3: 
-            PartPlacement[0].push_back(1); 
-            PartPlacement[1].push_back(1); 
-            PartPlacement[2].push_back(1); 
-            break; 
-        case TErasureType::ErasureMirror3dc: 
-            PartPlacement[0].push_back(1); 
-            PartPlacement[3].push_back(2); 
-            PartPlacement[6].push_back(3); 
-            break; 
-        default: 
-            UNIT_ASSERT(false); // not implemented 
-        } 
-    } 
- 
-    void ResetDefaultPlacement() { 
-        ErrorVDisks.assign(GType.BlobSubgroupSize(), false); 
-        PartPlacement.resize(GType.BlobSubgroupSize()); 
-        MakeDefaultPartPlacement(); 
-    } 
- 
-    void MakeDefault(TBlobStorageGroupType type, bool sameGroupId = true, bool goodPatchedId = true) { 
-        constexpr ui32 bufferSize = 1000; 
-        OriginalId = TLogoBlobID(1, 2, 3, 4, bufferSize, 5); 
-        PatchedId = TLogoBlobID(1, 3, 3, 4, bufferSize, 6); 
-        OriginalGroupId = 0; 
-        CurrentGroupId = OriginalGroupId + !sameGroupId; 
-        Buffer = TString::Uninitialized(bufferSize); 
-        for (char &c : Buffer) { 
-            c = 'a'; 
-        } 
-        for (ui32 idx = 0; idx < bufferSize; idx += 2) { 
-            Diffs.emplace_back("b", idx); 
-        } 
-        GType = type; 
- 
-        ErrorVDisks.assign(type.BlobSubgroupSize(), false); 
-        PartPlacement.resize(type.BlobSubgroupSize()); 
-        MakeDefaultPartPlacement(); 
- 
-        MaskForCookieBruteForcing = (Max<ui32>() << 17) & TLogoBlobID::MaxCookie; 
-        if (goodPatchedId) { 
-            UNIT_ASSERT(TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(OriginalId, &PatchedId, 
-                    MaskForCookieBruteForcing, OriginalGroupId, CurrentGroupId)); 
-        } 
-    } 
-}; 
- 
-enum class ENaivePatchCase { 
-    Ok, 
-    ErrorOnGetItem, 
-    ErrorOnGet, 
-    ErrorOnPut, 
-}; 
- 
-NKikimrProto::EReplyStatus GetPatchResultStatus(ENaivePatchCase naiveCase) { 
-    switch (naiveCase) { 
-    case ENaivePatchCase::Ok: 
-        return NKikimrProto::OK; 
-    case ENaivePatchCase::ErrorOnGetItem: 
-    case ENaivePatchCase::ErrorOnGet: 
-    case ENaivePatchCase::ErrorOnPut: 
-        return NKikimrProto::ERROR; 
-    } 
-} 
- 
-NKikimrProto::EReplyStatus GetGetResultStatus(ENaivePatchCase naiveCase) { 
-    switch (naiveCase) { 
-    case ENaivePatchCase::Ok: 
-        return NKikimrProto::OK; 
-    case ENaivePatchCase::ErrorOnGetItem: 
-        return NKikimrProto::OK; 
-    case ENaivePatchCase::ErrorOnGet: 
-        return NKikimrProto::ERROR; 
-    case ENaivePatchCase::ErrorOnPut: 
-        return NKikimrProto::OK; 
-    } 
-} 
- 
-NKikimrProto::EReplyStatus GetPutResultStatus(ENaivePatchCase naiveCase) { 
-    switch (naiveCase) { 
-    case ENaivePatchCase::Ok: 
-        return NKikimrProto::OK; 
-    case ENaivePatchCase::ErrorOnGetItem: 
-        return NKikimrProto::UNKNOWN; 
-    case ENaivePatchCase::ErrorOnGet: 
-        return NKikimrProto::UNKNOWN; 
-    case ENaivePatchCase::ErrorOnPut: 
-        return NKikimrProto::ERROR; 
-    } 
-} 
- 
-enum class EVPatchCase { 
-    Ok, 
-    OneErrorAndAllPartExistInStart, 
-    OnePartLostInStart, 
-    DeadGroupInStart, 
-    ErrorDuringVPatchDiff, 
-    Custom, 
-}; 
- 
-NKikimrProto::EReplyStatus GetPatchResultStatus(EVPatchCase vpatchCase) { 
-    switch (vpatchCase) { 
-        case EVPatchCase::Ok: 
-        case EVPatchCase::OneErrorAndAllPartExistInStart: 
-            return NKikimrProto::OK; 
-        case EVPatchCase::OnePartLostInStart: 
-        case EVPatchCase::DeadGroupInStart: 
-        case EVPatchCase::ErrorDuringVPatchDiff: 
-        case EVPatchCase::Custom: 
-            return NKikimrProto::UNKNOWN; 
-    } 
-} 
- 
-struct TFoundPartsResult { 
-    NKikimrProto::EReplyStatus Status; 
-    TVector<ui64> Parts; 
-}; 
- 
-TFoundPartsResult GetVPatchFoundPartsStatus(const TDSProxyEnv &env, const TTestArgs &args, 
-        EVPatchCase vpatchCase, const TVDiskPointer &vdisk) { 
- 
-    TVector<ui64> foundPartsOk; 
-    auto [vdiskIdx, idxInSubgroup] = vdisk.GetIndecies(env, args.OriginalId.Hash()); 
-    if (args.GType.GetErasure() == TErasureType::ErasureMirror3dc) { 
-        foundPartsOk.push_back(idxInSubgroup / 3); 
-    } else if (idxInSubgroup < args.GType.TotalPartCount()) { 
-        foundPartsOk.push_back(idxInSubgroup + 1); 
-    } 
-    TFoundPartsResult okResult{NKikimrProto::OK, foundPartsOk}; 
-    TFoundPartsResult lostResult{NKikimrProto::OK, {}}; 
-    TFoundPartsResult errorResult{NKikimrProto::ERROR, {}}; 
-    TFoundPartsResult customOkResult{NKikimrProto::OK, args.PartPlacement[idxInSubgroup]}; 
- 
-    if (args.GType.GetErasure() == TErasureType::ErasureMirror3dc) { 
-        TFoundPartsResult correctResult = (idxInSubgroup % 3 == 0) ? okResult : lostResult; 
-        switch (vpatchCase) { 
-        case EVPatchCase::Ok: 
-        case EVPatchCase::ErrorDuringVPatchDiff: 
-            return correctResult; 
-        case EVPatchCase::OneErrorAndAllPartExistInStart: 
-            return (idxInSubgroup % 3 == 2 && idxInSubgroup / 3 == 2) ? errorResult : correctResult; 
-        case EVPatchCase::OnePartLostInStart: 
-            return (idxInSubgroup == 0) ? lostResult : correctResult; 
-        case EVPatchCase::DeadGroupInStart: 
-            return (idxInSubgroup / 3 < 2) ? errorResult : correctResult; 
-        case EVPatchCase::Custom: 
-            return args.ErrorVDisks[idxInSubgroup] ? errorResult : customOkResult; 
-        } 
-    } else { 
-        switch (vpatchCase) { 
-        case EVPatchCase::Ok: 
-        case EVPatchCase::ErrorDuringVPatchDiff: 
-            return okResult; 
-        case EVPatchCase::OneErrorAndAllPartExistInStart: 
-            return (idxInSubgroup == args.GType.TotalPartCount()) ? errorResult : okResult; 
-        case EVPatchCase::OnePartLostInStart: 
-            return (idxInSubgroup == 0) ? lostResult : okResult; 
-        case EVPatchCase::DeadGroupInStart: 
-            return (idxInSubgroup <= args.GType.Handoff()) ? errorResult : okResult; 
-        case EVPatchCase::Custom: 
-            return args.ErrorVDisks[vdiskIdx] ? errorResult : customOkResult; 
-        } 
-    } 
-} 
- 
-NKikimrProto::EReplyStatus GetVPatchResultStatus(const TDSProxyEnv &env, const TTestArgs &args, 
-        EVPatchCase vpatchCase, const TVDiskPointer &vdisk) 
-{ 
-    auto [prevStatus, parts] = GetVPatchFoundPartsStatus(env, args, vpatchCase, vdisk); 
-    if (!parts) { 
-        return NKikimrProto::UNKNOWN; 
-    } 
-    if (prevStatus != NKikimrProto::OK) { 
-        return NKikimrProto::UNKNOWN; 
-    } 
- 
-    switch (vpatchCase) { 
-    case EVPatchCase::Ok: 
-    case EVPatchCase::OneErrorAndAllPartExistInStart: 
-    case EVPatchCase::OnePartLostInStart: 
-    case EVPatchCase::DeadGroupInStart: 
-    case EVPatchCase::Custom: 
-        return NKikimrProto::OK; 
-    case EVPatchCase::ErrorDuringVPatchDiff: 
-        return NKikimrProto::ERROR; 
-    } 
-} 
- 
-enum class EMovedPatchCase { 
-    Ok, 
-    Error 
-}; 
- 
-NKikimrProto::EReplyStatus GetPatchResultStatus(EMovedPatchCase movedCase) { 
-    switch (movedCase) { 
-    case EMovedPatchCase::Ok: 
-        return NKikimrProto::OK; 
-    case EMovedPatchCase::Error: 
-        return NKikimrProto::UNKNOWN; 
-    } 
-} 
- 
-NKikimrProto::EReplyStatus GetVMovedPatchResultStatus(EMovedPatchCase movedCase) { 
-    switch (movedCase) { 
-    case EMovedPatchCase::Ok: 
-        return NKikimrProto::OK; 
-    case EMovedPatchCase::Error: 
-        return NKikimrProto::ERROR; 
-    } 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-template <typename THandle, typename TEventHolder> 
-void SendByHandle(TTestBasicRuntime &runtime, const THandle &oldHandle, TEventHolder &&ev) { 
+
+#include <cstring>
+
+namespace NKikimr {
+namespace NDSProxyPatchTest {
+
+struct TVDiskPointer {
+    ui32 VDiskIdx;
+
+    static TVDiskPointer GetVDiskIdx(ui32 vdiskIdx) {
+        return {vdiskIdx};
+    }
+
+    std::pair<ui32, ui32> GetIndecies(const TDSProxyEnv &env, ui64 hash) const {
+        TVDiskID vdisk = env.Info->GetVDiskId(VDiskIdx);
+        ui32 idxInSubgroup = env.Info->GetIdxInSubgroup(vdisk, hash);
+        return {VDiskIdx, idxInSubgroup};
+    }
+};
+
+struct TTestArgs {
+    TLogoBlobID OriginalId;
+    TLogoBlobID PatchedId;
+    ui64 OriginalGroupId;
+    ui64 CurrentGroupId;
+    TString Buffer;
+    TVector<TDiff> Diffs;
+    TBlobStorageGroupType GType;
+    ui32 MaskForCookieBruteForcing;
+
+    ui32 StatusFlags = 1;
+    float ApproximateFreeSpaceShare = 0.1;
+    TVector<TVector<ui64>> PartPlacement;
+    TVector<bool> ErrorVDisks;
+
+    void MakeDefaultPartPlacement() {
+        for (TVector<ui64> &pl : PartPlacement) {
+            pl.clear();
+        }
+        switch (GType.GetErasure()) {
+        case TErasureType::Erasure4Plus2Block:
+            for (ui64 idx = 0; idx < GType.TotalPartCount(); ++idx) {
+                PartPlacement[idx].push_back(idx + 1);
+            }
+            break;
+        case TErasureType::ErasureNone:
+            PartPlacement[0].push_back(1);
+            break;
+        case TErasureType::ErasureMirror3:
+            PartPlacement[0].push_back(1);
+            PartPlacement[1].push_back(1);
+            PartPlacement[2].push_back(1);
+            break;
+        case TErasureType::ErasureMirror3dc:
+            PartPlacement[0].push_back(1);
+            PartPlacement[3].push_back(2);
+            PartPlacement[6].push_back(3);
+            break;
+        default:
+            UNIT_ASSERT(false); // not implemented
+        }
+    }
+
+    void ResetDefaultPlacement() {
+        ErrorVDisks.assign(GType.BlobSubgroupSize(), false);
+        PartPlacement.resize(GType.BlobSubgroupSize());
+        MakeDefaultPartPlacement();
+    }
+
+    void MakeDefault(TBlobStorageGroupType type, bool sameGroupId = true, bool goodPatchedId = true) {
+        constexpr ui32 bufferSize = 1000;
+        OriginalId = TLogoBlobID(1, 2, 3, 4, bufferSize, 5);
+        PatchedId = TLogoBlobID(1, 3, 3, 4, bufferSize, 6);
+        OriginalGroupId = 0;
+        CurrentGroupId = OriginalGroupId + !sameGroupId;
+        Buffer = TString::Uninitialized(bufferSize);
+        for (char &c : Buffer) {
+            c = 'a';
+        }
+        for (ui32 idx = 0; idx < bufferSize; idx += 2) {
+            Diffs.emplace_back("b", idx);
+        }
+        GType = type;
+
+        ErrorVDisks.assign(type.BlobSubgroupSize(), false);
+        PartPlacement.resize(type.BlobSubgroupSize());
+        MakeDefaultPartPlacement();
+
+        MaskForCookieBruteForcing = (Max<ui32>() << 17) & TLogoBlobID::MaxCookie;
+        if (goodPatchedId) {
+            UNIT_ASSERT(TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(OriginalId, &PatchedId,
+                    MaskForCookieBruteForcing, OriginalGroupId, CurrentGroupId));
+        }
+    }
+};
+
+enum class ENaivePatchCase {
+    Ok,
+    ErrorOnGetItem,
+    ErrorOnGet,
+    ErrorOnPut,
+};
+
+NKikimrProto::EReplyStatus GetPatchResultStatus(ENaivePatchCase naiveCase) {
+    switch (naiveCase) {
+    case ENaivePatchCase::Ok:
+        return NKikimrProto::OK;
+    case ENaivePatchCase::ErrorOnGetItem:
+    case ENaivePatchCase::ErrorOnGet:
+    case ENaivePatchCase::ErrorOnPut:
+        return NKikimrProto::ERROR;
+    }
+}
+
+NKikimrProto::EReplyStatus GetGetResultStatus(ENaivePatchCase naiveCase) {
+    switch (naiveCase) {
+    case ENaivePatchCase::Ok:
+        return NKikimrProto::OK;
+    case ENaivePatchCase::ErrorOnGetItem:
+        return NKikimrProto::OK;
+    case ENaivePatchCase::ErrorOnGet:
+        return NKikimrProto::ERROR;
+    case ENaivePatchCase::ErrorOnPut:
+        return NKikimrProto::OK;
+    }
+}
+
+NKikimrProto::EReplyStatus GetPutResultStatus(ENaivePatchCase naiveCase) {
+    switch (naiveCase) {
+    case ENaivePatchCase::Ok:
+        return NKikimrProto::OK;
+    case ENaivePatchCase::ErrorOnGetItem:
+        return NKikimrProto::UNKNOWN;
+    case ENaivePatchCase::ErrorOnGet:
+        return NKikimrProto::UNKNOWN;
+    case ENaivePatchCase::ErrorOnPut:
+        return NKikimrProto::ERROR;
+    }
+}
+
+enum class EVPatchCase {
+    Ok,
+    OneErrorAndAllPartExistInStart,
+    OnePartLostInStart,
+    DeadGroupInStart,
+    ErrorDuringVPatchDiff,
+    Custom,
+};
+
+NKikimrProto::EReplyStatus GetPatchResultStatus(EVPatchCase vpatchCase) {
+    switch (vpatchCase) {
+        case EVPatchCase::Ok:
+        case EVPatchCase::OneErrorAndAllPartExistInStart:
+            return NKikimrProto::OK;
+        case EVPatchCase::OnePartLostInStart:
+        case EVPatchCase::DeadGroupInStart:
+        case EVPatchCase::ErrorDuringVPatchDiff:
+        case EVPatchCase::Custom:
+            return NKikimrProto::UNKNOWN;
+    }
+}
+
+struct TFoundPartsResult {
+    NKikimrProto::EReplyStatus Status;
+    TVector<ui64> Parts;
+};
+
+TFoundPartsResult GetVPatchFoundPartsStatus(const TDSProxyEnv &env, const TTestArgs &args,
+        EVPatchCase vpatchCase, const TVDiskPointer &vdisk) {
+
+    TVector<ui64> foundPartsOk;
+    auto [vdiskIdx, idxInSubgroup] = vdisk.GetIndecies(env, args.OriginalId.Hash());
+    if (args.GType.GetErasure() == TErasureType::ErasureMirror3dc) {
+        foundPartsOk.push_back(idxInSubgroup / 3);
+    } else if (idxInSubgroup < args.GType.TotalPartCount()) {
+        foundPartsOk.push_back(idxInSubgroup + 1);
+    }
+    TFoundPartsResult okResult{NKikimrProto::OK, foundPartsOk};
+    TFoundPartsResult lostResult{NKikimrProto::OK, {}};
+    TFoundPartsResult errorResult{NKikimrProto::ERROR, {}};
+    TFoundPartsResult customOkResult{NKikimrProto::OK, args.PartPlacement[idxInSubgroup]};
+
+    if (args.GType.GetErasure() == TErasureType::ErasureMirror3dc) {
+        TFoundPartsResult correctResult = (idxInSubgroup % 3 == 0) ? okResult : lostResult;
+        switch (vpatchCase) {
+        case EVPatchCase::Ok:
+        case EVPatchCase::ErrorDuringVPatchDiff:
+            return correctResult;
+        case EVPatchCase::OneErrorAndAllPartExistInStart:
+            return (idxInSubgroup % 3 == 2 && idxInSubgroup / 3 == 2) ? errorResult : correctResult;
+        case EVPatchCase::OnePartLostInStart:
+            return (idxInSubgroup == 0) ? lostResult : correctResult;
+        case EVPatchCase::DeadGroupInStart:
+            return (idxInSubgroup / 3 < 2) ? errorResult : correctResult;
+        case EVPatchCase::Custom:
+            return args.ErrorVDisks[idxInSubgroup] ? errorResult : customOkResult;
+        }
+    } else {
+        switch (vpatchCase) {
+        case EVPatchCase::Ok:
+        case EVPatchCase::ErrorDuringVPatchDiff:
+            return okResult;
+        case EVPatchCase::OneErrorAndAllPartExistInStart:
+            return (idxInSubgroup == args.GType.TotalPartCount()) ? errorResult : okResult;
+        case EVPatchCase::OnePartLostInStart:
+            return (idxInSubgroup == 0) ? lostResult : okResult;
+        case EVPatchCase::DeadGroupInStart:
+            return (idxInSubgroup <= args.GType.Handoff()) ? errorResult : okResult;
+        case EVPatchCase::Custom:
+            return args.ErrorVDisks[vdiskIdx] ? errorResult : customOkResult;
+        }
+    }
+}
+
+NKikimrProto::EReplyStatus GetVPatchResultStatus(const TDSProxyEnv &env, const TTestArgs &args,
+        EVPatchCase vpatchCase, const TVDiskPointer &vdisk)
+{
+    auto [prevStatus, parts] = GetVPatchFoundPartsStatus(env, args, vpatchCase, vdisk);
+    if (!parts) {
+        return NKikimrProto::UNKNOWN;
+    }
+    if (prevStatus != NKikimrProto::OK) {
+        return NKikimrProto::UNKNOWN;
+    }
+
+    switch (vpatchCase) {
+    case EVPatchCase::Ok:
+    case EVPatchCase::OneErrorAndAllPartExistInStart:
+    case EVPatchCase::OnePartLostInStart:
+    case EVPatchCase::DeadGroupInStart:
+    case EVPatchCase::Custom:
+        return NKikimrProto::OK;
+    case EVPatchCase::ErrorDuringVPatchDiff:
+        return NKikimrProto::ERROR;
+    }
+}
+
+enum class EMovedPatchCase {
+    Ok,
+    Error
+};
+
+NKikimrProto::EReplyStatus GetPatchResultStatus(EMovedPatchCase movedCase) {
+    switch (movedCase) {
+    case EMovedPatchCase::Ok:
+        return NKikimrProto::OK;
+    case EMovedPatchCase::Error:
+        return NKikimrProto::UNKNOWN;
+    }
+}
+
+NKikimrProto::EReplyStatus GetVMovedPatchResultStatus(EMovedPatchCase movedCase) {
+    switch (movedCase) {
+    case EMovedPatchCase::Ok:
+        return NKikimrProto::OK;
+    case EMovedPatchCase::Error:
+        return NKikimrProto::ERROR;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename THandle, typename TEventHolder>
+void SendByHandle(TTestBasicRuntime &runtime, const THandle &oldHandle, TEventHolder &&ev) {
     auto handle = std::make_unique<IEventHandle>(oldHandle->Sender, oldHandle->Recipient, ev.release(), oldHandle->Flags, oldHandle->Cookie);
     runtime.Send(handle.release());
-} 
- 
-void ReceivePatchResult(TTestBasicRuntime &runtime, const TTestArgs &args, NKikimrProto::EReplyStatus status) { 
-    CTEST << "ReceivePatchResult: Start\n"; 
-    TAutoPtr<IEventHandle> handle; 
-    TEvBlobStorage::TEvPatchResult *result = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvPatchResult>(handle); 
-    UNIT_ASSERT_VALUES_EQUAL(result->Status, status); 
-    UNIT_ASSERT_VALUES_EQUAL(result->Id, args.PatchedId); 
-    if (status == NKikimrProto::OK) { 
-        UNIT_ASSERT_VALUES_EQUAL(result->StatusFlags.Raw, args.StatusFlags); 
-        UNIT_ASSERT_VALUES_EQUAL(result->ApproximateFreeSpaceShare, args.ApproximateFreeSpaceShare); 
-    } 
-    CTEST << "ReceivePatchResult: Finish\n"; 
-} 
- 
-void ConductGet(TTestBasicRuntime &runtime, const TTestArgs &args, ENaivePatchCase naiveCase) { 
-    CTEST << "ConductGet: Start\n"; 
-    NKikimrProto::EReplyStatus resultStatus = GetGetResultStatus(naiveCase); 
-    TAutoPtr<IEventHandle> handle; 
-    TEvBlobStorage::TEvGet *get = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvGet>(handle); 
-    UNIT_ASSERT_VALUES_EQUAL(get->QuerySize, 1); 
-    UNIT_ASSERT_VALUES_EQUAL(get->Queries[0].Id, args.OriginalId); 
-    UNIT_ASSERT_VALUES_EQUAL(handle->Cookie, args.PatchedId.Hash()); 
- 
+}
+
+void ReceivePatchResult(TTestBasicRuntime &runtime, const TTestArgs &args, NKikimrProto::EReplyStatus status) {
+    CTEST << "ReceivePatchResult: Start\n";
+    TAutoPtr<IEventHandle> handle;
+    TEvBlobStorage::TEvPatchResult *result = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvPatchResult>(handle);
+    UNIT_ASSERT_VALUES_EQUAL(result->Status, status);
+    UNIT_ASSERT_VALUES_EQUAL(result->Id, args.PatchedId);
+    if (status == NKikimrProto::OK) {
+        UNIT_ASSERT_VALUES_EQUAL(result->StatusFlags.Raw, args.StatusFlags);
+        UNIT_ASSERT_VALUES_EQUAL(result->ApproximateFreeSpaceShare, args.ApproximateFreeSpaceShare);
+    }
+    CTEST << "ReceivePatchResult: Finish\n";
+}
+
+void ConductGet(TTestBasicRuntime &runtime, const TTestArgs &args, ENaivePatchCase naiveCase) {
+    CTEST << "ConductGet: Start\n";
+    NKikimrProto::EReplyStatus resultStatus = GetGetResultStatus(naiveCase);
+    TAutoPtr<IEventHandle> handle;
+    TEvBlobStorage::TEvGet *get = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvGet>(handle);
+    UNIT_ASSERT_VALUES_EQUAL(get->QuerySize, 1);
+    UNIT_ASSERT_VALUES_EQUAL(get->Queries[0].Id, args.OriginalId);
+    UNIT_ASSERT_VALUES_EQUAL(handle->Cookie, args.PatchedId.Hash());
+
     std::unique_ptr<TEvBlobStorage::TEvGetResult> getResult;
-    if (resultStatus == NKikimrProto::OK) { 
+    if (resultStatus == NKikimrProto::OK) {
         getResult = std::make_unique<TEvBlobStorage::TEvGetResult>(NKikimrProto::OK, 1, args.CurrentGroupId);
-        if (naiveCase == ENaivePatchCase::ErrorOnGetItem) { 
-            getResult->Responses[0].Id = args.OriginalId; 
-            getResult->Responses[0].Status = NKikimrProto::ERROR; 
-        } else { 
-            getResult->Responses[0].Buffer = args.Buffer; 
-            getResult->Responses[0].Id = args.OriginalId; 
-            getResult->Responses[0].Status = NKikimrProto::OK; 
-        } 
-    } else { 
+        if (naiveCase == ENaivePatchCase::ErrorOnGetItem) {
+            getResult->Responses[0].Id = args.OriginalId;
+            getResult->Responses[0].Status = NKikimrProto::ERROR;
+        } else {
+            getResult->Responses[0].Buffer = args.Buffer;
+            getResult->Responses[0].Id = args.OriginalId;
+            getResult->Responses[0].Status = NKikimrProto::OK;
+        }
+    } else {
         getResult = std::make_unique<TEvBlobStorage::TEvGetResult>(NKikimrProto::ERROR, 0, args.CurrentGroupId);
-    } 
- 
-    SendByHandle(runtime, handle, std::move(getResult)); 
-    CTEST << "ConductGet: Finish\n"; 
-} 
- 
-TString MakePatchedBuffer(const TTestArgs &args) { 
-    TString buffer = TString::Uninitialized(args.Buffer.size()); 
-    memcpy(buffer.begin(), args.Buffer.begin(), args.Buffer.size()); 
-    for (auto &diff : args.Diffs) { 
-        memcpy(buffer.begin() + diff.Offset, diff.GetDataBegin(), diff.GetDiffLength()); 
-    } 
-    return buffer; 
-} 
- 
-void ConductPut(TTestBasicRuntime &runtime, const TTestArgs &args, ENaivePatchCase naiveCase) { 
-    NKikimrProto::EReplyStatus resultStatus = GetPutResultStatus(naiveCase); 
-    if (resultStatus == NKikimrProto::UNKNOWN) { 
-        CTEST << "ConductPut: Skip\n"; 
-        return; 
-    } 
-    CTEST << "ConductPut: Start\n"; 
-    TAutoPtr<IEventHandle> handle; 
-    TEvBlobStorage::TEvPut *put = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvPut>(handle); 
-    UNIT_ASSERT_VALUES_EQUAL(put->Id, args.PatchedId); 
-    UNIT_ASSERT_VALUES_EQUAL(handle->Cookie, args.OriginalId.Hash()); 
-    TString patchedBuffer = MakePatchedBuffer(args); 
-    UNIT_ASSERT_VALUES_EQUAL(put->Buffer, patchedBuffer); 
- 
+    }
+
+    SendByHandle(runtime, handle, std::move(getResult));
+    CTEST << "ConductGet: Finish\n";
+}
+
+TString MakePatchedBuffer(const TTestArgs &args) {
+    TString buffer = TString::Uninitialized(args.Buffer.size());
+    memcpy(buffer.begin(), args.Buffer.begin(), args.Buffer.size());
+    for (auto &diff : args.Diffs) {
+        memcpy(buffer.begin() + diff.Offset, diff.GetDataBegin(), diff.GetDiffLength());
+    }
+    return buffer;
+}
+
+void ConductPut(TTestBasicRuntime &runtime, const TTestArgs &args, ENaivePatchCase naiveCase) {
+    NKikimrProto::EReplyStatus resultStatus = GetPutResultStatus(naiveCase);
+    if (resultStatus == NKikimrProto::UNKNOWN) {
+        CTEST << "ConductPut: Skip\n";
+        return;
+    }
+    CTEST << "ConductPut: Start\n";
+    TAutoPtr<IEventHandle> handle;
+    TEvBlobStorage::TEvPut *put = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvPut>(handle);
+    UNIT_ASSERT_VALUES_EQUAL(put->Id, args.PatchedId);
+    UNIT_ASSERT_VALUES_EQUAL(handle->Cookie, args.OriginalId.Hash());
+    TString patchedBuffer = MakePatchedBuffer(args);
+    UNIT_ASSERT_VALUES_EQUAL(put->Buffer, patchedBuffer);
+
     std::unique_ptr<TEvBlobStorage::TEvPutResult> putResult = std::make_unique<TEvBlobStorage::TEvPutResult>(
-            resultStatus, args.PatchedId, args.StatusFlags, args.CurrentGroupId, args.ApproximateFreeSpaceShare); 
-    SendByHandle(runtime, handle, std::move(putResult)); 
-    CTEST << "ConductPut: Finish\n"; 
-} 
- 
-void ConductNaivePatch(TTestBasicRuntime &runtime, const TTestArgs &args, ENaivePatchCase naiveCase) { 
-    CTEST << "ConductNaivePatch: Start\n"; 
-    ConductGet(runtime, args, naiveCase); 
-    ConductPut(runtime, args, naiveCase); 
-    NKikimrProto::EReplyStatus resultStatus = GetPatchResultStatus(naiveCase); 
-    ReceivePatchResult(runtime, args, resultStatus); 
-    CTEST << "ConductNaivePatch: Finish\n"; 
-} 
- 
- 
-void ConductVPatchStart(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args, 
-        EVPatchCase naiveCase, TVDiskPointer vdiskPointer) 
-{ 
-    auto [vdiskIdx, idxInSubgroup] = vdiskPointer.GetIndecies(env, args.OriginalId.Hash()); 
-    CTEST << "ConductVPatchStart: Start vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n"; 
-    TVDiskID vdisk = env.Info->GetVDiskInSubgroup(idxInSubgroup, args.OriginalId.Hash()); 
-    auto [status, parts] = GetVPatchFoundPartsStatus(env, args, naiveCase, vdiskPointer); 
- 
-    auto start = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchStart>({env.VDisks[vdiskIdx]}); 
-    auto &startRecord = start->Get()->Record; 
-    UNIT_ASSERT(vdisk == VDiskIDFromVDiskID(startRecord.GetVDiskID())); 
-    UNIT_ASSERT(args.OriginalId == LogoBlobIDFromLogoBlobID(startRecord.GetOriginalBlobId())); 
- 
-    TInstant now = runtime.GetCurrentTime(); 
-    UNIT_ASSERT(startRecord.HasCookie()); 
+            resultStatus, args.PatchedId, args.StatusFlags, args.CurrentGroupId, args.ApproximateFreeSpaceShare);
+    SendByHandle(runtime, handle, std::move(putResult));
+    CTEST << "ConductPut: Finish\n";
+}
+
+void ConductNaivePatch(TTestBasicRuntime &runtime, const TTestArgs &args, ENaivePatchCase naiveCase) {
+    CTEST << "ConductNaivePatch: Start\n";
+    ConductGet(runtime, args, naiveCase);
+    ConductPut(runtime, args, naiveCase);
+    NKikimrProto::EReplyStatus resultStatus = GetPatchResultStatus(naiveCase);
+    ReceivePatchResult(runtime, args, resultStatus);
+    CTEST << "ConductNaivePatch: Finish\n";
+}
+
+
+void ConductVPatchStart(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args,
+        EVPatchCase naiveCase, TVDiskPointer vdiskPointer)
+{
+    auto [vdiskIdx, idxInSubgroup] = vdiskPointer.GetIndecies(env, args.OriginalId.Hash());
+    CTEST << "ConductVPatchStart: Start vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n";
+    TVDiskID vdisk = env.Info->GetVDiskInSubgroup(idxInSubgroup, args.OriginalId.Hash());
+    auto [status, parts] = GetVPatchFoundPartsStatus(env, args, naiveCase, vdiskPointer);
+
+    auto start = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchStart>({env.VDisks[vdiskIdx]});
+    auto &startRecord = start->Get()->Record;
+    UNIT_ASSERT(vdisk == VDiskIDFromVDiskID(startRecord.GetVDiskID()));
+    UNIT_ASSERT(args.OriginalId == LogoBlobIDFromLogoBlobID(startRecord.GetOriginalBlobId()));
+
+    TInstant now = runtime.GetCurrentTime();
+    UNIT_ASSERT(startRecord.HasCookie());
     std::unique_ptr<TEvBlobStorage::TEvVPatchFoundParts> foundParts = std::make_unique<TEvBlobStorage::TEvVPatchFoundParts>(
-            status, args.OriginalId, args.PatchedId, vdisk, startRecord.GetCookie(), now, "", &startRecord, 
-            nullptr, nullptr, nullptr, NWilson::TTraceId(), 0); 
-    for (auto partId : parts) { 
-        foundParts->AddPart(partId); 
-    } 
-    SendByHandle(runtime, start, std::move(foundParts)); 
-    CTEST << "ConductVPatchStart: Finish vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n"; 
-} 
- 
-void ConductVPatchDiff(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args, 
-        EVPatchCase naiveCase, TVDiskPointer vdiskPointer) 
-{ 
-    auto [vdiskIdx, idxInSubgroup] = vdiskPointer.GetIndecies(env, args.PatchedId.Hash()); 
-    TVDiskID vdisk = env.Info->GetVDiskInSubgroup(idxInSubgroup, args.PatchedId.Hash()); 
-    NKikimrProto::EReplyStatus resultStatus = GetVPatchResultStatus(env, args, naiveCase, vdiskPointer); 
-    if (resultStatus == NKikimrProto::UNKNOWN) { 
-        CTEST << "ConductVPatchDiff: Skip vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n"; 
-        return; 
-    } 
-    CTEST << "ConductVPatchDiff: Start vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n"; 
- 
-    auto diffEv = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchDiff>({env.VDisks[vdiskIdx]}); 
-    auto &diffRecord = diffEv->Get()->Record; 
-    UNIT_ASSERT(vdisk == VDiskIDFromVDiskID(diffRecord.GetVDiskID())); 
-    UNIT_ASSERT_VALUES_EQUAL(args.OriginalId, LogoBlobIDFromLogoBlobID(diffRecord.GetOriginalPartBlobId()).FullID()); 
-    UNIT_ASSERT_VALUES_EQUAL(args.PatchedId, LogoBlobIDFromLogoBlobID(diffRecord.GetPatchedPartBlobId()).FullID()); 
- 
-    if (env.Info->Type.ErasureFamily() == TErasureType::ErasureMirror) { 
-        UNIT_ASSERT_C(!diffEv->Get()->IsXorReceiver(), "it can't be xorreceiver"); 
-        UNIT_ASSERT_C(!diffRecord.XorReceiversSize(), "it can't has xorreceivers"); 
-    } 
- 
-    TInstant now = runtime.GetCurrentTime(); 
-    UNIT_ASSERT(diffRecord.HasCookie()); 
+            status, args.OriginalId, args.PatchedId, vdisk, startRecord.GetCookie(), now, "", &startRecord,
+            nullptr, nullptr, nullptr, NWilson::TTraceId(), 0);
+    for (auto partId : parts) {
+        foundParts->AddPart(partId);
+    }
+    SendByHandle(runtime, start, std::move(foundParts));
+    CTEST << "ConductVPatchStart: Finish vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n";
+}
+
+void ConductVPatchDiff(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args,
+        EVPatchCase naiveCase, TVDiskPointer vdiskPointer)
+{
+    auto [vdiskIdx, idxInSubgroup] = vdiskPointer.GetIndecies(env, args.PatchedId.Hash());
+    TVDiskID vdisk = env.Info->GetVDiskInSubgroup(idxInSubgroup, args.PatchedId.Hash());
+    NKikimrProto::EReplyStatus resultStatus = GetVPatchResultStatus(env, args, naiveCase, vdiskPointer);
+    if (resultStatus == NKikimrProto::UNKNOWN) {
+        CTEST << "ConductVPatchDiff: Skip vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n";
+        return;
+    }
+    CTEST << "ConductVPatchDiff: Start vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n";
+
+    auto diffEv = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchDiff>({env.VDisks[vdiskIdx]});
+    auto &diffRecord = diffEv->Get()->Record;
+    UNIT_ASSERT(vdisk == VDiskIDFromVDiskID(diffRecord.GetVDiskID()));
+    UNIT_ASSERT_VALUES_EQUAL(args.OriginalId, LogoBlobIDFromLogoBlobID(diffRecord.GetOriginalPartBlobId()).FullID());
+    UNIT_ASSERT_VALUES_EQUAL(args.PatchedId, LogoBlobIDFromLogoBlobID(diffRecord.GetPatchedPartBlobId()).FullID());
+
+    if (env.Info->Type.ErasureFamily() == TErasureType::ErasureMirror) {
+        UNIT_ASSERT_C(!diffEv->Get()->IsXorReceiver(), "it can't be xorreceiver");
+        UNIT_ASSERT_C(!diffRecord.XorReceiversSize(), "it can't has xorreceivers");
+    }
+
+    TInstant now = runtime.GetCurrentTime();
+    UNIT_ASSERT(diffRecord.HasCookie());
     std::unique_ptr<TEvBlobStorage::TEvVPatchResult> result = std::make_unique<TEvBlobStorage::TEvVPatchResult>(
-            resultStatus, args.OriginalId, args.PatchedId, vdisk, diffRecord.GetCookie(), now, 
-            &diffRecord, nullptr, nullptr, nullptr,NWilson::TTraceId(), 0); 
-    result->SetStatusFlagsAndFreeSpace(args.StatusFlags, args.ApproximateFreeSpaceShare); 
- 
-    SendByHandle(runtime, diffEv, std::move(result)); 
-    CTEST << "ConductVPatchDiff: Finish vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n"; 
-} 
- 
-void ConductFailedVPatch(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args) { 
-    CTEST << "ConductFailedVPatch: Start\n"; 
-    for (ui32 idxInSubgroup = 0; idxInSubgroup < args.GType.BlobSubgroupSize(); ++idxInSubgroup) { 
-        TVDiskPointer vdisk = TVDiskPointer::GetVDiskIdx(idxInSubgroup); 
-        ConductVPatchStart(runtime, env, args, EVPatchCase::OnePartLostInStart, vdisk); 
-    } 
-    for (ui32 idxInSubgroup = 0; idxInSubgroup < args.GType.BlobSubgroupSize(); ++idxInSubgroup) { 
-        TVDiskPointer vdisk = TVDiskPointer::GetVDiskIdx(idxInSubgroup); 
-        ConductVPatchDiff(runtime, env, args, EVPatchCase::OnePartLostInStart, vdisk); 
-    } 
-    CTEST << "ConductFailedVPatch: Finish\n"; 
-} 
- 
- 
-void ConductVMovedPatch(TTestBasicRuntime &runtime, const TTestArgs &args, EMovedPatchCase movedCase) { 
-    CTEST << "ConductVMovedPatch: Start\n"; 
-    NKikimrProto::EReplyStatus resultStatus = GetVMovedPatchResultStatus(movedCase); 
-    TAutoPtr<IEventHandle> handle; 
-    TEvBlobStorage::TEvVMovedPatch *vPatch = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVMovedPatch>(handle); 
- 
-    NKikimrBlobStorage::TEvVMovedPatch &vPatchRecord = vPatch->Record; 
-    UNIT_ASSERT(args.OriginalId == LogoBlobIDFromLogoBlobID(vPatchRecord.GetOriginalBlobId())); 
-    UNIT_ASSERT(args.PatchedId == LogoBlobIDFromLogoBlobID(vPatchRecord.GetPatchedBlobId())); 
-    UNIT_ASSERT_VALUES_EQUAL(vPatchRecord.DiffsSize(), args.Diffs.size()); 
-    for (ui32 diffIdx = 0; diffIdx < args.Diffs.size(); ++diffIdx) { 
-        UNIT_ASSERT_VALUES_EQUAL(vPatchRecord.GetDiffs(diffIdx).GetOffset(), args.Diffs[diffIdx].Offset); 
-        UNIT_ASSERT_EQUAL(vPatchRecord.GetDiffs(diffIdx).GetBuffer(), args.Diffs[diffIdx].Buffer); 
-    } 
-    ui64 expectedCookie = ((ui64)args.OriginalId.Hash() << 32) | args.PatchedId.Hash(); 
-    UNIT_ASSERT(vPatchRecord.HasCookie()); 
-    UNIT_ASSERT(vPatchRecord.GetCookie() == expectedCookie); 
- 
-    TVDiskID vDiskId = VDiskIDFromVDiskID(vPatchRecord.GetVDiskID()); 
-    TOutOfSpaceStatus oos(args.StatusFlags, args.ApproximateFreeSpaceShare); 
+            resultStatus, args.OriginalId, args.PatchedId, vdisk, diffRecord.GetCookie(), now,
+            &diffRecord, nullptr, nullptr, nullptr,NWilson::TTraceId(), 0);
+    result->SetStatusFlagsAndFreeSpace(args.StatusFlags, args.ApproximateFreeSpaceShare);
+
+    SendByHandle(runtime, diffEv, std::move(result));
+    CTEST << "ConductVPatchDiff: Finish vdiskIdx# " <<  vdiskIdx << " idxInSubgroup# " << idxInSubgroup << "\n";
+}
+
+void ConductFailedVPatch(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args) {
+    CTEST << "ConductFailedVPatch: Start\n";
+    for (ui32 idxInSubgroup = 0; idxInSubgroup < args.GType.BlobSubgroupSize(); ++idxInSubgroup) {
+        TVDiskPointer vdisk = TVDiskPointer::GetVDiskIdx(idxInSubgroup);
+        ConductVPatchStart(runtime, env, args, EVPatchCase::OnePartLostInStart, vdisk);
+    }
+    for (ui32 idxInSubgroup = 0; idxInSubgroup < args.GType.BlobSubgroupSize(); ++idxInSubgroup) {
+        TVDiskPointer vdisk = TVDiskPointer::GetVDiskIdx(idxInSubgroup);
+        ConductVPatchDiff(runtime, env, args, EVPatchCase::OnePartLostInStart, vdisk);
+    }
+    CTEST << "ConductFailedVPatch: Finish\n";
+}
+
+
+void ConductVMovedPatch(TTestBasicRuntime &runtime, const TTestArgs &args, EMovedPatchCase movedCase) {
+    CTEST << "ConductVMovedPatch: Start\n";
+    NKikimrProto::EReplyStatus resultStatus = GetVMovedPatchResultStatus(movedCase);
+    TAutoPtr<IEventHandle> handle;
+    TEvBlobStorage::TEvVMovedPatch *vPatch = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVMovedPatch>(handle);
+
+    NKikimrBlobStorage::TEvVMovedPatch &vPatchRecord = vPatch->Record;
+    UNIT_ASSERT(args.OriginalId == LogoBlobIDFromLogoBlobID(vPatchRecord.GetOriginalBlobId()));
+    UNIT_ASSERT(args.PatchedId == LogoBlobIDFromLogoBlobID(vPatchRecord.GetPatchedBlobId()));
+    UNIT_ASSERT_VALUES_EQUAL(vPatchRecord.DiffsSize(), args.Diffs.size());
+    for (ui32 diffIdx = 0; diffIdx < args.Diffs.size(); ++diffIdx) {
+        UNIT_ASSERT_VALUES_EQUAL(vPatchRecord.GetDiffs(diffIdx).GetOffset(), args.Diffs[diffIdx].Offset);
+        UNIT_ASSERT_EQUAL(vPatchRecord.GetDiffs(diffIdx).GetBuffer(), args.Diffs[diffIdx].Buffer);
+    }
+    ui64 expectedCookie = ((ui64)args.OriginalId.Hash() << 32) | args.PatchedId.Hash();
+    UNIT_ASSERT(vPatchRecord.HasCookie());
+    UNIT_ASSERT(vPatchRecord.GetCookie() == expectedCookie);
+
+    TVDiskID vDiskId = VDiskIDFromVDiskID(vPatchRecord.GetVDiskID());
+    TOutOfSpaceStatus oos(args.StatusFlags, args.ApproximateFreeSpaceShare);
     std::unique_ptr<TEvBlobStorage::TEvVMovedPatchResult> vPatchResult = std::make_unique<TEvBlobStorage::TEvVMovedPatchResult>(
-            resultStatus, args.OriginalId, args.PatchedId, vDiskId, expectedCookie, oos, 
-            TAppData::TimeProvider->Now(), 0, &vPatchRecord, nullptr, nullptr, nullptr, NWilson::TTraceId(), 0, TString()); 
- 
-    SendByHandle(runtime, handle, std::move(vPatchResult)); 
-    CTEST << "ConductVMovedPatch: Finish\n"; 
-} 
- 
-void ConductMovedPatch(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args, 
-        EMovedPatchCase movedCase) 
-{ 
-    CTEST << "ConductMovedPatch: Start\n"; 
-    ConductFailedVPatch(runtime, env, args); 
-    ConductVMovedPatch(runtime, args, movedCase); 
-    NKikimrProto::EReplyStatus resultStatus = GetPatchResultStatus(movedCase); 
-    if (resultStatus == NKikimrProto::UNKNOWN) { 
-        ConductNaivePatch(runtime, args, ENaivePatchCase::Ok); 
-    } else { 
-        ReceivePatchResult(runtime, args, resultStatus); 
-    } 
-    CTEST << "ConductMovedPatch: Finish\n"; 
-} 
- 
-void ConductFallbackPatch(TTestBasicRuntime &runtime, const TTestArgs &args) { 
-    CTEST << "ConductFallbackPatch: Start\n"; 
-    ConductVMovedPatch(runtime, args, EMovedPatchCase::Ok); 
-    ReceivePatchResult(runtime, args, NKikimrProto::OK); 
-    CTEST << "ConductFallbackPatch: Finish\n"; 
-} 
- 
-void ConductVPatchEvents(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args, 
-        EVPatchCase vpatchCase) 
-{ 
-    CTEST << "ConductVPatchEvents: Start\n"; 
-    for (ui32 idxInSubgroup = 0; idxInSubgroup < args.GType.BlobSubgroupSize(); ++idxInSubgroup) { 
-        TVDiskPointer vdisk = TVDiskPointer::GetVDiskIdx(idxInSubgroup); 
-        ConductVPatchStart(runtime, env, args, vpatchCase, vdisk); 
-    } 
-    for (ui32 idxInSubgroup = 0; idxInSubgroup < args.GType.BlobSubgroupSize(); ++idxInSubgroup) { 
-        TVDiskPointer vdisk = TVDiskPointer::GetVDiskIdx(idxInSubgroup); 
-        ConductVPatchDiff(runtime, env, args, vpatchCase, vdisk); 
-    } 
-    CTEST << "ConductVPatchEvents: Finish\n"; 
-} 
- 
-void ConductVPatch(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args, 
-        EVPatchCase vpatchCase) 
-{ 
-    CTEST << "ConductFallbackPatch: Start\n"; 
-    ConductVPatchEvents(runtime, env, args, vpatchCase); 
-    NKikimrProto::EReplyStatus resultStatus = GetPatchResultStatus(vpatchCase); 
-    if (resultStatus == NKikimrProto::UNKNOWN) { 
-        ConductFallbackPatch(runtime, args); 
-    } else { 
-        ReceivePatchResult(runtime, args, resultStatus); 
-    } 
-    CTEST << "ConductFallbackPatch: Finish\n"; 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-TEvBlobStorage::TEvPatch::TPtr CreatePatch(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args) { 
-    TArrayHolder<TEvBlobStorage::TEvPatch::TDiff> diffs(new TEvBlobStorage::TEvPatch::TDiff[args.Diffs.size()]); 
-    for (ui32 diffIdx = 0; diffIdx < args.Diffs.size(); ++diffIdx) { 
-        const TDiff &diff = args.Diffs[diffIdx]; 
-        UNIT_ASSERT(!diff.IsXor && !diff.IsAligned); 
-        diffs[diffIdx].Offset = diff.Offset; 
-        diffs[diffIdx].Buffer = diff.Buffer; 
-    } 
-    TInstant deadline = runtime.GetCurrentTime() + TDuration::Seconds(5); 
+            resultStatus, args.OriginalId, args.PatchedId, vDiskId, expectedCookie, oos,
+            TAppData::TimeProvider->Now(), 0, &vPatchRecord, nullptr, nullptr, nullptr, NWilson::TTraceId(), 0, TString());
+
+    SendByHandle(runtime, handle, std::move(vPatchResult));
+    CTEST << "ConductVMovedPatch: Finish\n";
+}
+
+void ConductMovedPatch(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args,
+        EMovedPatchCase movedCase)
+{
+    CTEST << "ConductMovedPatch: Start\n";
+    ConductFailedVPatch(runtime, env, args);
+    ConductVMovedPatch(runtime, args, movedCase);
+    NKikimrProto::EReplyStatus resultStatus = GetPatchResultStatus(movedCase);
+    if (resultStatus == NKikimrProto::UNKNOWN) {
+        ConductNaivePatch(runtime, args, ENaivePatchCase::Ok);
+    } else {
+        ReceivePatchResult(runtime, args, resultStatus);
+    }
+    CTEST << "ConductMovedPatch: Finish\n";
+}
+
+void ConductFallbackPatch(TTestBasicRuntime &runtime, const TTestArgs &args) {
+    CTEST << "ConductFallbackPatch: Start\n";
+    ConductVMovedPatch(runtime, args, EMovedPatchCase::Ok);
+    ReceivePatchResult(runtime, args, NKikimrProto::OK);
+    CTEST << "ConductFallbackPatch: Finish\n";
+}
+
+void ConductVPatchEvents(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args,
+        EVPatchCase vpatchCase)
+{
+    CTEST << "ConductVPatchEvents: Start\n";
+    for (ui32 idxInSubgroup = 0; idxInSubgroup < args.GType.BlobSubgroupSize(); ++idxInSubgroup) {
+        TVDiskPointer vdisk = TVDiskPointer::GetVDiskIdx(idxInSubgroup);
+        ConductVPatchStart(runtime, env, args, vpatchCase, vdisk);
+    }
+    for (ui32 idxInSubgroup = 0; idxInSubgroup < args.GType.BlobSubgroupSize(); ++idxInSubgroup) {
+        TVDiskPointer vdisk = TVDiskPointer::GetVDiskIdx(idxInSubgroup);
+        ConductVPatchDiff(runtime, env, args, vpatchCase, vdisk);
+    }
+    CTEST << "ConductVPatchEvents: Finish\n";
+}
+
+void ConductVPatch(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args,
+        EVPatchCase vpatchCase)
+{
+    CTEST << "ConductFallbackPatch: Start\n";
+    ConductVPatchEvents(runtime, env, args, vpatchCase);
+    NKikimrProto::EReplyStatus resultStatus = GetPatchResultStatus(vpatchCase);
+    if (resultStatus == NKikimrProto::UNKNOWN) {
+        ConductFallbackPatch(runtime, args);
+    } else {
+        ReceivePatchResult(runtime, args, resultStatus);
+    }
+    CTEST << "ConductFallbackPatch: Finish\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEvBlobStorage::TEvPatch::TPtr CreatePatch(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args) {
+    TArrayHolder<TEvBlobStorage::TEvPatch::TDiff> diffs(new TEvBlobStorage::TEvPatch::TDiff[args.Diffs.size()]);
+    for (ui32 diffIdx = 0; diffIdx < args.Diffs.size(); ++diffIdx) {
+        const TDiff &diff = args.Diffs[diffIdx];
+        UNIT_ASSERT(!diff.IsXor && !diff.IsAligned);
+        diffs[diffIdx].Offset = diff.Offset;
+        diffs[diffIdx].Buffer = diff.Buffer;
+    }
+    TInstant deadline = runtime.GetCurrentTime() + TDuration::Seconds(5);
     std::unique_ptr<TEvBlobStorage::TEvPatch> patch = std::make_unique<TEvBlobStorage::TEvPatch>(
-            args.OriginalGroupId, args.OriginalId, args.PatchedId, args.MaskForCookieBruteForcing, std::move(diffs), 
-            args.Diffs.size(), deadline); 
-    TEvBlobStorage::TEvPatch::TPtr ev(static_cast<TEventHandle<TEvBlobStorage::TEvPatch>*>( 
+            args.OriginalGroupId, args.OriginalId, args.PatchedId, args.MaskForCookieBruteForcing, std::move(diffs),
+            args.Diffs.size(), deadline);
+    TEvBlobStorage::TEvPatch::TPtr ev(static_cast<TEventHandle<TEvBlobStorage::TEvPatch>*>(
             new IEventHandle(env.FakeProxyActorId, env.FakeProxyActorId, patch.release())));
-    return ev; 
-} 
- 
-void RunNaivePatchTest(TTestBasicRuntime &runtime, const TTestArgs &args, ENaivePatchCase naiveCase) { 
-    TDSProxyEnv env; 
-    env.Configure(runtime, args.GType, args.CurrentGroupId, 0); 
-    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args); 
+    return ev;
+}
+
+void RunNaivePatchTest(TTestBasicRuntime &runtime, const TTestArgs &args, ENaivePatchCase naiveCase) {
+    TDSProxyEnv env;
+    env.Configure(runtime, args.GType, args.CurrentGroupId, 0);
+    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args);
     std::unique_ptr<IActor> patchActor = env.CreatePatchRequestActor(patch, false);
     runtime.Register(patchActor.release());
-    ConductNaivePatch(runtime, args, naiveCase); 
-} 
- 
-void RunMovedPatchTest(TTestBasicRuntime &runtime, const TTestArgs &args, EMovedPatchCase movedCase) { 
-    TDSProxyEnv env; 
-    env.Configure(runtime, args.GType, args.CurrentGroupId, 0); 
-    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args); 
+    ConductNaivePatch(runtime, args, naiveCase);
+}
+
+void RunMovedPatchTest(TTestBasicRuntime &runtime, const TTestArgs &args, EMovedPatchCase movedCase) {
+    TDSProxyEnv env;
+    env.Configure(runtime, args.GType, args.CurrentGroupId, 0);
+    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args);
     std::unique_ptr<IActor> patchActor = env.CreatePatchRequestActor(patch, true);
     runtime.Register(patchActor.release());
-    ConductMovedPatch(runtime, env, args, movedCase); 
-} 
- 
-void RunVPatchTest(TTestBasicRuntime &runtime, const TTestArgs &args, EVPatchCase vpatchCase) { 
-    TDSProxyEnv env; 
-    env.Configure(runtime, args.GType, args.CurrentGroupId, 0); 
-    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args); 
+    ConductMovedPatch(runtime, env, args, movedCase);
+}
+
+void RunVPatchTest(TTestBasicRuntime &runtime, const TTestArgs &args, EVPatchCase vpatchCase) {
+    TDSProxyEnv env;
+    env.Configure(runtime, args.GType, args.CurrentGroupId, 0);
+    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args);
     std::unique_ptr<IActor> patchActor = env.CreatePatchRequestActor(patch, true);
     runtime.Register(patchActor.release());
-    ConductVPatch(runtime, env, args, vpatchCase); 
-} 
- 
-void SetLogPriorities(TTestBasicRuntime &runtime) { 
-    bool IsVerbose = false; 
-    if (IsVerbose) { 
-        runtime.SetLogPriority(NKikimrServices::BS_PROXY_PATCH, NLog::PRI_DEBUG); 
-        runtime.SetLogPriority(NActorsServices::TEST, NLog::PRI_DEBUG); 
-    } 
-    runtime.SetLogPriority(NKikimrServices::BS_PROXY, NLog::PRI_CRIT); 
-    runtime.SetLogPriority(NKikimrServices::BS_QUEUE, NLog::PRI_CRIT); 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-Y_UNIT_TEST_SUITE(TDSProxyPatchTest) { 
- 
-template <typename ECase> 
-void RunGeneralTest(void(*runner)(TTestBasicRuntime &runtime, const TTestArgs &args, ECase testCase), 
-        TErasureType::TErasureType::EErasureSpecies erasure, 
-        ECase testCase) 
-{ 
-    TTestArgs args; 
-    args.MakeDefault(erasure, true); 
-    TTestBasicRuntime runtime(1, false); 
-    SetLogPriorities(runtime); 
-    SetupRuntime(runtime); 
-    runner(runtime, args, testCase); 
-} 
- 
-#define Y_UNIT_TEST_NAIVE(naiveCase, erasure) \ 
-    Y_UNIT_TEST(Naive ## naiveCase ## _ ## erasure) { \ 
-        RunGeneralTest(RunNaivePatchTest, TErasureType::TErasureType:: erasure, ENaivePatchCase:: naiveCase); \ 
-    } \ 
-// end Y_UNIT_TEST_NAIVE 
- 
-#define Y_UNIT_TEST_MOVED(movedCase, erasure) \ 
-    Y_UNIT_TEST(Moved ## movedCase ## _ ## erasure) { \ 
-        RunGeneralTest(RunMovedPatchTest, TErasureType::TErasureType:: erasure, EMovedPatchCase:: movedCase); \ 
-    } \ 
-// end Y_UNIT_TEST_MOVED 
- 
-#define Y_UNIT_TEST_VPATCH(vpatchCase, erasure) \ 
-    Y_UNIT_TEST(VPatch ## vpatchCase ## _ ## erasure) { \ 
-        RunGeneralTest(RunVPatchTest, TErasureType::TErasureType:: erasure, EVPatchCase:: vpatchCase); \ 
-    } \ 
-// end Y_UNIT_TEST_VPATCH 
- 
-#define Y_UNIT_TEST_PATCH_PACK(erasure) \ 
-    Y_UNIT_TEST_NAIVE(Ok, erasure) \ 
-    Y_UNIT_TEST_NAIVE(ErrorOnGetItem, erasure) \ 
-    Y_UNIT_TEST_NAIVE(ErrorOnGet, erasure) \ 
-    Y_UNIT_TEST_NAIVE(ErrorOnPut, erasure) \ 
-    Y_UNIT_TEST_MOVED(Ok, erasure) \ 
-    Y_UNIT_TEST_MOVED(Error, erasure) \ 
-    Y_UNIT_TEST_VPATCH(Ok, erasure) \ 
-    Y_UNIT_TEST_VPATCH(OneErrorAndAllPartExistInStart, erasure) \ 
-    Y_UNIT_TEST_VPATCH(OnePartLostInStart, erasure) \ 
-    Y_UNIT_TEST_VPATCH(DeadGroupInStart, erasure) \ 
-    Y_UNIT_TEST_VPATCH(ErrorDuringVPatchDiff, erasure) \ 
-// end Y_UNIT_TEST_PATCH_PACK 
- 
-    Y_UNIT_TEST_PATCH_PACK(ErasureNone) 
-    Y_UNIT_TEST_PATCH_PACK(Erasure4Plus2Block) 
-    Y_UNIT_TEST_PATCH_PACK(ErasureMirror3) 
-    Y_UNIT_TEST_PATCH_PACK(ErasureMirror3dc) 
- 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////// 
- 
-void MakeFaultToleranceArgsForBlock4Plus2(TTestArgs &args, i64 wiped1, i64 wiped2, 
-        ui32 errorMask, i64 handoff1, i64 handoff2, i64 extraHandoff) 
-{ 
-    args.ResetDefaultPlacement(); 
-    if (wiped1 != -1) { 
-        args.PartPlacement[wiped1].clear(); 
-    } 
-    if (wiped2 != -1) { 
-        args.PartPlacement[wiped2].clear(); 
-    } 
-    if (handoff1 > 0) { 
-        args.PartPlacement[6].push_back(handoff1); 
-    } 
-    if (handoff2 > 0) { 
-        args.PartPlacement[7].push_back(handoff2); 
-    } 
-    if (extraHandoff < 0) { 
-        args.PartPlacement[6].push_back(-extraHandoff); 
-    } 
-    if (extraHandoff > 0) { 
-        args.PartPlacement[7].push_back(extraHandoff); 
-    } 
-    for (ui32 bit = 1, idx = 0; bit < errorMask; idx++, bit <<= 1) { 
-        args.ErrorVDisks[idx] = (errorMask & bit); 
-    } 
-} 
- 
-void MakeFaultToleranceArgsForMirror3dc(TTestArgs &args, bool is2x2, ui32 errorMask, i64 wipedDc, i64 startIdxInDc[]) { 
-    args.ResetDefaultPlacement(); 
-    for (auto &pl : args.PartPlacement) { 
-        pl.clear(); 
-    } 
- 
-    for (ui32 dcIdx = 0; dcIdx < 3; ++dcIdx) { 
-        ui32 replCnt = is2x2 ? 2 : 1; 
-        ui32 startIdx = dcIdx * 3; 
-        for (ui32 replIdx = 0; replIdx < replCnt; ++replIdx) { 
-            ui32 orderIdx = (startIdxInDc[dcIdx] + replIdx) % 3; 
-            ui32 diskIdx = startIdx + orderIdx; 
-            args.PartPlacement[diskIdx].push_back(dcIdx + 1); 
-        } 
-    } 
- 
-    if (wipedDc >= 0) { 
-        ui32 startIdx = wipedDc * 3; 
-        for (ui32 orderIdx = 0; orderIdx < 3; ++orderIdx) { 
-            ui32 diskIdx = startIdx + orderIdx; 
-            args.PartPlacement[diskIdx].clear(); 
-        } 
-    } 
- 
-    for (ui32 bit = 1, idx = 0; bit < errorMask; idx++, bit <<= 1) { 
-        args.ErrorVDisks[idx] = (errorMask & bit); 
-    } 
-} 
- 
-enum class EFaultToleranceCase { 
-    Ok, 
-    Fallback 
-}; 
- 
-EFaultToleranceCase GetFaultToleranceCaseForBlock4Plus2(const TDSProxyEnv &env, const TTestArgs &args) { 
-    UNIT_ASSERT_VALUES_EQUAL(args.PartPlacement.size(), args.ErrorVDisks.size()); 
-    UNIT_ASSERT_VALUES_EQUAL(args.PartPlacement.size(), env.Info->Type.BlobSubgroupSize()); 
-    TSubgroupPartLayout layout; 
-    for (ui32 vdiskIdx = 0; vdiskIdx <  env.Info->Type.BlobSubgroupSize(); ++vdiskIdx) { 
-        if (!args.ErrorVDisks[vdiskIdx]) { 
-            auto [_, idxInSubgroup] = TVDiskPointer::GetVDiskIdx(vdiskIdx).GetIndecies(env, args.OriginalId.Hash()); 
-            for (ui64 partId : args.PartPlacement[idxInSubgroup]) { 
-                layout.AddItem(idxInSubgroup, partId - 1, env.Info->Type); 
-            } 
-        } 
-    } 
-    if (layout.CountEffectiveReplicas(env.Info->Type) == env.Info->Type.TotalPartCount()) { 
-        return EFaultToleranceCase::Ok; 
-    } else { 
-        return EFaultToleranceCase::Fallback; 
-    } 
-} 
- 
- 
-EFaultToleranceCase GetFaultToleranceCaseForMirror3dc(const TDSProxyEnv &env, const TTestArgs &args) { 
-    UNIT_ASSERT_VALUES_EQUAL(args.PartPlacement.size(), args.ErrorVDisks.size()); 
-    UNIT_ASSERT_VALUES_EQUAL(args.PartPlacement.size(), env.Info->Type.BlobSubgroupSize()); 
-    TSubgroupPartLayout layout; 
-    constexpr ui32 dcCnt = 3; 
-    ui32 replInDc[dcCnt] = {0, 0, 0}; 
-    for (ui32 vdiskIdx = 0; vdiskIdx < env.Info->Type.BlobSubgroupSize(); ++vdiskIdx) { 
-        if (!args.ErrorVDisks[vdiskIdx] && args.PartPlacement[vdiskIdx]) { 
-            ui32 dcIdx = vdiskIdx / 3; 
-            replInDc[dcIdx]++; 
-        } 
-    } 
-    ui32 x2cnt = 0; 
-    for (ui32 dcIdx = 0; dcIdx < dcCnt; ++dcIdx) { 
-        x2cnt += (replInDc[dcIdx] >= 2); 
-    } 
-    if ((replInDc[0] && replInDc[1] && replInDc[2]) || x2cnt >= 2) { 
-        return EFaultToleranceCase::Ok; 
-    } else { 
-        return EFaultToleranceCase::Fallback; 
-    } 
-} 
- 
-void ConductFaultTolerance(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args, 
-        EFaultToleranceCase faultCase) 
-{ 
-    CTEST << "ConductFallbackPatch: Start\n"; 
-    ConductVPatchEvents(runtime, env, args, EVPatchCase::Custom); 
-    if (faultCase == EFaultToleranceCase::Fallback) { 
-        ConductFallbackPatch(runtime, args); 
-    } else { 
-        ReceivePatchResult(runtime, args, NKikimrProto::OK); 
-    } 
-    CTEST << "ConductFallbackPatch: Finish\n"; 
-} 
- 
-void RunFaultToleranceBlock4Plus2(TTestBasicRuntime &runtime, const TTestArgs &args) { 
-    TDSProxyEnv env; 
-    env.Configure(runtime, args.GType, args.CurrentGroupId, 0); 
-    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args); 
+    ConductVPatch(runtime, env, args, vpatchCase);
+}
+
+void SetLogPriorities(TTestBasicRuntime &runtime) {
+    bool IsVerbose = false;
+    if (IsVerbose) {
+        runtime.SetLogPriority(NKikimrServices::BS_PROXY_PATCH, NLog::PRI_DEBUG);
+        runtime.SetLogPriority(NActorsServices::TEST, NLog::PRI_DEBUG);
+    }
+    runtime.SetLogPriority(NKikimrServices::BS_PROXY, NLog::PRI_CRIT);
+    runtime.SetLogPriority(NKikimrServices::BS_QUEUE, NLog::PRI_CRIT);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+Y_UNIT_TEST_SUITE(TDSProxyPatchTest) {
+
+template <typename ECase>
+void RunGeneralTest(void(*runner)(TTestBasicRuntime &runtime, const TTestArgs &args, ECase testCase),
+        TErasureType::TErasureType::EErasureSpecies erasure,
+        ECase testCase)
+{
+    TTestArgs args;
+    args.MakeDefault(erasure, true);
+    TTestBasicRuntime runtime(1, false);
+    SetLogPriorities(runtime);
+    SetupRuntime(runtime);
+    runner(runtime, args, testCase);
+}
+
+#define Y_UNIT_TEST_NAIVE(naiveCase, erasure) \
+    Y_UNIT_TEST(Naive ## naiveCase ## _ ## erasure) { \
+        RunGeneralTest(RunNaivePatchTest, TErasureType::TErasureType:: erasure, ENaivePatchCase:: naiveCase); \
+    } \
+// end Y_UNIT_TEST_NAIVE
+
+#define Y_UNIT_TEST_MOVED(movedCase, erasure) \
+    Y_UNIT_TEST(Moved ## movedCase ## _ ## erasure) { \
+        RunGeneralTest(RunMovedPatchTest, TErasureType::TErasureType:: erasure, EMovedPatchCase:: movedCase); \
+    } \
+// end Y_UNIT_TEST_MOVED
+
+#define Y_UNIT_TEST_VPATCH(vpatchCase, erasure) \
+    Y_UNIT_TEST(VPatch ## vpatchCase ## _ ## erasure) { \
+        RunGeneralTest(RunVPatchTest, TErasureType::TErasureType:: erasure, EVPatchCase:: vpatchCase); \
+    } \
+// end Y_UNIT_TEST_VPATCH
+
+#define Y_UNIT_TEST_PATCH_PACK(erasure) \
+    Y_UNIT_TEST_NAIVE(Ok, erasure) \
+    Y_UNIT_TEST_NAIVE(ErrorOnGetItem, erasure) \
+    Y_UNIT_TEST_NAIVE(ErrorOnGet, erasure) \
+    Y_UNIT_TEST_NAIVE(ErrorOnPut, erasure) \
+    Y_UNIT_TEST_MOVED(Ok, erasure) \
+    Y_UNIT_TEST_MOVED(Error, erasure) \
+    Y_UNIT_TEST_VPATCH(Ok, erasure) \
+    Y_UNIT_TEST_VPATCH(OneErrorAndAllPartExistInStart, erasure) \
+    Y_UNIT_TEST_VPATCH(OnePartLostInStart, erasure) \
+    Y_UNIT_TEST_VPATCH(DeadGroupInStart, erasure) \
+    Y_UNIT_TEST_VPATCH(ErrorDuringVPatchDiff, erasure) \
+// end Y_UNIT_TEST_PATCH_PACK
+
+    Y_UNIT_TEST_PATCH_PACK(ErasureNone)
+    Y_UNIT_TEST_PATCH_PACK(Erasure4Plus2Block)
+    Y_UNIT_TEST_PATCH_PACK(ErasureMirror3)
+    Y_UNIT_TEST_PATCH_PACK(ErasureMirror3dc)
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void MakeFaultToleranceArgsForBlock4Plus2(TTestArgs &args, i64 wiped1, i64 wiped2,
+        ui32 errorMask, i64 handoff1, i64 handoff2, i64 extraHandoff)
+{
+    args.ResetDefaultPlacement();
+    if (wiped1 != -1) {
+        args.PartPlacement[wiped1].clear();
+    }
+    if (wiped2 != -1) {
+        args.PartPlacement[wiped2].clear();
+    }
+    if (handoff1 > 0) {
+        args.PartPlacement[6].push_back(handoff1);
+    }
+    if (handoff2 > 0) {
+        args.PartPlacement[7].push_back(handoff2);
+    }
+    if (extraHandoff < 0) {
+        args.PartPlacement[6].push_back(-extraHandoff);
+    }
+    if (extraHandoff > 0) {
+        args.PartPlacement[7].push_back(extraHandoff);
+    }
+    for (ui32 bit = 1, idx = 0; bit < errorMask; idx++, bit <<= 1) {
+        args.ErrorVDisks[idx] = (errorMask & bit);
+    }
+}
+
+void MakeFaultToleranceArgsForMirror3dc(TTestArgs &args, bool is2x2, ui32 errorMask, i64 wipedDc, i64 startIdxInDc[]) {
+    args.ResetDefaultPlacement();
+    for (auto &pl : args.PartPlacement) {
+        pl.clear();
+    }
+
+    for (ui32 dcIdx = 0; dcIdx < 3; ++dcIdx) {
+        ui32 replCnt = is2x2 ? 2 : 1;
+        ui32 startIdx = dcIdx * 3;
+        for (ui32 replIdx = 0; replIdx < replCnt; ++replIdx) {
+            ui32 orderIdx = (startIdxInDc[dcIdx] + replIdx) % 3;
+            ui32 diskIdx = startIdx + orderIdx;
+            args.PartPlacement[diskIdx].push_back(dcIdx + 1);
+        }
+    }
+
+    if (wipedDc >= 0) {
+        ui32 startIdx = wipedDc * 3;
+        for (ui32 orderIdx = 0; orderIdx < 3; ++orderIdx) {
+            ui32 diskIdx = startIdx + orderIdx;
+            args.PartPlacement[diskIdx].clear();
+        }
+    }
+
+    for (ui32 bit = 1, idx = 0; bit < errorMask; idx++, bit <<= 1) {
+        args.ErrorVDisks[idx] = (errorMask & bit);
+    }
+}
+
+enum class EFaultToleranceCase {
+    Ok,
+    Fallback
+};
+
+EFaultToleranceCase GetFaultToleranceCaseForBlock4Plus2(const TDSProxyEnv &env, const TTestArgs &args) {
+    UNIT_ASSERT_VALUES_EQUAL(args.PartPlacement.size(), args.ErrorVDisks.size());
+    UNIT_ASSERT_VALUES_EQUAL(args.PartPlacement.size(), env.Info->Type.BlobSubgroupSize());
+    TSubgroupPartLayout layout;
+    for (ui32 vdiskIdx = 0; vdiskIdx <  env.Info->Type.BlobSubgroupSize(); ++vdiskIdx) {
+        if (!args.ErrorVDisks[vdiskIdx]) {
+            auto [_, idxInSubgroup] = TVDiskPointer::GetVDiskIdx(vdiskIdx).GetIndecies(env, args.OriginalId.Hash());
+            for (ui64 partId : args.PartPlacement[idxInSubgroup]) {
+                layout.AddItem(idxInSubgroup, partId - 1, env.Info->Type);
+            }
+        }
+    }
+    if (layout.CountEffectiveReplicas(env.Info->Type) == env.Info->Type.TotalPartCount()) {
+        return EFaultToleranceCase::Ok;
+    } else {
+        return EFaultToleranceCase::Fallback;
+    }
+}
+
+
+EFaultToleranceCase GetFaultToleranceCaseForMirror3dc(const TDSProxyEnv &env, const TTestArgs &args) {
+    UNIT_ASSERT_VALUES_EQUAL(args.PartPlacement.size(), args.ErrorVDisks.size());
+    UNIT_ASSERT_VALUES_EQUAL(args.PartPlacement.size(), env.Info->Type.BlobSubgroupSize());
+    TSubgroupPartLayout layout;
+    constexpr ui32 dcCnt = 3;
+    ui32 replInDc[dcCnt] = {0, 0, 0};
+    for (ui32 vdiskIdx = 0; vdiskIdx < env.Info->Type.BlobSubgroupSize(); ++vdiskIdx) {
+        if (!args.ErrorVDisks[vdiskIdx] && args.PartPlacement[vdiskIdx]) {
+            ui32 dcIdx = vdiskIdx / 3;
+            replInDc[dcIdx]++;
+        }
+    }
+    ui32 x2cnt = 0;
+    for (ui32 dcIdx = 0; dcIdx < dcCnt; ++dcIdx) {
+        x2cnt += (replInDc[dcIdx] >= 2);
+    }
+    if ((replInDc[0] && replInDc[1] && replInDc[2]) || x2cnt >= 2) {
+        return EFaultToleranceCase::Ok;
+    } else {
+        return EFaultToleranceCase::Fallback;
+    }
+}
+
+void ConductFaultTolerance(TTestBasicRuntime &runtime, const TDSProxyEnv &env, const TTestArgs &args,
+        EFaultToleranceCase faultCase)
+{
+    CTEST << "ConductFallbackPatch: Start\n";
+    ConductVPatchEvents(runtime, env, args, EVPatchCase::Custom);
+    if (faultCase == EFaultToleranceCase::Fallback) {
+        ConductFallbackPatch(runtime, args);
+    } else {
+        ReceivePatchResult(runtime, args, NKikimrProto::OK);
+    }
+    CTEST << "ConductFallbackPatch: Finish\n";
+}
+
+void RunFaultToleranceBlock4Plus2(TTestBasicRuntime &runtime, const TTestArgs &args) {
+    TDSProxyEnv env;
+    env.Configure(runtime, args.GType, args.CurrentGroupId, 0);
+    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args);
     std::unique_ptr<IActor> patchActor = env.CreatePatchRequestActor(patch, true);
     runtime.Register(patchActor.release());
-    ConductFaultTolerance(runtime, env, args, GetFaultToleranceCaseForBlock4Plus2(env, args)); 
-} 
- 
-void RunFaultToleranceMirror3dc(TTestBasicRuntime &runtime, const TTestArgs &args) { 
-    TDSProxyEnv env; 
-    env.Configure(runtime, args.GType, args.CurrentGroupId, 0); 
-    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args); 
+    ConductFaultTolerance(runtime, env, args, GetFaultToleranceCaseForBlock4Plus2(env, args));
+}
+
+void RunFaultToleranceMirror3dc(TTestBasicRuntime &runtime, const TTestArgs &args) {
+    TDSProxyEnv env;
+    env.Configure(runtime, args.GType, args.CurrentGroupId, 0);
+    TEvBlobStorage::TEvPatch::TPtr patch = CreatePatch(runtime, env, args);
     std::unique_ptr<IActor> patchActor = env.CreatePatchRequestActor(patch, true);
     runtime.Register(patchActor.release());
-    ConductFaultTolerance(runtime, env, args, GetFaultToleranceCaseForMirror3dc(env, args)); 
-} 
- 
- 
-Y_UNIT_TEST_SUITE(TDSProxyFaultTolerancePatchTest) { 
-    Y_UNIT_TEST(mirror3dc) { 
-        TBlobStorageGroupType type = TBlobStorageGroupType::ErasureMirror3dc; 
-        ui64 errorMaskEnd = (1 << type.BlobSubgroupSize()); 
- 
-        TTestArgs args; 
-        args.MakeDefault(type); 
-        for (bool is2x2 : {false, true}) { 
-            for (i64 wipedDc = -1; wipedDc < 3; ++wipedDc) { 
-                //for (i64 i = 0; i < 27; ++i) { // don't use because this test alreade is very fat 
-                i64 startIdxInDC[3] = {0, 0, 0}; // {i % 3, i / 3 % 3, i / 9}; 
-                TTestBasicRuntime runtime; 
-                SetupRuntime(runtime); 
-                for (ui32 errorMask = 0; errorMask < errorMaskEnd; ++errorMask) { 
-                    MakeFaultToleranceArgsForMirror3dc(args, is2x2, errorMask, wipedDc, startIdxInDC); 
-                    RunFaultToleranceMirror3dc(runtime, args); 
-                } 
-                //} 
-            } 
-        } 
-    } 
- 
- 
-    Y_UNIT_TEST(block42) { 
-        TBlobStorageGroupType type = TBlobStorageGroupType::Erasure4Plus2Block; 
-        ui64 errorMaskEnd = (1 << type.BlobSubgroupSize()); 
- 
-        TTestArgs args; 
-        args.MakeDefault(type); 
-        for (i64 wiped1 = -1; wiped1 < type.TotalPartCount(); ++wiped1) { 
-            for (i64 wiped2 = -1; wiped2 < type.TotalPartCount(); ++wiped2) { 
-                if (wiped1 != -1 && wiped1 >= wiped2) { 
-                    continue; 
-                } 
-                TTestBasicRuntime runtime; 
-                SetupRuntime(runtime); 
-                for (ui32 errorMask = 0; errorMask < errorMaskEnd; ++errorMask) { 
-                    for (i64 extra = -type.TotalPartCount(); extra <= type.TotalPartCount(); extra++) { 
-                        if (extra == wiped1 + 1 || extra == wiped2 + 1) { 
-                            continue; 
-                        } 
-                        if (-extra == wiped1 + 1 || -extra == wiped2 + 1) { 
-                            continue; 
-                        } 
-                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, 0, 0, extra); 
-                        RunFaultToleranceBlock4Plus2(runtime, args); 
-                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, wiped1 + 1, 0, extra); 
-                        RunFaultToleranceBlock4Plus2(runtime, args); 
-                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, wiped2 + 1, 0, extra); 
-                        RunFaultToleranceBlock4Plus2(runtime, args); 
-                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, 0, wiped1 + 1, extra); 
-                        RunFaultToleranceBlock4Plus2(runtime, args); 
-                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, 0, wiped2 + 1, extra); 
-                        RunFaultToleranceBlock4Plus2(runtime, args); 
-                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, wiped1 + 1, wiped2 + 1, extra); 
-                        RunFaultToleranceBlock4Plus2(runtime, args); 
-                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, wiped2 + 1, wiped1 + 1, extra); 
-                        RunFaultToleranceBlock4Plus2(runtime, args); 
-                    } 
-                } 
-            } 
-        } 
-    } 
-} 
- 
-} // NDSProxyPatchTest 
-} // NKikimr 
+    ConductFaultTolerance(runtime, env, args, GetFaultToleranceCaseForMirror3dc(env, args));
+}
+
+
+Y_UNIT_TEST_SUITE(TDSProxyFaultTolerancePatchTest) {
+    Y_UNIT_TEST(mirror3dc) {
+        TBlobStorageGroupType type = TBlobStorageGroupType::ErasureMirror3dc;
+        ui64 errorMaskEnd = (1 << type.BlobSubgroupSize());
+
+        TTestArgs args;
+        args.MakeDefault(type);
+        for (bool is2x2 : {false, true}) {
+            for (i64 wipedDc = -1; wipedDc < 3; ++wipedDc) {
+                //for (i64 i = 0; i < 27; ++i) { // don't use because this test alreade is very fat
+                i64 startIdxInDC[3] = {0, 0, 0}; // {i % 3, i / 3 % 3, i / 9};
+                TTestBasicRuntime runtime;
+                SetupRuntime(runtime);
+                for (ui32 errorMask = 0; errorMask < errorMaskEnd; ++errorMask) {
+                    MakeFaultToleranceArgsForMirror3dc(args, is2x2, errorMask, wipedDc, startIdxInDC);
+                    RunFaultToleranceMirror3dc(runtime, args);
+                }
+                //}
+            }
+        }
+    }
+
+
+    Y_UNIT_TEST(block42) {
+        TBlobStorageGroupType type = TBlobStorageGroupType::Erasure4Plus2Block;
+        ui64 errorMaskEnd = (1 << type.BlobSubgroupSize());
+
+        TTestArgs args;
+        args.MakeDefault(type);
+        for (i64 wiped1 = -1; wiped1 < type.TotalPartCount(); ++wiped1) {
+            for (i64 wiped2 = -1; wiped2 < type.TotalPartCount(); ++wiped2) {
+                if (wiped1 != -1 && wiped1 >= wiped2) {
+                    continue;
+                }
+                TTestBasicRuntime runtime;
+                SetupRuntime(runtime);
+                for (ui32 errorMask = 0; errorMask < errorMaskEnd; ++errorMask) {
+                    for (i64 extra = -type.TotalPartCount(); extra <= type.TotalPartCount(); extra++) {
+                        if (extra == wiped1 + 1 || extra == wiped2 + 1) {
+                            continue;
+                        }
+                        if (-extra == wiped1 + 1 || -extra == wiped2 + 1) {
+                            continue;
+                        }
+                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, 0, 0, extra);
+                        RunFaultToleranceBlock4Plus2(runtime, args);
+                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, wiped1 + 1, 0, extra);
+                        RunFaultToleranceBlock4Plus2(runtime, args);
+                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, wiped2 + 1, 0, extra);
+                        RunFaultToleranceBlock4Plus2(runtime, args);
+                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, 0, wiped1 + 1, extra);
+                        RunFaultToleranceBlock4Plus2(runtime, args);
+                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, 0, wiped2 + 1, extra);
+                        RunFaultToleranceBlock4Plus2(runtime, args);
+                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, wiped1 + 1, wiped2 + 1, extra);
+                        RunFaultToleranceBlock4Plus2(runtime, args);
+                        MakeFaultToleranceArgsForBlock4Plus2(args, wiped1, wiped2, errorMask, wiped2 + 1, wiped1 + 1, extra);
+                        RunFaultToleranceBlock4Plus2(runtime, args);
+                    }
+                }
+            }
+        }
+    }
+}
+
+} // NDSProxyPatchTest
+} // NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_put_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_put_ut.cpp
index f1b6e602f8..d2d39a3550 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_put_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_put_ut.cpp
@@ -1,15 +1,15 @@
 #include "defs.h"
-#include "dsproxy_vdisk_mock_ut.h" 
-#include "dsproxy_env_mock_ut.h" 
+#include "dsproxy_vdisk_mock_ut.h"
+#include "dsproxy_env_mock_ut.h"
 
 #include <ydb/core/blobstorage/dsproxy/dsproxy_put_impl.h>
 #include <ydb/core/blobstorage/vdisk/common/vdisk_events.h>
- 
+
 #include <ydb/core/testlib/basics/runtime.h>
 #include <ydb/core/testlib/actor_helpers.h>
 
 #include <library/cpp/containers/stack_vector/stack_vec.h>
-#include <library/cpp/testing/unittest/registar.h> 
+#include <library/cpp/testing/unittest/registar.h>
 
 namespace NKikimr {
 namespace NDSProxyPutTest {
@@ -25,264 +25,264 @@ TString AlphaData(ui32 size) {
     return data;
 }
 
-void TestPutMaxPartCountOnHandoff(TErasureType::EErasureSpecies erasureSpecies) { 
-    TActorSystemStub actorSystemStub; 
-    i32 size = 786; 
-    TLogoBlobID blobId(72075186224047637, 1, 863, 1, size, 24576); 
-    TString data = AlphaData(size); 
-
-    const ui32 groupId = 0; 
-    TBlobStorageGroupType groupType(erasureSpecies); 
-    const ui32 domainCount = groupType.BlobSubgroupSize();; 
- 
-    TGroupMock group(groupId, erasureSpecies, domainCount, 1); 
+void TestPutMaxPartCountOnHandoff(TErasureType::EErasureSpecies erasureSpecies) {
+    TActorSystemStub actorSystemStub;
+    i32 size = 786;
+    TLogoBlobID blobId(72075186224047637, 1, 863, 1, size, 24576);
+    TString data = AlphaData(size);
+
+    const ui32 groupId = 0;
+    TBlobStorageGroupType groupType(erasureSpecies);
+    const ui32 domainCount = groupType.BlobSubgroupSize();;
+
+    TGroupMock group(groupId, erasureSpecies, domainCount, 1);
     TIntrusivePtr<TGroupQueues> groupQueues = group.MakeGroupQueues();
- 
-    TIntrusivePtr<NMonitoring::TDynamicCounters> counters(new NMonitoring::TDynamicCounters()); 
+
+    TIntrusivePtr<NMonitoring::TDynamicCounters> counters(new NMonitoring::TDynamicCounters());
     TIntrusivePtr<TDsProxyNodeMon> nodeMon(new TDsProxyNodeMon(counters, true));
-    TIntrusivePtr<TBlobStorageGroupProxyMon> mon(new TBlobStorageGroupProxyMon(counters, counters, counters, 
+    TIntrusivePtr<TBlobStorageGroupProxyMon> mon(new TBlobStorageGroupProxyMon(counters, counters, counters,
                 group.GetInfo(), nodeMon, false));
- 
-    TLogContext logCtx(NKikimrServices::BS_PROXY_PUT, false); 
-    logCtx.LogAcc.IsLogEnabled = false; 
- 
-    const ui32 hash = blobId.Hash(); 
-    const ui32 totalvd = group.GetInfo()->Type.BlobSubgroupSize(); 
-    const ui32 totalParts = group.GetInfo()->Type.TotalPartCount(); 
-    Y_VERIFY(blobId.BlobSize() == data.size()); 
-    Y_VERIFY(totalvd >= totalParts); 
-    TBlobStorageGroupInfo::TServiceIds vDisksSvc; 
-    TBlobStorageGroupInfo::TVDiskIds vDisksId; 
-    group.GetInfo()->PickSubgroup(hash, &vDisksId, &vDisksSvc); 
- 
-    TString encryptedData = data; 
-    char *dataBytes = encryptedData.Detach(); 
-    Encrypt(dataBytes, dataBytes, 0, encryptedData.size(), blobId, *group.GetInfo()); 
- 
-    TBatchedVec<TDataPartSet> partSetSingleton(1); 
-    partSetSingleton[0].Parts.resize(totalParts); 
-    group.GetInfo()->Type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedData, partSetSingleton[0]); 
- 
-    TEvBlobStorage::TEvPut ev(blobId, data, TInstant::Max(), NKikimrBlobStorage::TabletLog, 
-            TEvBlobStorage::TEvPut::TacticDefault); 
- 
-    TPutImpl putImpl(group.GetInfo(), groupQueues, &ev, mon, false); 
- 
-    for (ui32 idx = 0; idx < domainCount; ++idx) { 
-        group.SetPredictedDelayNs(idx, 1); 
-    } 
-    group.SetPredictedDelayNs(7, 10); 
- 
+
+    TLogContext logCtx(NKikimrServices::BS_PROXY_PUT, false);
+    logCtx.LogAcc.IsLogEnabled = false;
+
+    const ui32 hash = blobId.Hash();
+    const ui32 totalvd = group.GetInfo()->Type.BlobSubgroupSize();
+    const ui32 totalParts = group.GetInfo()->Type.TotalPartCount();
+    Y_VERIFY(blobId.BlobSize() == data.size());
+    Y_VERIFY(totalvd >= totalParts);
+    TBlobStorageGroupInfo::TServiceIds vDisksSvc;
+    TBlobStorageGroupInfo::TVDiskIds vDisksId;
+    group.GetInfo()->PickSubgroup(hash, &vDisksId, &vDisksSvc);
+
+    TString encryptedData = data;
+    char *dataBytes = encryptedData.Detach();
+    Encrypt(dataBytes, dataBytes, 0, encryptedData.size(), blobId, *group.GetInfo());
+
+    TBatchedVec<TDataPartSet> partSetSingleton(1);
+    partSetSingleton[0].Parts.resize(totalParts);
+    group.GetInfo()->Type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedData, partSetSingleton[0]);
+
+    TEvBlobStorage::TEvPut ev(blobId, data, TInstant::Max(), NKikimrBlobStorage::TabletLog,
+            TEvBlobStorage::TEvPut::TacticDefault);
+
+    TPutImpl putImpl(group.GetInfo(), groupQueues, &ev, mon, false);
+
+    for (ui32 idx = 0; idx < domainCount; ++idx) {
+        group.SetPredictedDelayNs(idx, 1);
+    }
+    group.SetPredictedDelayNs(7, 10);
+
     TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
-    putImpl.GenerateInitialRequests(logCtx, partSetSingleton, vPuts); 
-    group.SetError(0, NKikimrProto::ERROR); 
- 
-    TPutImpl::TPutResultVec putResults; 
- 
-    TVector<ui32> diskSequence = {0, 7, 7, 7, 7, 6, 3, 4, 5, 1, 2}; 
-    TVector<ui32> slowDiskSequence = {3, 4, 5, 6, 1, 2}; 
- 
-    for (ui32 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) { 
-        ui32 nextVPut = vPutIdx; 
-        ui32 diskPos = (ui32)-1; 
-        for (ui32 i = vPutIdx; i < vPuts.size(); ++i) { 
-            auto& record = vPuts[i]->Record; 
-            TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
-            ui32 diskIdx = group.VDiskIdx(vDiskId); 
-            auto it = Find(diskSequence, diskIdx); 
-            if (it != diskSequence.end()) { 
-                ui32 pos = it - diskSequence.begin(); 
-                if (pos < diskPos) { 
-                    nextVPut = i; 
-                    diskPos = pos; 
-                } 
-            } 
-        } 
-        CTEST << "vdisk exp# " << (diskSequence.size() ? diskSequence.front() : -1) << " get# " << group.VDiskIdx(VDiskIDFromVDiskID(vPuts[nextVPut]->Record.GetVDiskID())) << Endl; 
-        if (diskPos != (ui32)-1) { 
-            diskSequence.erase(diskSequence.begin() + diskPos); 
-        } 
-        std::swap(vPuts[vPutIdx], vPuts[nextVPut]); 
- 
-        for (ui32 idx = 0; idx < domainCount; ++idx) { 
-            group.SetPredictedDelayNs(idx, 1); 
-        } 
-        if (vPutIdx < slowDiskSequence.size()) { 
-            group.SetPredictedDelayNs(slowDiskSequence[vPutIdx], 10); 
-        } 
- 
+    putImpl.GenerateInitialRequests(logCtx, partSetSingleton, vPuts);
+    group.SetError(0, NKikimrProto::ERROR);
+
+    TPutImpl::TPutResultVec putResults;
+
+    TVector<ui32> diskSequence = {0, 7, 7, 7, 7, 6, 3, 4, 5, 1, 2};
+    TVector<ui32> slowDiskSequence = {3, 4, 5, 6, 1, 2};
+
+    for (ui32 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) {
+        ui32 nextVPut = vPutIdx;
+        ui32 diskPos = (ui32)-1;
+        for (ui32 i = vPutIdx; i < vPuts.size(); ++i) {
+            auto& record = vPuts[i]->Record;
+            TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
+            ui32 diskIdx = group.VDiskIdx(vDiskId);
+            auto it = Find(diskSequence, diskIdx);
+            if (it != diskSequence.end()) {
+                ui32 pos = it - diskSequence.begin();
+                if (pos < diskPos) {
+                    nextVPut = i;
+                    diskPos = pos;
+                }
+            }
+        }
+        CTEST << "vdisk exp# " << (diskSequence.size() ? diskSequence.front() : -1) << " get# " << group.VDiskIdx(VDiskIDFromVDiskID(vPuts[nextVPut]->Record.GetVDiskID())) << Endl;
+        if (diskPos != (ui32)-1) {
+            diskSequence.erase(diskSequence.begin() + diskPos);
+        }
+        std::swap(vPuts[vPutIdx], vPuts[nextVPut]);
+
+        for (ui32 idx = 0; idx < domainCount; ++idx) {
+            group.SetPredictedDelayNs(idx, 1);
+        }
+        if (vPutIdx < slowDiskSequence.size()) {
+            group.SetPredictedDelayNs(slowDiskSequence[vPutIdx], 10);
+        }
+
         TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> nextVPuts;
- 
-        TEvBlobStorage::TEvVPut& vPut = *vPuts[vPutIdx]; 
+
+        TEvBlobStorage::TEvVPut& vPut = *vPuts[vPutIdx];
         TActorId sender;
-        TEvBlobStorage::TEvVPutResult vPutResult; 
-        NKikimrProto::EReplyStatus status = group.OnVPut(vPut); 
+        TEvBlobStorage::TEvVPutResult vPutResult;
+        NKikimrProto::EReplyStatus status = group.OnVPut(vPut);
         vPutResult.MakeError(status, TString(), vPut.Record);
- 
-        putImpl.OnVPutEventResult(logCtx, sender, vPutResult, nextVPuts, putResults); 
- 
-        if (putResults.size()) { 
-            break; 
-        } 
- 
+
+        putImpl.OnVPutEventResult(logCtx, sender, vPutResult, nextVPuts, putResults);
+
+        if (putResults.size()) {
+            break;
+        }
+
         std::move(nextVPuts.begin(), nextVPuts.end(), std::back_inserter(vPuts));
-    } 
-    UNIT_ASSERT(putResults.size() == 1); 
-    auto& [_, result] = putResults.front(); 
-    UNIT_ASSERT(result->Status == NKikimrProto::OK); 
-    UNIT_ASSERT(result->Id == blobId); 
-    UNIT_ASSERT(putImpl.GetHandoffPartsSent() == 7); 
-} 
- 
-Y_UNIT_TEST(TestBlock42MaxPartCountOnHandoff) { 
-    TestPutMaxPartCountOnHandoff(TErasureType::Erasure4Plus2Block); 
-} 
- 
-enum ETestPutAllOkMode { 
-    TPAOM_VPUT, 
-    TPAOM_VMULTIPUT 
-}; 
-
-template <TErasureType::EErasureSpecies ErasureSpecies, ETestPutAllOkMode TestMode> 
-struct TTestPutAllOk { 
-    static constexpr ui32 GroupId = 0; 
-    static constexpr i32 DataSize = 100500; 
-    static constexpr bool IsVPut = TestMode == TPAOM_VPUT; 
-    static constexpr ui64 BlobCount = IsVPut ? 1 : 2; 
-    static constexpr ui32 MaxIterations = 10000; 
-
-    TActorSystemStub ActorSystemStub; 
-    TBlobStorageGroupType GroupType; 
-    TGroupMock Group; 
+    }
+    UNIT_ASSERT(putResults.size() == 1);
+    auto& [_, result] = putResults.front();
+    UNIT_ASSERT(result->Status == NKikimrProto::OK);
+    UNIT_ASSERT(result->Id == blobId);
+    UNIT_ASSERT(putImpl.GetHandoffPartsSent() == 7);
+}
+
+Y_UNIT_TEST(TestBlock42MaxPartCountOnHandoff) {
+    TestPutMaxPartCountOnHandoff(TErasureType::Erasure4Plus2Block);
+}
+
+enum ETestPutAllOkMode {
+    TPAOM_VPUT,
+    TPAOM_VMULTIPUT
+};
+
+template <TErasureType::EErasureSpecies ErasureSpecies, ETestPutAllOkMode TestMode>
+struct TTestPutAllOk {
+    static constexpr ui32 GroupId = 0;
+    static constexpr i32 DataSize = 100500;
+    static constexpr bool IsVPut = TestMode == TPAOM_VPUT;
+    static constexpr ui64 BlobCount = IsVPut ? 1 : 2;
+    static constexpr ui32 MaxIterations = 10000;
+
+    TActorSystemStub ActorSystemStub;
+    TBlobStorageGroupType GroupType;
+    TGroupMock Group;
     TIntrusivePtr<TGroupQueues> GroupQueues;
 
-    TBatchedVec<TLogoBlobID> BlobIds; 
-    TString Data; 
+    TBatchedVec<TLogoBlobID> BlobIds;
+    TString Data;
 
-    TIntrusivePtr<NMonitoring::TDynamicCounters> Counters; 
-    TIntrusivePtr<TDsProxyNodeMon> NodeMon; 
-    TIntrusivePtr<TBlobStorageGroupProxyMon> Mon; 
+    TIntrusivePtr<NMonitoring::TDynamicCounters> Counters;
+    TIntrusivePtr<TDsProxyNodeMon> NodeMon;
+    TIntrusivePtr<TBlobStorageGroupProxyMon> Mon;
 
-    TLogContext LogCtx; 
+    TLogContext LogCtx;
 
-    TBatchedVec<TDataPartSet> PartSets; 
+    TBatchedVec<TDataPartSet> PartSets;
 
-    TStackVec<ui32, 16> CheckStack; 
+    TStackVec<ui32, 16> CheckStack;
 
-    TTestPutAllOk() 
-        : GroupType(ErasureSpecies) 
-        , Group(GroupId, ErasureSpecies, GroupType.BlobSubgroupSize(), 1) 
+    TTestPutAllOk()
+        : GroupType(ErasureSpecies)
+        , Group(GroupId, ErasureSpecies, GroupType.BlobSubgroupSize(), 1)
         , GroupQueues(Group.MakeGroupQueues())
-        , BlobIds({TLogoBlobID(743284823, 10, 12345, 0, DataSize, 0), TLogoBlobID(743284823, 9, 12346, 0, DataSize, 0)}) 
-        , Data(AlphaData(DataSize)) 
-        , Counters(new NMonitoring::TDynamicCounters()) 
-        , NodeMon(new TDsProxyNodeMon(Counters, true)) 
+        , BlobIds({TLogoBlobID(743284823, 10, 12345, 0, DataSize, 0), TLogoBlobID(743284823, 9, 12346, 0, DataSize, 0)})
+        , Data(AlphaData(DataSize))
+        , Counters(new NMonitoring::TDynamicCounters())
+        , NodeMon(new TDsProxyNodeMon(Counters, true))
         , Mon(new TBlobStorageGroupProxyMon(Counters, Counters, Counters, Group.GetInfo(), NodeMon, false))
-        , LogCtx(NKikimrServices::BS_PROXY_PUT, false) 
-        , PartSets(BlobCount) 
-    { 
-        LogCtx.LogAcc.IsLogEnabled = false; 
-
-        const ui32 totalvd = Group.GetInfo()->Type.BlobSubgroupSize(); 
-        const ui32 totalParts = Group.GetInfo()->Type.TotalPartCount(); 
-        Y_VERIFY(totalvd >= totalParts); 
-
-        for (ui64 blobIdx = 0; blobIdx < BlobCount; ++blobIdx) { 
-            TLogoBlobID blobId = BlobIds[blobIdx]; 
-            Y_VERIFY(blobId.BlobSize() == Data.size()); 
-            TBlobStorageGroupInfo::TServiceIds vDisksSvc; 
-            TBlobStorageGroupInfo::TVDiskIds vDisksId; 
-            const ui32 hash = blobId.Hash(); 
-            Group.GetInfo()->PickSubgroup(hash, &vDisksId, &vDisksSvc); 
-
-            TString encryptedData = Data; 
-            char *dataBytes = encryptedData.Detach(); 
-            Encrypt(dataBytes, dataBytes, 0, encryptedData.size(), blobId, *Group.GetInfo()); 
-
-            PartSets[blobIdx].Parts.resize(totalParts); 
-            Group.GetInfo()->Type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedData, PartSets[blobIdx]); 
-        } 
-    } 
+        , LogCtx(NKikimrServices::BS_PROXY_PUT, false)
+        , PartSets(BlobCount)
+    {
+        LogCtx.LogAcc.IsLogEnabled = false;
+
+        const ui32 totalvd = Group.GetInfo()->Type.BlobSubgroupSize();
+        const ui32 totalParts = Group.GetInfo()->Type.TotalPartCount();
+        Y_VERIFY(totalvd >= totalParts);
+
+        for (ui64 blobIdx = 0; blobIdx < BlobCount; ++blobIdx) {
+            TLogoBlobID blobId = BlobIds[blobIdx];
+            Y_VERIFY(blobId.BlobSize() == Data.size());
+            TBlobStorageGroupInfo::TServiceIds vDisksSvc;
+            TBlobStorageGroupInfo::TVDiskIds vDisksId;
+            const ui32 hash = blobId.Hash();
+            Group.GetInfo()->PickSubgroup(hash, &vDisksId, &vDisksSvc);
+
+            TString encryptedData = Data;
+            char *dataBytes = encryptedData.Detach();
+            Encrypt(dataBytes, dataBytes, 0, encryptedData.size(), blobId, *Group.GetInfo());
+
+            PartSets[blobIdx].Parts.resize(totalParts);
+            Group.GetInfo()->Type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedData, PartSets[blobIdx]);
+        }
+    }
 
     void InitVPutResults(TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> &vPuts,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPutResult>> &vPutResults)
-    { 
+    {
         vPutResults.resize(vPuts.size());
         for (ui32 vPutIdx = 0; vPutIdx < vPuts.size(); ++vPutIdx) {
             TEvBlobStorage::TEvVPut &vPut = *vPuts[vPutIdx];
-            NKikimrProto::EReplyStatus status = Group.OnVPut(vPut); 
+            NKikimrProto::EReplyStatus status = Group.OnVPut(vPut);
             UNIT_ASSERT_VALUES_EQUAL(status, NKikimrProto::OK);
             vPutResults[vPutIdx].reset(new TEvBlobStorage::TEvVPutResult());
             TEvBlobStorage::TEvVPutResult &vPutResult = *vPutResults[vPutIdx];
             vPutResult.MakeError(status, TString(), vPut.Record);
         }
-    } 
+    }
 
     void InitVPutResults(TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> &vMultiPuts,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPutResult>> &vMultiPutResults)
-    { 
-        vMultiPutResults.resize(vMultiPuts.size()); 
-        for (ui32 vMultiPutIdx = 0; vMultiPutIdx < vMultiPuts.size(); ++vMultiPutIdx) { 
-            TEvBlobStorage::TEvVMultiPut &vMultiPut = *vMultiPuts[vMultiPutIdx]; 
-            TVector<NKikimrProto::EReplyStatus> statuses = Group.OnVMultiPut(vMultiPut); 
-            for (auto status : statuses) { 
-                UNIT_ASSERT_VALUES_EQUAL(status, NKikimrProto::OK); 
-            } 
+    {
+        vMultiPutResults.resize(vMultiPuts.size());
+        for (ui32 vMultiPutIdx = 0; vMultiPutIdx < vMultiPuts.size(); ++vMultiPutIdx) {
+            TEvBlobStorage::TEvVMultiPut &vMultiPut = *vMultiPuts[vMultiPutIdx];
+            TVector<NKikimrProto::EReplyStatus> statuses = Group.OnVMultiPut(vMultiPut);
+            for (auto status : statuses) {
+                UNIT_ASSERT_VALUES_EQUAL(status, NKikimrProto::OK);
+            }
             vMultiPutResults[vMultiPutIdx].reset(new TEvBlobStorage::TEvVMultiPutResult());
-            Y_VERIFY(vMultiPut.Record.ItemsSize() == statuses.size()); 
-            TEvBlobStorage::TEvVMultiPutResult &vMultiPutResult = *vMultiPutResults[vMultiPutIdx]; 
+            Y_VERIFY(vMultiPut.Record.ItemsSize() == statuses.size());
+            TEvBlobStorage::TEvVMultiPutResult &vMultiPutResult = *vMultiPutResults[vMultiPutIdx];
             vMultiPutResult.MakeError(NKikimrProto::OK, TString(), vMultiPut.Record);
-            for (ui64 itemIdx = 0; itemIdx < statuses.size(); ++itemIdx) { 
-                NKikimrBlobStorage::TVMultiPutResultItem &item = *vMultiPutResult.Record.MutableItems(itemIdx); 
-                NKikimrProto::EReplyStatus status = statuses[itemIdx]; 
-                item.SetStatus(status); 
-            } 
-            Y_VERIFY(vMultiPutResult.Record.ItemsSize() == statuses.size()); 
-        } 
-    } 
- 
-    template <typename TVPutResultEvent> 
+            for (ui64 itemIdx = 0; itemIdx < statuses.size(); ++itemIdx) {
+                NKikimrBlobStorage::TVMultiPutResultItem &item = *vMultiPutResult.Record.MutableItems(itemIdx);
+                NKikimrProto::EReplyStatus status = statuses[itemIdx];
+                item.SetStatus(status);
+            }
+            Y_VERIFY(vMultiPutResult.Record.ItemsSize() == statuses.size());
+        }
+    }
+
+    template <typename TVPutResultEvent>
     void PermutateVPutResults(ui64 resIdx, bool &isAborted, TDeque<std::unique_ptr<TVPutResultEvent>> &vPutResults) {
-        // select result in range [resIdx, vPutResults.size()) 
-        if (resIdx + 1 < CheckStack.size()) { 
-            ui32 tgt = CheckStack[resIdx]; 
-            UNIT_ASSERT(tgt < vPutResults.size()); 
-            UNIT_ASSERT(tgt >= resIdx); 
-            std::swap(vPutResults[resIdx], vPutResults[tgt]); 
-        } else if (resIdx + 1 == CheckStack.size()) { 
-            ui32 &tgt = CheckStack[resIdx]; 
-            tgt++; 
-            if (tgt >= vPutResults.size()) { 
-                isAborted = true; 
-                CheckStack.pop_back(); 
-                return; 
-            } 
-        } else { 
-            CheckStack.push_back(resIdx); 
-        } 
-    } 
- 
-    bool Step(TPutImpl &putImpl, 
+        // select result in range [resIdx, vPutResults.size())
+        if (resIdx + 1 < CheckStack.size()) {
+            ui32 tgt = CheckStack[resIdx];
+            UNIT_ASSERT(tgt < vPutResults.size());
+            UNIT_ASSERT(tgt >= resIdx);
+            std::swap(vPutResults[resIdx], vPutResults[tgt]);
+        } else if (resIdx + 1 == CheckStack.size()) {
+            ui32 &tgt = CheckStack[resIdx];
+            tgt++;
+            if (tgt >= vPutResults.size()) {
+                isAborted = true;
+                CheckStack.pop_back();
+                return;
+            }
+        } else {
+            CheckStack.push_back(resIdx);
+        }
+    }
+
+    bool Step(TPutImpl &putImpl,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPutResult>> &vPutResults,
-            TPutImpl::TPutResultVec &putResults) 
-    { 
+            TPutImpl::TPutResultVec &putResults)
+    {
         bool isAborted = false;
-        for (ui64 resIdx = 0; resIdx < vPutResults.size(); ++resIdx) { 
-            PermutateVPutResults(resIdx, isAborted, vPutResults); 
-            if (isAborted) { 
-                break; 
+        for (ui64 resIdx = 0; resIdx < vPutResults.size(); ++resIdx) {
+            PermutateVPutResults(resIdx, isAborted, vPutResults);
+            if (isAborted) {
+                break;
             }
 
             TActorId sender;
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts2;
-            putImpl.OnVPutEventResult(LogCtx, sender, *vPutResults[resIdx], vPuts2, putResults); 
-            if (putResults.size()) { 
+            putImpl.OnVPutEventResult(LogCtx, sender, *vPutResults[resIdx], vPuts2, putResults);
+            if (putResults.size()) {
                 break;
             }
- 
+
             for (ui32 vPutIdx = 0; vPutIdx < vPuts2.size(); ++vPutIdx) {
                 TEvBlobStorage::TEvVPut &vPut = *vPuts2[vPutIdx];
-                NKikimrProto::EReplyStatus status = Group.OnVPut(vPut); 
+                NKikimrProto::EReplyStatus status = Group.OnVPut(vPut);
                 UNIT_ASSERT_VALUES_EQUAL(status, NKikimrProto::OK);
                 vPutResults.emplace_back(new TEvBlobStorage::TEvVPutResult());
                 TEvBlobStorage::TEvVPutResult &vPutResult = *vPutResults.back();
@@ -290,158 +290,158 @@ struct TTestPutAllOk {
             }
         }
 
-        return isAborted; 
-    } 
- 
-    bool Step(TPutImpl &putImpl, 
+        return isAborted;
+    }
+
+    bool Step(TPutImpl &putImpl,
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPutResult>> &vMultiPutResults,
-            TPutImpl::TPutResultVec &putResults) 
-    { 
-        bool isAborted = false; 
-        for (ui64 resIdx = 0; resIdx < vMultiPutResults.size(); ++resIdx) { 
-            PermutateVPutResults(resIdx, isAborted, vMultiPutResults); 
-            if (isAborted) { 
+            TPutImpl::TPutResultVec &putResults)
+    {
+        bool isAborted = false;
+        for (ui64 resIdx = 0; resIdx < vMultiPutResults.size(); ++resIdx) {
+            PermutateVPutResults(resIdx, isAborted, vMultiPutResults);
+            if (isAborted) {
                 break;
             }
- 
+
             TActorId sender;
             TDeque<std::unique_ptr<TEvBlobStorage::TEvVMultiPut>> vMultiPuts2;
-            putImpl.OnVPutEventResult(LogCtx, sender, *vMultiPutResults[resIdx], vMultiPuts2, putResults); 
-            if (putResults.size() == BlobIds.size()) { 
-                break; 
-            } 
- 
-            for (ui32 vMultiPutIdx = 0; vMultiPutIdx < vMultiPuts2.size(); ++vMultiPutIdx) { 
-                TEvBlobStorage::TEvVMultiPut &vMultiPut = *vMultiPuts2[vMultiPutIdx]; 
-                TVector<NKikimrProto::EReplyStatus> statuses = Group.OnVMultiPut(vMultiPut); 
-                for (auto status : statuses) { 
-                    UNIT_ASSERT_VALUES_EQUAL(status, NKikimrProto::OK); 
-                } 
- 
+            putImpl.OnVPutEventResult(LogCtx, sender, *vMultiPutResults[resIdx], vMultiPuts2, putResults);
+            if (putResults.size() == BlobIds.size()) {
+                break;
+            }
+
+            for (ui32 vMultiPutIdx = 0; vMultiPutIdx < vMultiPuts2.size(); ++vMultiPutIdx) {
+                TEvBlobStorage::TEvVMultiPut &vMultiPut = *vMultiPuts2[vMultiPutIdx];
+                TVector<NKikimrProto::EReplyStatus> statuses = Group.OnVMultiPut(vMultiPut);
+                for (auto status : statuses) {
+                    UNIT_ASSERT_VALUES_EQUAL(status, NKikimrProto::OK);
+                }
+
                 vMultiPutResults[vMultiPutIdx].reset(new TEvBlobStorage::TEvVMultiPutResult());
-                Y_VERIFY(vMultiPut.Record.ItemsSize() == statuses.size()); 
-                TEvBlobStorage::TEvVMultiPutResult &vMultiPutResult = *vMultiPutResults[vMultiPutIdx]; 
+                Y_VERIFY(vMultiPut.Record.ItemsSize() == statuses.size());
+                TEvBlobStorage::TEvVMultiPutResult &vMultiPutResult = *vMultiPutResults[vMultiPutIdx];
                 vMultiPutResult.MakeError(NKikimrProto::OK, TString(), vMultiPut.Record);
- 
-                for (ui64 itemIdx = 0; itemIdx < statuses.size(); ++itemIdx) { 
-                    auto &item = vMultiPut.Record.GetItems(itemIdx); 
-                    NKikimrProto::EReplyStatus status = statuses[itemIdx]; 
-                    TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
- 
-                    ui64 cookieValue = 0; 
-                    ui64 *cookie = nullptr; 
-                    if (item.HasCookie()) { 
-                        cookieValue = item.GetCookie(); 
-                        cookie = &cookieValue; 
-                    } 
- 
+
+                for (ui64 itemIdx = 0; itemIdx < statuses.size(); ++itemIdx) {
+                    auto &item = vMultiPut.Record.GetItems(itemIdx);
+                    NKikimrProto::EReplyStatus status = statuses[itemIdx];
+                    TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+
+                    ui64 cookieValue = 0;
+                    ui64 *cookie = nullptr;
+                    if (item.HasCookie()) {
+                        cookieValue = item.GetCookie();
+                        cookie = &cookieValue;
+                    }
+
                     vMultiPutResult.AddVPutResult(status, TString(), blobId, cookie);
-                } 
-            } 
+                }
+            }
         }
- 
-        return isAborted; 
+
+        return isAborted;
     }
 
-    void Run() { 
-        using TVPutEvent = std::conditional_t<IsVPut, TEvBlobStorage::TEvVPut, TEvBlobStorage::TEvVMultiPut>; 
-        using TVPutResultEvent = std::conditional_t<IsVPut, TEvBlobStorage::TEvVPutResult, 
-                TEvBlobStorage::TEvVMultiPutResult>; 
- 
-        ui64 i = 0; 
-        for (; i < MaxIterations; ++i) { 
-            Group.Wipe(); 
-            TBatchedVec<TEvBlobStorage::TEvPut::TPtr> events; 
-            for (auto &blobId : BlobIds) { 
+    void Run() {
+        using TVPutEvent = std::conditional_t<IsVPut, TEvBlobStorage::TEvVPut, TEvBlobStorage::TEvVMultiPut>;
+        using TVPutResultEvent = std::conditional_t<IsVPut, TEvBlobStorage::TEvVPutResult,
+                TEvBlobStorage::TEvVMultiPutResult>;
+
+        ui64 i = 0;
+        for (; i < MaxIterations; ++i) {
+            Group.Wipe();
+            TBatchedVec<TEvBlobStorage::TEvPut::TPtr> events;
+            for (auto &blobId : BlobIds) {
                 std::unique_ptr<TEvBlobStorage::TEvPut> vPut(new TEvBlobStorage::TEvPut(blobId, Data, TInstant::Max(),
-                        NKikimrBlobStorage::TabletLog, TEvBlobStorage::TEvPut::TacticDefault)); 
-                events.emplace_back(static_cast<TEventHandle<TEvBlobStorage::TEvPut> *>( 
+                        NKikimrBlobStorage::TabletLog, TEvBlobStorage::TEvPut::TacticDefault));
+                events.emplace_back(static_cast<TEventHandle<TEvBlobStorage::TEvPut> *>(
                         new IEventHandle(TActorId(),  TActorId(), vPut.release())));
-            } 
- 
-            TMaybe<TPutImpl> putImpl; 
-            TPutImpl::TPutResultVec putResults; 
-            if constexpr (IsVPut) { 
-                putImpl.ConstructInPlace(Group.GetInfo(), GroupQueues, events[0]->Get(), Mon, false); 
-            } else { 
+            }
+
+            TMaybe<TPutImpl> putImpl;
+            TPutImpl::TPutResultVec putResults;
+            if constexpr (IsVPut) {
+                putImpl.ConstructInPlace(Group.GetInfo(), GroupQueues, events[0]->Get(), Mon, false);
+            } else {
                 putImpl.ConstructInPlace(Group.GetInfo(), GroupQueues, events, Mon,
-                        NKikimrBlobStorage::TabletLog, TEvBlobStorage::TEvPut::TacticDefault, false); 
-            } 
- 
+                        NKikimrBlobStorage::TabletLog, TEvBlobStorage::TEvPut::TacticDefault, false);
+            }
+
             TDeque<std::unique_ptr<TVPutEvent>> vPuts;
-            putImpl->GenerateInitialRequests(LogCtx, PartSets, vPuts); 
-            UNIT_ASSERT(vPuts.size() == 6 || !IsVPut); 
+            putImpl->GenerateInitialRequests(LogCtx, PartSets, vPuts);
+            UNIT_ASSERT(vPuts.size() == 6 || !IsVPut);
             TDeque<std::unique_ptr<TVPutResultEvent>> vPutResults;
-            InitVPutResults(vPuts, vPutResults); 
- 
-            bool isAborted = Step(*putImpl, vPutResults, putResults); 
-            if (!isAborted) { 
-                UNIT_ASSERT(putResults.size() == BlobCount); 
-                for (auto& [blobIdx, result] : putResults) { 
-                    UNIT_ASSERT(result->Status == NKikimrProto::OK); 
-                    UNIT_ASSERT(result->Id == BlobIds[blobIdx]); 
-                } 
-            } else { 
-                if (CheckStack.size() == 0) { 
-                    break; 
-                } 
-            } 
-        } 
- 
-        UNIT_ASSERT(i != MaxIterations || !IsVPut); 
-    } 
-}; 
- 
+            InitVPutResults(vPuts, vPutResults);
+
+            bool isAborted = Step(*putImpl, vPutResults, putResults);
+            if (!isAborted) {
+                UNIT_ASSERT(putResults.size() == BlobCount);
+                for (auto& [blobIdx, result] : putResults) {
+                    UNIT_ASSERT(result->Status == NKikimrProto::OK);
+                    UNIT_ASSERT(result->Id == BlobIds[blobIdx]);
+                }
+            } else {
+                if (CheckStack.size() == 0) {
+                    break;
+                }
+            }
+        }
+
+        UNIT_ASSERT(i != MaxIterations || !IsVPut);
+    }
+};
+
 Y_UNIT_TEST(TestBlock42PutAllOk) {
-    TTestPutAllOk<TErasureType::Erasure4Plus2Block, TPAOM_VPUT>().Run(); 
+    TTestPutAllOk<TErasureType::Erasure4Plus2Block, TPAOM_VPUT>().Run();
 }
 
-Y_UNIT_TEST(TestBlock42MultiPutAllOk) { 
-    TTestPutAllOk<TErasureType::Erasure4Plus2Block, TPAOM_VMULTIPUT>().Run(); 
-} 
- 
-Y_UNIT_TEST(TestMirror3dcWith3x3MinLatencyMod) { 
-    TTestBasicRuntime runtime; 
-    SetupRuntime(runtime); 
-    TDSProxyEnv env; 
-    env.Configure(runtime, TErasureType::ErasureMirror3dc, 1, 0); 
- 
-    i32 size = 786; 
-    TLogoBlobID blobId(72075186224047637, 1, 863, 1, size, 24576); 
-    TString data = AlphaData(size); 
-    TEvBlobStorage::TEvPut ev(blobId, data, TInstant::Max(), NKikimrBlobStorage::TabletLog, 
-            TEvBlobStorage::TEvPut::TacticMinLatency); 
-    TPutImpl putImpl(env.Info, env.GroupQueues, &ev, env.Mon, true); 
+Y_UNIT_TEST(TestBlock42MultiPutAllOk) {
+    TTestPutAllOk<TErasureType::Erasure4Plus2Block, TPAOM_VMULTIPUT>().Run();
+}
+
+Y_UNIT_TEST(TestMirror3dcWith3x3MinLatencyMod) {
+    TTestBasicRuntime runtime;
+    SetupRuntime(runtime);
+    TDSProxyEnv env;
+    env.Configure(runtime, TErasureType::ErasureMirror3dc, 1, 0);
+
+    i32 size = 786;
+    TLogoBlobID blobId(72075186224047637, 1, 863, 1, size, 24576);
+    TString data = AlphaData(size);
+    TEvBlobStorage::TEvPut ev(blobId, data, TInstant::Max(), NKikimrBlobStorage::TabletLog,
+            TEvBlobStorage::TEvPut::TacticMinLatency);
+    TPutImpl putImpl(env.Info, env.GroupQueues, &ev, env.Mon, true);
     TDeque<std::unique_ptr<TEvBlobStorage::TEvVPut>> vPuts;
- 
-    TLogContext logCtx(NKikimrServices::BS_PROXY_PUT, false); 
-    logCtx.LogAcc.IsLogEnabled = false; 
- 
-    const ui32 totalParts = env.Info->Type.TotalPartCount(); 
-    TBatchedVec<TDataPartSet> partSetSingleton(1); 
-    partSetSingleton[0].Parts.resize(totalParts); 
- 
-    TString encryptedData = data; 
-    char *dataBytes = encryptedData.Detach(); 
-    Encrypt(dataBytes, dataBytes, 0, encryptedData.size(), blobId, *env.Info); 
-    env.Info->Type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedData, partSetSingleton[0]); 
-    putImpl.GenerateInitialRequests(logCtx, partSetSingleton, vPuts); 
- 
-    UNIT_ASSERT_VALUES_EQUAL(vPuts.size(), 9); 
-    using TVDiskIDTuple = decltype(std::declval<TVDiskID>().ConvertToTuple()); 
-    THashSet<TVDiskIDTuple> vDiskIds; 
-    for (auto &vPut : vPuts) { 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(vPut->Record.GetVDiskID()); 
-        bool inserted = vDiskIds.insert(vDiskId.ConvertToTuple()).second; 
-        UNIT_ASSERT(inserted); 
-    } 
-    for (ui32 diskOrderNumber = 0; diskOrderNumber < env.Info->Type.BlobSubgroupSize(); ++diskOrderNumber) { 
-        TVDiskID vDiskId = env.Info->GetVDiskId(diskOrderNumber); 
-        auto it = vDiskIds.find(vDiskId.ConvertToTuple()); 
-        UNIT_ASSERT(it != vDiskIds.end()); 
-    } 
-} 
- 
+
+    TLogContext logCtx(NKikimrServices::BS_PROXY_PUT, false);
+    logCtx.LogAcc.IsLogEnabled = false;
+
+    const ui32 totalParts = env.Info->Type.TotalPartCount();
+    TBatchedVec<TDataPartSet> partSetSingleton(1);
+    partSetSingleton[0].Parts.resize(totalParts);
+
+    TString encryptedData = data;
+    char *dataBytes = encryptedData.Detach();
+    Encrypt(dataBytes, dataBytes, 0, encryptedData.size(), blobId, *env.Info);
+    env.Info->Type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedData, partSetSingleton[0]);
+    putImpl.GenerateInitialRequests(logCtx, partSetSingleton, vPuts);
+
+    UNIT_ASSERT_VALUES_EQUAL(vPuts.size(), 9);
+    using TVDiskIDTuple = decltype(std::declval<TVDiskID>().ConvertToTuple());
+    THashSet<TVDiskIDTuple> vDiskIds;
+    for (auto &vPut : vPuts) {
+        TVDiskID vDiskId = VDiskIDFromVDiskID(vPut->Record.GetVDiskID());
+        bool inserted = vDiskIds.insert(vDiskId.ConvertToTuple()).second;
+        UNIT_ASSERT(inserted);
+    }
+    for (ui32 diskOrderNumber = 0; diskOrderNumber < env.Info->Type.BlobSubgroupSize(); ++diskOrderNumber) {
+        TVDiskID vDiskId = env.Info->GetVDiskId(diskOrderNumber);
+        auto it = vDiskIds.find(vDiskId.ConvertToTuple());
+        UNIT_ASSERT(it != vDiskIds.end());
+    }
+}
+
 } // Y_UNIT_TEST_SUITE TDSProxyPutTest
 } // namespace NDSProxyPutTest
 } // namespace NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_sequence_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_sequence_ut.cpp
index 8e6de594ad..fdd7a92ea3 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_sequence_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_sequence_ut.cpp
@@ -1,11 +1,11 @@
 #include "defs.h"
-#include "dsproxy_env_mock_ut.h" 
-#include "dsproxy_vdisk_mock_ut.h" 
-#include "dsproxy_test_state_ut.h" 
+#include "dsproxy_env_mock_ut.h"
+#include "dsproxy_vdisk_mock_ut.h"
+#include "dsproxy_test_state_ut.h"
 
 #include <ydb/core/blobstorage/dsproxy/dsproxy.h>
 #include <ydb/core/blobstorage/dsproxy/dsproxy_nodemon.h>
- 
+
 #include <ydb/core/blobstorage/base/utility.h>
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h>
 #include <ydb/core/blobstorage/vdisk/common/vdisk_events.h>
@@ -13,28 +13,28 @@
 
 #include <ydb/core/testlib/basics/runtime.h>
 #include <ydb/core/testlib/basics/appdata.h>
- 
+
 #include <library/cpp/testing/unittest/registar.h>
 
 namespace NKikimr {
 namespace NBlobStorageProxySequenceTest {
 
 constexpr ui32 GROUP_ID = 0;
-TDSProxyEnv DSProxyEnv; 
+TDSProxyEnv DSProxyEnv;
 
-void Setup(TTestActorRuntime& runtime, TBlobStorageGroupType type) { 
+void Setup(TTestActorRuntime& runtime, TBlobStorageGroupType type) {
     if (IsVerbose) {
         runtime.SetLogPriority(NKikimrServices::BS_PROXY_PUT, NLog::PRI_DEBUG);
         runtime.SetLogPriority(NKikimrServices::BS_PROXY_GET, NLog::PRI_DEBUG);
-        runtime.SetLogPriority(NKikimrServices::BS_PROXY_PATCH, NLog::PRI_DEBUG); 
+        runtime.SetLogPriority(NKikimrServices::BS_PROXY_PATCH, NLog::PRI_DEBUG);
     } else {
         runtime.SetLogPriority(NKikimrServices::BS_PROXY, NLog::PRI_CRIT);
         runtime.SetLogPriority(NKikimrServices::BS_PROXY_PUT, NLog::PRI_CRIT);
         runtime.SetLogPriority(NKikimrServices::BS_PROXY_GET, NLog::PRI_CRIT);
         runtime.SetLogPriority(NKikimrServices::BS_QUEUE, NLog::PRI_CRIT);
     }
-    SetupRuntime(runtime); 
-    DSProxyEnv.Configure(runtime, type, GROUP_ID, 0); 
+    SetupRuntime(runtime);
+    DSProxyEnv.Configure(runtime, type, GROUP_ID, 0);
 }
 
 struct TGetQuery {
@@ -174,25 +174,25 @@ struct TVDiskState {
         IsValid = true;
     }
 
-    void SetFrom(const IEventHandle *handle, const TEvBlobStorage::TEvVMultiPut *vput, ui64 itemIdx) { 
-        Sender = handle->Sender; 
-        ActorId = handle->Recipient; 
-        auto &item = vput->Record.GetItems(itemIdx); 
-        LogoBlobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-        VDiskId = VDiskIDFromVDiskID(vput->Record.GetVDiskID()); 
-        LastCookie = handle->Cookie; 
-        InnerCookie = item.GetCookie(); 
-        Data = item.GetBuffer(); 
-        if (!item.HasBuffer()) { 
-            const TRope& rope = vput->GetPayload(itemIdx); 
-            Data = TString::Uninitialized(rope.GetSize()); 
-            rope.Begin().ExtractPlainDataAndAdvance(Data.Detach(), Data.size()); 
-        } 
-        MsgId = vput->Record.GetMsgQoS().GetMsgId().GetMsgId(); 
-        SequenceId = vput->Record.GetMsgQoS().GetMsgId().GetSequenceId(); 
-        IsValid = true; 
-    } 
- 
+    void SetFrom(const IEventHandle *handle, const TEvBlobStorage::TEvVMultiPut *vput, ui64 itemIdx) {
+        Sender = handle->Sender;
+        ActorId = handle->Recipient;
+        auto &item = vput->Record.GetItems(itemIdx);
+        LogoBlobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+        VDiskId = VDiskIDFromVDiskID(vput->Record.GetVDiskID());
+        LastCookie = handle->Cookie;
+        InnerCookie = item.GetCookie();
+        Data = item.GetBuffer();
+        if (!item.HasBuffer()) {
+            const TRope& rope = vput->GetPayload(itemIdx);
+            Data = TString::Uninitialized(rope.GetSize());
+            rope.Begin().ExtractPlainDataAndAdvance(Data.Detach(), Data.size());
+        }
+        MsgId = vput->Record.GetMsgQoS().GetMsgId().GetMsgId();
+        SequenceId = vput->Record.GetMsgQoS().GetMsgId().GetSequenceId();
+        IsValid = true;
+    }
+
     void SetCookiesAndSenderFrom(const IEventHandle *handle, const TEvBlobStorage::TEvVGet *vget) {
         Sender = handle->Sender;
         LastCookie = handle->Cookie;
@@ -209,38 +209,38 @@ struct TVDiskState {
     }
 };
 
- 
-void SetPredictedDelaysForAllQueues(const THashMap<TVDiskID, ui32> &latencies) { 
-    UNIT_ASSERT(DSProxyEnv.GroupQueues); 
-    for (TGroupQueues::TFailDomain &domain : DSProxyEnv.GroupQueues->FailDomains) { 
-        for (TGroupQueues::TVDisk &vDisk : domain.VDisks) { 
-            ui32 begin = NKikimrBlobStorage::EVDiskQueueId::Begin; 
-            ui32 end = NKikimrBlobStorage::EVDiskQueueId::End; 
-            for (ui32 id = begin; id < end; ++id) { 
-                NKikimrBlobStorage::EVDiskQueueId vDiskQueueId = static_cast<NKikimrBlobStorage::EVDiskQueueId>(id); 
-                auto flowRecord = vDisk.Queues.FlowRecordForQueueId(vDiskQueueId); 
-                if (flowRecord) { 
-                    flowRecord->SetPredictedDelayNs(0); 
-                } 
-            } 
-        } 
-    } 
-    ui64 changedCount = 0; 
-    for (auto &[vDiskId, latency] : latencies) { 
-        changedCount++; 
-        TGroupQueues::TVDisk &vDisk = DSProxyEnv.GroupQueues->FailDomains[vDiskId.FailDomain].VDisks[vDiskId.VDisk]; 
-        ui32 begin = NKikimrBlobStorage::EVDiskQueueId::Begin; 
-        ui32 end = NKikimrBlobStorage::EVDiskQueueId::End; 
-        for (ui32 id = begin; id < end; ++id) { 
-            NKikimrBlobStorage::EVDiskQueueId vDiskQueueId = static_cast<NKikimrBlobStorage::EVDiskQueueId>(id);; 
-            auto flowRecord = vDisk.Queues.FlowRecordForQueueId(vDiskQueueId); 
-            if (flowRecord) { 
-                flowRecord->SetPredictedDelayNs(latency); 
-            } 
-        } 
-    } 
-} 
- 
+
+void SetPredictedDelaysForAllQueues(const THashMap<TVDiskID, ui32> &latencies) {
+    UNIT_ASSERT(DSProxyEnv.GroupQueues);
+    for (TGroupQueues::TFailDomain &domain : DSProxyEnv.GroupQueues->FailDomains) {
+        for (TGroupQueues::TVDisk &vDisk : domain.VDisks) {
+            ui32 begin = NKikimrBlobStorage::EVDiskQueueId::Begin;
+            ui32 end = NKikimrBlobStorage::EVDiskQueueId::End;
+            for (ui32 id = begin; id < end; ++id) {
+                NKikimrBlobStorage::EVDiskQueueId vDiskQueueId = static_cast<NKikimrBlobStorage::EVDiskQueueId>(id);
+                auto flowRecord = vDisk.Queues.FlowRecordForQueueId(vDiskQueueId);
+                if (flowRecord) {
+                    flowRecord->SetPredictedDelayNs(0);
+                }
+            }
+        }
+    }
+    ui64 changedCount = 0;
+    for (auto &[vDiskId, latency] : latencies) {
+        changedCount++;
+        TGroupQueues::TVDisk &vDisk = DSProxyEnv.GroupQueues->FailDomains[vDiskId.FailDomain].VDisks[vDiskId.VDisk];
+        ui32 begin = NKikimrBlobStorage::EVDiskQueueId::Begin;
+        ui32 end = NKikimrBlobStorage::EVDiskQueueId::End;
+        for (ui32 id = begin; id < end; ++id) {
+            NKikimrBlobStorage::EVDiskQueueId vDiskQueueId = static_cast<NKikimrBlobStorage::EVDiskQueueId>(id);;
+            auto flowRecord = vDisk.Queues.FlowRecordForQueueId(vDiskQueueId);
+            if (flowRecord) {
+                flowRecord->SetPredictedDelayNs(latency);
+            }
+        }
+    }
+}
+
 void SendVGetResult(ui32 vDiskIdx, NKikimrProto::EReplyStatus status, ui32 partId,
         TVector<TVDiskState> &subgroup, TTestActorRuntime &runtime) {
 
@@ -249,7 +249,7 @@ void SendVGetResult(ui32 vDiskIdx, NKikimrProto::EReplyStatus status, ui32 partI
     std::unique_ptr<TEvBlobStorage::TEvVGetResult> result(new TEvBlobStorage::TEvVGetResult(NKikimrProto::OK, from->VDiskId,
         TAppData::TimeProvider->Now(), 0, nullptr, nullptr, nullptr, nullptr, NWilson::TTraceId(), {}, 0U, 0U));
 
-    SetPredictedDelaysForAllQueues({}); 
+    SetPredictedDelaysForAllQueues({});
     ui64 queryCookie = from->QueryCookies.size() ? from->QueryCookies[0] : 0;
     if (status == NKikimrProto::OK) {
         result->Record.SetCookie(from->InnerCookie);
@@ -282,7 +282,7 @@ void SendVGetResult(ui32 blobIdx, ui32 vDiskIdx, NKikimrProto::EReplyStatus stat
         return;
     }
 
-    SetPredictedDelaysForAllQueues({}); 
+    SetPredictedDelaysForAllQueues({});
     if (status == NKikimrProto::ERROR || status == NKikimrProto::TRYLATER
             || status == NKikimrProto::TRYLATER_SIZE || status == NKikimrProto::TRYLATER_TIME
             || status == NKikimrProto::VDISK_ERROR_STATE) {
@@ -347,55 +347,55 @@ void SendVGetResult(ui32 blobIdx, ui32 vDiskIdx, NKikimrProto::EReplyStatus stat
     }
 }
 
- 
-void GrabVPutEvent(TTestActorRuntime &runtime, TVector<TVDiskState> &subgroup, ui32 vDiskIdxShift = 0) { 
-    TAutoPtr <IEventHandle> handle; 
-    auto vput = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPut>(handle); 
-    UNIT_ASSERT(vput); 
-    TLogoBlobID id = LogoBlobIDFromLogoBlobID(vput->Record.GetBlobID()); 
-    ui32 idx = id.PartId(); 
-    Y_VERIFY(idx); 
-    idx = idx - 1 + vDiskIdxShift; 
-    Y_VERIFY_S(idx < subgroup.size(), idx << ' ' << subgroup.size() << ' ' << vDiskIdxShift << ' ' << vput->ToString()); 
-    Y_VERIFY(!subgroup[idx].IsValid); 
-    subgroup[idx].SetFrom(handle.Get(), vput); 
-} 
- 
-void SendVPutResultEvent(TTestActorRuntime &runtime, TVDiskState &vdisk, NKikimrProto::EReplyStatus status) { 
-    Y_VERIFY(vdisk.IsValid); 
+
+void GrabVPutEvent(TTestActorRuntime &runtime, TVector<TVDiskState> &subgroup, ui32 vDiskIdxShift = 0) {
+    TAutoPtr <IEventHandle> handle;
+    auto vput = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPut>(handle);
+    UNIT_ASSERT(vput);
+    TLogoBlobID id = LogoBlobIDFromLogoBlobID(vput->Record.GetBlobID());
+    ui32 idx = id.PartId();
+    Y_VERIFY(idx);
+    idx = idx - 1 + vDiskIdxShift;
+    Y_VERIFY_S(idx < subgroup.size(), idx << ' ' << subgroup.size() << ' ' << vDiskIdxShift << ' ' << vput->ToString());
+    Y_VERIFY(!subgroup[idx].IsValid);
+    subgroup[idx].SetFrom(handle.Get(), vput);
+}
+
+void SendVPutResultEvent(TTestActorRuntime &runtime, TVDiskState &vdisk, NKikimrProto::EReplyStatus status) {
+    Y_VERIFY(vdisk.IsValid);
     std::unique_ptr<TEvBlobStorage::TEvVPutResult> vPutResult(new TEvBlobStorage::TEvVPutResult(
-        status, vdisk.LogoBlobId, vdisk.VDiskId, 
-        &vdisk.InnerCookie, TOutOfSpaceStatus(0u, 0.0), TAppData::TimeProvider->Now(), 
+        status, vdisk.LogoBlobId, vdisk.VDiskId,
+        &vdisk.InnerCookie, TOutOfSpaceStatus(0u, 0.0), TAppData::TimeProvider->Now(),
         0, nullptr, nullptr, nullptr, nullptr, 0, NWilson::TTraceId(), 0, TString()));
-    vPutResult->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(vdisk.MsgId); 
-    vPutResult->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(vdisk.SequenceId); 
-    SetPredictedDelaysForAllQueues({}); 
+    vPutResult->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(vdisk.MsgId);
+    vPutResult->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(vdisk.SequenceId);
+    SetPredictedDelaysForAllQueues({});
     runtime.Send(new IEventHandle(vdisk.Sender, vdisk.ActorId, vPutResult.release(), 0, vdisk.LastCookie));
-} 
- 
+}
+
 void PrepareBlobSubgroup(TLogoBlobID logoblobid, TString data, TVector<TVDiskState> &subgroup,
-        TTestActorRuntime &runtime, TBlobStorageGroupType type) { 
+        TTestActorRuntime &runtime, TBlobStorageGroupType type) {
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
 
     runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvPut(logoblobid, data, TInstant::Max())));
-    subgroup.resize(type.BlobSubgroupSize()); 
+    subgroup.resize(type.BlobSubgroupSize());
 
-    ui32 partCount = type.TotalPartCount(); 
-    for (ui32 i = 0; i < partCount; ++i) { 
-        GrabVPutEvent(runtime, subgroup); 
+    ui32 partCount = type.TotalPartCount();
+    for (ui32 i = 0; i < partCount; ++i) {
+        GrabVPutEvent(runtime, subgroup);
     }
-    for (ui32 i = type.Handoff(); i < partCount; ++i) { 
-        SendVPutResultEvent(runtime, subgroup[i], NKikimrProto::OK); 
+    for (ui32 i = type.Handoff(); i < partCount; ++i) {
+        SendVPutResultEvent(runtime, subgroup[i], NKikimrProto::OK);
     }
-    for (ui32 i = 0; i < type.Handoff(); ++i) { 
-        SendVPutResultEvent(runtime, subgroup[i], NKikimrProto::ERROR); 
+    for (ui32 i = 0; i < type.Handoff(); ++i) {
+        SendVPutResultEvent(runtime, subgroup[i], NKikimrProto::ERROR);
     }
-    for (ui32 i = 0; i < type.Handoff(); ++i) { 
-        GrabVPutEvent(runtime, subgroup, type.TotalPartCount()); 
+    for (ui32 i = 0; i < type.Handoff(); ++i) {
+        GrabVPutEvent(runtime, subgroup, type.TotalPartCount());
     }
-    for (ui32 i = 0; i < type.Handoff(); ++i) { 
-        SendVPutResultEvent(runtime, subgroup[i + type.TotalPartCount()], NKikimrProto::OK); 
+    for (ui32 i = 0; i < type.Handoff(); ++i) {
+        SendVPutResultEvent(runtime, subgroup[i + type.TotalPartCount()], NKikimrProto::OK);
     }
 
     TAutoPtr<IEventHandle> handle;
@@ -404,352 +404,352 @@ void PrepareBlobSubgroup(TLogoBlobID logoblobid, TString data, TVector<TVDiskSta
     UNIT_ASSERT(putResult->Status == NKikimrProto::OK);
 }
 
- 
- 
+
+
 Y_UNIT_TEST_SUITE(TBlobStorageProxySequenceTest) {
- 
- 
-struct TGeneralDecorator : public TDecorator { 
-    using TAction = std::function<bool(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx)>; 
- 
-    TAction Action; 
- 
-    TGeneralDecorator(THolder<IActor> &&actor, TAction action) 
-        : TDecorator(std::move(actor)) 
-        , Action(action) 
-    { 
-    } 
- 
-    bool DoBeforeReceiving(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) override { 
-        return Action(ev, ctx); 
-    } 
-}; 
- 
- 
-Y_UNIT_TEST(TestBlock42PutWithChangingSlowDisk) { 
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block}; 
-    TTestBasicRuntime runtime(1, false); 
-    Setup(runtime, type); 
-    TTestState testState(runtime, type, DSProxyEnv.Info); 
- 
-    TLogoBlobID blobId(72075186224047637, 1, 863, 1, 786, 24576); 
- 
-    TStringBuilder dataBuilder; 
-    for (size_t i = 0; i < blobId.BlobSize(); ++i) { 
-        dataBuilder << 'a'; 
-    } 
-    TBlobTestSet::TBlob blob(blobId, dataBuilder); 
- 
- 
-    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault; 
-    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog; 
- 
-    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched; 
- 
-    TEvBlobStorage::TEvPut::TPtr ev = testState.CreatePutRequest(blob, tactic, handleClass); 
+
+
+struct TGeneralDecorator : public TDecorator {
+    using TAction = std::function<bool(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx)>;
+
+    TAction Action;
+
+    TGeneralDecorator(THolder<IActor> &&actor, TAction action)
+        : TDecorator(std::move(actor))
+        , Action(action)
+    {
+    }
+
+    bool DoBeforeReceiving(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) override {
+        return Action(ev, ctx);
+    }
+};
+
+
+Y_UNIT_TEST(TestBlock42PutWithChangingSlowDisk) {
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block};
+    TTestBasicRuntime runtime(1, false);
+    Setup(runtime, type);
+    TTestState testState(runtime, type, DSProxyEnv.Info);
+
+    TLogoBlobID blobId(72075186224047637, 1, 863, 1, 786, 24576);
+
+    TStringBuilder dataBuilder;
+    for (size_t i = 0; i < blobId.BlobSize(); ++i) {
+        dataBuilder << 'a';
+    }
+    TBlobTestSet::TBlob blob(blobId, dataBuilder);
+
+
+    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault;
+    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog;
+
+    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched;
+
+    TEvBlobStorage::TEvPut::TPtr ev = testState.CreatePutRequest(blob, tactic, handleClass);
     std::unique_ptr<IActor> putActor = DSProxyEnv.CreatePutRequestActor(ev);
- 
-    TGroupMock &groupMock = testState.GetGroupMock(); 
-    groupMock.SetError(0, NKikimrProto::ERROR); 
-    groupMock.SetError(5, NKikimrProto::ERROR); 
- 
-    THashMap<TVDiskID, ui32> latencies = testState.MakePredictedDelaysForVDisks(blobId); 
-    for (auto &[vDiskId, latency] : latencies) { 
-        latency = 1; 
-    } 
-    std::optional<TVDiskID> prevVDiskId; 
-    TSet<TLogoBlobID> okParts; 
- 
-    auto action = [&](TAutoPtr<IEventHandle>& ev, const TActorContext&) { 
-        if (ev->Type == TEvents::TSystem::Bootstrap) { 
-            return true; 
-        } 
-        UNIT_ASSERT(ev->Type == TEvBlobStorage::EvVPutResult); 
-        TEvBlobStorage::TEvVPutResult *putResult = ev->Get<TEvBlobStorage::TEvVPutResult>(); 
-        UNIT_ASSERT(putResult); 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(putResult->Record.GetVDiskID()); 
-        TLogoBlobID part = LogoBlobIDFromLogoBlobID(putResult->Record.GetBlobID()); 
-        NKikimrProto::EReplyStatus status = putResult->Record.GetStatus(); 
-        CTEST << "Receive LogoBlobId# " << part << " vdisk " << vDiskId << " " << NKikimrProto::EReplyStatus_Name(status) << Endl; 
-        if (prevVDiskId) { 
-            latencies[*prevVDiskId] = 1; 
-        } 
-        latencies[vDiskId] = 10; 
-        prevVDiskId = vDiskId; 
-        SetPredictedDelaysForAllQueues(latencies); 
-        return true; 
-    }; 
- 
+
+    TGroupMock &groupMock = testState.GetGroupMock();
+    groupMock.SetError(0, NKikimrProto::ERROR);
+    groupMock.SetError(5, NKikimrProto::ERROR);
+
+    THashMap<TVDiskID, ui32> latencies = testState.MakePredictedDelaysForVDisks(blobId);
+    for (auto &[vDiskId, latency] : latencies) {
+        latency = 1;
+    }
+    std::optional<TVDiskID> prevVDiskId;
+    TSet<TLogoBlobID> okParts;
+
+    auto action = [&](TAutoPtr<IEventHandle>& ev, const TActorContext&) {
+        if (ev->Type == TEvents::TSystem::Bootstrap) {
+            return true;
+        }
+        UNIT_ASSERT(ev->Type == TEvBlobStorage::EvVPutResult);
+        TEvBlobStorage::TEvVPutResult *putResult = ev->Get<TEvBlobStorage::TEvVPutResult>();
+        UNIT_ASSERT(putResult);
+        TVDiskID vDiskId = VDiskIDFromVDiskID(putResult->Record.GetVDiskID());
+        TLogoBlobID part = LogoBlobIDFromLogoBlobID(putResult->Record.GetBlobID());
+        NKikimrProto::EReplyStatus status = putResult->Record.GetStatus();
+        CTEST << "Receive LogoBlobId# " << part << " vdisk " << vDiskId << " " << NKikimrProto::EReplyStatus_Name(status) << Endl;
+        if (prevVDiskId) {
+            latencies[*prevVDiskId] = 1;
+        }
+        latencies[vDiskId] = 10;
+        prevVDiskId = vDiskId;
+        SetPredictedDelaysForAllQueues(latencies);
+        return true;
+    };
+
     runtime.Register(new TGeneralDecorator(THolder<IActor>(putActor.release()), action));
- 
-    for (ui64 idx = 0; idx < 8; ++idx) { 
-        TEvBlobStorage::TEvVPut::TPtr ev = testState.GrabEventPtr<TEvBlobStorage::TEvVPut>(); 
-        TLogoBlobID part = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetBlobID()); 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(ev->Get()->Record.GetVDiskID()); 
-        UNIT_ASSERT(okParts.count(part) == 0); 
-        NKikimrProto::EReplyStatus status = groupMock.OnVPut(*ev->Get()); 
-        if (status == NKikimrProto::OK) { 
-            okParts.insert(part); 
-        } 
-        TEvBlobStorage::TEvVPutResult::TPtr result = testState.CreateEventResultPtr(ev, status, vDiskId); 
-        runtime.Send(result.Release()); 
-    } 
- 
- 
-    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> expectedStatus { 
-        {blobId, NKikimrProto::OK} 
-    }; 
-    testState.ReceivePutResults(1, expectedStatus); 
-} 
- 
-void MakeTestMultiPutItemStatuses(TTestBasicRuntime &runtime, const TBlobStorageGroupType &type, 
-                                  const TBatchedVec<NKikimrProto::EReplyStatus> &statuses) { 
-    TString data("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); 
-    TTestState testState(runtime, type, DSProxyEnv.Info); 
- 
-    TVector<TLogoBlobID> blobIds = { 
-        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576), 
-        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288) 
-    }; 
-    TVector<TBlobTestSet::TBlob> blobs; 
-    for (const auto& id : blobIds) { 
-        TStringBuilder builder; 
-        for (size_t i = 0; i < id.BlobSize(); ++i) { 
-            builder << 'a'; 
-        } 
-        blobs.emplace_back(id, builder); 
-    } 
- 
-    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault; 
-    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog; 
- 
-    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched; 
-    testState.CreatePutRequests(blobs, std::back_inserter(batched), tactic, handleClass); 
+
+    for (ui64 idx = 0; idx < 8; ++idx) {
+        TEvBlobStorage::TEvVPut::TPtr ev = testState.GrabEventPtr<TEvBlobStorage::TEvVPut>();
+        TLogoBlobID part = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetBlobID());
+        TVDiskID vDiskId = VDiskIDFromVDiskID(ev->Get()->Record.GetVDiskID());
+        UNIT_ASSERT(okParts.count(part) == 0);
+        NKikimrProto::EReplyStatus status = groupMock.OnVPut(*ev->Get());
+        if (status == NKikimrProto::OK) {
+            okParts.insert(part);
+        }
+        TEvBlobStorage::TEvVPutResult::TPtr result = testState.CreateEventResultPtr(ev, status, vDiskId);
+        runtime.Send(result.Release());
+    }
+
+
+    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> expectedStatus {
+        {blobId, NKikimrProto::OK}
+    };
+    testState.ReceivePutResults(1, expectedStatus);
+}
+
+void MakeTestMultiPutItemStatuses(TTestBasicRuntime &runtime, const TBlobStorageGroupType &type,
+                                  const TBatchedVec<NKikimrProto::EReplyStatus> &statuses) {
+    TString data("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+    TTestState testState(runtime, type, DSProxyEnv.Info);
+
+    TVector<TLogoBlobID> blobIds = {
+        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576),
+        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288)
+    };
+    TVector<TBlobTestSet::TBlob> blobs;
+    for (const auto& id : blobIds) {
+        TStringBuilder builder;
+        for (size_t i = 0; i < id.BlobSize(); ++i) {
+            builder << 'a';
+        }
+        blobs.emplace_back(id, builder);
+    }
+
+    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault;
+    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog;
+
+    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched;
+    testState.CreatePutRequests(blobs, std::back_inserter(batched), tactic, handleClass);
     runtime.Register(DSProxyEnv.CreatePutRequestActor(batched, tactic, handleClass).release());
- 
-    TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses; 
-    for (ui64 idx = 0; idx < blobIds.size(); ++idx) { 
-        for (ui64 part = 1; part <= type.TotalPartCount(); ++part) { 
-            TLogoBlobID partBlobId(blobIds[idx], part); 
-            TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId); 
-            specialStatuses[id] = statuses[idx]; 
-        } 
-    } 
- 
-    TGroupMock &groupMock = testState.GetGroupMock(); 
-    groupMock.SetSpecialStatuses(specialStatuses); 
- 
-    testState.HandleVMultiPutsWithMock(type.BlobSubgroupSize()); 
- 
-    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> expectedStatus; 
-    for (ui64 idx = 0; idx < blobIds.size(); ++idx) { 
-        expectedStatus[blobIds[idx]] = statuses[idx]; 
-    } 
-    testState.ReceivePutResults(expectedStatus.size(), expectedStatus); 
-} 
- 
-Y_UNIT_TEST(TestGivenBlock42MultiPut2ItemsStatuses) { 
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block}; 
-    TTestBasicRuntime runtime(1, false); 
-    Setup(runtime, type); 
+
+    TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses;
+    for (ui64 idx = 0; idx < blobIds.size(); ++idx) {
+        for (ui64 part = 1; part <= type.TotalPartCount(); ++part) {
+            TLogoBlobID partBlobId(blobIds[idx], part);
+            TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId);
+            specialStatuses[id] = statuses[idx];
+        }
+    }
+
+    TGroupMock &groupMock = testState.GetGroupMock();
+    groupMock.SetSpecialStatuses(specialStatuses);
+
+    testState.HandleVMultiPutsWithMock(type.BlobSubgroupSize());
+
+    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> expectedStatus;
+    for (ui64 idx = 0; idx < blobIds.size(); ++idx) {
+        expectedStatus[blobIds[idx]] = statuses[idx];
+    }
+    testState.ReceivePutResults(expectedStatus.size(), expectedStatus);
+}
+
+Y_UNIT_TEST(TestGivenBlock42MultiPut2ItemsStatuses) {
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block};
+    TTestBasicRuntime runtime(1, false);
+    Setup(runtime, type);
     constexpr ui64 statusCount = 3;
-    NKikimrProto::EReplyStatus maybeStatuses[statusCount] = { 
-        NKikimrProto::OK, 
-        NKikimrProto::BLOCKED, 
-        NKikimrProto::DEADLINE 
-    }; 
-    Y_VERIFY(maybeStatuses[statusCount - 1] == NKikimrProto::DEADLINE); 
-    for (ui64 fstIdx = 0; fstIdx < statusCount; ++fstIdx) { 
-        for (ui64 sndIdx = 0; sndIdx < statusCount; ++sndIdx) { 
-            MakeTestMultiPutItemStatuses(runtime, type, {maybeStatuses[fstIdx], maybeStatuses[sndIdx]}); 
-        } 
-    } 
-} 
- 
-enum { 
-    Begin = EventSpaceBegin(TEvents::ES_USERSPACE), 
-    EvRequestEnd 
-}; 
- 
-struct TEvRequestEnd : TEventLocal<TEvRequestEnd, EvRequestEnd> { 
-    TEvRequestEnd() = default; 
-}; 
- 
-struct TDyingDecorator : public TTestDecorator { 
-    TActorId ParentId; 
- 
-    TDyingDecorator(THolder<IActor> &&actor, TActorId parentId) 
-        : TTestDecorator(std::move(actor)) 
-        , ParentId(parentId) 
-    { 
-    } 
- 
-    virtual ~TDyingDecorator() { 
-        if (NActors::TlsActivationContext) { 
-            std::unique_ptr<IEventBase> ev = std::make_unique<TEvRequestEnd>(); 
-            std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(ParentId, ParentId, ev.release()); 
-            TActivationContext::Send(handle.release()); 
-        } 
-    } 
-}; 
- 
-Y_UNIT_TEST(TestGivenBlock42GroupGenerationGreaterThanVDiskGenerations) { 
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block}; 
-    TTestBasicRuntime runtime(1, false); 
-    Setup(runtime, type); 
- 
-    TString data("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); 
-    TTestState testState(runtime, type, DSProxyEnv.Info); 
- 
-    TVector<TLogoBlobID> blobIds = { 
-        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576), 
-        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288) 
-    }; 
-    TVector<TBlobTestSet::TBlob> blobs; 
-    for (const auto& id : blobIds) { 
-        TStringBuilder builder; 
-        for (size_t i = 0; i < id.BlobSize(); ++i) { 
-            builder << 'a'; 
-        } 
-        blobs.emplace_back(id, builder); 
-    } 
- 
-    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault; 
-    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog; 
- 
-    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched; 
-    testState.CreatePutRequests(blobs, std::back_inserter(batched), tactic, handleClass); 
- 
-    DSProxyEnv.SetGroupGeneration(2); 
- 
-    THolder<IActor> putActor(DSProxyEnv.CreatePutRequestActor(batched, tactic, handleClass).release()); 
-    runtime.Register(new TDyingDecorator( 
-            std::move(putActor), testState.EdgeActor)); 
- 
-    TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses; 
-    for (ui64 idx = 0; idx < blobIds.size(); ++idx) { 
-        for (ui64 part = 1; part <= type.TotalPartCount(); ++part) { 
-            TLogoBlobID partBlobId(blobIds[idx], part); 
-            TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId); 
-            specialStatuses[id] = NKikimrProto::RACE; 
-        } 
-    } 
- 
-    TGroupMock &groupMock = testState.GetGroupMock(); 
-    groupMock.SetSpecialStatuses(specialStatuses); 
- 
-    testState.HandleVMultiPutsWithMock(8); 
-    testState.GrabEventPtr<TEvRequestEnd>(); 
-} 
- 
-void MakeTestGivenBlock42GetRecoverMultiPutStatuses(NKikimrProto::EReplyStatus expectedStatus, 
-        const TVector<NKikimrProto::EReplyStatus> &statuses = {}) { 
-    Y_UNUSED(expectedStatus); 
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block}; 
-    TTestBasicRuntime runtime(1, false); 
-    Setup(runtime, type); 
- 
-    constexpr ui64 blobCount = 2; 
-    TVector<TLogoBlobID> blobIds = { 
-        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576), 
-        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288) 
-    }; 
-    Y_VERIFY(blobIds.size() == blobCount); 
-    Y_VERIFY(statuses.empty() || statuses.size() == blobCount); 
- 
-    TVector<TBlobTestSet::TBlob> blobs; 
-    for (const auto& id : blobIds) { 
-        TStringBuilder builder; 
-        for (size_t i = 0; i < id.BlobSize(); ++i) { 
-            builder << 'a'; 
-        } 
-        blobs.emplace_back(id, builder); 
-    } 
- 
-    TTestState testState(runtime, type, DSProxyEnv.Info); 
- 
-    TGroupMock &groupMock = testState.GetGroupMock(); 
-    testState.PutBlobsToGroupMock(blobs); 
-    groupMock.Wipe(3); 
-    groupMock.Wipe(4); 
- 
-    TEvBlobStorage::TEvGet::TPtr ev = testState.CreateGetRequest(blobIds, true); 
+    NKikimrProto::EReplyStatus maybeStatuses[statusCount] = {
+        NKikimrProto::OK,
+        NKikimrProto::BLOCKED,
+        NKikimrProto::DEADLINE
+    };
+    Y_VERIFY(maybeStatuses[statusCount - 1] == NKikimrProto::DEADLINE);
+    for (ui64 fstIdx = 0; fstIdx < statusCount; ++fstIdx) {
+        for (ui64 sndIdx = 0; sndIdx < statusCount; ++sndIdx) {
+            MakeTestMultiPutItemStatuses(runtime, type, {maybeStatuses[fstIdx], maybeStatuses[sndIdx]});
+        }
+    }
+}
+
+enum {
+    Begin = EventSpaceBegin(TEvents::ES_USERSPACE),
+    EvRequestEnd
+};
+
+struct TEvRequestEnd : TEventLocal<TEvRequestEnd, EvRequestEnd> {
+    TEvRequestEnd() = default;
+};
+
+struct TDyingDecorator : public TTestDecorator {
+    TActorId ParentId;
+
+    TDyingDecorator(THolder<IActor> &&actor, TActorId parentId)
+        : TTestDecorator(std::move(actor))
+        , ParentId(parentId)
+    {
+    }
+
+    virtual ~TDyingDecorator() {
+        if (NActors::TlsActivationContext) {
+            std::unique_ptr<IEventBase> ev = std::make_unique<TEvRequestEnd>();
+            std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(ParentId, ParentId, ev.release());
+            TActivationContext::Send(handle.release());
+        }
+    }
+};
+
+Y_UNIT_TEST(TestGivenBlock42GroupGenerationGreaterThanVDiskGenerations) {
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block};
+    TTestBasicRuntime runtime(1, false);
+    Setup(runtime, type);
+
+    TString data("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+    TTestState testState(runtime, type, DSProxyEnv.Info);
+
+    TVector<TLogoBlobID> blobIds = {
+        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576),
+        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288)
+    };
+    TVector<TBlobTestSet::TBlob> blobs;
+    for (const auto& id : blobIds) {
+        TStringBuilder builder;
+        for (size_t i = 0; i < id.BlobSize(); ++i) {
+            builder << 'a';
+        }
+        blobs.emplace_back(id, builder);
+    }
+
+    TEvBlobStorage::TEvPut::ETactic tactic = TEvBlobStorage::TEvPut::TacticDefault;
+    NKikimrBlobStorage::EPutHandleClass handleClass = NKikimrBlobStorage::TabletLog;
+
+    TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched;
+    testState.CreatePutRequests(blobs, std::back_inserter(batched), tactic, handleClass);
+
+    DSProxyEnv.SetGroupGeneration(2);
+
+    THolder<IActor> putActor(DSProxyEnv.CreatePutRequestActor(batched, tactic, handleClass).release());
+    runtime.Register(new TDyingDecorator(
+            std::move(putActor), testState.EdgeActor));
+
+    TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses;
+    for (ui64 idx = 0; idx < blobIds.size(); ++idx) {
+        for (ui64 part = 1; part <= type.TotalPartCount(); ++part) {
+            TLogoBlobID partBlobId(blobIds[idx], part);
+            TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId);
+            specialStatuses[id] = NKikimrProto::RACE;
+        }
+    }
+
+    TGroupMock &groupMock = testState.GetGroupMock();
+    groupMock.SetSpecialStatuses(specialStatuses);
+
+    testState.HandleVMultiPutsWithMock(8);
+    testState.GrabEventPtr<TEvRequestEnd>();
+}
+
+void MakeTestGivenBlock42GetRecoverMultiPutStatuses(NKikimrProto::EReplyStatus expectedStatus,
+        const TVector<NKikimrProto::EReplyStatus> &statuses = {}) {
+    Y_UNUSED(expectedStatus);
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block};
+    TTestBasicRuntime runtime(1, false);
+    Setup(runtime, type);
+
+    constexpr ui64 blobCount = 2;
+    TVector<TLogoBlobID> blobIds = {
+        TLogoBlobID(72075186224047637, 1, 863, 1, 786, 24576),
+        TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288)
+    };
+    Y_VERIFY(blobIds.size() == blobCount);
+    Y_VERIFY(statuses.empty() || statuses.size() == blobCount);
+
+    TVector<TBlobTestSet::TBlob> blobs;
+    for (const auto& id : blobIds) {
+        TStringBuilder builder;
+        for (size_t i = 0; i < id.BlobSize(); ++i) {
+            builder << 'a';
+        }
+        blobs.emplace_back(id, builder);
+    }
+
+    TTestState testState(runtime, type, DSProxyEnv.Info);
+
+    TGroupMock &groupMock = testState.GetGroupMock();
+    testState.PutBlobsToGroupMock(blobs);
+    groupMock.Wipe(3);
+    groupMock.Wipe(4);
+
+    TEvBlobStorage::TEvGet::TPtr ev = testState.CreateGetRequest(blobIds, true);
     runtime.Register(DSProxyEnv.CreateGetRequestActor(ev, NKikimrBlobStorage::TabletLog, true).release());
- 
-    testState.HandleVGetsWithMock(type.BlobSubgroupSize()); 
- 
-    if (statuses.empty()) { 
-        groupMock.SetError(3, expectedStatus); 
-        groupMock.SetError(4, expectedStatus); 
-    } else { 
-        TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses; 
-        for (ui64 idx = 0; idx < blobIds.size(); ++idx) { 
-            for (ui64 part = 3; part <= 4; ++part) { 
-                TLogoBlobID partBlobId(blobIds[idx], part - 2 * idx); 
-                TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId); 
-                specialStatuses[id] = statuses[idx]; 
-            } 
-        } 
-        groupMock.SetSpecialStatuses(specialStatuses); 
-    } 
- 
-    testState.HandleVMultiPutsWithMock(3); 
- 
-    TAutoPtr<IEventHandle> handle; 
-    auto getResult = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvGetResult>(handle); 
-    UNIT_ASSERT(getResult); 
-    UNIT_ASSERT(getResult->Status == expectedStatus); 
-} 
- 
-Y_UNIT_TEST(TestGivenBlock42GetRecoverMultiPutStatuses) { 
+
+    testState.HandleVGetsWithMock(type.BlobSubgroupSize());
+
+    if (statuses.empty()) {
+        groupMock.SetError(3, expectedStatus);
+        groupMock.SetError(4, expectedStatus);
+    } else {
+        TMap<TPartLocation, NKikimrProto::EReplyStatus> specialStatuses;
+        for (ui64 idx = 0; idx < blobIds.size(); ++idx) {
+            for (ui64 part = 3; part <= 4; ++part) {
+                TLogoBlobID partBlobId(blobIds[idx], part - 2 * idx);
+                TPartLocation id = testState.PrimaryVDiskForBlobPart(partBlobId);
+                specialStatuses[id] = statuses[idx];
+            }
+        }
+        groupMock.SetSpecialStatuses(specialStatuses);
+    }
+
+    testState.HandleVMultiPutsWithMock(3);
+
+    TAutoPtr<IEventHandle> handle;
+    auto getResult = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvGetResult>(handle);
+    UNIT_ASSERT(getResult);
+    UNIT_ASSERT(getResult->Status == expectedStatus);
+}
+
+Y_UNIT_TEST(TestGivenBlock42GetRecoverMultiPutStatuses) {
     constexpr ui64 statusCount = 3;
-    NKikimrProto::EReplyStatus maybeStatuses[statusCount] = { 
-        NKikimrProto::OK, 
-        NKikimrProto::BLOCKED, 
-        NKikimrProto::DEADLINE 
-    }; 
-    Y_VERIFY(maybeStatuses[statusCount - 1] == NKikimrProto::DEADLINE); 
-    for (ui64 idx = 0; idx < statusCount; ++idx) { 
-        MakeTestGivenBlock42GetRecoverMultiPutStatuses(maybeStatuses[idx]); 
-    } 
-} 
- 
-Y_UNIT_TEST(TestGivenBlock42GetRecoverMultiPut2ItemsStatuses) { 
+    NKikimrProto::EReplyStatus maybeStatuses[statusCount] = {
+        NKikimrProto::OK,
+        NKikimrProto::BLOCKED,
+        NKikimrProto::DEADLINE
+    };
+    Y_VERIFY(maybeStatuses[statusCount - 1] == NKikimrProto::DEADLINE);
+    for (ui64 idx = 0; idx < statusCount; ++idx) {
+        MakeTestGivenBlock42GetRecoverMultiPutStatuses(maybeStatuses[idx]);
+    }
+}
+
+Y_UNIT_TEST(TestGivenBlock42GetRecoverMultiPut2ItemsStatuses) {
     constexpr ui64 statusCount = 3;
-    NKikimrProto::EReplyStatus maybeStatuses[statusCount] = { 
-        NKikimrProto::OK, 
-        NKikimrProto::BLOCKED, 
-        NKikimrProto::DEADLINE 
-    }; 
-    Y_VERIFY(maybeStatuses[statusCount - 1] == NKikimrProto::DEADLINE); 
-    for (ui64 idx = 1; idx < statusCount; ++idx) { 
-        MakeTestGivenBlock42GetRecoverMultiPutStatuses(maybeStatuses[idx], {maybeStatuses[idx], maybeStatuses[0]}); 
-        MakeTestGivenBlock42GetRecoverMultiPutStatuses(maybeStatuses[idx], {maybeStatuses[0], maybeStatuses[idx]}); 
-    } 
-} 
- 
-Y_UNIT_TEST(TestGivenMirror3DCGetWithFirstSlowDisk) { 
-    TBlobStorageGroupType type = {TErasureType::ErasureMirror3dc}; 
-    TTestBasicRuntime runtime(1, false); 
-    Setup(runtime, type); 
- 
-    TLogoBlobID blobId = TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288); 
- 
-    TTestState testState(runtime, type, DSProxyEnv.Info); 
- 
- 
-    TEvBlobStorage::TEvGet::TPtr ev = testState.CreateGetRequest({blobId}, false); 
+    NKikimrProto::EReplyStatus maybeStatuses[statusCount] = {
+        NKikimrProto::OK,
+        NKikimrProto::BLOCKED,
+        NKikimrProto::DEADLINE
+    };
+    Y_VERIFY(maybeStatuses[statusCount - 1] == NKikimrProto::DEADLINE);
+    for (ui64 idx = 1; idx < statusCount; ++idx) {
+        MakeTestGivenBlock42GetRecoverMultiPutStatuses(maybeStatuses[idx], {maybeStatuses[idx], maybeStatuses[0]});
+        MakeTestGivenBlock42GetRecoverMultiPutStatuses(maybeStatuses[idx], {maybeStatuses[0], maybeStatuses[idx]});
+    }
+}
+
+Y_UNIT_TEST(TestGivenMirror3DCGetWithFirstSlowDisk) {
+    TBlobStorageGroupType type = {TErasureType::ErasureMirror3dc};
+    TTestBasicRuntime runtime(1, false);
+    Setup(runtime, type);
+
+    TLogoBlobID blobId = TLogoBlobID(72075186224047637, 1, 2194, 1, 142, 12288);
+
+    TTestState testState(runtime, type, DSProxyEnv.Info);
+
+
+    TEvBlobStorage::TEvGet::TPtr ev = testState.CreateGetRequest({blobId}, false);
     TActorId getActorId = runtime.Register(DSProxyEnv.CreateGetRequestActor(ev, NKikimrBlobStorage::TabletLog, false).release());
-    runtime.EnableScheduleForActor(getActorId); 
- 
-    testState.GrabEventPtr<TEvBlobStorage::TEvVGet>(); 
-    TEvBlobStorage::TEvVGet::TPtr vget = testState.GrabEventPtr<TEvBlobStorage::TEvVGet>(); 
-} 
- 
+    runtime.EnableScheduleForActor(getActorId);
+
+    testState.GrabEventPtr<TEvBlobStorage::TEvVGet>();
+    TEvBlobStorage::TEvVGet::TPtr vget = testState.GrabEventPtr<TEvBlobStorage::TEvVGet>();
+}
+
 Y_UNIT_TEST(TestGivenBlock42GetThenVGetResponseParts2523Nodata4ThenGetOk) {
     TTestBasicRuntime runtime(1, false);
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block}; 
-    Setup(runtime, type); 
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block};
+    Setup(runtime, type);
 
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
@@ -758,7 +758,7 @@ Y_UNIT_TEST(TestGivenBlock42GetThenVGetResponseParts2523Nodata4ThenGetOk) {
     TLogoBlobID logoblobid(1, 0, 0, 0, (ui32)data.size(), 0);
 
     TVector<TVDiskState> subgroup;
-    PrepareBlobSubgroup(logoblobid, data, subgroup, runtime, type); 
+    PrepareBlobSubgroup(logoblobid, data, subgroup, runtime, type);
 
     runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet(logoblobid, 0, 0, TInstant::Max(),
             NKikimrBlobStorage::EGetHandleClass::FastRead)));
@@ -790,194 +790,194 @@ Y_UNIT_TEST(TestGivenBlock42GetThenVGetResponseParts2523Nodata4ThenGetOk) {
     UNIT_ASSERT(getResult->Responses[0].Status == NKikimrProto::OK);
 }
 
- 
-struct TBlobPack { 
-    ui32 Count; 
-    ui32 DataLength; 
- 
-    static TString ToString(const TBlobPack &pack) { 
-        return TStringBuilder() << "{" 
-            << "Count# " << pack.Count 
-            << " DataLength# " << pack.DataLength 
-            << '}'; 
-    } 
- 
-    TString ToString() const { 
-        return ToString(*this); 
-    } 
-}; 
- 
-TString VectorToString(const TVector<ui32> &vec) { 
-    TStringBuilder str; 
-    str << "{" << Endl; 
-    str << "Size# " << vec.size() << Endl; 
-    for (ui64 idx = 0; idx < vec.size(); ++idx) { 
-        str << " [" << idx << "]# " << ToString(vec[idx]); 
-    } 
-    str << "}"; 
-    return str; 
-} 
- 
-template <typename Type> 
-TString VectorToString(const TVector<Type> &vec) { 
-    TStringBuilder str; 
-    str << "{" << Endl; 
-    str << "Size# " << vec.size() << Endl; 
-    for (ui64 idx = 0; idx < vec.size(); ++idx) { 
-        str << " [" << idx << "]# " << Type::ToString(vec[idx]); 
-    } 
-    str << "}"; 
-    return str; 
-} 
- 
-void MakeTestProtobufSizeWithMultiGet(const TVector<TBlobPack> &packs, TVector<ui32> vGetQueryCounts) { 
-    TTestBasicRuntime runtime(1, false); 
-    TBlobStorageGroupType type(TErasureType::ErasureNone); 
-    Setup(runtime, type); 
- 
+
+struct TBlobPack {
+    ui32 Count;
+    ui32 DataLength;
+
+    static TString ToString(const TBlobPack &pack) {
+        return TStringBuilder() << "{"
+            << "Count# " << pack.Count
+            << " DataLength# " << pack.DataLength
+            << '}';
+    }
+
+    TString ToString() const {
+        return ToString(*this);
+    }
+};
+
+TString VectorToString(const TVector<ui32> &vec) {
+    TStringBuilder str;
+    str << "{" << Endl;
+    str << "Size# " << vec.size() << Endl;
+    for (ui64 idx = 0; idx < vec.size(); ++idx) {
+        str << " [" << idx << "]# " << ToString(vec[idx]);
+    }
+    str << "}";
+    return str;
+}
+
+template <typename Type>
+TString VectorToString(const TVector<Type> &vec) {
+    TStringBuilder str;
+    str << "{" << Endl;
+    str << "Size# " << vec.size() << Endl;
+    for (ui64 idx = 0; idx < vec.size(); ++idx) {
+        str << " [" << idx << "]# " << Type::ToString(vec[idx]);
+    }
+    str << "}";
+    return str;
+}
+
+void MakeTestProtobufSizeWithMultiGet(const TVector<TBlobPack> &packs, TVector<ui32> vGetQueryCounts) {
+    TTestBasicRuntime runtime(1, false);
+    TBlobStorageGroupType type(TErasureType::ErasureNone);
+    Setup(runtime, type);
+
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
- 
-    TVector<TString> datas(packs.size()); 
-    for (ui32 idx = 0; idx < packs.size(); ++idx) { 
-        for (ui32 chIdx = 0; chIdx < packs[idx].DataLength; ++chIdx) { 
-            datas[idx] += 'a' + chIdx % 26; 
-        } 
-    } 
-    ui32 blobCount = 0; 
-    for (const TBlobPack &pack : packs) { 
-        blobCount += pack.Count; 
-    } 
- 
-    TVector<TVector<TVDiskState>> blobSubgroups(blobCount); 
-    TVector<TLogoBlobID> blobIds(blobCount); 
-    for (ui32 packIdx = 0, blobIdx = 0; packIdx < packs.size(); ++packIdx) { 
-        const TBlobPack &pack = packs[packIdx]; 
-        for (ui32 interIdx = 0; interIdx < pack.Count; ++interIdx, ++blobIdx) { 
-            blobIds[blobIdx] = TLogoBlobID(1, 0, blobIdx, 0, datas[packIdx].size(), 0); 
-            PrepareBlobSubgroup(blobIds[blobIdx], datas[packIdx], blobSubgroups[blobIdx], runtime, type); 
-        } 
-    } 
- 
-    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queries(new TEvBlobStorage::TEvGet::TQuery[blobCount]); 
-    for (ui32 i = 0; i < blobCount; ++i) { 
-        auto &q = queries[i]; 
-        q.Id = blobIds[i]; 
-        q.Shift = 0; 
-        q.Size = q.Id.BlobSize(); 
-    } 
-    runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet( 
-        queries, blobCount, TInstant::Max(), 
-        NKikimrBlobStorage::EGetHandleClass::AsyncRead, false))); 
- 
-    struct TTestVGetInfo { 
-        ui32 Count; 
-        ui32 ProtobufSize; 
- 
-        static TString ToString(const TTestVGetInfo& self) { 
-            return TStringBuilder() << "{" << "Count# " << self.Count << " ProtobufSize# " << self.ProtobufSize << "}"; 
-        } 
- 
-        TString ToString() const { 
-            return ToString(*this); 
-        } 
-    }; 
- 
-    TVector<TTestVGetInfo> vGetInformations; 
-    vGetInformations.push_back({0, 0}); 
-    TQueryResultSizeTracker resultSize; 
-    resultSize.Init(); 
-    TMap<ui64, ui64> firstQueryStepToVGetIdx = { {0, 0} }; 
-    TVector<ui64> firstSteps(1, 0); 
-    for (ui32 i = 0; i < blobCount; ++i) { 
-        ui32 size = blobIds[i].BlobSize(); 
-        resultSize.AddLogoBlobIndex(); 
-        resultSize.AddLogoBlobData(size, 0, 0); 
-        if (resultSize.IsOverflow()) { 
-            firstSteps.push_back(blobIds[i].Step()); 
-            firstQueryStepToVGetIdx[firstSteps.back()] = firstSteps.size() - 1; 
-            resultSize.Init(); 
-            resultSize.AddLogoBlobIndex(); 
-            resultSize.AddLogoBlobData(size, 0, 0); 
-            vGetInformations.push_back({0, 0}); 
-        } 
-        vGetInformations.back().Count++; 
-        vGetInformations.back().ProtobufSize = resultSize.GetSize(); 
-    } 
- 
-    UNIT_ASSERT_C(vGetInformations.size() == vGetQueryCounts.size(), 
-            "not equal vGetCount for multiget" 
-            << " vGetInformations# " << VectorToString(vGetInformations) 
-            << " vGetQueryCounts# " << VectorToString(vGetQueryCounts)); 
-    for (ui32 vGetIdx = 0; vGetIdx < vGetInformations.size(); ++vGetIdx) { 
-        UNIT_ASSERT_C(vGetInformations[vGetIdx].Count == vGetQueryCounts[vGetIdx], 
-                "not equal query count " 
-                << " vGetIdx# " << vGetIdx 
-                << " vGetInformations# " << VectorToString(vGetInformations) 
-                << " vGetQueryCounts# " << VectorToString(vGetQueryCounts)); 
-    } 
- 
-    for (ui64 idx = 0; idx < vGetInformations.size(); ++idx) { 
+
+    TVector<TString> datas(packs.size());
+    for (ui32 idx = 0; idx < packs.size(); ++idx) {
+        for (ui32 chIdx = 0; chIdx < packs[idx].DataLength; ++chIdx) {
+            datas[idx] += 'a' + chIdx % 26;
+        }
+    }
+    ui32 blobCount = 0;
+    for (const TBlobPack &pack : packs) {
+        blobCount += pack.Count;
+    }
+
+    TVector<TVector<TVDiskState>> blobSubgroups(blobCount);
+    TVector<TLogoBlobID> blobIds(blobCount);
+    for (ui32 packIdx = 0, blobIdx = 0; packIdx < packs.size(); ++packIdx) {
+        const TBlobPack &pack = packs[packIdx];
+        for (ui32 interIdx = 0; interIdx < pack.Count; ++interIdx, ++blobIdx) {
+            blobIds[blobIdx] = TLogoBlobID(1, 0, blobIdx, 0, datas[packIdx].size(), 0);
+            PrepareBlobSubgroup(blobIds[blobIdx], datas[packIdx], blobSubgroups[blobIdx], runtime, type);
+        }
+    }
+
+    TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queries(new TEvBlobStorage::TEvGet::TQuery[blobCount]);
+    for (ui32 i = 0; i < blobCount; ++i) {
+        auto &q = queries[i];
+        q.Id = blobIds[i];
+        q.Shift = 0;
+        q.Size = q.Id.BlobSize();
+    }
+    runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet(
+        queries, blobCount, TInstant::Max(),
+        NKikimrBlobStorage::EGetHandleClass::AsyncRead, false)));
+
+    struct TTestVGetInfo {
+        ui32 Count;
+        ui32 ProtobufSize;
+
+        static TString ToString(const TTestVGetInfo& self) {
+            return TStringBuilder() << "{" << "Count# " << self.Count << " ProtobufSize# " << self.ProtobufSize << "}";
+        }
+
+        TString ToString() const {
+            return ToString(*this);
+        }
+    };
+
+    TVector<TTestVGetInfo> vGetInformations;
+    vGetInformations.push_back({0, 0});
+    TQueryResultSizeTracker resultSize;
+    resultSize.Init();
+    TMap<ui64, ui64> firstQueryStepToVGetIdx = { {0, 0} };
+    TVector<ui64> firstSteps(1, 0);
+    for (ui32 i = 0; i < blobCount; ++i) {
+        ui32 size = blobIds[i].BlobSize();
+        resultSize.AddLogoBlobIndex();
+        resultSize.AddLogoBlobData(size, 0, 0);
+        if (resultSize.IsOverflow()) {
+            firstSteps.push_back(blobIds[i].Step());
+            firstQueryStepToVGetIdx[firstSteps.back()] = firstSteps.size() - 1;
+            resultSize.Init();
+            resultSize.AddLogoBlobIndex();
+            resultSize.AddLogoBlobData(size, 0, 0);
+            vGetInformations.push_back({0, 0});
+        }
+        vGetInformations.back().Count++;
+        vGetInformations.back().ProtobufSize = resultSize.GetSize();
+    }
+
+    UNIT_ASSERT_C(vGetInformations.size() == vGetQueryCounts.size(),
+            "not equal vGetCount for multiget"
+            << " vGetInformations# " << VectorToString(vGetInformations)
+            << " vGetQueryCounts# " << VectorToString(vGetQueryCounts));
+    for (ui32 vGetIdx = 0; vGetIdx < vGetInformations.size(); ++vGetIdx) {
+        UNIT_ASSERT_C(vGetInformations[vGetIdx].Count == vGetQueryCounts[vGetIdx],
+                "not equal query count "
+                << " vGetIdx# " << vGetIdx
+                << " vGetInformations# " << VectorToString(vGetInformations)
+                << " vGetQueryCounts# " << VectorToString(vGetQueryCounts));
+    }
+
+    for (ui64 idx = 0; idx < vGetInformations.size(); ++idx) {
         TMap<TActorId, TGetRequest> lastRequest;
-        TAutoPtr<IEventHandle> handle; 
-        auto vget = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVGet>(handle); 
-        UNIT_ASSERT_C(vget->Record.ExtremeQueriesSize(), "vget without queries vGet# " << vget->ToString()); 
-        auto firstQuery = vget->Record.GetExtremeQueries(0); 
-        TLogoBlobID firstBlobId = LogoBlobIDFromLogoBlobID(firstQuery.GetId()); 
-        ui64 step = firstBlobId.Step(); 
-        UNIT_ASSERT_C(firstQueryStepToVGetIdx.count(step), 
-                "not expected first blobId step" 
-                << " idx# " << idx 
-                << " step# " << step 
-                << " firstSteps# " << FormatList(firstSteps) 
-                << " vGet# " << vget->ToString() 
-                << " vGetInformations# " << VectorToString(vGetInformations) 
-                << " vGetQueryCounts# " << VectorToString(vGetQueryCounts)); 
-        ui64 vGetIdx = firstQueryStepToVGetIdx[step]; 
-        TTestVGetInfo &vGetInfo = vGetInformations[vGetIdx]; 
-        lastRequest[handle->Recipient].SetFrom(handle.Get(), vget); 
-        UNIT_ASSERT_C(vget->Record.ExtremeQueriesSize() == vGetInfo.Count, 
-                "vget query count not equal predicted count" 
-                << " idx# " << idx 
-                << " vGetIdx# " << vGetIdx 
-                << " realQueryCount# " << vget->Record.ExtremeQueriesSize() 
-                << " predictedQueryCount# " << vGetInfo.Count 
-                << " vGet# " << vget->ToString() 
-                << " vGetInformations# " << VectorToString(vGetInformations) 
-                << " vGetQueryCounts# " << VectorToString(vGetQueryCounts)); 
-        UNIT_ASSERT_C(vget->Record.ByteSizeLong() <= vGetInfo.ProtobufSize, 
-                "real protobuf size greater than predicted size" 
-                << " idx# " << idx 
-                << " vGetIdx# " << vGetIdx 
-                << " realProtoBufSize# " << vget->Record.ByteSizeLong() 
-                << " predictedProtoBufSize# " << vGetInfo.ProtobufSize 
-                << " vGet# " << vget->ToString() 
-                << " vGetInformations# " << VectorToString(vGetInformations) 
-                << " vGetQueryCounts# " << VectorToString(vGetQueryCounts)); 
-        SendVGetResult(0, 0, NKikimrProto::OK, blobSubgroups, lastRequest, runtime); 
-    } 
- 
-    TAutoPtr<IEventHandle> handle; 
-    auto getResult = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvGetResult>(handle); 
-    UNIT_ASSERT(getResult); 
-    UNIT_ASSERT(getResult->Status == NKikimrProto::OK); 
-    UNIT_ASSERT(getResult->ResponseSz == blobCount); 
-    UNIT_ASSERT(getResult->Responses[0].Status == NKikimrProto::OK); 
-} 
- 
-Y_UNIT_TEST(TestProtobufSizeWithMultiGet) { 
-    MakeTestProtobufSizeWithMultiGet({TBlobPack{223, 300'000}, TBlobPack{1, 186'332}}, {224}); // MaxProtobufSize - 1 
-    MakeTestProtobufSizeWithMultiGet({TBlobPack{223, 300'000}, TBlobPack{1, 186'333}}, {224}); // MaxProtobufSize 
-    MakeTestProtobufSizeWithMultiGet({TBlobPack{223, 300'000}, TBlobPack{1, 186'334}}, {223, 1}); // MaxProtobufSize + 1 
- 
-    auto blobPacks = {TBlobPack{223, 300'000}, TBlobPack{1, 186'333}, TBlobPack{223, 300'000}, TBlobPack{1, 186'334}}; 
-    MakeTestProtobufSizeWithMultiGet(blobPacks, {224, 223, 1}); 
-} 
- 
+        TAutoPtr<IEventHandle> handle;
+        auto vget = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVGet>(handle);
+        UNIT_ASSERT_C(vget->Record.ExtremeQueriesSize(), "vget without queries vGet# " << vget->ToString());
+        auto firstQuery = vget->Record.GetExtremeQueries(0);
+        TLogoBlobID firstBlobId = LogoBlobIDFromLogoBlobID(firstQuery.GetId());
+        ui64 step = firstBlobId.Step();
+        UNIT_ASSERT_C(firstQueryStepToVGetIdx.count(step),
+                "not expected first blobId step"
+                << " idx# " << idx
+                << " step# " << step
+                << " firstSteps# " << FormatList(firstSteps)
+                << " vGet# " << vget->ToString()
+                << " vGetInformations# " << VectorToString(vGetInformations)
+                << " vGetQueryCounts# " << VectorToString(vGetQueryCounts));
+        ui64 vGetIdx = firstQueryStepToVGetIdx[step];
+        TTestVGetInfo &vGetInfo = vGetInformations[vGetIdx];
+        lastRequest[handle->Recipient].SetFrom(handle.Get(), vget);
+        UNIT_ASSERT_C(vget->Record.ExtremeQueriesSize() == vGetInfo.Count,
+                "vget query count not equal predicted count"
+                << " idx# " << idx
+                << " vGetIdx# " << vGetIdx
+                << " realQueryCount# " << vget->Record.ExtremeQueriesSize()
+                << " predictedQueryCount# " << vGetInfo.Count
+                << " vGet# " << vget->ToString()
+                << " vGetInformations# " << VectorToString(vGetInformations)
+                << " vGetQueryCounts# " << VectorToString(vGetQueryCounts));
+        UNIT_ASSERT_C(vget->Record.ByteSizeLong() <= vGetInfo.ProtobufSize,
+                "real protobuf size greater than predicted size"
+                << " idx# " << idx
+                << " vGetIdx# " << vGetIdx
+                << " realProtoBufSize# " << vget->Record.ByteSizeLong()
+                << " predictedProtoBufSize# " << vGetInfo.ProtobufSize
+                << " vGet# " << vget->ToString()
+                << " vGetInformations# " << VectorToString(vGetInformations)
+                << " vGetQueryCounts# " << VectorToString(vGetQueryCounts));
+        SendVGetResult(0, 0, NKikimrProto::OK, blobSubgroups, lastRequest, runtime);
+    }
+
+    TAutoPtr<IEventHandle> handle;
+    auto getResult = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvGetResult>(handle);
+    UNIT_ASSERT(getResult);
+    UNIT_ASSERT(getResult->Status == NKikimrProto::OK);
+    UNIT_ASSERT(getResult->ResponseSz == blobCount);
+    UNIT_ASSERT(getResult->Responses[0].Status == NKikimrProto::OK);
+}
+
+Y_UNIT_TEST(TestProtobufSizeWithMultiGet) {
+    MakeTestProtobufSizeWithMultiGet({TBlobPack{223, 300'000}, TBlobPack{1, 186'332}}, {224}); // MaxProtobufSize - 1
+    MakeTestProtobufSizeWithMultiGet({TBlobPack{223, 300'000}, TBlobPack{1, 186'333}}, {224}); // MaxProtobufSize
+    MakeTestProtobufSizeWithMultiGet({TBlobPack{223, 300'000}, TBlobPack{1, 186'334}}, {223, 1}); // MaxProtobufSize + 1
+
+    auto blobPacks = {TBlobPack{223, 300'000}, TBlobPack{1, 186'333}, TBlobPack{223, 300'000}, TBlobPack{1, 186'334}};
+    MakeTestProtobufSizeWithMultiGet(blobPacks, {224, 223, 1});
+}
+
 Y_UNIT_TEST(TestGivenStripe42GetThenVGetResponsePartsNodata263451ThenGetOk) {
     TTestBasicRuntime runtime(1, false);
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Stripe}; 
-    Setup(runtime, type); 
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Stripe};
+    Setup(runtime, type);
 
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
@@ -987,7 +987,7 @@ Y_UNIT_TEST(TestGivenStripe42GetThenVGetResponsePartsNodata263451ThenGetOk) {
     TLogoBlobID logoblobid(0x10010000001000Bull, 5, 58949, 1, 1209816, 10);
 
     TVector<TVDiskState> subgroup;
-    PrepareBlobSubgroup(logoblobid, data, subgroup, runtime, type); 
+    PrepareBlobSubgroup(logoblobid, data, subgroup, runtime, type);
 
     runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet(logoblobid, 0, 0, TInstant::Max(),
         NKikimrBlobStorage::EGetHandleClass::FastRead)));
@@ -1019,11 +1019,11 @@ Y_UNIT_TEST(TestGivenStripe42GetThenVGetResponsePartsNodata263451ThenGetOk) {
     UNIT_ASSERT(getResult->Responses[0].Status == NKikimrProto::OK);
 }
 
-Y_UNIT_TEST(TestGivenStripe42WhenGet2PartsOfBlobThenGetOk) { 
+Y_UNIT_TEST(TestGivenStripe42WhenGet2PartsOfBlobThenGetOk) {
     // Arrange
     TTestBasicRuntime runtime(1, false);
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Stripe}; 
-    Setup(runtime, type); 
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Stripe};
+    Setup(runtime, type);
 
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
@@ -1047,7 +1047,7 @@ Y_UNIT_TEST(TestGivenStripe42WhenGet2PartsOfBlobThenGetOk) {
     TMap<TActorId, TGetRequest> lastRequest;
 
     for (ui32 i = 0; i < logoblobids.size(); ++i) {
-        PrepareBlobSubgroup(logoblobids[i], data, blobSubgroups[i], runtime, type); 
+        PrepareBlobSubgroup(logoblobids[i], data, blobSubgroups[i], runtime, type);
     }
 
     // Act
@@ -1087,8 +1087,8 @@ Y_UNIT_TEST(TestGivenStripe42WhenGet2PartsOfBlobThenGetOk) {
 
 Y_UNIT_TEST(TestGivenBlock42IntersectingPutWhenNodataOkThenOk) {
     TTestBasicRuntime runtime(1, false);
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block}; 
-    Setup(runtime, type); 
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block};
+    Setup(runtime, type);
 
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
@@ -1108,7 +1108,7 @@ Y_UNIT_TEST(TestGivenBlock42IntersectingPutWhenNodataOkThenOk) {
     TMap<TActorId, TGetRequest> lastRequest;
 
     for (ui32 i = 0; i < logoblobids.size(); ++i) {
-        PrepareBlobSubgroup(logoblobids[i], data, blobSubgroups[i], runtime, type); 
+        PrepareBlobSubgroup(logoblobids[i], data, blobSubgroups[i], runtime, type);
     }
 
     TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queries(new TEvBlobStorage::TEvGet::TQuery[4]);
@@ -1147,8 +1147,8 @@ Y_UNIT_TEST(TestGivenBlock42IntersectingPutWhenNodataOkThenOk) {
 
 Y_UNIT_TEST(TestGivenBlock42PutWhenPartialGetThenSingleDiskRequestOk) {
     TTestBasicRuntime runtime(1, false);
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block}; 
-    Setup(runtime, type); 
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block};
+    Setup(runtime, type);
 
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
@@ -1160,7 +1160,7 @@ Y_UNIT_TEST(TestGivenBlock42PutWhenPartialGetThenSingleDiskRequestOk) {
     }
     TLogoBlobID logoblobid(1, 2, 3, 4, (ui32)data.size(), 5);
     TVector<TVDiskState> blobSubgroup;
-    PrepareBlobSubgroup(logoblobid, data, blobSubgroup, runtime, type); 
+    PrepareBlobSubgroup(logoblobid, data, blobSubgroup, runtime, type);
 
     for (ui32 step = 0; step < 32; ++step) {
         for (ui32 part = 0; part < 4; ++part) {
@@ -1256,8 +1256,8 @@ Y_UNIT_TEST(TestGivenBlock42PutWhenPartialGetThenSingleDiskRequestOk) {
 
 Y_UNIT_TEST(TestGivenBlock42Put6PartsOnOneVDiskWhenDiscoverThenRecoverFirst) {
     TTestBasicRuntime runtime(1, false);
-    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block}; 
-    Setup(runtime, type); 
+    TBlobStorageGroupType type = {TErasureType::Erasure4Plus2Block};
+    Setup(runtime, type);
 
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
@@ -1270,7 +1270,7 @@ Y_UNIT_TEST(TestGivenBlock42Put6PartsOnOneVDiskWhenDiscoverThenRecoverFirst) {
     TLogoBlobID logoblobid(1, 2, 3, 4, (ui32)data.size(), 5);
     TVector<TVector<TVDiskState>> blobSubgroups;
     blobSubgroups.resize(1);
-    PrepareBlobSubgroup(logoblobid, data, blobSubgroups[0], runtime, type); 
+    PrepareBlobSubgroup(logoblobid, data, blobSubgroups[0], runtime, type);
 
 
     const ui64 tabletId = 1;
@@ -1305,7 +1305,7 @@ Y_UNIT_TEST(TestGivenBlock42Put6PartsOnOneVDiskWhenDiscoverThenRecoverFirst) {
         TIngress ingress;
         for (ui32 partIdx = 0; partIdx < 6; ++partIdx) {
             TLogoBlobID blobPartId(logoblobid, partIdx + 1);
-            TIngress partIngress(*TIngress::CreateIngressWithLocal(&DSProxyEnv.Info->GetTopology(), req.VDiskId, blobPartId)); 
+            TIngress partIngress(*TIngress::CreateIngressWithLocal(&DSProxyEnv.Info->GetTopology(), req.VDiskId, blobPartId));
             ingress.Merge(partIngress);
         }
         const ui64 ingressRaw = ingress.Raw();
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_test_state_ut.h b/ydb/core/blobstorage/dsproxy/ut/dsproxy_test_state_ut.h
index 7b550ddf97..bc805ac12b 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_test_state_ut.h
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_test_state_ut.h
@@ -1,289 +1,289 @@
-#pragma once 
- 
-#include "defs.h" 
-#include "dsproxy_vdisk_mock_ut.h" 
- 
-#include <library/cpp/testing/unittest/registar.h> 
- 
- 
-namespace NKikimr { 
- 
-struct TTestState { 
-    TTestActorRuntime &Runtime; 
-    TActorId EdgeActor; 
-    TBlobStorageGroupType Type; 
-    TGroupMock GroupMock; 
-    TIntrusivePtr<TBlobStorageGroupInfo> Info; 
- 
- 
-    TTestState(TTestActorRuntime &runtime, const TBlobStorageGroupType &type, 
-            TIntrusivePtr<TBlobStorageGroupInfo> &info, ui64 nodeIndex = 0) 
-        : Runtime(runtime) 
-        , EdgeActor(runtime.AllocateEdgeActor(nodeIndex)) 
-        , Type(type) 
-        , GroupMock(0, Type.GetErasure(), Type.BlobSubgroupSize(), 1, info) 
-        , Info(info) 
-    { 
-    } 
- 
-    TTestState(TTestActorRuntime &runtime, const TBlobStorageGroupType &type, ui64 nodeIndex = 0) 
-        : Runtime(runtime) 
-        , EdgeActor(runtime.AllocateEdgeActor(nodeIndex)) 
-        , Type(type) 
-        , GroupMock(0, Type.GetErasure(), Type.BlobSubgroupSize(), 1) 
-        , Info(GroupMock.GetInfo()) 
-    { 
-    } 
- 
-    TGroupMock& GetGroupMock() { 
-        return GroupMock; 
-    } 
- 
-    //////////////////////////////////////////////////////////////////////////// 
-    // HELPER FUNCTIONS 
-    //////////////////////////////////////////////////////////////////////////// 
-    TPartLocation PrimaryVDiskForBlobPart(TLogoBlobID blobId) { 
-        Y_VERIFY(blobId.PartId()); 
-        TLogoBlobID origBlobId(blobId, 0); 
-        TVDiskID vDiskId = Info->GetVDiskInSubgroup(blobId.PartId() - 1, origBlobId.Hash()); 
-        return {blobId, vDiskId}; 
-    } 
- 
-    TPartLocation HandoffVDiskForBlobPart(TLogoBlobID blobId, ui64 handoffIdx) { 
-        Y_VERIFY(blobId.PartId()); 
-        Y_VERIFY(handoffIdx < Type.Handoff()); 
-        TLogoBlobID origBlobId(blobId, 0); 
-        TVDiskID vDiskId = Info->GetVDiskInSubgroup(Type.TotalPartCount() + handoffIdx, origBlobId.Hash()); 
-        return {blobId, vDiskId}; 
-    } 
- 
-    THashMap<TVDiskID, ui32> MakePredictedDelaysForVDisks(TLogoBlobID blobId) { 
-        TBlobStorageGroupInfo::TVDiskIds vDiskIds; 
-        TBlobStorageGroupInfo::TServiceIds serviceIds; 
-        THashMap<TVDiskID, ui32> result; 
-        Info->PickSubgroup(blobId.Hash(), &vDiskIds, &serviceIds); 
-        for (ui32 idx = 0; idx < vDiskIds.size(); ++idx) { 
-            result.emplace(vDiskIds[idx], 0); 
-        } 
-        return result; 
-    } 
- 
-    //////////////////////////////////////////////////////////////////////////// 
-    // PUT BLOBS TO GROUP MOCK 
-    //////////////////////////////////////////////////////////////////////////// 
-    TTestState& PutBlobsToGroupMock(const TBlobTestSet &blobSet) { 
-        GroupMock.PutBlobSet(blobSet); 
-        return *this; 
-    } 
- 
-    template <typename TIter> 
-    TTestState& PutBlobsToGroupMock(TIter begin, TIter end) { 
-        TBlobTestSet blobSet; 
-        blobSet.AddBlobs(begin, end); 
-        return PutBlobsToGroupMock(blobSet); 
-    } 
- 
-    TTestState& PutBlobsToGroupMock(const TVector<TBlobTestSet::TBlob> &blobs) { 
-        return PutBlobsToGroupMock(blobs.begin(), blobs.end()); 
-    } 
- 
-    //////////////////////////////////////////////////////////////////////////// 
-    // CREATE REQUESTS 
-    //////////////////////////////////////////////////////////////////////////// 
-    TEvBlobStorage::TEvPut::TPtr CreatePutRequest(const TBlobTestSet::TBlob &blob, 
-            TEvBlobStorage::TEvPut::ETactic tactic, NKikimrBlobStorage::EPutHandleClass handleClass) 
-    { 
+#pragma once
+
+#include "defs.h"
+#include "dsproxy_vdisk_mock_ut.h"
+
+#include <library/cpp/testing/unittest/registar.h>
+
+
+namespace NKikimr {
+
+struct TTestState {
+    TTestActorRuntime &Runtime;
+    TActorId EdgeActor;
+    TBlobStorageGroupType Type;
+    TGroupMock GroupMock;
+    TIntrusivePtr<TBlobStorageGroupInfo> Info;
+
+
+    TTestState(TTestActorRuntime &runtime, const TBlobStorageGroupType &type,
+            TIntrusivePtr<TBlobStorageGroupInfo> &info, ui64 nodeIndex = 0)
+        : Runtime(runtime)
+        , EdgeActor(runtime.AllocateEdgeActor(nodeIndex))
+        , Type(type)
+        , GroupMock(0, Type.GetErasure(), Type.BlobSubgroupSize(), 1, info)
+        , Info(info)
+    {
+    }
+
+    TTestState(TTestActorRuntime &runtime, const TBlobStorageGroupType &type, ui64 nodeIndex = 0)
+        : Runtime(runtime)
+        , EdgeActor(runtime.AllocateEdgeActor(nodeIndex))
+        , Type(type)
+        , GroupMock(0, Type.GetErasure(), Type.BlobSubgroupSize(), 1)
+        , Info(GroupMock.GetInfo())
+    {
+    }
+
+    TGroupMock& GetGroupMock() {
+        return GroupMock;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // HELPER FUNCTIONS
+    ////////////////////////////////////////////////////////////////////////////
+    TPartLocation PrimaryVDiskForBlobPart(TLogoBlobID blobId) {
+        Y_VERIFY(blobId.PartId());
+        TLogoBlobID origBlobId(blobId, 0);
+        TVDiskID vDiskId = Info->GetVDiskInSubgroup(blobId.PartId() - 1, origBlobId.Hash());
+        return {blobId, vDiskId};
+    }
+
+    TPartLocation HandoffVDiskForBlobPart(TLogoBlobID blobId, ui64 handoffIdx) {
+        Y_VERIFY(blobId.PartId());
+        Y_VERIFY(handoffIdx < Type.Handoff());
+        TLogoBlobID origBlobId(blobId, 0);
+        TVDiskID vDiskId = Info->GetVDiskInSubgroup(Type.TotalPartCount() + handoffIdx, origBlobId.Hash());
+        return {blobId, vDiskId};
+    }
+
+    THashMap<TVDiskID, ui32> MakePredictedDelaysForVDisks(TLogoBlobID blobId) {
+        TBlobStorageGroupInfo::TVDiskIds vDiskIds;
+        TBlobStorageGroupInfo::TServiceIds serviceIds;
+        THashMap<TVDiskID, ui32> result;
+        Info->PickSubgroup(blobId.Hash(), &vDiskIds, &serviceIds);
+        for (ui32 idx = 0; idx < vDiskIds.size(); ++idx) {
+            result.emplace(vDiskIds[idx], 0);
+        }
+        return result;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // PUT BLOBS TO GROUP MOCK
+    ////////////////////////////////////////////////////////////////////////////
+    TTestState& PutBlobsToGroupMock(const TBlobTestSet &blobSet) {
+        GroupMock.PutBlobSet(blobSet);
+        return *this;
+    }
+
+    template <typename TIter>
+    TTestState& PutBlobsToGroupMock(TIter begin, TIter end) {
+        TBlobTestSet blobSet;
+        blobSet.AddBlobs(begin, end);
+        return PutBlobsToGroupMock(blobSet);
+    }
+
+    TTestState& PutBlobsToGroupMock(const TVector<TBlobTestSet::TBlob> &blobs) {
+        return PutBlobsToGroupMock(blobs.begin(), blobs.end());
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // CREATE REQUESTS
+    ////////////////////////////////////////////////////////////////////////////
+    TEvBlobStorage::TEvPut::TPtr CreatePutRequest(const TBlobTestSet::TBlob &blob,
+            TEvBlobStorage::TEvPut::ETactic tactic, NKikimrBlobStorage::EPutHandleClass handleClass)
+    {
         std::unique_ptr<TEvBlobStorage::TEvPut> put = std::make_unique<TEvBlobStorage::TEvPut>(blob.Id, blob.Data, TInstant::Max(),
-                handleClass, tactic); 
-        return static_cast<TEventHandle<TEvBlobStorage::TEvPut>*>( 
+                handleClass, tactic);
+        return static_cast<TEventHandle<TEvBlobStorage::TEvPut>*>(
                 new IEventHandle(EdgeActor, EdgeActor, put.release()));
-    } 
- 
-    template <typename TIter, typename TPutIter> 
-    void CreatePutRequests(TIter begin, TIter end, TPutIter out, 
-            TEvBlobStorage::TEvPut::ETactic tactic, NKikimrBlobStorage::EPutHandleClass handleClass) 
-    { 
-        for (auto it = begin; it != end; ++it) { 
-            *out++ = CreatePutRequest(*it, tactic, handleClass); 
-        } 
-    } 
- 
-    template <typename TPutIter> 
-    void CreatePutRequests(const TVector<TBlobTestSet::TBlob> &blobs, TPutIter out, TEvBlobStorage::TEvPut::ETactic tactic, 
-            NKikimrBlobStorage::EPutHandleClass handleClass) 
-    { 
-        CreatePutRequests(blobs.begin(), blobs.end(), out, tactic, handleClass); 
-    } 
- 
-    TEvBlobStorage::TEvGet::TPtr CreateGetRequest(const TVector<TLogoBlobID> &blobs, bool mustRestore) 
-    { 
-        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queries(new TEvBlobStorage::TEvGet::TQuery[blobs.size()]); 
-        for (ui64 queryIdx = 0; queryIdx < blobs.size(); ++queryIdx) { 
-            TEvBlobStorage::TEvGet::TQuery &q = queries[queryIdx]; 
-            q.Id = blobs[queryIdx]; 
-            q.Shift = 0; 
-            q.Size = q.Id.BlobSize(); 
-        } 
+    }
+
+    template <typename TIter, typename TPutIter>
+    void CreatePutRequests(TIter begin, TIter end, TPutIter out,
+            TEvBlobStorage::TEvPut::ETactic tactic, NKikimrBlobStorage::EPutHandleClass handleClass)
+    {
+        for (auto it = begin; it != end; ++it) {
+            *out++ = CreatePutRequest(*it, tactic, handleClass);
+        }
+    }
+
+    template <typename TPutIter>
+    void CreatePutRequests(const TVector<TBlobTestSet::TBlob> &blobs, TPutIter out, TEvBlobStorage::TEvPut::ETactic tactic,
+            NKikimrBlobStorage::EPutHandleClass handleClass)
+    {
+        CreatePutRequests(blobs.begin(), blobs.end(), out, tactic, handleClass);
+    }
+
+    TEvBlobStorage::TEvGet::TPtr CreateGetRequest(const TVector<TLogoBlobID> &blobs, bool mustRestore)
+    {
+        TArrayHolder<TEvBlobStorage::TEvGet::TQuery> queries(new TEvBlobStorage::TEvGet::TQuery[blobs.size()]);
+        for (ui64 queryIdx = 0; queryIdx < blobs.size(); ++queryIdx) {
+            TEvBlobStorage::TEvGet::TQuery &q = queries[queryIdx];
+            q.Id = blobs[queryIdx];
+            q.Shift = 0;
+            q.Size = q.Id.BlobSize();
+        }
         std::unique_ptr<TEvBlobStorage::TEvGet> get = std::make_unique<TEvBlobStorage::TEvGet>(queries, blobs.size(), TInstant::Max(),
-                NKikimrBlobStorage::EGetHandleClass::FastRead, mustRestore, false); 
-        return static_cast<TEventHandle<TEvBlobStorage::TEvGet>*>( 
+                NKikimrBlobStorage::EGetHandleClass::FastRead, mustRestore, false);
+        return static_cast<TEventHandle<TEvBlobStorage::TEvGet>*>(
                 new IEventHandle(EdgeActor, EdgeActor, get.release()));
-    } 
- 
-    //////////////////////////////////////////////////////////////////////////// 
-    // CREATE EVENTS 
-    //////////////////////////////////////////////////////////////////////////// 
-    template <typename TEvent> 
-    typename TEvent::TPtr CreateEventPtr(TActorId recipient, TActorId sender, TEvent *ev, ui64 cookie) { 
-        TAutoPtr<IEventHandle> handle = new IEventHandle(recipient, sender, ev, 0, cookie); 
-        return static_cast<TEventHandle<TEvent>*>(handle.Release()); 
-    } 
- 
-    template <typename TEvent> 
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // CREATE EVENTS
+    ////////////////////////////////////////////////////////////////////////////
+    template <typename TEvent>
+    typename TEvent::TPtr CreateEventPtr(TActorId recipient, TActorId sender, TEvent *ev, ui64 cookie) {
+        TAutoPtr<IEventHandle> handle = new IEventHandle(recipient, sender, ev, 0, cookie);
+        return static_cast<TEventHandle<TEvent>*>(handle.Release());
+    }
+
+    template <typename TEvent>
     typename TEvent::TPtr CreateEventPtr(TActorId recipient, TActorId sender, std::unique_ptr<TEvent> &ev, ui64 cookie) {
         return CreateEventPtr(recipient, sender, ev.release(), cookie);
-    } 
- 
-    template <typename TEvent> 
-    typename TEvent::TPtr GrabEventPtr() { 
-        TAutoPtr<IEventHandle> handle; 
-        auto ev = Runtime.GrabEdgeEventRethrow<TEvent>(handle); 
-        UNIT_ASSERT(ev); 
-        return static_cast<TEventHandle<TEvent>*>(handle.Release()); 
-    } 
- 
-    template <typename TEventPtr, typename ...TArgs> 
-    auto CreateEventResultPtr(TEventPtr &ev, TArgs ...args) { 
-        auto result = CreateEventResult(ev->Get(), args...); 
-        auto handle = CreateEventPtr(ev->Sender, ev->Recipient, result, ev->Cookie); 
-        ui64 msgId = ev->Get()->Record.GetMsgQoS().GetMsgId().GetMsgId(); 
-        ui64 sequenceId = ev->Get()->Record.GetMsgQoS().GetMsgId().GetSequenceId(); 
-        handle->Get()->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(msgId); 
-        handle->Get()->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(sequenceId); 
-        return handle; 
-    } 
- 
+    }
+
+    template <typename TEvent>
+    typename TEvent::TPtr GrabEventPtr() {
+        TAutoPtr<IEventHandle> handle;
+        auto ev = Runtime.GrabEdgeEventRethrow<TEvent>(handle);
+        UNIT_ASSERT(ev);
+        return static_cast<TEventHandle<TEvent>*>(handle.Release());
+    }
+
+    template <typename TEventPtr, typename ...TArgs>
+    auto CreateEventResultPtr(TEventPtr &ev, TArgs ...args) {
+        auto result = CreateEventResult(ev->Get(), args...);
+        auto handle = CreateEventPtr(ev->Sender, ev->Recipient, result, ev->Cookie);
+        ui64 msgId = ev->Get()->Record.GetMsgQoS().GetMsgId().GetMsgId();
+        ui64 sequenceId = ev->Get()->Record.GetMsgQoS().GetMsgId().GetSequenceId();
+        handle->Get()->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(msgId);
+        handle->Get()->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(sequenceId);
+        return handle;
+    }
+
     std::unique_ptr<TEvBlobStorage::TEvVPutResult> CreateEventResult(TEvBlobStorage::TEvVPut *ev,
-            NKikimrProto::EReplyStatus status, TVDiskID vDiskId) 
-    { 
-        NKikimrBlobStorage::TEvVPut &record = ev->Record; 
-        TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID()); 
-        ui64 cookieValue = record.GetCookie(); 
-        ui64 *cookie = record.HasCookie() ? &cookieValue : nullptr; 
+            NKikimrProto::EReplyStatus status, TVDiskID vDiskId)
+    {
+        NKikimrBlobStorage::TEvVPut &record = ev->Record;
+        TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID());
+        ui64 cookieValue = record.GetCookie();
+        ui64 *cookie = record.HasCookie() ? &cookieValue : nullptr;
         std::unique_ptr<TEvBlobStorage::TEvVPutResult> result(new TEvBlobStorage::TEvVPutResult(status, blobId, vDiskId,
-                cookie, TOutOfSpaceStatus(0u, 0.0), TAppData::TimeProvider->Now(), 
-                0, nullptr, nullptr, nullptr, nullptr, 0, NWilson::TTraceId(), 0, TString())); 
-        return result; 
-    } 
- 
+                cookie, TOutOfSpaceStatus(0u, 0.0), TAppData::TimeProvider->Now(),
+                0, nullptr, nullptr, nullptr, nullptr, 0, NWilson::TTraceId(), 0, TString()));
+        return result;
+    }
+
     std::unique_ptr<TEvBlobStorage::TEvVMultiPutResult> CreateEventResult(TEvBlobStorage::TEvVMultiPut *ev,
-            NKikimrProto::EReplyStatus status, TVDiskID vDiskId) 
-    { 
-        NKikimrBlobStorage::TEvVMultiPut &record = ev->Record; 
-        ui64 cookieValue = record.GetCookie(); 
-        ui64 *cookie = record.HasCookie() ? &cookieValue : nullptr; 
+            NKikimrProto::EReplyStatus status, TVDiskID vDiskId)
+    {
+        NKikimrBlobStorage::TEvVMultiPut &record = ev->Record;
+        ui64 cookieValue = record.GetCookie();
+        ui64 *cookie = record.HasCookie() ? &cookieValue : nullptr;
         std::unique_ptr<TEvBlobStorage::TEvVMultiPutResult> result(
-                new TEvBlobStorage::TEvVMultiPutResult(status, vDiskId, cookie, TAppData::TimeProvider->Now(), 0, 
-                        nullptr, nullptr, nullptr, nullptr, 0, NWilson::TTraceId(), 0, TString())); 
-        result->Record.SetStatusFlags(TOutOfSpaceStatus(0u, 0.0).Flags); 
-        return result; 
-    } 
- 
-    template <typename TIter> 
+                new TEvBlobStorage::TEvVMultiPutResult(status, vDiskId, cookie, TAppData::TimeProvider->Now(), 0,
+                        nullptr, nullptr, nullptr, nullptr, 0, NWilson::TTraceId(), 0, TString()));
+        result->Record.SetStatusFlags(TOutOfSpaceStatus(0u, 0.0).Flags);
+        return result;
+    }
+
+    template <typename TIter>
     std::unique_ptr<TEvBlobStorage::TEvVMultiPutResult> CreateEventResult(TEvBlobStorage::TEvVMultiPut *ev,
-            NKikimrProto::EReplyStatus status, TIter begin, TIter end, TVDiskID vDiskId) 
-    { 
-        NKikimrBlobStorage::TEvVMultiPut &record = ev->Record; 
-        std::unique_ptr<TEvBlobStorage::TEvVMultiPutResult> result = CreateEventResult(ev, status, vDiskId); 
- 
-        ui64 itemCount = record.ItemsSize(); 
-        for (ui64 itemIdx = 0; itemIdx < itemCount; ++itemIdx) { 
-            UNIT_ASSERT(begin != end); 
-            auto &item = record.GetItems(itemIdx); 
-            UNIT_ASSERT(item.HasBlobID()); 
-            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-            ui64 cookieValue = item.GetCookie(); 
-            ui64 *cookie = item.HasCookie() ? &cookieValue : nullptr; 
-            result->AddVPutResult(*begin, TString(), blobId, cookie, TOutOfSpaceStatus(0u, 0.0).Flags); 
-            begin++; 
-        } 
-        UNIT_ASSERT(begin == end); 
-        return result; 
-    } 
- 
-    template <typename TCont> 
+            NKikimrProto::EReplyStatus status, TIter begin, TIter end, TVDiskID vDiskId)
+    {
+        NKikimrBlobStorage::TEvVMultiPut &record = ev->Record;
+        std::unique_ptr<TEvBlobStorage::TEvVMultiPutResult> result = CreateEventResult(ev, status, vDiskId);
+
+        ui64 itemCount = record.ItemsSize();
+        for (ui64 itemIdx = 0; itemIdx < itemCount; ++itemIdx) {
+            UNIT_ASSERT(begin != end);
+            auto &item = record.GetItems(itemIdx);
+            UNIT_ASSERT(item.HasBlobID());
+            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+            ui64 cookieValue = item.GetCookie();
+            ui64 *cookie = item.HasCookie() ? &cookieValue : nullptr;
+            result->AddVPutResult(*begin, TString(), blobId, cookie, TOutOfSpaceStatus(0u, 0.0).Flags);
+            begin++;
+        }
+        UNIT_ASSERT(begin == end);
+        return result;
+    }
+
+    template <typename TCont>
     std::unique_ptr<TEvBlobStorage::TEvVMultiPutResult> CreateEventResult(TEvBlobStorage::TEvVMultiPut *ev,
-            NKikimrProto::EReplyStatus status, const TCont &cont, TVDiskID vDiskId) 
-    { 
-        return CreateEventResult(ev, status, cont.cbegin(), cont.cend(), vDiskId); 
-    } 
- 
+            NKikimrProto::EReplyStatus status, const TCont &cont, TVDiskID vDiskId)
+    {
+        return CreateEventResult(ev, status, cont.cbegin(), cont.cend(), vDiskId);
+    }
+
     std::unique_ptr<TEvBlobStorage::TEvVGetResult> CreateEventResult(TEvBlobStorage::TEvVGet *ev,
-            NKikimrProto::EReplyStatus status = NKikimrProto::OK) 
-    { 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(ev->Record.GetVDiskID()); 
+            NKikimrProto::EReplyStatus status = NKikimrProto::OK)
+    {
+        TVDiskID vDiskId = VDiskIDFromVDiskID(ev->Record.GetVDiskID());
         std::unique_ptr<TEvBlobStorage::TEvVGetResult> result(new TEvBlobStorage::TEvVGetResult(
-                status, vDiskId, TAppData::TimeProvider->Now(), 0, nullptr, 
-                nullptr, nullptr, nullptr, NWilson::TTraceId(), {}, 0U, 0U)); 
-        return result; 
-    } 
- 
-    //////////////////////////////////////////////////////////////////////////// 
-    // HANDLE WITH MOCK 
-    //////////////////////////////////////////////////////////////////////////// 
-    void HandleVGetsWithMock(ui64 vGetCount) { 
-        for (ui64 idx = 0; idx < vGetCount; ++idx) { 
-            TEvBlobStorage::TEvVGet::TPtr ev = GrabEventPtr<TEvBlobStorage::TEvVGet>(); 
-            TEvBlobStorage::TEvVGetResult::TPtr result = CreateEventResultPtr(ev, NKikimrProto::UNKNOWN); 
-            GroupMock.OnVGet(*ev->Get(), *result->Get()); 
-            Runtime.Send(result.Release()); 
-        } 
-    } 
- 
-    void HandleVPutsWithMock(ui64 vPutCount) { 
-        for (ui64 idx = 0; idx < vPutCount; ++idx) { 
-            TEvBlobStorage::TEvVPut::TPtr ev = GrabEventPtr<TEvBlobStorage::TEvVPut>(); 
-            TVDiskID vDiskId = GroupMock.GetVDiskID(*ev->Get()); 
-            NKikimrProto::EReplyStatus status = GroupMock.OnVPut(*ev->Get()); 
-            TEvBlobStorage::TEvVPutResult::TPtr result = CreateEventResultPtr(ev, status, vDiskId); 
-            Runtime.Send(result.Release()); 
-        } 
-    } 
- 
-    void HandleVMultiPutsWithMock(ui64 vMultiPutCount) { 
-        for (ui64 idx = 0; idx < vMultiPutCount; ++idx) { 
-            TEvBlobStorage::TEvVMultiPut::TPtr ev = GrabEventPtr<TEvBlobStorage::TEvVMultiPut>(); 
-            TVDiskID vDiskId = GroupMock.GetVDiskID(*ev->Get()); 
-            TVector<NKikimrProto::EReplyStatus> statuses = GroupMock.OnVMultiPut(*ev->Get()); 
-            NKikimrProto::EReplyStatus status = NKikimrProto::OK; 
-            if (std::all_of(statuses.begin(), statuses.end(), [](auto st) { return st == NKikimrProto::RACE; })) { 
-                status = NKikimrProto::RACE; 
-            } 
-            TEvBlobStorage::TEvVMultiPutResult::TPtr result = CreateEventResultPtr(ev, status, statuses, vDiskId); 
-            Runtime.Send(result.Release()); 
-        } 
-    } 
- 
-    //////////////////////////////////////////////////////////////////////////// 
-    // RECEIVE RESPONSES 
-    //////////////////////////////////////////////////////////////////////////// 
-    void ReceivePutResults(ui64 count, const TMap<TLogoBlobID, NKikimrProto::EReplyStatus> &specialStatus) 
-    { 
-        TSet<TLogoBlobID> seenBlobs; 
-        for (ui64 idx = 0; idx < count; ++idx) { 
-            TAutoPtr<IEventHandle> handle; 
-            TEvBlobStorage::TEvPutResult *putResult = Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvPutResult>(handle); 
-            Y_VERIFY(!seenBlobs.count(putResult->Id)); 
-            seenBlobs.insert(putResult->Id); 
-            auto it = specialStatus.find(putResult->Id); 
-            Y_VERIFY(it != specialStatus.end()); 
-            NKikimrProto::EReplyStatus expectedStatus = it->second; 
-            Y_VERIFY_S(putResult->Status == expectedStatus, "expected status " 
-                    << NKikimrProto::EReplyStatus_Name(expectedStatus) 
-                    << ", but given " 
-                    << NKikimrProto::EReplyStatus_Name(putResult->Status)); 
-        } 
-    } 
-}; 
- 
+                status, vDiskId, TAppData::TimeProvider->Now(), 0, nullptr,
+                nullptr, nullptr, nullptr, NWilson::TTraceId(), {}, 0U, 0U));
+        return result;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // HANDLE WITH MOCK
+    ////////////////////////////////////////////////////////////////////////////
+    void HandleVGetsWithMock(ui64 vGetCount) {
+        for (ui64 idx = 0; idx < vGetCount; ++idx) {
+            TEvBlobStorage::TEvVGet::TPtr ev = GrabEventPtr<TEvBlobStorage::TEvVGet>();
+            TEvBlobStorage::TEvVGetResult::TPtr result = CreateEventResultPtr(ev, NKikimrProto::UNKNOWN);
+            GroupMock.OnVGet(*ev->Get(), *result->Get());
+            Runtime.Send(result.Release());
+        }
+    }
+
+    void HandleVPutsWithMock(ui64 vPutCount) {
+        for (ui64 idx = 0; idx < vPutCount; ++idx) {
+            TEvBlobStorage::TEvVPut::TPtr ev = GrabEventPtr<TEvBlobStorage::TEvVPut>();
+            TVDiskID vDiskId = GroupMock.GetVDiskID(*ev->Get());
+            NKikimrProto::EReplyStatus status = GroupMock.OnVPut(*ev->Get());
+            TEvBlobStorage::TEvVPutResult::TPtr result = CreateEventResultPtr(ev, status, vDiskId);
+            Runtime.Send(result.Release());
+        }
+    }
+
+    void HandleVMultiPutsWithMock(ui64 vMultiPutCount) {
+        for (ui64 idx = 0; idx < vMultiPutCount; ++idx) {
+            TEvBlobStorage::TEvVMultiPut::TPtr ev = GrabEventPtr<TEvBlobStorage::TEvVMultiPut>();
+            TVDiskID vDiskId = GroupMock.GetVDiskID(*ev->Get());
+            TVector<NKikimrProto::EReplyStatus> statuses = GroupMock.OnVMultiPut(*ev->Get());
+            NKikimrProto::EReplyStatus status = NKikimrProto::OK;
+            if (std::all_of(statuses.begin(), statuses.end(), [](auto st) { return st == NKikimrProto::RACE; })) {
+                status = NKikimrProto::RACE;
+            }
+            TEvBlobStorage::TEvVMultiPutResult::TPtr result = CreateEventResultPtr(ev, status, statuses, vDiskId);
+            Runtime.Send(result.Release());
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // RECEIVE RESPONSES
+    ////////////////////////////////////////////////////////////////////////////
+    void ReceivePutResults(ui64 count, const TMap<TLogoBlobID, NKikimrProto::EReplyStatus> &specialStatus)
+    {
+        TSet<TLogoBlobID> seenBlobs;
+        for (ui64 idx = 0; idx < count; ++idx) {
+            TAutoPtr<IEventHandle> handle;
+            TEvBlobStorage::TEvPutResult *putResult = Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvPutResult>(handle);
+            Y_VERIFY(!seenBlobs.count(putResult->Id));
+            seenBlobs.insert(putResult->Id);
+            auto it = specialStatus.find(putResult->Id);
+            Y_VERIFY(it != specialStatus.end());
+            NKikimrProto::EReplyStatus expectedStatus = it->second;
+            Y_VERIFY_S(putResult->Status == expectedStatus, "expected status "
+                    << NKikimrProto::EReplyStatus_Name(expectedStatus)
+                    << ", but given "
+                    << NKikimrProto::EReplyStatus_Name(putResult->Status));
+        }
+    }
+};
+
 } // namespace NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_vdisk_mock_ut.h b/ydb/core/blobstorage/dsproxy/ut/dsproxy_vdisk_mock_ut.h
index 3ddcb3c88e..0a17c046e7 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_vdisk_mock_ut.h
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_vdisk_mock_ut.h
@@ -1,542 +1,542 @@
-#pragma once 
- 
-#include "defs.h" 
- 
+#pragma once
+
+#include "defs.h"
+
 #include <ydb/core/blobstorage/dsproxy/dsproxy.h>
- 
+
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h>
 #include <ydb/core/blobstorage/vdisk/common/vdisk_events.h>
- 
+
 #include <ydb/core/testlib/basics/runtime.h>
 #include <ydb/core/testlib/actor_helpers.h>
- 
+
 #include <library/cpp/testing/unittest/registar.h>
- 
-namespace NKikimr { 
- 
-class TVDiskMock { 
-    TIntrusivePtr<TBlobStorageGroupInfo> Info; 
-    const TVDiskID VDiskId; 
-    TMap<TLogoBlobID, TString> Blobs; 
-    TMap<TLogoBlobID, TString> NotYetBlobs; 
-    bool IsError; 
-    NKikimrProto::EReplyStatus Status; 
-    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> SpecialStatuses; 
-public: 
-    TIntrusivePtr<NBackpressure::TFlowRecord> FlowRecord; 
- 
-    TVDiskMock(TVDiskID vDiskId) 
-        : VDiskId(vDiskId) 
-        , IsError(false) 
-        , Status(NKikimrProto::OK) 
-        , FlowRecord(new NBackpressure::TFlowRecord()) 
-    { 
-    } 
- 
-    void SetInfo(TIntrusivePtr<TBlobStorageGroupInfo> info) { 
-        Info = info; 
-    } 
- 
+
+namespace NKikimr {
+
+class TVDiskMock {
+    TIntrusivePtr<TBlobStorageGroupInfo> Info;
+    const TVDiskID VDiskId;
+    TMap<TLogoBlobID, TString> Blobs;
+    TMap<TLogoBlobID, TString> NotYetBlobs;
+    bool IsError;
+    NKikimrProto::EReplyStatus Status;
+    TMap<TLogoBlobID, NKikimrProto::EReplyStatus> SpecialStatuses;
+public:
+    TIntrusivePtr<NBackpressure::TFlowRecord> FlowRecord;
+
+    TVDiskMock(TVDiskID vDiskId)
+        : VDiskId(vDiskId)
+        , IsError(false)
+        , Status(NKikimrProto::OK)
+        , FlowRecord(new NBackpressure::TFlowRecord())
+    {
+    }
+
+    void SetInfo(TIntrusivePtr<TBlobStorageGroupInfo> info) {
+        Info = info;
+    }
+
     TActorId GetActorId() {
-        return Info->GetActorId(Info->GetOrderNumber(VDiskId)); 
-    } 
- 
-    TVDiskID GetVDiskId() const { 
-        return VDiskId; 
-    } 
- 
-    NKikimrProto::EReplyStatus Put(const TLogoBlobID id, const TString &data) { 
-        if (IsError) { 
-            return Status; 
-        } 
-        auto it = SpecialStatuses.find(id); 
-        if (it != SpecialStatuses.end()) { 
-            return it->second; 
-        } 
-        if (Blobs.count(id)) { 
-            return NKikimrProto::ALREADY; 
-        } 
-        Blobs[id] = data; 
-        return NKikimrProto::OK; 
-    } 
- 
-    void Wipe() { 
-        Blobs.clear(); 
-        FlowRecord->SetPredictedDelayNs(0); 
-    } 
- 
-    void SetError(NKikimrProto::EReplyStatus status) { 
-        if (status == NKikimrProto::NOT_YET) { 
-            for (auto it = Blobs.begin(); it != Blobs.end(); ++it) { 
-                NotYetBlobs[it->first] = it->second; 
-            } 
-        } else { 
-            IsError = true; 
-            Status = status; 
-        } 
-    } 
- 
-    void SetNotYet(const TLogoBlobID blobID) { 
-        auto it = Blobs.find(blobID); 
-        if (it != Blobs.end()) { 
-            NotYetBlobs[blobID] = it->second; 
-        } 
-    } 
- 
-    void SetPredictedDelayNs(ui64 predictDelaysNs) { 
-        FlowRecord->SetPredictedDelayNs(predictDelaysNs); 
-    } 
- 
-    void UnsetError() { 
-        NotYetBlobs.clear(); 
-        IsError = false; 
-        Status = NKikimrProto::OK; 
-    } 
- 
-    void SetSpecialStatus(const TLogoBlobID blobID, NKikimrProto::EReplyStatus status) { 
-        SpecialStatuses[blobID] = status; 
-    } 
- 
-    void OnVGet(const TEvBlobStorage::TEvVGet &vGet, TEvBlobStorage::TEvVGetResult &outVGetResult) { 
-        auto &request = vGet.Record; 
-        Y_VERIFY(request.HasCookie()); 
-        if (IsError) { 
+        return Info->GetActorId(Info->GetOrderNumber(VDiskId));
+    }
+
+    TVDiskID GetVDiskId() const {
+        return VDiskId;
+    }
+
+    NKikimrProto::EReplyStatus Put(const TLogoBlobID id, const TString &data) {
+        if (IsError) {
+            return Status;
+        }
+        auto it = SpecialStatuses.find(id);
+        if (it != SpecialStatuses.end()) {
+            return it->second;
+        }
+        if (Blobs.count(id)) {
+            return NKikimrProto::ALREADY;
+        }
+        Blobs[id] = data;
+        return NKikimrProto::OK;
+    }
+
+    void Wipe() {
+        Blobs.clear();
+        FlowRecord->SetPredictedDelayNs(0);
+    }
+
+    void SetError(NKikimrProto::EReplyStatus status) {
+        if (status == NKikimrProto::NOT_YET) {
+            for (auto it = Blobs.begin(); it != Blobs.end(); ++it) {
+                NotYetBlobs[it->first] = it->second;
+            }
+        } else {
+            IsError = true;
+            Status = status;
+        }
+    }
+
+    void SetNotYet(const TLogoBlobID blobID) {
+        auto it = Blobs.find(blobID);
+        if (it != Blobs.end()) {
+            NotYetBlobs[blobID] = it->second;
+        }
+    }
+
+    void SetPredictedDelayNs(ui64 predictDelaysNs) {
+        FlowRecord->SetPredictedDelayNs(predictDelaysNs);
+    }
+
+    void UnsetError() {
+        NotYetBlobs.clear();
+        IsError = false;
+        Status = NKikimrProto::OK;
+    }
+
+    void SetSpecialStatus(const TLogoBlobID blobID, NKikimrProto::EReplyStatus status) {
+        SpecialStatuses[blobID] = status;
+    }
+
+    void OnVGet(const TEvBlobStorage::TEvVGet &vGet, TEvBlobStorage::TEvVGetResult &outVGetResult) {
+        auto &request = vGet.Record;
+        Y_VERIFY(request.HasCookie());
+        if (IsError) {
             outVGetResult.MakeError(Status, TString(), request);
-            return; 
-        } 
-        //ui64 messageCookie = request->Record.GetCookie(); 
- 
-        outVGetResult.Record.SetStatus(NKikimrProto::OK); 
-        // Ignore RangeQuery (pretend there are no results) 
- 
-        // TODO: Check for overlapping / out of order queries 
-        size_t size = request.ExtremeQueriesSize(); 
-        for (unsigned i = 0; i < size; i++) { 
-            const NKikimrBlobStorage::TExtremeQuery &query = request.GetExtremeQueries(i); 
-            Y_VERIFY(request.HasVDiskID()); 
-            TLogoBlobID id = LogoBlobIDFromLogoBlobID(query.GetId()); 
-            ui64 partId = id.PartId(); 
-            ui64 partBegin = partId ? partId : 1; 
-            ui64 partEnd = partId ? partId : 7; 
- 
-            ui64 shift = (query.HasShift() ? query.GetShift() : 0); 
-            ui64 *cookie = nullptr; 
-            ui64 cookieValue = 0; 
-            if (query.HasCookie()) { 
-                cookieValue = query.GetCookie(); 
-                cookie = &cookieValue; 
-            } 
- 
-            ui64 partSize = Info->Type.PartSize(id); 
- 
-            ui64 rShift = (shift > partSize ? partSize : shift); 
-            ui64 resultSize = query.HasSize() ? query.GetSize() : 0; 
-            if (!resultSize) { 
-                resultSize = partSize; 
-            } 
-            resultSize = Min(partSize - rShift, resultSize); 
- 
-            bool isNoData = true; 
-            TLogoBlobID idFirst(id, partBegin); 
-            TLogoBlobID idLast(id, partEnd); 
-            for (auto it = Blobs.lower_bound(idFirst); it != Blobs.end() && it->first <= idLast; it++) { 
-                isNoData = false; 
-                if (NotYetBlobs.find(it->first) != NotYetBlobs.end()) { 
-                    outVGetResult.AddResult(NKikimrProto::NOT_YET, it->first, shift, 
-                            nullptr, 0, cookie); 
-                } else { 
-                    TString resultData; 
-                    resultData.resize(resultSize); 
-                    memcpy((void*)resultData.data(), ((char*)(void*)it->second.data()) + rShift, resultSize); 
-                    outVGetResult.AddResult(NKikimrProto::OK, it->first, shift, 
-                            resultData.data(), resultSize, cookie); 
-                } 
-            } 
-            if (isNoData) { 
-                CTEST << "VDisk# " << VDiskId.ToString() << " blob# " << id.ToString() << " NODATA" << Endl; 
-                outVGetResult.AddResult(NKikimrProto::NODATA, id, shift, nullptr, 0, cookie); 
-            } 
-        } 
-        Y_VERIFY(request.HasVDiskID()); 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(request.GetVDiskID()); 
-        VDiskIDFromVDiskID(vDiskId, outVGetResult.Record.MutableVDiskID()); 
-        if (request.HasCookie()) { 
-            outVGetResult.Record.SetCookie(request.GetCookie()); 
-        } 
-    } 
-}; 
- 
-class TBlobTestSet { 
-public: 
-    struct TBlob { 
-        TLogoBlobID Id; 
-        TString Data; 
- 
-        TBlob(TLogoBlobID id, TString data) 
-            : Id(id) 
-            , Data(data) 
-        {} 
-    }; 
- 
-private: 
-    TVector<TBlob> Blobs; 
-    TMap<TLogoBlobID, TString> DataById; 
- 
-    TString AlphaData(ui32 size) { 
-        TString data = TString::Uninitialized(size); 
-        ui8 *p = (ui8*)(void*)data.Detach(); 
-        for (ui32 offset = 0; offset < size; ++offset) { 
-            p[offset] = (ui8)offset; 
-        } 
-        return data; 
-    } 
-public: 
-    TBlobTestSet() 
-    {} 
- 
-    template <typename TIter> 
-    void AddBlobs(TIter begin, TIter end) { 
-        for (auto it = begin; it != end; ++it) { 
-            Blobs.emplace_back(*it); 
-            DataById[it->Id] = it->Data; 
-        } 
-    } 
- 
-    template <typename TCont> 
-    void AddBlobs(const TCont& blobs) { 
-        AddBlobs(blobs.begin(), blobs.end()); 
-    } 
- 
-    void GenerateSet(ui32 setIdx, ui32 count, ui32 forceSize = 0) { 
-        switch (setIdx) { 
-            case 0: 
-                for (ui64 i = 0; i < count; ++i) { 
-                    ui32 step = i + 1; 
-                    ui32 size = forceSize ? forceSize : 750 + i * 31; 
-                    TLogoBlobID id(1, 2, step, 0, size, 0); 
-                    TString data = AlphaData(size); 
-                    Blobs.emplace_back(id, data); 
-                    DataById[id] = data; 
-                } 
-                break; 
-            case 1: 
-                for (ui64 i = 0; i < count; ++i) { 
-                    ui32 step = i + 1; 
-                    ui32 size = forceSize ? forceSize : 92 + i * 31; 
-                    TLogoBlobID id(1, 2, step, 0, size, 0); 
-                    TString data = AlphaData(size); 
-                    Blobs.emplace_back(id, data); 
-                    DataById[id] = data; 
-                } 
-                break; 
-            case 2: 
-                for (ui64 i = 0; i < count; ++i) { 
-                    ui32 step = i + 1; 
-                    ui32 size = forceSize ? forceSize : 92 + i * 31; 
-                    TLogoBlobID id(1, 2, step, 0, size, 0, 0, TErasureType::CrcModeWholePart); 
-                    TString data = AlphaData(size); 
-                    Blobs.emplace_back(id, data); 
-                    DataById[id] = data; 
-                } 
-                break; 
-            default: 
-                Y_VERIFY(false, "Unexpected setIdx# %" PRIu32, setIdx); 
-                break; 
-        } 
-    } 
- 
-    ui64 Size() const { 
-        return Blobs.size(); 
-    } 
- 
-    const TBlob& Get(ui32 idx) const { 
-        Y_VERIFY(idx < Blobs.size()); 
-        return Blobs[idx]; 
-    } 
- 
-    TString Get(TLogoBlobID id, ui32 shift, ui32 size) const { 
-        auto it = DataById.find(id); 
-        Y_VERIFY(it != DataById.end()); 
-        TString data = it->second; 
-        shift = Min(shift, id.BlobSize()); 
-        ui32 rSize = size ? size : id.BlobSize(); 
-        rSize = Min(rSize, id.BlobSize() - shift); 
-        TString result; 
-        result.resize(rSize); 
-        memcpy((void*)result.data(), (char*)(void*)data.data() + shift, rSize); 
-        return result; 
-    } 
- 
-    void Check(ui32 idx, TLogoBlobID id, ui32 shift, ui32 size, TString buffer) const { 
-        const TBlob& blob = Get(idx); 
-        Y_VERIFY(id == blob.Id); 
-        if (size != buffer.size()) { 
-            UNIT_ASSERT_VALUES_EQUAL(size, buffer.size()); 
-        } 
-        const ui8 *a = (const ui8*)(void*)blob.Data.data(); 
-        const ui8 *b = (const ui8*)(void*)buffer.data(); 
-        if (memcmp(a + shift, b, size) != 0) { 
-            for (ui32 offset = 0; offset < size; ++offset) { 
-                UNIT_ASSERT_VALUES_EQUAL_C((ui32)a[shift + offset], (ui32)b[offset], 
-                        "Id# " << id.ToString() << " offset# " << offset 
-                        << " shift# " << shift << " s+o# " << (shift + offset) << " size# " << size 
-                        << " canonic a# " << (ui32)a[shift+offset] << " actual b# " << (ui32)b[offset]); 
-            } 
-        } 
-    } 
-}; 
- 
-struct TPartLocation { 
-    TLogoBlobID BlobId; 
-    TVDiskID VDiskId; 
- 
-    static TString ToString(const TPartLocation &self) { 
-        return TStringBuilder() 
-            << "{BlobId# " << self.BlobId.ToString() 
-            << " VDiskId# " << self.VDiskId.ToString() 
-            << "}"; 
-    } 
- 
-    TString ToString() const { 
-        return ToString(*this); 
-    } 
- 
-    bool operator<(const TPartLocation &other) const { 
-        return std::tie(BlobId, VDiskId) < std::tie(other.BlobId, other.VDiskId); 
-    } 
-}; 
- 
-class TGroupMock { 
-    const ui32 GroupId; 
-    const TErasureType::EErasureSpecies ErasureSpecies; 
-    const ui32 FailDomains; 
-    const ui32 DrivesPerFailDomain; 
- 
-    TVector<TVDiskMock> VDisks; 
-    TIntrusivePtr<TBlobStorageGroupInfo> Info; 
- 
-    TVDiskMock& GetVDisk(ui32 failDomainIdx, ui32 driveIdx) { 
-        ui32 i = failDomainIdx * DrivesPerFailDomain + driveIdx; 
-        Y_VERIFY(i < VDisks.size(), "i# %" PRIu32 " size# %" PRIu32, (ui32)i, (ui32)VDisks.size()); 
-        return VDisks[i]; 
-    } 
- 
-    void InitBsInfo() { 
-        for (auto& mock : VDisks) { 
-            mock.SetInfo(Info); 
-        } 
-    } 
- 
-    void InitVDisks() { 
-        for (ui64 domainIdx = 0; domainIdx < FailDomains; ++domainIdx) { 
-            for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) { 
-                // Node = domainIdx 
-                // PoolId = driveIdx 
-                // LocalId = index in VDisks 
-                TVDiskID vDiskId(GroupId, 1, 0, domainIdx, driveIdx); 
-                VDisks.emplace_back(vDiskId); 
-            } 
-        } 
-    } 
- 
-public: 
-    TGroupMock(ui32 groupId, TErasureType::EErasureSpecies erasureSpecies, ui32 failDomains, ui32 drivesPerFailDomain, 
-            TIntrusivePtr<TBlobStorageGroupInfo> info) 
-        : GroupId(groupId) 
-        , ErasureSpecies(erasureSpecies) 
-        , FailDomains(failDomains) 
-        , DrivesPerFailDomain(drivesPerFailDomain) 
-        , Info(info) 
-    { 
-        Y_UNUSED(ErasureSpecies); 
-        InitVDisks(); 
-        InitBsInfo(); 
-    } 
- 
-    TGroupMock(ui32 groupId, TErasureType::EErasureSpecies erasureSpecies, ui32 failDomains, ui32 drivesPerFailDomain) 
-        : TGroupMock(groupId, erasureSpecies, failDomains, drivesPerFailDomain, 
-                new TBlobStorageGroupInfo(erasureSpecies, drivesPerFailDomain, failDomains)) 
-    { 
-    } 
- 
-    ui32 VDiskIdx(const TVDiskID &id) { 
-        ui32 idx = (ui32)id.FailDomain * DrivesPerFailDomain + (ui32)id.VDisk; 
-        return idx; 
-    } 
- 
-    TIntrusivePtr<TBlobStorageGroupInfo> GetInfo() { 
-        return Info; 
-    } 
- 
-    void OnVGet(const TEvBlobStorage::TEvVGet &vGet, TEvBlobStorage::TEvVGetResult &outVGetResult) { 
-        Y_VERIFY(vGet.Record.HasVDiskID()); 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(vGet.Record.GetVDiskID()); 
-        GetVDisk(vDiskId.FailDomain, vDiskId.VDisk).OnVGet(vGet, outVGetResult); 
-    } 
- 
-    NKikimrProto::EReplyStatus OnVPut(TEvBlobStorage::TEvVPut &vPut) { 
-        const NKikimrBlobStorage::TEvVPut &record = vPut.Record; 
-        Y_VERIFY(record.HasVDiskID()); 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
-        ui32 idx = VDiskIdx(vDiskId); 
-        TVDiskMock &disk = VDisks[idx]; 
-        if (disk.GetVDiskId() != vDiskId) { 
-            return NKikimrProto::RACE; 
-        } 
-        const TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID()); 
-        TString buffer = vPut.GetBuffer().ConvertToString(); 
-        NKikimrProto::EReplyStatus status = disk.Put(blobId, buffer); 
-        return status; 
-    } 
- 
-    template <typename TEvent> 
-    TVDiskID GetVDiskID(TEvent &vPut) { 
-        const auto &record = vPut.Record; 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
-        ui32 idx = VDiskIdx(vDiskId); 
-        TVDiskMock &disk = VDisks[idx]; 
-        return disk.GetVDiskId(); 
-    } 
- 
-    TVector<NKikimrProto::EReplyStatus> OnVMultiPut(TEvBlobStorage::TEvVMultiPut &vMultiPut) { 
-        const NKikimrBlobStorage::TEvVMultiPut &record = vMultiPut.Record; 
-        Y_VERIFY(record.HasVDiskID()); 
-        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
-        ui32 idx = VDiskIdx(vDiskId); 
-        TVDiskMock &disk = VDisks[idx]; 
-        if (disk.GetVDiskId() != vDiskId) { 
-            return TVector<NKikimrProto::EReplyStatus>(record.ItemsSize(), NKikimrProto::RACE); 
-        } 
-        Y_VERIFY(disk.GetVDiskId() == vDiskId); 
-        TVector<NKikimrProto::EReplyStatus> statuses; 
-        for (ui64 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) { 
-            auto &item = record.GetItems(itemIdx); 
-            const TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-            TString buffer = vMultiPut.GetItemBuffer(itemIdx).ConvertToString(); 
-            statuses.push_back(disk.Put(blobId, buffer)); 
-        } 
-        return statuses; 
-    } 
- 
-    void Wipe(ui32 domainIdx) { 
-        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) { 
-            GetVDisk(domainIdx, driveIdx).Wipe(); 
-        } 
-    } 
- 
-    void Wipe() { 
-        for (ui32 idx = 0; idx < VDisks.size(); ++idx) { 
-            VDisks[idx].Wipe(); 
-        } 
-    } 
- 
-    void SetError(ui32 domainIdx, NKikimrProto::EReplyStatus status) { 
-        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) { 
-            GetVDisk(domainIdx, driveIdx).SetError(status); 
-        } 
-    } 
- 
-    void SetPredictedDelayNs(ui32 domainIdx, ui64 predictedDelayNs) { 
-        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) { 
-            GetVDisk(domainIdx, driveIdx).SetPredictedDelayNs(predictedDelayNs); 
-        } 
-    } 
- 
-    void UnsetError(ui32 domainIdx) { 
-        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) { 
-            GetVDisk(domainIdx, driveIdx).UnsetError(); 
-        } 
-    } 
- 
-    void SetSpecialStatus(ui32 domainIdx, TLogoBlobID blobID, NKikimrProto::EReplyStatus status) { 
-        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) { 
-            GetVDisk(domainIdx, driveIdx).SetSpecialStatus(blobID, status); 
-        } 
-    } 
- 
-    void SetSpecialStatuses(const TMap<TPartLocation, NKikimrProto::EReplyStatus> &statuses) { 
-        for (auto &[partLocation, status] : statuses) { 
-            ui64 vDiskIdx = VDiskIdx(partLocation.VDiskId); 
-            VDisks[vDiskIdx].SetSpecialStatus(partLocation.BlobId, status); 
-        } 
-    } 
- 
-    void SetNotYetBlob(ui32 domainIdx, const TLogoBlobID blobID) { 
-        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) { 
-            GetVDisk(domainIdx, driveIdx).SetNotYet(blobID); 
-        } 
-    } 
- 
-    void Put(const TLogoBlobID id, const TString &data, ui32 handoffsToUse = 0) { 
-        const ui32 hash = id.Hash(); 
-        const ui32 totalvd = Info->Type.BlobSubgroupSize(); 
-        const ui32 totalParts = Info->Type.TotalPartCount(); 
-        Y_VERIFY(id.BlobSize() == data.size()); 
-        Y_VERIFY(totalvd >= totalParts); 
-        TBlobStorageGroupInfo::TServiceIds vDisksSvc; 
-        TBlobStorageGroupInfo::TVDiskIds vDisksId; 
-        Info->PickSubgroup(hash, &vDisksId, &vDisksSvc); 
- 
-        TString encryptedData = data; 
-        char *dataBytes = encryptedData.Detach(); 
-        Encrypt(dataBytes, dataBytes, 0, encryptedData.size(), id, *Info); 
- 
-        TDataPartSet partSet; 
-        partSet.Parts.resize(totalParts); 
-        Info->Type.SplitData((TErasureType::ECrcMode)id.CrcMode(), encryptedData, partSet); 
-        for (ui32 i = 0; i < totalParts; ++i) { 
-            TLogoBlobID pId(id, i + 1); 
-            TString pData = partSet.Parts[i].OwnedString; 
-            if (i < handoffsToUse) { 
-                Y_VERIFY(totalParts + i < totalvd); 
-                GetVDisk(vDisksId[totalParts + i].FailDomain, vDisksId[totalParts + i].VDisk).Put(pId, pData); 
-            } else { 
-                GetVDisk(vDisksId[i].FailDomain, vDisksId[i].VDisk).Put(pId, pData); 
-            } 
-        } 
-    } 
- 
-    i32 DomainIdxForBlobSubgroupIdx(const TLogoBlobID id, i32 subgroupIdx) { 
-        const ui32 hash = id.Hash(); 
-        const ui32 totalvd = Info->Type.BlobSubgroupSize(); 
-        const ui32 totalParts = Info->Type.TotalPartCount(); 
-        Y_VERIFY(totalvd >= totalParts); 
-        TBlobStorageGroupInfo::TServiceIds vDisksSvc; 
-        TBlobStorageGroupInfo::TVDiskIds vDisksId; 
-        Info->PickSubgroup(hash, &vDisksId, &vDisksSvc); 
- 
-        return vDisksId[subgroupIdx].FailDomain; 
-    } 
- 
-    void PutBlobSet(const TBlobTestSet &blobSet, ui32 handoffsToUse = 0) { 
-        for (ui64 i = 0; i < blobSet.Size(); ++i) { 
-            const auto &blob = blobSet.Get(i); 
-            Put(blob.Id, blob.Data, handoffsToUse); 
-        } 
-    } 
- 
+            return;
+        }
+        //ui64 messageCookie = request->Record.GetCookie();
+
+        outVGetResult.Record.SetStatus(NKikimrProto::OK);
+        // Ignore RangeQuery (pretend there are no results)
+
+        // TODO: Check for overlapping / out of order queries
+        size_t size = request.ExtremeQueriesSize();
+        for (unsigned i = 0; i < size; i++) {
+            const NKikimrBlobStorage::TExtremeQuery &query = request.GetExtremeQueries(i);
+            Y_VERIFY(request.HasVDiskID());
+            TLogoBlobID id = LogoBlobIDFromLogoBlobID(query.GetId());
+            ui64 partId = id.PartId();
+            ui64 partBegin = partId ? partId : 1;
+            ui64 partEnd = partId ? partId : 7;
+
+            ui64 shift = (query.HasShift() ? query.GetShift() : 0);
+            ui64 *cookie = nullptr;
+            ui64 cookieValue = 0;
+            if (query.HasCookie()) {
+                cookieValue = query.GetCookie();
+                cookie = &cookieValue;
+            }
+
+            ui64 partSize = Info->Type.PartSize(id);
+
+            ui64 rShift = (shift > partSize ? partSize : shift);
+            ui64 resultSize = query.HasSize() ? query.GetSize() : 0;
+            if (!resultSize) {
+                resultSize = partSize;
+            }
+            resultSize = Min(partSize - rShift, resultSize);
+
+            bool isNoData = true;
+            TLogoBlobID idFirst(id, partBegin);
+            TLogoBlobID idLast(id, partEnd);
+            for (auto it = Blobs.lower_bound(idFirst); it != Blobs.end() && it->first <= idLast; it++) {
+                isNoData = false;
+                if (NotYetBlobs.find(it->first) != NotYetBlobs.end()) {
+                    outVGetResult.AddResult(NKikimrProto::NOT_YET, it->first, shift,
+                            nullptr, 0, cookie);
+                } else {
+                    TString resultData;
+                    resultData.resize(resultSize);
+                    memcpy((void*)resultData.data(), ((char*)(void*)it->second.data()) + rShift, resultSize);
+                    outVGetResult.AddResult(NKikimrProto::OK, it->first, shift,
+                            resultData.data(), resultSize, cookie);
+                }
+            }
+            if (isNoData) {
+                CTEST << "VDisk# " << VDiskId.ToString() << " blob# " << id.ToString() << " NODATA" << Endl;
+                outVGetResult.AddResult(NKikimrProto::NODATA, id, shift, nullptr, 0, cookie);
+            }
+        }
+        Y_VERIFY(request.HasVDiskID());
+        TVDiskID vDiskId = VDiskIDFromVDiskID(request.GetVDiskID());
+        VDiskIDFromVDiskID(vDiskId, outVGetResult.Record.MutableVDiskID());
+        if (request.HasCookie()) {
+            outVGetResult.Record.SetCookie(request.GetCookie());
+        }
+    }
+};
+
+class TBlobTestSet {
+public:
+    struct TBlob {
+        TLogoBlobID Id;
+        TString Data;
+
+        TBlob(TLogoBlobID id, TString data)
+            : Id(id)
+            , Data(data)
+        {}
+    };
+
+private:
+    TVector<TBlob> Blobs;
+    TMap<TLogoBlobID, TString> DataById;
+
+    TString AlphaData(ui32 size) {
+        TString data = TString::Uninitialized(size);
+        ui8 *p = (ui8*)(void*)data.Detach();
+        for (ui32 offset = 0; offset < size; ++offset) {
+            p[offset] = (ui8)offset;
+        }
+        return data;
+    }
+public:
+    TBlobTestSet()
+    {}
+
+    template <typename TIter>
+    void AddBlobs(TIter begin, TIter end) {
+        for (auto it = begin; it != end; ++it) {
+            Blobs.emplace_back(*it);
+            DataById[it->Id] = it->Data;
+        }
+    }
+
+    template <typename TCont>
+    void AddBlobs(const TCont& blobs) {
+        AddBlobs(blobs.begin(), blobs.end());
+    }
+
+    void GenerateSet(ui32 setIdx, ui32 count, ui32 forceSize = 0) {
+        switch (setIdx) {
+            case 0:
+                for (ui64 i = 0; i < count; ++i) {
+                    ui32 step = i + 1;
+                    ui32 size = forceSize ? forceSize : 750 + i * 31;
+                    TLogoBlobID id(1, 2, step, 0, size, 0);
+                    TString data = AlphaData(size);
+                    Blobs.emplace_back(id, data);
+                    DataById[id] = data;
+                }
+                break;
+            case 1:
+                for (ui64 i = 0; i < count; ++i) {
+                    ui32 step = i + 1;
+                    ui32 size = forceSize ? forceSize : 92 + i * 31;
+                    TLogoBlobID id(1, 2, step, 0, size, 0);
+                    TString data = AlphaData(size);
+                    Blobs.emplace_back(id, data);
+                    DataById[id] = data;
+                }
+                break;
+            case 2:
+                for (ui64 i = 0; i < count; ++i) {
+                    ui32 step = i + 1;
+                    ui32 size = forceSize ? forceSize : 92 + i * 31;
+                    TLogoBlobID id(1, 2, step, 0, size, 0, 0, TErasureType::CrcModeWholePart);
+                    TString data = AlphaData(size);
+                    Blobs.emplace_back(id, data);
+                    DataById[id] = data;
+                }
+                break;
+            default:
+                Y_VERIFY(false, "Unexpected setIdx# %" PRIu32, setIdx);
+                break;
+        }
+    }
+
+    ui64 Size() const {
+        return Blobs.size();
+    }
+
+    const TBlob& Get(ui32 idx) const {
+        Y_VERIFY(idx < Blobs.size());
+        return Blobs[idx];
+    }
+
+    TString Get(TLogoBlobID id, ui32 shift, ui32 size) const {
+        auto it = DataById.find(id);
+        Y_VERIFY(it != DataById.end());
+        TString data = it->second;
+        shift = Min(shift, id.BlobSize());
+        ui32 rSize = size ? size : id.BlobSize();
+        rSize = Min(rSize, id.BlobSize() - shift);
+        TString result;
+        result.resize(rSize);
+        memcpy((void*)result.data(), (char*)(void*)data.data() + shift, rSize);
+        return result;
+    }
+
+    void Check(ui32 idx, TLogoBlobID id, ui32 shift, ui32 size, TString buffer) const {
+        const TBlob& blob = Get(idx);
+        Y_VERIFY(id == blob.Id);
+        if (size != buffer.size()) {
+            UNIT_ASSERT_VALUES_EQUAL(size, buffer.size());
+        }
+        const ui8 *a = (const ui8*)(void*)blob.Data.data();
+        const ui8 *b = (const ui8*)(void*)buffer.data();
+        if (memcmp(a + shift, b, size) != 0) {
+            for (ui32 offset = 0; offset < size; ++offset) {
+                UNIT_ASSERT_VALUES_EQUAL_C((ui32)a[shift + offset], (ui32)b[offset],
+                        "Id# " << id.ToString() << " offset# " << offset
+                        << " shift# " << shift << " s+o# " << (shift + offset) << " size# " << size
+                        << " canonic a# " << (ui32)a[shift+offset] << " actual b# " << (ui32)b[offset]);
+            }
+        }
+    }
+};
+
+struct TPartLocation {
+    TLogoBlobID BlobId;
+    TVDiskID VDiskId;
+
+    static TString ToString(const TPartLocation &self) {
+        return TStringBuilder()
+            << "{BlobId# " << self.BlobId.ToString()
+            << " VDiskId# " << self.VDiskId.ToString()
+            << "}";
+    }
+
+    TString ToString() const {
+        return ToString(*this);
+    }
+
+    bool operator<(const TPartLocation &other) const {
+        return std::tie(BlobId, VDiskId) < std::tie(other.BlobId, other.VDiskId);
+    }
+};
+
+class TGroupMock {
+    const ui32 GroupId;
+    const TErasureType::EErasureSpecies ErasureSpecies;
+    const ui32 FailDomains;
+    const ui32 DrivesPerFailDomain;
+
+    TVector<TVDiskMock> VDisks;
+    TIntrusivePtr<TBlobStorageGroupInfo> Info;
+
+    TVDiskMock& GetVDisk(ui32 failDomainIdx, ui32 driveIdx) {
+        ui32 i = failDomainIdx * DrivesPerFailDomain + driveIdx;
+        Y_VERIFY(i < VDisks.size(), "i# %" PRIu32 " size# %" PRIu32, (ui32)i, (ui32)VDisks.size());
+        return VDisks[i];
+    }
+
+    void InitBsInfo() {
+        for (auto& mock : VDisks) {
+            mock.SetInfo(Info);
+        }
+    }
+
+    void InitVDisks() {
+        for (ui64 domainIdx = 0; domainIdx < FailDomains; ++domainIdx) {
+            for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) {
+                // Node = domainIdx
+                // PoolId = driveIdx
+                // LocalId = index in VDisks
+                TVDiskID vDiskId(GroupId, 1, 0, domainIdx, driveIdx);
+                VDisks.emplace_back(vDiskId);
+            }
+        }
+    }
+
+public:
+    TGroupMock(ui32 groupId, TErasureType::EErasureSpecies erasureSpecies, ui32 failDomains, ui32 drivesPerFailDomain,
+            TIntrusivePtr<TBlobStorageGroupInfo> info)
+        : GroupId(groupId)
+        , ErasureSpecies(erasureSpecies)
+        , FailDomains(failDomains)
+        , DrivesPerFailDomain(drivesPerFailDomain)
+        , Info(info)
+    {
+        Y_UNUSED(ErasureSpecies);
+        InitVDisks();
+        InitBsInfo();
+    }
+
+    TGroupMock(ui32 groupId, TErasureType::EErasureSpecies erasureSpecies, ui32 failDomains, ui32 drivesPerFailDomain)
+        : TGroupMock(groupId, erasureSpecies, failDomains, drivesPerFailDomain,
+                new TBlobStorageGroupInfo(erasureSpecies, drivesPerFailDomain, failDomains))
+    {
+    }
+
+    ui32 VDiskIdx(const TVDiskID &id) {
+        ui32 idx = (ui32)id.FailDomain * DrivesPerFailDomain + (ui32)id.VDisk;
+        return idx;
+    }
+
+    TIntrusivePtr<TBlobStorageGroupInfo> GetInfo() {
+        return Info;
+    }
+
+    void OnVGet(const TEvBlobStorage::TEvVGet &vGet, TEvBlobStorage::TEvVGetResult &outVGetResult) {
+        Y_VERIFY(vGet.Record.HasVDiskID());
+        TVDiskID vDiskId = VDiskIDFromVDiskID(vGet.Record.GetVDiskID());
+        GetVDisk(vDiskId.FailDomain, vDiskId.VDisk).OnVGet(vGet, outVGetResult);
+    }
+
+    NKikimrProto::EReplyStatus OnVPut(TEvBlobStorage::TEvVPut &vPut) {
+        const NKikimrBlobStorage::TEvVPut &record = vPut.Record;
+        Y_VERIFY(record.HasVDiskID());
+        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
+        ui32 idx = VDiskIdx(vDiskId);
+        TVDiskMock &disk = VDisks[idx];
+        if (disk.GetVDiskId() != vDiskId) {
+            return NKikimrProto::RACE;
+        }
+        const TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID());
+        TString buffer = vPut.GetBuffer().ConvertToString();
+        NKikimrProto::EReplyStatus status = disk.Put(blobId, buffer);
+        return status;
+    }
+
+    template <typename TEvent>
+    TVDiskID GetVDiskID(TEvent &vPut) {
+        const auto &record = vPut.Record;
+        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
+        ui32 idx = VDiskIdx(vDiskId);
+        TVDiskMock &disk = VDisks[idx];
+        return disk.GetVDiskId();
+    }
+
+    TVector<NKikimrProto::EReplyStatus> OnVMultiPut(TEvBlobStorage::TEvVMultiPut &vMultiPut) {
+        const NKikimrBlobStorage::TEvVMultiPut &record = vMultiPut.Record;
+        Y_VERIFY(record.HasVDiskID());
+        TVDiskID vDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
+        ui32 idx = VDiskIdx(vDiskId);
+        TVDiskMock &disk = VDisks[idx];
+        if (disk.GetVDiskId() != vDiskId) {
+            return TVector<NKikimrProto::EReplyStatus>(record.ItemsSize(), NKikimrProto::RACE);
+        }
+        Y_VERIFY(disk.GetVDiskId() == vDiskId);
+        TVector<NKikimrProto::EReplyStatus> statuses;
+        for (ui64 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) {
+            auto &item = record.GetItems(itemIdx);
+            const TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+            TString buffer = vMultiPut.GetItemBuffer(itemIdx).ConvertToString();
+            statuses.push_back(disk.Put(blobId, buffer));
+        }
+        return statuses;
+    }
+
+    void Wipe(ui32 domainIdx) {
+        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) {
+            GetVDisk(domainIdx, driveIdx).Wipe();
+        }
+    }
+
+    void Wipe() {
+        for (ui32 idx = 0; idx < VDisks.size(); ++idx) {
+            VDisks[idx].Wipe();
+        }
+    }
+
+    void SetError(ui32 domainIdx, NKikimrProto::EReplyStatus status) {
+        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) {
+            GetVDisk(domainIdx, driveIdx).SetError(status);
+        }
+    }
+
+    void SetPredictedDelayNs(ui32 domainIdx, ui64 predictedDelayNs) {
+        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) {
+            GetVDisk(domainIdx, driveIdx).SetPredictedDelayNs(predictedDelayNs);
+        }
+    }
+
+    void UnsetError(ui32 domainIdx) {
+        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) {
+            GetVDisk(domainIdx, driveIdx).UnsetError();
+        }
+    }
+
+    void SetSpecialStatus(ui32 domainIdx, TLogoBlobID blobID, NKikimrProto::EReplyStatus status) {
+        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) {
+            GetVDisk(domainIdx, driveIdx).SetSpecialStatus(blobID, status);
+        }
+    }
+
+    void SetSpecialStatuses(const TMap<TPartLocation, NKikimrProto::EReplyStatus> &statuses) {
+        for (auto &[partLocation, status] : statuses) {
+            ui64 vDiskIdx = VDiskIdx(partLocation.VDiskId);
+            VDisks[vDiskIdx].SetSpecialStatus(partLocation.BlobId, status);
+        }
+    }
+
+    void SetNotYetBlob(ui32 domainIdx, const TLogoBlobID blobID) {
+        for (ui64 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) {
+            GetVDisk(domainIdx, driveIdx).SetNotYet(blobID);
+        }
+    }
+
+    void Put(const TLogoBlobID id, const TString &data, ui32 handoffsToUse = 0) {
+        const ui32 hash = id.Hash();
+        const ui32 totalvd = Info->Type.BlobSubgroupSize();
+        const ui32 totalParts = Info->Type.TotalPartCount();
+        Y_VERIFY(id.BlobSize() == data.size());
+        Y_VERIFY(totalvd >= totalParts);
+        TBlobStorageGroupInfo::TServiceIds vDisksSvc;
+        TBlobStorageGroupInfo::TVDiskIds vDisksId;
+        Info->PickSubgroup(hash, &vDisksId, &vDisksSvc);
+
+        TString encryptedData = data;
+        char *dataBytes = encryptedData.Detach();
+        Encrypt(dataBytes, dataBytes, 0, encryptedData.size(), id, *Info);
+
+        TDataPartSet partSet;
+        partSet.Parts.resize(totalParts);
+        Info->Type.SplitData((TErasureType::ECrcMode)id.CrcMode(), encryptedData, partSet);
+        for (ui32 i = 0; i < totalParts; ++i) {
+            TLogoBlobID pId(id, i + 1);
+            TString pData = partSet.Parts[i].OwnedString;
+            if (i < handoffsToUse) {
+                Y_VERIFY(totalParts + i < totalvd);
+                GetVDisk(vDisksId[totalParts + i].FailDomain, vDisksId[totalParts + i].VDisk).Put(pId, pData);
+            } else {
+                GetVDisk(vDisksId[i].FailDomain, vDisksId[i].VDisk).Put(pId, pData);
+            }
+        }
+    }
+
+    i32 DomainIdxForBlobSubgroupIdx(const TLogoBlobID id, i32 subgroupIdx) {
+        const ui32 hash = id.Hash();
+        const ui32 totalvd = Info->Type.BlobSubgroupSize();
+        const ui32 totalParts = Info->Type.TotalPartCount();
+        Y_VERIFY(totalvd >= totalParts);
+        TBlobStorageGroupInfo::TServiceIds vDisksSvc;
+        TBlobStorageGroupInfo::TVDiskIds vDisksId;
+        Info->PickSubgroup(hash, &vDisksId, &vDisksSvc);
+
+        return vDisksId[subgroupIdx].FailDomain;
+    }
+
+    void PutBlobSet(const TBlobTestSet &blobSet, ui32 handoffsToUse = 0) {
+        for (ui64 i = 0; i < blobSet.Size(); ++i) {
+            const auto &blob = blobSet.Get(i);
+            Put(blob.Id, blob.Data, handoffsToUse);
+        }
+    }
+
     TIntrusivePtr<TGroupQueues> MakeGroupQueues() {
         TIntrusivePtr<TGroupQueues> groupQueues(new TGroupQueues(Info->GetTopology()));
         ui32 idx = 0;
         for (auto& domain : groupQueues->FailDomains) {
-            for (auto& vDisk : domain.VDisks) { 
-                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::PutTabletLog).Reset( 
-                        VDisks[idx].FlowRecord); 
-                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob).Reset( 
-                        VDisks[idx].FlowRecord); 
-                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::PutUserData).Reset( 
-                        VDisks[idx].FlowRecord); 
-                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::GetAsyncRead).Reset( 
-                        VDisks[idx].FlowRecord); 
-                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::GetFastRead).Reset( 
-                        VDisks[idx].FlowRecord); 
-                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::GetDiscover).Reset( 
-                        VDisks[idx].FlowRecord); 
+            for (auto& vDisk : domain.VDisks) {
+                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::PutTabletLog).Reset(
+                        VDisks[idx].FlowRecord);
+                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob).Reset(
+                        VDisks[idx].FlowRecord);
+                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::PutUserData).Reset(
+                        VDisks[idx].FlowRecord);
+                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::GetAsyncRead).Reset(
+                        VDisks[idx].FlowRecord);
+                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::GetFastRead).Reset(
+                        VDisks[idx].FlowRecord);
+                vDisk.Queues.FlowRecordForQueueId(NKikimrBlobStorage::EVDiskQueueId::GetDiscover).Reset(
+                        VDisks[idx].FlowRecord);
                 ++idx;
-            } 
-        } 
+            }
+        }
         return groupQueues;
-    } 
-}; 
- 
-} // namespace NKikimr 
+    }
+};
+
+} // namespace NKikimr
diff --git a/ydb/core/blobstorage/dsproxy/ut/ya.make b/ydb/core/blobstorage/dsproxy/ut/ya.make
index baef8d115a..76825e572b 100644
--- a/ydb/core/blobstorage/dsproxy/ut/ya.make
+++ b/ydb/core/blobstorage/dsproxy/ut/ya.make
@@ -41,8 +41,8 @@ SRCS(
     dsproxy_put_ut.cpp
     dsproxy_quorum_tracker_ut.cpp
     dsproxy_sequence_ut.cpp
-    dsproxy_patch_ut.cpp 
-    dsproxy_counters_ut.cpp 
+    dsproxy_patch_ut.cpp
+    dsproxy_counters_ut.cpp
 )
 
 
diff --git a/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp b/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
index b9dccb8a11..13b1bec356 100644
--- a/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
@@ -30,9 +30,9 @@
 #include <library/cpp/actors/core/log.h>
 #include <library/cpp/actors/core/scheduler_basic.h>
 #include <library/cpp/actors/interconnect/interconnect.h>
-#include <library/cpp/actors/interconnect/poller_tcp.h> 
-#include <library/cpp/actors/interconnect/poller_actor.h> 
-#include <library/cpp/actors/interconnect/mock/ic_mock.h> 
+#include <library/cpp/actors/interconnect/poller_tcp.h>
+#include <library/cpp/actors/interconnect/poller_actor.h>
+#include <library/cpp/actors/interconnect/mock/ic_mock.h>
 #include <library/cpp/actors/protos/services_common.pb.h>
 #include <library/cpp/actors/util/affinity.h>
 #include <library/cpp/svnversion/svnversion.h>
@@ -41,13 +41,13 @@
 
 #include <util/folder/dirut.h>
 #include <util/folder/tempdir.h>
-#include <util/generic/algorithm.h> 
+#include <util/generic/algorithm.h>
 #include <util/generic/hash.h>
 #include <util/generic/string.h>
 #include <util/generic/yexception.h>
-#include <util/random/mersenne.h> 
-#include <util/random/random.h> 
-#include <util/random/shuffle.h> 
+#include <util/random/mersenne.h>
+#include <util/random/random.h>
+#include <util/random/shuffle.h>
 #include <util/string/escape.h>
 #include <util/string/printf.h>
 #include <util/system/backtrace.h>
@@ -64,7 +64,7 @@ namespace NKikimr {
 do { \
     UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::msg, "Unexpected message " << (int)LastResponse.Message); \
     UNIT_ASSERT_EQUAL_C(LastResponse.Status, NKikimrProto::st, "Unexpected status " \
-            << StatusToString(LastResponse.Status) << " deadVDisks " << Env->DeadVDisksMask); \ 
+            << StatusToString(LastResponse.Status) << " deadVDisks " << Env->DeadVDisksMask); \
     UNIT_ASSERT_VALUES_EQUAL_C(LastResponse.Data.size(), sz, "Data size " \
         << (int)LastResponse.Data.size() << " while expected " << (sz)); \
 } while(false)
@@ -76,16 +76,16 @@ do { \
         << EscapeC(TString(LastResponse.Data[0])).c_str() << "' instead of '" << EscapeC(TString(d)).c_str() << "'"); \
 } while(false)
 
- 
-#define TEST_RESPONSE_FULLCHECK(msg, st, sz, d) \ 
-do { \ 
-    TEST_RESPONSE_3(msg, st, sz); \ 
-    for (size_t i = 0; i < sz; ++i) { \ 
-        UNIT_ASSERT_C(TString(LastResponse.Data[i]) == TString(d[i]), "Got " << i << "'th element '" \ 
-            << EscapeC(TString(LastResponse.Data[i])).c_str() << "' instead of '" << EscapeC(TString(d[i])).c_str() << "' at test step " << TestStep); \ 
-    } \ 
-} while (false) 
- 
+
+#define TEST_RESPONSE_FULLCHECK(msg, st, sz, d) \
+do { \
+    TEST_RESPONSE_3(msg, st, sz); \
+    for (size_t i = 0; i < sz; ++i) { \
+        UNIT_ASSERT_C(TString(LastResponse.Data[i]) == TString(d[i]), "Got " << i << "'th element '" \
+            << EscapeC(TString(LastResponse.Data[i])).c_str() << "' instead of '" << EscapeC(TString(d[i])).c_str() << "' at test step " << TestStep); \
+    } \
+} while (false)
+
 #define VERBOSE_COUT(str) \
 do { \
     if (IsVerbose) { \
@@ -107,105 +107,105 @@ static bool IsVerbose = false;
 static bool IsProfilerEnabled = true;
 
 
-TString TestData2( 
-        "But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born.."); 
+TString TestData2(
+        "But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born..");
 
 static TString StatusToString(const NKikimrProto::EReplyStatus status) {
     return NKikimrProto::EReplyStatus_Name(status);
 }
 
- 
-struct ITestParametrs : public TThrRefBase { 
-    virtual ~ITestParametrs() 
-    { 
-    } 
-}; 
- 
-struct TTestArgs { 
-    ui64 BadVDiskMask = 0; 
-    TBlobStorageGroupType::EErasureSpecies ErasureSpecies; 
-    ui32 SleepMilliseconds = 0; 
-    bool StartBadDisks = true; 
-    ui32 FailDomainCount = 0; 
-    ui32 DrivesPerFailDomain = 0; 
-    TIntrusivePtr<ITestParametrs> Parametrs = nullptr; 
-    bool EnablePutBatching = DefaultEnablePutBatching; 
-    TPDiskCategory::EDeviceType DeviceType = TPDiskCategory::DEVICE_TYPE_ROT; 
-}; 
- 
-struct TTestEnvironment : public TThrRefBase { 
-    ui32 VDiskCount; 
-    ui64 DeadVDisksMask; 
+
+struct ITestParametrs : public TThrRefBase {
+    virtual ~ITestParametrs()
+    {
+    }
+};
+
+struct TTestArgs {
+    ui64 BadVDiskMask = 0;
+    TBlobStorageGroupType::EErasureSpecies ErasureSpecies;
+    ui32 SleepMilliseconds = 0;
+    bool StartBadDisks = true;
+    ui32 FailDomainCount = 0;
+    ui32 DrivesPerFailDomain = 0;
+    TIntrusivePtr<ITestParametrs> Parametrs = nullptr;
+    bool EnablePutBatching = DefaultEnablePutBatching;
+    TPDiskCategory::EDeviceType DeviceType = TPDiskCategory::DEVICE_TYPE_ROT;
+};
+
+struct TTestEnvironment : public TThrRefBase {
+    ui32 VDiskCount;
+    ui64 DeadVDisksMask;
     TVector<TActorId> VDisks;
     TVector<TActorId> PDisks;
-    TVector<TVDiskID> VDiskIds; 
- 
-    bool ShouldBeUnwritable; 
-    bool ShouldBeUndiscoverable; 
- 
-    ui64 FailDomainCount; 
-    ui64 DrivesPerFailDomain; 
-    ui32 FailedDiskCount; 
-    TBlobStorageGroupType GroupType; 
- 
+    TVector<TVDiskID> VDiskIds;
+
+    bool ShouldBeUnwritable;
+    bool ShouldBeUndiscoverable;
+
+    ui64 FailDomainCount;
+    ui64 DrivesPerFailDomain;
+    ui32 FailedDiskCount;
+    TBlobStorageGroupType GroupType;
+
     TActorId ProxyId;
     TActorId ProxyTestId;
- 
-    TSystemEvent DoneEvent; 
-    yexception LastException; 
-    volatile bool IsLastExceptionSet = false; 
- 
- 
-    TTestEnvironment(const TTestArgs &args) 
-        : DeadVDisksMask(args.StartBadDisks ? 0 : args.BadVDiskMask) 
-        , FailedDiskCount(0) 
-        , GroupType(args.ErasureSpecies) 
-        , ProxyId(MakeBlobStorageProxyID(0)) 
-        , ProxyTestId(MakeBlobStorageProxyID(1)) 
-    { 
-        for (int i = 0; i < 32; ++i) { 
-            if (args.BadVDiskMask & (1 << i)) { 
-                ++FailedDiskCount; 
-            } 
-        } 
- 
-        ShouldBeUnwritable = FailedDiskCount > GroupType.Handoff(); 
-        ShouldBeUndiscoverable = FailedDiskCount > GroupType.ParityParts(); 
- 
-        VDiskCount = args.FailDomainCount * args.DrivesPerFailDomain; 
-        if (VDiskCount == 0) { 
-            VDiskCount = GroupType.BlobSubgroupSize(); 
-            DrivesPerFailDomain = 1; 
-            FailDomainCount = VDiskCount; 
-        } else { 
-            DrivesPerFailDomain = args.DrivesPerFailDomain; 
-            FailDomainCount = args.FailDomainCount; 
-        } 
- 
-        VDisks.resize(VDiskCount); 
-        PDisks.resize(VDiskCount); 
-        VDiskIds.reserve(VDiskCount); 
-        for (ui32 failDomainIdx = 0; failDomainIdx < FailDomainCount; ++failDomainIdx) { 
-            for (ui32 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) { 
-                ui32 i = GetVDiskTestIdx(failDomainIdx, driveIdx); 
-                VDisks[i] = MakeBlobStorageVDiskID(2, i + 1, 1); 
-                PDisks[i] = MakeBlobStoragePDiskID(2, i + 1); 
-                VDiskIds.emplace_back(0, 1, 0, failDomainIdx, driveIdx); 
-            } 
-        } 
-    } 
- 
-    ui64 GetVDiskTestIdx(ui64 failDomain, ui64 orderNumber) const { 
-        return failDomain * DrivesPerFailDomain + orderNumber; 
-    } 
- 
-    ui64 GetVDiskTestIdx(const TVDiskID &vDiskId) const { 
-        ui64 failDomain = vDiskId.FailDomain; 
-        ui64 orderNumber = vDiskId.VDisk; 
-        return GetVDiskTestIdx(failDomain, orderNumber); 
-    } 
-}; 
- 
+
+    TSystemEvent DoneEvent;
+    yexception LastException;
+    volatile bool IsLastExceptionSet = false;
+
+
+    TTestEnvironment(const TTestArgs &args)
+        : DeadVDisksMask(args.StartBadDisks ? 0 : args.BadVDiskMask)
+        , FailedDiskCount(0)
+        , GroupType(args.ErasureSpecies)
+        , ProxyId(MakeBlobStorageProxyID(0))
+        , ProxyTestId(MakeBlobStorageProxyID(1))
+    {
+        for (int i = 0; i < 32; ++i) {
+            if (args.BadVDiskMask & (1 << i)) {
+                ++FailedDiskCount;
+            }
+        }
+
+        ShouldBeUnwritable = FailedDiskCount > GroupType.Handoff();
+        ShouldBeUndiscoverable = FailedDiskCount > GroupType.ParityParts();
+
+        VDiskCount = args.FailDomainCount * args.DrivesPerFailDomain;
+        if (VDiskCount == 0) {
+            VDiskCount = GroupType.BlobSubgroupSize();
+            DrivesPerFailDomain = 1;
+            FailDomainCount = VDiskCount;
+        } else {
+            DrivesPerFailDomain = args.DrivesPerFailDomain;
+            FailDomainCount = args.FailDomainCount;
+        }
+
+        VDisks.resize(VDiskCount);
+        PDisks.resize(VDiskCount);
+        VDiskIds.reserve(VDiskCount);
+        for (ui32 failDomainIdx = 0; failDomainIdx < FailDomainCount; ++failDomainIdx) {
+            for (ui32 driveIdx = 0; driveIdx < DrivesPerFailDomain; ++driveIdx) {
+                ui32 i = GetVDiskTestIdx(failDomainIdx, driveIdx);
+                VDisks[i] = MakeBlobStorageVDiskID(2, i + 1, 1);
+                PDisks[i] = MakeBlobStoragePDiskID(2, i + 1);
+                VDiskIds.emplace_back(0, 1, 0, failDomainIdx, driveIdx);
+            }
+        }
+    }
+
+    ui64 GetVDiskTestIdx(ui64 failDomain, ui64 orderNumber) const {
+        return failDomain * DrivesPerFailDomain + orderNumber;
+    }
+
+    ui64 GetVDiskTestIdx(const TVDiskID &vDiskId) const {
+        ui64 failDomain = vDiskId.FailDomain;
+        ui64 orderNumber = vDiskId.VDisk;
+        return GetVDiskTestIdx(failDomain, orderNumber);
+    }
+};
+
 class TTestBlobStorageProxy : public TActor<TTestBlobStorageProxy> {
 protected:
     struct TResponseData {
@@ -225,8 +225,8 @@ protected:
             , MessageStopProfilerResult
             , MessageVStatusResult
             , MessageVCompactResult
-            , MessageProxyQueueState 
-            , MessageProxySessionsState 
+            , MessageProxyQueueState
+            , MessageProxySessionsState
         };
         EMessage Message;
         NKikimrProto::EReplyStatus Status;
@@ -238,8 +238,8 @@ protected:
         bool LogoBlobsCompacted;
         TStorageStatusFlags StatusFlags;
         TActorId Sender;
-        TVDiskID VDiskId; 
-        bool IsConnected; 
+        TVDiskID VDiskId;
+        bool IsConnected;
         TIntrusivePtr<TGroupQueues> GroupQueues;
 
         TResponseData()
@@ -273,84 +273,84 @@ protected:
     int InitStep;
     ui32 InitVDiskIdx;
 
-    ui32 ReadyQueueCount = 0; 
-    ui32 QueueCount = 0; 
+    ui32 ReadyQueueCount = 0;
+    ui32 QueueCount = 0;
     TIntrusivePtr<TGroupQueues> GroupQueues;
- 
-    const TIntrusivePtr<TTestEnvironment> Env; 
-    const TIntrusivePtr<ITestParametrs> Parametrs; 
- 
+
+    const TIntrusivePtr<TTestEnvironment> Env;
+    const TIntrusivePtr<ITestParametrs> Parametrs;
+
     virtual void TestFSM(const TActorContext &ctx) = 0;
-    void ActTestFSM(const TActorContext &ctx) { 
+    void ActTestFSM(const TActorContext &ctx) {
         try {
             switch (InitStep) {
             case 0:
-            { 
-                ctx.Send(Env->ProxyId, new TEvRequestProxySessionsState); 
-                InitStep = 3; 
-                break; 
- 
-            case 3: 
-                UNIT_ASSERT(LastResponse.Message == TResponseData::MessageProxySessionsState); 
+            {
+                ctx.Send(Env->ProxyId, new TEvRequestProxySessionsState);
+                InitStep = 3;
+                break;
+
+            case 3:
+                UNIT_ASSERT(LastResponse.Message == TResponseData::MessageProxySessionsState);
                 GroupQueues = std::move(LastResponse.GroupQueues);
                 UNIT_ASSERT(GroupQueues);
                 auto &failDomains = GroupQueues->FailDomains;
-                for (ui64 failDomainIdx = 0; failDomainIdx < failDomains.size(); ++failDomainIdx) { 
-                    auto &failDomain = failDomains[failDomainIdx]; 
-                    for (ui64 vDiskIdx = 0; vDiskIdx < failDomain.VDisks.size(); ++vDiskIdx) { 
-                        ui64 vDiskTestIdx = Env->GetVDiskTestIdx(failDomainIdx, vDiskIdx); 
-                        if (Env->DeadVDisksMask & (1ull << vDiskTestIdx)) { 
-                            continue; 
-                        } 
-                        auto &queues = failDomain.VDisks[vDiskIdx].Queues; 
-                        ctx.Send(queues.PutTabletLog.ActorId, new TEvRequestProxyQueueState); 
-                        ctx.Send(queues.PutAsyncBlob.ActorId, new TEvRequestProxyQueueState); 
-                        ctx.Send(queues.PutUserData.ActorId, new TEvRequestProxyQueueState); 
-                        ctx.Send(queues.GetAsyncRead.ActorId, new TEvRequestProxyQueueState); 
-                        ctx.Send(queues.GetFastRead.ActorId, new TEvRequestProxyQueueState); 
-                        ctx.Send(queues.GetDiscover.ActorId, new TEvRequestProxyQueueState); 
-                        QueueCount += 6; 
-                    } 
-                } 
-                InitStep = 6; 
-                break; 
-            } 
-            case 6: 
-                UNIT_ASSERT(LastResponse.Message == TResponseData::MessageProxyQueueState); 
-                if (LastResponse.IsConnected) { 
-                    ReadyQueueCount++; 
-                } else { 
-                    ctx.Send(LastResponse.Sender, new TEvRequestProxyQueueState); 
-                } 
- 
-                if (ReadyQueueCount != QueueCount) { 
-                    break; 
-                } 
-                InitStep = 8; 
+                for (ui64 failDomainIdx = 0; failDomainIdx < failDomains.size(); ++failDomainIdx) {
+                    auto &failDomain = failDomains[failDomainIdx];
+                    for (ui64 vDiskIdx = 0; vDiskIdx < failDomain.VDisks.size(); ++vDiskIdx) {
+                        ui64 vDiskTestIdx = Env->GetVDiskTestIdx(failDomainIdx, vDiskIdx);
+                        if (Env->DeadVDisksMask & (1ull << vDiskTestIdx)) {
+                            continue;
+                        }
+                        auto &queues = failDomain.VDisks[vDiskIdx].Queues;
+                        ctx.Send(queues.PutTabletLog.ActorId, new TEvRequestProxyQueueState);
+                        ctx.Send(queues.PutAsyncBlob.ActorId, new TEvRequestProxyQueueState);
+                        ctx.Send(queues.PutUserData.ActorId, new TEvRequestProxyQueueState);
+                        ctx.Send(queues.GetAsyncRead.ActorId, new TEvRequestProxyQueueState);
+                        ctx.Send(queues.GetFastRead.ActorId, new TEvRequestProxyQueueState);
+                        ctx.Send(queues.GetDiscover.ActorId, new TEvRequestProxyQueueState);
+                        QueueCount += 6;
+                    }
+                }
+                InitStep = 6;
+                break;
+            }
+            case 6:
+                UNIT_ASSERT(LastResponse.Message == TResponseData::MessageProxyQueueState);
+                if (LastResponse.IsConnected) {
+                    ReadyQueueCount++;
+                } else {
+                    ctx.Send(LastResponse.Sender, new TEvRequestProxyQueueState);
+                }
+
+                if (ReadyQueueCount != QueueCount) {
+                    break;
+                }
+                InitStep = 8;
                 [[fallthrough]];
- 
-            case 8: 
-                while (Env->DeadVDisksMask & (1ull << InitVDiskIdx)) { 
+
+            case 8:
+                while (Env->DeadVDisksMask & (1ull << InitVDiskIdx)) {
                     ++InitVDiskIdx;
                 }
                 [[fallthrough]];
- 
+
             case 10:
             {
                 bool isSendNeeded = false;
-                if (InitStep == 8 || LastResponse.Status == NKikimrProto::NOTREADY || LastResponse.Status == NKikimrProto::ERROR) { 
-                    if (LastResponse.Status == NKikimrProto::NOTREADY || LastResponse.Status == NKikimrProto::ERROR) { 
+                if (InitStep == 8 || LastResponse.Status == NKikimrProto::NOTREADY || LastResponse.Status == NKikimrProto::ERROR) {
+                    if (LastResponse.Status == NKikimrProto::NOTREADY || LastResponse.Status == NKikimrProto::ERROR) {
                         Sleep(TDuration::MilliSeconds(50));
                     }
                     isSendNeeded = true;
                     InitStep = 10;
                 } else {
                     ++InitVDiskIdx;
-                    while (Env->DeadVDisksMask & (1ull << InitVDiskIdx)) { 
+                    while (Env->DeadVDisksMask & (1ull << InitVDiskIdx)) {
                         ++InitVDiskIdx;
                     }
 
-                    if (InitVDiskIdx < Env->VDiskCount) { 
+                    if (InitVDiskIdx < Env->VDiskCount) {
                         isSendNeeded = true;
                     } else {
                         InitStep = 20;
@@ -359,7 +359,7 @@ protected:
                 }
                 if (isSendNeeded) {
                     ui32 domains = BsInfo->GetTotalFailDomainsNum();
-                    ui32 drives = Env->VDiskCount / domains; 
+                    ui32 drives = Env->VDiskCount / domains;
                     ui32 domainIdx = InitVDiskIdx / drives;
                     ui32 driveIdx = InitVDiskIdx - domainIdx * drives;
 
@@ -373,12 +373,12 @@ protected:
                                                                             {},
                                                                             from,
                                                                             to);
- 
+
                     auto& msgId = *x->Record.MutableMsgQoS()->MutableMsgId();
                     msgId.SetMsgId(1);
                     msgId.SetSequenceId(1);
                     GroupQueues->Send(*this, BsInfo->GetTopology(), std::move(x), 0, NWilson::TTraceId(), false);
-                  break; 
+                  break;
                 }
                 [[fallthrough]];
             }
@@ -389,11 +389,11 @@ protected:
             LastResponse.Clear();
         }
         catch (yexception ex) {
-            Env->IsLastExceptionSet = true; 
-            Env->LastException = ex; 
-            Env->DoneEvent.Signal(); 
+            Env->IsLastExceptionSet = true;
+            Env->LastException = ex;
+            Env->DoneEvent.Signal();
         }
-        VERBOSE_COUT("InitStep# " << InitStep); 
+        VERBOSE_COUT("InitStep# " << InitStep);
     }
 
     void HandleStartProfilerResult(TEvProfiler::TEvStartResult::TPtr &ev, const TActorContext &ctx) {
@@ -597,26 +597,26 @@ protected:
         Y_UNUSED(ev);
     }
 
-    void HandleProxyQueueState(TEvProxyQueueState::TPtr &ev, const TActorContext &ctx) { 
-        VERBOSE_COUT("HandleProxyQueueState"); 
-        LastResponse.Message = TResponseData::MessageProxyQueueState; 
-        LastResponse.VDiskId = ev->Get()->VDiskId; 
-        LastResponse.IsConnected = ev->Get()->IsConnected; 
-        LastResponse.Sender = ev->Sender; 
-        ActTestFSM(ctx); 
-    } 
- 
-    void HandleProxySessionsState(TEvProxySessionsState::TPtr &ev, const TActorContext &ctx) { 
-        VERBOSE_COUT("HandleProxySessionsState"); 
-        LastResponse.Message = TResponseData::MessageProxySessionsState; 
+    void HandleProxyQueueState(TEvProxyQueueState::TPtr &ev, const TActorContext &ctx) {
+        VERBOSE_COUT("HandleProxyQueueState");
+        LastResponse.Message = TResponseData::MessageProxyQueueState;
+        LastResponse.VDiskId = ev->Get()->VDiskId;
+        LastResponse.IsConnected = ev->Get()->IsConnected;
+        LastResponse.Sender = ev->Sender;
+        ActTestFSM(ctx);
+    }
+
+    void HandleProxySessionsState(TEvProxySessionsState::TPtr &ev, const TActorContext &ctx) {
+        VERBOSE_COUT("HandleProxySessionsState");
+        LastResponse.Message = TResponseData::MessageProxySessionsState;
         LastResponse.GroupQueues = std::move(ev->Get()->GroupQueues);
-        LastResponse.Sender = ev->Sender; 
-        ActTestFSM(ctx); 
-    } 
- 
+        LastResponse.Sender = ev->Sender;
+        ActTestFSM(ctx);
+    }
+
 public:
     TTestBlobStorageProxy(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
         : TActor(&TThis::StateRegister)
         , Proxy(proxy)
         , ErasureSpecies(bsInfo->Type.GetErasure())
@@ -624,8 +624,8 @@ public:
         , TestStep(0)
         , InitStep(0)
         , InitVDiskIdx(0)
-        , Env(env) 
-        , Parametrs(parametrs) 
+        , Env(env)
+        , Parametrs(parametrs)
     {}
 
     STFUNC(StateRegister) {
@@ -645,8 +645,8 @@ public:
             HFunc(TEvBlobStorage::TEvBlockResult, HandleBlockResult);
             HFunc(TEvProfiler::TEvStartResult, HandleStartProfilerResult);
             HFunc(TEvProfiler::TEvStopResult, HandleStopProfilerResult);
-            HFunc(TEvProxyQueueState, HandleProxyQueueState); 
-            HFunc(TEvProxySessionsState, HandleProxySessionsState); 
+            HFunc(TEvProxyQueueState, HandleProxyQueueState);
+            HFunc(TEvProxySessionsState, HandleProxySessionsState);
         }
     }
 };
@@ -666,7 +666,7 @@ class TTestBlobStorageProxyBlockSet : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageBlockResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -676,8 +676,8 @@ class TTestBlobStorageProxyBlockSet : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyBlockSet(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -717,7 +717,7 @@ class TTestBlobStorageProxyBlockCheck : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessagePutResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -727,179 +727,179 @@ class TTestBlobStorageProxyBlockCheck : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyBlockCheck(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
 
-char DefaultCharGenerator(int i) { 
-    return i % 256; 
-} 
- 
-template <const TVector<size_t>& Order> 
-class TTestIterativePut: public TTestBlobStorageProxy { 
-    void TestFSM(const TActorContext& ctx) { 
-        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__); 
- 
-        if (!TestStep) { 
-            UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone, 
-                                "Unexpected " << (int)LastResponse.Message); 
-            for (auto idx : Order) { 
-                char ch = DefaultCharGenerator(idx); 
-                TLogoBlobID logoblobid(1, idx, 0, 0, 1, 0); 
-                ctx.Send(Proxy, new TEvBlobStorage::TEvPut(logoblobid, TString(ch), TInstant::Max())); 
-            } 
-        } else if (TestStep < (int)Order.size()) { 
-            TEST_RESPONSE(MessagePutResult, OK, 0, ""); 
-        } else { 
-            TEST_RESPONSE(MessagePutResult, OK, 0, ""); 
-            VERBOSE_COUT("Done"); 
-            Env->DoneEvent.Signal(); 
-        } 
-        TestStep++; 
-    } 
- 
-public: 
+char DefaultCharGenerator(int i) {
+    return i % 256;
+}
+
+template <const TVector<size_t>& Order>
+class TTestIterativePut: public TTestBlobStorageProxy {
+    void TestFSM(const TActorContext& ctx) {
+        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__);
+
+        if (!TestStep) {
+            UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone,
+                                "Unexpected " << (int)LastResponse.Message);
+            for (auto idx : Order) {
+                char ch = DefaultCharGenerator(idx);
+                TLogoBlobID logoblobid(1, idx, 0, 0, 1, 0);
+                ctx.Send(Proxy, new TEvBlobStorage::TEvPut(logoblobid, TString(ch), TInstant::Max()));
+            }
+        } else if (TestStep < (int)Order.size()) {
+            TEST_RESPONSE(MessagePutResult, OK, 0, "");
+        } else {
+            TEST_RESPONSE(MessagePutResult, OK, 0, "");
+            VERBOSE_COUT("Done");
+            Env->DoneEvent.Signal();
+        }
+        TestStep++;
+    }
+
+public:
     TTestIterativePut(const TActorId& proxy, const TIntrusivePtr<TBlobStorageGroupInfo>& bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
-    { 
-    } 
-}; 
- 
-template <ui64 PutInFlight, ui64 MaxSendPut> 
-class TTestInFlightPuts: public TTestBlobStorageProxy { 
-    TString Data; 
- 
-    void TestFSM(const TActorContext& ctx) { 
-        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__); 
-        ui64 testStep = TestStep; 
-        if (!testStep) { 
-            UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone, 
-                                "Unexpected " << (int)LastResponse.Message); 
-            for (ui64 idx = 0; idx < PutInFlight && idx < MaxSendPut; ++idx) { 
-                TLogoBlobID logoblobid(1, idx, 0, 0, Data.size(), 0); 
-                ctx.Send(Proxy, new TEvBlobStorage::TEvPut(logoblobid, Data, TInstant::Max())); 
-            } 
-        } else if (testStep <= MaxSendPut - PutInFlight) { 
-            TEST_RESPONSE(MessagePutResult, OK, 0, ""); 
-            ui64 idx = testStep + PutInFlight - 1; 
-            TLogoBlobID logoblobid(1, idx, 0, 0, Data.size(), 0); 
-            ctx.Send(Proxy, new TEvBlobStorage::TEvPut(logoblobid, Data, TInstant::Max())); 
-        } else if (testStep < MaxSendPut) { 
-            TEST_RESPONSE(MessagePutResult, OK, 0, ""); 
-        } else { 
-            TEST_RESPONSE(MessagePutResult, OK, 0, ""); 
-            VERBOSE_COUT("Done"); 
-            Env->DoneEvent.Signal(); 
-        } 
-        TestStep++; 
-    } 
- 
-public: 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
+    {
+    }
+};
+
+template <ui64 PutInFlight, ui64 MaxSendPut>
+class TTestInFlightPuts: public TTestBlobStorageProxy {
+    TString Data;
+
+    void TestFSM(const TActorContext& ctx) {
+        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__);
+        ui64 testStep = TestStep;
+        if (!testStep) {
+            UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone,
+                                "Unexpected " << (int)LastResponse.Message);
+            for (ui64 idx = 0; idx < PutInFlight && idx < MaxSendPut; ++idx) {
+                TLogoBlobID logoblobid(1, idx, 0, 0, Data.size(), 0);
+                ctx.Send(Proxy, new TEvBlobStorage::TEvPut(logoblobid, Data, TInstant::Max()));
+            }
+        } else if (testStep <= MaxSendPut - PutInFlight) {
+            TEST_RESPONSE(MessagePutResult, OK, 0, "");
+            ui64 idx = testStep + PutInFlight - 1;
+            TLogoBlobID logoblobid(1, idx, 0, 0, Data.size(), 0);
+            ctx.Send(Proxy, new TEvBlobStorage::TEvPut(logoblobid, Data, TInstant::Max()));
+        } else if (testStep < MaxSendPut) {
+            TEST_RESPONSE(MessagePutResult, OK, 0, "");
+        } else {
+            TEST_RESPONSE(MessagePutResult, OK, 0, "");
+            VERBOSE_COUT("Done");
+            Env->DoneEvent.Signal();
+        }
+        TestStep++;
+    }
+
+public:
     TTestInFlightPuts(const TActorId& proxy, const TIntrusivePtr<TBlobStorageGroupInfo>& bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
-    { 
-        Data.reserve(4096); 
-        for (ui64 i = 0; i < 4096; ++i) { 
-            Data.push_back('a'); 
-        } 
-    } 
-}; 
- 
-template <const TVector<size_t>& Order> 
-class TTestOrderGet: public TTestBlobStorageProxy { 
-    size_t GetIdx(int i) { 
-        return Order ? Order[i] : i; 
-    } 
- 
-    void InitExpectedValues() { 
-        ExpectedValues.resize(Order.size()); 
-        for (size_t idx = 0; idx != Order.size(); idx++) { 
-            ExpectedValues[idx] = TString(DefaultCharGenerator(GetIdx(idx))); 
-        } 
-    } 
- 
-    void TestFSM(const TActorContext& ctx) { 
-        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__); 
- 
-        if (!TestStep) { 
-            UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone, 
-                                "Unexpected " << (int)LastResponse.Message); 
- 
-            TArrayHolder<TEvBlobStorage::TEvGet::TQuery> q(new TEvBlobStorage::TEvGet::TQuery[Order.size()]); 
-            for (size_t idx = 0; idx < Order.size(); ++idx) { 
-                q[idx].Set(TLogoBlobID(1, GetIdx(idx), 0, 0, 1, 0)); 
-            } 
- 
-            ctx.Send(Proxy, new TEvBlobStorage::TEvGet(q, Order.size(), TInstant::Max(), 
-                                                    NKikimrBlobStorage::EGetHandleClass::FastRead)); 
-        } else { 
-            InitExpectedValues(); 
-            TEST_RESPONSE_FULLCHECK(MessageGetResult, OK, Order.size(), ExpectedValues); 
- 
-            VERBOSE_COUT("Done"); 
-            Env->DoneEvent.Signal(); 
-        } 
-        TestStep++; 
-    } 
- 
-public: 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
+    {
+        Data.reserve(4096);
+        for (ui64 i = 0; i < 4096; ++i) {
+            Data.push_back('a');
+        }
+    }
+};
+
+template <const TVector<size_t>& Order>
+class TTestOrderGet: public TTestBlobStorageProxy {
+    size_t GetIdx(int i) {
+        return Order ? Order[i] : i;
+    }
+
+    void InitExpectedValues() {
+        ExpectedValues.resize(Order.size());
+        for (size_t idx = 0; idx != Order.size(); idx++) {
+            ExpectedValues[idx] = TString(DefaultCharGenerator(GetIdx(idx)));
+        }
+    }
+
+    void TestFSM(const TActorContext& ctx) {
+        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__);
+
+        if (!TestStep) {
+            UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone,
+                                "Unexpected " << (int)LastResponse.Message);
+
+            TArrayHolder<TEvBlobStorage::TEvGet::TQuery> q(new TEvBlobStorage::TEvGet::TQuery[Order.size()]);
+            for (size_t idx = 0; idx < Order.size(); ++idx) {
+                q[idx].Set(TLogoBlobID(1, GetIdx(idx), 0, 0, 1, 0));
+            }
+
+            ctx.Send(Proxy, new TEvBlobStorage::TEvGet(q, Order.size(), TInstant::Max(),
+                                                    NKikimrBlobStorage::EGetHandleClass::FastRead));
+        } else {
+            InitExpectedValues();
+            TEST_RESPONSE_FULLCHECK(MessageGetResult, OK, Order.size(), ExpectedValues);
+
+            VERBOSE_COUT("Done");
+            Env->DoneEvent.Signal();
+        }
+        TestStep++;
+    }
+
+public:
     TTestOrderGet(const TActorId& proxy, const TIntrusivePtr<TBlobStorageGroupInfo>& bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
-    { 
-    } 
- 
-private: 
-    TVector<TString> ExpectedValues; 
-}; 
- 
-template <int StartIdx, int RangeLength> 
-class TTestRangeGet: public TTestBlobStorageProxy { 
-    void InitExpectedValues() { 
-        ExpectedValues.resize(RangeSize); 
-        for (int i = 0; i != RangeSize; i++) { 
-            ExpectedValues[i] = TString(DefaultCharGenerator(StartIdx + i * DIdx)); 
-        } 
-    } 
- 
-    void TestFSM(const TActorContext& ctx) { 
-        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__); 
- 
-        if (!TestStep) { 
-            UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone, 
-                                "Unexpected " << (int)LastResponse.Message); 
- 
-            TLogoBlobID from(1, StartIdx, 0, 0, 1, 0); 
-            TLogoBlobID to(1, StartIdx + RangeLength, 0, 0, 1, 0); 
-            ctx.Send(Proxy, new TEvBlobStorage::TEvRange(MakeTabletID(0, 0, 1), from, to, true, TInstant::Max())); 
-        } else { 
-            InitExpectedValues(); 
-            TEST_RESPONSE_FULLCHECK(MessageRangeResult, OK, (size_t)RangeSize, ExpectedValues); 
- 
-            VERBOSE_COUT("Done"); 
-            Env->DoneEvent.Signal(); 
-        } 
-        TestStep++; 
-    } 
- 
-public: 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
+    {
+    }
+
+private:
+    TVector<TString> ExpectedValues;
+};
+
+template <int StartIdx, int RangeLength>
+class TTestRangeGet: public TTestBlobStorageProxy {
+    void InitExpectedValues() {
+        ExpectedValues.resize(RangeSize);
+        for (int i = 0; i != RangeSize; i++) {
+            ExpectedValues[i] = TString(DefaultCharGenerator(StartIdx + i * DIdx));
+        }
+    }
+
+    void TestFSM(const TActorContext& ctx) {
+        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__);
+
+        if (!TestStep) {
+            UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone,
+                                "Unexpected " << (int)LastResponse.Message);
+
+            TLogoBlobID from(1, StartIdx, 0, 0, 1, 0);
+            TLogoBlobID to(1, StartIdx + RangeLength, 0, 0, 1, 0);
+            ctx.Send(Proxy, new TEvBlobStorage::TEvRange(MakeTabletID(0, 0, 1), from, to, true, TInstant::Max()));
+        } else {
+            InitExpectedValues();
+            TEST_RESPONSE_FULLCHECK(MessageRangeResult, OK, (size_t)RangeSize, ExpectedValues);
+
+            VERBOSE_COUT("Done");
+            Env->DoneEvent.Signal();
+        }
+        TestStep++;
+    }
+
+public:
     TTestRangeGet(const TActorId& proxy, const TIntrusivePtr<TBlobStorageGroupInfo>& bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
-    { 
-    } 
- 
-private: 
-    const int RangeSize = std::abs(RangeLength); 
-    const int DIdx = RangeLength > 0 ? 1 : -1; 
-    TVector<TString> ExpectedValues; 
-}; 
- 
- 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
+    {
+    }
+
+private:
+    const int RangeSize = std::abs(RangeLength);
+    const int DIdx = RangeLength > 0 ? 1 : -1;
+    TVector<TString> ExpectedValues;
+};
+
+
 class TTestBlobStorageProxyBlock : public TTestBlobStorageProxy {
     void TestFSM(const TActorContext &ctx) {
         VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__);
@@ -989,7 +989,7 @@ class TTestBlobStorageProxyBlock : public TTestBlobStorageProxy {
             case 90:
 
                 TEST_RESPONSE(MessagePutResult, OK, 0, "");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -999,8 +999,8 @@ class TTestBlobStorageProxyBlock : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyBlock(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1027,7 +1027,7 @@ class TTestBlobStorageProxyPut : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessagePutResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -1037,8 +1037,8 @@ class TTestBlobStorageProxyPut : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyPut(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1065,7 +1065,7 @@ class TTestBlobStorageProxyPutInvalidSize : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessagePutResult, ERROR, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -1075,8 +1075,8 @@ class TTestBlobStorageProxyPutInvalidSize : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyPutInvalidSize(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1100,7 +1100,7 @@ class TTestBlobStorageProxyPutFail : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessagePutResult, ERROR, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -1110,8 +1110,8 @@ class TTestBlobStorageProxyPutFail : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyPutFail(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1137,7 +1137,7 @@ class TTestBlobStorageProxyGet : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageGetResult, OK, 1, testData2);
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -1147,8 +1147,8 @@ class TTestBlobStorageProxyGet : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyGet(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1172,7 +1172,7 @@ class TTestBlobStorageProxyGetFail : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageGetResult, OK, 1, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -1182,8 +1182,8 @@ class TTestBlobStorageProxyGetFail : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyGetFail(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1207,7 +1207,7 @@ class TTestBlobStorageProxyGetTimeout : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageGetResult, ERROR, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -1217,8 +1217,8 @@ class TTestBlobStorageProxyGetTimeout : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyGetTimeout(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1246,7 +1246,7 @@ class TTestBlobStorageProxyPutGetMany: public TTestBlobStorageProxy {
         } else if (TestStep == int(count) + 1) {
             TEST_RESPONSE_3(MessageGetResult, OK, count);
             VERBOSE_COUT("Done");
-            Env->DoneEvent.Signal(); 
+            Env->DoneEvent.Signal();
             ++TestStep;
             return;
         } else {
@@ -1272,8 +1272,8 @@ class TTestBlobStorageProxyPutGetMany: public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyPutGetMany(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1344,7 +1344,7 @@ class TTestBlobStorageProxyPutGetStatus: public TTestBlobStorageProxy {
                 UNIT_ASSERT(LastResponse.StatusFlags.Raw & ui32(NKikimrBlobStorage::StatusIsValid));
             }
             VERBOSE_COUT("Done");
-            Env->DoneEvent.Signal(); 
+            Env->DoneEvent.Signal();
             ++TestStep;
             return;
         } else {
@@ -1365,8 +1365,8 @@ class TTestBlobStorageProxyPutGetStatus: public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyPutGetStatus(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1397,7 +1397,7 @@ class TTestBlobStorageProxyVPutVGet : public TTestBlobStorageProxy {
                 TAutoPtr<TEvBlobStorage::TEvVPut> vPut(
                    new TEvBlobStorage::TEvVPut(logoblobid, partSet.Parts[0].OwnedString, vDiskId, false,
                                                nullptr, TInstant::Max(), NKikimrBlobStorage::AsyncBlob));
-                ctx.Send(Env->VDisks[vDiskIdx], vPut.Release()); 
+                ctx.Send(Env->VDisks[vDiskIdx], vPut.Release());
                 break;
             }
             case 10:
@@ -1423,7 +1423,7 @@ class TTestBlobStorageProxyVPutVGet : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageVGetResult, OK, 1, partSet.Parts[0].OwnedString);
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -1434,8 +1434,8 @@ class TTestBlobStorageProxyVPutVGet : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyVPutVGet(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1490,7 +1490,7 @@ class TTestBlobStorageProxyVPutVGetLimit : public TTestBlobStorageProxy {
                     auto& msgId = *vPut->Record.MutableMsgQoS()->MutableMsgId();
                     msgId.SetMsgId(i);
                     msgId.SetSequenceId(1);
-                    ctx.Send(Env->VDisks[vDiskIdx], vPut.Release()); 
+                    ctx.Send(Env->VDisks[vDiskIdx], vPut.Release());
                 }
                 break;
             }
@@ -1520,7 +1520,7 @@ class TTestBlobStorageProxyVPutVGetLimit : public TTestBlobStorageProxy {
             {
                 TEST_RESPONSE_3(MessageVGetResult, OK, 5);
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -1531,102 +1531,102 @@ class TTestBlobStorageProxyVPutVGetLimit : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyVPutVGetLimit(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
         , Iteration(0)
     {}
 };
 
-enum EVDiskIdxMode { 
-    VDIM_TestIdx, 
-    VDIM_IdxInSubgroup 
-}; 
- 
+enum EVDiskIdxMode {
+    VDIM_TestIdx,
+    VDIM_IdxInSubgroup
+};
+
 class TTestBlobStorageProxyVPut : public TTestBlobStorageProxy {
-public: 
-    struct TParametrs : public ITestParametrs { 
-        using TPtr = TIntrusivePtr<TParametrs>; 
- 
-        TString TestData; 
-        ui64 PartId; 
-        EVDiskIdxMode Mode = VDIM_IdxInSubgroup; 
-        ui64 VDiskIdx = Max<ui64>(); // default value for VDIM_IdxInSubgroup 
- 
-        TParametrs(TString testData = "", ui64 partId = 0, EVDiskIdxMode mode = VDIM_IdxInSubgroup, 
-                ui64 vDiskIdx = Max<ui64>()) 
-            : TestData(testData) 
-            , PartId(partId) 
-            , Mode(mode) 
-            , VDiskIdx(vDiskIdx) 
-        {} 
- 
-        virtual ~TParametrs() 
-        {} 
-    }; 
- 
-private: 
-    TParametrs& GetParametrs() { 
-        TParametrs *param = dynamic_cast<TParametrs*>(Parametrs.Get()); 
-        UNIT_ASSERT(param); 
-        return *param; 
-    } 
- 
+public:
+    struct TParametrs : public ITestParametrs {
+        using TPtr = TIntrusivePtr<TParametrs>;
+
+        TString TestData;
+        ui64 PartId;
+        EVDiskIdxMode Mode = VDIM_IdxInSubgroup;
+        ui64 VDiskIdx = Max<ui64>(); // default value for VDIM_IdxInSubgroup
+
+        TParametrs(TString testData = "", ui64 partId = 0, EVDiskIdxMode mode = VDIM_IdxInSubgroup,
+                ui64 vDiskIdx = Max<ui64>())
+            : TestData(testData)
+            , PartId(partId)
+            , Mode(mode)
+            , VDiskIdx(vDiskIdx)
+        {}
+
+        virtual ~TParametrs()
+        {}
+    };
+
+private:
+    TParametrs& GetParametrs() {
+        TParametrs *param = dynamic_cast<TParametrs*>(Parametrs.Get());
+        UNIT_ASSERT(param);
+        return *param;
+    }
+
     void TestFSM(const TActorContext &ctx) {
-        TParametrs &parametrs = GetParametrs(); 
-        UNIT_ASSERT(parametrs.PartId <= BsInfo->Type.TotalPartCount()); 
-        UNIT_ASSERT(parametrs.PartId > 0); 
-        TLogoBlobID blobId(1, 0, 0, 0, parametrs.TestData.size(), 0); 
-        TLogoBlobID logoblobid(1, 0, 0, 0, parametrs.TestData.size(), 0, parametrs.PartId); 
-        UNIT_ASSERT(parametrs.VDiskIdx < BsInfo->Type.BlobSubgroupSize() || parametrs.VDiskIdx == Max<ui64>()); 
-        TMaybe<TVDiskID> vDiskId; 
-        ui64 realVDiskIdx = parametrs.VDiskIdx; 
- 
-        switch (parametrs.Mode) { 
-            case VDIM_TestIdx: 
-                UNIT_ASSERT(parametrs.VDiskIdx != Max<ui64>()); 
-                vDiskId = Env->VDiskIds[parametrs.VDiskIdx]; 
-                break; 
-            case VDIM_IdxInSubgroup: 
-                ui64 idxInSubgroup = (parametrs.VDiskIdx == Max<ui64>()) ? (parametrs.PartId  - 1) : parametrs.VDiskIdx; 
-                vDiskId = BsInfo->GetVDiskInSubgroup(idxInSubgroup, blobId.Hash()); 
-                realVDiskIdx = Env->GetVDiskTestIdx(*vDiskId); 
-                if (*vDiskId != Env->VDiskIds[realVDiskIdx]) { 
-                    TStringBuilder str; 
-                    str << "partId# " << parametrs.PartId; 
-                    str << " idxInSubgroup# " << idxInSubgroup; 
-                    str << " vDiskId# " << vDiskId->ToString(); 
-                    str << " realVDiskIdx# " << realVDiskIdx; 
-                    str << " vDisks# ["; 
-                    for (ui64 idx = 0; idx < Env->VDiskIds.size(); ++idx) { 
-                        str << (idx ? " " : "") << Env->VDiskIds[idx].ToString(); 
-                    } 
-                    str << "]"; 
-                    UNIT_ASSERT_C(*vDiskId == Env->VDiskIds[realVDiskIdx], str); 
-                } 
-                break; 
-        } 
-        UNIT_ASSERT(vDiskId); 
+        TParametrs &parametrs = GetParametrs();
+        UNIT_ASSERT(parametrs.PartId <= BsInfo->Type.TotalPartCount());
+        UNIT_ASSERT(parametrs.PartId > 0);
+        TLogoBlobID blobId(1, 0, 0, 0, parametrs.TestData.size(), 0);
+        TLogoBlobID logoblobid(1, 0, 0, 0, parametrs.TestData.size(), 0, parametrs.PartId);
+        UNIT_ASSERT(parametrs.VDiskIdx < BsInfo->Type.BlobSubgroupSize() || parametrs.VDiskIdx == Max<ui64>());
+        TMaybe<TVDiskID> vDiskId;
+        ui64 realVDiskIdx = parametrs.VDiskIdx;
+
+        switch (parametrs.Mode) {
+            case VDIM_TestIdx:
+                UNIT_ASSERT(parametrs.VDiskIdx != Max<ui64>());
+                vDiskId = Env->VDiskIds[parametrs.VDiskIdx];
+                break;
+            case VDIM_IdxInSubgroup:
+                ui64 idxInSubgroup = (parametrs.VDiskIdx == Max<ui64>()) ? (parametrs.PartId  - 1) : parametrs.VDiskIdx;
+                vDiskId = BsInfo->GetVDiskInSubgroup(idxInSubgroup, blobId.Hash());
+                realVDiskIdx = Env->GetVDiskTestIdx(*vDiskId);
+                if (*vDiskId != Env->VDiskIds[realVDiskIdx]) {
+                    TStringBuilder str;
+                    str << "partId# " << parametrs.PartId;
+                    str << " idxInSubgroup# " << idxInSubgroup;
+                    str << " vDiskId# " << vDiskId->ToString();
+                    str << " realVDiskIdx# " << realVDiskIdx;
+                    str << " vDisks# [";
+                    for (ui64 idx = 0; idx < Env->VDiskIds.size(); ++idx) {
+                        str << (idx ? " " : "") << Env->VDiskIds[idx].ToString();
+                    }
+                    str << "]";
+                    UNIT_ASSERT_C(*vDiskId == Env->VDiskIds[realVDiskIdx], str);
+                }
+                break;
+        }
+        UNIT_ASSERT(vDiskId);
         VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__);
 
-        TString encryptedTestData; 
-        encryptedTestData.resize(parametrs.TestData.size()); 
-        Encrypt(encryptedTestData.Detach(), parametrs.TestData.data(), 0, parametrs.TestData.size(), blobId, *BsInfo); 
- 
+        TString encryptedTestData;
+        encryptedTestData.resize(parametrs.TestData.size());
+        Encrypt(encryptedTestData.Detach(), parametrs.TestData.data(), 0, parametrs.TestData.size(), blobId, *BsInfo);
+
         switch (TestStep) {
             case 0:
             {
                 UNIT_ASSERT_EQUAL_C(LastResponse.Message, TResponseData::MessageNone,
                     "Unexpected " << (int)LastResponse.Message);
 
-                VERBOSE_COUT(" Sending TEvVPut to " << vDiskId->ToString() << " blob " << logoblobid.ToString()); 
+                VERBOSE_COUT(" Sending TEvVPut to " << vDiskId->ToString() << " blob " << logoblobid.ToString());
 
                 NKikimr::TDataPartSet partSet;
-                BsInfo->Type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedTestData, partSet); 
+                BsInfo->Type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedTestData, partSet);
 
                 TAutoPtr<TEvBlobStorage::TEvVPut> vPut(
-                        new TEvBlobStorage::TEvVPut(logoblobid, partSet.Parts[parametrs.PartId-1].OwnedString, *vDiskId, 
-                            false, nullptr, TInstant::Max(), NKikimrBlobStorage::AsyncBlob)); 
-                ctx.Send(Env->VDisks[realVDiskIdx], vPut.Release()); 
+                        new TEvBlobStorage::TEvVPut(logoblobid, partSet.Parts[parametrs.PartId-1].OwnedString, *vDiskId,
+                            false, nullptr, TInstant::Max(), NKikimrBlobStorage::AsyncBlob));
+                ctx.Send(Env->VDisks[realVDiskIdx], vPut.Release());
                 break;
             }
             case 10:
@@ -1634,7 +1634,7 @@ private:
                 TEST_RESPONSE(MessageVPutResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -1645,12 +1645,12 @@ private:
     }
 public:
     TTestBlobStorageProxyVPut(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
-template <int vDiskIdx, int partId, bool &isNoData> 
+template <int vDiskIdx, int partId, bool &isNoData>
 class TTestBlobStorageProxyVGet : public TTestBlobStorageProxy {
     void TestFSM(const TActorContext &ctx) {
         VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__);
@@ -1699,13 +1699,13 @@ class TTestBlobStorageProxyVGet : public TTestBlobStorageProxy {
                                                                                          {id});
                                 ctx.Send(Env->VDisks[vDiskIdx], x.release());
                                 break;
-                            } else if (LastResponse.ItemStatus[0] == NKikimrProto::NODATA) { 
-                                isNoData = true; 
-                                VERBOSE_COUT("Done"); 
-                                Env->DoneEvent.Signal(); 
-                                break; 
-                            } else if (LastResponse.ItemStatus[0] != NKikimrProto::OK) { 
-                                UNIT_ASSERT(false); 
+                            } else if (LastResponse.ItemStatus[0] == NKikimrProto::NODATA) {
+                                isNoData = true;
+                                VERBOSE_COUT("Done");
+                                Env->DoneEvent.Signal();
+                                break;
+                            } else if (LastResponse.ItemStatus[0] != NKikimrProto::OK) {
+                                UNIT_ASSERT(false);
                             }
                         }
                     }
@@ -1715,9 +1715,9 @@ class TTestBlobStorageProxyVGet : public TTestBlobStorageProxy {
                 type.SplitData((TErasureType::ECrcMode)blobId.CrcMode(), encryptedTestData2, partSet);
                 TEST_RESPONSE(MessageVGetResult, OK, 1, partSet.Parts[0].OwnedString);
 
-                isNoData = false; 
+                isNoData = false;
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -1728,8 +1728,8 @@ class TTestBlobStorageProxyVGet : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyVGet(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1785,7 +1785,7 @@ class TTestBlobStorageProxyVGetFail : public TTestBlobStorageProxy {
                     ctx.Send(Env->VDisks[vDiskIdx], x.release());
                 } else {
                     VERBOSE_COUT("Done");
-                    Env->DoneEvent.Signal(); 
+                    Env->DoneEvent.Signal();
                 }
             }
                 break;
@@ -1804,7 +1804,7 @@ class TTestBlobStorageProxyVGetFail : public TTestBlobStorageProxy {
                 }
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
             }
                 break;
             default:
@@ -1815,8 +1815,8 @@ class TTestBlobStorageProxyVGetFail : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyVGetFail(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1840,7 +1840,7 @@ class TTestBlobStorageProxyVBlockVPutVGet : public TTestBlobStorageProxy {
                 msgId.SetMsgId(0);
                 msgId.SetSequenceId(1);
 
-                ctx.Send(Env->VDisks[0], x.Release()); 
+                ctx.Send(Env->VDisks[0], x.Release());
                 break;
             }
             case 10:
@@ -1860,7 +1860,7 @@ class TTestBlobStorageProxyVBlockVPutVGet : public TTestBlobStorageProxy {
                 msgId.SetMsgId(0);
                 msgId.SetSequenceId(1);
 
-                ctx.Send(Env->VDisks[0], x.Release()); 
+                ctx.Send(Env->VDisks[0], x.Release());
                 break;
             }
             case 20:
@@ -1888,7 +1888,7 @@ class TTestBlobStorageProxyVBlockVPutVGet : public TTestBlobStorageProxy {
             {
                 TEST_RESPONSE(MessageVGetResult, OK, 1, "");
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -1899,8 +1899,8 @@ class TTestBlobStorageProxyVBlockVPutVGet : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyVBlockVPutVGet(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1928,7 +1928,7 @@ class TTestBlobStorageProxyGarbageMark : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageCollectGarbageResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -1938,8 +1938,8 @@ class TTestBlobStorageProxyGarbageMark : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyGarbageMark(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1965,7 +1965,7 @@ class TTestBlobStorageProxyGarbageUnmark : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageCollectGarbageResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -1975,8 +1975,8 @@ class TTestBlobStorageProxyGarbageUnmark : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyGarbageUnmark(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -1998,7 +1998,7 @@ class TTestBlobStorageProxyGarbageCollect : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageCollectGarbageResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2008,8 +2008,8 @@ class TTestBlobStorageProxyGarbageCollect : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyGarbageCollect(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2045,7 +2045,7 @@ class TTestBlobStorageProxyGarbageCollectHuge : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageCollectGarbageResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2055,8 +2055,8 @@ class TTestBlobStorageProxyGarbageCollectHuge : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyGarbageCollectHuge(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2088,7 +2088,7 @@ class TTestBlobStorageProxyEmptyGet : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessagePutResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2098,8 +2098,8 @@ class TTestBlobStorageProxyEmptyGet : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyEmptyGet(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2220,7 +2220,7 @@ class TTestBlobStorageProxyGarbageCollectComplex : public TTestBlobStorageProxy
                 TEST_RESPONSE(MessageCollectGarbageResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -2231,9 +2231,9 @@ class TTestBlobStorageProxyGarbageCollectComplex : public TTestBlobStorageProxy
     }
 public:
     TTestBlobStorageProxyGarbageCollectComplex(const TActorId &proxy,
-            const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo, 
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2284,7 +2284,7 @@ class TTestBlobStorageProxyGarbageCollectAfterLargeData : public TTestBlobStorag
                 TEST_RESPONSE(MessageCollectGarbageResult, OK, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -2297,9 +2297,9 @@ class TTestBlobStorageProxyGarbageCollectAfterLargeData : public TTestBlobStorag
     }
 public:
     TTestBlobStorageProxyGarbageCollectAfterLargeData(const TActorId &proxy,
-            const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo, 
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2349,7 +2349,7 @@ class TTestBlobStorageProxySimpleDiscover : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageDiscoverResult, OK, 1, testData2);
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2359,8 +2359,8 @@ class TTestBlobStorageProxySimpleDiscover : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxySimpleDiscover(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2405,7 +2405,7 @@ class TTestBlobStorageProxyDiscover : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageDiscoverResult, OK, 1, testData2);
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2415,8 +2415,8 @@ class TTestBlobStorageProxyDiscover : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyDiscover(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2441,7 +2441,7 @@ class TTestBlobStorageProxyDiscoverFail : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageDiscoverResult, ERROR, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2451,8 +2451,8 @@ class TTestBlobStorageProxyDiscoverFail : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyDiscoverFail(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2477,7 +2477,7 @@ class TTestBlobStorageProxyDiscoverEmpty : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageDiscoverResult, NODATA, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2487,8 +2487,8 @@ class TTestBlobStorageProxyDiscoverEmpty : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyDiscoverEmpty(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2513,7 +2513,7 @@ class TTestBlobStorageProxyDiscoverTimeout : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageDiscoverResult, TIMEOUT, 0, "");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2523,8 +2523,8 @@ class TTestBlobStorageProxyDiscoverTimeout : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyDiscoverTimeout(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2605,7 +2605,7 @@ class TTestBlobStorageProxyLongTailDiscoverPut : public TTestBlobStorageProxy {
                     partIdx = 0;
                 }
 
-                ui32 vDiskIdx = vDiskId.FailDomain * BsInfo->GetNumVDisksPerFailDomain() + vDiskId.VDisk; 
+                ui32 vDiskIdx = vDiskId.FailDomain * BsInfo->GetNumVDisksPerFailDomain() + vDiskId.VDisk;
 
                 TLogoBlobID from(1, 0, 2 + Iteration/*step*/, 0, testData3.size(), cookie, partIdx + 1);
                 VERBOSE_COUT(" Sending TEvVPut partId# " << (partIdx + 1) << " cookie# " << cookie);
@@ -2617,7 +2617,7 @@ class TTestBlobStorageProxyLongTailDiscoverPut : public TTestBlobStorageProxy {
                 msgId.SetMsgId(MsgIdx);
                 msgId.SetSequenceId(9990);
                 ++MsgIdx;
-                ctx.Send(Env->VDisks[vDiskIdx], vPut.Release()); 
+                ctx.Send(Env->VDisks[vDiskIdx], vPut.Release());
                 ++Iteration;
                 if (Iteration < 100) {
                     return;
@@ -2655,8 +2655,8 @@ class TTestBlobStorageProxyLongTailDiscoverPut : public TTestBlobStorageProxy {
                 msgId.SetMsgId(MsgIdx);
                 msgId.SetSequenceId(9990);
                 ++MsgIdx;
-                ui32 vDiskIdx = vDiskId.FailDomain * BsInfo->GetNumVDisksPerFailDomain() + vDiskId.VDisk; 
-                ctx.Send(Env->VDisks[vDiskIdx], vPut.Release()); 
+                ui32 vDiskIdx = vDiskId.FailDomain * BsInfo->GetNumVDisksPerFailDomain() + vDiskId.VDisk;
+                ctx.Send(Env->VDisks[vDiskIdx], vPut.Release());
                 ++Iteration;
                 if (Iteration < 200) {
                     return;
@@ -2666,7 +2666,7 @@ class TTestBlobStorageProxyLongTailDiscoverPut : public TTestBlobStorageProxy {
             case 60:
                 TEST_RESPONSE(MessageVPutResult, OK, 0, "");
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2676,8 +2676,8 @@ class TTestBlobStorageProxyLongTailDiscoverPut : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyLongTailDiscoverPut(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
         , MsgIdx(0)
         , Iteration(0)
     {}
@@ -2711,7 +2711,7 @@ class TTestBlobStorageProxyLongTailDiscover : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageDiscoverResult, OK, 1, testData2);
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2721,8 +2721,8 @@ class TTestBlobStorageProxyLongTailDiscover : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyLongTailDiscover(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2765,7 +2765,7 @@ class TTestBlobStorageProxyPartialGet : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageGetResult, OK, 1, TString(testData, 7, testData.size() - 7));
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2775,8 +2775,8 @@ class TTestBlobStorageProxyPartialGet : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyPartialGet(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2799,7 +2799,7 @@ class TTestEmptyRange : public TTestBlobStorageProxy {
             case 10:
                 TEST_RESPONSE(MessageRangeResult, OK, 0, "");
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -2809,8 +2809,8 @@ class TTestEmptyRange : public TTestBlobStorageProxy {
     }
 public:
     TTestEmptyRange(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -2852,7 +2852,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             }
             case 10:
             {
-                if (!Env->ShouldBeUnwritable) { 
+                if (!Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessageGetResult, OK, 1, "");
                 }
                 // Put.
@@ -2863,7 +2863,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             }
             case 20:
             {
-                if (Env->ShouldBeUnwritable) { 
+                if (Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessagePutResult, ERROR, 0, "");
                 } else {
                     TEST_RESPONSE(MessagePutResult, OK, 0, "");
@@ -2883,11 +2883,11 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             case 60:
             {
                 if (isFirstFallthrough) {
-                    if (!Env->ShouldBeUnwritable) { 
+                    if (!Env->ShouldBeUnwritable) {
                         TEST_RESPONSE(MessageGetResult, OK, 1, testData);
                     }
                 } else {
-                    if (Env->ShouldBeUnwritable) { 
+                    if (Env->ShouldBeUnwritable) {
                         TEST_RESPONSE(MessagePutResult, ERROR, 0, "");
                     } else {
                         TEST_RESPONSE(MessagePutResult, OK, 0, "");
@@ -2909,13 +2909,13 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             {
                 ui32 iteration = (TestStep - 70)/10;
                 if (isFirstFallthrough) {
-                    if (Env->ShouldBeUnwritable) { 
+                    if (Env->ShouldBeUnwritable) {
                         TEST_RESPONSE(MessagePutResult, ERROR, 0, "");
                     } else {
                         TEST_RESPONSE(MessagePutResult, OK, 0, "");
                     }
                 } else {
-                    if (!Env->ShouldBeUnwritable) { 
+                    if (!Env->ShouldBeUnwritable) {
                         TEST_RESPONSE(MessageGetResult, OK, 1, testData);
                     }
                 }
@@ -2928,7 +2928,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             }
             case 110:
             {
-                if (!Env->ShouldBeUnwritable) { 
+                if (!Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessageGetResult, OK, 1, testData);
                 }
                 // Get range.
@@ -2940,7 +2940,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             }
             case 120:
             {
-                if (!Env->ShouldBeUnwritable) { 
+                if (!Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessageRangeResult, OK, 1, testData);
                 }
                 // Get range.
@@ -2952,7 +2952,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             }
             case 130:
             {
-                if (!Env->ShouldBeUnwritable) { 
+                if (!Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessageRangeResult, OK, 4, testData);
                     for (int i = 0; i < 4; ++i) {
                         if (LastResponse.Data[i] != testData) {
@@ -2971,7 +2971,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             }
             case 140:
             {
-                if (!Env->ShouldBeUnwritable) { 
+                if (!Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessageRangeResult, OK, 4, testData);
                     for (int i = 0; i < 4; ++i) {
                         if (LastResponse.Data[i] != testData) {
@@ -2990,7 +2990,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             }
             case 150:
             {
-                if (!Env->ShouldBeUnwritable) { 
+                if (!Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessageRangeResult, OK, 0, "");
                 }
                 // Get range.
@@ -3009,7 +3009,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             {
                 ui32 iteration = (TestStep - 160)/10;
                 if (isFirstFallthrough) {
-                    if (!Env->ShouldBeUnwritable) { 
+                    if (!Env->ShouldBeUnwritable) {
                         TEST_RESPONSE(MessageRangeResult, OK, 1, testData);
                     }
                 } else {
@@ -3018,7 +3018,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 }
                 // Get 1 part
                 ui32 domains = BsInfo->GetTotalFailDomainsNum();
-                ui32 drives = Env->VDiskCount / domains; 
+                ui32 drives = Env->VDiskCount / domains;
                 ui32 domainIdx = iteration / drives;
                 ui32 driveIdx = iteration - domainIdx * drives;
 
@@ -3049,7 +3049,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
             }
             case 210:
             {
-                if (!Env->ShouldBeUnwritable) { 
+                if (!Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessageGetResult, OK, 1, TString(testData, 7, 11));
                 }
                 // Put.
@@ -3059,7 +3059,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 break;
             }
             case 220:
-                if (Env->ShouldBeUnwritable) { 
+                if (Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessagePutResult, ERROR, 0, "");
                 } else {
                     TEST_RESPONSE(MessagePutResult, OK, 0, "");
@@ -3068,7 +3068,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 ctx.Send(Proxy, new TEvBlobStorage::TEvDiscover(1, 0, true, false, TInstant::Max(), 0));
                 break;
             case 230:
-                if (Env->ShouldBeUndiscoverable) { 
+                if (Env->ShouldBeUndiscoverable) {
                     TEST_RESPONSE(MessageDiscoverResult, ERROR, 0, nullptr);
                 } else {
                     TEST_RESPONSE(MessageDiscoverResult, OK, 1, testData2);
@@ -3077,7 +3077,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 ctx.Send(Proxy, new TEvBlobStorage::TEvDiscover(1, 0, false, false, TInstant::Max(), 0));
                 break;
             case 240:
-                if (Env->ShouldBeUndiscoverable) { 
+                if (Env->ShouldBeUndiscoverable) {
                     TEST_RESPONSE(MessageDiscoverResult, ERROR, 0, 0);
                 } else {
                     TEST_RESPONSE(MessageDiscoverResult, OK, 1, "");
@@ -3086,7 +3086,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 ctx.Send(Proxy, new TEvBlobStorage::TEvDiscover(2/*tabletId*/, 0, true, false, TInstant::Max(), 0));
                 break;
             case 250:
-                if (Env->ShouldBeUndiscoverable) { 
+                if (Env->ShouldBeUndiscoverable) {
                     TEST_RESPONSE(MessageDiscoverResult, ERROR, 0, 0);
                 } else {
                     TEST_RESPONSE(MessageDiscoverResult, NODATA, 0, "");
@@ -3095,7 +3095,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 ctx.Send(Proxy, new TEvBlobStorage::TEvDiscover(1, 0, true, true, TInstant::Max(), 0));
                 break;
             case 260:
-                if (Env->ShouldBeUndiscoverable) { 
+                if (Env->ShouldBeUndiscoverable) {
                     TEST_RESPONSE(MessageDiscoverResult, ERROR, 0, 0);
                 } else {
                     TEST_RESPONSE(MessageDiscoverResult, OK, 1, testData2);
@@ -3104,7 +3104,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 ctx.Send(Proxy, new TEvBlobStorage::TEvDiscover(1, 0, false, true, TInstant::Max(), 0));
                 break;
             case 270:
-                if (Env->ShouldBeUndiscoverable) { 
+                if (Env->ShouldBeUndiscoverable) {
                     TEST_RESPONSE(MessageDiscoverResult, ERROR, 0, 0);
                 } else {
                     TEST_RESPONSE(MessageDiscoverResult, OK, 1, "");
@@ -3114,7 +3114,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 break;
             case 280:
             {
-                if (Env->ShouldBeUndiscoverable) { 
+                if (Env->ShouldBeUndiscoverable) {
                     TEST_RESPONSE(MessageDiscoverResult, ERROR, 0, 0);
                 } else {
                     TEST_RESPONSE(MessageDiscoverResult, NODATA, 0, "");
@@ -3128,7 +3128,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                 break;
             }
             case 290:
-                if (Env->ShouldBeUnwritable) { 
+                if (Env->ShouldBeUnwritable) {
                     TEST_RESPONSE(MessagePutResult, ERROR, 0, "");
                 } else {
                     TEST_RESPONSE(MessagePutResult, OK, 0, "");
@@ -3146,7 +3146,7 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
                     VERBOSE_COUT(LastResponse.Profile);
                 }
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             default:
                 ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
@@ -3156,8 +3156,8 @@ class TTestBlobStorageProxyBasic1 : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyBasic1(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -3192,7 +3192,7 @@ class TTestGetMultipart : public TTestBlobStorageProxy {
                     "Got '" << LastResponse.Data[1] << "' instead of '" << p2 << "'");
 
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -3203,8 +3203,8 @@ class TTestGetMultipart : public TTestBlobStorageProxy {
     }
 public:
     TTestGetMultipart(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -3219,7 +3219,7 @@ class TTestVDiskCompacted : public TTestBlobStorageProxy {
                 TAutoPtr<TEvBlobStorage::TEvVCompact> vCompact(new TEvBlobStorage::TEvVCompact(
                     vDiskId, NKikimrBlobStorage::TEvVCompact::ASYNC));
                 VERBOSE_COUT("Sending EvVCompact to vDiskIdx: " << vDiskIdx);
-                ctx.Send(Env->VDisks[vDiskIdx], vCompact.Release()); 
+                ctx.Send(Env->VDisks[vDiskIdx], vCompact.Release());
                 break;
             }
             case 10:
@@ -3228,7 +3228,7 @@ class TTestVDiskCompacted : public TTestBlobStorageProxy {
                 TVDiskID vDiskId(0, 1, 0, vDiskIdx , 0);
                 TAutoPtr<TEvBlobStorage::TEvVStatus> vStatus(new TEvBlobStorage::TEvVStatus(vDiskId));
                 VERBOSE_COUT("Sending EvVStatus to vDiskIdx: " << vDiskIdx);
-                ctx.Send(Env->VDisks[vDiskIdx], vStatus.Release()); 
+                ctx.Send(Env->VDisks[vDiskIdx], vStatus.Release());
                 break;
             }
             case 20:
@@ -3236,14 +3236,14 @@ class TTestVDiskCompacted : public TTestBlobStorageProxy {
                 TEST_RESPONSE(MessageVStatusResult, OK, 0, "");
                 if (LastResponse.LogoBlobsCompacted) {
                     VERBOSE_COUT("Done");
-                    Env->DoneEvent.Signal(); 
+                    Env->DoneEvent.Signal();
                     break;
                 }
                 Sleep(TDuration::MilliSeconds(50));
                 TVDiskID vDiskId(0, 1, 0, vDiskIdx , 0);
                 TAutoPtr<TEvBlobStorage::TEvVStatus> vStatus(new TEvBlobStorage::TEvVStatus(vDiskId));
                 VERBOSE_COUT("Sending EvVStatus to vDiskIdx: " << vDiskIdx);
-                ctx.Send(Env->VDisks[vDiskIdx], vStatus.Release()); 
+                ctx.Send(Env->VDisks[vDiskIdx], vStatus.Release());
                 return;
             }
             default:
@@ -3254,8 +3254,8 @@ class TTestVDiskCompacted : public TTestBlobStorageProxy {
     }
 public:
     TTestVDiskCompacted(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
@@ -3281,7 +3281,7 @@ class TTestBlobStorageProxyVPutVCollectVGetRace : public TTestBlobStorageProxy {
                 msgId.SetMsgId(0);
                 msgId.SetSequenceId(1);
 
-                ctx.Send(Env->VDisks[0], x.Release()); 
+                ctx.Send(Env->VDisks[0], x.Release());
                 break;
             }
             case 10:
@@ -3327,7 +3327,7 @@ class TTestBlobStorageProxyVPutVCollectVGetRace : public TTestBlobStorageProxy {
             {
                 TEST_RESPONSE(MessageVGetResult, OK, 1, testData);
                 VERBOSE_COUT("Done");
-                Env->DoneEvent.Signal(); 
+                Env->DoneEvent.Signal();
                 break;
             }
             default:
@@ -3338,113 +3338,113 @@ class TTestBlobStorageProxyVPutVCollectVGetRace : public TTestBlobStorageProxy {
     }
 public:
     TTestBlobStorageProxyVPutVCollectVGetRace(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
+    {}
+};
+
+TMaybe<TGroupStat::EKind> PutHandleClassToGroupStatKind(NKikimrBlobStorage::EPutHandleClass handleClass) {
+    switch (handleClass) {
+    case NKikimrBlobStorage::TabletLog:
+        return  TGroupStat::EKind::PUT_TABLET_LOG;
+
+    case NKikimrBlobStorage::UserData:
+        return TGroupStat::EKind::PUT_USER_DATA;
+
+    default:
+        return {};
+    }
+}
+
+class TTestBlobStorageProxyForRequest : public TTestBlobStorageProxy {
+protected:
+    void TestFSM(const TActorContext &ctx) override {
+        if (!TestStep) {
+            TIntrusivePtr<TDsProxyNodeMon> nodeMon = new TDsProxyNodeMon(NKikimr::AppData(ctx)->Counters, true);
+            TString name = Sprintf("%09" PRIu32, 0);
+            TIntrusivePtr<NMonitoring::TDynamicCounters> group = GetServiceCounters(
+                NKikimr::AppData(ctx)->Counters, "dsproxy")->GetSubgroup("blobstorageproxy", name);
+            TIntrusivePtr<NMonitoring::TDynamicCounters> percentileGroup = GetServiceCounters(
+                    NKikimr::AppData(ctx)->Counters, "dsproxy_percentile")->GetSubgroup("blobstorageproxy", name);
+            TIntrusivePtr<NMonitoring::TDynamicCounters> overviewGroup = GetServiceCounters(
+                    NKikimr::AppData(ctx)->Counters, "dsproxy_overview");
+            Mon = new TBlobStorageGroupProxyMon(group, percentileGroup, overviewGroup, BsInfo, nodeMon, false);
+
+            TIntrusivePtr<NMonitoring::TDynamicCounters> DynCounters = new NMonitoring::TDynamicCounters();
+            StoragePoolCounters = new NKikimr::TStoragePoolCounters(DynCounters, "", {});
+            PerDiskStatsPtr = new TDiskResponsivenessTracker::TPerDiskStats;
+        }
+    }
+
+    TIntrusivePtr<TBlobStorageGroupProxyMon> Mon;
+    TIntrusivePtr<NKikimr::TStoragePoolCounters> StoragePoolCounters;
+    TDiskResponsivenessTracker::TPerDiskStatsPtr PerDiskStatsPtr;
+
+    TTestBlobStorageProxyForRequest(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs)
     {}
 };
 
-TMaybe<TGroupStat::EKind> PutHandleClassToGroupStatKind(NKikimrBlobStorage::EPutHandleClass handleClass) { 
-    switch (handleClass) { 
-    case NKikimrBlobStorage::TabletLog: 
-        return  TGroupStat::EKind::PUT_TABLET_LOG; 
- 
-    case NKikimrBlobStorage::UserData: 
-        return TGroupStat::EKind::PUT_USER_DATA; 
- 
-    default: 
-        return {}; 
-    } 
-} 
- 
-class TTestBlobStorageProxyForRequest : public TTestBlobStorageProxy { 
-protected: 
-    void TestFSM(const TActorContext &ctx) override { 
-        if (!TestStep) { 
-            TIntrusivePtr<TDsProxyNodeMon> nodeMon = new TDsProxyNodeMon(NKikimr::AppData(ctx)->Counters, true); 
-            TString name = Sprintf("%09" PRIu32, 0); 
-            TIntrusivePtr<NMonitoring::TDynamicCounters> group = GetServiceCounters( 
-                NKikimr::AppData(ctx)->Counters, "dsproxy")->GetSubgroup("blobstorageproxy", name); 
-            TIntrusivePtr<NMonitoring::TDynamicCounters> percentileGroup = GetServiceCounters( 
-                    NKikimr::AppData(ctx)->Counters, "dsproxy_percentile")->GetSubgroup("blobstorageproxy", name); 
-            TIntrusivePtr<NMonitoring::TDynamicCounters> overviewGroup = GetServiceCounters( 
-                    NKikimr::AppData(ctx)->Counters, "dsproxy_overview"); 
-            Mon = new TBlobStorageGroupProxyMon(group, percentileGroup, overviewGroup, BsInfo, nodeMon, false); 
- 
-            TIntrusivePtr<NMonitoring::TDynamicCounters> DynCounters = new NMonitoring::TDynamicCounters(); 
-            StoragePoolCounters = new NKikimr::TStoragePoolCounters(DynCounters, "", {}); 
-            PerDiskStatsPtr = new TDiskResponsivenessTracker::TPerDiskStats; 
-        } 
-    } 
- 
-    TIntrusivePtr<TBlobStorageGroupProxyMon> Mon; 
-    TIntrusivePtr<NKikimr::TStoragePoolCounters> StoragePoolCounters; 
-    TDiskResponsivenessTracker::TPerDiskStatsPtr PerDiskStatsPtr; 
- 
-    TTestBlobStorageProxyForRequest(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo, 
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxy(proxy, bsInfo, env, parametrs) 
-    {} 
-}; 
- 
-class TTestBlobStorageProxyBatchedPutRequestDoesNotContainAHugeBlob : public TTestBlobStorageProxyForRequest { 
-    void TestFSM(const TActorContext &ctx) { 
-        TTestBlobStorageProxyForRequest::TestFSM(ctx); 
- 
-        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__); 
-        TVector<TLogoBlobID> blobIds = { 
-            TLogoBlobID(72075186224047637, 1, 863, 1, Data1.size(), 24576), 
-            TLogoBlobID(72075186224047637, 1, 2194, 1, Data2.size(), 12288) 
-        }; 
- 
-        switch (TestStep) { 
-            case 0: { 
-                TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched(2); 
-                batched[0] = GetPut(blobIds[0], Data1); 
-                batched[1] = GetPut(blobIds[1], Data2); 
- 
-                TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(HandleClass); 
+class TTestBlobStorageProxyBatchedPutRequestDoesNotContainAHugeBlob : public TTestBlobStorageProxyForRequest {
+    void TestFSM(const TActorContext &ctx) {
+        TTestBlobStorageProxyForRequest::TestFSM(ctx);
+
+        VERBOSE_COUT("Test step " << TestStep << " Line " << __LINE__);
+        TVector<TLogoBlobID> blobIds = {
+            TLogoBlobID(72075186224047637, 1, 863, 1, Data1.size(), 24576),
+            TLogoBlobID(72075186224047637, 1, 2194, 1, Data2.size(), 12288)
+        };
+
+        switch (TestStep) {
+            case 0: {
+                TBatchedVec<TEvBlobStorage::TEvPut::TPtr> batched(2);
+                batched[0] = GetPut(blobIds[0], Data1);
+                batched[1] = GetPut(blobIds[1], Data2);
+
+                TMaybe<TGroupStat::EKind> kind = PutHandleClassToGroupStatKind(HandleClass);
                 IActor *reqActor = CreateBlobStorageGroupPutRequest(BsInfo, GroupQueues,
-                        Mon, batched, false, PerDiskStatsPtr, kind,TInstant::Now(), 
-                        StoragePoolCounters, HandleClass, Tactic, false); 
- 
-                ctx.Register(reqActor); 
-                break; 
-            } 
-            case 10: 
-                TEST_RESPONSE(MessagePutResult, OK, 0, ""); 
-                break; 
-            case 20: 
-                TEST_RESPONSE(MessagePutResult, OK, 0, ""); 
-                VERBOSE_COUT("Done"); 
-                Env->DoneEvent.Signal(); 
-                break; 
-            default: 
-                ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl; 
-                break; 
-        } 
-        TestStep += 10; 
-    } 
- 
-    TEvBlobStorage::TEvPut::TPtr GetPut(TLogoBlobID id, const TString &data) { 
+                        Mon, batched, false, PerDiskStatsPtr, kind,TInstant::Now(),
+                        StoragePoolCounters, HandleClass, Tactic, false);
+
+                ctx.Register(reqActor);
+                break;
+            }
+            case 10:
+                TEST_RESPONSE(MessagePutResult, OK, 0, "");
+                break;
+            case 20:
+                TEST_RESPONSE(MessagePutResult, OK, 0, "");
+                VERBOSE_COUT("Done");
+                Env->DoneEvent.Signal();
+                break;
+            default:
+                ythrow TWithBackTrace<yexception>() << "Unexpected TestStep " << TestStep << Endl;
+                break;
+        }
+        TestStep += 10;
+    }
+
+    TEvBlobStorage::TEvPut::TPtr GetPut(TLogoBlobID id, const TString &data) {
         std::unique_ptr<TEvBlobStorage::TEvPut> put = std::make_unique<TEvBlobStorage::TEvPut>(id, data,
-                TInstant::Max(), HandleClass, Tactic); 
+                TInstant::Max(), HandleClass, Tactic);
         return static_cast<TEventHandle<TEvBlobStorage::TEvPut>*>(new IEventHandle(SelfId(), SelfId(), put.release()));
-    } 
- 
-    TEvBlobStorage::TEvPut::ETactic Tactic = TEvBlobStorage::TEvPut::TacticDefault; 
-    NKikimrBlobStorage::EPutHandleClass HandleClass = NKikimrBlobStorage::TabletLog; 
-    TString Data1; 
-    TString Data2; 
-public: 
-    TTestBlobStorageProxyBatchedPutRequestDoesNotContainAHugeBlob(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo, 
-            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs) 
-        : TTestBlobStorageProxyForRequest(proxy, bsInfo, env, parametrs) 
-    { 
-        Data1.resize(MaxBatchedPutSize - 1, 'a'); 
-        Data2.resize(1, 'a'); 
-    } 
-}; 
- 
+    }
+
+    TEvBlobStorage::TEvPut::ETactic Tactic = TEvBlobStorage::TEvPut::TacticDefault;
+    NKikimrBlobStorage::EPutHandleClass HandleClass = NKikimrBlobStorage::TabletLog;
+    TString Data1;
+    TString Data2;
+public:
+    TTestBlobStorageProxyBatchedPutRequestDoesNotContainAHugeBlob(const TActorId &proxy, const TIntrusivePtr<TBlobStorageGroupInfo> &bsInfo,
+            const TIntrusivePtr<TTestEnvironment> &env, const TIntrusivePtr<ITestParametrs> &parametrs)
+        : TTestBlobStorageProxyForRequest(proxy, bsInfo, env, parametrs)
+    {
+        Data1.resize(MaxBatchedPutSize - 1, 'a');
+        Data2.resize(1, 'a');
+    }
+};
+
 #define PROXY_UNIT_TEST(a) UNIT_TEST(a)
 
 class TBlobStorageProxyTest: public TTestBase {
@@ -3459,8 +3459,8 @@ class TBlobStorageProxyTest: public TTestBase {
         PROXY_UNIT_TEST(TestPartialGetMirror);
         PROXY_UNIT_TEST(TestBlock);
         PROXY_UNIT_TEST(TestBlockPersistence);
-        PROXY_UNIT_TEST(TestGetAndRangeGetManyBlobs); 
-        PROXY_UNIT_TEST(TestInFlightPuts); 
+        PROXY_UNIT_TEST(TestGetAndRangeGetManyBlobs);
+        PROXY_UNIT_TEST(TestInFlightPuts);
         PROXY_UNIT_TEST(TestCollectGarbage);
         PROXY_UNIT_TEST(TestHugeCollectGarbage);
         PROXY_UNIT_TEST(TestCollectGarbageAfterLargeData);
@@ -3510,7 +3510,7 @@ class TBlobStorageProxyTest: public TTestBase {
         PROXY_UNIT_TEST(TestEmptyDiscover);
         PROXY_UNIT_TEST(TestEmptyDiscoverMaxi);
         PROXY_UNIT_TEST(TestCompactedGetMultipart);
-        PROXY_UNIT_TEST(TestBatchedPutRequestDoesNotContainAHugeBlob); 
+        PROXY_UNIT_TEST(TestBatchedPutRequestDoesNotContainAHugeBlob);
 //TODO: Think of another way to emulate VDisk errors
 //        PROXY_UNIT_TEST(TestProxyGetDoubleTimeout);
 //        PROXY_UNIT_TEST(TestProxyDiscoverDoubleTimeout);
@@ -3518,7 +3518,7 @@ class TBlobStorageProxyTest: public TTestBase {
 //        PROXY_UNIT_TEST(TestProxyPutDoubleTimeout);
     UNIT_TEST_SUITE_END();
 
-    TIntrusivePtr<TTestEnvironment> LastTestEnv; 
+    TIntrusivePtr<TTestEnvironment> LastTestEnv;
     TMap<TString, TIntrusivePtr<NPDisk::TSectorMap>> SectorMapByPath;
 public:
 
@@ -3546,13 +3546,13 @@ public:
     void TestVPutVGetPersistence() {
         TTempDir tempDir;
         TBlobStorageGroupType::EErasureSpecies erasureSpecies = TBlobStorageGroupType::Erasure3Plus1Block;
-        ui64 partId = 1; 
-        ui64 vDiskIdx = 1; 
-        TTestArgs args{0, erasureSpecies}; 
-        args.Parametrs = new TTestBlobStorageProxyVPut::TParametrs(TestData2, partId, VDIM_TestIdx, vDiskIdx); 
-        TestBlobStorage<TTestBlobStorageProxyVPut>(tempDir().c_str(), args); 
-        static bool isNoData = false; 
-        TestBlobStorage<TTestBlobStorageProxyVGet<1, 1, isNoData>>(0, erasureSpecies, tempDir().c_str()); 
+        ui64 partId = 1;
+        ui64 vDiskIdx = 1;
+        TTestArgs args{0, erasureSpecies};
+        args.Parametrs = new TTestBlobStorageProxyVPut::TParametrs(TestData2, partId, VDIM_TestIdx, vDiskIdx);
+        TestBlobStorage<TTestBlobStorageProxyVPut>(tempDir().c_str(), args);
+        static bool isNoData = false;
+        TestBlobStorage<TTestBlobStorageProxyVGet<1, 1, isNoData>>(0, erasureSpecies, tempDir().c_str());
         SectorMapByPath.clear();
     }
 
@@ -3726,43 +3726,43 @@ public:
         SectorMapByPath.clear();
     }
 
-    void TestGetAndRangeGetManyBlobs() { 
-        TTempDir tempDir; 
-        TMersenne<ui64> prng(42); 
-        TBlobStorageGroupType::EErasureSpecies erasureSpecies = TBlobStorageGroupType::Erasure4Plus2Stripe; 
- 
-        constexpr int actionCount = 17'000; 
-        constexpr int startIndx = 1; 
- 
-        static TVector<size_t> order(actionCount); 
-        Iota(order.begin(), order.end(), (size_t)startIndx); 
- 
-        // Put 
-        Shuffle(order.begin(), order.end(), prng); 
-        TestBlobStorage<TTestIterativePut<order>>(0, erasureSpecies, tempDir().c_str()); 
- 
-        // Get 
-        Shuffle(order.begin(), order.end(), prng); 
-        TestBlobStorage<TTestOrderGet<order>>(0, erasureSpecies, tempDir().c_str()); 
- 
-        order.clear(); 
- 
-        // Forward range 
-        TestBlobStorage<TTestRangeGet<startIndx, actionCount>>(0, erasureSpecies, tempDir().c_str()); 
- 
-        // Backward range 
-        TestBlobStorage<TTestRangeGet<actionCount, -actionCount>>(0, erasureSpecies, tempDir().c_str()); 
- 
-        SectorMapByPath.clear(); 
-    } 
- 
-    void TestInFlightPuts() { 
-        TTempDir tempDir; 
-        TBlobStorageGroupType::EErasureSpecies erasureSpecies = TBlobStorageGroupType::Erasure4Plus2Stripe; 
-        TestBlobStorage<TTestInFlightPuts<256, 1'000>>(0, erasureSpecies, tempDir().c_str()); 
-        SectorMapByPath.clear(); 
-    } 
- 
+    void TestGetAndRangeGetManyBlobs() {
+        TTempDir tempDir;
+        TMersenne<ui64> prng(42);
+        TBlobStorageGroupType::EErasureSpecies erasureSpecies = TBlobStorageGroupType::Erasure4Plus2Stripe;
+
+        constexpr int actionCount = 17'000;
+        constexpr int startIndx = 1;
+
+        static TVector<size_t> order(actionCount);
+        Iota(order.begin(), order.end(), (size_t)startIndx);
+
+        // Put
+        Shuffle(order.begin(), order.end(), prng);
+        TestBlobStorage<TTestIterativePut<order>>(0, erasureSpecies, tempDir().c_str());
+
+        // Get
+        Shuffle(order.begin(), order.end(), prng);
+        TestBlobStorage<TTestOrderGet<order>>(0, erasureSpecies, tempDir().c_str());
+
+        order.clear();
+
+        // Forward range
+        TestBlobStorage<TTestRangeGet<startIndx, actionCount>>(0, erasureSpecies, tempDir().c_str());
+
+        // Backward range
+        TestBlobStorage<TTestRangeGet<actionCount, -actionCount>>(0, erasureSpecies, tempDir().c_str());
+
+        SectorMapByPath.clear();
+    }
+
+    void TestInFlightPuts() {
+        TTempDir tempDir;
+        TBlobStorageGroupType::EErasureSpecies erasureSpecies = TBlobStorageGroupType::Erasure4Plus2Stripe;
+        TestBlobStorage<TTestInFlightPuts<256, 1'000>>(0, erasureSpecies, tempDir().c_str());
+        SectorMapByPath.clear();
+    }
+
     void TestHugeCollectGarbage() {
         TBlobStorageGroupType::EErasureSpecies erasureSpecies = TBlobStorageGroupType::Erasure3Plus1Block;
         TestBlobStorage<TTestBlobStorageProxyGarbageCollectHuge>(0, erasureSpecies, nullptr);
@@ -3818,33 +3818,33 @@ public:
         }
     }
 
- 
+
     template <int vDiskIdx, int partId>
     void TestProxyRestoreOnGet(TBlobStorageGroupType::EErasureSpecies erasureSpecies) {
         TTempDir tempDir;
- 
-        TBlobStorageGroupType type(erasureSpecies); 
-        TTestArgs args{0, erasureSpecies}; 
-        TIntrusivePtr<TTestBlobStorageProxyVPut::TParametrs> param = 
-                new TTestBlobStorageProxyVPut::TParametrs(TestData2, 0); 
-        args.Parametrs = param.Get(); 
- 
-        for (param->PartId = 1; param->PartId  <= type.TotalPartCount(); ++param->PartId ) { 
-            TestBlobStorage<TTestBlobStorageProxyVPut>(tempDir().c_str(), args); 
-        } 
- 
-        static bool isNoData = false; 
-        TestBlobStorage<TTestBlobStorageProxyVGet<vDiskIdx, partId, isNoData>>(0, erasureSpecies, tempDir().c_str()); 
-        if (isNoData) { 
-            SectorMapByPath.clear(); 
-            return; 
-        } 
+
+        TBlobStorageGroupType type(erasureSpecies);
+        TTestArgs args{0, erasureSpecies};
+        TIntrusivePtr<TTestBlobStorageProxyVPut::TParametrs> param =
+                new TTestBlobStorageProxyVPut::TParametrs(TestData2, 0);
+        args.Parametrs = param.Get();
+
+        for (param->PartId = 1; param->PartId  <= type.TotalPartCount(); ++param->PartId ) {
+            TestBlobStorage<TTestBlobStorageProxyVPut>(tempDir().c_str(), args);
+        }
+
+        static bool isNoData = false;
+        TestBlobStorage<TTestBlobStorageProxyVGet<vDiskIdx, partId, isNoData>>(0, erasureSpecies, tempDir().c_str());
+        if (isNoData) {
+            SectorMapByPath.clear();
+            return;
+        }
         RemoveVDiskData(vDiskIdx, tempDir());
         //TestBlobStorage<TTestBlobStorageProxyVGetFail<vDiskIdx>>(0, erasureSpecies, tempDir().c_str());
-        TestBlobStorage<TTestBlobStorageProxyGet>(0, erasureSpecies, tempDir().c_str()); 
+        TestBlobStorage<TTestBlobStorageProxyGet>(0, erasureSpecies, tempDir().c_str());
 
         // Hands here
-        TestBlobStorage<TTestBlobStorageProxyVGet<vDiskIdx, partId, isNoData>>(0, erasureSpecies, tempDir().c_str()); 
+        TestBlobStorage<TTestBlobStorageProxyVGet<vDiskIdx, partId, isNoData>>(0, erasureSpecies, tempDir().c_str());
         SectorMapByPath.clear();
     }
 
@@ -3860,10 +3860,10 @@ public:
         TestBlobStorage<TTestBlobStorageProxyVGetFail<handoffVDiskIdx>>(badDiskMask, erasureSpecies,
             tempDir().c_str());
         TestBlobStorage<TTestBlobStorageProxyDiscover>(badDiskMask, erasureSpecies, tempDir().c_str());
-        static bool isNoData = false; 
-        TestBlobStorage<TTestBlobStorageProxyVGet<handoffVDiskIdx, 1, isNoData>>(badDiskMask, erasureSpecies, 
+        static bool isNoData = false;
+        TestBlobStorage<TTestBlobStorageProxyVGet<handoffVDiskIdx, 1, isNoData>>(badDiskMask, erasureSpecies,
             tempDir().c_str());
-        UNIT_ASSERT(!isNoData); 
+        UNIT_ASSERT(!isNoData);
         TestBlobStorage<TTestBlobStorageProxyBlockCheck>(badDiskMask, erasureSpecies, tempDir().c_str());
         SectorMapByPath.clear();
     }
@@ -4044,72 +4044,72 @@ public:
         SectorMapByPath.clear();
     }
 
-    void TestBatchedPutRequestDoesNotContainAHugeBlob() { 
-        TTestArgs args{0, TBlobStorageGroupType::ErasureNone}; 
-        args.DeviceType = TPDiskCategory::DEVICE_TYPE_NVME; 
-        TestBlobStorage<TTestBlobStorageProxyBatchedPutRequestDoesNotContainAHugeBlob>(nullptr, args); 
-        SectorMapByPath.clear(); 
+    void TestBatchedPutRequestDoesNotContainAHugeBlob() {
+        TTestArgs args{0, TBlobStorageGroupType::ErasureNone};
+        args.DeviceType = TPDiskCategory::DEVICE_TYPE_NVME;
+        TestBlobStorage<TTestBlobStorageProxyBatchedPutRequestDoesNotContainAHugeBlob>(nullptr, args);
+        SectorMapByPath.clear();
     }
 
     THolder<TActorSystemSetup> BuildActorSystemSetup(ui32 nodeId, NMonitoring::TDynamicCounters &counters,
             TIntrusivePtr<TTableNameserverSetup> &nameserverTable, TInterconnectMock &interconnectMock) {
-        auto setup = MakeHolder<TActorSystemSetup>(); 
-        setup->NodeId = nodeId; 
-        setup->ExecutorsCount = 4; 
-        setup->Executors.Reset(new TAutoPtr<IExecutorPool>[4]); 
-#if RT_EXECUTOR_POOL 
-        setup->Executors[0].Reset(new TRtExecutorPool(0, 1)); 
-        setup->Executors[1].Reset(new TRtExecutorPool(1, 2)); 
-        setup->Executors[2].Reset(new TRtExecutorPool(2, 10)); 
-        setup->Executors[3].Reset(new TRtExecutorPool(3, 2)); 
-#else 
-        setup->Executors[0].Reset(new TBasicExecutorPool(0, 1, 20)); 
-        setup->Executors[1].Reset(new TBasicExecutorPool(1, 2, 20)); 
-        setup->Executors[2].Reset(new TIOExecutorPool(2, 10)); 
-        setup->Executors[3].Reset(new TBasicExecutorPool(3, 2, 20)); 
-#endif 
-        setup->Scheduler.Reset(new TBasicSchedulerThread(TSchedulerConfig(512, 100))); 
+        auto setup = MakeHolder<TActorSystemSetup>();
+        setup->NodeId = nodeId;
+        setup->ExecutorsCount = 4;
+        setup->Executors.Reset(new TAutoPtr<IExecutorPool>[4]);
+#if RT_EXECUTOR_POOL
+        setup->Executors[0].Reset(new TRtExecutorPool(0, 1));
+        setup->Executors[1].Reset(new TRtExecutorPool(1, 2));
+        setup->Executors[2].Reset(new TRtExecutorPool(2, 10));
+        setup->Executors[3].Reset(new TRtExecutorPool(3, 2));
+#else
+        setup->Executors[0].Reset(new TBasicExecutorPool(0, 1, 20));
+        setup->Executors[1].Reset(new TBasicExecutorPool(1, 2, 20));
+        setup->Executors[2].Reset(new TIOExecutorPool(2, 10));
+        setup->Executors[3].Reset(new TBasicExecutorPool(3, 2, 20));
+#endif
+        setup->Scheduler.Reset(new TBasicSchedulerThread(TSchedulerConfig(512, 100)));
 
         setup->LocalServices.emplace_back(MakePollerActorId(), TActorSetupCmd(CreatePollerActor(), TMailboxType::ReadAsFilled, 0));
- 
-        ui64 nodeCount = nameserverTable->StaticNodeTable.size() + 1; 
-        setup->LocalServices.emplace_back( 
+
+        ui64 nodeCount = nameserverTable->StaticNodeTable.size() + 1;
+        setup->LocalServices.emplace_back(
             GetNameserviceActorId(),
-            TActorSetupCmd(CreateNameserverTable(nameserverTable), TMailboxType::ReadAsFilled, 0) 
-        ); 
-        TIntrusivePtr<TInterconnectProxyCommon> icCommon = new TInterconnectProxyCommon(); 
+            TActorSetupCmd(CreateNameserverTable(nameserverTable), TMailboxType::ReadAsFilled, 0)
+        );
+        TIntrusivePtr<TInterconnectProxyCommon> icCommon = new TInterconnectProxyCommon();
         icCommon->NameserviceId = GetNameserviceActorId();
-        icCommon->MonCounters = counters.GetSubgroup("counters", "interconnect"); 
-        icCommon->TechnicalSelfHostName = "127.0.0.1"; 
-        setup->Interconnect.ProxyActors.resize(nodeCount); 
-        //ui64 basePort = 12000; 
-        for (ui32 xnode : xrange<ui32>(1, nodeCount)) { 
-            if (xnode != nodeId) { 
-                //IActor *actor = new TInterconnectProxyTCP(xnode, icCommon); 
-                IActor *actor = interconnectMock.CreateProxyMock(nodeId, xnode, icCommon); 
-                setup->Interconnect.ProxyActors[xnode] = TActorSetupCmd(actor, TMailboxType::ReadAsFilled, 0); 
-            } 
-        } 
- 
-        TActorSetupCmd profilerSetup(CreateProfilerActor(nullptr, "."), TMailboxType::Simple, 0); 
+        icCommon->MonCounters = counters.GetSubgroup("counters", "interconnect");
+        icCommon->TechnicalSelfHostName = "127.0.0.1";
+        setup->Interconnect.ProxyActors.resize(nodeCount);
+        //ui64 basePort = 12000;
+        for (ui32 xnode : xrange<ui32>(1, nodeCount)) {
+            if (xnode != nodeId) {
+                //IActor *actor = new TInterconnectProxyTCP(xnode, icCommon);
+                IActor *actor = interconnectMock.CreateProxyMock(nodeId, xnode, icCommon);
+                setup->Interconnect.ProxyActors[xnode] = TActorSetupCmd(actor, TMailboxType::ReadAsFilled, 0);
+            }
+        }
+
+        TActorSetupCmd profilerSetup(CreateProfilerActor(nullptr, "."), TMailboxType::Simple, 0);
         setup->LocalServices.push_back(std::pair<TActorId, TActorSetupCmd>(MakeProfilerID(nodeId), profilerSetup));
- 
+
         const TActorId nameserviceId = GetNameserviceActorId();
-        TActorSetupCmd nameserviceSetup(CreateNameserverTable(nameserverTable), TMailboxType::Simple, 0); 
+        TActorSetupCmd nameserviceSetup(CreateNameserverTable(nameserverTable), TMailboxType::Simple, 0);
         setup->LocalServices.push_back(std::pair<TActorId, TActorSetupCmd>(nameserviceId, nameserviceSetup));
- 
-        return setup; 
-    } 
- 
-    TIntrusivePtr<NActors::NLog::TSettings> AddLoggerActor(THolder<TActorSystemSetup> &setup, 
-            NMonitoring::TDynamicCounters &counters) { 
- 
+
+        return setup;
+    }
+
+    TIntrusivePtr<NActors::NLog::TSettings> AddLoggerActor(THolder<TActorSystemSetup> &setup,
+            NMonitoring::TDynamicCounters &counters) {
+
         NActors::TActorId loggerActorId = NActors::TActorId(setup->NodeId, "logger");
-        TIntrusivePtr<NActors::NLog::TSettings> logSettings( 
-            new NActors::NLog::TSettings(loggerActorId, NKikimrServices::LOGGER, 
-                IsVerbose ? NLog::PRI_ERROR : NLog::PRI_CRIT, 
-                IsVerbose ? NLog::PRI_ERROR : NLog::PRI_CRIT, 
-                0)); 
+        TIntrusivePtr<NActors::NLog::TSettings> logSettings(
+            new NActors::NLog::TSettings(loggerActorId, NKikimrServices::LOGGER,
+                IsVerbose ? NLog::PRI_ERROR : NLog::PRI_CRIT,
+                IsVerbose ? NLog::PRI_ERROR : NLog::PRI_CRIT,
+                0));
         logSettings->Append(
             NActorsServices::EServiceCommon_MIN,
             NActorsServices::EServiceCommon_MAX,
@@ -4117,67 +4117,67 @@ public:
         );
         logSettings->Append(
             NKikimrServices::EServiceKikimr_MIN,
-            NKikimrServices::EServiceKikimr_MAX, 
+            NKikimrServices::EServiceKikimr_MAX,
             NKikimrServices::EServiceKikimr_Name
         );
- 
-        if (IsVerbose) { 
-            TString explanation; 
-            //logSettings->SetLevel(NLog::PRI_CRIT, NKikimrServices::BS_LOCALRECOVERY, explanation); 
-            //logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_PROXY_COLLECT, explanation); 
-            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_PROXY_DISCOVER, explanation); 
-            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_PROXY_PUT, explanation); 
-            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_PROXY_GET, explanation); 
-            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_VDISK_GET, explanation); 
-            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_VDISK_PUT, explanation); 
-            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_SKELETON, explanation); 
-            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_QUEUE, explanation); 
-            // logSettings->TimeThresholdMs = 5000; 
-            // logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_IFACE, explanation); 
-            //logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_LOCALRECOVERY, explanation); 
-        } 
-        NActors::TLoggerActor *loggerActor = new NActors::TLoggerActor(logSettings, 
-                NActors::CreateStderrBackend(), 
-                counters.GetSubgroup("counters", "utils")); 
-        NActors::TActorSetupCmd loggerActorCmd(loggerActor, NActors::TMailboxType::Simple, 2); 
+
+        if (IsVerbose) {
+            TString explanation;
+            //logSettings->SetLevel(NLog::PRI_CRIT, NKikimrServices::BS_LOCALRECOVERY, explanation);
+            //logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_PROXY_COLLECT, explanation);
+            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_PROXY_DISCOVER, explanation);
+            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_PROXY_PUT, explanation);
+            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_PROXY_GET, explanation);
+            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_VDISK_GET, explanation);
+            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_VDISK_PUT, explanation);
+            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_SKELETON, explanation);
+            logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_QUEUE, explanation);
+            // logSettings->TimeThresholdMs = 5000;
+            // logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_IFACE, explanation);
+            //logSettings->SetLevel(NLog::PRI_DEBUG, NKikimrServices::BS_LOCALRECOVERY, explanation);
+        }
+        NActors::TLoggerActor *loggerActor = new NActors::TLoggerActor(logSettings,
+                NActors::CreateStderrBackend(),
+                counters.GetSubgroup("counters", "utils"));
+        NActors::TActorSetupCmd loggerActorCmd(loggerActor, NActors::TMailboxType::Simple, 2);
         std::pair<NActors::TActorId, NActors::TActorSetupCmd> loggerActorPair(loggerActorId, loggerActorCmd);
-        setup->LocalServices.push_back(loggerActorPair); 
- 
-        return logSettings; 
-    } 
- 
+        setup->LocalServices.push_back(loggerActorPair);
+
+        return logSettings;
+    }
+
     template <class T>
     void TestBlobStorage(ui64 badVDiskMask, TBlobStorageGroupType::EErasureSpecies erasureSpecies,
             const char* dir, ui32 sleepMilliseconds = 0, bool startBadDisks = true, ui32 failDomains = 0,
             ui32 drivesPerFailDomain = 0) {
-        TTestArgs args; 
-        args.BadVDiskMask = badVDiskMask; 
-        args.ErasureSpecies = erasureSpecies; 
-        args.SleepMilliseconds = sleepMilliseconds; 
-        args.StartBadDisks = startBadDisks; 
-        args.FailDomainCount = failDomains; 
-        args.DrivesPerFailDomain = drivesPerFailDomain; 
-        TestBlobStorage<T>(dir, args); 
-    } 
-
-    template <class T> 
-    void TestBlobStorage(const char* dir, const TTestArgs &args = TTestArgs()) { 
-        TIntrusivePtr<TTestEnvironment> env = new TTestEnvironment(args); 
+        TTestArgs args;
+        args.BadVDiskMask = badVDiskMask;
+        args.ErasureSpecies = erasureSpecies;
+        args.SleepMilliseconds = sleepMilliseconds;
+        args.StartBadDisks = startBadDisks;
+        args.FailDomainCount = failDomains;
+        args.DrivesPerFailDomain = drivesPerFailDomain;
+        TestBlobStorage<T>(dir, args);
+    }
+
+    template <class T>
+    void TestBlobStorage(const char* dir, const TTestArgs &args = TTestArgs()) {
+        TIntrusivePtr<TTestEnvironment> env = new TTestEnvironment(args);
 
         TIntrusivePtr<TTableNameserverSetup> nameserverTable(new TTableNameserverSetup());
         TPortManager pm;
         nameserverTable->StaticNodeTable[1] = std::pair<TString, ui32>("127.0.0.1", pm.GetPort(12001));
         nameserverTable->StaticNodeTable[2] = std::pair<TString, ui32>("127.0.0.1", pm.GetPort(12002));
 
-        TIntrusivePtr<TBlobStorageGroupInfo> bsInfo(new TBlobStorageGroupInfo(args.ErasureSpecies, 
-                env->DrivesPerFailDomain, env->FailDomainCount, 1, &env->VDisks)); 
+        TIntrusivePtr<TBlobStorageGroupInfo> bsInfo(new TBlobStorageGroupInfo(args.ErasureSpecies,
+                env->DrivesPerFailDomain, env->FailDomainCount, 1, &env->VDisks));
 
         // first node
         TIntrusivePtr<NMonitoring::TDynamicCounters> counters(new NMonitoring::TDynamicCounters());
 
-        TInterconnectMock interconnect; 
- 
-        TAppData appData(0, 0, 0, 0, TMap<TString, ui32>(), nullptr, nullptr, nullptr, nullptr); 
+        TInterconnectMock interconnect;
+
+        TAppData appData(0, 0, 0, 0, TMap<TString, ui32>(), nullptr, nullptr, nullptr, nullptr);
         appData.Counters = counters;
         auto ioContext = std::make_shared<NKikimr::NPDisk::TIoContextFactoryOSS>();
         appData.IoContextFactory = ioContext.get();
@@ -4196,11 +4196,11 @@ public:
         TTempDir tempDir;
         NPDisk::TKey mainKey = 123;
         NPDisk::TKey badMainKey = 124;
-        for (ui32 failDomainIdx = 0; failDomainIdx < env->FailDomainCount; ++failDomainIdx) { 
-            for (ui32 driveIdx = 0; driveIdx < env->DrivesPerFailDomain; ++driveIdx) { 
-                ui32 i = env->GetVDiskTestIdx(failDomainIdx, driveIdx); 
-                bool isBad = (args.BadVDiskMask & (1 << i)); 
-                if (!args.StartBadDisks && isBad) { 
+        for (ui32 failDomainIdx = 0; failDomainIdx < env->FailDomainCount; ++failDomainIdx) {
+            for (ui32 driveIdx = 0; driveIdx < env->DrivesPerFailDomain; ++driveIdx) {
+                ui32 i = env->GetVDiskTestIdx(failDomainIdx, driveIdx);
+                bool isBad = (args.BadVDiskMask & (1 << i));
+                if (!args.StartBadDisks && isBad) {
                     continue;
                 }
                 TString databaseDirectory = Sprintf(isBad ? "%s/vdisk_bad_%d" : "%s/vdisk_%d",
@@ -4233,11 +4233,11 @@ public:
                 setup2->LocalServices.push_back(std::pair<TActorId, TActorSetupCmd>(pdiskId, pDiskSetup));
 
                 TVDiskConfig::TBaseInfo baseInfo(
-                    env->VDiskIds[i], 
-                    pdiskId, 
+                    env->VDiskIds[i],
+                    pdiskId,
                     mainKey,
                     i + 1,
-                    args.DeviceType, 
+                    args.DeviceType,
                     0,
                     NKikimrBlobStorage::TVDiskKind::Default,
                     2,
@@ -4258,14 +4258,14 @@ public:
             }
         }
 
-        TActorSetupCmd proxyTestSetup(new T(env->ProxyId, bsInfo.Get(), env, args.Parametrs), 
-                TMailboxType::Revolving, 0); 
+        TActorSetupCmd proxyTestSetup(new T(env->ProxyId, bsInfo.Get(), env, args.Parametrs),
+                TMailboxType::Revolving, 0);
         setup1->LocalServices.push_back(std::pair<TActorId, TActorSetupCmd>(env->ProxyTestId, proxyTestSetup));
 
-        ////////////////////////////////////////////////////////////////////////////// 
+        //////////////////////////////////////////////////////////////////////////////
         GetServiceCounters(counters, "utils");
-        TIntrusivePtr<NActors::NLog::TSettings> logSettings1 = AddLoggerActor(setup1, *counters); 
-        TIntrusivePtr<NActors::NLog::TSettings> logSettings2 = AddLoggerActor(setup2, *counters); 
+        TIntrusivePtr<NActors::NLog::TSettings> logSettings1 = AddLoggerActor(setup1, *counters);
+        TIntrusivePtr<NActors::NLog::TSettings> logSettings2 = AddLoggerActor(setup2, *counters);
 
         //////////////////////////////////////////////////////////////////////////////
         std::unique_ptr<TActorSystem> actorSystem1;
@@ -4273,7 +4273,7 @@ public:
         actorSystem1->Start();
         std::unique_ptr<TActorSystem> actorSystem2;
         actorSystem2.reset(new TActorSystem(setup2, &appData, logSettings2));
-        actorSystem2->Start(); 
+        actorSystem2->Start();
         EnableActorCallstack();
         try {
             VERBOSE_COUT("Sending TEvBoot to testproxy");
@@ -4281,38 +4281,38 @@ public:
                         nullptr));
             VERBOSE_COUT("Done");
 
-            bool isDone = env->DoneEvent.Wait(TEST_TIMEOUT); 
-            UNIT_ASSERT_C(isDone, "test timeout, badVDiskMask = " << args.BadVDiskMask); 
+            bool isDone = env->DoneEvent.Wait(TEST_TIMEOUT);
+            UNIT_ASSERT_C(isDone, "test timeout, badVDiskMask = " << args.BadVDiskMask);
 
             if (isDone) {
-                Sleep(TDuration::MilliSeconds(args.SleepMilliseconds)); 
+                Sleep(TDuration::MilliSeconds(args.SleepMilliseconds));
             }
 
-            for (ui32 i = 0; i != env->VDiskCount; ++i) { 
-                actorSystem2->Send(env->VDisks[i], new NActors::TEvents::TEvPoisonPill()); 
+            for (ui32 i = 0; i != env->VDiskCount; ++i) {
+                actorSystem2->Send(env->VDisks[i], new NActors::TEvents::TEvPoisonPill());
             }
 
             actorSystem1->Stop();
-            actorSystem2->Stop(); 
-            env->DoneEvent.Reset(); 
+            actorSystem2->Stop();
+            env->DoneEvent.Reset();
             DisableActorCallstack();
         } catch (yexception ex) {
-            env->IsLastExceptionSet = true; 
-            env->LastException = ex; 
+            env->IsLastExceptionSet = true;
+            env->LastException = ex;
             DisableActorCallstack();
             actorSystem1->Stop();
-            actorSystem2->Stop(); 
+            actorSystem2->Stop();
         } catch (...) {
             DisableActorCallstack();
             actorSystem1->Stop();
-            actorSystem2->Stop(); 
+            actorSystem2->Stop();
             throw;
         }
-        if (env->IsLastExceptionSet) { 
-            env->IsLastExceptionSet = false; 
-            ythrow env->LastException; 
+        if (env->IsLastExceptionSet) {
+            env->IsLastExceptionSet = false;
+            ythrow env->LastException;
         }
-        LastTestEnv = env; 
+        LastTestEnv = env;
     }
 };
 
diff --git a/ydb/core/blobstorage/dsproxy/ya.make b/ydb/core/blobstorage/dsproxy/ya.make
index 1a7a9db573..6e165c7f5d 100644
--- a/ydb/core/blobstorage/dsproxy/ya.make
+++ b/ydb/core/blobstorage/dsproxy/ya.make
@@ -35,7 +35,7 @@ SRCS(
     dsproxy_nodemon.h
     dsproxy_nodemonactor.cpp
     dsproxy_nodemonactor.h
-    dsproxy_patch.cpp 
+    dsproxy_patch.cpp
     dsproxy_put.cpp
     dsproxy_put_impl.cpp
     dsproxy_put_impl.h
diff --git a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.cpp b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.cpp
index d11a6711d1..054d5be665 100644
--- a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.cpp
+++ b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.cpp
@@ -787,17 +787,17 @@ void TBlobStorageGroupInfo::PickSubgroup(ui32 hash, TVDiskIds *outVDisk, TServic
 }
 
 bool TBlobStorageGroupInfo::BelongsToSubgroup(const TVDiskID &vdisk, ui32 hash) const {
-    Y_VERIFY_DEBUG_S(vdisk.GroupID == GroupID, "Expected GroupID# " << GroupID << ", given GroupID# " << vdisk.GroupID); 
-    Y_VERIFY_DEBUG_S(vdisk.GroupGeneration == GroupGeneration, "Expected GroupGeeration# " << GroupGeneration 
-            << ", given GroupGeneration# " << vdisk.GroupGeneration); 
+    Y_VERIFY_DEBUG_S(vdisk.GroupID == GroupID, "Expected GroupID# " << GroupID << ", given GroupID# " << vdisk.GroupID);
+    Y_VERIFY_DEBUG_S(vdisk.GroupGeneration == GroupGeneration, "Expected GroupGeeration# " << GroupGeneration
+            << ", given GroupGeneration# " << vdisk.GroupGeneration);
     return Topology->BelongsToSubgroup(TVDiskIdShort(vdisk), hash);
 }
 
 // Returns either vdisk idx in the blob subgroup, or BlobSubgroupSize if the vdisk is not in the blob subgroup
 ui32 TBlobStorageGroupInfo::GetIdxInSubgroup(const TVDiskID &vdisk, ui32 hash) const {
-    Y_VERIFY_DEBUG_S(vdisk.GroupID == GroupID, "Expected GroupID# " << GroupID << ", given GroupID# " << vdisk.GroupID); 
-    Y_VERIFY_DEBUG_S(vdisk.GroupGeneration == GroupGeneration, "Expected GroupGeeration# " << GroupGeneration 
-            << ", given GroupGeneration# " << vdisk.GroupGeneration); 
+    Y_VERIFY_DEBUG_S(vdisk.GroupID == GroupID, "Expected GroupID# " << GroupID << ", given GroupID# " << vdisk.GroupID);
+    Y_VERIFY_DEBUG_S(vdisk.GroupGeneration == GroupGeneration, "Expected GroupGeeration# " << GroupGeneration
+            << ", given GroupGeneration# " << vdisk.GroupGeneration);
     return Topology->GetIdxInSubgroup(vdisk, hash);
 }
 
@@ -807,9 +807,9 @@ TVDiskID TBlobStorageGroupInfo::GetVDiskInSubgroup(ui32 idxInSubgroup, ui32 hash
 }
 
 ui32 TBlobStorageGroupInfo::GetOrderNumber(const TVDiskID &vdisk) const {
-    Y_VERIFY_S(vdisk.GroupID == GroupID, "Expected GroupID# " << GroupID << ", given GroupID# " << vdisk.GroupID); 
-    Y_VERIFY_S(vdisk.GroupGeneration == GroupGeneration, "Expected GroupGeeration# " << GroupGeneration 
-            << ", given GroupGeneration# " << vdisk.GroupGeneration); 
+    Y_VERIFY_S(vdisk.GroupID == GroupID, "Expected GroupID# " << GroupID << ", given GroupID# " << vdisk.GroupID);
+    Y_VERIFY_S(vdisk.GroupGeneration == GroupGeneration, "Expected GroupGeeration# " << GroupGeneration
+            << ", given GroupGeneration# " << vdisk.GroupGeneration);
     return Topology->GetOrderNumber(vdisk);
 }
 
diff --git a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h
index c1de55152c..e2d1445be4 100644
--- a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h
+++ b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h
@@ -413,7 +413,7 @@ public:
     // origin of the group info content
     std::optional<NKikimrBlobStorage::TGroupInfo> Group;
 
-    TAtomicLogPriorityMuteChecker<NLog::PRI_ERROR, NLog::PRI_DEBUG> PutErrorMuteChecker; 
+    TAtomicLogPriorityMuteChecker<NLog::PRI_ERROR, NLog::PRI_DEBUG> PutErrorMuteChecker;
 
 private:
     // group topology -- all disks inside this group
diff --git a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_blobmap.cpp b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_blobmap.cpp
index 2abb19d4ce..572c36fbab 100644
--- a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_blobmap.cpp
+++ b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_blobmap.cpp
@@ -15,24 +15,24 @@ namespace NKikimr {
                 ui32 domainIdx = hash % numFailDomains;
 
                 // get shift of this disk inside ring
-                ui32 shift = failDomainOrderNumber + numFailDomains - domainIdx; 
-                if (shift >= numFailDomains) { 
-                    shift -= numFailDomains; 
-                } 
+                ui32 shift = failDomainOrderNumber + numFailDomains - domainIdx;
+                if (shift >= numFailDomains) {
+                    shift -= numFailDomains;
+                }
                 if (shift >= BlobSubgroupSize) {
                     return BlobSubgroupSize;
                 }
 
-                const TBlobStorageGroupInfo::TFailDomain& domain = Topology->GetFailDomain(vdisk); 
-                if (domain.VDisks.size() == 1) { 
-                    return shift; 
-                } else { 
-                    TReallyFastRng32 rng(hash); 
-                    for (ui32 i = 0; i < shift; ++i) { 
-                        rng(); 
-                    } 
- 
-                    return vdisk.VDisk == rng() % domain.VDisks.size() ? shift : BlobSubgroupSize; 
+                const TBlobStorageGroupInfo::TFailDomain& domain = Topology->GetFailDomain(vdisk);
+                if (domain.VDisks.size() == 1) {
+                    return shift;
+                } else {
+                    TReallyFastRng32 rng(hash);
+                    for (ui32 i = 0; i < shift; ++i) {
+                        rng();
+                    }
+
+                    return vdisk.VDisk == rng() % domain.VDisks.size() ? shift : BlobSubgroupSize;
                 }
             }
 
@@ -48,28 +48,28 @@ namespace NKikimr {
                 const ui32 numFailDomains = Topology->GetTotalFailDomainsNum();
                 ui32 domainIdx = hash % numFailDomains;
 
-                if (Topology->GetNumVDisksPerFailDomain() == 1) { 
-                    for (ui32 i = 0; i < BlobSubgroupSize; ++i) { 
-                        const TBlobStorageGroupInfo::TFailDomain& domain = Topology->GetFailDomain(domainIdx); 
-                        if (++domainIdx == numFailDomains) { 
-                            domainIdx = 0; 
-                        } 
-                        Y_VERIFY_DEBUG(domain.VDisks.size() == 1); 
-                        const TBlobStorageGroupInfo::TVDiskInfo& vdisk = domain.VDisks[0]; 
-                        orderNums.push_back(vdisk.OrderNumber); 
+                if (Topology->GetNumVDisksPerFailDomain() == 1) {
+                    for (ui32 i = 0; i < BlobSubgroupSize; ++i) {
+                        const TBlobStorageGroupInfo::TFailDomain& domain = Topology->GetFailDomain(domainIdx);
+                        if (++domainIdx == numFailDomains) {
+                            domainIdx = 0;
+                        }
+                        Y_VERIFY_DEBUG(domain.VDisks.size() == 1);
+                        const TBlobStorageGroupInfo::TVDiskInfo& vdisk = domain.VDisks[0];
+                        orderNums.push_back(vdisk.OrderNumber);
+                    }
+                } else {
+                    TReallyFastRng32 rng(hash);
+
+                    for (ui32 i = 0; i < BlobSubgroupSize; ++i) {
+                        const TBlobStorageGroupInfo::TFailDomain& domain = Topology->GetFailDomain(domainIdx);
+                        if (++domainIdx == numFailDomains) {
+                            domainIdx = 0;
+                        }
+                        const ui32 vdiskIdx = rng() % domain.VDisks.size();
+                        const TBlobStorageGroupInfo::TVDiskInfo& vdisk = domain.VDisks[vdiskIdx];
+                        orderNums.push_back(vdisk.OrderNumber);
                     }
-                } else { 
-                    TReallyFastRng32 rng(hash); 
- 
-                    for (ui32 i = 0; i < BlobSubgroupSize; ++i) { 
-                        const TBlobStorageGroupInfo::TFailDomain& domain = Topology->GetFailDomain(domainIdx); 
-                        if (++domainIdx == numFailDomains) { 
-                            domainIdx = 0; 
-                        } 
-                        const ui32 vdiskIdx = rng() % domain.VDisks.size(); 
-                        const TBlobStorageGroupInfo::TVDiskInfo& vdisk = domain.VDisks[vdiskIdx]; 
-                        orderNums.push_back(vdisk.OrderNumber); 
-                    } 
                 }
             }
 
@@ -83,19 +83,19 @@ namespace NKikimr {
 
             TVDiskIdShort GetVDiskInSubgroup(ui32 idxInSubgroup, ui32 hash) override final {
                 const ui32 numFailDomains = Topology->GetTotalFailDomainsNum();
-                ui32 domainIdx = (static_cast<ui64>(hash) + idxInSubgroup) % numFailDomains; 
+                ui32 domainIdx = (static_cast<ui64>(hash) + idxInSubgroup) % numFailDomains;
                 const TBlobStorageGroupInfo::TFailDomain& domain = Topology->GetFailDomain(domainIdx);
 
-                if (domain.VDisks.size() == 1) { 
-                    return domain.VDisks[0].VDiskIdShort; 
-                } else { 
-                    TReallyFastRng32 rng(hash); 
-                    for (ui32 i = 0; i < idxInSubgroup; ++i) { 
-                        rng(); 
-                    } 
- 
-                    const ui32 vdiskIdx = rng() % domain.VDisks.size(); 
-                    return domain.VDisks[vdiskIdx].VDiskIdShort; 
+                if (domain.VDisks.size() == 1) {
+                    return domain.VDisks[0].VDiskIdShort;
+                } else {
+                    TReallyFastRng32 rng(hash);
+                    for (ui32 i = 0; i < idxInSubgroup; ++i) {
+                        rng();
+                    }
+
+                    const ui32 vdiskIdx = rng() % domain.VDisks.size();
+                    return domain.VDisks[vdiskIdx].VDiskIdShort;
                 }
             }
         };
diff --git a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_blobmap_ut.cpp b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_blobmap_ut.cpp
index 20bc84ca77..9147c6a871 100644
--- a/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_blobmap_ut.cpp
+++ b/ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_blobmap_ut.cpp
@@ -97,8 +97,8 @@ namespace {
 
 Y_UNIT_TEST_SUITE(TBlobStorageGroupInfoBlobMapTest) {
 
-    void MakeBelongsToSubgroupBenchmark(TBlobStorageGroupType::EErasureSpecies erasure, ui32 numFailDomains, 
-            NUnitTest::TTestContext& ut_context) { 
+    void MakeBelongsToSubgroupBenchmark(TBlobStorageGroupType::EErasureSpecies erasure, ui32 numFailDomains,
+            NUnitTest::TTestContext& ut_context) {
         auto groupInfo = std::make_unique<TBlobStorageGroupInfo>(erasure, 1, numFailDomains, 1);
         const ui32 blobSubgroupSize = groupInfo->Type.BlobSubgroupSize();
         TOriginalBlobStorageGroupInfo orig(blobSubgroupSize, *groupInfo);
@@ -110,10 +110,10 @@ Y_UNIT_TEST_SUITE(TBlobStorageGroupInfoBlobMapTest) {
             }
         }
 
-        constexpr ui64 blobCount = 10'000'000; 
-        UNIT_ASSERT(blobCount == ids.size()); 
-        ui64 iterationCount = numFailDomains * blobCount; 
- 
+        constexpr ui64 blobCount = 10'000'000;
+        UNIT_ASSERT(blobCount == ids.size());
+        ui64 iterationCount = numFailDomains * blobCount;
+
         THPTimer timer;
         ui32 num = 0;
         for (const auto& vdisk : groupInfo->GetVDisks()) {
@@ -122,14 +122,14 @@ Y_UNIT_TEST_SUITE(TBlobStorageGroupInfoBlobMapTest) {
                 num += groupInfo->BelongsToSubgroup(vd, id.Hash()) ? 1 : 0;
             }
         }
-        double newMetric = 1'000'000'000 * timer.PassedReset() / iterationCount; 
-        TString newMetricsName = TStringBuilder() << TErasureType::ErasureSpeciesToStr(erasure) 
-                << " domains " << numFailDomains 
-                << " new (ns)"; 
-        ut_context.Metrics[newMetricsName] = newMetric; 
-        Cerr << newMetricsName << ": " << newMetric<< Endl; 
-
-        timer.Reset(); 
+        double newMetric = 1'000'000'000 * timer.PassedReset() / iterationCount;
+        TString newMetricsName = TStringBuilder() << TErasureType::ErasureSpeciesToStr(erasure)
+                << " domains " << numFailDomains
+                << " new (ns)";
+        ut_context.Metrics[newMetricsName] = newMetric;
+        Cerr << newMetricsName << ": " << newMetric<< Endl;
+
+        timer.Reset();
         ui32 num2 = 0;
         for (const auto& vdisk : groupInfo->GetVDisks()) {
             for (const TLogoBlobID& id : ids) {
@@ -137,75 +137,75 @@ Y_UNIT_TEST_SUITE(TBlobStorageGroupInfoBlobMapTest) {
                 num2 += orig.BelongsToSubgroup(vd, id.Hash()) ? 1 : 0;
             }
         }
-        double oldMetric = 1'000'000'000 * timer.PassedReset() / iterationCount; 
-        TString oldMetricsName = TStringBuilder() << TErasureType::ErasureSpeciesToStr(erasure) 
-                << " domains " << numFailDomains 
-                << " old (ns)"; 
-        ut_context.Metrics[oldMetricsName] = oldMetric; 
-        Cerr << oldMetricsName << ": " << oldMetric << Endl; 
+        double oldMetric = 1'000'000'000 * timer.PassedReset() / iterationCount;
+        TString oldMetricsName = TStringBuilder() << TErasureType::ErasureSpeciesToStr(erasure)
+                << " domains " << numFailDomains
+                << " old (ns)";
+        ut_context.Metrics[oldMetricsName] = oldMetric;
+        Cerr << oldMetricsName << ": " << oldMetric << Endl;
 
         UNIT_ASSERT_VALUES_EQUAL(num, num2);
     }
 
-    Y_UNIT_TEST(BelongsToSubgroupBenchmark) { 
-        auto erasures = {TBlobStorageGroupType::ErasureNone, 
-                TBlobStorageGroupType::ErasureMirror3, 
-                TBlobStorageGroupType::Erasure4Plus2Block, 
-                TBlobStorageGroupType::ErasureMirror3of4}; 
-        for (auto erasure : erasures) { 
-            TBlobStorageGroupType type(erasure); 
-            for (ui32 domains : {type.BlobSubgroupSize(), 9u}) { 
-                MakeBelongsToSubgroupBenchmark(erasure, domains, ut_context); 
-            } 
-        } 
-    } 
- 
+    Y_UNIT_TEST(BelongsToSubgroupBenchmark) {
+        auto erasures = {TBlobStorageGroupType::ErasureNone,
+                TBlobStorageGroupType::ErasureMirror3,
+                TBlobStorageGroupType::Erasure4Plus2Block,
+                TBlobStorageGroupType::ErasureMirror3of4};
+        for (auto erasure : erasures) {
+            TBlobStorageGroupType type(erasure);
+            for (ui32 domains : {type.BlobSubgroupSize(), 9u}) {
+                MakeBelongsToSubgroupBenchmark(erasure, domains, ut_context);
+            }
+        }
+    }
+
     void BasicCheck(const std::unique_ptr<TBlobStorageGroupInfo> &groupInfo, TOriginalBlobStorageGroupInfo &orig,
-            TLogoBlobID id, ui32 blobSubgroupSize) { 
-        std::array<TVDiskID, 8> vdisks; 
-        std::array<TActorId, 8> services; 
-        orig.PickSubgroup(id.Hash(), blobSubgroupSize, vdisks.data(), services.data()); 
- 
-        TBlobStorageGroupInfo::TVDiskIds vdisks2; 
-        TBlobStorageGroupInfo::TServiceIds services2; 
-        groupInfo->PickSubgroup(id.Hash(), &vdisks2, &services2); 
- 
-        UNIT_ASSERT_EQUAL(vdisks2.size(), blobSubgroupSize); 
-        UNIT_ASSERT_EQUAL(services2.size(), blobSubgroupSize); 
-        UNIT_ASSERT(std::equal(vdisks2.begin(), vdisks2.end(), vdisks.begin())); 
-        UNIT_ASSERT(std::equal(services2.begin(), services2.end(), services.begin())); 
- 
-        for (ui32 i = 0; i < blobSubgroupSize; ++i) { 
-            const TVDiskID& vdisk = vdisks[i]; 
- 
-            UNIT_ASSERT_EQUAL(groupInfo->GetVDiskInSubgroup(i, id.Hash()), 
-                    orig.GetVDiskInSubgroup(i, id.Hash())); 
-            UNIT_ASSERT_EQUAL(groupInfo->GetVDiskInSubgroup(i, id.Hash()), vdisk); 
- 
-            UNIT_ASSERT_EQUAL(groupInfo->GetIdxInSubgroup(vdisk, id.Hash()), 
-                    orig.GetIdxInSubgroup(vdisk, id.Hash())); 
-            UNIT_ASSERT_EQUAL(groupInfo->GetIdxInSubgroup(vdisk, id.Hash()), i); 
-        } 
- 
-        THashMap<TVDiskID, ui32> disk2index; 
-        for (ui32 i = 0; i < blobSubgroupSize; ++i) { 
-            disk2index[vdisks2[i]] = i; 
-        } 
- 
-        for (const auto& vdisk : groupInfo->GetVDisks()) { 
-            auto vd = groupInfo->GetVDiskId(vdisk.OrderNumber); 
-            auto it = disk2index.find(vd); 
-            bool isReplicaFor = it != disk2index.end(); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(orig.BelongsToSubgroup(vd, id.Hash()), isReplicaFor); 
-            UNIT_ASSERT_VALUES_EQUAL(groupInfo->BelongsToSubgroup(vd, id.Hash()), isReplicaFor); 
- 
-            const ui32 index = isReplicaFor ? it->second : blobSubgroupSize; 
-            UNIT_ASSERT_VALUES_EQUAL(orig.GetIdxInSubgroup(vd, id.Hash()), index); 
-            UNIT_ASSERT_VALUES_EQUAL(groupInfo->GetIdxInSubgroup(vd, id.Hash()), index); 
-        } 
-    } 
- 
+            TLogoBlobID id, ui32 blobSubgroupSize) {
+        std::array<TVDiskID, 8> vdisks;
+        std::array<TActorId, 8> services;
+        orig.PickSubgroup(id.Hash(), blobSubgroupSize, vdisks.data(), services.data());
+
+        TBlobStorageGroupInfo::TVDiskIds vdisks2;
+        TBlobStorageGroupInfo::TServiceIds services2;
+        groupInfo->PickSubgroup(id.Hash(), &vdisks2, &services2);
+
+        UNIT_ASSERT_EQUAL(vdisks2.size(), blobSubgroupSize);
+        UNIT_ASSERT_EQUAL(services2.size(), blobSubgroupSize);
+        UNIT_ASSERT(std::equal(vdisks2.begin(), vdisks2.end(), vdisks.begin()));
+        UNIT_ASSERT(std::equal(services2.begin(), services2.end(), services.begin()));
+
+        for (ui32 i = 0; i < blobSubgroupSize; ++i) {
+            const TVDiskID& vdisk = vdisks[i];
+
+            UNIT_ASSERT_EQUAL(groupInfo->GetVDiskInSubgroup(i, id.Hash()),
+                    orig.GetVDiskInSubgroup(i, id.Hash()));
+            UNIT_ASSERT_EQUAL(groupInfo->GetVDiskInSubgroup(i, id.Hash()), vdisk);
+
+            UNIT_ASSERT_EQUAL(groupInfo->GetIdxInSubgroup(vdisk, id.Hash()),
+                    orig.GetIdxInSubgroup(vdisk, id.Hash()));
+            UNIT_ASSERT_EQUAL(groupInfo->GetIdxInSubgroup(vdisk, id.Hash()), i);
+        }
+
+        THashMap<TVDiskID, ui32> disk2index;
+        for (ui32 i = 0; i < blobSubgroupSize; ++i) {
+            disk2index[vdisks2[i]] = i;
+        }
+
+        for (const auto& vdisk : groupInfo->GetVDisks()) {
+            auto vd = groupInfo->GetVDiskId(vdisk.OrderNumber);
+            auto it = disk2index.find(vd);
+            bool isReplicaFor = it != disk2index.end();
+
+            UNIT_ASSERT_VALUES_EQUAL(orig.BelongsToSubgroup(vd, id.Hash()), isReplicaFor);
+            UNIT_ASSERT_VALUES_EQUAL(groupInfo->BelongsToSubgroup(vd, id.Hash()), isReplicaFor);
+
+            const ui32 index = isReplicaFor ? it->second : blobSubgroupSize;
+            UNIT_ASSERT_VALUES_EQUAL(orig.GetIdxInSubgroup(vd, id.Hash()), index);
+            UNIT_ASSERT_VALUES_EQUAL(groupInfo->GetIdxInSubgroup(vd, id.Hash()), index);
+        }
+    }
+
     Y_UNIT_TEST(BasicChecks) {
         for (auto erasure : {TBlobStorageGroupType::ErasureNone, TBlobStorageGroupType::ErasureMirror3,
                 TBlobStorageGroupType::Erasure3Plus1Block, TBlobStorageGroupType::Erasure3Plus1Stripe,
@@ -219,20 +219,20 @@ Y_UNIT_TEST_SUITE(TBlobStorageGroupInfoBlobMapTest) {
             for (ui32 i = 0; i < 100; ++i) {
                 for (ui32 j = 0; j < 10; ++j) {
                     TLogoBlobID id(i, 1, j, 1, 1000, 1);
-                    BasicCheck(groupInfo, orig, id, blobSubgroupSize); 
+                    BasicCheck(groupInfo, orig, id, blobSubgroupSize);
                 }
             }
         }
     }
 
-    Y_UNIT_TEST(CheckCorrectBehaviourWithHashOverlow) { 
+    Y_UNIT_TEST(CheckCorrectBehaviourWithHashOverlow) {
         auto groupInfo = std::make_unique<TBlobStorageGroupInfo>(TErasureType::ErasureMirror3, 1U, 5U, 1U);
-        const ui32 blobSubgroupSize = groupInfo->Type.BlobSubgroupSize(); 
-        TOriginalBlobStorageGroupInfo orig(blobSubgroupSize, *groupInfo); 
-        TLogoBlobID id(4550843067551373890, 2564314201, 2840555155, 59, 0, 2230444); 
-        BasicCheck(groupInfo, orig, id, blobSubgroupSize); 
-    } 
- 
+        const ui32 blobSubgroupSize = groupInfo->Type.BlobSubgroupSize();
+        TOriginalBlobStorageGroupInfo orig(blobSubgroupSize, *groupInfo);
+        TLogoBlobID id(4550843067551373890, 2564314201, 2840555155, 59, 0, 2230444);
+        BasicCheck(groupInfo, orig, id, blobSubgroupSize);
+    }
+
     Y_UNIT_TEST(Mirror3dcMapper) {
         auto groupInfo = std::make_unique<TBlobStorageGroupInfo>(TBlobStorageGroupType::ErasureMirror3, 3U, 5U, 4U);
 
diff --git a/ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.cpp b/ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.cpp
index fad6cb8b09..0f6a440f57 100644
--- a/ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.cpp
+++ b/ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.cpp
@@ -36,7 +36,7 @@ void TBlobPutTactics::ToString(ui64 value, TString *out) {
 void TEventTypeField::ToString(ui64 value, TString* out) {
 #define CASE(EVENT) case TEvBlobStorage::EVENT: *out = #EVENT; break;
     switch(TEvBlobStorage::EEv(value)) {
-    CASE(EvPatch); 
+    CASE(EvPatch);
     CASE(EvPut);
     CASE(EvVPut);
     CASE(EvGet);
diff --git a/ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.h b/ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.h
index 27638251f5..7e20a7bd81 100644
--- a/ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.h
+++ b/ydb/core/blobstorage/lwtrace_probes/blobstorage_probes.h
@@ -56,12 +56,12 @@ struct TEventTypeField {
 }
 
 #define BLOBSTORAGE_PROVIDER(PROBE, EVENT, GROUPS, TYPES, NAMES) \
-    PROBE(DSProxyBatchedPutRequest, GROUPS("DSProxy"), \ 
-        TYPES(ui64, ui32), \ 
-        NAMES("count" , "groupId")) \ 
-    PROBE(DSProxyBatchedGetRequest, GROUPS("DSProxy"), \ 
-        TYPES(ui64, ui32), \ 
-        NAMES("count" , "groupId")) \ 
+    PROBE(DSProxyBatchedPutRequest, GROUPS("DSProxy"), \
+        TYPES(ui64, ui32), \
+        NAMES("count" , "groupId")) \
+    PROBE(DSProxyBatchedGetRequest, GROUPS("DSProxy"), \
+        TYPES(ui64, ui32), \
+        NAMES("count" , "groupId")) \
     PROBE(ProxyPutBootstrapPart, GROUPS("Durations"), \
       TYPES(ui64, double, double, ui64, double), \
       NAMES("size", "waitMs", "splitMs", "splitCount", "splitElapsedMs")) \
@@ -72,18 +72,18 @@ struct TEventTypeField {
       TYPES(NKikimr::TEventTypeField, ui64, ui64, ui32, ui32, ui32, double, double, double, double, TString, TString), \
       NAMES("type", "size", "tabletId", "groupId", "channel", "vdiskOrderNum", "startTime", "totalDurationMs", \
           "vdiskDurationMs", "transferDurationMs", "handleClass", "status")) \
-    PROBE(VDiskSkeletonFrontVMovedPatchRecieved, GROUPS("VDisk", "DSProxy"), \ 
-      TYPES(ui32, ui32, ui32, ui64, ui64), \ 
-      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \ 
-    PROBE(VDiskSkeletonFrontVPatchStartRecieved, GROUPS("VDisk", "DSProxy"), \ 
-      TYPES(ui32, ui32, ui32, ui64, ui64), \ 
-      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \ 
-    PROBE(VDiskSkeletonFrontVPatchDiffRecieved, GROUPS("VDisk", "DSProxy"), \ 
-      TYPES(ui32, ui32, ui32, ui64, ui64), \ 
-      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \ 
-    PROBE(VDiskSkeletonFrontVPatchXorDiffRecieved, GROUPS("VDisk", "DSProxy"), \ 
-      TYPES(ui32, ui32, ui32, ui64, ui64), \ 
-      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \ 
+    PROBE(VDiskSkeletonFrontVMovedPatchRecieved, GROUPS("VDisk", "DSProxy"), \
+      TYPES(ui32, ui32, ui32, ui64, ui64), \
+      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \
+    PROBE(VDiskSkeletonFrontVPatchStartRecieved, GROUPS("VDisk", "DSProxy"), \
+      TYPES(ui32, ui32, ui32, ui64, ui64), \
+      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \
+    PROBE(VDiskSkeletonFrontVPatchDiffRecieved, GROUPS("VDisk", "DSProxy"), \
+      TYPES(ui32, ui32, ui32, ui64, ui64), \
+      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \
+    PROBE(VDiskSkeletonFrontVPatchXorDiffRecieved, GROUPS("VDisk", "DSProxy"), \
+      TYPES(ui32, ui32, ui32, ui64, ui64), \
+      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \
     PROBE(VDiskSkeletonFrontVPutRecieved, GROUPS("VDisk", "DSProxy"), \
       TYPES(ui32, ui32, ui32, ui64, ui64), \
       NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \
@@ -93,9 +93,9 @@ struct TEventTypeField {
     PROBE(VDiskSkeletonVPutRecieved, GROUPS("VDisk", "DSProxy"), \
       TYPES(ui32, ui32, ui32, ui64, ui64), \
       NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \
-    PROBE(VDiskSkeletonVMultiPutRecieved, GROUPS("VDisk", "DSProxy"), \ 
-      TYPES(ui32, ui32, ui32, ui64, ui64), \ 
-      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \ 
+    PROBE(VDiskSkeletonVMultiPutRecieved, GROUPS("VDisk", "DSProxy"), \
+      TYPES(ui32, ui32, ui32, ui64, ui64), \
+      NAMES("nodeId", "groupId", "vdiskOrderNum", "tabletId", "size")) \
     PROBE(VDiskRecoveryLogWriterVPutIsRecieved, GROUPS("VDisk"), \
       TYPES(ui32, ui64), \
       NAMES("owner", "lsn")) \
diff --git a/ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp b/ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp
index 2a942f0007..e3c74cce7b 100644
--- a/ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp
+++ b/ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp
@@ -483,23 +483,23 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
         BlockGroup(runtime, sender0, tabletId, groupId, generation++, true, NKikimrProto::EReplyStatus::NO_GROUP);
     }
 
-    CUSTOM_UNIT_TEST(TestSendToInvalidGroupId) { 
-        TTestBasicRuntime runtime(1, false); 
-        Setup(runtime, "", nullptr); 
- 
-        auto sender = runtime.AllocateEdgeActor(0); 
- 
-        CreateStoragePool(runtime, DOMAIN_ID, "test_storage", "pool-kind-1"); 
-        ui32 groupId = Max<ui32>(); 
- 
-        ui64 tabletId = 1234; 
-        ui32 generation = 1; 
+    CUSTOM_UNIT_TEST(TestSendToInvalidGroupId) {
+        TTestBasicRuntime runtime(1, false);
+        Setup(runtime, "", nullptr);
+
+        auto sender = runtime.AllocateEdgeActor(0);
+
+        CreateStoragePool(runtime, DOMAIN_ID, "test_storage", "pool-kind-1");
+        ui32 groupId = Max<ui32>();
+
+        ui64 tabletId = 1234;
+        ui32 generation = 1;
         BlockGroup(runtime, sender, tabletId, groupId, generation, true, NKikimrProto::ERROR);
-        Put(runtime, sender, groupId, TLogoBlobID(tabletId, generation, 0, 0, 5, 0), "hello", 
-                NKikimrProto::EReplyStatus::ERROR); 
+        Put(runtime, sender, groupId, TLogoBlobID(tabletId, generation, 0, 0, 5, 0), "hello",
+                NKikimrProto::EReplyStatus::ERROR);
         CollectGroup(runtime, sender, tabletId, groupId, true, NKikimrProto::EReplyStatus::ERROR);
-    } 
- 
+    }
+
     CUSTOM_UNIT_TEST(TestBlockEncriptedGroup) {
         TTestBasicRuntime runtime(2, false);
         Setup(runtime, "", nullptr);
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp b/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
index c61cfcfcdd..47093a108d 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
@@ -33,14 +33,14 @@ void TNodeWarden::StartInvalidGroupProxy() {
     STLOG(PRI_DEBUG, BS_NODE, NW11, "StartInvalidGroupProxy", (GroupId, groupId));
     TlsActivationContext->ExecutorThread.ActorSystem->RegisterLocalService(MakeBlobStorageProxyID(groupId), Register(
         CreateBlobStorageGroupEjectedProxy(groupId, DsProxyNodeMon), TMailboxType::ReadAsFilled, AppData()->SystemPoolId));
-} 
- 
+}
+
 void TNodeWarden::StopInvalidGroupProxy() {
-    ui32 groupId = Max<ui32>(); 
+    ui32 groupId = Max<ui32>();
     STLOG(PRI_DEBUG, BS_NODE, NW15, "StopInvalidGroupProxy", (GroupId, groupId));
     TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, MakeBlobStorageProxyID(groupId), {}, nullptr, 0));
-} 
- 
+}
+
 void TNodeWarden::PassAway() {
     STLOG(PRI_DEBUG, BS_NODE, NW25, "PassAway");
     NTabletPipe::CloseClient(SelfId(), PipeClientId);
@@ -74,11 +74,11 @@ void TNodeWarden::Bootstrap() {
     DsProxyNodeMonActor = Register(CreateDsProxyNodeMon(DsProxyNodeMon));
     DsProxyPerPoolCounters = new TDsProxyPerPoolCounters(AppData()->Counters);
 
-    if (actorSystem && actorSystem->AppData<TAppData>() && actorSystem->AppData<TAppData>()->Icb) { 
-        actorSystem->AppData<TAppData>()->Icb->RegisterLocalControl(EnablePutBatching, "BlobStorage_EnablePutBatching"); 
-        actorSystem->AppData<TAppData>()->Icb->RegisterLocalControl(EnableVPatch, "BlobStorage_EnableVPatch"); 
-    } 
- 
+    if (actorSystem && actorSystem->AppData<TAppData>() && actorSystem->AppData<TAppData>()->Icb) {
+        actorSystem->AppData<TAppData>()->Icb->RegisterLocalControl(EnablePutBatching, "BlobStorage_EnablePutBatching");
+        actorSystem->AppData<TAppData>()->Icb->RegisterLocalControl(EnableVPatch, "BlobStorage_EnableVPatch");
+    }
+
     // start replication broker
     const auto& replBrokerConfig = Cfg->ServiceSet.GetReplBrokerConfig();
 
@@ -147,7 +147,7 @@ void TNodeWarden::HandleReadCache() {
                 if (!proto.HasInstanceId() && !proto.HasAvailDomain() && !proto.HasServiceSet()) {
                     return;
                 }
- 
+
                 Y_VERIFY(proto.HasInstanceId());
                 Y_VERIFY(proto.HasAvailDomain() && proto.GetAvailDomain() == AvailDomainId);
                 if (!InstanceId) {
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_impl.h b/ydb/core/blobstorage/nodewarden/node_warden_impl.h
index b4c28eade6..be67e5ef67 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_impl.h
+++ b/ydb/core/blobstorage/nodewarden/node_warden_impl.h
@@ -5,7 +5,7 @@
 
 #include <ydb/core/blobstorage/dsproxy/group_sessions.h>
 #include <ydb/core/node_whiteboard/node_whiteboard.h>
- 
+
 namespace NKikimr::NStorage {
 
     constexpr ui32 ProxyConfigurationTimeoutMilliseconds = 200;
@@ -105,9 +105,9 @@ namespace NKikimr::NStorage {
             struct TEvUpdateNodeDrives : TEventLocal<TEvUpdateNodeDrives, EvUpdateNodeDrives> {};
         };
 
-        TControlWrapper EnablePutBatching; 
-        TControlWrapper EnableVPatch; 
- 
+        TControlWrapper EnablePutBatching;
+        TControlWrapper EnableVPatch;
+
         TReplQuoter::TPtr ReplNodeRequestQuoter;
         TReplQuoter::TPtr ReplNodeResponseQuoter;
 
@@ -118,8 +118,8 @@ namespace NKikimr::NStorage {
 
         TNodeWarden(const TIntrusivePtr<TNodeWardenConfig> &cfg)
             : Cfg(cfg)
-            , EnablePutBatching(Cfg->FeatureFlags.GetEnablePutBatchingForBlobStorage(), false, true) 
-            , EnableVPatch(Cfg->FeatureFlags.GetEnableVPatch(), false, true) 
+            , EnablePutBatching(Cfg->FeatureFlags.GetEnablePutBatchingForBlobStorage(), false, true)
+            , EnableVPatch(Cfg->FeatureFlags.GetEnableVPatch(), false, true)
         {
             Y_VERIFY(Cfg->ServiceSet.AvailabilityDomainsSize() <= 1);
             AvailDomainId = 1;
@@ -409,7 +409,7 @@ namespace NKikimr::NStorage {
         void RenderWholePage(IOutputStream&);
         void RenderLocalDrives(IOutputStream&);
         void RenderDSProxies(IOutputStream& out);
- 
+
         void SendDiskMetrics(bool reportMetrics);
         void Handle(TEvStatusUpdate::TPtr ev);
 
@@ -418,7 +418,7 @@ namespace NKikimr::NStorage {
         void Handle(TEvBlobStorage::TEvRestartPDiskResult::TPtr ev);
 
         void FillInVDiskStatus(google::protobuf::RepeatedPtrField<NKikimrBlobStorage::TVDiskStatus> *pb, bool initial);
- 
+
         void HandleForwarded(TAutoPtr<::NActors::IEventHandle> &ev);
         void HandleIncrHugeInit(NIncrHuge::TEvIncrHugeInit::TPtr ev);
 
@@ -449,13 +449,13 @@ namespace NKikimr::NStorage {
                 fFunc(TEvBlobStorage::TEvPut::EventType, HandleForwarded);
                 fFunc(TEvBlobStorage::TEvGet::EventType, HandleForwarded);
                 fFunc(TEvBlobStorage::TEvBlock::EventType, HandleForwarded);
-                fFunc(TEvBlobStorage::TEvPatch::EventType, HandleForwarded); 
+                fFunc(TEvBlobStorage::TEvPatch::EventType, HandleForwarded);
                 fFunc(TEvBlobStorage::TEvDiscover::EventType, HandleForwarded);
                 fFunc(TEvBlobStorage::TEvRange::EventType, HandleForwarded);
                 fFunc(TEvBlobStorage::TEvCollectGarbage::EventType, HandleForwarded);
                 fFunc(TEvBlobStorage::TEvStatus::EventType, HandleForwarded);
                 fFunc(TEvBlobStorage::TEvBunchOfEvents::EventType, HandleForwarded);
-                fFunc(TEvRequestProxySessionsState::EventType, HandleForwarded); 
+                fFunc(TEvRequestProxySessionsState::EventType, HandleForwarded);
 
                 hFunc(NIncrHuge::TEvIncrHugeInit, HandleIncrHugeInit);
 
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk.h
index fb8230b226..8e722ce42a 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk.h
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk.h
@@ -329,37 +329,37 @@ struct TEvLog : public TEventLocal<TEvLog, TEvBlobStorage::EvLog> {
     mutable NLWTrace::TOrbit Orbit;
 };
 
-struct TEvMultiLog : public TEventLocal<TEvMultiLog, TEvBlobStorage::EvMultiLog> { 
-    TBatchedVec<THolder<TEvLog>> Logs; 
-    TLsnSeg LsnSeg; 
- 
-    void AddLog(THolder<TEvLog> &&ev) { 
-        Logs.emplace_back(std::move(ev)); 
-        auto &log = *Logs.back(); 
-        if (Logs.size() == 1) { 
-            LsnSeg = TLsnSeg(log.LsnSegmentStart, log.Lsn); 
-        } else { 
-            Y_VERIFY_S(LsnSeg.Last + 1 == log.LsnSegmentStart, "LastLsn# " << LsnSeg.Last << 
-                                                               " NewLsnStart# " << log.LsnSegmentStart); 
-            LsnSeg.Last = log.Lsn; 
-        } 
-    } 
- 
-    TString ToString() const { 
-        return ToString(*this); 
-    } 
- 
-    static TString ToString(const TEvMultiLog &record) { 
-        TStringBuilder str; 
-        str << '{'; 
-        for (ui64 idx = 0; idx < record.Logs.size(); ++idx) { 
-            str << (idx ? ", " : "") << idx << "# " << record.Logs[idx]->ToString(); 
-        } 
-        str << '}'; 
-        return str; 
-    } 
-}; 
- 
+struct TEvMultiLog : public TEventLocal<TEvMultiLog, TEvBlobStorage::EvMultiLog> {
+    TBatchedVec<THolder<TEvLog>> Logs;
+    TLsnSeg LsnSeg;
+
+    void AddLog(THolder<TEvLog> &&ev) {
+        Logs.emplace_back(std::move(ev));
+        auto &log = *Logs.back();
+        if (Logs.size() == 1) {
+            LsnSeg = TLsnSeg(log.LsnSegmentStart, log.Lsn);
+        } else {
+            Y_VERIFY_S(LsnSeg.Last + 1 == log.LsnSegmentStart, "LastLsn# " << LsnSeg.Last <<
+                                                               " NewLsnStart# " << log.LsnSegmentStart);
+            LsnSeg.Last = log.Lsn;
+        }
+    }
+
+    TString ToString() const {
+        return ToString(*this);
+    }
+
+    static TString ToString(const TEvMultiLog &record) {
+        TStringBuilder str;
+        str << '{';
+        for (ui64 idx = 0; idx < record.Logs.size(); ++idx) {
+            str << (idx ? ", " : "") << idx << "# " << record.Logs[idx]->ToString();
+        }
+        str << '}';
+        return str;
+    }
+};
+
 struct TEvLogResult : public TEventLocal<TEvLogResult, TEvBlobStorage::EvLogResult> {
     struct TRecord {
         ui64 Lsn;
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
index 84517e0c77..d92b19c6cc 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
@@ -539,27 +539,27 @@ public:
     }
 
     void ErrorHandle(NPDisk::TEvMultiLog::TPtr &ev) {
-        const NPDisk::TEvMultiLog &evMultiLog = *ev->Get(); 
-        TStringStream str; 
-        str << "PDiskId# " << PDisk->PDiskId; 
-        str << " TEvBatchedLogs error because PDisk State# "; 
-        if (CurrentStateFunc() == &TPDiskActor::StateInit) { 
-            str << "Init, wait for PDisk to initialize. Did you ckeck EvYardInit result? Marker# BSY10"; 
-        } else if (CurrentStateFunc() == &TPDiskActor::StateError) { 
-            str << "Error, there is a terminal internal error in PDisk. Did you check EvYardInit result? Marker# BSY11"; 
-        } else { 
-            str << "Unknown, something went very wrong in PDisk. Marker# BSY12"; 
-        } 
-        str << " StateErrorReason# " << StateErrorReason; 
-        THolder<NPDisk::TEvLogResult> result(new NPDisk::TEvLogResult(NKikimrProto::CORRUPTED, 0, str.Str())); 
-        for (auto &log : evMultiLog.Logs) { 
-            result->Results.push_back(NPDisk::TEvLogResult::TRecord(log->Lsn, log->Cookie)); 
-        } 
-        PDisk->Mon.WriteLog.CountRequest(0); 
+        const NPDisk::TEvMultiLog &evMultiLog = *ev->Get();
+        TStringStream str;
+        str << "PDiskId# " << PDisk->PDiskId;
+        str << " TEvBatchedLogs error because PDisk State# ";
+        if (CurrentStateFunc() == &TPDiskActor::StateInit) {
+            str << "Init, wait for PDisk to initialize. Did you ckeck EvYardInit result? Marker# BSY10";
+        } else if (CurrentStateFunc() == &TPDiskActor::StateError) {
+            str << "Error, there is a terminal internal error in PDisk. Did you check EvYardInit result? Marker# BSY11";
+        } else {
+            str << "Unknown, something went very wrong in PDisk. Marker# BSY12";
+        }
+        str << " StateErrorReason# " << StateErrorReason;
+        THolder<NPDisk::TEvLogResult> result(new NPDisk::TEvLogResult(NKikimrProto::CORRUPTED, 0, str.Str()));
+        for (auto &log : evMultiLog.Logs) {
+            result->Results.push_back(NPDisk::TEvLogResult::TRecord(log->Lsn, log->Cookie));
+        }
+        PDisk->Mon.WriteLog.CountRequest(0);
         Send(ev->Sender, result.Release());
-        PDisk->Mon.WriteLog.CountResponse(); 
-    } 
- 
+        PDisk->Mon.WriteLog.CountResponse();
+    }
+
     void ErrorHandle(NPDisk::TEvReadLog::TPtr &ev) {
         const NPDisk::TEvReadLog &evReadLog = *ev->Get();
         TStringStream str;
@@ -677,15 +677,15 @@ public:
     }
 
     void Handle(NPDisk::TEvMultiLog::TPtr &ev) {
-        for (auto &log : ev->Get()->Logs) { 
-            double burstMs; 
-            TLogWrite* request = PDisk->ReqCreator.CreateLogWrite(*log, ev->Sender, burstMs, std::move(ev->TraceId)); 
-            CheckBurst(request->IsSensitive, burstMs); 
-            request->Orbit = std::move(log->Orbit); 
-            PDisk->InputRequest(request); 
-        } 
-    } 
- 
+        for (auto &log : ev->Get()->Logs) {
+            double burstMs;
+            TLogWrite* request = PDisk->ReqCreator.CreateLogWrite(*log, ev->Sender, burstMs, std::move(ev->TraceId));
+            CheckBurst(request->IsSensitive, burstMs);
+            request->Orbit = std::move(log->Orbit);
+            PDisk->InputRequest(request);
+        }
+    }
+
     void Handle(NPDisk::TEvReadLog::TPtr &ev) {
         LOG_DEBUG(*TlsActivationContext, NKikimrServices::BS_PDISK, "PDiskId# %" PRIu32 " %s Marker# BSY01",
             (ui32)PDisk->PDiskId, ev->Get()->ToString().c_str());
diff --git a/ydb/core/blobstorage/testload/test_load_actor.cpp b/ydb/core/blobstorage/testload/test_load_actor.cpp
index 7d4768fef3..c8788b1310 100644
--- a/ydb/core/blobstorage/testload/test_load_actor.cpp
+++ b/ydb/core/blobstorage/testload/test_load_actor.cpp
@@ -1,10 +1,10 @@
 #include "test_load_actor.h"
- 
+
 #include <ydb/core/base/appdata.h>
 #include <ydb/core/base/counters.h>
 #include <ydb/core/blobstorage/base/blobstorage_events.h>
 #include <ydb/public/lib/base/msgbus.h>
- 
+
 #include <google/protobuf/text_format.h>
 #include <library/cpp/monlib/service/pages/templates.h>
 
@@ -238,7 +238,7 @@ public:
         LOG_DEBUG_S(ctx, NKikimrServices::BS_LOAD_TEST, "Load actor with tag# " << msg->Tag << " finished");
         LoadActors.erase(iter);
 
-        FinishedTests.push_back({msg->Tag, msg->ErrorReason, TAppData::TimeProvider->Now()}); 
+        FinishedTests.push_back({msg->Tag, msg->ErrorReason, TAppData::TimeProvider->Now()});
 
         auto it = InfoRequests.begin();
         while (it != InfoRequests.end()) {
diff --git a/ydb/core/blobstorage/testload/test_load_pdisk_read.cpp b/ydb/core/blobstorage/testload/test_load_pdisk_read.cpp
index c70b7b0018..3b446a74c2 100644
--- a/ydb/core/blobstorage/testload/test_load_pdisk_read.cpp
+++ b/ydb/core/blobstorage/testload/test_load_pdisk_read.cpp
@@ -373,7 +373,7 @@ public:
 
             if (IntervalMs) {
                 // Enforce intervals between requests
-                TInstant now = TAppData::TimeProvider->Now(); 
+                TInstant now = TAppData::TimeProvider->Now();
                 TInstant nextRequest = LastRequest + TDuration::MilliSeconds(IntervalMs);
                 if (now < nextRequest) {
                     // Suspend sending until interval will elapse
diff --git a/ydb/core/blobstorage/testload/test_load_pdisk_write.cpp b/ydb/core/blobstorage/testload/test_load_pdisk_write.cpp
index a18244d0fc..8ea16e014c 100644
--- a/ydb/core/blobstorage/testload/test_load_pdisk_write.cpp
+++ b/ydb/core/blobstorage/testload/test_load_pdisk_write.cpp
@@ -387,7 +387,7 @@ public:
 
             if (IntervalMs) {
                 // Enforce intervals between requests
-                TInstant now = TAppData::TimeProvider->Now(); 
+                TInstant now = TAppData::TimeProvider->Now();
                 TInstant nextRequest = LastRequest + TDuration::MilliSeconds(IntervalMs);
                 if (now < nextRequest) {
                     // Suspend sending until interval will elapse
diff --git a/ydb/core/blobstorage/testload/test_load_vdisk_write.cpp b/ydb/core/blobstorage/testload/test_load_vdisk_write.cpp
index 6cd952ccf2..39ecca9dbd 100644
--- a/ydb/core/blobstorage/testload/test_load_vdisk_write.cpp
+++ b/ydb/core/blobstorage/testload/test_load_vdisk_write.cpp
@@ -148,7 +148,7 @@ namespace NKikimr {
             }
 
             void TryToIssuePuts(const TActorContext& ctx) {
-                const TInstant now = TAppData::TimeProvider->Now(); 
+                const TInstant now = TAppData::TimeProvider->Now();
 
                 while (IsConnected &&
                         now >= NextWriteRequestTimestamp &&
@@ -218,7 +218,7 @@ namespace NKikimr {
             }
 
             void TryToCollect(const TActorContext& ctx) {
-                const TInstant now = TAppData::TimeProvider->Now(); 
+                const TInstant now = TAppData::TimeProvider->Now();
                 if (IsConnected && now >= NextCollectRequestTimestamp) {
                     if (CollectStep < BlobStep + StepDistance) {
                         const ui32 collectStep = CollectStep++;
diff --git a/ydb/core/blobstorage/testload/test_load_write.cpp b/ydb/core/blobstorage/testload/test_load_write.cpp
index 572278f9ae..3169c1609e 100644
--- a/ydb/core/blobstorage/testload/test_load_write.cpp
+++ b/ydb/core/blobstorage/testload/test_load_write.cpp
@@ -41,7 +41,7 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
 
     public:
         void Wakeup(const TActorContext& ctx) {
-            while (Events && TAppData::TimeProvider->Now() >= Events.top().Timestamp) { 
+            while (Events && TAppData::TimeProvider->Now() >= Events.top().Timestamp) {
                 TCallback callback = std::move(Events.top().Callback);
                 Events.pop();
                 callback(ctx);
@@ -248,7 +248,7 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
 
         // Issue TEvDiscover
         void Bootstrap(const TActorContext& ctx) {
-            NextWriteTimestamp = TAppData::TimeProvider->Now(); 
+            NextWriteTimestamp = TAppData::TimeProvider->Now();
             auto ev = std::make_unique<TEvBlobStorage::TEvDiscover>(TabletId, Generation, false, true, TInstant::Max(), 0);
             LOG_DEBUG_S(ctx, NKikimrServices::BS_LOAD_TEST, PrintMe() << " is bootstrapped, going to send "
                     << ev->ToString());
@@ -326,8 +326,8 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
         }
 
         void StartWorking(const TActorContext& ctx) {
-            StartTimestamp = TAppData::TimeProvider->Now(); 
-            InitializeTrackers(StartTimestamp); 
+            StartTimestamp = TAppData::TimeProvider->Now();
+            InitializeTrackers(StartTimestamp);
             IssueWriteIfPossible(ctx);
             ScheduleGarbageCollect(ctx);
             ExposeCounters(ctx);
@@ -353,7 +353,7 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
             SendToBSProxy(ctx, GroupId, ev.Release(), QueryDispatcher.ObtainCookie(std::move(callback)));
         }
 
-        void InitializeTrackers(TInstant now) { 
+        void InitializeTrackers(TInstant now) {
             LastLatencyTrackerUpdate = now;
 
             MegabytesPerSecondST.Add(now, 0);
@@ -407,8 +407,8 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
             ReadBytesInFlightQT.CalculateQuantiles();
 
             using namespace std::placeholders;
-            WakeupQueue.Put(TAppData::TimeProvider->Now() + ExposePeriod, 
-                    std::bind(&TTabletWriter::ExposeCounters, this, _1), ctx); 
+            WakeupQueue.Put(TAppData::TimeProvider->Now() + ExposePeriod,
+                    std::bind(&TTabletWriter::ExposeCounters, this, _1), ctx);
         }
 
         void DumpState(IOutputStream& str) {
@@ -503,7 +503,7 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
         }
 
         void IssueWriteIfPossible(const TActorContext& ctx) {
-            const TInstant now = TAppData::TimeProvider->Now(); 
+            const TInstant now = TAppData::TimeProvider->Now();
 
             while ((WritesInFlight < MaxWritesInFlight || !MaxWritesInFlight) &&
                     (WriteBytesInFlight < MaxWriteBytesInFlight || !MaxWriteBytesInFlight) &&
@@ -575,7 +575,7 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
 
                 if (ConfirmedBlobIds.size() == 1) {
                     if (NextReadTimestamp == TInstant()) {
-                        NextReadTimestamp = TAppData::TimeProvider->Now(); 
+                        NextReadTimestamp = TAppData::TimeProvider->Now();
                     }
                     IssueReadIfPossible(ctx);
                 }
@@ -584,7 +584,7 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
             const auto nowCycles = GetCycleCountFast();
             WritesInFlightTimestamps.emplace_back(writeQueryId, nowCycles);
             SentTimestamp.emplace(writeQueryId, nowCycles);
-            IssuedWriteTimestamp.push_back(TAppData::TimeProvider->Now()); 
+            IssuedWriteTimestamp.push_back(TAppData::TimeProvider->Now());
             while (IssuedWriteTimestamp.size() > 10000 || IssuedWriteTimestamp.back() - IssuedWriteTimestamp.front() >= TDuration::Seconds(5)) {
                 IssuedWriteTimestamp.pop_front();
             }
@@ -638,8 +638,8 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
             TDuration duration = GarbageCollectIntervalGen.Generate();
             if (duration != TDuration()) {
                 using namespace std::placeholders;
-                WakeupQueue.Put(TAppData::TimeProvider->Now() + duration, 
-                        std::bind(&TTabletWriter::IssueGarbageCollectRequest, this, _1), ctx); 
+                WakeupQueue.Put(TAppData::TimeProvider->Now() + duration,
+                        std::bind(&TTabletWriter::IssueGarbageCollectRequest, this, _1), ctx);
             }
         }
 
@@ -665,7 +665,7 @@ class TLogWriterTestLoadActor : public TActorBootstrapped<TLogWriterTestLoadActo
         }
 
         void IssueReadIfPossible(const TActorContext& ctx) {
-            const TInstant now = TAppData::TimeProvider->Now(); 
+            const TInstant now = TAppData::TimeProvider->Now();
 
             while (ReadsInFlight < MaxReadsInFlight &&
                     (ReadBytesInFlight < MaxReadBytesInFlight || !MaxReadBytesInFlight) &&
@@ -877,7 +877,7 @@ public:
     }
 
     void HandleUpdateQuantile(const TActorContext& ctx) {
-        TInstant now = TAppData::TimeProvider->Now(); 
+        TInstant now = TAppData::TimeProvider->Now();
         for (auto& writer : TabletWriters) {
             writer.UpdateQuantile(now);
         }
@@ -887,7 +887,7 @@ public:
     void HandleWakeup(const TActorContext& ctx) {
         // erase all scheduled items before this time point, including it
         WakeupScheduledAt.erase(WakeupScheduledAt.begin(), std::upper_bound(WakeupScheduledAt.begin(),
-            WakeupScheduledAt.end(), TAppData::TimeProvider->Now())); 
+            WakeupScheduledAt.end(), TAppData::TimeProvider->Now()));
         WakeupQueue.Wakeup(ctx);
         ScheduleWakeup(ctx);
     }
@@ -907,7 +907,7 @@ public:
         const TInstant scheduledWakeupTime = WakeupScheduledAt ? WakeupScheduledAt.front() : TInstant::Max();
         if (nextWakeupTime && *nextWakeupTime < scheduledWakeupTime) {
             WakeupScheduledAt.push_front(*nextWakeupTime);
-            TDuration delta = *nextWakeupTime - TAppData::TimeProvider->Now(); 
+            TDuration delta = *nextWakeupTime - TAppData::TimeProvider->Now();
             if (delta >= WakeupScheduleThreshold) {
                 ctx.Schedule(delta, new TEvents::TEvWakeup);
             } else {
diff --git a/ydb/core/blobstorage/ut_blobstorage/counting_events.cpp b/ydb/core/blobstorage/ut_blobstorage/counting_events.cpp
index 01c0f79c83..1f1b9e27be 100644
--- a/ydb/core/blobstorage/ut_blobstorage/counting_events.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/counting_events.cpp
@@ -2,7 +2,7 @@
 
 #include <ydb/core/blobstorage/dsproxy/group_sessions.h>
 
- 
+
 Y_UNIT_TEST_SUITE(CountingEvents) {
 
     struct TTestInfo {
@@ -56,34 +56,34 @@ Y_UNIT_TEST_SUITE(CountingEvents) {
         UNIT_ASSERT_EQUAL(collectResult->Status, status);
     }
 
-    TIntrusivePtr<TGroupQueues> ReceiveGroupQueues(const TTestInfo &test) { 
-        test.Runtime->WrapInActorContext(test.Edge, [&] { 
-            SendToBSProxy(test.Edge, test.Info->GroupID, new TEvRequestProxySessionsState); 
-        }); 
-        std::unique_ptr<IEventHandle> handle = test.Runtime->WaitForEdgeActorEvent({test.Edge}); 
-        UNIT_ASSERT_EQUAL_C(handle->Type, TEvBlobStorage::EvProxySessionsState, "expected# " << (ui64)TEvBlobStorage::EvProxySessionsState 
-                << " given# " << handle->Type); 
-        TEvProxySessionsState *state = handle->Get<TEvProxySessionsState>(); 
-        return state->GroupQueues; 
-    } 
-
-    void NormalizePredictedDelays(const TIntrusivePtr<TGroupQueues> &queues) { 
-        for (TGroupQueues::TFailDomain &domain : queues->FailDomains) { 
-            for (TGroupQueues::TVDisk &vDisk : domain.VDisks) { 
-                ui32 begin = NKikimrBlobStorage::EVDiskQueueId::Begin; 
-                ui32 end = NKikimrBlobStorage::EVDiskQueueId::End; 
-                for (ui32 id = begin; id < end; ++id) { 
-                    NKikimrBlobStorage::EVDiskQueueId vDiskQueueId = static_cast<NKikimrBlobStorage::EVDiskQueueId>(id); 
-                    auto flowRecord = vDisk.Queues.FlowRecordForQueueId(vDiskQueueId); 
-                    if (flowRecord) { 
-                        flowRecord->SetPredictedDelayNs(1'000'000); 
-                    } 
-                } 
-            } 
-        } 
-    } 
- 
- 
+    TIntrusivePtr<TGroupQueues> ReceiveGroupQueues(const TTestInfo &test) {
+        test.Runtime->WrapInActorContext(test.Edge, [&] {
+            SendToBSProxy(test.Edge, test.Info->GroupID, new TEvRequestProxySessionsState);
+        });
+        std::unique_ptr<IEventHandle> handle = test.Runtime->WaitForEdgeActorEvent({test.Edge});
+        UNIT_ASSERT_EQUAL_C(handle->Type, TEvBlobStorage::EvProxySessionsState, "expected# " << (ui64)TEvBlobStorage::EvProxySessionsState
+                << " given# " << handle->Type);
+        TEvProxySessionsState *state = handle->Get<TEvProxySessionsState>();
+        return state->GroupQueues;
+    }
+
+    void NormalizePredictedDelays(const TIntrusivePtr<TGroupQueues> &queues) {
+        for (TGroupQueues::TFailDomain &domain : queues->FailDomains) {
+            for (TGroupQueues::TVDisk &vDisk : domain.VDisks) {
+                ui32 begin = NKikimrBlobStorage::EVDiskQueueId::Begin;
+                ui32 end = NKikimrBlobStorage::EVDiskQueueId::End;
+                for (ui32 id = begin; id < end; ++id) {
+                    NKikimrBlobStorage::EVDiskQueueId vDiskQueueId = static_cast<NKikimrBlobStorage::EVDiskQueueId>(id);
+                    auto flowRecord = vDisk.Queues.FlowRecordForQueueId(vDiskQueueId);
+                    if (flowRecord) {
+                        flowRecord->SetPredictedDelayNs(1'000'000);
+                    }
+                }
+            }
+        }
+    }
+
+
     void CountingEventsTest(TString typeOperation, ui32 eventsCount, TBlobStorageGroupType groupType)
     {
         TEnvironmentSetup env(true, groupType);
@@ -98,9 +98,9 @@ Y_UNIT_TEST_SUITE(CountingEvents) {
         const TActorId& edge = runtime->AllocateEdgeActor(1);
         TTestInfo test{runtime, edge, info};
 
-        // set predicted a response time 
-        TIntrusivePtr<TGroupQueues> queues = ReceiveGroupQueues(test); 
- 
+        // set predicted a response time
+        TIntrusivePtr<TGroupQueues> queues = ReceiveGroupQueues(test);
+
         constexpr ui32 size = 100;
         TString data(size, 'a');
         ui64 tabletId = 1;
@@ -110,12 +110,12 @@ Y_UNIT_TEST_SUITE(CountingEvents) {
 
         if (typeOperation == "put") {
             TLogoBlobID originalBlobId(tabletId, 1, 0, 0, size, 0);
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendPut(test, originalBlobId, data, NKikimrProto::OK);
 
             startEventsCount = test.Runtime->GetEventsProcessed();
             TLogoBlobID originalBlobId2(tabletId, 1, 1, 0, size, 0);
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendPut(test, originalBlobId2, data, NKikimrProto::OK);
             finishEventsCount = test.Runtime->GetEventsProcessed();
 
@@ -123,39 +123,39 @@ Y_UNIT_TEST_SUITE(CountingEvents) {
 
             startEventsCount = test.Runtime->GetEventsProcessed();
             TLogoBlobID originalBlobId3(tabletId, 1, 2, 0, size, 0);
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendPut(test, originalBlobId3, data, NKikimrProto::OK);
             finishEventsCount = test.Runtime->GetEventsProcessed();
 
             UNIT_ASSERT_VALUES_EQUAL(finishEventsCount - startEventsCount, eventsCount);
         } else if (typeOperation == "get") {
             TLogoBlobID originalBlobId(tabletId, 1, 0, 0, size, 0);
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendPut(test, originalBlobId, data, NKikimrProto::OK);
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendGet(test, originalBlobId, data, NKikimrProto::OK);
 
             startEventsCount = test.Runtime->GetEventsProcessed();
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendGet(test, originalBlobId, data, NKikimrProto::OK);
             finishEventsCount = test.Runtime->GetEventsProcessed();
 
             UNIT_ASSERT_VALUES_EQUAL(finishEventsCount - startEventsCount, eventsCount);
 
             startEventsCount = test.Runtime->GetEventsProcessed();
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendGet(test, originalBlobId, data, NKikimrProto::OK);
             finishEventsCount = test.Runtime->GetEventsProcessed();
 
             UNIT_ASSERT_VALUES_EQUAL(finishEventsCount - startEventsCount, eventsCount);
         } else if (typeOperation == "collect") {
             TLogoBlobID originalBlobId(tabletId, 1, 0, 0, size, 0);
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendPut(test, originalBlobId, data, NKikimrProto::OK);
 
             startEventsCount = test.Runtime->GetEventsProcessed();
             TLogoBlobID originalBlobId2(tabletId, 1, 1, 0, size, 0);
-            NormalizePredictedDelays(queues); 
+            NormalizePredictedDelays(queues);
             SendCollect(test, originalBlobId2, NKikimrProto::OK);
             finishEventsCount = test.Runtime->GetEventsProcessed();
 
diff --git a/ydb/core/blobstorage/ut_blobstorage/lib/env.h b/ydb/core/blobstorage/ut_blobstorage/lib/env.h
index a09f8c16f9..1cc05f00bf 100644
--- a/ydb/core/blobstorage/ut_blobstorage/lib/env.h
+++ b/ydb/core/blobstorage/ut_blobstorage/lib/env.h
@@ -61,7 +61,7 @@ struct TEnvironmentSetup {
         })
     {}
 
-    TEnvironmentSetup(ui32 nodeCount, TNodeWardenMockActor::TSetup::TPtr nodeWardenMockSetup, 
+    TEnvironmentSetup(ui32 nodeCount, TNodeWardenMockActor::TSetup::TPtr nodeWardenMockSetup,
             TBlobStorageGroupType erasure = TBlobStorageGroupType::ErasureNone)
         : TEnvironmentSetup(TSettings{
             .NodeCount = nodeCount,
@@ -308,7 +308,7 @@ struct TEnvironmentSetup {
         }
 
         auto response = Invoke(request);
-        UNIT_ASSERT_C(response.GetSuccess(), response.GetErrorDescription()); 
+        UNIT_ASSERT_C(response.GetSuccess(), response.GetErrorDescription());
     }
 
     std::vector<ui32> GetGroups() {
@@ -446,18 +446,18 @@ struct TEnvironmentSetup {
         return WaitForEdgeActorEvent<TEvBlobStorage::TEvVDbStatResult>(edge)->Get()->Record.GetData();
     }
 
-    void WithQueueId(const TVDiskID& vdiskId, NKikimrBlobStorage::EVDiskQueueId queue, std::function<void(TActorId)> action) { 
-        const TActorId& queueId = CreateQueueActor(vdiskId, queue, 1000); 
-        action(queueId); 
-        Runtime->Send(new IEventHandle(TEvents::TSystem::Poison, 0, queueId, {}, nullptr, 0), queueId.NodeId()); 
-    } 
- 
+    void WithQueueId(const TVDiskID& vdiskId, NKikimrBlobStorage::EVDiskQueueId queue, std::function<void(TActorId)> action) {
+        const TActorId& queueId = CreateQueueActor(vdiskId, queue, 1000);
+        action(queueId);
+        Runtime->Send(new IEventHandle(TEvents::TSystem::Poison, 0, queueId, {}, nullptr, 0), queueId.NodeId());
+    }
+
     void CheckBlob(const TActorId& vdiskActorId, const TVDiskID& vdiskId, const TLogoBlobID& blobId, const TString& part,
             NKikimrProto::EReplyStatus status = NKikimrProto::OK) {
-        WithQueueId(vdiskId, NKikimrBlobStorage::EVDiskQueueId::GetFastRead, [&](TActorId queueId) { 
-            const TActorId& edge = Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__); 
-            Runtime->Send(new IEventHandle(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(vdiskId, 
-                TInstant::Max(), NKikimrBlobStorage::EGetHandleClass::FastRead, TEvBlobStorage::TEvVGet::EFlags::None, 
+        WithQueueId(vdiskId, NKikimrBlobStorage::EVDiskQueueId::GetFastRead, [&](TActorId queueId) {
+            const TActorId& edge = Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
+            Runtime->Send(new IEventHandle(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(vdiskId,
+                TInstant::Max(), NKikimrBlobStorage::EGetHandleClass::FastRead, TEvBlobStorage::TEvVGet::EFlags::None,
                 Nothing(), {{blobId, 1u, ui32(part.size() - 2)}}).release()), queueId.NodeId());
             auto r = WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge, false);
             {
@@ -483,22 +483,22 @@ struct TEnvironmentSetup {
                 UNIT_ASSERT(!res.HasBuffer());
                 UNIT_ASSERT_VALUES_EQUAL(LogoBlobIDFromLogoBlobID(res.GetBlobID()), blobId.FullID());
                 UNIT_ASSERT_VALUES_EQUAL(res.GetStatus(), status);
-            } 
-        }); 
+            }
+        });
     }
 
     void PutBlob(const TVDiskID& vdiskId, const TLogoBlobID& blobId, const TString& part) {
-        WithQueueId(vdiskId, NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](TActorId queueId) { 
-            const TActorId& edge = Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__); 
-            Runtime->Send(new IEventHandle(queueId, edge, new TEvBlobStorage::TEvVPut(blobId, part, vdiskId, false, nullptr, 
-                TInstant::Max(), NKikimrBlobStorage::EPutHandleClass::TabletLog)), queueId.NodeId()); 
-            auto r = WaitForEdgeActorEvent<TEvBlobStorage::TEvVPutResult>(edge); 
-
-            auto& record = r->Get()->Record; 
-            Cerr << "*** PUT BLOB " << blobId << " TO " << vdiskId << " FINISHED WITH " 
-                << NKikimrProto::EReplyStatus_Name(record.GetStatus()) << " ***" << Endl; 
-            UNIT_ASSERT_VALUES_EQUAL(record.GetStatus(), NKikimrProto::OK); 
-        }); 
+        WithQueueId(vdiskId, NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](TActorId queueId) {
+            const TActorId& edge = Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
+            Runtime->Send(new IEventHandle(queueId, edge, new TEvBlobStorage::TEvVPut(blobId, part, vdiskId, false, nullptr,
+                TInstant::Max(), NKikimrBlobStorage::EPutHandleClass::TabletLog)), queueId.NodeId());
+            auto r = WaitForEdgeActorEvent<TEvBlobStorage::TEvVPutResult>(edge);
+
+            auto& record = r->Get()->Record;
+            Cerr << "*** PUT BLOB " << blobId << " TO " << vdiskId << " FINISHED WITH "
+                << NKikimrProto::EReplyStatus_Name(record.GetStatus()) << " ***" << Endl;
+            UNIT_ASSERT_VALUES_EQUAL(record.GetStatus(), NKikimrProto::OK);
+        });
     }
 
     void CommenceReplication() {
diff --git a/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp b/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
index 5122f6c14f..b9ffea9da2 100644
--- a/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
@@ -6,7 +6,7 @@ Y_UNIT_TEST_SUITE(Mirror3of4) {
         SetRandomSeed(1);
         TEnvironmentSetup env(false, TBlobStorageGroupType::ErasureMirror3of4);
         auto& runtime = env.Runtime;
-        env.CreateBoxAndPool(); 
+        env.CreateBoxAndPool();
         env.Sim(TDuration::Minutes(1));
 //        runtime->SetLogPriority(NKikimrServices::BS_PROXY_PUT, NLog::PRI_DEBUG);
 //        runtime->SetLogPriority(NKikimrServices::BS_VDISK_PUT, NLog::PRI_DEBUG);
diff --git a/ydb/core/blobstorage/ut_blobstorage/patch.cpp b/ydb/core/blobstorage/ut_blobstorage/patch.cpp
index 5f1559a5c8..b68c05b80e 100644
--- a/ydb/core/blobstorage/ut_blobstorage/patch.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/patch.cpp
@@ -2,68 +2,68 @@
 #include <ydb/core/blobstorage/ut_blobstorage/lib/common.h>
 
 Y_UNIT_TEST_SUITE(BlobPatching) {
- 
-    void SendPut(const TTestInfo &test, const TLogoBlobID &blobId, const TString &data, 
-            NKikimrProto::EReplyStatus status) 
-    { 
+
+    void SendPut(const TTestInfo &test, const TLogoBlobID &blobId, const TString &data,
+            NKikimrProto::EReplyStatus status)
+    {
         std::unique_ptr<IEventBase> ev = std::make_unique<TEvBlobStorage::TEvPut>(blobId, data, TInstant::Max());
- 
-        test.Runtime->WrapInActorContext(test.Edge, [&] { 
+
+        test.Runtime->WrapInActorContext(test.Edge, [&] {
             SendToBSProxy(test.Edge, test.Info->GroupID, ev.release());
-        }); 
-        std::unique_ptr<IEventHandle> handle = test.Runtime->WaitForEdgeActorEvent({test.Edge}); 
- 
-        UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvPutResult); 
-        TEvBlobStorage::TEvPutResult *putResult = handle->Get<TEvBlobStorage::TEvPutResult>(); 
-        UNIT_ASSERT_EQUAL(putResult->Status, status); 
-    }; 
- 
-    void SendGet(const TTestInfo &test, const TLogoBlobID &blobId, const TString &data, 
-            NKikimrProto::EReplyStatus status) 
-    { 
+        });
+        std::unique_ptr<IEventHandle> handle = test.Runtime->WaitForEdgeActorEvent({test.Edge});
+
+        UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvPutResult);
+        TEvBlobStorage::TEvPutResult *putResult = handle->Get<TEvBlobStorage::TEvPutResult>();
+        UNIT_ASSERT_EQUAL(putResult->Status, status);
+    };
+
+    void SendGet(const TTestInfo &test, const TLogoBlobID &blobId, const TString &data,
+            NKikimrProto::EReplyStatus status)
+    {
         TArrayHolder<TEvBlobStorage::TEvGet::TQuery> getQueries{new TEvBlobStorage::TEvGet::TQuery[1]};
-        getQueries[0].Id = blobId; 
+        getQueries[0].Id = blobId;
         std::unique_ptr<IEventBase> ev = std::make_unique<TEvBlobStorage::TEvGet>(getQueries, 1, TInstant::Max(),
-                NKikimrBlobStorage::AsyncRead); 
-        test.Runtime->WrapInActorContext(test.Edge, [&] { 
+                NKikimrBlobStorage::AsyncRead);
+        test.Runtime->WrapInActorContext(test.Edge, [&] {
             SendToBSProxy(test.Edge, test.Info->GroupID, ev.release());
-        }); 
-        std::unique_ptr<IEventHandle> handle = test.Runtime->WaitForEdgeActorEvent({test.Edge}); 
-        UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvGetResult); 
-        TEvBlobStorage::TEvGetResult *getResult = handle->Get<TEvBlobStorage::TEvGetResult>(); 
-        UNIT_ASSERT(getResult); 
-        UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, 1); 
-        UNIT_ASSERT_VALUES_EQUAL(getResult->Responses[0].Status, status); 
-        UNIT_ASSERT_VALUES_EQUAL(getResult->Responses[0].Buffer, data); 
-    }; 
- 
-    void SendPatch(const TTestInfo &test, const TLogoBlobID &originalBlobId, const TLogoBlobID &patchedBlobId, ui32 mask, 
-            const TVector<TEvBlobStorage::TEvPatch::TDiff> &diffs, NKikimrProto::EReplyStatus status) 
-    { 
+        });
+        std::unique_ptr<IEventHandle> handle = test.Runtime->WaitForEdgeActorEvent({test.Edge});
+        UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvGetResult);
+        TEvBlobStorage::TEvGetResult *getResult = handle->Get<TEvBlobStorage::TEvGetResult>();
+        UNIT_ASSERT(getResult);
+        UNIT_ASSERT_VALUES_EQUAL(getResult->ResponseSz, 1);
+        UNIT_ASSERT_VALUES_EQUAL(getResult->Responses[0].Status, status);
+        UNIT_ASSERT_VALUES_EQUAL(getResult->Responses[0].Buffer, data);
+    };
+
+    void SendPatch(const TTestInfo &test, const TLogoBlobID &originalBlobId, const TLogoBlobID &patchedBlobId, ui32 mask,
+            const TVector<TEvBlobStorage::TEvPatch::TDiff> &diffs, NKikimrProto::EReplyStatus status)
+    {
         TArrayHolder<TEvBlobStorage::TEvPatch::TDiff> diffArr{new TEvBlobStorage::TEvPatch::TDiff[diffs.size()]};
-        for (ui32 idx = 0; idx < diffs.size(); ++idx) { 
-            diffArr[idx] = diffs[idx]; 
-        } 
+        for (ui32 idx = 0; idx < diffs.size(); ++idx) {
+            diffArr[idx] = diffs[idx];
+        }
         std::unique_ptr<IEventBase> ev = std::make_unique<TEvBlobStorage::TEvPatch>(test.Info->GroupID, originalBlobId, patchedBlobId,
-                mask, std::move(diffArr), diffs.size(), TInstant::Max()); 
-        test.Runtime->WrapInActorContext(test.Edge, [&] { 
+                mask, std::move(diffArr), diffs.size(), TInstant::Max());
+        test.Runtime->WrapInActorContext(test.Edge, [&] {
             SendToBSProxy(test.Edge, test.Info->GroupID, ev.release());
-        }); 
-        std::unique_ptr<IEventHandle> handle = test.Runtime->WaitForEdgeActorEvent({test.Edge}); 
-        UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvPatchResult); 
-        TEvBlobStorage::TEvPatchResult *patchResult = handle->Get<TEvBlobStorage::TEvPatchResult>(); 
-        UNIT_ASSERT_EQUAL(patchResult->Status, status); 
-    }; 
- 
-    TString ApplyDiffs(const TString &source, const TVector<TEvBlobStorage::TEvPatch::TDiff> &diffs) { 
-        TString result = TString::Uninitialized(source.size()); 
-        Copy(source.begin(), source.end(), result.begin()); 
-        for (auto &diff : diffs) { 
-            Copy(diff.Buffer.begin(), diff.Buffer.end(), result.begin() + diff.Offset); 
-        } 
-        return result; 
-    }; 
- 
+        });
+        std::unique_ptr<IEventHandle> handle = test.Runtime->WaitForEdgeActorEvent({test.Edge});
+        UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvPatchResult);
+        TEvBlobStorage::TEvPatchResult *patchResult = handle->Get<TEvBlobStorage::TEvPatchResult>();
+        UNIT_ASSERT_EQUAL(patchResult->Status, status);
+    };
+
+    TString ApplyDiffs(const TString &source, const TVector<TEvBlobStorage::TEvPatch::TDiff> &diffs) {
+        TString result = TString::Uninitialized(source.size());
+        Copy(source.begin(), source.end(), result.begin());
+        for (auto &diff : diffs) {
+            Copy(diff.Buffer.begin(), diff.Buffer.end(), result.begin() + diff.Offset);
+        }
+        return result;
+    };
+
     void MakePatchingTest(TString erasure) {
         TEnvironmentSetup env(true, GetErasureTypeByString(erasure));
         TTestInfo test = InitTest(env);
@@ -73,133 +73,133 @@ Y_UNIT_TEST_SUITE(BlobPatching) {
         TLogoBlobID originalBlobId(1, 1, 0, 0, size, 0);
         std::unique_ptr<IEventHandle> handle;
 
-        SendPut(test, originalBlobId, data, NKikimrProto::OK); 
-        SendGet(test, originalBlobId, data, NKikimrProto::OK); 
+        SendPut(test, originalBlobId, data, NKikimrProto::OK);
+        SendGet(test, originalBlobId, data, NKikimrProto::OK);
 
         TVector<TEvBlobStorage::TEvPatch::TDiff> diffs1(1);
         diffs1[0].Set("b", 0);
-        TString patchedData1 = ApplyDiffs(data, diffs1); 
+        TString patchedData1 = ApplyDiffs(data, diffs1);
         TLogoBlobID patchedBlobId1(1, 1, 1, 0, size, 0);
         TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(originalBlobId, &patchedBlobId1, 0,
                 test.Info->GroupID, test.Info->GroupID);
-        SendPatch(test, originalBlobId, patchedBlobId1, 0, diffs1, NKikimrProto::OK); 
-        SendGet(test, patchedBlobId1, patchedData1, NKikimrProto::OK); 
+        SendPatch(test, originalBlobId, patchedBlobId1, 0, diffs1, NKikimrProto::OK);
+        SendGet(test, patchedBlobId1, patchedData1, NKikimrProto::OK);
 
         TVector<TEvBlobStorage::TEvPatch::TDiff> diffs2(2);
         diffs2[0].Set("b", 0);
         diffs2[1].Set("b", 99);
-        TString patchedData2 = ApplyDiffs(data, diffs2); 
+        TString patchedData2 = ApplyDiffs(data, diffs2);
         TLogoBlobID patchedBlobId2(1, 1, 2, 0, size, 0);
         TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(originalBlobId, &patchedBlobId2, 0,
                 test.Info->GroupID, test.Info->GroupID);
-        SendPatch(test, originalBlobId, patchedBlobId2, 0, diffs2, NKikimrProto::OK); 
-        SendGet(test, patchedBlobId2, patchedData2, NKikimrProto::OK); 
+        SendPatch(test, originalBlobId, patchedBlobId2, 0, diffs2, NKikimrProto::OK);
+        SendGet(test, patchedBlobId2, patchedData2, NKikimrProto::OK);
 
         TLogoBlobID patchedBlobId3(1, 1, 3, 0, size, 0);
         TLogoBlobID truePatchedBlobId3(1, 1, 3, 0, size, 0);
         TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(originalBlobId, &truePatchedBlobId3, TLogoBlobID::MaxCookie,
                 test.Info->GroupID, test.Info->GroupID);
         UNIT_ASSERT(patchedBlobId3 != truePatchedBlobId3);
-        NKikimrProto::EReplyStatus statusWhenNotMatchingCookie = (erasure == "block-4-2" ? NKikimrProto::ERROR : NKikimrProto::OK); 
-        SendPatch(test, originalBlobId, patchedBlobId3, TLogoBlobID::MaxCookie, diffs2, statusWhenNotMatchingCookie); 
-        SendPatch(test, originalBlobId, truePatchedBlobId3, TLogoBlobID::MaxCookie, diffs2, NKikimrProto::OK); 
-        SendGet(test, truePatchedBlobId3, patchedData2, NKikimrProto::OK); 
+        NKikimrProto::EReplyStatus statusWhenNotMatchingCookie = (erasure == "block-4-2" ? NKikimrProto::ERROR : NKikimrProto::OK);
+        SendPatch(test, originalBlobId, patchedBlobId3, TLogoBlobID::MaxCookie, diffs2, statusWhenNotMatchingCookie);
+        SendPatch(test, originalBlobId, truePatchedBlobId3, TLogoBlobID::MaxCookie, diffs2, NKikimrProto::OK);
+        SendGet(test, truePatchedBlobId3, patchedData2, NKikimrProto::OK);
     }
 
-    void MakeStressPatchingTest(TString erasure) { 
+    void MakeStressPatchingTest(TString erasure) {
         TEnvironmentSetup env(true, GetErasureTypeByString(erasure));
         TTestInfo test = InitTest(env);
- 
-        constexpr ui32 size = 100; 
+
+        constexpr ui32 size = 100;
         TString data(size, 'a');
-        TLogoBlobID originalBlobId(1, 1, 0, 0, size, 0); 
-        std::unique_ptr<IEventHandle> handle; 
- 
-        SendPut(test, originalBlobId, data, NKikimrProto::OK); 
-        SendGet(test, originalBlobId, data, NKikimrProto::OK); 
- 
-        TVector<TEvBlobStorage::TEvPatch::TDiff> diffs(50); 
-        for (ui32 idx = 0; idx < diffs.size(); ++idx) { 
-            diffs[idx].Set("b", idx * 2); 
-        } 
-        TString patchedData = ApplyDiffs(data, diffs); 
- 
-        constexpr ui32 patchCount = 1'000; 
-        for (ui32 patchIdx = 0; patchIdx < patchCount; ++patchIdx) { 
-            TLogoBlobID patchedBlobId(1, 1, patchIdx + 1, 0, size, 0); 
-            TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(originalBlobId, &patchedBlobId, TLogoBlobID::MaxCookie, 
+        TLogoBlobID originalBlobId(1, 1, 0, 0, size, 0);
+        std::unique_ptr<IEventHandle> handle;
+
+        SendPut(test, originalBlobId, data, NKikimrProto::OK);
+        SendGet(test, originalBlobId, data, NKikimrProto::OK);
+
+        TVector<TEvBlobStorage::TEvPatch::TDiff> diffs(50);
+        for (ui32 idx = 0; idx < diffs.size(); ++idx) {
+            diffs[idx].Set("b", idx * 2);
+        }
+        TString patchedData = ApplyDiffs(data, diffs);
+
+        constexpr ui32 patchCount = 1'000;
+        for (ui32 patchIdx = 0; patchIdx < patchCount; ++patchIdx) {
+            TLogoBlobID patchedBlobId(1, 1, patchIdx + 1, 0, size, 0);
+            TEvBlobStorage::TEvPatch::GetBlobIdWithSamePlacement(originalBlobId, &patchedBlobId, TLogoBlobID::MaxCookie,
                     test.Info->GroupID, test.Info->GroupID);
-            SendPatch(test, originalBlobId, patchedBlobId, 0, diffs, NKikimrProto::OK); 
-            SendGet(test, patchedBlobId, patchedData, NKikimrProto::OK); 
-        } 
-    } 
- 
- 
-    Y_UNIT_TEST(Mirror3of4) { 
+            SendPatch(test, originalBlobId, patchedBlobId, 0, diffs, NKikimrProto::OK);
+            SendGet(test, patchedBlobId, patchedData, NKikimrProto::OK);
+        }
+    }
+
+
+    Y_UNIT_TEST(Mirror3of4) {
         MakePatchingTest("mirror-3of4");
     }
 
-    Y_UNIT_TEST(Mirror3dc) { 
-        MakePatchingTest("mirror-3-dc"); 
-    } 
- 
-    Y_UNIT_TEST(Mirror3) { 
+    Y_UNIT_TEST(Mirror3dc) {
+        MakePatchingTest("mirror-3-dc");
+    }
+
+    Y_UNIT_TEST(Mirror3) {
         MakePatchingTest("mirror-3");
     }
 
-    Y_UNIT_TEST(Block42) { 
+    Y_UNIT_TEST(Block42) {
         MakePatchingTest("block-4-2");
     }
 
-    Y_UNIT_TEST(None) { 
+    Y_UNIT_TEST(None) {
         MakePatchingTest("none");
     }
- 
- 
-    Y_UNIT_TEST(StressMirror3of4) { 
-        MakeStressPatchingTest("mirror-3of4"); 
-    } 
- 
-    Y_UNIT_TEST(StressMirror3dc) { 
-        MakeStressPatchingTest("mirror-3-dc"); 
-    } 
- 
-    Y_UNIT_TEST(StressMirror3) { 
-        MakeStressPatchingTest("mirror-3"); 
-    } 
- 
-    Y_UNIT_TEST(StressBlock42) { 
-        MakeStressPatchingTest("block-4-2"); 
-    } 
- 
-    Y_UNIT_TEST(StressNone) { 
-        MakeStressPatchingTest("none"); 
-    } 
-
-    Y_UNIT_TEST(DiffsWithIncorectPatchedBlobPartId) { 
-        TEnvironmentSetup env(true); 
-        auto& runtime = env.Runtime; 
-        env.CreateBoxAndPool(); 
-        env.CommenceReplication(); 
-        auto groups = env.GetGroups(); 
-        auto info = env.GetGroupInfo(groups[0]); 
-        constexpr ui32 size = 100; 
-        TLogoBlobID originalBlobId(1, 1, 0, 0, size, 0); 
-
-        env.WithQueueId(info->GetVDiskId(0), NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob, [&](TActorId queueId) { 
-            TActorId edge = runtime->AllocateEdgeActor(queueId.NodeId()); 
-            constexpr ui32 diffCount = 100; 
-            for (ui32 diffIdx = 0; diffIdx < diffCount; ++diffIdx) { 
-                TLogoBlobID patchedBlobId(1, 1, diffIdx + 1, 0, size, 0); 
+
+
+    Y_UNIT_TEST(StressMirror3of4) {
+        MakeStressPatchingTest("mirror-3of4");
+    }
+
+    Y_UNIT_TEST(StressMirror3dc) {
+        MakeStressPatchingTest("mirror-3-dc");
+    }
+
+    Y_UNIT_TEST(StressMirror3) {
+        MakeStressPatchingTest("mirror-3");
+    }
+
+    Y_UNIT_TEST(StressBlock42) {
+        MakeStressPatchingTest("block-4-2");
+    }
+
+    Y_UNIT_TEST(StressNone) {
+        MakeStressPatchingTest("none");
+    }
+
+    Y_UNIT_TEST(DiffsWithIncorectPatchedBlobPartId) {
+        TEnvironmentSetup env(true);
+        auto& runtime = env.Runtime;
+        env.CreateBoxAndPool();
+        env.CommenceReplication();
+        auto groups = env.GetGroups();
+        auto info = env.GetGroupInfo(groups[0]);
+        constexpr ui32 size = 100;
+        TLogoBlobID originalBlobId(1, 1, 0, 0, size, 0);
+
+        env.WithQueueId(info->GetVDiskId(0), NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob, [&](TActorId queueId) {
+            TActorId edge = runtime->AllocateEdgeActor(queueId.NodeId());
+            constexpr ui32 diffCount = 100;
+            for (ui32 diffIdx = 0; diffIdx < diffCount; ++diffIdx) {
+                TLogoBlobID patchedBlobId(1, 1, diffIdx + 1, 0, size, 0);
                 std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> ev = std::make_unique<TEvBlobStorage::TEvVPatchDiff>(
-                        originalBlobId, patchedBlobId, info->GetVDiskId(0), 0, TInstant::Max(), 0); 
+                        originalBlobId, patchedBlobId, info->GetVDiskId(0), 0, TInstant::Max(), 0);
                 runtime->Send(new IEventHandle(queueId, edge, ev.release()), queueId.NodeId());
-            } 
-            for (ui32 diffIdx = 0; diffIdx < diffCount; ++diffIdx) { 
-                auto r = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVPatchResult>(edge, false); 
-                UNIT_ASSERT_VALUES_EQUAL(r->Get()->Record.GetStatus(), NKikimrProto::ERROR); 
-            } 
-        }); 
-    } 
+            }
+            for (ui32 diffIdx = 0; diffIdx < diffCount; ++diffIdx) {
+                auto r = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVPatchResult>(edge, false);
+                UNIT_ASSERT_VALUES_EQUAL(r->Get()->Record.GetStatus(), NKikimrProto::ERROR);
+            }
+        });
+    }
 }
 
diff --git a/ydb/core/blobstorage/ut_blobstorage/scrub.cpp b/ydb/core/blobstorage/ut_blobstorage/scrub.cpp
index 334781cb53..8a355a5bd3 100644
--- a/ydb/core/blobstorage/ut_blobstorage/scrub.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/scrub.cpp
@@ -161,9 +161,9 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
 
     void ScrubTest(TBlobStorageGroupType erasure) {
         SetRandomSeed(1);
-        TEnvironmentSetup env(false, erasure); 
+        TEnvironmentSetup env(false, erasure);
         auto& runtime = env.Runtime;
-        env.CreateBoxAndPool(); 
+        env.CreateBoxAndPool();
         env.Sim(TDuration::Minutes(1));
         auto groups = env.GetGroups();
         auto info = env.GetGroupInfo(groups[0]);
diff --git a/ydb/core/blobstorage/ut_vdisk/lib/helpers.cpp b/ydb/core/blobstorage/ut_vdisk/lib/helpers.cpp
index e269040cb1..b73da3df8d 100644
--- a/ydb/core/blobstorage/ut_vdisk/lib/helpers.cpp
+++ b/ydb/core/blobstorage/ut_vdisk/lib/helpers.cpp
@@ -185,26 +185,26 @@ IActor *CreateRangeGet(const TActorId &notifyID, const TAllVDisks::TVDiskInstanc
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 class TManyPuts : public TActorBootstrapped<TManyPuts> {
-    struct TPut { 
-        ui64 Step; 
-        TString Data; 
-    }; 
- 
+    struct TPut {
+        ui64 Step;
+        TString Data;
+    };
+
     TConfiguration *Conf;
     TActorId NotifyID;
     const TAllVDisks::TVDiskInstance VDiskInfo;
- 
+
     std::shared_ptr<TVector<TMsgPackInfo>> MsgPacks;
-    ui32 MsgNum; 
- 
+    ui32 MsgNum;
+
     const ui64 TabletId;
     const ui32 Channel;
     const ui32 Gen;
     std::shared_ptr<IPutHandleClassGenerator> HandleClassGen;
     std::shared_ptr<TSet<ui32>> BadSteps;
     const TDuration RequestTimeout;
-    TVector<TPut> Puts; 
-    ui32 PutIdx; 
+    TVector<TPut> Puts;
+    ui32 PutIdx;
     TActorId QueueActorId;
     bool Started = false;
     // how many deadline statuses we got
@@ -243,30 +243,30 @@ class TManyPuts : public TActorBootstrapped<TManyPuts> {
         Die(ctx);
     }
 
-    bool IsEnd() { 
-        return PutIdx == MsgNum; 
-    } 
- 
+    bool IsEnd() {
+        return PutIdx == MsgNum;
+    }
+
     void SendPut(const TActorContext &ctx) {
         // put logo blob
-        while (!IsEnd()) { 
-            if (PutIdx % 100 == 0) 
-                LOG_NOTICE(ctx, NActorsServices::TEST, "PUT PutIdx=%u", PutIdx); 
+        while (!IsEnd()) {
+            if (PutIdx % 100 == 0)
+                LOG_NOTICE(ctx, NActorsServices::TEST, "PUT PutIdx=%u", PutIdx);
+
+            const TPut &put = Puts[PutIdx];
 
-            const TPut &put = Puts[PutIdx]; 
- 
-            TLogoBlobID logoBlobID(TabletId, Gen, put.Step, Channel, put.Data.size(), 0, 1); 
+            TLogoBlobID logoBlobID(TabletId, Gen, put.Step, Channel, put.Data.size(), 0, 1);
             TVDiskIdShort mainVDiskId = TIngress::GetMainReplica(&Conf->GroupInfo->GetTopology(), logoBlobID);
             if (mainVDiskId == VDiskInfo.VDiskID) {
                 const bool noTimeout = RequestTimeout == TDuration::Seconds(0);
                 const TInstant deadline = noTimeout ? TInstant::Max() : TInstant::Now() + RequestTimeout;
                 ctx.Send(QueueActorId,
-                         new TEvBlobStorage::TEvVPut(logoBlobID, put.Data, VDiskInfo.VDiskID, false, 
+                         new TEvBlobStorage::TEvVPut(logoBlobID, put.Data, VDiskInfo.VDiskID, false,
                                                      nullptr, deadline, HandleClassGen->GetHandleClass()));
                 return;
             } else {
-                BadSteps->insert(put.Step); 
-                PutIdx++; 
+                BadSteps->insert(put.Step);
+                PutIdx++;
             }
         }
 
@@ -286,8 +286,8 @@ class TManyPuts : public TActorBootstrapped<TManyPuts> {
             }
         }
 
-        PutIdx++; 
-        if (IsEnd()) { 
+        PutIdx++;
+        if (IsEnd()) {
             Finish(ctx);
         } else {
             SendPut(ctx);
@@ -299,23 +299,23 @@ class TManyPuts : public TActorBootstrapped<TManyPuts> {
         HFunc(TEvProxyQueueState, Handle);
     )
 
-    void Init() { 
-        MsgNum = 0; 
-        for (auto & el: *MsgPacks) { 
-            MsgNum += el.Count; 
-        } 
-        Puts.reserve(MsgNum); 
-        ui64 msgIdx = 0; 
-        for (ui32 packIdx = 0; packIdx < MsgPacks->size(); ++packIdx) { 
-            for (ui32 i = 0; i < MsgPacks->at(packIdx).Count; ++i) { 
-                Puts.push_back({msgIdx, MsgPacks->at(packIdx).MsgData}); 
-                msgIdx++; 
-            } 
-        } 
-        Shuffle(Puts.begin(), Puts.end()); 
-        Y_VERIFY(Puts.size() == MsgNum); 
-    } 
- 
+    void Init() {
+        MsgNum = 0;
+        for (auto & el: *MsgPacks) {
+            MsgNum += el.Count;
+        }
+        Puts.reserve(MsgNum);
+        ui64 msgIdx = 0;
+        for (ui32 packIdx = 0; packIdx < MsgPacks->size(); ++packIdx) {
+            for (ui32 i = 0; i < MsgPacks->at(packIdx).Count; ++i) {
+                Puts.push_back({msgIdx, MsgPacks->at(packIdx).MsgData});
+                msgIdx++;
+            }
+        }
+        Shuffle(Puts.begin(), Puts.end());
+        Y_VERIFY(Puts.size() == MsgNum);
+    }
+
 public:
     TManyPuts(TConfiguration *conf, const TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo,
               ui32 msgDataSize, ui32 msgNum, ui64 tabletId, ui32 channel, ui32 gen,
@@ -325,36 +325,36 @@ public:
         , Conf(conf)
         , NotifyID(notifyID)
         , VDiskInfo(vdiskInfo)
-        , MsgPacks(new TVector<TMsgPackInfo>{TMsgPackInfo(msgDataSize, msgNum)}) 
+        , MsgPacks(new TVector<TMsgPackInfo>{TMsgPackInfo(msgDataSize, msgNum)})
         , TabletId(tabletId)
         , Channel(channel)
         , Gen(gen)
         , HandleClassGen(cls)
         , BadSteps(badSteps)
         , RequestTimeout(requestTimeout)
-        , PutIdx(0) 
+        , PutIdx(0)
     {
-        Init(); 
-    } 
+        Init();
+    }
 
     TManyPuts(TConfiguration *conf, const TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo,
               std::shared_ptr<TVector<TMsgPackInfo>> msgPacks, ui64 tabletId, ui32 channel, ui32 gen,
               std::shared_ptr<IPutHandleClassGenerator> cls, std::shared_ptr<TSet<ui32>> badSteps,
-              TDuration requestTimeout) 
-        : TActorBootstrapped<TManyPuts>() 
-        , Conf(conf) 
-        , NotifyID(notifyID) 
-        , VDiskInfo(vdiskInfo) 
-        , MsgPacks(msgPacks) 
-        , TabletId(tabletId) 
-        , Channel(channel) 
-        , Gen(gen) 
-        , HandleClassGen(cls) 
-        , BadSteps(badSteps) 
-        , RequestTimeout(requestTimeout) 
-        , PutIdx(0) 
-    { 
-        Init(); 
+              TDuration requestTimeout)
+        : TActorBootstrapped<TManyPuts>()
+        , Conf(conf)
+        , NotifyID(notifyID)
+        , VDiskInfo(vdiskInfo)
+        , MsgPacks(msgPacks)
+        , TabletId(tabletId)
+        , Channel(channel)
+        , Gen(gen)
+        , HandleClassGen(cls)
+        , BadSteps(badSteps)
+        , RequestTimeout(requestTimeout)
+        , PutIdx(0)
+    {
+        Init();
     }
 };
 
@@ -369,10 +369,10 @@ IActor *CreateManyPuts(TConfiguration *conf, const TActorId &notifyID, const TAl
 IActor *CreateManyPuts(TConfiguration *conf, const TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo,
                        std::shared_ptr<TVector<TMsgPackInfo>> msgPacks, ui64 tabletId, ui32 channel, ui32 gen,
                        std::shared_ptr<IPutHandleClassGenerator> cls, std::shared_ptr<TSet<ui32>> badSteps,
-                       TDuration requestTimeout) { 
-    return new TManyPuts(conf, notifyID, vdiskInfo, msgPacks, tabletId, channel, gen, cls, badSteps, requestTimeout); 
-} 
- 
+                       TDuration requestTimeout) {
+    return new TManyPuts(conf, notifyID, vdiskInfo, msgPacks, tabletId, channel, gen, cls, badSteps, requestTimeout);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 class TManyMultiPuts : public TActorBootstrapped<TManyMultiPuts> {
     TConfiguration *Conf;
@@ -650,152 +650,152 @@ IActor *CreateManyGets(const TActorId &notifyID, const TAllVDisks::TVDiskInstanc
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class TGet : public TActorBootstrapped<TGet> { 
+class TGet : public TActorBootstrapped<TGet> {
     TActorId NotifyID;
-    const TAllVDisks::TVDiskInstance VDiskInfo; 
-    ui32 MsgNum; 
+    const TAllVDisks::TVDiskInstance VDiskInfo;
+    ui32 MsgNum;
     std::shared_ptr<TVector<TMsgPackInfo>> MsgPacks;
-    const ui64 TabletId; 
-    const ui32 Channel; 
-    const ui32 Gen; 
-    const ui64 Shift; 
-    TVector<TString> Data; 
- 
-    bool WithErrorResponse; 
- 
-    friend class TActorBootstrapped<TGet>; 
- 
-    void Bootstrap(const TActorContext &ctx) { 
-        Become(&TThis::StateReadFunc); 
- 
-        // get logo blob 
-        SendGet(ctx); 
-    } 
- 
-    void SendGet(const TActorContext &ctx) { 
-        // get logo blob 
-        auto req = TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(VDiskInfo.VDiskID, 
-                                                                   TInstant::Max(), 
-                                                                   NKikimrBlobStorage::EGetHandleClass::AsyncRead, 
-                                                                   TEvBlobStorage::TEvVGet::EFlags::None, 
-                                                                   {}, 
-                                                                   {}); 
-        for (ui64 i = 0; i < MsgNum; ++i) { 
-            const TString data = Data[i]; 
-            TLogoBlobID logoBlobID(TabletId, Gen, i, Channel, data.size(), 0, 1); 
-            req->AddExtremeQuery(logoBlobID, Shift, data.size() - Shift, &i); 
-        } 
+    const ui64 TabletId;
+    const ui32 Channel;
+    const ui32 Gen;
+    const ui64 Shift;
+    TVector<TString> Data;
+
+    bool WithErrorResponse;
+
+    friend class TActorBootstrapped<TGet>;
+
+    void Bootstrap(const TActorContext &ctx) {
+        Become(&TThis::StateReadFunc);
+
+        // get logo blob
+        SendGet(ctx);
+    }
+
+    void SendGet(const TActorContext &ctx) {
+        // get logo blob
+        auto req = TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(VDiskInfo.VDiskID,
+                                                                   TInstant::Max(),
+                                                                   NKikimrBlobStorage::EGetHandleClass::AsyncRead,
+                                                                   TEvBlobStorage::TEvVGet::EFlags::None,
+                                                                   {},
+                                                                   {});
+        for (ui64 i = 0; i < MsgNum; ++i) {
+            const TString data = Data[i];
+            TLogoBlobID logoBlobID(TabletId, Gen, i, Channel, data.size(), 0, 1);
+            req->AddExtremeQuery(logoBlobID, Shift, data.size() - Shift, &i);
+        }
         ctx.Send(VDiskInfo.ActorID, req.release());
-    } 
- 
-    void Check(const TActorContext &ctx, const NKikimrBlobStorage::TEvVGetResult &rec) { 
-        Y_UNUSED(ctx); 
-        ui32 size = rec.GetResult().size(); 
-        Y_VERIFY(size == MsgNum, "size=%d", size); 
-        for (ui64 i = 0; i < MsgNum; ++i) { 
-            const NKikimrBlobStorage::TQueryResult &q = rec.GetResult(i); 
-            const TString &data = Data[i]; 
-            if (q.GetBuffer() != data.substr(Shift)) { 
-                fprintf(stderr, "Original: %s\n", data.data()); 
-                fprintf(stderr, "Received: %s\n", q.GetBuffer().data()); 
-                Y_VERIFY(q.GetBuffer() == data.substr(Shift)); 
-            } 
-        } 
-        auto serial = rec.SerializeAsString(); 
-        if (serial.size() > MaxProtobufSize) { 
-            Y_FAIL(); 
-        } 
-    } 
- 
-    void Handle(TEvBlobStorage::TEvVGetResult::TPtr &ev, const TActorContext &ctx) { 
-        NKikimrProto::EReplyStatus status = ev->Get()->Record.GetStatus(); 
-        switch (status) { 
-        case NKikimrProto::OK: 
-            if (WithErrorResponse) { 
-                Y_FAIL("Expected ERROR status but given OK"); 
-            } 
-            Check(ctx, ev->Get()->Record); 
-            break; 
- 
-        case NKikimrProto::ERROR: 
-            if (!WithErrorResponse) { 
-                Y_FAIL("Expected OK status but given ERROR"); 
-            } 
-            break; 
- 
-        default: 
-            LOG_NOTICE(ctx, NActorsServices::TEST, "ERROR"); 
-            fprintf(stderr, "ERROR\n"); 
-        } 
- 
-        ctx.Send(NotifyID, new TEvents::TEvCompleted()); 
-        Die(ctx); 
-    } 
- 
-    STRICT_STFUNC(StateReadFunc, 
-        HFunc(TEvBlobStorage::TEvVGetResult, Handle); 
-        IgnoreFunc(TEvBlobStorage::TEvVWindowChange); 
-    ) 
- 
-    void Init() { 
-        MsgNum = 0; 
-        for (auto &el: *MsgPacks) { 
-            MsgNum += el.Count; 
-        } 
-        Data.reserve(MsgNum); 
-        for (ui32 packIdx = 0; packIdx < MsgPacks->size(); ++packIdx) { 
-            for (ui32 i = 0; i < MsgPacks->at(packIdx).Count; ++i) { 
-                Data.emplace_back(MsgPacks->at(packIdx).MsgData); 
-            } 
-        } 
-        Y_VERIFY(Data.size() == MsgNum); 
-    } 
- 
-public: 
+    }
+
+    void Check(const TActorContext &ctx, const NKikimrBlobStorage::TEvVGetResult &rec) {
+        Y_UNUSED(ctx);
+        ui32 size = rec.GetResult().size();
+        Y_VERIFY(size == MsgNum, "size=%d", size);
+        for (ui64 i = 0; i < MsgNum; ++i) {
+            const NKikimrBlobStorage::TQueryResult &q = rec.GetResult(i);
+            const TString &data = Data[i];
+            if (q.GetBuffer() != data.substr(Shift)) {
+                fprintf(stderr, "Original: %s\n", data.data());
+                fprintf(stderr, "Received: %s\n", q.GetBuffer().data());
+                Y_VERIFY(q.GetBuffer() == data.substr(Shift));
+            }
+        }
+        auto serial = rec.SerializeAsString();
+        if (serial.size() > MaxProtobufSize) {
+            Y_FAIL();
+        }
+    }
+
+    void Handle(TEvBlobStorage::TEvVGetResult::TPtr &ev, const TActorContext &ctx) {
+        NKikimrProto::EReplyStatus status = ev->Get()->Record.GetStatus();
+        switch (status) {
+        case NKikimrProto::OK:
+            if (WithErrorResponse) {
+                Y_FAIL("Expected ERROR status but given OK");
+            }
+            Check(ctx, ev->Get()->Record);
+            break;
+
+        case NKikimrProto::ERROR:
+            if (!WithErrorResponse) {
+                Y_FAIL("Expected OK status but given ERROR");
+            }
+            break;
+
+        default:
+            LOG_NOTICE(ctx, NActorsServices::TEST, "ERROR");
+            fprintf(stderr, "ERROR\n");
+        }
+
+        ctx.Send(NotifyID, new TEvents::TEvCompleted());
+        Die(ctx);
+    }
+
+    STRICT_STFUNC(StateReadFunc,
+        HFunc(TEvBlobStorage::TEvVGetResult, Handle);
+        IgnoreFunc(TEvBlobStorage::TEvVWindowChange);
+    )
+
+    void Init() {
+        MsgNum = 0;
+        for (auto &el: *MsgPacks) {
+            MsgNum += el.Count;
+        }
+        Data.reserve(MsgNum);
+        for (ui32 packIdx = 0; packIdx < MsgPacks->size(); ++packIdx) {
+            for (ui32 i = 0; i < MsgPacks->at(packIdx).Count; ++i) {
+                Data.emplace_back(MsgPacks->at(packIdx).MsgData);
+            }
+        }
+        Y_VERIFY(Data.size() == MsgNum);
+    }
+
+public:
     TGet(const TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo, ui32 msgDataSize, ui32 msgNum,
-              ui64 tabletId, ui32 channel, ui32 gen, ui64 shift, bool withErrorResponse) 
-        : TActorBootstrapped<TGet>() 
-        , NotifyID(notifyID) 
-        , VDiskInfo(vdiskInfo) 
-        , MsgPacks(new TVector<TMsgPackInfo>{TMsgPackInfo(msgDataSize, msgNum)}) 
-        , TabletId(tabletId) 
-        , Channel(channel) 
-        , Gen(gen) 
-        , Shift(shift) 
-        , WithErrorResponse(withErrorResponse) 
-    { 
-        Init(); 
-    } 
- 
+              ui64 tabletId, ui32 channel, ui32 gen, ui64 shift, bool withErrorResponse)
+        : TActorBootstrapped<TGet>()
+        , NotifyID(notifyID)
+        , VDiskInfo(vdiskInfo)
+        , MsgPacks(new TVector<TMsgPackInfo>{TMsgPackInfo(msgDataSize, msgNum)})
+        , TabletId(tabletId)
+        , Channel(channel)
+        , Gen(gen)
+        , Shift(shift)
+        , WithErrorResponse(withErrorResponse)
+    {
+        Init();
+    }
+
     TGet(const TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo,
             std::shared_ptr<TVector<TMsgPackInfo>> msgPacks,
-            ui64 tabletId, ui32 channel, ui32 gen, ui64 shift, bool withErrorResponse) 
-        : TActorBootstrapped<TGet>() 
-        , NotifyID(notifyID) 
-        , VDiskInfo(vdiskInfo) 
-        , MsgPacks(msgPacks) 
-        , TabletId(tabletId) 
-        , Channel(channel) 
-        , Gen(gen) 
-        , Shift(shift) 
-        , WithErrorResponse(withErrorResponse) 
-    { 
-        Init(); 
-    } 
-}; 
- 
+            ui64 tabletId, ui32 channel, ui32 gen, ui64 shift, bool withErrorResponse)
+        : TActorBootstrapped<TGet>()
+        , NotifyID(notifyID)
+        , VDiskInfo(vdiskInfo)
+        , MsgPacks(msgPacks)
+        , TabletId(tabletId)
+        , Channel(channel)
+        , Gen(gen)
+        , Shift(shift)
+        , WithErrorResponse(withErrorResponse)
+    {
+        Init();
+    }
+};
+
 IActor *CreateGet(const TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo, ui32 msgDataSize,
-                       ui32 msgNum, ui64 tabletId, ui32 channel, ui32 gen, ui64 shift, bool withErrorResponse) { 
-    return new TGet(notifyID, vdiskInfo, msgDataSize, msgNum, tabletId, channel, gen, shift, withErrorResponse); 
-} 
- 
+                       ui32 msgNum, ui64 tabletId, ui32 channel, ui32 gen, ui64 shift, bool withErrorResponse) {
+    return new TGet(notifyID, vdiskInfo, msgDataSize, msgNum, tabletId, channel, gen, shift, withErrorResponse);
+}
+
 IActor *CreateGet(const TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo,
                   std::shared_ptr<TVector<TMsgPackInfo>> msgPacks, ui64 tabletId, ui32 channel, ui32 gen, ui64 shift,
-                  bool withErrorResponse) { 
-    return new TGet(notifyID, vdiskInfo, msgPacks, tabletId, channel, gen, shift, withErrorResponse); 
-} 
- 
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
+                  bool withErrorResponse) {
+    return new TGet(notifyID, vdiskInfo, msgPacks, tabletId, channel, gen, shift, withErrorResponse);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 class TPutGC : public TActorBootstrapped<TPutGC> {
     const NActors::TActorId NotifyID;
     const TAllVDisks::TVDiskInstance VDiskInfo;
diff --git a/ydb/core/blobstorage/ut_vdisk/lib/helpers.h b/ydb/core/blobstorage/ut_vdisk/lib/helpers.h
index 0c5e20a643..ed8792b838 100644
--- a/ydb/core/blobstorage/ut_vdisk/lib/helpers.h
+++ b/ydb/core/blobstorage/ut_vdisk/lib/helpers.h
@@ -80,27 +80,27 @@ NActors::IActor *CreateManyPuts(TConfiguration *conf, const NActors::TActorId &n
                                 std::shared_ptr<IPutHandleClassGenerator> cls, std::shared_ptr<TSet<ui32>> badSteps,
                                 TDuration requestTimeout);
 
-struct TMsgPackInfo { 
-    ui32 Count; 
-    TString MsgData; 
- 
-    TMsgPackInfo(ui32 dataSize, ui32 count) 
-        : Count(count) 
-    { 
-        MsgData.reserve(dataSize); 
-        for (ui32 i = 0; i < dataSize; i++) { 
-            MsgData.append('a' + i % 26); 
-        } 
-    } 
-}; 
- 
- 
+struct TMsgPackInfo {
+    ui32 Count;
+    TString MsgData;
+
+    TMsgPackInfo(ui32 dataSize, ui32 count)
+        : Count(count)
+    {
+        MsgData.reserve(dataSize);
+        for (ui32 i = 0; i < dataSize; i++) {
+            MsgData.append('a' + i % 26);
+        }
+    }
+};
+
+
 NActors::IActor *CreateManyPuts(TConfiguration *conf, const NActors::TActorId &notifyID,
-                                const TAllVDisks::TVDiskInstance &vdiskInfo, 
+                                const TAllVDisks::TVDiskInstance &vdiskInfo,
                                 std::shared_ptr<TVector<TMsgPackInfo>> msgPacks, ui64 tabletId, ui32 channel, ui32 gen,
                                 std::shared_ptr<IPutHandleClassGenerator> cls, std::shared_ptr<TSet<ui32>> badSteps,
-                                TDuration requestTimeout); 
- 
+                                TDuration requestTimeout);
+
 NActors::IActor *CreateManyMultiPuts(TConfiguration *conf, const NActors::TActorId &notifyID,
                                      const TAllVDisks::TVDiskInstance &vdiskInfo,
                                      ui32 msgDataSize, ui32 msgNum, ui32 batchSize,
@@ -113,13 +113,13 @@ NActors::IActor *CreateManyGets(const NActors::TActorId &notifyID, const TAllVDi
                                 std::shared_ptr<TSet<ui32>> badSteps);
 
 NActors::IActor *CreateGet(const NActors::TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo,
-                           ui32 msgDataSize, ui32 msgNum, ui64 tabletId, ui32 channel, ui32 gen, ui64 shift, 
-                           bool withErrorResponse); 
- 
+                           ui32 msgDataSize, ui32 msgNum, ui64 tabletId, ui32 channel, ui32 gen, ui64 shift,
+                           bool withErrorResponse);
+
 NActors::IActor *CreateGet(const NActors::TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo,
                            std::shared_ptr<TVector<TMsgPackInfo>> msgPacks, ui64 tabletId, ui32 channel, ui32 gen,
-                           ui64 shift, bool withErrorResponse); 
- 
+                           ui64 shift, bool withErrorResponse);
+
 NActors::IActor *CreatePutGC(const NActors::TActorId &notifyID, const TAllVDisks::TVDiskInstance &vdiskInfo,
                              ui64 tabletID, ui32 recGen, ui32 recGenCounter, ui32 channel, bool collect, ui32 collectGen,
                              ui32 collectStep, TAutoPtr<TVector<NKikimr::TLogoBlobID>> keep,
diff --git a/ydb/core/blobstorage/ut_vdisk/lib/test_many.cpp b/ydb/core/blobstorage/ut_vdisk/lib/test_many.cpp
index 8b4140726b..d542dfc32a 100644
--- a/ydb/core/blobstorage/ut_vdisk/lib/test_many.cpp
+++ b/ydb/core/blobstorage/ut_vdisk/lib/test_many.cpp
@@ -7,69 +7,69 @@ using namespace NKikimr;
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class TManyPutOneGetActor : public TSyncTestBase { 
-protected: 
-    const bool WaitForCompaction; 
+class TManyPutOneGetActor : public TSyncTestBase {
+protected:
+    const bool WaitForCompaction;
     std::shared_ptr<TVector<TMsgPackInfo>> MsgPacks;
-    const ui64 TabletId; 
-    const ui64 Shift; 
+    const ui64 TabletId;
+    const ui64 Shift;
     std::shared_ptr<IPutHandleClassGenerator> HandleClassGen;
     std::shared_ptr<TSet<ui32>> BadSteps;
-    const bool WithErrorResponse; 
- 
-    virtual void Scenario(const TActorContext &ctx) { 
-        // load data 
-        SyncRunner->Run(ctx, CreateManyPuts(Conf, SyncRunner->NotifyID(), Conf->VDisks->Get(0), MsgPacks, 
-                                            TabletId, 0, 1, HandleClassGen, BadSteps, TDuration::Seconds(0))); 
-        LOG_NOTICE(ctx, NActorsServices::TEST, "  Data is loaded"); 
- 
-        // wait for compaction 
-        if (WaitForCompaction) { 
-            SyncRunner->Run(ctx, CreateWaitForCompaction(SyncRunner->NotifyID(), Conf)); 
-            LOG_NOTICE(ctx, NActorsServices::TEST, "  COMPACTION done"); 
-        } 
- 
-        // read 
-        SyncRunner->Run(ctx, CreateGet(SyncRunner->NotifyID(), Conf->VDisks->Get(0), MsgPacks, TabletId, 0, 1, Shift, 
-                                       WithErrorResponse)); 
-        LOG_NOTICE(ctx, NActorsServices::TEST, "  GET done"); 
-    } 
- 
- 
-public: 
-    TManyPutOneGetActor(TConfiguration *conf, bool waitForCompaction, ui32 msgNum, ui32 msgSize, 
-                        ui64 tabletId, ui64 shift, NKikimrBlobStorage::EPutHandleClass cls, 
-                        bool withErrorResponse) 
-        : TSyncTestBase(conf) 
-        , WaitForCompaction(waitForCompaction) 
-        , MsgPacks(new TVector<TMsgPackInfo>{TMsgPackInfo(msgSize, msgNum)}) 
-        , TabletId(tabletId) 
-        , Shift(shift) 
+    const bool WithErrorResponse;
+
+    virtual void Scenario(const TActorContext &ctx) {
+        // load data
+        SyncRunner->Run(ctx, CreateManyPuts(Conf, SyncRunner->NotifyID(), Conf->VDisks->Get(0), MsgPacks,
+                                            TabletId, 0, 1, HandleClassGen, BadSteps, TDuration::Seconds(0)));
+        LOG_NOTICE(ctx, NActorsServices::TEST, "  Data is loaded");
+
+        // wait for compaction
+        if (WaitForCompaction) {
+            SyncRunner->Run(ctx, CreateWaitForCompaction(SyncRunner->NotifyID(), Conf));
+            LOG_NOTICE(ctx, NActorsServices::TEST, "  COMPACTION done");
+        }
+
+        // read
+        SyncRunner->Run(ctx, CreateGet(SyncRunner->NotifyID(), Conf->VDisks->Get(0), MsgPacks, TabletId, 0, 1, Shift,
+                                       WithErrorResponse));
+        LOG_NOTICE(ctx, NActorsServices::TEST, "  GET done");
+    }
+
+
+public:
+    TManyPutOneGetActor(TConfiguration *conf, bool waitForCompaction, ui32 msgNum, ui32 msgSize,
+                        ui64 tabletId, ui64 shift, NKikimrBlobStorage::EPutHandleClass cls,
+                        bool withErrorResponse)
+        : TSyncTestBase(conf)
+        , WaitForCompaction(waitForCompaction)
+        , MsgPacks(new TVector<TMsgPackInfo>{TMsgPackInfo(msgSize, msgNum)})
+        , TabletId(tabletId)
+        , Shift(shift)
         , HandleClassGen(std::make_shared<TPutHandleClassGenerator>(cls))
         , BadSteps(std::make_shared<TSet<ui32>>())
-        , WithErrorResponse(withErrorResponse) 
-    {} 
- 
+        , WithErrorResponse(withErrorResponse)
+    {}
+
     TManyPutOneGetActor(TConfiguration *conf, bool waitForCompaction, std::shared_ptr<TVector<TMsgPackInfo>> msgPacks,
-                        ui64 tabletId, ui64 shift, NKikimrBlobStorage::EPutHandleClass cls, 
-                        bool withErrorResponse) 
-        : TSyncTestBase(conf) 
-        , WaitForCompaction(waitForCompaction) 
-        , MsgPacks(msgPacks) 
-        , TabletId(tabletId) 
-        , Shift(shift) 
+                        ui64 tabletId, ui64 shift, NKikimrBlobStorage::EPutHandleClass cls,
+                        bool withErrorResponse)
+        : TSyncTestBase(conf)
+        , WaitForCompaction(waitForCompaction)
+        , MsgPacks(msgPacks)
+        , TabletId(tabletId)
+        , Shift(shift)
         , HandleClassGen(std::make_shared<TPutHandleClassGenerator>(cls))
         , BadSteps(std::make_shared<TSet<ui32>>())
-        , WithErrorResponse(withErrorResponse) 
-    {} 
-}; 
- 
-void TManyPutOneGet::operator ()(TConfiguration *conf) { 
-    conf->ActorSystem1->Register(new TManyPutOneGetActor(conf, WaitForCompaction, MsgPacks, TabletId, Shift, 
-                                                         HandleClass, WithErrorResponse)); 
-} 
- 
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
+        , WithErrorResponse(withErrorResponse)
+    {}
+};
+
+void TManyPutOneGet::operator ()(TConfiguration *conf) {
+    conf->ActorSystem1->Register(new TManyPutOneGetActor(conf, WaitForCompaction, MsgPacks, TabletId, Shift,
+                                                         HandleClass, WithErrorResponse));
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 class TManyPutGetActor : public TSyncTestBase {
 protected:
     const bool WaitForCompaction;
diff --git a/ydb/core/blobstorage/ut_vdisk/lib/test_many.h b/ydb/core/blobstorage/ut_vdisk/lib/test_many.h
index 20539ae2ae..acfe4549df 100644
--- a/ydb/core/blobstorage/ut_vdisk/lib/test_many.h
+++ b/ydb/core/blobstorage/ut_vdisk/lib/test_many.h
@@ -2,42 +2,42 @@
 
 #include "defs.h"
 #include "prepare.h"
-#include "helpers.h" 
+#include "helpers.h"
 
 ///////////////////////////////////////////////////////////////////////////
-struct TManyPutOneGet { 
-    const bool WaitForCompaction; 
+struct TManyPutOneGet {
+    const bool WaitForCompaction;
     std::shared_ptr<TVector<TMsgPackInfo>> MsgPacks;
-    const NKikimrBlobStorage::EPutHandleClass HandleClass; 
-    const ui64 TabletId; 
-    const ui64 Shift; 
-    const bool WithErrorResponse; 
- 
-    TManyPutOneGet(bool waitForCompaction, ui32 msgNum, ui32 msgSize, NKikimrBlobStorage::EPutHandleClass cls, 
-                   ui64 tabletId = 0, ui64 shift = 0, bool withErrorResponse = false) 
-        : WaitForCompaction(waitForCompaction) 
-        , MsgPacks(new TVector<TMsgPackInfo>{TMsgPackInfo(msgSize, msgNum)}) 
-        , HandleClass(cls) 
-        , TabletId(tabletId) 
-        , Shift(shift) 
-        , WithErrorResponse(withErrorResponse) 
-    {} 
- 
+    const NKikimrBlobStorage::EPutHandleClass HandleClass;
+    const ui64 TabletId;
+    const ui64 Shift;
+    const bool WithErrorResponse;
+
+    TManyPutOneGet(bool waitForCompaction, ui32 msgNum, ui32 msgSize, NKikimrBlobStorage::EPutHandleClass cls,
+                   ui64 tabletId = 0, ui64 shift = 0, bool withErrorResponse = false)
+        : WaitForCompaction(waitForCompaction)
+        , MsgPacks(new TVector<TMsgPackInfo>{TMsgPackInfo(msgSize, msgNum)})
+        , HandleClass(cls)
+        , TabletId(tabletId)
+        , Shift(shift)
+        , WithErrorResponse(withErrorResponse)
+    {}
+
     TManyPutOneGet(bool waitForCompaction, std::shared_ptr<TVector<TMsgPackInfo>> msgPacks,
-                   NKikimrBlobStorage::EPutHandleClass cls, ui64 tabletId = 0, ui64 shift = 0, 
-                   bool withErrorResponse = false) 
-        : WaitForCompaction(waitForCompaction) 
-        , MsgPacks(msgPacks) 
-        , HandleClass(cls) 
-        , TabletId(tabletId) 
-        , Shift(shift) 
-        , WithErrorResponse(withErrorResponse) 
-    {} 
- 
-    void operator ()(TConfiguration *conf); 
-}; 
- 
-/////////////////////////////////////////////////////////////////////////// 
+                   NKikimrBlobStorage::EPutHandleClass cls, ui64 tabletId = 0, ui64 shift = 0,
+                   bool withErrorResponse = false)
+        : WaitForCompaction(waitForCompaction)
+        , MsgPacks(msgPacks)
+        , HandleClass(cls)
+        , TabletId(tabletId)
+        , Shift(shift)
+        , WithErrorResponse(withErrorResponse)
+    {}
+
+    void operator ()(TConfiguration *conf);
+};
+
+///////////////////////////////////////////////////////////////////////////
 struct TManyPutGet {
     const bool WaitForCompaction;
     const ui32 MsgNum;
diff --git a/ydb/core/blobstorage/ut_vdisk/vdisk_test.cpp b/ydb/core/blobstorage/ut_vdisk/vdisk_test.cpp
index bd20ab3c70..694828c9f8 100644
--- a/ydb/core/blobstorage/ut_vdisk/vdisk_test.cpp
+++ b/ydb/core/blobstorage/ut_vdisk/vdisk_test.cpp
@@ -257,22 +257,22 @@ Y_UNIT_TEST_SUITE(TBsVDiskRangeHuge) {
 #endif
 
 Y_UNIT_TEST_SUITE(TBsVDiskManyPutGetCheckSize) {
-    Y_UNIT_TEST(ManyPutGetCheckSize) { 
+    Y_UNIT_TEST(ManyPutGetCheckSize) {
         std::shared_ptr<TVector<TMsgPackInfo>> msgPacks(std::unique_ptr<TVector<TMsgPackInfo>>(new TVector<TMsgPackInfo>{
-            TMsgPackInfo(100'000, 672), 
-            TMsgPackInfo(17'026, 1) 
+            TMsgPackInfo(100'000, 672),
+            TMsgPackInfo(17'026, 1)
         }));
-        TManyPutOneGet testOk(false, msgPacks, UNK, 0, 257, false); 
-        TestRun<TManyPutOneGet, TFastVDiskSetupHndOff>(&testOk, TDuration::Minutes(100), DefChunkSize, DefDiskSize, 
-                1, 1, NKikimr::TErasureType::ErasureNone); 
+        TManyPutOneGet testOk(false, msgPacks, UNK, 0, 257, false);
+        TestRun<TManyPutOneGet, TFastVDiskSetupHndOff>(&testOk, TDuration::Minutes(100), DefChunkSize, DefDiskSize,
+                1, 1, NKikimr::TErasureType::ErasureNone);
         std::shared_ptr<TVector<TMsgPackInfo>> failMsgPacks(std::unique_ptr<TVector<TMsgPackInfo>>(new TVector<TMsgPackInfo>{
-            TMsgPackInfo(100'000, 672), 
-            TMsgPackInfo(17'027, 1) 
+            TMsgPackInfo(100'000, 672),
+            TMsgPackInfo(17'027, 1)
         }));
-        TManyPutOneGet testError(false, failMsgPacks, UNK, 0, 257, true); 
-        TestRun<TManyPutOneGet, TFastVDiskSetupHndOff>(&testError, TDuration::Minutes(100), DefChunkSize, DefDiskSize, 
-                1, 1, NKikimr::TErasureType::ErasureNone); 
-    } 
+        TManyPutOneGet testError(false, failMsgPacks, UNK, 0, 257, true);
+        TestRun<TManyPutOneGet, TFastVDiskSetupHndOff>(&testError, TDuration::Minutes(100), DefChunkSize, DefDiskSize,
+                1, 1, NKikimr::TErasureType::ErasureNone);
+    }
 }
 Y_UNIT_TEST_SUITE(TBsVDiskManyPutGet) {
     //// Group
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_config.h b/ydb/core/blobstorage/vdisk/common/vdisk_config.h
index 9f9341c4e5..ff4bb4f0d6 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_config.h
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_config.h
@@ -201,7 +201,7 @@ namespace NKikimr {
         bool BarrierValidation;
         TDuration WhiteboardUpdateInterval;
         bool EnableVDiskCooldownTimeout;
-        TControlWrapper EnableVPatch = true; 
+        TControlWrapper EnableVPatch = true;
 
         TVDiskConfig(const TBaseInfo &baseInfo);
         void Merge(const NKikimrBlobStorage::TVDiskConfig &update);
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_costmodel.cpp b/ydb/core/blobstorage/vdisk/common/vdisk_costmodel.cpp
index ca0969d554..3acfe26ea3 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_costmodel.cpp
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_costmodel.cpp
@@ -4,24 +4,24 @@
 namespace NKikimr {
 
     TCostModel::TCostModel(ui64 seekTimeUs, ui64 readSpeedBps, ui64 writeSpeedBps, ui64 readBlockSize,
-                           ui64 writeBlockSize, ui32 minREALHugeBlobInBytes, TBlobStorageGroupType gType) 
+                           ui64 writeBlockSize, ui32 minREALHugeBlobInBytes, TBlobStorageGroupType gType)
         : SeekTimeUs(seekTimeUs)
         , ReadSpeedBps(readSpeedBps)
         , WriteSpeedBps(writeSpeedBps)
         , ReadBlockSize(readBlockSize)
         , WriteBlockSize(writeBlockSize)
         , MinREALHugeBlobInBytes(minREALHugeBlobInBytes)
-        , GType(gType) 
+        , GType(gType)
     {}
 
-    TCostModel::TCostModel(const NKikimrBlobStorage::TVDiskCostSettings &settings, TBlobStorageGroupType gType) 
+    TCostModel::TCostModel(const NKikimrBlobStorage::TVDiskCostSettings &settings, TBlobStorageGroupType gType)
         : SeekTimeUs(settings.GetSeekTimeUs())
         , ReadSpeedBps(settings.GetReadSpeedBps())
         , WriteSpeedBps(settings.GetWriteSpeedBps())
         , ReadBlockSize(settings.GetReadBlockSize())
         , WriteBlockSize(settings.GetWriteBlockSize())
         , MinREALHugeBlobInBytes(settings.GetMinREALHugeBlobInBytes())
-        , GType(gType) 
+        , GType(gType)
     {}
 
     void TCostModel::FillInSettings(NKikimrBlobStorage::TVDiskCostSettings &settings) const {
@@ -33,26 +33,26 @@ namespace NKikimr {
         settings.SetMinREALHugeBlobInBytes(MinREALHugeBlobInBytes);
     }
 
-    ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVPatchStart &) const { 
-        return InMemReadCost(); 
-    } 
- 
-    ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVPatchDiff &ev) const { 
-        TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(ev.Record.GetPatchedPartBlobId()); 
-        ui32 size = blobId.BlobSize(); 
-        return ReadCostBySize(size) + HugeWriteCost(size); 
-    } 
- 
-    ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVPatchXorDiff &ev) const { 
-        const ui64 bufSize = ev.DiffSizeSum(); 
-        return HugeWriteCost(bufSize); 
-    } 
- 
-    ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVMovedPatch &ev) const { 
-        TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(ev.Record.GetPatchedBlobId()); 
-        return MovedPatchCostBySize(blobId.BlobSize()); 
-    } 
- 
+    ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVPatchStart &) const {
+        return InMemReadCost();
+    }
+
+    ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVPatchDiff &ev) const {
+        TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(ev.Record.GetPatchedPartBlobId());
+        ui32 size = blobId.BlobSize();
+        return ReadCostBySize(size) + HugeWriteCost(size);
+    }
+
+    ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVPatchXorDiff &ev) const {
+        const ui64 bufSize = ev.DiffSizeSum();
+        return HugeWriteCost(bufSize);
+    }
+
+    ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVMovedPatch &ev) const {
+        TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(ev.Record.GetPatchedBlobId());
+        return MovedPatchCostBySize(blobId.BlobSize());
+    }
+
     ui64 TCostModel::GetCost(const TEvBlobStorage::TEvVPut &ev, bool *logPutInternalQueue) const {
         const auto &record = ev.Record;
         const NKikimrBlobStorage::EPutHandleClass handleClass = record.GetHandleClass();
@@ -86,18 +86,18 @@ namespace NKikimr {
         return cost;
     }
 
-    ui64 TCostModel::MovedPatchCostBySize(ui32 blobSize) const { 
-        ui32 partSize = GType.TErasureType::PartSize(TErasureType::CrcModeNone, blobSize); 
-        ui32 memMultiply = 3; // in the worst case (buffer + parts + serealized events) 
-        return memMultiply * GType.TotalPartCount() * (ReadCostBySize(partSize) + HugeWriteCost(partSize)); 
-    } 
- 
-    ui64 TCostModel::ReadCostBySize(ui64 size) const { 
-        ui64 seekCost = (size / ReadBlockSize + 1) * SeekTimeUs; 
-        ui64 readCost = size * ui64(1000000000) / ReadSpeedBps; 
-        return seekCost + readCost; 
-    } 
- 
+    ui64 TCostModel::MovedPatchCostBySize(ui32 blobSize) const {
+        ui32 partSize = GType.TErasureType::PartSize(TErasureType::CrcModeNone, blobSize);
+        ui32 memMultiply = 3; // in the worst case (buffer + parts + serealized events)
+        return memMultiply * GType.TotalPartCount() * (ReadCostBySize(partSize) + HugeWriteCost(partSize));
+    }
+
+    ui64 TCostModel::ReadCostBySize(ui64 size) const {
+        ui64 seekCost = (size / ReadBlockSize + 1) * SeekTimeUs;
+        ui64 readCost = size * ui64(1000000000) / ReadSpeedBps;
+        return seekCost + readCost;
+    }
+
     ui64 TCostModel::ReadCost(const TEvBlobStorage::TEvVGet &ev) const {
         const auto &record = ev.Record;
         ui64 cost = 0;
@@ -123,7 +123,7 @@ namespace NKikimr {
                 size = id.BlobSize();
             }
 
-            cost += ReadCostBySize(size); 
+            cost += ReadCostBySize(size);
         }
 
         Y_VERIFY_DEBUG(cost);
@@ -133,14 +133,14 @@ namespace NKikimr {
     ui64 TCostModel::CalculateCost(const TMessageCostEssence& essence) const {
         ui64 cost = essence.BaseCost;
         for (ui64 size : essence.ReadSizes) {
-            cost += ReadCostBySize(size); 
+            cost += ReadCostBySize(size);
         }
         if (essence.SmallWriteSize != -1) {
             cost += SmallWriteCost(essence.SmallWriteSize);
         }
-        if (essence.MovedPatchBlobSize != -1) { 
-            cost += MovedPatchCostBySize(essence.MovedPatchBlobSize); 
-        } 
+        if (essence.MovedPatchBlobSize != -1) {
+            cost += MovedPatchCostBySize(essence.MovedPatchBlobSize);
+        }
         for (ui64 size : essence.PutBufferSizes) {
             NPriPut::EHandleType handleType = NPriPut::HandleType(MinREALHugeBlobInBytes, essence.HandleClass, size);
             if (handleType == NPriPut::Log) {
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_costmodel.h b/ydb/core/blobstorage/vdisk/common/vdisk_costmodel.h
index 4717a5f3d0..eb16996c30 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_costmodel.h
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_costmodel.h
@@ -17,10 +17,10 @@ namespace NKikimr {
             friend class TCostModel;
 
             ui64 BaseCost = 0;
-            i32 SmallWriteSize = -1; 
-            i32 MovedPatchBlobSize = -1; 
-            TStackVec<i32, 1> PutBufferSizes; 
-            TVector<ui32> ReadSizes; // FIXME: optimize 
+            i32 SmallWriteSize = -1;
+            i32 MovedPatchBlobSize = -1;
+            TStackVec<i32, 1> PutBufferSizes;
+            TVector<ui32> ReadSizes; // FIXME: optimize
             // handle class for TEvPut and TEvMultiPut only
             NKikimrBlobStorage::EPutHandleClass HandleClass = NKikimrBlobStorage::TabletLog;
 
@@ -70,34 +70,34 @@ namespace NKikimr {
                 : SmallWriteSize(ev.GetCachedByteSize())
             {}
 
-            TMessageCostEssence(const TEvBlobStorage::TEvVMovedPatch& ev) 
-                : HandleClass(NKikimrBlobStorage::EPutHandleClass::AsyncBlob) 
-            { 
-                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev.Record.GetOriginalBlobId()); 
-                MovedPatchBlobSize = id.BlobSize(); 
-            } 
- 
-            TMessageCostEssence(const TEvBlobStorage::TEvVPatchStart&) 
-                : BaseCost(TCostModel::InMemReadCost(EInMemType::Read)) 
-                , HandleClass(NKikimrBlobStorage::EPutHandleClass::AsyncBlob) 
-            { 
-            } 
- 
-            TMessageCostEssence(const TEvBlobStorage::TEvVPatchDiff& ev) 
-                : HandleClass(NKikimrBlobStorage::EPutHandleClass::AsyncBlob) 
-            { 
-                // it has range vget subquery for finding parts 
-                TLogoBlobID id(LogoBlobIDFromLogoBlobID(ev.Record.GetOriginalPartBlobId())); 
-                ReadSizes.push_back(id.BlobSize()); 
-                PutBufferSizes.push_back(id.BlobSize()); 
-            } 
- 
-            TMessageCostEssence(const TEvBlobStorage::TEvVPatchXorDiff& ev) 
-                : HandleClass(NKikimrBlobStorage::EPutHandleClass::AsyncBlob) 
-            { 
-                PutBufferSizes.push_back(ev.DiffSizeSum()); 
-            } 
- 
+            TMessageCostEssence(const TEvBlobStorage::TEvVMovedPatch& ev)
+                : HandleClass(NKikimrBlobStorage::EPutHandleClass::AsyncBlob)
+            {
+                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev.Record.GetOriginalBlobId());
+                MovedPatchBlobSize = id.BlobSize();
+            }
+
+            TMessageCostEssence(const TEvBlobStorage::TEvVPatchStart&)
+                : BaseCost(TCostModel::InMemReadCost(EInMemType::Read))
+                , HandleClass(NKikimrBlobStorage::EPutHandleClass::AsyncBlob)
+            {
+            }
+
+            TMessageCostEssence(const TEvBlobStorage::TEvVPatchDiff& ev)
+                : HandleClass(NKikimrBlobStorage::EPutHandleClass::AsyncBlob)
+            {
+                // it has range vget subquery for finding parts
+                TLogoBlobID id(LogoBlobIDFromLogoBlobID(ev.Record.GetOriginalPartBlobId()));
+                ReadSizes.push_back(id.BlobSize());
+                PutBufferSizes.push_back(id.BlobSize());
+            }
+
+            TMessageCostEssence(const TEvBlobStorage::TEvVPatchXorDiff& ev)
+                : HandleClass(NKikimrBlobStorage::EPutHandleClass::AsyncBlob)
+            {
+                PutBufferSizes.push_back(ev.DiffSizeSum());
+            }
+
             TMessageCostEssence(const TEvBlobStorage::TEvVPut& ev)
                 : HandleClass(ev.Record.GetHandleClass())
             {
@@ -124,11 +124,11 @@ namespace NKikimr {
         ui64 ReadBlockSize;
         ui64 WriteBlockSize;
         ui32 MinREALHugeBlobInBytes;
-        TBlobStorageGroupType GType; 
+        TBlobStorageGroupType GType;
 
         TCostModel(ui64 seekTimeUs, ui64 readSpeedBps, ui64 writeSpeedBps, ui64 readBlockSize, ui64 writeBlockSize,
-                   ui32 minREALHugeBlobInBytes, TBlobStorageGroupType gType); 
-        TCostModel(const NKikimrBlobStorage::TVDiskCostSettings &settings, TBlobStorageGroupType gType); 
+                   ui32 minREALHugeBlobInBytes, TBlobStorageGroupType gType);
+        TCostModel(const NKikimrBlobStorage::TVDiskCostSettings &settings, TBlobStorageGroupType gType);
 
         /// SETTINGS
         void FillInSettings(NKikimrBlobStorage::TVDiskCostSettings &settings) const;
@@ -164,11 +164,11 @@ namespace NKikimr {
             return GetCost(ev, &logPutInternalQueue);
         }
 
-        ui64 GetCost(const TEvBlobStorage::TEvVPatchStart &ev) const; 
-        ui64 GetCost(const TEvBlobStorage::TEvVPatchDiff &ev) const; 
-        ui64 GetCost(const TEvBlobStorage::TEvVPatchXorDiff &ev) const; 
-        ui64 GetCost(const TEvBlobStorage::TEvVMovedPatch &ev) const; 
- 
+        ui64 GetCost(const TEvBlobStorage::TEvVPatchStart &ev) const;
+        ui64 GetCost(const TEvBlobStorage::TEvVPatchDiff &ev) const;
+        ui64 GetCost(const TEvBlobStorage::TEvVPatchXorDiff &ev) const;
+        ui64 GetCost(const TEvBlobStorage::TEvVMovedPatch &ev) const;
+
         ui64 GetCost(const TEvBlobStorage::TEvVPut &ev, bool *logPutInternalQueue) const;
 
         ui64 GetCost(const TEvBlobStorage::TEvVMultiPut &ev, bool *logPutInternalQueue) const;
@@ -213,8 +213,8 @@ namespace NKikimr {
             return costs.at(size_t(t));
         }
 
-        ui64 MovedPatchCostBySize(ui32 blobSize) const; 
-        ui64 ReadCostBySize(ui64 size) const; 
+        ui64 MovedPatchCostBySize(ui32 blobSize) const;
+        ui64 ReadCostBySize(ui64 size) const;
         ui64 ReadCost(const TEvBlobStorage::TEvVGet &ev) const;
     };
 
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_events.cpp b/ydb/core/blobstorage/vdisk/common/vdisk_events.cpp
index 9d972a37bc..25a0e24320 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_events.cpp
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_events.cpp
@@ -42,26 +42,26 @@ namespace NKikimr {
         }
     }
 
-    void TEvBlobStorage::TEvVPut::StorePayload(TRope&& buffer) { 
-        Y_VERIFY(KIKIMR_USE_PROTOBUF_WITH_PAYLOAD); 
-        AddPayload(std::move(buffer)); 
-    } 
- 
-    void TEvBlobStorage::TEvVMultiPut::StorePayload(NKikimrBlobStorage::TVMultiPutItem &item, const TString& buffer) { 
-        if (KIKIMR_USE_PROTOBUF_WITH_PAYLOAD) { 
+    void TEvBlobStorage::TEvVPut::StorePayload(TRope&& buffer) {
+        Y_VERIFY(KIKIMR_USE_PROTOBUF_WITH_PAYLOAD);
+        AddPayload(std::move(buffer));
+    }
+
+    void TEvBlobStorage::TEvVMultiPut::StorePayload(NKikimrBlobStorage::TVMultiPutItem &item, const TString& buffer) {
+        if (KIKIMR_USE_PROTOBUF_WITH_PAYLOAD) {
             AddPayload(TRope(buffer));
             Y_VERIFY_DEBUG(Record.ItemsSize() == GetPayloadCount());
-        } else { 
-            item.SetBuffer(buffer); 
-        } 
-    } 
- 
-    TRope TEvBlobStorage::TEvVMultiPut::GetItemBuffer(ui64 itemIdx) const { 
-        auto &item = Record.GetItems(itemIdx); 
-        if (item.HasBuffer()) { 
+        } else {
+            item.SetBuffer(buffer);
+        }
+    }
+
+    TRope TEvBlobStorage::TEvVMultiPut::GetItemBuffer(ui64 itemIdx) const {
+        auto &item = Record.GetItems(itemIdx);
+        if (item.HasBuffer()) {
             return TRope(item.GetBuffer());
-        } else { 
-            return GetPayload(itemIdx); 
-        } 
-    } 
+        } else {
+            return GetPayload(itemIdx);
+        }
+    }
 } // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_events.h b/ydb/core/blobstorage/vdisk/common/vdisk_events.h
index 6173a1fe39..47fbd959c9 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_events.h
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_events.h
@@ -38,7 +38,7 @@ namespace NKikimr {
             ReplJob,
             DSProxy,
             VDiskLoad,
-            VPatch, 
+            VPatch,
         };
 
         inline const char *EQueueClientType2String(EQueueClientType t) {
@@ -47,7 +47,7 @@ namespace NKikimr {
                 case EQueueClientType::ReplJob:     return "ReplJob";
                 case EQueueClientType::DSProxy:     return "DSProxy";
                 case EQueueClientType::VDiskLoad:   return "VDiskLoad";
-                case EQueueClientType::VPatch:   return "VPatch"; 
+                case EQueueClientType::VPatch:   return "VPatch";
             }
 
             Y_FAIL("unexpected EQueueClientType");
@@ -87,11 +87,11 @@ namespace NKikimr {
                         Identifier = msgQoS.GetVDiskLoadId();
                         break;
 
-                    case NKikimrBlobStorage::TMsgQoS::ClientIdCase::kVPatchVDiskId: 
-                        Type = EQueueClientType::VPatch; 
-                        Identifier = msgQoS.GetVPatchVDiskId(); 
-                        break; 
- 
+                    case NKikimrBlobStorage::TMsgQoS::ClientIdCase::kVPatchVDiskId:
+                        Type = EQueueClientType::VPatch;
+                        Identifier = msgQoS.GetVPatchVDiskId();
+                        break;
+
                     case NKikimrBlobStorage::TMsgQoS::ClientIdCase::CLIENTID_NOT_SET:
                         Type = EQueueClientType::None;
                         Identifier = 0;
@@ -118,10 +118,10 @@ namespace NKikimr {
                     case EQueueClientType::VDiskLoad:
                         msgQoS->SetVDiskLoadId(Identifier);
                         break;
- 
-                    case EQueueClientType::VPatch: 
-                        msgQoS->SetVPatchVDiskId(Identifier); 
-                        break; 
+
+                    case EQueueClientType::VPatch:
+                        msgQoS->SetVPatchVDiskId(Identifier);
+                        break;
                 }
             }
 
@@ -491,10 +491,10 @@ namespace NKikimr {
         }
     };
 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
-    // TEvVPut 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
- 
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // TEvVPut
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
     struct TEvBlobStorage::TEvVPut
             : public TEventPB<TEvBlobStorage::TEvVPut, NKikimrBlobStorage::TEvVPut, TEvBlobStorage::EvVPut> {
         // In current realization it is intentionaly lost on event serialization since
@@ -508,22 +508,22 @@ namespace NKikimr {
                 const bool ignoreBlock, const ui64 *cookie, TInstant deadline,
                 NKikimrBlobStorage::EPutHandleClass cls)
         {
-            InitWithoutBuffer(logoBlobId, vdisk, ignoreBlock, cookie, deadline, cls); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(buffer.Data(), buffer.size()); 
-            StorePayload(buffer); 
-        } 
- 
-        TEvVPut(const TLogoBlobID &logoBlobId, TRope buffer, const TVDiskID &vdisk, 
-                const bool ignoreBlock, const ui64 *cookie, TInstant deadline, 
-                NKikimrBlobStorage::EPutHandleClass cls) 
-        { 
-            InitWithoutBuffer(logoBlobId, vdisk, ignoreBlock, cookie, deadline, cls); 
-            StorePayload(std::move(buffer)); 
-        } 
- 
-        void InitWithoutBuffer(const TLogoBlobID &logoBlobId, const TVDiskID &vdisk, const bool ignoreBlock, 
-                const ui64 *cookie, TInstant deadline, NKikimrBlobStorage::EPutHandleClass cls) 
-        { 
+            InitWithoutBuffer(logoBlobId, vdisk, ignoreBlock, cookie, deadline, cls);
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(buffer.Data(), buffer.size());
+            StorePayload(buffer);
+        }
+
+        TEvVPut(const TLogoBlobID &logoBlobId, TRope buffer, const TVDiskID &vdisk,
+                const bool ignoreBlock, const ui64 *cookie, TInstant deadline,
+                NKikimrBlobStorage::EPutHandleClass cls)
+        {
+            InitWithoutBuffer(logoBlobId, vdisk, ignoreBlock, cookie, deadline, cls);
+            StorePayload(std::move(buffer));
+        }
+
+        void InitWithoutBuffer(const TLogoBlobID &logoBlobId, const TVDiskID &vdisk, const bool ignoreBlock,
+                const ui64 *cookie, TInstant deadline, NKikimrBlobStorage::EPutHandleClass cls)
+        {
             REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&logoBlobId, sizeof(logoBlobId));
             REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&vdisk, sizeof(vdisk));
             REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&ignoreBlock, sizeof(ignoreBlock));
@@ -551,14 +551,14 @@ namespace NKikimr {
             return Record.GetIgnoreBlock();
         }
 
-        TRope GetBuffer() const { 
-            return Record.HasBuffer() ? TRope(Record.GetBuffer()) : GetPayload(0); 
-        } 
- 
+        TRope GetBuffer() const {
+            return Record.HasBuffer() ? TRope(Record.GetBuffer()) : GetPayload(0);
+        }
+
         void StorePayload(const TString& buffer);
 
-        void StorePayload(TRope&& buffer); 
- 
+        void StorePayload(TRope&& buffer);
+
         ui64 GetBufferBytes() const {
             if (KIKIMR_USE_PROTOBUF_WITH_PAYLOAD) {
                 ui64 sizeBytes = 0;
@@ -760,32 +760,32 @@ namespace NKikimr {
 
     struct TEvBlobStorage::TEvVMultiPut
         : public TEventPB<TEvBlobStorage::TEvVMultiPut, NKikimrBlobStorage::TEvVMultiPut, TEvBlobStorage::EvVMultiPut>
-    { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVMultiPut() = default; 
- 
-        TEvVMultiPut(const TVDiskID &vdisk, TInstant deadline, NKikimrBlobStorage::EPutHandleClass cls, 
-                     bool ignoreBlock, const ui64 *cookie = nullptr) 
-        { 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&vdisk, sizeof(vdisk)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&ignoreBlock, sizeof(ignoreBlock)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&cookie, sizeof(cookie)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&deadline, sizeof(deadline)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&cls, sizeof(cls)); 
- 
-            VDiskIDFromVDiskID(vdisk, Record.MutableVDiskID()); 
-            Record.SetIgnoreBlock(ignoreBlock); 
-            if (cookie) { 
-                Record.SetCookie(*cookie); 
-            } 
-            if (deadline != TInstant::Max()) { 
-                Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds()); 
-            } 
-            Record.SetHandleClass(cls); 
-            Record.MutableMsgQoS()->SetExtQueueId(HandleClassToQueueId(cls)); 
-        } 
- 
+    {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVMultiPut() = default;
+
+        TEvVMultiPut(const TVDiskID &vdisk, TInstant deadline, NKikimrBlobStorage::EPutHandleClass cls,
+                     bool ignoreBlock, const ui64 *cookie = nullptr)
+        {
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&vdisk, sizeof(vdisk));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&ignoreBlock, sizeof(ignoreBlock));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&cookie, sizeof(cookie));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&deadline, sizeof(deadline));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&cls, sizeof(cls));
+
+            VDiskIDFromVDiskID(vdisk, Record.MutableVDiskID());
+            Record.SetIgnoreBlock(ignoreBlock);
+            if (cookie) {
+                Record.SetCookie(*cookie);
+            }
+            if (deadline != TInstant::Max()) {
+                Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds());
+            }
+            Record.SetHandleClass(cls);
+            Record.MutableMsgQoS()->SetExtQueueId(HandleClassToQueueId(cls));
+        }
+
         ui64 GetBufferBytes(ui64 idx) const {
             Y_VERIFY_DEBUG(idx < Record.ItemsSize());
             if (KIKIMR_USE_PROTOBUF_WITH_PAYLOAD) {
@@ -795,46 +795,46 @@ namespace NKikimr {
             }
         }
 
-        ui64 GetBufferBytes() const { 
-            ui64 bytes = 0; 
-            if (KIKIMR_USE_PROTOBUF_WITH_PAYLOAD) { 
+        ui64 GetBufferBytes() const {
+            ui64 bytes = 0;
+            if (KIKIMR_USE_PROTOBUF_WITH_PAYLOAD) {
                 ui32 size = GetPayloadCount();
-                for (ui32 i = 0; i < size; ++i) { 
-                    bytes += GetPayload(i).GetSize(); 
-                } 
-            } else { 
-                for (const auto &item : Record.GetItems()) { 
-                    bytes += item.GetBuffer().size(); 
-                } 
-            } 
-            return bytes; 
-        } 
- 
-        ui64 GetSumBlobSize() const { 
-            ui64 sum = 0; 
-            for (auto &item : Record.GetItems()) { 
-                TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-                sum += blobId.BlobSize(); 
-            } 
-            return sum; 
-        } 
- 
-        void StorePayload(NKikimrBlobStorage::TVMultiPutItem &item, const TString &buffer); 
- 
- 
-        TRope GetItemBuffer(ui64 itemIdx) const; 
- 
-        void AddVPut(const TLogoBlobID &logoBlobId, const TString &buffer, ui64 *cookie) { 
-            NKikimrBlobStorage::TVMultiPutItem *item = Record.AddItems(); 
-            LogoBlobIDFromLogoBlobID(logoBlobId, item->MutableBlobID()); 
-            item->SetFullDataSize(logoBlobId.BlobSize()); 
-            StorePayload(*item, buffer); 
-            item->SetFullDataSize(logoBlobId.BlobSize()); 
-            if (cookie) { 
-                item->SetCookie(*cookie); 
-            } 
-        } 
- 
+                for (ui32 i = 0; i < size; ++i) {
+                    bytes += GetPayload(i).GetSize();
+                }
+            } else {
+                for (const auto &item : Record.GetItems()) {
+                    bytes += item.GetBuffer().size();
+                }
+            }
+            return bytes;
+        }
+
+        ui64 GetSumBlobSize() const {
+            ui64 sum = 0;
+            for (auto &item : Record.GetItems()) {
+                TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+                sum += blobId.BlobSize();
+            }
+            return sum;
+        }
+
+        void StorePayload(NKikimrBlobStorage::TVMultiPutItem &item, const TString &buffer);
+
+
+        TRope GetItemBuffer(ui64 itemIdx) const;
+
+        void AddVPut(const TLogoBlobID &logoBlobId, const TString &buffer, ui64 *cookie) {
+            NKikimrBlobStorage::TVMultiPutItem *item = Record.AddItems();
+            LogoBlobIDFromLogoBlobID(logoBlobId, item->MutableBlobID());
+            item->SetFullDataSize(logoBlobId.BlobSize());
+            StorePayload(*item, buffer);
+            item->SetFullDataSize(logoBlobId.BlobSize());
+            if (cookie) {
+                item->SetCookie(*cookie);
+            }
+        }
+
         bool Validate(TString& errorReason) {
             if (Record.ItemsSize() == 0) {
                 errorReason =  "TEvVMultiPut rejected by VDisk. It has 0 blobs to put";
@@ -853,172 +853,172 @@ namespace NKikimr {
             return false;
         }
 
-        TString ToString() const override { 
-            TStringStream str; 
-            str << "{EvVMultiPut"; 
-            ui64 size = Record.ItemsSize(); 
-            for (ui64 itemIdx = 0; itemIdx < size; ++itemIdx) { 
-                const NKikimrBlobStorage::TVMultiPutItem &item = Record.GetItems(itemIdx); 
-                str << " Item# {VMultiPutItem"; 
-                TLogoBlobID id = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-                str << " ID# " << id.ToString(); 
-                str << " FullDataSize# " << item.GetFullDataSize(); 
-                TString data = GetItemBuffer(itemIdx).ConvertToString(); 
-                str << " DataSize# " << data.size(); 
-                if (data.size() > 16) { 
-                    str << " Data# <too_large>"; 
-                } else { 
-                    str << " Data# " << data; 
-                } 
-                if (item.HasCookie()) { 
-                    str << " Cookie# " << item.GetCookie(); 
-                } 
-                str << "}"; 
-            } 
- 
-            str << " VDiskId# " << VDiskIDFromVDiskID(Record.GetVDiskID()); 
- 
-            if (Record.GetIgnoreBlock()) { 
-                str << " IgnoreBlock"; 
-            } 
-            if (Record.HasHandleClass()) { 
-                str << " HandleClass# " << Record.GetHandleClass(); 
-            } 
-            if (Record.HasMsgQoS()) { 
-                str << " "; 
-                TEvBlobStorage::TEvVPut::OutMsgQos(Record.GetMsgQoS(), str); 
-            } 
-            if (Record.HasCookie()) { 
-                str << " Cookie# " << Record.GetCookie(); 
-            } 
-            str << "}"; 
-            return str.Str(); 
-        } 
-    }; 
- 
+        TString ToString() const override {
+            TStringStream str;
+            str << "{EvVMultiPut";
+            ui64 size = Record.ItemsSize();
+            for (ui64 itemIdx = 0; itemIdx < size; ++itemIdx) {
+                const NKikimrBlobStorage::TVMultiPutItem &item = Record.GetItems(itemIdx);
+                str << " Item# {VMultiPutItem";
+                TLogoBlobID id = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+                str << " ID# " << id.ToString();
+                str << " FullDataSize# " << item.GetFullDataSize();
+                TString data = GetItemBuffer(itemIdx).ConvertToString();
+                str << " DataSize# " << data.size();
+                if (data.size() > 16) {
+                    str << " Data# <too_large>";
+                } else {
+                    str << " Data# " << data;
+                }
+                if (item.HasCookie()) {
+                    str << " Cookie# " << item.GetCookie();
+                }
+                str << "}";
+            }
+
+            str << " VDiskId# " << VDiskIDFromVDiskID(Record.GetVDiskID());
+
+            if (Record.GetIgnoreBlock()) {
+                str << " IgnoreBlock";
+            }
+            if (Record.HasHandleClass()) {
+                str << " HandleClass# " << Record.GetHandleClass();
+            }
+            if (Record.HasMsgQoS()) {
+                str << " ";
+                TEvBlobStorage::TEvVPut::OutMsgQos(Record.GetMsgQoS(), str);
+            }
+            if (Record.HasCookie()) {
+                str << " Cookie# " << Record.GetCookie();
+            }
+            str << "}";
+            return str.Str();
+        }
+    };
+
     struct TEvBlobStorage::TEvVMultiPutResult
         : public TEvVResultBaseWithQoSPB<TEvBlobStorage::TEvVMultiPutResult,
                 NKikimrBlobStorage::TEvVMultiPutResult,
-                TEvBlobStorage::EvVMultiPutResult> 
-    { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVMultiPutResult() = default; 
- 
+                TEvBlobStorage::EvVMultiPutResult>
+    {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVMultiPutResult() = default;
+
         TEvVMultiPutResult(const NKikimrProto::EReplyStatus status, const TVDiskID &vdisk, const ui64 *cookie,
                 const TInstant &now, ui32 recByteSize, NKikimrBlobStorage::TEvVMultiPut *record,
                 const TActorIDPtr &skeletonFrontIDPtr, const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr,
                 const NVDiskMon::TLtcHistoPtr &histoPtr, const ui64 bufferSizeBytes, NWilson::TTraceId traceId,
                 ui64 incarnationGuid, const TString& errorReason)
-            : TEvVResultBaseWithQoSPB(now, counterPtr, histoPtr, std::move(traceId), 
-                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, recByteSize, record, skeletonFrontIDPtr) 
-        { 
+            : TEvVResultBaseWithQoSPB(now, counterPtr, histoPtr, std::move(traceId),
+                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, recByteSize, record, skeletonFrontIDPtr)
+        {
             IncrementSize(bufferSizeBytes);
-            Record.SetStatus(status); 
-            VDiskIDFromVDiskID(vdisk, Record.MutableVDiskID()); 
-            if (cookie) { 
-                Record.SetCookie(*cookie); 
-            } 
-            if (record && record->HasTimestamps()) { 
-                Record.MutableTimestamps()->CopyFrom(record->GetTimestamps()); 
-            } 
+            Record.SetStatus(status);
+            VDiskIDFromVDiskID(vdisk, Record.MutableVDiskID());
+            if (cookie) {
+                Record.SetCookie(*cookie);
+            }
+            if (record && record->HasTimestamps()) {
+                Record.MutableTimestamps()->CopyFrom(record->GetTimestamps());
+            }
             if (status == NKikimrProto::OK) {
                 Record.SetIncarnationGuid(incarnationGuid);
             }
             if (errorReason && status != NKikimrProto::OK) {
                 Record.SetErrorReason(errorReason);
             }
-        } 
- 
+        }
+
         void AddVPutResult(NKikimrProto::EReplyStatus status, const TString& errorReason, const TLogoBlobID &logoBlobId,
                 ui64 *cookie, ui32 statusFlags = 0)
-        { 
-            NKikimrBlobStorage::TVMultiPutResultItem *item = Record.AddItems(); 
-            item->SetStatus(status); 
+        {
+            NKikimrBlobStorage::TVMultiPutResultItem *item = Record.AddItems();
+            item->SetStatus(status);
             if (errorReason && status != NKikimrProto::OK) {
                 item->SetErrorReason(errorReason);
             }
-            LogoBlobIDFromLogoBlobID(logoBlobId, item->MutableBlobID()); 
-            if (cookie) { 
-                item->SetCookie(*cookie); 
-            } 
-            item->SetStatusFlags(statusFlags); 
-        } 
- 
+            LogoBlobIDFromLogoBlobID(logoBlobId, item->MutableBlobID());
+            if (cookie) {
+                item->SetCookie(*cookie);
+            }
+            item->SetStatusFlags(statusFlags);
+        }
+
         void MakeError(NKikimrProto::EReplyStatus status, const TString& errorReason,
                 const NKikimrBlobStorage::TEvVMultiPut &request) {
-            Record.SetStatus(status); 
+            Record.SetStatus(status);
             if (errorReason && status != NKikimrProto::OK) {
                 Record.SetErrorReason(errorReason);
             }
             if (status == NKikimrProto::NOTREADY) {
                 status = NKikimrProto::ERROR; // treat BS_QUEUE internally generated NOTREADY as ERROR
             }
- 
-            for (auto &item : request.GetItems()) { 
-                Y_VERIFY(item.HasBlobID()); 
-                TLogoBlobID logoBlobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-                ui64 cookieValue = 0; 
-                ui64 *cookie = nullptr; 
-                if (item.HasCookie()) { 
-                    cookieValue = item.GetCookie(); 
-                    cookie = &cookieValue; 
-                } 
+
+            for (auto &item : request.GetItems()) {
+                Y_VERIFY(item.HasBlobID());
+                TLogoBlobID logoBlobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+                ui64 cookieValue = 0;
+                ui64 *cookie = nullptr;
+                if (item.HasCookie()) {
+                    cookieValue = item.GetCookie();
+                    cookie = &cookieValue;
+                }
                 AddVPutResult(status, errorReason, logoBlobId, cookie);
-            } 
+            }
 
             if (request.HasVDiskID()) {
                 Record.MutableVDiskID()->CopyFrom(request.GetVDiskID());
             }
-            if (request.HasCookie()) { 
-                Record.SetCookie(request.GetCookie()); 
-            } 
-            if (request.HasTimestamps()) { 
-                Record.MutableTimestamps()->CopyFrom(request.GetTimestamps()); 
-            } 
-        } 
- 
-        TString ToString() const override { 
-            return ToString(Record); 
-        } 
- 
-        static TString ToString(const NKikimrBlobStorage::TEvVMultiPutResult &record) { 
-            TStringStream str; 
-            str << "{EvVMultiPutResult Status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()).data(); 
+            if (request.HasCookie()) {
+                Record.SetCookie(request.GetCookie());
+            }
+            if (request.HasTimestamps()) {
+                Record.MutableTimestamps()->CopyFrom(request.GetTimestamps());
+            }
+        }
+
+        TString ToString() const override {
+            return ToString(Record);
+        }
+
+        static TString ToString(const NKikimrBlobStorage::TEvVMultiPutResult &record) {
+            TStringStream str;
+            str << "{EvVMultiPutResult Status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()).data();
             if (record.HasErrorReason()) {
                 str << " ErrorReason# " << '"' << EscapeC(record.GetErrorReason()) << '"';
             }
-            ui64 size = record.ItemsSize(); 
-            for (ui64 itemIdx = 0; itemIdx < size; ++itemIdx) { 
-                const NKikimrBlobStorage::TVMultiPutResultItem &item = record.GetItems(itemIdx); 
-                str << " Item# {VMultiPutResultItem"; 
-                str << " Status# " << NKikimrProto::EReplyStatus_Name(item.GetStatus()).data(); 
+            ui64 size = record.ItemsSize();
+            for (ui64 itemIdx = 0; itemIdx < size; ++itemIdx) {
+                const NKikimrBlobStorage::TVMultiPutResultItem &item = record.GetItems(itemIdx);
+                str << " Item# {VMultiPutResultItem";
+                str << " Status# " << NKikimrProto::EReplyStatus_Name(item.GetStatus()).data();
                 if (item.HasErrorReason()) {
                     str << " ErrorReason# " << '"' << EscapeC(item.GetErrorReason()) << '"';
                 }
-                TLogoBlobID id = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-                str << " ID# " << id.ToString(); 
-                if (item.HasCookie()) { 
-                    str << " Cookie# " << item.GetCookie(); 
-                } 
-                str << "}"; 
-            } 
-            if (record.HasMsgQoS()) { 
-                str << " "; 
-                TEvBlobStorage::TEvVPut::OutMsgQos(record.GetMsgQoS(), str); 
-            } 
-            if (record.HasCookie()) { 
-                str << " Cookie# " << record.GetCookie(); 
-            } 
-            str << "}"; 
-            return str.Str(); 
-        } 
-    }; 
- 
+                TLogoBlobID id = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+                str << " ID# " << id.ToString();
+                if (item.HasCookie()) {
+                    str << " Cookie# " << item.GetCookie();
+                }
+                str << "}";
+            }
+            if (record.HasMsgQoS()) {
+                str << " ";
+                TEvBlobStorage::TEvVPut::OutMsgQos(record.GetMsgQoS(), str);
+            }
+            if (record.HasCookie()) {
+                str << " Cookie# " << record.GetCookie();
+            }
+            str << "}";
+            return str.Str();
+        }
+    };
+
     //////////////////////////////////////////////////////////////////////////////////////////////
     // VGet
     //////////////////////////////////////////////////////////////////////////////////////////////
- 
+
     struct TEvBlobStorage::TEvVGet
         : public TEventPB<TEvBlobStorage::TEvVGet, NKikimrBlobStorage::TEvVGet, TEvBlobStorage::EvVGet>
     {
@@ -1383,297 +1383,297 @@ namespace NKikimr {
         }
     };
 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
-    // VPatch 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
- 
-    template <typename TEv, typename TRecord, ui32 EventType> 
-    struct TEvVSpecialPatchBase 
-            : public TEventPB<TEv, TRecord, EventType> { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVSpecialPatchBase() = default; 
- 
-        TEvVSpecialPatchBase(ui32 originalGroupId, ui32 patchedGroupId, const TLogoBlobID &originalBlobId, 
-                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, bool ignoreBlock, TMaybe<ui64> cookie, 
-                TInstant deadline) 
-        { 
-            InitWithoutBuffer(originalGroupId, patchedGroupId, originalBlobId, patchedBlobId, vdisk, ignoreBlock, 
-                    cookie, deadline); 
-        } 
- 
-        void InitWithoutBuffer(ui32 originalGroupId, ui32 patchedGroupId, const TLogoBlobID &originalBlobId, 
-                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, bool ignoreBlock, TMaybe<ui64> cookie, 
-                TInstant deadline) 
-        { 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&originalBlobId, sizeof(originalBlobId)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&patchedBlobId, sizeof(patchedBlobId)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&vdisk, sizeof(vdisk)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&ignoreBlock, sizeof(ignoreBlock)); 
- 
-            this->Record.SetOriginalGroupId(originalGroupId); 
-            this->Record.SetPatchedGroupId(patchedGroupId); 
- 
-            LogoBlobIDFromLogoBlobID(originalBlobId, this->Record.MutableOriginalBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedBlobId, this->Record.MutablePatchedBlobId()); 
- 
-            VDiskIDFromVDiskID(vdisk, this->Record.MutableVDiskID()); 
-            if (ignoreBlock) { 
-                this->Record.SetIgnoreBlock(ignoreBlock); 
-            } 
-            if (cookie) { 
-                this->Record.SetCookie(*cookie); 
-            } 
-            if (deadline != TInstant::Max()) { 
-                this->Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds()); 
-            } 
-            this->Record.MutableMsgQoS()->SetExtQueueId(HandleClassToQueueId(NKikimrBlobStorage::AsyncBlob)); 
-        } 
- 
-        bool GetIgnoreBlock() const { 
-            return this->Record.GetIgnoreBlock(); 
-        } 
- 
-        void AddDiff(ui64 startIdx, const TString &buffer) { 
-            TLogoBlobID id = LogoBlobIDFromLogoBlobID(this->Record.GetOriginalBlobId()); 
-            Y_VERIFY(startIdx < id.BlobSize()); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&buffer, sizeof(buffer)); 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(buffer.data(), buffer.size() + 1); 
-            Y_VERIFY(startIdx + buffer.size() <= id.BlobSize()); 
- 
-            NKikimrBlobStorage::TDiffBlock *diffBlock = this->Record.AddDiffs(); 
-            diffBlock->SetOffset(startIdx); 
-            diffBlock->SetBuffer(buffer); 
-        } 
- 
-        TString ToString() const override { 
-            return ToString(this->Record); 
-        } 
- 
-        static TString ToString(const TRecord &record) { 
-            TStringStream str; 
-            TLogoBlobID originalId = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId()); 
-            TLogoBlobID patchedId = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId()); 
-            str << "{TEvVMovedPatch"; 
-            str << " OriginalBlobId# " << originalId.ToString(); 
-            str << " PatchedBlobId# " << patchedId.ToString(); 
-            str << " OriginalGroupId# " << record.GetOriginalBlobId(); 
-            str << " PatchedGroupId# " << record.GetPatchedBlobId(); 
-            if (record.GetIgnoreBlock()) { 
-                str << " IgnoreBlock"; 
-            } 
-            if (record.HasMsgQoS()) { 
-                str << " "; 
-                TEvBlobStorage::TEvVPut::OutMsgQos(record.GetMsgQoS(), str); 
-            } 
-            str << " DiffCount# " << record.DiffsSize(); 
-            str << "}"; 
-            return str.Str(); 
-        } 
- 
-        ui32 DiffSizeSum() const { 
-            ui32 result = 0; 
-            for (auto &diff : this->Record.GetDiffs()) { 
-                result += diff.GetBuffer().size(); 
-            } 
-            return result; 
-        } 
-    }; 
- 
-    template <typename TEv, typename TRecord, ui32 EventType, typename TReqRecord> 
-    struct TEvVSpecialPatchBaseResult 
-            : public TEvVResultBaseWithQoSPB<TEv, TRecord, EventType> { 
-        using TBase = TEvVResultBaseWithQoSPB<TEv, TRecord, EventType>; 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVSpecialPatchBaseResult() = default; 
- 
-        TEvVSpecialPatchBaseResult(const NKikimrProto::EReplyStatus status, const TLogoBlobID &originalBlobId, 
-                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, TMaybe<ui64> cookie, 
-                TOutOfSpaceStatus oosStatus, const TInstant &now, ui32 recByteSize, 
-                TReqRecord *record, const TActorIDPtr &skeletonFrontIDPtr, 
-                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, const NVDiskMon::TLtcHistoPtr &histoPtr, 
-                NWilson::TTraceId traceId, ui64 incarnationGuid, const TString& errorReason) 
-            : TBase(now, counterPtr, histoPtr, std::move(traceId), 
-                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, recByteSize, record, skeletonFrontIDPtr) 
-        { 
-            this->Record.SetStatus(status); 
-            LogoBlobIDFromLogoBlobID(originalBlobId, this->Record.MutableOriginalBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedBlobId, this->Record.MutablePatchedBlobId()); 
-            VDiskIDFromVDiskID(vdisk, this->Record.MutableVDiskID()); 
-            if (cookie) { 
-                this->Record.SetCookie(*cookie); 
-            } 
-            this->Record.SetStatusFlags(oosStatus.Flags); 
-            this->Record.SetApproximateFreeSpaceShare(oosStatus.ApproximateFreeSpaceShare); 
-            if (record && record->HasTimestamps()) { 
-                this->Record.MutableTimestamps()->CopyFrom(record->GetTimestamps()); 
-            } 
-            if (status == NKikimrProto::OK) { 
-                this->Record.SetIncarnationGuid(incarnationGuid); 
-            } 
-            if (errorReason && status != NKikimrProto::OK) { 
-                this->Record.SetErrorReason(errorReason); 
-            } 
-        } 
- 
-        void UpdateStatus(const NKikimrProto::EReplyStatus status) { 
-            this->Record.SetStatus(status); 
-        } 
- 
-        TString ToString() const override { 
-            return ToString(this->Record); 
-        } 
- 
-        static TString ToString(const TRecord &record) { 
-            TStringStream str; 
-            TLogoBlobID originalId = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId()); 
-            TLogoBlobID patchedId = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId()); 
-            TVDiskID vdiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
-            str << "{EvVMovedPatchResult Status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()).data(); 
-            if (record.HasErrorReason()) { 
-                str << " ErrorReason# " << '"' << EscapeC(record.GetErrorReason()) << '"'; 
-            } 
-            str << " OriginalBlobId# " << originalId; 
-            str << " PatchedBlobId# " << patchedId; 
-            str << " VDiskId# " << vdiskId; 
-            if (record.HasCookie()) { 
-                str << " Cookie# " << record.GetCookie(); 
-            } 
-            if (record.HasMsgQoS()) { 
-                str << " "; 
-                TEvBlobStorage::TEvVPut::OutMsgQos(record.GetMsgQoS(), str); 
-            } 
-            str << "}"; 
- 
-            return str.Str(); 
-        } 
- 
-        void MakeError(NKikimrProto::EReplyStatus status, const TString& errorReason, 
-                const TReqRecord &request) { 
-            this->Record.SetStatus(status); 
-            if (status != NKikimrProto::OK && errorReason) { 
-                this->Record.SetErrorReason(errorReason); 
-            } 
-            Y_VERIFY(request.HasOriginalBlobId()); 
-            Y_VERIFY(request.HasPatchedBlobId()); 
-            TLogoBlobID originalBlobId = LogoBlobIDFromLogoBlobID(request.GetOriginalBlobId()); 
-            TLogoBlobID patchedBlobId = LogoBlobIDFromLogoBlobID(request.GetPatchedBlobId()); 
-            LogoBlobIDFromLogoBlobID(originalBlobId, this->Record.MutableOriginalBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedBlobId, this->Record.MutablePatchedBlobId()); 
- 
-            Y_VERIFY(request.HasVDiskID()); 
-            TVDiskID vDiskId = VDiskIDFromVDiskID(request.GetVDiskID()); 
-            VDiskIDFromVDiskID(vDiskId, this->Record.MutableVDiskID()); 
-            if (request.HasCookie()) { 
-                this->Record.SetCookie(request.GetCookie()); 
-            } 
-            if (request.HasTimestamps()) { 
-                this->Record.MutableTimestamps()->CopyFrom(request.GetTimestamps()); 
-            } 
-        } 
-    }; 
- 
- 
-    struct TEvBlobStorage::TEvVMovedPatch 
-        : TEvVSpecialPatchBase< 
-                TEvBlobStorage::TEvVMovedPatch, 
-                NKikimrBlobStorage::TEvVMovedPatch, 
-                TEvBlobStorage::EvVMovedPatch> 
-    { 
-        using TBase = TEvVSpecialPatchBase< 
-                TEvBlobStorage::TEvVMovedPatch, 
-                NKikimrBlobStorage::TEvVMovedPatch, 
-                TEvBlobStorage::EvVMovedPatch>; 
- 
-        TEvVMovedPatch() = default; 
- 
-        TEvVMovedPatch(ui32 originalGroupId, ui32 patchedGroupId, const TLogoBlobID &originalBlobId, 
-                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, bool ignoreBlock, TMaybe<ui64> cookie, 
-                TInstant deadline) 
-            : TBase(originalGroupId, patchedGroupId, originalBlobId, patchedBlobId, vdisk, ignoreBlock, 
-                    cookie, deadline) 
-        {} 
-    }; 
- 
-    struct TEvBlobStorage::TEvVMovedPatchResult 
-        : TEvVSpecialPatchBaseResult< 
-                TEvBlobStorage::TEvVMovedPatchResult, 
-                NKikimrBlobStorage::TEvVMovedPatchResult, 
-                TEvBlobStorage::EvVMovedPatchResult, 
-                NKikimrBlobStorage::TEvVMovedPatch> 
-    { 
-        using TBase = TEvVSpecialPatchBaseResult< 
-                TEvBlobStorage::TEvVMovedPatchResult, 
-                NKikimrBlobStorage::TEvVMovedPatchResult, 
-                TEvBlobStorage::EvVMovedPatchResult, 
-                NKikimrBlobStorage::TEvVMovedPatch>; 
- 
-        TEvVMovedPatchResult() = default; 
- 
-        TEvVMovedPatchResult(const NKikimrProto::EReplyStatus status, const TLogoBlobID &originalBlobId, 
-                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, TMaybe<ui64> cookie, 
-                TOutOfSpaceStatus oosStatus, const TInstant &now, ui32 recByteSize, 
-                NKikimrBlobStorage::TEvVMovedPatch *record, const TActorIDPtr &skeletonFrontIDPtr, 
-                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, const NVDiskMon::TLtcHistoPtr &histoPtr, 
-                NWilson::TTraceId traceId, ui64 incarnationGuid, const TString& errorReason) 
-            : TBase(status, originalBlobId, patchedBlobId, vdisk, cookie, oosStatus, now, recByteSize, 
-                    record, skeletonFrontIDPtr, counterPtr, histoPtr, std::move(traceId), incarnationGuid, errorReason) 
-        {} 
-    }; 
- 
- 
-    struct TEvBlobStorage::TEvVInplacePatch 
-        : TEvVSpecialPatchBase< 
-                TEvBlobStorage::TEvVInplacePatch, 
-                NKikimrBlobStorage::TEvVInplacePatch, 
-                TEvBlobStorage::EvVInplacePatch> 
-    { 
-        using TBase = TEvVSpecialPatchBase< 
-                TEvBlobStorage::TEvVInplacePatch, 
-                NKikimrBlobStorage::TEvVInplacePatch, 
-                TEvBlobStorage::EvVInplacePatch>; 
- 
-        TEvVInplacePatch() = default; 
- 
-        TEvVInplacePatch(ui32 originalGroupId, ui32 patchedGroupId, const TLogoBlobID &originalBlobId, 
-                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, bool ignoreBlock, TMaybe<ui64> cookie, 
-                TInstant deadline) 
-            : TBase(originalGroupId, patchedGroupId, originalBlobId, patchedBlobId, vdisk, ignoreBlock, 
-                    cookie, deadline) 
-        {} 
-    }; 
- 
-    struct TEvBlobStorage::TEvVInplacePatchResult 
-        : TEvVSpecialPatchBaseResult< 
-                TEvBlobStorage::TEvVInplacePatchResult, 
-                NKikimrBlobStorage::TEvVInplacePatchResult, 
-                TEvBlobStorage::EvVInplacePatchResult, 
-                NKikimrBlobStorage::TEvVInplacePatch> 
-    { 
-        using TBase = TEvVSpecialPatchBaseResult< 
-                TEvBlobStorage::TEvVInplacePatchResult, 
-                NKikimrBlobStorage::TEvVInplacePatchResult, 
-                TEvBlobStorage::EvVInplacePatchResult, 
-                NKikimrBlobStorage::TEvVInplacePatch>; 
- 
-        TEvVInplacePatchResult() = default; 
- 
-        TEvVInplacePatchResult(const NKikimrProto::EReplyStatus status, const TLogoBlobID &originalBlobId, 
-                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, TMaybe<ui64> cookie, 
-                TOutOfSpaceStatus oosStatus, const TInstant &now, ui32 recByteSize, 
-                NKikimrBlobStorage::TEvVInplacePatch *record, const TActorIDPtr &skeletonFrontIDPtr, 
-                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, const NVDiskMon::TLtcHistoPtr &histoPtr, 
-                NWilson::TTraceId traceId, ui64 incarnationGuid, const TString& errorReason) 
-            : TBase(status, originalBlobId, patchedBlobId, vdisk, cookie, oosStatus, now, recByteSize, 
-                    record, skeletonFrontIDPtr, counterPtr, histoPtr, std::move(traceId), incarnationGuid, errorReason) 
-        {} 
-    }; 
- 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
-    // VBLOCK 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
- 
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // VPatch
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    template <typename TEv, typename TRecord, ui32 EventType>
+    struct TEvVSpecialPatchBase
+            : public TEventPB<TEv, TRecord, EventType> {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVSpecialPatchBase() = default;
+
+        TEvVSpecialPatchBase(ui32 originalGroupId, ui32 patchedGroupId, const TLogoBlobID &originalBlobId,
+                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, bool ignoreBlock, TMaybe<ui64> cookie,
+                TInstant deadline)
+        {
+            InitWithoutBuffer(originalGroupId, patchedGroupId, originalBlobId, patchedBlobId, vdisk, ignoreBlock,
+                    cookie, deadline);
+        }
+
+        void InitWithoutBuffer(ui32 originalGroupId, ui32 patchedGroupId, const TLogoBlobID &originalBlobId,
+                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, bool ignoreBlock, TMaybe<ui64> cookie,
+                TInstant deadline)
+        {
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&originalBlobId, sizeof(originalBlobId));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&patchedBlobId, sizeof(patchedBlobId));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&vdisk, sizeof(vdisk));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&ignoreBlock, sizeof(ignoreBlock));
+
+            this->Record.SetOriginalGroupId(originalGroupId);
+            this->Record.SetPatchedGroupId(patchedGroupId);
+
+            LogoBlobIDFromLogoBlobID(originalBlobId, this->Record.MutableOriginalBlobId());
+            LogoBlobIDFromLogoBlobID(patchedBlobId, this->Record.MutablePatchedBlobId());
+
+            VDiskIDFromVDiskID(vdisk, this->Record.MutableVDiskID());
+            if (ignoreBlock) {
+                this->Record.SetIgnoreBlock(ignoreBlock);
+            }
+            if (cookie) {
+                this->Record.SetCookie(*cookie);
+            }
+            if (deadline != TInstant::Max()) {
+                this->Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds());
+            }
+            this->Record.MutableMsgQoS()->SetExtQueueId(HandleClassToQueueId(NKikimrBlobStorage::AsyncBlob));
+        }
+
+        bool GetIgnoreBlock() const {
+            return this->Record.GetIgnoreBlock();
+        }
+
+        void AddDiff(ui64 startIdx, const TString &buffer) {
+            TLogoBlobID id = LogoBlobIDFromLogoBlobID(this->Record.GetOriginalBlobId());
+            Y_VERIFY(startIdx < id.BlobSize());
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&buffer, sizeof(buffer));
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(buffer.data(), buffer.size() + 1);
+            Y_VERIFY(startIdx + buffer.size() <= id.BlobSize());
+
+            NKikimrBlobStorage::TDiffBlock *diffBlock = this->Record.AddDiffs();
+            diffBlock->SetOffset(startIdx);
+            diffBlock->SetBuffer(buffer);
+        }
+
+        TString ToString() const override {
+            return ToString(this->Record);
+        }
+
+        static TString ToString(const TRecord &record) {
+            TStringStream str;
+            TLogoBlobID originalId = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId());
+            TLogoBlobID patchedId = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId());
+            str << "{TEvVMovedPatch";
+            str << " OriginalBlobId# " << originalId.ToString();
+            str << " PatchedBlobId# " << patchedId.ToString();
+            str << " OriginalGroupId# " << record.GetOriginalBlobId();
+            str << " PatchedGroupId# " << record.GetPatchedBlobId();
+            if (record.GetIgnoreBlock()) {
+                str << " IgnoreBlock";
+            }
+            if (record.HasMsgQoS()) {
+                str << " ";
+                TEvBlobStorage::TEvVPut::OutMsgQos(record.GetMsgQoS(), str);
+            }
+            str << " DiffCount# " << record.DiffsSize();
+            str << "}";
+            return str.Str();
+        }
+
+        ui32 DiffSizeSum() const {
+            ui32 result = 0;
+            for (auto &diff : this->Record.GetDiffs()) {
+                result += diff.GetBuffer().size();
+            }
+            return result;
+        }
+    };
+
+    template <typename TEv, typename TRecord, ui32 EventType, typename TReqRecord>
+    struct TEvVSpecialPatchBaseResult
+            : public TEvVResultBaseWithQoSPB<TEv, TRecord, EventType> {
+        using TBase = TEvVResultBaseWithQoSPB<TEv, TRecord, EventType>;
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVSpecialPatchBaseResult() = default;
+
+        TEvVSpecialPatchBaseResult(const NKikimrProto::EReplyStatus status, const TLogoBlobID &originalBlobId,
+                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, TMaybe<ui64> cookie,
+                TOutOfSpaceStatus oosStatus, const TInstant &now, ui32 recByteSize,
+                TReqRecord *record, const TActorIDPtr &skeletonFrontIDPtr,
+                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, const NVDiskMon::TLtcHistoPtr &histoPtr,
+                NWilson::TTraceId traceId, ui64 incarnationGuid, const TString& errorReason)
+            : TBase(now, counterPtr, histoPtr, std::move(traceId),
+                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, recByteSize, record, skeletonFrontIDPtr)
+        {
+            this->Record.SetStatus(status);
+            LogoBlobIDFromLogoBlobID(originalBlobId, this->Record.MutableOriginalBlobId());
+            LogoBlobIDFromLogoBlobID(patchedBlobId, this->Record.MutablePatchedBlobId());
+            VDiskIDFromVDiskID(vdisk, this->Record.MutableVDiskID());
+            if (cookie) {
+                this->Record.SetCookie(*cookie);
+            }
+            this->Record.SetStatusFlags(oosStatus.Flags);
+            this->Record.SetApproximateFreeSpaceShare(oosStatus.ApproximateFreeSpaceShare);
+            if (record && record->HasTimestamps()) {
+                this->Record.MutableTimestamps()->CopyFrom(record->GetTimestamps());
+            }
+            if (status == NKikimrProto::OK) {
+                this->Record.SetIncarnationGuid(incarnationGuid);
+            }
+            if (errorReason && status != NKikimrProto::OK) {
+                this->Record.SetErrorReason(errorReason);
+            }
+        }
+
+        void UpdateStatus(const NKikimrProto::EReplyStatus status) {
+            this->Record.SetStatus(status);
+        }
+
+        TString ToString() const override {
+            return ToString(this->Record);
+        }
+
+        static TString ToString(const TRecord &record) {
+            TStringStream str;
+            TLogoBlobID originalId = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId());
+            TLogoBlobID patchedId = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId());
+            TVDiskID vdiskId = VDiskIDFromVDiskID(record.GetVDiskID());
+            str << "{EvVMovedPatchResult Status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()).data();
+            if (record.HasErrorReason()) {
+                str << " ErrorReason# " << '"' << EscapeC(record.GetErrorReason()) << '"';
+            }
+            str << " OriginalBlobId# " << originalId;
+            str << " PatchedBlobId# " << patchedId;
+            str << " VDiskId# " << vdiskId;
+            if (record.HasCookie()) {
+                str << " Cookie# " << record.GetCookie();
+            }
+            if (record.HasMsgQoS()) {
+                str << " ";
+                TEvBlobStorage::TEvVPut::OutMsgQos(record.GetMsgQoS(), str);
+            }
+            str << "}";
+
+            return str.Str();
+        }
+
+        void MakeError(NKikimrProto::EReplyStatus status, const TString& errorReason,
+                const TReqRecord &request) {
+            this->Record.SetStatus(status);
+            if (status != NKikimrProto::OK && errorReason) {
+                this->Record.SetErrorReason(errorReason);
+            }
+            Y_VERIFY(request.HasOriginalBlobId());
+            Y_VERIFY(request.HasPatchedBlobId());
+            TLogoBlobID originalBlobId = LogoBlobIDFromLogoBlobID(request.GetOriginalBlobId());
+            TLogoBlobID patchedBlobId = LogoBlobIDFromLogoBlobID(request.GetPatchedBlobId());
+            LogoBlobIDFromLogoBlobID(originalBlobId, this->Record.MutableOriginalBlobId());
+            LogoBlobIDFromLogoBlobID(patchedBlobId, this->Record.MutablePatchedBlobId());
+
+            Y_VERIFY(request.HasVDiskID());
+            TVDiskID vDiskId = VDiskIDFromVDiskID(request.GetVDiskID());
+            VDiskIDFromVDiskID(vDiskId, this->Record.MutableVDiskID());
+            if (request.HasCookie()) {
+                this->Record.SetCookie(request.GetCookie());
+            }
+            if (request.HasTimestamps()) {
+                this->Record.MutableTimestamps()->CopyFrom(request.GetTimestamps());
+            }
+        }
+    };
+
+
+    struct TEvBlobStorage::TEvVMovedPatch
+        : TEvVSpecialPatchBase<
+                TEvBlobStorage::TEvVMovedPatch,
+                NKikimrBlobStorage::TEvVMovedPatch,
+                TEvBlobStorage::EvVMovedPatch>
+    {
+        using TBase = TEvVSpecialPatchBase<
+                TEvBlobStorage::TEvVMovedPatch,
+                NKikimrBlobStorage::TEvVMovedPatch,
+                TEvBlobStorage::EvVMovedPatch>;
+
+        TEvVMovedPatch() = default;
+
+        TEvVMovedPatch(ui32 originalGroupId, ui32 patchedGroupId, const TLogoBlobID &originalBlobId,
+                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, bool ignoreBlock, TMaybe<ui64> cookie,
+                TInstant deadline)
+            : TBase(originalGroupId, patchedGroupId, originalBlobId, patchedBlobId, vdisk, ignoreBlock,
+                    cookie, deadline)
+        {}
+    };
+
+    struct TEvBlobStorage::TEvVMovedPatchResult
+        : TEvVSpecialPatchBaseResult<
+                TEvBlobStorage::TEvVMovedPatchResult,
+                NKikimrBlobStorage::TEvVMovedPatchResult,
+                TEvBlobStorage::EvVMovedPatchResult,
+                NKikimrBlobStorage::TEvVMovedPatch>
+    {
+        using TBase = TEvVSpecialPatchBaseResult<
+                TEvBlobStorage::TEvVMovedPatchResult,
+                NKikimrBlobStorage::TEvVMovedPatchResult,
+                TEvBlobStorage::EvVMovedPatchResult,
+                NKikimrBlobStorage::TEvVMovedPatch>;
+
+        TEvVMovedPatchResult() = default;
+
+        TEvVMovedPatchResult(const NKikimrProto::EReplyStatus status, const TLogoBlobID &originalBlobId,
+                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, TMaybe<ui64> cookie,
+                TOutOfSpaceStatus oosStatus, const TInstant &now, ui32 recByteSize,
+                NKikimrBlobStorage::TEvVMovedPatch *record, const TActorIDPtr &skeletonFrontIDPtr,
+                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, const NVDiskMon::TLtcHistoPtr &histoPtr,
+                NWilson::TTraceId traceId, ui64 incarnationGuid, const TString& errorReason)
+            : TBase(status, originalBlobId, patchedBlobId, vdisk, cookie, oosStatus, now, recByteSize,
+                    record, skeletonFrontIDPtr, counterPtr, histoPtr, std::move(traceId), incarnationGuid, errorReason)
+        {}
+    };
+
+
+    struct TEvBlobStorage::TEvVInplacePatch
+        : TEvVSpecialPatchBase<
+                TEvBlobStorage::TEvVInplacePatch,
+                NKikimrBlobStorage::TEvVInplacePatch,
+                TEvBlobStorage::EvVInplacePatch>
+    {
+        using TBase = TEvVSpecialPatchBase<
+                TEvBlobStorage::TEvVInplacePatch,
+                NKikimrBlobStorage::TEvVInplacePatch,
+                TEvBlobStorage::EvVInplacePatch>;
+
+        TEvVInplacePatch() = default;
+
+        TEvVInplacePatch(ui32 originalGroupId, ui32 patchedGroupId, const TLogoBlobID &originalBlobId,
+                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, bool ignoreBlock, TMaybe<ui64> cookie,
+                TInstant deadline)
+            : TBase(originalGroupId, patchedGroupId, originalBlobId, patchedBlobId, vdisk, ignoreBlock,
+                    cookie, deadline)
+        {}
+    };
+
+    struct TEvBlobStorage::TEvVInplacePatchResult
+        : TEvVSpecialPatchBaseResult<
+                TEvBlobStorage::TEvVInplacePatchResult,
+                NKikimrBlobStorage::TEvVInplacePatchResult,
+                TEvBlobStorage::EvVInplacePatchResult,
+                NKikimrBlobStorage::TEvVInplacePatch>
+    {
+        using TBase = TEvVSpecialPatchBaseResult<
+                TEvBlobStorage::TEvVInplacePatchResult,
+                NKikimrBlobStorage::TEvVInplacePatchResult,
+                TEvBlobStorage::EvVInplacePatchResult,
+                NKikimrBlobStorage::TEvVInplacePatch>;
+
+        TEvVInplacePatchResult() = default;
+
+        TEvVInplacePatchResult(const NKikimrProto::EReplyStatus status, const TLogoBlobID &originalBlobId,
+                const TLogoBlobID &patchedBlobId, const TVDiskID &vdisk, TMaybe<ui64> cookie,
+                TOutOfSpaceStatus oosStatus, const TInstant &now, ui32 recByteSize,
+                NKikimrBlobStorage::TEvVInplacePatch *record, const TActorIDPtr &skeletonFrontIDPtr,
+                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, const NVDiskMon::TLtcHistoPtr &histoPtr,
+                NWilson::TTraceId traceId, ui64 incarnationGuid, const TString& errorReason)
+            : TBase(status, originalBlobId, patchedBlobId, vdisk, cookie, oosStatus, now, recByteSize,
+                    record, skeletonFrontIDPtr, counterPtr, histoPtr, std::move(traceId), incarnationGuid, errorReason)
+        {}
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // VBLOCK
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
     struct TEvBlobStorage::TEvVBlock
         : public TEventPB<TEvBlobStorage::TEvVBlock, NKikimrBlobStorage::TEvVBlock, TEvBlobStorage::EvVBlock> {
         TEvVBlock()
@@ -1762,303 +1762,303 @@ namespace NKikimr {
         }
     };
 
-    ////////////////////////////////////////////////////////////////////////////////////////////// 
-    // VPatch 
-    ////////////////////////////////////////////////////////////////////////////////////////////// 
-
-    struct TEvBlobStorage::TEvVPatchStart 
-        : public TEventPB<TEvBlobStorage::TEvVPatchStart, 
-                NKikimrBlobStorage::TEvVPatchStart, 
-                TEvBlobStorage::EvVPatchStart> 
-    { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVPatchStart() = default; 
- 
-        TEvVPatchStart(const TLogoBlobID &originalBlobId, const TLogoBlobID &patchedBlobId, const TVDiskID &vDiskId, 
-                TInstant deadline, TMaybe<ui64> cookie, bool notifyIfNotReady) 
-        { 
-            LogoBlobIDFromLogoBlobID(originalBlobId, Record.MutableOriginalBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedBlobId, Record.MutablePatchedBlobId()); 
-            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID()); 
-            if (cookie) { 
-                Record.SetCookie(*cookie); 
-            } 
-            if (deadline != TInstant::Max()) { 
-                Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds()); 
-            } 
-            if (notifyIfNotReady) { 
-                Record.SetNotifyIfNotReady(true); 
-            } 
-            Record.MutableMsgQoS()->SetExtQueueId(NKikimrBlobStorage::EVDiskQueueId::GetFastRead); 
-        } 
-    }; 
- 
-    struct TEvBlobStorage::TEvVPatchFoundParts 
-        : public TEvVResultBaseWithQoSPB<TEvBlobStorage::TEvVPatchFoundParts, 
-                NKikimrBlobStorage::TEvVPatchFoundParts, 
-                TEvBlobStorage::EvVPatchFoundParts> 
-    { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVPatchFoundParts() = default; 
- 
-        TEvVPatchFoundParts(NKikimrProto::EReplyStatus status, const TLogoBlobID &originalBlobId, 
-                const TLogoBlobID &patchedBlobId, const TVDiskID &vDiskId, TMaybe<ui64> cookie, const TInstant &now, 
-                const TString &errorReason, NKikimrBlobStorage::TEvVPatchStart *record, 
-                const TActorIDPtr &skeletonFrontIDPtr, const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, 
-                const NVDiskMon::TLtcHistoPtr &histoPtr, NWilson::TTraceId traceId, ui64 incarnationGuid) 
-            : TEvVResultBaseWithQoSPB(now, counterPtr, histoPtr, std::move(traceId), 
-                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, record->GetCachedSize(), 
-                    record, skeletonFrontIDPtr) 
-        { 
-            Record.SetStatus(status); 
-            LogoBlobIDFromLogoBlobID(originalBlobId, Record.MutableOriginalBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedBlobId, Record.MutablePatchedBlobId()); 
-            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID()); 
- 
-            if (cookie) { 
-                Record.SetCookie(*cookie); 
-            } 
-            if (record && record->HasTimestamps()) { 
-                Record.MutableTimestamps()->CopyFrom(record->GetTimestamps()); 
-            } 
-            if (status == NKikimrProto::OK) { 
-                Record.SetIncarnationGuid(incarnationGuid); 
-            } 
-            Record.SetErrorReason(errorReason); 
-        } 
- 
-        void AddPart(ui8 part) { 
-            Record.AddOriginalParts(part); 
-        } 
- 
-        void SetStatus(NKikimrProto::EReplyStatus status) { 
-            Record.SetStatus(status); 
-        } 
- 
-        void MakeError(NKikimrProto::EReplyStatus status, const TString& errorReason, 
-                const NKikimrBlobStorage::TEvVPatchStart &request) { 
-            Record.SetErrorReason(errorReason); 
-            Record.SetStatus(status); 
-            Y_VERIFY(request.HasOriginalBlobId()); 
-            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(request.GetOriginalBlobId()); 
-            LogoBlobIDFromLogoBlobID(blobId, Record.MutableOriginalBlobId()); 
-            Y_VERIFY(request.HasVDiskID()); 
-            TVDiskID vDiskId = VDiskIDFromVDiskID(request.GetVDiskID()); 
-            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID()); 
-            Y_VERIFY(request.HasCookie()); 
-            Record.SetCookie(request.GetCookie()); 
-        } 
-    }; 
- 
-    struct TEvBlobStorage::TEvVPatchDiff 
-        : public TEventPB<TEvBlobStorage::TEvVPatchDiff, 
-                NKikimrBlobStorage::TEvVPatchDiff, 
-                TEvBlobStorage::EvVPatchDiff> 
-    { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVPatchDiff() = default; 
- 
-        TEvVPatchDiff(const TLogoBlobID &originalPartBlobId, const TLogoBlobID &patchedPartBlobId, const TVDiskID &vDiskId, 
-                ui32 expectedXorDiffs, TInstant deadline, TMaybe<ui64> cookie) 
-        { 
-            LogoBlobIDFromLogoBlobID(originalPartBlobId, Record.MutableOriginalPartBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedPartBlobId, Record.MutablePatchedPartBlobId()); 
-            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID()); 
-            if (expectedXorDiffs) { 
-                Record.SetExpectedXorDiffs(expectedXorDiffs); 
-            } 
-            if (cookie) { 
-                Record.SetCookie(*cookie); 
-            } 
-            if (deadline != TInstant::Max()) { 
-                Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds()); 
-            } 
-            Record.MutableMsgQoS()->SetExtQueueId(NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob); 
-        } 
- 
-        void AddDiff(ui64 startIdx, const TString &buffer) { 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(buffer.data(), buffer.size()); 
- 
-            NKikimrBlobStorage::TDiffBlock *r = Record.AddDiffs(); 
-            r->SetOffset(startIdx); 
-            r->SetBuffer(buffer.data(), buffer.size()); 
-        } 
- 
-        void AddXorReceiver(const TVDiskID &vDiskId, ui8 partId) { 
-            NKikimrBlobStorage::TXorDiffReceiver *r = Record.AddXorReceivers(); 
-            VDiskIDFromVDiskID(vDiskId, r->MutableVDiskID()); 
-            r->SetPartId(partId); 
-        } 
- 
-        void SetForceEnd() { 
-            Record.SetForceEnd(true); 
-        } 
- 
-        bool IsForceEnd() const { 
-            return Record.HasForceEnd() && Record.GetForceEnd(); 
-        } 
- 
-        bool IsXorReceiver() const { 
-            return Record.HasExpectedXorDiffs() && Record.GetExpectedXorDiffs(); 
-        } 
- 
-        ui32 GetExpectedXorDiffs() const { 
-            return Record.HasExpectedXorDiffs() ? Record.GetExpectedXorDiffs() : 0; 
-        } 
- 
-        ui32 DiffSizeSum() const { 
-            ui32 result = 0; 
-            for (auto &diff : Record.GetDiffs()) { 
-                result += diff.GetBuffer().size(); 
-            } 
-            return result; 
-        } 
-    }; 
- 
- 
-    struct TEvBlobStorage::TEvVPatchXorDiff 
-        : public TEventPB<TEvBlobStorage::TEvVPatchXorDiff, 
-                NKikimrBlobStorage::TEvVPatchXorDiff, 
-                TEvBlobStorage::EvVPatchXorDiff> 
-    { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVPatchXorDiff() = default; 
- 
-        TEvVPatchXorDiff(const TLogoBlobID &originalPartBlobId, const TLogoBlobID &patchedPartBlobId, const TVDiskID &vDiskId, 
-                ui8 partId, TInstant deadline, TMaybe<ui64> cookie) 
-        { 
-            LogoBlobIDFromLogoBlobID(originalPartBlobId, Record.MutableOriginalPartBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedPartBlobId, Record.MutablePatchedPartBlobId()); 
-            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID()); 
-            Record.SetFromPartId(partId); 
-            if (cookie) { 
-                Record.SetCookie(*cookie); 
-            } 
-            if (deadline != TInstant::Max()) { 
-                Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds()); 
-            } 
-            Record.MutableMsgQoS()->SetExtQueueId(NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob); 
-        } 
- 
-        void AddDiff(ui64 startIdx, const TString &buffer) { 
-            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(buffer.data(), buffer.size()); 
- 
-            NKikimrBlobStorage::TDiffBlock *r = Record.AddDiffs(); 
-            r->SetOffset(startIdx); 
-            r->SetBuffer(buffer.data(), buffer.size()); 
-        } 
- 
-        ui32 DiffSizeSum() const { 
-            ui32 result = 0; 
-            for (auto &diff : Record.GetDiffs()) { 
-                result += diff.GetBuffer().size(); 
-            } 
-            return result; 
-        } 
-    }; 
- 
-    struct TEvBlobStorage::TEvVPatchXorDiffResult 
-        : public TEvVResultBaseWithQoSPB<TEvBlobStorage::TEvVPatchXorDiffResult, 
-                NKikimrBlobStorage::TEvVPatchXorDiffResult, 
-                TEvBlobStorage::EvVPatchXorDiffResult> 
-    { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVPatchXorDiffResult() = default; 
- 
-        TEvVPatchXorDiffResult(NKikimrProto::EReplyStatus status, TInstant now, 
-                NKikimrBlobStorage::TEvVPatchXorDiff *record, const TActorIDPtr &skeletonFrontIDPtr, 
-                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, 
-                const NVDiskMon::TLtcHistoPtr &histoPtr, NWilson::TTraceId traceId) 
-            : TEvVResultBaseWithQoSPB(now, counterPtr, histoPtr, std::move(traceId), 
-                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, record->GetCachedSize(), 
-                    record, skeletonFrontIDPtr) 
-        { 
-            Record.SetStatus(status); 
-            if (record && record->HasTimestamps()) { 
-                Record.MutableTimestamps()->CopyFrom(record->GetTimestamps()); 
-            } 
-        } 
- 
-        void MakeError(NKikimrProto::EReplyStatus status, const TString& /*errorReason*/, 
-                const NKikimrBlobStorage::TEvVPatchXorDiff &request) 
-        { 
-            Record.SetStatus(status); 
-            if (request.HasTimestamps()) { 
-                Record.MutableTimestamps()->CopyFrom(request.GetTimestamps()); 
-            } 
-        } 
-    }; 
- 
-    struct TEvBlobStorage::TEvVPatchResult 
-        : public TEvVResultBaseWithQoSPB<TEvBlobStorage::TEvVPatchResult, 
-                NKikimrBlobStorage::TEvVPatchResult, 
-                TEvBlobStorage::EvVPatchResult> 
-    { 
-        mutable NLWTrace::TOrbit Orbit; 
- 
-        TEvVPatchResult() = default; 
- 
-        TEvVPatchResult(NKikimrProto::EReplyStatus status, const TLogoBlobID &originalPartBlobId, 
-                const TLogoBlobID &patchedPartBlobId, const TVDiskID &vDiskId, TMaybe<ui64> cookie, TInstant now, 
-                NKikimrBlobStorage::TEvVPatchDiff *record, const TActorIDPtr &skeletonFrontIDPtr, 
-                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, const NVDiskMon::TLtcHistoPtr &histoPtr, 
-                NWilson::TTraceId traceId, ui64 incarnationGuid) 
-            : TEvVResultBaseWithQoSPB(now, counterPtr, histoPtr, std::move(traceId), 
-                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, record->GetCachedSize(), 
-                    record, skeletonFrontIDPtr) 
-        { 
-            Record.SetStatus(status); 
-            LogoBlobIDFromLogoBlobID(originalPartBlobId, Record.MutableOriginalPartBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedPartBlobId, Record.MutablePatchedPartBlobId()); 
-            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID()); 
- 
-            if (cookie) { 
-                Record.SetCookie(*cookie); 
-            } 
-            if (record && record->HasTimestamps()) { 
-                Record.MutableTimestamps()->CopyFrom(record->GetTimestamps()); 
-            } 
-            if (status == NKikimrProto::OK) { 
-                Record.SetIncarnationGuid(incarnationGuid); 
-            } 
-        } 
- 
-        void SetStatus(NKikimrProto::EReplyStatus status, const TString &errorReason) { 
-            Record.SetStatus(status); 
-            Record.SetErrorReason(errorReason); 
-        } 
- 
-        void SetStatusFlagsAndFreeSpace(ui32 statusFlags, float approximateFreeSpaceShare) { 
-            Record.SetStatusFlags(statusFlags); 
-            Record.SetApproximateFreeSpaceShare(approximateFreeSpaceShare); 
-        } 
- 
-        void MakeError(NKikimrProto::EReplyStatus status, const TString &errorReason, 
-                const NKikimrBlobStorage::TEvVPatchDiff &request) 
-        { 
-            Record.SetErrorReason(errorReason); 
-            Record.SetStatus(status); 
- 
-            Y_VERIFY(request.HasOriginalPartBlobId()); 
-            TLogoBlobID originalPartBlobId = LogoBlobIDFromLogoBlobID(request.GetOriginalPartBlobId()); 
-            LogoBlobIDFromLogoBlobID(originalPartBlobId, Record.MutableOriginalPartBlobId()); 
- 
-            Y_VERIFY(request.HasPatchedPartBlobId()); 
-            TLogoBlobID patchedPartBlobId = LogoBlobIDFromLogoBlobID(request.GetPatchedPartBlobId()); 
-            LogoBlobIDFromLogoBlobID(patchedPartBlobId, Record.MutablePatchedPartBlobId()); 
- 
-            Y_VERIFY(request.HasVDiskID()); 
+    //////////////////////////////////////////////////////////////////////////////////////////////
+    // VPatch
+    //////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct TEvBlobStorage::TEvVPatchStart
+        : public TEventPB<TEvBlobStorage::TEvVPatchStart,
+                NKikimrBlobStorage::TEvVPatchStart,
+                TEvBlobStorage::EvVPatchStart>
+    {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVPatchStart() = default;
+
+        TEvVPatchStart(const TLogoBlobID &originalBlobId, const TLogoBlobID &patchedBlobId, const TVDiskID &vDiskId,
+                TInstant deadline, TMaybe<ui64> cookie, bool notifyIfNotReady)
+        {
+            LogoBlobIDFromLogoBlobID(originalBlobId, Record.MutableOriginalBlobId());
+            LogoBlobIDFromLogoBlobID(patchedBlobId, Record.MutablePatchedBlobId());
+            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID());
+            if (cookie) {
+                Record.SetCookie(*cookie);
+            }
+            if (deadline != TInstant::Max()) {
+                Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds());
+            }
+            if (notifyIfNotReady) {
+                Record.SetNotifyIfNotReady(true);
+            }
+            Record.MutableMsgQoS()->SetExtQueueId(NKikimrBlobStorage::EVDiskQueueId::GetFastRead);
+        }
+    };
+
+    struct TEvBlobStorage::TEvVPatchFoundParts
+        : public TEvVResultBaseWithQoSPB<TEvBlobStorage::TEvVPatchFoundParts,
+                NKikimrBlobStorage::TEvVPatchFoundParts,
+                TEvBlobStorage::EvVPatchFoundParts>
+    {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVPatchFoundParts() = default;
+
+        TEvVPatchFoundParts(NKikimrProto::EReplyStatus status, const TLogoBlobID &originalBlobId,
+                const TLogoBlobID &patchedBlobId, const TVDiskID &vDiskId, TMaybe<ui64> cookie, const TInstant &now,
+                const TString &errorReason, NKikimrBlobStorage::TEvVPatchStart *record,
+                const TActorIDPtr &skeletonFrontIDPtr, const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr,
+                const NVDiskMon::TLtcHistoPtr &histoPtr, NWilson::TTraceId traceId, ui64 incarnationGuid)
+            : TEvVResultBaseWithQoSPB(now, counterPtr, histoPtr, std::move(traceId),
+                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, record->GetCachedSize(),
+                    record, skeletonFrontIDPtr)
+        {
+            Record.SetStatus(status);
+            LogoBlobIDFromLogoBlobID(originalBlobId, Record.MutableOriginalBlobId());
+            LogoBlobIDFromLogoBlobID(patchedBlobId, Record.MutablePatchedBlobId());
+            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID());
+
+            if (cookie) {
+                Record.SetCookie(*cookie);
+            }
+            if (record && record->HasTimestamps()) {
+                Record.MutableTimestamps()->CopyFrom(record->GetTimestamps());
+            }
+            if (status == NKikimrProto::OK) {
+                Record.SetIncarnationGuid(incarnationGuid);
+            }
+            Record.SetErrorReason(errorReason);
+        }
+
+        void AddPart(ui8 part) {
+            Record.AddOriginalParts(part);
+        }
+
+        void SetStatus(NKikimrProto::EReplyStatus status) {
+            Record.SetStatus(status);
+        }
+
+        void MakeError(NKikimrProto::EReplyStatus status, const TString& errorReason,
+                const NKikimrBlobStorage::TEvVPatchStart &request) {
+            Record.SetErrorReason(errorReason);
+            Record.SetStatus(status);
+            Y_VERIFY(request.HasOriginalBlobId());
+            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(request.GetOriginalBlobId());
+            LogoBlobIDFromLogoBlobID(blobId, Record.MutableOriginalBlobId());
+            Y_VERIFY(request.HasVDiskID());
+            TVDiskID vDiskId = VDiskIDFromVDiskID(request.GetVDiskID());
+            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID());
+            Y_VERIFY(request.HasCookie());
+            Record.SetCookie(request.GetCookie());
+        }
+    };
+
+    struct TEvBlobStorage::TEvVPatchDiff
+        : public TEventPB<TEvBlobStorage::TEvVPatchDiff,
+                NKikimrBlobStorage::TEvVPatchDiff,
+                TEvBlobStorage::EvVPatchDiff>
+    {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVPatchDiff() = default;
+
+        TEvVPatchDiff(const TLogoBlobID &originalPartBlobId, const TLogoBlobID &patchedPartBlobId, const TVDiskID &vDiskId,
+                ui32 expectedXorDiffs, TInstant deadline, TMaybe<ui64> cookie)
+        {
+            LogoBlobIDFromLogoBlobID(originalPartBlobId, Record.MutableOriginalPartBlobId());
+            LogoBlobIDFromLogoBlobID(patchedPartBlobId, Record.MutablePatchedPartBlobId());
+            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID());
+            if (expectedXorDiffs) {
+                Record.SetExpectedXorDiffs(expectedXorDiffs);
+            }
+            if (cookie) {
+                Record.SetCookie(*cookie);
+            }
+            if (deadline != TInstant::Max()) {
+                Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds());
+            }
+            Record.MutableMsgQoS()->SetExtQueueId(NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob);
+        }
+
+        void AddDiff(ui64 startIdx, const TString &buffer) {
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(buffer.data(), buffer.size());
+
+            NKikimrBlobStorage::TDiffBlock *r = Record.AddDiffs();
+            r->SetOffset(startIdx);
+            r->SetBuffer(buffer.data(), buffer.size());
+        }
+
+        void AddXorReceiver(const TVDiskID &vDiskId, ui8 partId) {
+            NKikimrBlobStorage::TXorDiffReceiver *r = Record.AddXorReceivers();
+            VDiskIDFromVDiskID(vDiskId, r->MutableVDiskID());
+            r->SetPartId(partId);
+        }
+
+        void SetForceEnd() {
+            Record.SetForceEnd(true);
+        }
+
+        bool IsForceEnd() const {
+            return Record.HasForceEnd() && Record.GetForceEnd();
+        }
+
+        bool IsXorReceiver() const {
+            return Record.HasExpectedXorDiffs() && Record.GetExpectedXorDiffs();
+        }
+
+        ui32 GetExpectedXorDiffs() const {
+            return Record.HasExpectedXorDiffs() ? Record.GetExpectedXorDiffs() : 0;
+        }
+
+        ui32 DiffSizeSum() const {
+            ui32 result = 0;
+            for (auto &diff : Record.GetDiffs()) {
+                result += diff.GetBuffer().size();
+            }
+            return result;
+        }
+    };
+
+
+    struct TEvBlobStorage::TEvVPatchXorDiff
+        : public TEventPB<TEvBlobStorage::TEvVPatchXorDiff,
+                NKikimrBlobStorage::TEvVPatchXorDiff,
+                TEvBlobStorage::EvVPatchXorDiff>
+    {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVPatchXorDiff() = default;
+
+        TEvVPatchXorDiff(const TLogoBlobID &originalPartBlobId, const TLogoBlobID &patchedPartBlobId, const TVDiskID &vDiskId,
+                ui8 partId, TInstant deadline, TMaybe<ui64> cookie)
+        {
+            LogoBlobIDFromLogoBlobID(originalPartBlobId, Record.MutableOriginalPartBlobId());
+            LogoBlobIDFromLogoBlobID(patchedPartBlobId, Record.MutablePatchedPartBlobId());
+            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID());
+            Record.SetFromPartId(partId);
+            if (cookie) {
+                Record.SetCookie(*cookie);
+            }
+            if (deadline != TInstant::Max()) {
+                Record.MutableMsgQoS()->SetDeadlineSeconds((ui32)deadline.Seconds());
+            }
+            Record.MutableMsgQoS()->SetExtQueueId(NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob);
+        }
+
+        void AddDiff(ui64 startIdx, const TString &buffer) {
+            REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(buffer.data(), buffer.size());
+
+            NKikimrBlobStorage::TDiffBlock *r = Record.AddDiffs();
+            r->SetOffset(startIdx);
+            r->SetBuffer(buffer.data(), buffer.size());
+        }
+
+        ui32 DiffSizeSum() const {
+            ui32 result = 0;
+            for (auto &diff : Record.GetDiffs()) {
+                result += diff.GetBuffer().size();
+            }
+            return result;
+        }
+    };
+
+    struct TEvBlobStorage::TEvVPatchXorDiffResult
+        : public TEvVResultBaseWithQoSPB<TEvBlobStorage::TEvVPatchXorDiffResult,
+                NKikimrBlobStorage::TEvVPatchXorDiffResult,
+                TEvBlobStorage::EvVPatchXorDiffResult>
+    {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVPatchXorDiffResult() = default;
+
+        TEvVPatchXorDiffResult(NKikimrProto::EReplyStatus status, TInstant now,
+                NKikimrBlobStorage::TEvVPatchXorDiff *record, const TActorIDPtr &skeletonFrontIDPtr,
+                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr,
+                const NVDiskMon::TLtcHistoPtr &histoPtr, NWilson::TTraceId traceId)
+            : TEvVResultBaseWithQoSPB(now, counterPtr, histoPtr, std::move(traceId),
+                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, record->GetCachedSize(),
+                    record, skeletonFrontIDPtr)
+        {
+            Record.SetStatus(status);
+            if (record && record->HasTimestamps()) {
+                Record.MutableTimestamps()->CopyFrom(record->GetTimestamps());
+            }
+        }
+
+        void MakeError(NKikimrProto::EReplyStatus status, const TString& /*errorReason*/,
+                const NKikimrBlobStorage::TEvVPatchXorDiff &request)
+        {
+            Record.SetStatus(status);
+            if (request.HasTimestamps()) {
+                Record.MutableTimestamps()->CopyFrom(request.GetTimestamps());
+            }
+        }
+    };
+
+    struct TEvBlobStorage::TEvVPatchResult
+        : public TEvVResultBaseWithQoSPB<TEvBlobStorage::TEvVPatchResult,
+                NKikimrBlobStorage::TEvVPatchResult,
+                TEvBlobStorage::EvVPatchResult>
+    {
+        mutable NLWTrace::TOrbit Orbit;
+
+        TEvVPatchResult() = default;
+
+        TEvVPatchResult(NKikimrProto::EReplyStatus status, const TLogoBlobID &originalPartBlobId,
+                const TLogoBlobID &patchedPartBlobId, const TVDiskID &vDiskId, TMaybe<ui64> cookie, TInstant now,
+                NKikimrBlobStorage::TEvVPatchDiff *record, const TActorIDPtr &skeletonFrontIDPtr,
+                const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr, const NVDiskMon::TLtcHistoPtr &histoPtr,
+                NWilson::TTraceId traceId, ui64 incarnationGuid)
+            : TEvVResultBaseWithQoSPB(now, counterPtr, histoPtr, std::move(traceId),
+                    TInterconnectChannels::IC_BLOBSTORAGE_SMALL_MSG, record->GetCachedSize(),
+                    record, skeletonFrontIDPtr)
+        {
+            Record.SetStatus(status);
+            LogoBlobIDFromLogoBlobID(originalPartBlobId, Record.MutableOriginalPartBlobId());
+            LogoBlobIDFromLogoBlobID(patchedPartBlobId, Record.MutablePatchedPartBlobId());
+            VDiskIDFromVDiskID(vDiskId, Record.MutableVDiskID());
+
+            if (cookie) {
+                Record.SetCookie(*cookie);
+            }
+            if (record && record->HasTimestamps()) {
+                Record.MutableTimestamps()->CopyFrom(record->GetTimestamps());
+            }
+            if (status == NKikimrProto::OK) {
+                Record.SetIncarnationGuid(incarnationGuid);
+            }
+        }
+
+        void SetStatus(NKikimrProto::EReplyStatus status, const TString &errorReason) {
+            Record.SetStatus(status);
+            Record.SetErrorReason(errorReason);
+        }
+
+        void SetStatusFlagsAndFreeSpace(ui32 statusFlags, float approximateFreeSpaceShare) {
+            Record.SetStatusFlags(statusFlags);
+            Record.SetApproximateFreeSpaceShare(approximateFreeSpaceShare);
+        }
+
+        void MakeError(NKikimrProto::EReplyStatus status, const TString &errorReason,
+                const NKikimrBlobStorage::TEvVPatchDiff &request)
+        {
+            Record.SetErrorReason(errorReason);
+            Record.SetStatus(status);
+
+            Y_VERIFY(request.HasOriginalPartBlobId());
+            TLogoBlobID originalPartBlobId = LogoBlobIDFromLogoBlobID(request.GetOriginalPartBlobId());
+            LogoBlobIDFromLogoBlobID(originalPartBlobId, Record.MutableOriginalPartBlobId());
+
+            Y_VERIFY(request.HasPatchedPartBlobId());
+            TLogoBlobID patchedPartBlobId = LogoBlobIDFromLogoBlobID(request.GetPatchedPartBlobId());
+            LogoBlobIDFromLogoBlobID(patchedPartBlobId, Record.MutablePatchedPartBlobId());
+
+            Y_VERIFY(request.HasVDiskID());
             Record.MutableVDiskID()->CopyFrom(request.GetVDiskID());
-            Y_VERIFY(request.HasCookie()); 
-            Record.SetCookie(request.GetCookie()); 
-        } 
-    }; 
- 
+            Y_VERIFY(request.HasCookie());
+            Record.SetCookie(request.GetCookie());
+        }
+    };
+
     struct TEvBlobStorage::TEvVGetBlock
         : public TEventPB<TEvBlobStorage::TEvVGetBlock,
                     NKikimrBlobStorage::TEvVGetBlock,
@@ -2717,15 +2717,15 @@ namespace NKikimr {
             Record.SetFrontQueueId(queueId);
             wstatus.Serialize(*Record.MutableWindow());
         }
- 
+
         TEvVWindowChange(NKikimrBlobStorage::EVDiskQueueId queueId, TDropConnection) {
             Record.SetFrontQueueId(queueId);
             Record.SetDropConnection(true);
         }
 
-        TString ToString() const override { 
+        TString ToString() const override {
             return SingleLineProto(Record);
-        } 
+        }
     };
 
     struct TEvVGenerationChange: public TEventLocal<TEvVGenerationChange, TEvBlobStorage::EvVGenerationChange> {
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_lsnmngr.h b/ydb/core/blobstorage/vdisk/common/vdisk_lsnmngr.h
index 28deb2f1cf..dde57d68b2 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_lsnmngr.h
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_lsnmngr.h
@@ -172,26 +172,26 @@ namespace NKikimr {
             AllocForSyncLog->Allocated(seg);
             return seg;
         }
- 
-        // hull db update 
-        TLsnSeg AllocDiscreteLsnBatchForHull(ui64 lsnAdvance) { 
-            TLsnSeg seg = AllocLsn(lsnAdvance); 
-            for (ui64 lsn = seg.First; lsn <= seg.Last; ++lsn) { 
-                TLsnSeg point(lsn, lsn); 
-                AllocForHull->Allocated(point); 
-            } 
-            return seg; 
-        } 
- 
-        // hull db and synclog update 
-        TLsnSeg AllocDiscreteLsnBatchForHullAndSyncLog(ui64 lsnAdvance) { 
-            TLsnSeg seg = AllocDiscreteLsnBatchForHull(lsnAdvance); 
-            for (ui64 lsn = seg.First; lsn <= seg.Last; ++lsn) { 
-                TLsnSeg point(lsn, lsn); 
-                AllocForSyncLog->Allocated(point); 
-            } 
-            return seg; 
-        } 
+
+        // hull db update
+        TLsnSeg AllocDiscreteLsnBatchForHull(ui64 lsnAdvance) {
+            TLsnSeg seg = AllocLsn(lsnAdvance);
+            for (ui64 lsn = seg.First; lsn <= seg.Last; ++lsn) {
+                TLsnSeg point(lsn, lsn);
+                AllocForHull->Allocated(point);
+            }
+            return seg;
+        }
+
+        // hull db and synclog update
+        TLsnSeg AllocDiscreteLsnBatchForHullAndSyncLog(ui64 lsnAdvance) {
+            TLsnSeg seg = AllocDiscreteLsnBatchForHull(lsnAdvance);
+            for (ui64 lsn = seg.First; lsn <= seg.Last; ++lsn) {
+                TLsnSeg point(lsn, lsn);
+                AllocForSyncLog->Allocated(point);
+            }
+            return seg;
+        }
         ////////////////////////////// LSN ALLOCATION //////////////////////////////////////
 
         ////////////////////////////// LSN CONFIRMATION ////////////////////////////////////
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_mongroups.h b/ydb/core/blobstorage/vdisk/common/vdisk_mongroups.h
index de4caf504e..aa1bff8f84 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_mongroups.h
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_mongroups.h
@@ -96,38 +96,38 @@ public:
         public:
             GROUP_CONSTRUCTOR(TSkeletonOverloadGroup)
             {
-                COUNTER_INIT(EmergencyMovedPatchQueueItems, false); 
-                COUNTER_INIT(EmergencyPatchStartQueueItems, false); 
+                COUNTER_INIT(EmergencyMovedPatchQueueItems, false);
+                COUNTER_INIT(EmergencyPatchStartQueueItems, false);
                 COUNTER_INIT(EmergencyPutQueueItems, false);
                 COUNTER_INIT(EmergencyMultiPutQueueItems, false);
                 COUNTER_INIT(EmergencyLocalSyncDataQueueItems, false);
                 COUNTER_INIT(EmergencyAnubisOsirisPutQueueItems, false);
- 
-                COUNTER_INIT(EmergencyMovedPatchQueueBytes, false); 
-                COUNTER_INIT(EmergencyPatchStartQueueBytes, false); 
+
+                COUNTER_INIT(EmergencyMovedPatchQueueBytes, false);
+                COUNTER_INIT(EmergencyPatchStartQueueBytes, false);
                 COUNTER_INIT(EmergencyPutQueueBytes, false);
                 COUNTER_INIT(EmergencyMultiPutQueueBytes, false);
                 COUNTER_INIT(EmergencyLocalSyncDataQueueBytes, false);
                 COUNTER_INIT(EmergencyAnubisOsirisPutQueueBytes, false);
- 
+
                 COUNTER_INIT(FreshSatisfactionRankPercent, false);
                 COUNTER_INIT(LevelSatisfactionRankPercent, false);
             }
 
-            COUNTER_DEF(EmergencyMovedPatchQueueItems); 
-            COUNTER_DEF(EmergencyPatchStartQueueItems); 
+            COUNTER_DEF(EmergencyMovedPatchQueueItems);
+            COUNTER_DEF(EmergencyPatchStartQueueItems);
             COUNTER_DEF(EmergencyPutQueueItems);
             COUNTER_DEF(EmergencyMultiPutQueueItems);
             COUNTER_DEF(EmergencyLocalSyncDataQueueItems);
             COUNTER_DEF(EmergencyAnubisOsirisPutQueueItems);
- 
-            COUNTER_DEF(EmergencyMovedPatchQueueBytes); 
-            COUNTER_DEF(EmergencyPatchStartQueueBytes); 
+
+            COUNTER_DEF(EmergencyMovedPatchQueueBytes);
+            COUNTER_DEF(EmergencyPatchStartQueueBytes);
             COUNTER_DEF(EmergencyPutQueueBytes);
             COUNTER_DEF(EmergencyMultiPutQueueBytes);
             COUNTER_DEF(EmergencyLocalSyncDataQueueBytes);
             COUNTER_DEF(EmergencyAnubisOsirisPutQueueBytes);
- 
+
             COUNTER_DEF(FreshSatisfactionRankPercent);
             COUNTER_DEF(LevelSatisfactionRankPercent);
         };
@@ -422,12 +422,12 @@ public:
         public:
             GROUP_CONSTRUCTOR(TVDiskIFaceGroup)
             {
-                COUNTER_INIT(MovedPatchMsgs, true); 
-                COUNTER_INIT(PatchStartMsgs, true); 
-                COUNTER_INIT(PatchDiffMsgs, true); 
-                COUNTER_INIT(PatchXorDiffMsgs, true); 
+                COUNTER_INIT(MovedPatchMsgs, true);
+                COUNTER_INIT(PatchStartMsgs, true);
+                COUNTER_INIT(PatchDiffMsgs, true);
+                COUNTER_INIT(PatchXorDiffMsgs, true);
                 COUNTER_INIT(PutMsgs, true);
-                COUNTER_INIT(MultiPutMsgs, true); 
+                COUNTER_INIT(MultiPutMsgs, true);
                 COUNTER_INIT(GetMsgs, true);
                 COUNTER_INIT(BlockMsgs, true);
                 COUNTER_INIT(GetBlockMsgs, true);
@@ -441,12 +441,12 @@ public:
                 COUNTER_INIT(AnubisPutMsgs, true);
                 COUNTER_INIT(OsirisPutMsgs, true);
 
-                COUNTER_INIT_PRIVATE(MovedPatchResMsgs, true); 
-                COUNTER_INIT_PRIVATE(PatchFoundPartsMsgs, true); 
-                COUNTER_INIT_PRIVATE(PatchXorDiffResMsgs, true); 
-                COUNTER_INIT_PRIVATE(PatchResMsgs, true); 
+                COUNTER_INIT_PRIVATE(MovedPatchResMsgs, true);
+                COUNTER_INIT_PRIVATE(PatchFoundPartsMsgs, true);
+                COUNTER_INIT_PRIVATE(PatchXorDiffResMsgs, true);
+                COUNTER_INIT_PRIVATE(PatchResMsgs, true);
                 COUNTER_INIT_PRIVATE(PutResMsgs, true);
-                COUNTER_INIT_PRIVATE(MultiPutResMsgs, true); 
+                COUNTER_INIT_PRIVATE(MultiPutResMsgs, true);
                 COUNTER_INIT_PRIVATE(GetResMsgs, true);
                 COUNTER_INIT_PRIVATE(BlockResMsgs, true);
                 COUNTER_INIT_PRIVATE(GetBlockResMsgs, true);
@@ -464,12 +464,12 @@ public:
                 COUNTER_INIT(GetTotalBytes, true);
             }
 
-            COUNTER_DEF(MovedPatchMsgs); 
-            COUNTER_DEF(PatchStartMsgs); 
-            COUNTER_DEF(PatchDiffMsgs); 
-            COUNTER_DEF(PatchXorDiffMsgs); 
+            COUNTER_DEF(MovedPatchMsgs);
+            COUNTER_DEF(PatchStartMsgs);
+            COUNTER_DEF(PatchDiffMsgs);
+            COUNTER_DEF(PatchXorDiffMsgs);
             COUNTER_DEF(PutMsgs);
-            COUNTER_DEF(MultiPutMsgs); 
+            COUNTER_DEF(MultiPutMsgs);
             COUNTER_DEF(GetMsgs);
             COUNTER_DEF(BlockMsgs);
             COUNTER_DEF(GetBlockMsgs);
@@ -483,12 +483,12 @@ public:
             COUNTER_DEF(AnubisPutMsgs);
             COUNTER_DEF(OsirisPutMsgs);
 
-            COUNTER_DEF(MovedPatchResMsgs); 
-            COUNTER_DEF(PatchFoundPartsMsgs); 
-            COUNTER_DEF(PatchXorDiffResMsgs); 
-            COUNTER_DEF(PatchResMsgs); 
+            COUNTER_DEF(MovedPatchResMsgs);
+            COUNTER_DEF(PatchFoundPartsMsgs);
+            COUNTER_DEF(PatchXorDiffResMsgs);
+            COUNTER_DEF(PatchResMsgs);
             COUNTER_DEF(PutResMsgs);
-            COUNTER_DEF(MultiPutResMsgs); 
+            COUNTER_DEF(MultiPutResMsgs);
             COUNTER_DEF(GetResMsgs);
             COUNTER_DEF(BlockResMsgs);
             COUNTER_DEF(GetBlockResMsgs);
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_queues.h b/ydb/core/blobstorage/vdisk/common/vdisk_queues.h
index 9377b95f53..9deed7fb43 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_queues.h
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_queues.h
@@ -1,73 +1,73 @@
-#pragma once 
- 
-#include "defs.h" 
- 
+#pragma once
+
+#include "defs.h"
+
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo_iter.h>
 #include <ydb/core/blobstorage/backpressure/queue_backpressure_client.h>
 #include <ydb/core/blobstorage/backpressure/queue_backpressure_common.h>
- 
- 
-namespace NKikimr { 
- 
-    inline TVDiskIdShort GetVDiskID(const TBlobStorageGroupInfo::TVDiskInfo &vdisk) { 
-        return vdisk.VDiskIdShort; 
-    } 
- 
-    inline TVDiskID GetVDiskID(const std::pair<TVDiskID, TActorId> &p) { 
-        return p.first; 
-    } 
- 
-    inline TActorId GetVDiskActorId(const TBlobStorageGroupInfo::TVDiskInfo &vdisk, 
-            const TIntrusivePtr<NKikimr::TBlobStorageGroupInfo> &gInfo) 
-    { 
-        return gInfo->GetActorId(vdisk.VDiskIdShort); 
-    } 
- 
+
+
+namespace NKikimr {
+
+    inline TVDiskIdShort GetVDiskID(const TBlobStorageGroupInfo::TVDiskInfo &vdisk) {
+        return vdisk.VDiskIdShort;
+    }
+
+    inline TVDiskID GetVDiskID(const std::pair<TVDiskID, TActorId> &p) {
+        return p.first;
+    }
+
+    inline TActorId GetVDiskActorId(const TBlobStorageGroupInfo::TVDiskInfo &vdisk,
+            const TIntrusivePtr<NKikimr::TBlobStorageGroupInfo> &gInfo)
+    {
+        return gInfo->GetActorId(vdisk.VDiskIdShort);
+    }
+
     inline TActorId GetVDiskActorId(const std::pair<TVDiskID, TActorId> &p,
-            const TIntrusivePtr<NKikimr::TBlobStorageGroupInfo> &) 
-    { 
-        return p.second; 
-    } 
- 
-    struct TBasicQueueActorIdWrapper { 
-        TActorId Wrap(TActorId &&id) const { 
-            return id; 
-        } 
-    }; 
- 
-    template <typename TContainer, typename TWrappedQueueActorId> 
-    void EmplaceToContainer(TContainer &cont, const TVDiskIdShort &vdisk, TWrappedQueueActorId &&actorId) { 
-        cont.emplace(vdisk, std::move(actorId)); 
-    } 
- 
-    inline void EmplaceToContainer(std::deque<std::pair<TVDiskID, TActorId>> &cont, const TVDiskID &vdisk, TActorId &&actorId) { 
-        cont.emplace_back(vdisk, std::move(actorId)); 
-    } 
- 
-    template <typename TContainer, typename TVDiskContainer, typename TWrapper = TBasicQueueActorIdWrapper> 
-    void CreateQueuesForVDisks(TContainer &cont, const TActorId &parent, 
-            const TIntrusivePtr<NKikimr::TBlobStorageGroupInfo> &gInfo, 
-            const TIntrusivePtr<TVDiskContext> &vCtx, const TVDiskContainer &disks, 
-            const TIntrusivePtr<NMonitoring::TDynamicCounters> &groupCounters, 
-            const NBackpressure::TQueueClientId &queueClientId, NKikimrBlobStorage::EVDiskQueueId vDiskQueueId, 
-            const TString &queueName, TInterconnectChannels::EInterconnectChannels interconnectChannel, 
-            TWrapper wrapper = {}) 
-    { 
-        TBlobStorageGroupType type = gInfo->Type; 
-        for (auto &vdiskInfo : disks) { 
-            auto vdisk = GetVDiskID(vdiskInfo); 
-            if (vdisk != vCtx->ShortSelfVDisk) { 
-                TIntrusivePtr<NBackpressure::TFlowRecord> flowRecord = MakeIntrusive<NBackpressure::TFlowRecord>(); 
-                TActorId vdiskActorId = GetVDiskActorId(vdiskInfo, gInfo); 
+            const TIntrusivePtr<NKikimr::TBlobStorageGroupInfo> &)
+    {
+        return p.second;
+    }
+
+    struct TBasicQueueActorIdWrapper {
+        TActorId Wrap(TActorId &&id) const {
+            return id;
+        }
+    };
+
+    template <typename TContainer, typename TWrappedQueueActorId>
+    void EmplaceToContainer(TContainer &cont, const TVDiskIdShort &vdisk, TWrappedQueueActorId &&actorId) {
+        cont.emplace(vdisk, std::move(actorId));
+    }
+
+    inline void EmplaceToContainer(std::deque<std::pair<TVDiskID, TActorId>> &cont, const TVDiskID &vdisk, TActorId &&actorId) {
+        cont.emplace_back(vdisk, std::move(actorId));
+    }
+
+    template <typename TContainer, typename TVDiskContainer, typename TWrapper = TBasicQueueActorIdWrapper>
+    void CreateQueuesForVDisks(TContainer &cont, const TActorId &parent,
+            const TIntrusivePtr<NKikimr::TBlobStorageGroupInfo> &gInfo,
+            const TIntrusivePtr<TVDiskContext> &vCtx, const TVDiskContainer &disks,
+            const TIntrusivePtr<NMonitoring::TDynamicCounters> &groupCounters,
+            const NBackpressure::TQueueClientId &queueClientId, NKikimrBlobStorage::EVDiskQueueId vDiskQueueId,
+            const TString &queueName, TInterconnectChannels::EInterconnectChannels interconnectChannel,
+            TWrapper wrapper = {})
+    {
+        TBlobStorageGroupType type = gInfo->Type;
+        for (auto &vdiskInfo : disks) {
+            auto vdisk = GetVDiskID(vdiskInfo);
+            if (vdisk != vCtx->ShortSelfVDisk) {
+                TIntrusivePtr<NBackpressure::TFlowRecord> flowRecord = MakeIntrusive<NBackpressure::TFlowRecord>();
+                TActorId vdiskActorId = GetVDiskActorId(vdiskInfo, gInfo);
                 std::unique_ptr<IActor> queue;
                 queue.reset(CreateVDiskBackpressureClient(gInfo, vdisk,
-                        vDiskQueueId, groupCounters, vCtx, queueClientId, queueName, 
-                        interconnectChannel, vdiskActorId.NodeId() == parent.NodeId(), 
+                        vDiskQueueId, groupCounters, vCtx, queueClientId, queueName,
+                        interconnectChannel, vdiskActorId.NodeId() == parent.NodeId(),
                         TDuration::Minutes(1), flowRecord, NMonitoring::TCountableBase::EVisibility::Private));
                 TActorId serviceId = TActivationContext::Register(queue.release(), parent);
-                EmplaceToContainer(cont, vdisk, wrapper.Wrap(std::move(serviceId))); 
-            } 
-        } 
-    } 
- 
-} // NKikimr 
+                EmplaceToContainer(cont, vdisk, wrapper.Wrap(std::move(serviceId)));
+            }
+        }
+    }
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_recoverylogwriter.cpp b/ydb/core/blobstorage/vdisk/common/vdisk_recoverylogwriter.cpp
index 2cfa5d0bc4..f0ec9c15e4 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_recoverylogwriter.cpp
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_recoverylogwriter.cpp
@@ -106,8 +106,8 @@ LWTRACE_USING(BLOBSTORAGE_PROVIDER);
             while (!Queue.empty() && ((item = &Queue.top())->LsnSegmentStart == CurSentLsn + 1)) {
                 CurSentLsn = item->Lsn;
                 std::unique_ptr<IEventHandle> ev = std::move(const_cast<TQueueItem*>(item)->Ev);
-                ui32 type = ev->Type; 
-                switch (type) { 
+                ui32 type = ev->Type;
+                switch (type) {
                     case TEvBlobStorage::EvLog:
                         LWTRACK(VDiskRecoveryLogWriterVPutIsSent, ev->Get<NPDisk::TEvLog>()->Orbit, Owner, item->Lsn);
                         break;
@@ -118,9 +118,9 @@ LWTRACE_USING(BLOBSTORAGE_PROVIDER);
                                 LWTRACK(VDiskRecoveryLogWriterVPutIsSent, log->Orbit, Owner, log->Lsn);
                             }
                             break;
-                        } 
-                } 
-                Queue.pop(); 
+                        }
+                }
+                Queue.pop();
                 ctx.ExecutorThread.Send(ev.release());
             }
         }
@@ -150,39 +150,39 @@ LWTRACE_USING(BLOBSTORAGE_PROVIDER);
             }
         }
 
-        void Handle(NPDisk::TEvMultiLog::TPtr &ev, const TActorContext &ctx) { 
-            NPDisk::TEvMultiLog *logs = ev->Get(); 
-            ui64 lsnSegmentStart = logs->LsnSeg.First; 
-            ui64 lsn = logs->LsnSeg.Last; 
-            Y_VERIFY_DEBUG_S(lsnSegmentStart == logs->Logs.front()->LsnSegmentStart && lsn == logs->Logs.back()->Lsn, 
-                    "LsnSeg not match with inner logs" 
-                    << "LsnSeg# " << logs->LsnSeg.ToString() 
-                    << "Logs.front().LsnSegmentStart# " << logs->Logs.front()->LsnSegmentStart 
-                    << "Logs.back().Lsn# " << logs->Logs.back()->Lsn); 
-            for (auto &log : logs->Logs) { 
-                LWTRACK(VDiskRecoveryLogWriterVPutIsRecieved, log->Orbit, Owner, log->Lsn); 
+        void Handle(NPDisk::TEvMultiLog::TPtr &ev, const TActorContext &ctx) {
+            NPDisk::TEvMultiLog *logs = ev->Get();
+            ui64 lsnSegmentStart = logs->LsnSeg.First;
+            ui64 lsn = logs->LsnSeg.Last;
+            Y_VERIFY_DEBUG_S(lsnSegmentStart == logs->Logs.front()->LsnSegmentStart && lsn == logs->Logs.back()->Lsn,
+                    "LsnSeg not match with inner logs"
+                    << "LsnSeg# " << logs->LsnSeg.ToString()
+                    << "Logs.front().LsnSegmentStart# " << logs->Logs.front()->LsnSegmentStart
+                    << "Logs.back().Lsn# " << logs->Logs.back()->Lsn);
+            for (auto &log : logs->Logs) {
+                LWTRACK(VDiskRecoveryLogWriterVPutIsRecieved, log->Orbit, Owner, log->Lsn);
                 TLogSignature signature = log->Signature.GetUnmasked();
                 Y_VERIFY(TLogSignature::First < signature && signature < TLogSignature::Max);
-                i64 msgSize = log->ApproximateSize(); 
-                // count written bytes 
-                *LsmLogBytesWritten += msgSize; 
-                // update generic counters 
+                i64 msgSize = log->ApproximateSize();
+                // count written bytes
+                *LsmLogBytesWritten += msgSize;
+                // update generic counters
                 Counters.Update(signature, msgSize);
-                LWTRACK(VDiskRecoveryLogWriterVPutIsSent, log->Orbit, Owner, lsn); 
-            } 
+                LWTRACK(VDiskRecoveryLogWriterVPutIsSent, log->Orbit, Owner, lsn);
+            }
             std::unique_ptr<IEventHandle> converted(ev->Forward(YardID).Release());
- 
-            if (lsnSegmentStart == CurSentLsn + 1) { 
-                // rewrite and send message; 
+
+            if (lsnSegmentStart == CurSentLsn + 1) {
+                // rewrite and send message;
                 ctx.ExecutorThread.Send(converted.release());
-                CurSentLsn = lsn; 
-                // proceed with elements waiting in the queue 
-                ProcessQueue(ctx); 
-            } else { 
+                CurSentLsn = lsn;
+                // proceed with elements waiting in the queue
+                ProcessQueue(ctx);
+            } else {
                 Queue.push(TQueueItem(std::move(converted), lsnSegmentStart, lsn));
-            } 
-        } 
- 
+            }
+        }
+
         void Handle(TEvBlobStorage::TEvVCompact::TPtr &ev, const TActorContext &ctx) {
             Y_UNUSED(ev);
             ui64 lsn = CurSentLsn + 1;
@@ -196,7 +196,7 @@ LWTRACE_USING(BLOBSTORAGE_PROVIDER);
 
         STRICT_STFUNC(StateFunc,
             HFunc(NPDisk::TEvLog, Handle)
-            HFunc(NPDisk::TEvMultiLog, Handle) 
+            HFunc(NPDisk::TEvMultiLog, Handle)
             HFunc(TEvBlobStorage::TEvVCompact, Handle)
             HFunc(TEvents::TEvPoisonPill, HandlePoison)
         )
diff --git a/ydb/core/blobstorage/vdisk/common/ya.make b/ydb/core/blobstorage/vdisk/common/ya.make
index 11194b0b74..4fb4364ee2 100644
--- a/ydb/core/blobstorage/vdisk/common/ya.make
+++ b/ydb/core/blobstorage/vdisk/common/ya.make
@@ -52,7 +52,7 @@ SRCS(
     vdisk_pdisk_error.h
     vdisk_pdiskctx.h
     vdisk_private_events.h
-    vdisk_queues.h 
+    vdisk_queues.h
     vdisk_recoverylogwriter.cpp
     vdisk_recoverylogwriter.h
     vdisk_response.cpp
diff --git a/ydb/core/blobstorage/vdisk/huge/blobstorage_hullhuge.cpp b/ydb/core/blobstorage/vdisk/huge/blobstorage_hullhuge.cpp
index db0ec52ffc..30d2aeece4 100644
--- a/ydb/core/blobstorage/vdisk/huge/blobstorage_hullhuge.cpp
+++ b/ydb/core/blobstorage/vdisk/huge/blobstorage_hullhuge.cpp
@@ -164,7 +164,7 @@ namespace NKikimr {
                 case NKikimrBlobStorage::EPutHandleClass::TabletLog:    return NPriWrite::HullHugeUserData;
                 case NKikimrBlobStorage::EPutHandleClass::AsyncBlob:    return NPriWrite::HullHugeAsyncBlob;
                 case NKikimrBlobStorage::EPutHandleClass::UserData:     return NPriWrite::HullHugeUserData;
-                default: Y_FAIL_S("Unexpected HandleClass# " << int(Item->HandleClass)); 
+                default: Y_FAIL_S("Unexpected HandleClass# " << int(Item->HandleClass));
             }
         }
 
@@ -685,9 +685,9 @@ namespace NKikimr {
 
             // notify log cutter if the FirstLsnToKeep has changed since last reporting
             if (firstLsnToKeep != State.LastReportedFirstLsnToKeep) {
-                Y_VERIFY_S(firstLsnToKeep > State.LastReportedFirstLsnToKeep, "huge keeper log rollback" 
-                        << " firstLsnToKeep#" << firstLsnToKeep 
-                        << " State.LastReportedFirstLsnToKeep# " << State.LastReportedFirstLsnToKeep); 
+                Y_VERIFY_S(firstLsnToKeep > State.LastReportedFirstLsnToKeep, "huge keeper log rollback"
+                        << " firstLsnToKeep#" << firstLsnToKeep
+                        << " State.LastReportedFirstLsnToKeep# " << State.LastReportedFirstLsnToKeep);
                 ctx.Send(HugeKeeperCtx->LogCutterId, new TEvVDiskCutLog(TEvVDiskCutLog::HugeKeeper, firstLsnToKeep));
                 State.LastReportedFirstLsnToKeep = firstLsnToKeep;
 
@@ -777,10 +777,10 @@ namespace NKikimr {
 
             auto checkAndSet = [this, msg] (ui64 &dbLsn) {
                 ui64 origRecoveredLsn = HugeKeeperCtx->LsnMngr->GetOriginallyRecoveredLsn();
-                Y_VERIFY_S(dbLsn <= msg->DeletionLsn, HugeKeeperCtx->VCtx->VDiskLogPrefix << " Check failed:" 
-                        << " dbLsn# " << dbLsn << " origRecoveredLsn# " << origRecoveredLsn 
-                        << " recovInfo# " << HugeKeeperCtx->LocalRecoveryInfoDbg 
-                        << " msg# " << msg->ToString()); 
+                Y_VERIFY_S(dbLsn <= msg->DeletionLsn, HugeKeeperCtx->VCtx->VDiskLogPrefix << " Check failed:"
+                        << " dbLsn# " << dbLsn << " origRecoveredLsn# " << origRecoveredLsn
+                        << " recovInfo# " << HugeKeeperCtx->LocalRecoveryInfoDbg
+                        << " msg# " << msg->ToString());
                 dbLsn = msg->DeletionLsn;
             };
 
@@ -842,8 +842,8 @@ namespace NKikimr {
             Y_VERIFY(nErased == 1);
             // depending on SlotIsUsed...
             if (msg->SlotIsUsed) {
-                Y_VERIFY_S(State.Pers->LogPos.HugeBlobLoggedLsn < msg->RecLsn, 
-                        "pers# " << State.Pers->ToString() << " msg# " << msg->ToString()); 
+                Y_VERIFY_S(State.Pers->LogPos.HugeBlobLoggedLsn < msg->RecLsn,
+                        "pers# " << State.Pers->ToString() << " msg# " << msg->ToString());
                 // ...update HugeBlobLoggedLsn (monotonically incremented)
                 State.Pers->LogPos.HugeBlobLoggedLsn = msg->RecLsn;
             } else {
diff --git a/ydb/core/blobstorage/vdisk/huge/blobstorage_hullhugeheap.cpp b/ydb/core/blobstorage/vdisk/huge/blobstorage_hullhugeheap.cpp
index 9985255928..e60200de98 100644
--- a/ydb/core/blobstorage/vdisk/huge/blobstorage_hullhugeheap.cpp
+++ b/ydb/core/blobstorage/vdisk/huge/blobstorage_hullhugeheap.cpp
@@ -84,9 +84,9 @@ namespace NKikimr {
         // TChain
         ////////////////////////////////////////////////////////////////////////////
         TMask TChain::BuildConstMask(const TString &prefix, ui32 slotsInChunk) {
-            Y_VERIFY_S(1 < slotsInChunk && slotsInChunk <= MaxNumberOfSlots, 
-                    prefix << "It's not a good idea to have so many slots in chunk;" 
-                    << " slotsInChunk# " << slotsInChunk); 
+            Y_VERIFY_S(1 < slotsInChunk && slotsInChunk <= MaxNumberOfSlots,
+                    prefix << "It's not a good idea to have so many slots in chunk;"
+                    << " slotsInChunk# " << slotsInChunk);
             TMask mask;
             mask.Reserve(slotsInChunk);
             mask.Set(0, slotsInChunk);
@@ -101,8 +101,8 @@ namespace NKikimr {
             TFreeSpace::iterator it = FreeSpace.begin();
             TMask &mask = it->second;
 
-            Y_VERIFY_S(!mask.Empty(), VDiskLogPrefix << "TChain::Allocate1:" 
-                    << " id# " << id->ToString() << " State# " << ToString()); 
+            Y_VERIFY_S(!mask.Empty(), VDiskLogPrefix << "TChain::Allocate1:"
+                    << " id# " << id->ToString() << " State# " << ToString());
             ui32 slot = mask.FirstNonZeroBit();
             mask.Reset(slot);
 
@@ -118,30 +118,30 @@ namespace NKikimr {
 
         // allocate id, but we know that this chain doesn't have free slots, so add a chunk to it
         void TChain::Allocate(NPrivate::TChunkSlot *id, TChunkID chunkId) {
-            Y_VERIFY_S(FreeSpace.empty(), VDiskLogPrefix << "Empty"); 
+            Y_VERIFY_S(FreeSpace.empty(), VDiskLogPrefix << "Empty");
 
             FreeSpace.emplace(chunkId, ConstMask);
             FreeSlotsInFreeSpace += SlotsInChunk;
             bool res = Allocate(id);
-            Y_VERIFY_S(res, VDiskLogPrefix << "TChain::Allocate2:" 
-                    << " id# " << id->ToString() << " chunkId# " << chunkId << " State# " << ToString()); 
+            Y_VERIFY_S(res, VDiskLogPrefix << "TChain::Allocate2:"
+                    << " id# " << id->ToString() << " chunkId# " << chunkId << " State# " << ToString());
         }
 
         TFreeRes TChain::Free(const NPrivate::TChunkSlot &id) {
-            Y_VERIFY_S(id.GetSlotId() < SlotsInChunk && AllocatedSlots > 0, VDiskLogPrefix 
-                    << " id# " << id.ToString() << " SlotsInChunk# " << SlotsInChunk 
-                    << " AllocatedSlots# " << AllocatedSlots << " State# " << ToString()); 
+            Y_VERIFY_S(id.GetSlotId() < SlotsInChunk && AllocatedSlots > 0, VDiskLogPrefix
+                    << " id# " << id.ToString() << " SlotsInChunk# " << SlotsInChunk
+                    << " AllocatedSlots# " << AllocatedSlots << " State# " << ToString());
             AllocatedSlots--;
 
             ui32 chunkId = id.GetChunkId();
             ui32 slotId = id.GetSlotId();
-            Y_VERIFY_S(chunkId, VDiskLogPrefix << "chunkId# " << chunkId); 
+            Y_VERIFY_S(chunkId, VDiskLogPrefix << "chunkId# " << chunkId);
             TFreeSpace::iterator it;
 
             auto freeFoundSlot = [&] (TFreeSpace &container, const char *containerName) {
                 TMask &mask = it->second;
                 Y_VERIFY_S(!mask.Get(slotId), VDiskLogPrefix << "TChain::Free: containerName# " << containerName
-                        << " id# " << id.ToString() << " State# " << ToString()); 
+                        << " id# " << id.ToString() << " State# " << ToString());
                 mask.Set(slotId);
                 ++FreeSlotsInFreeSpace;
                 if (mask == ConstMask) {
@@ -208,8 +208,8 @@ namespace NKikimr {
             TFreeSpace::iterator it = FreeSpace.find(chunkId);
             if (it != FreeSpace.end()) {
                 TMask &mask = it->second;
-                Y_VERIFY_S(mask.Get(slotId), VDiskLogPrefix << "RecoveryModeAllocate:" 
-                        << " id# " << id.ToString() << " State# " << ToString()); 
+                Y_VERIFY_S(mask.Get(slotId), VDiskLogPrefix << "RecoveryModeAllocate:"
+                        << " id# " << id.ToString() << " State# " << ToString());
                 mask.Reset(slotId);
 
                 if (mask.Empty()) {
@@ -225,15 +225,15 @@ namespace NKikimr {
         }
 
         void TChain::RecoveryModeAllocate(const NPrivate::TChunkSlot &id, TChunkID chunkId) {
-            Y_VERIFY_S(id.GetChunkId() == chunkId && FreeSpace.find(chunkId) == FreeSpace.end(), 
-                    VDiskLogPrefix << " id# " << id.ToString() << " chunkId# " << chunkId << " State# " << ToString()); 
+            Y_VERIFY_S(id.GetChunkId() == chunkId && FreeSpace.find(chunkId) == FreeSpace.end(),
+                    VDiskLogPrefix << " id# " << id.ToString() << " chunkId# " << chunkId << " State# " << ToString());
 
             FreeSpace.emplace(chunkId, ConstMask);
             FreeSlotsInFreeSpace += SlotsInChunk;
             bool res = RecoveryModeAllocate(id);
 
-            Y_VERIFY_S(res, VDiskLogPrefix << "RecoveryModeAllocate:" 
-                    << " id# " << id.ToString() << " chunkId# " << chunkId << " State# " << ToString()); 
+            Y_VERIFY_S(res, VDiskLogPrefix << "RecoveryModeAllocate:"
+                    << " id# " << id.ToString() << " chunkId# " << chunkId << " State# " << ToString());
         }
 
         void TChain::Save(IOutputStream *s) const {
@@ -252,8 +252,8 @@ namespace NKikimr {
             FreeSpace.clear();
             ui32 slotsInChunk = 0;
             ::Load(s, slotsInChunk);
-            Y_VERIFY_S(slotsInChunk == SlotsInChunk, VDiskLogPrefix 
-                    << "slotsInChunk# " << slotsInChunk << " SlotsInChunk# " << SlotsInChunk); 
+            Y_VERIFY_S(slotsInChunk == SlotsInChunk, VDiskLogPrefix
+                    << "slotsInChunk# " << slotsInChunk << " SlotsInChunk# " << SlotsInChunk);
             ::Load(s, AllocatedSlots);
             ::Load(s, FreeSpace);
             FreeSlotsInFreeSpace = 0;
@@ -331,9 +331,9 @@ namespace NKikimr {
         {
             ui32 slotSizeInBlocks = Blocks + ShiftInBlocks;
             ui32 blocksInChunk = chunkSize / appendBlockSize;
-            Y_VERIFY_S(appendBlockSize * blocksInChunk == chunkSize, VDiskLogPrefix 
-                    << "Blocks# " << Blocks << " ShiftInBlocks# " << ShiftInBlocks 
-                    << " chunkSize# " << chunkSize << " appendBlockSize# " << appendBlockSize); 
+            Y_VERIFY_S(appendBlockSize * blocksInChunk == chunkSize, VDiskLogPrefix
+                    << "Blocks# " << Blocks << " ShiftInBlocks# " << ShiftInBlocks
+                    << " chunkSize# " << chunkSize << " appendBlockSize# " << appendBlockSize);
 
             SlotsInChunk = blocksInChunk / slotSizeInBlocks;
             SlotSize = slotSizeInBlocks * appendBlockSize;
@@ -347,8 +347,8 @@ namespace NKikimr {
 
         NPrivate::TChunkSlot TChainDelegator::Convert(const TDiskPart &addr) const {
             ui32 slotId = addr.Offset / SlotSize;
-            Y_VERIFY_S(slotId * SlotSize == addr.Offset, VDiskLogPrefix 
-                    << "slotId# " << slotId << " addr# " << addr.ToString() << " State# " << ToString()); 
+            Y_VERIFY_S(slotId * SlotSize == addr.Offset, VDiskLogPrefix
+                    << "slotId# " << slotId << " addr# " << addr.ToString() << " State# " << ToString());
             return NPrivate::TChunkSlot(addr.ChunkIdx, slotId);
         }
 
@@ -416,12 +416,12 @@ namespace NKikimr {
             , Overhead(overhead)
             , OldMapCompatible(oldMapCompatible)
         {
-            Y_VERIFY_S(MinHugeBlobInBytes != 0 && 
+            Y_VERIFY_S(MinHugeBlobInBytes != 0 &&
                     MinHugeBlobInBytes <= MilestoneBlobInBytes &&
                     MilestoneBlobInBytes < MaxBlobInBytes, "INVALID CONFIGURATION! (SETTINGS ARE:"
-                            << " MaxBlobInBytes# " << MaxBlobInBytes << " MinHugeBlobInBytes# " << MinHugeBlobInBytes 
-                            << " MilestoneBlobInBytes# " << MilestoneBlobInBytes << " ChunkSize# " << ChunkSize 
-                            << " AppendBlockSize# " << AppendBlockSize << ")"); 
+                            << " MaxBlobInBytes# " << MaxBlobInBytes << " MinHugeBlobInBytes# " << MinHugeBlobInBytes
+                            << " MilestoneBlobInBytes# " << MilestoneBlobInBytes << " ChunkSize# " << ChunkSize
+                            << " AppendBlockSize# " << AppendBlockSize << ")");
             BuildLayout(OldMapCompatible);
         }
 
@@ -511,8 +511,8 @@ namespace NKikimr {
                 // map size has been changed, run migration
                 StartMode = EStartMode::Migrated;
                 TBuiltChainDelegators b = BuildChains(MilestoneBlobInBytes);
-                Y_VERIFY_S(size == b.ChainDelegators.size(), "size# " << size 
-                        << " b.ChainDelegators.size()# " << b.ChainDelegators.size()); 
+                Y_VERIFY_S(size == b.ChainDelegators.size(), "size# " << size
+                        << " b.ChainDelegators.size()# " << b.ChainDelegators.size());
 
                 // load into temporary delegators
                 for (auto &x : b.ChainDelegators) {
@@ -535,10 +535,10 @@ namespace NKikimr {
                 // entry point size rollback case
                 Y_VERIFY(size > ChainDelegators.size());
                 ui32 curChainDelegatorsSize = ChainDelegators.size();
-                Y_FAIL_S("Impossible case; MinHugeBlobInBytes# " << MinHugeBlobInBytes 
-                        << " MilestoneBlobInBytes# " << MilestoneBlobInBytes 
-                        << " loadedSize# " << size 
-                        << " curChainDelegatorsSize# " << curChainDelegatorsSize); 
+                Y_FAIL_S("Impossible case; MinHugeBlobInBytes# " << MinHugeBlobInBytes
+                        << " MilestoneBlobInBytes# " << MilestoneBlobInBytes
+                        << " loadedSize# " << size
+                        << " curChainDelegatorsSize# " << curChainDelegatorsSize);
             }
         }
 
@@ -676,11 +676,11 @@ namespace NKikimr {
             Y_VERIFY(!ChainDelegators.empty());
             BuildSearchTable();
 
-            Y_VERIFY_S(GetMinREALHugeBlobInBytes() != 0, "INVALID CONFIGURATION: MinREALHugeBlobInBytes IS 0" 
+            Y_VERIFY_S(GetMinREALHugeBlobInBytes() != 0, "INVALID CONFIGURATION: MinREALHugeBlobInBytes IS 0"
                     << " (SETTINGS ARE: MaxBlobInBytes# " << MaxBlobInBytes
-                    << " MinHugeBlobInBytes# " << MinHugeBlobInBytes 
-                    << " ChunkSize# " << ChunkSize 
-                    << " AppendBlockSize# " << AppendBlockSize << ')'); 
+                    << " MinHugeBlobInBytes# " << MinHugeBlobInBytes
+                    << " ChunkSize# " << ChunkSize
+                    << " AppendBlockSize# " << AppendBlockSize << ')');
         }
 
         inline ui32 TAllChains::SizeToBlocks(ui32 size) const {
@@ -721,14 +721,14 @@ namespace NKikimr {
         //////////////////////////////////////////////////////////////////////////////////////////
         THugeSlot THeap::ConvertDiskPartToHugeSlot(const TDiskPart &addr) const {
             const TChainDelegator *chainD = Chains.GetChain(addr.Size);
-            Y_VERIFY_S(chainD && (addr.Offset / chainD->SlotSize * chainD->SlotSize == addr.Offset), VDiskLogPrefix 
-                    << "chainD# " <<  (chainD ? chainD->ToString() : "nullptr") << " addr# " << addr.ToString()); 
+            Y_VERIFY_S(chainD && (addr.Offset / chainD->SlotSize * chainD->SlotSize == addr.Offset), VDiskLogPrefix
+                    << "chainD# " <<  (chainD ? chainD->ToString() : "nullptr") << " addr# " << addr.ToString());
             return THugeSlot(addr.ChunkIdx, addr.Offset, chainD->SlotSize);
         }
 
         bool THeap::Allocate(ui32 size, THugeSlot *hugeSlot, ui32 *slotSize) {
             TChainDelegator *chainD = Chains.GetChain(size);
-            Y_VERIFY_S(chainD, VDiskLogPrefix << "size# " << size << " Heap# " << ToString()); 
+            Y_VERIFY_S(chainD, VDiskLogPrefix << "size# " << size << " Heap# " << ToString());
             *slotSize = chainD->SlotSize;
 
             NPrivate::TChunkSlot id;
@@ -761,7 +761,7 @@ namespace NKikimr {
         ui32 THeap::RemoveChunk() {
             if (FreeChunks.size() > FreeChunksReservation) {
                 ui32 chunkId = GetChunkIdFromFreeChunks();
-                Y_VERIFY_S(chunkId, VDiskLogPrefix << "State# " << ToString()); 
+                Y_VERIFY_S(chunkId, VDiskLogPrefix << "State# " << ToString());
                 return chunkId;
             } else {
                 return 0;
@@ -787,7 +787,7 @@ namespace NKikimr {
         void THeap::RecoveryModeAllocate(const TDiskPart &addr) {
             ui32 size = addr.Size;
             TChainDelegator *chainD = Chains.GetChain(size);
-            Y_VERIFY_S(chainD, VDiskLogPrefix << "State# " << ToString()); 
+            Y_VERIFY_S(chainD, VDiskLogPrefix << "State# " << ToString());
 
             NPrivate::TChunkSlot id(chainD->Convert(addr));
             bool allocated = chainD->ChainPtr->RecoveryModeAllocate(id);
@@ -887,7 +887,7 @@ namespace NKikimr {
         // THeap: Private
         //////////////////////////////////////////////////////////////////////////////////////////
         inline ui32 THeap::GetChunkIdFromFreeChunks() {
-            Y_VERIFY_S(!FreeChunks.empty(), VDiskLogPrefix << "State# " << ToString()); 
+            Y_VERIFY_S(!FreeChunks.empty(), VDiskLogPrefix << "State# " << ToString());
             TFreeChunks::iterator it = FreeChunks.begin();
             ui32 chunkId = *it;
             FreeChunks.erase(it);
@@ -896,7 +896,7 @@ namespace NKikimr {
 
         inline void THeap::PutChunkIdToFreeChunks(ui32 chunkId) {
             bool res = FreeChunks.insert(chunkId).second;
-            Y_VERIFY_S(res, VDiskLogPrefix << "State# " << ToString()); 
+            Y_VERIFY_S(res, VDiskLogPrefix << "State# " << ToString());
         }
 
     } // NHuge
diff --git a/ydb/core/blobstorage/vdisk/ingress/blobstorage_ingress.cpp b/ydb/core/blobstorage/vdisk/ingress/blobstorage_ingress.cpp
index 8f57ff4477..4e9f1f03c3 100644
--- a/ydb/core/blobstorage/vdisk/ingress/blobstorage_ingress.cpp
+++ b/ydb/core/blobstorage/vdisk/ingress/blobstorage_ingress.cpp
@@ -37,10 +37,10 @@ namespace NKikimr {
         Y_VERIFY(handoff < domainsNum);
 
         // barrierIngressValueMask
-        ui32 barrierIngressValueMask = (1ull << totalVDisks) - 1; 
+        ui32 barrierIngressValueMask = (1ull << totalVDisks) - 1;
 
         // barrierIngressDomainMask
-        ui32 barrierIngressDomainMask = (1ull << disksInDomain) - 1; 
+        ui32 barrierIngressDomainMask = (1ull << disksInDomain) - 1;
 
         return new TIngressCache(vdiskOrderNum, totalVDisks, domainsNum, disksInDomain, handoff,
                                  barrierIngressValueMask, barrierIngressDomainMask, std::move(top));
diff --git a/ydb/core/blobstorage/vdisk/query/query_base.h b/ydb/core/blobstorage/vdisk/query/query_base.h
index a4e337643d..092b93964f 100644
--- a/ydb/core/blobstorage/vdisk/query/query_base.h
+++ b/ydb/core/blobstorage/vdisk/query/query_base.h
@@ -76,7 +76,7 @@ namespace NKikimr {
         void SendResponseAndDie(const TActorContext &ctx, T *self) {
             bool hasNotYet = false;
 
-            if (ResultSize.IsOverflow()) { 
+            if (ResultSize.IsOverflow()) {
                 Result->Record.SetStatus(NKikimrProto::ERROR);
                 Result->Record.MutableResult()->Clear();
                 // for every 'extreme' query add ERROR result, for 'range' would empty vec for now
diff --git a/ydb/core/blobstorage/vdisk/query/query_extr.cpp b/ydb/core/blobstorage/vdisk/query/query_extr.cpp
index ee7a26d0c3..196b6d2054 100644
--- a/ydb/core/blobstorage/vdisk/query/query_extr.cpp
+++ b/ydb/core/blobstorage/vdisk/query/query_extr.cpp
@@ -105,7 +105,7 @@ namespace NKikimr {
 
         void MainCycle(const TActorContext &ctx) {
             TQuery *query = nullptr;
-            while ((query = FetchNextQuery()) && !ResultSize.IsOverflow()) { 
+            while ((query = FetchNextQuery()) && !ResultSize.IsOverflow()) {
                 Y_VERIFY(query->PartId == 0); // only full blobs (w/o specifying a part) are allowed
                 const ui64 *cookiePtr = query->HasCookie ? &query->CookieVal : nullptr;
                 ResultSize.AddLogoBlobIndex();
@@ -170,7 +170,7 @@ namespace NKikimr {
         friend class TLevelIndexExtremeQueryViaBatcherBase;
         friend class TLevelIndexQueryBase;
 
-        const TBlobStorageGroupType GType; 
+        const TBlobStorageGroupType GType;
         TReadBatcher Batcher;
         TRecordMergerCallback Merger;
         TActiveActors ActiveActors;
@@ -312,7 +312,7 @@ namespace NKikimr {
 
         void MainCycle(const TActorContext &ctx) {
             TQuery *query = nullptr;
-            while ((query = FetchNextQuery()) && !ResultSize.IsOverflow()) { 
+            while ((query = FetchNextQuery()) && !ResultSize.IsOverflow()) {
                 const TLogoBlobID &fullId = query->LogoBlobID; // full blob id we are looking for
                 const TLogoBlobID partId = TLogoBlobID(fullId, query->PartId);
                 bool found = false;
@@ -320,7 +320,7 @@ namespace NKikimr {
 
                 ResultSize.AddLogoBlobIndex();
                 if (BlobInIndex) {
-                    ResultSize.AddLogoBlobData(GType.PartSize(partId), query->Shift, query->Size); 
+                    ResultSize.AddLogoBlobData(GType.PartSize(partId), query->Shift, query->Size);
                     Batcher.StartTraverse(fullId, query, query->PartId, query->Shift, query->Size);
                     ForwardIt->PutToMerger(&Merger);
                     Merger.Finish();
@@ -342,7 +342,7 @@ namespace NKikimr {
                 }
             }
 
-            if (ResultSize.IsOverflow()) { 
+            if (ResultSize.IsOverflow()) {
                 SendResponseAndDie(ctx, this);
             } else {
                 ui8 priority = PDiskPriority();
@@ -391,9 +391,9 @@ namespace NKikimr {
             : TLevelIndexExtremeQueryViaBatcherBase(queryCtx, parentId, std::move(logoBlobsSnapshot),
                     std::move(barrierSnapshot), ev, std::move(result), replSchedulerId)
             , TActorBootstrapped<TLevelIndexExtremeQueryViaBatcherMergeData>()
-            , GType(QueryCtx->HullCtx->VCtx->Top->GType) 
+            , GType(QueryCtx->HullCtx->VCtx->Top->GType)
             , Batcher(BatcherCtx)
-            , Merger(&Batcher, GType) 
+            , Merger(&Batcher, GType)
         {}
     };
 
diff --git a/ydb/core/blobstorage/vdisk/query/query_range.cpp b/ydb/core/blobstorage/vdisk/query/query_range.cpp
index 722b25d654..4513187b55 100644
--- a/ydb/core/blobstorage/vdisk/query/query_range.cpp
+++ b/ydb/core/blobstorage/vdisk/query/query_range.cpp
@@ -95,7 +95,7 @@ namespace NKikimr {
         void MainCycleIndexOnly(const TActorContext &ctx) {
             if (DirectionForward) {
                 // forward direction
-                while (Counter > 0 && !ResultSize.IsOverflow() && ForwardIt.Valid() && ForwardIt.GetCurKey() <= Last) { 
+                while (Counter > 0 && !ResultSize.IsOverflow() && ForwardIt.Valid() && ForwardIt.GetCurKey() <= Last) {
                     ForwardIt.PutToMerger(&Merger);
                     Merger.Finish();
                     AddIndexOnly(ForwardIt.GetCurKey().LogoBlobID(), Merger);
@@ -104,7 +104,7 @@ namespace NKikimr {
                 }
             } else {
                 // backward direction
-                while (Counter > 0 && !ResultSize.IsOverflow() && BackwardIt.Valid() && BackwardIt.GetCurKey() >= First) { 
+                while (Counter > 0 && !ResultSize.IsOverflow() && BackwardIt.Valid() && BackwardIt.GetCurKey() >= First) {
                     BackwardIt.PutToMerger(&Merger);
                     Merger.Finish();
                     AddIndexOnly(BackwardIt.GetCurKey().LogoBlobID(), Merger);
diff --git a/ydb/core/blobstorage/vdisk/query/query_spacetracker.h b/ydb/core/blobstorage/vdisk/query/query_spacetracker.h
index 20d5aefa55..374107424c 100644
--- a/ydb/core/blobstorage/vdisk/query/query_spacetracker.h
+++ b/ydb/core/blobstorage/vdisk/query/query_spacetracker.h
@@ -15,7 +15,7 @@ namespace NKikimr {
         void AddLogoBlobIndex() {
             Size += LogoBlobIndexSize;
         }
- 
+
         void AddLogoBlobData(ui64 blobSize, ui64 queryShift, ui64 querySize) {
             if (querySize) {
                 Size += querySize;
@@ -25,14 +25,14 @@ namespace NKikimr {
             }
         }
 
-        void AddAllPartsOfLogoBlob(const TBlobStorageGroupType &type, TLogoBlobID blobId) { 
-            for (ui32 partIdx = 0; partIdx < type.TotalPartCount(); ++partIdx) { 
-                AddLogoBlobIndex(); 
+        void AddAllPartsOfLogoBlob(const TBlobStorageGroupType &type, TLogoBlobID blobId) {
+            for (ui32 partIdx = 0; partIdx < type.TotalPartCount(); ++partIdx) {
+                AddLogoBlobIndex();
                 AddLogoBlobData(type.PartSize(TLogoBlobID(blobId, partIdx + 1)), 0, 0);
-            } 
-        } 
- 
-        bool IsOverflow() const { 
+            }
+        }
+
+        bool IsOverflow() const {
             return Size > MaxProtobufSize;
         }
 
@@ -40,34 +40,34 @@ namespace NKikimr {
             return Size;
         }
 
-        void Init() { 
-            Size = VGetResultIndexSize; 
-        } 
- 
+        void Init() {
+            Size = VGetResultIndexSize;
+        }
+
     private:
         // Result size we have counted
         ui64 Size = 0;
 
-        // Max size of TQueryResult without Buffer data 
+        // Max size of TQueryResult without Buffer data
         static constexpr ui64 LogoBlobIndexSize =
-            1 + 2        // Status 
-            + 1 + 1 + 24 // BlobId 
-            + 1 + 10     // Shift 
-            + 1 + 10     // Size 
-            + 1 + 10     // Buffer filed byte and varint 
-            + 1 + 10     // Cookie 
-            + 1 + 10     // FullDataSize 
-            + 1 + 10;    // Ingress 
- 
-        // Max size of TEvVGetResult without TQueryResult data 
-        static constexpr ui64 VGetResultIndexSize = 
-            1 + 2          // Status 
-            + 1 + 10       // TQueryResult field byte and varint 
-            + 1 + 1 + 30   // VDiskID 
-            + 1 + 10       // Cookier 
-            + 1 + 2 + 274  // MsgQoS 
-            + 1 + 5        // BlockedGeneration 
-            + 1 + 1 + 45;  // Timestamp= 
+            1 + 2        // Status
+            + 1 + 1 + 24 // BlobId
+            + 1 + 10     // Shift
+            + 1 + 10     // Size
+            + 1 + 10     // Buffer filed byte and varint
+            + 1 + 10     // Cookie
+            + 1 + 10     // FullDataSize
+            + 1 + 10;    // Ingress
+
+        // Max size of TEvVGetResult without TQueryResult data
+        static constexpr ui64 VGetResultIndexSize =
+            1 + 2          // Status
+            + 1 + 10       // TQueryResult field byte and varint
+            + 1 + 1 + 30   // VDiskID
+            + 1 + 10       // Cookier
+            + 1 + 2 + 274  // MsgQoS
+            + 1 + 5        // BlockedGeneration
+            + 1 + 1 + 45;  // Timestamp=
         // total limit on result
     };
 
diff --git a/ydb/core/blobstorage/vdisk/query/query_spacetracker_ut.cpp b/ydb/core/blobstorage/vdisk/query/query_spacetracker_ut.cpp
index 5ad9528fa1..8f5b39bab8 100644
--- a/ydb/core/blobstorage/vdisk/query/query_spacetracker_ut.cpp
+++ b/ydb/core/blobstorage/vdisk/query/query_spacetracker_ut.cpp
@@ -1,205 +1,205 @@
-#include "query_spacetracker.h" 
- 
+#include "query_spacetracker.h"
+
 #include <ydb/core/protos/base.pb.h>
 #include <ydb/core/protos/blobstorage.pb.h>
- 
+
 #include <library/cpp/testing/unittest/registar.h>
- 
-namespace NKikimr { 
- 
-    NKikimrBlobStorage::TVDiskID GetMaxTVDiskID() { 
-        NKikimrBlobStorage::TVDiskID diskId; 
-        diskId.SetGroupID(Max<ui32>()); 
-        diskId.SetGroupGeneration(Max<ui32>()); 
-        diskId.SetRing(Max<ui32>()); 
-        diskId.SetDomain(Max<ui32>()); 
-        diskId.SetVDisk(Max<ui32>()); 
-        return diskId; 
-    } 
- 
-    NKikimrBlobStorage::TMessageId GetMaxTMessageId() { 
-        NKikimrBlobStorage::TMessageId msgId; 
-        msgId.SetSequenceId(Max<ui64>()); 
-        msgId.SetMsgId(Max<ui64>()); 
-        return msgId; 
-    } 
- 
-    NKikimrBlobStorage::TVDiskCostSettings GetMaxTVDiskCostSettings() { 
-        NKikimrBlobStorage::TVDiskCostSettings costSettings; 
-        costSettings.SetSeekTimeUs(Max<ui64>()); 
-        costSettings.SetReadSpeedBps(Max<ui64>()); 
-        costSettings.SetWriteSpeedBps(Max<ui64>()); 
-        costSettings.SetReadBlockSize(Max<ui64>()); 
-        costSettings.SetWriteBlockSize(Max<ui64>()); 
-        costSettings.SetMinREALHugeBlobInBytes(Max<ui32>()); 
-        return costSettings; 
-    } 
- 
-    NKikimrBlobStorage::TWindowFeedback GetMaxTWindowFeedback() { 
-        NKikimrBlobStorage::TWindowFeedback feedback; 
-        feedback.SetStatus(NKikimrBlobStorage::TWindowFeedback_EStatus_EStatus_MAX); 
-        feedback.SetActualWindowSize(Max<ui64>()); 
-        feedback.SetMaxWindowSize(Max<ui64>()); 
-        *feedback.MutableExpectedMsgId() = GetMaxTMessageId(); 
-        *feedback.MutableFailedMsgId() = GetMaxTMessageId(); 
-        return feedback; 
-    } 
- 
-    NKikimrBlobStorage::TExecTimeStats GetMaxTExecTimeStats() { 
-        NKikimrBlobStorage::TExecTimeStats stats; 
-        stats.SetSubmitTimestamp(Max<ui64>()); 
-        stats.SetInSenderQueue(Max<ui64>()); 
-        stats.SetReceivedTimestamp(Max<ui64>()); 
-        stats.SetTotal(Max<ui64>()); 
-        stats.SetInQueue(Max<ui64>()); 
-        stats.SetExecution(Max<ui64>()); 
-        stats.SetHugeWriteTime(Max<ui64>()); 
-        return stats; 
-    } 
- 
-    NKikimrBlobStorage::TMsgQoS GetMaxTMsgQoS() { 
-        NKikimrBlobStorage::TMsgQoS msgQoS; 
-        msgQoS.SetDeadlineSeconds(Max<ui32>()); 
-        *msgQoS.MutableMsgId() = GetMaxTMessageId(); 
-        msgQoS.SetCost(Max<ui64>()); 
-        msgQoS.SetExtQueueId(NKikimrBlobStorage::EVDiskQueueId_MAX); 
-        msgQoS.SetIntQueueId(NKikimrBlobStorage::EVDiskInternalQueueId_MAX); 
-        *msgQoS.MutableCostSettings() = GetMaxTVDiskCostSettings(); 
-        msgQoS.SetSendMeCostSettings(true); 
-        *msgQoS.MutableWindow() = GetMaxTWindowFeedback(); 
-        msgQoS.SetVDiskLoadId(Max<ui64>()); 
-        *msgQoS.MutableExecTimeStats() = GetMaxTExecTimeStats(); 
-        return msgQoS; 
-    } 
- 
-    NKikimrBlobStorage::TTimestamps GetMaxTTimestamps() { 
-        NKikimrBlobStorage::TTimestamps ts; 
-        ts.SetSentByDSProxyUs(Max<ui64>()); 
-        ts.SetReceivedByDSProxyUs(Max<ui64>()); 
-        ts.SetSentByVDiskUs(Max<ui64>()); 
-        ts.SetReceivedByVDiskUs(Max<ui64>()); 
-        return ts; 
-    } 
- 
-    constexpr ui64 DefaultDataSize = 200'000; 
-    constexpr ui64 DefaultQueryMaxCount = MaxProtobufSize / DefaultDataSize; 
- 
-    NKikimrBlobStorage::TQueryResult GetMaxTQueryResult(ui64 size = DefaultDataSize) { 
-        static TString data; 
-        if (data.size() != size) { 
-            data.resize(size, 'a'); 
-        } 
-        NKikimrBlobStorage::TQueryResult res; 
-        res.SetStatus(NKikimrProto::EReplyStatus_MAX); 
-        res.MutableBlobID(); // in only fixuint64 
-        res.SetShift(Max<ui64>()); 
-        res.SetSize(Max<ui64>()); 
-        res.SetBuffer(data); 
-        res.SetCookie(Max<ui64>()); 
-        res.SetFullDataSize(Max<ui64>()); 
-        res.SetIngress(Max<ui64>()); 
-        return res; 
-    } 
- 
-    Y_UNIT_TEST_SUITE(TQueryResultSizeTrackerTest) { 
-        Y_UNIT_TEST(CheckWithoutQueryResult) { 
-            TQueryResultSizeTracker resultSize; 
-            NKikimrBlobStorage::TEvVGetResult result; 
- 
-            // check without QueryResult 
-            resultSize.Init(); 
- 
-            result.SetStatus(NKikimrProto::EReplyStatus_MAX); 
-            *result.MutableVDiskID() = GetMaxTVDiskID(); 
-            result.SetCookie(Max<ui64>()); 
-            *result.MutableMsgQoS() = GetMaxTMsgQoS(); 
-            result.SetBlockedGeneration(Max<ui32>()); 
-            *result.MutableTimestamps() = GetMaxTTimestamps(); 
- 
-            UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize()); 
-            UNIT_ASSERT(!resultSize.IsOverflow()); 
-        } 
- 
-        Y_UNIT_TEST(CheckOnlyQueryResult) { 
-            TQueryResultSizeTracker resultSize; 
-            NKikimrBlobStorage::TEvVGetResult result; 
- 
-            constexpr ui64 queryCount = (MaxProtobufSize + DefaultDataSize - 1) / DefaultDataSize; 
-            UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize()); 
- 
-            for (ui64 idx = 0; idx < queryCount; ++idx) { 
-                UNIT_ASSERT(!resultSize.IsOverflow()); 
-                resultSize.AddLogoBlobIndex(); 
-                resultSize.AddLogoBlobData(DefaultDataSize, 0, 0); 
-                *result.AddResult() = GetMaxTQueryResult(); 
-                UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize()); 
-            } 
- 
-            UNIT_ASSERT(resultSize.IsOverflow()); 
-        } 
- 
-        Y_UNIT_TEST(CheckAll) { 
-            TQueryResultSizeTracker resultSize; 
-            NKikimrBlobStorage::TEvVGetResult result; 
- 
-            // check without QueryResult 
-            resultSize.Init(); 
- 
-            result.SetStatus(NKikimrProto::EReplyStatus_MAX); 
-            *result.MutableVDiskID() = GetMaxTVDiskID(); 
-            result.SetCookie(Max<ui64>()); 
-            *result.MutableMsgQoS() = GetMaxTMsgQoS(); 
-            result.SetBlockedGeneration(Max<ui32>()); 
-            *result.MutableTimestamps() = GetMaxTTimestamps(); 
- 
-            constexpr ui64 queryCount = (MaxProtobufSize + DefaultDataSize - 1) / DefaultDataSize; 
-            UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize()); 
- 
-            for (ui64 idx = 0; idx < queryCount; ++idx) { 
-                UNIT_ASSERT(!resultSize.IsOverflow()); 
-                resultSize.AddLogoBlobIndex(); 
-                resultSize.AddLogoBlobData(DefaultDataSize, 0, 0); 
-                *result.AddResult() = GetMaxTQueryResult(); 
-                UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize()); 
-            } 
- 
-            UNIT_ASSERT(resultSize.IsOverflow()); 
-        } 
- 
-        void MakeTestSerializeDeserialize(ui64 defaultQueryCount, ui64 lastDataSize, ui64 protobufSize) { 
-            NKikimrBlobStorage::TEvVGetResult result; 
- 
-            result.SetStatus(NKikimrProto::EReplyStatus_MAX); 
-            *result.MutableVDiskID() = GetMaxTVDiskID(); 
-            result.SetCookie(Max<ui64>()); 
-            *result.MutableMsgQoS() = GetMaxTMsgQoS(); 
-            result.SetBlockedGeneration(Max<ui32>()); 
-            *result.MutableTimestamps() = GetMaxTTimestamps(); 
- 
-            for (ui64 idx = 0; idx < defaultQueryCount; ++idx) { 
+
+namespace NKikimr {
+
+    NKikimrBlobStorage::TVDiskID GetMaxTVDiskID() {
+        NKikimrBlobStorage::TVDiskID diskId;
+        diskId.SetGroupID(Max<ui32>());
+        diskId.SetGroupGeneration(Max<ui32>());
+        diskId.SetRing(Max<ui32>());
+        diskId.SetDomain(Max<ui32>());
+        diskId.SetVDisk(Max<ui32>());
+        return diskId;
+    }
+
+    NKikimrBlobStorage::TMessageId GetMaxTMessageId() {
+        NKikimrBlobStorage::TMessageId msgId;
+        msgId.SetSequenceId(Max<ui64>());
+        msgId.SetMsgId(Max<ui64>());
+        return msgId;
+    }
+
+    NKikimrBlobStorage::TVDiskCostSettings GetMaxTVDiskCostSettings() {
+        NKikimrBlobStorage::TVDiskCostSettings costSettings;
+        costSettings.SetSeekTimeUs(Max<ui64>());
+        costSettings.SetReadSpeedBps(Max<ui64>());
+        costSettings.SetWriteSpeedBps(Max<ui64>());
+        costSettings.SetReadBlockSize(Max<ui64>());
+        costSettings.SetWriteBlockSize(Max<ui64>());
+        costSettings.SetMinREALHugeBlobInBytes(Max<ui32>());
+        return costSettings;
+    }
+
+    NKikimrBlobStorage::TWindowFeedback GetMaxTWindowFeedback() {
+        NKikimrBlobStorage::TWindowFeedback feedback;
+        feedback.SetStatus(NKikimrBlobStorage::TWindowFeedback_EStatus_EStatus_MAX);
+        feedback.SetActualWindowSize(Max<ui64>());
+        feedback.SetMaxWindowSize(Max<ui64>());
+        *feedback.MutableExpectedMsgId() = GetMaxTMessageId();
+        *feedback.MutableFailedMsgId() = GetMaxTMessageId();
+        return feedback;
+    }
+
+    NKikimrBlobStorage::TExecTimeStats GetMaxTExecTimeStats() {
+        NKikimrBlobStorage::TExecTimeStats stats;
+        stats.SetSubmitTimestamp(Max<ui64>());
+        stats.SetInSenderQueue(Max<ui64>());
+        stats.SetReceivedTimestamp(Max<ui64>());
+        stats.SetTotal(Max<ui64>());
+        stats.SetInQueue(Max<ui64>());
+        stats.SetExecution(Max<ui64>());
+        stats.SetHugeWriteTime(Max<ui64>());
+        return stats;
+    }
+
+    NKikimrBlobStorage::TMsgQoS GetMaxTMsgQoS() {
+        NKikimrBlobStorage::TMsgQoS msgQoS;
+        msgQoS.SetDeadlineSeconds(Max<ui32>());
+        *msgQoS.MutableMsgId() = GetMaxTMessageId();
+        msgQoS.SetCost(Max<ui64>());
+        msgQoS.SetExtQueueId(NKikimrBlobStorage::EVDiskQueueId_MAX);
+        msgQoS.SetIntQueueId(NKikimrBlobStorage::EVDiskInternalQueueId_MAX);
+        *msgQoS.MutableCostSettings() = GetMaxTVDiskCostSettings();
+        msgQoS.SetSendMeCostSettings(true);
+        *msgQoS.MutableWindow() = GetMaxTWindowFeedback();
+        msgQoS.SetVDiskLoadId(Max<ui64>());
+        *msgQoS.MutableExecTimeStats() = GetMaxTExecTimeStats();
+        return msgQoS;
+    }
+
+    NKikimrBlobStorage::TTimestamps GetMaxTTimestamps() {
+        NKikimrBlobStorage::TTimestamps ts;
+        ts.SetSentByDSProxyUs(Max<ui64>());
+        ts.SetReceivedByDSProxyUs(Max<ui64>());
+        ts.SetSentByVDiskUs(Max<ui64>());
+        ts.SetReceivedByVDiskUs(Max<ui64>());
+        return ts;
+    }
+
+    constexpr ui64 DefaultDataSize = 200'000;
+    constexpr ui64 DefaultQueryMaxCount = MaxProtobufSize / DefaultDataSize;
+
+    NKikimrBlobStorage::TQueryResult GetMaxTQueryResult(ui64 size = DefaultDataSize) {
+        static TString data;
+        if (data.size() != size) {
+            data.resize(size, 'a');
+        }
+        NKikimrBlobStorage::TQueryResult res;
+        res.SetStatus(NKikimrProto::EReplyStatus_MAX);
+        res.MutableBlobID(); // in only fixuint64
+        res.SetShift(Max<ui64>());
+        res.SetSize(Max<ui64>());
+        res.SetBuffer(data);
+        res.SetCookie(Max<ui64>());
+        res.SetFullDataSize(Max<ui64>());
+        res.SetIngress(Max<ui64>());
+        return res;
+    }
+
+    Y_UNIT_TEST_SUITE(TQueryResultSizeTrackerTest) {
+        Y_UNIT_TEST(CheckWithoutQueryResult) {
+            TQueryResultSizeTracker resultSize;
+            NKikimrBlobStorage::TEvVGetResult result;
+
+            // check without QueryResult
+            resultSize.Init();
+
+            result.SetStatus(NKikimrProto::EReplyStatus_MAX);
+            *result.MutableVDiskID() = GetMaxTVDiskID();
+            result.SetCookie(Max<ui64>());
+            *result.MutableMsgQoS() = GetMaxTMsgQoS();
+            result.SetBlockedGeneration(Max<ui32>());
+            *result.MutableTimestamps() = GetMaxTTimestamps();
+
+            UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize());
+            UNIT_ASSERT(!resultSize.IsOverflow());
+        }
+
+        Y_UNIT_TEST(CheckOnlyQueryResult) {
+            TQueryResultSizeTracker resultSize;
+            NKikimrBlobStorage::TEvVGetResult result;
+
+            constexpr ui64 queryCount = (MaxProtobufSize + DefaultDataSize - 1) / DefaultDataSize;
+            UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize());
+
+            for (ui64 idx = 0; idx < queryCount; ++idx) {
+                UNIT_ASSERT(!resultSize.IsOverflow());
+                resultSize.AddLogoBlobIndex();
+                resultSize.AddLogoBlobData(DefaultDataSize, 0, 0);
+                *result.AddResult() = GetMaxTQueryResult();
+                UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize());
+            }
+
+            UNIT_ASSERT(resultSize.IsOverflow());
+        }
+
+        Y_UNIT_TEST(CheckAll) {
+            TQueryResultSizeTracker resultSize;
+            NKikimrBlobStorage::TEvVGetResult result;
+
+            // check without QueryResult
+            resultSize.Init();
+
+            result.SetStatus(NKikimrProto::EReplyStatus_MAX);
+            *result.MutableVDiskID() = GetMaxTVDiskID();
+            result.SetCookie(Max<ui64>());
+            *result.MutableMsgQoS() = GetMaxTMsgQoS();
+            result.SetBlockedGeneration(Max<ui32>());
+            *result.MutableTimestamps() = GetMaxTTimestamps();
+
+            constexpr ui64 queryCount = (MaxProtobufSize + DefaultDataSize - 1) / DefaultDataSize;
+            UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize());
+
+            for (ui64 idx = 0; idx < queryCount; ++idx) {
+                UNIT_ASSERT(!resultSize.IsOverflow());
+                resultSize.AddLogoBlobIndex();
+                resultSize.AddLogoBlobData(DefaultDataSize, 0, 0);
+                *result.AddResult() = GetMaxTQueryResult();
+                UNIT_ASSERT_LE(result.ByteSizeLong(), resultSize.GetSize());
+            }
+
+            UNIT_ASSERT(resultSize.IsOverflow());
+        }
+
+        void MakeTestSerializeDeserialize(ui64 defaultQueryCount, ui64 lastDataSize, ui64 protobufSize) {
+            NKikimrBlobStorage::TEvVGetResult result;
+
+            result.SetStatus(NKikimrProto::EReplyStatus_MAX);
+            *result.MutableVDiskID() = GetMaxTVDiskID();
+            result.SetCookie(Max<ui64>());
+            *result.MutableMsgQoS() = GetMaxTMsgQoS();
+            result.SetBlockedGeneration(Max<ui32>());
+            *result.MutableTimestamps() = GetMaxTTimestamps();
+
+            for (ui64 idx = 0; idx < defaultQueryCount; ++idx) {
                 Y_PROTOBUF_SUPPRESS_NODISCARD result.ParseFromString(result.SerializeAsString());
-                *result.AddResult() = GetMaxTQueryResult(); 
-            } 
-            *result.AddResult() = GetMaxTQueryResult(lastDataSize); 
-            UNIT_ASSERT(result.ByteSizeLong() == protobufSize); 
- 
-            NKikimrBlobStorage::TEvVGetResult desResult; 
+                *result.AddResult() = GetMaxTQueryResult();
+            }
+            *result.AddResult() = GetMaxTQueryResult(lastDataSize);
+            UNIT_ASSERT(result.ByteSizeLong() == protobufSize);
+
+            NKikimrBlobStorage::TEvVGetResult desResult;
             TArrayHolder<char> buffer(new char[protobufSize]);
             Y_PROTOBUF_SUPPRESS_NODISCARD result.SerializeToArray(buffer.Get(), protobufSize);
-            UNIT_ASSERT(desResult.ParseFromArray(buffer.Get(), protobufSize)); 
-        } 
- 
-        Y_UNIT_TEST(SerializeDeserializeMaxPtotobufSizeMinusOne) { 
-            MakeTestSerializeDeserialize(DefaultQueryMaxCount, 84'775, MaxProtobufSize - 1); 
-        } 
- 
-        Y_UNIT_TEST(SerializeDeserializeMaxPtotobufSize) { 
-            MakeTestSerializeDeserialize(DefaultQueryMaxCount, 84'776, MaxProtobufSize); 
-        } 
- 
-        Y_UNIT_TEST(SerializeDeserializeMaxPtotobufSizePlusOne) { 
-            MakeTestSerializeDeserialize(DefaultQueryMaxCount, 84'777, MaxProtobufSize + 1); 
-        } 
-    } 
- 
-} // NKikimr 
+            UNIT_ASSERT(desResult.ParseFromArray(buffer.Get(), protobufSize));
+        }
+
+        Y_UNIT_TEST(SerializeDeserializeMaxPtotobufSizeMinusOne) {
+            MakeTestSerializeDeserialize(DefaultQueryMaxCount, 84'775, MaxProtobufSize - 1);
+        }
+
+        Y_UNIT_TEST(SerializeDeserializeMaxPtotobufSize) {
+            MakeTestSerializeDeserialize(DefaultQueryMaxCount, 84'776, MaxProtobufSize);
+        }
+
+        Y_UNIT_TEST(SerializeDeserializeMaxPtotobufSizePlusOne) {
+            MakeTestSerializeDeserialize(DefaultQueryMaxCount, 84'777, MaxProtobufSize + 1);
+        }
+    }
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/query/ut/ya.make b/ydb/core/blobstorage/vdisk/query/ut/ya.make
index c94445e8ee..53d39a8af6 100644
--- a/ydb/core/blobstorage/vdisk/query/ut/ya.make
+++ b/ydb/core/blobstorage/vdisk/query/ut/ya.make
@@ -1,7 +1,7 @@
 UNITTEST_FOR(ydb/core/blobstorage/vdisk/query)
- 
-OWNER(g:kikimr) 
- 
+
+OWNER(g:kikimr)
+
 IF (WITH_VALGRIND)
     FORK_SUBTESTS()
     TIMEOUT(1800)
@@ -12,14 +12,14 @@ ELSE()
     TIMEOUT(600)
     SIZE(MEDIUM)
 ENDIF()
- 
-PEERDIR( 
+
+PEERDIR(
     ydb/core/blobstorage/vdisk/huge
     ydb/core/protos
-) 
- 
-SRCS( 
+)
+
+SRCS(
     query_spacetracker_ut.cpp
-) 
- 
-END() 
+)
+
+END()
diff --git a/ydb/core/blobstorage/vdisk/query/ya.make b/ydb/core/blobstorage/vdisk/query/ya.make
index 2238e89269..4d638cf803 100644
--- a/ydb/core/blobstorage/vdisk/query/ya.make
+++ b/ydb/core/blobstorage/vdisk/query/ya.make
@@ -38,7 +38,7 @@ SRCS(
 )
 
 END()
- 
+
 RECURSE_FOR_TESTS(
     ut
 )
diff --git a/ydb/core/blobstorage/vdisk/repl/blobstorage_repl.cpp b/ydb/core/blobstorage/vdisk/repl/blobstorage_repl.cpp
index 1bac48eda3..34be219abc 100644
--- a/ydb/core/blobstorage/vdisk/repl/blobstorage_repl.cpp
+++ b/ydb/core/blobstorage/vdisk/repl/blobstorage_repl.cpp
@@ -190,17 +190,17 @@ namespace NKikimr {
 
         void Bootstrap() {
             QueueActorMapPtr = std::make_shared<TQueueActorMap>();
-            auto replInterconnectChannel = static_cast<TInterconnectChannels::EInterconnectChannels>( 
+            auto replInterconnectChannel = static_cast<TInterconnectChannels::EInterconnectChannels>(
                     ReplCtx->VDiskCfg->ReplInterconnectChannel);
- 
+
             const TBlobStorageGroupInfo::TTopology& topology = ReplCtx->GInfo->GetTopology();
-            NBackpressure::TQueueClientId replQueueClientId(NBackpressure::EQueueClientType::ReplJob, 
-                        topology.GetOrderNumber(ReplCtx->VCtx->ShortSelfVDisk)); 
-            CreateQueuesForVDisks(*QueueActorMapPtr, SelfId(), ReplCtx->GInfo, ReplCtx->VCtx, 
-                    ReplCtx->GInfo->GetVDisks(), ReplCtx->MonGroup.GetGroup(), 
-                    replQueueClientId, NKikimrBlobStorage::EVDiskQueueId::GetAsyncRead, 
-                    "PeerRepl", replInterconnectChannel); 
- 
+            NBackpressure::TQueueClientId replQueueClientId(NBackpressure::EQueueClientType::ReplJob,
+                        topology.GetOrderNumber(ReplCtx->VCtx->ShortSelfVDisk));
+            CreateQueuesForVDisks(*QueueActorMapPtr, SelfId(), ReplCtx->GInfo, ReplCtx->VCtx,
+                    ReplCtx->GInfo->GetVDisks(), ReplCtx->MonGroup.GetGroup(),
+                    replQueueClientId, NKikimrBlobStorage::EVDiskQueueId::GetAsyncRead,
+                    "PeerRepl", replInterconnectChannel);
+
             for (const auto& [vdiskId, vdiskActorId] : ReplCtx->VDiskCfg->BaseInfo.DonorDiskIds) {
                 TIntrusivePtr<NBackpressure::TFlowRecord> flowRecord(new NBackpressure::TFlowRecord);
                 auto info = MakeIntrusive<TBlobStorageGroupInfo>(ReplCtx->GInfo, vdiskId, vdiskActorId);
diff --git a/ydb/core/blobstorage/vdisk/scrub/blob_recovery_queue.cpp b/ydb/core/blobstorage/vdisk/scrub/blob_recovery_queue.cpp
index bf5d5851d3..6e4c2b6675 100644
--- a/ydb/core/blobstorage/vdisk/scrub/blob_recovery_queue.cpp
+++ b/ydb/core/blobstorage/vdisk/scrub/blob_recovery_queue.cpp
@@ -1,20 +1,20 @@
 #include "blob_recovery_impl.h"
 
 #include <ydb/core/blobstorage/vdisk/common/vdisk_queues.h>
- 
+
 namespace NKikimr {
 
     void TBlobRecoveryActor::StartQueues() {
-        struct TQueueActorIdWrapper { 
-            TQueueInfo Wrap(TActorId &&id) const { 
-                return {std::move(id)}; 
-            } 
-        }; 
+        struct TQueueActorIdWrapper {
+            TQueueInfo Wrap(TActorId &&id) const {
+                return {std::move(id)};
+            }
+        };
         const NBackpressure::TQueueClientId clientId(NBackpressure::EQueueClientType::ReplJob,
             Info->GetTotalVDisksNum() + Info->GetOrderNumber(VCtx->ShortSelfVDisk)); // distinct queue client id
-        CreateQueuesForVDisks(Queues, SelfId(), Info, VCtx, Info->GetVDisks(), Counters, 
-            clientId, NKikimrBlobStorage::EVDiskQueueId::GetLowRead, "PeerScrub", 
-            TInterconnectChannels::IC_BLOBSTORAGE_ASYNC_DATA, TQueueActorIdWrapper()); 
+        CreateQueuesForVDisks(Queues, SelfId(), Info, VCtx, Info->GetVDisks(), Counters,
+            clientId, NKikimrBlobStorage::EVDiskQueueId::GetLowRead, "PeerScrub",
+            TInterconnectChannels::IC_BLOBSTORAGE_ASYNC_DATA, TQueueActorIdWrapper());
     }
 
     void TBlobRecoveryActor::StopQueues() {
diff --git a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp
index 445d0b5cb3..96b813d317 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp
@@ -7,8 +7,8 @@
 #include "blobstorage_takedbsnap.h"
 #include "skeleton_loggedrec.h"
 #include "skeleton_vmultiput_actor.h"
-#include "skeleton_vmovedpatch_actor.h" 
-#include "skeleton_vpatch_actor.h" 
+#include "skeleton_vmovedpatch_actor.h"
+#include "skeleton_vpatch_actor.h"
 #include "skeleton_oos_logic.h"
 #include "skeleton_oos_tracker.h"
 #include "skeleton_overload_handler.h"
@@ -143,129 +143,129 @@ namespace NKikimr {
         }
 
         ////////////////////////////////////////////////////////////////////////
-        // PATCH SECTOR 
-        //////////////////////////////////////////////////////////////////////// 
- 
-        void Handle(TEvBlobStorage::TEvVMovedPatch::TPtr &ev, const TActorContext &ctx) { 
-            const bool postpone = OverloadHandler->PostponeEvent(ev, ctx, this); 
-            if (!postpone) { 
-                PrivateHandle(ev, ctx); 
-            } 
-        } 
- 
-         void PrivateHandle(TEvBlobStorage::TEvVMovedPatch::TPtr &ev, const TActorContext &ctx) { 
-            LOG_DEBUG_S(ctx, BS_VDISK_PATCH, VCtx->VDiskLogPrefix << "TEvVMovedPatch: register actor;" 
-                    << " Event# " << ev->Get()->ToString()); 
-            IFaceMonGroup->MovedPatchMsgs()++; 
-            TOutOfSpaceStatus oosStatus = VCtx->GetOutOfSpaceState().GetGlobalStatusFlags(); 
-            Register(CreateSkeletonVMovedPatchActor(SelfId(), oosStatus, ev, SkeletonFrontIDPtr, 
-                    IFaceMonGroup->MovedPatchResMsgsPtr(), Db->GetVDiskIncarnationGuid(), VCtx)); 
-        } 
- 
-        void UpdateVPatchCtx() { 
-            if (!VPatchCtx) { 
-                TIntrusivePtr<NMonitoring::TDynamicCounters> patchGroup = VCtx->VDiskCounters->GetSubgroup("subsystem", "patch"); 
-                VPatchCtx = MakeIntrusive<TVPatchCtx>(); 
-                NBackpressure::TQueueClientId patchQueueClientId(NBackpressure::EQueueClientType::VPatch, 
-                            VCtx->Top->GetOrderNumber(VCtx->ShortSelfVDisk)); 
-                CreateQueuesForVDisks(VPatchCtx->AsyncBlobQueues, SelfId(), GInfo, VCtx, GInfo->GetVDisks(), patchGroup, 
-                        patchQueueClientId, NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob, 
-                        "PeerVPatch",  TInterconnectChannels::IC_BLOBSTORAGE_ASYNC_DATA); 
-            } 
-        } 
- 
-        void Handle(TEvProxyQueueState::TPtr &/*ev*/, const TActorContext &/*ctx*/) { 
-            // TODO(kruall): Make it better 
-        } 
- 
-        template <typename TEvPtr> 
-        void ReplyVPatchError(NKikimrProto::EReplyStatus status, const TString& errorReason, TEvPtr &ev) { 
-            using namespace NErrBuilder; 
+        // PATCH SECTOR
+        ////////////////////////////////////////////////////////////////////////
+
+        void Handle(TEvBlobStorage::TEvVMovedPatch::TPtr &ev, const TActorContext &ctx) {
+            const bool postpone = OverloadHandler->PostponeEvent(ev, ctx, this);
+            if (!postpone) {
+                PrivateHandle(ev, ctx);
+            }
+        }
+
+         void PrivateHandle(TEvBlobStorage::TEvVMovedPatch::TPtr &ev, const TActorContext &ctx) {
+            LOG_DEBUG_S(ctx, BS_VDISK_PATCH, VCtx->VDiskLogPrefix << "TEvVMovedPatch: register actor;"
+                    << " Event# " << ev->Get()->ToString());
+            IFaceMonGroup->MovedPatchMsgs()++;
+            TOutOfSpaceStatus oosStatus = VCtx->GetOutOfSpaceState().GetGlobalStatusFlags();
+            Register(CreateSkeletonVMovedPatchActor(SelfId(), oosStatus, ev, SkeletonFrontIDPtr,
+                    IFaceMonGroup->MovedPatchResMsgsPtr(), Db->GetVDiskIncarnationGuid(), VCtx));
+        }
+
+        void UpdateVPatchCtx() {
+            if (!VPatchCtx) {
+                TIntrusivePtr<NMonitoring::TDynamicCounters> patchGroup = VCtx->VDiskCounters->GetSubgroup("subsystem", "patch");
+                VPatchCtx = MakeIntrusive<TVPatchCtx>();
+                NBackpressure::TQueueClientId patchQueueClientId(NBackpressure::EQueueClientType::VPatch,
+                            VCtx->Top->GetOrderNumber(VCtx->ShortSelfVDisk));
+                CreateQueuesForVDisks(VPatchCtx->AsyncBlobQueues, SelfId(), GInfo, VCtx, GInfo->GetVDisks(), patchGroup,
+                        patchQueueClientId, NKikimrBlobStorage::EVDiskQueueId::PutAsyncBlob,
+                        "PeerVPatch",  TInterconnectChannels::IC_BLOBSTORAGE_ASYNC_DATA);
+            }
+        }
+
+        void Handle(TEvProxyQueueState::TPtr &/*ev*/, const TActorContext &/*ctx*/) {
+            // TODO(kruall): Make it better
+        }
+
+        template <typename TEvPtr>
+        void ReplyVPatchError(NKikimrProto::EReplyStatus status, const TString& errorReason, TEvPtr &ev) {
+            using namespace NErrBuilder;
             std::unique_ptr<IEventBase> res = ErroneousResult(VCtx, status, errorReason, ev, TActivationContext::Now(),
-                    SkeletonFrontIDPtr, SelfVDiskId, Db->GetVDiskIncarnationGuid(), GInfo); 
+                    SkeletonFrontIDPtr, SelfVDiskId, Db->GetVDiskIncarnationGuid(), GInfo);
             SendReply(TActivationContext::AsActorContext(), std::move(res), ev, BS_VDISK_PATCH);
-        } 
- 
-        void Handle(TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TActorContext &ctx) { 
-            const bool postpone = OverloadHandler->PostponeEvent(ev, ctx, this); 
-            if (!postpone) { 
-                PrivateHandle(ev, ctx); 
-            } 
-        } 
- 
-        void PrivateHandle(TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TActorContext &ctx) { 
-            TInstant now = ctx.Now(); 
-            if (!EnableVPatch.Update(now)) { 
-                ReplyVPatchError(NKikimrProto::ERROR, "VPatch is disabled", ev); 
-                return; 
-            } 
- 
-            TLogoBlobID patchedBlobId = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetPatchedBlobId()); 
- 
-            if (VPatchActors.count(patchedBlobId)) { 
-                ReplyVPatchError(NKikimrProto::ERROR, "The patching request already is running", ev); 
-                return; 
-            } 
- 
-            LOG_DEBUG_S(ctx, BS_VDISK_PATCH, VCtx->VDiskLogPrefix << "TEvVPatch: register actor;" 
-                    << " Event# " << ev->Get()->ToString()); 
-            IFaceMonGroup->PatchStartMsgs()++; 
-            UpdateVPatchCtx(); 
+        }
+
+        void Handle(TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TActorContext &ctx) {
+            const bool postpone = OverloadHandler->PostponeEvent(ev, ctx, this);
+            if (!postpone) {
+                PrivateHandle(ev, ctx);
+            }
+        }
+
+        void PrivateHandle(TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TActorContext &ctx) {
+            TInstant now = ctx.Now();
+            if (!EnableVPatch.Update(now)) {
+                ReplyVPatchError(NKikimrProto::ERROR, "VPatch is disabled", ev);
+                return;
+            }
+
+            TLogoBlobID patchedBlobId = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetPatchedBlobId());
+
+            if (VPatchActors.count(patchedBlobId)) {
+                ReplyVPatchError(NKikimrProto::ERROR, "The patching request already is running", ev);
+                return;
+            }
+
+            LOG_DEBUG_S(ctx, BS_VDISK_PATCH, VCtx->VDiskLogPrefix << "TEvVPatch: register actor;"
+                    << " Event# " << ev->Get()->ToString());
+            IFaceMonGroup->PatchStartMsgs()++;
+            UpdateVPatchCtx();
             std::unique_ptr<IActor> actor{CreateSkeletonVPatchActor(SelfId(), GInfo->Type, ev, now, SkeletonFrontIDPtr,
-                    IFaceMonGroup->PatchFoundPartsMsgsPtr(), IFaceMonGroup->PatchResMsgsPtr(), VPatchCtx, 
+                    IFaceMonGroup->PatchFoundPartsMsgsPtr(), IFaceMonGroup->PatchResMsgsPtr(), VPatchCtx,
                     VCtx->VDiskLogPrefix, Db->GetVDiskIncarnationGuid())};
             TActorId vPatchActor = Register(actor.release());
-            VPatchActors.emplace(patchedBlobId, vPatchActor); 
-        } 
- 
-        template <typename TEvDiffPtr> 
-        void HandleVPatchDiffResending(TEvDiffPtr &ev, const TActorContext &ctx) { 
-            if constexpr (std::is_same_v<TEvDiffPtr, TEvBlobStorage::TEvVPatchDiff::TPtr>) { 
-                LOG_DEBUG_S(ctx, BS_VDISK_PATCH, VCtx->VDiskLogPrefix << "TEvVPatch: recieve diff;" 
-                        << " Event# " << ev->Get()->ToString()); 
-                IFaceMonGroup->PatchDiffMsgs()++; 
-            } 
-            if constexpr (std::is_same_v<TEvDiffPtr, TEvBlobStorage::TEvVPatchXorDiff::TPtr>) { 
-                LOG_DEBUG_S(ctx, BS_VDISK_PATCH, VCtx->VDiskLogPrefix << "TEvVPatch: recieve xor diff;" 
-                        << " Event# " << ev->Get()->ToString()); 
-                IFaceMonGroup->PatchXorDiffMsgs()++; 
-            } 
-            TLogoBlobID patchedBlobId = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetPatchedPartBlobId()).FullID(); 
-            auto it = VPatchActors.find(patchedBlobId); 
-            if (it != VPatchActors.end()) { 
+            VPatchActors.emplace(patchedBlobId, vPatchActor);
+        }
+
+        template <typename TEvDiffPtr>
+        void HandleVPatchDiffResending(TEvDiffPtr &ev, const TActorContext &ctx) {
+            if constexpr (std::is_same_v<TEvDiffPtr, TEvBlobStorage::TEvVPatchDiff::TPtr>) {
+                LOG_DEBUG_S(ctx, BS_VDISK_PATCH, VCtx->VDiskLogPrefix << "TEvVPatch: recieve diff;"
+                        << " Event# " << ev->Get()->ToString());
+                IFaceMonGroup->PatchDiffMsgs()++;
+            }
+            if constexpr (std::is_same_v<TEvDiffPtr, TEvBlobStorage::TEvVPatchXorDiff::TPtr>) {
+                LOG_DEBUG_S(ctx, BS_VDISK_PATCH, VCtx->VDiskLogPrefix << "TEvVPatch: recieve xor diff;"
+                        << " Event# " << ev->Get()->ToString());
+                IFaceMonGroup->PatchXorDiffMsgs()++;
+            }
+            TLogoBlobID patchedBlobId = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetPatchedPartBlobId()).FullID();
+            auto it = VPatchActors.find(patchedBlobId);
+            if (it != VPatchActors.end()) {
                 TActivationContext::Send(ev->Forward(it->second));
-            } else { 
-                ReplyVPatchError(NKikimrProto::ERROR, "VPatchActor doesn't exist", ev); 
-            } 
-        } 
- 
-        void Handle(TEvVPatchDyingRequest::TPtr &ev) { 
-            auto it = VPatchActors.find(ev->Get()->PatchedBlobId); 
-            if (it != VPatchActors.end()) { 
-                VPatchActors.erase(it); 
-            } 
-            Send(ev->Sender, new TEvVPatchDyingConfirm); 
-        } 
- 
-        //////////////////////////////////////////////////////////////////////// 
+            } else {
+                ReplyVPatchError(NKikimrProto::ERROR, "VPatchActor doesn't exist", ev);
+            }
+        }
+
+        void Handle(TEvVPatchDyingRequest::TPtr &ev) {
+            auto it = VPatchActors.find(ev->Get()->PatchedBlobId);
+            if (it != VPatchActors.end()) {
+                VPatchActors.erase(it);
+            }
+            Send(ev->Sender, new TEvVPatchDyingConfirm);
+        }
+
+        ////////////////////////////////////////////////////////////////////////
         // MULTIPUT SECTOR
         ////////////////////////////////////////////////////////////////////////
         void ReplyError(NKikimrProto::EReplyStatus status, const TString& errorReason, TEvBlobStorage::TEvVMultiPut::TPtr &ev,
                         const TActorContext &ctx, TInstant now) {
-            using namespace NErrBuilder; 
+            using namespace NErrBuilder;
             std::unique_ptr<IEventBase> res(ErroneousResult(VCtx, status, errorReason, ev, now, SkeletonFrontIDPtr, SelfVDiskId,
                     Db->GetVDiskIncarnationGuid(), GInfo));
             SendReply(ctx, std::move(res), ev, BS_VDISK_PUT);
-        } 
- 
+        }
+
         void ReplyError(NKikimrProto::EReplyStatus status, const TString& errorReason, TEvBlobStorage::TEvVMultiPut::TPtr &ev,
                         const TActorContext &ctx, TInstant now, const TBatchedVec<NKikimrProto::EReplyStatus> &statuses) {
-            using namespace NErrBuilder; 
+            using namespace NErrBuilder;
             std::unique_ptr<IEventBase> res(ErroneousResult(VCtx, status, errorReason, ev, now, SkeletonFrontIDPtr, SelfVDiskId, statuses,
                     Db->GetVDiskIncarnationGuid(), GInfo));
             SendReply(ctx, std::move(res), ev, BS_VDISK_PUT);
-        } 
- 
+        }
+
         void Handle(TEvBlobStorage::TEvVMultiPut::TPtr &ev, const TActorContext &ctx) {
             const bool postpone = OverloadHandler->PostponeEvent(ev, ctx, this);
             if (!postpone) {
@@ -273,98 +273,98 @@ namespace NKikimr {
             }
         }
 
-        struct TVPutInfo { 
-            TRope Buffer = {}; 
-            TLogoBlobID BlobId = {}; 
-            TIngress Ingress = {}; 
-            TLsnSeg Lsn = {}; 
-            THullCheckStatus HullStatus; 
-            bool IsHugeBlob = false; 
- 
-            TVPutInfo(TLogoBlobID blobId, TRope &&buffer) 
-                : Buffer(std::move(buffer)) 
-                , BlobId(blobId) 
-                , HullStatus({NKikimrProto::UNKNOWN, 0 ,false}) 
-            {} 
-        }; 
- 
+        struct TVPutInfo {
+            TRope Buffer = {};
+            TLogoBlobID BlobId = {};
+            TIngress Ingress = {};
+            TLsnSeg Lsn = {};
+            THullCheckStatus HullStatus;
+            bool IsHugeBlob = false;
+
+            TVPutInfo(TLogoBlobID blobId, TRope &&buffer)
+                : Buffer(std::move(buffer))
+                , BlobId(blobId)
+                , HullStatus({NKikimrProto::UNKNOWN, 0 ,false})
+            {}
+        };
+
         void UpdatePDiskWriteBytes(size_t size) {
             *PDiskWriteBytes += size; // actual size for small blobs may be up to one block, but it may be
             // batched along with other VDisk log entries on the PDisk
         }
 
-        TLoggedRecVPut* CreateLoggedRec(TLsnSeg seg, bool confirmSyncLogAlso, const TLogoBlobID &id, 
+        TLoggedRecVPut* CreateLoggedRec(TLsnSeg seg, bool confirmSyncLogAlso, const TLogoBlobID &id,
                 const TIngress &ingress, TRope &&buffer, std::unique_ptr<TEvBlobStorage::TEvVPutResult> res,
                 const TActorId &sender, ui64 cookie)
-        { 
+        {
             return new TLoggedRecVPut(seg, confirmSyncLogAlso, id, ingress, std::move(buffer), std::move(res), sender, cookie);
-        } 
- 
-        TLoggedRecVMultiPutItem* CreateLoggedRec(TLsnSeg seg, bool confirmSyncLogAlso, const TLogoBlobID &id, 
+        }
+
+        TLoggedRecVMultiPutItem* CreateLoggedRec(TLsnSeg seg, bool confirmSyncLogAlso, const TLogoBlobID &id,
                 const TIngress &ingress, TRope &&buffer, std::unique_ptr<TEvVMultiPutItemResult> res,
                 const TActorId &sender, ui64 cookie)
-        { 
+        {
             return new TLoggedRecVMultiPutItem(seg, confirmSyncLogAlso, id, ingress, std::move(buffer), std::move(res),
-                    sender, cookie); 
-        } 
- 
-        template <typename TEvResult> 
+                    sender, cookie);
+        }
+
+        template <typename TEvResult>
         std::unique_ptr<NPDisk::TEvLog> CreatePutLogEvent(const TActorContext &ctx, TString evPrefix, NActors::TActorId sender,
-                ui64 cookie, NLWTrace::TOrbit &&orbit, TVPutInfo &info, 
+                ui64 cookie, NLWTrace::TOrbit &&orbit, TVPutInfo &info,
                 std::unique_ptr<TEvResult> result)
-        { 
-            Y_VERIFY_DEBUG(info.HullStatus.Status == NKikimrProto::OK); 
-            const TLogoBlobID &id = info.BlobId; 
-            TRope &buffer = info.Buffer; 
-            const TLsnSeg &seg = info.Lsn; 
-            const TIngress &ingress = info.Ingress; 
- 
-#ifdef OPTIMIZE_SYNC 
-            // nothing to do, don't create synclog record 
+        {
+            Y_VERIFY_DEBUG(info.HullStatus.Status == NKikimrProto::OK);
+            const TLogoBlobID &id = info.BlobId;
+            TRope &buffer = info.Buffer;
+            const TLsnSeg &seg = info.Lsn;
+            const TIngress &ingress = info.Ingress;
+
+#ifdef OPTIMIZE_SYNC
+            // nothing to do, don't create synclog record
             std::unique_ptr<NSyncLog::TEvSyncLogPut> syncLogMsg;
-#else 
+#else
             std::unique_ptr<NSyncLog::TEvSyncLogPut> syncLogMsg(
-                new NSyncLog::TEvSyncLogPut(Db->GType, seg.Point(), TLogoBlobID(id, 0), info.Ingress)); 
-#endif 
- 
+                new NSyncLog::TEvSyncLogPut(Db->GType, seg.Point(), TLogoBlobID(id, 0), info.Ingress));
+#endif
+
             // prepare message to recovery log
             TString dataToWrite = TPutRecoveryLogRecOpt::Serialize(Db->GType, id, buffer);
-            LOG_DEBUG_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix 
-                    << evPrefix << ": userDataSize# " << buffer.GetSize() 
-                    << " writtenSize# " << dataToWrite.size() 
-                    << " channel# " << id.Channel() 
-                    << " Marker# BSVS04"); 
+            LOG_DEBUG_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix
+                    << evPrefix << ": userDataSize# " << buffer.GetSize()
+                    << " writtenSize# " << dataToWrite.size()
+                    << " channel# " << id.Channel()
+                    << " Marker# BSVS04");
             UpdatePDiskWriteBytes(dataToWrite.size());
- 
-            bool confirmSyncLogAlso = static_cast<bool>(syncLogMsg); 
-            intptr_t loggedRecId = LoggedRecsVault.Put( 
+
+            bool confirmSyncLogAlso = static_cast<bool>(syncLogMsg);
+            intptr_t loggedRecId = LoggedRecsVault.Put(
                 CreateLoggedRec(seg, confirmSyncLogAlso, id, ingress, std::move(buffer), std::move(result), sender, cookie));
-            void *loggedRecCookie = reinterpret_cast<void *>(loggedRecId); 
-            // create log msg 
+            void *loggedRecCookie = reinterpret_cast<void *>(loggedRecId);
+            // create log msg
             auto logMsg = CreateHullUpdate(HullLogCtx, TLogSignature::SignatureLogoBlobOpt, dataToWrite,
                     seg, loggedRecCookie, std::move(syncLogMsg), nullptr);
-            // send prepared message to recovery log 
-            logMsg->Orbit = std::move(orbit); 
-            return logMsg; 
-        } 
- 
+            // send prepared message to recovery log
+            logMsg->Orbit = std::move(orbit);
+            return logMsg;
+        }
+
         std::unique_ptr<TEvHullWriteHugeBlob> CreateHullWriteHugeBlob(const TActorContext &ctx, NActors::TActorId sender,
-                ui64 cookie, NWilson::TTraceId &traceId, bool ignoreBlock, 
-                NKikimrBlobStorage::EPutHandleClass handleClass, TVPutInfo &info, 
+                ui64 cookie, NWilson::TTraceId &traceId, bool ignoreBlock,
+                NKikimrBlobStorage::EPutHandleClass handleClass, TVPutInfo &info,
                 std::unique_ptr<TEvBlobStorage::TEvVPutResult> res)
-        { 
-            Y_VERIFY_DEBUG(info.HullStatus.Status == NKikimrProto::OK); 
-            WILSON_TRACE_FROM_ACTOR(ctx, *this, &traceId, EvHullWriteHugeBlobSent); 
+        {
+            Y_VERIFY_DEBUG(info.HullStatus.Status == NKikimrProto::OK);
+            WILSON_TRACE_FROM_ACTOR(ctx, *this, &traceId, EvHullWriteHugeBlobSent);
             info.Buffer = TDiskBlob::Create(info.BlobId.BlobSize(), info.BlobId.PartId(), Db->GType.TotalPartCount(),
                 std::move(info.Buffer), *Arena);
             UpdatePDiskWriteBytes(info.Buffer.GetSize());
             return std::make_unique<TEvHullWriteHugeBlob>(sender, cookie, info.BlobId, info.Ingress,
                     std::move(info.Buffer), ignoreBlock, handleClass, std::move(res));
-        } 
- 
+        }
+
         THullCheckStatus ValidateVPut(const TActorContext &ctx, TString evPrefix,
-                TLogoBlobID id, ui64 bufSize, bool ignoreBlock) 
-        { 
+                TLogoBlobID id, ui64 bufSize, bool ignoreBlock)
+        {
             ui64 blobPartSize = 0;
             try {
                 blobPartSize = GInfo->Type.PartSize(id);
@@ -378,91 +378,91 @@ namespace NKikimr {
                         << evPrefix << ": buffer size does not match with part size;"
                         << " buffer size# " << bufSize
                         << " PartSize# " << blobPartSize
-                        << " id# " << id 
-                        << " Marker# BSVS01"); 
+                        << " id# " << id
+                        << " Marker# BSVS01");
                 return {NKikimrProto::ERROR, "buffer size mismatch"};
             }
- 
-            if (bufSize > Config->MaxLogoBlobDataSize) { 
-                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << evPrefix << ": data is too large;" 
-                        << " id# " << id 
-                        << " size# " << bufSize 
-                        << " chunkSize# " << PDiskCtx->Dsk->ChunkSize 
-                        << " Marker# BSVS02"); 
+
+            if (bufSize > Config->MaxLogoBlobDataSize) {
+                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << evPrefix << ": data is too large;"
+                        << " id# " << id
+                        << " size# " << bufSize
+                        << " chunkSize# " << PDiskCtx->Dsk->ChunkSize
+                        << " Marker# BSVS02");
                 return {NKikimrProto::ERROR, "buffer is too large"};
-            } 
- 
+            }
+
             auto status = Hull->CheckLogoBlob(ctx, id, ignoreBlock);
             if (status.Status != NKikimrProto::OK) {
-                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << evPrefix << ": failed to pass the Hull check;" 
-                        << " id# " << id 
-                        << " status# " << status 
-                        << " Marker# BSVS03"); 
-            } 
-            return status; 
-        } 
- 
-        TString GetHugeBlobsForErrorMsg(const TBatchedVec<TVPutInfo> &putsInfo) { 
-            TStringBuilder hugeBlobs; 
-            bool hasHugeBlob = false; 
-            for (auto &item : putsInfo) { 
-                if (item.IsHugeBlob) { 
-                    hugeBlobs << (hasHugeBlob ? " " : "") << "{" 
-                        << "BlobId# " << item.BlobId 
-                        << " BufferSize# " << item.Buffer.GetSize() << "}"; 
-                    hasHugeBlob = true; 
-                } 
-            } 
-            return hugeBlobs; 
-        } 
- 
+                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << evPrefix << ": failed to pass the Hull check;"
+                        << " id# " << id
+                        << " status# " << status
+                        << " Marker# BSVS03");
+            }
+            return status;
+        }
+
+        TString GetHugeBlobsForErrorMsg(const TBatchedVec<TVPutInfo> &putsInfo) {
+            TStringBuilder hugeBlobs;
+            bool hasHugeBlob = false;
+            for (auto &item : putsInfo) {
+                if (item.IsHugeBlob) {
+                    hugeBlobs << (hasHugeBlob ? " " : "") << "{"
+                        << "BlobId# " << item.BlobId
+                        << " BufferSize# " << item.Buffer.GetSize() << "}";
+                    hasHugeBlob = true;
+                }
+            }
+            return hugeBlobs;
+        }
+
         void PrivateHandle(TEvBlobStorage::TEvVMultiPut::TPtr &ev, const TActorContext &ctx) {
-            WILSON_TRACE_FROM_ACTOR(ctx, *this, &ev->TraceId, EvVPutReceived, VDiskId = SelfVDiskId, 
-                    PDiskId = Config->BaseInfo.PDiskId, VDiskSlotId = Config->BaseInfo.VDiskSlotId); 
-            IFaceMonGroup->MultiPutMsgs()++; 
+            WILSON_TRACE_FROM_ACTOR(ctx, *this, &ev->TraceId, EvVPutReceived, VDiskId = SelfVDiskId,
+                    PDiskId = Config->BaseInfo.PDiskId, VDiskSlotId = Config->BaseInfo.VDiskSlotId);
+            IFaceMonGroup->MultiPutMsgs()++;
             IFaceMonGroup->PutTotalBytes() += ev->GetSize();
- 
-            NKikimrBlobStorage::TEvVMultiPut &record = ev->Get()->Record; 
-            TInstant now = TAppData::TimeProvider->Now(); 
- 
-            if (!record.ItemsSize()) { 
-                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVMultiPut: empty multiput;" 
-                    << " event# " << ev->Get()->ToString() 
-                    << " sender actorId# " << ev->Sender 
-                    << " Marker# BSVS05"); 
+
+            NKikimrBlobStorage::TEvVMultiPut &record = ev->Get()->Record;
+            TInstant now = TAppData::TimeProvider->Now();
+
+            if (!record.ItemsSize()) {
+                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVMultiPut: empty multiput;"
+                    << " event# " << ev->Get()->ToString()
+                    << " sender actorId# " << ev->Sender
+                    << " Marker# BSVS05");
                 ReplyError(NKikimrProto::ERROR, "empty multiput", ev, ctx, now);
-                return; 
-            } 
- 
-            TLogoBlobID firstBlobId = LogoBlobIDFromLogoBlobID(record.GetItems(0).GetBlobID()); 
-            LWTRACK(VDiskSkeletonVMultiPutRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId, 
-                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), 
-                    firstBlobId.TabletID(), ev->Get()->GetSumBlobSize()); 
- 
-            if (!OutOfSpaceLogic->Allow(ctx, ev)) { 
+                return;
+            }
+
+            TLogoBlobID firstBlobId = LogoBlobIDFromLogoBlobID(record.GetItems(0).GetBlobID());
+            LWTRACK(VDiskSkeletonVMultiPutRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId,
+                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk),
+                    firstBlobId.TabletID(), ev->Get()->GetSumBlobSize());
+
+            if (!OutOfSpaceLogic->Allow(ctx, ev)) {
                 ReplyError(NKikimrProto::OUT_OF_SPACE, "out of space", ev, ctx, now);
-                return; 
-            } 
- 
-            if (!SelfVDiskId.SameDisk(record.GetVDiskID())) { 
-                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVMultiPut: race;" 
-                        << " Marker# BSVS06"); 
+                return;
+            }
+
+            if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
+                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVMultiPut: race;"
+                        << " Marker# BSVS06");
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, now);
-                return; 
-            } 
- 
-            bool hasPostponed = false; 
-            bool hasHugeBlob = false; 
-            bool ignoreBlock = record.GetIgnoreBlock(); 
- 
-            TBatchedVec<TVPutInfo> putsInfo; 
-            ui64 lsnCount = 0; 
-            for (ui64 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) { 
-                auto &item = record.GetItems(itemIdx); 
-                TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
-                putsInfo.emplace_back(blobId, ev->Get()->GetItemBuffer(itemIdx)); 
-                TVPutInfo &info = putsInfo.back(); 
- 
+                return;
+            }
+
+            bool hasPostponed = false;
+            bool hasHugeBlob = false;
+            bool ignoreBlock = record.GetIgnoreBlock();
+
+            TBatchedVec<TVPutInfo> putsInfo;
+            ui64 lsnCount = 0;
+            for (ui64 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) {
+                auto &item = record.GetItems(itemIdx);
+                TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+                putsInfo.emplace_back(blobId, ev->Get()->GetItemBuffer(itemIdx));
+                TVPutInfo &info = putsInfo.back();
+
                 try {
                     info.IsHugeBlob = HugeBlobCtx->IsHugeBlob(VCtx->Top->GType, blobId.FullID());
                 } catch (yexception ex) {
@@ -474,95 +474,95 @@ namespace NKikimr {
                     info.HullStatus = ValidateVPut(ctx, "TEvVMultiPut", blobId, info.Buffer.GetSize(), ignoreBlock);
                 }
 
-                if (info.HullStatus.Status == NKikimrProto::OK) { 
+                if (info.HullStatus.Status == NKikimrProto::OK) {
                     auto ingressOpt = TIngress::CreateIngressWithLocal(VCtx->Top.get(), VCtx->ShortSelfVDisk, blobId);
-                    if (!ingressOpt) { 
-                        LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVMultiPut: ingress mismatch;" 
-                                << " id# " << blobId 
-                                << " Marker# BSVS07"); 
-                        info.HullStatus = {NKikimrProto::ERROR, 0, false}; 
-                    } else { 
-                        info.Ingress = *ingressOpt; 
-                    } 
-                } 
-                hasPostponed |= info.HullStatus.Postponed; 
- 
-                if (info.IsHugeBlob) { 
-                    hasHugeBlob = true; 
-                } else { 
-                    lsnCount += (info.HullStatus.Status == NKikimrProto::OK); 
-                } 
-            } 
- 
-            if (hasHugeBlob) { 
-                LOG_CRIT_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix 
-                        << "TEvVMultiPut: TEvVMultiPut has huge blobs# " << GetHugeBlobsForErrorMsg(putsInfo) 
-                        << " Marker# BSVS08"); 
-            } 
- 
-            TBatchedVec<NKikimrProto::EReplyStatus> statuses; 
-            for (auto &info : putsInfo) { 
-                if (info.HullStatus.Postponed) { 
-                    statuses.push_back(NKikimrProto::OK); 
-                } else { 
-                    statuses.push_back(info.HullStatus.Status); 
-                } 
-            } 
-            if (!hasHugeBlob && !lsnCount && !hasPostponed) { 
-                LOG_INFO_S(ctx, BS_VDISK_PUT, Db->VCtx->VDiskLogPrefix << "TEvVMultiPut: all items have errors" 
-                        << " Marker# BSVS09"); 
+                    if (!ingressOpt) {
+                        LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVMultiPut: ingress mismatch;"
+                                << " id# " << blobId
+                                << " Marker# BSVS07");
+                        info.HullStatus = {NKikimrProto::ERROR, 0, false};
+                    } else {
+                        info.Ingress = *ingressOpt;
+                    }
+                }
+                hasPostponed |= info.HullStatus.Postponed;
+
+                if (info.IsHugeBlob) {
+                    hasHugeBlob = true;
+                } else {
+                    lsnCount += (info.HullStatus.Status == NKikimrProto::OK);
+                }
+            }
+
+            if (hasHugeBlob) {
+                LOG_CRIT_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix
+                        << "TEvVMultiPut: TEvVMultiPut has huge blobs# " << GetHugeBlobsForErrorMsg(putsInfo)
+                        << " Marker# BSVS08");
+            }
+
+            TBatchedVec<NKikimrProto::EReplyStatus> statuses;
+            for (auto &info : putsInfo) {
+                if (info.HullStatus.Postponed) {
+                    statuses.push_back(NKikimrProto::OK);
+                } else {
+                    statuses.push_back(info.HullStatus.Status);
+                }
+            }
+            if (!hasHugeBlob && !lsnCount && !hasPostponed) {
+                LOG_INFO_S(ctx, BS_VDISK_PUT, Db->VCtx->VDiskLogPrefix << "TEvVMultiPut: all items have errors"
+                        << " Marker# BSVS09");
                 ReplyError(NKikimrProto::OK, TString(), ev, ctx, now, statuses);
-                return; 
-            } 
- 
-            TOutOfSpaceStatus oosStatus = VCtx->GetOutOfSpaceState().GetGlobalStatusFlags(); 
-            NLWTrace::TOrbit orbit = std::move(ev->Get()->Orbit); 
-            NKikimrBlobStorage::EPutHandleClass handleClass = ev->Get()->Record.GetHandleClass(); 
-            TVDiskID vdisk = VDiskIDFromVDiskID(ev->Get()->Record.GetVDiskID()); 
- 
+                return;
+            }
+
+            TOutOfSpaceStatus oosStatus = VCtx->GetOutOfSpaceState().GetGlobalStatusFlags();
+            NLWTrace::TOrbit orbit = std::move(ev->Get()->Orbit);
+            NKikimrBlobStorage::EPutHandleClass handleClass = ev->Get()->Record.GetHandleClass();
+            TVDiskID vdisk = VDiskIDFromVDiskID(ev->Get()->Record.GetVDiskID());
+
             std::unique_ptr<NPDisk::TEvMultiLog> evLogs = std::make_unique<NPDisk::TEvMultiLog>();
-            ui64 cookie = ev->Cookie; 
- 
-            IActor* vMultiPutActor = CreateSkeletonVMultiPutActor(SelfId(), statuses, oosStatus, ev, 
-                    SkeletonFrontIDPtr, IFaceMonGroup->MultiPutResMsgsPtr(), Db->GetVDiskIncarnationGuid()); 
+            ui64 cookie = ev->Cookie;
+
+            IActor* vMultiPutActor = CreateSkeletonVMultiPutActor(SelfId(), statuses, oosStatus, ev,
+                    SkeletonFrontIDPtr, IFaceMonGroup->MultiPutResMsgsPtr(), Db->GetVDiskIncarnationGuid());
             NActors::TActorId vMultiPutActorId = ctx.Register(vMultiPutActor);
- 
-            TLsnSeg lsnBatch; 
-            if (lsnCount) { 
-#ifdef OPTIMIZE_SYNC 
-                lsnBatch = Db->LsnMngr->AllocDiscreteLsnBatchForHull(lsnCount); 
-#else 
-                lsnBatch = Db->LsnMngr->AllocDiscreteLsnBatchForHullAndSyncLog(lsnCount); 
-#endif 
-            } 
- 
-            for (ui64 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) { 
-                TVPutInfo &info = putsInfo[itemIdx]; 
-                NKikimrProto::EReplyStatus status = info.HullStatus.Status; 
+
+            TLsnSeg lsnBatch;
+            if (lsnCount) {
+#ifdef OPTIMIZE_SYNC
+                lsnBatch = Db->LsnMngr->AllocDiscreteLsnBatchForHull(lsnCount);
+#else
+                lsnBatch = Db->LsnMngr->AllocDiscreteLsnBatchForHullAndSyncLog(lsnCount);
+#endif
+            }
+
+            for (ui64 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) {
+                TVPutInfo &info = putsInfo[itemIdx];
+                NKikimrProto::EReplyStatus status = info.HullStatus.Status;
                 const TString& errorReason = info.HullStatus.ErrorReason;
- 
-                if (info.HullStatus.Postponed) { 
+
+                if (info.HullStatus.Postponed) {
                     auto result = std::make_unique<TEvVMultiPutItemResult>(info.BlobId, itemIdx, status, errorReason);
                     Hull->PostponeReplyUntilCommitted(result.release(), vMultiPutActorId, itemIdx, info.HullStatus.Lsn);
-                    continue; 
-                } 
- 
-                if (status != NKikimrProto::OK) { 
-                    continue; 
-                } 
- 
-                if (info.IsHugeBlob) { 
-                    // pass the work to huge blob writer 
-                    NWilson::TTraceId traceId; 
-                    TInstant deadline = (record.HasMsgQoS() && record.GetMsgQoS().HasDeadlineSeconds()) ? 
-                            TInstant::Seconds(record.GetMsgQoS().GetDeadlineSeconds()) : 
-                            TInstant::Max(); 
-                    TEvBlobStorage::TEvVPut vPut(info.BlobId, TRope(), vdisk, ignoreBlock, 
-                            &itemIdx, deadline, handleClass); 
+                    continue;
+                }
+
+                if (status != NKikimrProto::OK) {
+                    continue;
+                }
+
+                if (info.IsHugeBlob) {
+                    // pass the work to huge blob writer
+                    NWilson::TTraceId traceId;
+                    TInstant deadline = (record.HasMsgQoS() && record.GetMsgQoS().HasDeadlineSeconds()) ?
+                            TInstant::Seconds(record.GetMsgQoS().GetDeadlineSeconds()) :
+                            TInstant::Max();
+                    TEvBlobStorage::TEvVPut vPut(info.BlobId, TRope(), vdisk, ignoreBlock,
+                            &itemIdx, deadline, handleClass);
                     std::unique_ptr<TEvBlobStorage::TEvVPutResult> result(
-                        new TEvBlobStorage::TEvVPutResult(status, info.BlobId, SelfVDiskId, &itemIdx, oosStatus, now, 
-                            vPut.GetCachedByteSize(), &vPut.Record, SkeletonFrontIDPtr, nullptr, 
-                            VCtx->Histograms.GetHistogram(handleClass), info.Buffer.GetSize(), 
+                        new TEvBlobStorage::TEvVPutResult(status, info.BlobId, SelfVDiskId, &itemIdx, oosStatus, now,
+                            vPut.GetCachedByteSize(), &vPut.Record, SkeletonFrontIDPtr, nullptr,
+                            VCtx->Histograms.GetHistogram(handleClass), info.Buffer.GetSize(),
                             NWilson::TTraceId(), Db->GetVDiskIncarnationGuid(), errorReason));
                     if (info.Buffer) {
                         auto hugeWrite = CreateHullWriteHugeBlob(ctx, vMultiPutActorId, cookie, traceId, ignoreBlock,
@@ -572,25 +572,25 @@ namespace NKikimr {
                         ctx.Send(SelfId(), new TEvHullLogHugeBlob(0, info.BlobId, info.Ingress, TDiskPart(),
                             ignoreBlock, vMultiPutActorId, cookie, std::move(result)));
                     }
-                } else { 
-                    Y_VERIFY(lsnBatch.First <= lsnBatch.Last); 
- 
-                    info.Lsn = TLsnSeg(lsnBatch.First, lsnBatch.First); 
-                    lsnBatch.First++; 
+                } else {
+                    Y_VERIFY(lsnBatch.First <= lsnBatch.Last);
+
+                    info.Lsn = TLsnSeg(lsnBatch.First, lsnBatch.First);
+                    lsnBatch.First++;
                     std::unique_ptr<TEvVMultiPutItemResult> evItemResult(
                             new TEvVMultiPutItemResult(info.BlobId, itemIdx, status, errorReason));
                     auto logMsg = CreatePutLogEvent(ctx, "TEvVMultiPut", vMultiPutActorId, cookie, std::move(orbit),
                         info, std::move(evItemResult));
                     evLogs->AddLog(THolder<NPDisk::TEvLog>(logMsg.release()));
-                } 
-            } 
- 
-            // Manage PDisk scheduler weights 
-            OverloadHandler->ActualizeWeights(ctx, Mask(EHullDbType::LogoBlobs)); 
- 
-            if (lsnCount) { 
+                }
+            }
+
+            // Manage PDisk scheduler weights
+            OverloadHandler->ActualizeWeights(ctx, Mask(EHullDbType::LogoBlobs));
+
+            if (lsnCount) {
                 ctx.Send(Db->LoggerID, evLogs.release());
-            } 
+            }
         }
 
         ////////////////////////////////////////////////////////////////////////
@@ -623,11 +623,11 @@ namespace NKikimr {
             IFaceMonGroup->PutTotalBytes() += ev->GetSize();
             TInstant now = TAppData::TimeProvider->Now();
             NKikimrBlobStorage::TEvVPut &record = ev->Get()->Record;
-            const TLogoBlobID id = LogoBlobIDFromLogoBlobID(record.GetBlobID()); 
+            const TLogoBlobID id = LogoBlobIDFromLogoBlobID(record.GetBlobID());
             LWTRACK(VDiskSkeletonVPutRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId,
-                   VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), id.TabletID(), id.BlobSize()); 
-            TVPutInfo info(id, ev->Get()->GetBuffer()); 
-            const ui64 bufSize = info.Buffer.GetSize(); 
+                   VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), id.TabletID(), id.BlobSize());
+            TVPutInfo info(id, ev->Get()->GetBuffer());
+            const ui64 bufSize = info.Buffer.GetSize();
 
             try {
                 info.IsHugeBlob = HugeBlobCtx->IsHugeBlob(VCtx->Top->GType, id.FullID());
@@ -644,38 +644,38 @@ namespace NKikimr {
                 ReplyError({NKikimrProto::OUT_OF_SPACE, "out of space", 0, false}, ev, ctx, now);
                 return;
             }
- 
-            if (!SelfVDiskId.SameDisk(record.GetVDiskID())) { 
-                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVPut: race; id# " << id 
-                        << " Marker# BSVS10"); 
+
+            if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
+                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVPut: race; id# " << id
+                        << " Marker# BSVS10");
                 ReplyError({NKikimrProto::RACE, "group generation mismatch", 0, false}, ev, ctx, now);
                 return;
             }
- 
-            info.HullStatus = ValidateVPut(ctx, "TEvVPut", id, bufSize, ignoreBlock); 
-            if (info.HullStatus.Status != NKikimrProto::OK) { 
-                ReplyError(info.HullStatus, ev, ctx, now); 
+
+            info.HullStatus = ValidateVPut(ctx, "TEvVPut", id, bufSize, ignoreBlock);
+            if (info.HullStatus.Status != NKikimrProto::OK) {
+                ReplyError(info.HullStatus, ev, ctx, now);
                 return;
             }
- 
+
             auto ingressOpt = TIngress::CreateIngressWithLocal(VCtx->Top.get(), VCtx->ShortSelfVDisk, id);
-            if (!ingressOpt) { 
-                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVPut: ingress mismatch; id# " << id 
-                        << " Marker# BSVS11"); 
+            if (!ingressOpt) {
+                LOG_ERROR_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix << "TEvVPut: ingress mismatch; id# " << id
+                        << " Marker# BSVS11");
                 ReplyError({NKikimrProto::ERROR, "ingress mismatch", 0, false}, ev, ctx, now);
                 return;
             }
-            info.Ingress = *ingressOpt; 
+            info.Ingress = *ingressOpt;
 
-            LOG_DEBUG_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix <<"TEvVPut: " << " result# " << ev->Get()->ToString() 
-                    << " Marker# BSVS12"); 
+            LOG_DEBUG_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix <<"TEvVPut: " << " result# " << ev->Get()->ToString()
+                    << " Marker# BSVS12");
 
-            if (!info.IsHugeBlob) { 
+            if (!info.IsHugeBlob) {
 
 #ifdef OPTIMIZE_SYNC
-                info.Lsn = Db->LsnMngr->AllocLsnForHull(); 
+                info.Lsn = Db->LsnMngr->AllocLsnForHull();
 #else
-                info.Lsn = Db->LsnMngr->AllocLsnForHullAndSyncLog(); 
+                info.Lsn = Db->LsnMngr->AllocLsnForHullAndSyncLog();
 #endif
             }
 
@@ -692,8 +692,8 @@ namespace NKikimr {
                 ctx.Send(Db->LoggerID, logMsg.release());
             } else if (info.Buffer) {
                 // pass the work to huge blob writer
-                NKikimrBlobStorage::EPutHandleClass handleClass = record.GetHandleClass(); 
-                auto hugeWrite = CreateHullWriteHugeBlob(ctx, ev->Sender, ev->Cookie, ev->TraceId, ignoreBlock, 
+                NKikimrBlobStorage::EPutHandleClass handleClass = record.GetHandleClass();
+                auto hugeWrite = CreateHullWriteHugeBlob(ctx, ev->Sender, ev->Cookie, ev->TraceId, ignoreBlock,
                         handleClass, info, std::move(result));
                 ctx.Send(Db->HugeKeeperID, hugeWrite.release());
             } else {
@@ -713,8 +713,8 @@ namespace NKikimr {
             if (status.Status != NKikimrProto::OK) {
                 msg->Result->UpdateStatus(status.Status); // modify status in result
                 LOG_DEBUG_S(ctx, BS_VDISK_PUT, VCtx->VDiskLogPrefix
-                        << "TEvVPut: realtime# false result# " << msg->Result->ToString() 
-                        << " Marker# BSVS13"); 
+                        << "TEvVPut: realtime# false result# " << msg->Result->ToString()
+                        << " Marker# BSVS13");
                 if (msg->HugeBlob != TDiskPart()) {
                     ctx.Send(Db->HugeKeeperID, new TEvHullHugeBlobLogged(msg->WriteId, msg->HugeBlob, 0, false));
                 }
@@ -832,8 +832,8 @@ namespace NKikimr {
             // FIXME: check PartId() is not null and is not too large
 
             LOG_DEBUG_S(ctx, BS_VDISK_GET, VCtx->VDiskLogPrefix
-                    << "TEvVGet: " << TEvBlobStorage::TEvVGet::ToString(record) 
-                    << " Marker# BSVS14"); 
+                    << "TEvVGet: " << TEvBlobStorage::TEvVGet::ToString(record)
+                    << " Marker# BSVS14");
 
             if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, now);
@@ -908,8 +908,8 @@ namespace NKikimr {
             }
 
             LOG_DEBUG_S(ctx, BS_VDISK_BLOCK, VCtx->VDiskLogPrefix
-                    << "TEvVBlock: tabletId# " << tabletId << " gen# " << gen 
-                    << " Marker# BSVS14"); 
+                    << "TEvVBlock: tabletId# " << tabletId << " gen# " << gen
+                    << " Marker# BSVS14");
 
             TLsnSeg seg;
             ui32 actGen = 0;
@@ -925,8 +925,8 @@ namespace NKikimr {
                 if (postponed) {
                     Hull->PostponeReplyUntilCommitted(result.release(), ev->Sender, ev->Cookie, postponeUntilLsn);
                 } else {
-                    LOG_DEBUG_S(ctx, BS_VDISK_BLOCK, VCtx->VDiskLogPrefix << "TEvVBlockResult: " << result->ToString() 
-                            << " Marker# BSVS15"); 
+                    LOG_DEBUG_S(ctx, BS_VDISK_BLOCK, VCtx->VDiskLogPrefix << "TEvVBlockResult: " << result->ToString()
+                            << " Marker# BSVS15");
                     SendReply(ctx, std::move(result), ev, BS_VDISK_BLOCK);
                 }
 
@@ -960,8 +960,8 @@ namespace NKikimr {
             const ui64 tabletId = record.GetTabletId();
 
             LOG_DEBUG_S(ctx, BS_VDISK_BLOCK, VCtx->VDiskLogPrefix
-                    << "TEvVGetBlock: tabletId# " << tabletId 
-                    << " Marker# BSVS16"); 
+                    << "TEvVGetBlock: tabletId# " << tabletId
+                    << " Marker# BSVS16");
 
             std::unique_ptr<TEvBlobStorage::TEvVGetBlockResult> result;
             if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
@@ -983,8 +983,8 @@ namespace NKikimr {
             }
 
             LOG_DEBUG_S(ctx, BS_VDISK_BLOCK, VCtx->VDiskLogPrefix
-                    << "TEvVGetBlockResult: " << result->ToString() 
-                    << " Marker# BSVS17"); 
+                    << "TEvVGetBlockResult: " << result->ToString()
+                    << " Marker# BSVS17");
             SendVDiskResponse(ctx, ev->Sender, result.release(), *this, ev->Cookie);
         }
 
@@ -1019,8 +1019,8 @@ namespace NKikimr {
             }
 
             LOG_DEBUG_S(ctx, BS_VDISK_GC, VCtx->VDiskLogPrefix
-                    << "TEvVCollectGarbage: " << ev->Get()->ToString() 
-                    << " Marker# BSVS18"); 
+                    << "TEvVCollectGarbage: " << ev->Get()->ToString()
+                    << " Marker# BSVS18");
 
             TLsnSeg seg;
             TBarrierIngress ingress(HullCtx->IngressCache.Get());
@@ -1067,8 +1067,8 @@ namespace NKikimr {
             TInstant now = TAppData::TimeProvider->Now();
             NKikimrBlobStorage::TEvVGetBarrier &record = ev->Get()->Record;
             LOG_DEBUG_S(ctx, BS_VDISK_GC, VCtx->VDiskLogPrefix
-                    << "TEvVGetBarrier: " << ev->Get()->ToString() 
-                    << " Marker# BSVS19"); 
+                    << "TEvVGetBarrier: " << ev->Get()->ToString()
+                    << " Marker# BSVS19");
 
             if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, now);
@@ -1096,8 +1096,8 @@ namespace NKikimr {
         void Handle(TEvBlobStorage::TEvVStatus::TPtr &ev, const TActorContext &ctx) {
             IFaceMonGroup->StatusMsgs()++;
             TInstant now = TAppData::TimeProvider->Now();
-            LOG_DEBUG_S(ctx, BS_VDISK_OTHER, VCtx->VDiskLogPrefix << "TEvVStatus" 
-                    << " Marker# BSVS20"); 
+            LOG_DEBUG_S(ctx, BS_VDISK_OTHER, VCtx->VDiskLogPrefix << "TEvVStatus"
+                    << " Marker# BSVS20");
             auto aid = ctx.Register(CreateStatusRequestHandler(VCtx, Db->SkeletonID, Db->SyncerID, Db->SyncLogID,
                 IFaceMonGroup, SelfVDiskId, Db->GetVDiskIncarnationGuid(), GInfo, ev, ctx.SelfID, now, ReplDone));
             ActiveActors.Insert(aid);
@@ -1129,8 +1129,8 @@ namespace NKikimr {
             IFaceMonGroup->DbStatMsgs()++;
             TInstant now = TAppData::TimeProvider->Now();
             const NKikimrBlobStorage::TEvVDbStat &record = ev->Get()->Record;
-            LOG_DEBUG_S(ctx, BS_VDISK_OTHER, VCtx->VDiskLogPrefix << "TEvVDbStat" 
-                    << " Marker# BSVS21"); 
+            LOG_DEBUG_S(ctx, BS_VDISK_OTHER, VCtx->VDiskLogPrefix << "TEvVDbStat"
+                    << " Marker# BSVS21");
 
             if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, now);
@@ -1187,8 +1187,8 @@ namespace NKikimr {
         void Handle(TEvBlobStorage::TEvVCompact::TPtr &ev, const TActorContext &ctx) {
             TInstant now = TAppData::TimeProvider->Now();
             const NKikimrBlobStorage::TEvVCompact &record = ev->Get()->Record;
-            LOG_DEBUG_S(ctx, BS_VDISK_OTHER, VCtx->VDiskLogPrefix << "TEvVCompact" 
-                    << " Marker# BSVS22"); 
+            LOG_DEBUG_S(ctx, BS_VDISK_OTHER, VCtx->VDiskLogPrefix << "TEvVCompact"
+                    << " Marker# BSVS22");
 
             if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, now);
@@ -1254,8 +1254,8 @@ namespace NKikimr {
         void Handle(TEvBlobStorage::TEvVBaldSyncLog::TPtr &ev, const TActorContext &ctx) {
             TInstant now = TAppData::TimeProvider->Now();
             const NKikimrBlobStorage::TEvVBaldSyncLog &record = ev->Get()->Record;
-            LOG_DEBUG_S(ctx, BS_VDISK_OTHER, VCtx->VDiskLogPrefix << "TEvVBaldSyncLog" 
-                    << " Marker# BSVS23"); 
+            LOG_DEBUG_S(ctx, BS_VDISK_OTHER, VCtx->VDiskLogPrefix << "TEvVBaldSyncLog"
+                    << " Marker# BSVS23");
 
             if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, now);
@@ -1303,17 +1303,17 @@ namespace NKikimr {
             if (!SelfVDiskId.SameGroupAndGeneration(record.GetSourceVDiskID())) {
                 auto protoVDisk = VDiskIDFromVDiskID(record.GetSourceVDiskID());
                 LOG_WARN_S(ctx, NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix
-                        << "TSkeleton::Handle(TEvBlobStorage::TEvVSyncGuid): Source:" 
-                        << " Self# " << SelfVDiskId << " Source# " << protoVDisk 
-                        << " Marker# BSVS24"); 
+                        << "TSkeleton::Handle(TEvBlobStorage::TEvVSyncGuid): Source:"
+                        << " Self# " << SelfVDiskId << " Source# " << protoVDisk
+                        << " Marker# BSVS24");
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, now);
             }
             if (!SelfVDiskId.SameDisk(record.GetTargetVDiskID())) {
                 auto protoVDisk = VDiskIDFromVDiskID(record.GetTargetVDiskID());
                 LOG_WARN_S(ctx, NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix
-                        << "TSkeleton::Handle(TEvBlobStorage::TEvVSyncGuid): Target:" 
-                        << " Self# " << SelfVDiskId << " Source# " << protoVDisk 
-                        << " Marker# BSVS25"); 
+                        << "TSkeleton::Handle(TEvBlobStorage::TEvVSyncGuid): Target:"
+                        << " Self# " << SelfVDiskId << " Source# " << protoVDisk
+                        << " Marker# BSVS25");
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, now);
             }
 
@@ -1499,8 +1499,8 @@ namespace NKikimr {
 
             const TEvRecoveredHugeBlob *msg = ev->Get();
             const TLogoBlobID& id = msg->Id;
-            LOG_DEBUG_S(ctx, BS_REPL, VCtx->VDiskLogPrefix << "TSkeleton::Handle(TEvRecoveredHugeBlob): id# " << id 
-                    << " Marker# BSVS26"); 
+            LOG_DEBUG_S(ctx, BS_REPL, VCtx->VDiskLogPrefix << "TSkeleton::Handle(TEvRecoveredHugeBlob): id# " << id
+                    << " Marker# BSVS26");
 
             TRope buf = std::move(msg->Data);
             const ui64 bufSize = buf.GetSize();
@@ -1528,8 +1528,8 @@ namespace NKikimr {
 
             for (const TLogoBlobID& logoBlobId : msg->Phantoms) {
                 LOG_ERROR_S(ctx, NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix
-                        << "adding DoNotKeep to phantom LogoBlobId# " << logoBlobId 
-                        << " Marker# BSVS27"); 
+                        << "adding DoNotKeep to phantom LogoBlobId# " << logoBlobId
+                        << " Marker# BSVS27");
             }
 
             TLsnSeg seg = Hull->AllocateLsnForPhantoms(msg->Phantoms);
@@ -1583,8 +1583,8 @@ namespace NKikimr {
         void SkeletonIsUpAndRunning(const TActorContext &ctx, bool runRepl = false) {
             Become(&TThis::StateNormal);
             VDiskMonGroup.VDiskState(NKikimrWhiteboard::EVDiskState::OK);
-            LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON IS UP AND RUNNING" 
-                    << " Marker# BSVS28"); 
+            LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON IS UP AND RUNNING"
+                    << " Marker# BSVS28");
             // notify SkeletonFront
             auto msg = std::make_unique<TEvFrontRecoveryStatus>(TEvFrontRecoveryStatus::SyncGuidRecoveryDone,
                                                           NKikimrProto::OK,
@@ -1655,8 +1655,8 @@ namespace NKikimr {
                 ctx.Send(*SkeletonFrontIDPtr, new TEv(TEv::UpdateIncarnationGuid, Db->GetVDiskIncarnationGuid()));
 
                 // we got a recovered local DB here
-                LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON LOCAL RECOVERY SUCCEEDED" 
-                        << " Marker# BSVS29"); 
+                LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON LOCAL RECOVERY SUCCEEDED"
+                        << " Marker# BSVS29");
 
                 // run logger forwarder
                 auto logWriter = CreateRecoveryLogWriter(PDiskCtx->PDiskId, Db->SkeletonID,
@@ -1731,12 +1731,12 @@ namespace NKikimr {
                 QueryCtx = std::make_shared<TQueryCtx>(HullCtx, PDiskCtx, SelfId());
 
                 // create overload handler
-                auto vMovedPatch = [this] (const TActorContext &ctx, TEvBlobStorage::TEvVMovedPatch::TPtr ev) { 
-                    this->PrivateHandle(ev, ctx); 
-                }; 
-                auto vPatchStart = [this] (const TActorContext &ctx, TEvBlobStorage::TEvVPatchStart::TPtr ev) { 
-                    this->PrivateHandle(ev, ctx); 
-                }; 
+                auto vMovedPatch = [this] (const TActorContext &ctx, TEvBlobStorage::TEvVMovedPatch::TPtr ev) {
+                    this->PrivateHandle(ev, ctx);
+                };
+                auto vPatchStart = [this] (const TActorContext &ctx, TEvBlobStorage::TEvVPatchStart::TPtr ev) {
+                    this->PrivateHandle(ev, ctx);
+                };
                 auto vput = [this] (const TActorContext &ctx, TEvBlobStorage::TEvVPut::TPtr ev) {
                     this->PrivateHandle(ev, ctx);
                 };
@@ -1751,8 +1751,8 @@ namespace NKikimr {
                 };
                 NMonGroup::TSkeletonOverloadGroup overloadMonGroup(VCtx->VDiskCounters, "subsystem", "emergency");
                 OverloadHandler = std::make_unique<TOverloadHandler>(VCtx, PDiskCtx, Hull,
-                    std::move(overloadMonGroup), std::move(vMovedPatch), std::move(vPatchStart), std::move(vput), 
-                    std::move(vMultiPutHandler), std::move(loc), std::move(aoput)); 
+                    std::move(overloadMonGroup), std::move(vMovedPatch), std::move(vPatchStart), std::move(vput),
+                    std::move(vMultiPutHandler), std::move(loc), std::move(aoput));
                 ScheduleWakeupEmergencyPutQueue(ctx);
 
                 // actualize weights before we start
@@ -1816,8 +1816,8 @@ namespace NKikimr {
                 // Deliver CutLog that we may receive if not initialized
                 DeliverDelayedCutLogIfAny(ctx);
             } else {
-                LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON LOCAL RECOVERY FAILED" 
-                        << " Marker# BSVS30"); 
+                LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON LOCAL RECOVERY FAILED"
+                        << " Marker# BSVS30");
                 auto phase = TEvFrontRecoveryStatus::LocalRecoveryDone;
                 auto state = NKikimrWhiteboard::EVDiskState::LocalRecoveryError;
                 SkeletonErrorState(ctx, phase, state);
@@ -1826,8 +1826,8 @@ namespace NKikimr {
 
         void Handle(TEvSyncGuidRecoveryDone::TPtr &ev, const TActorContext &ctx) {
             if (ev->Get()->Status == NKikimrProto::OK) {
-                LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON SYNC GUID RECOVERY SUCCEEDED" 
-                        << " Marker# BSVS31"); 
+                LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON SYNC GUID RECOVERY SUCCEEDED"
+                        << " Marker# BSVS31");
                 DbBirthLsn = ev->Get()->DbBirthLsn;
                 SkeletonIsUpAndRunning(ctx, Config->RunRepl);
                 if (Config->RunRepl) {
@@ -1841,8 +1841,8 @@ namespace NKikimr {
                     }
                 }
             } else {
-                LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON SYNC GUID RECOVERY FAILED" 
-                        << " Marker# BSVS32"); 
+                LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON SYNC GUID RECOVERY FAILED"
+                        << " Marker# BSVS32");
                 auto phase = TEvFrontRecoveryStatus::SyncGuidRecoveryDone;
                 auto state = NKikimrWhiteboard::EVDiskState::SyncGuidRecoveryError;
                 SkeletonErrorState(ctx, phase, state);
@@ -2044,14 +2044,14 @@ namespace NKikimr {
                 Y_VERIFY(!CutLogDelayedMsg);
                 LOG_DEBUG_S(ctx, BS_LOGCUTTER, VCtx->VDiskLogPrefix
                         << "Handle " << msg->ToString()
-                        << " actorid# " << ctx.SelfID.ToString() 
-                        << " Marker# BSVS33"); 
+                        << " actorid# " << ctx.SelfID.ToString()
+                        << " Marker# BSVS33");
                 SpreadCutLog(std::move(msg), ctx);
             } else {
                 LOG_DEBUG_S(ctx, BS_LOGCUTTER, VCtx->VDiskLogPrefix
                         << "Handle " << msg->ToString()
-                        << " DELAYED actorid# " << ctx.SelfID.ToString() 
-                        << " Marker# BSVS34"); 
+                        << " DELAYED actorid# " << ctx.SelfID.ToString()
+                        << " Marker# BSVS34");
                 CutLogDelayedMsg = std::move(msg);
             }
         }
@@ -2091,8 +2091,8 @@ namespace NKikimr {
             LOG_DEBUG_S(ctx, BS_LOGCUTTER, VCtx->VDiskLogPrefix
                     << "SpreadCutLog: Handle " << msg->ToString()
                     << " DELAYED; counter# " << counter
-                    << " actorid# " << ctx.SelfID.ToString() 
-                    << " Marker# BSVS35"); 
+                    << " actorid# " << ctx.SelfID.ToString()
+                    << " Marker# BSVS35");
         }
 
         // NOTE: We can get NPDisk::TEvCutLog when local recovery is not finished.
@@ -2101,8 +2101,8 @@ namespace NKikimr {
         void DeliverDelayedCutLogIfAny(const TActorContext &ctx) {
             LOG_DEBUG_S(ctx, BS_LOGCUTTER, VCtx->VDiskLogPrefix
                     << "DeliverDelayedCutLogIfAny: hasMsg# " << (CutLogDelayedMsg ? "true" : "false")
-                    << " actorid# " << ctx.SelfID.ToString() 
-                    << " Marker# BSVS36"); 
+                    << " actorid# " << ctx.SelfID.ToString()
+                    << " Marker# BSVS36");
 
             LocalDbInitialized = true;
             if (CutLogDelayedMsg) {
@@ -2122,9 +2122,9 @@ namespace NKikimr {
             GInfo = msg->NewInfo;
             SelfVDiskId = msg->NewVDiskId;
 
-            // clear VPatchCtx 
-            VPatchCtx = nullptr; 
- 
+            // clear VPatchCtx
+            VPatchCtx = nullptr;
+
             // send command to Synclog
             ctx.Send(Db->SyncLogID, ev->Get()->Clone());
             // send command to Syncer
@@ -2162,8 +2162,8 @@ namespace NKikimr {
         friend class TActorBootstrapped<TSkeleton>;
 
         void Bootstrap(const TActorContext &ctx) {
-            LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON START" 
-                    << " Marker# BSVS37"); 
+            LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "SKELETON START"
+                    << " Marker# BSVS37");
             Become(&TThis::StateLocalRecovery);
             Db->SkeletonID.Set(ctx.SelfID);
             // generation independent self VDisk Id
@@ -2272,7 +2272,7 @@ namespace NKikimr {
             FFunc(TEvBlobStorage::EvScrubAwait, ForwardToScrubActor)
             FFunc(TEvBlobStorage::EvRecoverBlob, ForwardToScrubActor)
             FFunc(TEvBlobStorage::EvNonrestoredCorruptedBlobNotify, ForwardToScrubActor)
-            HFunc(TEvProxyQueueState, Handle) 
+            HFunc(TEvProxyQueueState, Handle)
         )
 
         STRICT_STFUNC(StateSyncGuidRecovery,
@@ -2320,15 +2320,15 @@ namespace NKikimr {
             HFunc(TEvReportScrubStatus, Handle)
             HFunc(TEvRestoreCorruptedBlob, Handle)
             HFunc(TEvBlobStorage::TEvCaptureVDiskLayout, Handle)
-            HFunc(TEvProxyQueueState, Handle) 
+            HFunc(TEvProxyQueueState, Handle)
         )
 
         STRICT_STFUNC(StateNormal,
-            HFunc(TEvBlobStorage::TEvVMovedPatch, Handle) 
-            HFunc(TEvBlobStorage::TEvVPatchStart, Handle) 
-            HFunc(TEvBlobStorage::TEvVPatchDiff, HandleVPatchDiffResending) 
-            HFunc(TEvBlobStorage::TEvVPatchXorDiff, HandleVPatchDiffResending) 
-            hFunc(TEvVPatchDyingRequest, Handle) 
+            HFunc(TEvBlobStorage::TEvVMovedPatch, Handle)
+            HFunc(TEvBlobStorage::TEvVPatchStart, Handle)
+            HFunc(TEvBlobStorage::TEvVPatchDiff, HandleVPatchDiffResending)
+            HFunc(TEvBlobStorage::TEvVPatchXorDiff, HandleVPatchDiffResending)
+            hFunc(TEvVPatchDyingRequest, Handle)
             HFunc(TEvBlobStorage::TEvVPut, Handle)
             HFunc(TEvBlobStorage::TEvVMultiPut, Handle)
             HFunc(TEvHullLogHugeBlob, Handle)
@@ -2379,7 +2379,7 @@ namespace NKikimr {
             HFunc(TEvReportScrubStatus, Handle)
             HFunc(TEvRestoreCorruptedBlob, Handle)
             HFunc(TEvBlobStorage::TEvCaptureVDiskLayout, Handle)
-            HFunc(TEvProxyQueueState, Handle) 
+            HFunc(TEvProxyQueueState, Handle)
         )
 
         STRICT_STFUNC(StateDatabaseError,
@@ -2401,8 +2401,8 @@ namespace NKikimr {
             HFunc(TEvReportScrubStatus, Handle)
             HFunc(TEvRestoreCorruptedBlob, Handle)
             HFunc(TEvBlobStorage::TEvCaptureVDiskLayout, Handle)
-            HFunc(TEvProxyQueueState, Handle) 
-            hFunc(TEvVPatchDyingRequest, Handle) 
+            HFunc(TEvProxyQueueState, Handle)
+            hFunc(TEvVPatchDyingRequest, Handle)
         )
 
         PDISK_TERMINATE_STATE_FUNC_DEF;
@@ -2432,7 +2432,7 @@ namespace NKikimr {
             , SyncLogIFaceGroup(VCtx->VDiskCounters, "subsystem", "synclog")
             , IFaceMonGroup(std::make_shared<NMonGroup::TVDiskIFaceGroup>(
                 VCtx->VDiskCounters, "subsystem", "interface"))
-            , EnableVPatch(cfg->EnableVPatch) 
+            , EnableVPatch(cfg->EnableVPatch)
         {}
 
         virtual ~TSkeleton() {
@@ -2450,7 +2450,7 @@ namespace NKikimr {
         std::shared_ptr<THull> Hull; // run it after local recovery
         std::shared_ptr<TOutOfSpaceLogic> OutOfSpaceLogic;
         std::shared_ptr<TQueryCtx> QueryCtx;
-        TIntrusivePtr<TVPatchCtx> VPatchCtx; 
+        TIntrusivePtr<TVPatchCtx> VPatchCtx;
         TIntrusivePtr<TLocalRecoveryInfo> LocalRecovInfo; // just info we got after local recovery
         std::unique_ptr<TOverloadHandler> OverloadHandler;
         TActorIDPtr SkeletonFrontIDPtr;
@@ -2475,8 +2475,8 @@ namespace NKikimr {
         TActorId DefragId;
         bool HasUnreadableBlobs = false;
         std::unique_ptr<TVDiskCompactionState> VDiskCompactionState;
-        TMemorizableControlWrapper EnableVPatch; 
-        THashMap<TLogoBlobID, TActorId> VPatchActors; 
+        TMemorizableControlWrapper EnableVPatch;
+        THashMap<TLogoBlobID, TActorId> VPatchActors;
     };
 
     ////////////////////////////////////////////////////////////////////////////
diff --git a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonerr.h b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonerr.h
index 1d19dda98a..7e899b3236 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonerr.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonerr.h
@@ -56,26 +56,26 @@ namespace NKikimr {
         return vctx->IFaceMonGroup->GetBarrierResMsgsPtr();
     }
 
-    inline const NMonitoring::TDynamicCounters::TCounterPtr &ResultingCounterForEvent(const TVDiskContextPtr &vctx, 
-                TEvBlobStorage::TEvVMovedPatch::TPtr &) { 
-        return vctx->IFaceMonGroup->MovedPatchMsgsPtr(); 
-    } 
- 
-    inline const NMonitoring::TDynamicCounters::TCounterPtr &ResultingCounterForEvent(const TVDiskContextPtr &vctx, 
-                TEvBlobStorage::TEvVPatchFoundParts::TPtr &) { 
-        return vctx->IFaceMonGroup->PatchFoundPartsMsgsPtr(); 
-    } 
- 
-    inline const NMonitoring::TDynamicCounters::TCounterPtr &ResultingCounterForEvent(const TVDiskContextPtr &vctx, 
-                TEvBlobStorage::TEvVPatchXorDiffResult::TPtr &) { 
-        return vctx->IFaceMonGroup->PatchXorDiffResMsgsPtr(); 
-    } 
- 
-    inline const NMonitoring::TDynamicCounters::TCounterPtr &ResultingCounterForEvent(const TVDiskContextPtr &vctx, 
-                TEvBlobStorage::TEvVPatchResult::TPtr &) { 
-        return vctx->IFaceMonGroup->PatchResMsgsPtr(); 
-    } 
- 
+    inline const NMonitoring::TDynamicCounters::TCounterPtr &ResultingCounterForEvent(const TVDiskContextPtr &vctx,
+                TEvBlobStorage::TEvVMovedPatch::TPtr &) {
+        return vctx->IFaceMonGroup->MovedPatchMsgsPtr();
+    }
+
+    inline const NMonitoring::TDynamicCounters::TCounterPtr &ResultingCounterForEvent(const TVDiskContextPtr &vctx,
+                TEvBlobStorage::TEvVPatchFoundParts::TPtr &) {
+        return vctx->IFaceMonGroup->PatchFoundPartsMsgsPtr();
+    }
+
+    inline const NMonitoring::TDynamicCounters::TCounterPtr &ResultingCounterForEvent(const TVDiskContextPtr &vctx,
+                TEvBlobStorage::TEvVPatchXorDiffResult::TPtr &) {
+        return vctx->IFaceMonGroup->PatchXorDiffResMsgsPtr();
+    }
+
+    inline const NMonitoring::TDynamicCounters::TCounterPtr &ResultingCounterForEvent(const TVDiskContextPtr &vctx,
+                TEvBlobStorage::TEvVPatchResult::TPtr &) {
+        return vctx->IFaceMonGroup->PatchResMsgsPtr();
+    }
+
     template<typename TRequest, typename TResponse>
     inline void SetRacingGroupInfo(const TRequest& request, TResponse& response,
             const TIntrusivePtr<TBlobStorageGroupInfo>& groupInfo) {
@@ -87,11 +87,11 @@ namespace NKikimr {
         }
     }
 
-    inline void SetRacingGroupInfo(const NKikimrBlobStorage::TEvVPatchXorDiff&, 
-            NKikimrBlobStorage::TEvVPatchXorDiffResult&, const TIntrusivePtr<TBlobStorageGroupInfo>&) 
-    {} 
+    inline void SetRacingGroupInfo(const NKikimrBlobStorage::TEvVPatchXorDiff&,
+            NKikimrBlobStorage::TEvVPatchXorDiffResult&, const TIntrusivePtr<TBlobStorageGroupInfo>&)
+    {}
+
 
- 
     ////////////////////////////////////////////////////////////////////////////////////////////
     // CreateResult -- create result from original message and status
     ////////////////////////////////////////////////////////////////////////////////////////////
@@ -108,12 +108,12 @@ namespace NKikimr {
         }
         const auto oosStatus = vctx->GetOutOfSpaceState().GetGlobalStatusFlags();
         const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr = ResultingCounterForEvent(vctx, ev);
- 
+
         return std::make_unique<TEvBlobStorage::TEvVMovedPatchResult>(status, originalId, patchedId, vdiskID, cookie,
             oosStatus, now, ev->Get()->GetCachedByteSize(), &record, skeletonFrontIDPtr, counterPtr, nullptr,
             std::move(ev->TraceId), vdiskIncarnationGuid, errorReason);
     }
- 
+
     static inline std::unique_ptr<TEvBlobStorage::TEvVPatchFoundParts>
     CreateResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& errorReason,
             TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TInstant &now, const TActorIDPtr &skeletonFrontIDPtr,
@@ -124,50 +124,50 @@ namespace NKikimr {
         TMaybe<ui64> cookie;
         if (record.HasCookie()) {
             cookie = record.GetCookie();
-        } 
+        }
         const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr = ResultingCounterForEvent(vctx, ev);
- 
+
         return std::make_unique<TEvBlobStorage::TEvVPatchFoundParts>(status, originalId, patchedId, vdiskID, cookie, now,
             errorReason, &record, skeletonFrontIDPtr, counterPtr, nullptr, std::move(ev->TraceId), vdiskIncarnationGuid);
     }
- 
+
     static inline std::unique_ptr<TEvBlobStorage::TEvVPatchResult>
     CreateResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& errorReason,
             TEvBlobStorage::TEvVPatchDiff::TPtr &ev, const TInstant &now, const TActorIDPtr &skeletonFrontIDPtr,
             const TVDiskID &vdiskID, ui64 vdiskIncarnationGuid) {
- 
+
         auto &record = ev->Get()->Record;
         TLogoBlobID originalId = LogoBlobIDFromLogoBlobID(record.GetOriginalPartBlobId());
         TLogoBlobID patchedId = LogoBlobIDFromLogoBlobID(record.GetPatchedPartBlobId());
         TMaybe<ui64> cookie;
         if (record.HasCookie()) {
             cookie = record.GetCookie();
-        } 
+        }
         const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr = ResultingCounterForEvent(vctx, ev);
- 
+
         auto res = std::make_unique<TEvBlobStorage::TEvVPatchResult>(status, originalId, patchedId, vdiskID, cookie,
             now, &record, skeletonFrontIDPtr, counterPtr, nullptr, std::move(ev->TraceId), vdiskIncarnationGuid);
         res->SetStatus(status, errorReason);
         return res;
     }
- 
+
     static inline std::unique_ptr<TEvBlobStorage::TEvVPatchXorDiffResult>
     CreateResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& errorReason,
             TEvBlobStorage::TEvVPatchXorDiff::TPtr &ev, const TInstant &now, const TActorIDPtr &skeletonFrontIDPtr,
             const TVDiskID &vdiskID, ui64 vdiskIncarnationGuid) {
- 
+
         Y_UNUSED(errorReason, vdiskID, vdiskIncarnationGuid);
         auto &record = ev->Get()->Record;
         const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr = ResultingCounterForEvent(vctx, ev);
         return std::make_unique<TEvBlobStorage::TEvVPatchXorDiffResult>(status, now, &record, skeletonFrontIDPtr,
             counterPtr, nullptr, std::move(ev->TraceId));
     }
- 
+
     static inline std::unique_ptr<TEvBlobStorage::TEvVPutResult>
     CreateResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& errorReason,
             TEvBlobStorage::TEvVPut::TPtr &ev, const TInstant &now, const TActorIDPtr &skeletonFrontIDPtr,
             const TVDiskID &vdiskID, ui64 vdiskIncarnationGuid) {
- 
+
         NKikimrBlobStorage::TEvVPut &record = ev->Get()->Record;
         const TLogoBlobID id = LogoBlobIDFromLogoBlobID(record.GetBlobID());
         const ui64 bufferSizeBytes = ev->Get()->GetBufferBytes();
@@ -177,7 +177,7 @@ namespace NKikimr {
         const auto handleClass = record.GetHandleClass();
         const NVDiskMon::TLtcHistoPtr &histoPtr = vctx->Histograms.GetHistogram(handleClass);
         const NMonitoring::TDynamicCounters::TCounterPtr &counterPtr = ResultingCounterForEvent(vctx, ev);
- 
+
         return std::make_unique<TEvBlobStorage::TEvVPutResult>(status, id, vdiskID, cookie, oosStatus, now,
                 ev->Get()->GetCachedByteSize(), &record, skeletonFrontIDPtr, counterPtr, histoPtr,
                 bufferSizeBytes, std::move(ev->TraceId), vdiskIncarnationGuid, errorReason);
@@ -214,47 +214,47 @@ namespace NKikimr {
     // NErrBuilder -- routines for error results
     ////////////////////////////////////////////////////////////////////////////
     namespace NErrBuilder {
-        template <typename TEvPtr> 
+        template <typename TEvPtr>
         static inline std::unique_ptr<IEventBase>
         ErroneousResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& errorReason,
-                        TEvPtr &ev, const TInstant &now, const TActorIDPtr &skeletonFrontIDPtr, 
-                        const TVDiskID &vdiskID, ui64 vdiskIncarnationGuid, 
-                        const TIntrusivePtr<TBlobStorageGroupInfo>& groupInfo) 
-        { 
-            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVMovedPatch::TPtr>) { 
-                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetOriginalBlobId()); 
-                LWTRACK(VDiskSkeletonFrontVMovedPatchRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId, 
-                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize()); 
-            } 
-            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchStart::TPtr>) { 
-                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetOriginalBlobId()); 
-                LWTRACK(VDiskSkeletonFrontVPatchStartRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId, 
-                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize()); 
-            } 
-            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchDiff::TPtr>) { 
-                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetOriginalPartBlobId()); 
-                LWTRACK(VDiskSkeletonFrontVPatchDiffRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId, 
-                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize()); 
-            } 
-            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchXorDiff::TPtr>) { 
-                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetOriginalPartBlobId()); 
-                LWTRACK(VDiskSkeletonFrontVPatchXorDiffRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId, 
-                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize()); 
-            } 
-            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPut::TPtr>) { 
-                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetBlobID()); 
-                LWTRACK(VDiskSkeletonFrontVPutRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId, 
-                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize()); 
-            } 
- 
+                        TEvPtr &ev, const TInstant &now, const TActorIDPtr &skeletonFrontIDPtr,
+                        const TVDiskID &vdiskID, ui64 vdiskIncarnationGuid,
+                        const TIntrusivePtr<TBlobStorageGroupInfo>& groupInfo)
+        {
+            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVMovedPatch::TPtr>) {
+                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetOriginalBlobId());
+                LWTRACK(VDiskSkeletonFrontVMovedPatchRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId,
+                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize());
+            }
+            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchStart::TPtr>) {
+                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetOriginalBlobId());
+                LWTRACK(VDiskSkeletonFrontVPatchStartRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId,
+                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize());
+            }
+            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchDiff::TPtr>) {
+                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetOriginalPartBlobId());
+                LWTRACK(VDiskSkeletonFrontVPatchDiffRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId,
+                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize());
+            }
+            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchXorDiff::TPtr>) {
+                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetOriginalPartBlobId());
+                LWTRACK(VDiskSkeletonFrontVPatchXorDiffRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId,
+                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize());
+            }
+            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPut::TPtr>) {
+                TLogoBlobID id = LogoBlobIDFromLogoBlobID(ev->Get()->Record.GetBlobID());
+                LWTRACK(VDiskSkeletonFrontVPutRecieved, ev->Get()->Orbit, vctx->NodeId, vctx->GroupId,
+                    vctx->Top->GetFailDomainOrderNumber(vctx->ShortSelfVDisk), id.TabletID(), id.BlobSize());
+            }
+
             auto result = CreateResult(vctx, status, errorReason, ev, now, skeletonFrontIDPtr, vdiskID,
                 vdiskIncarnationGuid);
-            SetRacingGroupInfo(ev->Get()->Record, result->Record, groupInfo); 
+            SetRacingGroupInfo(ev->Get()->Record, result->Record, groupInfo);
             return result;
-        } 
- 
+        }
+
         static inline std::unique_ptr<IEventBase>
-        ErroneousResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& errorReason, 
+        ErroneousResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& errorReason,
                         TEvBlobStorage::TEvVMultiPut::TPtr &ev, const TInstant &now,
                         const TActorIDPtr &skeletonFrontIDPtr, const TVDiskID &vdiskID,
                         const TBatchedVec<NKikimrProto::EReplyStatus> &statuses, ui64 vdiskIncarnationGuid,
@@ -273,9 +273,9 @@ namespace NKikimr {
             auto result = std::make_unique<TEvBlobStorage::TEvVMultiPutResult>(status, vdiskID, cookie, now,
                 ev->Get()->GetCachedByteSize(), &record, skeletonFrontIDPtr, counterPtr, histoPtr, bufferSizeBytes,
                 std::move(ev->TraceId), vdiskIncarnationGuid, errorReason);
-            Y_VERIFY(record.ItemsSize() == statuses.size()); 
-            for (ui64 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) { 
-                auto &item = record.GetItems(itemIdx); 
+            Y_VERIFY(record.ItemsSize() == statuses.size());
+            for (ui64 itemIdx = 0; itemIdx < record.ItemsSize(); ++itemIdx) {
+                auto &item = record.GetItems(itemIdx);
                 ui64 cookieValue = 0;
                 ui64 *cookiePtr = nullptr;
                 if (item.HasCookie()) {
@@ -291,17 +291,17 @@ namespace NKikimr {
 
         static inline std::unique_ptr<IEventBase>
         ErroneousResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& errorReason,
-                        TEvBlobStorage::TEvVMultiPut::TPtr &ev, const TInstant &now, 
-                        const TActorIDPtr &skeletonFrontIDPtr, 
+                        TEvBlobStorage::TEvVMultiPut::TPtr &ev, const TInstant &now,
+                        const TActorIDPtr &skeletonFrontIDPtr,
                         const TVDiskID &vdiskID, ui64 vdiskIncarnationGuid,
                         const TIntrusivePtr<TBlobStorageGroupInfo>& groupInfo)
-        { 
-            NKikimrBlobStorage::TEvVMultiPut &record = ev->Get()->Record; 
-            TBatchedVec<NKikimrProto::EReplyStatus> statuses(record.ItemsSize(), status); 
+        {
+            NKikimrBlobStorage::TEvVMultiPut &record = ev->Get()->Record;
+            TBatchedVec<NKikimrProto::EReplyStatus> statuses(record.ItemsSize(), status);
             return ErroneousResult(vctx, status, errorReason, ev, now, skeletonFrontIDPtr, vdiskID, statuses,
                 vdiskIncarnationGuid, groupInfo);
-        } 
- 
+        }
+
         static inline std::unique_ptr<IEventBase>
         ErroneousResult(const TVDiskContextPtr &vctx, const NKikimrProto::EReplyStatus status, const TString& /*errorReason*/,
                         TEvBlobStorage::TEvVGet::TPtr &ev, const TInstant &now, const TActorIDPtr &skeletonFrontIDPtr,
diff --git a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonfront.cpp b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonfront.cpp
index 89d125e457..08c32a8921 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonfront.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonfront.cpp
@@ -55,10 +55,10 @@ namespace NKikimr {
         void ApplyToRecord(IEventHandle& event, Func&& callback) {
             switch (event.GetTypeRewrite()) {
 #define EVENT_TYPE(EVENT) case TEvBlobStorage::EVENT::EventType: callback(static_cast<TEvBlobStorage::EVENT&>(*event.GetBase()).Record); return;
-                EVENT_TYPE(TEvVMovedPatch) 
-                EVENT_TYPE(TEvVPatchStart) 
-                EVENT_TYPE(TEvVPatchDiff) 
-                EVENT_TYPE(TEvVPatchXorDiff) 
+                EVENT_TYPE(TEvVMovedPatch)
+                EVENT_TYPE(TEvVPatchStart)
+                EVENT_TYPE(TEvVPatchDiff)
+                EVENT_TYPE(TEvVPatchXorDiff)
                 EVENT_TYPE(TEvVPut)
                 EVENT_TYPE(TEvVMultiPut)
                 EVENT_TYPE(TEvVGet)
@@ -517,10 +517,10 @@ namespace NKikimr {
                 switch (ev->Type()) {
 #define UPDATE_WINDOW_STATUS(TYPE) case TYPE::EventType: msgQoS = static_cast<TYPE&>(*ev).Record.MutableMsgQoS(); break;
                     // all message types that have MsgQoS structure
-                    UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVMovedPatchResult) 
-                    UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVPatchFoundParts) 
-                    UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVPatchXorDiffResult) 
-                    UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVPatchResult) 
+                    UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVMovedPatchResult)
+                    UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVPatchFoundParts)
+                    UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVPatchXorDiffResult)
+                    UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVPatchResult)
                     UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVPutResult)
                     UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVMultiPutResult)
                     UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVGetResult)
@@ -724,14 +724,14 @@ namespace NKikimr {
             } else {
                 switch (msg->Phase) {
                     case TEvFrontRecoveryStatus::LocalRecoveryDone:
-                    { 
+                    {
                         Become(&TThis::StateSyncGuidRecoveryInProgress);
-                        TBlobStorageGroupType type = (GInfo ? GInfo->Type : TErasureType::ErasureNone); 
+                        TBlobStorageGroupType type = (GInfo ? GInfo->Type : TErasureType::ErasureNone);
                         CostModel = std::make_unique<TCostModel>(msg->Dsk->SeekTimeUs, msg->Dsk->ReadSpeedBps,
                             msg->Dsk->WriteSpeedBps, msg->Dsk->ReadBlockSize, msg->Dsk->WriteBlockSize,
                             msg->HugeBlobCtx->MinREALHugeBlobInBytes, type);
                         break;
-                    } 
+                    }
                     case TEvFrontRecoveryStatus::SyncGuidRecoveryDone:
                         Become(&TThis::StateFunc);
                         SendNotifications(ctx);
@@ -940,8 +940,8 @@ namespace NKikimr {
                     << "Access denied Type# " << Sprintf("0x%08" PRIx32, ev->GetTypeRewrite())
                     << " Sender# " << ev->Sender.ToString()
                     << " OriginScopeId# " << ScopeIdToString(ev->OriginScopeId)
-                    << " LocalScopeId# " << ScopeIdToString(AppData(ctx)->LocalScopeId.GetInterconnectScopeId()) 
-                    << " Marker# BSVSF01"); 
+                    << " LocalScopeId# " << ScopeIdToString(AppData(ctx)->LocalScopeId.GetInterconnectScopeId())
+                    << " Marker# BSVSF01");
             ++*AccessDeniedMessages;
             TInstant now = TAppData::TimeProvider->Now();
             FillInCostSettingsAndTimestampIfApplicable(ev->Get()->Record, now);
@@ -984,26 +984,26 @@ namespace NKikimr {
             return val ? TInstant::Seconds(val) : TInstant::Max();
         }
 
-        template <typename TRecord, typename Dimmy = void> 
-        struct THasMsgQoS { 
-            static constexpr bool value = false; 
-        }; 
-
-        template <typename TRecord> 
-        struct THasMsgQoS<TRecord, TRecord> { 
-            static constexpr bool value = true; 
- 
-            static auto Checking(TRecord &r) { 
-                return r.MutableMsgQoS(); 
-            } 
-        }; 
-
-        template<typename TRecord> 
-        void FillInCostSettingsAndTimestampIfApplicable(TRecord& record, TInstant now) const 
-        { 
-            if constexpr (THasMsgQoS<TRecord>::value) { 
-                FillInCostSettingsAndTimestampIfRequired(record.MutableMsgQoS(), now); 
-            } 
+        template <typename TRecord, typename Dimmy = void>
+        struct THasMsgQoS {
+            static constexpr bool value = false;
+        };
+
+        template <typename TRecord>
+        struct THasMsgQoS<TRecord, TRecord> {
+            static constexpr bool value = true;
+
+            static auto Checking(TRecord &r) {
+                return r.MutableMsgQoS();
+            }
+        };
+
+        template<typename TRecord>
+        void FillInCostSettingsAndTimestampIfApplicable(TRecord& record, TInstant now) const
+        {
+            if constexpr (THasMsgQoS<TRecord>::value) {
+                FillInCostSettingsAndTimestampIfRequired(record.MutableMsgQoS(), now);
+            }
         }
 
         void FillInCostSettingsAndTimestampIfRequired(NKikimrBlobStorage::TMsgQoS *qos, TInstant now) const {
@@ -1077,50 +1077,50 @@ namespace NKikimr {
             return compatibilityMatrix[extId][intId];
         }
 
-        template <typename TEvPtr> 
-        void HandlePatchEvent(TEvPtr &ev) { 
-            const ui64 cost = CostModel->GetCost(*ev->Get()); 
- 
-            auto &record = ev->Get()->Record; 
- 
-            TLogoBlobID blob; 
-            TLogoBlobID patchedBlob; 
-            constexpr bool blobIdWithoutPartId = std::is_same_v<TEvPtr, TEvBlobStorage::TEvVMovedPatch::TPtr> 
-                    || std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchStart::TPtr>; 
-            if constexpr (blobIdWithoutPartId) { 
-                blob = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId()); 
-                patchedBlob = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId()); 
-            } else { 
-                blob = LogoBlobIDFromLogoBlobID(record.GetOriginalPartBlobId()); 
-                patchedBlob = LogoBlobIDFromLogoBlobID(record.GetPatchedPartBlobId()); 
-            } 
- 
-            const char* name = "Unknown"; 
+        template <typename TEvPtr>
+        void HandlePatchEvent(TEvPtr &ev) {
+            const ui64 cost = CostModel->GetCost(*ev->Get());
+
+            auto &record = ev->Get()->Record;
+
+            TLogoBlobID blob;
+            TLogoBlobID patchedBlob;
+            constexpr bool blobIdWithoutPartId = std::is_same_v<TEvPtr, TEvBlobStorage::TEvVMovedPatch::TPtr>
+                    || std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchStart::TPtr>;
+            if constexpr (blobIdWithoutPartId) {
+                blob = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId());
+                patchedBlob = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId());
+            } else {
+                blob = LogoBlobIDFromLogoBlobID(record.GetOriginalPartBlobId());
+                patchedBlob = LogoBlobIDFromLogoBlobID(record.GetPatchedPartBlobId());
+            }
+
+            const char* name = "Unknown";
             TIntQueueClass *queue = IntQueueHugePutsBackground.get();
-            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVMovedPatch::TPtr>) { 
-                LWTRACK(VDiskSkeletonFrontVMovedPatchRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId, 
-                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), blob.TabletID(), blob.BlobSize()); 
-                name = "TEvVMovedPatch"; 
-            } else if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchStart::TPtr>) { 
-                LWTRACK(VDiskSkeletonFrontVPatchStartRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId, 
-                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), blob.TabletID(), blob.BlobSize()); 
+            if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVMovedPatch::TPtr>) {
+                LWTRACK(VDiskSkeletonFrontVMovedPatchRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId,
+                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), blob.TabletID(), blob.BlobSize());
+                name = "TEvVMovedPatch";
+            } else if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchStart::TPtr>) {
+                LWTRACK(VDiskSkeletonFrontVPatchStartRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId,
+                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), blob.TabletID(), blob.BlobSize());
                 queue = IntQueueFastGets.get();
-                name = "TEvVPatchStart"; 
-            } else if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchDiff::TPtr>) { 
-                LWTRACK(VDiskSkeletonFrontVPatchDiffRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId, 
-                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), blob.TabletID(), blob.BlobSize()); 
-                name = "TEvVPatchDiff"; 
-            } else if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchXorDiff::TPtr>) { 
-                LWTRACK(VDiskSkeletonFrontVPatchXorDiffRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId, 
-                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), blob.TabletID(), blob.BlobSize()); 
-                name = "TEvVPatchXorDiff"; 
-            } 
- 
-            LOG_DEBUG_S(TActivationContext::AsActorContext(), NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix 
-                    << name << ": received;" << " OriginalBlobId# " << blob << " PatchedBlobId# " << patchedBlob); 
-            HandleRequestWithQoS(TActivationContext::AsActorContext(), ev, name, cost, *queue); 
-        } 
- 
+                name = "TEvVPatchStart";
+            } else if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchDiff::TPtr>) {
+                LWTRACK(VDiskSkeletonFrontVPatchDiffRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId,
+                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), blob.TabletID(), blob.BlobSize());
+                name = "TEvVPatchDiff";
+            } else if constexpr (std::is_same_v<TEvPtr, TEvBlobStorage::TEvVPatchXorDiff::TPtr>) {
+                LWTRACK(VDiskSkeletonFrontVPatchXorDiffRecieved, ev->Get()->Orbit, VCtx->NodeId, VCtx->GroupId,
+                    VCtx->Top->GetFailDomainOrderNumber(VCtx->ShortSelfVDisk), blob.TabletID(), blob.BlobSize());
+                name = "TEvVPatchXorDiff";
+            }
+
+            LOG_DEBUG_S(TActivationContext::AsActorContext(), NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix
+                    << name << ": received;" << " OriginalBlobId# " << blob << " PatchedBlobId# " << patchedBlob);
+            HandleRequestWithQoS(TActivationContext::AsActorContext(), ev, name, cost, *queue);
+        }
+
         void Handle(TEvBlobStorage::TEvVPut::TPtr &ev, const TActorContext &ctx) {
             bool logPutInternalQueue = true;
             const ui64 cost = CostModel->GetCost(*ev->Get(), &logPutInternalQueue);
@@ -1270,11 +1270,11 @@ namespace NKikimr {
         template <typename TPtr>
         void SetReceivedTime(TPtr& ev) {
             using TRecord = decltype(ev->Get()->Record);
-            if constexpr (std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVMovedPatch> 
-                       || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVPatchStart> 
-                       || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVPatchDiff> 
-                       || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVPatchXorDiff> 
-                       || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVPut> 
+            if constexpr (std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVMovedPatch>
+                       || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVPatchStart>
+                       || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVPatchDiff>
+                       || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVPatchXorDiff>
+                       || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVPut>
                        || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVMultiPut>
                        || std::is_convertible_v<TRecord, NKikimrBlobStorage::TEvVGet>)
             {
@@ -1393,9 +1393,9 @@ namespace NKikimr {
             }
 
             // all checks passed
-            LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "VDisk Generation Change success;" 
-                    << " new VDiskId# " << vdiskId 
-                    << " Marker# BSVSF02"); 
+            LOG_INFO_S(ctx, BS_SKELETON, VCtx->VDiskLogPrefix << "VDisk Generation Change success;"
+                    << " new VDiskId# " << vdiskId
+                    << " Marker# BSVSF02");
 
             // update GroupInfo-related fields
             GInfo = info;
@@ -1418,8 +1418,8 @@ namespace NKikimr {
         void Handle(TEvPDiskErrorStateChange::TPtr &ev, const TActorContext &ctx) {
             LOG_ERROR_S(ctx, NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix
                     << "SkeletonFront: got TEvPDiskErrorStateChange;"
-                    << " state# " << TPDiskErrorState::StateToString(ev->Get()->State) 
-                    << " Marker# BSVSF03"); 
+                    << " state# " << TPDiskErrorState::StateToString(ev->Get()->State)
+                    << " Marker# BSVSF03");
 
 
             // switch skeleton state to PDiskError
@@ -1438,11 +1438,11 @@ namespace NKikimr {
             for (auto *q : {&IntQueueAsyncGets, &IntQueueFastGets, &IntQueueDiscover, &IntQueueLowGets, &IntQueueLogPuts,
                     &IntQueueHugePutsForeground, &IntQueueHugePutsBackground}) {
                 (*q)->DropWithError(ctx, *this);
-            } 
+            }
             // drop external queues
             DisconnectClients(ctx);
         }
- 
+
         void DisconnectClients(const TActorContext& ctx) {
             const auto& base = Config->BaseInfo;
             const TActorId& serviceId = MakeBlobStorageVDiskID(SelfId().NodeId(), base.PDiskId, base.VDiskSlotId);
@@ -1540,10 +1540,10 @@ namespace NKikimr {
 
         // while local db recovery is in progress, we use this state function to handle requests
         STRICT_STFUNC(StateLocalRecoveryInProgress,
-            HFunc(TEvBlobStorage::TEvVMovedPatch, DatabaseNotReadyHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchStart, DatabaseNotReadyHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchDiff, DatabaseNotReadyHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchXorDiff, DatabaseNotReadyHandle) 
+            HFunc(TEvBlobStorage::TEvVMovedPatch, DatabaseNotReadyHandle)
+            HFunc(TEvBlobStorage::TEvVPatchStart, DatabaseNotReadyHandle)
+            HFunc(TEvBlobStorage::TEvVPatchDiff, DatabaseNotReadyHandle)
+            HFunc(TEvBlobStorage::TEvVPatchXorDiff, DatabaseNotReadyHandle)
             HFunc(TEvBlobStorage::TEvVPut, DatabaseNotReadyHandle)
             HFunc(TEvBlobStorage::TEvVMultiPut, DatabaseNotReadyHandle)
             HFunc(TEvBlobStorage::TEvVGet, DatabaseNotReadyHandle)
@@ -1579,10 +1579,10 @@ namespace NKikimr {
 
         // while recovering sync guid we use this state function to handle requests
         STRICT_STFUNC(StateSyncGuidRecoveryInProgress,
-            HFunc(TEvBlobStorage::TEvVMovedPatch, DatabaseNotReadyHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchStart, DatabaseNotReadyHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchDiff, DatabaseNotReadyHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchXorDiff, DatabaseNotReadyHandle) 
+            HFunc(TEvBlobStorage::TEvVMovedPatch, DatabaseNotReadyHandle)
+            HFunc(TEvBlobStorage::TEvVPatchStart, DatabaseNotReadyHandle)
+            HFunc(TEvBlobStorage::TEvVPatchDiff, DatabaseNotReadyHandle)
+            HFunc(TEvBlobStorage::TEvVPatchXorDiff, DatabaseNotReadyHandle)
             HFunc(TEvBlobStorage::TEvVPut, DatabaseNotReadyHandle)
             HFunc(TEvBlobStorage::TEvVMultiPut, DatabaseNotReadyHandle)
             HFunc(TEvBlobStorage::TEvVGet, DatabaseNotReadyHandle)
@@ -1621,10 +1621,10 @@ namespace NKikimr {
         )
 
         STRICT_STFUNC(StateDatabaseError,
-            HFunc(TEvBlobStorage::TEvVMovedPatch, DatabaseErrorHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchStart, DatabaseErrorHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchDiff, DatabaseErrorHandle) 
-            HFunc(TEvBlobStorage::TEvVPatchXorDiff, DatabaseErrorHandle) 
+            HFunc(TEvBlobStorage::TEvVMovedPatch, DatabaseErrorHandle)
+            HFunc(TEvBlobStorage::TEvVPatchStart, DatabaseErrorHandle)
+            HFunc(TEvBlobStorage::TEvVPatchDiff, DatabaseErrorHandle)
+            HFunc(TEvBlobStorage::TEvVPatchXorDiff, DatabaseErrorHandle)
             HFunc(TEvBlobStorage::TEvVPut, DatabaseErrorHandle)
             HFunc(TEvBlobStorage::TEvVMultiPut, DatabaseErrorHandle)
             HFunc(TEvBlobStorage::TEvVGet, DatabaseErrorHandle)
@@ -1663,33 +1663,33 @@ namespace NKikimr {
         // Events checking: RACE and access control
         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-        template <typename TEv> 
-        static constexpr bool IsPatchEvent = std::is_same_v<TEv, TEvBlobStorage::TEvVMovedPatch> 
-                || std::is_same_v<TEv, TEvBlobStorage::TEvVPatchStart> 
-                || std::is_same_v<TEv, TEvBlobStorage::TEvVPatchDiff> 
-                || std::is_same_v<TEv, TEvBlobStorage::TEvVPatchXorDiff>; 
+        template <typename TEv>
+        static constexpr bool IsPatchEvent = std::is_same_v<TEv, TEvBlobStorage::TEvVMovedPatch>
+                || std::is_same_v<TEv, TEvBlobStorage::TEvVPatchStart>
+                || std::is_same_v<TEv, TEvBlobStorage::TEvVPatchDiff>
+                || std::is_same_v<TEv, TEvBlobStorage::TEvVPatchXorDiff>;
 
-        template <typename TEv> 
-        static constexpr bool IsWithoutQoS = std::is_same_v<TEv, TEvBlobStorage::TEvVStatus> 
-                || std::is_same_v<TEv, TEvBlobStorage::TEvVDbStat> 
-                || std::is_same_v<TEv, TEvBlobStorage::TEvVCompact> 
+        template <typename TEv>
+        static constexpr bool IsWithoutQoS = std::is_same_v<TEv, TEvBlobStorage::TEvVStatus>
+                || std::is_same_v<TEv, TEvBlobStorage::TEvVDbStat>
+                || std::is_same_v<TEv, TEvBlobStorage::TEvVCompact>
                 || std::is_same_v<TEv, TEvBlobStorage::TEvVDefrag>
-                || std::is_same_v<TEv, TEvBlobStorage::TEvVBaldSyncLog>; 
+                || std::is_same_v<TEv, TEvBlobStorage::TEvVBaldSyncLog>;
 
         template <typename TEv>
         static constexpr bool IsValidatable = std::is_same_v<TEv, TEvBlobStorage::TEvVMultiPut>
                 || std::is_same_v<TEv, TEvBlobStorage::TEvVGet>
                 || std::is_same_v<TEv, TEvBlobStorage::TEvVPut>;
 
-        template<typename TEventType> 
-        void CheckExecute(TAutoPtr<TEventHandle<TEventType>>& ev, const TActorContext& ctx) { 
-            if constexpr (IsPatchEvent<TEventType>) { 
-                HandlePatchEvent(ev); 
-            } else if constexpr (IsWithoutQoS<TEventType>) { 
-                HandleRequestWithoutQoS(ev, ctx); 
-            } else { 
-                Handle(ev, ctx); 
-            } 
+        template<typename TEventType>
+        void CheckExecute(TAutoPtr<TEventHandle<TEventType>>& ev, const TActorContext& ctx) {
+            if constexpr (IsPatchEvent<TEventType>) {
+                HandlePatchEvent(ev);
+            } else if constexpr (IsWithoutQoS<TEventType>) {
+                HandleRequestWithoutQoS(ev, ctx);
+            } else {
+                Handle(ev, ctx);
+            }
         }
 
         template <typename TEv>
@@ -1700,8 +1700,8 @@ namespace NKikimr {
             return true;
         }
 
-        template <typename TEventType> 
-        void Check(TAutoPtr<TEventHandle<TEventType>>& ev, const TActorContext& ctx) { 
+        template <typename TEventType>
+        void Check(TAutoPtr<TEventHandle<TEventType>>& ev, const TActorContext& ctx) {
             const auto& record = ev->Get()->Record;
             if (!SelfVDiskId.SameDisk(record.GetVDiskID())) {
                 return Reply(ev, ctx, NKikimrProto::RACE, "group generation mismatch", TAppData::TimeProvider->Now());
@@ -1734,10 +1734,10 @@ namespace NKikimr {
         }
 
         STRICT_STFUNC(StateFunc,
-            HFunc(TEvBlobStorage::TEvVMovedPatch, Check) 
-            HFunc(TEvBlobStorage::TEvVPatchStart, Check) 
-            HFunc(TEvBlobStorage::TEvVPatchDiff, Check) 
-            HFunc(TEvBlobStorage::TEvVPatchXorDiff, Check) 
+            HFunc(TEvBlobStorage::TEvVMovedPatch, Check)
+            HFunc(TEvBlobStorage::TEvVPatchStart, Check)
+            HFunc(TEvBlobStorage::TEvVPatchDiff, Check)
+            HFunc(TEvBlobStorage::TEvVPatchXorDiff, Check)
             HFunc(TEvBlobStorage::TEvVPut, ValidateEvent)
             HFunc(TEvBlobStorage::TEvVMultiPut, ValidateEvent)
             HFunc(TEvBlobStorage::TEvVGet, ValidateEvent)
@@ -1786,10 +1786,10 @@ namespace NKikimr {
                        NKikimrProto::EReplyStatus status, const TString& errorReason, TInstant now,
                        const TWindowStatus &wstatus) {
             switch (ev->GetTypeRewrite()) {
-                HFuncStatus(TEvBlobStorage::TEvVMovedPatch, status, errorReason, now, wstatus); 
-                HFuncStatus(TEvBlobStorage::TEvVPatchStart, status, errorReason, now, wstatus); 
-                HFuncStatus(TEvBlobStorage::TEvVPatchDiff, status, errorReason, now, wstatus); 
-                HFuncStatus(TEvBlobStorage::TEvVPatchXorDiff, status, errorReason, now, wstatus); 
+                HFuncStatus(TEvBlobStorage::TEvVMovedPatch, status, errorReason, now, wstatus);
+                HFuncStatus(TEvBlobStorage::TEvVPatchStart, status, errorReason, now, wstatus);
+                HFuncStatus(TEvBlobStorage::TEvVPatchDiff, status, errorReason, now, wstatus);
+                HFuncStatus(TEvBlobStorage::TEvVPatchXorDiff, status, errorReason, now, wstatus);
                 HFuncStatus(TEvBlobStorage::TEvVPut, status, errorReason, now, wstatus);
                 HFuncStatus(TEvBlobStorage::TEvVMultiPut, status, errorReason, now, wstatus);
                 HFuncStatus(TEvBlobStorage::TEvVGet, status, errorReason, now, wstatus);
diff --git a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_syncfullhandler.cpp b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_syncfullhandler.cpp
index baf982c98e..11f708e717 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_syncfullhandler.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_syncfullhandler.cpp
@@ -49,8 +49,8 @@ namespace NKikimr {
             LOG_DEBUG_S(ctx, BS_SYNCJOB, Db->VCtx->VDiskLogPrefix
                     << "TVSyncFullHandler: Bootstrap: fromVDisk# "
                     << VDiskIDFromVDiskID(Record.GetSourceVDiskID())
-                    << " fromSyncState# " << clientSyncState.ToString() 
-                    << " Marker# BSVSFH01"); 
+                    << " fromSyncState# " << clientSyncState.ToString()
+                    << " Marker# BSVSFH01");
 
 
             // check that the disk is from this group
@@ -67,10 +67,10 @@ namespace NKikimr {
             // check disk guid and start from the beginning if it has changed
             if (Db->GetVDiskIncarnationGuid() != clientSyncState.Guid) {
                 LOG_DEBUG_S(ctx, BS_SYNCJOB, Db->VCtx->VDiskLogPrefix
-                        << "TVSyncFullHandler: GUID CHANGED;" 
-                        << " SourceVDisk# " << SourceVDisk 
-                        << " DbBirthLsn# " << DbBirthLsn 
-                        << " Marker# BSVSFH02"); 
+                        << "TVSyncFullHandler: GUID CHANGED;"
+                        << " SourceVDisk# " << SourceVDisk
+                        << " DbBirthLsn# " << DbBirthLsn
+                        << " Marker# BSVSFH02");
                 auto result = std::make_unique<TEvBlobStorage::TEvVSyncFullResult>(NKikimrProto::NODATA, SelfVDiskId,
                     TSyncState(Db->GetVDiskIncarnationGuid(), DbBirthLsn), Record.GetCookie(), Now,
                     IFaceMonGroup->SyncFullResMsgsPtr(), nullptr, std::move(Ev->TraceId), Ev->GetChannel());
@@ -113,8 +113,8 @@ namespace NKikimr {
             LOG_DEBUG_S(ctx, BS_SYNCJOB, Db->VCtx->VDiskLogPrefix
                     << "TVSyncFullHandler: ourConfirmedLsn# " << ConfirmedLsn
                     << " syncedLsn# " << syncedLsn
-                    << " SourceVDisk# " << SourceVDisk 
-                    << " Marker# BSVSFH03"); 
+                    << " SourceVDisk# " << SourceVDisk
+                    << " Marker# BSVSFH03");
 
             IActor *actor = CreateHullSyncFullActor(
                 Db->Config,
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.cpp
index 6fc6c5fb85..ce4615fb5d 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.cpp
@@ -39,50 +39,50 @@ namespace NKikimr {
         TLogoBlobID genId(Id, 0);
         hull.AddLogoBlob(ctx, genId, Id.PartId(), Ingress, Buffer, Seg.Point());
 
-        LOG_DEBUG_S(ctx, NKikimrServices::BS_VDISK_PUT, hull.GetHullCtx()->VCtx->VDiskLogPrefix << "TEvVPut: reply;" 
-                << " id# " << Id 
-                << " msg# " << Result->ToString() 
-                << " Marker# BSVSLR01"); 
+        LOG_DEBUG_S(ctx, NKikimrServices::BS_VDISK_PUT, hull.GetHullCtx()->VCtx->VDiskLogPrefix << "TEvVPut: reply;"
+                << " id# " << Id
+                << " msg# " << Result->ToString()
+                << " Marker# BSVSLR01");
 
         SendVDiskResponse(ctx, Recipient, Result.release(), actor, RecipientCookie);
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////////
-    // TLoggedRecVPut -- incapsulates TEvVPut replay action (for small blobs) 
-    /////////////////////////////////////////////////////////////////////////////////////////////////////// 
-    TLoggedRecVMultiPutItem::TLoggedRecVMultiPutItem( 
-            TLsnSeg seg, 
-            bool confirmSyncLogAlso, 
-            const TLogoBlobID &id, 
-            const TIngress &ingress, 
-            TRope &&buffer, 
+    // TLoggedRecVPut -- incapsulates TEvVPut replay action (for small blobs)
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////
+    TLoggedRecVMultiPutItem::TLoggedRecVMultiPutItem(
+            TLsnSeg seg,
+            bool confirmSyncLogAlso,
+            const TLogoBlobID &id,
+            const TIngress &ingress,
+            TRope &&buffer,
             std::unique_ptr<TEvVMultiPutItemResult> result,
             const TActorId &recipient,
-            ui64 recipientCookie) 
-        : ILoggedRec(seg, confirmSyncLogAlso) 
-        , Id(id) 
-        , Ingress(ingress) 
-        , Buffer(std::move(buffer)) 
+            ui64 recipientCookie)
+        : ILoggedRec(seg, confirmSyncLogAlso)
+        , Id(id)
+        , Ingress(ingress)
+        , Buffer(std::move(buffer))
         , Result(std::move(result))
-        , Recipient(recipient) 
-        , RecipientCookie(recipientCookie) 
-    {} 
- 
-    void TLoggedRecVMultiPutItem::Replay(THull &hull, const TActorContext &ctx, const IActor& actor) { 
-        Y_UNUSED(actor); 
-        TLogoBlobID genId(Id, 0); 
-        hull.AddLogoBlob(ctx, genId, Id.PartId(), Ingress, Buffer, Seg.Point()); 
- 
-        LOG_DEBUG_S(ctx, NKikimrServices::BS_VDISK_PUT, hull.GetHullCtx()->VCtx->VDiskLogPrefix 
-                << "TEvVMultiPut: item reply;" 
-                << " id# " << Id 
-                << " msg# " << Result->ToString() 
-                << " Marker# BSVSLR02"); 
- 
+        , Recipient(recipient)
+        , RecipientCookie(recipientCookie)
+    {}
+
+    void TLoggedRecVMultiPutItem::Replay(THull &hull, const TActorContext &ctx, const IActor& actor) {
+        Y_UNUSED(actor);
+        TLogoBlobID genId(Id, 0);
+        hull.AddLogoBlob(ctx, genId, Id.PartId(), Ingress, Buffer, Seg.Point());
+
+        LOG_DEBUG_S(ctx, NKikimrServices::BS_VDISK_PUT, hull.GetHullCtx()->VCtx->VDiskLogPrefix
+                << "TEvVMultiPut: item reply;"
+                << " id# " << Id
+                << " msg# " << Result->ToString()
+                << " Marker# BSVSLR02");
+
         ctx.Send(Recipient, Result.release(), RecipientCookie);
-    } 
- 
-    /////////////////////////////////////////////////////////////////////////////////////////////////////// 
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////
     // TLoggedRecVPut -- incapsulates TEvVPut replay action (for huge blobs)
     ///////////////////////////////////////////////////////////////////////////////////////////////////////
     TLoggedRecVPutHuge::TLoggedRecVPutHuge(
@@ -106,8 +106,8 @@ namespace NKikimr {
         }
 
         LOG_DEBUG_S(ctx, NKikimrServices::BS_VDISK_PUT, hull.GetHullCtx()->VCtx->VDiskLogPrefix
-                << "TEvVPut: realtime# false result# " << msg->Result->ToString() 
-                << " Marker# BSVSLR03"); 
+                << "TEvVPut: realtime# false result# " << msg->Result->ToString()
+                << " Marker# BSVSLR03");
         SendVDiskResponse(ctx, msg->OrigClient, msg->Result.release(), actor, msg->OrigCookie);
     }
 
@@ -140,8 +140,8 @@ namespace NKikimr {
         hull.AddBlockCmd(ctx, TabletId, Gen, IssuerGuid, Seg.Point(), replySender);
 
         LOG_DEBUG_S(ctx, NKikimrServices::BS_VDISK_BLOCK, hull.GetHullCtx()->VCtx->VDiskLogPrefix
-                << "TEvVBlock: result# " << Result->ToString() 
-                << " Marker# BSVSLR04"); 
+                << "TEvVBlock: result# " << Result->ToString()
+                << " Marker# BSVSLR04");
         SendVDiskResponse(ctx, Recipient, Result.release(), actor, RecipientCookie);
     }
 
@@ -165,8 +165,8 @@ namespace NKikimr {
         hull.AddGCCmd(ctx, record, Ingress, Seg);
 
         LOG_DEBUG_S(ctx, NKikimrServices::BS_VDISK_GC, hull.GetHullCtx()->VCtx->VDiskLogPrefix
-                << "TEvVCollectGarbage: result# " << Result->ToString() 
-                << " Marker# BSVSLR05"); 
+                << "TEvVCollectGarbage: result# " << Result->ToString()
+                << " Marker# BSVSLR05");
         SendVDiskResponse(ctx, OrigEv->Sender, Result.release(), actor, OrigEv->Cookie);
     }
 
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.h b/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.h
index 33ad29d596..50a7a06d2a 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.h
@@ -1,6 +1,6 @@
 #pragma once
 #include "defs.h"
-#include "skeleton_vmultiput_actor.h" 
+#include "skeleton_vmultiput_actor.h"
 #include <ydb/core/blobstorage/vdisk/common/vdisk_private_events.h>
 #include <ydb/core/blobstorage/vdisk/hulldb/hulldb_bulksst_add.h>
 #include <ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_localwriter.h>
@@ -62,25 +62,25 @@ namespace NKikimr {
     };
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////////
-    // TLoggedRecVMultiPutItem -- incapsulates TEvVMultiPut item replay action (for small blobs) 
-    /////////////////////////////////////////////////////////////////////////////////////////////////////// 
-    class TLoggedRecVMultiPutItem : public ILoggedRec { 
-    public: 
-        TLoggedRecVMultiPutItem(TLsnSeg seg, bool confirmSyncLogAlso, const TLogoBlobID &id, const TIngress &ingress, 
+    // TLoggedRecVMultiPutItem -- incapsulates TEvVMultiPut item replay action (for small blobs)
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////
+    class TLoggedRecVMultiPutItem : public ILoggedRec {
+    public:
+        TLoggedRecVMultiPutItem(TLsnSeg seg, bool confirmSyncLogAlso, const TLogoBlobID &id, const TIngress &ingress,
                 TRope &&buffer, std::unique_ptr<TEvVMultiPutItemResult> result, const TActorId &recipient,
-                ui64 recipientCookie); 
-        void Replay(THull &hull, const TActorContext &ctx, const IActor& actor) override; 
- 
-    private: 
-        TLogoBlobID Id; 
-        TIngress Ingress; 
-        TRope Buffer; 
+                ui64 recipientCookie);
+        void Replay(THull &hull, const TActorContext &ctx, const IActor& actor) override;
+
+    private:
+        TLogoBlobID Id;
+        TIngress Ingress;
+        TRope Buffer;
         std::unique_ptr<TEvVMultiPutItemResult> Result;
         TActorId Recipient;
-        ui64 RecipientCookie; 
-    }; 
- 
-    /////////////////////////////////////////////////////////////////////////////////////////////////////// 
+        ui64 RecipientCookie;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////
     // TLoggedRecVPut -- incapsulates TEvVPut replay action (for huge blobs)
     ///////////////////////////////////////////////////////////////////////////////////////////////////////
     class TLoggedRecVPutHuge : public ILoggedRec {
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_logic.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_logic.cpp
index 5bc3e10b05..5592abd5c0 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_logic.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_logic.cpp
@@ -132,8 +132,8 @@ namespace NKikimr {
 
     TOutOfSpaceLogic::~TOutOfSpaceLogic() {}
 
-    template <typename TPutEventPtr> 
-    bool AllowImpl(const TOutOfSpaceLogic &logic, const TActorContext &ctx, TPutEventPtr &ev) { 
+    template <typename TPutEventPtr>
+    bool AllowImpl(const TOutOfSpaceLogic &logic, const TActorContext &ctx, TPutEventPtr &ev) {
         Y_UNUSED(ctx);
         auto color = logic.VCtx->GetOutOfSpaceState().GetGlobalColor();
         auto &stat = logic.Stat->Lookup(TOutOfSpaceLogic::TStat::Put, color).HandleMsg(ev->Get()->GetCachedByteSize());
@@ -147,7 +147,7 @@ namespace NKikimr {
             case TSpaceColor::ORANGE:
             {
                 // allow writes with IgnoreBlock=true
-                auto &record = ev->Get()->Record; 
+                auto &record = ev->Get()->Record;
                 const bool allow = record.GetIgnoreBlock();
                 return stat.Pass(allow);
             }
@@ -159,14 +159,14 @@ namespace NKikimr {
         }
     }
 
-    bool TOutOfSpaceLogic::Allow(const TActorContext &ctx, TEvBlobStorage::TEvVPut::TPtr &ev) const { 
-        return AllowImpl(*this, ctx, ev); 
-    } 
- 
-    bool TOutOfSpaceLogic::Allow(const TActorContext &ctx, TEvBlobStorage::TEvVMultiPut::TPtr &ev) const { 
-        return AllowImpl(*this, ctx, ev); 
-    } 
- 
+    bool TOutOfSpaceLogic::Allow(const TActorContext &ctx, TEvBlobStorage::TEvVPut::TPtr &ev) const {
+        return AllowImpl(*this, ctx, ev);
+    }
+
+    bool TOutOfSpaceLogic::Allow(const TActorContext &ctx, TEvBlobStorage::TEvVMultiPut::TPtr &ev) const {
+        return AllowImpl(*this, ctx, ev);
+    }
+
     bool TOutOfSpaceLogic::Allow(const TActorContext &ctx, TEvBlobStorage::TEvVBlock::TPtr &ev) const {
         Y_UNUSED(ctx);
         auto color = VCtx->GetOutOfSpaceState().GetGlobalColor();
@@ -227,16 +227,16 @@ namespace NKikimr {
                 if (msg->IsAnubis()) {
                     LOG_ERROR_S(ctx, NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix
                             << "OUT OF SPACE while removing LogoBlob we got from Anubis;"
-                            << " LogoBlobId# " << msg->LogoBlobId 
-                            << " Marker# BSVSOOSL01"); 
+                            << " LogoBlobId# " << msg->LogoBlobId
+                            << " Marker# BSVSOOSL01");
                     return stat.NotAllow();
                 } else {
                     // We MUST allow Osiris writes. W/o Osiris we can't work.
                     // There should not be too much of them.
                     LOG_ERROR_S(ctx, NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix
                             << "OUT OF SPACE while adding resurrected by Osiris LogoBlob;"
-                            << " FORCING addition: LogoBlobId# " << msg->LogoBlobId 
-                            << " Marker# BSVSOOSL02"); 
+                            << " FORCING addition: LogoBlobId# " << msg->LogoBlobId
+                            << " Marker# BSVSOOSL02");
                     return stat.Allow();
                 }
             }
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_logic.h b/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_logic.h
index 7963f07ede..8def77caa1 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_logic.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_logic.h
@@ -21,7 +21,7 @@ namespace NKikimr {
 
         // Check if we allow this write
         bool Allow(const TActorContext &ctx, TEvBlobStorage::TEvVPut::TPtr &ev) const;
-        bool Allow(const TActorContext &ctx, TEvBlobStorage::TEvVMultiPut::TPtr &ev) const; 
+        bool Allow(const TActorContext &ctx, TEvBlobStorage::TEvVMultiPut::TPtr &ev) const;
         bool Allow(const TActorContext &ctx, TEvBlobStorage::TEvVBlock::TPtr &ev) const;
         bool Allow(const TActorContext &ctx, TEvBlobStorage::TEvVCollectGarbage::TPtr &ev) const;
         bool Allow(const TActorContext &ctx, TEvLocalSyncData::TPtr &ev) const;
@@ -38,9 +38,9 @@ namespace NKikimr {
         mutable std::unique_ptr<TStat> Stat;
 
         bool DefaultAllow(ESpaceColor color) const;
- 
-        template <typename TEvPtr> 
-        friend bool AllowImpl(const TOutOfSpaceLogic &logic, const TActorContext &ctx, TEvPtr &ev); 
+
+        template <typename TEvPtr>
+        friend bool AllowImpl(const TOutOfSpaceLogic &logic, const TActorContext &ctx, TEvPtr &ev);
     };
 
 } // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_tracker.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_tracker.cpp
index 925fbd00c3..8af5bd8dc2 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_tracker.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_oos_tracker.cpp
@@ -75,8 +75,8 @@ namespace NKikimr {
         void Handle(NPDisk::TEvCheckSpaceResult::TPtr &ev, const TActorContext &ctx) {
             const auto *msg = ev->Get();
             LOG_DEBUG_S(ctx, NKikimrServices::BS_SKELETON, VCtx->VDiskLogPrefix
-                    << "TDskSpaceTrackerActor:handle TEvCheckSpaceResult; msg# " << msg->ToString() 
-                    << " Marker# BSVSOOST02"); 
+                    << "TDskSpaceTrackerActor:handle TEvCheckSpaceResult; msg# " << msg->ToString()
+                    << " Marker# BSVSOOST02");
 
             CHECK_PDISK_RESPONSE(VCtx, ev, ctx);
 
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.cpp
index 169322f913..45968b8d54 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.cpp
@@ -27,8 +27,8 @@ namespace NKikimr {
 
         NMonGroup::TSkeletonOverloadGroup &Mon;
         TQueueType Queue;
-        TVMovedPatchHandler VMovedPatchHandler; 
-        TVPatchStartHandler VPatchStartHandler; 
+        TVMovedPatchHandler VMovedPatchHandler;
+        TVPatchStartHandler VPatchStartHandler;
         TVPutHandler VPutHandler;
         TVMultiPutHandler VMultiPutHandler;
         TLocalSyncDataHandler LocalSyncDataHandler;
@@ -37,33 +37,33 @@ namespace NKikimr {
     public:
         TEmergencyQueue(
                 NMonGroup::TSkeletonOverloadGroup &mon,
-                TVMovedPatchHandler &&vMovedPatch, 
-                TVPatchStartHandler &&vPatchStart, 
+                TVMovedPatchHandler &&vMovedPatch,
+                TVPatchStartHandler &&vPatchStart,
                 TVPutHandler &&vput,
                 TVMultiPutHandler &&vMultiPut,
                 TLocalSyncDataHandler &&loc,
                 TAnubisOsirisPutHandler &&aoput)
             : Mon(mon)
-            , VMovedPatchHandler(std::move(vMovedPatch)) 
-            , VPatchStartHandler(std::move(vPatchStart)) 
+            , VMovedPatchHandler(std::move(vMovedPatch))
+            , VPatchStartHandler(std::move(vPatchStart))
             , VPutHandler(std::move(vput))
             , VMultiPutHandler(std::move(vMultiPut))
             , LocalSyncDataHandler(std::move(loc))
             , AnubisOsirisPutHandler(std::move(aoput))
         {}
 
-        void Push(TEvBlobStorage::TEvVMovedPatch::TPtr ev) { 
-            ++Mon.EmergencyMovedPatchQueueItems(); 
-            Mon.EmergencyMovedPatchQueueBytes() += ev->Get()->Record.ByteSize(); 
-            Queue.Push(TItem(ev)); 
-        } 
- 
-        void Push(TEvBlobStorage::TEvVPatchStart::TPtr ev) { 
-            ++Mon.EmergencyPatchStartQueueItems(); 
-            Mon.EmergencyPatchStartQueueBytes() += ev->Get()->Record.ByteSize(); 
-            Queue.Push(TItem(ev)); 
-        } 
- 
+        void Push(TEvBlobStorage::TEvVMovedPatch::TPtr ev) {
+            ++Mon.EmergencyMovedPatchQueueItems();
+            Mon.EmergencyMovedPatchQueueBytes() += ev->Get()->Record.ByteSize();
+            Queue.Push(TItem(ev));
+        }
+
+        void Push(TEvBlobStorage::TEvVPatchStart::TPtr ev) {
+            ++Mon.EmergencyPatchStartQueueItems();
+            Mon.EmergencyPatchStartQueueBytes() += ev->Get()->Record.ByteSize();
+            Queue.Push(TItem(ev));
+        }
+
         void Push(TEvBlobStorage::TEvVPut::TPtr ev) {
             ++Mon.EmergencyPutQueueItems();
             Mon.EmergencyPutQueueBytes() += ev->Get()->Record.ByteSize();
@@ -71,8 +71,8 @@ namespace NKikimr {
         }
 
         void Push(TEvBlobStorage::TEvVMultiPut::TPtr ev) {
-            ++Mon.EmergencyMultiPutQueueItems(); 
-            Mon.EmergencyMultiPutQueueBytes() += ev->Get()->Record.ByteSize(); 
+            ++Mon.EmergencyMultiPutQueueItems();
+            Mon.EmergencyMultiPutQueueBytes() += ev->Get()->Record.ByteSize();
             Queue.Push(TItem(ev));
         }
 
@@ -98,20 +98,20 @@ namespace NKikimr {
             TAutoPtr<IEventHandle> ev = item->Ev.release();
             Queue.Pop();
             switch (ev->GetTypeRewrite()) {
-                case TEvBlobStorage::EvVMovedPatch: { 
-                    auto *evMovedPatch = reinterpret_cast<TEvBlobStorage::TEvVMovedPatch::TPtr*>(&ev); 
-                    --Mon.EmergencyMovedPatchQueueItems(); 
-                    Mon.EmergencyMovedPatchQueueBytes() -= (*evMovedPatch)->Get()->Record.ByteSize(); 
-                    VMovedPatchHandler(ctx, *evMovedPatch); 
-                    break; 
-                } 
-                case TEvBlobStorage::EvVPatchStart: { 
-                    auto *evPatchStart = reinterpret_cast<TEvBlobStorage::TEvVPatchStart::TPtr*>(&ev); 
-                    --Mon.EmergencyPatchStartQueueItems(); 
-                    Mon.EmergencyPatchStartQueueBytes() -= (*evPatchStart)->Get()->Record.ByteSize(); 
-                    VPatchStartHandler(ctx, *evPatchStart); 
-                    break; 
-                } 
+                case TEvBlobStorage::EvVMovedPatch: {
+                    auto *evMovedPatch = reinterpret_cast<TEvBlobStorage::TEvVMovedPatch::TPtr*>(&ev);
+                    --Mon.EmergencyMovedPatchQueueItems();
+                    Mon.EmergencyMovedPatchQueueBytes() -= (*evMovedPatch)->Get()->Record.ByteSize();
+                    VMovedPatchHandler(ctx, *evMovedPatch);
+                    break;
+                }
+                case TEvBlobStorage::EvVPatchStart: {
+                    auto *evPatchStart = reinterpret_cast<TEvBlobStorage::TEvVPatchStart::TPtr*>(&ev);
+                    --Mon.EmergencyPatchStartQueueItems();
+                    Mon.EmergencyPatchStartQueueBytes() -= (*evPatchStart)->Get()->Record.ByteSize();
+                    VPatchStartHandler(ctx, *evPatchStart);
+                    break;
+                }
                 case TEvBlobStorage::EvVPut: {
                     auto *evPut = reinterpret_cast<TEvBlobStorage::TEvVPut::TPtr*>(&ev);
                     --Mon.EmergencyPutQueueItems();
@@ -154,16 +154,16 @@ namespace NKikimr {
             const TPDiskCtxPtr &pdiskCtx,
             std::shared_ptr<THull> hull,
             NMonGroup::TSkeletonOverloadGroup &&mon,
-            TVMovedPatchHandler &&vMovedPatch, 
-            TVPatchStartHandler &&vPatchStart, 
+            TVMovedPatchHandler &&vMovedPatch,
+            TVPatchStartHandler &&vPatchStart,
             TVPutHandler &&vput,
             TVMultiPutHandler &&vMultiPut,
             TLocalSyncDataHandler &&loc,
             TAnubisOsirisPutHandler &&aoput)
         : Hull(std::move(hull))
         , Mon(std::move(mon))
-        , EmergencyQueue(new TEmergencyQueue(Mon, std::move(vMovedPatch), std::move(vPatchStart), std::move(vput), 
-                std::move(vMultiPut), std::move(loc), std::move(aoput))) 
+        , EmergencyQueue(new TEmergencyQueue(Mon, std::move(vMovedPatch), std::move(vPatchStart), std::move(vput),
+                std::move(vMultiPut), std::move(loc), std::move(aoput)))
         , DynamicPDiskWeightsManager(std::make_shared<TDynamicPDiskWeightsManager>(vctx, pdiskCtx))
     {}
 
@@ -210,14 +210,14 @@ namespace NKikimr {
         return proceedFurther;
     }
 
-    bool TOverloadHandler::PostponeEvent(TEvBlobStorage::TEvVMovedPatch::TPtr &ev, const TActorContext &ctx, IActor *skeleton) { 
-        return PostponeEventPrivate(ev, ctx, skeleton); 
-    } 
- 
-    bool TOverloadHandler::PostponeEvent(TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TActorContext &ctx, IActor *skeleton) { 
-        return PostponeEventPrivate(ev, ctx, skeleton); 
-    } 
- 
+    bool TOverloadHandler::PostponeEvent(TEvBlobStorage::TEvVMovedPatch::TPtr &ev, const TActorContext &ctx, IActor *skeleton) {
+        return PostponeEventPrivate(ev, ctx, skeleton);
+    }
+
+    bool TOverloadHandler::PostponeEvent(TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TActorContext &ctx, IActor *skeleton) {
+        return PostponeEventPrivate(ev, ctx, skeleton);
+    }
+
     bool TOverloadHandler::PostponeEvent(TEvBlobStorage::TEvVPut::TPtr &ev, const TActorContext &ctx, IActor *skeleton) {
         return PostponeEventPrivate(ev, ctx, skeleton);
     }
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.h b/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.h
index 8d84422f93..00707bb803 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.h
@@ -36,10 +36,10 @@ namespace NKikimr {
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Handlers for postponed events
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-    using TVMovedPatchHandler = std::function<void(const TActorContext &ctx, 
-            TEvBlobStorage::TEvVMovedPatch::TPtr ev)>; 
-    using TVPatchStartHandler = std::function<void(const TActorContext &ctx, 
-            TEvBlobStorage::TEvVPatchStart::TPtr ev)>; 
+    using TVMovedPatchHandler = std::function<void(const TActorContext &ctx,
+            TEvBlobStorage::TEvVMovedPatch::TPtr ev)>;
+    using TVPatchStartHandler = std::function<void(const TActorContext &ctx,
+            TEvBlobStorage::TEvVPatchStart::TPtr ev)>;
     using TVPutHandler = std::function<void(const TActorContext &ctx,
             TEvBlobStorage::TEvVPut::TPtr ev)>;
     using TVMultiPutHandler = std::function<void(const TActorContext &ctx,
@@ -63,8 +63,8 @@ namespace NKikimr {
                 const TPDiskCtxPtr &pdiskCtx,
                 std::shared_ptr<THull> hull,
                 NMonGroup::TSkeletonOverloadGroup &&mon,
-                TVMovedPatchHandler &&vMovedPatch, 
-                TVPatchStartHandler &&vPatchStart, 
+                TVMovedPatchHandler &&vMovedPatch,
+                TVPatchStartHandler &&vPatchStart,
                 TVPutHandler &&vput,
                 TVMultiPutHandler &&vMultiPut,
                 TLocalSyncDataHandler &&loc,
@@ -78,8 +78,8 @@ namespace NKikimr {
         bool ProcessPostponedEvents(const TActorContext &ctx, int batchSize, bool actualizeLevels);
 
         // Postpone event in case of overload
-        bool PostponeEvent(TEvBlobStorage::TEvVMovedPatch::TPtr &ev, const TActorContext &ctx, IActor *skeleton); 
-        bool PostponeEvent(TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TActorContext &ctx, IActor *skeleton); 
+        bool PostponeEvent(TEvBlobStorage::TEvVMovedPatch::TPtr &ev, const TActorContext &ctx, IActor *skeleton);
+        bool PostponeEvent(TEvBlobStorage::TEvVPatchStart::TPtr &ev, const TActorContext &ctx, IActor *skeleton);
         bool PostponeEvent(TEvBlobStorage::TEvVPut::TPtr &ev, const TActorContext &ctx, IActor *skeleton);
         bool PostponeEvent(TEvBlobStorage::TEvVMultiPut::TPtr &ev, const TActorContext &ctx, IActor *skeleton);
         bool PostponeEvent(TEvLocalSyncData::TPtr &ev, const TActorContext &ctx, IActor *skeleton);
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.cpp
index cc55bb6038..cc24115b3f 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.cpp
@@ -1,208 +1,208 @@
-#include "skeleton_vmovedpatch_actor.h" 
- 
+#include "skeleton_vmovedpatch_actor.h"
+
 #include <ydb/core/blobstorage/vdisk/common/vdisk_response.h>
- 
- 
-namespace NKikimr { 
-    namespace NPrivate { 
- 
-        class TVMovedPatchActor : public TActorBootstrapped<TVMovedPatchActor> { 
-            friend TActorBootstrapped<TVMovedPatchActor>; 
- 
-            static constexpr ui64 SubRequestDurationMs = 1000; 
- 
-            ui32 OriginalGroupId; 
-            ui32 PatchedGroupId; 
-            TLogoBlobID OriginalId; 
-            TLogoBlobID PatchedId; 
- 
-            TString Buffer; 
-            TString ErrorReason; 
- 
-            ui32 DiffCount = 0; 
+
+
+namespace NKikimr {
+    namespace NPrivate {
+
+        class TVMovedPatchActor : public TActorBootstrapped<TVMovedPatchActor> {
+            friend TActorBootstrapped<TVMovedPatchActor>;
+
+            static constexpr ui64 SubRequestDurationMs = 1000;
+
+            ui32 OriginalGroupId;
+            ui32 PatchedGroupId;
+            TLogoBlobID OriginalId;
+            TLogoBlobID PatchedId;
+
+            TString Buffer;
+            TString ErrorReason;
+
+            ui32 DiffCount = 0;
             std::unique_ptr<TEvBlobStorage::TEvPatch::TDiff[]> Diffs;
- 
-            TActorIDPtr SkeletonFrontIDPtr; 
-            NMonitoring::TDynamicCounters::TCounterPtr MovedPatchResMsgsPtr; 
- 
-            TEvBlobStorage::TEvVMovedPatch::TPtr Event; 
+
+            TActorIDPtr SkeletonFrontIDPtr;
+            NMonitoring::TDynamicCounters::TCounterPtr MovedPatchResMsgsPtr;
+
+            TEvBlobStorage::TEvVMovedPatch::TPtr Event;
             TActorId LeaderId;
-            TOutOfSpaceStatus OOSStatus; 
- 
- 
-            NWilson::TTraceId TraceId; 
-            NLWTrace::TOrbit Orbit; 
- 
-            const ui64 IncarnationGuid; 
- 
-            TVDiskContextPtr VCtx; 
- 
-        public: 
+            TOutOfSpaceStatus OOSStatus;
+
+
+            NWilson::TTraceId TraceId;
+            NLWTrace::TOrbit Orbit;
+
+            const ui64 IncarnationGuid;
+
+            TVDiskContextPtr VCtx;
+
+        public:
             TVMovedPatchActor(TActorId leaderId, TOutOfSpaceStatus oosStatus, TEvBlobStorage::TEvVMovedPatch::TPtr &ev,
-                    TActorIDPtr skeletonFrontIDPtr, NMonitoring::TDynamicCounters::TCounterPtr movedPatchResMsgsPtr, 
-                    ui64 incarnationGuid, const TVDiskContextPtr &vCtx) 
-                : TActorBootstrapped() 
-                , SkeletonFrontIDPtr(skeletonFrontIDPtr) 
-                , MovedPatchResMsgsPtr(movedPatchResMsgsPtr) 
-                , Event(ev) 
+                    TActorIDPtr skeletonFrontIDPtr, NMonitoring::TDynamicCounters::TCounterPtr movedPatchResMsgsPtr,
+                    ui64 incarnationGuid, const TVDiskContextPtr &vCtx)
+                : TActorBootstrapped()
+                , SkeletonFrontIDPtr(skeletonFrontIDPtr)
+                , MovedPatchResMsgsPtr(movedPatchResMsgsPtr)
+                , Event(ev)
                 , LeaderId(leaderId)
-                , OOSStatus(oosStatus) 
-                , IncarnationGuid(incarnationGuid) 
-                , VCtx(vCtx) 
-            { 
-                NKikimrBlobStorage::TEvVMovedPatch &record = Event->Get()->Record; 
-                Y_VERIFY(record.HasOriginalGroupId()); 
-                OriginalGroupId = record.GetOriginalGroupId(); 
-                Y_VERIFY(record.HasPatchedGroupId()); 
-                PatchedGroupId = record.GetPatchedGroupId(); 
-                Y_VERIFY(record.HasOriginalBlobId()); 
-                OriginalId = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId()); 
-                Y_VERIFY(record.HasPatchedBlobId()); 
-                PatchedId = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId()); 
- 
-                DiffCount = record.DiffsSize(); 
+                , OOSStatus(oosStatus)
+                , IncarnationGuid(incarnationGuid)
+                , VCtx(vCtx)
+            {
+                NKikimrBlobStorage::TEvVMovedPatch &record = Event->Get()->Record;
+                Y_VERIFY(record.HasOriginalGroupId());
+                OriginalGroupId = record.GetOriginalGroupId();
+                Y_VERIFY(record.HasPatchedGroupId());
+                PatchedGroupId = record.GetPatchedGroupId();
+                Y_VERIFY(record.HasOriginalBlobId());
+                OriginalId = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId());
+                Y_VERIFY(record.HasPatchedBlobId());
+                PatchedId = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId());
+
+                DiffCount = record.DiffsSize();
                 Diffs.reset(new TEvBlobStorage::TEvPatch::TDiff[DiffCount]);
-                for (ui32 idx = 0; idx < DiffCount; ++idx) { 
-                    const NKikimrBlobStorage::TDiffBlock &diff = record.GetDiffs(idx); 
-                    Y_VERIFY(diff.HasOffset()); 
-                    Diffs[idx].Offset = diff.GetOffset(); 
-                    Y_VERIFY(diff.HasBuffer()); 
-                    Diffs[idx].Buffer = diff.GetBuffer(); 
-                } 
-            } 
- 
-        private: 
-            void SendResponseAndDie(const TActorContext &ctx, NKikimrProto::EReplyStatus status, 
-                    const TString &errorSubMsg = "") 
-            { 
-                NKikimrBlobStorage::TEvVMovedPatch &record = Event->Get()->Record; 
-                TVDiskID vdisk = VDiskIDFromVDiskID(record.GetVDiskID()); 
- 
-                TMaybe<ui64> cookie; 
-                if (record.HasCookie()) { 
-                    cookie = record.GetCookie(); 
-                } 
- 
-                TInstant now = TAppData::TimeProvider->Now(); 
+                for (ui32 idx = 0; idx < DiffCount; ++idx) {
+                    const NKikimrBlobStorage::TDiffBlock &diff = record.GetDiffs(idx);
+                    Y_VERIFY(diff.HasOffset());
+                    Diffs[idx].Offset = diff.GetOffset();
+                    Y_VERIFY(diff.HasBuffer());
+                    Diffs[idx].Buffer = diff.GetBuffer();
+                }
+            }
+
+        private:
+            void SendResponseAndDie(const TActorContext &ctx, NKikimrProto::EReplyStatus status,
+                    const TString &errorSubMsg = "")
+            {
+                NKikimrBlobStorage::TEvVMovedPatch &record = Event->Get()->Record;
+                TVDiskID vdisk = VDiskIDFromVDiskID(record.GetVDiskID());
+
+                TMaybe<ui64> cookie;
+                if (record.HasCookie()) {
+                    cookie = record.GetCookie();
+                }
+
+                TInstant now = TAppData::TimeProvider->Now();
                 auto vMovedPatchResult = std::make_unique<TEvBlobStorage::TEvVMovedPatchResult>(status, OriginalId,
-                        PatchedId, vdisk, cookie, OOSStatus, now, Event->Get()->GetCachedByteSize(), &record, 
-                        SkeletonFrontIDPtr, MovedPatchResMsgsPtr, nullptr, std::move(TraceId), IncarnationGuid, 
-                        ErrorReason); 
-                vMovedPatchResult->Orbit = std::move(Orbit); 
- 
-                if (status == NKikimrProto::ERROR) { 
-                    LOG_ERROR_S(ctx, NKikimrServices::BS_VDISK_PATCH, VCtx->VDiskLogPrefix 
-                            << "TEvVMovedPatch: " << errorSubMsg << ';' 
-                            << " OriginalBlobId# " << OriginalId 
-                            << " PatchedBlobId# " << PatchedId 
-                            << " ErrorReason# " << ErrorReason 
-                            << " Marker# BSVSP01"); 
-                } 
+                        PatchedId, vdisk, cookie, OOSStatus, now, Event->Get()->GetCachedByteSize(), &record,
+                        SkeletonFrontIDPtr, MovedPatchResMsgsPtr, nullptr, std::move(TraceId), IncarnationGuid,
+                        ErrorReason);
+                vMovedPatchResult->Orbit = std::move(Orbit);
+
+                if (status == NKikimrProto::ERROR) {
+                    LOG_ERROR_S(ctx, NKikimrServices::BS_VDISK_PATCH, VCtx->VDiskLogPrefix
+                            << "TEvVMovedPatch: " << errorSubMsg << ';'
+                            << " OriginalBlobId# " << OriginalId
+                            << " PatchedBlobId# " << PatchedId
+                            << " ErrorReason# " << ErrorReason
+                            << " Marker# BSVSP01");
+                }
                 SendVDiskResponse(ctx, Event->Sender, vMovedPatchResult.release(), *this, Event->Cookie);
-                PassAway(); 
-            } 
- 
-            void ApplyDiffs() { 
-                for (ui32 idx = 0; idx < DiffCount; ++idx) { 
-                    const TEvBlobStorage::TEvPatch::TDiff &diff = Diffs[idx]; 
-                    memcpy(Buffer.begin() + diff.Offset, diff.Buffer.begin(), diff.Buffer.size()); 
-                } 
-            } 
- 
-            void Handle(TEvBlobStorage::TEvGetResult::TPtr &ev, const TActorContext &ctx) { 
-                TEvBlobStorage::TEvGetResult *result = ev->Get(); 
-                Orbit = std::move(result->Orbit); 
-                TraceId = std::move(ev->TraceId); 
- 
-                ui32 patchedIdHash = PatchedId.Hash(); 
- 
-                constexpr auto errorSubMsg = "failed on VGet"; 
-                if (ev->Cookie != patchedIdHash) { 
-                    ErrorReason = "Couldn't get the original blob; Received TEvGetResult with wrong cookie"; 
-                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg); 
-                    return; 
-                } else if (result->ResponseSz > 1) { 
-                    ErrorReason = "Couldn't get the original blob; Received TEvGetResult with more responses than needed"; 
-                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg); 
-                    return; 
-                } else if (result->Status != NKikimrProto::OK || result->ResponseSz != 1 || result->Responses[0].Status != NKikimrProto::OK) { 
-                    TString getResponseStatus; 
-                    if (result->ResponseSz == 1) { 
-                        getResponseStatus = TStringBuilder() << " GetResponseStatus# " 
-                                << NKikimrProto::EReplyStatus_Name(result->Responses[0].Status); 
-                    } 
-                    ErrorReason = TStringBuilder() << "Couldn't get the original blob;" 
-                            << " GetStatus# " << NKikimrProto::EReplyStatus_Name(result->Status) 
-                            << getResponseStatus 
-                            << " GetErrorReason# " << result->ErrorReason; 
-                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg); 
-                    return; 
-                } 
- 
-                Buffer = result->Responses[0].Buffer; 
-                ApplyDiffs(); 
-                TInstant deadline = TActivationContext::Now() + TDuration::MilliSeconds(SubRequestDurationMs); 
- 
-                // We have chosen UserData as PutHandleClass on purpose. 
-                // If VMovedPatch and Put were AsyncWrite, it would become a deadlock 
-                // because the put subrequest may not send and the moved patch request will end by timeout. 
+                PassAway();
+            }
+
+            void ApplyDiffs() {
+                for (ui32 idx = 0; idx < DiffCount; ++idx) {
+                    const TEvBlobStorage::TEvPatch::TDiff &diff = Diffs[idx];
+                    memcpy(Buffer.begin() + diff.Offset, diff.Buffer.begin(), diff.Buffer.size());
+                }
+            }
+
+            void Handle(TEvBlobStorage::TEvGetResult::TPtr &ev, const TActorContext &ctx) {
+                TEvBlobStorage::TEvGetResult *result = ev->Get();
+                Orbit = std::move(result->Orbit);
+                TraceId = std::move(ev->TraceId);
+
+                ui32 patchedIdHash = PatchedId.Hash();
+
+                constexpr auto errorSubMsg = "failed on VGet";
+                if (ev->Cookie != patchedIdHash) {
+                    ErrorReason = "Couldn't get the original blob; Received TEvGetResult with wrong cookie";
+                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg);
+                    return;
+                } else if (result->ResponseSz > 1) {
+                    ErrorReason = "Couldn't get the original blob; Received TEvGetResult with more responses than needed";
+                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg);
+                    return;
+                } else if (result->Status != NKikimrProto::OK || result->ResponseSz != 1 || result->Responses[0].Status != NKikimrProto::OK) {
+                    TString getResponseStatus;
+                    if (result->ResponseSz == 1) {
+                        getResponseStatus = TStringBuilder() << " GetResponseStatus# "
+                                << NKikimrProto::EReplyStatus_Name(result->Responses[0].Status);
+                    }
+                    ErrorReason = TStringBuilder() << "Couldn't get the original blob;"
+                            << " GetStatus# " << NKikimrProto::EReplyStatus_Name(result->Status)
+                            << getResponseStatus
+                            << " GetErrorReason# " << result->ErrorReason;
+                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg);
+                    return;
+                }
+
+                Buffer = result->Responses[0].Buffer;
+                ApplyDiffs();
+                TInstant deadline = TActivationContext::Now() + TDuration::MilliSeconds(SubRequestDurationMs);
+
+                // We have chosen UserData as PutHandleClass on purpose.
+                // If VMovedPatch and Put were AsyncWrite, it would become a deadlock
+                // because the put subrequest may not send and the moved patch request will end by timeout.
                 std::unique_ptr<TEvBlobStorage::TEvPut> put = std::make_unique<TEvBlobStorage::TEvPut>(PatchedId, Buffer, deadline,
-                        NKikimrBlobStorage::UserData, TEvBlobStorage::TEvPut::TacticDefault); 
-                put->Orbit = std::move(Orbit); 
- 
+                        NKikimrBlobStorage::UserData, TEvBlobStorage::TEvPut::TacticDefault);
+                put->Orbit = std::move(Orbit);
+
                 SendToBSProxy(SelfId(), PatchedGroupId, put.release(), OriginalId.Hash(), std::move(Event->TraceId));
-            } 
- 
-            void Handle(TEvBlobStorage::TEvPutResult::TPtr &ev, const TActorContext &ctx) { 
-                TEvBlobStorage::TEvPutResult *result = ev->Get(); 
-                Orbit = std::move(result->Orbit); 
-                TraceId = std::move(ev->TraceId); 
- 
-                ui32 originalIdHash = OriginalId.Hash(); 
- 
-                constexpr auto errorSubMsg = "failed on VPut"; 
-                if (ev->Cookie != originalIdHash) { 
-                    ErrorReason = "Couldn't put the patched blob; Received TEvPutResult with wrong cookie"; 
-                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg); 
-                    return; 
-                } else if (result->Status != NKikimrProto::OK) { 
-                    ErrorReason = TStringBuilder() << "Couldn't put the patched blob;" 
-                            << " PutStatus# " << NKikimrProto::EReplyStatus_Name(result->Status) 
-                            << " PutErrorReason# " << result->ErrorReason; 
-                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg); 
-                    return; 
-                } 
- 
-                SendResponseAndDie(ctx, NKikimrProto::OK); 
-            } 
- 
-            void Bootstrap() { 
-                TInstant deadline = TActivationContext::Now() + TDuration::MilliSeconds(SubRequestDurationMs); 
+            }
+
+            void Handle(TEvBlobStorage::TEvPutResult::TPtr &ev, const TActorContext &ctx) {
+                TEvBlobStorage::TEvPutResult *result = ev->Get();
+                Orbit = std::move(result->Orbit);
+                TraceId = std::move(ev->TraceId);
+
+                ui32 originalIdHash = OriginalId.Hash();
+
+                constexpr auto errorSubMsg = "failed on VPut";
+                if (ev->Cookie != originalIdHash) {
+                    ErrorReason = "Couldn't put the patched blob; Received TEvPutResult with wrong cookie";
+                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg);
+                    return;
+                } else if (result->Status != NKikimrProto::OK) {
+                    ErrorReason = TStringBuilder() << "Couldn't put the patched blob;"
+                            << " PutStatus# " << NKikimrProto::EReplyStatus_Name(result->Status)
+                            << " PutErrorReason# " << result->ErrorReason;
+                    SendResponseAndDie(ctx, NKikimrProto::ERROR, errorSubMsg);
+                    return;
+                }
+
+                SendResponseAndDie(ctx, NKikimrProto::OK);
+            }
+
+            void Bootstrap() {
+                TInstant deadline = TActivationContext::Now() + TDuration::MilliSeconds(SubRequestDurationMs);
                 std::unique_ptr<TEvBlobStorage::TEvGet> get = std::make_unique<TEvBlobStorage::TEvGet>(OriginalId, 0,
-                        OriginalId.BlobSize(), deadline, NKikimrBlobStorage::AsyncRead); 
-                get->Orbit = std::move(Event->Get()->Orbit); 
- 
+                        OriginalId.BlobSize(), deadline, NKikimrBlobStorage::AsyncRead);
+                get->Orbit = std::move(Event->Get()->Orbit);
+
                 SendToBSProxy(SelfId(), OriginalGroupId, get.release(), PatchedId.Hash(), std::move(Event->TraceId));
-                Become(&TThis::StateWait); 
-            } 
- 
-            STFUNC(StateWait) { 
-                switch (ev->GetTypeRewrite()) { 
-                    HFunc(TEvBlobStorage::TEvGetResult, Handle); 
-                    HFunc(TEvBlobStorage::TEvPutResult, Handle); 
-                } 
-            } 
-        }; 
- 
-    } // NPrivate 
- 
+                Become(&TThis::StateWait);
+            }
+
+            STFUNC(StateWait) {
+                switch (ev->GetTypeRewrite()) {
+                    HFunc(TEvBlobStorage::TEvGetResult, Handle);
+                    HFunc(TEvBlobStorage::TEvPutResult, Handle);
+                }
+            }
+        };
+
+    } // NPrivate
+
     IActor* CreateSkeletonVMovedPatchActor(TActorId leaderId, TOutOfSpaceStatus oosStatus,
-            TEvBlobStorage::TEvVMovedPatch::TPtr &ev, TActorIDPtr skeletonFrontIDPtr, 
-            NMonitoring::TDynamicCounters::TCounterPtr counterPtr, ui64 incarnationGuid, 
-            const TVDiskContextPtr &vCtx) 
-    { 
+            TEvBlobStorage::TEvVMovedPatch::TPtr &ev, TActorIDPtr skeletonFrontIDPtr,
+            NMonitoring::TDynamicCounters::TCounterPtr counterPtr, ui64 incarnationGuid,
+            const TVDiskContextPtr &vCtx)
+    {
         return new NPrivate::TVMovedPatchActor(leaderId, oosStatus, ev, skeletonFrontIDPtr,
-                counterPtr, incarnationGuid, vCtx); 
-    } 
- 
-} // NKikimr 
+                counterPtr, incarnationGuid, vCtx);
+    }
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.h b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.h
index 396bc91ec9..91f8109385 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmovedpatch_actor.h
@@ -1,14 +1,14 @@
-#pragma once 
- 
-#include "defs.h" 
- 
+#pragma once
+
+#include "defs.h"
+
 #include <ydb/core/blobstorage/vdisk/common/vdisk_events.h>
- 
-namespace NKikimr { 
- 
+
+namespace NKikimr {
+
 IActor* CreateSkeletonVMovedPatchActor(TActorId leaderId, TOutOfSpaceStatus oosStatus,
-        TEvBlobStorage::TEvVMovedPatch::TPtr &ev, TActorIDPtr skeletonFrontIDPtr, 
-        NMonitoring::TDynamicCounters::TCounterPtr multiPutResMsgsPtr, 
-        ui64 incarnationGuid, const TVDiskContextPtr &vCtx); 
- 
-} // NKikimr 
+        TEvBlobStorage::TEvVMovedPatch::TPtr &ev, TActorIDPtr skeletonFrontIDPtr,
+        NMonitoring::TDynamicCounters::TCounterPtr multiPutResMsgsPtr,
+        ui64 incarnationGuid, const TVDiskContextPtr &vCtx);
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmultiput_actor.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmultiput_actor.cpp
index 526c4b48a7..ac7dcd7d58 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmultiput_actor.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmultiput_actor.cpp
@@ -2,7 +2,7 @@
 
 #include <ydb/core/blobstorage/vdisk/common/vdisk_response.h>
 #include <ydb/core/blobstorage/base/batched_vec.h>
- 
+
 namespace NKikimr {
     namespace NPrivate {
 
@@ -17,55 +17,55 @@ namespace NKikimr {
                 ui32 StatusFlags = 0;
                 bool Received = false;
                 bool HasCookie = false;
- 
-                TString ToString() const { 
-                    return TStringBuilder() 
-                        << "{" 
-                        << " Status# " << NKikimrProto::EReplyStatus_Name(Status) 
+
+                TString ToString() const {
+                    return TStringBuilder()
+                        << "{"
+                        << " Status# " << NKikimrProto::EReplyStatus_Name(Status)
                         << " ErrorReason# " << '"' << EscapeC(ErrorReason) << '"'
-                        << " BlobId# " << BlobId.ToString() 
-                        << " HasCookie# " << HasCookie 
-                        << " Cookie# " << Cookie 
-                        << " StatusFlags# " << NPDisk::StatusFlagsToString(StatusFlags) 
-                        << " Received# " << Received 
-                        << " }"; 
-                } 
+                        << " BlobId# " << BlobId.ToString()
+                        << " HasCookie# " << HasCookie
+                        << " Cookie# " << Cookie
+                        << " StatusFlags# " << NPDisk::StatusFlagsToString(StatusFlags)
+                        << " Received# " << Received
+                        << " }";
+                }
             };
 
-            TBatchedVec<TItem> Items; 
+            TBatchedVec<TItem> Items;
             ui64 ReceivedResults;
             TActorIDPtr SkeletonFrontIDPtr;
-            NMonitoring::TDynamicCounters::TCounterPtr MultiPutResMsgsPtr; 
+            NMonitoring::TDynamicCounters::TCounterPtr MultiPutResMsgsPtr;
 
             TEvBlobStorage::TEvVMultiPut::TPtr Event;
             TActorId LeaderId;
-            TOutOfSpaceStatus OOSStatus; 
+            TOutOfSpaceStatus OOSStatus;
 
             const ui64 IncarnationGuid;
 
         public:
             TBufferVMultiPutActor(TActorId leaderId, const TBatchedVec<NKikimrProto::EReplyStatus> &statuses,
-                    TOutOfSpaceStatus oosStatus, TEvBlobStorage::TEvVMultiPut::TPtr &ev, 
-                    TActorIDPtr skeletonFrontIDPtr, NMonitoring::TDynamicCounters::TCounterPtr multiPutResMsgsPtr, 
+                    TOutOfSpaceStatus oosStatus, TEvBlobStorage::TEvVMultiPut::TPtr &ev,
+                    TActorIDPtr skeletonFrontIDPtr, NMonitoring::TDynamicCounters::TCounterPtr multiPutResMsgsPtr,
                     ui64 incarnationGuid)
                 : TActorBootstrapped()
                 , Items(ev->Get()->Record.ItemsSize())
                 , ReceivedResults(0)
                 , SkeletonFrontIDPtr(skeletonFrontIDPtr)
-                , MultiPutResMsgsPtr(multiPutResMsgsPtr) 
+                , MultiPutResMsgsPtr(multiPutResMsgsPtr)
                 , Event(ev)
                 , LeaderId(leaderId)
-                , OOSStatus(oosStatus) 
+                , OOSStatus(oosStatus)
                 , IncarnationGuid(incarnationGuid)
             {
-                Y_VERIFY(statuses.size() == Items.size()); 
-                for (ui64 idx = 0; idx < Items.size(); ++idx) { 
-                    Items[idx].Status = statuses[idx]; 
-                } 
+                Y_VERIFY(statuses.size() == Items.size());
+                for (ui64 idx = 0; idx < Items.size(); ++idx) {
+                    Items[idx].Status = statuses[idx];
+                }
             }
 
         private:
-            void SendResponseAndDie(const TActorContext &ctx) { 
+            void SendResponseAndDie(const TActorContext &ctx) {
                 NKikimrBlobStorage::TEvVMultiPut &vMultiPutRecord = Event->Get()->Record;
                 TVDiskID vdisk = VDiskIDFromVDiskID(vMultiPutRecord.GetVDiskID());
 
@@ -88,56 +88,56 @@ namespace NKikimr {
                         result.HasCookie ? &result.Cookie : nullptr, result.StatusFlags);
                 }
 
-                vMultiPutResult->Record.SetStatusFlags(OOSStatus.Flags); 
+                vMultiPutResult->Record.SetStatusFlags(OOSStatus.Flags);
 
                 SendVDiskResponse(ctx, Event->Sender, vMultiPutResult.release(), *this, Event->Cookie);
                 PassAway();
             }
 
-            void Handle(TEvVMultiPutItemResult::TPtr &ev, const TActorContext &ctx) { 
-                TLogoBlobID blobId = ev->Get()->BlobId; 
-                ui64 idx = ev->Get()->ItemIdx; 
-                Y_VERIFY(idx < Items.size(), "itemIdx# %" PRIu64 " ItemsSize# %" PRIu64, idx, (ui64)Items.size()); 
-                TItem &item = Items[idx]; 
-                Y_VERIFY(blobId == item.BlobId, "itemIdx# %" PRIu64 " blobId# %s item# %s", idx, blobId.ToString().data(), item.ToString().data()); 
- 
-                Y_VERIFY(!item.Received, "itemIdx# %" PRIu64 " item# %s", idx, item.ToString().data()); 
-                item.Received = true; 
-                item.Status = ev->Get()->Status; 
+            void Handle(TEvVMultiPutItemResult::TPtr &ev, const TActorContext &ctx) {
+                TLogoBlobID blobId = ev->Get()->BlobId;
+                ui64 idx = ev->Get()->ItemIdx;
+                Y_VERIFY(idx < Items.size(), "itemIdx# %" PRIu64 " ItemsSize# %" PRIu64, idx, (ui64)Items.size());
+                TItem &item = Items[idx];
+                Y_VERIFY(blobId == item.BlobId, "itemIdx# %" PRIu64 " blobId# %s item# %s", idx, blobId.ToString().data(), item.ToString().data());
+
+                Y_VERIFY(!item.Received, "itemIdx# %" PRIu64 " item# %s", idx, item.ToString().data());
+                item.Received = true;
+                item.Status = ev->Get()->Status;
                 item.ErrorReason = ev->Get()->ErrorReason;
- 
-                ReceivedResults++; 
- 
-                if (ReceivedResults == Items.size()) { 
-                    SendResponseAndDie(ctx); 
-                } 
-            } 
- 
+
+                ReceivedResults++;
+
+                if (ReceivedResults == Items.size()) {
+                    SendResponseAndDie(ctx);
+                }
+            }
+
             void Handle(TEvBlobStorage::TEvVPutResult::TPtr &ev, const TActorContext &ctx) {
                 NKikimrBlobStorage::TEvVPutResult &record = ev->Get()->Record;
 
                 TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID());
                 Y_VERIFY(record.HasCookie());
                 ui64 idx = record.GetCookie();
-                Y_VERIFY(idx < Items.size(), "itemIdx# %" PRIu64 " ItemsSize# %" PRIu64, idx, (ui64)Items.size()); 
+                Y_VERIFY(idx < Items.size(), "itemIdx# %" PRIu64 " ItemsSize# %" PRIu64, idx, (ui64)Items.size());
                 TItem &item = Items[idx];
-                Y_VERIFY(blobId == item.BlobId, "itemIdx# %" PRIu64 " blobId# %s item# %s", idx, blobId.ToString().data(), item.ToString().data()); 
+                Y_VERIFY(blobId == item.BlobId, "itemIdx# %" PRIu64 " blobId# %s item# %s", idx, blobId.ToString().data(), item.ToString().data());
 
-                Y_VERIFY(!item.Received, "itemIdx# %" PRIu64 " item# %s", idx, item.ToString().data()); 
+                Y_VERIFY(!item.Received, "itemIdx# %" PRIu64 " item# %s", idx, item.ToString().data());
                 item.Received = true;
                 Y_VERIFY(record.HasStatus());
                 item.Status = record.GetStatus();
                 item.ErrorReason = record.GetErrorReason();
- 
+
                 ReceivedResults++;
 
                 if (ReceivedResults == Items.size()) {
-                    SendResponseAndDie(ctx); 
+                    SendResponseAndDie(ctx);
                 }
             }
 
             void Bootstrap(const TActorContext &ctx) {
-                Y_UNUSED(ctx); 
+                Y_UNUSED(ctx);
                 NKikimrBlobStorage::TEvVMultiPut &record = Event->Get()->Record;
 
                 for (ui64 idx = 0; idx < record.ItemsSize(); ++idx) {
@@ -152,10 +152,10 @@ namespace NKikimr {
                         item.Cookie = recItem.GetCookie();
                     }
 
-                    if (item.Status != NKikimrProto::OK) { 
-                        item.Received = true; 
-                        ReceivedResults++; 
-                    } 
+                    if (item.Status != NKikimrProto::OK) {
+                        item.Received = true;
+                        ReceivedResults++;
+                    }
                 }
 
                 Become(&TThis::StateWait);
@@ -164,7 +164,7 @@ namespace NKikimr {
             STFUNC(StateWait) {
                 Y_UNUSED(ctx);
                 switch (ev->GetTypeRewrite()) {
-                    HFunc(TEvVMultiPutItemResult, Handle); 
+                    HFunc(TEvVMultiPutItemResult, Handle);
                     HFunc(TEvBlobStorage::TEvVPutResult, Handle);
                 }
             }
@@ -173,11 +173,11 @@ namespace NKikimr {
     } // NPrivate
 
     IActor* CreateSkeletonVMultiPutActor(TActorId leaderId, const TBatchedVec<NKikimrProto::EReplyStatus> &statuses,
-            TOutOfSpaceStatus oosStatus, TEvBlobStorage::TEvVMultiPut::TPtr &ev, 
-            TActorIDPtr skeletonFrontIDPtr, NMonitoring::TDynamicCounters::TCounterPtr counterPtr, 
-            ui64 incarnationGuid) { 
+            TOutOfSpaceStatus oosStatus, TEvBlobStorage::TEvVMultiPut::TPtr &ev,
+            TActorIDPtr skeletonFrontIDPtr, NMonitoring::TDynamicCounters::TCounterPtr counterPtr,
+            ui64 incarnationGuid) {
         return new NPrivate::TBufferVMultiPutActor(leaderId, statuses, oosStatus, ev,
-                skeletonFrontIDPtr, counterPtr, incarnationGuid); 
+                skeletonFrontIDPtr, counterPtr, incarnationGuid);
     }
 
 } // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmultiput_actor.h b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmultiput_actor.h
index beeccfff1c..1eebe00456 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmultiput_actor.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vmultiput_actor.h
@@ -9,23 +9,23 @@
 namespace NKikimr {
 
 struct TEvVMultiPutItemResult : TEventLocal<TEvVMultiPutItemResult, TEvBlobStorage::EvVMultiPutItemResult> {
-    TLogoBlobID BlobId; 
-    ui64 ItemIdx; 
-    NKikimrProto::EReplyStatus Status; 
+    TLogoBlobID BlobId;
+    ui64 ItemIdx;
+    NKikimrProto::EReplyStatus Status;
     TString ErrorReason;
- 
+
     TEvVMultiPutItemResult(TLogoBlobID id, ui64 itemIdx, NKikimrProto::EReplyStatus status, TString errorReason)
-        : TEventLocal() 
-        , BlobId(id) 
-        , ItemIdx(itemIdx) 
-        , Status(status) 
+        : TEventLocal()
+        , BlobId(id)
+        , ItemIdx(itemIdx)
+        , Status(status)
         , ErrorReason(std::move(errorReason))
-    {} 
-}; 
- 
+    {}
+};
+
 IActor* CreateSkeletonVMultiPutActor(TActorId leaderId, const TBatchedVec<NKikimrProto::EReplyStatus> &statuses,
-        TOutOfSpaceStatus oosStatus, TEvBlobStorage::TEvVMultiPut::TPtr &ev, 
-        TActorIDPtr skeletonFrontIDPtr, NMonitoring::TDynamicCounters::TCounterPtr multiPutResMsgsPtr, 
+        TOutOfSpaceStatus oosStatus, TEvBlobStorage::TEvVMultiPut::TPtr &ev,
+        TActorIDPtr skeletonFrontIDPtr, NMonitoring::TDynamicCounters::TCounterPtr multiPutResMsgsPtr,
         ui64 incarnationGuid);
 
 } // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.cpp
index 2426398998..b04e8d6d8f 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.cpp
@@ -1,683 +1,683 @@
-#include "skeleton_vpatch_actor.h" 
- 
+#include "skeleton_vpatch_actor.h"
+
 #include <ydb/core/blobstorage/vdisk/common/vdisk_response.h>
 #include <ydb/core/util/stlog.h>
- 
-#include <util/generic/serialized_enum.h> 
- 
- 
-namespace NKikimr::NPrivate { 
- 
-    class TSkeletonVPatchActor : public TActorBootstrapped<TSkeletonVPatchActor> { 
-        friend TActorBootstrapped<TSkeletonVPatchActor>; 
-        // When the actor is created with VPatchStart(request) 
-        // Send VGet for finding parts 
-        // Go to StartState 
- 
-        // When the actor in StartState 
-        // Receive VGetResult 
-        // if it has error then send Error in VPatchFoundParts(response VPatchStart) and die 
-        // if it doesn't find parts send Ok in VPatchFoundParts(response VPatchStart) without parts and die 
-        // otherwise it send Ok in VPatchFoundParts(response VPatchStart) and fo to WaitState 
- 
-        // When the actor in WaitState 
-        // Receive VPatchDiff(request) 
-        // if it has a force end flag then send Ok in VPatchResult(response for VPatchDiff) and die 
-        // Send VGet for pulling part 
-        // if it has expected xor diffs then part is parity and actor go to ParityState 
-        // otherwise part is data and actor go to DataState 
- 
-        // When the actor in DataState 
-        // Receive VGetResult 
-        // if it has some troubles send Error in VPatchResult(response for VPatchDiff) and die 
-        // Send VPatchXorDiffs to vdisk with parity parts in future ignore their responses(VPatchResult) 
-        // Apply the patch 
-        // Send VPut with the patched part 
-        // Receive VPutResult 
-        // Send VPatchResult(response VPatchDiff) and die 
- 
-        // When the actor in ParityState 
-        // Receive VGetResult 
-        // if it has some troubles send Error in VPatchResult(response for VPatchDiff) and die 
-        // Receive VPatchXorDiffs from vdisk with data parts, apply them and send responses(VPatchXorDiffs) 
-        // Send VPut with the patched part 
-        // Receive VPutResult 
-        // Send VPatchResult(response VPatchDiff) and die 
- 
-        struct TXorReceiver { 
-            TVDiskID VDiskId; 
-            ui8 PartId; 
- 
-            TXorReceiver(const TVDiskID &vDiskId, ui8 partId) 
-                : VDiskId(vDiskId) 
-                , PartId(partId) 
-            { 
-            } 
-        }; 
- 
-        struct TXorDiffs { 
-            TVector<TDiff> Diffs; 
-            ui8 PartId; 
+
+#include <util/generic/serialized_enum.h>
+
+
+namespace NKikimr::NPrivate {
+
+    class TSkeletonVPatchActor : public TActorBootstrapped<TSkeletonVPatchActor> {
+        friend TActorBootstrapped<TSkeletonVPatchActor>;
+        // When the actor is created with VPatchStart(request)
+        // Send VGet for finding parts
+        // Go to StartState
+
+        // When the actor in StartState
+        // Receive VGetResult
+        // if it has error then send Error in VPatchFoundParts(response VPatchStart) and die
+        // if it doesn't find parts send Ok in VPatchFoundParts(response VPatchStart) without parts and die
+        // otherwise it send Ok in VPatchFoundParts(response VPatchStart) and fo to WaitState
+
+        // When the actor in WaitState
+        // Receive VPatchDiff(request)
+        // if it has a force end flag then send Ok in VPatchResult(response for VPatchDiff) and die
+        // Send VGet for pulling part
+        // if it has expected xor diffs then part is parity and actor go to ParityState
+        // otherwise part is data and actor go to DataState
+
+        // When the actor in DataState
+        // Receive VGetResult
+        // if it has some troubles send Error in VPatchResult(response for VPatchDiff) and die
+        // Send VPatchXorDiffs to vdisk with parity parts in future ignore their responses(VPatchResult)
+        // Apply the patch
+        // Send VPut with the patched part
+        // Receive VPutResult
+        // Send VPatchResult(response VPatchDiff) and die
+
+        // When the actor in ParityState
+        // Receive VGetResult
+        // if it has some troubles send Error in VPatchResult(response for VPatchDiff) and die
+        // Receive VPatchXorDiffs from vdisk with data parts, apply them and send responses(VPatchXorDiffs)
+        // Send VPut with the patched part
+        // Receive VPutResult
+        // Send VPatchResult(response VPatchDiff) and die
+
+        struct TXorReceiver {
+            TVDiskID VDiskId;
+            ui8 PartId;
+
+            TXorReceiver(const TVDiskID &vDiskId, ui8 partId)
+                : VDiskId(vDiskId)
+                , PartId(partId)
+            {
+            }
+        };
+
+        struct TXorDiffs {
+            TVector<TDiff> Diffs;
+            ui8 PartId;
             std::unique_ptr<TEvBlobStorage::TEvVPatchXorDiffResult> ResultEvent;
-            TActorId Sender; 
-            ui64 Cookie; 
- 
- 
+            TActorId Sender;
+            ui64 Cookie;
+
+
             TXorDiffs(TVector<TDiff> &&diffs, ui8 partId, std::unique_ptr<TEvBlobStorage::TEvVPatchXorDiffResult> &&result,
-                    const TActorId &sender, ui64 cookie) 
-                : Diffs(std::move(diffs)) 
-                , PartId(partId) 
-                , ResultEvent(std::move(result)) 
-                , Sender(sender) 
-                , Cookie(cookie) 
-            { 
-            } 
-        }; 
- 
-        static constexpr TDuration CommonLiveTime = TDuration::Seconds(57); 
-        // 60s is timeout in backpressure queue, try to be nearer to it 
- 
-        TActorId ProxyId; 
- 
-        TLogoBlobID OriginalBlobId; 
-        TLogoBlobID PatchedBlobId; 
-        ui8 OriginalPartId = 0; 
-        ui8 PatchedPartId = 0; 
-        TVDiskID VDiskId; 
- 
-        TInstant Deadline; 
- 
-        TActorId Sender; 
-        ui64 Cookie; 
-        TActorIDPtr SkeletonFrontIDPtr; 
-        NMonitoring::TDynamicCounters::TCounterPtr VPatchFoundPartsMsgsPtr; 
-        NMonitoring::TDynamicCounters::TCounterPtr VPatchResMsgsPtr; 
-        const TIntrusivePtr<TVPatchCtx> VPatchCtx; 
-        TString VDiskLogPrefix; 
- 
+                    const TActorId &sender, ui64 cookie)
+                : Diffs(std::move(diffs))
+                , PartId(partId)
+                , ResultEvent(std::move(result))
+                , Sender(sender)
+                , Cookie(cookie)
+            {
+            }
+        };
+
+        static constexpr TDuration CommonLiveTime = TDuration::Seconds(57);
+        // 60s is timeout in backpressure queue, try to be nearer to it
+
+        TActorId ProxyId;
+
+        TLogoBlobID OriginalBlobId;
+        TLogoBlobID PatchedBlobId;
+        ui8 OriginalPartId = 0;
+        ui8 PatchedPartId = 0;
+        TVDiskID VDiskId;
+
+        TInstant Deadline;
+
+        TActorId Sender;
+        ui64 Cookie;
+        TActorIDPtr SkeletonFrontIDPtr;
+        NMonitoring::TDynamicCounters::TCounterPtr VPatchFoundPartsMsgsPtr;
+        NMonitoring::TDynamicCounters::TCounterPtr VPatchResMsgsPtr;
+        const TIntrusivePtr<TVPatchCtx> VPatchCtx;
+        TString VDiskLogPrefix;
+
         TActorId LeaderId;
- 
-        const ui64 IncarnationGuid; 
- 
-        TStackVec<ui32, 1> FoundOriginalParts; 
- 
-        TStackVec<TXorReceiver, 2> XorReceivers; 
-        TString Buffer; 
-        TVector<TDiff> Diffs; 
-        TVector<TXorDiffs> ReceivedXorDiffs; 
- 
-        TString ErrorReason; 
- 
+
+        const ui64 IncarnationGuid;
+
+        TStackVec<ui32, 1> FoundOriginalParts;
+
+        TStackVec<TXorReceiver, 2> XorReceivers;
+        TString Buffer;
+        TVector<TDiff> Diffs;
+        TVector<TXorDiffs> ReceivedXorDiffs;
+
+        TString ErrorReason;
+
         std::unique_ptr<TEvBlobStorage::TEvVPatchFoundParts> FoundPartsEvent;
         std::unique_ptr<TEvBlobStorage::TEvVPatchResult> ResultEvent;
- 
-        TBlobStorageGroupType GType; 
- 
-        ui64 ReceivedXorDiffCount = 0; 
-        ui64 WaitedXorDiffCount = 0; 
- 
-    public: 
+
+        TBlobStorageGroupType GType;
+
+        ui64 ReceivedXorDiffCount = 0;
+        ui64 WaitedXorDiffCount = 0;
+
+    public:
         TSkeletonVPatchActor(TActorId leaderId, const TBlobStorageGroupType &gType,
-                TEvBlobStorage::TEvVPatchStart::TPtr &ev, TInstant now, TActorIDPtr skeletonFrontIDPtr, 
-                const NMonitoring::TDynamicCounters::TCounterPtr &vPatchFoundPartsMsgsPtr, 
-                const NMonitoring::TDynamicCounters::TCounterPtr &vPatchResMsgsPtr, 
-                const TIntrusivePtr<TVPatchCtx> &vPatchCtx, const TString &vDiskLogPrefix, ui64 incarnationGuid) 
-            : TActorBootstrapped() 
-            , Sender(ev->Sender) 
-            , Cookie(ev->Cookie) 
-            , SkeletonFrontIDPtr(skeletonFrontIDPtr) 
-            , VPatchFoundPartsMsgsPtr(vPatchFoundPartsMsgsPtr) 
-            , VPatchResMsgsPtr(vPatchResMsgsPtr) 
-            , VPatchCtx(vPatchCtx) 
-            , VDiskLogPrefix(vDiskLogPrefix) 
+                TEvBlobStorage::TEvVPatchStart::TPtr &ev, TInstant now, TActorIDPtr skeletonFrontIDPtr,
+                const NMonitoring::TDynamicCounters::TCounterPtr &vPatchFoundPartsMsgsPtr,
+                const NMonitoring::TDynamicCounters::TCounterPtr &vPatchResMsgsPtr,
+                const TIntrusivePtr<TVPatchCtx> &vPatchCtx, const TString &vDiskLogPrefix, ui64 incarnationGuid)
+            : TActorBootstrapped()
+            , Sender(ev->Sender)
+            , Cookie(ev->Cookie)
+            , SkeletonFrontIDPtr(skeletonFrontIDPtr)
+            , VPatchFoundPartsMsgsPtr(vPatchFoundPartsMsgsPtr)
+            , VPatchResMsgsPtr(vPatchResMsgsPtr)
+            , VPatchCtx(vPatchCtx)
+            , VDiskLogPrefix(vDiskLogPrefix)
             , LeaderId(leaderId)
-            , IncarnationGuid(incarnationGuid) 
-            , GType(gType) 
-        { 
-            NKikimrBlobStorage::TEvVPatchStart &record = ev->Get()->Record; 
-            if (record.HasMsgQoS() && record.GetMsgQoS().HasDeadlineSeconds()) { 
-                Deadline = TInstant::Seconds(record.GetMsgQoS().HasDeadlineSeconds()); 
-            } 
-            if (!Deadline) { 
-                Deadline = now + CommonLiveTime; 
-            } 
- 
-            Y_VERIFY(record.HasOriginalBlobId()); 
-            OriginalBlobId = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId()); 
-            Y_VERIFY(record.HasPatchedBlobId()); 
-            PatchedBlobId = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId()); 
-            Y_VERIFY(record.HasVDiskID()); 
-            VDiskId = VDiskIDFromVDiskID(record.GetVDiskID()); 
-            Y_VERIFY(record.HasCookie()); 
+            , IncarnationGuid(incarnationGuid)
+            , GType(gType)
+        {
+            NKikimrBlobStorage::TEvVPatchStart &record = ev->Get()->Record;
+            if (record.HasMsgQoS() && record.GetMsgQoS().HasDeadlineSeconds()) {
+                Deadline = TInstant::Seconds(record.GetMsgQoS().HasDeadlineSeconds());
+            }
+            if (!Deadline) {
+                Deadline = now + CommonLiveTime;
+            }
+
+            Y_VERIFY(record.HasOriginalBlobId());
+            OriginalBlobId = LogoBlobIDFromLogoBlobID(record.GetOriginalBlobId());
+            Y_VERIFY(record.HasPatchedBlobId());
+            PatchedBlobId = LogoBlobIDFromLogoBlobID(record.GetPatchedBlobId());
+            Y_VERIFY(record.HasVDiskID());
+            VDiskId = VDiskIDFromVDiskID(record.GetVDiskID());
+            Y_VERIFY(record.HasCookie());
             FoundPartsEvent = std::make_unique<TEvBlobStorage::TEvVPatchFoundParts>(
-                    NKikimrProto::OK, OriginalBlobId, PatchedBlobId, VDiskId, record.GetCookie(), now, ErrorReason, &record, 
-                    SkeletonFrontIDPtr, VPatchFoundPartsMsgsPtr, nullptr, 
-                    std::move(ev->TraceId), IncarnationGuid); 
-        } 
- 
-        void Bootstrap() { 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP03, 
-                    VDiskLogPrefix << " TEvVPatch: bootsrapped;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (Deadline, Deadline)); 
-            ui32 cookie = 0; 
+                    NKikimrProto::OK, OriginalBlobId, PatchedBlobId, VDiskId, record.GetCookie(), now, ErrorReason, &record,
+                    SkeletonFrontIDPtr, VPatchFoundPartsMsgsPtr, nullptr,
+                    std::move(ev->TraceId), IncarnationGuid);
+        }
+
+        void Bootstrap() {
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP03,
+                    VDiskLogPrefix << " TEvVPatch: bootsrapped;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (Deadline, Deadline));
+            ui32 cookie = 0;
             std::unique_ptr<TEvBlobStorage::TEvVGet> msg = TEvBlobStorage::TEvVGet::CreateRangeIndexQuery(VDiskId, Deadline,
-                    NKikimrBlobStorage::EGetHandleClass::FastRead, TEvBlobStorage::TEvVGet::EFlags::None, cookie, 
-                    OriginalBlobId, TLogoBlobID(OriginalBlobId, TLogoBlobID::MaxPartId), 
-                    TLogoBlobID::MaxPartId, nullptr, false); 
+                    NKikimrBlobStorage::EGetHandleClass::FastRead, TEvBlobStorage::TEvVGet::EFlags::None, cookie,
+                    OriginalBlobId, TLogoBlobID(OriginalBlobId, TLogoBlobID::MaxPartId),
+                    TLogoBlobID::MaxPartId, nullptr, false);
             Send(LeaderId, msg.release());
- 
-            Become(&TThis::StartState); 
- 
-            TDuration liveDuration = Deadline - TActivationContext::Now(); 
-            Schedule(liveDuration, new TKikimrEvents::TEvWakeup); 
-        } 
- 
-        void SendVPatchFoundParts(NKikimrProto::EReplyStatus status) 
-        { 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP04, 
-                    VDiskLogPrefix << " TEvVPatch: sended found parts;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (FoundParts, FormatList(FoundOriginalParts)), 
-                    (Status, status)); 
-            for (ui8 part : FoundOriginalParts) { 
-                FoundPartsEvent->AddPart(part); 
-            } 
-            FoundPartsEvent->SetStatus(status); 
+
+            Become(&TThis::StartState);
+
+            TDuration liveDuration = Deadline - TActivationContext::Now();
+            Schedule(liveDuration, new TKikimrEvents::TEvWakeup);
+        }
+
+        void SendVPatchFoundParts(NKikimrProto::EReplyStatus status)
+        {
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP04,
+                    VDiskLogPrefix << " TEvVPatch: sended found parts;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (FoundParts, FormatList(FoundOriginalParts)),
+                    (Status, status));
+            for (ui8 part : FoundOriginalParts) {
+                FoundPartsEvent->AddPart(part);
+            }
+            FoundPartsEvent->SetStatus(status);
             SendVDiskResponse(TActivationContext::AsActorContext(), Sender, FoundPartsEvent.release(), *this, Cookie);
-        } 
- 
-        void PullOriginalPart(ui64 pullingPart) { 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP05, 
-                    VDiskLogPrefix << " TEvVPatch: send vGet for pulling part data;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (PullingPart, pullingPart)); 
-            ui32 cookie = 0; 
+        }
+
+        void PullOriginalPart(ui64 pullingPart) {
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP05,
+                    VDiskLogPrefix << " TEvVPatch: send vGet for pulling part data;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (PullingPart, pullingPart));
+            ui32 cookie = 0;
             std::unique_ptr<TEvBlobStorage::TEvVGet> msg = TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(VDiskId, Deadline,
-                    NKikimrBlobStorage::EGetHandleClass::FastRead, TEvBlobStorage::TEvVGet::EFlags::None, cookie, 
-                    {}, false); 
-            TLogoBlobID id(OriginalBlobId, pullingPart); 
-            msg->AddExtremeQuery(id, 0, 0, &pullingPart); 
+                    NKikimrBlobStorage::EGetHandleClass::FastRead, TEvBlobStorage::TEvVGet::EFlags::None, cookie,
+                    {}, false);
+            TLogoBlobID id(OriginalBlobId, pullingPart);
+            msg->AddExtremeQuery(id, 0, 0, &pullingPart);
             Send(LeaderId, msg.release());
-        } 
- 
-        void HandleVGetRangeResult(TEvBlobStorage::TEvVGetResult::TPtr &ev) { 
-            Become(&TThis::WaitState); 
-            NKikimrBlobStorage::TEvVGetResult &record = ev->Get()->Record; 
-            Y_VERIFY(record.HasStatus()); 
- 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP06, 
-                    VDiskLogPrefix << " TEvVPatch: received parts index;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (Status, record.GetStatus()), 
-                    (ResultSize, record.ResultSize())); 
-            if (record.GetStatus() != NKikimrProto::OK) { 
-                ErrorReason = TStringBuilder() << "Recieve not OK status from VGetRange," 
-                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()); 
-                SendVPatchFoundParts(NKikimrProto::ERROR); 
-                ConfirmDying(true); 
-                return; 
-            } 
-            if (record.ResultSize() != 1) { 
-                ErrorReason = TStringBuilder() << "Expected only one result, but given " << record.ResultSize() 
-                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()); 
-                SendVPatchFoundParts(NKikimrProto::ERROR); 
-                ConfirmDying(true); 
-                return; 
-            } 
- 
-            // it has to have only one result 
-            auto &item = record.GetResult(0); 
-            FoundOriginalParts.reserve(item.PartsSize()); 
-            Y_VERIFY(item.HasStatus()); 
-            if (item.GetStatus() == NKikimrProto::OK) { 
-                for (ui32 partId : item.GetParts()) { 
-                    FoundOriginalParts.push_back(partId); 
-                } 
-            } 
- 
-            SendVPatchFoundParts(NKikimrProto::OK); 
-            if (FoundOriginalParts.empty()) { 
-                ConfirmDying(true); 
-            } 
-        } 
- 
-        void SendVPatchResult(NKikimrProto::EReplyStatus status) 
-        { 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP07, 
-                    VDiskLogPrefix << " TEvVPatch: send patch result;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (PatchedBlobId, PatchedBlobId), 
-                    (OriginalPartId, (ui32)OriginalPartId), 
-                    (PatchedPartId, (ui32)PatchedPartId), 
-                    (Status, status), 
-                    (ErrorReason, ErrorReason)); 
-            Y_VERIFY(ResultEvent); 
-            ResultEvent->SetStatus(status, ErrorReason); 
+        }
+
+        void HandleVGetRangeResult(TEvBlobStorage::TEvVGetResult::TPtr &ev) {
+            Become(&TThis::WaitState);
+            NKikimrBlobStorage::TEvVGetResult &record = ev->Get()->Record;
+            Y_VERIFY(record.HasStatus());
+
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP06,
+                    VDiskLogPrefix << " TEvVPatch: received parts index;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (Status, record.GetStatus()),
+                    (ResultSize, record.ResultSize()));
+            if (record.GetStatus() != NKikimrProto::OK) {
+                ErrorReason = TStringBuilder() << "Recieve not OK status from VGetRange,"
+                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus());
+                SendVPatchFoundParts(NKikimrProto::ERROR);
+                ConfirmDying(true);
+                return;
+            }
+            if (record.ResultSize() != 1) {
+                ErrorReason = TStringBuilder() << "Expected only one result, but given " << record.ResultSize()
+                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus());
+                SendVPatchFoundParts(NKikimrProto::ERROR);
+                ConfirmDying(true);
+                return;
+            }
+
+            // it has to have only one result
+            auto &item = record.GetResult(0);
+            FoundOriginalParts.reserve(item.PartsSize());
+            Y_VERIFY(item.HasStatus());
+            if (item.GetStatus() == NKikimrProto::OK) {
+                for (ui32 partId : item.GetParts()) {
+                    FoundOriginalParts.push_back(partId);
+                }
+            }
+
+            SendVPatchFoundParts(NKikimrProto::OK);
+            if (FoundOriginalParts.empty()) {
+                ConfirmDying(true);
+            }
+        }
+
+        void SendVPatchResult(NKikimrProto::EReplyStatus status)
+        {
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP07,
+                    VDiskLogPrefix << " TEvVPatch: send patch result;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (PatchedBlobId, PatchedBlobId),
+                    (OriginalPartId, (ui32)OriginalPartId),
+                    (PatchedPartId, (ui32)PatchedPartId),
+                    (Status, status),
+                    (ErrorReason, ErrorReason));
+            Y_VERIFY(ResultEvent);
+            ResultEvent->SetStatus(status, ErrorReason);
             SendVDiskResponse(TActivationContext::AsActorContext(), Sender, ResultEvent.release(), *this, Cookie);
-        } 
- 
-        void HandleVGetResult(TEvBlobStorage::TEvVGetResult::TPtr &ev) { 
-            NKikimrBlobStorage::TEvVGetResult &record = ev->Get()->Record; 
-            Y_VERIFY(record.HasStatus()); 
-            if (record.GetStatus() != NKikimrProto::OK) { 
-                ErrorReason = TStringBuilder() << "Recieve not OK status from VGetResult," 
-                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()); 
-                SendVPatchResult(NKikimrProto::ERROR); 
-                PassAway(); 
-                return; 
-            } 
-            if (record.ResultSize() != 1) { 
-                ErrorReason = TStringBuilder() << "Recieve not correct result count from VGetResult," 
-                        << " expetced 1 but given " << record.ResultSize(); 
-                SendVPatchResult(NKikimrProto::ERROR); 
-                PassAway(); 
-                return; 
-            } 
- 
-            auto &item = *record.MutableResult(0); 
-            Y_VERIFY(item.HasStatus()); 
-            if (item.GetStatus() != NKikimrProto::OK) { 
-                ErrorReason = TStringBuilder() << "Recieve not OK status from VGetResult," 
-                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()) 
-                        << " response status# " << NKikimrProto::EReplyStatus_Name(item.GetStatus()); 
-                SendVPatchResult(NKikimrProto::ERROR); 
-                PassAway(); 
-                return; 
-            } 
- 
-            Y_VERIFY(item.HasBlobID()); 
-            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID()); 
- 
-            Y_VERIFY(item.HasBuffer()); 
-            Buffer = item.GetBuffer(); 
- 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP08, 
-                    VDiskLogPrefix << " TEvVPatch: received part data;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (PatchedBlobId, PatchedBlobId), 
-                    (OriginalPartId, (ui32)OriginalPartId), 
-                    (PatchedPartId, (ui32)PatchedPartId), 
-                    (ReceivedBlobId, blobId), 
-                    (Status, record.GetStatus()), 
-                    (ResultSize, record.ResultSize())); 
- 
-            ui8 *buffer = reinterpret_cast<ui8*>(const_cast<char*>(Buffer.data())); 
-            if (blobId.PartId() <= GType.DataParts()) { 
-                if (GType.ErasureFamily() != TErasureType::ErasureMirror) { 
-                    SendXorDiff(); 
-                } 
-                GType.ApplyDiff(TErasureType::CrcModeNone, buffer, Diffs); 
-                SendVPut(); 
-            } else { 
-                ui8 toPart = blobId.PartId(); 
-                ui32 dataSize = blobId.BlobSize(); 
- 
-                for (ui32 idx = ReceivedXorDiffs.size(); idx != 0; --idx) { 
-                    auto &[diffs, partId, result, sender, cookie] = ReceivedXorDiffs.back(); 
-                    GType.ApplyXorDiff(TErasureType::CrcModeNone, dataSize, buffer, diffs, partId - 1, toPart - 1); 
+        }
+
+        void HandleVGetResult(TEvBlobStorage::TEvVGetResult::TPtr &ev) {
+            NKikimrBlobStorage::TEvVGetResult &record = ev->Get()->Record;
+            Y_VERIFY(record.HasStatus());
+            if (record.GetStatus() != NKikimrProto::OK) {
+                ErrorReason = TStringBuilder() << "Recieve not OK status from VGetResult,"
+                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus());
+                SendVPatchResult(NKikimrProto::ERROR);
+                PassAway();
+                return;
+            }
+            if (record.ResultSize() != 1) {
+                ErrorReason = TStringBuilder() << "Recieve not correct result count from VGetResult,"
+                        << " expetced 1 but given " << record.ResultSize();
+                SendVPatchResult(NKikimrProto::ERROR);
+                PassAway();
+                return;
+            }
+
+            auto &item = *record.MutableResult(0);
+            Y_VERIFY(item.HasStatus());
+            if (item.GetStatus() != NKikimrProto::OK) {
+                ErrorReason = TStringBuilder() << "Recieve not OK status from VGetResult,"
+                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus())
+                        << " response status# " << NKikimrProto::EReplyStatus_Name(item.GetStatus());
+                SendVPatchResult(NKikimrProto::ERROR);
+                PassAway();
+                return;
+            }
+
+            Y_VERIFY(item.HasBlobID());
+            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(item.GetBlobID());
+
+            Y_VERIFY(item.HasBuffer());
+            Buffer = item.GetBuffer();
+
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP08,
+                    VDiskLogPrefix << " TEvVPatch: received part data;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (PatchedBlobId, PatchedBlobId),
+                    (OriginalPartId, (ui32)OriginalPartId),
+                    (PatchedPartId, (ui32)PatchedPartId),
+                    (ReceivedBlobId, blobId),
+                    (Status, record.GetStatus()),
+                    (ResultSize, record.ResultSize()));
+
+            ui8 *buffer = reinterpret_cast<ui8*>(const_cast<char*>(Buffer.data()));
+            if (blobId.PartId() <= GType.DataParts()) {
+                if (GType.ErasureFamily() != TErasureType::ErasureMirror) {
+                    SendXorDiff();
+                }
+                GType.ApplyDiff(TErasureType::CrcModeNone, buffer, Diffs);
+                SendVPut();
+            } else {
+                ui8 toPart = blobId.PartId();
+                ui32 dataSize = blobId.BlobSize();
+
+                for (ui32 idx = ReceivedXorDiffs.size(); idx != 0; --idx) {
+                    auto &[diffs, partId, result, sender, cookie] = ReceivedXorDiffs.back();
+                    GType.ApplyXorDiff(TErasureType::CrcModeNone, dataSize, buffer, diffs, partId - 1, toPart - 1);
                     SendVDiskResponse(TActivationContext::AsActorContext(), sender, result.release(), *this, cookie);
-                    ReceivedXorDiffs.pop_back(); 
-                } 
- 
-                if (ReceivedXorDiffCount == WaitedXorDiffCount) { 
-                    SendVPut(); 
-                } 
-            } 
-        } 
- 
-        template <typename TDiffEvent> 
-        TVector<TDiff> PullDiff(const TDiffEvent &diffRecord, bool isXor) { 
-            TVector<TDiff> diffs; 
-            diffs.reserve(diffRecord.DiffsSize()); 
-            for (auto &diff : diffRecord.GetDiffs()) { 
-                TString buffer = diff.GetBuffer(); 
-                bool isAligned = (GType.ErasureFamily() != TErasureType::ErasureMirror); 
-                diffs.emplace_back(buffer, diff.GetOffset(), isXor, isAligned); 
-            } 
-            return std::move(diffs); 
-        } 
- 
-        bool CheckDiff(const TVector<TDiff> &diffs, const TString &diffName) { 
-            for (ui32 diffIdx = 0; diffIdx < diffs.size(); ++diffIdx) { 
-                const TDiff &diff = diffs[diffIdx]; 
-                bool ok = (diff.Offset < GType.PartSize(OriginalBlobId)); 
-                ok &= (diff.Offset + diff.GetDiffLength() <= GType.PartSize(OriginalBlobId)); 
-                if (!ok) { 
-                    ErrorReason = TStringBuilder() << "The diff at index " << diffIdx << " went beyound the blob part;" 
-                            << " DiffStart# " << diff.Offset 
-                            << " DiffEnd# " << diff.Offset + diff.GetDiffLength() 
-                            << " BlobPartSize# " << GType.PartSize(OriginalBlobId); 
-                    return false; 
-                } 
-            } 
-            for (ui32 diffIdx = 1; diffIdx < diffs.size(); ++diffIdx) { 
-                ui32 prevIdx = diffIdx - 1; 
-                bool ok = diffs[prevIdx].Offset < diffs[diffIdx].Offset; 
-                if (!ok) { 
-                    ErrorReason = TStringBuilder() << "[" << diffName << "]" 
-                            << " the start of the diff at index " << prevIdx << " righter than" 
-                            << " the start of the diff at index " << diffIdx << ';' 
-                            << " PrevDiffStart# " << diffs[prevIdx].Offset + diffs[prevIdx].GetDiffLength() 
-                            << " DiffStart# " << diffs[diffIdx].Offset; 
-                    return false; 
-                } 
-            } 
-            return true; 
-        } 
- 
-        void SendXorDiff() { 
-            TVector<TDiff> xorDiffs; 
- 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP14, 
-                    VDiskLogPrefix << " TEvVPatch: send xor diffs;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (PatchedBlobId, PatchedBlobId), 
-                    (OriginalPartId, (ui32)OriginalPartId), 
-                    (PatchedPartId, (ui32)PatchedPartId), 
-                    (XorDiffCount, XorReceivers.size())); 
- 
-            const ui8 *buffer = reinterpret_cast<const ui8*>(Buffer.data()); 
-            GType.MakeXorDiff(TErasureType::CrcModeNone, OriginalBlobId.BlobSize(), buffer, Diffs, &xorDiffs); 
- 
-            for (TXorReceiver &xorReceiver : XorReceivers) { 
+                    ReceivedXorDiffs.pop_back();
+                }
+
+                if (ReceivedXorDiffCount == WaitedXorDiffCount) {
+                    SendVPut();
+                }
+            }
+        }
+
+        template <typename TDiffEvent>
+        TVector<TDiff> PullDiff(const TDiffEvent &diffRecord, bool isXor) {
+            TVector<TDiff> diffs;
+            diffs.reserve(diffRecord.DiffsSize());
+            for (auto &diff : diffRecord.GetDiffs()) {
+                TString buffer = diff.GetBuffer();
+                bool isAligned = (GType.ErasureFamily() != TErasureType::ErasureMirror);
+                diffs.emplace_back(buffer, diff.GetOffset(), isXor, isAligned);
+            }
+            return std::move(diffs);
+        }
+
+        bool CheckDiff(const TVector<TDiff> &diffs, const TString &diffName) {
+            for (ui32 diffIdx = 0; diffIdx < diffs.size(); ++diffIdx) {
+                const TDiff &diff = diffs[diffIdx];
+                bool ok = (diff.Offset < GType.PartSize(OriginalBlobId));
+                ok &= (diff.Offset + diff.GetDiffLength() <= GType.PartSize(OriginalBlobId));
+                if (!ok) {
+                    ErrorReason = TStringBuilder() << "The diff at index " << diffIdx << " went beyound the blob part;"
+                            << " DiffStart# " << diff.Offset
+                            << " DiffEnd# " << diff.Offset + diff.GetDiffLength()
+                            << " BlobPartSize# " << GType.PartSize(OriginalBlobId);
+                    return false;
+                }
+            }
+            for (ui32 diffIdx = 1; diffIdx < diffs.size(); ++diffIdx) {
+                ui32 prevIdx = diffIdx - 1;
+                bool ok = diffs[prevIdx].Offset < diffs[diffIdx].Offset;
+                if (!ok) {
+                    ErrorReason = TStringBuilder() << "[" << diffName << "]"
+                            << " the start of the diff at index " << prevIdx << " righter than"
+                            << " the start of the diff at index " << diffIdx << ';'
+                            << " PrevDiffStart# " << diffs[prevIdx].Offset + diffs[prevIdx].GetDiffLength()
+                            << " DiffStart# " << diffs[diffIdx].Offset;
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        void SendXorDiff() {
+            TVector<TDiff> xorDiffs;
+
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP14,
+                    VDiskLogPrefix << " TEvVPatch: send xor diffs;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (PatchedBlobId, PatchedBlobId),
+                    (OriginalPartId, (ui32)OriginalPartId),
+                    (PatchedPartId, (ui32)PatchedPartId),
+                    (XorDiffCount, XorReceivers.size()));
+
+            const ui8 *buffer = reinterpret_cast<const ui8*>(Buffer.data());
+            GType.MakeXorDiff(TErasureType::CrcModeNone, OriginalBlobId.BlobSize(), buffer, Diffs, &xorDiffs);
+
+            for (TXorReceiver &xorReceiver : XorReceivers) {
                 std::unique_ptr<TEvBlobStorage::TEvVPatchXorDiff> xorDiff = std::make_unique<TEvBlobStorage::TEvVPatchXorDiff>(
-                        TLogoBlobID(OriginalBlobId, xorReceiver.PartId), 
-                        TLogoBlobID(PatchedBlobId, xorReceiver.PartId), 
-                        xorReceiver.VDiskId, OriginalPartId, Deadline, 0); 
-                for (auto &diff : xorDiffs) { 
-                    Y_VERIFY(diff.Offset < GType.PartSize(PatchedBlobId)); 
-                    Y_VERIFY(diff.Offset + diff.GetDiffLength() <= GType.PartSize(PatchedBlobId)); 
-                    xorDiff->AddDiff(diff.Offset, diff.Buffer); 
-                } 
-                TVDiskIdShort shortId(xorReceiver.VDiskId); 
-                Y_VERIFY(VPatchCtx); 
-                Y_VERIFY(VPatchCtx->AsyncBlobQueues); 
-                auto it = VPatchCtx->AsyncBlobQueues.find(shortId); 
-                Y_VERIFY(it != VPatchCtx->AsyncBlobQueues.end()); 
- 
-                TInstant now = TActivationContext::Now(); 
-                NKikimrBlobStorage::TEvVPatchXorDiff &record = xorDiff->Record; 
-                NKikimrBlobStorage::TMsgQoS &msgQoS = *record.MutableMsgQoS(); 
-                NKikimrBlobStorage::TExecTimeStats &execTimeStats = *msgQoS.MutableExecTimeStats(); 
-                execTimeStats.SetSubmitTimestamp(now.GetValue()); 
- 
+                        TLogoBlobID(OriginalBlobId, xorReceiver.PartId),
+                        TLogoBlobID(PatchedBlobId, xorReceiver.PartId),
+                        xorReceiver.VDiskId, OriginalPartId, Deadline, 0);
+                for (auto &diff : xorDiffs) {
+                    Y_VERIFY(diff.Offset < GType.PartSize(PatchedBlobId));
+                    Y_VERIFY(diff.Offset + diff.GetDiffLength() <= GType.PartSize(PatchedBlobId));
+                    xorDiff->AddDiff(diff.Offset, diff.Buffer);
+                }
+                TVDiskIdShort shortId(xorReceiver.VDiskId);
+                Y_VERIFY(VPatchCtx);
+                Y_VERIFY(VPatchCtx->AsyncBlobQueues);
+                auto it = VPatchCtx->AsyncBlobQueues.find(shortId);
+                Y_VERIFY(it != VPatchCtx->AsyncBlobQueues.end());
+
+                TInstant now = TActivationContext::Now();
+                NKikimrBlobStorage::TEvVPatchXorDiff &record = xorDiff->Record;
+                NKikimrBlobStorage::TMsgQoS &msgQoS = *record.MutableMsgQoS();
+                NKikimrBlobStorage::TExecTimeStats &execTimeStats = *msgQoS.MutableExecTimeStats();
+                execTimeStats.SetSubmitTimestamp(now.GetValue());
+
                 Send(it->second, xorDiff.release());
-            } 
-        } 
- 
-        void SendVPut() { 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP15, 
-                    VDiskLogPrefix << " TEvVPatch: send vPut;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (PatchedBlobId, PatchedBlobId), 
-                    (OriginalPartId, (ui32)OriginalPartId), 
-                    (PatchedPartId, (ui32)PatchedPartId)); 
-            ui64 cookie = OriginalBlobId.Hash(); 
+            }
+        }
+
+        void SendVPut() {
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP15,
+                    VDiskLogPrefix << " TEvVPatch: send vPut;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (PatchedBlobId, PatchedBlobId),
+                    (OriginalPartId, (ui32)OriginalPartId),
+                    (PatchedPartId, (ui32)PatchedPartId));
+            ui64 cookie = OriginalBlobId.Hash();
             std::unique_ptr<IEventBase> put = std::make_unique<TEvBlobStorage::TEvVPut>(TLogoBlobID(PatchedBlobId, PatchedPartId),
-                    Buffer, VDiskId, false, &cookie, Deadline, NKikimrBlobStorage::AsyncBlob); 
+                    Buffer, VDiskId, false, &cookie, Deadline, NKikimrBlobStorage::AsyncBlob);
             Send(LeaderId, put.release());
-        } 
- 
-        void HandleError(TEvBlobStorage::TEvVPatchDiff::TPtr &ev) { 
-            NKikimrBlobStorage::TEvVPatchDiff &record = ev->Get()->Record; 
-            TInstant now = TActivationContext::Now(); 
+        }
+
+        void HandleError(TEvBlobStorage::TEvVPatchDiff::TPtr &ev) {
+            NKikimrBlobStorage::TEvVPatchDiff &record = ev->Get()->Record;
+            TInstant now = TActivationContext::Now();
             ResultEvent = std::make_unique<TEvBlobStorage::TEvVPatchResult>(
-                    NKikimrProto::OK, TLogoBlobID(OriginalBlobId, OriginalPartId), 
-                    TLogoBlobID(PatchedBlobId, PatchedPartId), VDiskId, record.GetCookie(), now, 
-                    &record, SkeletonFrontIDPtr, VPatchResMsgsPtr, nullptr, 
-                    std::move(ev->TraceId), IncarnationGuid); 
-            Sender = ev->Sender; 
-            Cookie = ev->Cookie; 
-            SendVPatchResult(NKikimrProto::ERROR); 
-            PassAway(); 
-        } 
- 
-        void Handle(TEvBlobStorage::TEvVPatchDiff::TPtr &ev) { 
-            NKikimrBlobStorage::TEvVPatchDiff &record = ev->Get()->Record; 
-            Y_VERIFY(record.HasCookie()); 
- 
-            TLogoBlobID originalPartBlobId = LogoBlobIDFromLogoBlobID(record.GetOriginalPartBlobId()); 
-            TLogoBlobID patchedPartBlobId = LogoBlobIDFromLogoBlobID(record.GetPatchedPartBlobId()); 
-            OriginalPartId = originalPartBlobId.PartId(); 
-            PatchedPartId = patchedPartBlobId.PartId(); 
- 
-            bool forceEnd = ev->Get()->IsForceEnd(); 
- 
-            bool isXorReceiver = ev->Get()->IsXorReceiver(); 
-            WaitedXorDiffCount = ev->Get()->GetExpectedXorDiffs(); 
- 
-            if (isXorReceiver) { 
-                Become(&TThis::ParityState); 
-            } else { 
-                Become(&TThis::DataState); 
-            } 
- 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP09, 
-                    VDiskLogPrefix << " TEvVPatch: received diff;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (PatchedBlobId, PatchedBlobId), 
-                    (OriginalPartId, (ui32)OriginalPartId), 
-                    (PatchedPartId, (ui32)PatchedPartId), 
-                    (XorReceiver, (isXorReceiver ? "yes" : "no")), 
-                    (ForceEnd, (forceEnd ? "yes" : "no"))); 
- 
-            Y_VERIFY(!ResultEvent); 
-            TInstant now = TActivationContext::Now(); 
- 
+                    NKikimrProto::OK, TLogoBlobID(OriginalBlobId, OriginalPartId),
+                    TLogoBlobID(PatchedBlobId, PatchedPartId), VDiskId, record.GetCookie(), now,
+                    &record, SkeletonFrontIDPtr, VPatchResMsgsPtr, nullptr,
+                    std::move(ev->TraceId), IncarnationGuid);
+            Sender = ev->Sender;
+            Cookie = ev->Cookie;
+            SendVPatchResult(NKikimrProto::ERROR);
+            PassAway();
+        }
+
+        void Handle(TEvBlobStorage::TEvVPatchDiff::TPtr &ev) {
+            NKikimrBlobStorage::TEvVPatchDiff &record = ev->Get()->Record;
+            Y_VERIFY(record.HasCookie());
+
+            TLogoBlobID originalPartBlobId = LogoBlobIDFromLogoBlobID(record.GetOriginalPartBlobId());
+            TLogoBlobID patchedPartBlobId = LogoBlobIDFromLogoBlobID(record.GetPatchedPartBlobId());
+            OriginalPartId = originalPartBlobId.PartId();
+            PatchedPartId = patchedPartBlobId.PartId();
+
+            bool forceEnd = ev->Get()->IsForceEnd();
+
+            bool isXorReceiver = ev->Get()->IsXorReceiver();
+            WaitedXorDiffCount = ev->Get()->GetExpectedXorDiffs();
+
+            if (isXorReceiver) {
+                Become(&TThis::ParityState);
+            } else {
+                Become(&TThis::DataState);
+            }
+
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP09,
+                    VDiskLogPrefix << " TEvVPatch: received diff;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (PatchedBlobId, PatchedBlobId),
+                    (OriginalPartId, (ui32)OriginalPartId),
+                    (PatchedPartId, (ui32)PatchedPartId),
+                    (XorReceiver, (isXorReceiver ? "yes" : "no")),
+                    (ForceEnd, (forceEnd ? "yes" : "no")));
+
+            Y_VERIFY(!ResultEvent);
+            TInstant now = TActivationContext::Now();
+
             ResultEvent = std::make_unique<TEvBlobStorage::TEvVPatchResult>(
-                    NKikimrProto::OK, originalPartBlobId, patchedPartBlobId, VDiskId, record.GetCookie(), now, 
-                    &record, SkeletonFrontIDPtr, VPatchResMsgsPtr, nullptr, 
-                    std::move(ev->TraceId), IncarnationGuid); 
-            Sender = ev->Sender; 
-            Cookie = ev->Cookie; 
- 
-            if (forceEnd) { 
-                SendVPatchResult(NKikimrProto::OK); 
-                PassAway(); 
-                return; 
-            } 
- 
-            for (auto &protoXorReceiver : record.GetXorReceivers()) { 
-                Y_VERIFY(protoXorReceiver.HasVDiskID()); 
-                Y_VERIFY(protoXorReceiver.HasPartId()); 
-                XorReceivers.emplace_back( 
-                        VDiskIDFromVDiskID(protoXorReceiver.GetVDiskID()), 
-                        protoXorReceiver.GetPartId()); 
-            } 
- 
-            Diffs = PullDiff(record, false); 
- 
-            if (!CheckDiff(Diffs, "Diff from DSProxy")) { 
-                SendVPatchResult(NKikimrProto::ERROR); 
-                PassAway(); 
-                return; 
-            } 
- 
-            PullOriginalPart(OriginalPartId); 
-        } 
- 
-        void Handle(TEvBlobStorage::TEvVPutResult::TPtr &ev) { 
-            NKikimrBlobStorage::TEvVPutResult &record = ev->Get()->Record; 
-            Y_VERIFY(record.HasStatus()); 
- 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP10, 
-                    VDiskLogPrefix << " TEvVPatch: received put result;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (PatchedBlobId, PatchedBlobId), 
-                    (OriginalPartId, (ui32)OriginalPartId), 
-                    (PatchedPartId, (ui32)PatchedPartId), 
-                    (Status, record.GetStatus())); 
- 
-            NKikimrProto::EReplyStatus status = NKikimrProto::OK; 
-            if (record.GetStatus() != NKikimrProto::OK) { 
-                ErrorReason = TStringBuilder() << "Recieve not OK status from VPutResult," 
-                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus()); 
-                status = NKikimrProto::ERROR; 
-            } 
- 
-            ResultEvent->SetStatusFlagsAndFreeSpace(record.GetStatusFlags(), record.GetApproximateFreeSpaceShare()); 
- 
-            SendVPatchResult(status); 
-            PassAway(); 
-        } 
- 
-        void HandleError(TEvBlobStorage::TEvVPatchXorDiff::TPtr &ev) { 
-            NKikimrBlobStorage::TEvVPatchXorDiff &record = ev->Get()->Record; 
-            TInstant now = TActivationContext::Now(); 
+                    NKikimrProto::OK, originalPartBlobId, patchedPartBlobId, VDiskId, record.GetCookie(), now,
+                    &record, SkeletonFrontIDPtr, VPatchResMsgsPtr, nullptr,
+                    std::move(ev->TraceId), IncarnationGuid);
+            Sender = ev->Sender;
+            Cookie = ev->Cookie;
+
+            if (forceEnd) {
+                SendVPatchResult(NKikimrProto::OK);
+                PassAway();
+                return;
+            }
+
+            for (auto &protoXorReceiver : record.GetXorReceivers()) {
+                Y_VERIFY(protoXorReceiver.HasVDiskID());
+                Y_VERIFY(protoXorReceiver.HasPartId());
+                XorReceivers.emplace_back(
+                        VDiskIDFromVDiskID(protoXorReceiver.GetVDiskID()),
+                        protoXorReceiver.GetPartId());
+            }
+
+            Diffs = PullDiff(record, false);
+
+            if (!CheckDiff(Diffs, "Diff from DSProxy")) {
+                SendVPatchResult(NKikimrProto::ERROR);
+                PassAway();
+                return;
+            }
+
+            PullOriginalPart(OriginalPartId);
+        }
+
+        void Handle(TEvBlobStorage::TEvVPutResult::TPtr &ev) {
+            NKikimrBlobStorage::TEvVPutResult &record = ev->Get()->Record;
+            Y_VERIFY(record.HasStatus());
+
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP10,
+                    VDiskLogPrefix << " TEvVPatch: received put result;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (PatchedBlobId, PatchedBlobId),
+                    (OriginalPartId, (ui32)OriginalPartId),
+                    (PatchedPartId, (ui32)PatchedPartId),
+                    (Status, record.GetStatus()));
+
+            NKikimrProto::EReplyStatus status = NKikimrProto::OK;
+            if (record.GetStatus() != NKikimrProto::OK) {
+                ErrorReason = TStringBuilder() << "Recieve not OK status from VPutResult,"
+                        << " received status# " << NKikimrProto::EReplyStatus_Name(record.GetStatus());
+                status = NKikimrProto::ERROR;
+            }
+
+            ResultEvent->SetStatusFlagsAndFreeSpace(record.GetStatusFlags(), record.GetApproximateFreeSpaceShare());
+
+            SendVPatchResult(status);
+            PassAway();
+        }
+
+        void HandleError(TEvBlobStorage::TEvVPatchXorDiff::TPtr &ev) {
+            NKikimrBlobStorage::TEvVPatchXorDiff &record = ev->Get()->Record;
+            TInstant now = TActivationContext::Now();
             auto resultEvent = std::make_unique<TEvBlobStorage::TEvVPatchXorDiffResult>(
-                    NKikimrProto::ERROR, now, &record, SkeletonFrontIDPtr, VPatchResMsgsPtr, nullptr, 
-                    std::move(ev->TraceId)); 
+                    NKikimrProto::ERROR, now, &record, SkeletonFrontIDPtr, VPatchResMsgsPtr, nullptr,
+                    std::move(ev->TraceId));
             SendVDiskResponse(TActivationContext::AsActorContext(), ev->Sender, resultEvent.release(), *this, ev->Cookie);
-        } 
- 
-        void Handle(TEvBlobStorage::TEvVPatchXorDiff::TPtr &ev) { 
-            NKikimrBlobStorage::TEvVPatchXorDiff &record = ev->Get()->Record; 
-            Y_VERIFY(record.HasFromPartId()); 
-            ui8 fromPart = record.GetFromPartId(); 
-            ui8 toPart = OriginalPartId; 
-            TVector<TDiff> xorDiffs = PullDiff(record, true); 
-            ReceivedXorDiffCount++; 
- 
-            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP13, 
-                    VDiskLogPrefix << " TEvVPatch: received xor diff;", 
-                    (OriginalBlobId, OriginalBlobId), 
-                    (PatchedBlobId, PatchedBlobId), 
-                    (FromPart, (ui32)fromPart), 
-                    (ToPart, (ui32)toPart), 
-                    (HasBuffer, (Buffer.empty() ? "no" : "yes")), 
-                    (ReceivedXorDiffCount, TStringBuilder() << ReceivedXorDiffCount << '/' << WaitedXorDiffCount)); 
- 
-            TInstant now = TActivationContext::Now(); 
+        }
+
+        void Handle(TEvBlobStorage::TEvVPatchXorDiff::TPtr &ev) {
+            NKikimrBlobStorage::TEvVPatchXorDiff &record = ev->Get()->Record;
+            Y_VERIFY(record.HasFromPartId());
+            ui8 fromPart = record.GetFromPartId();
+            ui8 toPart = OriginalPartId;
+            TVector<TDiff> xorDiffs = PullDiff(record, true);
+            ReceivedXorDiffCount++;
+
+            STLOG(PRI_INFO, BS_VDISK_PATCH, BSVSP13,
+                    VDiskLogPrefix << " TEvVPatch: received xor diff;",
+                    (OriginalBlobId, OriginalBlobId),
+                    (PatchedBlobId, PatchedBlobId),
+                    (FromPart, (ui32)fromPart),
+                    (ToPart, (ui32)toPart),
+                    (HasBuffer, (Buffer.empty() ? "no" : "yes")),
+                    (ReceivedXorDiffCount, TStringBuilder() << ReceivedXorDiffCount << '/' << WaitedXorDiffCount));
+
+            TInstant now = TActivationContext::Now();
             std::unique_ptr<TEvBlobStorage::TEvVPatchXorDiffResult> resultEvent = std::make_unique<TEvBlobStorage::TEvVPatchXorDiffResult>(
-                    NKikimrProto::OK, now, &record, SkeletonFrontIDPtr, VPatchResMsgsPtr, nullptr, std::move(ev->TraceId)); 
- 
-            if (!CheckDiff(xorDiffs, "XorDiff from datapart")) { 
-                for (auto &[diffs, partId, result, sender, cookie] : ReceivedXorDiffs) { 
+                    NKikimrProto::OK, now, &record, SkeletonFrontIDPtr, VPatchResMsgsPtr, nullptr, std::move(ev->TraceId));
+
+            if (!CheckDiff(xorDiffs, "XorDiff from datapart")) {
+                for (auto &[diffs, partId, result, sender, cookie] : ReceivedXorDiffs) {
                     SendVDiskResponse(TActivationContext::AsActorContext(), sender, result.release(), *this, cookie);
-                } 
+                }
                 SendVDiskResponse(TActivationContext::AsActorContext(), ev->Sender, resultEvent.release(), *this, ev->Cookie);
- 
-                if (ResultEvent) { 
-                    SendVPatchResult(NKikimrProto::ERROR); 
-                    PassAway(); 
-                } else { 
-                    Become(&TThis::ErrorState); 
-                } 
-                return; 
-            } 
- 
-            if (Buffer) { 
-                ui8 *buffer = reinterpret_cast<ui8*>(const_cast<char*>(Buffer.data())); 
-                ui32 dataSize = OriginalBlobId.BlobSize(); 
-                GType.ApplyXorDiff(TErasureType::CrcModeNone, dataSize, buffer, xorDiffs, fromPart - 1, toPart - 1); 
- 
-                if (ReceivedXorDiffCount == WaitedXorDiffCount) { 
-                    SendVPut(); 
-                } 
- 
-                xorDiffs.clear(); 
+
+                if (ResultEvent) {
+                    SendVPatchResult(NKikimrProto::ERROR);
+                    PassAway();
+                } else {
+                    Become(&TThis::ErrorState);
+                }
+                return;
+            }
+
+            if (Buffer) {
+                ui8 *buffer = reinterpret_cast<ui8*>(const_cast<char*>(Buffer.data()));
+                ui32 dataSize = OriginalBlobId.BlobSize();
+                GType.ApplyXorDiff(TErasureType::CrcModeNone, dataSize, buffer, xorDiffs, fromPart - 1, toPart - 1);
+
+                if (ReceivedXorDiffCount == WaitedXorDiffCount) {
+                    SendVPut();
+                }
+
+                xorDiffs.clear();
                 SendVDiskResponse(TActivationContext::AsActorContext(), ev->Sender, resultEvent.release(), *this, ev->Cookie);
-            } else { 
-                ReceivedXorDiffs.emplace_back(std::move(xorDiffs), fromPart, std::move(resultEvent), 
-                        ev->Sender, ev->Cookie); 
-            } 
-        } 
- 
-        void ConfirmDying(bool forceDeath) { 
+            } else {
+                ReceivedXorDiffs.emplace_back(std::move(xorDiffs), fromPart, std::move(resultEvent),
+                        ev->Sender, ev->Cookie);
+            }
+        }
+
+        void ConfirmDying(bool forceDeath) {
             Send(LeaderId, new TEvVPatchDyingRequest(PatchedBlobId));
-            if (forceDeath) { 
-                PassAway(); 
-            } else { 
-                Schedule(CommonLiveTime, new TEvVPatchDyingConfirm); 
-            } 
-        } 
- 
-        void HandleInStartState(TKikimrEvents::TEvWakeup::TPtr &/*ev*/) { 
-            ErrorReason = "TEvVPatch: the vpatch actor died due to a deadline, before receiving diff"; 
-            STLOG(PRI_ERROR, BS_VDISK_PATCH, BSVSP11, VDiskLogPrefix << " " << ErrorReason << ";"); 
-            SendVPatchFoundParts(NKikimrProto::ERROR); 
-            ConfirmDying(true); 
-        } 
- 
-        void HandleInWaitState(TKikimrEvents::TEvWakeup::TPtr &/*ev*/) { 
-            ErrorReason = "TEvVPatch: the vpatch actor died due to a deadline, before receiving diff"; 
-            STLOG(PRI_ERROR, BS_VDISK_PATCH, BSVSP16, VDiskLogPrefix << " " << ErrorReason << ";"); 
-            ConfirmDying(false); 
-            Become(&TThis::ErrorState); 
-        } 
- 
-        void HandleInDataOrParityStates(TKikimrEvents::TEvWakeup::TPtr &/*ev*/) { 
-            ErrorReason = "TEvVPatch: the vpatch actor died due to a deadline, after receiving diff"; 
-            STLOG(PRI_ERROR, BS_VDISK_PATCH, BSVSP12, VDiskLogPrefix << " " << ErrorReason << ";"); 
-            SendVPatchResult(NKikimrProto::ERROR); 
-            PassAway(); 
-        } 
- 
-        STATEFN(StartState) { 
-            switch (ev->GetTypeRewrite()) { 
-                hFunc(TEvBlobStorage::TEvVGetResult, HandleVGetRangeResult) 
-                hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle) 
-                hFunc(TKikimrEvents::TEvWakeup, HandleInStartState) 
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite())); 
-            } 
-        } 
- 
-        STATEFN(WaitState) { 
-            switch (ev->GetTypeRewrite()) { 
-                hFunc(TEvBlobStorage::TEvVPatchDiff, Handle) 
-                hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle) 
-                hFunc(TKikimrEvents::TEvWakeup, HandleInWaitState) 
-                sFunc(TEvVPatchDyingConfirm, PassAway) 
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite())); 
-            } 
-        } 
- 
-        STATEFN(ErrorState) { 
-            switch (ev->GetTypeRewrite()) { 
-                hFunc(TEvBlobStorage::TEvVPatchDiff, HandleError) 
-                hFunc(TEvBlobStorage::TEvVPatchXorDiff, HandleError) 
-                hFunc(TKikimrEvents::TEvWakeup, HandleInWaitState) 
-                sFunc(TEvVPatchDyingConfirm, PassAway) 
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite())); 
-            } 
-        } 
- 
-        STATEFN(DataState) { 
-            switch (ev->GetTypeRewrite()) { 
-                hFunc(TEvBlobStorage::TEvVGetResult, HandleVGetResult) 
-                hFunc(TEvBlobStorage::TEvVPutResult, Handle) 
-                IgnoreFunc(TEvBlobStorage::TEvVPatchXorDiffResult) 
-                hFunc(TKikimrEvents::TEvWakeup, HandleInDataOrParityStates) 
-                IgnoreFunc(TEvVPatchDyingConfirm) 
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite())); 
-            } 
-        } 
- 
-        STATEFN(ParityState) { 
-            switch (ev->GetTypeRewrite()) { 
-                hFunc(TEvBlobStorage::TEvVGetResult, HandleVGetResult) 
-                hFunc(TEvBlobStorage::TEvVPutResult, Handle) 
-                hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle) 
-                hFunc(TKikimrEvents::TEvWakeup, HandleInDataOrParityStates) 
-                IgnoreFunc(TEvVPatchDyingConfirm) 
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite())); 
-            } 
-        } 
-    }; 
- 
-} // NKikimr::NPrivate 
- 
-namespace NKikimr { 
- 
+            if (forceDeath) {
+                PassAway();
+            } else {
+                Schedule(CommonLiveTime, new TEvVPatchDyingConfirm);
+            }
+        }
+
+        void HandleInStartState(TKikimrEvents::TEvWakeup::TPtr &/*ev*/) {
+            ErrorReason = "TEvVPatch: the vpatch actor died due to a deadline, before receiving diff";
+            STLOG(PRI_ERROR, BS_VDISK_PATCH, BSVSP11, VDiskLogPrefix << " " << ErrorReason << ";");
+            SendVPatchFoundParts(NKikimrProto::ERROR);
+            ConfirmDying(true);
+        }
+
+        void HandleInWaitState(TKikimrEvents::TEvWakeup::TPtr &/*ev*/) {
+            ErrorReason = "TEvVPatch: the vpatch actor died due to a deadline, before receiving diff";
+            STLOG(PRI_ERROR, BS_VDISK_PATCH, BSVSP16, VDiskLogPrefix << " " << ErrorReason << ";");
+            ConfirmDying(false);
+            Become(&TThis::ErrorState);
+        }
+
+        void HandleInDataOrParityStates(TKikimrEvents::TEvWakeup::TPtr &/*ev*/) {
+            ErrorReason = "TEvVPatch: the vpatch actor died due to a deadline, after receiving diff";
+            STLOG(PRI_ERROR, BS_VDISK_PATCH, BSVSP12, VDiskLogPrefix << " " << ErrorReason << ";");
+            SendVPatchResult(NKikimrProto::ERROR);
+            PassAway();
+        }
+
+        STATEFN(StartState) {
+            switch (ev->GetTypeRewrite()) {
+                hFunc(TEvBlobStorage::TEvVGetResult, HandleVGetRangeResult)
+                hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle)
+                hFunc(TKikimrEvents::TEvWakeup, HandleInStartState)
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite()));
+            }
+        }
+
+        STATEFN(WaitState) {
+            switch (ev->GetTypeRewrite()) {
+                hFunc(TEvBlobStorage::TEvVPatchDiff, Handle)
+                hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle)
+                hFunc(TKikimrEvents::TEvWakeup, HandleInWaitState)
+                sFunc(TEvVPatchDyingConfirm, PassAway)
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite()));
+            }
+        }
+
+        STATEFN(ErrorState) {
+            switch (ev->GetTypeRewrite()) {
+                hFunc(TEvBlobStorage::TEvVPatchDiff, HandleError)
+                hFunc(TEvBlobStorage::TEvVPatchXorDiff, HandleError)
+                hFunc(TKikimrEvents::TEvWakeup, HandleInWaitState)
+                sFunc(TEvVPatchDyingConfirm, PassAway)
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite()));
+            }
+        }
+
+        STATEFN(DataState) {
+            switch (ev->GetTypeRewrite()) {
+                hFunc(TEvBlobStorage::TEvVGetResult, HandleVGetResult)
+                hFunc(TEvBlobStorage::TEvVPutResult, Handle)
+                IgnoreFunc(TEvBlobStorage::TEvVPatchXorDiffResult)
+                hFunc(TKikimrEvents::TEvWakeup, HandleInDataOrParityStates)
+                IgnoreFunc(TEvVPatchDyingConfirm)
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite()));
+            }
+        }
+
+        STATEFN(ParityState) {
+            switch (ev->GetTypeRewrite()) {
+                hFunc(TEvBlobStorage::TEvVGetResult, HandleVGetResult)
+                hFunc(TEvBlobStorage::TEvVPutResult, Handle)
+                hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle)
+                hFunc(TKikimrEvents::TEvWakeup, HandleInDataOrParityStates)
+                IgnoreFunc(TEvVPatchDyingConfirm)
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ToString(ev->GetTypeRewrite()));
+            }
+        }
+    };
+
+} // NKikimr::NPrivate
+
+namespace NKikimr {
+
     IActor* CreateSkeletonVPatchActor(TActorId leaderId, const TBlobStorageGroupType &gType,
-            TEvBlobStorage::TEvVPatchStart::TPtr &ev, TInstant now, TActorIDPtr skeletonFrontIDPtr, 
-            const NMonitoring::TDynamicCounters::TCounterPtr &vPatchFoundPartsMsgsPtr, 
-            const NMonitoring::TDynamicCounters::TCounterPtr &vPatchResMsgsPtr, 
-            const TIntrusivePtr<TVPatchCtx> &vPatchCtx, const TString &vDiskLogPrefix, ui64 incarnationGuid) 
-    { 
+            TEvBlobStorage::TEvVPatchStart::TPtr &ev, TInstant now, TActorIDPtr skeletonFrontIDPtr,
+            const NMonitoring::TDynamicCounters::TCounterPtr &vPatchFoundPartsMsgsPtr,
+            const NMonitoring::TDynamicCounters::TCounterPtr &vPatchResMsgsPtr,
+            const TIntrusivePtr<TVPatchCtx> &vPatchCtx, const TString &vDiskLogPrefix, ui64 incarnationGuid)
+    {
         return new NPrivate::TSkeletonVPatchActor(leaderId, gType, ev, now, skeletonFrontIDPtr,
-                vPatchFoundPartsMsgsPtr, vPatchResMsgsPtr, vPatchCtx, vDiskLogPrefix, incarnationGuid); 
-    } 
- 
-} // NKikimr 
+                vPatchFoundPartsMsgsPtr, vPatchResMsgsPtr, vPatchCtx, vDiskLogPrefix, incarnationGuid);
+    }
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.h b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.h
index d5b2fdefae..8c2c0d658c 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.h
@@ -1,39 +1,39 @@
-#pragma once 
- 
-#include "defs.h" 
- 
+#pragma once
+
+#include "defs.h"
+
 #include <ydb/core/blobstorage/vdisk/common/vdisk_events.h>
 #include <ydb/core/blobstorage/base/utility.h>
 #include <ydb/core/blobstorage/base/vdisk_sync_common.h>
- 
- 
-namespace NKikimr { 
- 
-struct TEvVPatchDyingRequest : TEventLocal< 
-    TEvVPatchDyingRequest, 
-    TEvBlobStorage::EvVPatchDyingRequest> 
-{ 
-    TEvVPatchDyingRequest(TLogoBlobID id) 
-        : PatchedBlobId(id) 
-    {} 
- 
-    TLogoBlobID PatchedBlobId; 
-}; 
- 
-struct TEvVPatchDyingConfirm : TEventLocal< 
-    TEvVPatchDyingConfirm, 
-    TEvBlobStorage::EvVPatchDyingConfirm> 
-{}; 
- 
-struct TVPatchCtx : public TThrRefBase, TNonCopyable  { 
-    TQueueActorMap AsyncBlobQueues; 
- 
-    TVPatchCtx() = default; 
-}; 
- 
+
+
+namespace NKikimr {
+
+struct TEvVPatchDyingRequest : TEventLocal<
+    TEvVPatchDyingRequest,
+    TEvBlobStorage::EvVPatchDyingRequest>
+{
+    TEvVPatchDyingRequest(TLogoBlobID id)
+        : PatchedBlobId(id)
+    {}
+
+    TLogoBlobID PatchedBlobId;
+};
+
+struct TEvVPatchDyingConfirm : TEventLocal<
+    TEvVPatchDyingConfirm,
+    TEvBlobStorage::EvVPatchDyingConfirm>
+{};
+
+struct TVPatchCtx : public TThrRefBase, TNonCopyable  {
+    TQueueActorMap AsyncBlobQueues;
+
+    TVPatchCtx() = default;
+};
+
 IActor* CreateSkeletonVPatchActor(TActorId leaderId, const TBlobStorageGroupType &gType, TEvBlobStorage::TEvVPatchStart::TPtr &ev,
-        TInstant now, TActorIDPtr skeletonFrontIDPtr, const NMonitoring::TDynamicCounters::TCounterPtr &vPatchFoundPartsMsgsPtr, 
-        const NMonitoring::TDynamicCounters::TCounterPtr &vPatchResMsgsPtr, const TIntrusivePtr<TVPatchCtx> &vPatchCtx, 
-        const TString &vDiskLogPrefix, ui64 incarnationGuid); 
- 
-} // NKikimr 
+        TInstant now, TActorIDPtr skeletonFrontIDPtr, const NMonitoring::TDynamicCounters::TCounterPtr &vPatchFoundPartsMsgsPtr,
+        const NMonitoring::TDynamicCounters::TCounterPtr &vPatchResMsgsPtr, const TIntrusivePtr<TVPatchCtx> &vPatchCtx,
+        const TString &vDiskLogPrefix, ui64 incarnationGuid);
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor_ut.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor_ut.cpp
index 8461000969..ca54eeec88 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor_ut.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor_ut.cpp
@@ -1,880 +1,880 @@
-#include "skeleton_vpatch_actor.h" 
- 
+#include "skeleton_vpatch_actor.h"
+
 #include <ydb/core/blobstorage/vdisk/common/vdisk_events.h>
- 
+
 #include <ydb/core/testlib/basics/runtime.h>
 #include <ydb/core/testlib/basics/appdata.h>
- 
- 
-#include <library/cpp/testing/unittest/registar.h> 
- 
-namespace NKikimr { 
- 
-    enum { 
-        Begin = EventSpaceBegin(TEvents::ES_USERSPACE), 
-        EvRequestEnd 
-    }; 
- 
-    struct TEvRequestEnd : TEventLocal<TEvRequestEnd, EvRequestEnd> { 
-        TEvRequestEnd() = default; 
-    }; 
- 
-    struct TVPatchDecoratorArgs { 
-        TActorId EdgeActor; 
-        bool IsCheckingEvents; 
-        TVector<ui64> SequenceOfReceivingEvents; 
-        TVector<ui64> SequenceOfSendingEvents; 
-    }; 
- 
-    struct TVPatchDecorator : public TTestDecorator { 
- 
-        static constexpr bool CheckDyingState = false; 
-        bool InStateFunc = false; 
- 
-        TActorId EdgeActor; 
- 
-        TVector<ui64> SequenceOfReceivingEvents; 
-        TVector<ui64> SequenceOfSendingEvents; 
-        ui64 ReceivingIdx = 0; 
-        ui64 SendingIdx = 0; 
-        bool IsCheckingEvents = false; 
- 
-        TVPatchDecorator(THolder<IActor> &&actor, TVPatchDecoratorArgs &args) 
-            : TTestDecorator(std::move(actor)) 
-            , EdgeActor(args.EdgeActor) 
-            , SequenceOfReceivingEvents(std::move(args.SequenceOfReceivingEvents)) 
-            , SequenceOfSendingEvents(std::move(args.SequenceOfSendingEvents)) 
-            , IsCheckingEvents(args.IsCheckingEvents) 
-        { 
-        } 
- 
-        virtual ~TVPatchDecorator() { 
-            if (NActors::TlsActivationContext) { 
+
+
+#include <library/cpp/testing/unittest/registar.h>
+
+namespace NKikimr {
+
+    enum {
+        Begin = EventSpaceBegin(TEvents::ES_USERSPACE),
+        EvRequestEnd
+    };
+
+    struct TEvRequestEnd : TEventLocal<TEvRequestEnd, EvRequestEnd> {
+        TEvRequestEnd() = default;
+    };
+
+    struct TVPatchDecoratorArgs {
+        TActorId EdgeActor;
+        bool IsCheckingEvents;
+        TVector<ui64> SequenceOfReceivingEvents;
+        TVector<ui64> SequenceOfSendingEvents;
+    };
+
+    struct TVPatchDecorator : public TTestDecorator {
+
+        static constexpr bool CheckDyingState = false;
+        bool InStateFunc = false;
+
+        TActorId EdgeActor;
+
+        TVector<ui64> SequenceOfReceivingEvents;
+        TVector<ui64> SequenceOfSendingEvents;
+        ui64 ReceivingIdx = 0;
+        ui64 SendingIdx = 0;
+        bool IsCheckingEvents = false;
+
+        TVPatchDecorator(THolder<IActor> &&actor, TVPatchDecoratorArgs &args)
+            : TTestDecorator(std::move(actor))
+            , EdgeActor(args.EdgeActor)
+            , SequenceOfReceivingEvents(std::move(args.SequenceOfReceivingEvents))
+            , SequenceOfSendingEvents(std::move(args.SequenceOfSendingEvents))
+            , IsCheckingEvents(args.IsCheckingEvents)
+        {
+        }
+
+        virtual ~TVPatchDecorator() {
+            if (NActors::TlsActivationContext) {
                 std::unique_ptr<IEventBase> ev = std::make_unique<TEvRequestEnd>();
                 std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(EdgeActor, EdgeActor, ev.release());
                 TActivationContext::Send(handle.release());
-            } 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (IsCheckingEvents) { 
-                UNIT_ASSERT_LT_C(SendingIdx, SequenceOfSendingEvents.size(), "SequenceOfSendingEvents overbounded"); 
-                UNIT_ASSERT_VALUES_EQUAL_C(SequenceOfSendingEvents[SendingIdx], ev->Type, "sending idx " << SendingIdx); 
-            } 
- 
-            SendingIdx++; 
-            return true; 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &ev, const TActorContext &/*ctx*/) override { 
-            if (ev->Type == TEvents::TSystem::PoisonPill) { 
-                PassAway(); 
-                return false; 
-            } 
- 
-            InStateFunc = true; 
-            if (IsCheckingEvents) { 
-                UNIT_ASSERT_LT_C(ReceivingIdx, SequenceOfReceivingEvents.size(), "SequenceOfReceivingEvents overbounded"); 
-                UNIT_ASSERT_VALUES_EQUAL_C(SequenceOfReceivingEvents[ReceivingIdx], ev->Type, "receive idx " << ReceivingIdx); 
-            } 
- 
-            ReceivingIdx++; 
-            return true; 
-        } 
- 
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            InStateFunc = false; 
-        } 
-    }; 
- 
-    bool ScheduledFilterFunc(NActors::TTestActorRuntimeBase& runtime, TAutoPtr<NActors::IEventHandle>& event, 
-            TDuration delay, TInstant& deadline) { 
-        if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) { 
-            deadline = runtime.GetTimeProvider()->Now() + delay; 
-            return false; 
-        } 
-        return true; 
-    } 
- 
-    struct TVPatchTestGeneralData { 
-        TBlobStorageGroupType GType; 
-        TTestBasicRuntime Runtime; // TODO(kruall): change to lighter 
-        TVector<TActorId> EdgeActors; 
-        TLogoBlobID OriginalBlobId; 
-        TLogoBlobID PatchedBlobId; 
- 
-        TInstant Deadline; 
-        TInstant Now; 
- 
-        TVector<ui64> SequenceOfReceivingEvents; 
-        TVector<ui64> SequenceOfSendingEvents; 
-        bool IsCheckingEventsByDecorator = false; 
- 
-        TVector<TActorId> VPatchActorIds; 
-        TVector<TVDiskID> VDiskIds; 
- 
-        float ApproximateFreeSpaceShare = 0.1; 
-        ui32 StatusFlags = 1; 
- 
-        TVPatchTestGeneralData(const TBlobStorageGroupType &gType, ui32 blobSize, ui32 nodeCount = 1) 
-            : GType(gType) 
-            , Runtime(nodeCount, false) 
-            , OriginalBlobId(1, 2, 3, 4, blobSize, 6) 
-            , PatchedBlobId(1, 3, 3, 4, blobSize, 6) 
-            , Deadline() 
-        { 
-            InitLogLevels(); 
-            Runtime.SetScheduledEventFilter(&ScheduledFilterFunc); 
-            Runtime.SetEventFilter([](NActors::TTestActorRuntimeBase&, TAutoPtr<NActors::IEventHandle>&) { 
-                return false; 
-            }); 
- 
-            TAppPrepare app; 
-            app.ClearDomainsAndHive(); 
-            Runtime.Initialize(app.Unwrap()); 
- 
-            for (ui32 nodeIdx = 0; nodeIdx < nodeCount; ++nodeIdx) { 
-                EdgeActors.push_back(Runtime.AllocateEdgeActor(nodeIdx)); 
-                TVDiskIdShort shortId(0, nodeIdx, 0); 
-                VDiskIds.emplace_back(0, 1, shortId); 
-            } 
- 
-            Now = Runtime.GetCurrentTime(); 
-        } 
- 
-        void InitLogLevels() { 
-            Runtime.SetLogPriority(NKikimrServices::BS_VDISK_PATCH, NLog::PRI_DEBUG); 
-            Runtime.SetLogPriority(NActorsServices::TEST, NLog::PRI_DEBUG); 
-        } 
- 
+            }
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (IsCheckingEvents) {
+                UNIT_ASSERT_LT_C(SendingIdx, SequenceOfSendingEvents.size(), "SequenceOfSendingEvents overbounded");
+                UNIT_ASSERT_VALUES_EQUAL_C(SequenceOfSendingEvents[SendingIdx], ev->Type, "sending idx " << SendingIdx);
+            }
+
+            SendingIdx++;
+            return true;
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &ev, const TActorContext &/*ctx*/) override {
+            if (ev->Type == TEvents::TSystem::PoisonPill) {
+                PassAway();
+                return false;
+            }
+
+            InStateFunc = true;
+            if (IsCheckingEvents) {
+                UNIT_ASSERT_LT_C(ReceivingIdx, SequenceOfReceivingEvents.size(), "SequenceOfReceivingEvents overbounded");
+                UNIT_ASSERT_VALUES_EQUAL_C(SequenceOfReceivingEvents[ReceivingIdx], ev->Type, "receive idx " << ReceivingIdx);
+            }
+
+            ReceivingIdx++;
+            return true;
+        }
+
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            InStateFunc = false;
+        }
+    };
+
+    bool ScheduledFilterFunc(NActors::TTestActorRuntimeBase& runtime, TAutoPtr<NActors::IEventHandle>& event,
+            TDuration delay, TInstant& deadline) {
+        if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) {
+            deadline = runtime.GetTimeProvider()->Now() + delay;
+            return false;
+        }
+        return true;
+    }
+
+    struct TVPatchTestGeneralData {
+        TBlobStorageGroupType GType;
+        TTestBasicRuntime Runtime; // TODO(kruall): change to lighter
+        TVector<TActorId> EdgeActors;
+        TLogoBlobID OriginalBlobId;
+        TLogoBlobID PatchedBlobId;
+
+        TInstant Deadline;
+        TInstant Now;
+
+        TVector<ui64> SequenceOfReceivingEvents;
+        TVector<ui64> SequenceOfSendingEvents;
+        bool IsCheckingEventsByDecorator = false;
+
+        TVector<TActorId> VPatchActorIds;
+        TVector<TVDiskID> VDiskIds;
+
+        float ApproximateFreeSpaceShare = 0.1;
+        ui32 StatusFlags = 1;
+
+        TVPatchTestGeneralData(const TBlobStorageGroupType &gType, ui32 blobSize, ui32 nodeCount = 1)
+            : GType(gType)
+            , Runtime(nodeCount, false)
+            , OriginalBlobId(1, 2, 3, 4, blobSize, 6)
+            , PatchedBlobId(1, 3, 3, 4, blobSize, 6)
+            , Deadline()
+        {
+            InitLogLevels();
+            Runtime.SetScheduledEventFilter(&ScheduledFilterFunc);
+            Runtime.SetEventFilter([](NActors::TTestActorRuntimeBase&, TAutoPtr<NActors::IEventHandle>&) {
+                return false;
+            });
+
+            TAppPrepare app;
+            app.ClearDomainsAndHive();
+            Runtime.Initialize(app.Unwrap());
+
+            for (ui32 nodeIdx = 0; nodeIdx < nodeCount; ++nodeIdx) {
+                EdgeActors.push_back(Runtime.AllocateEdgeActor(nodeIdx));
+                TVDiskIdShort shortId(0, nodeIdx, 0);
+                VDiskIds.emplace_back(0, 1, shortId);
+            }
+
+            Now = Runtime.GetCurrentTime();
+        }
+
+        void InitLogLevels() {
+            Runtime.SetLogPriority(NKikimrServices::BS_VDISK_PATCH, NLog::PRI_DEBUG);
+            Runtime.SetLogPriority(NActorsServices::TEST, NLog::PRI_DEBUG);
+        }
+
         std::unique_ptr<TEvBlobStorage::TEvVPatchStart> CreateVPatchStart(TMaybe<ui64> cookie, ui32 nodeId = 0) const {
             return std::make_unique<TEvBlobStorage::TEvVPatchStart>(OriginalBlobId, PatchedBlobId, VDiskIds[nodeId], Deadline,
-                    cookie, false); 
-        } 
- 
+                    cookie, false);
+        }
+
         std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> CreateVPatchDiff(ui8 partId, ui8 waitedXorDiffs,
-                const TVector<TDiff> &diffs, TMaybe<ui64> cookie, ui8 nodeId = 0) const { 
+                const TVector<TDiff> &diffs, TMaybe<ui64> cookie, ui8 nodeId = 0) const {
             std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = std::make_unique<TEvBlobStorage::TEvVPatchDiff>(TLogoBlobID(OriginalBlobId, partId),
-                    TLogoBlobID(PatchedBlobId, partId), VDiskIds[nodeId], waitedXorDiffs, Deadline, cookie); 
-            for (auto &diffBlock : diffs) { 
-                diff->AddDiff(diffBlock.Offset, diffBlock.Buffer); 
-            } 
-            return std::move(diff); 
-        } 
- 
+                    TLogoBlobID(PatchedBlobId, partId), VDiskIds[nodeId], waitedXorDiffs, Deadline, cookie);
+            for (auto &diffBlock : diffs) {
+                diff->AddDiff(diffBlock.Offset, diffBlock.Buffer);
+            }
+            return std::move(diff);
+        }
+
         std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> CreateForceEndVPatchDiff(ui8 partId, TMaybe<ui64> cookie) const {
             std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = std::make_unique<TEvBlobStorage::TEvVPatchDiff>(TLogoBlobID(OriginalBlobId, partId),
-                    TLogoBlobID(PatchedBlobId, partId), VDiskIds[partId - 1], false, Deadline, cookie); 
-            diff->SetForceEnd(); 
-            return std::move(diff); 
-        } 
- 
-        template <typename DecoratorType = void> 
-        TActorId CreateTVPatchActor(TEvBlobStorage::TEvVPatchStart::TPtr &&ev, ui32 nodeId = 0) { 
-            TIntrusivePtr<TVPatchCtx> patchCtx = MakeIntrusive<TVPatchCtx>(); 
-            for (ui32 idx = 0; idx < VDiskIds.size(); ++idx) { 
-                TVDiskIdShort id(VDiskIds[idx]); 
-                patchCtx->AsyncBlobQueues.emplace(id, EdgeActors[idx]); 
-            } 
- 
+                    TLogoBlobID(PatchedBlobId, partId), VDiskIds[partId - 1], false, Deadline, cookie);
+            diff->SetForceEnd();
+            return std::move(diff);
+        }
+
+        template <typename DecoratorType = void>
+        TActorId CreateTVPatchActor(TEvBlobStorage::TEvVPatchStart::TPtr &&ev, ui32 nodeId = 0) {
+            TIntrusivePtr<TVPatchCtx> patchCtx = MakeIntrusive<TVPatchCtx>();
+            for (ui32 idx = 0; idx < VDiskIds.size(); ++idx) {
+                TVDiskIdShort id(VDiskIds[idx]);
+                patchCtx->AsyncBlobQueues.emplace(id, EdgeActors[idx]);
+            }
+
             THolder<IActor> actor{CreateSkeletonVPatchActor(EdgeActors[nodeId], GType,
                     ev, TInstant(), nullptr, nullptr, nullptr, patchCtx, VDiskIds[nodeId].ToString(), 0)};
- 
-            if constexpr (!std::is_void_v<DecoratorType>) { 
-                TVPatchDecoratorArgs args{EdgeActors[nodeId], IsCheckingEventsByDecorator, 
-                        SequenceOfReceivingEvents, SequenceOfSendingEvents}; 
-                actor = MakeHolder<DecoratorType>(std::move(actor), args); 
-            } 
- 
-            VPatchActorIds.emplace_back(Runtime.Register(actor.Release(), nodeId)); 
-            return VPatchActorIds.back(); 
-        } 
- 
-        void WaitEndTest() { 
-            for (TActorId &edgeActor : EdgeActors) { 
-                Runtime.GrabEdgeEventRethrow<TEvRequestEnd>({edgeActor}); 
-            } 
-        } 
- 
-        void ForceEndTest() { 
+
+            if constexpr (!std::is_void_v<DecoratorType>) {
+                TVPatchDecoratorArgs args{EdgeActors[nodeId], IsCheckingEventsByDecorator,
+                        SequenceOfReceivingEvents, SequenceOfSendingEvents};
+                actor = MakeHolder<DecoratorType>(std::move(actor), args);
+            }
+
+            VPatchActorIds.emplace_back(Runtime.Register(actor.Release(), nodeId));
+            return VPatchActorIds.back();
+        }
+
+        void WaitEndTest() {
+            for (TActorId &edgeActor : EdgeActors) {
+                Runtime.GrabEdgeEventRethrow<TEvRequestEnd>({edgeActor});
+            }
+        }
+
+        void ForceEndTest() {
             std::unique_ptr<IEventHandle> handle;
-            ui32 nodeCount = Runtime.GetNodeCount(); 
-            for (ui32 nodeId = 0; nodeId < nodeCount; ++nodeId) { 
+            ui32 nodeCount = Runtime.GetNodeCount();
+            for (ui32 nodeId = 0; nodeId < nodeCount; ++nodeId) {
                 handle = std::make_unique<IEventHandle>(VPatchActorIds[nodeId], EdgeActors[nodeId],
-                        new NActors::TEvents::TEvPoisonPill); 
+                        new NActors::TEvents::TEvPoisonPill);
                 Runtime.Send(handle.release());
-            } 
-            WaitEndTest(); 
-        } 
-    }; 
- 
-    template<typename EventType> 
-    typename EventType::TPtr CreateEventHandle(const TActorId &recipient, const TActorId &sender, 
+            }
+            WaitEndTest();
+        }
+    };
+
+    template<typename EventType>
+    typename EventType::TPtr CreateEventHandle(const TActorId &recipient, const TActorId &sender,
             std::unique_ptr<EventType> &&ev)
-    { 
+    {
         return static_cast<TEventHandle<EventType>*>(new IEventHandle(recipient, sender, ev.release()));
-    } 
- 
- 
- 
-    Y_UNIT_TEST_SUITE(TVPatchTests) { 
- 
-        struct TBlob { 
-            TLogoBlobID BlobId; 
-            TString Buffer; 
- 
-            TBlob(const TLogoBlobID &blob, ui8 partId, const TString &buffer = "") 
-                : BlobId(blob, partId) 
-                , Buffer(buffer) 
-            { 
-            } 
- 
-            TBlob(const TLogoBlobID &blob, ui8 partId, ui32 bufferSize) 
-                : BlobId(blob, partId) 
-            { 
-                TStringBuilder str; 
-                for (ui32 idx = 0; idx < bufferSize; ++idx) { 
-                    str << 'a'; 
-                } 
-                Buffer = str; 
-            } 
-        }; 
- 
-        bool PassFindingParts(TVPatchTestGeneralData &testData, NKikimrProto::EReplyStatus vGetStatus, 
-                const TVector<ui8> &foundParts, ui32 nodeId = 0) { 
-            TTestActorRuntimeBase &runtime = testData.Runtime; 
-            TActorId edgeActor = testData.EdgeActors[nodeId]; 
-            TActorId vPatchActorId = testData.VPatchActorIds[nodeId]; 
- 
-            TAutoPtr<IEventHandle> handle; 
-            auto evVGetRange = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVGet>(handle); 
- 
-            UNIT_ASSERT(evVGetRange->Record.HasCookie()); 
-            UNIT_ASSERT(evVGetRange->Record.HasIndexOnly() && evVGetRange->Record.GetIndexOnly()); 
+    }
+
+
+
+    Y_UNIT_TEST_SUITE(TVPatchTests) {
+
+        struct TBlob {
+            TLogoBlobID BlobId;
+            TString Buffer;
+
+            TBlob(const TLogoBlobID &blob, ui8 partId, const TString &buffer = "")
+                : BlobId(blob, partId)
+                , Buffer(buffer)
+            {
+            }
+
+            TBlob(const TLogoBlobID &blob, ui8 partId, ui32 bufferSize)
+                : BlobId(blob, partId)
+            {
+                TStringBuilder str;
+                for (ui32 idx = 0; idx < bufferSize; ++idx) {
+                    str << 'a';
+                }
+                Buffer = str;
+            }
+        };
+
+        bool PassFindingParts(TVPatchTestGeneralData &testData, NKikimrProto::EReplyStatus vGetStatus,
+                const TVector<ui8> &foundParts, ui32 nodeId = 0) {
+            TTestActorRuntimeBase &runtime = testData.Runtime;
+            TActorId edgeActor = testData.EdgeActors[nodeId];
+            TActorId vPatchActorId = testData.VPatchActorIds[nodeId];
+
+            TAutoPtr<IEventHandle> handle;
+            auto evVGetRange = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVGet>(handle);
+
+            UNIT_ASSERT(evVGetRange->Record.HasCookie());
+            UNIT_ASSERT(evVGetRange->Record.HasIndexOnly() && evVGetRange->Record.GetIndexOnly());
             std::unique_ptr<TEvBlobStorage::TEvVGetResult> evVGetRangeResult = std::make_unique<TEvBlobStorage::TEvVGetResult>(
-                    vGetStatus, testData.VDiskIds[nodeId], testData.Now, evVGetRange->GetCachedByteSize(), &evVGetRange->Record, 
-                    nullptr, nullptr, nullptr, std::move(handle->TraceId), evVGetRange->Record.GetCookie(), 
-                    handle->GetChannel(), 0); 
- 
-            evVGetRangeResult->AddResult(NKikimrProto::OK, TLogoBlobID(testData.OriginalBlobId, 0)); 
-            for (ui8 partId : foundParts) { 
-                evVGetRangeResult->Record.MutableResult(0)->AddParts(partId); 
-            } 
+                    vGetStatus, testData.VDiskIds[nodeId], testData.Now, evVGetRange->GetCachedByteSize(), &evVGetRange->Record,
+                    nullptr, nullptr, nullptr, std::move(handle->TraceId), evVGetRange->Record.GetCookie(),
+                    handle->GetChannel(), 0);
+
+            evVGetRangeResult->AddResult(NKikimrProto::OK, TLogoBlobID(testData.OriginalBlobId, 0));
+            for (ui8 partId : foundParts) {
+                evVGetRangeResult->Record.MutableResult(0)->AddParts(partId);
+            }
             handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, evVGetRangeResult.release());
-            runtime.Send(handle.Release()); 
- 
-            auto evVPatchFoundParts = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchFoundParts>(handle); 
-            NKikimrBlobStorage::TEvVPatchFoundParts &vPatchFoundParts = evVPatchFoundParts->Record; 
-            UNIT_ASSERT(vPatchFoundParts.HasCookie()); 
-            UNIT_ASSERT(vPatchFoundParts.GetCookie() == nodeId); 
-            if (vPatchFoundParts.OriginalPartsSize()) { 
-                UNIT_ASSERT(vPatchFoundParts.HasStatus()); 
-                UNIT_ASSERT(vPatchFoundParts.GetStatus() == NKikimrProto::OK); 
- 
-                TVector<ui8> parts; 
-                parts.reserve(vPatchFoundParts.OriginalPartsSize()); 
-                for (ui64 part : vPatchFoundParts.GetOriginalParts()) { 
-                    UNIT_ASSERT(part <= TLogoBlobID::MaxPartId); 
-                    parts.push_back(part); 
-                } 
-                UNIT_ASSERT(foundParts == parts); 
-                return false; 
-            } else { 
-                UNIT_ASSERT(vPatchFoundParts.HasStatus()); 
-                return true; 
-            } 
-        } 
- 
-        void MakeVPatchFindingPartsTest(NKikimrProto::EReplyStatus vGetStatus, const TVector<ui8> &foundParts, 
-                TVector<ui64> &&receivingEvents, TVector<ui64> &&sendingEvents) 
-        { 
-            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block); 
-            TVPatchTestGeneralData testData(type, 10); 
-            TActorId edgeActor = testData.EdgeActors[0]; 
- 
-            testData.IsCheckingEventsByDecorator = true; 
-            testData.SequenceOfReceivingEvents = std::move(receivingEvents); 
-            testData.SequenceOfSendingEvents = std::move(sendingEvents); 
- 
+            runtime.Send(handle.Release());
+
+            auto evVPatchFoundParts = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchFoundParts>(handle);
+            NKikimrBlobStorage::TEvVPatchFoundParts &vPatchFoundParts = evVPatchFoundParts->Record;
+            UNIT_ASSERT(vPatchFoundParts.HasCookie());
+            UNIT_ASSERT(vPatchFoundParts.GetCookie() == nodeId);
+            if (vPatchFoundParts.OriginalPartsSize()) {
+                UNIT_ASSERT(vPatchFoundParts.HasStatus());
+                UNIT_ASSERT(vPatchFoundParts.GetStatus() == NKikimrProto::OK);
+
+                TVector<ui8> parts;
+                parts.reserve(vPatchFoundParts.OriginalPartsSize());
+                for (ui64 part : vPatchFoundParts.GetOriginalParts()) {
+                    UNIT_ASSERT(part <= TLogoBlobID::MaxPartId);
+                    parts.push_back(part);
+                }
+                UNIT_ASSERT(foundParts == parts);
+                return false;
+            } else {
+                UNIT_ASSERT(vPatchFoundParts.HasStatus());
+                return true;
+            }
+        }
+
+        void MakeVPatchFindingPartsTest(NKikimrProto::EReplyStatus vGetStatus, const TVector<ui8> &foundParts,
+                TVector<ui64> &&receivingEvents, TVector<ui64> &&sendingEvents)
+        {
+            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block);
+            TVPatchTestGeneralData testData(type, 10);
+            TActorId edgeActor = testData.EdgeActors[0];
+
+            testData.IsCheckingEventsByDecorator = true;
+            testData.SequenceOfReceivingEvents = std::move(receivingEvents);
+            testData.SequenceOfSendingEvents = std::move(sendingEvents);
+
             std::unique_ptr<TEvBlobStorage::TEvVPatchStart> start = testData.CreateVPatchStart(0);
-            TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start)); 
-            TActorId vPatchActorId = testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev)); 
- 
-            bool isKilled = PassFindingParts(testData, vGetStatus, foundParts); 
-            TAutoPtr<IEventHandle> handle; 
-            if (!isKilled) { 
+            TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start));
+            TActorId vPatchActorId = testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev));
+
+            bool isKilled = PassFindingParts(testData, vGetStatus, foundParts);
+            TAutoPtr<IEventHandle> handle;
+            if (!isKilled) {
                 std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateForceEndVPatchDiff(1, 0);
                 handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, diff.release());
-                testData.Runtime.Send(handle.Release()); 
- 
-                auto result = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle); 
-                UNIT_ASSERT(result->Record.GetStatus() == NKikimrProto::OK); 
-            } else { 
-                auto diyngRequest = testData.Runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle); 
-                UNIT_ASSERT(diyngRequest->PatchedBlobId == testData.PatchedBlobId); 
-            } 
- 
-            testData.WaitEndTest(); 
-        } 
- 
-        Y_UNIT_TEST(FindingPartsWhenPartsAreDontExist) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVPatchDyingRequest}; 
-            MakeVPatchFindingPartsTest(NKikimrProto::OK, {}, std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        Y_UNIT_TEST(FindingPartsWhenOnlyOnePartExists) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPatchDiff}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVPatchResult}; 
-            MakeVPatchFindingPartsTest(NKikimrProto::OK, {1}, std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        Y_UNIT_TEST(FindingPartsWhenSeveralPartsExist) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPatchDiff}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVPatchResult}; 
-            MakeVPatchFindingPartsTest(NKikimrProto::OK, {1, 2}, std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        Y_UNIT_TEST(FindingPartsWhenError) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVPatchDyingRequest}; 
-            MakeVPatchFindingPartsTest(NKikimrProto::ERROR, {}, std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        Y_UNIT_TEST(FindingPartsWithTimeout) { 
-            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block); 
-            TVPatchTestGeneralData testData(type, 10); 
-            TTestActorRuntimeBase &runtime = testData.Runtime; 
-            TActorId edgeActor = testData.EdgeActors[0]; 
- 
-            testData.IsCheckingEventsByDecorator = true; 
-            testData.SequenceOfReceivingEvents = {TEvents::TSystem::Bootstrap, TKikimrEvents::TSystem::Wakeup}; 
-            testData.SequenceOfSendingEvents = { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVPatchDyingRequest}; 
- 
+                testData.Runtime.Send(handle.Release());
+
+                auto result = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle);
+                UNIT_ASSERT(result->Record.GetStatus() == NKikimrProto::OK);
+            } else {
+                auto diyngRequest = testData.Runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle);
+                UNIT_ASSERT(diyngRequest->PatchedBlobId == testData.PatchedBlobId);
+            }
+
+            testData.WaitEndTest();
+        }
+
+        Y_UNIT_TEST(FindingPartsWhenPartsAreDontExist) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVPatchDyingRequest};
+            MakeVPatchFindingPartsTest(NKikimrProto::OK, {}, std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        Y_UNIT_TEST(FindingPartsWhenOnlyOnePartExists) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPatchDiff};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVPatchResult};
+            MakeVPatchFindingPartsTest(NKikimrProto::OK, {1}, std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        Y_UNIT_TEST(FindingPartsWhenSeveralPartsExist) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPatchDiff};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVPatchResult};
+            MakeVPatchFindingPartsTest(NKikimrProto::OK, {1, 2}, std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        Y_UNIT_TEST(FindingPartsWhenError) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVPatchDyingRequest};
+            MakeVPatchFindingPartsTest(NKikimrProto::ERROR, {}, std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        Y_UNIT_TEST(FindingPartsWithTimeout) {
+            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block);
+            TVPatchTestGeneralData testData(type, 10);
+            TTestActorRuntimeBase &runtime = testData.Runtime;
+            TActorId edgeActor = testData.EdgeActors[0];
+
+            testData.IsCheckingEventsByDecorator = true;
+            testData.SequenceOfReceivingEvents = {TEvents::TSystem::Bootstrap, TKikimrEvents::TSystem::Wakeup};
+            testData.SequenceOfSendingEvents = {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVPatchDyingRequest};
+
             std::unique_ptr<TEvBlobStorage::TEvVPatchStart> start = testData.CreateVPatchStart(0);
-            TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start)); 
-            TActorId actorId = testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev)); 
- 
-            runtime.EnableScheduleForActor(actorId); 
- 
-            TAutoPtr<IEventHandle> handle; 
-            auto evVPatchFoundParts = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchFoundParts>(handle); 
-            NKikimrBlobStorage::TEvVPatchFoundParts &vPatchFoundParts = evVPatchFoundParts->Record; 
-            UNIT_ASSERT_VALUES_EQUAL(vPatchFoundParts.GetStatus(), NKikimrProto::ERROR); 
- 
-            auto dyingRequest = runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle); 
-            UNIT_ASSERT_VALUES_EQUAL(dyingRequest->PatchedBlobId, testData.PatchedBlobId); 
-            testData.WaitEndTest(); 
-        } 
- 
-        bool PassPullingPart(TVPatchTestGeneralData &testData, NKikimrProto::EReplyStatus vGetStatus, 
-                const TBlob &blob, ui32 nodeId = 0) { 
-            TTestActorRuntimeBase &runtime = testData.Runtime; 
-            TActorId edgeActor = testData.EdgeActors[nodeId]; 
-            TActorId vPatchActorId = testData.VPatchActorIds[nodeId]; 
- 
- 
-            auto vGetHandle = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVGet>({edgeActor}); 
-            auto evVGet = vGetHandle->Get(); 
- 
-            UNIT_ASSERT(evVGet->Record.HasCookie()); 
-            UNIT_ASSERT(!evVGet->Record.HasIndexOnly() || !evVGet->Record.GetIndexOnly()); 
- 
+            TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start));
+            TActorId actorId = testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev));
+
+            runtime.EnableScheduleForActor(actorId);
+
+            TAutoPtr<IEventHandle> handle;
+            auto evVPatchFoundParts = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchFoundParts>(handle);
+            NKikimrBlobStorage::TEvVPatchFoundParts &vPatchFoundParts = evVPatchFoundParts->Record;
+            UNIT_ASSERT_VALUES_EQUAL(vPatchFoundParts.GetStatus(), NKikimrProto::ERROR);
+
+            auto dyingRequest = runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle);
+            UNIT_ASSERT_VALUES_EQUAL(dyingRequest->PatchedBlobId, testData.PatchedBlobId);
+            testData.WaitEndTest();
+        }
+
+        bool PassPullingPart(TVPatchTestGeneralData &testData, NKikimrProto::EReplyStatus vGetStatus,
+                const TBlob &blob, ui32 nodeId = 0) {
+            TTestActorRuntimeBase &runtime = testData.Runtime;
+            TActorId edgeActor = testData.EdgeActors[nodeId];
+            TActorId vPatchActorId = testData.VPatchActorIds[nodeId];
+
+
+            auto vGetHandle = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVGet>({edgeActor});
+            auto evVGet = vGetHandle->Get();
+
+            UNIT_ASSERT(evVGet->Record.HasCookie());
+            UNIT_ASSERT(!evVGet->Record.HasIndexOnly() || !evVGet->Record.GetIndexOnly());
+
             std::unique_ptr<TEvBlobStorage::TEvVGetResult> evVGetResult = std::make_unique<TEvBlobStorage::TEvVGetResult>(
-                    vGetStatus, testData.VDiskIds[nodeId], testData.Now, evVGet->GetCachedByteSize(), &evVGet->Record, 
-                    nullptr, nullptr, nullptr, std::move(vGetHandle->TraceId), evVGet->Record.GetCookie(), 
-                    vGetHandle->GetChannel(), 0); 
-            evVGetResult->AddResult(NKikimrProto::OK, blob.BlobId, 0, blob.Buffer.data(), blob.Buffer.size()); 
- 
+                    vGetStatus, testData.VDiskIds[nodeId], testData.Now, evVGet->GetCachedByteSize(), &evVGet->Record,
+                    nullptr, nullptr, nullptr, std::move(vGetHandle->TraceId), evVGet->Record.GetCookie(),
+                    vGetHandle->GetChannel(), 0);
+            evVGetResult->AddResult(NKikimrProto::OK, blob.BlobId, 0, blob.Buffer.data(), blob.Buffer.size());
+
             std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(vPatchActorId, edgeActor, evVGetResult.release());
             runtime.Send(handle.release());
- 
-            return vGetStatus != NKikimrProto::OK; 
-        } 
- 
-        bool PassStoringPart(TVPatchTestGeneralData &testData, NKikimrProto::EReplyStatus vPutStatus, const TBlob &blob, 
-                ui32 nodeId = 0) 
-        { 
-            TTestActorRuntimeBase &runtime = testData.Runtime; 
-            TActorId edgeActor = testData.EdgeActors[nodeId]; 
-            TActorId vPatchActorId = testData.VPatchActorIds[nodeId]; 
- 
-            TAutoPtr<IEventHandle> handle; 
-            auto vPut = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPut>(handle); 
-            NKikimrBlobStorage::TEvVPut &record = vPut->Record; 
- 
-            UNIT_ASSERT(record.HasCookie()); 
-            ui64 cookie = record.GetCookie(); 
-            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID()); 
-            UNIT_ASSERT_VALUES_EQUAL(blobId, blob.BlobId); 
-            UNIT_ASSERT_C(vPut->GetBuffer() == blob.Buffer, "NodeId# " << nodeId); 
- 
-            TOutOfSpaceStatus oos = TOutOfSpaceStatus(testData.StatusFlags, testData.ApproximateFreeSpaceShare); 
+
+            return vGetStatus != NKikimrProto::OK;
+        }
+
+        bool PassStoringPart(TVPatchTestGeneralData &testData, NKikimrProto::EReplyStatus vPutStatus, const TBlob &blob,
+                ui32 nodeId = 0)
+        {
+            TTestActorRuntimeBase &runtime = testData.Runtime;
+            TActorId edgeActor = testData.EdgeActors[nodeId];
+            TActorId vPatchActorId = testData.VPatchActorIds[nodeId];
+
+            TAutoPtr<IEventHandle> handle;
+            auto vPut = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPut>(handle);
+            NKikimrBlobStorage::TEvVPut &record = vPut->Record;
+
+            UNIT_ASSERT(record.HasCookie());
+            ui64 cookie = record.GetCookie();
+            TLogoBlobID blobId = LogoBlobIDFromLogoBlobID(record.GetBlobID());
+            UNIT_ASSERT_VALUES_EQUAL(blobId, blob.BlobId);
+            UNIT_ASSERT_C(vPut->GetBuffer() == blob.Buffer, "NodeId# " << nodeId);
+
+            TOutOfSpaceStatus oos = TOutOfSpaceStatus(testData.StatusFlags, testData.ApproximateFreeSpaceShare);
             std::unique_ptr<TEvBlobStorage::TEvVPutResult> vPutResult = std::make_unique<TEvBlobStorage::TEvVPutResult>(
-                    vPutStatus, blobId, testData.VDiskIds[nodeId], &cookie, oos, testData.Now, 
-                    0, &record, nullptr, nullptr, nullptr, vPut->GetBufferBytes(), std::move(handle->TraceId), 
-                    0, ""); 
- 
+                    vPutStatus, blobId, testData.VDiskIds[nodeId], &cookie, oos, testData.Now,
+                    0, &record, nullptr, nullptr, nullptr, vPut->GetBufferBytes(), std::move(handle->TraceId),
+                    0, "");
+
             handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, vPutResult.release());
-            runtime.Send(handle.Release()); 
-            return true; 
-        } 
- 
-        void MakeVPatchTest(NKikimrProto::EReplyStatus pullingStatus, NKikimrProto::EReplyStatus storingStatus, 
-                ui32 partSize, const TVector<ui8> &foundPartIds, ui8 pullingPart, ui32 xorReceiverCount, 
-                TVector<ui64> &&receivingEvents, TVector<ui64> &&sendingEvents) 
-        { 
-            Y_UNUSED(xorReceiverCount); 
-            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block); 
-            TVPatchTestGeneralData testData(type, 10); 
-            TTestActorRuntimeBase &runtime = testData.Runtime; 
-            TActorId edgeActor = testData.EdgeActors[0]; 
- 
-            testData.IsCheckingEventsByDecorator = true; 
-            testData.SequenceOfReceivingEvents = std::move(receivingEvents); 
-            testData.SequenceOfSendingEvents = std::move(sendingEvents); 
- 
+            runtime.Send(handle.Release());
+            return true;
+        }
+
+        void MakeVPatchTest(NKikimrProto::EReplyStatus pullingStatus, NKikimrProto::EReplyStatus storingStatus,
+                ui32 partSize, const TVector<ui8> &foundPartIds, ui8 pullingPart, ui32 xorReceiverCount,
+                TVector<ui64> &&receivingEvents, TVector<ui64> &&sendingEvents)
+        {
+            Y_UNUSED(xorReceiverCount);
+            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block);
+            TVPatchTestGeneralData testData(type, 10);
+            TTestActorRuntimeBase &runtime = testData.Runtime;
+            TActorId edgeActor = testData.EdgeActors[0];
+
+            testData.IsCheckingEventsByDecorator = true;
+            testData.SequenceOfReceivingEvents = std::move(receivingEvents);
+            testData.SequenceOfSendingEvents = std::move(sendingEvents);
+
             std::unique_ptr<TEvBlobStorage::TEvVPatchStart> start = testData.CreateVPatchStart(0);
-            TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start)); 
-            TActorId vPatchActorId = testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev)); 
- 
- 
-            bool isKilled = false; 
-            isKilled = PassFindingParts(testData, NKikimrProto::OK, foundPartIds); 
-            UNIT_ASSERT(!isKilled); 
- 
+            TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start));
+            TActorId vPatchActorId = testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev));
+
+
+            bool isKilled = false;
+            isKilled = PassFindingParts(testData, NKikimrProto::OK, foundPartIds);
+            UNIT_ASSERT(!isKilled);
+
             std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(pullingPart, false, {}, 0);
-            TAutoPtr<IEventHandle> handle; 
- 
+            TAutoPtr<IEventHandle> handle;
+
             handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, diff.release());
-            runtime.Send(handle.Release()); 
-            TBlob pullingBlob(testData.OriginalBlobId, pullingPart, partSize); 
- 
-            isKilled = PassPullingPart(testData, pullingStatus, pullingBlob); 
-            if (isKilled) { 
-                auto result = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle); 
-                UNIT_ASSERT(result->Record.GetStatus() == NKikimrProto::ERROR); 
-                testData.WaitEndTest(); 
-                return; 
-            } 
- 
-            TBlob storingBlob = pullingBlob; 
-            storingBlob.BlobId = TLogoBlobID(testData.PatchedBlobId, pullingPart); 
-            isKilled = PassStoringPart(testData, storingStatus, storingBlob); 
-            NKikimrProto::EReplyStatus expectedResultStatus = 
-                    (storingStatus != NKikimrProto::OK) ? NKikimrProto::ERROR : NKikimrProto::OK; 
- 
-            auto result = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle); 
-            UNIT_ASSERT(result->Record.GetStatus() == expectedResultStatus); 
-            UNIT_ASSERT(result->Record.GetStatusFlags() == testData.StatusFlags); 
-            UNIT_ASSERT(result->Record.GetApproximateFreeSpaceShare() == testData.ApproximateFreeSpaceShare); 
-            testData.WaitEndTest(); 
-        } 
- 
-        Y_UNIT_TEST(PatchPartOk) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPatchDiff, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPutResult}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPut, 
-                    TEvBlobStorage::EvVPatchResult}; 
- 
-            TVector<ui8> foundPartIds = {1}; 
-            MakeVPatchTest(NKikimrProto::OK, NKikimrProto::OK, 100, {1}, 1, 0, 
-                    std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        Y_UNIT_TEST(PatchPartGetError) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPatchDiff, 
-                    TEvBlobStorage::EvVGetResult}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchResult}; 
- 
-            TVector<ui8> foundPartIds = {1}; 
-            MakeVPatchTest(NKikimrProto::ERROR, NKikimrProto::OK, 100, {1}, 1, 0, 
-                    std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        Y_UNIT_TEST(PatchPartPutError) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPatchDiff, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPutResult}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPut, 
-                    TEvBlobStorage::EvVPatchResult}; 
- 
-            TVector<ui8> foundPartIds = {1}; 
-            MakeVPatchTest(NKikimrProto::OK, NKikimrProto::ERROR, 100, {1}, 1, 0, 
-                    std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        void SendXorDiff(TVPatchTestGeneralData &testData, const TVector<TDiff> &xorDiffs, ui32 toPart, ui32 nodeId = 0) { 
-            TTestActorRuntimeBase &runtime = testData.Runtime; 
-            TActorId edgeActor = testData.EdgeActors[nodeId]; 
-            TActorId vPatchActorId = testData.VPatchActorIds[nodeId]; 
-            TVDiskID vDiskId = testData.VDiskIds[nodeId]; 
- 
+            runtime.Send(handle.Release());
+            TBlob pullingBlob(testData.OriginalBlobId, pullingPart, partSize);
+
+            isKilled = PassPullingPart(testData, pullingStatus, pullingBlob);
+            if (isKilled) {
+                auto result = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle);
+                UNIT_ASSERT(result->Record.GetStatus() == NKikimrProto::ERROR);
+                testData.WaitEndTest();
+                return;
+            }
+
+            TBlob storingBlob = pullingBlob;
+            storingBlob.BlobId = TLogoBlobID(testData.PatchedBlobId, pullingPart);
+            isKilled = PassStoringPart(testData, storingStatus, storingBlob);
+            NKikimrProto::EReplyStatus expectedResultStatus =
+                    (storingStatus != NKikimrProto::OK) ? NKikimrProto::ERROR : NKikimrProto::OK;
+
+            auto result = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle);
+            UNIT_ASSERT(result->Record.GetStatus() == expectedResultStatus);
+            UNIT_ASSERT(result->Record.GetStatusFlags() == testData.StatusFlags);
+            UNIT_ASSERT(result->Record.GetApproximateFreeSpaceShare() == testData.ApproximateFreeSpaceShare);
+            testData.WaitEndTest();
+        }
+
+        Y_UNIT_TEST(PatchPartOk) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPatchDiff,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPutResult};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPut,
+                    TEvBlobStorage::EvVPatchResult};
+
+            TVector<ui8> foundPartIds = {1};
+            MakeVPatchTest(NKikimrProto::OK, NKikimrProto::OK, 100, {1}, 1, 0,
+                    std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        Y_UNIT_TEST(PatchPartGetError) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPatchDiff,
+                    TEvBlobStorage::EvVGetResult};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchResult};
+
+            TVector<ui8> foundPartIds = {1};
+            MakeVPatchTest(NKikimrProto::ERROR, NKikimrProto::OK, 100, {1}, 1, 0,
+                    std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        Y_UNIT_TEST(PatchPartPutError) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPatchDiff,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPutResult};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPut,
+                    TEvBlobStorage::EvVPatchResult};
+
+            TVector<ui8> foundPartIds = {1};
+            MakeVPatchTest(NKikimrProto::OK, NKikimrProto::ERROR, 100, {1}, 1, 0,
+                    std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        void SendXorDiff(TVPatchTestGeneralData &testData, const TVector<TDiff> &xorDiffs, ui32 toPart, ui32 nodeId = 0) {
+            TTestActorRuntimeBase &runtime = testData.Runtime;
+            TActorId edgeActor = testData.EdgeActors[nodeId];
+            TActorId vPatchActorId = testData.VPatchActorIds[nodeId];
+            TVDiskID vDiskId = testData.VDiskIds[nodeId];
+
             std::unique_ptr<TEvBlobStorage::TEvVPatchXorDiff> xorDiff = std::make_unique<TEvBlobStorage::TEvVPatchXorDiff>(
-                    TLogoBlobID(testData.OriginalBlobId, toPart), 
-                    TLogoBlobID(testData.PatchedBlobId, toPart), 
-                    vDiskId, toPart, testData.Deadline, 0); 
-            for (auto &diff : xorDiffs) { 
-                xorDiff->AddDiff(diff.Offset, diff.Buffer); 
-            } 
- 
+                    TLogoBlobID(testData.OriginalBlobId, toPart),
+                    TLogoBlobID(testData.PatchedBlobId, toPart),
+                    vDiskId, toPart, testData.Deadline, 0);
+            for (auto &diff : xorDiffs) {
+                xorDiff->AddDiff(diff.Offset, diff.Buffer);
+            }
+
             std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(vPatchActorId, edgeActor, xorDiff.release());
             runtime.Send(handle.release());
-        } 
- 
-        void ReceiveVPatchResult(TVPatchTestGeneralData &testData, NKikimrProto::EReplyStatus status) { 
-            TAutoPtr<IEventHandle> handle; 
-            auto result = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle); 
-            UNIT_ASSERT(result->Record.GetStatus() == status); 
-        } 
- 
-        void MakeXorDiffFaultToleranceTest(NKikimrProto::EReplyStatus status, ui64 partSize, 
-                const TVector<TDiff> &diffs, TVector<ui64> &&receivingEvents, TVector<ui64> &&sendingEvents) 
-        { 
-            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block); 
-            TVPatchTestGeneralData testData(type, partSize); 
-            TTestActorRuntimeBase &runtime = testData.Runtime; 
-            TActorId edgeActor = testData.EdgeActors[0]; 
- 
-            testData.IsCheckingEventsByDecorator = true; 
-            testData.SequenceOfReceivingEvents = std::move(receivingEvents); 
-            testData.SequenceOfSendingEvents = std::move(sendingEvents); 
- 
+        }
+
+        void ReceiveVPatchResult(TVPatchTestGeneralData &testData, NKikimrProto::EReplyStatus status) {
+            TAutoPtr<IEventHandle> handle;
+            auto result = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle);
+            UNIT_ASSERT(result->Record.GetStatus() == status);
+        }
+
+        void MakeXorDiffFaultToleranceTest(NKikimrProto::EReplyStatus status, ui64 partSize,
+                const TVector<TDiff> &diffs, TVector<ui64> &&receivingEvents, TVector<ui64> &&sendingEvents)
+        {
+            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block);
+            TVPatchTestGeneralData testData(type, partSize);
+            TTestActorRuntimeBase &runtime = testData.Runtime;
+            TActorId edgeActor = testData.EdgeActors[0];
+
+            testData.IsCheckingEventsByDecorator = true;
+            testData.SequenceOfReceivingEvents = std::move(receivingEvents);
+            testData.SequenceOfSendingEvents = std::move(sendingEvents);
+
             std::unique_ptr<TEvBlobStorage::TEvVPatchStart> start = testData.CreateVPatchStart(0);
-            TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start)); 
-            TActorId vPatchActorId = testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev)); 
- 
-            ui8 partId = type.DataParts() + 1; 
-            bool isKilled = false; 
-            isKilled = PassFindingParts(testData, NKikimrProto::OK, {partId}); 
-            UNIT_ASSERT(!isKilled); 
- 
-            SendXorDiff(testData, diffs, type.DataParts()); 
+            TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start));
+            TActorId vPatchActorId = testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev));
+
+            ui8 partId = type.DataParts() + 1;
+            bool isKilled = false;
+            isKilled = PassFindingParts(testData, NKikimrProto::OK, {partId});
+            UNIT_ASSERT(!isKilled);
+
+            SendXorDiff(testData, diffs, type.DataParts());
             std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(partId, 1, {}, 0);
             std::unique_ptr<IEventHandle> handle;
- 
+
             handle = std::make_unique<IEventHandle>(vPatchActorId, edgeActor, diff.release());
             runtime.Send(handle.release());
- 
-            if (status != NKikimrProto::OK) { 
-                TAutoPtr<IEventHandle> handle; 
-                testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchXorDiffResult>(handle); 
-                ReceiveVPatchResult(testData, status); 
-                testData.WaitEndTest(); 
-            } else { 
-                testData.ForceEndTest(); 
-            } 
- 
-        } 
- 
-        Y_UNIT_TEST(PatchPartFastXorDiffWithEmptyDiffBuffer) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPatchXorDiff, 
-                    TEvBlobStorage::EvVPatchDiff, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPutResult}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPut, 
-                    TEvBlobStorage::EvVPatchResult, 
-                    TEvBlobStorage::EvVPatchResult}; 
- 
-            TVector<TDiff> diffs; 
-            diffs.emplace_back("", 0, true, false); 
-            MakeXorDiffFaultToleranceTest(NKikimrProto::OK, 100, diffs, 
-                    std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        Y_UNIT_TEST(PatchPartFastXorDiffBeyoundBlob) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPatchXorDiff, 
-                    TEvBlobStorage::EvVPatchDiff,}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVPatchXorDiffResult, 
-                    TEvBlobStorage::EvVPatchResult}; 
- 
-            TVector<TDiff> diffs; 
-            diffs.emplace_back("", 100, true, false); 
-            MakeXorDiffFaultToleranceTest(NKikimrProto::ERROR, 100, diffs, 
-                    std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        Y_UNIT_TEST(PatchPartFastXorDiffDisorder) { 
-            TVector<ui64> receivingEvents { 
-                    TEvents::TSystem::Bootstrap, 
-                    TEvBlobStorage::EvVGetResult, 
-                    TEvBlobStorage::EvVPatchXorDiff, 
-                    TEvBlobStorage::EvVPatchDiff,}; 
-            TVector<ui64> sendingEvents { 
-                    TEvBlobStorage::EvVGet, 
-                    TEvBlobStorage::EvVPatchFoundParts, 
-                    TEvBlobStorage::EvVPatchXorDiffResult, 
-                    TEvBlobStorage::EvVPatchResult}; 
- 
-            TVector<TDiff> diffs; 
-            diffs.emplace_back("aa", 3, true, false); 
-            diffs.emplace_back("aa", 0, true, false); 
-            MakeXorDiffFaultToleranceTest(NKikimrProto::ERROR, 100, diffs, 
-                    std::move(receivingEvents), std::move(sendingEvents)); 
-        } 
- 
-        void MakeFullVPatchTest(const TBlobStorageGroupType &type, const TString &data, const TVector<TDiff> &diffs, 
-                bool quickXorDiffs = false) 
-        { 
-            ui32 nodeCount = type.TotalPartCount(); 
-            TVPatchTestGeneralData testData(type, data.Size(), nodeCount); 
- 
-            for (ui32 nodeIdx = 0; nodeIdx < nodeCount; ++nodeIdx) { 
+
+            if (status != NKikimrProto::OK) {
+                TAutoPtr<IEventHandle> handle;
+                testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchXorDiffResult>(handle);
+                ReceiveVPatchResult(testData, status);
+                testData.WaitEndTest();
+            } else {
+                testData.ForceEndTest();
+            }
+
+        }
+
+        Y_UNIT_TEST(PatchPartFastXorDiffWithEmptyDiffBuffer) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPatchXorDiff,
+                    TEvBlobStorage::EvVPatchDiff,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPutResult};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPut,
+                    TEvBlobStorage::EvVPatchResult,
+                    TEvBlobStorage::EvVPatchResult};
+
+            TVector<TDiff> diffs;
+            diffs.emplace_back("", 0, true, false);
+            MakeXorDiffFaultToleranceTest(NKikimrProto::OK, 100, diffs,
+                    std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        Y_UNIT_TEST(PatchPartFastXorDiffBeyoundBlob) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPatchXorDiff,
+                    TEvBlobStorage::EvVPatchDiff,};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVPatchXorDiffResult,
+                    TEvBlobStorage::EvVPatchResult};
+
+            TVector<TDiff> diffs;
+            diffs.emplace_back("", 100, true, false);
+            MakeXorDiffFaultToleranceTest(NKikimrProto::ERROR, 100, diffs,
+                    std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        Y_UNIT_TEST(PatchPartFastXorDiffDisorder) {
+            TVector<ui64> receivingEvents {
+                    TEvents::TSystem::Bootstrap,
+                    TEvBlobStorage::EvVGetResult,
+                    TEvBlobStorage::EvVPatchXorDiff,
+                    TEvBlobStorage::EvVPatchDiff,};
+            TVector<ui64> sendingEvents {
+                    TEvBlobStorage::EvVGet,
+                    TEvBlobStorage::EvVPatchFoundParts,
+                    TEvBlobStorage::EvVPatchXorDiffResult,
+                    TEvBlobStorage::EvVPatchResult};
+
+            TVector<TDiff> diffs;
+            diffs.emplace_back("aa", 3, true, false);
+            diffs.emplace_back("aa", 0, true, false);
+            MakeXorDiffFaultToleranceTest(NKikimrProto::ERROR, 100, diffs,
+                    std::move(receivingEvents), std::move(sendingEvents));
+        }
+
+        void MakeFullVPatchTest(const TBlobStorageGroupType &type, const TString &data, const TVector<TDiff> &diffs,
+                bool quickXorDiffs = false)
+        {
+            ui32 nodeCount = type.TotalPartCount();
+            TVPatchTestGeneralData testData(type, data.Size(), nodeCount);
+
+            for (ui32 nodeIdx = 0; nodeIdx < nodeCount; ++nodeIdx) {
                 std::unique_ptr<TEvBlobStorage::TEvVPatchStart> start = testData.CreateVPatchStart(nodeIdx, nodeIdx);
-                TActorId edgeActor = testData.EdgeActors[nodeIdx]; 
-                TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start)); 
-                testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev), nodeIdx); 
-            } 
- 
-            TString savedData = TString::Uninitialized(data.size()); 
-            memcpy(savedData.begin(), data.begin(), data.size()); 
- 
-            TString result = TString::Uninitialized(data.size()); 
-            memcpy(result.begin(), data.begin(), data.size()); 
-            ui8 *resultBytes = reinterpret_cast<ui8*>(const_cast<char*>(result.data())); 
-            type.ApplyDiff(TErasureType::CrcModeNone, resultBytes, diffs); 
-            TDataPartSet partSet; 
-            TDataPartSet resultPartSet; 
-            TDataPartSet savedPartSet; 
-            type.SplitData(TErasureType::CrcModeNone, data, partSet); 
-            type.SplitData(TErasureType::CrcModeNone, savedData, savedPartSet); 
-            type.SplitData(TErasureType::CrcModeNone, result, resultPartSet); 
- 
-            TPartDiffSet diffSet; 
-            type.SplitDiffs(TErasureType::CrcModeNone, data.size(), diffs, diffSet); 
- 
-            for (ui32 nodeIdx = 0; nodeIdx < nodeCount; ++nodeIdx) { 
-                ui8 partId = nodeIdx + 1; 
-                PassFindingParts(testData, NKikimrProto::OK, {partId}, nodeIdx);; 
-            } 
- 
-            ui32 dataPartCount = type.DataParts(); 
-            ui32 totalPartCount = type.TotalPartCount(); 
- 
-            ui32 dataDiffCount = 0; 
-            for (ui32 partIdx = 0; partIdx < dataPartCount; ++partIdx) { 
-                ui32 partId = partIdx + 1; 
+                TActorId edgeActor = testData.EdgeActors[nodeIdx];
+                TEvBlobStorage::TEvVPatchStart::TPtr ev = CreateEventHandle(edgeActor, edgeActor, std::move(start));
+                testData.CreateTVPatchActor<TVPatchDecorator>(std::move(ev), nodeIdx);
+            }
+
+            TString savedData = TString::Uninitialized(data.size());
+            memcpy(savedData.begin(), data.begin(), data.size());
+
+            TString result = TString::Uninitialized(data.size());
+            memcpy(result.begin(), data.begin(), data.size());
+            ui8 *resultBytes = reinterpret_cast<ui8*>(const_cast<char*>(result.data()));
+            type.ApplyDiff(TErasureType::CrcModeNone, resultBytes, diffs);
+            TDataPartSet partSet;
+            TDataPartSet resultPartSet;
+            TDataPartSet savedPartSet;
+            type.SplitData(TErasureType::CrcModeNone, data, partSet);
+            type.SplitData(TErasureType::CrcModeNone, savedData, savedPartSet);
+            type.SplitData(TErasureType::CrcModeNone, result, resultPartSet);
+
+            TPartDiffSet diffSet;
+            type.SplitDiffs(TErasureType::CrcModeNone, data.size(), diffs, diffSet);
+
+            for (ui32 nodeIdx = 0; nodeIdx < nodeCount; ++nodeIdx) {
+                ui8 partId = nodeIdx + 1;
+                PassFindingParts(testData, NKikimrProto::OK, {partId}, nodeIdx);;
+            }
+
+            ui32 dataPartCount = type.DataParts();
+            ui32 totalPartCount = type.TotalPartCount();
+
+            ui32 dataDiffCount = 0;
+            for (ui32 partIdx = 0; partIdx < dataPartCount; ++partIdx) {
+                ui32 partId = partIdx + 1;
                 std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(partId, 0,
-                        diffSet.PartDiffs[partIdx].Diffs, 0, partIdx); 
- 
-                for (ui32 parityPartIdx = dataPartCount; parityPartIdx < totalPartCount; ++parityPartIdx) { 
-                    diff->AddXorReceiver(testData.VDiskIds[parityPartIdx], parityPartIdx + 1); 
-                } 
- 
+                        diffSet.PartDiffs[partIdx].Diffs, 0, partIdx);
+
+                for (ui32 parityPartIdx = dataPartCount; parityPartIdx < totalPartCount; ++parityPartIdx) {
+                    diff->AddXorReceiver(testData.VDiskIds[parityPartIdx], parityPartIdx + 1);
+                }
+
                 std::unique_ptr<IEventHandle> handle;
                 handle = std::make_unique<IEventHandle>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
                         diff.release());
                 testData.Runtime.Send(handle.release());
-                dataDiffCount++; 
-            } 
- 
-            for (ui32 partIdx = 0; partIdx < dataPartCount; ++partIdx) { 
-                ui32 partId = partIdx + 1; 
-                TBlob pullingBlob(testData.OriginalBlobId, partId, partSet.Parts[partIdx].OwnedString); 
-                PassPullingPart(testData, NKikimrProto::OK, pullingBlob, partIdx); 
-            } 
- 
-            if (!quickXorDiffs) { 
-                for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) { 
-                    ui32 partId = partIdx + 1; 
+                dataDiffCount++;
+            }
+
+            for (ui32 partIdx = 0; partIdx < dataPartCount; ++partIdx) {
+                ui32 partId = partIdx + 1;
+                TBlob pullingBlob(testData.OriginalBlobId, partId, partSet.Parts[partIdx].OwnedString);
+                PassPullingPart(testData, NKikimrProto::OK, pullingBlob, partIdx);
+            }
+
+            if (!quickXorDiffs) {
+                for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) {
+                    ui32 partId = partIdx + 1;
                     std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(partId, dataDiffCount,
-                            {}, 0, partIdx); 
+                            {}, 0, partIdx);
                     std::unique_ptr<IEventHandle> handle;
                     handle = std::make_unique<IEventHandle>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
                             diff.release());
                     testData.Runtime.Send(handle.release());
-                } 
- 
-                for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) { 
-                    ui32 partId = partIdx + 1; 
-                    TBlob pullingBlob(testData.OriginalBlobId, partId, savedPartSet.Parts[partIdx].OwnedString); 
-                    PassPullingPart(testData, NKikimrProto::OK, pullingBlob, partIdx); 
-                } 
-            } 
- 
-            for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) { 
-                for (ui32 dataDiffIdx = 0; dataDiffIdx < dataDiffCount; ++dataDiffIdx) { 
-                    TActorId edgeActor = testData.EdgeActors[partIdx]; 
-                    auto handle = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchXorDiff>({edgeActor}); 
-                    auto &record = handle->Get()->Record; 
- 
-                    ui8 fromPartId = record.GetFromPartId(); 
-                    ui32 patchedPartId = LogoBlobIDFromLogoBlobID(record.GetPatchedPartBlobId()).PartId(); 
- 
-                    TVector<TDiff> xorDiffs; 
-                    const ui8 *buffer = reinterpret_cast<const ui8*>(partSet.Parts[fromPartId - 1].OwnedString.data()); 
-                    testData.GType.MakeXorDiff(TErasureType::CrcModeNone, data.size(), buffer, diffSet.PartDiffs[fromPartId - 1].Diffs, &xorDiffs); 
- 
-                    UNIT_ASSERT_VALUES_EQUAL_C(xorDiffs.size(), record.DiffsSize(), "from# " << (ui32)fromPartId); 
-                    for (ui32 idx = 0; idx < xorDiffs.size(); ++idx) { 
-                        UNIT_ASSERT_VALUES_EQUAL_C(xorDiffs[idx].Offset, record.GetDiffs(idx).GetOffset(), "from# " << (ui32)fromPartId); 
-                        UNIT_ASSERT_EQUAL(xorDiffs[idx].Buffer, record.GetDiffs(idx).GetBuffer()); 
-                    } 
- 
-                    TActorId patchActor = testData.VPatchActorIds[patchedPartId - 1]; 
+                }
+
+                for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) {
+                    ui32 partId = partIdx + 1;
+                    TBlob pullingBlob(testData.OriginalBlobId, partId, savedPartSet.Parts[partIdx].OwnedString);
+                    PassPullingPart(testData, NKikimrProto::OK, pullingBlob, partIdx);
+                }
+            }
+
+            for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) {
+                for (ui32 dataDiffIdx = 0; dataDiffIdx < dataDiffCount; ++dataDiffIdx) {
+                    TActorId edgeActor = testData.EdgeActors[partIdx];
+                    auto handle = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchXorDiff>({edgeActor});
+                    auto &record = handle->Get()->Record;
+
+                    ui8 fromPartId = record.GetFromPartId();
+                    ui32 patchedPartId = LogoBlobIDFromLogoBlobID(record.GetPatchedPartBlobId()).PartId();
+
+                    TVector<TDiff> xorDiffs;
+                    const ui8 *buffer = reinterpret_cast<const ui8*>(partSet.Parts[fromPartId - 1].OwnedString.data());
+                    testData.GType.MakeXorDiff(TErasureType::CrcModeNone, data.size(), buffer, diffSet.PartDiffs[fromPartId - 1].Diffs, &xorDiffs);
+
+                    UNIT_ASSERT_VALUES_EQUAL_C(xorDiffs.size(), record.DiffsSize(), "from# " << (ui32)fromPartId);
+                    for (ui32 idx = 0; idx < xorDiffs.size(); ++idx) {
+                        UNIT_ASSERT_VALUES_EQUAL_C(xorDiffs[idx].Offset, record.GetDiffs(idx).GetOffset(), "from# " << (ui32)fromPartId);
+                        UNIT_ASSERT_EQUAL(xorDiffs[idx].Buffer, record.GetDiffs(idx).GetBuffer());
+                    }
+
+                    TActorId patchActor = testData.VPatchActorIds[patchedPartId - 1];
                     auto handle2 = std::make_unique<IEventHandle>(patchActor, edgeActor, handle->Release().Release(), handle->Flags,
-                            handle->Cookie, nullptr, std::move(handle->TraceId)); 
+                            handle->Cookie, nullptr, std::move(handle->TraceId));
                     testData.Runtime.Send(handle2.release());
-                } 
-            } 
- 
-            for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) { 
-                UNIT_ASSERT_EQUAL(partSet.Parts[partIdx].OwnedString, savedPartSet.Parts[partIdx].OwnedString); 
-            } 
- 
-            if (quickXorDiffs) { 
-                for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) { 
-                    ui32 partId = partIdx + 1; 
+                }
+            }
+
+            for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) {
+                UNIT_ASSERT_EQUAL(partSet.Parts[partIdx].OwnedString, savedPartSet.Parts[partIdx].OwnedString);
+            }
+
+            if (quickXorDiffs) {
+                for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) {
+                    ui32 partId = partIdx + 1;
                     std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(partId, dataDiffCount,
-                            {}, 0, partIdx); 
+                            {}, 0, partIdx);
                     std::unique_ptr<IEventHandle> handle;
                     handle = std::make_unique<IEventHandle>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
                             diff.release());
                     testData.Runtime.Send(handle.release());
-                } 
- 
-                for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) { 
-                    ui32 partId = partIdx + 1; 
-                    TBlob pullingBlob(testData.OriginalBlobId, partId, savedPartSet.Parts[partIdx].OwnedString); 
-                    PassPullingPart(testData, NKikimrProto::OK, pullingBlob, partIdx); 
-                } 
-            } 
- 
-            // receive xor diff's results 
-            for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) { 
-                for (ui32 dataDiffIdx = 0; dataDiffIdx < dataDiffCount; ++dataDiffIdx) { 
-                    TActorId edgeActor = testData.EdgeActors[partIdx]; 
-                    testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchXorDiffResult>({edgeActor}); 
-                } 
-            } 
- 
-            for (ui32 partIdx = 0; partIdx < totalPartCount; ++partIdx) { 
-                ui32 partId = partIdx + 1; 
-                TBlob storingBlob(testData.PatchedBlobId, partId, resultPartSet.Parts[partIdx].OwnedString); 
-                PassStoringPart(testData, NKikimrProto::OK, storingBlob, partIdx); 
-            } 
- 
-            testData.ForceEndTest(); 
-            Y_UNUSED(partSet, resultPartSet, diffSet); 
-        } 
- 
-       Y_UNIT_TEST(FullPatchTest) { 
-            ui32 dataSize = 2079; 
-            TString data = TString::Uninitialized(dataSize); 
-            Fill(data.begin(), data.vend(), 'a'); 
- 
-            ui32 diffSize = 31; 
-            UNIT_ASSERT(dataSize % (diffSize + 1) == diffSize); 
-            ui32 diffCount = dataSize / (diffSize + 1) + 1; 
-            TVector<TDiff> diffs; 
-            diffs.reserve(diffCount); 
-            ui32 left = 0; 
-            for (ui32 idx = 0; idx < diffCount; ++idx) { 
-                TString buffer = TString::Uninitialized(diffSize); 
-                Fill(buffer.begin(), buffer.vend(), 'a' + 1 + (idx % 25)); 
-                diffs.emplace_back(buffer, left); 
-                left += diffSize + 1; 
-            } 
- 
-            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block); 
-            MakeFullVPatchTest(type, data, diffs); 
-        } 
- 
-       Y_UNIT_TEST(FullPatchTestXorDiffFasterVGetResult) { 
-            ui32 dataSize = 2079; 
-            TString data = TString::Uninitialized(dataSize); 
-            Fill(data.begin(), data.vend(), 'a'); 
- 
-            ui32 diffSize = 31; 
-            UNIT_ASSERT(dataSize % (diffSize + 1) == diffSize); 
-            ui32 diffCount = dataSize / (diffSize + 1) + 1; 
-            TVector<TDiff> diffs; 
-            diffs.reserve(diffCount); 
-            ui32 left = 0; 
-            for (ui32 idx = 0; idx < diffCount; ++idx) { 
-                TString buffer = TString::Uninitialized(diffSize); 
-                Fill(buffer.begin(), buffer.vend(), 'a' + 1 + (idx % 25)); 
-                diffs.emplace_back(buffer, left); 
-                left += diffSize + 1; 
-            } 
- 
-            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block); 
-            MakeFullVPatchTest(type, data, diffs, true); 
-        } 
- 
-       Y_UNIT_TEST(FullPatchTestSpecialCase1) { 
-            ui32 dataSize = 100; 
-            TString data = TString::Uninitialized(dataSize); 
-            Fill(data.begin(), data.vend(), 'a'); 
- 
-            TVector<TDiff> diffs; 
-            diffs.reserve(2); 
-            diffs.emplace_back("b", 0); 
-            diffs.emplace_back("b", 99); 
- 
-            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block); 
-            MakeFullVPatchTest(type, data, diffs, true); 
-        } 
-    } 
- 
-} // NKikimr 
+                }
+
+                for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) {
+                    ui32 partId = partIdx + 1;
+                    TBlob pullingBlob(testData.OriginalBlobId, partId, savedPartSet.Parts[partIdx].OwnedString);
+                    PassPullingPart(testData, NKikimrProto::OK, pullingBlob, partIdx);
+                }
+            }
+
+            // receive xor diff's results
+            for (ui32 partIdx = dataPartCount; partIdx < totalPartCount; ++partIdx) {
+                for (ui32 dataDiffIdx = 0; dataDiffIdx < dataDiffCount; ++dataDiffIdx) {
+                    TActorId edgeActor = testData.EdgeActors[partIdx];
+                    testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchXorDiffResult>({edgeActor});
+                }
+            }
+
+            for (ui32 partIdx = 0; partIdx < totalPartCount; ++partIdx) {
+                ui32 partId = partIdx + 1;
+                TBlob storingBlob(testData.PatchedBlobId, partId, resultPartSet.Parts[partIdx].OwnedString);
+                PassStoringPart(testData, NKikimrProto::OK, storingBlob, partIdx);
+            }
+
+            testData.ForceEndTest();
+            Y_UNUSED(partSet, resultPartSet, diffSet);
+        }
+
+       Y_UNIT_TEST(FullPatchTest) {
+            ui32 dataSize = 2079;
+            TString data = TString::Uninitialized(dataSize);
+            Fill(data.begin(), data.vend(), 'a');
+
+            ui32 diffSize = 31;
+            UNIT_ASSERT(dataSize % (diffSize + 1) == diffSize);
+            ui32 diffCount = dataSize / (diffSize + 1) + 1;
+            TVector<TDiff> diffs;
+            diffs.reserve(diffCount);
+            ui32 left = 0;
+            for (ui32 idx = 0; idx < diffCount; ++idx) {
+                TString buffer = TString::Uninitialized(diffSize);
+                Fill(buffer.begin(), buffer.vend(), 'a' + 1 + (idx % 25));
+                diffs.emplace_back(buffer, left);
+                left += diffSize + 1;
+            }
+
+            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block);
+            MakeFullVPatchTest(type, data, diffs);
+        }
+
+       Y_UNIT_TEST(FullPatchTestXorDiffFasterVGetResult) {
+            ui32 dataSize = 2079;
+            TString data = TString::Uninitialized(dataSize);
+            Fill(data.begin(), data.vend(), 'a');
+
+            ui32 diffSize = 31;
+            UNIT_ASSERT(dataSize % (diffSize + 1) == diffSize);
+            ui32 diffCount = dataSize / (diffSize + 1) + 1;
+            TVector<TDiff> diffs;
+            diffs.reserve(diffCount);
+            ui32 left = 0;
+            for (ui32 idx = 0; idx < diffCount; ++idx) {
+                TString buffer = TString::Uninitialized(diffSize);
+                Fill(buffer.begin(), buffer.vend(), 'a' + 1 + (idx % 25));
+                diffs.emplace_back(buffer, left);
+                left += diffSize + 1;
+            }
+
+            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block);
+            MakeFullVPatchTest(type, data, diffs, true);
+        }
+
+       Y_UNIT_TEST(FullPatchTestSpecialCase1) {
+            ui32 dataSize = 100;
+            TString data = TString::Uninitialized(dataSize);
+            Fill(data.begin(), data.vend(), 'a');
+
+            TVector<TDiff> diffs;
+            diffs.reserve(2);
+            diffs.emplace_back("b", 0);
+            diffs.emplace_back("b", 99);
+
+            TBlobStorageGroupType type(TErasureType::Erasure4Plus2Block);
+            MakeFullVPatchTest(type, data, diffs, true);
+        }
+    }
+
+} // NKikimr
diff --git a/ydb/core/blobstorage/vdisk/skeleton/ut/ya.make b/ydb/core/blobstorage/vdisk/skeleton/ut/ya.make
index 426f765888..67d78277da 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/ut/ya.make
+++ b/ydb/core/blobstorage/vdisk/skeleton/ut/ya.make
@@ -20,9 +20,9 @@ PEERDIR(
 
 SRCS(
     skeleton_oos_logic_ut.cpp
-    skeleton_vpatch_actor_ut.cpp 
+    skeleton_vpatch_actor_ut.cpp
 )
 
-YQL_LAST_ABI_VERSION() 
- 
+YQL_LAST_ABI_VERSION()
+
 END()
diff --git a/ydb/core/blobstorage/vdisk/skeleton/ya.make b/ydb/core/blobstorage/vdisk/skeleton/ya.make
index e649cec219..892b79e6e1 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/ya.make
+++ b/ydb/core/blobstorage/vdisk/skeleton/ya.make
@@ -41,10 +41,10 @@ SRCS(
     skeleton_overload_handler.h
     skeleton_vmultiput_actor.cpp
     skeleton_vmultiput_actor.h
-    skeleton_vmovedpatch_actor.cpp 
-    skeleton_vmovedpatch_actor.h 
-    skeleton_vpatch_actor.cpp 
-    skeleton_vpatch_actor.h 
+    skeleton_vmovedpatch_actor.cpp
+    skeleton_vmovedpatch_actor.h
+    skeleton_vpatch_actor.cpp
+    skeleton_vpatch_actor.h
 )
 
 END()
diff --git a/ydb/core/control/immediate_control_board_wrapper.h b/ydb/core/control/immediate_control_board_wrapper.h
index 69e210355d..ce8a6adde5 100644
--- a/ydb/core/control/immediate_control_board_wrapper.h
+++ b/ydb/core/control/immediate_control_board_wrapper.h
@@ -31,34 +31,34 @@ public:
     }
 };
 
-class TMemorizableControlWrapper { 
-    static constexpr i32 RequestCountWithRelevantValue = 1024; 
-    static constexpr TDuration TimeDurationWithRelevantValue = TDuration::Seconds(15); 
-    TControlWrapper Control; 
-    TInstant CheckingRelevantDeadline; 
-    i32 CheckingCounter = 0; 
-    i64 CurrentValue = 0; 
- 
-public: 
-    TMemorizableControlWrapper(const TControlWrapper &control) 
-        : Control(control) 
-        , CurrentValue(Control) 
-    { 
-    } 
- 
-    i64 Update(TInstant now) { 
-        CheckingCounter--; 
-        if (now > CheckingRelevantDeadline || CheckingCounter <= 0) { 
-            CurrentValue = Control; 
-            CheckingRelevantDeadline = now + TimeDurationWithRelevantValue; 
-            CheckingCounter = RequestCountWithRelevantValue; 
-        } 
-        return CurrentValue; 
-    } 
- 
-    operator i64() const { 
-        return CurrentValue; 
-    } 
-}; 
- 
+class TMemorizableControlWrapper {
+    static constexpr i32 RequestCountWithRelevantValue = 1024;
+    static constexpr TDuration TimeDurationWithRelevantValue = TDuration::Seconds(15);
+    TControlWrapper Control;
+    TInstant CheckingRelevantDeadline;
+    i32 CheckingCounter = 0;
+    i64 CurrentValue = 0;
+
+public:
+    TMemorizableControlWrapper(const TControlWrapper &control)
+        : Control(control)
+        , CurrentValue(Control)
+    {
+    }
+
+    i64 Update(TInstant now) {
+        CheckingCounter--;
+        if (now > CheckingRelevantDeadline || CheckingCounter <= 0) {
+            CurrentValue = Control;
+            CheckingRelevantDeadline = now + TimeDurationWithRelevantValue;
+            CheckingCounter = RequestCountWithRelevantValue;
+        }
+        return CurrentValue;
+    }
+
+    operator i64() const {
+        return CurrentValue;
+    }
+};
+
 }
diff --git a/ydb/core/erasure/erasure.cpp b/ydb/core/erasure/erasure.cpp
index 0a737fdb03..a41b027932 100644
--- a/ydb/core/erasure/erasure.cpp
+++ b/ydb/core/erasure/erasure.cpp
@@ -2642,332 +2642,332 @@ void TErasureType::IncrementalSplitData(ECrcMode crcMode, const TString& buffer,
     }
 }
 
-void MirrorSplitDiff(const TErasureType &type, const TVector<TDiff> &diffs, TPartDiffSet& outDiffSet) { 
-    outDiffSet.PartDiffs.resize(type.TotalPartCount()); 
-    ui32 parityParts = type.ParityParts(); 
-    for (ui32 partIdx = 0; partIdx <= parityParts; ++partIdx) { 
-        outDiffSet.PartDiffs[partIdx].Diffs = diffs; 
-    } 
-} 
- 
-void EoBlockSplitDiff(TErasureType::ECrcMode crcMode, const TErasureType &type, ui32 dataSize, const TVector<TDiff> &diffs, TPartDiffSet& outDiffSet) { 
-    TBlockParams p(crcMode, type, dataSize); 
-    outDiffSet.PartDiffs.resize(type.TotalPartCount()); 
-    ui32 dataParts = type.DataParts(); 
- 
-    ui32 partOffset = 0; 
-    ui32 diffIdx = 0; 
-    for (ui32 partIdx = 0; partIdx < dataParts && diffIdx < diffs.size(); ++partIdx) { 
-        ui32 nextOffset = partOffset; 
-        if (partIdx < p.FirstSmallPartIdx) { 
-            nextOffset += p.LargePartSize; 
-        } else { 
-            nextOffset += p.SmallPartSize; 
-        } 
-        if (partIdx + 1 == dataParts) { 
-            nextOffset = dataSize; 
-        } 
-        if (partOffset == nextOffset) { 
-            continue; 
-        } 
-        TPartDiff &part = outDiffSet.PartDiffs[partIdx]; 
- 
-        while (diffIdx < diffs.size()) { 
-            const TDiff &diff = diffs[diffIdx]; 
-            ui32 lineOffset = diff.Offset % sizeof(ui64); 
-            ui32 diffEnd = diff.Offset + diff.GetDiffLength(); 
- 
-            if (diff.Offset <= partOffset && diffEnd >= partOffset) { 
-                ui32 diffEndForThisPart = Min(diffEnd, nextOffset); 
-                ui32 diffShift = partOffset - diff.Offset; 
- 
-                ui32 bufferSize = diffEndForThisPart - partOffset; 
-                Y_VERIFY(bufferSize); 
-                Y_VERIFY_S(diffShift + bufferSize <= diff.Buffer.size(), "diffShift# " << diffShift 
-                        << " bufferSize# " << bufferSize << " diff.GetDiffLength()# " << diff.GetDiffLength()); 
-                TString newBuffer = TString::Uninitialized(bufferSize); 
-                memcpy(newBuffer.begin(), diff.Buffer.begin() + diffShift, bufferSize); 
-                part.Diffs.emplace_back(newBuffer, 0, false, true); 
- 
-                if (diffEnd <= nextOffset) { 
-                    diffIdx++; 
-                } else { 
-                    break; 
-                } 
-            } else if (diffEnd <= nextOffset) { 
-                TString buffer; 
-                ui32 bufferSize = 0; 
-                if (lineOffset && !diff.IsAligned) { 
-                    bufferSize = diff.GetDiffLength() + lineOffset; 
-                    buffer = TString::Uninitialized(bufferSize); 
-                    memcpy(buffer.begin() + lineOffset, diff.Buffer.begin(), diff.GetDiffLength()); 
-                } else { 
-                    buffer = diff.Buffer; 
-                    bufferSize = diff.Buffer.size(); 
-                } 
-                Y_VERIFY(bufferSize); 
-                part.Diffs.emplace_back(buffer, diff.Offset - partOffset, false, true); 
-                diffIdx++; 
-            } else if (diff.Offset < nextOffset) { 
-                ui32 bufferSize = nextOffset - diff.Offset + lineOffset; 
-                TString newBuffer = TString::Uninitialized(bufferSize); 
-                memcpy(newBuffer.begin() + lineOffset, diff.Buffer.begin(), bufferSize - lineOffset); 
-                Y_VERIFY(bufferSize); 
-                part.Diffs.emplace_back(newBuffer, diff.Offset - partOffset, false, true); 
-                break; 
-            } else { 
-                break; 
-            } 
-        } 
- 
-        partOffset = nextOffset; 
-    } 
-} 
- 
-void TErasureType::SplitDiffs(ECrcMode crcMode, ui32 dataSize, const TVector<TDiff> &diffs, TPartDiffSet& outDiffSet) const { 
-    Y_VERIFY(crcMode == CrcModeNone, "crc's not implemented"); 
-    const TErasureParameters& erasure = ErasureSpeciesParameters[ErasureSpecies]; 
- 
-    // change crc part only in during of applying diffs 
-    switch (erasure.ErasureFamily) { 
-        case TErasureType::ErasureMirror: 
-            MirrorSplitDiff(*this, diffs, outDiffSet); 
-            break; 
-        case TErasureType::ErasureParityStripe: 
-            Y_FAIL("Not implemented"); 
-            break; 
-        case TErasureType::ErasureParityBlock: 
-            Y_VERIFY(erasure.ParityParts == 2, "Other is not implemented"); 
-            EoBlockSplitDiff(crcMode, *this, dataSize, diffs, outDiffSet); 
-            break; 
-    } 
-} 
- 
-template <typename Bucket> 
-void XorCpy(Bucket *dest, const Bucket *orig, const Bucket *diff, ui32 count) { 
-    for (ui32 idx = 0; idx < count; ++idx) { 
-        dest[idx] = orig[idx] ^ diff[idx]; 
-    } 
-} 
- 
-void MakeEoBlockXorDiff(TErasureType::ECrcMode crcMode, const TErasureType &type, ui32 dataSize, 
-        const ui8 *src, const TVector<TDiff> &inDiffs, TVector<TDiff> *outDiffs) 
-{ 
-    Y_VERIFY(crcMode == TErasureType::CrcModeNone, "crc's not implemented"); 
-    TBlockParams p(crcMode, type, dataSize); 
- 
-    for (const TDiff &diff : inDiffs) { 
-        const ui8 *diffBufferBytes = reinterpret_cast<const ui8*>(diff.Buffer.data()); 
- 
-        ui32 lineOffset = diff.Offset % sizeof(ui64); 
-        ui32 lowerStartPos = diff.Offset - lineOffset; 
-        ui32 upperStartPos = lowerStartPos + (lineOffset ? sizeof(ui64) : 0); 
- 
-        ui32 end = diff.Offset + diff.GetDiffLength(); 
-        ui32 endLineOffset = end % sizeof(ui64); 
-        ui32 lowerEndPos = end - endLineOffset; 
-        ui32 upperEndPos = lowerEndPos + (endLineOffset ? sizeof(ui64) : 0); 
- 
-        ui32 bufferSize = upperEndPos - lowerStartPos; 
-        Y_VERIFY(bufferSize); 
-        TString xorDiffBuffer = TString::Uninitialized(bufferSize); 
-        ui8 *xorDiffBufferBytes = reinterpret_cast<ui8*>(const_cast<char*>(xorDiffBuffer.data())); 
- 
-        if (lowerEndPos == lowerStartPos) { 
-            ui64 &val = *reinterpret_cast<ui64*>(xorDiffBufferBytes); 
-            val = 0; 
-            ui32 byteCount = diff.GetDiffLength(); 
-            XorCpy(xorDiffBufferBytes + lineOffset, src + diff.Offset, diffBufferBytes + lineOffset, byteCount); 
-            outDiffs->emplace_back(xorDiffBuffer, diff.Offset, true, true); 
-            continue; 
-        } 
- 
-        if (lineOffset) { 
-            ui64 &val = *reinterpret_cast<ui64*>(xorDiffBufferBytes); 
-            val = 0; 
-            ui32 byteCount = Min<ui32>(sizeof(ui64) - lineOffset, diff.GetDiffLength()); 
-            XorCpy(xorDiffBufferBytes + lineOffset, src + diff.Offset, diffBufferBytes + lineOffset, byteCount); 
-        } 
- 
-        ui32 firstLine = lowerStartPos / sizeof(ui64); 
-        ui32 lineStart = upperStartPos / sizeof(ui64); 
-        ui32 lineEnd = lowerEndPos / sizeof(ui64); 
-        ui64 *xorUI64 = reinterpret_cast<ui64*>(xorDiffBufferBytes) + (lineStart - firstLine); 
-        const ui64 *srcUI64 = reinterpret_cast<const ui64*>(src) + lineStart; 
-        const ui64 *diffUI64 = reinterpret_cast<const ui64*>(diffBufferBytes)+ (lineStart - firstLine); 
-        ui32 countUI64 = lineEnd - lineStart; 
-        XorCpy(xorUI64, srcUI64, diffUI64, countUI64); 
- 
-        if (endLineOffset) { 
-            ui64 &val = reinterpret_cast<ui64*>(xorDiffBufferBytes)[lineEnd - firstLine]; 
-            val = 0; 
-            ui32 diffOffset = lowerEndPos - lowerStartPos; 
-            XorCpy(xorDiffBufferBytes + diffOffset, src + lowerEndPos, diffBufferBytes + diffOffset, endLineOffset); 
-        } 
-        outDiffs->emplace_back(xorDiffBuffer, diff.Offset, true, true); 
-    } 
-} 
- 
-void TErasureType::MakeXorDiff(ECrcMode crcMode, ui32 dataSize, const ui8 *src, 
-        const TVector<TDiff> &inDiffs, TVector<TDiff> *outDiffs) const 
-{ 
-    Y_VERIFY(crcMode == CrcModeNone, "crc's not implemented"); 
-    const TErasureParameters& erasure = ErasureSpeciesParameters[ErasureSpecies]; 
-    switch (erasure.ErasureFamily) { 
-        case TErasureType::ErasureMirror: 
-            Y_FAIL("unreachable"); 
-            break; 
-        case TErasureType::ErasureParityStripe: 
-            Y_FAIL("Not implemented"); 
-            break; 
-        case TErasureType::ErasureParityBlock: 
-            Y_VERIFY(erasure.ParityParts == 2, "Other is not implemented"); 
-            MakeEoBlockXorDiff(crcMode, *this, dataSize, src, inDiffs, outDiffs); 
-            break; 
-    } 
-} 
- 
-void TErasureType::ApplyDiff(ECrcMode crcMode, ui8 *dst, const TVector<TDiff> &diffs) const { 
-    Y_VERIFY(crcMode == CrcModeNone, "crc's not implemented"); 
-    for (auto &diff : diffs) { 
-        memcpy(dst + diff.Offset, diff.GetDataBegin(), diff.GetDiffLength()); 
-    } 
-} 
- 
-template <bool forSecondParity> 
-void ApllyXorDiffForEoBlock(const TBlockParams &p, ui64 *buffer, const ui64 *diff, ui64 adj, 
-        ui32 begin, ui32 end, ui32 diffOffset, ui8 fromPart = 0) 
- { 
-    ui32 blockBegin = begin / p.LineCount; 
-    ui32 blockEnd = (end + p.LineCount - 1) / p.LineCount; 
- 
-    Y_VERIFY(!forSecondParity || (blockBegin == 0 && blockEnd == 1)); 
- 
-    if (forSecondParity && adj) { 
-        for (ui32 idx = 0; idx < p.LineCount; ++idx) { 
-            buffer[idx] ^= adj; 
-        } 
-    } 
- 
-    Y_VERIFY(begin < end); 
-    if constexpr (forSecondParity) { 
-        ui32 lineBorder = p.LineCount - fromPart; 
- 
-        if (begin < lineBorder) { 
-            ui32 bufferBegin = begin + fromPart; 
-            ui32 diffBegin = begin - diffOffset; 
-            ui32 count = Min(lineBorder, end) - begin; 
-            XorCpy(buffer + bufferBegin, buffer + bufferBegin, diff + diffBegin, count); 
-        } 
- 
-        if (end > lineBorder + 1) { 
-            ui32 currentBegin = Max(lineBorder + 1, begin); 
-            ui32 bufferBegin = currentBegin + fromPart - p.Prime; 
-            ui32 count = end - currentBegin; 
-            ui32 diffBegin = currentBegin - diffOffset; 
-            XorCpy(buffer + bufferBegin, buffer + bufferBegin, diff + diffBegin, count); 
-        } 
-    } else { 
-        ui32 count = end - begin; 
-        ui32 diffBegin = begin - diffOffset; 
-        XorCpy(buffer + begin, buffer + begin, diff + diffBegin, count); 
-    } 
-} 
- 
-void ApplyEoBlockXorDiffForFirstParityPart(TErasureType::ECrcMode crcMode, const TErasureType &type, ui32 dataSize, 
-        ui64 *dst, const TVector<TDiff> &xorDiffs) 
-{ 
-    Y_VERIFY(crcMode == TErasureType::CrcModeNone, "crc's not implemented"); 
-    TBlockParams p(crcMode, type, dataSize); 
- 
-    for (const TDiff &diff : xorDiffs) { 
-        Y_VERIFY(diff.Buffer.size() % sizeof(ui64) == 0); 
-        Y_VERIFY(diff.IsXor && diff.IsAligned); 
-        const ui64 *diffBuffer = reinterpret_cast<const ui64*>(diff.GetBufferBegin()); 
-        ui32 diffOffset = diff.Offset / sizeof(ui64); 
-        ui32 offset = diff.Offset / sizeof(ui64); 
-        ui32 lineCount = diff.Buffer.size() / sizeof(ui64); 
-        Y_VERIFY(diff.Offset < type.PartSize(crcMode, dataSize)); 
-        Y_VERIFY(diff.Offset + diff.GetDiffLength() <= type.PartSize(crcMode, dataSize)); 
-        ApllyXorDiffForEoBlock<false>(p, dst, diffBuffer, 0, offset, offset + lineCount, diffOffset); 
-    } 
-} 
- 
-void ApplyXorForSecondParityPart(const TBlockParams &p, ui64 *startBufferBlock, const ui64 *startDiffBlock, 
-        ui32 begin, ui32 end, ui8 fromPart, ui32 diffOffset) 
-{ 
-    ui32 m = p.Prime; 
-    const ui32 mint = (m - 2 < p.LineCount ? 1 : m - 2 - p.LineCount); 
-    ui64 adj = 0; 
-    ui32 adjRelatedBytesBegin = m - 1 - fromPart; 
-    bool isAdjChanged = (fromPart >= mint) 
-            && (adjRelatedBytesBegin >= begin) 
-            && (adjRelatedBytesBegin < end); 
- 
-    if (isAdjChanged) { 
-        adj = startDiffBlock[adjRelatedBytesBegin - diffOffset]; 
-    } 
- 
-    ApllyXorDiffForEoBlock<true>(p, startBufferBlock, startDiffBlock, adj, begin, end, diffOffset, fromPart); 
-} 
- 
-void ApplyEoBlockXorDiffForSecondParityPart(TErasureType::ECrcMode crcMode, const TErasureType &type, ui32 dataSize, 
-        ui8 fromPart, ui64 *dst, const TVector<TDiff> &xorDiffs) 
-{ 
-    Y_VERIFY(crcMode == TErasureType::CrcModeNone, "crc's not implemented"); 
-    TBlockParams p(crcMode, type, dataSize); 
- 
-    ui64 bytesInBlock = p.LineCount * sizeof(ui64); 
- 
-    for (const TDiff &diff : xorDiffs) { 
-        Y_VERIFY(diff.Buffer.size() % sizeof(ui64) == 0); 
-        Y_VERIFY(diff.IsXor && diff.IsAligned); 
- 
-        const ui64 *diffBuffer = reinterpret_cast<const ui64*>(diff.GetBufferBegin()); 
- 
-        ui32 firstBlock = diff.Offset / bytesInBlock * p.LineCount; 
-        ui32 begin = diff.Offset / sizeof(ui64); 
-        ui32 end = begin + diff.Buffer.size() / sizeof(ui64); 
-        ui32 endBlock = (end + p.LineCount - 1) / p.LineCount * p.LineCount; 
- 
-        for (ui32 idx = firstBlock; idx < endBlock; idx += p.LineCount) { 
-            ui32 lineBegin = Max(idx, begin) - idx; 
-            ui32 lineEnd = Min<ui32>(idx + p.LineCount, end) - idx; 
-            if (idx == firstBlock) { 
-                ui32 diffOffset = begin - idx; 
-                ApplyXorForSecondParityPart(p, dst + idx, diffBuffer, lineBegin, lineEnd, fromPart, diffOffset); 
-            } else { 
-                ui32 diffOffset = idx - begin; 
-                ApplyXorForSecondParityPart(p, dst + idx, diffBuffer + diffOffset, lineBegin, lineEnd, fromPart, 0); 
-            } 
-        } 
-    } 
-} 
- 
-void TErasureType::ApplyXorDiff(ECrcMode crcMode, ui32 dataSize, ui8 *dst, 
-        const TVector<TDiff> &diffs, ui8 fromPart, ui8 toPart) const 
-{ 
-    Y_VERIFY(crcMode == CrcModeNone, "crc's not implemented"); 
-    const TErasureParameters& erasure = ErasureSpeciesParameters[ErasureSpecies]; 
-    switch (erasure.ErasureFamily) { 
-        case TErasureType::ErasureMirror: 
-            Y_FAIL("unreachable"); 
-            break; 
-        case TErasureType::ErasureParityStripe: 
-            Y_FAIL("Not implemented"); 
-            break; 
-        case TErasureType::ErasureParityBlock: 
-            Y_VERIFY(erasure.ParityParts == 2, "Other is not implemented"); 
-            ui64 *lineDst = reinterpret_cast<ui64*>(dst); 
-            if (toPart + 1 != TotalPartCount()) { 
-                ApplyEoBlockXorDiffForFirstParityPart(crcMode, *this, dataSize, lineDst, diffs); 
-            } else { 
-                ApplyEoBlockXorDiffForSecondParityPart(crcMode, *this, dataSize, fromPart, lineDst, diffs); 
-            } 
-            break; 
-    } 
-} 
- 
+void MirrorSplitDiff(const TErasureType &type, const TVector<TDiff> &diffs, TPartDiffSet& outDiffSet) {
+    outDiffSet.PartDiffs.resize(type.TotalPartCount());
+    ui32 parityParts = type.ParityParts();
+    for (ui32 partIdx = 0; partIdx <= parityParts; ++partIdx) {
+        outDiffSet.PartDiffs[partIdx].Diffs = diffs;
+    }
+}
+
+void EoBlockSplitDiff(TErasureType::ECrcMode crcMode, const TErasureType &type, ui32 dataSize, const TVector<TDiff> &diffs, TPartDiffSet& outDiffSet) {
+    TBlockParams p(crcMode, type, dataSize);
+    outDiffSet.PartDiffs.resize(type.TotalPartCount());
+    ui32 dataParts = type.DataParts();
+
+    ui32 partOffset = 0;
+    ui32 diffIdx = 0;
+    for (ui32 partIdx = 0; partIdx < dataParts && diffIdx < diffs.size(); ++partIdx) {
+        ui32 nextOffset = partOffset;
+        if (partIdx < p.FirstSmallPartIdx) {
+            nextOffset += p.LargePartSize;
+        } else {
+            nextOffset += p.SmallPartSize;
+        }
+        if (partIdx + 1 == dataParts) {
+            nextOffset = dataSize;
+        }
+        if (partOffset == nextOffset) {
+            continue;
+        }
+        TPartDiff &part = outDiffSet.PartDiffs[partIdx];
+
+        while (diffIdx < diffs.size()) {
+            const TDiff &diff = diffs[diffIdx];
+            ui32 lineOffset = diff.Offset % sizeof(ui64);
+            ui32 diffEnd = diff.Offset + diff.GetDiffLength();
+
+            if (diff.Offset <= partOffset && diffEnd >= partOffset) {
+                ui32 diffEndForThisPart = Min(diffEnd, nextOffset);
+                ui32 diffShift = partOffset - diff.Offset;
+
+                ui32 bufferSize = diffEndForThisPart - partOffset;
+                Y_VERIFY(bufferSize);
+                Y_VERIFY_S(diffShift + bufferSize <= diff.Buffer.size(), "diffShift# " << diffShift
+                        << " bufferSize# " << bufferSize << " diff.GetDiffLength()# " << diff.GetDiffLength());
+                TString newBuffer = TString::Uninitialized(bufferSize);
+                memcpy(newBuffer.begin(), diff.Buffer.begin() + diffShift, bufferSize);
+                part.Diffs.emplace_back(newBuffer, 0, false, true);
+
+                if (diffEnd <= nextOffset) {
+                    diffIdx++;
+                } else {
+                    break;
+                }
+            } else if (diffEnd <= nextOffset) {
+                TString buffer;
+                ui32 bufferSize = 0;
+                if (lineOffset && !diff.IsAligned) {
+                    bufferSize = diff.GetDiffLength() + lineOffset;
+                    buffer = TString::Uninitialized(bufferSize);
+                    memcpy(buffer.begin() + lineOffset, diff.Buffer.begin(), diff.GetDiffLength());
+                } else {
+                    buffer = diff.Buffer;
+                    bufferSize = diff.Buffer.size();
+                }
+                Y_VERIFY(bufferSize);
+                part.Diffs.emplace_back(buffer, diff.Offset - partOffset, false, true);
+                diffIdx++;
+            } else if (diff.Offset < nextOffset) {
+                ui32 bufferSize = nextOffset - diff.Offset + lineOffset;
+                TString newBuffer = TString::Uninitialized(bufferSize);
+                memcpy(newBuffer.begin() + lineOffset, diff.Buffer.begin(), bufferSize - lineOffset);
+                Y_VERIFY(bufferSize);
+                part.Diffs.emplace_back(newBuffer, diff.Offset - partOffset, false, true);
+                break;
+            } else {
+                break;
+            }
+        }
+
+        partOffset = nextOffset;
+    }
+}
+
+void TErasureType::SplitDiffs(ECrcMode crcMode, ui32 dataSize, const TVector<TDiff> &diffs, TPartDiffSet& outDiffSet) const {
+    Y_VERIFY(crcMode == CrcModeNone, "crc's not implemented");
+    const TErasureParameters& erasure = ErasureSpeciesParameters[ErasureSpecies];
+
+    // change crc part only in during of applying diffs
+    switch (erasure.ErasureFamily) {
+        case TErasureType::ErasureMirror:
+            MirrorSplitDiff(*this, diffs, outDiffSet);
+            break;
+        case TErasureType::ErasureParityStripe:
+            Y_FAIL("Not implemented");
+            break;
+        case TErasureType::ErasureParityBlock:
+            Y_VERIFY(erasure.ParityParts == 2, "Other is not implemented");
+            EoBlockSplitDiff(crcMode, *this, dataSize, diffs, outDiffSet);
+            break;
+    }
+}
+
+template <typename Bucket>
+void XorCpy(Bucket *dest, const Bucket *orig, const Bucket *diff, ui32 count) {
+    for (ui32 idx = 0; idx < count; ++idx) {
+        dest[idx] = orig[idx] ^ diff[idx];
+    }
+}
+
+void MakeEoBlockXorDiff(TErasureType::ECrcMode crcMode, const TErasureType &type, ui32 dataSize,
+        const ui8 *src, const TVector<TDiff> &inDiffs, TVector<TDiff> *outDiffs)
+{
+    Y_VERIFY(crcMode == TErasureType::CrcModeNone, "crc's not implemented");
+    TBlockParams p(crcMode, type, dataSize);
+
+    for (const TDiff &diff : inDiffs) {
+        const ui8 *diffBufferBytes = reinterpret_cast<const ui8*>(diff.Buffer.data());
+
+        ui32 lineOffset = diff.Offset % sizeof(ui64);
+        ui32 lowerStartPos = diff.Offset - lineOffset;
+        ui32 upperStartPos = lowerStartPos + (lineOffset ? sizeof(ui64) : 0);
+
+        ui32 end = diff.Offset + diff.GetDiffLength();
+        ui32 endLineOffset = end % sizeof(ui64);
+        ui32 lowerEndPos = end - endLineOffset;
+        ui32 upperEndPos = lowerEndPos + (endLineOffset ? sizeof(ui64) : 0);
+
+        ui32 bufferSize = upperEndPos - lowerStartPos;
+        Y_VERIFY(bufferSize);
+        TString xorDiffBuffer = TString::Uninitialized(bufferSize);
+        ui8 *xorDiffBufferBytes = reinterpret_cast<ui8*>(const_cast<char*>(xorDiffBuffer.data()));
+
+        if (lowerEndPos == lowerStartPos) {
+            ui64 &val = *reinterpret_cast<ui64*>(xorDiffBufferBytes);
+            val = 0;
+            ui32 byteCount = diff.GetDiffLength();
+            XorCpy(xorDiffBufferBytes + lineOffset, src + diff.Offset, diffBufferBytes + lineOffset, byteCount);
+            outDiffs->emplace_back(xorDiffBuffer, diff.Offset, true, true);
+            continue;
+        }
+
+        if (lineOffset) {
+            ui64 &val = *reinterpret_cast<ui64*>(xorDiffBufferBytes);
+            val = 0;
+            ui32 byteCount = Min<ui32>(sizeof(ui64) - lineOffset, diff.GetDiffLength());
+            XorCpy(xorDiffBufferBytes + lineOffset, src + diff.Offset, diffBufferBytes + lineOffset, byteCount);
+        }
+
+        ui32 firstLine = lowerStartPos / sizeof(ui64);
+        ui32 lineStart = upperStartPos / sizeof(ui64);
+        ui32 lineEnd = lowerEndPos / sizeof(ui64);
+        ui64 *xorUI64 = reinterpret_cast<ui64*>(xorDiffBufferBytes) + (lineStart - firstLine);
+        const ui64 *srcUI64 = reinterpret_cast<const ui64*>(src) + lineStart;
+        const ui64 *diffUI64 = reinterpret_cast<const ui64*>(diffBufferBytes)+ (lineStart - firstLine);
+        ui32 countUI64 = lineEnd - lineStart;
+        XorCpy(xorUI64, srcUI64, diffUI64, countUI64);
+
+        if (endLineOffset) {
+            ui64 &val = reinterpret_cast<ui64*>(xorDiffBufferBytes)[lineEnd - firstLine];
+            val = 0;
+            ui32 diffOffset = lowerEndPos - lowerStartPos;
+            XorCpy(xorDiffBufferBytes + diffOffset, src + lowerEndPos, diffBufferBytes + diffOffset, endLineOffset);
+        }
+        outDiffs->emplace_back(xorDiffBuffer, diff.Offset, true, true);
+    }
+}
+
+void TErasureType::MakeXorDiff(ECrcMode crcMode, ui32 dataSize, const ui8 *src,
+        const TVector<TDiff> &inDiffs, TVector<TDiff> *outDiffs) const
+{
+    Y_VERIFY(crcMode == CrcModeNone, "crc's not implemented");
+    const TErasureParameters& erasure = ErasureSpeciesParameters[ErasureSpecies];
+    switch (erasure.ErasureFamily) {
+        case TErasureType::ErasureMirror:
+            Y_FAIL("unreachable");
+            break;
+        case TErasureType::ErasureParityStripe:
+            Y_FAIL("Not implemented");
+            break;
+        case TErasureType::ErasureParityBlock:
+            Y_VERIFY(erasure.ParityParts == 2, "Other is not implemented");
+            MakeEoBlockXorDiff(crcMode, *this, dataSize, src, inDiffs, outDiffs);
+            break;
+    }
+}
+
+void TErasureType::ApplyDiff(ECrcMode crcMode, ui8 *dst, const TVector<TDiff> &diffs) const {
+    Y_VERIFY(crcMode == CrcModeNone, "crc's not implemented");
+    for (auto &diff : diffs) {
+        memcpy(dst + diff.Offset, diff.GetDataBegin(), diff.GetDiffLength());
+    }
+}
+
+template <bool forSecondParity>
+void ApllyXorDiffForEoBlock(const TBlockParams &p, ui64 *buffer, const ui64 *diff, ui64 adj,
+        ui32 begin, ui32 end, ui32 diffOffset, ui8 fromPart = 0)
+ {
+    ui32 blockBegin = begin / p.LineCount;
+    ui32 blockEnd = (end + p.LineCount - 1) / p.LineCount;
+
+    Y_VERIFY(!forSecondParity || (blockBegin == 0 && blockEnd == 1));
+
+    if (forSecondParity && adj) {
+        for (ui32 idx = 0; idx < p.LineCount; ++idx) {
+            buffer[idx] ^= adj;
+        }
+    }
+
+    Y_VERIFY(begin < end);
+    if constexpr (forSecondParity) {
+        ui32 lineBorder = p.LineCount - fromPart;
+
+        if (begin < lineBorder) {
+            ui32 bufferBegin = begin + fromPart;
+            ui32 diffBegin = begin - diffOffset;
+            ui32 count = Min(lineBorder, end) - begin;
+            XorCpy(buffer + bufferBegin, buffer + bufferBegin, diff + diffBegin, count);
+        }
+
+        if (end > lineBorder + 1) {
+            ui32 currentBegin = Max(lineBorder + 1, begin);
+            ui32 bufferBegin = currentBegin + fromPart - p.Prime;
+            ui32 count = end - currentBegin;
+            ui32 diffBegin = currentBegin - diffOffset;
+            XorCpy(buffer + bufferBegin, buffer + bufferBegin, diff + diffBegin, count);
+        }
+    } else {
+        ui32 count = end - begin;
+        ui32 diffBegin = begin - diffOffset;
+        XorCpy(buffer + begin, buffer + begin, diff + diffBegin, count);
+    }
+}
+
+void ApplyEoBlockXorDiffForFirstParityPart(TErasureType::ECrcMode crcMode, const TErasureType &type, ui32 dataSize,
+        ui64 *dst, const TVector<TDiff> &xorDiffs)
+{
+    Y_VERIFY(crcMode == TErasureType::CrcModeNone, "crc's not implemented");
+    TBlockParams p(crcMode, type, dataSize);
+
+    for (const TDiff &diff : xorDiffs) {
+        Y_VERIFY(diff.Buffer.size() % sizeof(ui64) == 0);
+        Y_VERIFY(diff.IsXor && diff.IsAligned);
+        const ui64 *diffBuffer = reinterpret_cast<const ui64*>(diff.GetBufferBegin());
+        ui32 diffOffset = diff.Offset / sizeof(ui64);
+        ui32 offset = diff.Offset / sizeof(ui64);
+        ui32 lineCount = diff.Buffer.size() / sizeof(ui64);
+        Y_VERIFY(diff.Offset < type.PartSize(crcMode, dataSize));
+        Y_VERIFY(diff.Offset + diff.GetDiffLength() <= type.PartSize(crcMode, dataSize));
+        ApllyXorDiffForEoBlock<false>(p, dst, diffBuffer, 0, offset, offset + lineCount, diffOffset);
+    }
+}
+
+void ApplyXorForSecondParityPart(const TBlockParams &p, ui64 *startBufferBlock, const ui64 *startDiffBlock,
+        ui32 begin, ui32 end, ui8 fromPart, ui32 diffOffset)
+{
+    ui32 m = p.Prime;
+    const ui32 mint = (m - 2 < p.LineCount ? 1 : m - 2 - p.LineCount);
+    ui64 adj = 0;
+    ui32 adjRelatedBytesBegin = m - 1 - fromPart;
+    bool isAdjChanged = (fromPart >= mint)
+            && (adjRelatedBytesBegin >= begin)
+            && (adjRelatedBytesBegin < end);
+
+    if (isAdjChanged) {
+        adj = startDiffBlock[adjRelatedBytesBegin - diffOffset];
+    }
+
+    ApllyXorDiffForEoBlock<true>(p, startBufferBlock, startDiffBlock, adj, begin, end, diffOffset, fromPart);
+}
+
+void ApplyEoBlockXorDiffForSecondParityPart(TErasureType::ECrcMode crcMode, const TErasureType &type, ui32 dataSize,
+        ui8 fromPart, ui64 *dst, const TVector<TDiff> &xorDiffs)
+{
+    Y_VERIFY(crcMode == TErasureType::CrcModeNone, "crc's not implemented");
+    TBlockParams p(crcMode, type, dataSize);
+
+    ui64 bytesInBlock = p.LineCount * sizeof(ui64);
+
+    for (const TDiff &diff : xorDiffs) {
+        Y_VERIFY(diff.Buffer.size() % sizeof(ui64) == 0);
+        Y_VERIFY(diff.IsXor && diff.IsAligned);
+
+        const ui64 *diffBuffer = reinterpret_cast<const ui64*>(diff.GetBufferBegin());
+
+        ui32 firstBlock = diff.Offset / bytesInBlock * p.LineCount;
+        ui32 begin = diff.Offset / sizeof(ui64);
+        ui32 end = begin + diff.Buffer.size() / sizeof(ui64);
+        ui32 endBlock = (end + p.LineCount - 1) / p.LineCount * p.LineCount;
+
+        for (ui32 idx = firstBlock; idx < endBlock; idx += p.LineCount) {
+            ui32 lineBegin = Max(idx, begin) - idx;
+            ui32 lineEnd = Min<ui32>(idx + p.LineCount, end) - idx;
+            if (idx == firstBlock) {
+                ui32 diffOffset = begin - idx;
+                ApplyXorForSecondParityPart(p, dst + idx, diffBuffer, lineBegin, lineEnd, fromPart, diffOffset);
+            } else {
+                ui32 diffOffset = idx - begin;
+                ApplyXorForSecondParityPart(p, dst + idx, diffBuffer + diffOffset, lineBegin, lineEnd, fromPart, 0);
+            }
+        }
+    }
+}
+
+void TErasureType::ApplyXorDiff(ECrcMode crcMode, ui32 dataSize, ui8 *dst,
+        const TVector<TDiff> &diffs, ui8 fromPart, ui8 toPart) const
+{
+    Y_VERIFY(crcMode == CrcModeNone, "crc's not implemented");
+    const TErasureParameters& erasure = ErasureSpeciesParameters[ErasureSpecies];
+    switch (erasure.ErasureFamily) {
+        case TErasureType::ErasureMirror:
+            Y_FAIL("unreachable");
+            break;
+        case TErasureType::ErasureParityStripe:
+            Y_FAIL("Not implemented");
+            break;
+        case TErasureType::ErasureParityBlock:
+            Y_VERIFY(erasure.ParityParts == 2, "Other is not implemented");
+            ui64 *lineDst = reinterpret_cast<ui64*>(dst);
+            if (toPart + 1 != TotalPartCount()) {
+                ApplyEoBlockXorDiffForFirstParityPart(crcMode, *this, dataSize, lineDst, diffs);
+            } else {
+                ApplyEoBlockXorDiffForSecondParityPart(crcMode, *this, dataSize, fromPart, lineDst, diffs);
+            }
+            break;
+    }
+}
+
 void TErasureType::RestoreData(ECrcMode crcMode, TDataPartSet& partSet, TString& outBuffer, bool restoreParts,
         bool restoreFullData, bool restoreParityParts) const {
     partSet.FullDataFragment.ReferenceTo(outBuffer);
diff --git a/ydb/core/erasure/erasure.h b/ydb/core/erasure/erasure.h
index 7704a11b0e..35bd68c2d2 100644
--- a/ydb/core/erasure/erasure.h
+++ b/ydb/core/erasure/erasure.h
@@ -15,46 +15,46 @@
 
 namespace NKikimr {
 
-struct TDiff { 
-    TString Buffer; 
-    ui32 Offset = 0; 
-    bool IsXor = false; 
-    bool IsAligned = false; 
- 
-    TDiff(const TString &buffer, ui32 offset, bool isXor, bool isAligned) 
-        : Buffer(buffer) 
-        , Offset(offset) 
-        , IsXor(isXor) 
-        , IsAligned(isAligned) 
-    { 
-    } 
- 
-    TDiff(const TString &buffer, ui32 offset) 
-        : TDiff(buffer, offset, false, false) 
-    { 
-    } 
- 
-    ui32 GetDiffLength() const { 
-        return (IsAligned ? Buffer.size() - Offset % sizeof(ui64) : Buffer.size()); 
-    } 
- 
-    const ui8* GetBufferBegin() const { 
-        return reinterpret_cast<const ui8*>((Buffer.data())); 
-    } 
- 
-    const ui8* GetDataBegin() const { 
-        return GetBufferBegin() + (IsAligned ? Offset % sizeof(ui64) : 0); 
-    } 
-}; 
- 
-struct TPartDiff { 
-    TVector<TDiff> Diffs; 
-}; 
- 
-struct TPartDiffSet { 
-    TVector<TPartDiff> PartDiffs; 
-}; 
- 
+struct TDiff {
+    TString Buffer;
+    ui32 Offset = 0;
+    bool IsXor = false;
+    bool IsAligned = false;
+
+    TDiff(const TString &buffer, ui32 offset, bool isXor, bool isAligned)
+        : Buffer(buffer)
+        , Offset(offset)
+        , IsXor(isXor)
+        , IsAligned(isAligned)
+    {
+    }
+
+    TDiff(const TString &buffer, ui32 offset)
+        : TDiff(buffer, offset, false, false)
+    {
+    }
+
+    ui32 GetDiffLength() const {
+        return (IsAligned ? Buffer.size() - Offset % sizeof(ui64) : Buffer.size());
+    }
+
+    const ui8* GetBufferBegin() const {
+        return reinterpret_cast<const ui8*>((Buffer.data()));
+    }
+
+    const ui8* GetDataBegin() const {
+        return GetBufferBegin() + (IsAligned ? Offset % sizeof(ui64) : 0);
+    }
+};
+
+struct TPartDiff {
+    TVector<TDiff> Diffs;
+};
+
+struct TPartDiffSet {
+    TVector<TPartDiff> PartDiffs;
+};
+
 // Part fragment, contains only some data
 struct TPartFragment {
     TString OwnedString; // Used for ownership only
@@ -320,13 +320,13 @@ struct TErasureType {
     void SplitData(ECrcMode crcMode, const TString& buffer, TDataPartSet& outPartSet) const;
     void IncrementalSplitData(ECrcMode crcMode, const TString& buffer, TDataPartSet& outPartSet) const;
 
-    void SplitDiffs(ECrcMode crcMode, ui32 dataSize, const TVector<TDiff> &diffs, TPartDiffSet& outDiffSet) const; 
-    void ApplyDiff(ECrcMode crcMode, ui8 *dst, const TVector<TDiff> &diffs) const; 
-    void MakeXorDiff(ECrcMode crcMode, ui32 dataSize, const ui8 *src, const TVector<TDiff> &inDiffs, 
-            TVector<TDiff> *outDiffs) const; 
-    void ApplyXorDiff(ECrcMode crcMode, ui32 dataSize, ui8 *dst, 
-            const TVector<TDiff> &diffs, ui8 fromPart, ui8 toPart) const; 
- 
+    void SplitDiffs(ECrcMode crcMode, ui32 dataSize, const TVector<TDiff> &diffs, TPartDiffSet& outDiffSet) const;
+    void ApplyDiff(ECrcMode crcMode, ui8 *dst, const TVector<TDiff> &diffs) const;
+    void MakeXorDiff(ECrcMode crcMode, ui32 dataSize, const ui8 *src, const TVector<TDiff> &inDiffs,
+            TVector<TDiff> *outDiffs) const;
+    void ApplyXorDiff(ECrcMode crcMode, ui32 dataSize, ui8 *dst,
+            const TVector<TDiff> &diffs, ui8 fromPart, ui8 toPart) const;
+
     void RestoreData(ECrcMode crcMode, TDataPartSet& partSet, TString& outBuffer, bool restoreParts,
             bool restoreFullData, bool restoreParityParts) const;
     void RestoreData(ECrcMode crcMode, TDataPartSet& partSet, bool restoreParts, bool restoreFullData,
diff --git a/ydb/core/erasure/erasure_rope_ut.cpp b/ydb/core/erasure/erasure_rope_ut.cpp
index 8f924f1a40..62a6242ea9 100644
--- a/ydb/core/erasure/erasure_rope_ut.cpp
+++ b/ydb/core/erasure/erasure_rope_ut.cpp
@@ -1,13 +1,13 @@
 #include "erasure_rope.h"
-#include "ut_util.h" 
+#include "ut_util.h"
 
 
 namespace NKikimr {
 namespace NErasureRope {
 
-TRope GenerateRandomRope(size_t dataSize) { 
+TRope GenerateRandomRope(size_t dataSize) {
     NPrivate::TMersenne64 randGen(Seed());
-    return TRopeHelpers::RopeFromStringMemcpy(GenerateRandomString(randGen, dataSize)); 
+    return TRopeHelpers::RopeFromStringMemcpy(GenerateRandomString(randGen, dataSize));
 }
 
 void TestMissingPartWithRandomData(TRopeErasureType &groupType, ui32 *missingPartIdx, ui32 missingParts,
diff --git a/ydb/core/erasure/erasure_ut.cpp b/ydb/core/erasure/erasure_ut.cpp
index bff83d9e60..2473bd1650 100644
--- a/ydb/core/erasure/erasure_ut.cpp
+++ b/ydb/core/erasure/erasure_ut.cpp
@@ -1,5 +1,5 @@
 #include "erasure.h"
-#include "ut_util.h" 
+#include "ut_util.h"
 
 
 namespace NKikimr {
@@ -122,112 +122,112 @@ void TestAllLossesDifferentSizes(TErasureType &groupType, ui32 maxParts) {
     } // missingVariant
 }
 
-void PrintBuffer(const TString &buffer) { 
-    Cerr << " ["; 
-    for (ui32 idx = 0; idx < buffer.size(); ++idx) { 
-        if (idx) { 
-            Cerr << " "; 
-        } 
-        Cerr << (ui32)(ui8)buffer[idx]; 
-    } 
-    Cerr << "]\n"; 
-} 
- 
-void PrintDiff(const TDiff &diff) { 
-    Cerr << "Offset# " << diff.Offset 
-        << " IsXor# " << (diff.IsXor ? "yes" : "no") 
-        << " IsAligned# " << (diff.IsAligned ? "yes" : "no"); 
-    PrintBuffer(diff.Buffer); 
-} 
- 
-void RunTestDiff(TErasureType &groupType, ui32 dataSize, const TString &testString, const TVector<TDiff> &diffs) { 
-    TDataPartSet partSet; 
-    groupType.SplitData(TErasureType::CrcModeNone, testString, partSet); 
-    ui64 partSize = groupType.PartSize(TErasureType::CrcModeNone, dataSize); 
-    for (ui32 part = 0; part < groupType.TotalPartCount(); ++part) { 
-        UNIT_ASSERT_EQUAL(partSize, partSet.Parts[part].size()); 
-    } 
- 
-    TString result = TString::Uninitialized(dataSize); 
-    memcpy(result.begin(), testString.begin(), dataSize); 
-    for (const auto &diff : diffs) { 
-        memcpy(result.begin() + diff.Offset, diff.GetDataBegin(), diff.GetDiffLength()); 
-    } 
- 
-    TDataPartSet resultPartSet; 
-    groupType.SplitData(TErasureType::CrcModeNone, result, resultPartSet); 
- 
-    TPartDiffSet diffSet; 
-    groupType.SplitDiffs(TErasureType::CrcModeNone, dataSize, diffs, diffSet); 
- 
-    ui32 dataParts = groupType.DataParts(); 
-    ui32 parityParts = groupType.ErasureFamily() == TErasureType::ErasureMirror ? 0 : groupType.ParityParts(); 
- 
-    for (ui32 partIdx = 0; partIdx < dataParts; ++partIdx) { 
-        if (!partSet.Parts[partIdx].Size) { 
-            continue; 
-        } 
-        const ui8 *src = reinterpret_cast<ui8*>(partSet.Parts[partIdx].GetDataAt(0)); 
-        const TVector<TDiff> &diffs = diffSet.PartDiffs[partIdx].Diffs; 
-        if (diffs.empty()) { 
-            continue; 
-        } 
- 
-        for (ui32 parityPartIdx = dataParts; parityPartIdx < dataParts + parityParts; ++parityPartIdx) { 
-            TVector<TDiff> xorDiffs; 
-            if (!partSet.Parts[parityPartIdx].Size) { 
-                continue; 
-            } 
-            ui8 *dst = reinterpret_cast<ui8*>(partSet.Parts[parityPartIdx].GetDataAt(0)); 
-            groupType.MakeXorDiff(TErasureType::CrcModeNone, dataSize, src, diffs, &xorDiffs); 
- 
-            groupType.ApplyXorDiff(TErasureType::CrcModeNone, dataSize, dst, 
-                    xorDiffs, partIdx, parityPartIdx); 
- 
-        } 
- 
-        ui8 *dst = reinterpret_cast<ui8*>(partSet.Parts[partIdx].GetDataAt(0));; 
-        groupType.ApplyDiff(TErasureType::CrcModeNone, dst, diffs); 
-    } 
- 
-    for (ui32 partIdx = 0; partIdx < dataParts + parityParts; ++partIdx) { 
-        UNIT_ASSERT_STRINGS_EQUAL(partSet.Parts[partIdx].OwnedString, resultPartSet.Parts[partIdx].OwnedString); 
-    } 
-} 
- 
-TVector<TDiff> GenerateRandomDiff(NPrivate::TMersenne64 &randGen, ui32 dataSize, ui32 diffCount, ui32 diffSize, 
-        ui32 offset = Max<ui32>()) { 
-    UNIT_ASSERT(dataSize >= diffCount * diffSize + diffCount - 1); 
-    TVector<TDiff> diffs; 
-    int leftPosition = 0; 
-    for (ui32 diffIdx = 0; diffIdx < diffCount; ++diffIdx) { 
-        ui32 diffPosition = 0; 
-        if (offset != Max<ui32>()) { 
-            diffPosition = leftPosition + offset; 
-        } else { 
-            ui32 nextDiffCount = diffCount - 1 - diffIdx; 
-            UNIT_ASSERT(nextDiffCount < diffCount); 
-            UNIT_ASSERT(dataSize >= leftPosition + nextDiffCount * (diffSize + 1) + diffSize); 
-            ui32 maxDiffOffset = dataSize - leftPosition - nextDiffCount * (diffSize + 1) - diffSize; 
-            UNIT_ASSERT(maxDiffOffset < dataSize); 
-            ui32 diffOffset = (maxDiffOffset ? randGen.GenRand() % maxDiffOffset : 0); 
-            UNIT_ASSERT(diffOffset < dataSize); 
-            UNIT_ASSERT(diffOffset + diffSize <= dataSize); 
-            diffPosition = leftPosition + diffOffset; 
-        } 
-        UNIT_ASSERT(diffPosition < dataSize); 
-        UNIT_ASSERT(diffPosition + diffSize <= dataSize); 
- 
-        TString buffer = TString::Uninitialized(diffSize); 
-        for (ui32 i = 0; i < diffSize; ++i) { 
-            buffer[i] = (char)randGen.GenRand(); 
-        } 
-        diffs.emplace_back(buffer, diffPosition, false, false); 
-        leftPosition = diffPosition + 1 + diffSize; 
-    } 
-    return diffs; 
-} 
- 
+void PrintBuffer(const TString &buffer) {
+    Cerr << " [";
+    for (ui32 idx = 0; idx < buffer.size(); ++idx) {
+        if (idx) {
+            Cerr << " ";
+        }
+        Cerr << (ui32)(ui8)buffer[idx];
+    }
+    Cerr << "]\n";
+}
+
+void PrintDiff(const TDiff &diff) {
+    Cerr << "Offset# " << diff.Offset
+        << " IsXor# " << (diff.IsXor ? "yes" : "no")
+        << " IsAligned# " << (diff.IsAligned ? "yes" : "no");
+    PrintBuffer(diff.Buffer);
+}
+
+void RunTestDiff(TErasureType &groupType, ui32 dataSize, const TString &testString, const TVector<TDiff> &diffs) {
+    TDataPartSet partSet;
+    groupType.SplitData(TErasureType::CrcModeNone, testString, partSet);
+    ui64 partSize = groupType.PartSize(TErasureType::CrcModeNone, dataSize);
+    for (ui32 part = 0; part < groupType.TotalPartCount(); ++part) {
+        UNIT_ASSERT_EQUAL(partSize, partSet.Parts[part].size());
+    }
+
+    TString result = TString::Uninitialized(dataSize);
+    memcpy(result.begin(), testString.begin(), dataSize);
+    for (const auto &diff : diffs) {
+        memcpy(result.begin() + diff.Offset, diff.GetDataBegin(), diff.GetDiffLength());
+    }
+
+    TDataPartSet resultPartSet;
+    groupType.SplitData(TErasureType::CrcModeNone, result, resultPartSet);
+
+    TPartDiffSet diffSet;
+    groupType.SplitDiffs(TErasureType::CrcModeNone, dataSize, diffs, diffSet);
+
+    ui32 dataParts = groupType.DataParts();
+    ui32 parityParts = groupType.ErasureFamily() == TErasureType::ErasureMirror ? 0 : groupType.ParityParts();
+
+    for (ui32 partIdx = 0; partIdx < dataParts; ++partIdx) {
+        if (!partSet.Parts[partIdx].Size) {
+            continue;
+        }
+        const ui8 *src = reinterpret_cast<ui8*>(partSet.Parts[partIdx].GetDataAt(0));
+        const TVector<TDiff> &diffs = diffSet.PartDiffs[partIdx].Diffs;
+        if (diffs.empty()) {
+            continue;
+        }
+
+        for (ui32 parityPartIdx = dataParts; parityPartIdx < dataParts + parityParts; ++parityPartIdx) {
+            TVector<TDiff> xorDiffs;
+            if (!partSet.Parts[parityPartIdx].Size) {
+                continue;
+            }
+            ui8 *dst = reinterpret_cast<ui8*>(partSet.Parts[parityPartIdx].GetDataAt(0));
+            groupType.MakeXorDiff(TErasureType::CrcModeNone, dataSize, src, diffs, &xorDiffs);
+
+            groupType.ApplyXorDiff(TErasureType::CrcModeNone, dataSize, dst,
+                    xorDiffs, partIdx, parityPartIdx);
+
+        }
+
+        ui8 *dst = reinterpret_cast<ui8*>(partSet.Parts[partIdx].GetDataAt(0));;
+        groupType.ApplyDiff(TErasureType::CrcModeNone, dst, diffs);
+    }
+
+    for (ui32 partIdx = 0; partIdx < dataParts + parityParts; ++partIdx) {
+        UNIT_ASSERT_STRINGS_EQUAL(partSet.Parts[partIdx].OwnedString, resultPartSet.Parts[partIdx].OwnedString);
+    }
+}
+
+TVector<TDiff> GenerateRandomDiff(NPrivate::TMersenne64 &randGen, ui32 dataSize, ui32 diffCount, ui32 diffSize,
+        ui32 offset = Max<ui32>()) {
+    UNIT_ASSERT(dataSize >= diffCount * diffSize + diffCount - 1);
+    TVector<TDiff> diffs;
+    int leftPosition = 0;
+    for (ui32 diffIdx = 0; diffIdx < diffCount; ++diffIdx) {
+        ui32 diffPosition = 0;
+        if (offset != Max<ui32>()) {
+            diffPosition = leftPosition + offset;
+        } else {
+            ui32 nextDiffCount = diffCount - 1 - diffIdx;
+            UNIT_ASSERT(nextDiffCount < diffCount);
+            UNIT_ASSERT(dataSize >= leftPosition + nextDiffCount * (diffSize + 1) + diffSize);
+            ui32 maxDiffOffset = dataSize - leftPosition - nextDiffCount * (diffSize + 1) - diffSize;
+            UNIT_ASSERT(maxDiffOffset < dataSize);
+            ui32 diffOffset = (maxDiffOffset ? randGen.GenRand() % maxDiffOffset : 0);
+            UNIT_ASSERT(diffOffset < dataSize);
+            UNIT_ASSERT(diffOffset + diffSize <= dataSize);
+            diffPosition = leftPosition + diffOffset;
+        }
+        UNIT_ASSERT(diffPosition < dataSize);
+        UNIT_ASSERT(diffPosition + diffSize <= dataSize);
+
+        TString buffer = TString::Uninitialized(diffSize);
+        for (ui32 i = 0; i < diffSize; ++i) {
+            buffer[i] = (char)randGen.GenRand();
+        }
+        diffs.emplace_back(buffer, diffPosition, false, false);
+        leftPosition = diffPosition + 1 + diffSize;
+    }
+    return diffs;
+}
+
 Y_UNIT_TEST_SUITE(TErasureTypeTest) {
 // Test if new version is capable to restore data splited by current version (which is right by definition)
     Y_UNIT_TEST(isSplittedDataEqualsToOldVerion) {
@@ -438,62 +438,62 @@ Y_UNIT_TEST_SUITE(TErasureTypeTest) {
         }
     }
 
-    void BaseCheckDiffSpliting(TErasureType type, ui32 dataSize, ui32 diffCount, 
-            ui32 diffSize, ui32 diffOffset) 
-    { 
-        NPrivate::TMersenne64 randGen(0); 
-        TString testString = GenerateRandomString(randGen, dataSize); 
-        TVector<TDiff> diffs = GenerateRandomDiff(randGen, dataSize, diffCount, diffSize, diffOffset); 
-        RunTestDiff(type, dataSize, testString, diffs); 
-    } 
- 
-    void CheckDifferentCasesInDiffSpliting(TErasureType type) { 
-        struct TTestCase { 
-            ui32 DataSize; 
-            ui32 DiffCount; 
-            ui32 DiffSize; 
-            ui32 DiffOffset; 
-        }; 
-        TVector<TTestCase> testCases = { 
-            TTestCase{31, 16, 1, 0}, 
-            TTestCase{120, 16, 3, 3}, 
-            TTestCase{511, 32, 10, 3}, 
-            TTestCase{50000, 100, 401, 89}, 
-            TTestCase{31, 1, 31, 0}, 
-            TTestCase{120, 1, 120, 0}, 
-            TTestCase{511, 1, 511, 0}, 
-            TTestCase{50000, 1, 50000, 0}, 
-            TTestCase{250, 1, 10, 240} 
-        }; 
-        for (auto [dataSize, diffCount, diffSize, diffOffset] : testCases) { 
-            BaseCheckDiffSpliting(type, dataSize, diffCount, diffSize, diffOffset); 
-        } 
-    } 
- 
-    Y_UNIT_TEST(TestDifferentCasesInDiffSplitingMirror3Of4) { 
-        CheckDifferentCasesInDiffSpliting(TErasureType::EErasureSpecies::ErasureMirror3of4); 
-    } 
- 
-    Y_UNIT_TEST(TestDifferentCasesInDiffSplitingBlock4Plus2) { 
-        CheckDifferentCasesInDiffSpliting(TErasureType::EErasureSpecies::Erasure4Plus2Block); 
-    } 
- 
- 
-    Y_UNIT_TEST(TestSplitDiffBlock4Plus2SpecialCase1) { 
-        TErasureType groupType(TErasureType::EErasureSpecies::Erasure4Plus2Block); 
-        ui32 dataSize = 100; 
-        TStringBuilder dataBuilder; 
-        for (ui32 idx = 0; idx < 100; ++idx) { 
-            dataBuilder << 'a'; 
-        } 
-        TString testString = dataBuilder; 
-        TVector<TDiff> diffs; 
-        diffs.reserve(2); 
-        diffs.emplace_back("b", 0); 
-        diffs.emplace_back("b", 99); 
-        RunTestDiff(groupType, dataSize, testString, diffs); 
-    } 
- 
+    void BaseCheckDiffSpliting(TErasureType type, ui32 dataSize, ui32 diffCount,
+            ui32 diffSize, ui32 diffOffset)
+    {
+        NPrivate::TMersenne64 randGen(0);
+        TString testString = GenerateRandomString(randGen, dataSize);
+        TVector<TDiff> diffs = GenerateRandomDiff(randGen, dataSize, diffCount, diffSize, diffOffset);
+        RunTestDiff(type, dataSize, testString, diffs);
+    }
+
+    void CheckDifferentCasesInDiffSpliting(TErasureType type) {
+        struct TTestCase {
+            ui32 DataSize;
+            ui32 DiffCount;
+            ui32 DiffSize;
+            ui32 DiffOffset;
+        };
+        TVector<TTestCase> testCases = {
+            TTestCase{31, 16, 1, 0},
+            TTestCase{120, 16, 3, 3},
+            TTestCase{511, 32, 10, 3},
+            TTestCase{50000, 100, 401, 89},
+            TTestCase{31, 1, 31, 0},
+            TTestCase{120, 1, 120, 0},
+            TTestCase{511, 1, 511, 0},
+            TTestCase{50000, 1, 50000, 0},
+            TTestCase{250, 1, 10, 240}
+        };
+        for (auto [dataSize, diffCount, diffSize, diffOffset] : testCases) {
+            BaseCheckDiffSpliting(type, dataSize, diffCount, diffSize, diffOffset);
+        }
+    }
+
+    Y_UNIT_TEST(TestDifferentCasesInDiffSplitingMirror3Of4) {
+        CheckDifferentCasesInDiffSpliting(TErasureType::EErasureSpecies::ErasureMirror3of4);
+    }
+
+    Y_UNIT_TEST(TestDifferentCasesInDiffSplitingBlock4Plus2) {
+        CheckDifferentCasesInDiffSpliting(TErasureType::EErasureSpecies::Erasure4Plus2Block);
+    }
+
+
+    Y_UNIT_TEST(TestSplitDiffBlock4Plus2SpecialCase1) {
+        TErasureType groupType(TErasureType::EErasureSpecies::Erasure4Plus2Block);
+        ui32 dataSize = 100;
+        TStringBuilder dataBuilder;
+        for (ui32 idx = 0; idx < 100; ++idx) {
+            dataBuilder << 'a';
+        }
+        TString testString = dataBuilder;
+        TVector<TDiff> diffs;
+        diffs.reserve(2);
+        diffs.emplace_back("b", 0);
+        diffs.emplace_back("b", 99);
+        RunTestDiff(groupType, dataSize, testString, diffs);
+    }
+
     // Mirror tests
     Y_UNIT_TEST(TestMirror3LossOfAllPossible3) {
         // Set up the erasure
diff --git a/ydb/core/erasure/ut_util.h b/ydb/core/erasure/ut_util.h
index b5ba9a6bbb..ef2f723655 100644
--- a/ydb/core/erasure/ut_util.h
+++ b/ydb/core/erasure/ut_util.h
@@ -1,70 +1,70 @@
-#pragma once 
- 
-#include <library/cpp/testing/unittest/registar.h> 
-#include <util/random/entropy.h> 
-#include <util/random/mersenne64.h> 
+#pragma once
+
+#include <library/cpp/testing/unittest/registar.h>
+#include <util/random/entropy.h>
+#include <util/random/mersenne64.h>
 #include <util/stream/null.h>
-#include <util/string/printf.h> 
- 
+#include <util/string/printf.h>
+
 IOutputStream& Ctest = Cnull;
- 
+
 #define VERBOSE_COUT(a) Ctest << a
- 
+
 inline TString PrintArr(ui32 *arr, ui32 n) {
-    TStringStream out; 
-    if (n == 0) { 
-        out << "-"; 
-    } 
-    for (ui32 i = 0; i < n; ++i) { 
-        out << arr[i] << " "; 
-    } 
-    out << Endl; 
-    return out.Str(); 
-} 
- 
+    TStringStream out;
+    if (n == 0) {
+        out << "-";
+    }
+    for (ui32 i = 0; i < n; ++i) {
+        out << arr[i] << " ";
+    }
+    out << Endl;
+    return out.Str();
+}
+
 inline const char *BoolToStr(bool val) {
-    return val ? "true " : "false"; 
-} 
- 
-inline ui32 Fact(ui32 n) { 
-    ui32 res = 1; 
-    while (n > 1) { 
-        res *= n; 
-        n--; 
-    } 
-    return res; 
-} 
- 
-inline void GenFirstCombination(ui32 *variants, ui32 const k) { 
-    for (ui32 i = 0; i < k; ++i) { 
-        variants[i] = i; 
-    } 
-} 
- 
-inline void GenNextCombination(ui32 *variants, ui32 const k, ui32 const n) { 
-    for (ui32 i = k-1; i != (ui32)-1; --i) { 
-        if ( variants[i] < n - 1 - (k - 1 - i)) { 
-            ui32 tmp = ++variants[i]; 
-            for (ui32 j = i+1; j < k; ++j) { 
-                variants[j] = ++tmp; 
-            } 
-            break; 
-        } 
-    } 
-} 
- 
-inline TString GenerateRandomString(NPrivate::TMersenne64 &randGen, size_t dataSize) { 
-    TString testString; 
-    testString.resize(dataSize); 
-    char *writePosChar = (char *)testString.data(); 
-    ui32 charParts = testString.size() % sizeof(ui64); 
-    for (ui32 i = 0; i < charParts; ++i) { 
-        writePosChar[i] = (char)randGen.GenRand(); 
-    } 
-    ui64 *writePos64 = (ui64 *)writePosChar; 
-    ui32 ui64Parts = testString.size() / sizeof(ui64); 
-    for (ui32 i = 0; i < ui64Parts; ++i) { 
-        writePos64[i] = randGen.GenRand(); 
-    } 
-    return testString; 
-} 
+    return val ? "true " : "false";
+}
+
+inline ui32 Fact(ui32 n) {
+    ui32 res = 1;
+    while (n > 1) {
+        res *= n;
+        n--;
+    }
+    return res;
+}
+
+inline void GenFirstCombination(ui32 *variants, ui32 const k) {
+    for (ui32 i = 0; i < k; ++i) {
+        variants[i] = i;
+    }
+}
+
+inline void GenNextCombination(ui32 *variants, ui32 const k, ui32 const n) {
+    for (ui32 i = k-1; i != (ui32)-1; --i) {
+        if ( variants[i] < n - 1 - (k - 1 - i)) {
+            ui32 tmp = ++variants[i];
+            for (ui32 j = i+1; j < k; ++j) {
+                variants[j] = ++tmp;
+            }
+            break;
+        }
+    }
+}
+
+inline TString GenerateRandomString(NPrivate::TMersenne64 &randGen, size_t dataSize) {
+    TString testString;
+    testString.resize(dataSize);
+    char *writePosChar = (char *)testString.data();
+    ui32 charParts = testString.size() % sizeof(ui64);
+    for (ui32 i = 0; i < charParts; ++i) {
+        writePosChar[i] = (char)randGen.GenRand();
+    }
+    ui64 *writePos64 = (ui64 *)writePosChar;
+    ui32 ui64Parts = testString.size() / sizeof(ui64);
+    for (ui32 i = 0; i < ui64Parts; ++i) {
+        writePos64[i] = randGen.GenRand();
+    }
+    return testString;
+}
diff --git a/ydb/core/keyvalue/keyvalue_const.h b/ydb/core/keyvalue/keyvalue_const.h
index 854668b687..09b2327ef5 100644
--- a/ydb/core/keyvalue/keyvalue_const.h
+++ b/ydb/core/keyvalue/keyvalue_const.h
@@ -7,8 +7,8 @@ namespace NKeyValue {
 constexpr ui32 BLOB_CHANNEL = 2;
 constexpr ui64 KEYVALUE_VERSION = 1ull;
 
-constexpr ui64 InlineStorageChannelInPublicApi = 1; 
-constexpr ui64 MainStorageChannelInPublicApi = 2; 
- 
+constexpr ui64 InlineStorageChannelInPublicApi = 1;
+constexpr ui64 MainStorageChannelInPublicApi = 2;
+
 } // NKeyValue
 } // NKikimr
diff --git a/ydb/core/keyvalue/keyvalue_events.h b/ydb/core/keyvalue/keyvalue_events.h
index 564aef6563..03bc81ad8f 100644
--- a/ydb/core/keyvalue/keyvalue_events.h
+++ b/ydb/core/keyvalue/keyvalue_events.h
@@ -5,7 +5,7 @@
 #include <ydb/public/lib/base/msgbus.h>
 #include <ydb/core/keyvalue/protos/events.pb.h>
 
- 
+
 namespace NKikimr {
 
 namespace NKeyValue {
@@ -24,20 +24,20 @@ struct TEvKeyValue {
         EvReportWriteLatency,
         EvUpdateWeights,
 
-        EvRead = EvRequest + 16, 
-        EvReadRange, 
-        EvExecuteTransaction, 
-        EvGetStatus, 
-        EvObtainLock, 
- 
+        EvRead = EvRequest + 16,
+        EvReadRange,
+        EvExecuteTransaction,
+        EvGetStatus,
+        EvObtainLock,
+
         EvResponse = EvRequest + 512,
 
-        EvReadResponse = EvResponse + 16, 
-        EvReadRangeResponse, 
-        EvExecuteTransactionResponse, 
-        EvGetStatusResponse, 
-        EvObtainLockResponse, 
- 
+        EvReadResponse = EvResponse + 16,
+        EvReadRangeResponse,
+        EvExecuteTransactionResponse,
+        EvGetStatusResponse,
+        EvObtainLockResponse,
+
         EvEnd
     };
 
@@ -45,87 +45,87 @@ struct TEvKeyValue {
         EvEnd < EventSpaceEnd(TKikimrEvents::ES_KEYVALUE),
         "expect EvEnd < EventSpaceEnd(TKikimrEvents::ES_KEYVALUE)");
 
-    struct TEvReadResponse; 
- 
-    struct TEvRead : public TEventPB<TEvRead, 
-            NKikimrKeyValue::ReadRequest, EvRead> { 
- 
-        using TResponse = TEvReadResponse; 
-        TEvRead() { } 
-    }; 
- 
-    struct TEvReadResponse : public TEventPB<TEvReadResponse, 
-            NKikimrKeyValue::ReadResult, EvReadResponse> { 
-        TEvReadResponse() { } 
-    }; 
- 
-    struct TEvReadRangeResponse; 
- 
-    struct TEvReadRange : public TEventPB<TEvReadRange, 
-            NKikimrKeyValue::ReadRangeRequest, EvReadRange> { 
- 
-        using TResponse = TEvReadRangeResponse; 
-        TEvReadRange() { } 
-    }; 
- 
-    struct TEvReadRangeResponse : public TEventPB<TEvReadRangeResponse, 
-            NKikimrKeyValue::ReadRangeResult, EvReadRangeResponse> { 
-        TEvReadRangeResponse() { } 
-    }; 
- 
-    struct TEvExecuteTransactionResponse; 
- 
-    struct TEvExecuteTransaction : public TEventPB<TEvExecuteTransaction, 
-            NKikimrKeyValue::ExecuteTransactionRequest, EvExecuteTransaction> { 
- 
-        using TResponse = TEvExecuteTransactionResponse; 
-        TEvExecuteTransaction() { } 
-    }; 
- 
-    struct TEvExecuteTransactionResponse : public TEventPB<TEvExecuteTransactionResponse, 
-            NKikimrKeyValue::ExecuteTransactionResult, EvExecuteTransactionResponse> { 
-        TEvExecuteTransactionResponse() { } 
-    }; 
- 
-    struct TEvGetStatusResponse; 
- 
-    struct TEvGetStatus : public TEventPB<TEvGetStatus, 
-            NKikimrKeyValue::GetStatusRequest, EvGetStatus> { 
- 
-        using TResponse = TEvGetStatusResponse; 
-        TEvGetStatus() { } 
-    }; 
- 
-    struct TEvGetStatusResponse : public TEventPB<TEvGetStatusResponse, 
-            NKikimrKeyValue::GetStatusResult, EvGetStatusResponse> { 
-        TEvGetStatusResponse() { } 
-    }; 
- 
-    struct TEvObtainLockResponse; 
- 
-    struct TEvObtainLock : public TEventPB<TEvObtainLock, 
-            NKikimrKeyValue::ObtainLockRequest, EvObtainLock> { 
- 
-        using TResponse = TEvObtainLockResponse; 
-        TEvObtainLock() { } 
-    }; 
- 
-    struct TEvObtainLockResponse : public TEventPB<TEvObtainLockResponse, 
-            NKikimrKeyValue::ObtainLockResult, EvObtainLockResponse> { 
-        TEvObtainLockResponse() { } 
-    }; 
- 
-    struct TEvRequest : public TEventPB<TEvRequest, 
+    struct TEvReadResponse;
+
+    struct TEvRead : public TEventPB<TEvRead,
+            NKikimrKeyValue::ReadRequest, EvRead> {
+
+        using TResponse = TEvReadResponse;
+        TEvRead() { }
+    };
+
+    struct TEvReadResponse : public TEventPB<TEvReadResponse,
+            NKikimrKeyValue::ReadResult, EvReadResponse> {
+        TEvReadResponse() { }
+    };
+
+    struct TEvReadRangeResponse;
+
+    struct TEvReadRange : public TEventPB<TEvReadRange,
+            NKikimrKeyValue::ReadRangeRequest, EvReadRange> {
+
+        using TResponse = TEvReadRangeResponse;
+        TEvReadRange() { }
+    };
+
+    struct TEvReadRangeResponse : public TEventPB<TEvReadRangeResponse,
+            NKikimrKeyValue::ReadRangeResult, EvReadRangeResponse> {
+        TEvReadRangeResponse() { }
+    };
+
+    struct TEvExecuteTransactionResponse;
+
+    struct TEvExecuteTransaction : public TEventPB<TEvExecuteTransaction,
+            NKikimrKeyValue::ExecuteTransactionRequest, EvExecuteTransaction> {
+
+        using TResponse = TEvExecuteTransactionResponse;
+        TEvExecuteTransaction() { }
+    };
+
+    struct TEvExecuteTransactionResponse : public TEventPB<TEvExecuteTransactionResponse,
+            NKikimrKeyValue::ExecuteTransactionResult, EvExecuteTransactionResponse> {
+        TEvExecuteTransactionResponse() { }
+    };
+
+    struct TEvGetStatusResponse;
+
+    struct TEvGetStatus : public TEventPB<TEvGetStatus,
+            NKikimrKeyValue::GetStatusRequest, EvGetStatus> {
+
+        using TResponse = TEvGetStatusResponse;
+        TEvGetStatus() { }
+    };
+
+    struct TEvGetStatusResponse : public TEventPB<TEvGetStatusResponse,
+            NKikimrKeyValue::GetStatusResult, EvGetStatusResponse> {
+        TEvGetStatusResponse() { }
+    };
+
+    struct TEvObtainLockResponse;
+
+    struct TEvObtainLock : public TEventPB<TEvObtainLock,
+            NKikimrKeyValue::ObtainLockRequest, EvObtainLock> {
+
+        using TResponse = TEvObtainLockResponse;
+        TEvObtainLock() { }
+    };
+
+    struct TEvObtainLockResponse : public TEventPB<TEvObtainLockResponse,
+            NKikimrKeyValue::ObtainLockResult, EvObtainLockResponse> {
+        TEvObtainLockResponse() { }
+    };
+
+    struct TEvRequest : public TEventPB<TEvRequest,
             NKikimrClient::TKeyValueRequest, EvRequest> {
         TEvRequest() { }
     };
 
-    struct TEvResponse : public TEventPB<TEvResponse, 
+    struct TEvResponse : public TEventPB<TEvResponse,
             NKikimrClient::TResponse, EvResponse> {
         TEvResponse() { }
     };
 
-    struct TEvIntermediate : public TEventLocal<TEvIntermediate, EvIntermediate> { 
+    struct TEvIntermediate : public TEventLocal<TEvIntermediate, EvIntermediate> {
         THolder<NKeyValue::TIntermediate> Intermediate;
 
         TEvIntermediate() { }
@@ -135,7 +135,7 @@ struct TEvKeyValue {
         {}
     };
 
-    struct TEvNotify : public TEventLocal<TEvNotify, EvNotify> { 
+    struct TEvNotify : public TEventLocal<TEvNotify, EvNotify> {
         ui64 RequestUid;
         ui64 Generation;
         ui64 Step;
@@ -152,45 +152,45 @@ struct TEvKeyValue {
             , Stat(stat)
             , Status(status)
         {}
- 
-        TEvNotify(ui64 requestUid, ui64 generation, ui64 step, const NKeyValue::TRequestStat &stat, 
-                NKikimrKeyValue::Statuses::ReplyStatus status) 
-            : RequestUid(requestUid) 
-            , Generation(generation) 
-            , Step(step) 
-            , Stat(stat) 
-            , Status(ConvertStatus(status)) 
-        {} 
- 
-        static NMsgBusProxy::EResponseStatus ConvertStatus(NKikimrKeyValue::Statuses::ReplyStatus status) { 
-            switch (status) { 
-            case NKikimrKeyValue::Statuses::RSTATUS_OK: 
-                return NMsgBusProxy::MSTATUS_OK; 
-            case NKikimrKeyValue::Statuses::RSTATUS_ERROR: 
-                return NMsgBusProxy::MSTATUS_ERROR; 
-            case NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT: 
-                return NMsgBusProxy::MSTATUS_TIMEOUT; 
-            case NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR: 
-                return NMsgBusProxy::MSTATUS_INTERNALERROR; 
-            default: 
-                return NMsgBusProxy::MSTATUS_INTERNALERROR; 
-            } 
-        } 
-    };
-
-    struct TEvStoreCollect : public TEventLocal<TEvStoreCollect, EvStoreCollect> { 
+
+        TEvNotify(ui64 requestUid, ui64 generation, ui64 step, const NKeyValue::TRequestStat &stat,
+                NKikimrKeyValue::Statuses::ReplyStatus status)
+            : RequestUid(requestUid)
+            , Generation(generation)
+            , Step(step)
+            , Stat(stat)
+            , Status(ConvertStatus(status))
+        {}
+
+        static NMsgBusProxy::EResponseStatus ConvertStatus(NKikimrKeyValue::Statuses::ReplyStatus status) {
+            switch (status) {
+            case NKikimrKeyValue::Statuses::RSTATUS_OK:
+                return NMsgBusProxy::MSTATUS_OK;
+            case NKikimrKeyValue::Statuses::RSTATUS_ERROR:
+                return NMsgBusProxy::MSTATUS_ERROR;
+            case NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT:
+                return NMsgBusProxy::MSTATUS_TIMEOUT;
+            case NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR:
+                return NMsgBusProxy::MSTATUS_INTERNALERROR;
+            default:
+                return NMsgBusProxy::MSTATUS_INTERNALERROR;
+            }
+        }
+    };
+
+    struct TEvStoreCollect : public TEventLocal<TEvStoreCollect, EvStoreCollect> {
         TEvStoreCollect() { }
     };
 
-    struct TEvCollect : public TEventLocal<TEvCollect, EvCollect> { 
+    struct TEvCollect : public TEventLocal<TEvCollect, EvCollect> {
         TEvCollect() { }
     };
 
-    struct TEvEraseCollect : public TEventLocal<TEvEraseCollect, EvEraseCollect> { 
+    struct TEvEraseCollect : public TEventLocal<TEvEraseCollect, EvEraseCollect> {
         TEvEraseCollect() { }
     };
 
-    struct TEvPeriodicRefresh : public TEventLocal<TEvPeriodicRefresh, EvPeriodicRefresh> { 
+    struct TEvPeriodicRefresh : public TEventLocal<TEvPeriodicRefresh, EvPeriodicRefresh> {
         TEvPeriodicRefresh() { }
     };
 };
diff --git a/ydb/core/keyvalue/keyvalue_flat_impl.h b/ydb/core/keyvalue/keyvalue_flat_impl.h
index 518771a5d2..292f2feff9 100644
--- a/ydb/core/keyvalue/keyvalue_flat_impl.h
+++ b/ydb/core/keyvalue/keyvalue_flat_impl.h
@@ -279,29 +279,29 @@ protected:
 
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // gRPC 
- 
-    void Handle(TEvKeyValue::TEvRead::TPtr &ev) { 
-        State.OnEvReadRequest(ev, TActivationContext::AsActorContext(), Info()); 
-    } 
- 
-    void Handle(TEvKeyValue::TEvReadRange::TPtr &ev) { 
-        State.OnEvReadRangeRequest(ev, TActivationContext::AsActorContext(), Info()); 
-    } 
- 
-    void Handle(TEvKeyValue::TEvExecuteTransaction::TPtr &ev) { 
-        State.OnEvExecuteTransaction(ev, TActivationContext::AsActorContext(), Info()); 
-    } 
- 
-    void Handle(TEvKeyValue::TEvGetStatus::TPtr &ev) { 
-        State.OnEvGetStatus(ev, TActivationContext::AsActorContext(), Info()); 
-    } 
- 
-    void Handle(TEvKeyValue::TEvObtainLock::TPtr &ev) { 
-        State.OnEvObtainLock(ev, TActivationContext::AsActorContext(), Info()); 
-    } 
- 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
+    // gRPC
+
+    void Handle(TEvKeyValue::TEvRead::TPtr &ev) {
+        State.OnEvReadRequest(ev, TActivationContext::AsActorContext(), Info());
+    }
+
+    void Handle(TEvKeyValue::TEvReadRange::TPtr &ev) {
+        State.OnEvReadRangeRequest(ev, TActivationContext::AsActorContext(), Info());
+    }
+
+    void Handle(TEvKeyValue::TEvExecuteTransaction::TPtr &ev) {
+        State.OnEvExecuteTransaction(ev, TActivationContext::AsActorContext(), Info());
+    }
+
+    void Handle(TEvKeyValue::TEvGetStatus::TPtr &ev) {
+        State.OnEvGetStatus(ev, TActivationContext::AsActorContext(), Info());
+    }
+
+    void Handle(TEvKeyValue::TEvObtainLock::TPtr &ev) {
+        State.OnEvObtainLock(ev, TActivationContext::AsActorContext(), Info());
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // Online state
     void Handle(TEvKeyValue::TEvEraseCollect::TPtr &ev, const TActorContext &ctx) {
         LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletID()
@@ -339,19 +339,19 @@ protected:
         Execute(new TTxStoreCollect(this), ctx);
     }
 
-    void CheckYellowChannels(TRequestStat& stat) { 
-        IExecutor* executor = Executor(); 
+    void CheckYellowChannels(TRequestStat& stat) {
+        IExecutor* executor = Executor();
         if ((stat.YellowMoveChannels || stat.YellowStopChannels) && executor) {
             executor->OnYellowChannels(std::move(stat.YellowMoveChannels), std::move(stat.YellowStopChannels));
-        } 
-    } 
- 
+        }
+    }
+
     void Handle(TEvKeyValue::TEvIntermediate::TPtr &ev, const TActorContext &ctx) {
         LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletID()
                 << " Handle TEvIntermediate " << ev->Get()->ToString());
- 
-        CheckYellowChannels(ev->Get()->Intermediate->Stat); 
- 
+
+        CheckYellowChannels(ev->Get()->Intermediate->Stat);
+
         State.OnEvIntermediate(*(ev->Get()->Intermediate), ctx);
         Execute(new TTxRequest(std::move(ev->Get()->Intermediate), this), ctx);
     }
@@ -360,8 +360,8 @@ protected:
         TEvKeyValue::TEvNotify &event = *ev->Get();
         LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletID()
                 << " Handle TEvNotify " << event.ToString());
- 
-        CheckYellowChannels(ev->Get()->Stat); 
+
+        CheckYellowChannels(ev->Get()->Stat);
         State.OnRequestComplete(event.RequestUid, event.Generation, event.Step, ctx, Info(), event.Status, event.Stat);
     }
 
@@ -469,12 +469,12 @@ public:
             return;
         RestoreActorActivity();
         switch (ev->GetTypeRewrite()) {
-            hFunc(TEvKeyValue::TEvRead, Handle); 
-            hFunc(TEvKeyValue::TEvReadRange, Handle); 
-            hFunc(TEvKeyValue::TEvExecuteTransaction, Handle); 
-            hFunc(TEvKeyValue::TEvGetStatus, Handle); 
-            hFunc(TEvKeyValue::TEvObtainLock, Handle); 
- 
+            hFunc(TEvKeyValue::TEvRead, Handle);
+            hFunc(TEvKeyValue::TEvReadRange, Handle);
+            hFunc(TEvKeyValue::TEvExecuteTransaction, Handle);
+            hFunc(TEvKeyValue::TEvGetStatus, Handle);
+            hFunc(TEvKeyValue::TEvObtainLock, Handle);
+
             HFunc(TEvKeyValue::TEvEraseCollect, Handle);
             HFunc(TEvKeyValue::TEvCollect, Handle);
             HFunc(TEvKeyValue::TEvStoreCollect, Handle);
@@ -535,9 +535,9 @@ public:
 
     }
 
-    bool ReassignChannelsEnabled() const override { 
-        return true; 
-    } 
+    bool ReassignChannelsEnabled() const override {
+        return true;
+    }
 };
 
 
diff --git a/ydb/core/keyvalue/keyvalue_intermediate.cpp b/ydb/core/keyvalue/keyvalue_intermediate.cpp
index d7dd7f2c75..82a78d9fa2 100644
--- a/ydb/core/keyvalue/keyvalue_intermediate.cpp
+++ b/ydb/core/keyvalue/keyvalue_intermediate.cpp
@@ -76,15 +76,15 @@ TIntermediate::TIntermediate(TActorId respondTo, TActorId keyValueActorId, ui64
 }
 
 void TIntermediate::UpdateStat() {
-    auto checkRead = [&] (const auto &read) { 
+    auto checkRead = [&] (const auto &read) {
         if (read.Status == NKikimrProto::NODATA) {
             Stat.ReadNodata++;
         } else if (read.Status == NKikimrProto::OK) {
             Stat.Reads++;
             Stat.ReadBytes += read.Value.size();
         }
-    }; 
-    auto checkRangeRead = [&] (const auto &range) { 
+    };
+    auto checkRangeRead = [&] (const auto &range) {
         if (range.IncludeData) {
             for (const auto &read: range.Reads) {
                 if (read.Status == NKikimrProto::NODATA) {
@@ -95,50 +95,50 @@ void TIntermediate::UpdateStat() {
                 }
             }
         } else {
-        Stat.IndexRangeRead++; 
+        Stat.IndexRangeRead++;
         }
-    }; 
- 
-    if (ReadCommand) { 
-        auto checkReadCommand = [&] (auto &cmd) { 
-            using Type = std::decay_t<decltype(cmd)>; 
-            if constexpr (std::is_same_v<Type, TIntermediate::TRead>) { 
-                checkRead(cmd); 
-            } 
-            if constexpr (std::is_same_v<Type, TIntermediate::TRangeRead>) { 
-                checkRangeRead(cmd); 
-            } 
-        }; 
-        std::visit(checkReadCommand, *ReadCommand); 
+    };
+
+    if (ReadCommand) {
+        auto checkReadCommand = [&] (auto &cmd) {
+            using Type = std::decay_t<decltype(cmd)>;
+            if constexpr (std::is_same_v<Type, TIntermediate::TRead>) {
+                checkRead(cmd);
+            }
+            if constexpr (std::is_same_v<Type, TIntermediate::TRangeRead>) {
+                checkRangeRead(cmd);
+            }
+        };
+        std::visit(checkReadCommand, *ReadCommand);
+    }
+
+    for (const auto &read: Reads) {
+        checkRead(read);
+    }
+    for (const auto &range: RangeReads) {
+        checkRangeRead(range);
     }
- 
-    for (const auto &read: Reads) { 
-        checkRead(read); 
-    } 
-    for (const auto &range: RangeReads) { 
-        checkRangeRead(range); 
-    } 
     for (const auto &write: Writes) {
         if (write.Status == NKikimrProto::OK) {
             Stat.WriteBytes += write.Data.size();
         }
     }
 
-    for (const auto &cmd : Commands) { 
-        if (!std::holds_alternative<TIntermediate::TWrite>(cmd)) { 
-            continue; 
-        } 
-        const auto &write = std::get<TIntermediate::TWrite>(cmd); 
-        if (write.Status == NKikimrProto::OK) { 
-            Stat.WriteBytes += write.Data.size(); 
-        } 
-    } 
- 
-    Stat.Writes = WriteCount; 
+    for (const auto &cmd : Commands) {
+        if (!std::holds_alternative<TIntermediate::TWrite>(cmd)) {
+            continue;
+        }
+        const auto &write = std::get<TIntermediate::TWrite>(cmd);
+        if (write.Status == NKikimrProto::OK) {
+            Stat.WriteBytes += write.Data.size();
+        }
+    }
+
+    Stat.Writes = WriteCount;
     Stat.GetStatuses = GetStatuses.size();
-    Stat.Renames = RenameCount; 
-    Stat.CopyRanges = CopyRangeCount; 
-    Stat.Concats = ConcatCount; 
+    Stat.Renames = RenameCount;
+    Stat.CopyRanges = CopyRangeCount;
+    Stat.Concats = ConcatCount;
 }
 
 } // NKeyValue
diff --git a/ydb/core/keyvalue/keyvalue_intermediate.h b/ydb/core/keyvalue/keyvalue_intermediate.h
index bc446c8d61..c28c14b9c3 100644
--- a/ydb/core/keyvalue/keyvalue_intermediate.h
+++ b/ydb/core/keyvalue/keyvalue_intermediate.h
@@ -38,7 +38,7 @@ struct TIntermediate {
         ui32 Offset;
         ui32 Size;
         ui32 ValueSize;
-        ui32 RequestedSize = 0; 
+        ui32 RequestedSize = 0;
         ui64 CreationUnixTime;
         NKikimrClient::TKeyValueRequest::EStorageChannel StorageChannel;
         NKikimrBlobStorage::EGetHandleClass HandleClass;
@@ -100,9 +100,9 @@ struct TIntermediate {
         bool IsAllowed;
     };
 
-    using TCmd = std::variant<TWrite, TDelete, TRename, TCopyRange, TConcat>; 
-    using TReadCmd = std::variant<TRead, TRangeRead>; 
- 
+    using TCmd = std::variant<TWrite, TDelete, TRename, TCopyRange, TConcat>;
+    using TReadCmd = std::variant<TRead, TRangeRead>;
+
     TDeque<TRead> Reads;
     TDeque<TRangeRead> RangeReads;
     TDeque<TWrite> Writes;
@@ -114,16 +114,16 @@ struct TIntermediate {
     TMaybe<TTrimLeakedBlobs> TrimLeakedBlobs;
     TMaybe<TSetExecutorFastLogPolicy> SetExecutorFastLogPolicy;
 
-    TStackVec<TCmd, 1> Commands; 
-    TStackVec<ui32, 1> WriteIndices; 
-    std::optional<TReadCmd> ReadCommand; 
- 
-    ui64 WriteCount = 0; 
-    ui64 DeleteCount = 0; 
-    ui64 RenameCount = 0; 
-    ui64 CopyRangeCount = 0; 
-    ui64 ConcatCount = 0; 
- 
+    TStackVec<TCmd, 1> Commands;
+    TStackVec<ui32, 1> WriteIndices;
+    std::optional<TReadCmd> ReadCommand;
+
+    ui64 WriteCount = 0;
+    ui64 DeleteCount = 0;
+    ui64 RenameCount = 0;
+    ui64 CopyRangeCount = 0;
+    ui64 ConcatCount = 0;
+
     ui64 Cookie;
     ui64 Generation;
     ui64 RequestUid;
@@ -150,13 +150,13 @@ struct TIntermediate {
     TRequestStat Stat;
 
     NKikimrClient::TResponse Response;
-    NKikimrKeyValue::ExecuteTransactionResult ExecuteTransactionResponse; 
-    NKikimrKeyValue::GetStatusResult GetStatusResponse; 
+    NKikimrKeyValue::ExecuteTransactionResult ExecuteTransactionResponse;
+    NKikimrKeyValue::GetStatusResult GetStatusResponse;
+
+    THashMap<ui32, NKikimrKeyValue::Channel*> Channels;
+
+    ui32 EvType = 0;
 
-    THashMap<ui32, NKikimrKeyValue::Channel*> Channels; 
- 
-    ui32 EvType = 0; 
- 
     TIntermediate(TActorId respondTo, TActorId keyValueActorId, ui64 channelGeneration, ui64 channelStep,
             TRequestType::EType requestType);
 
diff --git a/ydb/core/keyvalue/keyvalue_request_stat.h b/ydb/core/keyvalue/keyvalue_request_stat.h
index d65fbcd019..070ffcbeca 100644
--- a/ydb/core/keyvalue/keyvalue_request_stat.h
+++ b/ydb/core/keyvalue/keyvalue_request_stat.h
@@ -37,7 +37,7 @@ struct TRequestStat {
 
     TVector<ui32> YellowStopChannels;
     TVector<ui32> YellowMoveChannels;
- 
+
     void Clear() {
         ReadBytes = 0;
         Reads = 0;
diff --git a/ydb/core/keyvalue/keyvalue_state.cpp b/ydb/core/keyvalue/keyvalue_state.cpp
index fda119eeeb..6b31c463f8 100644
--- a/ydb/core/keyvalue/keyvalue_state.cpp
+++ b/ydb/core/keyvalue/keyvalue_state.cpp
@@ -1,6 +1,6 @@
 #include "keyvalue_state.h"
 #include "keyvalue_data.h"
-#include "keyvalue_storage_read_request.h" 
+#include "keyvalue_storage_read_request.h"
 #include "keyvalue_storage_request.h"
 #include "keyvalue_trash_key_arbitrary.h"
 #include <ydb/core/base/tablet.h>
@@ -14,7 +14,7 @@
 #include <library/cpp/monlib/service/pages/templates.h>
 #include <library/cpp/json/writer/json_value.h>
 #include <util/string/escape.h>
-#include <util/charset/utf8.h> 
+#include <util/charset/utf8.h>
 
 // Set to 1 in order for tablet to reboot instead of failing a Y_VERIFY on database damage
 #define KIKIMR_KEYVALUE_ALLOW_DAMAGE 0
@@ -24,41 +24,41 @@ namespace NKeyValue {
 
 constexpr ui64 KeyValuePairSizeEstimation = 1 + 5 // Key id, length
     + 1 + 5 // Value id, length
-    + 1 + 4 // ValueSize id, value 
-    + 1 + 8 // CreationUnixTime id, value 
+    + 1 + 4 // ValueSize id, value
+    + 1 + 8 // CreationUnixTime id, value
     + 1 + 1 // StorageChannel id, value
     + 1 + 1 // Status id, value
     ;
 
-constexpr ui64 KeyValuePairSizeEstimationNewApi = 1 + 5 // Key id, length 
-    + 1 + 5 // Value id, length 
-    + 1 + 4 // ValueSize id, value 
-    + 1 + 8 // CreationUnixTime id, value 
-    + 1 + 4 // StorageChannel id, value 
-    + 1 + 1 // Status id, value 
-    ; 
- 
-constexpr ui64 KeyInfoSizeEstimation = 1 + 5 // Key id, length 
-    + 1 + 4 // ValueSize id, value 
-    + 1 + 8 // CreationUnixTime id, value 
-    + 1 + 4 // StorageChannel id, value 
-    ; 
- 
-constexpr ui64 ReadRangeRequestMetaDataSizeEstimation = 1 + 5 // pair id, length 
-    + 1 + 1 // Status id, value 
-    ; 
- 
+constexpr ui64 KeyValuePairSizeEstimationNewApi = 1 + 5 // Key id, length
+    + 1 + 5 // Value id, length
+    + 1 + 4 // ValueSize id, value
+    + 1 + 8 // CreationUnixTime id, value
+    + 1 + 4 // StorageChannel id, value
+    + 1 + 1 // Status id, value
+    ;
+
+constexpr ui64 KeyInfoSizeEstimation = 1 + 5 // Key id, length
+    + 1 + 4 // ValueSize id, value
+    + 1 + 8 // CreationUnixTime id, value
+    + 1 + 4 // StorageChannel id, value
+    ;
+
+constexpr ui64 ReadRangeRequestMetaDataSizeEstimation = 1 + 5 // pair id, length
+    + 1 + 1 // Status id, value
+    ;
+
 constexpr ui64 ReadResultSizeEstimation = 1 + 1 // Status id, value
     + 1 + 5 // Value id, length OR Message id, length
     ;
 
-constexpr ui64 ReadResultSizeEstimationNewApi = 1 + 5 // Key id, length 
-    + 1 + 5 // Value id, length 
-    + 1 + 8 // Offset id, value 
-    + 1 + 8 // Size id, value 
-    + 1 + 1 // Status id, value 
-    ; 
- 
+constexpr ui64 ReadResultSizeEstimationNewApi = 1 + 5 // Key id, length
+    + 1 + 5 // Value id, length
+    + 1 + 8 // Offset id, value
+    + 1 + 8 // Size id, value
+    + 1 + 1 // Status id, value
+    ;
+
 constexpr ui64 ErrorMessageSizeEstimation = 128;
 
 // Guideline:
@@ -134,9 +134,9 @@ void TKeyValueState::SetupResourceMetrics(NMetrics::TResourceMetrics* resourceMe
     ResourceMetrics = resourceMetrics;
 }
 
-void TKeyValueState::CountRequestComplete(NMsgBusProxy::EResponseStatus status, 
-        const TRequestStat &stat, const TActorContext &ctx) 
-{ 
+void TKeyValueState::CountRequestComplete(NMsgBusProxy::EResponseStatus status,
+        const TRequestStat &stat, const TActorContext &ctx)
+{
     ui64 fullLatencyMs = (TAppData::TimeProvider->Now() - stat.IntermediateCreatedAt).MilliSeconds();
     if (stat.RequestType == TRequestType::WriteOnly) {
         TabletCounters->Percentile()[COUNTER_LATENCY_FULL_WO].IncrementFor(fullLatencyMs);
@@ -807,8 +807,8 @@ void TKeyValueState::RequestExecute(THolder<TIntermediate> &intermediate, ISimpl
     // Process CmdIncrementGeneration()
     if (intermediate->HasIncrementGeneration) {
 
-        bool IsOk = intermediate->Commands.size() == 0 
-            && intermediate->Deletes.size() == 0 && intermediate->RangeReads.size() == 0 
+        bool IsOk = intermediate->Commands.size() == 0
+            && intermediate->Deletes.size() == 0 && intermediate->RangeReads.size() == 0
             && intermediate->Reads.size() == 0 && intermediate->Renames.size() == 0
             && intermediate->Writes.size() == 0 && intermediate->GetStatuses.size() == 0;
 
@@ -819,7 +819,7 @@ void TKeyValueState::RequestExecute(THolder<TIntermediate> &intermediate, ISimpl
             TStringStream str;
             str << "KeyValue# " << TabletId;
             str << " CmdIncrementGeneration can't be grouped with any other Cmd!";
-            str << " Commands# " << intermediate->Commands.size(); 
+            str << " Commands# " << intermediate->Commands.size();
             str << " Deletes# " << intermediate->Deletes.size();
             str << " RangeReads# " << intermediate->RangeReads.size();
             str << " Reads# " << intermediate->Reads.size();
@@ -852,35 +852,35 @@ void TKeyValueState::RequestComplete(THolder<TIntermediate> &intermediate, const
 ///////////////////////////////////////////////////////////////////////////////
 // Request processing
 //
- 
+
 void TKeyValueState::Reply(THolder<TIntermediate> &intermediate, const TActorContext &ctx,
         const TTabletStorageInfo *info) {
     if (!intermediate->IsReplied) {
-        if (intermediate->EvType == TEvKeyValue::TEvRequest::EventType) { 
-            THolder<TEvKeyValue::TEvResponse> response(new TEvKeyValue::TEvResponse); 
-            response->Record = intermediate->Response; 
-            ResourceMetrics->Network.Increment(response->Record.ByteSize()); 
-            ctx.Send(intermediate->RespondTo, response.Release()); 
-        } 
-        if (intermediate->EvType == TEvKeyValue::TEvExecuteTransaction::EventType) { 
-            THolder<TEvKeyValue::TEvExecuteTransactionResponse> response(new TEvKeyValue::TEvExecuteTransactionResponse); 
-            response->Record = intermediate->ExecuteTransactionResponse; 
-            ResourceMetrics->Network.Increment(response->Record.ByteSize()); 
-            ctx.Send(intermediate->RespondTo, response.Release()); 
-        } 
-        if (intermediate->EvType == TEvKeyValue::TEvGetStatus::EventType) { 
-            THolder<TEvKeyValue::TEvGetStatusResponse> response(new TEvKeyValue::TEvGetStatusResponse); 
-            response->Record = intermediate->GetStatusResponse; 
-            ResourceMetrics->Network.Increment(response->Record.ByteSize()); 
-            ctx.Send(intermediate->RespondTo, response.Release()); 
-        } 
-        if (intermediate->EvType == TEvKeyValue::TEvObtainLock::EventType) { 
-            THolder<TEvKeyValue::TEvObtainLockResponse> response(new TEvKeyValue::TEvObtainLockResponse); 
-            response->Record.set_lock_generation(StoredState.GetUserGeneration()); 
-            response->Record.set_cookie(intermediate->Cookie); 
-            ResourceMetrics->Network.Increment(response->Record.ByteSize()); 
-            ctx.Send(intermediate->RespondTo, response.Release()); 
-        } 
+        if (intermediate->EvType == TEvKeyValue::TEvRequest::EventType) {
+            THolder<TEvKeyValue::TEvResponse> response(new TEvKeyValue::TEvResponse);
+            response->Record = intermediate->Response;
+            ResourceMetrics->Network.Increment(response->Record.ByteSize());
+            ctx.Send(intermediate->RespondTo, response.Release());
+        }
+        if (intermediate->EvType == TEvKeyValue::TEvExecuteTransaction::EventType) {
+            THolder<TEvKeyValue::TEvExecuteTransactionResponse> response(new TEvKeyValue::TEvExecuteTransactionResponse);
+            response->Record = intermediate->ExecuteTransactionResponse;
+            ResourceMetrics->Network.Increment(response->Record.ByteSize());
+            ctx.Send(intermediate->RespondTo, response.Release());
+        }
+        if (intermediate->EvType == TEvKeyValue::TEvGetStatus::EventType) {
+            THolder<TEvKeyValue::TEvGetStatusResponse> response(new TEvKeyValue::TEvGetStatusResponse);
+            response->Record = intermediate->GetStatusResponse;
+            ResourceMetrics->Network.Increment(response->Record.ByteSize());
+            ctx.Send(intermediate->RespondTo, response.Release());
+        }
+        if (intermediate->EvType == TEvKeyValue::TEvObtainLock::EventType) {
+            THolder<TEvKeyValue::TEvObtainLockResponse> response(new TEvKeyValue::TEvObtainLockResponse);
+            response->Record.set_lock_generation(StoredState.GetUserGeneration());
+            response->Record.set_cookie(intermediate->Cookie);
+            ResourceMetrics->Network.Increment(response->Record.ByteSize());
+            ctx.Send(intermediate->RespondTo, response.Release());
+        }
         intermediate->IsReplied = true;
         intermediate->UpdateStat();
 
@@ -891,338 +891,338 @@ void TKeyValueState::Reply(THolder<TIntermediate> &intermediate, const TActorCon
     }
 }
 
-void TKeyValueState::ProcessCmd(TIntermediate::TRead &request, 
-        NKikimrClient::TKeyValueResponse::TReadResult *legacyResponse, 
-        NKikimrKeyValue::Channel */*response*/, 
-        ISimpleDb &/*db*/, const TActorContext &/*ctx*/, TRequestStat &/*stat*/, ui64 /*unixTime*/) 
-{ 
-    NKikimrProto::EReplyStatus outStatus = request.CumulativeStatus(); 
-    request.Status = outStatus; 
-    legacyResponse->SetStatus(outStatus); 
-    if (outStatus == NKikimrProto::OK) { 
-        legacyResponse->SetValue(request.Value); 
-        Y_VERIFY(request.Value.size() == request.ValueSize); 
-    } else { 
-        legacyResponse->SetMessage(request.Message); 
-        if (outStatus == NKikimrProto::NODATA) { 
-            for (ui32 itemIdx = 0; itemIdx < request.ReadItems.size(); ++itemIdx) { 
-                TIntermediate::TRead::TReadItem &item = request.ReadItems[itemIdx]; 
-                // Make sure the blob is not referenced anymore 
-                auto refCountIt = RefCounts.find(item.LogoBlobId); 
-                if (refCountIt != RefCounts.end()) { 
-                    TStringStream str; 
-                    str << "KeyValue# " << TabletId 
-                        << " CmdRead " 
-                        //<< " ReadIdx# " << i 
-                        << " key# " << EscapeC(request.Key) 
-                        << " ItemIdx# " << itemIdx 
-                        << " BlobId# " << item.LogoBlobId.ToString() 
-                        << " Status# " << NKikimrProto::EReplyStatus_Name(item.Status) 
-                        << " outStatus# " << NKikimrProto::EReplyStatus_Name(outStatus) 
-                        << " but blob has RefCount# " << refCountIt->second 
-                        << " ! KEYVALUE CONSISTENCY ERROR!" 
-                        << " Message# " << request.Message 
-                        << " Marker# KV46"; 
-                    Y_VERIFY(false, "%s", str.Str().c_str()); 
-                } 
-            } 
-        } 
-    } 
-} 
-
-void TKeyValueState::ProcessCmd(TIntermediate::TRangeRead &request, 
-        NKikimrClient::TKeyValueResponse::TReadRangeResult *legacyResponse, 
-        NKikimrKeyValue::Channel */*response*/, 
-        ISimpleDb &/*db*/, const TActorContext &/*ctx*/, TRequestStat &/*stat*/, ui64 /*unixTime*/) 
-{ 
-    for (ui64 r = 0; r < request.Reads.size(); ++r) { 
-        auto &read = request.Reads[r]; 
-        auto *resultKv = legacyResponse->AddPair(); 
- 
-        NKikimrProto::EReplyStatus outStatus = read.CumulativeStatus(); 
-        read.Status = outStatus; 
-        if (outStatus != NKikimrProto::OK && outStatus != NKikimrProto::OVERRUN) { 
-            // LOG_ERROR_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " CmdReadRange " << r 
-            //    << " status " << NKikimrProto::EReplyStatus_Name(outStatus) 
-            //    << " message " << read.Message 
-            //    << " key " << EscapeC(read.Key)); 
- 
+void TKeyValueState::ProcessCmd(TIntermediate::TRead &request,
+        NKikimrClient::TKeyValueResponse::TReadResult *legacyResponse,
+        NKikimrKeyValue::Channel */*response*/,
+        ISimpleDb &/*db*/, const TActorContext &/*ctx*/, TRequestStat &/*stat*/, ui64 /*unixTime*/)
+{
+    NKikimrProto::EReplyStatus outStatus = request.CumulativeStatus();
+    request.Status = outStatus;
+    legacyResponse->SetStatus(outStatus);
+    if (outStatus == NKikimrProto::OK) {
+        legacyResponse->SetValue(request.Value);
+        Y_VERIFY(request.Value.size() == request.ValueSize);
+    } else {
+        legacyResponse->SetMessage(request.Message);
+        if (outStatus == NKikimrProto::NODATA) {
+            for (ui32 itemIdx = 0; itemIdx < request.ReadItems.size(); ++itemIdx) {
+                TIntermediate::TRead::TReadItem &item = request.ReadItems[itemIdx];
+                // Make sure the blob is not referenced anymore
+                auto refCountIt = RefCounts.find(item.LogoBlobId);
+                if (refCountIt != RefCounts.end()) {
+                    TStringStream str;
+                    str << "KeyValue# " << TabletId
+                        << " CmdRead "
+                        //<< " ReadIdx# " << i
+                        << " key# " << EscapeC(request.Key)
+                        << " ItemIdx# " << itemIdx
+                        << " BlobId# " << item.LogoBlobId.ToString()
+                        << " Status# " << NKikimrProto::EReplyStatus_Name(item.Status)
+                        << " outStatus# " << NKikimrProto::EReplyStatus_Name(outStatus)
+                        << " but blob has RefCount# " << refCountIt->second
+                        << " ! KEYVALUE CONSISTENCY ERROR!"
+                        << " Message# " << request.Message
+                        << " Marker# KV46";
+                    Y_VERIFY(false, "%s", str.Str().c_str());
+                }
+            }
+        }
+    }
+}
+
+void TKeyValueState::ProcessCmd(TIntermediate::TRangeRead &request,
+        NKikimrClient::TKeyValueResponse::TReadRangeResult *legacyResponse,
+        NKikimrKeyValue::Channel */*response*/,
+        ISimpleDb &/*db*/, const TActorContext &/*ctx*/, TRequestStat &/*stat*/, ui64 /*unixTime*/)
+{
+    for (ui64 r = 0; r < request.Reads.size(); ++r) {
+        auto &read = request.Reads[r];
+        auto *resultKv = legacyResponse->AddPair();
+
+        NKikimrProto::EReplyStatus outStatus = read.CumulativeStatus();
+        read.Status = outStatus;
+        if (outStatus != NKikimrProto::OK && outStatus != NKikimrProto::OVERRUN) {
+            // LOG_ERROR_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " CmdReadRange " << r
+            //    << " status " << NKikimrProto::EReplyStatus_Name(outStatus)
+            //    << " message " << read.Message
+            //    << " key " << EscapeC(read.Key));
+
             if (outStatus == NKikimrProto::NODATA) {
-                for (ui32 itemIdx = 0; itemIdx < read.ReadItems.size(); ++itemIdx) { 
-                    TIntermediate::TRead::TReadItem &item = read.ReadItems[itemIdx]; 
+                for (ui32 itemIdx = 0; itemIdx < read.ReadItems.size(); ++itemIdx) {
+                    TIntermediate::TRead::TReadItem &item = read.ReadItems[itemIdx];
                     // Make sure the blob is not referenced anymore
                     auto refCountIt = RefCounts.find(item.LogoBlobId);
                     if (refCountIt != RefCounts.end()) {
                         TStringStream str;
                         str << "KeyValue# " << TabletId
-                            << " CmdReadRange " 
-                            // << " RangeReadIdx# " << i 
-                            << " ReadIdx# " << r 
+                            << " CmdReadRange "
+                            // << " RangeReadIdx# " << i
+                            << " ReadIdx# " << r
                             << " ItemIdx# " << itemIdx
-                            << " key# " << EscapeC(read.Key) 
+                            << " key# " << EscapeC(read.Key)
                             << " BlobId# " << item.LogoBlobId.ToString()
                             << " Status# " << NKikimrProto::EReplyStatus_Name(item.Status)
                             << " outStatus# " << NKikimrProto::EReplyStatus_Name(outStatus)
                             << " but blob has RefCount# " << refCountIt->second
                             << " ! KEYVALUE CONSISTENCY ERROR!"
-                            << " Message# " << read.Message 
-                            << " Marker# KV47"; 
+                            << " Message# " << read.Message
+                            << " Marker# KV47";
                         Y_VERIFY(false, "%s", str.Str().c_str());
                     }
                 }
             }
         }
- 
-        resultKv->SetStatus(outStatus); 
-        resultKv->SetKey(read.Key); 
-        if (request.IncludeData && (outStatus == NKikimrProto::OK || outStatus == NKikimrProto::OVERRUN)) { 
-            resultKv->SetValue(read.Value); 
-            Y_VERIFY(read.Value.size() == read.ValueSize); 
-        } 
-        resultKv->SetValueSize(read.ValueSize); 
-        resultKv->SetCreationUnixTime(read.CreationUnixTime); 
-        resultKv->SetStorageChannel(read.StorageChannel); 
-    }
- 
-    legacyResponse->SetStatus(request.Status); 
-}
-
-
-void SetStatusFlags(NKikimrKeyValue::Flags *flags, const TStorageStatusFlags &statusFlags) { 
-    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceCyan)) { 
-        flags->set_disk_space_cyan(true); 
-    } 
-    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceLightYellowMove)) { 
-        flags->set_disk_space_light_yellow_move(true); 
-    } 
-    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceYellowStop)) { 
-        flags->set_disk_space_yellow_stop(true); 
-    } 
-    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceLightOrange)) { 
-        flags->set_disk_space_light_orange(true); 
-    } 
-    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceOrange)) { 
-        flags->set_disk_space_orange(true); 
-    } 
-    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceRed)) { 
-        flags->set_disk_space_red(true); 
-    } 
-    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceBlack)) { 
-        flags->set_disk_space_black(true); 
-    } 
-} 
- 
-void TKeyValueState::ProcessCmd(TIntermediate::TWrite &request, 
-        NKikimrClient::TKeyValueResponse::TWriteResult *legacyResponse, 
-        NKikimrKeyValue::Channel *response, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &/*stat*/, ui64 unixTime) 
-{ 
-    TIndexRecord& record = Index[request.Key]; 
-    Dereference(record, db, ctx); 
-
-    record.Chain = {}; 
-    ui32 storage_channel = 0; 
-    if (request.Status == NKikimrProto::SCHEDULED) { 
-        TString inlineData = request.Data; 
-        record.Chain.push_back(TIndexRecord::TChainItem(inlineData, 0)); 
-        CountWriteRecord(0, inlineData.size()); 
-        request.Status = NKikimrProto::OK; 
-        storage_channel = InlineStorageChannelInPublicApi; 
-    } else { 
-        int channel = -1; 
-
-        ui64 offset = 0; 
-        for (const TLogoBlobID& logoBlobId : request.LogoBlobIds) { 
-            record.Chain.push_back(TIndexRecord::TChainItem(logoBlobId, offset)); 
-            offset += logoBlobId.BlobSize(); 
-            CountWriteRecord(logoBlobId.Channel(), logoBlobId.BlobSize()); 
-            if (channel == -1) { 
-                channel = logoBlobId.Channel(); 
-            } else { 
-                // all blobs from the same write must be within the same channel 
-                Y_VERIFY(channel == (int)logoBlobId.Channel()); 
+
+        resultKv->SetStatus(outStatus);
+        resultKv->SetKey(read.Key);
+        if (request.IncludeData && (outStatus == NKikimrProto::OK || outStatus == NKikimrProto::OVERRUN)) {
+            resultKv->SetValue(read.Value);
+            Y_VERIFY(read.Value.size() == read.ValueSize);
+        }
+        resultKv->SetValueSize(read.ValueSize);
+        resultKv->SetCreationUnixTime(read.CreationUnixTime);
+        resultKv->SetStorageChannel(read.StorageChannel);
+    }
+
+    legacyResponse->SetStatus(request.Status);
+}
+
+
+void SetStatusFlags(NKikimrKeyValue::Flags *flags, const TStorageStatusFlags &statusFlags) {
+    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceCyan)) {
+        flags->set_disk_space_cyan(true);
+    }
+    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceLightYellowMove)) {
+        flags->set_disk_space_light_yellow_move(true);
+    }
+    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceYellowStop)) {
+        flags->set_disk_space_yellow_stop(true);
+    }
+    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceLightOrange)) {
+        flags->set_disk_space_light_orange(true);
+    }
+    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceOrange)) {
+        flags->set_disk_space_orange(true);
+    }
+    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceRed)) {
+        flags->set_disk_space_red(true);
+    }
+    if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceBlack)) {
+        flags->set_disk_space_black(true);
+    }
+}
+
+void TKeyValueState::ProcessCmd(TIntermediate::TWrite &request,
+        NKikimrClient::TKeyValueResponse::TWriteResult *legacyResponse,
+        NKikimrKeyValue::Channel *response,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &/*stat*/, ui64 unixTime)
+{
+    TIndexRecord& record = Index[request.Key];
+    Dereference(record, db, ctx);
+
+    record.Chain = {};
+    ui32 storage_channel = 0;
+    if (request.Status == NKikimrProto::SCHEDULED) {
+        TString inlineData = request.Data;
+        record.Chain.push_back(TIndexRecord::TChainItem(inlineData, 0));
+        CountWriteRecord(0, inlineData.size());
+        request.Status = NKikimrProto::OK;
+        storage_channel = InlineStorageChannelInPublicApi;
+    } else {
+        int channel = -1;
+
+        ui64 offset = 0;
+        for (const TLogoBlobID& logoBlobId : request.LogoBlobIds) {
+            record.Chain.push_back(TIndexRecord::TChainItem(logoBlobId, offset));
+            offset += logoBlobId.BlobSize();
+            CountWriteRecord(logoBlobId.Channel(), logoBlobId.BlobSize());
+            if (channel == -1) {
+                channel = logoBlobId.Channel();
+            } else {
+                // all blobs from the same write must be within the same channel
+                Y_VERIFY(channel == (int)logoBlobId.Channel());
             }
-        } 
-        storage_channel = channel + MainStorageChannelInPublicApi; 
-
-        ctx.Send(ChannelBalancerActorId, new TChannelBalancer::TEvReportWriteLatency(channel, request.Latency)); 
-    } 
- 
-    record.CreationUnixTime = unixTime; 
-    UpdateKeyValue(request.Key, record, db, ctx); 
- 
-    if (legacyResponse) { 
-        legacyResponse->SetStatus(NKikimrProto::OK); 
-        legacyResponse->SetStatusFlags(request.StatusFlags.Raw); 
-    } 
-    if (response) { 
-        response->set_status(NKikimrKeyValue::Statuses::RSTATUS_OK); 
-        auto *flags = response->mutable_status_flags(); 
-        SetStatusFlags(flags, request.StatusFlags); 
-        response->set_storage_channel(storage_channel); 
-    } 
-} 
- 
-void TKeyValueState::ProcessCmd(const TIntermediate::TDelete &request, 
-        NKikimrClient::TKeyValueResponse::TDeleteRangeResult *legacyResponse, 
-        NKikimrKeyValue::Channel */*response*/, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 /*unixTime*/) 
-{ 
-    TraverseRange(request.Range, [&](TIndex::iterator it) { 
-        stat.Deletes++; 
-        stat.DeleteBytes += it->second.GetFullValueSize(); 
-        Dereference(it->second, db, ctx); 
-        THelpers::DbEraseUserKey(it->first, db, ctx); 
-        Index.erase(it); 
-    }); 
- 
-    if (legacyResponse) { 
-        legacyResponse->SetStatus(NKikimrProto::OK); 
-    } 
-} 
- 
-void TKeyValueState::ProcessCmd(const TIntermediate::TRename &request, 
-        NKikimrClient::TKeyValueResponse::TRenameResult *legacyResponse, 
-        NKikimrKeyValue::Channel */*response*/, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &/*stat*/, ui64 unixTime) 
-{ 
-    auto oldIter = Index.find(request.OldKey); 
-    Y_VERIFY(oldIter != Index.end()); 
-    TIndexRecord& source = oldIter->second; 
- 
-    TIndexRecord& dest = Index[request.NewKey]; 
-    Dereference(dest, db, ctx); 
-    dest.Chain = std::move(source.Chain); 
-    dest.CreationUnixTime = unixTime; 
- 
-    THelpers::DbEraseUserKey(oldIter->first, db, ctx); 
-    Index.erase(oldIter); 
- 
-    UpdateKeyValue(request.NewKey, dest, db, ctx); 
- 
-    if (legacyResponse) { 
-        legacyResponse->SetStatus(NKikimrProto::OK); 
-    } 
-} 
- 
-void TKeyValueState::ProcessCmd(const TIntermediate::TCopyRange &request, 
-        NKikimrClient::TKeyValueResponse::TCopyRangeResult *legacyResponse, 
-        NKikimrKeyValue::Channel */*response*/, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &/*stat*/, ui64 /*unixTime*/) 
-{ 
-    TVector<TIndex::iterator> itemsToClone; 
- 
-    TraverseRange(request.Range, [&](TIndex::iterator it) { 
-        if (it->first.StartsWith(request.PrefixToRemove)) { 
-            itemsToClone.push_back(it); 
-        } 
-    }); 
- 
-    for (TIndex::iterator it : itemsToClone) { 
-        const TIndexRecord& sourceRecord = it->second; 
-        for (const TIndexRecord::TChainItem& item : sourceRecord.Chain) { 
-            if (!item.IsInline()) { 
-                ++RefCounts[item.LogoBlobId]; 
+        }
+        storage_channel = channel + MainStorageChannelInPublicApi;
+
+        ctx.Send(ChannelBalancerActorId, new TChannelBalancer::TEvReportWriteLatency(channel, request.Latency));
+    }
+
+    record.CreationUnixTime = unixTime;
+    UpdateKeyValue(request.Key, record, db, ctx);
+
+    if (legacyResponse) {
+        legacyResponse->SetStatus(NKikimrProto::OK);
+        legacyResponse->SetStatusFlags(request.StatusFlags.Raw);
+    }
+    if (response) {
+        response->set_status(NKikimrKeyValue::Statuses::RSTATUS_OK);
+        auto *flags = response->mutable_status_flags();
+        SetStatusFlags(flags, request.StatusFlags);
+        response->set_storage_channel(storage_channel);
+    }
+}
+
+void TKeyValueState::ProcessCmd(const TIntermediate::TDelete &request,
+        NKikimrClient::TKeyValueResponse::TDeleteRangeResult *legacyResponse,
+        NKikimrKeyValue::Channel */*response*/,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 /*unixTime*/)
+{
+    TraverseRange(request.Range, [&](TIndex::iterator it) {
+        stat.Deletes++;
+        stat.DeleteBytes += it->second.GetFullValueSize();
+        Dereference(it->second, db, ctx);
+        THelpers::DbEraseUserKey(it->first, db, ctx);
+        Index.erase(it);
+    });
+
+    if (legacyResponse) {
+        legacyResponse->SetStatus(NKikimrProto::OK);
+    }
+}
+
+void TKeyValueState::ProcessCmd(const TIntermediate::TRename &request,
+        NKikimrClient::TKeyValueResponse::TRenameResult *legacyResponse,
+        NKikimrKeyValue::Channel */*response*/,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &/*stat*/, ui64 unixTime)
+{
+    auto oldIter = Index.find(request.OldKey);
+    Y_VERIFY(oldIter != Index.end());
+    TIndexRecord& source = oldIter->second;
+
+    TIndexRecord& dest = Index[request.NewKey];
+    Dereference(dest, db, ctx);
+    dest.Chain = std::move(source.Chain);
+    dest.CreationUnixTime = unixTime;
+
+    THelpers::DbEraseUserKey(oldIter->first, db, ctx);
+    Index.erase(oldIter);
+
+    UpdateKeyValue(request.NewKey, dest, db, ctx);
+
+    if (legacyResponse) {
+        legacyResponse->SetStatus(NKikimrProto::OK);
+    }
+}
+
+void TKeyValueState::ProcessCmd(const TIntermediate::TCopyRange &request,
+        NKikimrClient::TKeyValueResponse::TCopyRangeResult *legacyResponse,
+        NKikimrKeyValue::Channel */*response*/,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &/*stat*/, ui64 /*unixTime*/)
+{
+    TVector<TIndex::iterator> itemsToClone;
+
+    TraverseRange(request.Range, [&](TIndex::iterator it) {
+        if (it->first.StartsWith(request.PrefixToRemove)) {
+            itemsToClone.push_back(it);
+        }
+    });
+
+    for (TIndex::iterator it : itemsToClone) {
+        const TIndexRecord& sourceRecord = it->second;
+        for (const TIndexRecord::TChainItem& item : sourceRecord.Chain) {
+            if (!item.IsInline()) {
+                ++RefCounts[item.LogoBlobId];
+            }
+        }
+
+        TString newKey = request.PrefixToAdd + it->first.substr(request.PrefixToRemove.size());
+        TIndexRecord& record = Index[newKey];
+        Dereference(record, db, ctx);
+        record.Chain = sourceRecord.Chain;
+        record.CreationUnixTime = sourceRecord.CreationUnixTime;
+        UpdateKeyValue(newKey, record, db, ctx);
+    }
+
+    if (legacyResponse) {
+        legacyResponse->SetStatus(NKikimrProto::OK);
+    }
+}
+
+void TKeyValueState::ProcessCmd(const TIntermediate::TConcat &request,
+        NKikimrClient::TKeyValueResponse::TConcatResult *legacyResponse,
+        NKikimrKeyValue::Channel */*response*/,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &/*stat*/, ui64 unixTime)
+{
+    TVector<TIndexRecord::TChainItem> chain;
+    ui64 offset = 0;
+
+    for (const TString& key : request.InputKeys) {
+        auto it = Index.find(key);
+        Y_VERIFY(it != Index.end());
+        TIndexRecord& input = it->second;
+
+        for (TIndexRecord::TChainItem& chainItem : input.Chain) {
+            if (chainItem.IsInline()) {
+                chain.push_back(TIndexRecord::TChainItem(chainItem.InlineData, offset));
+            } else {
+                const TLogoBlobID& id = chainItem.LogoBlobId;
+                chain.push_back(TIndexRecord::TChainItem(id, offset));
+                ++RefCounts[id];
             }
+            offset += chainItem.GetSize();
+        }
+
+        if (!request.KeepInputs) {
+            Dereference(input, db, ctx);
+            THelpers::DbEraseUserKey(it->first, db, ctx);
+            Index.erase(it);
         }
+    }
+
+    TIndexRecord& record = Index[request.OutputKey];
+    Dereference(record, db, ctx);
+    record.Chain = std::move(chain);
+    record.CreationUnixTime = unixTime;
+    UpdateKeyValue(request.OutputKey, record, db, ctx);
+
+    if (legacyResponse) {
+        legacyResponse->SetStatus(NKikimrProto::OK);
+    }
+}
+
+void TKeyValueState::CmdRead(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) {
+    for (ui64 i = 0; i < intermediate->Reads.size(); ++i) {
+        auto &request = intermediate->Reads[i];
+        auto *response = intermediate->Response.AddReadResult();
+        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0);
+    }
+    if (intermediate->ReadCommand && std::holds_alternative<TIntermediate::TRead>(*intermediate->ReadCommand)) {
+        auto &request = std::get<TIntermediate::TRead>(*intermediate->ReadCommand);
+        auto *response = intermediate->Response.AddReadResult();
+        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0);
+    }
+}
+
+void TKeyValueState::CmdReadRange(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) {
+    Y_UNUSED(ctx);
+    Y_UNUSED(db);
+    for (ui64 i = 0; i < intermediate->RangeReads.size(); ++i) {
+        auto &rangeRead = intermediate->RangeReads[i];
+        auto *rangeReadResult = intermediate->Response.AddReadRangeResult();
+        ProcessCmd(rangeRead, rangeReadResult, nullptr, db, ctx, intermediate->Stat, 0);
+    }
+    if (intermediate->ReadCommand && std::holds_alternative<TIntermediate::TRangeRead>(*intermediate->ReadCommand)) {
+        auto &request = std::get<TIntermediate::TRangeRead>(*intermediate->ReadCommand);
+        auto *response = intermediate->Response.AddReadRangeResult();
+        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0);
+    }
+}
+
+void TKeyValueState::CmdRename(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) {
+    ui64 unixTime = TAppData::TimeProvider->Now().Seconds();
+    for (ui32 i = 0; i < intermediate->Renames.size(); ++i) {
+        auto& request = intermediate->Renames[i];
+        auto *response = intermediate->Response.AddRenameResult();
+        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, unixTime);
+    }
+}
 
-        TString newKey = request.PrefixToAdd + it->first.substr(request.PrefixToRemove.size()); 
-        TIndexRecord& record = Index[newKey]; 
-        Dereference(record, db, ctx); 
-        record.Chain = sourceRecord.Chain; 
-        record.CreationUnixTime = sourceRecord.CreationUnixTime; 
-        UpdateKeyValue(newKey, record, db, ctx); 
-    }
- 
-    if (legacyResponse) { 
-        legacyResponse->SetStatus(NKikimrProto::OK); 
-    } 
-}
-
-void TKeyValueState::ProcessCmd(const TIntermediate::TConcat &request, 
-        NKikimrClient::TKeyValueResponse::TConcatResult *legacyResponse, 
-        NKikimrKeyValue::Channel */*response*/, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &/*stat*/, ui64 unixTime) 
-{ 
-    TVector<TIndexRecord::TChainItem> chain; 
-    ui64 offset = 0; 
-
-    for (const TString& key : request.InputKeys) { 
-        auto it = Index.find(key); 
-        Y_VERIFY(it != Index.end()); 
-        TIndexRecord& input = it->second; 
-
-        for (TIndexRecord::TChainItem& chainItem : input.Chain) { 
-            if (chainItem.IsInline()) { 
-                chain.push_back(TIndexRecord::TChainItem(chainItem.InlineData, offset)); 
-            } else { 
-                const TLogoBlobID& id = chainItem.LogoBlobId; 
-                chain.push_back(TIndexRecord::TChainItem(id, offset)); 
-                ++RefCounts[id]; 
-            } 
-            offset += chainItem.GetSize(); 
-        } 
-
-        if (!request.KeepInputs) { 
-            Dereference(input, db, ctx); 
-            THelpers::DbEraseUserKey(it->first, db, ctx); 
-            Index.erase(it); 
-        } 
-    } 
-
-    TIndexRecord& record = Index[request.OutputKey]; 
-    Dereference(record, db, ctx); 
-    record.Chain = std::move(chain); 
-    record.CreationUnixTime = unixTime; 
-    UpdateKeyValue(request.OutputKey, record, db, ctx); 
-
-    if (legacyResponse) { 
-        legacyResponse->SetStatus(NKikimrProto::OK); 
-    } 
-} 
- 
-void TKeyValueState::CmdRead(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) { 
-    for (ui64 i = 0; i < intermediate->Reads.size(); ++i) { 
-        auto &request = intermediate->Reads[i]; 
-        auto *response = intermediate->Response.AddReadResult(); 
-        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0); 
-    }
-    if (intermediate->ReadCommand && std::holds_alternative<TIntermediate::TRead>(*intermediate->ReadCommand)) { 
-        auto &request = std::get<TIntermediate::TRead>(*intermediate->ReadCommand); 
-        auto *response = intermediate->Response.AddReadResult(); 
-        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0); 
-    } 
-}
-
-void TKeyValueState::CmdReadRange(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) { 
-    Y_UNUSED(ctx); 
-    Y_UNUSED(db); 
-    for (ui64 i = 0; i < intermediate->RangeReads.size(); ++i) { 
-        auto &rangeRead = intermediate->RangeReads[i]; 
-        auto *rangeReadResult = intermediate->Response.AddReadRangeResult(); 
-        ProcessCmd(rangeRead, rangeReadResult, nullptr, db, ctx, intermediate->Stat, 0); 
-    } 
-    if (intermediate->ReadCommand && std::holds_alternative<TIntermediate::TRangeRead>(*intermediate->ReadCommand)) { 
-        auto &request = std::get<TIntermediate::TRangeRead>(*intermediate->ReadCommand); 
-        auto *response = intermediate->Response.AddReadRangeResult(); 
-        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0); 
-    } 
-} 
- 
-void TKeyValueState::CmdRename(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) { 
-    ui64 unixTime = TAppData::TimeProvider->Now().Seconds(); 
-    for (ui32 i = 0; i < intermediate->Renames.size(); ++i) { 
-        auto& request = intermediate->Renames[i]; 
-        auto *response = intermediate->Response.AddRenameResult(); 
-        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, unixTime); 
-    } 
-} 
- 
 void TKeyValueState::CmdDelete(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) {
     for (ui32 i = 0; i < intermediate->Deletes.size(); ++i) {
         auto& request = intermediate->Deletes[i];
-        auto *response = intermediate->Response.AddDeleteRangeResult(); 
-        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0); 
+        auto *response = intermediate->Response.AddDeleteRangeResult();
+        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0);
     }
 }
 
@@ -1230,8 +1230,8 @@ void TKeyValueState::CmdWrite(THolder<TIntermediate> &intermediate, ISimpleDb &d
     ui64 unixTime = TAppData::TimeProvider->Now().Seconds();
     for (ui32 i = 0; i < intermediate->Writes.size(); ++i) {
         auto& request = intermediate->Writes[i];
-        auto *response = intermediate->Response.AddWriteResult(); 
-        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, unixTime); 
+        auto *response = intermediate->Response.AddWriteResult();
+        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, unixTime);
     }
     ResourceMetrics->TryUpdate(ctx);
 }
@@ -1241,47 +1241,47 @@ void TKeyValueState::CmdGetStatus(THolder<TIntermediate> &intermediate, ISimpleD
     Y_UNUSED(ctx);
     for (ui32 i = 0; i < intermediate->GetStatuses.size(); ++i) {
         auto& request = intermediate->GetStatuses[i];
-        if (intermediate->EvType == TEvKeyValue::TEvRequest::EventType) { 
-            auto& response = *intermediate->Response.AddGetStatusResult(); 
-
-            response.SetStatus(request.Status); 
-            response.SetStorageChannel(request.StorageChannel); 
-            response.SetStatusFlags(request.StatusFlags.Raw); 
-        } else if ((intermediate->EvType == TEvKeyValue::TEvGetStatus::EventType)) { 
-            auto response = intermediate->GetStatusResponse.add_channel(); 
- 
-            if (request.Status == NKikimrProto::OK) { 
-                response->set_status(NKikimrKeyValue::Statuses::RSTATUS_OK); 
-            } else if (request.Status == NKikimrProto::TIMEOUT) { 
-                response->set_status(NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT); 
-            } else { 
-                response->set_status(NKikimrKeyValue::Statuses::RSTATUS_ERROR); 
-            } 
- 
-            if (request.StorageChannel == NKikimrClient::TKeyValueRequest::INLINE) { 
-                response->set_storage_channel(1); 
-            } else { 
-                response->set_storage_channel(request.StorageChannel - BLOB_CHANNEL + MainStorageChannelInPublicApi); 
-            } 
- 
-            SetStatusFlags(response->mutable_status_flags(), request.StatusFlags); 
-        } 
-    }
-    intermediate->GetStatusResponse.set_status(NKikimrKeyValue::Statuses::RSTATUS_OK); 
+        if (intermediate->EvType == TEvKeyValue::TEvRequest::EventType) {
+            auto& response = *intermediate->Response.AddGetStatusResult();
+
+            response.SetStatus(request.Status);
+            response.SetStorageChannel(request.StorageChannel);
+            response.SetStatusFlags(request.StatusFlags.Raw);
+        } else if ((intermediate->EvType == TEvKeyValue::TEvGetStatus::EventType)) {
+            auto response = intermediate->GetStatusResponse.add_channel();
+
+            if (request.Status == NKikimrProto::OK) {
+                response->set_status(NKikimrKeyValue::Statuses::RSTATUS_OK);
+            } else if (request.Status == NKikimrProto::TIMEOUT) {
+                response->set_status(NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT);
+            } else {
+                response->set_status(NKikimrKeyValue::Statuses::RSTATUS_ERROR);
+            }
+
+            if (request.StorageChannel == NKikimrClient::TKeyValueRequest::INLINE) {
+                response->set_storage_channel(1);
+            } else {
+                response->set_storage_channel(request.StorageChannel - BLOB_CHANNEL + MainStorageChannelInPublicApi);
+            }
+
+            SetStatusFlags(response->mutable_status_flags(), request.StatusFlags);
+        }
+    }
+    intermediate->GetStatusResponse.set_status(NKikimrKeyValue::Statuses::RSTATUS_OK);
 }
 
 void TKeyValueState::CmdCopyRange(THolder<TIntermediate>& intermediate, ISimpleDb& db, const TActorContext& ctx) {
     for (const auto& request : intermediate->CopyRanges) {
-        auto *response = intermediate->Response.AddCopyRangeResult(); 
-        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0); 
+        auto *response = intermediate->Response.AddCopyRangeResult();
+        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, 0);
     }
 }
 
 void TKeyValueState::CmdConcat(THolder<TIntermediate>& intermediate, ISimpleDb& db, const TActorContext& ctx) {
     ui64 unixTime = TAppData::TimeProvider->Now().Seconds();
     for (const auto& request : intermediate->Concats) {
-        auto *response = intermediate->Response.AddConcatResult(); 
-        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, unixTime); 
+        auto *response = intermediate->Response.AddConcatResult();
+        ProcessCmd(request, response, nullptr, db, ctx, intermediate->Stat, unixTime);
     }
 }
 
@@ -1320,220 +1320,220 @@ void TKeyValueState::CmdSetExecutorFastLogPolicy(THolder<TIntermediate> &interme
     }
 }
 
-void TKeyValueState::CmdCmds(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) { 
-    ui64 unixTime = TAppData::TimeProvider->Now().Seconds(); 
-    bool wasWrite = false; 
-    auto getChannel = [&](auto &cmd) -> NKikimrKeyValue::Channel* { 
-        using Type = std::decay_t<decltype(cmd)>; 
-        if constexpr (std::is_same_v<Type, TIntermediate::TWrite>) { 
-            if (intermediate->EvType != TEvKeyValue::TEvExecuteTransaction::EventType) { 
-                return nullptr; 
-            } 
-            ui32 storageChannel = MainStorageChannelInPublicApi; 
-            if (cmd.Status == NKikimrProto::SCHEDULED) { 
-                storageChannel = InlineStorageChannelInPublicApi; 
-            } 
-            if (cmd.LogoBlobIds.size()) { 
-                storageChannel = cmd.LogoBlobIds.front().Channel() - BLOB_CHANNEL + MainStorageChannelInPublicApi; 
-            } 
-            auto it = intermediate->Channels.find(storageChannel); 
-            if (it == intermediate->Channels.end()) { 
-                auto channel = intermediate->ExecuteTransactionResponse.add_channel(); 
-                intermediate->Channels.emplace(storageChannel, channel); 
-                return channel; 
-            } 
-            return it->second; 
-        } 
-        return nullptr; 
-    }; 
-    auto getLegacyResponse = [&](auto &cmd) { 
-        using Type = std::decay_t<decltype(cmd)>; 
-        if constexpr (std::is_same_v<Type, TIntermediate::TWrite>) { 
-            wasWrite = true; 
-            return intermediate->Response.AddWriteResult(); 
-        }
-        if constexpr (std::is_same_v<Type, TIntermediate::TDelete>) { 
-            return intermediate->Response.AddDeleteRangeResult(); 
-        } 
-        if constexpr (std::is_same_v<Type, TIntermediate::TRename>) { 
-            return intermediate->Response.AddRenameResult(); 
-        } 
-        if constexpr (std::is_same_v<Type, TIntermediate::TCopyRange>) { 
-            return intermediate->Response.AddCopyRangeResult(); 
-        } 
-        if constexpr (std::is_same_v<Type, TIntermediate::TConcat>) { 
-            return intermediate->Response.AddConcatResult(); 
-        } 
-    }; 
-    auto process = [&](auto &cmd) { 
-        ProcessCmd(cmd, getLegacyResponse(cmd), getChannel(cmd), db, ctx, intermediate->Stat, unixTime); 
-    }; 
-    for (auto &cmd : intermediate->Commands) { 
-        std::visit(process, cmd); 
-    }
-    if (wasWrite) { 
-        ResourceMetrics->TryUpdate(ctx); 
-    } 
-} 
- 
-TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TCopyRange &cmd, TKeySet& keys, 
-        ui32 /*index*/) const 
-{ 
-    TVector<TString> nkeys; 
-    auto range = GetRange(cmd.Range, keys); 
-    for (auto it = range.first; it != range.second; ++it) { 
-        if (it->StartsWith(cmd.PrefixToRemove)) { 
-            nkeys.push_back(cmd.PrefixToAdd + it->substr(cmd.PrefixToRemove.size())); 
-        } 
-    } 
-    keys.insert(nkeys.begin(), nkeys.end()); 
-    return {}; 
-} 
- 
-TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TRename &cmd, TKeySet& keys, 
-        ui32 index) const 
-{ 
-    auto it = keys.find(cmd.OldKey); 
-    if (it == keys.end()) { 
-        TStringStream str; 
-        str << "KeyValue# " << TabletId 
-            << " OldKey# " << EscapeC(cmd.OldKey) << " does not exist in CmdRename(" << index << ")" 
-            << " Marker# KV18"; 
-        return {false, str.Str()}; 
-    } 
-    keys.erase(it); 
-    keys.insert(cmd.NewKey); 
-    return {}; 
-} 
- 
-TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TConcat &cmd, TKeySet& keys, 
-        ui32 index) const 
-{ 
-    for (const TString& key : cmd.InputKeys) { 
-        auto it = keys.find(key); 
-        if (it == keys.end()) { 
-            TStringStream str; 
-            str << "KeyValue# " << TabletId 
-                << " InputKey# " << EscapeC(key) << " does not exist in CmdConcat(" << index << ")" 
-                << " Marker# KV19"; 
-            return {false, str.Str()}; 
-        } 
-        if (!cmd.KeepInputs) { 
-            keys.erase(it); 
-        } 
-    } 
- 
-    keys.insert(cmd.OutputKey); 
-    return {}; 
-} 
- 
-TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TDelete &cmd, TKeySet& keys, 
-        ui32 /*index*/) const 
-{ 
-    auto r = GetRange(cmd.Range, keys); 
-    keys.erase(r.first, r.second); 
-    return {}; 
-} 
- 
-TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TWrite &cmd, TKeySet& keys, 
-        ui32 /*index*/) const 
-{ 
-    keys.insert(cmd.Key); 
-    return {}; 
-} 
- 
-bool TKeyValueState::CheckCmdCopyRanges(THolder<TIntermediate>& intermediate, const TActorContext& /*ctx*/, 
-        TKeySet& keys, const TTabletStorageInfo* /*info*/) 
-{ 
-    for (const auto& cmd : intermediate->CopyRanges) { 
-        CheckCmd(cmd, keys, 0); 
-    } 
+void TKeyValueState::CmdCmds(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx) {
+    ui64 unixTime = TAppData::TimeProvider->Now().Seconds();
+    bool wasWrite = false;
+    auto getChannel = [&](auto &cmd) -> NKikimrKeyValue::Channel* {
+        using Type = std::decay_t<decltype(cmd)>;
+        if constexpr (std::is_same_v<Type, TIntermediate::TWrite>) {
+            if (intermediate->EvType != TEvKeyValue::TEvExecuteTransaction::EventType) {
+                return nullptr;
+            }
+            ui32 storageChannel = MainStorageChannelInPublicApi;
+            if (cmd.Status == NKikimrProto::SCHEDULED) {
+                storageChannel = InlineStorageChannelInPublicApi;
+            }
+            if (cmd.LogoBlobIds.size()) {
+                storageChannel = cmd.LogoBlobIds.front().Channel() - BLOB_CHANNEL + MainStorageChannelInPublicApi;
+            }
+            auto it = intermediate->Channels.find(storageChannel);
+            if (it == intermediate->Channels.end()) {
+                auto channel = intermediate->ExecuteTransactionResponse.add_channel();
+                intermediate->Channels.emplace(storageChannel, channel);
+                return channel;
+            }
+            return it->second;
+        }
+        return nullptr;
+    };
+    auto getLegacyResponse = [&](auto &cmd) {
+        using Type = std::decay_t<decltype(cmd)>;
+        if constexpr (std::is_same_v<Type, TIntermediate::TWrite>) {
+            wasWrite = true;
+            return intermediate->Response.AddWriteResult();
+        }
+        if constexpr (std::is_same_v<Type, TIntermediate::TDelete>) {
+            return intermediate->Response.AddDeleteRangeResult();
+        }
+        if constexpr (std::is_same_v<Type, TIntermediate::TRename>) {
+            return intermediate->Response.AddRenameResult();
+        }
+        if constexpr (std::is_same_v<Type, TIntermediate::TCopyRange>) {
+            return intermediate->Response.AddCopyRangeResult();
+        }
+        if constexpr (std::is_same_v<Type, TIntermediate::TConcat>) {
+            return intermediate->Response.AddConcatResult();
+        }
+    };
+    auto process = [&](auto &cmd) {
+        ProcessCmd(cmd, getLegacyResponse(cmd), getChannel(cmd), db, ctx, intermediate->Stat, unixTime);
+    };
+    for (auto &cmd : intermediate->Commands) {
+        std::visit(process, cmd);
+    }
+    if (wasWrite) {
+        ResourceMetrics->TryUpdate(ctx);
+    }
+}
+
+TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TCopyRange &cmd, TKeySet& keys,
+        ui32 /*index*/) const
+{
+    TVector<TString> nkeys;
+    auto range = GetRange(cmd.Range, keys);
+    for (auto it = range.first; it != range.second; ++it) {
+        if (it->StartsWith(cmd.PrefixToRemove)) {
+            nkeys.push_back(cmd.PrefixToAdd + it->substr(cmd.PrefixToRemove.size()));
+        }
+    }
+    keys.insert(nkeys.begin(), nkeys.end());
+    return {};
+}
+
+TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TRename &cmd, TKeySet& keys,
+        ui32 index) const
+{
+    auto it = keys.find(cmd.OldKey);
+    if (it == keys.end()) {
+        TStringStream str;
+        str << "KeyValue# " << TabletId
+            << " OldKey# " << EscapeC(cmd.OldKey) << " does not exist in CmdRename(" << index << ")"
+            << " Marker# KV18";
+        return {false, str.Str()};
+    }
+    keys.erase(it);
+    keys.insert(cmd.NewKey);
+    return {};
+}
+
+TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TConcat &cmd, TKeySet& keys,
+        ui32 index) const
+{
+    for (const TString& key : cmd.InputKeys) {
+        auto it = keys.find(key);
+        if (it == keys.end()) {
+            TStringStream str;
+            str << "KeyValue# " << TabletId
+                << " InputKey# " << EscapeC(key) << " does not exist in CmdConcat(" << index << ")"
+                << " Marker# KV19";
+            return {false, str.Str()};
+        }
+        if (!cmd.KeepInputs) {
+            keys.erase(it);
+        }
+    }
+
+    keys.insert(cmd.OutputKey);
+    return {};
+}
+
+TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TDelete &cmd, TKeySet& keys,
+        ui32 /*index*/) const
+{
+    auto r = GetRange(cmd.Range, keys);
+    keys.erase(r.first, r.second);
+    return {};
+}
+
+TKeyValueState::TCheckResult TKeyValueState::CheckCmd(const TIntermediate::TWrite &cmd, TKeySet& keys,
+        ui32 /*index*/) const
+{
+    keys.insert(cmd.Key);
+    return {};
+}
+
+bool TKeyValueState::CheckCmdCopyRanges(THolder<TIntermediate>& intermediate, const TActorContext& /*ctx*/,
+        TKeySet& keys, const TTabletStorageInfo* /*info*/)
+{
+    for (const auto& cmd : intermediate->CopyRanges) {
+        CheckCmd(cmd, keys, 0);
+    }
     return true;
 }
 
-bool TKeyValueState::CheckCmdRenames(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys, 
-        const TTabletStorageInfo *info) 
-{ 
+bool TKeyValueState::CheckCmdRenames(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys,
+        const TTabletStorageInfo *info)
+{
     ui32 index = 0;
     for (const auto& cmd : intermediate->Renames) {
-        const auto &[ok, msg] = CheckCmd(cmd, keys, index++); 
-        if (!ok) { 
-            ReplyError(ctx, msg, NMsgBusProxy::MSTATUS_ERROR, intermediate, info); 
+        const auto &[ok, msg] = CheckCmd(cmd, keys, index++);
+        if (!ok) {
+            ReplyError(ctx, msg, NMsgBusProxy::MSTATUS_ERROR, intermediate, info);
             return false;
         }
     }
     return true;
 }
 
-bool TKeyValueState::CheckCmdConcats(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys, 
-        const TTabletStorageInfo *info) 
-{ 
+bool TKeyValueState::CheckCmdConcats(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys,
+        const TTabletStorageInfo *info)
+{
     ui32 index = 0;
     for (const auto& cmd : intermediate->Concats) {
-        const auto &[ok, msg] = CheckCmd(cmd, keys, index++); 
-        if (!ok) { 
-            ReplyError(ctx, msg, NMsgBusProxy::MSTATUS_ERROR, intermediate, info); 
-            return false; 
+        const auto &[ok, msg] = CheckCmd(cmd, keys, index++);
+        if (!ok) {
+            ReplyError(ctx, msg, NMsgBusProxy::MSTATUS_ERROR, intermediate, info);
+            return false;
         }
     }
 
     return true;
 }
 
-bool TKeyValueState::CheckCmdDeletes(THolder<TIntermediate>& intermediate, const TActorContext& /*ctx*/, TKeySet& keys, 
-        const TTabletStorageInfo* /*info*/) 
-{ 
+bool TKeyValueState::CheckCmdDeletes(THolder<TIntermediate>& intermediate, const TActorContext& /*ctx*/, TKeySet& keys,
+        const TTabletStorageInfo* /*info*/)
+{
     for (const auto& cmd : intermediate->Deletes) {
-        CheckCmd(cmd, keys, 0); 
+        CheckCmd(cmd, keys, 0);
     }
     return true;
 }
 
-bool TKeyValueState::CheckCmdWrites(THolder<TIntermediate>& intermediate, const TActorContext& /*ctx*/, TKeySet& keys, 
-        const TTabletStorageInfo* /*info*/) 
-{ 
+bool TKeyValueState::CheckCmdWrites(THolder<TIntermediate>& intermediate, const TActorContext& /*ctx*/, TKeySet& keys,
+        const TTabletStorageInfo* /*info*/)
+{
     for (const auto& cmd : intermediate->Writes) {
-        CheckCmd(cmd, keys, 0); 
+        CheckCmd(cmd, keys, 0);
     }
     return true;
 }
 
 bool TKeyValueState::CheckCmdGetStatus(THolder<TIntermediate>& /*intermediate*/, const TActorContext& /*ctx*/,
-        TKeySet& /*keys*/, const TTabletStorageInfo* /*info*/) 
-{ 
+        TKeySet& /*keys*/, const TTabletStorageInfo* /*info*/)
+{
+    return true;
+}
+
+bool TKeyValueState::CheckCmds(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys,
+        const TTabletStorageInfo* info)
+{
+    ui32 renameIndex = 0;
+    ui32 concatIndex = 0;
+
+    auto nextIdx = [&](auto &cmd) -> ui32 {
+        using Type = std::decay_t<decltype(cmd)>;
+        if constexpr (std::is_same_v<Type, TIntermediate::TRename>) {
+            return renameIndex++;
+        }
+        if constexpr (std::is_same_v<Type, TIntermediate::TConcat>) {
+            return concatIndex++;
+        }
+        return 0;
+    };
+    auto visitor = [&](auto &cmd) {
+        return CheckCmd(cmd, keys, nextIdx(cmd));
+    };
+
+    for (const auto& cmd : intermediate->Commands) {
+        const auto &[ok, msg] = std::visit(visitor, cmd);
+        if (!ok) {
+            ReplyError(ctx, msg, NMsgBusProxy::MSTATUS_ERROR, intermediate, info);
+            return false;
+        }
+    }
     return true;
 }
 
-bool TKeyValueState::CheckCmds(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys, 
-        const TTabletStorageInfo* info) 
-{ 
-    ui32 renameIndex = 0; 
-    ui32 concatIndex = 0; 
- 
-    auto nextIdx = [&](auto &cmd) -> ui32 { 
-        using Type = std::decay_t<decltype(cmd)>; 
-        if constexpr (std::is_same_v<Type, TIntermediate::TRename>) { 
-            return renameIndex++; 
-        } 
-        if constexpr (std::is_same_v<Type, TIntermediate::TConcat>) { 
-            return concatIndex++; 
-        } 
-        return 0; 
-    }; 
-    auto visitor = [&](auto &cmd) { 
-        return CheckCmd(cmd, keys, nextIdx(cmd)); 
-    }; 
- 
-    for (const auto& cmd : intermediate->Commands) { 
-        const auto &[ok, msg] = std::visit(visitor, cmd); 
-        if (!ok) { 
-            ReplyError(ctx, msg, NMsgBusProxy::MSTATUS_ERROR, intermediate, info); 
-            return false; 
-        } 
-    } 
-    return true; 
-} 
- 
 void TKeyValueState::ProcessCmds(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx,
         const TTabletStorageInfo *info) {
     LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " TTxRequest ProcessCmds");
@@ -1551,12 +1551,12 @@ void TKeyValueState::ProcessCmds(THolder<TIntermediate> &intermediate, ISimpleDb
         success = false;
     }
 
-    success = success && CheckCmdCopyRanges(intermediate, ctx, keys, info); 
-    success = success && CheckCmdRenames(intermediate, ctx, keys, info); 
-    success = success && CheckCmdConcats(intermediate, ctx, keys, info); 
-    success = success && CheckCmdDeletes(intermediate, ctx, keys, info); 
-    success = success && CheckCmdWrites(intermediate, ctx, keys, info); 
-    success = success && CheckCmds(intermediate, ctx, keys, info); 
+    success = success && CheckCmdCopyRanges(intermediate, ctx, keys, info);
+    success = success && CheckCmdRenames(intermediate, ctx, keys, info);
+    success = success && CheckCmdConcats(intermediate, ctx, keys, info);
+    success = success && CheckCmdDeletes(intermediate, ctx, keys, info);
+    success = success && CheckCmdWrites(intermediate, ctx, keys, info);
+    success = success && CheckCmds(intermediate, ctx, keys, info);
     success = success && CheckCmdGetStatus(intermediate, ctx, keys, info);
     if (!success) {
         for (const auto& cmd : intermediate->Writes) {
@@ -1564,15 +1564,15 @@ void TKeyValueState::ProcessCmds(THolder<TIntermediate> &intermediate, ISimpleDb
                 Dereference(logoBlobId, db, ctx, true);
             }
         }
-        for (const auto& cmd : intermediate->Commands) { 
-            if (!std::holds_alternative<TIntermediate::TWrite>(cmd)) { 
-                continue; 
-            } 
-            auto& write = std::get<TIntermediate::TWrite>(cmd); 
-            for (const TLogoBlobID& logoBlobId : write.LogoBlobIds) { 
-                Dereference(logoBlobId, db, ctx, true); 
-            } 
-        } 
+        for (const auto& cmd : intermediate->Commands) {
+            if (!std::holds_alternative<TIntermediate::TWrite>(cmd)) {
+                continue;
+            }
+            auto& write = std::get<TIntermediate::TWrite>(cmd);
+            for (const TLogoBlobID& logoBlobId : write.LogoBlobIds) {
+                Dereference(logoBlobId, db, ctx, true);
+            }
+        }
     } else {
         // Read + validate
         CmdRead(intermediate, db, ctx);
@@ -1585,7 +1585,7 @@ void TKeyValueState::ProcessCmds(THolder<TIntermediate> &intermediate, ISimpleDb
         CmdDelete(intermediate, db, ctx);
         CmdWrite(intermediate, db, ctx);
         CmdGetStatus(intermediate, db, ctx);
-        CmdCmds(intermediate, db, ctx); 
+        CmdCmds(intermediate, db, ctx);
 
         // Blob trimming
         CmdTrimLeakedBlobs(intermediate, db, ctx);
@@ -1688,16 +1688,16 @@ void TKeyValueState::OnRequestComplete(ui64 requestUid, ui64 generation, ui64 st
     CountRequestComplete(status, stat, ctx);
     ResourceMetrics->TryUpdate(ctx);
 
-    if (Queue.size() && IntermediatesInFlight < IntermediatesInFlightLimit) { 
-        TRequestType::EType requestType = Queue.front()->Stat.RequestType; 
+    if (Queue.size() && IntermediatesInFlight < IntermediatesInFlightLimit) {
+        TRequestType::EType requestType = Queue.front()->Stat.RequestType;
 
-        CountLatencyQueue(Queue.front()->Stat); 
+        CountLatencyQueue(Queue.front()->Stat);
 
-        ProcessPostponedIntermediate(ctx, std::move(Queue.front()), info); 
-        Queue.pop_front(); 
-        ++IntermediatesInFlight; 
+        ProcessPostponedIntermediate(ctx, std::move(Queue.front()), info);
+        Queue.pop_front();
+        ++IntermediatesInFlight;
 
-        CountRequestTakeOffOrEnqueue(requestType); 
+        CountRequestTakeOffOrEnqueue(requestType);
     }
 
     if (StoredState.GetChannelGeneration() == generation) {
@@ -1752,209 +1752,209 @@ bool TKeyValueState::CheckGeneration(const TActorContext &ctx, NKikimrClient::TK
     return false;
 }
 
- 
-template <typename TypeWithPriority> 
-void SetPriority(NKikimrBlobStorage::EGetHandleClass *outHandleClass, ui8 priority) { 
-    *outHandleClass = NKikimrBlobStorage::FastRead; 
-    if constexpr (std::is_same_v<TypeWithPriority, NKikimrKeyValue::Priorities>) { 
-        switch (priority) { 
-            case TypeWithPriority::PRIORITY_UNSPECIFIED: 
-            case TypeWithPriority::PRIORITY_REALTIME: 
-                *outHandleClass = NKikimrBlobStorage::FastRead; 
-                break; 
-            case TypeWithPriority::PRIORITY_BACKGROUND: 
-                *outHandleClass = NKikimrBlobStorage::AsyncRead; 
-                break; 
-        } 
-    } else { 
-        switch (priority) { 
-            case TypeWithPriority::REALTIME: 
-                *outHandleClass = NKikimrBlobStorage::FastRead; 
-                break; 
-            case TypeWithPriority::BACKGROUND: 
-                *outHandleClass = NKikimrBlobStorage::AsyncRead; 
-                break; 
-        } 
-    } 
-} 
- 
-template <typename TypeWithPriority, bool WithOverrun = false, ui64 SpecificReadResultSizeEstimation=ReadResultSizeEstimation> 
-bool PrepareOneRead(const TString &key, TIndexRecord &indexRecord, ui64 offset, ui64 size, ui8 priority, 
-        ui64 cmdLimitBytes, THolder<TIntermediate> &intermediate, TIntermediate::TRead &response, bool &outIsInlineOnly) 
-{ 
-    for (ui64 idx = 0; idx < indexRecord.Chain.size(); ++idx) { 
-        if (!indexRecord.Chain[idx].IsInline()) { 
-            outIsInlineOnly = false; 
-            break; 
-        } 
-    } 
- 
-    if (!size) { 
-        size = std::numeric_limits<decltype(size)>::max(); 
-    } 
-    ui64 fullValueSize = indexRecord.GetFullValueSize(); 
-    offset = std::min(offset, fullValueSize); 
-    size = std::min(size, fullValueSize - offset); 
-    ui64 metaDataSize = key.size() + SpecificReadResultSizeEstimation; 
-    ui64 recSize = std::max(size, ErrorMessageSizeEstimation) + metaDataSize; 
- 
-    response.RequestedSize = size; 
-    bool isOverRun = false; 
- 
-    if (intermediate->IsTruncated 
-            || intermediate->TotalSize + recSize > intermediate->TotalSizeLimit 
-            || (cmdLimitBytes && intermediate->TotalSize + recSize > cmdLimitBytes)) { 
-        response.Status = NKikimrProto::OVERRUN; 
-        if (!WithOverrun 
-                || std::min(intermediate->TotalSizeLimit, cmdLimitBytes) < intermediate->TotalSize + metaDataSize) 
-        { 
-            return true; 
-        } 
-        if (cmdLimitBytes) { 
-            size = std::min(intermediate->TotalSizeLimit, cmdLimitBytes) - intermediate->TotalSize - metaDataSize; 
-        } else { 
-            size = intermediate->TotalSizeLimit - intermediate->TotalSize - metaDataSize; 
-        } 
-        isOverRun = true; 
-    } 
- 
-    response.ValueSize = size; 
-    response.CreationUnixTime = indexRecord.CreationUnixTime; 
-    response.Key = key; 
- 
-    SetPriority<TypeWithPriority>(&response.HandleClass, priority); 
- 
-    if (size) { 
-        const ui32 numReads = indexRecord.GetReadItems(offset, size, response); 
-        intermediate->TotalSize += recSize; 
-        intermediate->TotalReadsScheduled += numReads; 
-    } else if (response.Status != NKikimrProto::OVERRUN) { 
-        response.Status = NKikimrProto::OK; 
-    } 
-    return isOverRun; 
-} 
- 
-template <typename TypeWithPriority, ui64 SpecificKeyValuePairSizeEstimation> 
-bool PrepareOneReadFromRangeReadWithoutData(const TString &key, TIndexRecord &indexRecord, ui8 priority, 
-        THolder<TIntermediate> &intermediate, TIntermediate::TRangeRead &response, 
-        ui64 &cmdSizeBytes, ui64 cmdLimitBytes, bool *outIsInlineOnly) 
-{ 
-    if (intermediate->IsTruncated) { 
-        return false; 
-    } 
- 
-    NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel = 
-        NKikimrClient::TKeyValueRequest::MAIN; 
-    if (indexRecord.Chain.size()) { 
-        if (indexRecord.Chain[0].IsInline()) { 
-            storageChannel = NKikimrClient::TKeyValueRequest::INLINE; 
-        } else { 
-            *outIsInlineOnly = false; 
-            ui32 storageChannelIdx = indexRecord.Chain[0].LogoBlobId.Channel(); 
-            ui32 storageChannelOffset = storageChannelIdx - BLOB_CHANNEL; 
-            storageChannel = (NKikimrClient::TKeyValueRequest::EStorageChannel)storageChannelOffset; 
-        } 
-    } 
- 
-    ui64 metadataSize = key.size() + SpecificKeyValuePairSizeEstimation; 
-    if (intermediate->TotalSize + metadataSize > intermediate->TotalSizeLimit 
-            || cmdSizeBytes + metadataSize > cmdLimitBytes) { 
-        STLOG(NLog::PRI_TRACE, NKikimrServices::KEYVALUE, KV330, "Went beyond limits", 
-                (intermediate->TotalSize + metadataSize, intermediate->TotalSize + metadataSize), 
-                (intermediate->TotalSizeLimit, intermediate->TotalSizeLimit), 
-                (cmdSizeBytes + metadataSize, cmdSizeBytes + metadataSize), 
-                (cmdLimitBytes, cmdLimitBytes)); 
-        return true; 
-    } 
-    response.Reads.emplace_back(key, indexRecord.GetFullValueSize(), indexRecord.CreationUnixTime, 
-            storageChannel); 
-    intermediate->TotalSize += metadataSize; 
-    SetPriority<TypeWithPriority>(&response.HandleClass, priority); 
- 
-    cmdSizeBytes += metadataSize; 
-    return false; 
-} 
- 
-struct TSeqInfo { 
-    ui32 Reads = 0; 
-    ui32 RunLen = 0; 
-    ui32 Generation = 0; 
-    ui32 Step = 0; 
-    ui32 Cookie = 0; 
-}; 
- 
-template <typename TypeWithPriority, ui64 SpecificKeyValuePairSizeEstimation> 
-bool PrepareOneReadFromRangeReadWithData(const TString &key, TIndexRecord &indexRecord, ui8 priority, 
-        THolder<TIntermediate> &intermediate, TIntermediate::TRangeRead &response, 
-        ui64 &cmdSizeBytes, ui64 cmdLimitBytes, TSeqInfo &seq, bool *outIsInlineOnly) 
-{ 
-    if (intermediate->IsTruncated) { 
-        return false; 
-    } 
- 
-    NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel = 
-        NKikimrClient::TKeyValueRequest::MAIN; 
-    if (indexRecord.Chain.size()) { 
-        if (indexRecord.Chain[0].IsInline()) { 
-            storageChannel = NKikimrClient::TKeyValueRequest::INLINE; 
-        } else { 
-            *outIsInlineOnly = false; 
-            ui32 storageChannelIdx = indexRecord.Chain[0].LogoBlobId.Channel(); 
-            ui32 storageChannelOffset = storageChannelIdx - BLOB_CHANNEL; 
-            storageChannel = (NKikimrClient::TKeyValueRequest::EStorageChannel)storageChannelOffset; 
-        } 
-    } 
- 
-    bool isSeq = false; 
-    bool isInline = false; 
-    if (indexRecord.Chain.size() == 1) { 
-        if (indexRecord.Chain.front().IsInline()) { 
-            isSeq = true; 
-            isInline = true; 
-        } else { 
-            const TLogoBlobID& id = indexRecord.Chain.front().LogoBlobId; 
-            isSeq = id.Generation() == seq.Generation 
-                && id.Step() == seq.Step 
-                && id.Cookie() == seq.Cookie; 
-            seq.Generation = id.Generation(); 
-            seq.Step = id.Step(); 
-            seq.Cookie = id.Cookie() + 1; 
-        } 
-    } 
-    if (isSeq) { 
-        seq.Reads++; 
-        if (seq.Reads > intermediate->SequentialReadLimit && !isInline) { 
-            isSeq = false; 
-        } else { 
-            ++seq.RunLen; 
-        } 
-    } 
-    if (!isSeq) { 
-        seq.RunLen = 1; 
-    } 
- 
-    ui64 valueSize = indexRecord.GetFullValueSize(); 
-    ui64 metadataSize = key.size() + SpecificKeyValuePairSizeEstimation; 
-    if (intermediate->TotalSize + valueSize + metadataSize > intermediate->TotalSizeLimit 
-            || cmdSizeBytes + valueSize + metadataSize > cmdLimitBytes 
-            || (seq.RunLen == 1 && intermediate->TotalReadsScheduled >= intermediate->TotalReadsLimit)) { 
-        return true; 
-    } 
- 
-    TIntermediate::TRead read(key, valueSize, indexRecord.CreationUnixTime, storageChannel); 
-    const ui32 numReads = indexRecord.GetReadItems(0, valueSize, read); 
-    SetPriority<TypeWithPriority>(&response.HandleClass, priority); 
-    SetPriority<TypeWithPriority>(&read.HandleClass, priority); 
- 
-    response.Reads.push_back(std::move(read)); 
- 
-    intermediate->TotalSize += valueSize + metadataSize; 
-    intermediate->TotalReadsScheduled += numReads; 
- 
-    cmdSizeBytes += valueSize + metadataSize; 
-    return false; 
-} 
- 
+
+template <typename TypeWithPriority>
+void SetPriority(NKikimrBlobStorage::EGetHandleClass *outHandleClass, ui8 priority) {
+    *outHandleClass = NKikimrBlobStorage::FastRead;
+    if constexpr (std::is_same_v<TypeWithPriority, NKikimrKeyValue::Priorities>) {
+        switch (priority) {
+            case TypeWithPriority::PRIORITY_UNSPECIFIED:
+            case TypeWithPriority::PRIORITY_REALTIME:
+                *outHandleClass = NKikimrBlobStorage::FastRead;
+                break;
+            case TypeWithPriority::PRIORITY_BACKGROUND:
+                *outHandleClass = NKikimrBlobStorage::AsyncRead;
+                break;
+        }
+    } else {
+        switch (priority) {
+            case TypeWithPriority::REALTIME:
+                *outHandleClass = NKikimrBlobStorage::FastRead;
+                break;
+            case TypeWithPriority::BACKGROUND:
+                *outHandleClass = NKikimrBlobStorage::AsyncRead;
+                break;
+        }
+    }
+}
+
+template <typename TypeWithPriority, bool WithOverrun = false, ui64 SpecificReadResultSizeEstimation=ReadResultSizeEstimation>
+bool PrepareOneRead(const TString &key, TIndexRecord &indexRecord, ui64 offset, ui64 size, ui8 priority,
+        ui64 cmdLimitBytes, THolder<TIntermediate> &intermediate, TIntermediate::TRead &response, bool &outIsInlineOnly)
+{
+    for (ui64 idx = 0; idx < indexRecord.Chain.size(); ++idx) {
+        if (!indexRecord.Chain[idx].IsInline()) {
+            outIsInlineOnly = false;
+            break;
+        }
+    }
+
+    if (!size) {
+        size = std::numeric_limits<decltype(size)>::max();
+    }
+    ui64 fullValueSize = indexRecord.GetFullValueSize();
+    offset = std::min(offset, fullValueSize);
+    size = std::min(size, fullValueSize - offset);
+    ui64 metaDataSize = key.size() + SpecificReadResultSizeEstimation;
+    ui64 recSize = std::max(size, ErrorMessageSizeEstimation) + metaDataSize;
+
+    response.RequestedSize = size;
+    bool isOverRun = false;
+
+    if (intermediate->IsTruncated
+            || intermediate->TotalSize + recSize > intermediate->TotalSizeLimit
+            || (cmdLimitBytes && intermediate->TotalSize + recSize > cmdLimitBytes)) {
+        response.Status = NKikimrProto::OVERRUN;
+        if (!WithOverrun
+                || std::min(intermediate->TotalSizeLimit, cmdLimitBytes) < intermediate->TotalSize + metaDataSize)
+        {
+            return true;
+        }
+        if (cmdLimitBytes) {
+            size = std::min(intermediate->TotalSizeLimit, cmdLimitBytes) - intermediate->TotalSize - metaDataSize;
+        } else {
+            size = intermediate->TotalSizeLimit - intermediate->TotalSize - metaDataSize;
+        }
+        isOverRun = true;
+    }
+
+    response.ValueSize = size;
+    response.CreationUnixTime = indexRecord.CreationUnixTime;
+    response.Key = key;
+
+    SetPriority<TypeWithPriority>(&response.HandleClass, priority);
+
+    if (size) {
+        const ui32 numReads = indexRecord.GetReadItems(offset, size, response);
+        intermediate->TotalSize += recSize;
+        intermediate->TotalReadsScheduled += numReads;
+    } else if (response.Status != NKikimrProto::OVERRUN) {
+        response.Status = NKikimrProto::OK;
+    }
+    return isOverRun;
+}
+
+template <typename TypeWithPriority, ui64 SpecificKeyValuePairSizeEstimation>
+bool PrepareOneReadFromRangeReadWithoutData(const TString &key, TIndexRecord &indexRecord, ui8 priority,
+        THolder<TIntermediate> &intermediate, TIntermediate::TRangeRead &response,
+        ui64 &cmdSizeBytes, ui64 cmdLimitBytes, bool *outIsInlineOnly)
+{
+    if (intermediate->IsTruncated) {
+        return false;
+    }
+
+    NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel =
+        NKikimrClient::TKeyValueRequest::MAIN;
+    if (indexRecord.Chain.size()) {
+        if (indexRecord.Chain[0].IsInline()) {
+            storageChannel = NKikimrClient::TKeyValueRequest::INLINE;
+        } else {
+            *outIsInlineOnly = false;
+            ui32 storageChannelIdx = indexRecord.Chain[0].LogoBlobId.Channel();
+            ui32 storageChannelOffset = storageChannelIdx - BLOB_CHANNEL;
+            storageChannel = (NKikimrClient::TKeyValueRequest::EStorageChannel)storageChannelOffset;
+        }
+    }
+
+    ui64 metadataSize = key.size() + SpecificKeyValuePairSizeEstimation;
+    if (intermediate->TotalSize + metadataSize > intermediate->TotalSizeLimit
+            || cmdSizeBytes + metadataSize > cmdLimitBytes) {
+        STLOG(NLog::PRI_TRACE, NKikimrServices::KEYVALUE, KV330, "Went beyond limits",
+                (intermediate->TotalSize + metadataSize, intermediate->TotalSize + metadataSize),
+                (intermediate->TotalSizeLimit, intermediate->TotalSizeLimit),
+                (cmdSizeBytes + metadataSize, cmdSizeBytes + metadataSize),
+                (cmdLimitBytes, cmdLimitBytes));
+        return true;
+    }
+    response.Reads.emplace_back(key, indexRecord.GetFullValueSize(), indexRecord.CreationUnixTime,
+            storageChannel);
+    intermediate->TotalSize += metadataSize;
+    SetPriority<TypeWithPriority>(&response.HandleClass, priority);
+
+    cmdSizeBytes += metadataSize;
+    return false;
+}
+
+struct TSeqInfo {
+    ui32 Reads = 0;
+    ui32 RunLen = 0;
+    ui32 Generation = 0;
+    ui32 Step = 0;
+    ui32 Cookie = 0;
+};
+
+template <typename TypeWithPriority, ui64 SpecificKeyValuePairSizeEstimation>
+bool PrepareOneReadFromRangeReadWithData(const TString &key, TIndexRecord &indexRecord, ui8 priority,
+        THolder<TIntermediate> &intermediate, TIntermediate::TRangeRead &response,
+        ui64 &cmdSizeBytes, ui64 cmdLimitBytes, TSeqInfo &seq, bool *outIsInlineOnly)
+{
+    if (intermediate->IsTruncated) {
+        return false;
+    }
+
+    NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel =
+        NKikimrClient::TKeyValueRequest::MAIN;
+    if (indexRecord.Chain.size()) {
+        if (indexRecord.Chain[0].IsInline()) {
+            storageChannel = NKikimrClient::TKeyValueRequest::INLINE;
+        } else {
+            *outIsInlineOnly = false;
+            ui32 storageChannelIdx = indexRecord.Chain[0].LogoBlobId.Channel();
+            ui32 storageChannelOffset = storageChannelIdx - BLOB_CHANNEL;
+            storageChannel = (NKikimrClient::TKeyValueRequest::EStorageChannel)storageChannelOffset;
+        }
+    }
+
+    bool isSeq = false;
+    bool isInline = false;
+    if (indexRecord.Chain.size() == 1) {
+        if (indexRecord.Chain.front().IsInline()) {
+            isSeq = true;
+            isInline = true;
+        } else {
+            const TLogoBlobID& id = indexRecord.Chain.front().LogoBlobId;
+            isSeq = id.Generation() == seq.Generation
+                && id.Step() == seq.Step
+                && id.Cookie() == seq.Cookie;
+            seq.Generation = id.Generation();
+            seq.Step = id.Step();
+            seq.Cookie = id.Cookie() + 1;
+        }
+    }
+    if (isSeq) {
+        seq.Reads++;
+        if (seq.Reads > intermediate->SequentialReadLimit && !isInline) {
+            isSeq = false;
+        } else {
+            ++seq.RunLen;
+        }
+    }
+    if (!isSeq) {
+        seq.RunLen = 1;
+    }
+
+    ui64 valueSize = indexRecord.GetFullValueSize();
+    ui64 metadataSize = key.size() + SpecificKeyValuePairSizeEstimation;
+    if (intermediate->TotalSize + valueSize + metadataSize > intermediate->TotalSizeLimit
+            || cmdSizeBytes + valueSize + metadataSize > cmdLimitBytes
+            || (seq.RunLen == 1 && intermediate->TotalReadsScheduled >= intermediate->TotalReadsLimit)) {
+        return true;
+    }
+
+    TIntermediate::TRead read(key, valueSize, indexRecord.CreationUnixTime, storageChannel);
+    const ui32 numReads = indexRecord.GetReadItems(0, valueSize, read);
+    SetPriority<TypeWithPriority>(&response.HandleClass, priority);
+    SetPriority<TypeWithPriority>(&read.HandleClass, priority);
+
+    response.Reads.push_back(std::move(read));
+
+    intermediate->TotalSize += valueSize + metadataSize;
+    intermediate->TotalReadsScheduled += numReads;
+
+    cmdSizeBytes += valueSize + metadataSize;
+    return false;
+}
+
 bool TKeyValueState::PrepareCmdRead(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
         THolder<TIntermediate> &intermediate, bool &outIsInlineOnly) {
     outIsInlineOnly = true;
@@ -1971,21 +1971,21 @@ bool TKeyValueState::PrepareCmdRead(const TActorContext &ctx, NKikimrClient::TKe
             return true;
         }
 
-        ui64 offset = request.HasOffset() ? request.GetOffset() : 0; 
-        ui64 size = request.HasSize() ? request.GetSize() : 0; 
-        NKikimrClient::TKeyValueRequest::EPriority priority = NKikimrClient::TKeyValueRequest::REALTIME; 
-        if (request.HasPriority()) { 
-            priority = request.GetPriority(); 
-        } 
- 
+        ui64 offset = request.HasOffset() ? request.GetOffset() : 0;
+        ui64 size = request.HasSize() ? request.GetSize() : 0;
+        NKikimrClient::TKeyValueRequest::EPriority priority = NKikimrClient::TKeyValueRequest::REALTIME;
+        if (request.HasPriority()) {
+            priority = request.GetPriority();
+        }
+
         auto it = Index.find(request.GetKey());
         if (it == Index.end()) {
             response.Status = NKikimrProto::NODATA;
             response.Message = "No such key Marker# KV48";
         } else {
-            bool isOverrun = PrepareOneRead<NKikimrClient::TKeyValueRequest>(it->first, it->second, offset, size, 
-                    priority, 0, intermediate, response, outIsInlineOnly); 
-            if (isOverrun) { 
+            bool isOverrun = PrepareOneRead<NKikimrClient::TKeyValueRequest>(it->first, it->second, offset, size,
+                    priority, 0, intermediate, response, outIsInlineOnly);
+            if (isOverrun) {
                 if (!intermediate->IsTruncated) {
                     CountOverrun();
                     intermediate->IsTruncated = true;
@@ -1996,56 +1996,56 @@ bool TKeyValueState::PrepareCmdRead(const TActorContext &ctx, NKikimrClient::TKe
     return false;
 }
 
-template <typename TypeWithPriority, bool CheckUTF8 = false, 
-        ui64 MetaDataSizeWithData = KeyValuePairSizeEstimation, 
-        ui64 MetaDataSizeWithoutData = KeyValuePairSizeEstimation> 
-void ProcessOneCmdReadRange(TKeyValueState *self, const TKeyRange &range, ui64 cmdLimitBytes, bool includeData, 
-        ui8 priority, TIntermediate::TRangeRead &response, THolder<TIntermediate> &intermediate, bool *outIsInlineOnly) 
-{ 
-    ui64 cmdSizeBytes = 0; 
-    TSeqInfo seq; 
-    seq.RunLen = 1; 
- 
-    self->TraverseRange(range, [&](TKeyValueState::TIndex::iterator it) { 
-        if (intermediate->IsTruncated) { 
-            return; 
-        } 
- 
-        auto &[key, indexRecord] = *it; 
- 
-        if (CheckUTF8 && !IsUtf(key)) { 
-            TIntermediate::TRead read; 
-            read.CreationUnixTime = indexRecord.CreationUnixTime; 
-            EscapeC(key, read.Key); 
-            read.Status = NKikimrProto::ERROR; 
-            read.Message = "Key isn't UTF8"; 
-            response.Reads.push_back(std::move(read)); 
-            return; 
-        } 
- 
-        bool isOverRun = false; 
-        if (includeData) { 
-            isOverRun = PrepareOneReadFromRangeReadWithData<NKikimrClient::TKeyValueRequest, MetaDataSizeWithData>( 
-                    key, indexRecord, priority, intermediate, response, 
-                    cmdSizeBytes, cmdLimitBytes, seq, outIsInlineOnly); 
-        } else { 
-            isOverRun = PrepareOneReadFromRangeReadWithoutData<NKikimrClient::TKeyValueRequest, MetaDataSizeWithoutData>( 
-                    key, indexRecord, priority, intermediate, response, cmdSizeBytes, 
-                    cmdLimitBytes, outIsInlineOnly); 
-        } 
-        if (isOverRun) { 
-            self->CountOverrun(); 
-            intermediate->IsTruncated = true; 
-        } 
-    }); 
- 
-    if (intermediate->IsTruncated) { 
-        response.Status = NKikimrProto::OVERRUN; 
-    } else if (response.Reads.size() == 0) { 
-        response.Status = NKikimrProto::NODATA; 
-    } 
-} 
- 
+template <typename TypeWithPriority, bool CheckUTF8 = false,
+        ui64 MetaDataSizeWithData = KeyValuePairSizeEstimation,
+        ui64 MetaDataSizeWithoutData = KeyValuePairSizeEstimation>
+void ProcessOneCmdReadRange(TKeyValueState *self, const TKeyRange &range, ui64 cmdLimitBytes, bool includeData,
+        ui8 priority, TIntermediate::TRangeRead &response, THolder<TIntermediate> &intermediate, bool *outIsInlineOnly)
+{
+    ui64 cmdSizeBytes = 0;
+    TSeqInfo seq;
+    seq.RunLen = 1;
+
+    self->TraverseRange(range, [&](TKeyValueState::TIndex::iterator it) {
+        if (intermediate->IsTruncated) {
+            return;
+        }
+
+        auto &[key, indexRecord] = *it;
+
+        if (CheckUTF8 && !IsUtf(key)) {
+            TIntermediate::TRead read;
+            read.CreationUnixTime = indexRecord.CreationUnixTime;
+            EscapeC(key, read.Key);
+            read.Status = NKikimrProto::ERROR;
+            read.Message = "Key isn't UTF8";
+            response.Reads.push_back(std::move(read));
+            return;
+        }
+
+        bool isOverRun = false;
+        if (includeData) {
+            isOverRun = PrepareOneReadFromRangeReadWithData<NKikimrClient::TKeyValueRequest, MetaDataSizeWithData>(
+                    key, indexRecord, priority, intermediate, response,
+                    cmdSizeBytes, cmdLimitBytes, seq, outIsInlineOnly);
+        } else {
+            isOverRun = PrepareOneReadFromRangeReadWithoutData<NKikimrClient::TKeyValueRequest, MetaDataSizeWithoutData>(
+                    key, indexRecord, priority, intermediate, response, cmdSizeBytes,
+                    cmdLimitBytes, outIsInlineOnly);
+        }
+        if (isOverRun) {
+            self->CountOverrun();
+            intermediate->IsTruncated = true;
+        }
+    });
+
+    if (intermediate->IsTruncated) {
+        response.Status = NKikimrProto::OVERRUN;
+    } else if (response.Reads.size() == 0) {
+        response.Status = NKikimrProto::NODATA;
+    }
+}
+
 bool TKeyValueState::PrepareCmdReadRange(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
         THolder<TIntermediate> &intermediate, bool &inOutIsInlineOnly) {
     intermediate->RangeReads.resize(kvRequest.CmdReadRangeSize());
@@ -2068,12 +2068,12 @@ bool TKeyValueState::PrepareCmdReadRange(const TActorContext &ctx, NKikimrClient
 
         ui64 cmdLimitBytes = request.HasLimitBytes() ? request.GetLimitBytes() : Max<ui64>();
         bool includeData = request.HasIncludeData() && request.GetIncludeData();
-        ui8 priority = request.HasPriority() ? request.GetPriority() : Max<ui8>(); 
+        ui8 priority = request.HasPriority() ? request.GetPriority() : Max<ui8>();
         response.IncludeData = includeData;
-        response.LimitBytes = cmdLimitBytes; 
+        response.LimitBytes = cmdLimitBytes;
 
-        ProcessOneCmdReadRange<NKikimrClient::TKeyValueRequest>(this, range, cmdLimitBytes, includeData, priority, 
-                response, intermediate, &inOutIsInlineOnly); 
+        ProcessOneCmdReadRange<NKikimrClient::TKeyValueRequest>(this, range, cmdLimitBytes, includeData, priority,
+                response, intermediate, &inOutIsInlineOnly);
     }
     return false;
 }
@@ -2082,8 +2082,8 @@ bool TKeyValueState::PrepareCmdRename(const TActorContext &ctx, NKikimrClient::T
         THolder<TIntermediate> &intermediate) {
     for (ui32 i = 0; i < kvRequest.CmdRenameSize(); ++i) {
         auto& request = kvRequest.GetCmdRename(i);
-        intermediate->Commands.emplace_back(TIntermediate::TRename()); 
-        auto& interm = std::get<TIntermediate::TRename>(intermediate->Commands.back()); 
+        intermediate->Commands.emplace_back(TIntermediate::TRename());
+        auto& interm = std::get<TIntermediate::TRename>(intermediate->Commands.back());
 
         if (!request.HasOldKey()) {
             TStringStream str;
@@ -2111,8 +2111,8 @@ bool TKeyValueState::PrepareCmdDelete(const TActorContext &ctx, NKikimrClient::T
     ui64 nToDelete = 0;
     for (ui32 i = 0; i < kvRequest.CmdDeleteRangeSize(); ++i) {
         auto& request = kvRequest.GetCmdDeleteRange(i);
-        intermediate->Commands.emplace_back(TIntermediate::TDelete()); 
-        auto& interm = std::get<TIntermediate::TDelete>(intermediate->Commands.back()); 
+        intermediate->Commands.emplace_back(TIntermediate::TDelete());
+        auto& interm = std::get<TIntermediate::TDelete>(intermediate->Commands.back());
 
         if (!request.HasRange()) {
             TStringStream str;
@@ -2141,39 +2141,39 @@ bool TKeyValueState::PrepareCmdDelete(const TActorContext &ctx, NKikimrClient::T
     return false;
 }
 
-void TKeyValueState::SplitIntoBlobs(TIntermediate::TWrite &cmd, bool isInline, ui32 storageChannelIdx) { 
-    if (isInline) { 
-        cmd.Status = NKikimrProto::SCHEDULED; 
-        cmd.StatusFlags = TStorageStatusFlags(ui32(NKikimrBlobStorage::StatusIsValid)); 
-        if (GetIsTabletYellowMove()) { 
-            cmd.StatusFlags.Merge(ui32(NKikimrBlobStorage::StatusDiskSpaceLightYellowMove)); 
-        } 
-        if (GetIsTabletYellowStop()) { 
-            cmd.StatusFlags.Merge(ui32(NKikimrBlobStorage::StatusDiskSpaceYellowStop)); 
-        } 
-    } else { 
-        cmd.Status = NKikimrProto::UNKNOWN; 
-        ui64 sizeRemain = cmd.Data.size(); 
-        while (sizeRemain) { 
-            ui32 blobSize = Min<ui64>(sizeRemain, 8 << 20); 
-            cmd.LogoBlobIds.push_back(AllocateLogoBlobId(blobSize, storageChannelIdx)); 
-            sizeRemain -= blobSize; 
-        } 
-        for (const TLogoBlobID& logoBlobId : cmd.LogoBlobIds) { 
-            ui32 newRefCount = ++RefCounts[logoBlobId]; 
-            Y_VERIFY(newRefCount == 1); 
-        } 
-    } 
-} 
- 
+void TKeyValueState::SplitIntoBlobs(TIntermediate::TWrite &cmd, bool isInline, ui32 storageChannelIdx) {
+    if (isInline) {
+        cmd.Status = NKikimrProto::SCHEDULED;
+        cmd.StatusFlags = TStorageStatusFlags(ui32(NKikimrBlobStorage::StatusIsValid));
+        if (GetIsTabletYellowMove()) {
+            cmd.StatusFlags.Merge(ui32(NKikimrBlobStorage::StatusDiskSpaceLightYellowMove));
+        }
+        if (GetIsTabletYellowStop()) {
+            cmd.StatusFlags.Merge(ui32(NKikimrBlobStorage::StatusDiskSpaceYellowStop));
+        }
+    } else {
+        cmd.Status = NKikimrProto::UNKNOWN;
+        ui64 sizeRemain = cmd.Data.size();
+        while (sizeRemain) {
+            ui32 blobSize = Min<ui64>(sizeRemain, 8 << 20);
+            cmd.LogoBlobIds.push_back(AllocateLogoBlobId(blobSize, storageChannelIdx));
+            sizeRemain -= blobSize;
+        }
+        for (const TLogoBlobID& logoBlobId : cmd.LogoBlobIds) {
+            ui32 newRefCount = ++RefCounts[logoBlobId];
+            Y_VERIFY(newRefCount == 1);
+        }
+    }
+}
+
 bool TKeyValueState::PrepareCmdWrite(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
         THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info) {
-    intermediate->WriteIndices.reserve(kvRequest.CmdWriteSize()); 
+    intermediate->WriteIndices.reserve(kvRequest.CmdWriteSize());
     for (ui32 i = 0; i < kvRequest.CmdWriteSize(); ++i) {
         auto& request = kvRequest.GetCmdWrite(i);
-        intermediate->WriteIndices.push_back(intermediate->Commands.size()); 
-        auto& cmd = intermediate->Commands.emplace_back(TIntermediate::TWrite()); 
-        auto& interm = std::get<TIntermediate::TWrite>(cmd); 
+        intermediate->WriteIndices.push_back(intermediate->Commands.size());
+        auto& cmd = intermediate->Commands.emplace_back(TIntermediate::TWrite());
+        auto& interm = std::get<TIntermediate::TWrite>(cmd);
 
         if (!request.HasKey()) {
             TStringStream str;
@@ -2249,45 +2249,45 @@ bool TKeyValueState::PrepareCmdWrite(const TActorContext &ctx, NKikimrClient::TK
                     break;
             }
         }
-        SplitIntoBlobs(interm, isInline, storageChannelIdx); 
+        SplitIntoBlobs(interm, isInline, storageChannelIdx);
     }
     return false;
 }
 
- 
-TKeyValueState::TPrepareResult TKeyValueState::InitGetStatusCommand(TIntermediate::TGetStatus &cmd, 
-        NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel, const TTabletStorageInfo *info) 
-{ 
-    TString msg; 
-    if (storageChannel == NKikimrClient::TKeyValueRequest::INLINE) { 
-        cmd.StorageChannel = storageChannel; 
-        cmd.LogoBlobId = TLogoBlobID(); 
-        cmd.Status = NKikimrProto::OK; 
-        cmd.StatusFlags = TStorageStatusFlags(ui32(NKikimrBlobStorage::StatusIsValid)); 
-        if (GetIsTabletYellowMove()) { 
-            cmd.StatusFlags.Merge(ui32(NKikimrBlobStorage::StatusDiskSpaceLightYellowMove)); 
-        } 
-        if (GetIsTabletYellowStop()) { 
-            cmd.StatusFlags.Merge(ui32(NKikimrBlobStorage::StatusDiskSpaceYellowStop)); 
-        } 
-    } else { 
-        ui32 storageChannelOffset = (ui32)storageChannel; 
-        ui32 storageChannelIdx = storageChannelOffset + BLOB_CHANNEL; 
-        ui32 endChannel = info->Channels.size(); 
-        if (storageChannelIdx >= endChannel) { 
-            storageChannelIdx = BLOB_CHANNEL; 
-            msg = TStringBuilder() << "KeyValue# " << TabletId 
-                    << " CmdGetStatus StorageChannel# " << storageChannelOffset 
-                    << " does not exist, using MAIN"; 
-        } 
- 
-        cmd.StorageChannel = storageChannel; 
-        cmd.LogoBlobId = AllocateLogoBlobId(1, storageChannelIdx); 
-        cmd.Status = NKikimrProto::UNKNOWN; 
-    } 
-    return {false, msg}; 
-} 
- 
+
+TKeyValueState::TPrepareResult TKeyValueState::InitGetStatusCommand(TIntermediate::TGetStatus &cmd,
+        NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel, const TTabletStorageInfo *info)
+{
+    TString msg;
+    if (storageChannel == NKikimrClient::TKeyValueRequest::INLINE) {
+        cmd.StorageChannel = storageChannel;
+        cmd.LogoBlobId = TLogoBlobID();
+        cmd.Status = NKikimrProto::OK;
+        cmd.StatusFlags = TStorageStatusFlags(ui32(NKikimrBlobStorage::StatusIsValid));
+        if (GetIsTabletYellowMove()) {
+            cmd.StatusFlags.Merge(ui32(NKikimrBlobStorage::StatusDiskSpaceLightYellowMove));
+        }
+        if (GetIsTabletYellowStop()) {
+            cmd.StatusFlags.Merge(ui32(NKikimrBlobStorage::StatusDiskSpaceYellowStop));
+        }
+    } else {
+        ui32 storageChannelOffset = (ui32)storageChannel;
+        ui32 storageChannelIdx = storageChannelOffset + BLOB_CHANNEL;
+        ui32 endChannel = info->Channels.size();
+        if (storageChannelIdx >= endChannel) {
+            storageChannelIdx = BLOB_CHANNEL;
+            msg = TStringBuilder() << "KeyValue# " << TabletId
+                    << " CmdGetStatus StorageChannel# " << storageChannelOffset
+                    << " does not exist, using MAIN";
+        }
+
+        cmd.StorageChannel = storageChannel;
+        cmd.LogoBlobId = AllocateLogoBlobId(1, storageChannelIdx);
+        cmd.Status = NKikimrProto::UNKNOWN;
+    }
+    return {false, msg};
+}
+
 bool TKeyValueState::PrepareCmdGetStatus(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
         THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info) {
     intermediate->GetStatuses.resize(kvRequest.CmdGetStatusSize());
@@ -2301,9 +2301,9 @@ bool TKeyValueState::PrepareCmdGetStatus(const TActorContext &ctx, NKikimrClient
         if (request.HasStorageChannel()) {
             storageChannel = request.GetStorageChannel();
         }
-        TPrepareResult result = InitGetStatusCommand(interm, storageChannel, info); 
-        if (result.ErrorMsg && !result.WithError) { 
-            LOG_INFO_S(ctx, NKikimrServices::KEYVALUE, result.ErrorMsg  << " Marker# KV76"); 
+        TPrepareResult result = InitGetStatusCommand(interm, storageChannel, info);
+        if (result.ErrorMsg && !result.WithError) {
+            LOG_INFO_S(ctx, NKikimrServices::KEYVALUE, result.ErrorMsg  << " Marker# KV76");
         }
     }
     return false;
@@ -2314,8 +2314,8 @@ bool TKeyValueState::PrepareCmdCopyRange(const TActorContext& ctx, NKikimrClient
         THolder<TIntermediate>& intermediate) {
     for (ui32 i = 0; i < kvRequest.CmdCopyRangeSize(); ++i) {
         auto& request = kvRequest.GetCmdCopyRange(i);
-        intermediate->Commands.emplace_back(TIntermediate::TCopyRange()); 
-        auto& interm = std::get<TIntermediate::TCopyRange>(intermediate->Commands.back()); 
+        intermediate->Commands.emplace_back(TIntermediate::TCopyRange());
+        auto& interm = std::get<TIntermediate::TCopyRange>(intermediate->Commands.back());
 
         if ((!request.HasPrefixToAdd() || request.GetPrefixToAdd().empty()) &&
                 (!request.HasPrefixToRemove() || request.GetPrefixToRemove().empty())) {
@@ -2340,8 +2340,8 @@ bool TKeyValueState::PrepareCmdConcat(const TActorContext& ctx, NKikimrClient::T
         THolder<TIntermediate>& intermediate) {
     for (ui32 i = 0; i < kvRequest.CmdConcatSize(); ++i) {
         auto& request = kvRequest.GetCmdConcat(i);
-        intermediate->Commands.emplace_back(TIntermediate::TConcat()); 
-        auto& interm = std::get<TIntermediate::TConcat>(intermediate->Commands.back()); 
+        intermediate->Commands.emplace_back(TIntermediate::TConcat());
+        auto& interm = std::get<TIntermediate::TConcat>(intermediate->Commands.back());
 
         if (!request.HasOutputKey()) {
             TStringStream str;
@@ -2389,150 +2389,150 @@ bool TKeyValueState::PrepareCmdSetExecutorFastLogPolicy(const TActorContext & /*
     return false;
 }
 
-using TPrepareResult = TKeyValueState::TPrepareResult; 
- 
-TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::Rename &request, THolder<TIntermediate> &intermediate) { 
-    intermediate->Commands.emplace_back(TIntermediate::TRename()); 
-    auto &cmd = std::get<TIntermediate::TRename>(intermediate->Commands.back()); 
-    cmd.OldKey = request.old_key(); 
-    cmd.NewKey = request.new_key(); 
-    return {}; 
-} 
- 
-TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::Concat &request, THolder<TIntermediate> &intermediate) { 
-    intermediate->Commands.emplace_back(TIntermediate::TConcat()); 
-    auto &cmd = std::get<TIntermediate::TConcat>(intermediate->Commands.back()); 
-    auto inputKeys = request.input_keys(); 
-    cmd.InputKeys.insert(cmd.InputKeys.end(), inputKeys.begin(), inputKeys.end()); 
- 
-    cmd.OutputKey = request.output_key(); 
-    cmd.KeepInputs = request.keep_inputs(); 
-    return {}; 
-} 
- 
-TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::CopyRange &request, THolder<TIntermediate> &intermediate) { 
-    intermediate->Commands.emplace_back(TIntermediate::TCopyRange()); 
-    auto &cmd = std::get<TIntermediate::TCopyRange>(intermediate->Commands.back()); 
-    auto convResult = ConvertRange(request.range(), &cmd.Range, "CopyRange"); 
-    if (convResult.WithError) { 
-        return {true, convResult.ErrorMsg}; 
-    } 
-    cmd.PrefixToAdd = request.prefix_to_add(); 
-    cmd.PrefixToRemove = request.prefix_to_remove(); 
-    return {}; 
-} 
- 
-TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::Write &request, THolder<TIntermediate> &intermediate, 
-        const TTabletStorageInfo *info) 
-{ 
-    intermediate->Commands.emplace_back(TIntermediate::TWrite()); 
-    auto &cmd = std::get<TIntermediate::TWrite>(intermediate->Commands.back()); 
-    cmd.Key = request.key(); 
-    cmd.Data = request.value(); 
-    switch (request.tactic()) { 
-    case TCommand::Write::TACTIC_MIN_LATENCY: 
-        cmd.Tactic = TEvBlobStorage::TEvPut::TacticMinLatency; 
-        break; 
-    case TCommand::Write::TACTIC_MAX_THROUGHPUT: 
-        cmd.Tactic = TEvBlobStorage::TEvPut::TacticMaxThroughput; 
-        break; 
-    default: 
-        cmd.Tactic = TEvBlobStorage::TEvPut::TacticDefault; 
-        break; 
-    } 
- 
-    cmd.HandleClass = NKikimrBlobStorage::UserData; 
-    if (request.priority() == NKikimrKeyValue::Priorities::PRIORITY_BACKGROUND) { 
-        cmd.HandleClass = NKikimrBlobStorage::AsyncBlob; 
-    } 
- 
-    bool isInline = false; 
-    ui32 storageChannelIdx = BLOB_CHANNEL; 
-    ui32 storageChannel = request.storage_channel(); 
-    if (!storageChannel) { 
-        storageChannel = MainStorageChannelInPublicApi; 
-    } 
-    ui32 storageChannelOffset = storageChannel - MainStorageChannelInPublicApi; 
- 
-    if (storageChannel == InlineStorageChannelInPublicApi) { 
-        isInline = true; 
-    } else { 
-        storageChannelIdx = storageChannelOffset + BLOB_CHANNEL; 
-        ui32 endChannel = info->Channels.size(); 
-        if (storageChannelIdx >= endChannel) { 
-            storageChannelIdx = BLOB_CHANNEL; 
-        } 
-    } 
-    SplitIntoBlobs(cmd, isInline, storageChannelIdx); 
-    return {}; 
-} 
- 
-TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::DeleteRange &request, THolder<TIntermediate> &intermediate, 
-        const TActorContext &ctx) 
-{ 
-    intermediate->Commands.emplace_back(TIntermediate::TDelete()); 
-    auto &cmd = std::get<TIntermediate::TDelete>(intermediate->Commands.back()); 
-    auto convResult = ConvertRange(request.range(), &cmd.Range, "DeleteRange"); 
-    if (convResult.WithError) { 
-        return {true, convResult.ErrorMsg}; 
-    } 
-    ui32 nToDelete = 0; 
-    TraverseRange(cmd.Range, [&](TIndex::iterator it) { 
-        Y_UNUSED(it); 
-        nToDelete++; 
-    }); 
-    // The use of >, not >= is important here. 
-    if (nToDelete > DeletesPerRequestLimit && !AppData(ctx)->AllowHugeKeyValueDeletes) { 
-        TStringBuilder str; 
-        str << "KeyValue# " << TabletId; 
-        str << " Can't delete Range, in DeleteRange, total limit of deletions per request (" 
-            << DeletesPerRequestLimit << ") reached, Marker# KV90"; 
-        TString msg = str; 
-        ReplyError<TEvKeyValue::TEvExecuteTransactionResponse>(ctx, msg, 
-                NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR, intermediate, nullptr); 
-        return {true, msg}; 
-    } 
-    return {}; 
-} 
- 
-TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand &request, THolder<TIntermediate> &intermediate, 
-        const TTabletStorageInfo *info, const TActorContext &ctx) 
-{ 
-    switch (request.action_case()) { 
-    case NKikimrKeyValue::ExecuteTransactionRequest::Command::ACTION_NOT_SET: 
-        return {true, "Command not specified Marker# KV68"}; 
-    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kDeleteRange: 
-        return PrepareOneCmd(request.delete_range(), intermediate, ctx); 
-    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kRename: 
-        return PrepareOneCmd(request.rename(), intermediate); 
-    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kCopyRange: 
-        return PrepareOneCmd(request.copy_range(), intermediate); 
-    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kConcat: 
-        return PrepareOneCmd(request.concat(), intermediate); 
-    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kWrite: 
-        return PrepareOneCmd(request.write(), intermediate, info); 
-    } 
-} 
- 
-TPrepareResult TKeyValueState::PrepareCommands(NKikimrKeyValue::ExecuteTransactionRequest &kvRequest, 
-    THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info, const TActorContext &ctx) 
-{ 
-    for (i32 idx = 0; idx < kvRequest.commands_size(); ++idx) { 
-        auto &cmd = kvRequest.commands(idx); 
-        TPrepareResult result = PrepareOneCmd(cmd, intermediate, info, ctx); 
-        if (cmd.has_write()) { 
-            intermediate->WriteIndices.push_back(idx); 
-        } 
-        if (result.WithError) { 
-            return result; 
-        } 
-    } 
-    if (intermediate->EvType == TEvKeyValue::TEvExecuteTransaction::EventType) { 
-        intermediate->ExecuteTransactionResponse.set_status(NKikimrKeyValue::Statuses::RSTATUS_OK); 
-    } 
-    return {}; 
-} 
- 
+using TPrepareResult = TKeyValueState::TPrepareResult;
+
+TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::Rename &request, THolder<TIntermediate> &intermediate) {
+    intermediate->Commands.emplace_back(TIntermediate::TRename());
+    auto &cmd = std::get<TIntermediate::TRename>(intermediate->Commands.back());
+    cmd.OldKey = request.old_key();
+    cmd.NewKey = request.new_key();
+    return {};
+}
+
+TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::Concat &request, THolder<TIntermediate> &intermediate) {
+    intermediate->Commands.emplace_back(TIntermediate::TConcat());
+    auto &cmd = std::get<TIntermediate::TConcat>(intermediate->Commands.back());
+    auto inputKeys = request.input_keys();
+    cmd.InputKeys.insert(cmd.InputKeys.end(), inputKeys.begin(), inputKeys.end());
+
+    cmd.OutputKey = request.output_key();
+    cmd.KeepInputs = request.keep_inputs();
+    return {};
+}
+
+TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::CopyRange &request, THolder<TIntermediate> &intermediate) {
+    intermediate->Commands.emplace_back(TIntermediate::TCopyRange());
+    auto &cmd = std::get<TIntermediate::TCopyRange>(intermediate->Commands.back());
+    auto convResult = ConvertRange(request.range(), &cmd.Range, "CopyRange");
+    if (convResult.WithError) {
+        return {true, convResult.ErrorMsg};
+    }
+    cmd.PrefixToAdd = request.prefix_to_add();
+    cmd.PrefixToRemove = request.prefix_to_remove();
+    return {};
+}
+
+TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::Write &request, THolder<TIntermediate> &intermediate,
+        const TTabletStorageInfo *info)
+{
+    intermediate->Commands.emplace_back(TIntermediate::TWrite());
+    auto &cmd = std::get<TIntermediate::TWrite>(intermediate->Commands.back());
+    cmd.Key = request.key();
+    cmd.Data = request.value();
+    switch (request.tactic()) {
+    case TCommand::Write::TACTIC_MIN_LATENCY:
+        cmd.Tactic = TEvBlobStorage::TEvPut::TacticMinLatency;
+        break;
+    case TCommand::Write::TACTIC_MAX_THROUGHPUT:
+        cmd.Tactic = TEvBlobStorage::TEvPut::TacticMaxThroughput;
+        break;
+    default:
+        cmd.Tactic = TEvBlobStorage::TEvPut::TacticDefault;
+        break;
+    }
+
+    cmd.HandleClass = NKikimrBlobStorage::UserData;
+    if (request.priority() == NKikimrKeyValue::Priorities::PRIORITY_BACKGROUND) {
+        cmd.HandleClass = NKikimrBlobStorage::AsyncBlob;
+    }
+
+    bool isInline = false;
+    ui32 storageChannelIdx = BLOB_CHANNEL;
+    ui32 storageChannel = request.storage_channel();
+    if (!storageChannel) {
+        storageChannel = MainStorageChannelInPublicApi;
+    }
+    ui32 storageChannelOffset = storageChannel - MainStorageChannelInPublicApi;
+
+    if (storageChannel == InlineStorageChannelInPublicApi) {
+        isInline = true;
+    } else {
+        storageChannelIdx = storageChannelOffset + BLOB_CHANNEL;
+        ui32 endChannel = info->Channels.size();
+        if (storageChannelIdx >= endChannel) {
+            storageChannelIdx = BLOB_CHANNEL;
+        }
+    }
+    SplitIntoBlobs(cmd, isInline, storageChannelIdx);
+    return {};
+}
+
+TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand::DeleteRange &request, THolder<TIntermediate> &intermediate,
+        const TActorContext &ctx)
+{
+    intermediate->Commands.emplace_back(TIntermediate::TDelete());
+    auto &cmd = std::get<TIntermediate::TDelete>(intermediate->Commands.back());
+    auto convResult = ConvertRange(request.range(), &cmd.Range, "DeleteRange");
+    if (convResult.WithError) {
+        return {true, convResult.ErrorMsg};
+    }
+    ui32 nToDelete = 0;
+    TraverseRange(cmd.Range, [&](TIndex::iterator it) {
+        Y_UNUSED(it);
+        nToDelete++;
+    });
+    // The use of >, not >= is important here.
+    if (nToDelete > DeletesPerRequestLimit && !AppData(ctx)->AllowHugeKeyValueDeletes) {
+        TStringBuilder str;
+        str << "KeyValue# " << TabletId;
+        str << " Can't delete Range, in DeleteRange, total limit of deletions per request ("
+            << DeletesPerRequestLimit << ") reached, Marker# KV90";
+        TString msg = str;
+        ReplyError<TEvKeyValue::TEvExecuteTransactionResponse>(ctx, msg,
+                NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR, intermediate, nullptr);
+        return {true, msg};
+    }
+    return {};
+}
+
+TPrepareResult TKeyValueState::PrepareOneCmd(const TCommand &request, THolder<TIntermediate> &intermediate,
+        const TTabletStorageInfo *info, const TActorContext &ctx)
+{
+    switch (request.action_case()) {
+    case NKikimrKeyValue::ExecuteTransactionRequest::Command::ACTION_NOT_SET:
+        return {true, "Command not specified Marker# KV68"};
+    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kDeleteRange:
+        return PrepareOneCmd(request.delete_range(), intermediate, ctx);
+    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kRename:
+        return PrepareOneCmd(request.rename(), intermediate);
+    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kCopyRange:
+        return PrepareOneCmd(request.copy_range(), intermediate);
+    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kConcat:
+        return PrepareOneCmd(request.concat(), intermediate);
+    case NKikimrKeyValue::ExecuteTransactionRequest::Command::kWrite:
+        return PrepareOneCmd(request.write(), intermediate, info);
+    }
+}
+
+TPrepareResult TKeyValueState::PrepareCommands(NKikimrKeyValue::ExecuteTransactionRequest &kvRequest,
+    THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info, const TActorContext &ctx)
+{
+    for (i32 idx = 0; idx < kvRequest.commands_size(); ++idx) {
+        auto &cmd = kvRequest.commands(idx);
+        TPrepareResult result = PrepareOneCmd(cmd, intermediate, info, ctx);
+        if (cmd.has_write()) {
+            intermediate->WriteIndices.push_back(idx);
+        }
+        if (result.WithError) {
+            return result;
+        }
+    }
+    if (intermediate->EvType == TEvKeyValue::TEvExecuteTransaction::EventType) {
+        intermediate->ExecuteTransactionResponse.set_status(NKikimrKeyValue::Statuses::RSTATUS_OK);
+    }
+    return {};
+}
+
 void TKeyValueState::ReplyError(const TActorContext &ctx, TString errorDescription,
         NMsgBusProxy::EResponseStatus status, THolder<TIntermediate> &intermediate,
         const TTabletStorageInfo *info) {
@@ -2559,423 +2559,423 @@ void TKeyValueState::ReplyError(const TActorContext &ctx, TString errorDescripti
     }
 }
 
-bool TKeyValueState::PrepareReadRequest(const TActorContext &ctx, TEvKeyValue::TEvRead::TPtr &ev, 
-        THolder<TIntermediate> &intermediate, TRequestType::EType *outRequestType) 
-{ 
-    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " PrepareReadRequest Marker# KV53"); 
- 
-    NKikimrKeyValue::ReadRequest &request = ev->Get()->Record; 
-    StoredState.SetChannelGeneration(ExecutorGeneration); 
-    StoredState.SetChannelStep(NextLogoBlobStep - 1); 
- 
-    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID, 
-            StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), TRequestType::ReadOnly)); 
- 
-    intermediate->HasCookie = true; 
-    intermediate->Cookie = request.cookie(); 
- 
-    intermediate->RequestUid = NextRequestUid; 
-    ++NextRequestUid; 
-    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now(); 
-    intermediate->EvType = TEvKeyValue::TEvRead::EventType; 
- 
-    bool isInlineOnly = true; 
-    intermediate->ReadCommand = TIntermediate::TRead(); 
-    auto &response = std::get<TIntermediate::TRead>(*intermediate->ReadCommand); 
-    response.Key = request.key(); 
- 
-    if (CheckDeadline(ctx, ev->Get(), intermediate)) { 
-        return false; 
-    } 
- 
-    if (CheckGeneration(ctx, ev->Get(), intermediate)) { 
-        return false; 
-    } 
- 
-    auto it = Index.find(request.key()); 
-    if (it == Index.end()) { 
-        response.Status = NKikimrProto::NODATA; 
-        response.Message = "No such key Marker# KV55"; 
-        ReplyError<TEvKeyValue::TEvReadResponse>(ctx, response.Message, 
-                NKikimrKeyValue::Statuses::RSTATUS_NO_DATA, intermediate); 
-        return false; 
-    } 
-    bool isOverRun = PrepareOneRead<NKikimrKeyValue::Priorities, true, ReadResultSizeEstimationNewApi>( 
-            it->first, it->second, request.offset(), request.size(), request.priority(), request.limit_bytes(), 
-            intermediate, response, isInlineOnly); 
- 
-    if (isInlineOnly) { 
-        *outRequestType = TRequestType::ReadOnlyInline; 
-        intermediate->Stat.RequestType = *outRequestType; 
-    } 
-    intermediate->IsTruncated = isOverRun; 
-    return true; 
-} 
- 
-bool TKeyValueState::PrepareReadRangeRequest(const TActorContext &ctx, TEvKeyValue::TEvReadRange::TPtr &ev, 
-        THolder<TIntermediate> &intermediate, TRequestType::EType *outRequestType) 
-{ 
-    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " PrepareReadRangeRequest Marker# KV57"); 
- 
-    NKikimrKeyValue::ReadRangeRequest &request = ev->Get()->Record; 
-    StoredState.SetChannelGeneration(ExecutorGeneration); 
-    StoredState.SetChannelStep(NextLogoBlobStep - 1); 
- 
-    TRequestType::EType requestType = TRequestType::ReadOnly; 
-    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID, 
-        StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), requestType)); 
- 
-    intermediate->HasCookie = true; 
-    intermediate->Cookie = request.cookie(); 
- 
-    intermediate->RequestUid = NextRequestUid; 
-    ++NextRequestUid; 
-    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now(); 
-    intermediate->EvType = TEvKeyValue::TEvReadRange::EventType; 
-    intermediate->TotalSize = ReadRangeRequestMetaDataSizeEstimation; 
- 
-    intermediate->ReadCommand = TIntermediate::TRangeRead(); 
-    auto &response = std::get<TIntermediate::TRangeRead>(*intermediate->ReadCommand); 
- 
-    if (CheckDeadline(ctx, ev->Get(), intermediate)) { 
-        response.Status = NKikimrProto::ERROR; 
-        return false; 
-    } 
- 
-    if (CheckGeneration(ctx, ev->Get(), intermediate)) { 
-        response.Status = NKikimrProto::ERROR; 
-        return false; 
-    } 
- 
-    TKeyRange range; 
-    auto convResult = ConvertRange(request.range(), &range, "ReadRange"); 
-    if (convResult.WithError) { 
-        response.Status = NKikimrProto::ERROR; 
-        return false; 
-    } 
-    response.Status = NKikimrProto::OK; 
- 
-    ui64 cmdLimitBytes = request.limit_bytes(); 
-    if (!cmdLimitBytes) { 
-        cmdLimitBytes = Max<ui64>(); 
-    } 
-    bool includeData = request.include_data(); 
-    ui8 priority = request.priority(); 
-    response.LimitBytes = cmdLimitBytes; 
-    response.IncludeData = includeData; 
- 
-    bool isInlineOnly = true; 
-    auto processOneCmdReadRange = ProcessOneCmdReadRange<NKikimrKeyValue::Priorities, true, 
-            KeyValuePairSizeEstimationNewApi, KeyInfoSizeEstimation>; 
-    processOneCmdReadRange(this, range, cmdLimitBytes, includeData, priority, response, intermediate, &isInlineOnly); 
- 
-    if (isInlineOnly) { 
-        *outRequestType = TRequestType::ReadOnlyInline; 
-        intermediate->Stat.RequestType = *outRequestType; 
-    } 
-    return true; 
-} 
- 
- 
-bool TKeyValueState::PrepareExecuteTransactionRequest(const TActorContext &ctx, 
-        TEvKeyValue::TEvExecuteTransaction::TPtr &ev, THolder<TIntermediate> &intermediate, 
-        const TTabletStorageInfo *info) 
-{ 
-    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-            << " PrepareExecuteTransactionRequest Marker# KV72"); 
- 
-    NKikimrKeyValue::ExecuteTransactionRequest &request = ev->Get()->Record; 
-    StoredState.SetChannelGeneration(ExecutorGeneration); 
-    StoredState.SetChannelStep(NextLogoBlobStep - 1); 
- 
-    TRequestType::EType requestType = TRequestType::WriteOnly; 
-    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID, 
-        StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), requestType)); 
- 
-    intermediate->HasCookie = true; 
-    intermediate->Cookie = request.cookie(); 
-    intermediate->ExecuteTransactionResponse.set_cookie(request.cookie()); 
- 
-    intermediate->RequestUid = NextRequestUid; 
-    ++NextRequestUid; 
-    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now(); 
-    intermediate->EvType = TEvKeyValue::TEvExecuteTransaction::EventType; 
- 
-    if (CheckDeadline(ctx, ev->Get(), intermediate)) { 
-        return false; 
-    } 
- 
-    if (CheckGeneration(ctx, ev->Get(), intermediate)) { 
-        return false; 
-    } 
- 
-    TPrepareResult result = PrepareCommands(request, intermediate, info, ctx); 
- 
-    if (result.WithError) { 
-        // discard allocated LogoBlobIds from the Write commands 
-        for (ui32 idx : intermediate->WriteIndices) { 
-            const auto &cmd = intermediate->Commands[idx]; 
-            Y_VERIFY(std::holds_alternative<TIntermediate::TWrite>(cmd)); 
-            auto &write = std::get<TIntermediate::TWrite>(cmd); 
-            for (const TLogoBlobID &id : write.LogoBlobIds) { 
-                const ui32 count = RefCounts.erase(id); 
-                Y_VERIFY(count == 1); 
-            } 
-        } 
- 
-        LOG_ERROR_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-                << " PrepareExecuteTransactionRequest return flase, Marker# KV73" 
-                << " Submsg# " << result.ErrorMsg); 
-        return false; 
-    } 
- 
-    return true; 
-} 
- 
- 
-TKeyValueState::TPrepareResult TKeyValueState::PrepareOneGetStatus(TIntermediate::TGetStatus &cmd, 
-        ui64 publicStorageChannel, const TTabletStorageInfo *info) 
-{ 
-    NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel = NKikimrClient::TKeyValueRequest::MAIN; 
-    if (publicStorageChannel == 1) { 
-        storageChannel = NKikimrClient::TKeyValueRequest::INLINE; 
-    } else if (publicStorageChannel) { 
-        ui32 storageChannelIdx = BLOB_CHANNEL + publicStorageChannel - MainStorageChannelInPublicApi; 
-        storageChannel = NKikimrClient::TKeyValueRequest::EStorageChannel(storageChannelIdx); 
-    } 
-    return InitGetStatusCommand(cmd, storageChannel, info);; 
-} 
- 
- 
-bool TKeyValueState::PrepareGetStatusRequest(const TActorContext &ctx, TEvKeyValue::TEvGetStatus::TPtr &ev, 
-        THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info) 
-{ 
-    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " PrepareGetStatusRequest Marker# KV78"); 
- 
-    NKikimrKeyValue::GetStatusRequest &request = ev->Get()->Record; 
-    StoredState.SetChannelGeneration(ExecutorGeneration); 
-    StoredState.SetChannelStep(NextLogoBlobStep - 1); 
- 
-    TRequestType::EType requestType = TRequestType::ReadOnly; 
-    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID, 
-        StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), requestType)); 
- 
-    intermediate->RequestUid = NextRequestUid; 
-    ++NextRequestUid; 
-    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now(); 
-    intermediate->EvType = TEvKeyValue::TEvGetStatus::EventType; 
- 
-    if (CheckDeadline(ctx, ev->Get(), intermediate)) { 
-        return false; 
-    } 
- 
-    if (CheckGeneration(ctx, ev->Get(), intermediate)) { 
-        return false; 
-    } 
- 
-    intermediate->GetStatuses.resize(request.storage_channel_size()); 
-    for (i32 idx = 0; idx < request.storage_channel_size(); ++idx) { 
-        TPrepareResult result = PrepareOneGetStatus(intermediate->GetStatuses[idx], request.storage_channel(idx), info); 
-        if (result.ErrorMsg && !result.WithError) { 
-            LOG_INFO_S(ctx, NKikimrServices::KEYVALUE, result.ErrorMsg  << " Marker# KV77"); 
-        } 
-    } 
-    return true; 
-} 
- 
-bool TKeyValueState::PrepareObtainLockRequest(const TActorContext &ctx, TEvKeyValue::TEvObtainLock::TPtr &ev, 
-        THolder<TIntermediate> &intermediate) 
-{ 
-    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " PrepareObtainLockRequest Marker# KV79"); 
- 
-    StoredState.SetChannelGeneration(ExecutorGeneration); 
-    StoredState.SetChannelStep(NextLogoBlobStep - 1); 
- 
-    TRequestType::EType requestType = TRequestType::ReadOnly; 
-    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID, 
-        StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), requestType)); 
- 
-    intermediate->RequestUid = NextRequestUid; 
-    ++NextRequestUid; 
-    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now(); 
-    intermediate->EvType = TEvKeyValue::TEvObtainLock::EventType; 
-    intermediate->HasIncrementGeneration = true; 
-    return true; 
-} 
- 
-void RegisterReadRequestActor(const TActorContext &ctx, THolder<TIntermediate> &&intermediate, 
-        const TTabletStorageInfo *info) 
-{ 
-    ctx.RegisterWithSameMailbox(CreateKeyValueStorageReadRequest(std::move(intermediate), info)); 
-} 
- 
-void RegisterRequestActor(const TActorContext &ctx, THolder<TIntermediate> &&intermediate, 
-        const TTabletStorageInfo *info) 
-{ 
-    ctx.RegisterWithSameMailbox(CreateKeyValueStorageRequest(std::move(intermediate), info)); 
-} 
- 
-void TKeyValueState::ProcessPostponedIntermediate(const TActorContext& ctx, THolder<TIntermediate> &&intermediate, 
-            const TTabletStorageInfo *info) 
-{ 
-    switch(intermediate->EvType) { 
-    case TEvKeyValue::TEvRequest::EventType: 
-        return RegisterRequestActor(ctx, std::move(intermediate), info); 
-    case TEvKeyValue::TEvRead::EventType: 
-    case TEvKeyValue::TEvReadRange::EventType: 
-        return RegisterReadRequestActor(ctx, std::move(intermediate), info); 
-    default: 
-        Y_FAIL_S("Unexpected event type# " << intermediate->EvType); 
-    } 
-} 
- 
-void TKeyValueState::OnEvReadRequest(TEvKeyValue::TEvRead::TPtr &ev, const TActorContext &ctx, 
-        const TTabletStorageInfo *info) 
-{ 
-    THolder<TIntermediate> intermediate; 
- 
-    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize()); 
-    ResourceMetrics->TryUpdate(ctx); 
- 
-    TRequestType::EType requestType = TRequestType::ReadOnly; 
-    CountRequestIncoming(requestType); 
- 
-    if (PrepareReadRequest(ctx, ev, intermediate, &requestType)) { 
-        ++InFlightForStep[StoredState.GetChannelStep()]; 
-        if (requestType == TRequestType::ReadOnlyInline) { 
-            LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-                << " Create storage inline read request, Marker# KV49"); 
-            RegisterReadRequestActor(ctx, std::move(intermediate), info); 
-            ++RoInlineIntermediatesInFlight; 
-        } else { 
-            if (IntermediatesInFlight < IntermediatesInFlightLimit) { 
-                LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-                    << " Create storage read request, Marker# KV54"); 
-                RegisterReadRequestActor(ctx, std::move(intermediate), info); 
-                ++IntermediatesInFlight; 
-            } else { 
-                LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-                    << " Enqueue storage read request, Marker# KV56"); 
-                PostponeIntermediate<TEvKeyValue::TEvRead>(std::move(intermediate)); 
-            } 
-        } 
-        CountRequestTakeOffOrEnqueue(requestType); 
-    } else { 
-        intermediate->UpdateStat(); 
-        CountRequestOtherError(requestType); 
-    } 
-} 
- 
-void TKeyValueState::OnEvReadRangeRequest(TEvKeyValue::TEvReadRange::TPtr &ev, const TActorContext &ctx, 
-        const TTabletStorageInfo *info) 
-{ 
-    THolder<TIntermediate> intermediate; 
- 
-    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize()); 
-    ResourceMetrics->TryUpdate(ctx); 
- 
-    TRequestType::EType requestType = TRequestType::ReadOnly; 
-    CountRequestIncoming(requestType); 
- 
-    if (PrepareReadRangeRequest(ctx, ev, intermediate, &requestType)) { 
-        ++InFlightForStep[StoredState.GetChannelStep()]; 
-        if (requestType == TRequestType::ReadOnlyInline) { 
-            LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-                << " Create storage inline read range request, Marker# KV58"); 
-            RegisterReadRequestActor(ctx, std::move(intermediate), info); 
-            ++RoInlineIntermediatesInFlight; 
-        } else { 
-            if (IntermediatesInFlight < IntermediatesInFlightLimit) { 
-                LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-                    << " Create storage read range request, Marker# KV66"); 
-                RegisterReadRequestActor(ctx, std::move(intermediate), info); 
-                ++IntermediatesInFlight; 
-            } else { 
-                LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-                    << " Enqueue storage read range request, Marker# KV59"); 
-                PostponeIntermediate<TEvKeyValue::TEvReadRange>(std::move(intermediate)); 
-            } 
-        } 
-        CountRequestTakeOffOrEnqueue(requestType); 
-    } else { 
-        intermediate->UpdateStat(); 
-        CountRequestOtherError(requestType); 
-    } 
-    CountRequestTakeOffOrEnqueue(requestType); 
-} 
- 
-void TKeyValueState::OnEvExecuteTransaction(TEvKeyValue::TEvExecuteTransaction::TPtr &ev, const TActorContext &ctx, 
-        const TTabletStorageInfo *info) 
-{ 
-    THolder<TIntermediate> intermediate; 
- 
-    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize()); 
-    ResourceMetrics->TryUpdate(ctx); 
- 
-    TRequestType::EType requestType = TRequestType::WriteOnly; 
-    CountRequestIncoming(requestType); 
- 
-    if (PrepareExecuteTransactionRequest(ctx, ev, intermediate, info)) { 
-        ++InFlightForStep[StoredState.GetChannelStep()]; 
-        LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-            << " Create storage request for WO, Marker# KV67"); 
-        RegisterRequestActor(ctx, std::move(intermediate), info); 
- 
-        CountRequestTakeOffOrEnqueue(requestType); 
-    } else { 
-        intermediate->UpdateStat(); 
-        CountRequestOtherError(requestType); 
-    } 
-} 
- 
-void TKeyValueState::OnEvGetStatus(TEvKeyValue::TEvGetStatus::TPtr &ev, const TActorContext &ctx, 
-        const TTabletStorageInfo *info) 
-{ 
-    THolder<TIntermediate> intermediate; 
- 
-    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize()); 
-    ResourceMetrics->TryUpdate(ctx); 
- 
-    TRequestType::EType requestType = TRequestType::ReadOnlyInline; 
-    CountRequestIncoming(requestType); 
- 
-    if (PrepareGetStatusRequest(ctx, ev, intermediate, info)) { 
-        ++InFlightForStep[StoredState.GetChannelStep()]; 
-        LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-            << " Create GetStatus request, Marker# KV75"); 
-        RegisterRequestActor(ctx, std::move(intermediate), info); 
-        ++RoInlineIntermediatesInFlight; 
-        CountRequestTakeOffOrEnqueue(requestType); 
-    } else { 
-        intermediate->UpdateStat(); 
-        CountRequestOtherError(requestType); 
-    } 
-} 
- 
-void TKeyValueState::OnEvObtainLock(TEvKeyValue::TEvObtainLock::TPtr &ev, const TActorContext &ctx, 
-        const TTabletStorageInfo *info) 
-{ 
-    THolder<TIntermediate> intermediate; 
- 
-    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize()); 
-    ResourceMetrics->TryUpdate(ctx); 
- 
-    TRequestType::EType requestType = TRequestType::ReadOnlyInline; 
- 
-    CountRequestIncoming(requestType); 
-    if (PrepareObtainLockRequest(ctx, ev, intermediate)) { 
-        ++InFlightForStep[StoredState.GetChannelStep()]; 
-        LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId 
-            << " Create ObtainLock request, Marker# KV80"); 
-        RegisterRequestActor(ctx, std::move(intermediate), info); 
-        ++RoInlineIntermediatesInFlight; 
-        CountRequestTakeOffOrEnqueue(requestType); 
-    } else { 
-        intermediate->UpdateStat(); 
-        CountRequestOtherError(requestType); 
-    } 
-} 
- 
+bool TKeyValueState::PrepareReadRequest(const TActorContext &ctx, TEvKeyValue::TEvRead::TPtr &ev,
+        THolder<TIntermediate> &intermediate, TRequestType::EType *outRequestType)
+{
+    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " PrepareReadRequest Marker# KV53");
+
+    NKikimrKeyValue::ReadRequest &request = ev->Get()->Record;
+    StoredState.SetChannelGeneration(ExecutorGeneration);
+    StoredState.SetChannelStep(NextLogoBlobStep - 1);
+
+    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID,
+            StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), TRequestType::ReadOnly));
+
+    intermediate->HasCookie = true;
+    intermediate->Cookie = request.cookie();
+
+    intermediate->RequestUid = NextRequestUid;
+    ++NextRequestUid;
+    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now();
+    intermediate->EvType = TEvKeyValue::TEvRead::EventType;
+
+    bool isInlineOnly = true;
+    intermediate->ReadCommand = TIntermediate::TRead();
+    auto &response = std::get<TIntermediate::TRead>(*intermediate->ReadCommand);
+    response.Key = request.key();
+
+    if (CheckDeadline(ctx, ev->Get(), intermediate)) {
+        return false;
+    }
+
+    if (CheckGeneration(ctx, ev->Get(), intermediate)) {
+        return false;
+    }
+
+    auto it = Index.find(request.key());
+    if (it == Index.end()) {
+        response.Status = NKikimrProto::NODATA;
+        response.Message = "No such key Marker# KV55";
+        ReplyError<TEvKeyValue::TEvReadResponse>(ctx, response.Message,
+                NKikimrKeyValue::Statuses::RSTATUS_NO_DATA, intermediate);
+        return false;
+    }
+    bool isOverRun = PrepareOneRead<NKikimrKeyValue::Priorities, true, ReadResultSizeEstimationNewApi>(
+            it->first, it->second, request.offset(), request.size(), request.priority(), request.limit_bytes(),
+            intermediate, response, isInlineOnly);
+
+    if (isInlineOnly) {
+        *outRequestType = TRequestType::ReadOnlyInline;
+        intermediate->Stat.RequestType = *outRequestType;
+    }
+    intermediate->IsTruncated = isOverRun;
+    return true;
+}
+
+bool TKeyValueState::PrepareReadRangeRequest(const TActorContext &ctx, TEvKeyValue::TEvReadRange::TPtr &ev,
+        THolder<TIntermediate> &intermediate, TRequestType::EType *outRequestType)
+{
+    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " PrepareReadRangeRequest Marker# KV57");
+
+    NKikimrKeyValue::ReadRangeRequest &request = ev->Get()->Record;
+    StoredState.SetChannelGeneration(ExecutorGeneration);
+    StoredState.SetChannelStep(NextLogoBlobStep - 1);
+
+    TRequestType::EType requestType = TRequestType::ReadOnly;
+    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID,
+        StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), requestType));
+
+    intermediate->HasCookie = true;
+    intermediate->Cookie = request.cookie();
+
+    intermediate->RequestUid = NextRequestUid;
+    ++NextRequestUid;
+    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now();
+    intermediate->EvType = TEvKeyValue::TEvReadRange::EventType;
+    intermediate->TotalSize = ReadRangeRequestMetaDataSizeEstimation;
+
+    intermediate->ReadCommand = TIntermediate::TRangeRead();
+    auto &response = std::get<TIntermediate::TRangeRead>(*intermediate->ReadCommand);
+
+    if (CheckDeadline(ctx, ev->Get(), intermediate)) {
+        response.Status = NKikimrProto::ERROR;
+        return false;
+    }
+
+    if (CheckGeneration(ctx, ev->Get(), intermediate)) {
+        response.Status = NKikimrProto::ERROR;
+        return false;
+    }
+
+    TKeyRange range;
+    auto convResult = ConvertRange(request.range(), &range, "ReadRange");
+    if (convResult.WithError) {
+        response.Status = NKikimrProto::ERROR;
+        return false;
+    }
+    response.Status = NKikimrProto::OK;
+
+    ui64 cmdLimitBytes = request.limit_bytes();
+    if (!cmdLimitBytes) {
+        cmdLimitBytes = Max<ui64>();
+    }
+    bool includeData = request.include_data();
+    ui8 priority = request.priority();
+    response.LimitBytes = cmdLimitBytes;
+    response.IncludeData = includeData;
+
+    bool isInlineOnly = true;
+    auto processOneCmdReadRange = ProcessOneCmdReadRange<NKikimrKeyValue::Priorities, true,
+            KeyValuePairSizeEstimationNewApi, KeyInfoSizeEstimation>;
+    processOneCmdReadRange(this, range, cmdLimitBytes, includeData, priority, response, intermediate, &isInlineOnly);
+
+    if (isInlineOnly) {
+        *outRequestType = TRequestType::ReadOnlyInline;
+        intermediate->Stat.RequestType = *outRequestType;
+    }
+    return true;
+}
+
+
+bool TKeyValueState::PrepareExecuteTransactionRequest(const TActorContext &ctx,
+        TEvKeyValue::TEvExecuteTransaction::TPtr &ev, THolder<TIntermediate> &intermediate,
+        const TTabletStorageInfo *info)
+{
+    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+            << " PrepareExecuteTransactionRequest Marker# KV72");
+
+    NKikimrKeyValue::ExecuteTransactionRequest &request = ev->Get()->Record;
+    StoredState.SetChannelGeneration(ExecutorGeneration);
+    StoredState.SetChannelStep(NextLogoBlobStep - 1);
+
+    TRequestType::EType requestType = TRequestType::WriteOnly;
+    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID,
+        StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), requestType));
+
+    intermediate->HasCookie = true;
+    intermediate->Cookie = request.cookie();
+    intermediate->ExecuteTransactionResponse.set_cookie(request.cookie());
+
+    intermediate->RequestUid = NextRequestUid;
+    ++NextRequestUid;
+    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now();
+    intermediate->EvType = TEvKeyValue::TEvExecuteTransaction::EventType;
+
+    if (CheckDeadline(ctx, ev->Get(), intermediate)) {
+        return false;
+    }
+
+    if (CheckGeneration(ctx, ev->Get(), intermediate)) {
+        return false;
+    }
+
+    TPrepareResult result = PrepareCommands(request, intermediate, info, ctx);
+
+    if (result.WithError) {
+        // discard allocated LogoBlobIds from the Write commands
+        for (ui32 idx : intermediate->WriteIndices) {
+            const auto &cmd = intermediate->Commands[idx];
+            Y_VERIFY(std::holds_alternative<TIntermediate::TWrite>(cmd));
+            auto &write = std::get<TIntermediate::TWrite>(cmd);
+            for (const TLogoBlobID &id : write.LogoBlobIds) {
+                const ui32 count = RefCounts.erase(id);
+                Y_VERIFY(count == 1);
+            }
+        }
+
+        LOG_ERROR_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+                << " PrepareExecuteTransactionRequest return flase, Marker# KV73"
+                << " Submsg# " << result.ErrorMsg);
+        return false;
+    }
+
+    return true;
+}
+
+
+TKeyValueState::TPrepareResult TKeyValueState::PrepareOneGetStatus(TIntermediate::TGetStatus &cmd,
+        ui64 publicStorageChannel, const TTabletStorageInfo *info)
+{
+    NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel = NKikimrClient::TKeyValueRequest::MAIN;
+    if (publicStorageChannel == 1) {
+        storageChannel = NKikimrClient::TKeyValueRequest::INLINE;
+    } else if (publicStorageChannel) {
+        ui32 storageChannelIdx = BLOB_CHANNEL + publicStorageChannel - MainStorageChannelInPublicApi;
+        storageChannel = NKikimrClient::TKeyValueRequest::EStorageChannel(storageChannelIdx);
+    }
+    return InitGetStatusCommand(cmd, storageChannel, info);;
+}
+
+
+bool TKeyValueState::PrepareGetStatusRequest(const TActorContext &ctx, TEvKeyValue::TEvGetStatus::TPtr &ev,
+        THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info)
+{
+    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " PrepareGetStatusRequest Marker# KV78");
+
+    NKikimrKeyValue::GetStatusRequest &request = ev->Get()->Record;
+    StoredState.SetChannelGeneration(ExecutorGeneration);
+    StoredState.SetChannelStep(NextLogoBlobStep - 1);
+
+    TRequestType::EType requestType = TRequestType::ReadOnly;
+    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID,
+        StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), requestType));
+
+    intermediate->RequestUid = NextRequestUid;
+    ++NextRequestUid;
+    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now();
+    intermediate->EvType = TEvKeyValue::TEvGetStatus::EventType;
+
+    if (CheckDeadline(ctx, ev->Get(), intermediate)) {
+        return false;
+    }
+
+    if (CheckGeneration(ctx, ev->Get(), intermediate)) {
+        return false;
+    }
+
+    intermediate->GetStatuses.resize(request.storage_channel_size());
+    for (i32 idx = 0; idx < request.storage_channel_size(); ++idx) {
+        TPrepareResult result = PrepareOneGetStatus(intermediate->GetStatuses[idx], request.storage_channel(idx), info);
+        if (result.ErrorMsg && !result.WithError) {
+            LOG_INFO_S(ctx, NKikimrServices::KEYVALUE, result.ErrorMsg  << " Marker# KV77");
+        }
+    }
+    return true;
+}
+
+bool TKeyValueState::PrepareObtainLockRequest(const TActorContext &ctx, TEvKeyValue::TEvObtainLock::TPtr &ev,
+        THolder<TIntermediate> &intermediate)
+{
+    LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId << " PrepareObtainLockRequest Marker# KV79");
+
+    StoredState.SetChannelGeneration(ExecutorGeneration);
+    StoredState.SetChannelStep(NextLogoBlobStep - 1);
+
+    TRequestType::EType requestType = TRequestType::ReadOnly;
+    intermediate.Reset(new TIntermediate(ev->Sender, ctx.SelfID,
+        StoredState.GetChannelGeneration(), StoredState.GetChannelStep(), requestType));
+
+    intermediate->RequestUid = NextRequestUid;
+    ++NextRequestUid;
+    RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now();
+    intermediate->EvType = TEvKeyValue::TEvObtainLock::EventType;
+    intermediate->HasIncrementGeneration = true;
+    return true;
+}
+
+void RegisterReadRequestActor(const TActorContext &ctx, THolder<TIntermediate> &&intermediate,
+        const TTabletStorageInfo *info)
+{
+    ctx.RegisterWithSameMailbox(CreateKeyValueStorageReadRequest(std::move(intermediate), info));
+}
+
+void RegisterRequestActor(const TActorContext &ctx, THolder<TIntermediate> &&intermediate,
+        const TTabletStorageInfo *info)
+{
+    ctx.RegisterWithSameMailbox(CreateKeyValueStorageRequest(std::move(intermediate), info));
+}
+
+void TKeyValueState::ProcessPostponedIntermediate(const TActorContext& ctx, THolder<TIntermediate> &&intermediate,
+            const TTabletStorageInfo *info)
+{
+    switch(intermediate->EvType) {
+    case TEvKeyValue::TEvRequest::EventType:
+        return RegisterRequestActor(ctx, std::move(intermediate), info);
+    case TEvKeyValue::TEvRead::EventType:
+    case TEvKeyValue::TEvReadRange::EventType:
+        return RegisterReadRequestActor(ctx, std::move(intermediate), info);
+    default:
+        Y_FAIL_S("Unexpected event type# " << intermediate->EvType);
+    }
+}
+
+void TKeyValueState::OnEvReadRequest(TEvKeyValue::TEvRead::TPtr &ev, const TActorContext &ctx,
+        const TTabletStorageInfo *info)
+{
+    THolder<TIntermediate> intermediate;
+
+    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize());
+    ResourceMetrics->TryUpdate(ctx);
+
+    TRequestType::EType requestType = TRequestType::ReadOnly;
+    CountRequestIncoming(requestType);
+
+    if (PrepareReadRequest(ctx, ev, intermediate, &requestType)) {
+        ++InFlightForStep[StoredState.GetChannelStep()];
+        if (requestType == TRequestType::ReadOnlyInline) {
+            LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+                << " Create storage inline read request, Marker# KV49");
+            RegisterReadRequestActor(ctx, std::move(intermediate), info);
+            ++RoInlineIntermediatesInFlight;
+        } else {
+            if (IntermediatesInFlight < IntermediatesInFlightLimit) {
+                LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+                    << " Create storage read request, Marker# KV54");
+                RegisterReadRequestActor(ctx, std::move(intermediate), info);
+                ++IntermediatesInFlight;
+            } else {
+                LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+                    << " Enqueue storage read request, Marker# KV56");
+                PostponeIntermediate<TEvKeyValue::TEvRead>(std::move(intermediate));
+            }
+        }
+        CountRequestTakeOffOrEnqueue(requestType);
+    } else {
+        intermediate->UpdateStat();
+        CountRequestOtherError(requestType);
+    }
+}
+
+void TKeyValueState::OnEvReadRangeRequest(TEvKeyValue::TEvReadRange::TPtr &ev, const TActorContext &ctx,
+        const TTabletStorageInfo *info)
+{
+    THolder<TIntermediate> intermediate;
+
+    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize());
+    ResourceMetrics->TryUpdate(ctx);
+
+    TRequestType::EType requestType = TRequestType::ReadOnly;
+    CountRequestIncoming(requestType);
+
+    if (PrepareReadRangeRequest(ctx, ev, intermediate, &requestType)) {
+        ++InFlightForStep[StoredState.GetChannelStep()];
+        if (requestType == TRequestType::ReadOnlyInline) {
+            LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+                << " Create storage inline read range request, Marker# KV58");
+            RegisterReadRequestActor(ctx, std::move(intermediate), info);
+            ++RoInlineIntermediatesInFlight;
+        } else {
+            if (IntermediatesInFlight < IntermediatesInFlightLimit) {
+                LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+                    << " Create storage read range request, Marker# KV66");
+                RegisterReadRequestActor(ctx, std::move(intermediate), info);
+                ++IntermediatesInFlight;
+            } else {
+                LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+                    << " Enqueue storage read range request, Marker# KV59");
+                PostponeIntermediate<TEvKeyValue::TEvReadRange>(std::move(intermediate));
+            }
+        }
+        CountRequestTakeOffOrEnqueue(requestType);
+    } else {
+        intermediate->UpdateStat();
+        CountRequestOtherError(requestType);
+    }
+    CountRequestTakeOffOrEnqueue(requestType);
+}
+
+void TKeyValueState::OnEvExecuteTransaction(TEvKeyValue::TEvExecuteTransaction::TPtr &ev, const TActorContext &ctx,
+        const TTabletStorageInfo *info)
+{
+    THolder<TIntermediate> intermediate;
+
+    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize());
+    ResourceMetrics->TryUpdate(ctx);
+
+    TRequestType::EType requestType = TRequestType::WriteOnly;
+    CountRequestIncoming(requestType);
+
+    if (PrepareExecuteTransactionRequest(ctx, ev, intermediate, info)) {
+        ++InFlightForStep[StoredState.GetChannelStep()];
+        LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+            << " Create storage request for WO, Marker# KV67");
+        RegisterRequestActor(ctx, std::move(intermediate), info);
+
+        CountRequestTakeOffOrEnqueue(requestType);
+    } else {
+        intermediate->UpdateStat();
+        CountRequestOtherError(requestType);
+    }
+}
+
+void TKeyValueState::OnEvGetStatus(TEvKeyValue::TEvGetStatus::TPtr &ev, const TActorContext &ctx,
+        const TTabletStorageInfo *info)
+{
+    THolder<TIntermediate> intermediate;
+
+    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize());
+    ResourceMetrics->TryUpdate(ctx);
+
+    TRequestType::EType requestType = TRequestType::ReadOnlyInline;
+    CountRequestIncoming(requestType);
+
+    if (PrepareGetStatusRequest(ctx, ev, intermediate, info)) {
+        ++InFlightForStep[StoredState.GetChannelStep()];
+        LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+            << " Create GetStatus request, Marker# KV75");
+        RegisterRequestActor(ctx, std::move(intermediate), info);
+        ++RoInlineIntermediatesInFlight;
+        CountRequestTakeOffOrEnqueue(requestType);
+    } else {
+        intermediate->UpdateStat();
+        CountRequestOtherError(requestType);
+    }
+}
+
+void TKeyValueState::OnEvObtainLock(TEvKeyValue::TEvObtainLock::TPtr &ev, const TActorContext &ctx,
+        const TTabletStorageInfo *info)
+{
+    THolder<TIntermediate> intermediate;
+
+    ResourceMetrics->Network.Increment(ev->Get()->Record.ByteSize());
+    ResourceMetrics->TryUpdate(ctx);
+
+    TRequestType::EType requestType = TRequestType::ReadOnlyInline;
+
+    CountRequestIncoming(requestType);
+    if (PrepareObtainLockRequest(ctx, ev, intermediate)) {
+        ++InFlightForStep[StoredState.GetChannelStep()];
+        LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
+            << " Create ObtainLock request, Marker# KV80");
+        RegisterRequestActor(ctx, std::move(intermediate), info);
+        ++RoInlineIntermediatesInFlight;
+        CountRequestTakeOffOrEnqueue(requestType);
+    } else {
+        intermediate->UpdateStat();
+        CountRequestOtherError(requestType);
+    }
+}
+
 void TKeyValueState::OnEvIntermediate(TIntermediate &intermediate, const TActorContext &ctx) {
     Y_UNUSED(ctx);
     CountLatencyBsOps(intermediate.Stat);
@@ -3010,26 +3010,26 @@ void TKeyValueState::OnEvRequest(TEvKeyValue::TEvRequest::TPtr &ev, const TActor
 
     if (PrepareIntermediate(ev, intermediate, requestType, ctx, info)) {
         // Spawn KeyValueStorageRequest actor on the same thread
-        ++InFlightForStep[StoredState.GetChannelStep()]; 
+        ++InFlightForStep[StoredState.GetChannelStep()];
         if (requestType == TRequestType::WriteOnly) {
             LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
                 << " Create storage request for WO, Marker# KV42");
-            RegisterRequestActor(ctx, std::move(intermediate), info); 
+            RegisterRequestActor(ctx, std::move(intermediate), info);
         } else if (requestType == TRequestType::ReadOnlyInline) {
             LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
                 << " Create storage request for RO_INLINE, Marker# KV45");
-            RegisterRequestActor(ctx, std::move(intermediate), info); 
+            RegisterRequestActor(ctx, std::move(intermediate), info);
             ++RoInlineIntermediatesInFlight;
         } else {
             if (IntermediatesInFlight < IntermediatesInFlightLimit) {
                 LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
                     << " Create storage request for RO/RW, Marker# KV43");
-                RegisterRequestActor(ctx, std::move(intermediate), info); 
+                RegisterRequestActor(ctx, std::move(intermediate), info);
                 ++IntermediatesInFlight;
             } else {
                 LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
                     << " Enqueue storage request for RO/RW, Marker# KV44");
-                PostponeIntermediate<TEvKeyValue::TEvRequest>(std::move(intermediate)); 
+                PostponeIntermediate<TEvKeyValue::TEvRequest>(std::move(intermediate));
             }
         }
 
@@ -3055,7 +3055,7 @@ bool TKeyValueState::PrepareIntermediate(TEvKeyValue::TEvRequest::TPtr &ev, THol
     intermediate->RequestUid = NextRequestUid;
     ++NextRequestUid;
     RequestInputTime[intermediate->RequestUid] = TAppData::TimeProvider->Now();
-    intermediate->EvType = TEvKeyValue::TEvRequest::EventType; 
+    intermediate->EvType = TEvKeyValue::TEvRequest::EventType;
 
     intermediate->HasCookie = request.HasCookie();
     if (request.HasCookie()) {
@@ -3081,10 +3081,10 @@ bool TKeyValueState::PrepareIntermediate(TEvKeyValue::TEvRequest::TPtr &ev, THol
         intermediate->Stat.RequestType = inOutRequestType;
     }
 
-    ui32 cmdCount = request.CmdWriteSize() + request.CmdDeleteRangeSize() + request.CmdRenameSize() 
-            + request.CmdCopyRangeSize() + request.CmdConcatSize(); 
-    intermediate->Commands.reserve(cmdCount); 
- 
+    ui32 cmdCount = request.CmdWriteSize() + request.CmdDeleteRangeSize() + request.CmdRenameSize()
+            + request.CmdCopyRangeSize() + request.CmdConcatSize();
+    intermediate->Commands.reserve(cmdCount);
+
     error = error || PrepareCmdCopyRange(ctx, request, intermediate);
     error = error || PrepareCmdRename(ctx, request, intermediate);
     error = error || PrepareCmdConcat(ctx, request, intermediate);
@@ -3094,12 +3094,12 @@ bool TKeyValueState::PrepareIntermediate(TEvKeyValue::TEvRequest::TPtr &ev, THol
     error = error || PrepareCmdTrimLeakedBlobs(ctx, request, intermediate, info);
     error = error || PrepareCmdSetExecutorFastLogPolicy(ctx, request, intermediate, info);
 
-    intermediate->WriteCount = request.CmdWriteSize(); 
-    intermediate->DeleteCount = request.CmdDeleteRangeSize(); 
-    intermediate->RenameCount = request.CmdRenameSize(); 
-    intermediate->CopyRangeCount = request.CmdCopyRangeSize(); 
-    intermediate->ConcatCount = request.CmdConcatSize(); 
- 
+    intermediate->WriteCount = request.CmdWriteSize();
+    intermediate->DeleteCount = request.CmdDeleteRangeSize();
+    intermediate->RenameCount = request.CmdRenameSize();
+    intermediate->CopyRangeCount = request.CmdCopyRangeSize();
+    intermediate->ConcatCount = request.CmdConcatSize();
+
     if (error) {
         // discard allocated LogoBlobIds from the Write commands
         for (const auto &write : intermediate->Writes) {
@@ -3109,16 +3109,16 @@ bool TKeyValueState::PrepareIntermediate(TEvKeyValue::TEvRequest::TPtr &ev, THol
             }
         }
 
-        for (ui32 idx : intermediate->WriteIndices) { 
-            const auto &cmd = intermediate->Commands[idx]; 
-            Y_VERIFY(std::holds_alternative<TIntermediate::TWrite>(cmd)); 
-            auto &write = std::get<TIntermediate::TWrite>(cmd); 
-            for (const TLogoBlobID &id : write.LogoBlobIds) { 
-                const ui32 count = RefCounts.erase(id); 
-                Y_VERIFY(count == 1); 
-            } 
-        } 
- 
+        for (ui32 idx : intermediate->WriteIndices) {
+            const auto &cmd = intermediate->Commands[idx];
+            Y_VERIFY(std::holds_alternative<TIntermediate::TWrite>(cmd));
+            auto &write = std::get<TIntermediate::TWrite>(cmd);
+            for (const TLogoBlobID &id : write.LogoBlobIds) {
+                const ui32 count = RefCounts.erase(id);
+                Y_VERIFY(count == 1);
+            }
+        }
+
         LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletId
                 << " PrepareIntermediate return flase, Marker# KV41");
         return false;
diff --git a/ydb/core/keyvalue/keyvalue_state.h b/ydb/core/keyvalue/keyvalue_state.h
index e13d7160e1..f57a69d35d 100644
--- a/ydb/core/keyvalue/keyvalue_state.h
+++ b/ydb/core/keyvalue/keyvalue_state.h
@@ -56,9 +56,9 @@ class TKeyValueState {
     };
 
 public:
-    using TIndex = TMap<TString, TIndexRecord>; 
-    using TCommand = NKikimrKeyValue::ExecuteTransactionRequest::Command; 
- 
+    using TIndex = TMap<TString, TIndexRecord>;
+    using TCommand = NKikimrKeyValue::ExecuteTransactionRequest::Command;
+
     class TIncrementalKeySet {
         TMap<TString, TIndexRecord>& Index;
         TSet<TString>                AddedKeys;
@@ -334,34 +334,34 @@ public:
     void OnEvEraseCollect(const TActorContext &ctx);
 
     void Reply(THolder<TIntermediate> &intermediate, const TActorContext &ctx, const TTabletStorageInfo *info);
-    void ProcessCmd(TIntermediate::TRead &read, 
-        NKikimrClient::TKeyValueResponse::TReadResult *legacyResponse, 
-        NKikimrKeyValue::Channel *response, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime); 
-    void ProcessCmd(TIntermediate::TRangeRead &request, 
-        NKikimrClient::TKeyValueResponse::TReadRangeResult *legacyResponse, 
-        NKikimrKeyValue::Channel *response, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime); 
-    void ProcessCmd(TIntermediate::TWrite &request, 
-        NKikimrClient::TKeyValueResponse::TWriteResult *legacyResponse, 
-        NKikimrKeyValue::Channel *response, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime); 
-    void ProcessCmd(const TIntermediate::TDelete &request, 
-        NKikimrClient::TKeyValueResponse::TDeleteRangeResult *legacyResponse, 
-        NKikimrKeyValue::Channel *response, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime); 
-    void ProcessCmd(const TIntermediate::TRename &request, 
-        NKikimrClient::TKeyValueResponse::TRenameResult *legacyResponse, 
-        NKikimrKeyValue::Channel *response, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime); 
-    void ProcessCmd(const TIntermediate::TCopyRange &request, 
-        NKikimrClient::TKeyValueResponse::TCopyRangeResult *legacyResponse, 
-        NKikimrKeyValue::Channel *response, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime); 
-    void ProcessCmd(const TIntermediate::TConcat &request, 
-        NKikimrClient::TKeyValueResponse::TConcatResult *resplegacyResponseonse, 
-        NKikimrKeyValue::Channel *response, 
-        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime); 
+    void ProcessCmd(TIntermediate::TRead &read,
+        NKikimrClient::TKeyValueResponse::TReadResult *legacyResponse,
+        NKikimrKeyValue::Channel *response,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime);
+    void ProcessCmd(TIntermediate::TRangeRead &request,
+        NKikimrClient::TKeyValueResponse::TReadRangeResult *legacyResponse,
+        NKikimrKeyValue::Channel *response,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime);
+    void ProcessCmd(TIntermediate::TWrite &request,
+        NKikimrClient::TKeyValueResponse::TWriteResult *legacyResponse,
+        NKikimrKeyValue::Channel *response,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime);
+    void ProcessCmd(const TIntermediate::TDelete &request,
+        NKikimrClient::TKeyValueResponse::TDeleteRangeResult *legacyResponse,
+        NKikimrKeyValue::Channel *response,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime);
+    void ProcessCmd(const TIntermediate::TRename &request,
+        NKikimrClient::TKeyValueResponse::TRenameResult *legacyResponse,
+        NKikimrKeyValue::Channel *response,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime);
+    void ProcessCmd(const TIntermediate::TCopyRange &request,
+        NKikimrClient::TKeyValueResponse::TCopyRangeResult *legacyResponse,
+        NKikimrKeyValue::Channel *response,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime);
+    void ProcessCmd(const TIntermediate::TConcat &request,
+        NKikimrClient::TKeyValueResponse::TConcatResult *resplegacyResponseonse,
+        NKikimrKeyValue::Channel *response,
+        ISimpleDb &db, const TActorContext &ctx, TRequestStat &stat, ui64 unixTime);
     void CmdRead(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx);
     void CmdReadRange(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx);
     void CmdRename(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx);
@@ -372,36 +372,36 @@ public:
     void CmdConcat(THolder<TIntermediate>& intermediate, ISimpleDb& db, const TActorContext& ctx);
     void CmdTrimLeakedBlobs(THolder<TIntermediate>& intermediate, ISimpleDb& db, const TActorContext& ctx);
     void CmdSetExecutorFastLogPolicy(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx);
-    void CmdCmds(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx); 
+    void CmdCmds(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx);
     void ProcessCmds(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx,
         const TTabletStorageInfo *info);
     bool IncrementGeneration(THolder<TIntermediate> &intermediate, ISimpleDb &db, const TActorContext &ctx);
 
-    struct TCheckResult { 
-        bool Result = true; 
-        TString ErrorMsg; 
-    }; 
- 
-    TCheckResult CheckCmd(const TIntermediate::TRename &cmd, TKeySet& keys, ui32 index) const; 
-    TCheckResult CheckCmd(const TIntermediate::TDelete &cmd, TKeySet& keys, ui32 index) const; 
-    TCheckResult CheckCmd(const TIntermediate::TWrite &cmd, TKeySet& keys, ui32 index) const; 
-    TCheckResult CheckCmd(const TIntermediate::TCopyRange &cmd, TKeySet& keys, ui32 index) const; 
-    TCheckResult CheckCmd(const TIntermediate::TConcat &cmd, TKeySet& keys, ui32 index) const; 
- 
-    bool CheckCmdRenames(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys, 
+    struct TCheckResult {
+        bool Result = true;
+        TString ErrorMsg;
+    };
+
+    TCheckResult CheckCmd(const TIntermediate::TRename &cmd, TKeySet& keys, ui32 index) const;
+    TCheckResult CheckCmd(const TIntermediate::TDelete &cmd, TKeySet& keys, ui32 index) const;
+    TCheckResult CheckCmd(const TIntermediate::TWrite &cmd, TKeySet& keys, ui32 index) const;
+    TCheckResult CheckCmd(const TIntermediate::TCopyRange &cmd, TKeySet& keys, ui32 index) const;
+    TCheckResult CheckCmd(const TIntermediate::TConcat &cmd, TKeySet& keys, ui32 index) const;
+
+    bool CheckCmdRenames(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys,
             const TTabletStorageInfo *info);
-    bool CheckCmdDeletes(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys, 
+    bool CheckCmdDeletes(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys,
             const TTabletStorageInfo *info);
-    bool CheckCmdWrites(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys, 
+    bool CheckCmdWrites(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys,
             const TTabletStorageInfo *info);
-    bool CheckCmdCopyRanges(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys, 
+    bool CheckCmdCopyRanges(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys,
             const TTabletStorageInfo *info);
-    bool CheckCmdConcats(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys, 
+    bool CheckCmdConcats(THolder<TIntermediate>& intermediate, const TActorContext& ctx, TKeySet& keys,
             const TTabletStorageInfo *info);
     bool CheckCmdGetStatus(THolder<TIntermediate>& /*intermediate*/, const TActorContext& /*ctx*/,
         TKeySet& /*keys*/, const TTabletStorageInfo* /*info*/);
-    bool CheckCmds(THolder<TIntermediate>& intermediate, const TActorContext& /*ctx*/, TKeySet& keys, 
-            const TTabletStorageInfo* /*info*/); 
+    bool CheckCmds(THolder<TIntermediate>& intermediate, const TActorContext& /*ctx*/, TKeySet& keys,
+            const TTabletStorageInfo* /*info*/);
 
     void Step();
     TLogoBlobID AllocateLogoBlobId(ui32 size, ui32 storageChannelIdx);
@@ -417,23 +417,23 @@ public:
         return PerGenerationCounter;
     }
 
-    void OnEvReadRequest(TEvKeyValue::TEvRead::TPtr &ev, const TActorContext &ctx, 
-            const TTabletStorageInfo *info); 
-    void OnEvReadRangeRequest(TEvKeyValue::TEvReadRange::TPtr &ev, const TActorContext &ctx, 
-            const TTabletStorageInfo *info); 
-    void OnEvExecuteTransaction(TEvKeyValue::TEvExecuteTransaction::TPtr &ev, const TActorContext &ctx, 
-            const TTabletStorageInfo *info); 
-    void OnEvGetStatus(TEvKeyValue::TEvGetStatus::TPtr &ev, const TActorContext &ctx, 
-            const TTabletStorageInfo *info); 
-    void OnEvObtainLock(TEvKeyValue::TEvObtainLock::TPtr &ev, const TActorContext &ctx, 
-            const TTabletStorageInfo *info); 
- 
+    void OnEvReadRequest(TEvKeyValue::TEvRead::TPtr &ev, const TActorContext &ctx,
+            const TTabletStorageInfo *info);
+    void OnEvReadRangeRequest(TEvKeyValue::TEvReadRange::TPtr &ev, const TActorContext &ctx,
+            const TTabletStorageInfo *info);
+    void OnEvExecuteTransaction(TEvKeyValue::TEvExecuteTransaction::TPtr &ev, const TActorContext &ctx,
+            const TTabletStorageInfo *info);
+    void OnEvGetStatus(TEvKeyValue::TEvGetStatus::TPtr &ev, const TActorContext &ctx,
+            const TTabletStorageInfo *info);
+    void OnEvObtainLock(TEvKeyValue::TEvObtainLock::TPtr &ev, const TActorContext &ctx,
+            const TTabletStorageInfo *info);
+
     void OnPeriodicRefresh(const TActorContext &ctx);
     void OnUpdateWeights(TChannelBalancer::TEvUpdateWeights::TPtr ev);
- 
+
     void OnRequestComplete(ui64 requestUid, ui64 generation, ui64 step, const TActorContext &ctx,
-        const TTabletStorageInfo *info, NMsgBusProxy::EResponseStatus status, const TRequestStat &stat); 
- 
+        const TTabletStorageInfo *info, NMsgBusProxy::EResponseStatus status, const TRequestStat &stat);
+
     void OnEvIntermediate(TIntermediate &intermediate, const TActorContext &ctx);
     void OnEvRequest(TEvKeyValue::TEvRequest::TPtr &ev, const TActorContext &ctx, const TTabletStorageInfo *info);
     bool PrepareIntermediate(TEvKeyValue::TEvRequest::TPtr &ev, THolder<TIntermediate> &intermediate,
@@ -443,57 +443,57 @@ public:
 
     bool CheckDeadline(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
         THolder<TIntermediate> &intermediate);
- 
-    template <typename TRequest> 
-    bool CheckDeadline(const TActorContext &ctx, TRequest *request, 
-            THolder<TIntermediate> &intermediate) 
-    { 
-        ui64 deadlineInstantMs = request->Record.deadline_instant_ms(); 
-        if (!deadlineInstantMs) { 
-            return false; 
-        } 
-        intermediate->Deadline = TInstant::MicroSeconds(deadlineInstantMs * 1000ull); 
- 
-        TInstant now = TAppData::TimeProvider->Now(); 
-        if (intermediate->Deadline <= now) { 
-            TStringStream str; 
-            str << "KeyValue# " << TabletId; 
-            str << " Deadline reached before processing the request!"; 
-            str << " DeadlineInstantMs# " << deadlineInstantMs; 
-            str << " < Now# " << (ui64)now.MilliSeconds(); 
-            ReplyError<typename TRequest::TResponse>(ctx, str.Str(), 
-                    NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT, intermediate); 
-            return true; 
-        } 
- 
-        return false; 
-    } 
- 
+
+    template <typename TRequest>
+    bool CheckDeadline(const TActorContext &ctx, TRequest *request,
+            THolder<TIntermediate> &intermediate)
+    {
+        ui64 deadlineInstantMs = request->Record.deadline_instant_ms();
+        if (!deadlineInstantMs) {
+            return false;
+        }
+        intermediate->Deadline = TInstant::MicroSeconds(deadlineInstantMs * 1000ull);
+
+        TInstant now = TAppData::TimeProvider->Now();
+        if (intermediate->Deadline <= now) {
+            TStringStream str;
+            str << "KeyValue# " << TabletId;
+            str << " Deadline reached before processing the request!";
+            str << " DeadlineInstantMs# " << deadlineInstantMs;
+            str << " < Now# " << (ui64)now.MilliSeconds();
+            ReplyError<typename TRequest::TResponse>(ctx, str.Str(),
+                    NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT, intermediate);
+            return true;
+        }
+
+        return false;
+    }
+
     bool CheckGeneration(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
         THolder<TIntermediate> &intermediate);
- 
-    template <typename TGrpcRequestWithLockGeneration> 
-    bool CheckGeneration(const TActorContext &ctx, TGrpcRequestWithLockGeneration *kvRequest, 
-            THolder<TIntermediate> &intermediate) 
-    { 
-        auto &record = kvRequest->Record; 
-        intermediate->HasGeneration = true; 
-        intermediate->Generation = record.lock_generation(); 
-        if (record.lock_generation() != StoredState.GetUserGeneration()) { 
-            TStringStream str; 
-            str << "KeyValue# " << TabletId; 
-            str << " Generation mismatch! Requested# " << record.lock_generation(); 
-            str << " Actual# " << StoredState.GetUserGeneration(); 
-            str << " Marker# KV05"; 
-            ReplyError<typename TGrpcRequestWithLockGeneration::TResponse>(ctx, str.Str(), 
-                    NKikimrKeyValue::Statuses::RSTATUS_ERROR, intermediate); 
-            return true; 
-        } 
-        return false; 
-    } 
- 
-    void SplitIntoBlobs(TIntermediate::TWrite &cmd, bool isInline, ui32 storageChannelIdx); 
- 
+
+    template <typename TGrpcRequestWithLockGeneration>
+    bool CheckGeneration(const TActorContext &ctx, TGrpcRequestWithLockGeneration *kvRequest,
+            THolder<TIntermediate> &intermediate)
+    {
+        auto &record = kvRequest->Record;
+        intermediate->HasGeneration = true;
+        intermediate->Generation = record.lock_generation();
+        if (record.lock_generation() != StoredState.GetUserGeneration()) {
+            TStringStream str;
+            str << "KeyValue# " << TabletId;
+            str << " Generation mismatch! Requested# " << record.lock_generation();
+            str << " Actual# " << StoredState.GetUserGeneration();
+            str << " Marker# KV05";
+            ReplyError<typename TGrpcRequestWithLockGeneration::TResponse>(ctx, str.Str(),
+                    NKikimrKeyValue::Statuses::RSTATUS_ERROR, intermediate);
+            return true;
+        }
+        return false;
+    }
+
+    void SplitIntoBlobs(TIntermediate::TWrite &cmd, bool isInline, ui32 storageChannelIdx);
+
     bool PrepareCmdRead(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
         THolder<TIntermediate> &intermediate, bool &outIsInlineOnly);
     bool PrepareCmdReadRange(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
@@ -514,144 +514,144 @@ public:
         THolder<TIntermediate>& intermediate, const TTabletStorageInfo *info);
     bool PrepareCmdSetExecutorFastLogPolicy(const TActorContext &ctx, NKikimrClient::TKeyValueRequest &kvRequest,
         THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info);
- 
- 
-    struct TPrepareResult { 
-        bool WithError = false; 
-        TString ErrorMsg; 
-    }; 
-    TPrepareResult PrepareOneCmd(const TCommand::Rename &request, THolder<TIntermediate> &intermediate); 
-    TPrepareResult PrepareOneCmd(const TCommand::Concat &request, THolder<TIntermediate> &intermediate); 
-    TPrepareResult PrepareOneCmd(const TCommand::CopyRange &request, THolder<TIntermediate> &intermediate); 
-    TPrepareResult PrepareOneCmd(const TCommand::Write &request, THolder<TIntermediate> &intermediate, 
-        const TTabletStorageInfo *info); 
-    TPrepareResult PrepareOneCmd(const TCommand::DeleteRange &request, THolder<TIntermediate> &intermediate, 
-        const TActorContext &ctx); 
-    TPrepareResult PrepareOneCmd(const TCommand &request, THolder<TIntermediate> &intermediate, 
-        const TTabletStorageInfo *info, const TActorContext &ctx); 
-    TPrepareResult PrepareCommands(NKikimrKeyValue::ExecuteTransactionRequest &kvRequest, 
-        THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info, const TActorContext &ctx); 
-    TPrepareResult InitGetStatusCommand(TIntermediate::TGetStatus &cmd, 
-        NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel, const TTabletStorageInfo *info); 
+
+
+    struct TPrepareResult {
+        bool WithError = false;
+        TString ErrorMsg;
+    };
+    TPrepareResult PrepareOneCmd(const TCommand::Rename &request, THolder<TIntermediate> &intermediate);
+    TPrepareResult PrepareOneCmd(const TCommand::Concat &request, THolder<TIntermediate> &intermediate);
+    TPrepareResult PrepareOneCmd(const TCommand::CopyRange &request, THolder<TIntermediate> &intermediate);
+    TPrepareResult PrepareOneCmd(const TCommand::Write &request, THolder<TIntermediate> &intermediate,
+        const TTabletStorageInfo *info);
+    TPrepareResult PrepareOneCmd(const TCommand::DeleteRange &request, THolder<TIntermediate> &intermediate,
+        const TActorContext &ctx);
+    TPrepareResult PrepareOneCmd(const TCommand &request, THolder<TIntermediate> &intermediate,
+        const TTabletStorageInfo *info, const TActorContext &ctx);
+    TPrepareResult PrepareCommands(NKikimrKeyValue::ExecuteTransactionRequest &kvRequest,
+        THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info, const TActorContext &ctx);
+    TPrepareResult InitGetStatusCommand(TIntermediate::TGetStatus &cmd,
+        NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel, const TTabletStorageInfo *info);
     void ReplyError(const TActorContext &ctx, TString errorDescription,
         NMsgBusProxy::EResponseStatus status, THolder<TIntermediate> &intermediate,
         const TTabletStorageInfo *info = nullptr);
 
-    template <typename TResponse> 
-    void ReplyError(const TActorContext &ctx, TString errorDescription, 
-        NKikimrKeyValue::Statuses::ReplyStatus status, THolder<TIntermediate> &intermediate, 
-        const TTabletStorageInfo *info = nullptr) 
-    { 
-        LOG_INFO_S(ctx, NKikimrServices::KEYVALUE, errorDescription); 
-        Y_VERIFY(!intermediate->IsReplied); 
-        std::unique_ptr<TResponse> response = std::make_unique<TResponse>(); 
-        response->Record.set_status(status); 
- 
-        if constexpr (std::is_same_v<TResponse, TEvKeyValue::TEvReadResponse>) { 
-            auto &cmd = *intermediate->ReadCommand; 
-            Y_VERIFY(std::holds_alternative<TIntermediate::TRead>(cmd)); 
-            TIntermediate::TRead &interRead = std::get<TIntermediate::TRead>(cmd); 
-            response->Record.set_requested_offset(interRead.Offset); 
-            response->Record.set_requested_size(interRead.ValueSize); 
-            response->Record.set_requested_key(interRead.Key); 
-        } 
-        if constexpr (!std::is_same_v<TResponse, TEvKeyValue::TEvGetStatusResponse>) { 
-            if (intermediate->HasCookie) { 
-                response->Record.set_cookie(intermediate->Cookie); 
-            } 
-        } 
- 
-        if (errorDescription) { 
-            response->Record.set_msg(errorDescription); 
-        } 
- 
-        ResourceMetrics->Network.Increment(response->Record.ByteSize()); 
- 
-        intermediate->IsReplied = true; 
-        ctx.Send(intermediate->RespondTo, response.release()); 
-        if (info) { 
-            intermediate->UpdateStat(); 
-            OnRequestComplete(intermediate->RequestUid, intermediate->CreatedAtGeneration, intermediate->CreatedAtStep, 
-                    ctx, info, TEvKeyValue::TEvNotify::ConvertStatus(status), intermediate->Stat); 
-        } else { //metrics change report in OnRequestComplete is not done 
-            ResourceMetrics->TryUpdate(ctx); 
-            RequestInputTime.erase(intermediate->RequestUid); 
-        } 
-    } 
- 
-    bool PrepareReadRequest(const TActorContext &ctx, TEvKeyValue::TEvRead::TPtr &ev, 
-        THolder<TIntermediate> &intermediate, TRequestType::EType *outRequestTyp); 
-    bool PrepareReadRangeRequest(const TActorContext &ctx, TEvKeyValue::TEvReadRange::TPtr &ev, 
-        THolder<TIntermediate> &intermediate, TRequestType::EType *outRequestType); 
-    bool PrepareExecuteTransactionRequest(const TActorContext &ctx, TEvKeyValue::TEvExecuteTransaction::TPtr &ev, 
-        THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info); 
-    TPrepareResult PrepareOneGetStatus(TIntermediate::TGetStatus &cmd, ui64 publicStorageChannel, 
-        const TTabletStorageInfo *info); 
-    bool PrepareGetStatusRequest(const TActorContext &ctx, TEvKeyValue::TEvGetStatus::TPtr &ev, 
-        THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info); 
-    bool PrepareObtainLockRequest(const TActorContext &ctx, TEvKeyValue::TEvObtainLock::TPtr &ev, 
-        THolder<TIntermediate> &intermediate); 
- 
-    template <typename TRequestType> 
-    void PostponeIntermediate(THolder<TIntermediate> &&intermediate) { 
-        intermediate->Stat.EnqueuedAs = Queue.size() + 1; 
-        Queue.push_back(std::move(intermediate)); 
-    } 
-    void ProcessPostponedIntermediate(const TActorContext& ctx, THolder<TIntermediate> &&intermediate, 
-             const TTabletStorageInfo *info); 
- 
+    template <typename TResponse>
+    void ReplyError(const TActorContext &ctx, TString errorDescription,
+        NKikimrKeyValue::Statuses::ReplyStatus status, THolder<TIntermediate> &intermediate,
+        const TTabletStorageInfo *info = nullptr)
+    {
+        LOG_INFO_S(ctx, NKikimrServices::KEYVALUE, errorDescription);
+        Y_VERIFY(!intermediate->IsReplied);
+        std::unique_ptr<TResponse> response = std::make_unique<TResponse>();
+        response->Record.set_status(status);
+
+        if constexpr (std::is_same_v<TResponse, TEvKeyValue::TEvReadResponse>) {
+            auto &cmd = *intermediate->ReadCommand;
+            Y_VERIFY(std::holds_alternative<TIntermediate::TRead>(cmd));
+            TIntermediate::TRead &interRead = std::get<TIntermediate::TRead>(cmd);
+            response->Record.set_requested_offset(interRead.Offset);
+            response->Record.set_requested_size(interRead.ValueSize);
+            response->Record.set_requested_key(interRead.Key);
+        }
+        if constexpr (!std::is_same_v<TResponse, TEvKeyValue::TEvGetStatusResponse>) {
+            if (intermediate->HasCookie) {
+                response->Record.set_cookie(intermediate->Cookie);
+            }
+        }
+
+        if (errorDescription) {
+            response->Record.set_msg(errorDescription);
+        }
+
+        ResourceMetrics->Network.Increment(response->Record.ByteSize());
+
+        intermediate->IsReplied = true;
+        ctx.Send(intermediate->RespondTo, response.release());
+        if (info) {
+            intermediate->UpdateStat();
+            OnRequestComplete(intermediate->RequestUid, intermediate->CreatedAtGeneration, intermediate->CreatedAtStep,
+                    ctx, info, TEvKeyValue::TEvNotify::ConvertStatus(status), intermediate->Stat);
+        } else { //metrics change report in OnRequestComplete is not done
+            ResourceMetrics->TryUpdate(ctx);
+            RequestInputTime.erase(intermediate->RequestUid);
+        }
+    }
+
+    bool PrepareReadRequest(const TActorContext &ctx, TEvKeyValue::TEvRead::TPtr &ev,
+        THolder<TIntermediate> &intermediate, TRequestType::EType *outRequestTyp);
+    bool PrepareReadRangeRequest(const TActorContext &ctx, TEvKeyValue::TEvReadRange::TPtr &ev,
+        THolder<TIntermediate> &intermediate, TRequestType::EType *outRequestType);
+    bool PrepareExecuteTransactionRequest(const TActorContext &ctx, TEvKeyValue::TEvExecuteTransaction::TPtr &ev,
+        THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info);
+    TPrepareResult PrepareOneGetStatus(TIntermediate::TGetStatus &cmd, ui64 publicStorageChannel,
+        const TTabletStorageInfo *info);
+    bool PrepareGetStatusRequest(const TActorContext &ctx, TEvKeyValue::TEvGetStatus::TPtr &ev,
+        THolder<TIntermediate> &intermediate, const TTabletStorageInfo *info);
+    bool PrepareObtainLockRequest(const TActorContext &ctx, TEvKeyValue::TEvObtainLock::TPtr &ev,
+        THolder<TIntermediate> &intermediate);
+
+    template <typename TRequestType>
+    void PostponeIntermediate(THolder<TIntermediate> &&intermediate) {
+        intermediate->Stat.EnqueuedAs = Queue.size() + 1;
+        Queue.push_back(std::move(intermediate));
+    }
+    void ProcessPostponedIntermediate(const TActorContext& ctx, THolder<TIntermediate> &&intermediate,
+             const TTabletStorageInfo *info);
+
     bool ConvertRange(const NKikimrClient::TKeyValueRequest::TKeyRange& from, TKeyRange *to,
                       const TActorContext& ctx, THolder<TIntermediate>& intermediate, const char *cmd, ui32 index);
 
-    struct TConvertRangeResult { 
-        TString ErrorMsg; 
-        bool WithError = false; 
-    }; 
- 
-    TConvertRangeResult ConvertRange(const NKikimrKeyValue::KVRange& range, TKeyRange *to, const char *cmd) 
-    { 
-        if (range.has_from_key_inclusive()) { 
-            to->HasFrom = true; 
-            to->KeyFrom = range.from_key_inclusive(); 
-            to->IncludeFrom = true; 
-        } else if (range.has_from_key_exclusive()) { 
-            to->HasFrom = true; 
-            to->KeyFrom = range.from_key_exclusive(); 
-            to->IncludeFrom = false; 
-        } else { 
-            to->HasFrom = false; 
-        } 
- 
-        if (range.has_to_key_inclusive()) { 
-            to->HasTo = true; 
-            to->KeyTo = range.to_key_inclusive(); 
-            to->IncludeTo = true; 
-        } else if (range.has_to_key_exclusive()) { 
-            to->HasTo = true; 
-            to->KeyTo = range.to_key_exclusive(); 
-            to->IncludeTo = false; 
-        } else { 
-            to->HasTo = false; 
-        } 
- 
-        if (to->HasFrom && to->HasTo) { 
-            if (!to->IncludeFrom && !to->IncludeTo && to->KeyFrom >= to->KeyTo) { 
-                TString msg = TStringBuilder() << "KeyValue# " << TabletId 
-                        << " Range.KeyFrom >= Range.KeyTo and both exclusive in " << cmd 
-                        << " Marker# KV31"; 
-                return TConvertRangeResult{msg, true}; 
-            } 
-            if (to->KeyFrom > to->KeyTo) { 
-                TString msg = TStringBuilder() << "KeyValue# " << TabletId 
-                        << " Range.KeyFrom > Range.KeyTo and both exclusive in " << cmd 
-                        << " Marker# KV33"; 
-                return TConvertRangeResult{msg, true}; 
-            } 
-        } 
- 
-        return {}; 
-    } 
- 
+    struct TConvertRangeResult {
+        TString ErrorMsg;
+        bool WithError = false;
+    };
+
+    TConvertRangeResult ConvertRange(const NKikimrKeyValue::KVRange& range, TKeyRange *to, const char *cmd)
+    {
+        if (range.has_from_key_inclusive()) {
+            to->HasFrom = true;
+            to->KeyFrom = range.from_key_inclusive();
+            to->IncludeFrom = true;
+        } else if (range.has_from_key_exclusive()) {
+            to->HasFrom = true;
+            to->KeyFrom = range.from_key_exclusive();
+            to->IncludeFrom = false;
+        } else {
+            to->HasFrom = false;
+        }
+
+        if (range.has_to_key_inclusive()) {
+            to->HasTo = true;
+            to->KeyTo = range.to_key_inclusive();
+            to->IncludeTo = true;
+        } else if (range.has_to_key_exclusive()) {
+            to->HasTo = true;
+            to->KeyTo = range.to_key_exclusive();
+            to->IncludeTo = false;
+        } else {
+            to->HasTo = false;
+        }
+
+        if (to->HasFrom && to->HasTo) {
+            if (!to->IncludeFrom && !to->IncludeTo && to->KeyFrom >= to->KeyTo) {
+                TString msg = TStringBuilder() << "KeyValue# " << TabletId
+                        << " Range.KeyFrom >= Range.KeyTo and both exclusive in " << cmd
+                        << " Marker# KV31";
+                return TConvertRangeResult{msg, true};
+            }
+            if (to->KeyFrom > to->KeyTo) {
+                TString msg = TStringBuilder() << "KeyValue# " << TabletId
+                        << " Range.KeyFrom > Range.KeyTo and both exclusive in " << cmd
+                        << " Marker# KV33";
+                return TConvertRangeResult{msg, true};
+            }
+        }
+
+        return {};
+    }
+
     template<typename Container, typename Iterator = typename Container::iterator>
     static std::pair<Iterator, Iterator> GetRange(const TKeyRange& range, Container& container) {
         auto first = !range.HasFrom ? container.begin()
diff --git a/ydb/core/keyvalue/keyvalue_storage_read_request.cpp b/ydb/core/keyvalue/keyvalue_storage_read_request.cpp
index d88ca3f1d1..3adab0a863 100644
--- a/ydb/core/keyvalue/keyvalue_storage_read_request.cpp
+++ b/ydb/core/keyvalue/keyvalue_storage_read_request.cpp
@@ -1,482 +1,482 @@
-#include "keyvalue_storage_read_request.h" 
-#include "keyvalue_const.h" 
- 
+#include "keyvalue_storage_read_request.h"
+#include "keyvalue_const.h"
+
 #include <ydb/core/util/stlog.h>
-#include <library/cpp/actors/protos/services_common.pb.h> 
- 
- 
-namespace NKikimr { 
-namespace NKeyValue { 
- 
-#define STLOG_WITH_ERROR_DESCRIPTION(VARIABLE, PRIO, COMP, MARKER, TEXT, ...) \ 
-    do { \ 
-        struct MARKER {}; \ 
-        VARIABLE = (TStringBuilder() << VARIABLE << Endl \ 
-                << ::NKikimr::NStLog::TMessage<MARKER>(__FILE__, __LINE__, #MARKER, TStringBuilder() << TEXT) \ 
-                        STLOG_PARAMS(__VA_ARGS__)); \ 
-        STLOG(PRIO, COMP, MARKER, TEXT, __VA_ARGS__); \ 
-    } while(false) \ 
-// STLOG_WITH_ERROR_DESCRIPTION 
- 
- 
-class TKeyValueStorageReadRequest : public TActorBootstrapped<TKeyValueStorageReadRequest> { 
-    struct TGetBatch { 
-        TStackVec<ui32, 1> ReadItemIndecies; 
-        ui32 GroupId; 
-        ui32 Cookie; 
-        TInstant SentTime; 
- 
-        TGetBatch(ui32 groupId, ui32 cookie) 
-            : GroupId(groupId) 
-            , Cookie(cookie) 
-        {} 
-    }; 
- 
-    struct TReadItemInfo { 
-        TIntermediate::TRead *Read; 
-        TIntermediate::TRead::TReadItem *ReadItem; 
-    }; 
- 
-    THolder<TIntermediate> IntermediateResult; 
-    const TTabletStorageInfo *TabletInfo; 
-    TStackVec<TGetBatch, 1> Batches; 
- 
-    ui32 ReceivedGetResults = 0; 
-    TString ErrorDescription; 
- 
-    TStackVec<TReadItemInfo, 1> ReadItems; 
- 
-public: 
-    static constexpr NKikimrServices::TActivity::EType ActorActivityType() { 
-        return NKikimrServices::TActivity::KEYVALUE_ACTOR; 
-    } 
- 
-    std::variant<TIntermediate::TRead, TIntermediate::TRangeRead>& GetCommand() const { 
-        return *IntermediateResult->ReadCommand; 
-    } 
- 
-    bool IsRead() const { 
-        return std::holds_alternative<TIntermediate::TRead>(GetCommand()); 
-    } 
- 
-    bool IsRangeRead() const { 
-        return std::holds_alternative<TIntermediate::TRangeRead>(GetCommand()); 
-    } 
- 
-    void AddRead(TIntermediate::TRead &read) { 
-        for (auto &readItem : read.ReadItems) { 
-            ReadItems.push_back({&read, &readItem}); 
-        } 
-    } 
- 
-    NKikimrBlobStorage::EGetHandleClass GetHandleClass() const { 
-        auto visitor = [&] (auto &request) { 
-            return request.HandleClass; 
-        }; 
-        return std::visit(visitor, GetCommand()); 
-    } 
- 
-    void Bootstrap() { 
-        if (IntermediateResult->Deadline != TInstant::Max()) { 
-            TInstant now = TActivationContext::Now(); 
-            if (IntermediateResult->Deadline <= now) { 
-                STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV313, 
-                        "Deadline reached before processing request.", 
-                        (KeyValue, TabletInfo->TabletID), 
-                        (Deadline, IntermediateResult->Deadline.MilliSeconds()), 
-                        (Now, now.MilliSeconds()), 
-                        (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()), 
-                        (EnqueuedAs, IntermediateResult->Stat.EnqueuedAs)); 
-                ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT); 
-                return; 
-            } 
- 
-            const TDuration timeout = IntermediateResult->Deadline - now; 
-            Schedule(timeout, new TEvents::TEvWakeup()); 
-        } 
- 
-        ui32 readCount = 0; 
-        auto addReadItems = [&](auto &request) { 
-            using Type = std::decay_t<decltype(request)>; 
-            if constexpr (std::is_same_v<Type, TIntermediate::TRead>) { 
-                AddRead(request); 
-                readCount++; 
-            } else { 
-                for (auto &read : request.Reads) { 
-                    AddRead(read); 
-                    readCount++; 
-                } 
-            } 
-        }; 
-        std::visit(addReadItems, GetCommand()); 
- 
-        if (ReadItems.empty()) { 
-            auto getStatus = [&](auto &request) { 
-                return request.Status; 
-            }; 
-            NKikimrProto::EReplyStatus status = std::visit(getStatus, GetCommand()); 
- 
-            STLOG(NLog::PRI_INFO, NKikimrServices::KEYVALUE, KV320, "Inline read request", 
-                    (KeyValue, TabletInfo->TabletID), 
-                    (Status, status)); 
-            bool isError = status != NKikimrProto::OK 
-                    && status != NKikimrProto::UNKNOWN 
-                    && status != NKikimrProto::NODATA 
-                    && status != NKikimrProto::OVERRUN; 
-            if (isError) { 
-                STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV321, 
-                    "Expected OK, UNKNOWN, NODATA or OVERRUN but given " << NKikimrProto::EReplyStatus_Name(status)); 
-                ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-            } else { 
-                STLOG(NLog::PRI_DEBUG, NKikimrServices::KEYVALUE, KV322, 
-                    "Expected OK or UNKNOWN and given " << NKikimrProto::EReplyStatus_Name(status) 
-                    << " readCount# " << readCount); 
-                NKikimrKeyValue::Statuses::ReplyStatus replyStatus = ConvertStatus(status); 
-                if (!readCount) { 
-                    replyStatus = NKikimrKeyValue::Statuses::RSTATUS_NO_DATA; 
-                } else if (status == NKikimrProto::UNKNOWN) { 
-                    replyStatus = NKikimrKeyValue::Statuses::RSTATUS_OK; 
-                } 
- 
-                SendResponseAndPassAway(replyStatus); 
-            } 
-        } 
- 
-        Become(&TThis::StateWait); 
-        SendGets(); 
-    } 
- 
-    void SendGets() { 
-        THashMap<ui32, ui32> mapFromGroupToBatch; 
- 
-        for (ui32 readItemIdx = 0; readItemIdx < ReadItems.size(); ++readItemIdx) { 
-            TIntermediate::TRead::TReadItem &readItem = *ReadItems[readItemIdx].ReadItem; 
-            TLogoBlobID &id = readItem.LogoBlobId; 
-            ui32 group = TabletInfo->GroupFor(id.Channel(), id.Generation()); 
- 
-            // INVALID GROUP 
-            if (group == Max<ui32>()) { 
-                STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV315, 
-                        "InternalError can't find correct group", 
-                        (KeyValue, TabletInfo->TabletID), 
-                        (Channel, id.Channel()), 
-                        (Generation, id.Generation())); 
-                ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-                return; 
-            } 
- 
-            auto it = mapFromGroupToBatch.find(group); 
-            if (it == mapFromGroupToBatch.end()) { 
-                it = mapFromGroupToBatch.emplace(group, Batches.size()).first; 
-                Batches.emplace_back(group, Batches.size()); 
-            } 
-            TGetBatch &batch = Batches[it->second]; 
-            batch.ReadItemIndecies.push_back(readItemIdx); 
-        } 
- 
-        NKikimrBlobStorage::EGetHandleClass handleClass = GetHandleClass(); 
- 
-        for (TGetBatch &batch : Batches) { 
-            TArrayHolder<TEvBlobStorage::TEvGet::TQuery> readQueries( 
-                    new TEvBlobStorage::TEvGet::TQuery[batch.ReadItemIndecies.size()]); 
-            for (ui32 readQueryIdx = 0; readQueryIdx < batch.ReadItemIndecies.size(); ++readQueryIdx) { 
-                ui32 readItemIdx = batch.ReadItemIndecies[readQueryIdx]; 
-                TIntermediate::TRead::TReadItem &readItem = *ReadItems[readItemIdx].ReadItem; 
-                readQueries[readQueryIdx].Set(readItem.LogoBlobId, readItem.BlobOffset, readItem.BlobSize); 
-                readItem.InFlight = true; 
-            } 
- 
-            std::unique_ptr<TEvBlobStorage::TEvGet> get = std::make_unique<TEvBlobStorage::TEvGet>( 
-                    readQueries, batch.ReadItemIndecies.size(), IntermediateResult->Deadline, handleClass, false); 
- 
-            SendToBSProxy(TActivationContext::AsActorContext(), batch.GroupId, get.release(), 
-                    batch.Cookie); 
-            batch.SentTime = TActivationContext::Now(); 
-        } 
-    } 
- 
-    void Handle(TEvBlobStorage::TEvGetResult::TPtr &ev) { 
-        TEvBlobStorage::TEvGetResult *result = ev->Get(); 
-        STLOG(NLog::PRI_INFO, NKikimrServices::KEYVALUE, KV20, "Received GetResult", 
-                (KeyValue, TabletInfo->TabletID), 
-                (GroupId, result->GroupId), 
-                (Status, result->Status), 
-                (ResponseSz, result->ResponseSz), 
-                (ErrorReason, result->ErrorReason), 
-                (ReadRequestCookie, IntermediateResult->Cookie)); 
- 
-        if (ev->Cookie >= Batches.size()) { 
-            STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV319, 
-                    "Received EvGetResult with an unexpected cookie.", 
-                    (KeyValue, TabletInfo->TabletID), 
-                    (Cookie, ev->Cookie), 
-                    (SentGets, Batches.size()), 
-                    (GroupId, result->GroupId), 
-                    (Status, result->Status), 
-                    (Deadline, IntermediateResult->Deadline.MilliSeconds()), 
-                    (Now, TActivationContext::Now().MilliSeconds()), 
-                    (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()), 
-                    (ErrorReason, result->ErrorReason)); 
-            ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-            return; 
-        } 
- 
-        TGetBatch &batch = Batches[ev->Cookie]; 
- 
-        if (result->GroupId != batch.GroupId) { 
-            STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV318, 
-                    "Received EvGetResult from an unexpected storage group.", 
-                    (KeyValue, TabletInfo->TabletID), 
-                    (GroupId, result->GroupId), 
-                    (ExpecetedGroupId, batch.GroupId), 
-                    (Status, result->Status), 
-                    (Deadline, IntermediateResult->Deadline.MilliSeconds()), 
-                    (Now, TActivationContext::Now().MilliSeconds()), 
-                    (SentAt, batch.SentTime), 
-                    (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()), 
-                    (ErrorReason, result->ErrorReason)); 
-            ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-            return; 
-        } 
- 
-        if (result->Status != NKikimrProto::OK) { 
-            STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV316, 
-                    "Unexpected EvGetResult.", 
-                    (KeyValue, TabletInfo->TabletID), 
-                    (Status, result->Status), 
-                    (Deadline, IntermediateResult->Deadline.MilliSeconds()), 
-                    (Now, TActivationContext::Now().MilliSeconds()), 
-                    (SentAt, batch.SentTime), 
-                    (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()), 
-                    (ErrorReason, result->ErrorReason)); 
-            ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-            return; 
-        } 
- 
- 
-        bool hasErrorResponses = false; 
-        for (ui32 readQueryIdx = 0; readQueryIdx < batch.ReadItemIndecies.size(); ++readQueryIdx) { 
-            ui32 readItemIdx = batch.ReadItemIndecies[readQueryIdx]; 
-            TEvBlobStorage::TEvGetResult::TResponse &response = ev->Get()->Responses[readQueryIdx]; 
-            TIntermediate::TRead &read = *ReadItems[readItemIdx].Read; 
-            TIntermediate::TRead::TReadItem &readItem = *ReadItems[readItemIdx].ReadItem; 
-            read.Status = response.Status; 
- 
-            if (response.Status == NKikimrProto::OK) { 
-                if (read.Value.size() != read.ValueSize) { 
-                    read.Value.resize(read.ValueSize); 
-                } 
-                Y_VERIFY_S(response.Buffer.size() == readItem.BlobSize, 
-                        "response.Buffer.size()# " << response.Buffer.size() 
-                        << " readItem.BlobSize# " << readItem.BlobSize); 
-                Y_VERIFY_S(readItem.ValueOffset + readItem.BlobSize <= read.ValueSize, 
-                        "readItem.ValueOffset# " << readItem.ValueOffset 
-                        << " readItem.BlobSize# " << readItem.BlobSize 
-                        << " read.ValueSize# " << read.ValueSize); 
-                memcpy(const_cast<char *>(read.Value.data()) + readItem.ValueOffset, response.Buffer.data(), response.Buffer.size()); 
-                IntermediateResult->Stat.GroupReadBytes[std::make_pair(response.Id.Channel(), batch.GroupId)] += response.Buffer.size(); 
-                // FIXME: count distinct blobs?" keyvalue_storage_request.cpp:279 
-                IntermediateResult->Stat.GroupReadIops[std::make_pair(response.Id.Channel(), batch.GroupId)] += 1; 
-            } else { 
-                STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV317, 
-                        "Unexpected EvGetResult.", 
-                        (KeyValue, TabletInfo->TabletID), 
-                        (Status, result->Status), 
-                        (ResponseStatus, response.Status), 
-                        (Deadline, IntermediateResult->Deadline.MilliSeconds()), 
-                        (Now, TActivationContext::Now().MilliSeconds()), 
-                        (SentAt, batch.SentTime), 
-                        (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()), 
-                        (ErrorReason, result->ErrorReason)); 
-                hasErrorResponses = true; 
-            } 
- 
-            Y_VERIFY(response.Status != NKikimrProto::UNKNOWN); 
-            readItem.Status = response.Status; 
-            readItem.InFlight = false; 
-        } 
-        if (hasErrorResponses) { 
-            ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-            return; 
-        } 
- 
-        ReceivedGetResults++; 
-        if (ReceivedGetResults == Batches.size()) { 
-            SendResponseAndPassAway(IntermediateResult->IsTruncated ? 
-                    NKikimrKeyValue::Statuses::RSTATUS_OVERRUN : 
-                    NKikimrKeyValue::Statuses::RSTATUS_OK); 
-        } 
-    } 
- 
-    void SendNotify(NKikimrKeyValue::Statuses::ReplyStatus status) { 
-        IntermediateResult->UpdateStat(); 
-        Send(IntermediateResult->KeyValueActorId, new TEvKeyValue::TEvNotify( 
-            IntermediateResult->RequestUid, 
-            IntermediateResult->CreatedAtGeneration, IntermediateResult->CreatedAtStep, 
-            IntermediateResult->Stat, status)); 
-    } 
- 
-    std::unique_ptr<TEvKeyValue::TEvReadResponse> CreateReadResponse(NKikimrKeyValue::Statuses::ReplyStatus status, 
-            const TString &errorDescription) 
-    { 
-        auto response = std::make_unique<TEvKeyValue::TEvReadResponse>(); 
-        response->Record.set_status(status); 
-        if (errorDescription) { 
-            response->Record.set_msg(errorDescription); 
-        } 
-        if (IntermediateResult->HasCookie) { 
-            response->Record.set_cookie(IntermediateResult->Cookie); 
-        } 
-        return response; 
-    } 
- 
-    std::unique_ptr<TEvKeyValue::TEvReadRangeResponse> CreateReadRangeResponse( 
-            NKikimrKeyValue::Statuses::ReplyStatus status, const TString &errorDescription) 
-    { 
-        auto response = std::make_unique<TEvKeyValue::TEvReadRangeResponse>(); 
-        response->Record.set_status(status); 
-        if (errorDescription) { 
-            response->Record.set_msg(errorDescription); 
-        } 
-        return response; 
-    } 
- 
-    std::unique_ptr<IEventBase> MakeErrorResponse(NKikimrKeyValue::Statuses::ReplyStatus status) { 
-        if (IsRead()) { 
-            return CreateReadResponse(status, ErrorDescription); 
-        } else { 
-            return CreateReadRangeResponse(status, ErrorDescription); 
-        } 
-    } 
- 
-    void ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::ReplyStatus status) { 
-        std::unique_ptr<IEventBase> response = MakeErrorResponse(status); 
-        Send(IntermediateResult->RespondTo, response.release()); 
-        IntermediateResult->IsReplied = true; 
-        SendNotify(status); 
-        PassAway(); 
-    } 
- 
-    TString MakeErrorMsg(const TString &msg) const { 
-        TStringBuilder builder; 
-        if (ErrorDescription) { 
-            builder << ErrorDescription << ';'; 
-        } 
-        if (msg) { 
-            builder << "Message# " << msg << ';'; 
-        } 
-        return builder; 
-    } 
- 
-    std::unique_ptr<TEvKeyValue::TEvReadResponse> MakeReadResponse(NKikimrKeyValue::Statuses::ReplyStatus status) { 
-        auto &cmd = GetCommand(); 
-        Y_VERIFY(std::holds_alternative<TIntermediate::TRead>(cmd)); 
-        TIntermediate::TRead &interRead = std::get<TIntermediate::TRead>(cmd); 
- 
-        TString errorMsg = MakeErrorMsg(interRead.Message); 
-        std::unique_ptr<TEvKeyValue::TEvReadResponse> response = CreateReadResponse(status, errorMsg); 
- 
-        response->Record.set_requested_key(interRead.Key); 
-        response->Record.set_requested_offset(interRead.Offset); 
-        response->Record.set_requested_size(interRead.RequestedSize); 
-        response->Record.set_value(interRead.Value); 
- 
-        return response; 
-    } 
- 
-    NKikimrKeyValue::Statuses::ReplyStatus ConvertStatus(NKikimrProto::EReplyStatus status) { 
-        if (status == NKikimrProto::OK) { 
-            return NKikimrKeyValue::Statuses::RSTATUS_OK; 
-        } else if (status == NKikimrProto::OVERRUN) { 
-            return NKikimrKeyValue::Statuses::RSTATUS_OVERRUN; 
-        } else if (status == NKikimrProto::NODATA) { 
-            return NKikimrKeyValue::Statuses::RSTATUS_NO_DATA; 
-        } else { 
-            return NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR; 
-        } 
-    } 
- 
-    std::unique_ptr<TEvKeyValue::TEvReadRangeResponse> MakeReadRangeResponse(NKikimrKeyValue::Statuses::ReplyStatus status) { 
-        auto &cmd = GetCommand(); 
-        Y_VERIFY(std::holds_alternative<TIntermediate::TRangeRead>(cmd)); 
-        TIntermediate::TRangeRead &interRange = std::get<TIntermediate::TRangeRead>(cmd); 
- 
-        TStringBuilder msgBuilder; 
-        if (ErrorDescription) { 
-            msgBuilder << ErrorDescription << ';'; 
-        } 
-        for (ui32 idx = 0; idx < interRange.Reads.size(); ++idx) { 
-            auto &interRead = interRange.Reads[idx]; 
-            if (interRead.Message) { 
-                msgBuilder << "Messages[" << idx << "]# " << interRead.Message << ';'; 
-            } 
-        } 
- 
-        std::unique_ptr<TEvKeyValue::TEvReadRangeResponse> response = CreateReadRangeResponse(status, msgBuilder); 
-        NKikimrKeyValue::ReadRangeResult &readRangeResult = response->Record; 
- 
-        for (auto &interRead : interRange.Reads) { 
-            auto *kvp = readRangeResult.add_pair(); 
-            kvp->set_key(interRead.Key); 
-            kvp->set_value(interRead.Value); 
-            kvp->set_value_size(interRead.ValueSize); 
-            kvp->set_creation_unix_time(interRead.CreationUnixTime); 
-            ui32 storageChannel = MainStorageChannelInPublicApi; 
-            if (interRead.StorageChannel == NKikimrClient::TKeyValueRequest::INLINE) { 
-                storageChannel = InlineStorageChannelInPublicApi; 
-            } else { 
-                storageChannel = interRead.StorageChannel + MainStorageChannelInPublicApi; 
-            } 
-            kvp->set_storage_channel(storageChannel); 
-            kvp->set_status(NKikimrKeyValue::Statuses::RSTATUS_OK); 
-        } 
-        readRangeResult.set_status(status); 
- 
-        return response; 
-    } 
- 
-    std::unique_ptr<IEventBase> MakeResponse(NKikimrKeyValue::Statuses::ReplyStatus status) { 
-        if (IsRead()) { 
-            return MakeReadResponse(status); 
-        } else { 
-            return MakeReadRangeResponse(status); 
-        } 
-    } 
- 
-    void SendResponseAndPassAway(NKikimrKeyValue::Statuses::ReplyStatus status = NKikimrKeyValue::Statuses::RSTATUS_OK) { 
-        STLOG(NLog::PRI_INFO, NKikimrServices::KEYVALUE, KV34, "Send respose", 
-                (KeyValue, TabletInfo->TabletID), 
-                (Status, NKikimrKeyValue::Statuses_ReplyStatus_Name(status)), 
-                (ReadRequestCookie, IntermediateResult->Cookie)); 
-        std::unique_ptr<IEventBase> response = MakeResponse(status); 
-        Send(IntermediateResult->RespondTo, response.release()); 
-        IntermediateResult->IsReplied = true; 
-        SendNotify(status); 
-        PassAway(); 
-    } 
- 
-    STATEFN(StateWait) { 
-        switch (ev->GetTypeRewrite()) { 
-            hFunc(TEvBlobStorage::TEvGetResult, Handle); 
-        default: 
-            Y_FAIL(); 
-        } 
-   } 
- 
-    TKeyValueStorageReadRequest(THolder<TIntermediate> &&intermediate, 
-            const TTabletStorageInfo *tabletInfo) 
-        : IntermediateResult(std::move(intermediate)) 
-        , TabletInfo(tabletInfo) 
-    {} 
-}; 
- 
- 
-IActor* CreateKeyValueStorageReadRequest(THolder<TIntermediate>&& intermediate, 
-        const TTabletStorageInfo *tabletInfo) 
-{ 
-    return new TKeyValueStorageReadRequest(std::move(intermediate), tabletInfo); 
-} 
- 
-} // NKeyValue 
- 
-} // NKikimr 
+#include <library/cpp/actors/protos/services_common.pb.h>
+
+
+namespace NKikimr {
+namespace NKeyValue {
+
+#define STLOG_WITH_ERROR_DESCRIPTION(VARIABLE, PRIO, COMP, MARKER, TEXT, ...) \
+    do { \
+        struct MARKER {}; \
+        VARIABLE = (TStringBuilder() << VARIABLE << Endl \
+                << ::NKikimr::NStLog::TMessage<MARKER>(__FILE__, __LINE__, #MARKER, TStringBuilder() << TEXT) \
+                        STLOG_PARAMS(__VA_ARGS__)); \
+        STLOG(PRIO, COMP, MARKER, TEXT, __VA_ARGS__); \
+    } while(false) \
+// STLOG_WITH_ERROR_DESCRIPTION
+
+
+class TKeyValueStorageReadRequest : public TActorBootstrapped<TKeyValueStorageReadRequest> {
+    struct TGetBatch {
+        TStackVec<ui32, 1> ReadItemIndecies;
+        ui32 GroupId;
+        ui32 Cookie;
+        TInstant SentTime;
+
+        TGetBatch(ui32 groupId, ui32 cookie)
+            : GroupId(groupId)
+            , Cookie(cookie)
+        {}
+    };
+
+    struct TReadItemInfo {
+        TIntermediate::TRead *Read;
+        TIntermediate::TRead::TReadItem *ReadItem;
+    };
+
+    THolder<TIntermediate> IntermediateResult;
+    const TTabletStorageInfo *TabletInfo;
+    TStackVec<TGetBatch, 1> Batches;
+
+    ui32 ReceivedGetResults = 0;
+    TString ErrorDescription;
+
+    TStackVec<TReadItemInfo, 1> ReadItems;
+
+public:
+    static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
+        return NKikimrServices::TActivity::KEYVALUE_ACTOR;
+    }
+
+    std::variant<TIntermediate::TRead, TIntermediate::TRangeRead>& GetCommand() const {
+        return *IntermediateResult->ReadCommand;
+    }
+
+    bool IsRead() const {
+        return std::holds_alternative<TIntermediate::TRead>(GetCommand());
+    }
+
+    bool IsRangeRead() const {
+        return std::holds_alternative<TIntermediate::TRangeRead>(GetCommand());
+    }
+
+    void AddRead(TIntermediate::TRead &read) {
+        for (auto &readItem : read.ReadItems) {
+            ReadItems.push_back({&read, &readItem});
+        }
+    }
+
+    NKikimrBlobStorage::EGetHandleClass GetHandleClass() const {
+        auto visitor = [&] (auto &request) {
+            return request.HandleClass;
+        };
+        return std::visit(visitor, GetCommand());
+    }
+
+    void Bootstrap() {
+        if (IntermediateResult->Deadline != TInstant::Max()) {
+            TInstant now = TActivationContext::Now();
+            if (IntermediateResult->Deadline <= now) {
+                STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV313,
+                        "Deadline reached before processing request.",
+                        (KeyValue, TabletInfo->TabletID),
+                        (Deadline, IntermediateResult->Deadline.MilliSeconds()),
+                        (Now, now.MilliSeconds()),
+                        (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()),
+                        (EnqueuedAs, IntermediateResult->Stat.EnqueuedAs));
+                ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT);
+                return;
+            }
+
+            const TDuration timeout = IntermediateResult->Deadline - now;
+            Schedule(timeout, new TEvents::TEvWakeup());
+        }
+
+        ui32 readCount = 0;
+        auto addReadItems = [&](auto &request) {
+            using Type = std::decay_t<decltype(request)>;
+            if constexpr (std::is_same_v<Type, TIntermediate::TRead>) {
+                AddRead(request);
+                readCount++;
+            } else {
+                for (auto &read : request.Reads) {
+                    AddRead(read);
+                    readCount++;
+                }
+            }
+        };
+        std::visit(addReadItems, GetCommand());
+
+        if (ReadItems.empty()) {
+            auto getStatus = [&](auto &request) {
+                return request.Status;
+            };
+            NKikimrProto::EReplyStatus status = std::visit(getStatus, GetCommand());
+
+            STLOG(NLog::PRI_INFO, NKikimrServices::KEYVALUE, KV320, "Inline read request",
+                    (KeyValue, TabletInfo->TabletID),
+                    (Status, status));
+            bool isError = status != NKikimrProto::OK
+                    && status != NKikimrProto::UNKNOWN
+                    && status != NKikimrProto::NODATA
+                    && status != NKikimrProto::OVERRUN;
+            if (isError) {
+                STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV321,
+                    "Expected OK, UNKNOWN, NODATA or OVERRUN but given " << NKikimrProto::EReplyStatus_Name(status));
+                ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+            } else {
+                STLOG(NLog::PRI_DEBUG, NKikimrServices::KEYVALUE, KV322,
+                    "Expected OK or UNKNOWN and given " << NKikimrProto::EReplyStatus_Name(status)
+                    << " readCount# " << readCount);
+                NKikimrKeyValue::Statuses::ReplyStatus replyStatus = ConvertStatus(status);
+                if (!readCount) {
+                    replyStatus = NKikimrKeyValue::Statuses::RSTATUS_NO_DATA;
+                } else if (status == NKikimrProto::UNKNOWN) {
+                    replyStatus = NKikimrKeyValue::Statuses::RSTATUS_OK;
+                }
+
+                SendResponseAndPassAway(replyStatus);
+            }
+        }
+
+        Become(&TThis::StateWait);
+        SendGets();
+    }
+
+    void SendGets() {
+        THashMap<ui32, ui32> mapFromGroupToBatch;
+
+        for (ui32 readItemIdx = 0; readItemIdx < ReadItems.size(); ++readItemIdx) {
+            TIntermediate::TRead::TReadItem &readItem = *ReadItems[readItemIdx].ReadItem;
+            TLogoBlobID &id = readItem.LogoBlobId;
+            ui32 group = TabletInfo->GroupFor(id.Channel(), id.Generation());
+
+            // INVALID GROUP
+            if (group == Max<ui32>()) {
+                STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV315,
+                        "InternalError can't find correct group",
+                        (KeyValue, TabletInfo->TabletID),
+                        (Channel, id.Channel()),
+                        (Generation, id.Generation()));
+                ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+                return;
+            }
+
+            auto it = mapFromGroupToBatch.find(group);
+            if (it == mapFromGroupToBatch.end()) {
+                it = mapFromGroupToBatch.emplace(group, Batches.size()).first;
+                Batches.emplace_back(group, Batches.size());
+            }
+            TGetBatch &batch = Batches[it->second];
+            batch.ReadItemIndecies.push_back(readItemIdx);
+        }
+
+        NKikimrBlobStorage::EGetHandleClass handleClass = GetHandleClass();
+
+        for (TGetBatch &batch : Batches) {
+            TArrayHolder<TEvBlobStorage::TEvGet::TQuery> readQueries(
+                    new TEvBlobStorage::TEvGet::TQuery[batch.ReadItemIndecies.size()]);
+            for (ui32 readQueryIdx = 0; readQueryIdx < batch.ReadItemIndecies.size(); ++readQueryIdx) {
+                ui32 readItemIdx = batch.ReadItemIndecies[readQueryIdx];
+                TIntermediate::TRead::TReadItem &readItem = *ReadItems[readItemIdx].ReadItem;
+                readQueries[readQueryIdx].Set(readItem.LogoBlobId, readItem.BlobOffset, readItem.BlobSize);
+                readItem.InFlight = true;
+            }
+
+            std::unique_ptr<TEvBlobStorage::TEvGet> get = std::make_unique<TEvBlobStorage::TEvGet>(
+                    readQueries, batch.ReadItemIndecies.size(), IntermediateResult->Deadline, handleClass, false);
+
+            SendToBSProxy(TActivationContext::AsActorContext(), batch.GroupId, get.release(),
+                    batch.Cookie);
+            batch.SentTime = TActivationContext::Now();
+        }
+    }
+
+    void Handle(TEvBlobStorage::TEvGetResult::TPtr &ev) {
+        TEvBlobStorage::TEvGetResult *result = ev->Get();
+        STLOG(NLog::PRI_INFO, NKikimrServices::KEYVALUE, KV20, "Received GetResult",
+                (KeyValue, TabletInfo->TabletID),
+                (GroupId, result->GroupId),
+                (Status, result->Status),
+                (ResponseSz, result->ResponseSz),
+                (ErrorReason, result->ErrorReason),
+                (ReadRequestCookie, IntermediateResult->Cookie));
+
+        if (ev->Cookie >= Batches.size()) {
+            STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV319,
+                    "Received EvGetResult with an unexpected cookie.",
+                    (KeyValue, TabletInfo->TabletID),
+                    (Cookie, ev->Cookie),
+                    (SentGets, Batches.size()),
+                    (GroupId, result->GroupId),
+                    (Status, result->Status),
+                    (Deadline, IntermediateResult->Deadline.MilliSeconds()),
+                    (Now, TActivationContext::Now().MilliSeconds()),
+                    (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()),
+                    (ErrorReason, result->ErrorReason));
+            ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+            return;
+        }
+
+        TGetBatch &batch = Batches[ev->Cookie];
+
+        if (result->GroupId != batch.GroupId) {
+            STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV318,
+                    "Received EvGetResult from an unexpected storage group.",
+                    (KeyValue, TabletInfo->TabletID),
+                    (GroupId, result->GroupId),
+                    (ExpecetedGroupId, batch.GroupId),
+                    (Status, result->Status),
+                    (Deadline, IntermediateResult->Deadline.MilliSeconds()),
+                    (Now, TActivationContext::Now().MilliSeconds()),
+                    (SentAt, batch.SentTime),
+                    (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()),
+                    (ErrorReason, result->ErrorReason));
+            ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+            return;
+        }
+
+        if (result->Status != NKikimrProto::OK) {
+            STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV316,
+                    "Unexpected EvGetResult.",
+                    (KeyValue, TabletInfo->TabletID),
+                    (Status, result->Status),
+                    (Deadline, IntermediateResult->Deadline.MilliSeconds()),
+                    (Now, TActivationContext::Now().MilliSeconds()),
+                    (SentAt, batch.SentTime),
+                    (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()),
+                    (ErrorReason, result->ErrorReason));
+            ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+            return;
+        }
+
+
+        bool hasErrorResponses = false;
+        for (ui32 readQueryIdx = 0; readQueryIdx < batch.ReadItemIndecies.size(); ++readQueryIdx) {
+            ui32 readItemIdx = batch.ReadItemIndecies[readQueryIdx];
+            TEvBlobStorage::TEvGetResult::TResponse &response = ev->Get()->Responses[readQueryIdx];
+            TIntermediate::TRead &read = *ReadItems[readItemIdx].Read;
+            TIntermediate::TRead::TReadItem &readItem = *ReadItems[readItemIdx].ReadItem;
+            read.Status = response.Status;
+
+            if (response.Status == NKikimrProto::OK) {
+                if (read.Value.size() != read.ValueSize) {
+                    read.Value.resize(read.ValueSize);
+                }
+                Y_VERIFY_S(response.Buffer.size() == readItem.BlobSize,
+                        "response.Buffer.size()# " << response.Buffer.size()
+                        << " readItem.BlobSize# " << readItem.BlobSize);
+                Y_VERIFY_S(readItem.ValueOffset + readItem.BlobSize <= read.ValueSize,
+                        "readItem.ValueOffset# " << readItem.ValueOffset
+                        << " readItem.BlobSize# " << readItem.BlobSize
+                        << " read.ValueSize# " << read.ValueSize);
+                memcpy(const_cast<char *>(read.Value.data()) + readItem.ValueOffset, response.Buffer.data(), response.Buffer.size());
+                IntermediateResult->Stat.GroupReadBytes[std::make_pair(response.Id.Channel(), batch.GroupId)] += response.Buffer.size();
+                // FIXME: count distinct blobs?" keyvalue_storage_request.cpp:279
+                IntermediateResult->Stat.GroupReadIops[std::make_pair(response.Id.Channel(), batch.GroupId)] += 1;
+            } else {
+                STLOG_WITH_ERROR_DESCRIPTION(ErrorDescription, NLog::PRI_ERROR, NKikimrServices::KEYVALUE, KV317,
+                        "Unexpected EvGetResult.",
+                        (KeyValue, TabletInfo->TabletID),
+                        (Status, result->Status),
+                        (ResponseStatus, response.Status),
+                        (Deadline, IntermediateResult->Deadline.MilliSeconds()),
+                        (Now, TActivationContext::Now().MilliSeconds()),
+                        (SentAt, batch.SentTime),
+                        (GotAt, IntermediateResult->Stat.IntermediateCreatedAt.MilliSeconds()),
+                        (ErrorReason, result->ErrorReason));
+                hasErrorResponses = true;
+            }
+
+            Y_VERIFY(response.Status != NKikimrProto::UNKNOWN);
+            readItem.Status = response.Status;
+            readItem.InFlight = false;
+        }
+        if (hasErrorResponses) {
+            ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+            return;
+        }
+
+        ReceivedGetResults++;
+        if (ReceivedGetResults == Batches.size()) {
+            SendResponseAndPassAway(IntermediateResult->IsTruncated ?
+                    NKikimrKeyValue::Statuses::RSTATUS_OVERRUN :
+                    NKikimrKeyValue::Statuses::RSTATUS_OK);
+        }
+    }
+
+    void SendNotify(NKikimrKeyValue::Statuses::ReplyStatus status) {
+        IntermediateResult->UpdateStat();
+        Send(IntermediateResult->KeyValueActorId, new TEvKeyValue::TEvNotify(
+            IntermediateResult->RequestUid,
+            IntermediateResult->CreatedAtGeneration, IntermediateResult->CreatedAtStep,
+            IntermediateResult->Stat, status));
+    }
+
+    std::unique_ptr<TEvKeyValue::TEvReadResponse> CreateReadResponse(NKikimrKeyValue::Statuses::ReplyStatus status,
+            const TString &errorDescription)
+    {
+        auto response = std::make_unique<TEvKeyValue::TEvReadResponse>();
+        response->Record.set_status(status);
+        if (errorDescription) {
+            response->Record.set_msg(errorDescription);
+        }
+        if (IntermediateResult->HasCookie) {
+            response->Record.set_cookie(IntermediateResult->Cookie);
+        }
+        return response;
+    }
+
+    std::unique_ptr<TEvKeyValue::TEvReadRangeResponse> CreateReadRangeResponse(
+            NKikimrKeyValue::Statuses::ReplyStatus status, const TString &errorDescription)
+    {
+        auto response = std::make_unique<TEvKeyValue::TEvReadRangeResponse>();
+        response->Record.set_status(status);
+        if (errorDescription) {
+            response->Record.set_msg(errorDescription);
+        }
+        return response;
+    }
+
+    std::unique_ptr<IEventBase> MakeErrorResponse(NKikimrKeyValue::Statuses::ReplyStatus status) {
+        if (IsRead()) {
+            return CreateReadResponse(status, ErrorDescription);
+        } else {
+            return CreateReadRangeResponse(status, ErrorDescription);
+        }
+    }
+
+    void ReplyErrorAndPassAway(NKikimrKeyValue::Statuses::ReplyStatus status) {
+        std::unique_ptr<IEventBase> response = MakeErrorResponse(status);
+        Send(IntermediateResult->RespondTo, response.release());
+        IntermediateResult->IsReplied = true;
+        SendNotify(status);
+        PassAway();
+    }
+
+    TString MakeErrorMsg(const TString &msg) const {
+        TStringBuilder builder;
+        if (ErrorDescription) {
+            builder << ErrorDescription << ';';
+        }
+        if (msg) {
+            builder << "Message# " << msg << ';';
+        }
+        return builder;
+    }
+
+    std::unique_ptr<TEvKeyValue::TEvReadResponse> MakeReadResponse(NKikimrKeyValue::Statuses::ReplyStatus status) {
+        auto &cmd = GetCommand();
+        Y_VERIFY(std::holds_alternative<TIntermediate::TRead>(cmd));
+        TIntermediate::TRead &interRead = std::get<TIntermediate::TRead>(cmd);
+
+        TString errorMsg = MakeErrorMsg(interRead.Message);
+        std::unique_ptr<TEvKeyValue::TEvReadResponse> response = CreateReadResponse(status, errorMsg);
+
+        response->Record.set_requested_key(interRead.Key);
+        response->Record.set_requested_offset(interRead.Offset);
+        response->Record.set_requested_size(interRead.RequestedSize);
+        response->Record.set_value(interRead.Value);
+
+        return response;
+    }
+
+    NKikimrKeyValue::Statuses::ReplyStatus ConvertStatus(NKikimrProto::EReplyStatus status) {
+        if (status == NKikimrProto::OK) {
+            return NKikimrKeyValue::Statuses::RSTATUS_OK;
+        } else if (status == NKikimrProto::OVERRUN) {
+            return NKikimrKeyValue::Statuses::RSTATUS_OVERRUN;
+        } else if (status == NKikimrProto::NODATA) {
+            return NKikimrKeyValue::Statuses::RSTATUS_NO_DATA;
+        } else {
+            return NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR;
+        }
+    }
+
+    std::unique_ptr<TEvKeyValue::TEvReadRangeResponse> MakeReadRangeResponse(NKikimrKeyValue::Statuses::ReplyStatus status) {
+        auto &cmd = GetCommand();
+        Y_VERIFY(std::holds_alternative<TIntermediate::TRangeRead>(cmd));
+        TIntermediate::TRangeRead &interRange = std::get<TIntermediate::TRangeRead>(cmd);
+
+        TStringBuilder msgBuilder;
+        if (ErrorDescription) {
+            msgBuilder << ErrorDescription << ';';
+        }
+        for (ui32 idx = 0; idx < interRange.Reads.size(); ++idx) {
+            auto &interRead = interRange.Reads[idx];
+            if (interRead.Message) {
+                msgBuilder << "Messages[" << idx << "]# " << interRead.Message << ';';
+            }
+        }
+
+        std::unique_ptr<TEvKeyValue::TEvReadRangeResponse> response = CreateReadRangeResponse(status, msgBuilder);
+        NKikimrKeyValue::ReadRangeResult &readRangeResult = response->Record;
+
+        for (auto &interRead : interRange.Reads) {
+            auto *kvp = readRangeResult.add_pair();
+            kvp->set_key(interRead.Key);
+            kvp->set_value(interRead.Value);
+            kvp->set_value_size(interRead.ValueSize);
+            kvp->set_creation_unix_time(interRead.CreationUnixTime);
+            ui32 storageChannel = MainStorageChannelInPublicApi;
+            if (interRead.StorageChannel == NKikimrClient::TKeyValueRequest::INLINE) {
+                storageChannel = InlineStorageChannelInPublicApi;
+            } else {
+                storageChannel = interRead.StorageChannel + MainStorageChannelInPublicApi;
+            }
+            kvp->set_storage_channel(storageChannel);
+            kvp->set_status(NKikimrKeyValue::Statuses::RSTATUS_OK);
+        }
+        readRangeResult.set_status(status);
+
+        return response;
+    }
+
+    std::unique_ptr<IEventBase> MakeResponse(NKikimrKeyValue::Statuses::ReplyStatus status) {
+        if (IsRead()) {
+            return MakeReadResponse(status);
+        } else {
+            return MakeReadRangeResponse(status);
+        }
+    }
+
+    void SendResponseAndPassAway(NKikimrKeyValue::Statuses::ReplyStatus status = NKikimrKeyValue::Statuses::RSTATUS_OK) {
+        STLOG(NLog::PRI_INFO, NKikimrServices::KEYVALUE, KV34, "Send respose",
+                (KeyValue, TabletInfo->TabletID),
+                (Status, NKikimrKeyValue::Statuses_ReplyStatus_Name(status)),
+                (ReadRequestCookie, IntermediateResult->Cookie));
+        std::unique_ptr<IEventBase> response = MakeResponse(status);
+        Send(IntermediateResult->RespondTo, response.release());
+        IntermediateResult->IsReplied = true;
+        SendNotify(status);
+        PassAway();
+    }
+
+    STATEFN(StateWait) {
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvBlobStorage::TEvGetResult, Handle);
+        default:
+            Y_FAIL();
+        }
+   }
+
+    TKeyValueStorageReadRequest(THolder<TIntermediate> &&intermediate,
+            const TTabletStorageInfo *tabletInfo)
+        : IntermediateResult(std::move(intermediate))
+        , TabletInfo(tabletInfo)
+    {}
+};
+
+
+IActor* CreateKeyValueStorageReadRequest(THolder<TIntermediate>&& intermediate,
+        const TTabletStorageInfo *tabletInfo)
+{
+    return new TKeyValueStorageReadRequest(std::move(intermediate), tabletInfo);
+}
+
+} // NKeyValue
+
+} // NKikimr
diff --git a/ydb/core/keyvalue/keyvalue_storage_read_request.h b/ydb/core/keyvalue/keyvalue_storage_read_request.h
index 2a4d225605..20e01dc5e9 100644
--- a/ydb/core/keyvalue/keyvalue_storage_read_request.h
+++ b/ydb/core/keyvalue/keyvalue_storage_read_request.h
@@ -1,12 +1,12 @@
-#pragma once 
-#include "defs.h" 
-#include "keyvalue_events.h" 
- 
-namespace NKikimr { 
-namespace NKeyValue { 
- 
-IActor* CreateKeyValueStorageReadRequest(THolder<TIntermediate>&& intermediate, 
-        const TTabletStorageInfo *tabletInfo); 
- 
-} // NKeyValue 
-} // NKikimr 
+#pragma once
+#include "defs.h"
+#include "keyvalue_events.h"
+
+namespace NKikimr {
+namespace NKeyValue {
+
+IActor* CreateKeyValueStorageReadRequest(THolder<TIntermediate>&& intermediate,
+        const TTabletStorageInfo *tabletInfo);
+
+} // NKeyValue
+} // NKikimr
diff --git a/ydb/core/keyvalue/keyvalue_storage_read_request_ut.cpp b/ydb/core/keyvalue/keyvalue_storage_read_request_ut.cpp
index 15ee4b0c9b..3d33155ad5 100644
--- a/ydb/core/keyvalue/keyvalue_storage_read_request_ut.cpp
+++ b/ydb/core/keyvalue/keyvalue_storage_read_request_ut.cpp
@@ -1,459 +1,459 @@
-#include "keyvalue_storage_read_request.h" 
- 
+#include "keyvalue_storage_read_request.h"
+
 #include <ydb/core/util/testactorsys.h>
- 
-#include <library/cpp/testing/unittest/registar.h> 
- 
- 
-namespace NKikimr { 
- 
-namespace NKeyValue { 
- 
-struct TBlobStorageMockState { 
-    struct TBlob { 
-        NKikimrProto::EReplyStatus Status = NKikimrProto::NODATA; 
-        TString Buffer; 
-    }; 
- 
-    struct TGroup { 
-        std::unordered_map<TLogoBlobID, TBlob, THash<TLogoBlobID>> Blobs; 
-        NKikimrProto::EReplyStatus Status = NKikimrProto::OK; 
-        std::optional<ui32> GroupId; 
-        std::optional<ui32> Cookie; 
-    }; 
- 
-    std::unordered_map<ui32, TGroup> Groups; 
- 
-    void Put(ui32 groupId, TLogoBlobID blobId, NKikimrProto::EReplyStatus status, const TString &buffer) { 
-        TBlob &blob = Groups[groupId].Blobs[blobId]; 
-        blob.Status = status; 
-        blob.Buffer = buffer; 
-    } 
- 
-    std::unique_ptr<TEvBlobStorage::TEvGetResult> MakeGetResult(ui32 groupId, TEvBlobStorage::TEvGet *get, 
-            std::function<const std::pair<NKikimrProto::EReplyStatus, const TString&>&(TLogoBlobID blobId)> getBlob) 
-    { 
-        TGroup &group = Groups[groupId]; 
-        if (group.GroupId) { 
-            groupId = *group.GroupId; 
-        } 
-        std::unique_ptr<TEvBlobStorage::TEvGetResult> getResult = std::make_unique<TEvBlobStorage::TEvGetResult>( 
-                group.Status, get->QuerySize, groupId); 
-        getResult->Responses.Reset(new TEvBlobStorage::TEvGetResult::TResponse[get->QuerySize]); 
-        for (ui32 queryIdx = 0; queryIdx < get->QuerySize; ++queryIdx) { 
-            auto &query = get->Queries[queryIdx]; 
-            auto &response = getResult->Responses[queryIdx]; 
-            response.Id = query.Id; 
-            response.Shift = query.Shift; 
-            response.RequestedSize = query.Size; 
-            std::tie(response.Status, response.Buffer) = getBlob(query.Id); 
-            if (response.Status == NKikimrProto::OK) { 
-                TString buffer = TString::Uninitialized(query.Size); 
-                memcpy(const_cast<char *>(buffer.data()), response.Buffer.data() + query.Shift, response.Buffer.size()); 
-                response.Buffer = buffer; 
-            } 
-        } 
-        return getResult; 
-    } 
- 
-    std::unique_ptr<TEvBlobStorage::TEvGetResult> OnGet(ui32 groupId, TEvBlobStorage::TEvGet *get) { 
-        TGroup &group = Groups[groupId]; 
- 
-        if (group.Status != NKikimrProto::OK) { 
-            TString str(""); 
-            return MakeGetResult(groupId, get, [&](...){ return std::make_pair(group.Status, str); }); 
-        } 
- 
-        return MakeGetResult(groupId, get, [&group](TLogoBlobID blobId) { 
-            TBlob &blob = group.Blobs[blobId]; 
-            return std::make_pair(blob.Status, blob.Buffer); 
-        }); 
-    } 
-}; 
- 
-struct TBlobStorageMock : TActorBootstrapped<TBlobStorageMock> { 
-    ui32 GroupId; 
-    TBlobStorageMockState *State; 
- 
-    TBlobStorageMock(ui32 groupId, TBlobStorageMockState *state) 
-        : GroupId(groupId) 
-        , State(state) 
-    {} 
- 
-    void Bootstrap() { 
-        Become(&TThis::Waiting); 
-    } 
- 
-    void Handle(TEvBlobStorage::TEvGet::TPtr &ev) { 
-        std::unique_ptr<TEvBlobStorage::TEvGetResult> result = State->OnGet(GroupId, ev->Get()); 
-        auto &group = State->Groups[GroupId]; 
-        ui64 cookie = ev->Cookie; 
-        if (group.Cookie) { 
-            cookie = *group.Cookie; 
-        } 
-        Send(ev->Sender, result.release(), ev->Flags, cookie, std::move(ev->TraceId)); 
-    } 
- 
-    STATEFN(Waiting) { 
-        switch (ev->GetTypeRewrite()) { 
-            hFunc(TEvBlobStorage::TEvGet, Handle); 
-        default: 
-            Y_FAIL(); 
-        } 
-   } 
-}; 
- 
- 
-struct TTestEnv { 
-    TBlobStorageMockState BlobStorageState; 
- 
-    std::unique_ptr<TTabletStorageInfo> TabletInfo; 
- 
-    std::unordered_map<ui64, TActorId> GroupActors; // [groupId, actorId] 
- 
-    TTestEnv() 
-        : TabletInfo(std::make_unique<TTabletStorageInfo>(1, TTabletTypes::KeyValue)) 
-    { 
-    } 
- 
-    void AddStorageGroup(TTestActorSystem &runtime, ui64 groupId) { 
-        if (GroupActors.count(groupId)) { 
-            return; 
-        } 
- 
-        TActorId groupActor = runtime.Register(new TBlobStorageMock(groupId, &BlobStorageState), 1); 
-        TActorId proxyId = MakeBlobStorageProxyID(groupId); 
-        runtime.RegisterService(proxyId, groupActor); 
-        GroupActors[groupId] = groupActor; 
-    } 
- 
-    void AddStorageGroups(TTestActorSystem &runtime, const std::vector<ui32> &groupIds) { 
-        for (ui32 groupId : groupIds) { 
-            AddStorageGroup(runtime, groupId); 
-        } 
-    } 
- 
-    void BindGroupsToChannel(TTestActorSystem &runtime, const std::vector<ui32> &groupIds) 
-    { 
-        AddStorageGroups(runtime, groupIds); 
-        for (ui32 channelIdx = 0; channelIdx < groupIds.size(); ++channelIdx) { 
-            TabletInfo->Channels.emplace_back(channelIdx, TErasureType::Erasure4Plus2Block); 
-            TabletInfo->Channels.back().History.emplace_back(1, groupIds[channelIdx]); 
-        } 
-    } 
-}; 
- 
- 
-struct TBuilderResult { 
-    THolder<TIntermediate> Intermediate; 
-    std::unordered_map<std::string, std::string> Values; 
-}; 
- 
- 
-struct TReadItem { 
-    std::string Value; 
-    TLogoBlobID BlobId; 
-    ui32 Offset; 
-    ui32 Size; 
- 
-    TReadItem(const std::string &value, TLogoBlobID blobId, ui32 offset, ui32 size) 
-        : Value(value) 
-        , BlobId(blobId) 
-        , Offset(offset) 
-        , Size(size) 
-    {} 
-}; 
- 
- 
-struct TReadRequestBuilder { 
-    std::string Key; 
-    std::vector<TReadItem> Items; 
- 
-    TReadRequestBuilder(const std::string &key) 
-        : Key(key) 
-    {} 
- 
-    TReadRequestBuilder& AddToEnd(const std::string &partOfValue, TLogoBlobID blobId, ui32 offset, ui32 size) { 
-        Items.emplace_back(partOfValue, blobId, offset, size); 
-        return *this; 
-    } 
- 
-    TBuilderResult Build(TActorId respondTo, TActorId keyValueActorId, ui32 channelGeneration = 1, ui32 channelStep = 1) 
-    { 
-        std::unique_ptr<TIntermediate> intermediate = std::make_unique<TIntermediate>(respondTo, keyValueActorId, 
-                channelGeneration, channelStep, TRequestType::ReadOnly); 
-        TStringBuilder valueBuilder; 
-        for (auto &[value, blobId, offset, size] : Items) { 
-                valueBuilder << value; 
-        } 
-        std::string value = valueBuilder; 
- 
- 
-        intermediate->ReadCommand = TIntermediate::TRead(TString(Key), value.size(), 0, 
-                NKikimrClient::TKeyValueRequest::MAIN); 
-        TIntermediate::TRead &read = std::get<TIntermediate::TRead>(*intermediate->ReadCommand); 
-        ui32 valueOffset = 0; 
-        for (auto &[value, blobId, offset, size] : Items) { 
-            read.ReadItems.emplace_back(blobId, offset, size, valueOffset); 
-            valueOffset += size; 
-        } 
-        TBuilderResult res; 
-        res.Values[Key] = value; 
-        res.Intermediate.Reset(intermediate.release()); 
-        return res; 
-    } 
-}; 
- 
- 
-struct TRangeReadRequestBuilder { 
-    std::map<std::string, std::vector<TReadItem>> Reads; 
-    ui64 CmdLimitBytes = Max<ui64>(); 
-    bool IncludeData = true; 
- 
-    TRangeReadRequestBuilder() 
-    {} 
- 
-    TRangeReadRequestBuilder& AddRead(const std::string &key, std::vector<TReadItem> &&items) { 
-        Reads[key] = std::move(items); 
-        return *this; 
-    } 
- 
-    TRangeReadRequestBuilder& AddRead(const std::string &key, const std::string &value, TLogoBlobID blobId) { 
-        Reads[key] = {TReadItem(value, blobId, 0, value.size())}; 
-        return *this; 
-    } 
- 
-    TBuilderResult Build(TActorId respondTo, TActorId keyValueActorId, ui32 channelGeneration = 1, ui32 channelStep = 1) 
-    { 
-        std::unique_ptr<TIntermediate> intermediate = std::make_unique<TIntermediate>(respondTo, keyValueActorId, 
-                channelGeneration, channelStep, TRequestType::ReadOnly); 
- 
-        TBuilderResult res; 
-        intermediate->ReadCommand = TIntermediate::TRangeRead(); 
-        auto &range = std::get<TIntermediate::TRangeRead>(*intermediate->ReadCommand); 
- 
-        for (auto &[key, items] : Reads) { 
-            TStringBuilder valueBuilder; 
-            for (auto &[value, blobId, offset, size] : items) { 
-                    valueBuilder << value; 
-            } 
-            std::string value = valueBuilder; 
- 
-            range.Reads.emplace_back(TString(key), value.size(), 0, NKikimrClient::TKeyValueRequest::MAIN); 
-            TIntermediate::TRead &read = range.Reads.back(); 
-            ui32 valueOffset = 0; 
-            for (auto &[value, blobId, offset, size] : items) { 
-                read.ReadItems.emplace_back(blobId, offset, size, valueOffset); 
-                valueOffset += size; 
-            } 
-            res.Values[key] = value; 
-        } 
- 
-        res.Intermediate.Reset(intermediate.release()); 
-        return res; 
-    } 
-}; 
- 
- 
-Y_UNIT_TEST_SUITE(KeyValueReadStorage) { 
- 
-void RunTest(TTestEnv &env, TReadRequestBuilder &builder, 
-        const std::vector<ui32> &groupIds, NKikimrKeyValue::Statuses::ReplyStatus status = NKikimrKeyValue::Statuses::RSTATUS_OK) { 
-    TTestActorSystem runtime(1); 
-    runtime.Start(); 
-    runtime.SetLogPriority(NKikimrServices::KEYVALUE, NLog::PRI_DEBUG); 
-    env.BindGroupsToChannel(runtime, groupIds); 
- 
-    TActorId edgeActor = runtime.AllocateEdgeActor(1); 
-    auto [intermediate, expectedValues] = builder.Build(edgeActor, edgeActor, 1, 1); 
- 
-    runtime.Register(CreateKeyValueStorageReadRequest(std::move(intermediate), env.TabletInfo.get()), 1); 
- 
-    std::unique_ptr<IEventHandle> ev = runtime.WaitForEdgeActorEvent({edgeActor}); 
-    UNIT_ASSERT(ev->Type == TEvKeyValue::EvReadResponse); 
-    TEvKeyValue::TEvReadResponse *response = ev->Get<TEvKeyValue::TEvReadResponse>(); 
-    NKikimrKeyValue::ReadResult &record = response->Record; 
- 
-    if (status == NKikimrKeyValue::Statuses::RSTATUS_OK) { 
-        UNIT_ASSERT_C(record.status() == NKikimrKeyValue::Statuses::RSTATUS_OK, "Expected# " << NKikimrKeyValue::Statuses::ReplyStatus_Name(status) 
-                << " Received# " <<  NKikimrKeyValue::Statuses::ReplyStatus_Name(record.status()) 
-                << " Message# " << record.msg()); 
-        UNIT_ASSERT_VALUES_EQUAL(record.value(), expectedValues[record.requested_key()]); 
-    } else { 
-        UNIT_ASSERT_C(record.status() == status, "Expected# " << NKikimrKeyValue::Statuses::ReplyStatus_Name(status) 
-                << " received# " <<  NKikimrKeyValue::Statuses::ReplyStatus_Name(record.status()) 
-                << " Message# " << record.msg()); 
-    } 
- 
-    runtime.Stop(); 
-} 
- 
-Y_UNIT_TEST(ReadOk) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TReadRequestBuilder builder("a"); 
-    TLogoBlobID id(1, 2, 3, 2, 1, 0); 
-    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b"); 
-    builder.AddToEnd("b", id, 0, 1); 
- 
-    RunTest(env, builder, groupIds); 
-} 
- 
-Y_UNIT_TEST(ReadWithTwoPartsOk) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TReadRequestBuilder builder("a"); 
-    TLogoBlobID id1(1, 2, 3, 2, 1, 0); 
-    env.BlobStorageState.Put(groupIds[2], id1, NKikimrProto::OK, "b"); 
-    builder.AddToEnd("b", id1, 0, 1); 
- 
-    TLogoBlobID id2(1, 2, 3, 2, 1, 1); 
-    env.BlobStorageState.Put(groupIds[2], id2, NKikimrProto::OK, "c"); 
-    builder.AddToEnd("c", id2, 0, 1); 
- 
-    RunTest(env, builder, groupIds); 
-} 
- 
-Y_UNIT_TEST(ReadNotWholeBlobOk) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TReadRequestBuilder builder("a"); 
-    TLogoBlobID id(1, 2, 3, 2, 3, 0); 
-    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "abc"); 
-    builder.AddToEnd("b", id, 1, 1); 
- 
-    RunTest(env, builder, groupIds); 
-} 
- 
-Y_UNIT_TEST(ReadError) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TReadRequestBuilder builder("a"); 
-    TLogoBlobID id(1, 2, 3, 2, 1, 0); 
-    env.BlobStorageState.Groups[groupIds[2]].Status = NKikimrProto::ERROR; 
-    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b"); 
-    builder.AddToEnd("b", id, 0, 1); 
- 
-    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-} 
- 
-Y_UNIT_TEST(ReadOneItemError) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TReadRequestBuilder builder("a"); 
-    TLogoBlobID id(1, 2, 3, 2, 1, 0); 
-    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::ERROR, "b"); 
-    builder.AddToEnd("b", id, 0, 1); 
- 
-    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-} 
- 
-Y_UNIT_TEST(ReadErrorWithWrongGroupId) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TReadRequestBuilder builder("a"); 
-    TLogoBlobID id(1, 2, 3, 2, 1, 0); 
-    env.BlobStorageState.Groups[groupIds[2]].GroupId = groupIds[1]; 
-    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b"); 
-    builder.AddToEnd("b", id, 0, 1); 
- 
-    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-} 
- 
-Y_UNIT_TEST(ReadErrorWithUncorrectCookie) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TReadRequestBuilder builder("a"); 
-    TLogoBlobID id(1, 2, 3, 2, 1, 0); 
-    env.BlobStorageState.Groups[groupIds[2]].Cookie = 1000; 
-    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b"); 
-    builder.AddToEnd("b", id, 0, 1); 
- 
-    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR); 
-} 
- 
- 
-void RunTest(TTestEnv &env, TRangeReadRequestBuilder &builder, const std::vector<ui32> &groupIds, 
-        NKikimrKeyValue::Statuses::ReplyStatus status = NKikimrKeyValue::Statuses::RSTATUS_OK) 
-{ 
-    TTestActorSystem runtime(1); 
-    runtime.Start(); 
-    runtime.SetLogPriority(NKikimrServices::KEYVALUE, NLog::PRI_DEBUG); 
-    env.BindGroupsToChannel(runtime, groupIds); 
- 
-    TActorId edgeActor = runtime.AllocateEdgeActor(1); 
-    auto [intermediate, expectedValues] = builder.Build(edgeActor, edgeActor, 1, 1); 
- 
-    runtime.Register(CreateKeyValueStorageReadRequest(std::move(intermediate), env.TabletInfo.get()), 1); 
- 
-    std::unique_ptr<IEventHandle> ev = runtime.WaitForEdgeActorEvent({edgeActor}); 
-    UNIT_ASSERT(ev->Type == TEvKeyValue::EvReadRangeResponse); 
-    TEvKeyValue::TEvReadRangeResponse *response = ev->Get<TEvKeyValue::TEvReadRangeResponse>(); 
-    NKikimrKeyValue::ReadRangeResult &record = response->Record; 
- 
-    if (status == NKikimrKeyValue::Statuses::RSTATUS_OK) { 
-        UNIT_ASSERT_C(record.status() == NKikimrKeyValue::Statuses::RSTATUS_OK, 
-                "Expected# " << NKikimrKeyValue::Statuses::ReplyStatus_Name(status) 
-                << " Received# " <<  NKikimrKeyValue::Statuses::ReplyStatus_Name(record.status()) 
-                << " Message# " << record.msg()); 
-        for (auto &kvp : record.pair()) { 
-            UNIT_ASSERT_VALUES_EQUAL(kvp.value(), expectedValues[kvp.key()]); 
-        } 
-    } else { 
-        UNIT_ASSERT_C(record.status() == status, 
-                "Expected# " << NKikimrKeyValue::Statuses::ReplyStatus_Name(status) 
-                << " received# " <<  NKikimrKeyValue::Statuses::ReplyStatus_Name(record.status()) 
-                << " Message# " << record.msg()); 
-    } 
- 
-    runtime.Stop(); 
-} 
- 
-Y_UNIT_TEST(ReadRangeOk1Key) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TRangeReadRequestBuilder builder; 
-    TLogoBlobID id(1, 2, 3, 2, 1, 0); 
-    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b"); 
-    builder.AddRead("key", "b", id); 
- 
-    RunTest(env, builder, groupIds); 
-} 
- 
-Y_UNIT_TEST(ReadRangeOk) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TRangeReadRequestBuilder builder; 
-    TLogoBlobID id1(1, 2, 3, 2, 1, 0); 
-    env.BlobStorageState.Put(groupIds[2], id1, NKikimrProto::OK, "b"); 
-    builder.AddRead("key", "b", id1); 
-    TLogoBlobID id2(1, 2, 4, 2, 1, 0); 
-    env.BlobStorageState.Put(groupIds[2], id2, NKikimrProto::OK, "c"); 
-    builder.AddRead("key2", "c", id2); 
- 
-    RunTest(env, builder, groupIds); 
-} 
- 
- 
-Y_UNIT_TEST(ReadRangeNoData) { 
-    TTestEnv env; 
-    std::vector<ui32> groupIds = {1, 2, 3}; 
- 
-    TRangeReadRequestBuilder builder; 
- 
-    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_NO_DATA); 
-} 
- 
-} // Y_UNIT_TEST_SUITE(KeyValueReadStorage) 
- 
-} // NKeyValue 
-} // NKikimr 
+
+#include <library/cpp/testing/unittest/registar.h>
+
+
+namespace NKikimr {
+
+namespace NKeyValue {
+
+struct TBlobStorageMockState {
+    struct TBlob {
+        NKikimrProto::EReplyStatus Status = NKikimrProto::NODATA;
+        TString Buffer;
+    };
+
+    struct TGroup {
+        std::unordered_map<TLogoBlobID, TBlob, THash<TLogoBlobID>> Blobs;
+        NKikimrProto::EReplyStatus Status = NKikimrProto::OK;
+        std::optional<ui32> GroupId;
+        std::optional<ui32> Cookie;
+    };
+
+    std::unordered_map<ui32, TGroup> Groups;
+
+    void Put(ui32 groupId, TLogoBlobID blobId, NKikimrProto::EReplyStatus status, const TString &buffer) {
+        TBlob &blob = Groups[groupId].Blobs[blobId];
+        blob.Status = status;
+        blob.Buffer = buffer;
+    }
+
+    std::unique_ptr<TEvBlobStorage::TEvGetResult> MakeGetResult(ui32 groupId, TEvBlobStorage::TEvGet *get,
+            std::function<const std::pair<NKikimrProto::EReplyStatus, const TString&>&(TLogoBlobID blobId)> getBlob)
+    {
+        TGroup &group = Groups[groupId];
+        if (group.GroupId) {
+            groupId = *group.GroupId;
+        }
+        std::unique_ptr<TEvBlobStorage::TEvGetResult> getResult = std::make_unique<TEvBlobStorage::TEvGetResult>(
+                group.Status, get->QuerySize, groupId);
+        getResult->Responses.Reset(new TEvBlobStorage::TEvGetResult::TResponse[get->QuerySize]);
+        for (ui32 queryIdx = 0; queryIdx < get->QuerySize; ++queryIdx) {
+            auto &query = get->Queries[queryIdx];
+            auto &response = getResult->Responses[queryIdx];
+            response.Id = query.Id;
+            response.Shift = query.Shift;
+            response.RequestedSize = query.Size;
+            std::tie(response.Status, response.Buffer) = getBlob(query.Id);
+            if (response.Status == NKikimrProto::OK) {
+                TString buffer = TString::Uninitialized(query.Size);
+                memcpy(const_cast<char *>(buffer.data()), response.Buffer.data() + query.Shift, response.Buffer.size());
+                response.Buffer = buffer;
+            }
+        }
+        return getResult;
+    }
+
+    std::unique_ptr<TEvBlobStorage::TEvGetResult> OnGet(ui32 groupId, TEvBlobStorage::TEvGet *get) {
+        TGroup &group = Groups[groupId];
+
+        if (group.Status != NKikimrProto::OK) {
+            TString str("");
+            return MakeGetResult(groupId, get, [&](...){ return std::make_pair(group.Status, str); });
+        }
+
+        return MakeGetResult(groupId, get, [&group](TLogoBlobID blobId) {
+            TBlob &blob = group.Blobs[blobId];
+            return std::make_pair(blob.Status, blob.Buffer);
+        });
+    }
+};
+
+struct TBlobStorageMock : TActorBootstrapped<TBlobStorageMock> {
+    ui32 GroupId;
+    TBlobStorageMockState *State;
+
+    TBlobStorageMock(ui32 groupId, TBlobStorageMockState *state)
+        : GroupId(groupId)
+        , State(state)
+    {}
+
+    void Bootstrap() {
+        Become(&TThis::Waiting);
+    }
+
+    void Handle(TEvBlobStorage::TEvGet::TPtr &ev) {
+        std::unique_ptr<TEvBlobStorage::TEvGetResult> result = State->OnGet(GroupId, ev->Get());
+        auto &group = State->Groups[GroupId];
+        ui64 cookie = ev->Cookie;
+        if (group.Cookie) {
+            cookie = *group.Cookie;
+        }
+        Send(ev->Sender, result.release(), ev->Flags, cookie, std::move(ev->TraceId));
+    }
+
+    STATEFN(Waiting) {
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvBlobStorage::TEvGet, Handle);
+        default:
+            Y_FAIL();
+        }
+   }
+};
+
+
+struct TTestEnv {
+    TBlobStorageMockState BlobStorageState;
+
+    std::unique_ptr<TTabletStorageInfo> TabletInfo;
+
+    std::unordered_map<ui64, TActorId> GroupActors; // [groupId, actorId]
+
+    TTestEnv()
+        : TabletInfo(std::make_unique<TTabletStorageInfo>(1, TTabletTypes::KeyValue))
+    {
+    }
+
+    void AddStorageGroup(TTestActorSystem &runtime, ui64 groupId) {
+        if (GroupActors.count(groupId)) {
+            return;
+        }
+
+        TActorId groupActor = runtime.Register(new TBlobStorageMock(groupId, &BlobStorageState), 1);
+        TActorId proxyId = MakeBlobStorageProxyID(groupId);
+        runtime.RegisterService(proxyId, groupActor);
+        GroupActors[groupId] = groupActor;
+    }
+
+    void AddStorageGroups(TTestActorSystem &runtime, const std::vector<ui32> &groupIds) {
+        for (ui32 groupId : groupIds) {
+            AddStorageGroup(runtime, groupId);
+        }
+    }
+
+    void BindGroupsToChannel(TTestActorSystem &runtime, const std::vector<ui32> &groupIds)
+    {
+        AddStorageGroups(runtime, groupIds);
+        for (ui32 channelIdx = 0; channelIdx < groupIds.size(); ++channelIdx) {
+            TabletInfo->Channels.emplace_back(channelIdx, TErasureType::Erasure4Plus2Block);
+            TabletInfo->Channels.back().History.emplace_back(1, groupIds[channelIdx]);
+        }
+    }
+};
+
+
+struct TBuilderResult {
+    THolder<TIntermediate> Intermediate;
+    std::unordered_map<std::string, std::string> Values;
+};
+
+
+struct TReadItem {
+    std::string Value;
+    TLogoBlobID BlobId;
+    ui32 Offset;
+    ui32 Size;
+
+    TReadItem(const std::string &value, TLogoBlobID blobId, ui32 offset, ui32 size)
+        : Value(value)
+        , BlobId(blobId)
+        , Offset(offset)
+        , Size(size)
+    {}
+};
+
+
+struct TReadRequestBuilder {
+    std::string Key;
+    std::vector<TReadItem> Items;
+
+    TReadRequestBuilder(const std::string &key)
+        : Key(key)
+    {}
+
+    TReadRequestBuilder& AddToEnd(const std::string &partOfValue, TLogoBlobID blobId, ui32 offset, ui32 size) {
+        Items.emplace_back(partOfValue, blobId, offset, size);
+        return *this;
+    }
+
+    TBuilderResult Build(TActorId respondTo, TActorId keyValueActorId, ui32 channelGeneration = 1, ui32 channelStep = 1)
+    {
+        std::unique_ptr<TIntermediate> intermediate = std::make_unique<TIntermediate>(respondTo, keyValueActorId,
+                channelGeneration, channelStep, TRequestType::ReadOnly);
+        TStringBuilder valueBuilder;
+        for (auto &[value, blobId, offset, size] : Items) {
+                valueBuilder << value;
+        }
+        std::string value = valueBuilder;
+
+
+        intermediate->ReadCommand = TIntermediate::TRead(TString(Key), value.size(), 0,
+                NKikimrClient::TKeyValueRequest::MAIN);
+        TIntermediate::TRead &read = std::get<TIntermediate::TRead>(*intermediate->ReadCommand);
+        ui32 valueOffset = 0;
+        for (auto &[value, blobId, offset, size] : Items) {
+            read.ReadItems.emplace_back(blobId, offset, size, valueOffset);
+            valueOffset += size;
+        }
+        TBuilderResult res;
+        res.Values[Key] = value;
+        res.Intermediate.Reset(intermediate.release());
+        return res;
+    }
+};
+
+
+struct TRangeReadRequestBuilder {
+    std::map<std::string, std::vector<TReadItem>> Reads;
+    ui64 CmdLimitBytes = Max<ui64>();
+    bool IncludeData = true;
+
+    TRangeReadRequestBuilder()
+    {}
+
+    TRangeReadRequestBuilder& AddRead(const std::string &key, std::vector<TReadItem> &&items) {
+        Reads[key] = std::move(items);
+        return *this;
+    }
+
+    TRangeReadRequestBuilder& AddRead(const std::string &key, const std::string &value, TLogoBlobID blobId) {
+        Reads[key] = {TReadItem(value, blobId, 0, value.size())};
+        return *this;
+    }
+
+    TBuilderResult Build(TActorId respondTo, TActorId keyValueActorId, ui32 channelGeneration = 1, ui32 channelStep = 1)
+    {
+        std::unique_ptr<TIntermediate> intermediate = std::make_unique<TIntermediate>(respondTo, keyValueActorId,
+                channelGeneration, channelStep, TRequestType::ReadOnly);
+
+        TBuilderResult res;
+        intermediate->ReadCommand = TIntermediate::TRangeRead();
+        auto &range = std::get<TIntermediate::TRangeRead>(*intermediate->ReadCommand);
+
+        for (auto &[key, items] : Reads) {
+            TStringBuilder valueBuilder;
+            for (auto &[value, blobId, offset, size] : items) {
+                    valueBuilder << value;
+            }
+            std::string value = valueBuilder;
+
+            range.Reads.emplace_back(TString(key), value.size(), 0, NKikimrClient::TKeyValueRequest::MAIN);
+            TIntermediate::TRead &read = range.Reads.back();
+            ui32 valueOffset = 0;
+            for (auto &[value, blobId, offset, size] : items) {
+                read.ReadItems.emplace_back(blobId, offset, size, valueOffset);
+                valueOffset += size;
+            }
+            res.Values[key] = value;
+        }
+
+        res.Intermediate.Reset(intermediate.release());
+        return res;
+    }
+};
+
+
+Y_UNIT_TEST_SUITE(KeyValueReadStorage) {
+
+void RunTest(TTestEnv &env, TReadRequestBuilder &builder,
+        const std::vector<ui32> &groupIds, NKikimrKeyValue::Statuses::ReplyStatus status = NKikimrKeyValue::Statuses::RSTATUS_OK) {
+    TTestActorSystem runtime(1);
+    runtime.Start();
+    runtime.SetLogPriority(NKikimrServices::KEYVALUE, NLog::PRI_DEBUG);
+    env.BindGroupsToChannel(runtime, groupIds);
+
+    TActorId edgeActor = runtime.AllocateEdgeActor(1);
+    auto [intermediate, expectedValues] = builder.Build(edgeActor, edgeActor, 1, 1);
+
+    runtime.Register(CreateKeyValueStorageReadRequest(std::move(intermediate), env.TabletInfo.get()), 1);
+
+    std::unique_ptr<IEventHandle> ev = runtime.WaitForEdgeActorEvent({edgeActor});
+    UNIT_ASSERT(ev->Type == TEvKeyValue::EvReadResponse);
+    TEvKeyValue::TEvReadResponse *response = ev->Get<TEvKeyValue::TEvReadResponse>();
+    NKikimrKeyValue::ReadResult &record = response->Record;
+
+    if (status == NKikimrKeyValue::Statuses::RSTATUS_OK) {
+        UNIT_ASSERT_C(record.status() == NKikimrKeyValue::Statuses::RSTATUS_OK, "Expected# " << NKikimrKeyValue::Statuses::ReplyStatus_Name(status)
+                << " Received# " <<  NKikimrKeyValue::Statuses::ReplyStatus_Name(record.status())
+                << " Message# " << record.msg());
+        UNIT_ASSERT_VALUES_EQUAL(record.value(), expectedValues[record.requested_key()]);
+    } else {
+        UNIT_ASSERT_C(record.status() == status, "Expected# " << NKikimrKeyValue::Statuses::ReplyStatus_Name(status)
+                << " received# " <<  NKikimrKeyValue::Statuses::ReplyStatus_Name(record.status())
+                << " Message# " << record.msg());
+    }
+
+    runtime.Stop();
+}
+
+Y_UNIT_TEST(ReadOk) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TReadRequestBuilder builder("a");
+    TLogoBlobID id(1, 2, 3, 2, 1, 0);
+    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b");
+    builder.AddToEnd("b", id, 0, 1);
+
+    RunTest(env, builder, groupIds);
+}
+
+Y_UNIT_TEST(ReadWithTwoPartsOk) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TReadRequestBuilder builder("a");
+    TLogoBlobID id1(1, 2, 3, 2, 1, 0);
+    env.BlobStorageState.Put(groupIds[2], id1, NKikimrProto::OK, "b");
+    builder.AddToEnd("b", id1, 0, 1);
+
+    TLogoBlobID id2(1, 2, 3, 2, 1, 1);
+    env.BlobStorageState.Put(groupIds[2], id2, NKikimrProto::OK, "c");
+    builder.AddToEnd("c", id2, 0, 1);
+
+    RunTest(env, builder, groupIds);
+}
+
+Y_UNIT_TEST(ReadNotWholeBlobOk) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TReadRequestBuilder builder("a");
+    TLogoBlobID id(1, 2, 3, 2, 3, 0);
+    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "abc");
+    builder.AddToEnd("b", id, 1, 1);
+
+    RunTest(env, builder, groupIds);
+}
+
+Y_UNIT_TEST(ReadError) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TReadRequestBuilder builder("a");
+    TLogoBlobID id(1, 2, 3, 2, 1, 0);
+    env.BlobStorageState.Groups[groupIds[2]].Status = NKikimrProto::ERROR;
+    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b");
+    builder.AddToEnd("b", id, 0, 1);
+
+    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+}
+
+Y_UNIT_TEST(ReadOneItemError) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TReadRequestBuilder builder("a");
+    TLogoBlobID id(1, 2, 3, 2, 1, 0);
+    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::ERROR, "b");
+    builder.AddToEnd("b", id, 0, 1);
+
+    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+}
+
+Y_UNIT_TEST(ReadErrorWithWrongGroupId) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TReadRequestBuilder builder("a");
+    TLogoBlobID id(1, 2, 3, 2, 1, 0);
+    env.BlobStorageState.Groups[groupIds[2]].GroupId = groupIds[1];
+    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b");
+    builder.AddToEnd("b", id, 0, 1);
+
+    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+}
+
+Y_UNIT_TEST(ReadErrorWithUncorrectCookie) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TReadRequestBuilder builder("a");
+    TLogoBlobID id(1, 2, 3, 2, 1, 0);
+    env.BlobStorageState.Groups[groupIds[2]].Cookie = 1000;
+    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b");
+    builder.AddToEnd("b", id, 0, 1);
+
+    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR);
+}
+
+
+void RunTest(TTestEnv &env, TRangeReadRequestBuilder &builder, const std::vector<ui32> &groupIds,
+        NKikimrKeyValue::Statuses::ReplyStatus status = NKikimrKeyValue::Statuses::RSTATUS_OK)
+{
+    TTestActorSystem runtime(1);
+    runtime.Start();
+    runtime.SetLogPriority(NKikimrServices::KEYVALUE, NLog::PRI_DEBUG);
+    env.BindGroupsToChannel(runtime, groupIds);
+
+    TActorId edgeActor = runtime.AllocateEdgeActor(1);
+    auto [intermediate, expectedValues] = builder.Build(edgeActor, edgeActor, 1, 1);
+
+    runtime.Register(CreateKeyValueStorageReadRequest(std::move(intermediate), env.TabletInfo.get()), 1);
+
+    std::unique_ptr<IEventHandle> ev = runtime.WaitForEdgeActorEvent({edgeActor});
+    UNIT_ASSERT(ev->Type == TEvKeyValue::EvReadRangeResponse);
+    TEvKeyValue::TEvReadRangeResponse *response = ev->Get<TEvKeyValue::TEvReadRangeResponse>();
+    NKikimrKeyValue::ReadRangeResult &record = response->Record;
+
+    if (status == NKikimrKeyValue::Statuses::RSTATUS_OK) {
+        UNIT_ASSERT_C(record.status() == NKikimrKeyValue::Statuses::RSTATUS_OK,
+                "Expected# " << NKikimrKeyValue::Statuses::ReplyStatus_Name(status)
+                << " Received# " <<  NKikimrKeyValue::Statuses::ReplyStatus_Name(record.status())
+                << " Message# " << record.msg());
+        for (auto &kvp : record.pair()) {
+            UNIT_ASSERT_VALUES_EQUAL(kvp.value(), expectedValues[kvp.key()]);
+        }
+    } else {
+        UNIT_ASSERT_C(record.status() == status,
+                "Expected# " << NKikimrKeyValue::Statuses::ReplyStatus_Name(status)
+                << " received# " <<  NKikimrKeyValue::Statuses::ReplyStatus_Name(record.status())
+                << " Message# " << record.msg());
+    }
+
+    runtime.Stop();
+}
+
+Y_UNIT_TEST(ReadRangeOk1Key) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TRangeReadRequestBuilder builder;
+    TLogoBlobID id(1, 2, 3, 2, 1, 0);
+    env.BlobStorageState.Put(groupIds[2], id, NKikimrProto::OK, "b");
+    builder.AddRead("key", "b", id);
+
+    RunTest(env, builder, groupIds);
+}
+
+Y_UNIT_TEST(ReadRangeOk) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TRangeReadRequestBuilder builder;
+    TLogoBlobID id1(1, 2, 3, 2, 1, 0);
+    env.BlobStorageState.Put(groupIds[2], id1, NKikimrProto::OK, "b");
+    builder.AddRead("key", "b", id1);
+    TLogoBlobID id2(1, 2, 4, 2, 1, 0);
+    env.BlobStorageState.Put(groupIds[2], id2, NKikimrProto::OK, "c");
+    builder.AddRead("key2", "c", id2);
+
+    RunTest(env, builder, groupIds);
+}
+
+
+Y_UNIT_TEST(ReadRangeNoData) {
+    TTestEnv env;
+    std::vector<ui32> groupIds = {1, 2, 3};
+
+    TRangeReadRequestBuilder builder;
+
+    RunTest(env, builder, groupIds, NKikimrKeyValue::Statuses::RSTATUS_NO_DATA);
+}
+
+} // Y_UNIT_TEST_SUITE(KeyValueReadStorage)
+
+} // NKeyValue
+} // NKikimr
diff --git a/ydb/core/keyvalue/keyvalue_storage_request.cpp b/ydb/core/keyvalue/keyvalue_storage_request.cpp
index 2fad1bfae8..e9032d2ed3 100644
--- a/ydb/core/keyvalue/keyvalue_storage_request.cpp
+++ b/ydb/core/keyvalue/keyvalue_storage_request.cpp
@@ -13,8 +13,8 @@ namespace NKeyValue {
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 class TKeyValueStorageRequest : public TActorBootstrapped<TKeyValueStorageRequest> {
-    using TBase = TActorBootstrapped<TKeyValueStorageRequest>; 
- 
+    using TBase = TActorBootstrapped<TKeyValueStorageRequest>;
+
     ui64 ReadRequestsSent;
     ui64 ReadRequestsReplied;
     ui64 WriteRequestsSent;
@@ -39,8 +39,8 @@ class TKeyValueStorageRequest : public TActorBootstrapped<TKeyValueStorageReques
     const TDuration MuteDuration = TDuration::Seconds(5);
     TLogPriorityMuteChecker<NLog::PRI_DEBUG, NLog::PRI_ERROR> ErrorStateMuteChecker;
 
-    THashMap<ui32, TInstant> TimeForNextSend; 
- 
+    THashMap<ui32, TInstant> TimeForNextSend;
+
     struct TReadQueueItem {
         TIntermediate::TRead *Read;
         TIntermediate::TRead::TReadItem *ReadItem;
@@ -60,7 +60,7 @@ class TKeyValueStorageRequest : public TActorBootstrapped<TKeyValueStorageReques
 
     TStackVec<ui32, 16> YellowMoveChannels;
     TStackVec<ui32, 16> YellowStopChannels;
- 
+
 public:
     static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
         return NKikimrServices::TActivity::KEYVALUE_ACTOR;
@@ -86,7 +86,7 @@ public:
         IntermediateResults->Stat.KeyvalueStorageRequestSentAt = TAppData::TimeProvider->Now();
     }
 
-    void CheckYellow(const TStorageStatusFlags &statusFlags, ui32 currentGroup) { 
+    void CheckYellow(const TStorageStatusFlags &statusFlags, ui32 currentGroup) {
         if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceLightYellowMove)) {
             for (ui32 channel : xrange(TabletInfo->Channels.size())) {
                 const ui32 group = TabletInfo->ChannelInfo(channel)->LatestEntry()->GroupID;
@@ -95,25 +95,25 @@ public:
                 }
             }
             SortUnique(YellowMoveChannels);
-        } 
+        }
         if (statusFlags.Check(NKikimrBlobStorage::StatusDiskSpaceYellowStop)) {
             for (ui32 channel : xrange(TabletInfo->Channels.size())) {
                 const ui32 group = TabletInfo->ChannelInfo(channel)->LatestEntry()->GroupID;
                 if (currentGroup == group) {
                     YellowStopChannels.push_back(channel);
                 }
-            } 
+            }
             SortUnique(YellowStopChannels);
-        } 
-    } 
- 
+        }
+    }
+
     void Handle(TEvBlobStorage::TEvPutResult::TPtr &ev, const TActorContext &ctx) {
         const TDuration duration = TDuration::Seconds(PutTimer.Passed());
         IntermediateResults->Stat.PutLatencies.push_back(duration.MilliSeconds());
 
-        auto groupId = ev->Get()->GroupId; 
-        CheckYellow(ev->Get()->StatusFlags, groupId); 
- 
+        auto groupId = ev->Get()->GroupId;
+        CheckYellow(ev->Get()->StatusFlags, groupId);
+
         NKikimrProto::EReplyStatus status = ev->Get()->Status;
         if (status != NKikimrProto::OK) {
             TInstant now = TAppData::TimeProvider->Now();
@@ -140,7 +140,7 @@ public:
         }
         ui64 cookie = ev->Cookie;
         ui64 writeIdx = cookie;
-        if (writeIdx >= IntermediateResults->Writes.size() && writeIdx >= IntermediateResults->Commands.size()) { 
+        if (writeIdx >= IntermediateResults->Writes.size() && writeIdx >= IntermediateResults->Commands.size()) {
             TStringStream str;
             str << "KeyValue# " << TabletInfo->TabletID;
             str << " EvPut cookie# " << (ui64)cookie;
@@ -149,15 +149,15 @@ public:
             ReplyErrorAndDie(ctx, str.Str());
             return;
         }
- 
-        TIntermediate::TWrite *wr = nullptr; 
-        if (IntermediateResults->Writes.size()) { 
-            wr = &IntermediateResults->Writes[writeIdx]; 
-        } else { 
-            wr = &std::get<TIntermediate::TWrite>(IntermediateResults->Commands[writeIdx]); 
-        } 
-        wr->StatusFlags.Merge(ev->Get()->StatusFlags.Raw); 
-        wr->Latency = duration; 
+
+        TIntermediate::TWrite *wr = nullptr;
+        if (IntermediateResults->Writes.size()) {
+            wr = &IntermediateResults->Writes[writeIdx];
+        } else {
+            wr = &std::get<TIntermediate::TWrite>(IntermediateResults->Commands[writeIdx]);
+        }
+        wr->StatusFlags.Merge(ev->Get()->StatusFlags.Raw);
+        wr->Latency = duration;
         ++WriteRequestsReplied;
         IntermediateResults->Stat.GroupWrittenBytes[std::make_pair(ev->Get()->Id.Channel(), groupId)] += ev->Get()->Id.BlobSize();
         IntermediateResults->Stat.GroupWrittenIops[std::make_pair(ev->Get()->Id.Channel(), groupId)] += 1; // FIXME: count distinct blobs?
@@ -169,9 +169,9 @@ public:
         ui64 durationMs = (now - GetStatusSentAt).MilliSeconds();
         IntermediateResults->Stat.GetStatusLatencies.push_back(durationMs);
 
-        ui64 cookie = ev->Cookie; // groupId 
-        CheckYellow(ev->Get()->StatusFlags, cookie); 
- 
+        ui64 cookie = ev->Cookie; // groupId
+        CheckYellow(ev->Get()->StatusFlags, cookie);
+
         NKikimrProto::EReplyStatus status = ev->Get()->Status;
         if (status != NKikimrProto::OK) {
             TStringStream str;
@@ -361,15 +361,15 @@ public:
                     getStatus.Status = NKikimrProto::OK;
                 }
             }
-            for (auto& cmd : IntermediateResults->Commands) { 
-                if (!std::holds_alternative<TIntermediate::TWrite>(cmd)) { 
-                    continue; 
-                } 
-                auto& write = std::get<TIntermediate::TWrite>(cmd); 
-                if (write.Status == NKikimrProto::UNKNOWN) { 
-                    write.Status = NKikimrProto::OK; 
-                } 
-            } 
+            for (auto& cmd : IntermediateResults->Commands) {
+                if (!std::holds_alternative<TIntermediate::TWrite>(cmd)) {
+                    continue;
+                }
+                auto& write = std::get<TIntermediate::TWrite>(cmd);
+                if (write.Status == NKikimrProto::UNKNOWN) {
+                    write.Status = NKikimrProto::OK;
+                }
+            }
             IntermediateResults->Stat.YellowStopChannels.reserve(YellowStopChannels.size());
             IntermediateResults->Stat.YellowStopChannels.insert(IntermediateResults->Stat.YellowStopChannels.end(),
                     YellowStopChannels.begin(), YellowStopChannels.end());
@@ -477,7 +477,7 @@ public:
         IntermediateResults->Stat.YellowMoveChannels.reserve(YellowMoveChannels.size());
         IntermediateResults->Stat.YellowMoveChannels.insert(IntermediateResults->Stat.YellowMoveChannels.end(),
                 YellowMoveChannels.begin(), YellowMoveChannels.end());
- 
+
         IntermediateResults->UpdateStat();
         TActorId keyValueActorId = IntermediateResults->KeyValueActorId;
         ctx.Send(keyValueActorId, new TEvKeyValue::TEvNotify(
@@ -629,45 +629,45 @@ public:
     }
 
     void SendWriteRequests(const TActorContext &ctx) {
-        auto sendWrite = [&](ui32 i, auto &request) -> void { 
-            using Type = std::decay_t<decltype(request)>; 
-            if constexpr (std::is_same_v<Type, TIntermediate::TWrite>) { 
-                if (request.Status != NKikimrProto::SCHEDULED) { 
-                    Y_VERIFY(request.Status == NKikimrProto::UNKNOWN); 
-
-                    ui64 offset = 0; 
-                    for (const TLogoBlobID& logoBlobId : request.LogoBlobIds) { 
-                        THolder<TEvBlobStorage::TEvPut> put( 
-                            new TEvBlobStorage::TEvPut( 
-                                logoBlobId, request.Data.substr(offset, logoBlobId.BlobSize()), 
-                                IntermediateResults->Deadline, request.HandleClass, 
-                                request.Tactic)); 
-                        const ui32 groupId = TabletInfo->GroupFor(logoBlobId.Channel(), logoBlobId.Generation()); 
-                        Y_VERIFY(groupId != Max<ui32>(), "Put Blob# %s is mapped to an invalid group (-1)!", 
-                                logoBlobId.ToString().c_str()); 
-                        LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletInfo->TabletID 
-                                << " Send TEvPut# " << put->ToString() << " to groupId# " << groupId 
-                                << " now# " << TAppData::TimeProvider->Now().MilliSeconds() << " Marker# KV60"); 
-
-                        SendPutToGroup(ctx, groupId, TabletInfo.Get(), std::move(put), i); 
-
-                        ++WriteRequestsSent; 
-                        offset += logoBlobId.BlobSize(); 
-                    } 
+        auto sendWrite = [&](ui32 i, auto &request) -> void {
+            using Type = std::decay_t<decltype(request)>;
+            if constexpr (std::is_same_v<Type, TIntermediate::TWrite>) {
+                if (request.Status != NKikimrProto::SCHEDULED) {
+                    Y_VERIFY(request.Status == NKikimrProto::UNKNOWN);
+
+                    ui64 offset = 0;
+                    for (const TLogoBlobID& logoBlobId : request.LogoBlobIds) {
+                        THolder<TEvBlobStorage::TEvPut> put(
+                            new TEvBlobStorage::TEvPut(
+                                logoBlobId, request.Data.substr(offset, logoBlobId.BlobSize()),
+                                IntermediateResults->Deadline, request.HandleClass,
+                                request.Tactic));
+                        const ui32 groupId = TabletInfo->GroupFor(logoBlobId.Channel(), logoBlobId.Generation());
+                        Y_VERIFY(groupId != Max<ui32>(), "Put Blob# %s is mapped to an invalid group (-1)!",
+                                logoBlobId.ToString().c_str());
+                        LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletInfo->TabletID
+                                << " Send TEvPut# " << put->ToString() << " to groupId# " << groupId
+                                << " now# " << TAppData::TimeProvider->Now().MilliSeconds() << " Marker# KV60");
+
+                        SendPutToGroup(ctx, groupId, TabletInfo.Get(), std::move(put), i);
+
+                        ++WriteRequestsSent;
+                        offset += logoBlobId.BlobSize();
+                    }
                 }
             }
-        }; 
- 
-        for (ui64 i : IntermediateResults->WriteIndices) { 
-            auto &cmd = IntermediateResults->Commands[i]; 
-            Y_VERIFY(std::holds_alternative<TIntermediate::TWrite>(cmd)); 
-            auto& write = std::get<TIntermediate::TWrite>(cmd); 
-            sendWrite(i, write); 
+        };
+
+        for (ui64 i : IntermediateResults->WriteIndices) {
+            auto &cmd = IntermediateResults->Commands[i];
+            Y_VERIFY(std::holds_alternative<TIntermediate::TWrite>(cmd));
+            auto& write = std::get<TIntermediate::TWrite>(cmd);
+            sendWrite(i, write);
+        }
+
+        for (ui64 i = 0; i < IntermediateResults->Writes.size(); ++i) {
+            sendWrite(i, IntermediateResults->Writes[i]);
         }
- 
-        for (ui64 i = 0; i < IntermediateResults->Writes.size(); ++i) { 
-            sendWrite(i, IntermediateResults->Writes[i]); 
-        } 
         PutTimer.Reset();
     }
 
diff --git a/ydb/core/keyvalue/keyvalue_ut.cpp b/ydb/core/keyvalue/keyvalue_ut.cpp
index b35d51507d..4ae1fcf56a 100644
--- a/ydb/core/keyvalue/keyvalue_ut.cpp
+++ b/ydb/core/keyvalue/keyvalue_ut.cpp
@@ -15,7 +15,7 @@ void SetupLogging(TTestActorRuntime& runtime) {
     NActors::NLog::EPriority priority = ENABLE_DETAILED_KV_LOG ? NLog::PRI_DEBUG : NLog::PRI_ERROR;
     NActors::NLog::EPriority otherPriority = NLog::PRI_ERROR;
 
-    runtime.SetLogPriority(NKikimrServices::KEYVALUE, priority); 
+    runtime.SetLogPriority(NKikimrServices::KEYVALUE, priority);
     runtime.SetLogPriority(NKikimrServices::BOOTSTRAPPER, priority);
     runtime.SetLogPriority(NKikimrServices::TABLET_MAIN, priority);
     runtime.SetLogPriority(NKikimrServices::TABLET_EXECUTOR, priority);
@@ -78,7 +78,7 @@ struct TTestContext {
         outActiveZone = false;
         Runtime.Reset(new TTestBasicRuntime);
         Runtime->SetScheduledLimit(100);
-        Runtime->SetLogPriority(NKikimrServices::KEYVALUE, NLog::PRI_DEBUG); 
+        Runtime->SetLogPriority(NKikimrServices::KEYVALUE, NLog::PRI_DEBUG);
         SetupLogging(*Runtime);
         SetupTabletServices(*Runtime);
         setup(*Runtime);
@@ -115,18 +115,18 @@ struct TFinalizer {
 // SINGLE COMMAND TEST FUNCTIONS
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void DoWithRetry(std::function<bool(void)> action, i32 retryCount = 2) { 
-    bool isEnd = false; 
-    for (i32 retriesLeft = retryCount; !isEnd && retriesLeft > 0; --retriesLeft) { 
-        try { 
-            isEnd = action(); 
-        } catch (NActors::TSchedulingLimitReachedException) { 
-            UNIT_ASSERT(retriesLeft != 1); 
-        } 
-    } 
-    UNIT_ASSERT(isEnd); 
-} 
- 
+void DoWithRetry(std::function<bool(void)> action, i32 retryCount = 2) {
+    bool isEnd = false;
+    for (i32 retriesLeft = retryCount; !isEnd && retriesLeft > 0; --retriesLeft) {
+        try {
+            isEnd = action();
+        } catch (NActors::TSchedulingLimitReachedException) {
+            UNIT_ASSERT(retriesLeft != 1);
+        }
+    }
+    UNIT_ASSERT(isEnd);
+}
+
 void CmdWrite(const TDeque<TString> &keys, const TDeque<TString> &values,
         const NKikimrClient::TKeyValueRequest::EStorageChannel storageChannel,
         const NKikimrClient::TKeyValueRequest::EPriority priority, TTestContext &tc) {
@@ -134,33 +134,33 @@ void CmdWrite(const TDeque<TString> &keys, const TDeque<TString> &values,
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        for (ui64 idx = 0; idx < keys.size(); ++idx) { 
-            auto write = request->Record.AddCmdWrite(); 
-            write->SetKey(keys[idx]); 
-            write->SetValue(values[idx]); 
-            write->SetStorageChannel(storageChannel); 
-            write->SetPriority(priority); 
-        } 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
-        UNIT_ASSERT(result); 
-        UNIT_ASSERT(result->Record.HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
-        UNIT_ASSERT_VALUES_EQUAL(result->Record.WriteResultSize(), values.size()); 
-        for (ui64 idx = 0; idx < values.size(); ++idx) { 
-            const auto &writeResult = result->Record.GetWriteResult(idx); 
-            UNIT_ASSERT(writeResult.HasStatus()); 
-            UNIT_ASSERT_EQUAL(writeResult.GetStatus(), NKikimrProto::OK); 
-            UNIT_ASSERT(writeResult.HasStatusFlags()); 
-            if (values[idx].size()) { 
-                UNIT_ASSERT(writeResult.GetStatusFlags() & ui32(NKikimrBlobStorage::StatusIsValid)); 
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        for (ui64 idx = 0; idx < keys.size(); ++idx) {
+            auto write = request->Record.AddCmdWrite();
+            write->SetKey(keys[idx]);
+            write->SetValue(values[idx]);
+            write->SetStorageChannel(storageChannel);
+            write->SetPriority(priority);
+        }
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
+        UNIT_ASSERT(result);
+        UNIT_ASSERT(result->Record.HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK);
+        UNIT_ASSERT_VALUES_EQUAL(result->Record.WriteResultSize(), values.size());
+        for (ui64 idx = 0; idx < values.size(); ++idx) {
+            const auto &writeResult = result->Record.GetWriteResult(idx);
+            UNIT_ASSERT(writeResult.HasStatus());
+            UNIT_ASSERT_EQUAL(writeResult.GetStatus(), NKikimrProto::OK);
+            UNIT_ASSERT(writeResult.HasStatusFlags());
+            if (values[idx].size()) {
+                UNIT_ASSERT(writeResult.GetStatusFlags() & ui32(NKikimrBlobStorage::StatusIsValid));
             }
         }
-        return true; 
-    }); 
+        return true;
+    });
 }
 
 void CmdWrite(const TString &key, const TString &value,
@@ -179,34 +179,34 @@ void CmdRead(const TDeque<TString> &keys,
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
- 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        for (const auto &key: keys) { 
-            auto read = request->Record.AddCmdRead(); 
-            read->SetKey(key); 
-            read->SetPriority(priority); 
-        } 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
-        UNIT_ASSERT(result); 
-        UNIT_ASSERT(result->Record.HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
-        UNIT_ASSERT_VALUES_EQUAL(result->Record.ReadResultSize(), keys.size()); 
-        for (ui64 idx = 0; idx < expectedValues.size(); ++idx) { 
-            const auto &readResult = result->Record.GetReadResult(idx); 
-            UNIT_ASSERT(readResult.HasStatus()); 
-            if (expectedNodatas.size() == 0 || !expectedNodatas[idx]) { 
-                UNIT_ASSERT_EQUAL(readResult.GetStatus(), NKikimrProto::OK); 
-                UNIT_ASSERT(readResult.HasValue()); 
-                UNIT_ASSERT_VALUES_EQUAL(readResult.GetValue(), expectedValues[idx]); 
-            } else { 
-                UNIT_ASSERT_EQUAL(readResult.GetStatus(), NKikimrProto::NODATA); 
+
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        for (const auto &key: keys) {
+            auto read = request->Record.AddCmdRead();
+            read->SetKey(key);
+            read->SetPriority(priority);
+        }
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
+        UNIT_ASSERT(result);
+        UNIT_ASSERT(result->Record.HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK);
+        UNIT_ASSERT_VALUES_EQUAL(result->Record.ReadResultSize(), keys.size());
+        for (ui64 idx = 0; idx < expectedValues.size(); ++idx) {
+            const auto &readResult = result->Record.GetReadResult(idx);
+            UNIT_ASSERT(readResult.HasStatus());
+            if (expectedNodatas.size() == 0 || !expectedNodatas[idx]) {
+                UNIT_ASSERT_EQUAL(readResult.GetStatus(), NKikimrProto::OK);
+                UNIT_ASSERT(readResult.HasValue());
+                UNIT_ASSERT_VALUES_EQUAL(readResult.GetValue(), expectedValues[idx]);
+            } else {
+                UNIT_ASSERT_EQUAL(readResult.GetStatus(), NKikimrProto::NODATA);
             }
         }
-        return true; 
-    }); 
+        return true;
+    });
 }
 
 void CmdRename(const TDeque<TString> &oldKeys, const TDeque<TString> &newKeys, TTestContext &tc,
@@ -215,33 +215,33 @@ void CmdRename(const TDeque<TString> &oldKeys, const TDeque<TString> &newKeys, T
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
- 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        for (ui64 idx = 0; idx < oldKeys.size(); ++idx) { 
-            auto cmd = request->Record.AddCmdRename(); 
-            cmd->SetOldKey(oldKeys[idx]); 
-            cmd->SetNewKey(newKeys[idx]); 
-        } 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
-        UNIT_ASSERT(result); 
-        UNIT_ASSERT(result->Record.HasStatus()); 
-        if (expectOk) { 
-            UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
-            UNIT_ASSERT_VALUES_EQUAL(result->Record.RenameResultSize(), oldKeys.size()); 
+
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        for (ui64 idx = 0; idx < oldKeys.size(); ++idx) {
+            auto cmd = request->Record.AddCmdRename();
+            cmd->SetOldKey(oldKeys[idx]);
+            cmd->SetNewKey(newKeys[idx]);
+        }
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
+        UNIT_ASSERT(result);
+        UNIT_ASSERT(result->Record.HasStatus());
+        if (expectOk) {
+            UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK);
+            UNIT_ASSERT_VALUES_EQUAL(result->Record.RenameResultSize(), oldKeys.size());
             for (ui64 idx = 0; idx < oldKeys.size(); ++idx) {
-                const auto &renameResult = result->Record.GetRenameResult(idx); 
-                UNIT_ASSERT(renameResult.HasStatus()); 
-                UNIT_ASSERT_EQUAL(renameResult.GetStatus(), NKikimrProto::OK); 
+                const auto &renameResult = result->Record.GetRenameResult(idx);
+                UNIT_ASSERT(renameResult.HasStatus());
+                UNIT_ASSERT_EQUAL(renameResult.GetStatus(), NKikimrProto::OK);
             }
-        } else { 
-            UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_ERROR); 
+        } else {
+            UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_ERROR);
         }
- 
-        return true; 
-    }); 
+
+        return true;
+    });
 }
 
 void CmdRename(const TString &oldKey, const TString &newKey, TTestContext &tc, bool expectOk = true) {
@@ -254,27 +254,27 @@ void CmdConcat(const TDeque<TString> &inputKeys, const TString &outputKey, const
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
- 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        auto cmd = request->Record.AddCmdConcat(); 
-        for (ui64 idx = 0; idx < inputKeys.size(); ++idx) { 
-            cmd->AddInputKeys(inputKeys[idx]); 
-        }
-        cmd->SetOutputKey(outputKey); 
-        cmd->SetKeepInputs(keepInputs); 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
-        UNIT_ASSERT(result); 
-        UNIT_ASSERT(result->Record.HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
-        UNIT_ASSERT_VALUES_EQUAL(result->Record.ConcatResultSize(), 1); 
-        UNIT_ASSERT(result->Record.GetConcatResult(0).HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetConcatResult(0).GetStatus(), NKikimrProto::OK); 
- 
-        return true; 
-    }); 
+
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        auto cmd = request->Record.AddCmdConcat();
+        for (ui64 idx = 0; idx < inputKeys.size(); ++idx) {
+            cmd->AddInputKeys(inputKeys[idx]);
+        }
+        cmd->SetOutputKey(outputKey);
+        cmd->SetKeepInputs(keepInputs);
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
+        UNIT_ASSERT(result);
+        UNIT_ASSERT(result->Record.HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK);
+        UNIT_ASSERT_VALUES_EQUAL(result->Record.ConcatResultSize(), 1);
+        UNIT_ASSERT(result->Record.GetConcatResult(0).HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetConcatResult(0).GetStatus(), NKikimrProto::OK);
+
+        return true;
+    });
 }
 
 void CmdDeleteRange(const TString &from, const bool includeFrom, const TString &to, const bool includeTo,
@@ -282,33 +282,33 @@ void CmdDeleteRange(const TString &from, const bool includeFrom, const TString &
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
- 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        auto deleteRange = request->Record.AddCmdDeleteRange(); 
-        deleteRange->MutableRange()->SetFrom(from); 
-        deleteRange->MutableRange()->SetIncludeFrom(includeFrom); 
-        deleteRange->MutableRange()->SetTo(to); 
-        deleteRange->MutableRange()->SetIncludeTo(includeTo); 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
-        UNIT_ASSERT(result); 
-        UNIT_ASSERT(result->Record.HasStatus()); 
-        if (expectedStatus == NMsgBusProxy::MSTATUS_OK) { 
-            UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
-            UNIT_ASSERT_VALUES_EQUAL(result->Record.DeleteRangeResultSize(), 1); 
-            UNIT_ASSERT(result->Record.GetDeleteRangeResult(0).HasStatus()); 
-            UNIT_ASSERT_EQUAL(result->Record.GetDeleteRangeResult(0).GetStatus(), NKikimrProto::OK); 
-        } else { 
-            UNIT_ASSERT_EQUAL_C(result->Record.GetStatus(), expectedStatus, 
-                    "Expected# " << (ui32)expectedStatus 
-                    << " Got# " << (ui32)result->Record.GetStatus() 
-                    << " ErrorReason# \"" << result->Record.GetErrorReason() << "\""); 
-        }
- 
-        return true; 
-    }); 
+
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        auto deleteRange = request->Record.AddCmdDeleteRange();
+        deleteRange->MutableRange()->SetFrom(from);
+        deleteRange->MutableRange()->SetIncludeFrom(includeFrom);
+        deleteRange->MutableRange()->SetTo(to);
+        deleteRange->MutableRange()->SetIncludeTo(includeTo);
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
+        UNIT_ASSERT(result);
+        UNIT_ASSERT(result->Record.HasStatus());
+        if (expectedStatus == NMsgBusProxy::MSTATUS_OK) {
+            UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK);
+            UNIT_ASSERT_VALUES_EQUAL(result->Record.DeleteRangeResultSize(), 1);
+            UNIT_ASSERT(result->Record.GetDeleteRangeResult(0).HasStatus());
+            UNIT_ASSERT_EQUAL(result->Record.GetDeleteRangeResult(0).GetStatus(), NKikimrProto::OK);
+        } else {
+            UNIT_ASSERT_EQUAL_C(result->Record.GetStatus(), expectedStatus,
+                    "Expected# " << (ui32)expectedStatus
+                    << " Got# " << (ui32)result->Record.GetStatus()
+                    << " ErrorReason# \"" << result->Record.GetErrorReason() << "\"");
+        }
+
+        return true;
+    });
 }
 
 void CmdCopyRange(const TString &from, const bool includeFrom, const TString &to, const bool includeTo,
@@ -316,38 +316,38 @@ void CmdCopyRange(const TString &from, const bool includeFrom, const TString &to
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
- 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        auto copyRange = request->Record.AddCmdCopyRange(); 
-        copyRange->MutableRange()->SetFrom(from); 
-        copyRange->MutableRange()->SetIncludeFrom(includeFrom); 
-        copyRange->MutableRange()->SetTo(to); 
-        copyRange->MutableRange()->SetIncludeTo(includeTo); 
-        copyRange->SetPrefixToAdd(prefixToAdd); 
-        copyRange->SetPrefixToRemove(prefixToRemove); 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
-        UNIT_ASSERT(result); 
-        UNIT_ASSERT(result->Record.HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
-        UNIT_ASSERT_VALUES_EQUAL(result->Record.CopyRangeResultSize(), 1); 
-        UNIT_ASSERT(result->Record.GetCopyRangeResult(0).HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetCopyRangeResult(0).GetStatus(), NKikimrProto::OK); 
- 
-        return true; 
-    }); 
-}
-
-template <typename TRequest> 
+
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        auto copyRange = request->Record.AddCmdCopyRange();
+        copyRange->MutableRange()->SetFrom(from);
+        copyRange->MutableRange()->SetIncludeFrom(includeFrom);
+        copyRange->MutableRange()->SetTo(to);
+        copyRange->MutableRange()->SetIncludeTo(includeTo);
+        copyRange->SetPrefixToAdd(prefixToAdd);
+        copyRange->SetPrefixToRemove(prefixToRemove);
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
+        UNIT_ASSERT(result);
+        UNIT_ASSERT(result->Record.HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK);
+        UNIT_ASSERT_VALUES_EQUAL(result->Record.CopyRangeResultSize(), 1);
+        UNIT_ASSERT(result->Record.GetCopyRangeResult(0).HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetCopyRangeResult(0).GetStatus(), NKikimrProto::OK);
+
+        return true;
+    });
+}
+
+template <typename TRequest>
 struct TDesiredPair {
-    typename TRequest::ProtoRecordType Request; 
-    typename TRequest::TResponse::ProtoRecordType Response; 
-}; 
- 
-template <> 
-struct TDesiredPair<TEvKeyValue::TEvRequest> { 
+    typename TRequest::ProtoRecordType Request;
+    typename TRequest::TResponse::ProtoRecordType Response;
+};
+
+template <>
+struct TDesiredPair<TEvKeyValue::TEvRequest> {
     NKikimrClient::TKeyValueRequest Request;
     NKikimrClient::TKeyValueResponse Response;
 };
@@ -383,34 +383,34 @@ void CheckResponse(NKikimrClient::TResponse &ar, NKikimrClient::TKeyValueRespons
     }
 }
 
-void RunRequest(TDesiredPair<TEvKeyValue::TEvRequest> &dp, TTestContext &tc, ui64 line) { 
+void RunRequest(TDesiredPair<TEvKeyValue::TEvRequest> &dp, TTestContext &tc, ui64 line) {
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        request->Record = dp.Request; 
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        request->Record = dp.Request;
 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
 
-        UNIT_ASSERT_C(result, "Line# " << line); 
-        UNIT_ASSERT_C(result->Record.HasStatus(), "Line# " << line); 
-        UNIT_ASSERT_EQUAL_C(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK, "Line# " << line); 
- 
-        CheckResponse(result->Record, dp.Response, line); 
- 
-        return true; 
-    }); 
+        UNIT_ASSERT_C(result, "Line# " << line);
+        UNIT_ASSERT_C(result->Record.HasStatus(), "Line# " << line);
+        UNIT_ASSERT_EQUAL_C(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK, "Line# " << line);
+
+        CheckResponse(result->Record, dp.Response, line);
+
+        return true;
+    });
 }
 
 void AddCmdReadRange(const TString &from, const bool includeFrom, const TString &to, const bool includeTo,
         const bool includeData, const ui64 limitBytes,
         const NKikimrClient::TKeyValueRequest::EPriority priority,
         const TDeque<TString> &expectedKeys, const TDeque<TString> &expectedValues,
-        const NKikimrProto::EReplyStatus expectedStatus, TTestContext &tc, TDesiredPair<TEvKeyValue::TEvRequest> &dp) { 
+        const NKikimrProto::EReplyStatus expectedStatus, TTestContext &tc, TDesiredPair<TEvKeyValue::TEvRequest> &dp) {
     Y_UNUSED(tc);
     Y_VERIFY(!includeData || expectedKeys.size() == expectedValues.size());
 
@@ -446,411 +446,411 @@ void CmdGetStatus(const NKikimrClient::TKeyValueRequest::EStorageChannel storage
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
- 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        auto getStatus = request->Record.AddCmdGetStatus(); 
-        getStatus->SetStorageChannel(storageChannel); 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
-        UNIT_ASSERT(result); 
-        UNIT_ASSERT(result->Record.HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
-        UNIT_ASSERT_VALUES_EQUAL(result->Record.GetStatusResultSize(), 1); 
-        UNIT_ASSERT(result->Record.GetGetStatusResult(0).HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetGetStatusResult(0).GetStatus(), NKikimrProto::OK); 
-        UNIT_ASSERT(result->Record.GetGetStatusResult(0).HasStatusFlags()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetGetStatusResult(0).GetStatusFlags(), expectedStatusFlags); 
- 
-        return true; 
-    }); 
+
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        auto getStatus = request->Record.AddCmdGetStatus();
+        getStatus->SetStorageChannel(storageChannel);
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
+        UNIT_ASSERT(result);
+        UNIT_ASSERT(result->Record.HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK);
+        UNIT_ASSERT_VALUES_EQUAL(result->Record.GetStatusResultSize(), 1);
+        UNIT_ASSERT(result->Record.GetGetStatusResult(0).HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetGetStatusResult(0).GetStatus(), NKikimrProto::OK);
+        UNIT_ASSERT(result->Record.GetGetStatusResult(0).HasStatusFlags());
+        UNIT_ASSERT_EQUAL(result->Record.GetGetStatusResult(0).GetStatusFlags(), expectedStatusFlags);
+
+        return true;
+    });
 }
 
 void CmdSetExecutorFastLogPolicy(bool isAllowed, TTestContext &tc) {
     TAutoPtr<IEventHandle> handle;
     TEvKeyValue::TEvResponse *result;
     THolder<TEvKeyValue::TEvRequest> request;
- 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request.Reset(new TEvKeyValue::TEvRequest); 
-        auto cmd = request->Record.MutableCmdSetExecutorFastLogPolicy(); 
-        cmd->SetIsAllowed(isAllowed); 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries()); 
-        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle); 
-        UNIT_ASSERT(result); 
-        UNIT_ASSERT(result->Record.HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK); 
-        UNIT_ASSERT(result->Record.HasSetExecutorFastLogPolicyResult()); 
-        UNIT_ASSERT(result->Record.GetSetExecutorFastLogPolicyResult().HasStatus()); 
-        UNIT_ASSERT_EQUAL(result->Record.GetSetExecutorFastLogPolicyResult().GetStatus(), NKikimrProto::OK); 
- 
-        return true; 
-    }); 
-} 
- 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
-// NEW SINGLE COMMAND TEST FUNCTIONS 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
- 
-struct TKeyValuePair { 
-    TString Key; 
-    TString Value; 
-}; 
- 
-template <typename TRequestEvent> 
-void ExecuteEvent(TDesiredPair<TRequestEvent> &dp, TTestContext &tc) { 
-    TAutoPtr<IEventHandle> handle; 
-    std::unique_ptr<TRequestEvent> request; 
-    typename TRequestEvent::TResponse *response; 
-    DoWithRetry([&] { 
-        tc.Runtime->ResetScheduledCount(); 
-        request = std::make_unique<TRequestEvent>(); 
-        request->Record = dp.Request; 
-        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.release(), 0, GetPipeConfigWithRetries()); 
-        response = tc.Runtime->GrabEdgeEvent<typename TRequestEvent::TResponse>(handle); 
-        dp.Response = response->Record; 
-        return true; 
-    }); 
-} 
- 
-template <NKikimrKeyValue::Statuses::ReplyStatus ExpectedStatus = NKikimrKeyValue::Statuses::RSTATUS_OK> 
-void ExecuteWrite(TTestContext &tc, const TDeque<TKeyValuePair> &pairs, ui64 lockedGeneration, ui64 storageChannel, 
-        NKikimrKeyValue::Priorities::Priority priority) 
-{ 
-    TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp; 
- 
-    for (auto &[key, value] : pairs) { 
-        NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands(); 
-        NKikimrKeyValue::ExecuteTransactionRequest::Command::Write *write = cmd->mutable_write(); 
- 
-        write->set_key(key); 
-        write->set_value(value); 
-        write->set_storage_channel(storageChannel); 
-        write->set_priority(priority); 
-    } 
- 
-    dp.Request.set_tablet_id(tc.TabletId); 
-    dp.Request.set_lock_generation(lockedGeneration); 
- 
-    ExecuteEvent(dp, tc); 
-    UNIT_ASSERT_C(dp.Response.status() == ExpectedStatus, 
-            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-            << " exp# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(ExpectedStatus) 
-            << " msg# " << dp.Response.msg()); 
-} 
- 
-enum class EBorderKind { 
-    Include, 
-    Exclude, 
-    Without 
-}; 
- 
-template <bool IsSuccess = true> 
-void ExecuteDeleteRange(TTestContext &tc, 
-        const TString &from, EBorderKind fromKind, 
-        const TString &to, EBorderKind toKind, 
-        ui64 lock_generation) 
-{ 
-    TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp; 
-    dp.Request.set_lock_generation(lock_generation); 
-    dp.Request.set_tablet_id(tc.TabletId); 
- 
-    NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands(); 
-    NKikimrKeyValue::ExecuteTransactionRequest::Command::DeleteRange *deleteRange = cmd->mutable_delete_range(); 
- 
-    auto *r = deleteRange->mutable_range(); 
- 
-    switch (fromKind) { 
-    case EBorderKind::Include: 
-        r->set_from_key_inclusive(from); 
-        break; 
-    case EBorderKind::Exclude: 
-        r->set_from_key_exclusive(from); 
-        break; 
-    case EBorderKind::Without: 
-        break; 
-    } 
- 
-    switch (toKind) { 
-    case EBorderKind::Include: 
-        r->set_to_key_inclusive(to); 
-        break; 
-    case EBorderKind::Exclude: 
-        r->set_to_key_exclusive(to); 
-        break; 
-    case EBorderKind::Without: 
-        break; 
-    } 
- 
-    ExecuteEvent(dp, tc); 
-    if constexpr (IsSuccess) { 
-        UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_OK, 
-                "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-                << " msg# " << dp.Response.msg()); 
-    } else { 
-        UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR, 
-                "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-                << " msg# " << dp.Response.msg()); 
-    } 
-} 
- 
- 
-template <bool IsSuccess = true> 
-void ExecuteCopyRange(TTestContext &tc, 
-        const TString &from, EBorderKind fromKind, 
-        const TString &to, EBorderKind toKind, 
-        ui64 lock_generation, const TString &prefixToAdd, const TString &prefixToRemove) 
-{ 
-   TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp; 
-    dp.Request.set_lock_generation(lock_generation); 
-    dp.Request.set_tablet_id(tc.TabletId); 
- 
-    NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands(); 
-    NKikimrKeyValue::ExecuteTransactionRequest::Command::CopyRange *copyRange = cmd->mutable_copy_range(); 
- 
-    auto *r = copyRange->mutable_range(); 
-    switch (fromKind) { 
-    case EBorderKind::Include: 
-        r->set_from_key_inclusive(from); 
-        break; 
-    case EBorderKind::Exclude: 
-        r->set_from_key_exclusive(from); 
-        break; 
-    case EBorderKind::Without: 
-        break; 
-    } 
- 
-    switch (toKind) { 
-    case EBorderKind::Include: 
-        r->set_to_key_inclusive(to); 
-        break; 
-    case EBorderKind::Exclude: 
-        r->set_to_key_exclusive(to); 
-        break; 
-    case EBorderKind::Without: 
-        break; 
-    } 
- 
-    copyRange->set_prefix_to_remove(prefixToRemove); 
-    copyRange->set_prefix_to_add(prefixToAdd); 
- 
-    ExecuteEvent(dp, tc); 
-    if constexpr (IsSuccess) { 
-        UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_OK, 
-                "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-                << " msg# " << dp.Response.msg()); 
-    } else { 
-        UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR, 
-                "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-                << " msg# " << dp.Response.msg()); 
-    } 
-} 
- 
- 
-struct TKeyRenamePair { 
-    TString OldKey; 
-    TString NewKey; 
-}; 
- 
- 
-void ExecuteRename(TTestContext &tc, const TDeque<TKeyRenamePair> &pairs, ui64 lockedGeneration) 
-{ 
-    TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp; 
- 
-    for (auto &[oldKey, newKey] : pairs) { 
-        NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands(); 
-        NKikimrKeyValue::ExecuteTransactionRequest::Command::Rename *rename = cmd->mutable_rename(); 
- 
-        rename->set_old_key(oldKey); 
-        rename->set_new_key(newKey); 
-    } 
- 
-    dp.Request.set_tablet_id(tc.TabletId); 
-    dp.Request.set_lock_generation(lockedGeneration); 
- 
-    ExecuteEvent(dp, tc); 
-    UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_OK, 
-            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-            << " msg# " << dp.Response.msg()); 
-} 
- 
-void ExecuteConcat(TTestContext &tc, const TString &newKey, const TDeque<TString> &inputKeys, ui64 lockedGeneration, 
-        bool keepKeys) 
-{ 
-    TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp; 
- 
-    NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands(); 
-    NKikimrKeyValue::ExecuteTransactionRequest::Command::Concat *concat = cmd->mutable_concat(); 
- 
-    concat->set_output_key(newKey); 
-    concat->set_keep_inputs(keepKeys); 
-    for (auto &key : inputKeys) { 
-        concat->add_input_keys(key); 
-    } 
- 
-    dp.Request.set_tablet_id(tc.TabletId); 
-    dp.Request.set_lock_generation(lockedGeneration); 
- 
-    ExecuteEvent(dp, tc); 
-    UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_OK, 
-            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-            << " msg# " << dp.Response.msg()); 
-} 
- 
- 
-template <NKikimrKeyValue::Statuses::ReplyStatus ExpectedStatus = NKikimrKeyValue::Statuses::RSTATUS_OK> 
-void ExecuteRead(TTestContext &tc, const TString &key, const TString &expectedValue, ui32 offset, ui32 size, 
-        ui64 lock_generation, ui64 limit_bytes=0) 
-{ 
-    TDesiredPair<TEvKeyValue::TEvRead> dp; 
-    dp.Request.set_key(key); 
-    dp.Request.set_offset(offset); 
-    dp.Request.set_size(size); 
-    dp.Request.set_lock_generation(lock_generation); 
-    dp.Request.set_tablet_id(tc.TabletId); 
-    dp.Request.set_limit_bytes(limit_bytes); 
-    ExecuteEvent(dp, tc); 
- 
-    UNIT_ASSERT_C(dp.Response.status() == ExpectedStatus, 
-            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-            << " exp# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(ExpectedStatus) 
-            << " msg# " << dp.Response.msg()); 
-    if constexpr (ExpectedStatus == NKikimrKeyValue::Statuses::RSTATUS_OK 
-            || ExpectedStatus == NKikimrKeyValue::Statuses::RSTATUS_OVERRUN) 
-    { 
-        UNIT_ASSERT(dp.Response.value() == expectedValue); 
-        if (size) { 
-            UNIT_ASSERT_VALUES_EQUAL(dp.Response.requested_size(), size); 
-        }
-    } else { 
-        UNIT_ASSERT(dp.Response.value() == ""); 
+
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request.Reset(new TEvKeyValue::TEvRequest);
+        auto cmd = request->Record.MutableCmdSetExecutorFastLogPolicy();
+        cmd->SetIsAllowed(isAllowed);
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.Release(), 0, GetPipeConfigWithRetries());
+        result = tc.Runtime->GrabEdgeEvent<TEvKeyValue::TEvResponse>(handle);
+        UNIT_ASSERT(result);
+        UNIT_ASSERT(result->Record.HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetStatus(), NMsgBusProxy::MSTATUS_OK);
+        UNIT_ASSERT(result->Record.HasSetExecutorFastLogPolicyResult());
+        UNIT_ASSERT(result->Record.GetSetExecutorFastLogPolicyResult().HasStatus());
+        UNIT_ASSERT_EQUAL(result->Record.GetSetExecutorFastLogPolicyResult().GetStatus(), NKikimrProto::OK);
+
+        return true;
+    });
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// NEW SINGLE COMMAND TEST FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct TKeyValuePair {
+    TString Key;
+    TString Value;
+};
+
+template <typename TRequestEvent>
+void ExecuteEvent(TDesiredPair<TRequestEvent> &dp, TTestContext &tc) {
+    TAutoPtr<IEventHandle> handle;
+    std::unique_ptr<TRequestEvent> request;
+    typename TRequestEvent::TResponse *response;
+    DoWithRetry([&] {
+        tc.Runtime->ResetScheduledCount();
+        request = std::make_unique<TRequestEvent>();
+        request->Record = dp.Request;
+        tc.Runtime->SendToPipe(tc.TabletId, tc.Edge, request.release(), 0, GetPipeConfigWithRetries());
+        response = tc.Runtime->GrabEdgeEvent<typename TRequestEvent::TResponse>(handle);
+        dp.Response = response->Record;
+        return true;
+    });
+}
+
+template <NKikimrKeyValue::Statuses::ReplyStatus ExpectedStatus = NKikimrKeyValue::Statuses::RSTATUS_OK>
+void ExecuteWrite(TTestContext &tc, const TDeque<TKeyValuePair> &pairs, ui64 lockedGeneration, ui64 storageChannel,
+        NKikimrKeyValue::Priorities::Priority priority)
+{
+    TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp;
+
+    for (auto &[key, value] : pairs) {
+        NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands();
+        NKikimrKeyValue::ExecuteTransactionRequest::Command::Write *write = cmd->mutable_write();
+
+        write->set_key(key);
+        write->set_value(value);
+        write->set_storage_channel(storageChannel);
+        write->set_priority(priority);
+    }
+
+    dp.Request.set_tablet_id(tc.TabletId);
+    dp.Request.set_lock_generation(lockedGeneration);
+
+    ExecuteEvent(dp, tc);
+    UNIT_ASSERT_C(dp.Response.status() == ExpectedStatus,
+            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+            << " exp# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(ExpectedStatus)
+            << " msg# " << dp.Response.msg());
+}
+
+enum class EBorderKind {
+    Include,
+    Exclude,
+    Without
+};
+
+template <bool IsSuccess = true>
+void ExecuteDeleteRange(TTestContext &tc,
+        const TString &from, EBorderKind fromKind,
+        const TString &to, EBorderKind toKind,
+        ui64 lock_generation)
+{
+    TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp;
+    dp.Request.set_lock_generation(lock_generation);
+    dp.Request.set_tablet_id(tc.TabletId);
+
+    NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands();
+    NKikimrKeyValue::ExecuteTransactionRequest::Command::DeleteRange *deleteRange = cmd->mutable_delete_range();
+
+    auto *r = deleteRange->mutable_range();
+
+    switch (fromKind) {
+    case EBorderKind::Include:
+        r->set_from_key_inclusive(from);
+        break;
+    case EBorderKind::Exclude:
+        r->set_from_key_exclusive(from);
+        break;
+    case EBorderKind::Without:
+        break;
+    }
+
+    switch (toKind) {
+    case EBorderKind::Include:
+        r->set_to_key_inclusive(to);
+        break;
+    case EBorderKind::Exclude:
+        r->set_to_key_exclusive(to);
+        break;
+    case EBorderKind::Without:
+        break;
+    }
+
+    ExecuteEvent(dp, tc);
+    if constexpr (IsSuccess) {
+        UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_OK,
+                "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+                << " msg# " << dp.Response.msg());
+    } else {
+        UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR,
+                "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+                << " msg# " << dp.Response.msg());
+    }
+}
+
+
+template <bool IsSuccess = true>
+void ExecuteCopyRange(TTestContext &tc,
+        const TString &from, EBorderKind fromKind,
+        const TString &to, EBorderKind toKind,
+        ui64 lock_generation, const TString &prefixToAdd, const TString &prefixToRemove)
+{
+   TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp;
+    dp.Request.set_lock_generation(lock_generation);
+    dp.Request.set_tablet_id(tc.TabletId);
+
+    NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands();
+    NKikimrKeyValue::ExecuteTransactionRequest::Command::CopyRange *copyRange = cmd->mutable_copy_range();
+
+    auto *r = copyRange->mutable_range();
+    switch (fromKind) {
+    case EBorderKind::Include:
+        r->set_from_key_inclusive(from);
+        break;
+    case EBorderKind::Exclude:
+        r->set_from_key_exclusive(from);
+        break;
+    case EBorderKind::Without:
+        break;
+    }
+
+    switch (toKind) {
+    case EBorderKind::Include:
+        r->set_to_key_inclusive(to);
+        break;
+    case EBorderKind::Exclude:
+        r->set_to_key_exclusive(to);
+        break;
+    case EBorderKind::Without:
+        break;
+    }
+
+    copyRange->set_prefix_to_remove(prefixToRemove);
+    copyRange->set_prefix_to_add(prefixToAdd);
+
+    ExecuteEvent(dp, tc);
+    if constexpr (IsSuccess) {
+        UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_OK,
+                "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+                << " msg# " << dp.Response.msg());
+    } else {
+        UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR,
+                "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+                << " msg# " << dp.Response.msg());
+    }
+}
+
+
+struct TKeyRenamePair {
+    TString OldKey;
+    TString NewKey;
+};
+
+
+void ExecuteRename(TTestContext &tc, const TDeque<TKeyRenamePair> &pairs, ui64 lockedGeneration)
+{
+    TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp;
+
+    for (auto &[oldKey, newKey] : pairs) {
+        NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands();
+        NKikimrKeyValue::ExecuteTransactionRequest::Command::Rename *rename = cmd->mutable_rename();
+
+        rename->set_old_key(oldKey);
+        rename->set_new_key(newKey);
+    }
+
+    dp.Request.set_tablet_id(tc.TabletId);
+    dp.Request.set_lock_generation(lockedGeneration);
+
+    ExecuteEvent(dp, tc);
+    UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_OK,
+            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+            << " msg# " << dp.Response.msg());
+}
+
+void ExecuteConcat(TTestContext &tc, const TString &newKey, const TDeque<TString> &inputKeys, ui64 lockedGeneration,
+        bool keepKeys)
+{
+    TDesiredPair<TEvKeyValue::TEvExecuteTransaction> dp;
+
+    NKikimrKeyValue::ExecuteTransactionRequest::Command *cmd = dp.Request.add_commands();
+    NKikimrKeyValue::ExecuteTransactionRequest::Command::Concat *concat = cmd->mutable_concat();
+
+    concat->set_output_key(newKey);
+    concat->set_keep_inputs(keepKeys);
+    for (auto &key : inputKeys) {
+        concat->add_input_keys(key);
+    }
+
+    dp.Request.set_tablet_id(tc.TabletId);
+    dp.Request.set_lock_generation(lockedGeneration);
+
+    ExecuteEvent(dp, tc);
+    UNIT_ASSERT_C(dp.Response.status() == NKikimrKeyValue::Statuses::RSTATUS_OK,
+            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+            << " msg# " << dp.Response.msg());
+}
+
+
+template <NKikimrKeyValue::Statuses::ReplyStatus ExpectedStatus = NKikimrKeyValue::Statuses::RSTATUS_OK>
+void ExecuteRead(TTestContext &tc, const TString &key, const TString &expectedValue, ui32 offset, ui32 size,
+        ui64 lock_generation, ui64 limit_bytes=0)
+{
+    TDesiredPair<TEvKeyValue::TEvRead> dp;
+    dp.Request.set_key(key);
+    dp.Request.set_offset(offset);
+    dp.Request.set_size(size);
+    dp.Request.set_lock_generation(lock_generation);
+    dp.Request.set_tablet_id(tc.TabletId);
+    dp.Request.set_limit_bytes(limit_bytes);
+    ExecuteEvent(dp, tc);
+
+    UNIT_ASSERT_C(dp.Response.status() == ExpectedStatus,
+            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+            << " exp# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(ExpectedStatus)
+            << " msg# " << dp.Response.msg());
+    if constexpr (ExpectedStatus == NKikimrKeyValue::Statuses::RSTATUS_OK
+            || ExpectedStatus == NKikimrKeyValue::Statuses::RSTATUS_OVERRUN)
+    {
+        UNIT_ASSERT(dp.Response.value() == expectedValue);
+        if (size) {
+            UNIT_ASSERT_VALUES_EQUAL(dp.Response.requested_size(), size);
+        }
+    } else {
+        UNIT_ASSERT(dp.Response.value() == "");
+    }
+    UNIT_ASSERT_VALUES_EQUAL(dp.Response.requested_key(), key);
+    UNIT_ASSERT_VALUES_EQUAL(dp.Response.requested_offset(), offset);
+}
+
+
+template <NKikimrKeyValue::Statuses::ReplyStatus ExpectedStatus = NKikimrKeyValue::Statuses::RSTATUS_OK>
+void ExecuteReadRange(TTestContext &tc,
+        const TString &from, EBorderKind fromKind,
+        const TString &to, EBorderKind toKind,
+        const TDeque<TKeyValuePair> &expectedPairs,
+        ui64 lock_generation, bool includeData, ui64 limitBytes)
+{
+    TDesiredPair<TEvKeyValue::TEvReadRange> dp;
+
+    dp.Request.set_lock_generation(lock_generation);
+    dp.Request.set_include_data(includeData);
+    dp.Request.set_limit_bytes(limitBytes);
+    dp.Request.set_tablet_id(tc.TabletId);
+
+    auto *r = dp.Request.mutable_range();
+    switch (fromKind) {
+    case EBorderKind::Include:
+        r->set_from_key_inclusive(from);
+        break;
+    case EBorderKind::Exclude:
+        r->set_from_key_exclusive(from);
+        break;
+    case EBorderKind::Without:
+        break;
     }
-    UNIT_ASSERT_VALUES_EQUAL(dp.Response.requested_key(), key); 
-    UNIT_ASSERT_VALUES_EQUAL(dp.Response.requested_offset(), offset); 
-}
-
- 
-template <NKikimrKeyValue::Statuses::ReplyStatus ExpectedStatus = NKikimrKeyValue::Statuses::RSTATUS_OK> 
-void ExecuteReadRange(TTestContext &tc, 
-        const TString &from, EBorderKind fromKind, 
-        const TString &to, EBorderKind toKind, 
-        const TDeque<TKeyValuePair> &expectedPairs, 
-        ui64 lock_generation, bool includeData, ui64 limitBytes) 
-{ 
-    TDesiredPair<TEvKeyValue::TEvReadRange> dp; 
- 
-    dp.Request.set_lock_generation(lock_generation); 
-    dp.Request.set_include_data(includeData); 
-    dp.Request.set_limit_bytes(limitBytes); 
-    dp.Request.set_tablet_id(tc.TabletId); 
- 
-    auto *r = dp.Request.mutable_range(); 
-    switch (fromKind) { 
-    case EBorderKind::Include: 
-        r->set_from_key_inclusive(from); 
-        break; 
-    case EBorderKind::Exclude: 
-        r->set_from_key_exclusive(from); 
-        break; 
-    case EBorderKind::Without: 
-        break; 
-    } 
- 
-    switch (toKind) { 
-    case EBorderKind::Include: 
-        r->set_to_key_inclusive(to); 
-        break; 
-    case EBorderKind::Exclude: 
-        r->set_to_key_exclusive(to); 
-        break; 
-    case EBorderKind::Without: 
-        break; 
-    } 
- 
-    ExecuteEvent(dp, tc); 
-    UNIT_ASSERT_C(dp.Response.status() == ExpectedStatus, 
-            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-            << " exp# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(ExpectedStatus) 
-            << " msg# " << dp.Response.msg()); 
-    if constexpr (ExpectedStatus == NKikimrKeyValue::Statuses::RSTATUS_OK) { 
-        UNIT_ASSERT_VALUES_EQUAL(dp.Response.pair_size(), expectedPairs.size()); 
-        for (ui32 idx = 0; idx < expectedPairs.size(); ++idx) { 
-            auto &pair = dp.Response.pair(idx); 
-            UNIT_ASSERT_C(pair.status() == NKikimrKeyValue::Statuses::RSTATUS_OK || 
-                    pair.status() == NKikimrKeyValue::Statuses::RSTATUS_ERROR, 
-                    "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(pair.status()) 
-                    << " msg# " << dp.Response.msg()); 
-            UNIT_ASSERT_VALUES_EQUAL_C(pair.key(), expectedPairs[idx].Key, "msg# " << dp.Response.msg()); 
-            UNIT_ASSERT_VALUES_EQUAL_C(pair.value(), expectedPairs[idx].Value, "msg# " << dp.Response.msg()); 
-        } 
-    } 
-} 
- 
- 
-template <NKikimrKeyValue::Statuses::ReplyStatus ExpectedStatus = NKikimrKeyValue::Statuses::RSTATUS_OK> 
-void ExecuteGetStatus(TTestContext &tc, const TDeque<ui32> &channels, ui64 lock_generation) { 
-    TDesiredPair<TEvKeyValue::TEvGetStatus> dp; 
-    dp.Request.set_lock_generation(lock_generation); 
-    dp.Request.set_tablet_id(tc.TabletId); 
-    for (ui32 channel : channels) { 
-        dp.Request.add_storage_channel(channel); 
-    } 
- 
-    ExecuteEvent(dp, tc); 
-    UNIT_ASSERT_C(dp.Response.status() == ExpectedStatus, 
-            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status()) 
-            << " exp# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(ExpectedStatus) 
-            << " msg# " << dp.Response.msg()); 
-    if constexpr (ExpectedStatus == NKikimrKeyValue::Statuses::RSTATUS_OK) { 
-        for (auto &channel : dp.Response.channel()) { 
-            UNIT_ASSERT(channel.status() == NKikimrKeyValue::Statuses::RSTATUS_OK); 
-        } 
-    } 
-} 
- 
-void ExecuteObtainLock(TTestContext &tc, ui64 expectedLockGeneration) { 
-    TDesiredPair<TEvKeyValue::TEvObtainLock> dp; 
-    dp.Request.set_tablet_id(tc.TabletId); 
-    ExecuteEvent(dp, tc); 
-    UNIT_ASSERT_VALUES_EQUAL(dp.Response.lock_generation(), expectedLockGeneration); 
-} 
- 
+
+    switch (toKind) {
+    case EBorderKind::Include:
+        r->set_to_key_inclusive(to);
+        break;
+    case EBorderKind::Exclude:
+        r->set_to_key_exclusive(to);
+        break;
+    case EBorderKind::Without:
+        break;
+    }
+
+    ExecuteEvent(dp, tc);
+    UNIT_ASSERT_C(dp.Response.status() == ExpectedStatus,
+            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+            << " exp# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(ExpectedStatus)
+            << " msg# " << dp.Response.msg());
+    if constexpr (ExpectedStatus == NKikimrKeyValue::Statuses::RSTATUS_OK) {
+        UNIT_ASSERT_VALUES_EQUAL(dp.Response.pair_size(), expectedPairs.size());
+        for (ui32 idx = 0; idx < expectedPairs.size(); ++idx) {
+            auto &pair = dp.Response.pair(idx);
+            UNIT_ASSERT_C(pair.status() == NKikimrKeyValue::Statuses::RSTATUS_OK ||
+                    pair.status() == NKikimrKeyValue::Statuses::RSTATUS_ERROR,
+                    "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(pair.status())
+                    << " msg# " << dp.Response.msg());
+            UNIT_ASSERT_VALUES_EQUAL_C(pair.key(), expectedPairs[idx].Key, "msg# " << dp.Response.msg());
+            UNIT_ASSERT_VALUES_EQUAL_C(pair.value(), expectedPairs[idx].Value, "msg# " << dp.Response.msg());
+        }
+    }
+}
+
+
+template <NKikimrKeyValue::Statuses::ReplyStatus ExpectedStatus = NKikimrKeyValue::Statuses::RSTATUS_OK>
+void ExecuteGetStatus(TTestContext &tc, const TDeque<ui32> &channels, ui64 lock_generation) {
+    TDesiredPair<TEvKeyValue::TEvGetStatus> dp;
+    dp.Request.set_lock_generation(lock_generation);
+    dp.Request.set_tablet_id(tc.TabletId);
+    for (ui32 channel : channels) {
+        dp.Request.add_storage_channel(channel);
+    }
+
+    ExecuteEvent(dp, tc);
+    UNIT_ASSERT_C(dp.Response.status() == ExpectedStatus,
+            "got# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(dp.Response.status())
+            << " exp# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(ExpectedStatus)
+            << " msg# " << dp.Response.msg());
+    if constexpr (ExpectedStatus == NKikimrKeyValue::Statuses::RSTATUS_OK) {
+        for (auto &channel : dp.Response.channel()) {
+            UNIT_ASSERT(channel.status() == NKikimrKeyValue::Statuses::RSTATUS_OK);
+        }
+    }
+}
+
+void ExecuteObtainLock(TTestContext &tc, ui64 expectedLockGeneration) {
+    TDesiredPair<TEvKeyValue::TEvObtainLock> dp;
+    dp.Request.set_tablet_id(tc.TabletId);
+    ExecuteEvent(dp, tc);
+    UNIT_ASSERT_VALUES_EQUAL(dp.Response.lock_generation(), expectedLockGeneration);
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // TEST CASES
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-Y_UNIT_TEST(TestBasicWriteRead) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        ExecuteWrite(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteRead(tc, "key", "value", 0, 0, 0); 
-    }); 
-} 
- 
-Y_UNIT_TEST(TestBasicWriteReadOverrun) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        ExecuteWrite(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ui64 limitBytes = 1 + 5 + 3 // Key id, length 
-                    + 1 + 5 + 1 // Value id, length, value 
-                    + 1 + 8 // Offset id, value 
-                    + 1 + 8 // Size id, value 
-                    + 1 + 1 // Status id, value 
-                    ; 
-        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_OVERRUN>(tc, "key", "v", 0, 0, 0, limitBytes); 
-    }); 
-} 
- 
+Y_UNIT_TEST(TestBasicWriteRead) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        ExecuteWrite(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteRead(tc, "key", "value", 0, 0, 0);
+    });
+}
+
+Y_UNIT_TEST(TestBasicWriteReadOverrun) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        ExecuteWrite(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ui64 limitBytes = 1 + 5 + 3 // Key id, length
+                    + 1 + 5 + 1 // Value id, length, value
+                    + 1 + 8 // Offset id, value
+                    + 1 + 8 // Size id, value
+                    + 1 + 1 // Status id, value
+                    ;
+        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_OVERRUN>(tc, "key", "v", 0, 0, 0, limitBytes);
+    });
+}
+
 Y_UNIT_TEST(TestWriteReadDeleteWithRestartsThenResponseOk) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -868,22 +868,22 @@ Y_UNIT_TEST(TestWriteReadDeleteWithRestartsThenResponseOk) {
     });
 }
 
- 
-Y_UNIT_TEST(TestWriteReadDeleteWithRestartsThenResponseOkWithNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        ExecuteWrite(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteRead(tc, "key", "value", 0, 0, 0); 
-        ExecuteDeleteRange(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 0); 
-        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key", "", 0, 0, 0); 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestWriteReadDeleteWithRestartsThenResponseOkWithNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        ExecuteWrite(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteRead(tc, "key", "value", 0, 0, 0);
+        ExecuteDeleteRange(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 0);
+        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key", "", 0, 0, 0);
+    });
+}
+
+
 Y_UNIT_TEST(TestRewriteThenLastValue) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -908,27 +908,27 @@ Y_UNIT_TEST(TestRewriteThenLastValue) {
     });
 }
 
- 
-Y_UNIT_TEST(TestRewriteThenLastValueNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        TVector<ui32> channels = {0, 1}; 
-        for (auto &ch1 : channels) { 
-            for (auto &ch2 : channels) { 
-                ExecuteWrite(tc, {{"key", "value"}}, 0, ch1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-                ExecuteRead(tc, "key", "value", 0, 0, 0); 
-                ExecuteWrite(tc, {{"key", "updated"}}, 0, ch2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-                ExecuteRead(tc, "key", "updated", 0, 0, 0); 
-            } 
-        } 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestRewriteThenLastValueNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        TVector<ui32> channels = {0, 1};
+        for (auto &ch1 : channels) {
+            for (auto &ch2 : channels) {
+                ExecuteWrite(tc, {{"key", "value"}}, 0, ch1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+                ExecuteRead(tc, "key", "value", 0, 0, 0);
+                ExecuteWrite(tc, {{"key", "updated"}}, 0, ch2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+                ExecuteRead(tc, "key", "updated", 0, 0, 0);
+            }
+        }
+    });
+}
+
+
 Y_UNIT_TEST(TestWriteTrimWithRestartsThenResponseOk) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1023,22 +1023,22 @@ Y_UNIT_TEST(TestInlineWriteReadDeleteWithRestartsThenResponseOk) {
     });
 }
 
- 
-Y_UNIT_TEST(TestInlineWriteReadDeleteWithRestartsThenResponseOkNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        ExecuteWrite(tc, {{"key", "value"}}, 0, 1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteRead(tc, "key", "value", 0, 0, 0); 
-        ExecuteDeleteRange(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 0); 
-        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key", "", 0, 0, 0); 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestInlineWriteReadDeleteWithRestartsThenResponseOkNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        ExecuteWrite(tc, {{"key", "value"}}, 0, 1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteRead(tc, "key", "value", 0, 0, 0);
+        ExecuteDeleteRange(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 0);
+        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key", "", 0, 0, 0);
+    });
+}
+
+
 Y_UNIT_TEST(TestWrite200KDeleteThenResponseError) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1067,32 +1067,32 @@ Y_UNIT_TEST(TestWrite200KDeleteThenResponseError) {
     });
 }
 
- 
-Y_UNIT_TEST(TestWrite200KDeleteThenResponseErrorNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        tc.Runtime->GetAppData(0).AllowHugeKeyValueDeletes = false; 
-        tc.Runtime->SetDispatchedEventsLimit(10'000'0000); 
-        activeZone = false; 
-        const ui32 BatchCount = 60; 
-        const ui32 ItemsPerBatch = 2048; 
-        for (ui32 i = 0; i < BatchCount; ++i) { 
-            TDeque<TKeyValuePair> pairs; 
-            for (ui32 j = 0; j < ItemsPerBatch; ++j) { 
-                TString key = Sprintf("k%08" PRIu32, i * ItemsPerBatch + j); 
-                pairs.push_back({key, TString("v")}); 
-            } 
-            ExecuteWrite(tc, pairs, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_BACKGROUND); 
-        } 
-        ExecuteDeleteRange<false>(tc, "a", EBorderKind::Include, "z", EBorderKind::Include, 0); 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestWrite200KDeleteThenResponseErrorNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        tc.Runtime->GetAppData(0).AllowHugeKeyValueDeletes = false;
+        tc.Runtime->SetDispatchedEventsLimit(10'000'0000);
+        activeZone = false;
+        const ui32 BatchCount = 60;
+        const ui32 ItemsPerBatch = 2048;
+        for (ui32 i = 0; i < BatchCount; ++i) {
+            TDeque<TKeyValuePair> pairs;
+            for (ui32 j = 0; j < ItemsPerBatch; ++j) {
+                TString key = Sprintf("k%08" PRIu32, i * ItemsPerBatch + j);
+                pairs.push_back({key, TString("v")});
+            }
+            ExecuteWrite(tc, pairs, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_BACKGROUND);
+        }
+        ExecuteDeleteRange<false>(tc, "a", EBorderKind::Include, "z", EBorderKind::Include, 0);
+    });
+}
+
+
 /*Y_UNIT_TEST(TestWrite16MillionReadDeleteWithRestartsThenResponseOk) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1164,19 +1164,19 @@ Y_UNIT_TEST(TestWriteReadWithRestartsThenResponseOk) {
             expectedValues.push_back(values[itemIdx]);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("key1", true, "key4", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                     expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("key0", false, "key4", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                     expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("key0", false, "key3", true, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                     expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -1184,38 +1184,38 @@ Y_UNIT_TEST(TestWriteReadWithRestartsThenResponseOk) {
     });
 }
 
- 
-Y_UNIT_TEST(TestWriteReadWithRestartsThenResponseOkNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        TDeque<TKeyValuePair> pairs; 
-        { 
-            TStringBuilder value; 
-            for (ui32 itemIdx = 0; itemIdx <= 4; ++itemIdx) { 
-                value << "x"; 
-                pairs.push_back({Sprintf("key%" PRIu32, itemIdx), TString(value)}); 
-            } 
-        } 
- 
-        ExecuteWrite(tc, pairs, 0, 11, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
- 
-        TDeque<TKeyValuePair> expectedPairs; 
-        for (ui32 itemIdx = 1; itemIdx < 4; ++itemIdx) { 
-            expectedPairs.push_back(pairs[itemIdx]); 
-        } 
- 
-        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key4", EBorderKind::Exclude, expectedPairs, 0, true, 0); 
-        ExecuteReadRange(tc, "key0", EBorderKind::Exclude, "key4", EBorderKind::Exclude, expectedPairs, 0, true, 0); 
-        ExecuteReadRange(tc, "key0", EBorderKind::Exclude, "key3", EBorderKind::Include, expectedPairs, 0, true, 0); 
-        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key3", EBorderKind::Include, expectedPairs, 0, true, 0); 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestWriteReadWithRestartsThenResponseOkNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        TDeque<TKeyValuePair> pairs;
+        {
+            TStringBuilder value;
+            for (ui32 itemIdx = 0; itemIdx <= 4; ++itemIdx) {
+                value << "x";
+                pairs.push_back({Sprintf("key%" PRIu32, itemIdx), TString(value)});
+            }
+        }
+
+        ExecuteWrite(tc, pairs, 0, 11, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+
+        TDeque<TKeyValuePair> expectedPairs;
+        for (ui32 itemIdx = 1; itemIdx < 4; ++itemIdx) {
+            expectedPairs.push_back(pairs[itemIdx]);
+        }
+
+        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key4", EBorderKind::Exclude, expectedPairs, 0, true, 0);
+        ExecuteReadRange(tc, "key0", EBorderKind::Exclude, "key4", EBorderKind::Exclude, expectedPairs, 0, true, 0);
+        ExecuteReadRange(tc, "key0", EBorderKind::Exclude, "key3", EBorderKind::Include, expectedPairs, 0, true, 0);
+        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key3", EBorderKind::Include, expectedPairs, 0, true, 0);
+    });
+}
+
+
 Y_UNIT_TEST(TestInlineWriteReadWithRestartsThenResponseOk) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1250,19 +1250,19 @@ Y_UNIT_TEST(TestInlineWriteReadWithRestartsThenResponseOk) {
             expectedValues.push_back(values[itemIdx]);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("key1", true, "key4", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                     expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("key0", false, "key4", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                     expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("key0", false, "key3", true, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                     expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -1271,52 +1271,52 @@ Y_UNIT_TEST(TestInlineWriteReadWithRestartsThenResponseOk) {
 }
 
 
-Y_UNIT_TEST(TestInlineWriteReadWithRestartsThenResponseOkNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        TDeque<TKeyValuePair> expectedPairs; 
-        { 
-            TStringBuilder value; 
-            for (ui32 itemIdx = 0; itemIdx <= 4; ++itemIdx) { 
-                value << "x"; 
-                TKeyValuePair pair{Sprintf("key%" PRIu32, itemIdx), TString(value)}; 
-                if (itemIdx && itemIdx < 4) { 
-                    expectedPairs.push_back(pair); 
-                } 
-                ExecuteWrite(tc, {pair}, 0, itemIdx % 2 == 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-            } 
-        } 
-
-        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key4", EBorderKind::Exclude, expectedPairs, 0, true, 0); 
-        ExecuteReadRange(tc, "key0", EBorderKind::Exclude, "key4", EBorderKind::Exclude, expectedPairs, 0, true, 0); 
-        ExecuteReadRange(tc, "key0", EBorderKind::Exclude, "key3", EBorderKind::Include, expectedPairs, 0, true, 0); 
-        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key3", EBorderKind::Include, expectedPairs, 0, true, 0); 
-    }); 
-} 
- 
-Y_UNIT_TEST(TestInlineWriteReadWithRestartsWithNotCorrectUTF8NewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
- 
-        TDeque<TKeyValuePair> expectedPairs; 
-        TKeyValuePair pair{TString("key1\0"), TString("value")}; 
-        expectedPairs.push_back({TString("key1\\0"), TString()}); 
-        ExecuteWrite(tc, {pair}, 0, 1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
- 
-        ExecuteReadRange<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key0", EBorderKind::Include, 
-                "key1", EBorderKind::Exclude, expectedPairs, 0, true, 0); 
-    }); 
-} 
- 
- 
+Y_UNIT_TEST(TestInlineWriteReadWithRestartsThenResponseOkNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        TDeque<TKeyValuePair> expectedPairs;
+        {
+            TStringBuilder value;
+            for (ui32 itemIdx = 0; itemIdx <= 4; ++itemIdx) {
+                value << "x";
+                TKeyValuePair pair{Sprintf("key%" PRIu32, itemIdx), TString(value)};
+                if (itemIdx && itemIdx < 4) {
+                    expectedPairs.push_back(pair);
+                }
+                ExecuteWrite(tc, {pair}, 0, itemIdx % 2 == 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+            }
+        }
+
+        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key4", EBorderKind::Exclude, expectedPairs, 0, true, 0);
+        ExecuteReadRange(tc, "key0", EBorderKind::Exclude, "key4", EBorderKind::Exclude, expectedPairs, 0, true, 0);
+        ExecuteReadRange(tc, "key0", EBorderKind::Exclude, "key3", EBorderKind::Include, expectedPairs, 0, true, 0);
+        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key3", EBorderKind::Include, expectedPairs, 0, true, 0);
+    });
+}
+
+Y_UNIT_TEST(TestInlineWriteReadWithRestartsWithNotCorrectUTF8NewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+
+        TDeque<TKeyValuePair> expectedPairs;
+        TKeyValuePair pair{TString("key1\0"), TString("value")};
+        expectedPairs.push_back({TString("key1\\0"), TString()});
+        ExecuteWrite(tc, {pair}, 0, 1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+
+        ExecuteReadRange<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key0", EBorderKind::Include,
+                "key1", EBorderKind::Exclude, expectedPairs, 0, true, 0);
+    });
+}
+
+
 Y_UNIT_TEST(TestEmptyWriteReadDeleteWithRestartsThenResponseOk) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1334,7 +1334,7 @@ Y_UNIT_TEST(TestEmptyWriteReadDeleteWithRestartsThenResponseOk) {
         expectedKeys.push_back("key");
         expectedValues.push_back("");
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("a", true, "z", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                     expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -1346,26 +1346,26 @@ Y_UNIT_TEST(TestEmptyWriteReadDeleteWithRestartsThenResponseOk) {
     });
 }
 
- 
-Y_UNIT_TEST(TestEmptyWriteReadDeleteWithRestartsThenResponseOkNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        TDeque<TKeyValuePair> pairs; 
-        pairs.push_back({"key", ""}); 
-        ExecuteWrite(tc, pairs, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteRead(tc, "key", "", 0, 0, 0); 
- 
-        ExecuteReadRange(tc, "", EBorderKind::Without, "", EBorderKind::Without, pairs, 0, true, 0); 
-        ExecuteDeleteRange(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 0); 
-        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key", "", 0, 0, 0); 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestEmptyWriteReadDeleteWithRestartsThenResponseOkNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        TDeque<TKeyValuePair> pairs;
+        pairs.push_back({"key", ""});
+        ExecuteWrite(tc, pairs, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteRead(tc, "key", "", 0, 0, 0);
+
+        ExecuteReadRange(tc, "", EBorderKind::Without, "", EBorderKind::Without, pairs, 0, true, 0);
+        ExecuteDeleteRange(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 0);
+        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key", "", 0, 0, 0);
+    });
+}
+
+
 Y_UNIT_TEST(TestInlineEmptyWriteReadDeleteWithRestartsThenResponseOk) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1383,7 +1383,7 @@ Y_UNIT_TEST(TestInlineEmptyWriteReadDeleteWithRestartsThenResponseOk) {
         expectedKeys.push_back("key");
         expectedValues.push_back("");
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("a", true, "z", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                 expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -1395,26 +1395,26 @@ Y_UNIT_TEST(TestInlineEmptyWriteReadDeleteWithRestartsThenResponseOk) {
     });
 }
 
- 
-Y_UNIT_TEST(TestInlineEmptyWriteReadDeleteWithRestartsThenResponseOkNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        TDeque<TKeyValuePair> pairs; 
-        pairs.push_back({"key", ""}); 
-        ExecuteWrite(tc, pairs, 0, 1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteRead(tc, "key", "", 0, 0, 0); 
- 
-        ExecuteReadRange(tc, "", EBorderKind::Without, "", EBorderKind::Without, pairs, 0, true, 0); 
-        ExecuteDeleteRange(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 0); 
-        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key", "", 0, 0, 0); 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestInlineEmptyWriteReadDeleteWithRestartsThenResponseOkNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        TDeque<TKeyValuePair> pairs;
+        pairs.push_back({"key", ""});
+        ExecuteWrite(tc, pairs, 0, 1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteRead(tc, "key", "", 0, 0, 0);
+
+        ExecuteReadRange(tc, "", EBorderKind::Without, "", EBorderKind::Without, pairs, 0, true, 0);
+        ExecuteDeleteRange(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 0);
+        ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_NO_DATA>(tc, "key", "", 0, 0, 0);
+    });
+}
+
+
 TString PrepareData(ui32 size, ui32 flavor) {
     TString data = TString::Uninitialized(size);
     for (ui32 i = 0; i < size; ++i) {
@@ -1455,13 +1455,13 @@ Y_UNIT_TEST(TestWriteReadRangeLimitThenLimitWorks) {
         Y_VERIFY(expectedKeys.size());
 
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("k0000000", true, "k9999999", true, false, sizeLimit,
                     NKikimrClient::TKeyValueRequest::REALTIME, expectedKeys, expectedValues, NKikimrProto::OVERRUN, tc, dp);
             RunRequest(dp, tc, __LINE__);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("k0000000", true, "k9999999", true, false, sizeLimit,
                     NKikimrClient::TKeyValueRequest::REALTIME, expectedKeys, expectedValues, NKikimrProto::OVERRUN, tc, dp);
             AddCmdReadRange("k0000000", true, "k9999999", true, false, sizeLimit,
@@ -1469,7 +1469,7 @@ Y_UNIT_TEST(TestWriteReadRangeLimitThenLimitWorks) {
             RunRequest(dp, tc, __LINE__);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("k0000000", true, expectedKeys[expectedKeys.size() - 1], true, false, sizeLimit,
                     NKikimrClient::TKeyValueRequest::REALTIME, expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
             AddCmdReadRange("k0000000", true, "k9999999", true, false, sizeLimit,
@@ -1481,43 +1481,43 @@ Y_UNIT_TEST(TestWriteReadRangeLimitThenLimitWorks) {
     });
 }
 
- 
-Y_UNIT_TEST(TestWriteReadRangeLimitThenLimitWorksNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        const ui32 itemCount = 1000; 
-        TDeque<TKeyValuePair> pairs; 
-        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) { 
-            pairs.push_back({Sprintf("k%07" PRIu32, itemIdx), PrepareData(10000, itemIdx)}); 
-        } 
-        ExecuteWrite(tc, pairs, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
- 
-        TDeque<TKeyValuePair> expectedPairs; 
-        ui64 totalSize = 0; 
-        ui64 sizeLimit = 200; 
-        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) { 
-            totalSize += pairs[itemIdx].Key.size() + 32; 
-            if (totalSize > sizeLimit) { 
-                break; 
-            } 
-            expectedPairs.push_back({pairs[itemIdx].Key, ""}); 
-        } 
-        Y_VERIFY(expectedPairs.size()); 
- 
-        ExecuteReadRange(tc, "", EBorderKind::Without, 
-                expectedPairs[expectedPairs.size() - 1].Key, EBorderKind::Include, 
-                expectedPairs, 0, false, sizeLimit); 
-        ExecuteReadRange<NKikimrKeyValue::Statuses::RSTATUS_OVERRUN>(tc, 
-                "", EBorderKind::Without, "", EBorderKind::Without, 
-                expectedPairs, 0, false, sizeLimit); 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestWriteReadRangeLimitThenLimitWorksNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        const ui32 itemCount = 1000;
+        TDeque<TKeyValuePair> pairs;
+        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) {
+            pairs.push_back({Sprintf("k%07" PRIu32, itemIdx), PrepareData(10000, itemIdx)});
+        }
+        ExecuteWrite(tc, pairs, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+
+        TDeque<TKeyValuePair> expectedPairs;
+        ui64 totalSize = 0;
+        ui64 sizeLimit = 200;
+        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) {
+            totalSize += pairs[itemIdx].Key.size() + 32;
+            if (totalSize > sizeLimit) {
+                break;
+            }
+            expectedPairs.push_back({pairs[itemIdx].Key, ""});
+        }
+        Y_VERIFY(expectedPairs.size());
+
+        ExecuteReadRange(tc, "", EBorderKind::Without,
+                expectedPairs[expectedPairs.size() - 1].Key, EBorderKind::Include,
+                expectedPairs, 0, false, sizeLimit);
+        ExecuteReadRange<NKikimrKeyValue::Statuses::RSTATUS_OVERRUN>(tc,
+                "", EBorderKind::Without, "", EBorderKind::Without,
+                expectedPairs, 0, false, sizeLimit);
+    });
+}
+
+
 Y_UNIT_TEST(TestWriteReadRangeDataLimitThenLimitWorks) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1550,13 +1550,13 @@ Y_UNIT_TEST(TestWriteReadRangeDataLimitThenLimitWorks) {
         Y_VERIFY(expectedKeys.size());
 
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("k0000000", true, "k9999999", true, true, sizeLimit,
                 NKikimrClient::TKeyValueRequest::REALTIME, expectedKeys, expectedValues, NKikimrProto::OVERRUN, tc, dp);
             RunRequest(dp, tc, __LINE__);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("k0000000", true, "k9999999", true, true, sizeLimit,
                 NKikimrClient::TKeyValueRequest::REALTIME, expectedKeys, expectedValues, NKikimrProto::OVERRUN, tc, dp);
             AddCmdReadRange("k0000000", true, "k9999999", true, true, sizeLimit,
@@ -1566,46 +1566,46 @@ Y_UNIT_TEST(TestWriteReadRangeDataLimitThenLimitWorks) {
     });
 }
 
- 
-void MakeTestWriteReadRangeDataLimitThenLimitWorksNewApi(ui32 storageChannel) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        const ui32 itemCount = 1000; 
-        TDeque<TKeyValuePair> pairs; 
-        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) { 
-            pairs.push_back({Sprintf("k%07" PRIu32, itemIdx), PrepareData(8, itemIdx)}); 
-        } 
-        ExecuteWrite(tc, pairs, 0, storageChannel, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
- 
-        TDeque<TKeyValuePair> expectedPairs; 
-        ui64 totalSize = 0; 
-        ui64 sizeLimit = 200; 
-        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) { 
-            totalSize += pairs[itemIdx].Key.size() + pairs[itemIdx].Value.size() + 32; 
-            if (totalSize > sizeLimit) { 
-                break; 
-            } 
-            expectedPairs.push_back(pairs[itemIdx]); 
-        } 
- 
-        ExecuteReadRange(tc, "", EBorderKind::Without, 
-                expectedPairs[expectedPairs.size() - 1].Key, EBorderKind::Include, 
-                expectedPairs, 0, true, sizeLimit); 
-        ExecuteReadRange<NKikimrKeyValue::Statuses::RSTATUS_OVERRUN>(tc, 
-                "", EBorderKind::Without, "", EBorderKind::Without, 
-                expectedPairs, 0, true, sizeLimit); 
-    }); 
-} 
- 
-Y_UNIT_TEST(TestWriteReadRangeDataLimitThenLimitWorksNewApi) { 
-    MakeTestWriteReadRangeDataLimitThenLimitWorksNewApi(0); 
-} 
- 
- 
+
+void MakeTestWriteReadRangeDataLimitThenLimitWorksNewApi(ui32 storageChannel) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        const ui32 itemCount = 1000;
+        TDeque<TKeyValuePair> pairs;
+        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) {
+            pairs.push_back({Sprintf("k%07" PRIu32, itemIdx), PrepareData(8, itemIdx)});
+        }
+        ExecuteWrite(tc, pairs, 0, storageChannel, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+
+        TDeque<TKeyValuePair> expectedPairs;
+        ui64 totalSize = 0;
+        ui64 sizeLimit = 200;
+        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) {
+            totalSize += pairs[itemIdx].Key.size() + pairs[itemIdx].Value.size() + 32;
+            if (totalSize > sizeLimit) {
+                break;
+            }
+            expectedPairs.push_back(pairs[itemIdx]);
+        }
+
+        ExecuteReadRange(tc, "", EBorderKind::Without,
+                expectedPairs[expectedPairs.size() - 1].Key, EBorderKind::Include,
+                expectedPairs, 0, true, sizeLimit);
+        ExecuteReadRange<NKikimrKeyValue::Statuses::RSTATUS_OVERRUN>(tc,
+                "", EBorderKind::Without, "", EBorderKind::Without,
+                expectedPairs, 0, true, sizeLimit);
+    });
+}
+
+Y_UNIT_TEST(TestWriteReadRangeDataLimitThenLimitWorksNewApi) {
+    MakeTestWriteReadRangeDataLimitThenLimitWorksNewApi(0);
+}
+
+
 Y_UNIT_TEST(TestInlineWriteReadRangeLimitThenLimitWorks) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1638,13 +1638,13 @@ Y_UNIT_TEST(TestInlineWriteReadRangeLimitThenLimitWorks) {
         Y_VERIFY(expectedKeys.size());
 
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("k0000000", true, "k9999999", true, true, sizeLimit,
                 NKikimrClient::TKeyValueRequest::REALTIME, expectedKeys, expectedValues, NKikimrProto::OVERRUN, tc, dp);
             RunRequest(dp, tc, __LINE__);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("k0000000", true, "k9999999", true, true, sizeLimit,
                 NKikimrClient::TKeyValueRequest::REALTIME, expectedKeys, expectedValues, NKikimrProto::OVERRUN, tc, dp);
             AddCmdReadRange("k0000000", true, "k9999999", true, true, sizeLimit,
@@ -1654,12 +1654,12 @@ Y_UNIT_TEST(TestInlineWriteReadRangeLimitThenLimitWorks) {
     });
 }
 
- 
-Y_UNIT_TEST(TestInlineWriteReadRangeLimitThenLimitWorksNewApi) { 
-    MakeTestWriteReadRangeDataLimitThenLimitWorksNewApi(1); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestInlineWriteReadRangeLimitThenLimitWorksNewApi) {
+    MakeTestWriteReadRangeDataLimitThenLimitWorksNewApi(1);
+}
+
+
 Y_UNIT_TEST(TestCopyRangeWorks) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1687,49 +1687,49 @@ Y_UNIT_TEST(TestCopyRangeWorks) {
             expectedKeys.push_back(Sprintf("pk%07" PRIu32, itemIdx));
             expectedValues.push_back(Sprintf("v%07" PRIu32, (ui32)itemIdx));
         }
-        TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+        TDesiredPair<TEvKeyValue::TEvRequest> dp;
         AddCmdReadRange("p", false, "q", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
             expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
         RunRequest(dp, tc, __LINE__);
     });
 }
 
- 
-void MakeTestCopyRangeWorksNewApi(ui64 storageChannel) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        const ui32 itemCount = 100; 
-        TDeque<TKeyValuePair> pairs; 
-        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) { 
-            pairs.push_back({Sprintf("k%07" PRIu32, itemIdx), Sprintf("v%07" PRIu32, (ui32)itemIdx)}); 
-        } 
-        ExecuteWrite(tc, pairs, 0, storageChannel, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
- 
-        ExecuteCopyRange(tc, "", EBorderKind::Without, "", EBorderKind::Without, 0, "p", ""); 
-        ExecuteWrite(tc, {{"0", "0"}}, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
- 
-        TDeque<TString> expectedKeys; 
-        TDeque<TString> expectedValues; 
- 
-        TDeque<TKeyValuePair> expectedPairs; 
-        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) { 
-            expectedPairs.push_back({Sprintf("pk%07" PRIu32, itemIdx), Sprintf("v%07" PRIu32, (ui32)itemIdx)}); 
-        } 
-        ExecuteReadRange(tc, "p", EBorderKind::Exclude, "q", EBorderKind::Exclude, 
-                expectedPairs, 0, true, 0); 
-    }); 
-} 
- 
- 
-Y_UNIT_TEST(TestCopyRangeWorksNewApi) { 
-    MakeTestCopyRangeWorksNewApi(0); 
-} 
- 
- 
+
+void MakeTestCopyRangeWorksNewApi(ui64 storageChannel) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        const ui32 itemCount = 100;
+        TDeque<TKeyValuePair> pairs;
+        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) {
+            pairs.push_back({Sprintf("k%07" PRIu32, itemIdx), Sprintf("v%07" PRIu32, (ui32)itemIdx)});
+        }
+        ExecuteWrite(tc, pairs, 0, storageChannel, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+
+        ExecuteCopyRange(tc, "", EBorderKind::Without, "", EBorderKind::Without, 0, "p", "");
+        ExecuteWrite(tc, {{"0", "0"}}, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+
+        TDeque<TString> expectedKeys;
+        TDeque<TString> expectedValues;
+
+        TDeque<TKeyValuePair> expectedPairs;
+        for (ui32 itemIdx = 0; itemIdx < itemCount; ++itemIdx) {
+            expectedPairs.push_back({Sprintf("pk%07" PRIu32, itemIdx), Sprintf("v%07" PRIu32, (ui32)itemIdx)});
+        }
+        ExecuteReadRange(tc, "p", EBorderKind::Exclude, "q", EBorderKind::Exclude,
+                expectedPairs, 0, true, 0);
+    });
+}
+
+
+Y_UNIT_TEST(TestCopyRangeWorksNewApi) {
+    MakeTestCopyRangeWorksNewApi(0);
+}
+
+
 Y_UNIT_TEST(TestInlineCopyRangeWorks) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1763,7 +1763,7 @@ Y_UNIT_TEST(TestInlineCopyRangeWorks) {
             expectedKeys.push_back(Sprintf("pk%07" PRIu32, itemIdx));
             expectedValues.push_back(Sprintf("v%07" PRIu32, (ui32)itemIdx));
         }
-        TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+        TDesiredPair<TEvKeyValue::TEvRequest> dp;
         AddCmdReadRange("p", false, "q", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
             expectedKeys, expectedValues, NKikimrProto::OK, tc, dp);
         RunRequest(dp, tc, __LINE__);
@@ -1771,11 +1771,11 @@ Y_UNIT_TEST(TestInlineCopyRangeWorks) {
 }
 
 
-Y_UNIT_TEST(TestInlineCopyRangeWorksNewApi) { 
-    MakeTestCopyRangeWorksNewApi(1); 
-} 
+Y_UNIT_TEST(TestInlineCopyRangeWorksNewApi) {
+    MakeTestCopyRangeWorksNewApi(1);
+}
+
 
- 
 Y_UNIT_TEST(TestConcatWorks) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1787,14 +1787,14 @@ Y_UNIT_TEST(TestConcatWorks) {
             NKikimrClient::TKeyValueRequest::REALTIME, tc);
         CmdConcat({"1", "2", "3", "4"}, "5", false, tc);
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("1", true, "5", true, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                     {"5"}, {"hello, world!"}, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
         }
         CmdConcat({"5", "5"}, "5", true, tc);
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("1", true, "5", true, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                 {"5"}, {"hello, world!hello, world!"}, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -1803,29 +1803,29 @@ Y_UNIT_TEST(TestConcatWorks) {
 }
 
 
-Y_UNIT_TEST(TestConcatWorksNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        TDeque<TKeyValuePair> pairs = { 
-            {"1", "hello"}, 
-            {"2", ", "}, 
-            {"3", "world"}, 
-            {"4", "!"}, 
-        }; 
-        ExecuteWrite(tc, pairs, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteConcat(tc, "5", {"1", "2", "3", "4"}, 0, false); 
-        ExecuteReadRange(tc, "1", EBorderKind::Include, "5", EBorderKind::Include, {{"5", "hello, world!"}}, 0, true, 0); 
-        ExecuteConcat(tc, "5", {"5", "5"}, 0, true); 
-        ExecuteReadRange(tc, "1", EBorderKind::Include, "5", EBorderKind::Include, 
-                {{"5", "hello, world!hello, world!"}}, 0, true, 0); 
-    }); 
-} 
- 
- 
+Y_UNIT_TEST(TestConcatWorksNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        TDeque<TKeyValuePair> pairs = {
+            {"1", "hello"},
+            {"2", ", "},
+            {"3", "world"},
+            {"4", "!"},
+        };
+        ExecuteWrite(tc, pairs, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteConcat(tc, "5", {"1", "2", "3", "4"}, 0, false);
+        ExecuteReadRange(tc, "1", EBorderKind::Include, "5", EBorderKind::Include, {{"5", "hello, world!"}}, 0, true, 0);
+        ExecuteConcat(tc, "5", {"5", "5"}, 0, true);
+        ExecuteReadRange(tc, "1", EBorderKind::Include, "5", EBorderKind::Include,
+                {{"5", "hello, world!hello, world!"}}, 0, true, 0);
+    });
+}
+
+
 Y_UNIT_TEST(TestRenameWorks) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1837,7 +1837,7 @@ Y_UNIT_TEST(TestRenameWorks) {
             NKikimrClient::TKeyValueRequest::REALTIME, tc);
         CmdRename("2", "3", tc);
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("1", true, "3", true, true, 1000, NKikimrClient::TKeyValueRequest::REALTIME,
                 {"1", "3"}, {"123", "456"}, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -1846,28 +1846,28 @@ Y_UNIT_TEST(TestRenameWorks) {
 }
 
 
-Y_UNIT_TEST(TestRenameWorksewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
- 
-        TDeque<TKeyValuePair> pairs = { 
-            {"1", "123"}, 
-            {"2", "456"}, 
-            {"3", "789"}, 
-            {"4", "012"}, 
-        }; 
-        ExecuteWrite(tc, pairs, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteRename(tc, {{"2", "3"}}, 0); 
-        ExecuteReadRange(tc, "1", EBorderKind::Include, "3", EBorderKind::Include, 
-                {{"1", "123"}, {"3", "456"}}, 0, true, 0); 
-   }); 
-} 
- 
- 
+Y_UNIT_TEST(TestRenameWorksewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+
+        TDeque<TKeyValuePair> pairs = {
+            {"1", "123"},
+            {"2", "456"},
+            {"3", "789"},
+            {"4", "012"},
+        };
+        ExecuteWrite(tc, pairs, 0, 0, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteRename(tc, {{"2", "3"}}, 0);
+        ExecuteReadRange(tc, "1", EBorderKind::Include, "3", EBorderKind::Include,
+                {{"1", "123"}, {"3", "456"}}, 0, true, 0);
+   });
+}
+
+
 Y_UNIT_TEST(TestWriteToExtraChannelThenReadMixedChannelsReturnsOk) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -1884,7 +1884,7 @@ Y_UNIT_TEST(TestWriteToExtraChannelThenReadMixedChannelsReturnsOk) {
         CmdRead({"key1", "key2", "key3"}, NKikimrClient::TKeyValueRequest::REALTIME,
             {"value1", "value2", "value3"}, {}, tc);
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("key1", true, "key3", true, true, 1000, NKikimrClient::TKeyValueRequest::REALTIME,
                 {"key1", "key2", "key3"}, {"value1", "value2", "value3"}, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -1892,24 +1892,24 @@ Y_UNIT_TEST(TestWriteToExtraChannelThenReadMixedChannelsReturnsOk) {
     });
 }
 
- 
-Y_UNIT_TEST(TestWriteToExtraChannelThenReadMixedChannelsReturnsOkNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
- 
-        ExecuteWrite(tc, {{"key1", "value1"}}, 0, 1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteWrite(tc, {{"key2", "value2"}}, 0, 3, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteWrite(tc, {{"key3", "value3"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key3", EBorderKind::Include, 
-                {{"key1", "value1"}, {"key2", "value2"}, {"key3", "value3"}}, 0, true, 0); 
-    }); 
-} 
- 
- 
+
+Y_UNIT_TEST(TestWriteToExtraChannelThenReadMixedChannelsReturnsOkNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+
+        ExecuteWrite(tc, {{"key1", "value1"}}, 0, 1, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteWrite(tc, {{"key2", "value2"}}, 0, 3, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteWrite(tc, {{"key3", "value3"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteReadRange(tc, "key1", EBorderKind::Include, "key3", EBorderKind::Include,
+                {{"key1", "value1"}, {"key2", "value2"}, {"key3", "value3"}}, 0, true, 0);
+    });
+}
+
+
 Y_UNIT_TEST(TestIncrementalKeySet) {
     // generate initial key set
     TSet<TString> keys;
@@ -2003,17 +2003,17 @@ Y_UNIT_TEST(TestGetStatusWorks) {
    });
 }
 
-Y_UNIT_TEST(TestGetStatusWorksNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        ExecuteGetStatus(tc, {1, 2}, 0); 
-   }); 
-} 
- 
+Y_UNIT_TEST(TestGetStatusWorksNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        ExecuteGetStatus(tc, {1, 2}, 0);
+   });
+}
+
 Y_UNIT_TEST(TestWriteReadWhileWriteWorks) {
     TTestContext tc;
     RunTestWithReboots(tc.TabletIds, [&]() {
@@ -2092,7 +2092,7 @@ Y_UNIT_TEST(TestWriteDeleteThenReadRemaining) {
                     NKikimrClient::TKeyValueRequest::REALTIME, tc);
         }
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("a", true, "z", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                 allKeys, allValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -2120,7 +2120,7 @@ Y_UNIT_TEST(TestWriteDeleteThenReadRemaining) {
         // Cerr << "total keys: " << BatchCount * ItemsPerBatch << ", after deletes: " << aliveKeys.size() << Endl;
         activeZone = true;
         {
-            TDesiredPair<TEvKeyValue::TEvRequest> dp; 
+            TDesiredPair<TEvKeyValue::TEvRequest> dp;
             AddCmdReadRange("a", true, "z", false, true, Max<ui64>(), NKikimrClient::TKeyValueRequest::REALTIME,
                 aliveKeys, aliveValues, NKikimrProto::OK, tc, dp);
             RunRequest(dp, tc, __LINE__);
@@ -2128,27 +2128,27 @@ Y_UNIT_TEST(TestWriteDeleteThenReadRemaining) {
     });
 }
 
- 
-Y_UNIT_TEST(TestObtainLockNewApi) { 
-    TTestContext tc; 
-    RunTestWithReboots(tc.TabletIds, [&]() { 
-        return tc.InitialEventsFilter.Prepare(); 
-    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) { 
-        TFinalizer finalizer(tc); 
-        tc.Prepare(dispatchName, setup, activeZone); 
-        constexpr NKikimrKeyValue::Statuses::ReplyStatus status = NKikimrKeyValue::Statuses::RSTATUS_ERROR; 
-        ExecuteObtainLock(tc, 1); 
- 
-        ExecuteGetStatus<status>(tc, {1, 2}, 0); 
-        ExecuteWrite<status>(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-        ExecuteRead<status>(tc, "key", "value", 0, 0, 0); 
-        ExecuteReadRange<status>(tc, "key", EBorderKind::Include, "key", EBorderKind::Include, 
-                {{"key", "value"}}, 0, true, 0); 
- 
-        ExecuteGetStatus(tc, {1, 2}, 1); 
-        ExecuteWrite(tc, {{"key", "value"}}, 1, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME); 
-   }); 
-} 
- 
+
+Y_UNIT_TEST(TestObtainLockNewApi) {
+    TTestContext tc;
+    RunTestWithReboots(tc.TabletIds, [&]() {
+        return tc.InitialEventsFilter.Prepare();
+    }, [&](const TString &dispatchName, std::function<void(TTestActorRuntime&)> setup, bool &activeZone) {
+        TFinalizer finalizer(tc);
+        tc.Prepare(dispatchName, setup, activeZone);
+        constexpr NKikimrKeyValue::Statuses::ReplyStatus status = NKikimrKeyValue::Statuses::RSTATUS_ERROR;
+        ExecuteObtainLock(tc, 1);
+
+        ExecuteGetStatus<status>(tc, {1, 2}, 0);
+        ExecuteWrite<status>(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+        ExecuteRead<status>(tc, "key", "value", 0, 0, 0);
+        ExecuteReadRange<status>(tc, "key", EBorderKind::Include, "key", EBorderKind::Include,
+                {{"key", "value"}}, 0, true, 0);
+
+        ExecuteGetStatus(tc, {1, 2}, 1);
+        ExecuteWrite(tc, {{"key", "value"}}, 1, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
+   });
+}
+
 } // TKeyValueTest
 } // NKikimr
diff --git a/ydb/core/keyvalue/protos/events.proto b/ydb/core/keyvalue/protos/events.proto
index 52ee16a4d6..fa365981ae 100644
--- a/ydb/core/keyvalue/protos/events.proto
+++ b/ydb/core/keyvalue/protos/events.proto
@@ -1,190 +1,190 @@
-syntax = "proto3"; 
-option cc_enable_arenas = true; 
- 
-package NKikimrKeyValue; 
-option java_package = "ru.yandex.kikimr.proto"; 
-option java_outer_classname = "KeyValueProtos"; 
-option java_multiple_files = true; 
- 
- 
-message Priorities { 
-    enum Priority { 
-        PRIORITY_UNSPECIFIED = 0; 
- 
-        // High priority for user-initiated operations. 
-        PRIORITY_REALTIME = 1; 
- 
-        // Low prioroty for background system activity. 
-        PRIORITY_BACKGROUND = 2; 
-    } 
-} 
- 
-message Statuses { 
-    enum ReplyStatus { 
-        RSTATUS_UNSPECIFIED = 0; 
-        RSTATUS_OK = 1; 
-        RSTATUS_ERROR = 2; 
-        RSTATUS_TIMEOUT = 3; 
-        RSTATUS_INTERNAL_ERROR = 4; 
-        RSTATUS_NO_DATA = 5; 
-        RSTATUS_OVERRUN = 6; 
-    } 
-} 
- 
-message Flags { 
-    bool disk_space_cyan = 1; 
-    bool disk_space_light_yellow_move = 2; 
-    bool disk_space_yellow_stop = 3; 
-    bool disk_space_light_orange = 4; 
-    bool disk_space_orange = 5; 
-    bool disk_space_red = 6; 
-    bool disk_space_black = 7; 
-} 
- 
-message Channel { 
-    Statuses.ReplyStatus status = 1; 
-    uint32 storage_channel = 2; 
-    optional Flags status_flags = 3; 
-} 
- 
-message KVRange { 
-    oneof from_bound { 
-        bytes from_key_inclusive = 1; 
-        bytes from_key_exclusive = 2; 
-    } 
- 
-    oneof to_bound { 
-        bytes to_key_inclusive = 3; 
-        bytes to_key_exclusive = 4; 
-    } 
-} 
- 
-message ReadRequest { 
-    uint64 tablet_id = 1; 
-    uint64 lock_generation = 2; 
-    bytes key = 3; 
-    uint64 offset = 4; 
-    uint64 size = 5; 
-    uint64 cookie = 6; 
-    Priorities.Priority priority = 7; 
-    uint64 deadline_instant_ms = 8; 
-    uint64 limit_bytes = 9; 
-} 
- 
-message ReadResult { 
-    bytes requested_key = 1; 
-    uint64 requested_offset = 2; 
-    uint64 requested_size = 3; 
-    bytes value = 4; 
-    string msg = 5; 
-    Statuses.ReplyStatus status = 6; 
-    uint64 cookie = 7; 
-} 
- 
-message ReadRangeRequest { 
-    uint64 tablet_id = 1; 
-    uint64 lock_generation = 2; 
- 
-    KVRange range = 3; 
- 
-    bool include_data = 4; 
-    uint64 limit_bytes = 5; 
-    Priorities.Priority priority = 6; 
-    uint64 cookie = 7; 
-    uint64 deadline_instant_ms = 8; 
-} 
- 
-message ReadRangeResult { 
-    message KeyValuePair { 
-        bytes key = 1; 
-        bytes value = 2; 
-        uint32 value_size = 3; 
- 
-        // Unix time of the creation of the key-value pair (in ms). 
-        uint64 creation_unix_time = 4; 
-        uint32 storage_channel = 5; // Returns the _actual_ storage channel 
-        Statuses.ReplyStatus status = 6; 
-    } 
-    Statuses.ReplyStatus status = 1; 
-    string msg = 2; 
-    repeated KeyValuePair pair = 3; 
-    uint64 cookie = 4; 
-} 
- 
-message ExecuteTransactionRequest { 
-    message Command { 
-        message Rename { 
-            bytes old_key = 1; 
-            bytes new_key = 2; 
-        } 
-        message Concat { 
-            repeated bytes input_keys = 1; 
-            bytes output_key = 2; 
-            bool keep_inputs = 3; 
-        } 
-        message CopyRange { 
-            KVRange range = 1; 
-            bytes prefix_to_remove = 2; 
-            bytes prefix_to_add = 3; 
-        } 
-        message Write { 
-            enum Tactic { 
-                TACTIC_UNSPECIFIED = 0; 
-                TACTIC_MAX_THROUGHPUT = 1; 
-                TACTIC_MIN_LATENCY = 2; 
-            } 
-            bytes key = 1; 
-            bytes value = 2; 
-            uint32 storage_channel = 3; 
-            Priorities.Priority priority = 4; 
-            Tactic tactic = 5; 
-        } 
-        message DeleteRange { 
-            KVRange range = 1; 
-        } 
- 
-        oneof action { 
-            DeleteRange delete_range = 1; 
-            Rename rename = 2; 
-            CopyRange copy_range = 3; 
-            Concat concat = 4; 
-            Write write = 5; 
-        } 
-    } 
- 
-    uint64 tablet_id = 1; 
-    uint64 lock_generation = 2; 
-    repeated Command commands = 3; 
-    uint64 cookie = 4; 
-    uint64 deadline_instant_ms = 5; 
-} 
- 
-message ExecuteTransactionResult { 
-    repeated Channel channel = 1; 
-    Statuses.ReplyStatus status = 2; 
-    string msg = 3; 
-    uint64 cookie = 4; 
-} 
- 
-message GetStatusRequest { 
-    uint64 tablet_id = 1; 
-    uint64 lock_generation = 2; 
-    repeated uint32 storage_channel = 3; 
-    uint64 deadline_instant_ms = 4; 
-} 
- 
-message GetStatusResult { 
-    repeated Channel channel = 1; 
-    Statuses.ReplyStatus status = 2; 
-    string msg = 3; 
-} 
- 
-message ObtainLockRequest { 
-    uint64 tablet_id = 1; 
-    uint64 cookie = 2; 
-} 
- 
-message ObtainLockResult { 
-    uint64 lock_generation = 1; 
-    uint64 cookie = 2; 
-} 
+syntax = "proto3";
+option cc_enable_arenas = true;
+
+package NKikimrKeyValue;
+option java_package = "ru.yandex.kikimr.proto";
+option java_outer_classname = "KeyValueProtos";
+option java_multiple_files = true;
+
+
+message Priorities {
+    enum Priority {
+        PRIORITY_UNSPECIFIED = 0;
+
+        // High priority for user-initiated operations.
+        PRIORITY_REALTIME = 1;
+
+        // Low prioroty for background system activity.
+        PRIORITY_BACKGROUND = 2;
+    }
+}
+
+message Statuses {
+    enum ReplyStatus {
+        RSTATUS_UNSPECIFIED = 0;
+        RSTATUS_OK = 1;
+        RSTATUS_ERROR = 2;
+        RSTATUS_TIMEOUT = 3;
+        RSTATUS_INTERNAL_ERROR = 4;
+        RSTATUS_NO_DATA = 5;
+        RSTATUS_OVERRUN = 6;
+    }
+}
+
+message Flags {
+    bool disk_space_cyan = 1;
+    bool disk_space_light_yellow_move = 2;
+    bool disk_space_yellow_stop = 3;
+    bool disk_space_light_orange = 4;
+    bool disk_space_orange = 5;
+    bool disk_space_red = 6;
+    bool disk_space_black = 7;
+}
+
+message Channel {
+    Statuses.ReplyStatus status = 1;
+    uint32 storage_channel = 2;
+    optional Flags status_flags = 3;
+}
+
+message KVRange {
+    oneof from_bound {
+        bytes from_key_inclusive = 1;
+        bytes from_key_exclusive = 2;
+    }
+
+    oneof to_bound {
+        bytes to_key_inclusive = 3;
+        bytes to_key_exclusive = 4;
+    }
+}
+
+message ReadRequest {
+    uint64 tablet_id = 1;
+    uint64 lock_generation = 2;
+    bytes key = 3;
+    uint64 offset = 4;
+    uint64 size = 5;
+    uint64 cookie = 6;
+    Priorities.Priority priority = 7;
+    uint64 deadline_instant_ms = 8;
+    uint64 limit_bytes = 9;
+}
+
+message ReadResult {
+    bytes requested_key = 1;
+    uint64 requested_offset = 2;
+    uint64 requested_size = 3;
+    bytes value = 4;
+    string msg = 5;
+    Statuses.ReplyStatus status = 6;
+    uint64 cookie = 7;
+}
+
+message ReadRangeRequest {
+    uint64 tablet_id = 1;
+    uint64 lock_generation = 2;
+
+    KVRange range = 3;
+
+    bool include_data = 4;
+    uint64 limit_bytes = 5;
+    Priorities.Priority priority = 6;
+    uint64 cookie = 7;
+    uint64 deadline_instant_ms = 8;
+}
+
+message ReadRangeResult {
+    message KeyValuePair {
+        bytes key = 1;
+        bytes value = 2;
+        uint32 value_size = 3;
+
+        // Unix time of the creation of the key-value pair (in ms).
+        uint64 creation_unix_time = 4;
+        uint32 storage_channel = 5; // Returns the _actual_ storage channel
+        Statuses.ReplyStatus status = 6;
+    }
+    Statuses.ReplyStatus status = 1;
+    string msg = 2;
+    repeated KeyValuePair pair = 3;
+    uint64 cookie = 4;
+}
+
+message ExecuteTransactionRequest {
+    message Command {
+        message Rename {
+            bytes old_key = 1;
+            bytes new_key = 2;
+        }
+        message Concat {
+            repeated bytes input_keys = 1;
+            bytes output_key = 2;
+            bool keep_inputs = 3;
+        }
+        message CopyRange {
+            KVRange range = 1;
+            bytes prefix_to_remove = 2;
+            bytes prefix_to_add = 3;
+        }
+        message Write {
+            enum Tactic {
+                TACTIC_UNSPECIFIED = 0;
+                TACTIC_MAX_THROUGHPUT = 1;
+                TACTIC_MIN_LATENCY = 2;
+            }
+            bytes key = 1;
+            bytes value = 2;
+            uint32 storage_channel = 3;
+            Priorities.Priority priority = 4;
+            Tactic tactic = 5;
+        }
+        message DeleteRange {
+            KVRange range = 1;
+        }
+
+        oneof action {
+            DeleteRange delete_range = 1;
+            Rename rename = 2;
+            CopyRange copy_range = 3;
+            Concat concat = 4;
+            Write write = 5;
+        }
+    }
+
+    uint64 tablet_id = 1;
+    uint64 lock_generation = 2;
+    repeated Command commands = 3;
+    uint64 cookie = 4;
+    uint64 deadline_instant_ms = 5;
+}
+
+message ExecuteTransactionResult {
+    repeated Channel channel = 1;
+    Statuses.ReplyStatus status = 2;
+    string msg = 3;
+    uint64 cookie = 4;
+}
+
+message GetStatusRequest {
+    uint64 tablet_id = 1;
+    uint64 lock_generation = 2;
+    repeated uint32 storage_channel = 3;
+    uint64 deadline_instant_ms = 4;
+}
+
+message GetStatusResult {
+    repeated Channel channel = 1;
+    Statuses.ReplyStatus status = 2;
+    string msg = 3;
+}
+
+message ObtainLockRequest {
+    uint64 tablet_id = 1;
+    uint64 cookie = 2;
+}
+
+message ObtainLockResult {
+    uint64 lock_generation = 1;
+    uint64 cookie = 2;
+}
diff --git a/ydb/core/keyvalue/protos/ya.make b/ydb/core/keyvalue/protos/ya.make
index 9631e46975..464bec3c22 100644
--- a/ydb/core/keyvalue/protos/ya.make
+++ b/ydb/core/keyvalue/protos/ya.make
@@ -1,18 +1,18 @@
-PROTO_LIBRARY() 
- 
+PROTO_LIBRARY()
+
 OWNER(
     kruall
     g:kikimr
 )
- 
-IF (OS_WINDOWS) 
-    NO_OPTIMIZE_PY_PROTOS() 
-ENDIF() 
- 
-SRCS( 
-    events.proto 
-) 
- 
-EXCLUDE_TAGS(GO_PROTO) 
- 
-END() 
+
+IF (OS_WINDOWS)
+    NO_OPTIMIZE_PY_PROTOS()
+ENDIF()
+
+SRCS(
+    events.proto
+)
+
+EXCLUDE_TAGS(GO_PROTO)
+
+END()
diff --git a/ydb/core/keyvalue/ut/ya.make b/ydb/core/keyvalue/ut/ya.make
index 7eb389580d..7124f2ccf8 100644
--- a/ydb/core/keyvalue/ut/ya.make
+++ b/ydb/core/keyvalue/ut/ya.make
@@ -15,7 +15,7 @@ IF (WITH_VALGRIND OR SANITIZER_TYPE)
 ELSE()
     TIMEOUT(600)
     SIZE(MEDIUM)
-    SPLIT_FACTOR(10) 
+    SPLIT_FACTOR(10)
 ENDIF()
 
 PEERDIR(
@@ -30,7 +30,7 @@ YQL_LAST_ABI_VERSION()
 SRCS(
     keyvalue_ut.cpp
     keyvalue_collector_ut.cpp
-    keyvalue_storage_read_request_ut.cpp 
+    keyvalue_storage_read_request_ut.cpp
 )
 
 END()
diff --git a/ydb/core/keyvalue/ya.make b/ydb/core/keyvalue/ya.make
index e924e8df91..17bb1853c0 100644
--- a/ydb/core/keyvalue/ya.make
+++ b/ydb/core/keyvalue/ya.make
@@ -38,7 +38,7 @@ SRCS(
     keyvalue_state.cpp
     keyvalue_state.h
     keyvalue_state_collect.cpp
-    keyvalue_storage_read_request.cpp 
+    keyvalue_storage_read_request.cpp
     keyvalue_storage_request.cpp
     keyvalue_storage_request.h
     keyvalue_stored_state_data.cpp
@@ -48,7 +48,7 @@ SRCS(
 
 PEERDIR(
     library/cpp/actors/core
-    library/cpp/actors/protos 
+    library/cpp/actors/protos
     ydb/core/base
     ydb/core/blobstorage/base
     ydb/core/blobstorage/dsproxy
@@ -65,7 +65,7 @@ END()
 RECURSE(
     protos
 )
- 
+
 RECURSE_FOR_TESTS(
     ut
 )
diff --git a/ydb/core/protos/blobstorage.proto b/ydb/core/protos/blobstorage.proto
index 30363915c5..a08ccbf865 100644
--- a/ydb/core/protos/blobstorage.proto
+++ b/ydb/core/protos/blobstorage.proto
@@ -122,7 +122,7 @@ message TMsgQoS {
         uint32 ProxyNodeId = 10; // set when client is DS Proxy from specific node
         uint32 ReplVDiskId = 11; // set when client is replication actor from specific vdisk
         uint64 VDiskLoadId = 13; // set when client is load test with specific tag
-        uint32 VPatchVDiskId = 14; // set when client is vpatch actor from specific vdisk 
+        uint32 VPatchVDiskId = 14; // set when client is vpatch actor from specific vdisk
     }
     optional TExecTimeStats ExecTimeStats = 12;
     optional NActorsProto.TActorId SenderActorId = 15;
@@ -188,172 +188,172 @@ message TGroupInfo {
     optional EPDiskType DeviceType = 14;
 }
 
-message TEvVPatchStart { 
-    optional NKikimrProto.TLogoBlobID OriginalBlobId = 1; 
-    optional NKikimrProto.TLogoBlobID PatchedBlobId = 2; 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 3; 
- 
-    optional bool NotifyIfNotReady = 4; 
-    optional uint64 Cookie = 5; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
-} 
- 
-message TEvVPatchFoundParts { 
-    optional NKikimrProto.EReplyStatus Status = 1; 
-    optional string ErrorReason = 200; // textual description of error 
-    optional NKikimrProto.TLogoBlobID OriginalBlobId = 2; 
-    optional NKikimrProto.TLogoBlobID PatchedBlobId = 3; 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 4; 
- 
-    optional uint64 Cookie = 5; 
-    repeated uint32 OriginalParts = 6; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
- 
-    optional fixed64 IncarnationGuid = 30; 
- 
-    optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation 
-} 
- 
-message TDiffBlock { 
-    optional uint64 Offset = 1; 
-    optional bytes Buffer = 2; 
-} 
- 
-message TXorDiffReceiver { 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 1; 
-    optional uint32 PartId = 2; 
-} 
- 
-message TEvVPatchDiff { 
-    optional NKikimrProto.TLogoBlobID OriginalPartBlobId = 1; 
-    optional NKikimrProto.TLogoBlobID PatchedPartBlobId = 2; 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 3; 
-    repeated TDiffBlock Diffs = 4; 
-    optional uint64 Cookie = 5; 
- 
-    repeated TXorDiffReceiver XorReceivers= 6; 
-    optional uint32 ExpectedXorDiffs = 7; 
-    optional bool ForceEnd = 8; 
-    optional bool NotifyIfNotReady = 9; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
-} 
- 
-message TEvVPatchXorDiff { 
-    optional NKikimrProto.TLogoBlobID OriginalPartBlobId = 1; 
-    optional NKikimrProto.TLogoBlobID PatchedPartBlobId = 2; 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 3; 
-    repeated TDiffBlock Diffs = 4; 
-    optional uint64 Cookie = 5; 
-    optional uint32 FromPartId = 6; 
-    optional bool NotifyIfNotReady = 7; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
-} 
- 
-message TEvVPatchXorDiffResult { 
-    optional NKikimrProto.EReplyStatus Status = 1; 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
-}; 
- 
-message TEvVPatchResult { 
-    optional NKikimrProto.EReplyStatus Status = 1; 
-    optional string ErrorReason = 200; // textual description of error 
-    optional NKikimrProto.TLogoBlobID OriginalPartBlobId = 2; 
-    optional NKikimrProto.TLogoBlobID PatchedPartBlobId = 3; 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 4; 
- 
-    optional uint64 Cookie = 5; 
-    optional uint32 StatusFlags = 6; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
- 
-    optional float ApproximateFreeSpaceShare = 25 [default = 0]; // 0 is a special value for 'unknown 
-    optional fixed64 IncarnationGuid = 30; 
- 
-    optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation 
-} 
- 
-message TEvVMovedPatch { 
-    optional NKikimrProto.TLogoBlobID OriginalBlobId = 1; 
-    optional NKikimrProto.TLogoBlobID PatchedBlobId = 2; 
-    optional uint32 OriginalGroupId = 3; 
-    optional uint32 PatchedGroupId = 4; 
-    repeated TDiffBlock Diffs = 5; 
- 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 6; 
- 
-    optional bool IgnoreBlock = 7; 
-    optional bool NotifyIfNotReady = 8; 
-    optional uint64 Cookie = 9; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
-} 
- 
-message TEvVMovedPatchResult { 
-    optional NKikimrProto.EReplyStatus Status = 1; 
-    optional string ErrorReason = 200; // textual description of error 
-    optional NKikimrProto.TLogoBlobID OriginalBlobId = 2; 
-    optional NKikimrProto.TLogoBlobID PatchedBlobId = 3; 
- 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 4; 
-    optional uint64 Cookie = 5; 
-    optional uint32 StatusFlags = 6; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
- 
-    optional float ApproximateFreeSpaceShare = 25 [default = 0]; // 0 is a special value for 'unknown' 
-    optional fixed64 IncarnationGuid = 30; 
- 
-    optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation 
-} 
- 
-message TEvVInplacePatch { 
-    optional NKikimrProto.TLogoBlobID OriginalBlobId = 1; 
-    optional NKikimrProto.TLogoBlobID PatchedBlobId = 2; 
-    optional uint32 OriginalGroupId = 3; 
-    optional uint32 PatchedGroupId = 4; 
-    repeated TDiffBlock Diffs = 5; 
- 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 6; 
- 
-    optional bool IgnoreBlock = 7; 
-    optional bool NotifyIfNotReady = 8; 
-    optional uint64 Cookie = 9; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
-} 
- 
-message TEvVInplacePatchResult { 
-    optional NKikimrProto.EReplyStatus Status = 1; 
-    optional string ErrorReason = 200; // textual description of error 
-    optional NKikimrProto.TLogoBlobID OriginalBlobId = 2; 
-    optional NKikimrProto.TLogoBlobID PatchedBlobId = 3; 
- 
-    optional NKikimrBlobStorage.TVDiskID VDiskID = 4; 
-    optional uint64 Cookie = 5; 
-    optional uint32 StatusFlags = 6; 
- 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
- 
-    optional float ApproximateFreeSpaceShare = 25 [default = 0]; // 0 is a special value for 'unknown' 
-    optional fixed64 IncarnationGuid = 30; 
- 
-    optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation 
-} 
- 
+message TEvVPatchStart {
+    optional NKikimrProto.TLogoBlobID OriginalBlobId = 1;
+    optional NKikimrProto.TLogoBlobID PatchedBlobId = 2;
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 3;
+
+    optional bool NotifyIfNotReady = 4;
+    optional uint64 Cookie = 5;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+}
+
+message TEvVPatchFoundParts {
+    optional NKikimrProto.EReplyStatus Status = 1;
+    optional string ErrorReason = 200; // textual description of error
+    optional NKikimrProto.TLogoBlobID OriginalBlobId = 2;
+    optional NKikimrProto.TLogoBlobID PatchedBlobId = 3;
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 4;
+
+    optional uint64 Cookie = 5;
+    repeated uint32 OriginalParts = 6;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+
+    optional fixed64 IncarnationGuid = 30;
+
+    optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation
+}
+
+message TDiffBlock {
+    optional uint64 Offset = 1;
+    optional bytes Buffer = 2;
+}
+
+message TXorDiffReceiver {
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 1;
+    optional uint32 PartId = 2;
+}
+
+message TEvVPatchDiff {
+    optional NKikimrProto.TLogoBlobID OriginalPartBlobId = 1;
+    optional NKikimrProto.TLogoBlobID PatchedPartBlobId = 2;
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 3;
+    repeated TDiffBlock Diffs = 4;
+    optional uint64 Cookie = 5;
+
+    repeated TXorDiffReceiver XorReceivers= 6;
+    optional uint32 ExpectedXorDiffs = 7;
+    optional bool ForceEnd = 8;
+    optional bool NotifyIfNotReady = 9;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+}
+
+message TEvVPatchXorDiff {
+    optional NKikimrProto.TLogoBlobID OriginalPartBlobId = 1;
+    optional NKikimrProto.TLogoBlobID PatchedPartBlobId = 2;
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 3;
+    repeated TDiffBlock Diffs = 4;
+    optional uint64 Cookie = 5;
+    optional uint32 FromPartId = 6;
+    optional bool NotifyIfNotReady = 7;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+}
+
+message TEvVPatchXorDiffResult {
+    optional NKikimrProto.EReplyStatus Status = 1;
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+};
+
+message TEvVPatchResult {
+    optional NKikimrProto.EReplyStatus Status = 1;
+    optional string ErrorReason = 200; // textual description of error
+    optional NKikimrProto.TLogoBlobID OriginalPartBlobId = 2;
+    optional NKikimrProto.TLogoBlobID PatchedPartBlobId = 3;
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 4;
+
+    optional uint64 Cookie = 5;
+    optional uint32 StatusFlags = 6;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+
+    optional float ApproximateFreeSpaceShare = 25 [default = 0]; // 0 is a special value for 'unknown
+    optional fixed64 IncarnationGuid = 30;
+
+    optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation
+}
+
+message TEvVMovedPatch {
+    optional NKikimrProto.TLogoBlobID OriginalBlobId = 1;
+    optional NKikimrProto.TLogoBlobID PatchedBlobId = 2;
+    optional uint32 OriginalGroupId = 3;
+    optional uint32 PatchedGroupId = 4;
+    repeated TDiffBlock Diffs = 5;
+
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 6;
+
+    optional bool IgnoreBlock = 7;
+    optional bool NotifyIfNotReady = 8;
+    optional uint64 Cookie = 9;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+}
+
+message TEvVMovedPatchResult {
+    optional NKikimrProto.EReplyStatus Status = 1;
+    optional string ErrorReason = 200; // textual description of error
+    optional NKikimrProto.TLogoBlobID OriginalBlobId = 2;
+    optional NKikimrProto.TLogoBlobID PatchedBlobId = 3;
+
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 4;
+    optional uint64 Cookie = 5;
+    optional uint32 StatusFlags = 6;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+
+    optional float ApproximateFreeSpaceShare = 25 [default = 0]; // 0 is a special value for 'unknown'
+    optional fixed64 IncarnationGuid = 30;
+
+    optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation
+}
+
+message TEvVInplacePatch {
+    optional NKikimrProto.TLogoBlobID OriginalBlobId = 1;
+    optional NKikimrProto.TLogoBlobID PatchedBlobId = 2;
+    optional uint32 OriginalGroupId = 3;
+    optional uint32 PatchedGroupId = 4;
+    repeated TDiffBlock Diffs = 5;
+
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 6;
+
+    optional bool IgnoreBlock = 7;
+    optional bool NotifyIfNotReady = 8;
+    optional uint64 Cookie = 9;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+}
+
+message TEvVInplacePatchResult {
+    optional NKikimrProto.EReplyStatus Status = 1;
+    optional string ErrorReason = 200; // textual description of error
+    optional NKikimrProto.TLogoBlobID OriginalBlobId = 2;
+    optional NKikimrProto.TLogoBlobID PatchedBlobId = 3;
+
+    optional NKikimrBlobStorage.TVDiskID VDiskID = 4;
+    optional uint64 Cookie = 5;
+    optional uint32 StatusFlags = 6;
+
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+
+    optional float ApproximateFreeSpaceShare = 25 [default = 0]; // 0 is a special value for 'unknown'
+    optional fixed64 IncarnationGuid = 30;
+
+    optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation
+}
+
 message TEvVPut {
     optional NKikimrProto.TLogoBlobID BlobID = 1;
     optional bytes Buffer = 2;
@@ -386,53 +386,53 @@ message TEvVPutResult {
     optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation
 }
 
-message TVMultiPutItem { 
-    optional NKikimrProto.TLogoBlobID BlobID = 1; 
-    optional bytes Buffer = 2; 
- 
-    optional uint64 FullDataSize = 3; 
-    optional uint64 Cookie = 4; 
-} 
- 
-message TEvVMultiPut { 
-    repeated TVMultiPutItem Items = 1; 
- 
-    optional TVDiskID VDiskID = 2; 
- 
+message TVMultiPutItem {
+    optional NKikimrProto.TLogoBlobID BlobID = 1;
+    optional bytes Buffer = 2;
+
+    optional uint64 FullDataSize = 3;
+    optional uint64 Cookie = 4;
+}
+
+message TEvVMultiPut {
+    repeated TVMultiPutItem Items = 1;
+
+    optional TVDiskID VDiskID = 2;
+
     optional bool IgnoreBlock = 3 [default = false];
-    optional bool NotifyIfNotReady = 4; 
-    optional uint64 Cookie = 5; 
-    optional EPutHandleClass HandleClass = 6; 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
-} 
- 
-message TVMultiPutResultItem { 
-    optional NKikimrProto.EReplyStatus Status = 1; 
+    optional bool NotifyIfNotReady = 4;
+    optional uint64 Cookie = 5;
+    optional EPutHandleClass HandleClass = 6;
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+}
+
+message TVMultiPutResultItem {
+    optional NKikimrProto.EReplyStatus Status = 1;
     optional string ErrorReason = 200;
-    optional NKikimrProto.TLogoBlobID BlobID = 2; 
- 
-    optional uint64 Cookie = 3; 
-    optional uint32 StatusFlags = 4 [default = 0]; 
-} 
- 
-message TEvVMultiPutResult { 
-    optional NKikimrProto.EReplyStatus Status = 1; 
+    optional NKikimrProto.TLogoBlobID BlobID = 2;
+
+    optional uint64 Cookie = 3;
+    optional uint32 StatusFlags = 4 [default = 0];
+}
+
+message TEvVMultiPutResult {
+    optional NKikimrProto.EReplyStatus Status = 1;
     optional string ErrorReason = 200;
-    repeated TVMultiPutResultItem Items = 2; 
- 
-    optional TVDiskID VDiskID = 3; 
-    optional uint64 Cookie = 4; 
-    optional uint32 StatusFlags = 5 [default = 0]; 
-    optional TMsgQoS MsgQoS = 10; 
-    optional TTimestamps Timestamps = 23; 
- 
-    optional float ApproximateFreeSpaceShare = 25 [default = 0]; // 0 is a special value for 'unknown' 
+    repeated TVMultiPutResultItem Items = 2;
+
+    optional TVDiskID VDiskID = 3;
+    optional uint64 Cookie = 4;
+    optional uint32 StatusFlags = 5 [default = 0];
+    optional TMsgQoS MsgQoS = 10;
+    optional TTimestamps Timestamps = 23;
+
+    optional float ApproximateFreeSpaceShare = 25 [default = 0]; // 0 is a special value for 'unknown'
     optional fixed64 IncarnationGuid = 30;
 
     optional TGroupInfo RecentGroup = 100; // filled in by VDisk on RACE when VDisk has newer generation
-} 
- 
+}
+
 message TRangeQuery {
     optional NKikimrProto.TLogoBlobID From = 1;
     optional NKikimrProto.TLogoBlobID To = 2;
diff --git a/ydb/core/protos/config.proto b/ydb/core/protos/config.proto
index e6be416cdd..d64169d4fc 100644
--- a/ydb/core/protos/config.proto
+++ b/ydb/core/protos/config.proto
@@ -639,7 +639,7 @@ message TFeatureFlags {
     optional bool AllowOnlineIndexBuild = 24 [default = true]; // deprecated: always true
     optional bool EnablePersistentQueryStats = 25 [default = false];
     optional bool DisableDataShardBarrier = 26 [default = false];
-    optional bool EnablePutBatchingForBlobStorage = 27 [default = true]; 
+    optional bool EnablePutBatchingForBlobStorage = 27 [default = true];
     optional bool EnableKqpWideFlow = 28 [default = true]; // deprecated: always true
     optional bool EnableKqpScanQueries = 29 [default = true]; // deprecated: always true
     optional bool EnablePersistentPartitionStats = 30 [default = false];
@@ -657,12 +657,12 @@ message TFeatureFlags {
     optional bool AllowStreamExecuteYqlScript = 42 [default = true];
     optional bool EnableKqpScanOverPersistentSnapshot = 43 [default = true]; // deprecated: always true
     optional bool EnableOlapSchemaOperations = 44 [default = false];
-    optional bool EnableVPatch = 45 [default = false]; 
+    optional bool EnableVPatch = 45 [default = false];
     optional bool EnableMvccSnapshotReads = 46 [default = false];
     optional Tribool EnableMvcc = 47 [default = VALUE_TRUE];
     optional bool EnableSchemeTransactionsAtSchemeShard = 48 [default = false];
     optional bool EnableArrowFormatAtDatashard = 49 [default = false];
-    optional bool Enable3x3RequestsForMirror3DCMinLatencyPut = 50 [default = false]; 
+    optional bool Enable3x3RequestsForMirror3DCMinLatencyPut = 50 [default = false];
     optional bool EnableBackgroundCompaction = 51 [default = true];
     optional bool EnableArrowFormatInChannels = 52 [default = false];
     optional bool EnableBackgroundCompactionServerless = 53 [default = false];
diff --git a/ydb/core/protos/services.proto b/ydb/core/protos/services.proto
index ea1e35d192..c17c8a7dc3 100644
--- a/ydb/core/protos/services.proto
+++ b/ydb/core/protos/services.proto
@@ -46,9 +46,9 @@ enum EServiceKikimr {
     BS_PROXY_MULTICOLLECT = 289;
     BS_CONTROLLER_AUDIT = 304;
     BS_SELFHEAL = 342;
-    BS_PROXY_PATCH = 343; 
+    BS_PROXY_PATCH = 343;
     BS_VDISK_SCRUB = 344;
-    BS_VDISK_PATCH = 345; 
+    BS_VDISK_PATCH = 345;
 
     // DATASHARD section //
     TX_DATASHARD = 290;  //
diff --git a/ydb/core/test_tablet/load_actor_impl.h b/ydb/core/test_tablet/load_actor_impl.h
index 3cfaf138cf..71bd0e4f41 100644
--- a/ydb/core/test_tablet/load_actor_impl.h
+++ b/ydb/core/test_tablet/load_actor_impl.h
@@ -14,8 +14,8 @@ namespace NKikimr::NTestShard {
         TActorId TabletActorId;
         const NKikimrClient::TTestShardControlRequest::TCmdInitialize Settings;
 
-        ui64 ValidationRunningCount = 0; 
- 
+        ui64 ValidationRunningCount = 0;
+
         struct TKeyInfo {
             const ui32 Len = 0;
             ::NTestShard::TStateServer::EEntityState ConfirmedState = ::NTestShard::TStateServer::ABSENT;
diff --git a/ydb/core/test_tablet/load_actor_mon.cpp b/ydb/core/test_tablet/load_actor_mon.cpp
index d8b9aa1887..24dfb0bc3c 100644
--- a/ydb/core/test_tablet/load_actor_mon.cpp
+++ b/ydb/core/test_tablet/load_actor_mon.cpp
@@ -116,11 +116,11 @@ namespace NKikimr::NTestShard {
                                         TABLED() { str << num; }
                                     }
 
-                                    TABLER() { 
-                                        TABLED() { str << "Count of validation runnings"; } 
-                                        TABLED() { str << self->ValidationRunningCount; } 
-                                    } 
- 
+                                    TABLER() {
+                                        TABLED() { str << "Count of validation runnings"; }
+                                        TABLED() { str << self->ValidationRunningCount; }
+                                    }
+
                                     const std::vector<double> ps{0.0, 0.5, 0.9, 0.99, 1.0};
 
                                     auto output = [&](auto& r, const char *name) {
diff --git a/ydb/core/test_tablet/load_actor_read_validate.cpp b/ydb/core/test_tablet/load_actor_read_validate.cpp
index 459897c586..f6fc171f1e 100644
--- a/ydb/core/test_tablet/load_actor_read_validate.cpp
+++ b/ydb/core/test_tablet/load_actor_read_validate.cpp
@@ -19,14 +19,14 @@ namespace NKikimr::NTestShard {
         std::unordered_map<ui64, TString> QueriesInFlight;
         ui64 LastCookie = 0;
 
-        bool IssueReadMode = false; // true - via EvRequest, false - via EvReadRequest 
-        bool IssueReadRangeMode = false; // true - via EvRequest, false - via EvReadRequest 
- 
-        ui32 WaitedReadsViaEvResponse = 0; 
-        ui32 WaitedReadsViaEvReadResponse = 0; 
-        ui32 WaitedReadRangesViaEvResponse = 0; 
-        ui32 WaitedReadRangesViaEvReadRangeResponse = 0; 
- 
+        bool IssueReadMode = false; // true - via EvRequest, false - via EvReadRequest
+        bool IssueReadRangeMode = false; // true - via EvRequest, false - via EvReadRequest
+
+        ui32 WaitedReadsViaEvResponse = 0;
+        ui32 WaitedReadsViaEvReadResponse = 0;
+        ui32 WaitedReadRangesViaEvResponse = 0;
+        ui32 WaitedReadRangesViaEvReadRangeResponse = 0;
+
         // read retry logic
         std::unordered_set<TString> KeyReadsWaitingForRetry;
         ui32 RetryCount = 0;
@@ -77,7 +77,7 @@ namespace NKikimr::NTestShard {
             }
         }
 
-        void SendReadRangeViaEvRequest() { 
+        void SendReadRangeViaEvRequest() {
             auto request = std::make_unique<TEvKeyValue::TEvRequest>();
             auto& record = request->Record;
             record.SetTabletId(TabletId);
@@ -91,40 +91,40 @@ namespace NKikimr::NTestShard {
             Send(TabletActorId, request.release());
         }
 
-        void SendReadRangeViaEvReadRange() { 
-            auto request = std::make_unique<TEvKeyValue::TEvReadRange>(); 
-            auto& record = request->Record; 
-            record.set_tablet_id(TabletId); 
-            record.set_cookie(0); 
-            auto *range = record.mutable_range(); 
-            range->set_from_key_exclusive(*LastKey); 
-            Send(TabletActorId, request.release()); 
-        } 
- 
-        void IssueNextReadRangeQuery() { 
-            IssueReadRangeMode = !IssueReadRangeMode; 
-            if (IssueReadRangeMode) { 
-                WaitedReadRangesViaEvResponse++; 
-                SendReadRangeViaEvRequest(); 
-            } else { 
-                WaitedReadRangesViaEvReadRangeResponse++; 
-                SendReadRangeViaEvReadRange(); 
-            } 
-        } 
- 
-        TString PopQueryByCookie(ui64 cookie) { 
-            auto it = QueriesInFlight.find(cookie); 
-            Y_VERIFY(it != QueriesInFlight.end()); 
-            TString key = std::move(it->second); 
-            QueriesInFlight.erase(it); 
-            return key; 
-        } 
- 
+        void SendReadRangeViaEvReadRange() {
+            auto request = std::make_unique<TEvKeyValue::TEvReadRange>();
+            auto& record = request->Record;
+            record.set_tablet_id(TabletId);
+            record.set_cookie(0);
+            auto *range = record.mutable_range();
+            range->set_from_key_exclusive(*LastKey);
+            Send(TabletActorId, request.release());
+        }
+
+        void IssueNextReadRangeQuery() {
+            IssueReadRangeMode = !IssueReadRangeMode;
+            if (IssueReadRangeMode) {
+                WaitedReadRangesViaEvResponse++;
+                SendReadRangeViaEvRequest();
+            } else {
+                WaitedReadRangesViaEvReadRangeResponse++;
+                SendReadRangeViaEvReadRange();
+            }
+        }
+
+        TString PopQueryByCookie(ui64 cookie) {
+            auto it = QueriesInFlight.find(cookie);
+            Y_VERIFY(it != QueriesInFlight.end());
+            TString key = std::move(it->second);
+            QueriesInFlight.erase(it);
+            return key;
+        }
+
         void Handle(TEvKeyValue::TEvResponse::TPtr ev) {
             auto& r = ev->Get()->Record;
             if (r.GetCookie()) {
-                WaitedReadsViaEvResponse--; 
-                TString key = PopQueryByCookie(r.GetCookie()); 
+                WaitedReadsViaEvResponse--;
+                TString key = PopQueryByCookie(r.GetCookie());
 
                 if (r.GetStatus() != NMsgBusProxy::MSTATUS_OK) {
                     STLOG(PRI_ERROR, TEST_SHARD, TS18, "CmdRead failed", (TabletId, TabletId), (Status, r.GetStatus()),
@@ -153,7 +153,7 @@ namespace NKikimr::NTestShard {
                     " actual# " << MD5::Calc(value) << " len# " << value.size());
                 STLOG(PRI_DEBUG, TEST_SHARD, TS16, "read key", (TabletId, TabletId), (Key, key));
             } else {
-                WaitedReadRangesViaEvResponse--; 
+                WaitedReadRangesViaEvResponse--;
                 if (r.GetStatus() != NMsgBusProxy::MSTATUS_OK) {
                     STLOG(PRI_ERROR, TEST_SHARD, TS17, "CmdRangeRead failed", (TabletId, TabletId), (Status, r.GetStatus()),
                         (ErrorReason, r.GetErrorReason()));
@@ -180,73 +180,73 @@ namespace NKikimr::NTestShard {
             FinishIfPossible();
         }
 
-        void Handle(TEvKeyValue::TEvReadResponse::TPtr ev) { 
-            auto& record = ev->Get()->Record; 
-            WaitedReadsViaEvReadResponse--; 
- 
-            const TString key = PopQueryByCookie(record.cookie()); 
-            const NKikimrKeyValue::Statuses::ReplyStatus status = record.status(); 
- 
-            if (status == NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT) { 
-                STLOG(PRI_ERROR, TEST_SHARD, TS23, "CmdRead failed", (TabletId, TabletId), (Status, status), 
-                    (ErrorReason, record.msg())); 
-                return IssueRead(key); 
-            } 
- 
-            if (status == NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR && RetryCount < 10) { 
-                const bool inserted = KeyReadsWaitingForRetry.insert(key).second; 
-                Y_VERIFY(inserted); 
-                STLOG(PRI_ERROR, TEST_SHARD, TS24, "read key failed -- going to retry", (TabletId, TabletId), 
-                    (Key, key), (ErrorReason, record.msg())); 
-                return; 
-            } 
- 
-            Y_VERIFY_S(status == NKikimrKeyValue::Statuses::RSTATUS_OK, 
-                "Status# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(status) 
-                << " Cookie# " << record.cookie() 
-                << " Message# " << record.msg()); 
- 
-            const TString& value = record.value(); 
-            const bool inserted = Keys.try_emplace(key, value.size()).second; 
-            Y_VERIFY(inserted); 
-            Y_VERIFY_S(MD5::Calc(value) == key, "TabletId# " << TabletId << " Key# " << key << " digest mismatch" 
-                " actual# " << MD5::Calc(value) << " len# " << value.size()); 
-            STLOG(PRI_DEBUG, TEST_SHARD, TS16, "read key", (TabletId, TabletId), (Key, key)); 
-            FinishIfPossible(); 
-        } 
- 
-        void Handle(TEvKeyValue::TEvReadRangeResponse::TPtr ev) { 
-            WaitedReadRangesViaEvReadRangeResponse--; 
-            auto& record = ev->Get()->Record; 
-            const NKikimrKeyValue::Statuses::ReplyStatus status = record.status(); 
- 
-            if (status != NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT) { 
-                STLOG(PRI_ERROR, TEST_SHARD, TS19, "CmdRangeRead failed", (TabletId, TabletId), (Status, status), 
-                    (ErrorReason, record.msg())); 
-                return IssueNextReadRangeQuery(); 
-            } 
- 
-            Y_VERIFY_S(status == NKikimrKeyValue::Statuses::RSTATUS_OK 
-                || status ==  NKikimrKeyValue::Statuses::RSTATUS_NO_DATA 
-                || status == NKikimrKeyValue::Statuses::RSTATUS_OVERRUN, 
-                "TabletId# " << TabletId << " CmdReadRange failed" 
-                << " Status# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(status)); 
- 
-            for (const auto& pair : record.pair()) { 
-                const TString& key = pair.key(); 
-                LastKey = key; 
-                IssueRead(key); 
-            } 
-            if (!record.pair_size()) { 
-                STLOG(PRI_INFO, TEST_SHARD, TS20, "finished reading from KeyValue tablet", (TabletId, TabletId)); 
-                KeyValueReadComplete = true; 
-            } else { 
-                IssueNextReadRangeQuery(); 
-            } 
-            FinishIfPossible(); 
-        } 
- 
-        ui64 SendReadViaEvRequest(const TString& key) { 
+        void Handle(TEvKeyValue::TEvReadResponse::TPtr ev) {
+            auto& record = ev->Get()->Record;
+            WaitedReadsViaEvReadResponse--;
+
+            const TString key = PopQueryByCookie(record.cookie());
+            const NKikimrKeyValue::Statuses::ReplyStatus status = record.status();
+
+            if (status == NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT) {
+                STLOG(PRI_ERROR, TEST_SHARD, TS23, "CmdRead failed", (TabletId, TabletId), (Status, status),
+                    (ErrorReason, record.msg()));
+                return IssueRead(key);
+            }
+
+            if (status == NKikimrKeyValue::Statuses::RSTATUS_INTERNAL_ERROR && RetryCount < 10) {
+                const bool inserted = KeyReadsWaitingForRetry.insert(key).second;
+                Y_VERIFY(inserted);
+                STLOG(PRI_ERROR, TEST_SHARD, TS24, "read key failed -- going to retry", (TabletId, TabletId),
+                    (Key, key), (ErrorReason, record.msg()));
+                return;
+            }
+
+            Y_VERIFY_S(status == NKikimrKeyValue::Statuses::RSTATUS_OK,
+                "Status# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(status)
+                << " Cookie# " << record.cookie()
+                << " Message# " << record.msg());
+
+            const TString& value = record.value();
+            const bool inserted = Keys.try_emplace(key, value.size()).second;
+            Y_VERIFY(inserted);
+            Y_VERIFY_S(MD5::Calc(value) == key, "TabletId# " << TabletId << " Key# " << key << " digest mismatch"
+                " actual# " << MD5::Calc(value) << " len# " << value.size());
+            STLOG(PRI_DEBUG, TEST_SHARD, TS16, "read key", (TabletId, TabletId), (Key, key));
+            FinishIfPossible();
+        }
+
+        void Handle(TEvKeyValue::TEvReadRangeResponse::TPtr ev) {
+            WaitedReadRangesViaEvReadRangeResponse--;
+            auto& record = ev->Get()->Record;
+            const NKikimrKeyValue::Statuses::ReplyStatus status = record.status();
+
+            if (status != NKikimrKeyValue::Statuses::RSTATUS_TIMEOUT) {
+                STLOG(PRI_ERROR, TEST_SHARD, TS19, "CmdRangeRead failed", (TabletId, TabletId), (Status, status),
+                    (ErrorReason, record.msg()));
+                return IssueNextReadRangeQuery();
+            }
+
+            Y_VERIFY_S(status == NKikimrKeyValue::Statuses::RSTATUS_OK
+                || status ==  NKikimrKeyValue::Statuses::RSTATUS_NO_DATA
+                || status == NKikimrKeyValue::Statuses::RSTATUS_OVERRUN,
+                "TabletId# " << TabletId << " CmdReadRange failed"
+                << " Status# " << NKikimrKeyValue::Statuses_ReplyStatus_Name(status));
+
+            for (const auto& pair : record.pair()) {
+                const TString& key = pair.key();
+                LastKey = key;
+                IssueRead(key);
+            }
+            if (!record.pair_size()) {
+                STLOG(PRI_INFO, TEST_SHARD, TS20, "finished reading from KeyValue tablet", (TabletId, TabletId));
+                KeyValueReadComplete = true;
+            } else {
+                IssueNextReadRangeQuery();
+            }
+            FinishIfPossible();
+        }
+
+        ui64 SendReadViaEvRequest(const TString& key) {
             auto request = std::make_unique<TEvKeyValue::TEvRequest>();
             auto& record = request->Record;
             record.SetTabletId(TabletId);
@@ -255,33 +255,33 @@ namespace NKikimr::NTestShard {
             auto *read = record.AddCmdRead();
             read->SetKey(key);
             Send(TabletActorId, request.release());
-            return cookie; 
-        } 
- 
-        ui64 SendReadViaEvReadRequest(const TString& key) { 
-            auto request = std::make_unique<TEvKeyValue::TEvRead>(); 
-            auto& record = request->Record; 
-            record.set_tablet_id(TabletId); 
-            const ui64 cookie = ++LastCookie; 
-            record.set_cookie(cookie); 
-            record.set_key(key); 
-            Send(TabletActorId, request.release()); 
-            return cookie; 
-        } 
- 
-        ui64 SendRead(const TString& key) { 
-            IssueReadMode = !IssueReadMode; 
-            if (IssueReadMode) { 
-                WaitedReadsViaEvResponse++; 
-                return SendReadViaEvRequest(key); 
-            } else { 
-                WaitedReadsViaEvReadResponse++; 
-                return SendReadViaEvReadRequest(key); 
-            } 
-        } 
- 
-        void IssueRead(const TString& key) { 
-            const ui64 cookie = SendRead(key); 
+            return cookie;
+        }
+
+        ui64 SendReadViaEvReadRequest(const TString& key) {
+            auto request = std::make_unique<TEvKeyValue::TEvRead>();
+            auto& record = request->Record;
+            record.set_tablet_id(TabletId);
+            const ui64 cookie = ++LastCookie;
+            record.set_cookie(cookie);
+            record.set_key(key);
+            Send(TabletActorId, request.release());
+            return cookie;
+        }
+
+        ui64 SendRead(const TString& key) {
+            IssueReadMode = !IssueReadMode;
+            if (IssueReadMode) {
+                WaitedReadsViaEvResponse++;
+                return SendReadViaEvRequest(key);
+            } else {
+                WaitedReadsViaEvReadResponse++;
+                return SendReadViaEvReadRequest(key);
+            }
+        }
+
+        void IssueRead(const TString& key) {
+            const ui64 cookie = SendRead(key);
             const bool inserted = QueriesInFlight.emplace(cookie, key).second;
             Y_VERIFY(inserted);
         }
@@ -530,30 +530,30 @@ namespace NKikimr::NTestShard {
                                     TABLED() { str << QueriesInFlight.size(); }
                                 }
                             }
-                            TABLEBODY() { 
-                                TABLER() { 
-                                    TABLED() { str << "WaitedReadsViaEvResponse"; } 
-                                    TABLED() { str << WaitedReadsViaEvResponse; } 
-                                } 
-                            } 
-                            TABLEBODY() { 
-                                TABLER() { 
-                                    TABLED() { str << "WaitedReadsViaEvReadResponse"; } 
-                                    TABLED() { str << WaitedReadsViaEvReadResponse; } 
-                                } 
-                            } 
-                            TABLEBODY() { 
-                                TABLER() { 
-                                    TABLED() { str << "WaitedReadRangesViaEvResponse"; } 
-                                    TABLED() { str << WaitedReadRangesViaEvResponse; } 
-                                } 
-                            } 
-                            TABLEBODY() { 
-                                TABLER() { 
-                                    TABLED() { str << "WaitedReadRangesViaEvReadRangeResponse"; } 
-                                    TABLED() { str << WaitedReadRangesViaEvReadRangeResponse; } 
-                                } 
-                            } 
+                            TABLEBODY() {
+                                TABLER() {
+                                    TABLED() { str << "WaitedReadsViaEvResponse"; }
+                                    TABLED() { str << WaitedReadsViaEvResponse; }
+                                }
+                            }
+                            TABLEBODY() {
+                                TABLER() {
+                                    TABLED() { str << "WaitedReadsViaEvReadResponse"; }
+                                    TABLED() { str << WaitedReadsViaEvReadResponse; }
+                                }
+                            }
+                            TABLEBODY() {
+                                TABLER() {
+                                    TABLED() { str << "WaitedReadRangesViaEvResponse"; }
+                                    TABLED() { str << WaitedReadRangesViaEvResponse; }
+                                }
+                            }
+                            TABLEBODY() {
+                                TABLER() {
+                                    TABLED() { str << "WaitedReadRangesViaEvReadRangeResponse"; }
+                                    TABLED() { str << WaitedReadRangesViaEvReadRangeResponse; }
+                                }
+                            }
                         }
                     }
                 }
@@ -566,8 +566,8 @@ namespace NKikimr::NTestShard {
         }
 
         STRICT_STFUNC(StateFunc,
-            hFunc(TEvKeyValue::TEvReadResponse, Handle); 
-            hFunc(TEvKeyValue::TEvReadRangeResponse, Handle); 
+            hFunc(TEvKeyValue::TEvReadResponse, Handle);
+            hFunc(TEvKeyValue::TEvReadRangeResponse, Handle);
             hFunc(TEvKeyValue::TEvResponse, Handle);
             hFunc(TEvStateServerStatus, Handle);
             hFunc(TEvStateServerReadResult, Handle);
@@ -582,7 +582,7 @@ namespace NKikimr::NTestShard {
         Send(TabletActorId, new TTestShard::TEvSwitchMode(TTestShard::EMode::READ_VALIDATE));
         Y_VERIFY(!ValidationActorId);
         ValidationActorId = RegisterWithSameMailbox(new TValidationActor(*this, initialCheck));
-        ValidationRunningCount++; 
+        ValidationRunningCount++;
     }
 
     void TLoadActor::Handle(TEvValidationFinished::TPtr ev) {
diff --git a/ydb/core/testlib/basics/helpers.cpp b/ydb/core/testlib/basics/helpers.cpp
index 00b9a697ce..259e4f9da9 100644
--- a/ydb/core/testlib/basics/helpers.cpp
+++ b/ydb/core/testlib/basics/helpers.cpp
@@ -38,34 +38,34 @@ namespace NKikimr {
         return pipeConfig;
     }
 
-    struct TPDiskReplyChecker : IReplyChecker { 
-        ~TPDiskReplyChecker() 
-        { 
-        } 
- 
-        void OnRequest(IEventHandle *request) override { 
-            if (request->Type == TEvBlobStorage::EvMultiLog) { 
-                NPDisk::TEvMultiLog *evLogs = request->Get<NPDisk::TEvMultiLog>(); 
-                LastLsn = evLogs->LsnSeg.Last; 
-            } else { 
-                LastLsn = {}; 
-            } 
-        } 
- 
-        bool IsWaitingForMoreResponses(IEventHandle *response) override { 
-            if (!LastLsn) { 
-                return false; 
-            } 
-            Y_VERIFY_S(response->Type == TEvBlobStorage::EvLogResult, "expected EvLogResult " 
-                    << (ui64)TEvBlobStorage::EvLogResult << ", but given " << response->Type); 
-            NPDisk::TEvLogResult *evResult = response->Get<NPDisk::TEvLogResult>(); 
-            ui64 responseLastLsn = evResult->Results.back().Lsn; 
-            return *LastLsn > responseLastLsn; 
-        } 
- 
-        TMaybe<ui64> LastLsn; 
-    }; 
- 
+    struct TPDiskReplyChecker : IReplyChecker {
+        ~TPDiskReplyChecker()
+        {
+        }
+
+        void OnRequest(IEventHandle *request) override {
+            if (request->Type == TEvBlobStorage::EvMultiLog) {
+                NPDisk::TEvMultiLog *evLogs = request->Get<NPDisk::TEvMultiLog>();
+                LastLsn = evLogs->LsnSeg.Last;
+            } else {
+                LastLsn = {};
+            }
+        }
+
+        bool IsWaitingForMoreResponses(IEventHandle *response) override {
+            if (!LastLsn) {
+                return false;
+            }
+            Y_VERIFY_S(response->Type == TEvBlobStorage::EvLogResult, "expected EvLogResult "
+                    << (ui64)TEvBlobStorage::EvLogResult << ", but given " << response->Type);
+            NPDisk::TEvLogResult *evResult = response->Get<NPDisk::TEvLogResult>();
+            ui64 responseLastLsn = evResult->Results.back().Lsn;
+            return *LastLsn > responseLastLsn;
+        }
+
+        TMaybe<ui64> LastLsn;
+    };
+
     void TStrandedPDiskServiceFactory::Create(const TActorContext &ctx, ui32 pDiskID,
             const TIntrusivePtr<TPDiskConfig> &cfg, const NPDisk::TKey &mainKey, ui32 poolId, ui32 nodeId)
     {
diff --git a/ydb/core/util/log_priority_mute_checker.h b/ydb/core/util/log_priority_mute_checker.h
index f10d71acf4..6baac545c8 100644
--- a/ydb/core/util/log_priority_mute_checker.h
+++ b/ydb/core/util/log_priority_mute_checker.h
@@ -1,92 +1,92 @@
-#pragma once 
- 
-#include "defs.h" 
- 
-#include <library/cpp/actors/core/log_settings.h> 
-#include <util/system/atomic.h> 
- 
-namespace NKikimr { 
- 
-    template <NActors::NLog::EPriority MainPrio, NActors::NLog::EPriority MutePrio> 
-    struct TLogPriorityMuteChecker { 
-        using EPriority = NActors::NLog::EPriority; 
-        static constexpr EPriority MainPriority = MainPrio; 
-        static constexpr EPriority MutePriority = MutePrio; 
- 
-        TInstant MuteDeadline; 
- 
-        void MuteUntil(const TInstant &muteDeadline) { 
-            MuteDeadline = muteDeadline; 
-        } 
- 
-        void Unmute() { 
-            MuteDeadline = TInstant::Zero(); 
-        } 
- 
-        bool IsMuted(const TInstant &now) const { 
-            return now < MuteDeadline; 
-        } 
- 
-        EPriority CheckPriority(const TInstant &now) const { 
-            return IsMuted(now) ? MutePriority : MainPriority; 
-        } 
- 
-        EPriority Register(const TInstant &now, const TInstant &muteDeadline) { 
-            if (IsMuted(now)) { 
-                return MutePriority; 
-            } 
-            MuteUntil(muteDeadline); 
-            return MainPriority; 
-        } 
- 
-        EPriority Register(const TInstant &now, const TDuration &muteDuration) { 
-            if (IsMuted(now)) { 
-                return MutePriority; 
-            } 
-            MuteUntil(now + muteDuration); 
-            return MainPriority; 
-        } 
-    }; 
- 
-    template <NActors::NLog::EPriority MainPrio, NActors::NLog::EPriority MutePrio> 
-    struct TAtomicLogPriorityMuteChecker { 
-        using EPriority = NActors::NLog::EPriority; 
-        static constexpr EPriority MainPriority = MainPrio; 
-        static constexpr EPriority MutePriority = MutePrio; 
- 
-        TAtomic MuteDeadlineUs = 0; 
- 
-        void MuteUntil(const TInstant &muteDeadline) { 
-            AtomicSet(MuteDeadlineUs, muteDeadline.MicroSeconds()); 
-        } 
- 
-        void Unmute() { 
-            AtomicSet(MuteDeadlineUs, 0); 
-        } 
- 
-        bool IsMuted(const TInstant &now) const { 
-            return now < TInstant::MicroSeconds(AtomicGet(MuteDeadlineUs)); 
-        } 
- 
-        EPriority CheckPriority(const TInstant &now) const { 
-            return IsMuted(now) ? MutePriority : MainPriority; 
-        } 
- 
-        EPriority Register(const TInstant &now, const TInstant &muteDeadline) { 
-            if (IsMuted(now)) { 
-                return MutePriority; 
-            } 
-            MuteUntil(muteDeadline); 
-            return MainPriority; 
-        } 
- 
-        EPriority Register(const TInstant &now, const TDuration &muteDuration) { 
-            if (IsMuted(now)) { 
-                return MutePriority; 
-            } 
-            MuteUntil(now + muteDuration); 
-            return MainPriority; 
-        } 
-    }; 
- 
-} 
+#pragma once
+
+#include "defs.h"
+
+#include <library/cpp/actors/core/log_settings.h>
+#include <util/system/atomic.h>
+
+namespace NKikimr {
+
+    template <NActors::NLog::EPriority MainPrio, NActors::NLog::EPriority MutePrio>
+    struct TLogPriorityMuteChecker {
+        using EPriority = NActors::NLog::EPriority;
+        static constexpr EPriority MainPriority = MainPrio;
+        static constexpr EPriority MutePriority = MutePrio;
+
+        TInstant MuteDeadline;
+
+        void MuteUntil(const TInstant &muteDeadline) {
+            MuteDeadline = muteDeadline;
+        }
+
+        void Unmute() {
+            MuteDeadline = TInstant::Zero();
+        }
+
+        bool IsMuted(const TInstant &now) const {
+            return now < MuteDeadline;
+        }
+
+        EPriority CheckPriority(const TInstant &now) const {
+            return IsMuted(now) ? MutePriority : MainPriority;
+        }
+
+        EPriority Register(const TInstant &now, const TInstant &muteDeadline) {
+            if (IsMuted(now)) {
+                return MutePriority;
+            }
+            MuteUntil(muteDeadline);
+            return MainPriority;
+        }
+
+        EPriority Register(const TInstant &now, const TDuration &muteDuration) {
+            if (IsMuted(now)) {
+                return MutePriority;
+            }
+            MuteUntil(now + muteDuration);
+            return MainPriority;
+        }
+    };
+
+    template <NActors::NLog::EPriority MainPrio, NActors::NLog::EPriority MutePrio>
+    struct TAtomicLogPriorityMuteChecker {
+        using EPriority = NActors::NLog::EPriority;
+        static constexpr EPriority MainPriority = MainPrio;
+        static constexpr EPriority MutePriority = MutePrio;
+
+        TAtomic MuteDeadlineUs = 0;
+
+        void MuteUntil(const TInstant &muteDeadline) {
+            AtomicSet(MuteDeadlineUs, muteDeadline.MicroSeconds());
+        }
+
+        void Unmute() {
+            AtomicSet(MuteDeadlineUs, 0);
+        }
+
+        bool IsMuted(const TInstant &now) const {
+            return now < TInstant::MicroSeconds(AtomicGet(MuteDeadlineUs));
+        }
+
+        EPriority CheckPriority(const TInstant &now) const {
+            return IsMuted(now) ? MutePriority : MainPriority;
+        }
+
+        EPriority Register(const TInstant &now, const TInstant &muteDeadline) {
+            if (IsMuted(now)) {
+                return MutePriority;
+            }
+            MuteUntil(muteDeadline);
+            return MainPriority;
+        }
+
+        EPriority Register(const TInstant &now, const TDuration &muteDuration) {
+            if (IsMuted(now)) {
+                return MutePriority;
+            }
+            MuteUntil(now + muteDuration);
+            return MainPriority;
+        }
+    };
+
+}
diff --git a/ydb/core/util/log_priority_mute_checker_ut.cpp b/ydb/core/util/log_priority_mute_checker_ut.cpp
index e8df7dafc5..c09bb14d30 100644
--- a/ydb/core/util/log_priority_mute_checker_ut.cpp
+++ b/ydb/core/util/log_priority_mute_checker_ut.cpp
@@ -1,110 +1,110 @@
-#include <library/cpp/testing/unittest/registar.h> 
- 
-#include "log_priority_mute_checker.h" 
- 
-using namespace NKikimr; 
-using namespace NActors::NLog; 
- 
-TInstant GetTime(ui64 seconds) { 
-    return TInstant::Zero() + TDuration::Seconds(seconds); 
-} 
- 
-void CheckPriority(EPriority expected, TMaybe<EPriority> prio) { 
-    UNIT_ASSERT(prio); 
-    UNIT_ASSERT_EQUAL(*prio, expected); 
-} 
- 
-void CheckPriority(EPriority expected, EPriority prio) { 
-    UNIT_ASSERT_EQUAL(prio, expected); 
-} 
- 
-Y_UNIT_TEST_SUITE(TLogPriorityMuteTests) { 
- 
-    template <template <NActors::NLog::EPriority, NActors::NLog::EPriority> typename TMuteChecker> 
-    void MakeMuteUntilTest(){ 
-        TMuteChecker<PRI_ERROR, PRI_DEBUG> checker; 
-        TInstant muteDeadline = GetTime(3); 
-        checker.MuteUntil(muteDeadline); 
-        for (ui64 i = 0; i < 3; ++i) { 
-            CheckPriority(PRI_DEBUG, checker.CheckPriority(GetTime(i))); 
-        } 
-        for (ui64 i = 3; i < 6; ++i) { 
-            CheckPriority(PRI_ERROR, checker.CheckPriority(GetTime(i))); 
-        } 
-    } 
-    Y_UNIT_TEST(MuteUntilTest) { 
-        MakeMuteUntilTest<TLogPriorityMuteChecker>(); 
-    } 
-    Y_UNIT_TEST(AtomicMuteUntilTest) { 
-        MakeMuteUntilTest<TAtomicLogPriorityMuteChecker>(); 
-    } 
- 
-    template <template <NActors::NLog::EPriority, NActors::NLog::EPriority> typename TMuteChecker> 
-    void MakeUnmuteTest() { 
-        TMuteChecker<PRI_ERROR, PRI_DEBUG> checker; 
-        TInstant muteDeadline = GetTime(3); 
-        checker.MuteUntil(muteDeadline); 
-        for (ui64 i = 0; i < 3; ++i) { 
-            CheckPriority(PRI_DEBUG, checker.CheckPriority(GetTime(i))); 
-        } 
-        checker.Unmute(); 
-        for (ui64 i = 0; i < 6; ++i) { 
-            CheckPriority(PRI_ERROR, checker.CheckPriority(GetTime(i))); 
-        } 
-    } 
-    Y_UNIT_TEST(UnmuteTest) { 
-        MakeUnmuteTest<TLogPriorityMuteChecker>(); 
-    } 
-    Y_UNIT_TEST(AtomicUnmuteTest) { 
-        MakeUnmuteTest<TAtomicLogPriorityMuteChecker>(); 
-    } 
- 
-    template <template <NActors::NLog::EPriority, NActors::NLog::EPriority> typename TMuteChecker> 
-    void MakeCheckPriorityWithSetMuteTest() { 
-        TLogPriorityMuteChecker<PRI_ERROR, PRI_DEBUG> checker; 
-        ui64 secondsForDeadlines[3] = {3, 6, 12}; 
- 
-        TInstant fakeDeadline = TInstant::Max(); 
-        ui64 currentTime = 0; 
-        for (ui64 deadlineIdx = 0; deadlineIdx < 3; ++deadlineIdx) { 
-            TInstant realDeadline = GetTime(secondsForDeadlines[deadlineIdx]); 
-            CheckPriority(PRI_ERROR, checker.Register(GetTime(currentTime++), realDeadline)); 
-            while (currentTime < secondsForDeadlines[deadlineIdx]) { 
-                CheckPriority(PRI_DEBUG, checker.Register(GetTime(currentTime++), fakeDeadline)); 
-            } 
-        } 
-        CheckPriority(PRI_ERROR, checker.CheckPriority(GetTime(currentTime))); 
-    } 
-    Y_UNIT_TEST(CheckPriorityWithSetMuteTest) { 
-        MakeCheckPriorityWithSetMuteTest<TLogPriorityMuteChecker>(); 
-    } 
-    Y_UNIT_TEST(AtomicCheckPriorityWithSetMuteTest) { 
-        MakeCheckPriorityWithSetMuteTest<TAtomicLogPriorityMuteChecker>(); 
-    } 
- 
-    template <template <NActors::NLog::EPriority, NActors::NLog::EPriority> typename TMuteChecker> 
-    void MakeCheckPriorityWithSetMuteDurationTest() { 
-        TLogPriorityMuteChecker<PRI_ERROR, PRI_DEBUG> checker; 
-        ui64 secondsForDurations[3] = {3, 6, 12}; 
- 
-        TDuration fakeDurations = TDuration::Seconds(600); 
-        ui64 currentTime = 0; 
-        ui64 deadline = 0; 
-        for (ui64 durationIdx = 0; durationIdx < 3; ++durationIdx) { 
-            TDuration realDuration = TDuration::Seconds(secondsForDurations[durationIdx]); 
-            deadline += secondsForDurations[durationIdx]; 
-            CheckPriority(PRI_ERROR, checker.Register(GetTime(currentTime++), realDuration)); 
-            while (currentTime < deadline) { 
-                CheckPriority(PRI_DEBUG, checker.Register(GetTime(currentTime++), fakeDurations)); 
-            } 
-        } 
-        CheckPriority(PRI_ERROR, checker.CheckPriority(GetTime(currentTime))); 
-    } 
-    Y_UNIT_TEST(CheckPriorityWithSetMuteDurationTest) { 
-        MakeCheckPriorityWithSetMuteDurationTest<TLogPriorityMuteChecker>(); 
-    } 
-    Y_UNIT_TEST(AtomicCheckPriorityWithSetMuteDurationTest) { 
-        MakeCheckPriorityWithSetMuteDurationTest<TAtomicLogPriorityMuteChecker>(); 
-    } 
- 
-} 
+#include <library/cpp/testing/unittest/registar.h>
+
+#include "log_priority_mute_checker.h"
+
+using namespace NKikimr;
+using namespace NActors::NLog;
+
+TInstant GetTime(ui64 seconds) {
+    return TInstant::Zero() + TDuration::Seconds(seconds);
+}
+
+void CheckPriority(EPriority expected, TMaybe<EPriority> prio) {
+    UNIT_ASSERT(prio);
+    UNIT_ASSERT_EQUAL(*prio, expected);
+}
+
+void CheckPriority(EPriority expected, EPriority prio) {
+    UNIT_ASSERT_EQUAL(prio, expected);
+}
+
+Y_UNIT_TEST_SUITE(TLogPriorityMuteTests) {
+
+    template <template <NActors::NLog::EPriority, NActors::NLog::EPriority> typename TMuteChecker>
+    void MakeMuteUntilTest(){
+        TMuteChecker<PRI_ERROR, PRI_DEBUG> checker;
+        TInstant muteDeadline = GetTime(3);
+        checker.MuteUntil(muteDeadline);
+        for (ui64 i = 0; i < 3; ++i) {
+            CheckPriority(PRI_DEBUG, checker.CheckPriority(GetTime(i)));
+        }
+        for (ui64 i = 3; i < 6; ++i) {
+            CheckPriority(PRI_ERROR, checker.CheckPriority(GetTime(i)));
+        }
+    }
+    Y_UNIT_TEST(MuteUntilTest) {
+        MakeMuteUntilTest<TLogPriorityMuteChecker>();
+    }
+    Y_UNIT_TEST(AtomicMuteUntilTest) {
+        MakeMuteUntilTest<TAtomicLogPriorityMuteChecker>();
+    }
+
+    template <template <NActors::NLog::EPriority, NActors::NLog::EPriority> typename TMuteChecker>
+    void MakeUnmuteTest() {
+        TMuteChecker<PRI_ERROR, PRI_DEBUG> checker;
+        TInstant muteDeadline = GetTime(3);
+        checker.MuteUntil(muteDeadline);
+        for (ui64 i = 0; i < 3; ++i) {
+            CheckPriority(PRI_DEBUG, checker.CheckPriority(GetTime(i)));
+        }
+        checker.Unmute();
+        for (ui64 i = 0; i < 6; ++i) {
+            CheckPriority(PRI_ERROR, checker.CheckPriority(GetTime(i)));
+        }
+    }
+    Y_UNIT_TEST(UnmuteTest) {
+        MakeUnmuteTest<TLogPriorityMuteChecker>();
+    }
+    Y_UNIT_TEST(AtomicUnmuteTest) {
+        MakeUnmuteTest<TAtomicLogPriorityMuteChecker>();
+    }
+
+    template <template <NActors::NLog::EPriority, NActors::NLog::EPriority> typename TMuteChecker>
+    void MakeCheckPriorityWithSetMuteTest() {
+        TLogPriorityMuteChecker<PRI_ERROR, PRI_DEBUG> checker;
+        ui64 secondsForDeadlines[3] = {3, 6, 12};
+
+        TInstant fakeDeadline = TInstant::Max();
+        ui64 currentTime = 0;
+        for (ui64 deadlineIdx = 0; deadlineIdx < 3; ++deadlineIdx) {
+            TInstant realDeadline = GetTime(secondsForDeadlines[deadlineIdx]);
+            CheckPriority(PRI_ERROR, checker.Register(GetTime(currentTime++), realDeadline));
+            while (currentTime < secondsForDeadlines[deadlineIdx]) {
+                CheckPriority(PRI_DEBUG, checker.Register(GetTime(currentTime++), fakeDeadline));
+            }
+        }
+        CheckPriority(PRI_ERROR, checker.CheckPriority(GetTime(currentTime)));
+    }
+    Y_UNIT_TEST(CheckPriorityWithSetMuteTest) {
+        MakeCheckPriorityWithSetMuteTest<TLogPriorityMuteChecker>();
+    }
+    Y_UNIT_TEST(AtomicCheckPriorityWithSetMuteTest) {
+        MakeCheckPriorityWithSetMuteTest<TAtomicLogPriorityMuteChecker>();
+    }
+
+    template <template <NActors::NLog::EPriority, NActors::NLog::EPriority> typename TMuteChecker>
+    void MakeCheckPriorityWithSetMuteDurationTest() {
+        TLogPriorityMuteChecker<PRI_ERROR, PRI_DEBUG> checker;
+        ui64 secondsForDurations[3] = {3, 6, 12};
+
+        TDuration fakeDurations = TDuration::Seconds(600);
+        ui64 currentTime = 0;
+        ui64 deadline = 0;
+        for (ui64 durationIdx = 0; durationIdx < 3; ++durationIdx) {
+            TDuration realDuration = TDuration::Seconds(secondsForDurations[durationIdx]);
+            deadline += secondsForDurations[durationIdx];
+            CheckPriority(PRI_ERROR, checker.Register(GetTime(currentTime++), realDuration));
+            while (currentTime < deadline) {
+                CheckPriority(PRI_DEBUG, checker.Register(GetTime(currentTime++), fakeDurations));
+            }
+        }
+        CheckPriority(PRI_ERROR, checker.CheckPriority(GetTime(currentTime)));
+    }
+    Y_UNIT_TEST(CheckPriorityWithSetMuteDurationTest) {
+        MakeCheckPriorityWithSetMuteDurationTest<TLogPriorityMuteChecker>();
+    }
+    Y_UNIT_TEST(AtomicCheckPriorityWithSetMuteDurationTest) {
+        MakeCheckPriorityWithSetMuteDurationTest<TAtomicLogPriorityMuteChecker>();
+    }
+
+}
diff --git a/ydb/core/util/testactorsys.cpp b/ydb/core/util/testactorsys.cpp
index 34c7ead121..73d27bc9d9 100644
--- a/ydb/core/util/testactorsys.cpp
+++ b/ydb/core/util/testactorsys.cpp
@@ -40,14 +40,14 @@ public:
     }
 
     bool Send(TAutoPtr<IEventHandle>& ev) override {
-        if (TlsActivationContext) { 
-            const TActorContext& ctx = TActivationContext::AsActorContext(); 
-            IActor* sender = Context->GetActor(ctx.SelfID); 
-            TTestDecorator* decorator = dynamic_cast<TTestDecorator*>(sender); 
-            if (decorator && !decorator->BeforeSending(ev)) { 
-                ev = nullptr; 
-            } 
-        } 
+        if (TlsActivationContext) {
+            const TActorContext& ctx = TActivationContext::AsActorContext();
+            IActor* sender = Context->GetActor(ctx.SelfID);
+            TTestDecorator* decorator = dynamic_cast<TTestDecorator*>(sender);
+            if (decorator && !decorator->BeforeSending(ev)) {
+                ev = nullptr;
+            }
+        }
         return Context->Send(ev, NodeId);
     }
 
@@ -134,10 +134,10 @@ TActorId TTestActorSystem::CreateTestBootstrapper(TTabletStorageInfo *info, std:
 
 void TTestActorSystem::SetupTabletRuntime(bool isMirror3dc, ui32 stateStorageNodeId, ui32 targetNodeId) {
     auto setup = MakeIntrusive<TTableNameserverSetup>();
-    ui32 nodeCountInDC = (MaxNodeId + 2) / 3; 
+    ui32 nodeCountInDC = (MaxNodeId + 2) / 3;
     for (ui32 nodeId : GetNodes()) {
         const TString name = Sprintf("127.0.0.%u", nodeId);
-        ui32 dcNum = isMirror3dc ? ((nodeId + nodeCountInDC - 1) / nodeCountInDC) : 1; 
+        ui32 dcNum = isMirror3dc ? ((nodeId + nodeCountInDC - 1) / nodeCountInDC) : 1;
         NActorsInterconnect::TNodeLocation location;
         location.SetDataCenter(ToString(dcNum));
         location.SetRack(ToString(nodeId));
diff --git a/ydb/core/util/ut/ya.make b/ydb/core/util/ut/ya.make
index 03c8d39250..315713cad8 100644
--- a/ydb/core/util/ut/ya.make
+++ b/ydb/core/util/ut/ya.make
@@ -36,7 +36,7 @@ SRCS(
     intrusive_heap_ut.cpp
     intrusive_stack_ut.cpp
     lf_stack_ut.cpp
-    log_priority_mute_checker_ut.cpp 
+    log_priority_mute_checker_ut.cpp
     lz4_data_generator_ut.cpp
     operation_queue_ut.cpp
     operation_queue_priority_ut.cpp
diff --git a/ydb/core/util/ya.make b/ydb/core/util/ya.make
index e4444ec3cc..4f325d8fcb 100644
--- a/ydb/core/util/ya.make
+++ b/ydb/core/util/ya.make
@@ -32,7 +32,7 @@ SRCS(
     intrusive_heap.cpp
     intrusive_heap.h
     intrusive_stack.h
-    log_priority_mute_checker.h 
+    log_priority_mute_checker.h
     memory_tracker.cpp
     memory_tracker.h
     operation_queue.h