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

contrib/libs/cxxsupp/builtins/ya.make

@@ -75,7 +75,7 @@ SRCS(
     extenddftf2.c
     extendsftf2.c
     fixdfti.c
-    fixsfti.c
+    fixsfti.c 
     fixtfdi.c
     fixtfsi.c
     fixunsdfti.c
@@ -91,7 +91,7 @@ SRCS(
     floatunditf.c
     floatunsitf.c
     floatuntidf.c
-    floatuntisf.c
+    floatuntisf.c 
     gcc_personality_v0.c
     int_util.c
     lshrti3.c

library/cpp/actors/core/buffer.cpp

@@ -1,93 +1,93 @@
-#include "buffer.h"
-
-#include <util/system/yassert.h>
-
+#include "buffer.h" 
+ 
+#include <util/system/yassert.h> 
+ 
 #include <algorithm>
-
-TBufferBase::TBufferBase(size_t size) noexcept
-    : Size(size)
+ 
+TBufferBase::TBufferBase(size_t size) noexcept 
+    : Size(size) 
 {
 }
-
-size_t
+ 
+size_t 
 TBufferBase::GetSize() const noexcept {
     return Size;
-}
-
+} 
+ 
 void TBufferBase::SetSize(size_t size) noexcept {
     Size = size;
-}
-
-/////////////////////////////////////////////////////////////////////
-
+} 
+ 
+///////////////////////////////////////////////////////////////////// 
+ 
 template <typename PointerType>
-TBufferBaseT<PointerType>::TBufferBaseT(PointerType data, size_t size) noexcept
+TBufferBaseT<PointerType>::TBufferBaseT(PointerType data, size_t size) noexcept 
     : TBufferBase(size)
     , Data(data)
 {
 }
-
+ 
 template <typename PointerType>
-PointerType
+PointerType 
 TBufferBaseT<PointerType>::GetPointer() const noexcept {
     return Data;
-}
-
+} 
+ 
 template <typename PointerType>
 void TBufferBaseT<PointerType>::Assign(PointerType data, size_t size) noexcept {
     Data = data;
     Size = size;
-}
-
+} 
+ 
 template <>
 void TBufferBaseT<void*>::Cut(size_t offset) noexcept {
     Y_VERIFY_DEBUG(offset <= Size);
     Data = static_cast<char*>(Data) + offset;
     TBufferBase::Size -= offset;
-}
-
+} 
+ 
 template <>
 void TBufferBaseT<const void*>::Cut(size_t offset) noexcept {
     Y_VERIFY_DEBUG(offset <= Size);
     Data = static_cast<const char*>(Data) + offset;
     TBufferBase::Size -= offset;
-}
-
-template class TBufferBaseT<void*>;
-template class TBufferBaseT<const void*>;
-
-/////////////////////////////////////////////////////////////////////
-
-TConstBuffer::TConstBuffer(const void* data, size_t size) noexcept
-    : TBufferBaseT<const void*>(data, size)
+} 
+ 
+template class TBufferBaseT<void*>; 
+template class TBufferBaseT<const void*>; 
+ 
+///////////////////////////////////////////////////////////////////// 
+ 
+TConstBuffer::TConstBuffer(const void* data, size_t size) noexcept 
+    : TBufferBaseT<const void*>(data, size) 
 {
 }
-
-TConstBuffer::TConstBuffer(const TMutableBuffer& buffer) noexcept
-    : TBufferBaseT<const void*>(buffer.GetPointer(), buffer.GetSize())
+ 
+TConstBuffer::TConstBuffer(const TMutableBuffer& buffer) noexcept 
+    : TBufferBaseT<const void*>(buffer.GetPointer(), buffer.GetSize()) 
 {
 }
-
-TConstBuffer
+ 
+TConstBuffer 
 TConstBuffer::Offset(ptrdiff_t offset, size_t size) const noexcept {
     return TConstBuffer(static_cast<const char*>(Data) + offset, std::min(Size - offset, size));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-TMutableBuffer::TMutableBuffer(void* data, size_t size) noexcept
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+TMutableBuffer::TMutableBuffer(void* data, size_t size) noexcept 
     : TBufferBaseT<void*>(data, size)
 {
 }
-
-TMutableBuffer
+ 
+TMutableBuffer 
 TMutableBuffer::Offset(ptrdiff_t offset, size_t size) const noexcept {
     return TMutableBuffer(static_cast<char*>(Data) + offset, std::min(Size - offset, size));
-}
-
-size_t
+} 
+ 
+size_t 
 TMutableBuffer::CopyFrom(const TConstBuffer& buffer) const noexcept {
     const auto size = std::min(Size, buffer.Size);
     std::memcpy(Data, buffer.Data, size);
     return size;
-}
+} 

library/cpp/actors/core/buffer.h

@@ -1,62 +1,62 @@
-#pragma once
-
+#pragma once 
+ 
 #include <limits>
-
-class TConstBuffer;
-class TMutableBuffer;
-
+ 
+class TConstBuffer; 
+class TMutableBuffer; 
+ 
 class TBufferBase {
-public:
-    size_t GetSize() const noexcept;
-
-    void SetSize(size_t newSize) noexcept;
-
-protected:
-    TBufferBase(size_t size = 0) noexcept;
-
-    size_t Size;
-};
-
+public: 
+    size_t GetSize() const noexcept; 
+ 
+    void SetSize(size_t newSize) noexcept; 
+ 
+protected: 
+    TBufferBase(size_t size = 0) noexcept; 
+ 
+    size_t Size; 
+}; 
+ 
 template <typename PointerType>
 class TBufferBaseT: public TBufferBase {
-public:
-    PointerType GetPointer() const noexcept;
-
-    void Cut(size_t offset) noexcept;
-
-    void Assign(PointerType data = nullptr, size_t size = 0U) noexcept;
-
-protected:
-    TBufferBaseT(PointerType data, size_t size) noexcept;
-
-    PointerType Data;
-};
-
-/// Represents constant memory buffer, but do not owns it.
+public: 
+    PointerType GetPointer() const noexcept; 
+ 
+    void Cut(size_t offset) noexcept; 
+ 
+    void Assign(PointerType data = nullptr, size_t size = 0U) noexcept; 
+ 
+protected: 
+    TBufferBaseT(PointerType data, size_t size) noexcept; 
+ 
+    PointerType Data; 
+}; 
+ 
+/// Represents constant memory buffer, but do not owns it. 
 class TConstBuffer: public TBufferBaseT<const void*> {
     friend class TMutableBuffer;
 
-public:
+public: 
     TConstBuffer(const TMutableBuffer& buffer) noexcept;
-
+ 
     TConstBuffer(const void* data = nullptr, size_t size = 0U) noexcept;
-
+ 
     TConstBuffer Offset(ptrdiff_t offset, size_t size = std::numeric_limits<size_t>::max()) const noexcept;
-};
-
-/// Represents mutable memory buffer, but do not owns it.
+}; 
+ 
+/// Represents mutable memory buffer, but do not owns it. 
 class TMutableBuffer: public TBufferBaseT<void*> {
     friend class TConstBuffer;
 
-public:
+public: 
     TMutableBuffer(void* data = nullptr, size_t size = 0U) noexcept;
-
+ 
     TMutableBuffer(const TMutableBuffer& value) noexcept
         : TBufferBaseT<void*>(value)
     {
     }
-
+ 
     TMutableBuffer Offset(ptrdiff_t offset, size_t size = std::numeric_limits<size_t>::max()) const noexcept;
-
+ 
     size_t CopyFrom(const TConstBuffer& buffer) const noexcept;
-};
+}; 

library/cpp/actors/core/event.h

@@ -116,18 +116,18 @@ namespace NActors {
 
         static const size_t ChannelBits = 12;
         static const size_t ChannelShift = (sizeof(ui32) << 3) - ChannelBits;
-
+ 
 #ifdef USE_ACTOR_CALLSTACK
         TCallstack Callstack;
 #endif
         ui16 GetChannel() const noexcept {
             return Flags >> ChannelShift;
         }
-
+ 
         ui64 GetSubChannel() const noexcept {
             return Flags & FlagUseSubChannel ? Sender.LocalId() : 0ULL;
         }
-
+ 
         static ui32 MakeFlags(ui32 channel, ui32 flags) {
             Y_VERIFY(channel < (1 << ChannelBits));
             Y_VERIFY(flags < (1 << ChannelShift));
@@ -249,7 +249,7 @@ namespace NActors {
                 return 0;
             }
         }
-
+ 
         bool HasBuffer() const {
             return bool(Buffer);
         }

library/cpp/actors/core/events.h

@@ -58,15 +58,15 @@ namespace NActors {
                 : Blob(blob)
             {
             }
-
+ 
             TString ToStringHeader() const noexcept override {
                 return "THelloWorld::Blob";
             }
-
+ 
             bool SerializeToArcadiaStream(TChunkSerializer *serializer) const override {
                 return serializer->WriteString(&Blob);
             }
-
+ 
             static IEventBase* Load(TEventSerializedData* bufs) noexcept {
                 return new TEvBlob(bufs->GetString());
             }
@@ -75,7 +75,7 @@ namespace NActors {
                 return true;
             }
         };
-
+ 
         struct TSystem {
             enum {
                 Start = EventSpaceBegin(ES_SYSTEM),
@@ -103,7 +103,7 @@ namespace NActors {
                 PoisonPill = Poison,
                 ActorDied = Gone,
             };
-
+ 
             static_assert(End < EventSpaceEnd(ES_SYSTEM), "expect End < EventSpaceEnd(ES_SYSTEM)");
         };
 
@@ -130,7 +130,7 @@ namespace NActors {
         struct TEvUnsubscribe: public TEventBase<TEvUnsubscribe, TSystem::Unsubscribe> {
             DEFINE_SIMPLE_LOCAL_EVENT(TEvUnsubscribe, "System: TEvUnsubscribe")
         };
-
+ 
         struct TEvUndelivered: public TEventBase<TEvUndelivered, TSystem::Undelivered> {
             enum EReason {
                 ReasonUnknown,
@@ -141,7 +141,7 @@ namespace NActors {
             const EReason Reason;
             const bool Unsure;
             const TString Data;
-
+ 
             TEvUndelivered(ui32 sourceType, ui32 reason, bool unsure = false)
                 : SourceType(sourceType)
                 , Reason(static_cast<EReason>(reason))

library/cpp/actors/core/interconnect.h

@@ -162,7 +162,7 @@ namespace NActors {
             }
             const ui32 NodeId;
         };
-
+ 
         struct TEvNodeDisconnected: public TEventLocal<TEvNodeDisconnected, EvNodeDisconnected> {
             DEFINE_SIMPLE_LOCAL_EVENT(TEvNodeDisconnected, "TEvInterconnect::TEvNodeDisconnected")
             TEvNodeDisconnected(ui32 node) noexcept
@@ -171,10 +171,10 @@ namespace NActors {
             }
             const ui32 NodeId;
         };
-
+ 
         struct TEvRegisterNode;
         struct TEvRegisterNodeResult;
-
+ 
         struct TEvListNodes: public TEventLocal<TEvListNodes, EvListNodes> {
         };
 

library/cpp/actors/testlib/test_runtime.cpp

@@ -62,9 +62,9 @@ namespace NActors {
     }
 
     void TTestActorRuntimeBase::TNodeDataBase::Stop() {
-        if (Poller)
-            Poller->Stop();
-
+        if (Poller) 
+            Poller->Stop(); 
+ 
         if (MailboxTable) {
             for (ui32 round = 0; !MailboxTable->Cleanup(); ++round)
                 Y_VERIFY(round < 10, "cyclic event/actor spawn while trying to shutdown actorsystem stub");
@@ -72,7 +72,7 @@ namespace NActors {
 
         if (ActorSystem)
             ActorSystem->Stop();
-
+ 
         ActorSystem.Destroy();
         Poller.Reset();
     }
@@ -684,37 +684,37 @@ namespace NActors {
 
     TTestActorRuntimeBase::TEventObserver TTestActorRuntimeBase::SetObserverFunc(TEventObserver observerFunc) {
         TGuard<TMutex> guard(Mutex);
-        auto result = ObserverFunc;
-        ObserverFunc = observerFunc;
-        return result;
+        auto result = ObserverFunc; 
+        ObserverFunc = observerFunc; 
+        return result; 
     }
 
     TTestActorRuntimeBase::TScheduledEventsSelector TTestActorRuntimeBase::SetScheduledEventsSelectorFunc(TScheduledEventsSelector scheduledEventsSelectorFunc) {
         TGuard<TMutex> guard(Mutex);
-        auto result = ScheduledEventsSelectorFunc;
-        ScheduledEventsSelectorFunc = scheduledEventsSelectorFunc;
-        return result;
+        auto result = ScheduledEventsSelectorFunc; 
+        ScheduledEventsSelectorFunc = scheduledEventsSelectorFunc; 
+        return result; 
     }
 
     TTestActorRuntimeBase::TEventFilter TTestActorRuntimeBase::SetEventFilter(TEventFilter filterFunc) {
         TGuard<TMutex> guard(Mutex);
-        auto result = EventFilterFunc;
-        EventFilterFunc = filterFunc;
-        return result;
+        auto result = EventFilterFunc; 
+        EventFilterFunc = filterFunc; 
+        return result; 
     }
 
     TTestActorRuntimeBase::TScheduledEventFilter TTestActorRuntimeBase::SetScheduledEventFilter(TScheduledEventFilter filterFunc) {
         TGuard<TMutex> guard(Mutex);
-        auto result = ScheduledEventFilterFunc;
-        ScheduledEventFilterFunc = filterFunc;
-        return result;
+        auto result = ScheduledEventFilterFunc; 
+        ScheduledEventFilterFunc = filterFunc; 
+        return result; 
     }
 
     TTestActorRuntimeBase::TRegistrationObserver TTestActorRuntimeBase::SetRegistrationObserverFunc(TRegistrationObserver observerFunc) {
         TGuard<TMutex> guard(Mutex);
-        auto result = RegistrationObserver;
-        RegistrationObserver = observerFunc;
-        return result;
+        auto result = RegistrationObserver; 
+        RegistrationObserver = observerFunc; 
+        return result; 
     }
 
     bool TTestActorRuntimeBase::IsVerbose() {
@@ -1641,7 +1641,7 @@ namespace NActors {
         }
 
         const auto& interconnectCounters = GetCountersForComponent(node->DynamicCounters, "interconnect");
-
+ 
         setup->LocalServices = node->LocalServices;
         setup->Interconnect.ProxyActors.resize(FirstNodeId + NodeCount);
         const TActorId nameserviceId = GetNameserviceActorId();

library/cpp/actors/testlib/test_runtime.h

@@ -30,8 +30,8 @@
 #include <util/system/valgrind.h>
 #include <utility>
 
-#include <functional>
-
+#include <functional> 
+ 
 const TDuration DEFAULT_DISPATCH_TIMEOUT = NSan::PlainOrUnderSanitizer(
         NValgrind::PlainOrUnderValgrind(TDuration::Seconds(60), TDuration::Seconds(120)),
         TDuration::Seconds(120)
@@ -355,7 +355,7 @@ namespace NActors {
 
         template <typename TEvent>
         TEvent* GrabEdgeEvent(TAutoPtr<IEventHandle>& handle, TDuration simTimeout = TDuration::Max()) {
-            std::function<bool(const TEvent&)> truth = [](const TEvent&) { return true; };
+            std::function<bool(const TEvent&)> truth = [](const TEvent&) { return true; }; 
             return GrabEdgeEventIf(handle, truth, simTimeout);
         }
 
@@ -644,7 +644,7 @@ namespace NActors {
     }
 
     template <typename TEvent>
-    TEvent* FindEvent(TEventsList& events, const std::function<bool(const TEvent&)>& predicate) {
+    TEvent* FindEvent(TEventsList& events, const std::function<bool(const TEvent&)>& predicate) { 
         for (auto& event : events) {
             if (event && event->GetTypeRewrite() == TEvent::EventType && predicate(*static_cast<TEvent*>(event->GetBase()))) {
                 return static_cast<TEvent*>(event->GetBase());
@@ -669,7 +669,7 @@ namespace NActors {
 
     template <typename TEvent>
     TEvent* GrabEvent(TEventsList& events, TAutoPtr<IEventHandle>& ev,
-        const std::function<bool(const typename TEvent::TPtr&)>& predicate) {
+        const std::function<bool(const typename TEvent::TPtr&)>& predicate) { 
         ev.Destroy();
         for (auto& event : events) {
             if (event && event->GetTypeRewrite() == TEvent::EventType) {

library/cpp/actors/util/funnel_queue.h

@@ -1,96 +1,96 @@
-#pragma once
-
-#include <util/system/atomic.h>
-#include <util/generic/noncopyable.h>
-
+#pragma once 
+ 
+#include <util/system/atomic.h> 
+#include <util/generic/noncopyable.h> 
+ 
 template <typename ElementType>
 class TFunnelQueue: private TNonCopyable {
-public:
-    TFunnelQueue() noexcept
+public: 
+    TFunnelQueue() noexcept 
         : Front(nullptr)
         , Back(nullptr)
     {
     }
-
+ 
     virtual ~TFunnelQueue() noexcept {
-        for (auto entry = Front; entry; entry = DeleteEntry(entry))
-            continue;
-    }
-
-    /// Push element. Can be used from many threads. Return true if is first element.
-    bool
+        for (auto entry = Front; entry; entry = DeleteEntry(entry)) 
+            continue; 
+    } 
+ 
+    /// Push element. Can be used from many threads. Return true if is first element. 
+    bool 
     Push(ElementType&& element) noexcept {
         TEntry* const next = NewEntry(static_cast<ElementType&&>(element));
         TEntry* const prev = AtomicSwap(&Back, next);
         AtomicSet(prev ? prev->Next : Front, next);
-        return !prev;
-    }
-
-    /// Extract top element. Must be used only from one thread. Return true if have more.
-    bool
+        return !prev; 
+    } 
+ 
+    /// Extract top element. Must be used only from one thread. Return true if have more. 
+    bool 
     Pop() noexcept {
         if (TEntry* const top = AtomicGet(Front)) {
-            const auto last = AtomicCas(&Back, nullptr, top);
-            if (last) // This is last element in queue. Queue is empty now.
-                AtomicCas(&Front, nullptr, top);
-            else // This element is not last.
-                for (;;) {
-                    if (const auto next = AtomicGet(top->Next)) {
-                        AtomicSet(Front, next);
-                        break;
-                    }
-                    // But Next is null. Wait next assignment in spin lock.
-                }
-
-            DeleteEntry(top);
-            return !last;
-        }
-
-        return false;
-    }
-
-    /// Peek top element. Must be used only from one thread.
-    ElementType&
+            const auto last = AtomicCas(&Back, nullptr, top); 
+            if (last) // This is last element in queue. Queue is empty now. 
+                AtomicCas(&Front, nullptr, top); 
+            else // This element is not last. 
+                for (;;) { 
+                    if (const auto next = AtomicGet(top->Next)) { 
+                        AtomicSet(Front, next); 
+                        break; 
+                    } 
+                    // But Next is null. Wait next assignment in spin lock. 
+                } 
+ 
+            DeleteEntry(top); 
+            return !last; 
+        } 
+ 
+        return false; 
+    } 
+ 
+    /// Peek top element. Must be used only from one thread. 
+    ElementType& 
     Top() const noexcept {
         return AtomicGet(Front)->Data;
-    }
-
-    bool
+    } 
+ 
+    bool 
     IsEmpty() const noexcept {
-        return !AtomicGet(Front);
-    }
-
-protected:
+        return !AtomicGet(Front); 
+    } 
+ 
+protected: 
     class TEntry: private TNonCopyable {
         friend class TFunnelQueue;
 
-    private:
-        explicit TEntry(ElementType&& element) noexcept
+    private: 
+        explicit TEntry(ElementType&& element) noexcept 
             : Data(static_cast<ElementType&&>(element))
             , Next(nullptr)
         {
         }
-
+ 
         ~TEntry() noexcept {
         }
-
-    public:
-        ElementType Data;
+ 
+    public: 
+        ElementType Data; 
         TEntry* volatile Next;
-    };
-
+    }; 
+ 
     TEntry* volatile Front;
     TEntry* volatile Back;
-
+ 
     virtual TEntry* NewEntry(ElementType&& element) noexcept {
-        return new TEntry(static_cast<ElementType&&>(element));
-    }
-
+        return new TEntry(static_cast<ElementType&&>(element)); 
+    } 
+ 
     virtual TEntry* DeleteEntry(TEntry* entry) noexcept {
-        const auto next = entry->Next;
-        delete entry;
-        return next;
-    }
+        const auto next = entry->Next; 
+        delete entry; 
+        return next; 
+    } 
 
 protected:
     struct TEntryIter {
@@ -166,75 +166,75 @@ public:
     const_iterator end() const {
         return {nullptr};
     }
-};
-
+}; 
+ 
 template <typename ElementType>
 class TPooledFunnelQueue: public TFunnelQueue<ElementType> {
-public:
-    TPooledFunnelQueue() noexcept
-        : Stack(nullptr)
+public: 
+    TPooledFunnelQueue() noexcept 
+        : Stack(nullptr) 
     {
     }
-
+ 
     virtual ~TPooledFunnelQueue() noexcept override {
-        for (auto entry = TBase::Front; entry; entry = TBase::DeleteEntry(entry))
-            continue;
-        for (auto entry = Stack; entry; entry = TBase::DeleteEntry(entry))
-            continue;
-        TBase::Back = TBase::Front = Stack = nullptr;
-    }
-
-private:
-    typedef TFunnelQueue<ElementType> TBase;
-
+        for (auto entry = TBase::Front; entry; entry = TBase::DeleteEntry(entry)) 
+            continue; 
+        for (auto entry = Stack; entry; entry = TBase::DeleteEntry(entry)) 
+            continue; 
+        TBase::Back = TBase::Front = Stack = nullptr; 
+    } 
+ 
+private: 
+    typedef TFunnelQueue<ElementType> TBase; 
+ 
     typename TBase::TEntry* volatile Stack;
-
-protected:
+ 
+protected: 
     virtual typename TBase::TEntry* NewEntry(ElementType&& element) noexcept override {
         while (const auto top = AtomicGet(Stack))
             if (AtomicCas(&Stack, top->Next, top)) {
-                top->Data = static_cast<ElementType&&>(element);
-                AtomicSet(top->Next, nullptr);
-                return top;
-            }
-
-        return TBase::NewEntry(static_cast<ElementType&&>(element));
-    }
-
+                top->Data = static_cast<ElementType&&>(element); 
+                AtomicSet(top->Next, nullptr); 
+                return top; 
+            } 
+ 
+        return TBase::NewEntry(static_cast<ElementType&&>(element)); 
+    } 
+ 
     virtual typename TBase::TEntry* DeleteEntry(typename TBase::TEntry* entry) noexcept override {
-        entry->Data = ElementType();
-        const auto next = entry->Next;
+        entry->Data = ElementType(); 
+        const auto next = entry->Next; 
         do
             AtomicSet(entry->Next, AtomicGet(Stack));
         while (!AtomicCas(&Stack, entry, entry->Next));
-        return next;
-    }
-};
-
+        return next; 
+    } 
+}; 
+ 
 template <typename ElementType, template <typename T> class TQueueType = TFunnelQueue>
 class TCountedFunnelQueue: public TQueueType<ElementType> {
-public:
-    TCountedFunnelQueue() noexcept
-        : Count(0)
+public: 
+    TCountedFunnelQueue() noexcept 
+        : Count(0) 
     {
     }
-
+ 
     TAtomicBase GetSize() const noexcept {
-        return AtomicGet(Count);
-    }
-
-private:
+        return AtomicGet(Count); 
+    } 
+ 
+private: 
     typedef TQueueType<ElementType> TBase;
-
+ 
     virtual typename TBase::TEntry* NewEntry(ElementType&& element) noexcept override {
-        AtomicAdd(Count, 1);
-        return TBase::NewEntry(static_cast<ElementType&&>(element));
-    }
-
+        AtomicAdd(Count, 1); 
+        return TBase::NewEntry(static_cast<ElementType&&>(element)); 
+    } 
+ 
     virtual typename TBase::TEntry* DeleteEntry(typename TBase::TEntry* entry) noexcept override {
-        AtomicSub(Count, 1);
-        return TBase::DeleteEntry(entry);
-    }
-
-    TAtomic Count;
-};
+        AtomicSub(Count, 1); 
+        return TBase::DeleteEntry(entry); 
+    } 
+ 
+    TAtomic Count; 
+}; 

library/cpp/binsaver/bin_saver.h

@@ -147,7 +147,7 @@ private:
             TVector<typename AM::key_type, typename std::allocator_traits<typename AM::allocator_type>::template rebind_alloc<typename AM::key_type>> indices;
             indices.resize(nSize);
             TStoredSize i = 1;
-            for (auto pos = data.begin(); pos != data.end(); ++pos, ++i)
+            for (auto pos = data.begin(); pos != data.end(); ++pos, ++i) 
                 indices[nSize - i] = pos->first;
             for (TStoredSize j = 0; j < nSize; ++j)
                 Add(1, &indices[j]);
@@ -155,7 +155,7 @@ private:
                 Add(2, &data[indices[j]]);
         }
     }
-
+ 
     // hash_multimap
     template <class AMM>
     void DoAnyMultiMap(AMM& data) {
@@ -168,7 +168,7 @@ private:
             for (TStoredSize i = 0; i < nSize; ++i)
                 Add(1, &indices[i]);
             for (TStoredSize i = 0; i < nSize; ++i) {
-                std::pair<typename AMM::key_type, typename AMM::mapped_type> valToInsert;
+                std::pair<typename AMM::key_type, typename AMM::mapped_type> valToInsert; 
                 valToInsert.first = indices[i];
                 Add(2, &valToInsert.second);
                 data.insert(valToInsert);
@@ -177,9 +177,9 @@ private:
             TStoredSize nSize = data.size();
             CheckOverflow(nSize, data.size());
             Add(3, &nSize);
-            for (auto pos = data.begin(); pos != data.end(); ++pos)
+            for (auto pos = data.begin(); pos != data.end(); ++pos) 
                 Add(1, (typename AMM::key_type*)(&pos->first));
-            for (auto pos = data.begin(); pos != data.end(); ++pos)
+            for (auto pos = data.begin(); pos != data.end(); ++pos) 
                 Add(2, &pos->second);
         }
     }
@@ -345,27 +345,27 @@ public:
 
     template <class T1, class T2, class T3, class T4>
     int Add(const chunk_id, TMap<T1, T2, T3, T4>* pMap) {
-        DoAnyMap(*pMap);
+        DoAnyMap(*pMap); 
         return 0;
     }
     template <class T1, class T2, class T3, class T4, class T5>
     int Add(const chunk_id, THashMap<T1, T2, T3, T4, T5>* pHash) {
-        DoAnyMap(*pHash);
+        DoAnyMap(*pHash); 
         return 0;
     }
     template <class T1, class T2, class T3, class T4, class T5>
     int Add(const chunk_id, THashMultiMap<T1, T2, T3, T4, T5>* pHash) {
-        DoAnyMultiMap(*pHash);
+        DoAnyMultiMap(*pHash); 
         return 0;
     }
     template <class K, class L, class A>
     int Add(const chunk_id, TSet<K, L, A>* pSet) {
-        DoAnySet(*pSet);
+        DoAnySet(*pSet); 
         return 0;
     }
     template <class T1, class T2, class T3, class T4>
     int Add(const chunk_id, THashSet<T1, T2, T3, T4>* pHash) {
-        DoAnySet(*pHash);
+        DoAnySet(*pHash); 
         return 0;
     }