Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

6 files changed, 436 insertions, 436 deletions

diff --git a/library/cpp/blockcodecs/core/codecs.cpp b/library/cpp/blockcodecs/core/codecs.cpp
index 21506e812b..4f6b15b550 100644
--- a/library/cpp/blockcodecs/core/codecs.cpp
+++ b/library/cpp/blockcodecs/core/codecs.cpp
@@ -1,91 +1,91 @@
-#include "codecs.h"
+#include "codecs.h" 
 #include "common.h"
 #include "register.h"
-
-#include <util/ysaveload.h>
+ 
+#include <util/ysaveload.h> 
 #include <util/stream/null.h>
-#include <util/stream/mem.h>
-#include <util/string/cast.h>
-#include <util/string/join.h>
-#include <util/system/align.h>
-#include <util/system/unaligned_mem.h>
-#include <util/generic/hash.h>
-#include <util/generic/cast.h>
+#include <util/stream/mem.h> 
+#include <util/string/cast.h> 
+#include <util/string/join.h> 
+#include <util/system/align.h> 
+#include <util/system/unaligned_mem.h> 
+#include <util/generic/hash.h> 
+#include <util/generic/cast.h> 
 #include <util/generic/deque.h>
-#include <util/generic/buffer.h>
+#include <util/generic/buffer.h> 
 #include <util/generic/array_ref.h>
-#include <util/generic/singleton.h>
-#include <util/generic/algorithm.h>
-#include <util/generic/mem_copy.h>
-
-using namespace NBlockCodecs;
-
-namespace {
-
-    struct TCodecFactory {
-        inline TCodecFactory() {
-            Add(&Null);
-        }
-
-        inline const ICodec* Find(const TStringBuf& name) const {
-            auto it = Registry.find(name);
-
-            if (it == Registry.end()) {
-                ythrow TNotFound() << "can not found " << name << " codec";
-            }
-
-            return it->second;
-        }
-
-        inline void ListCodecs(TCodecList& lst) const {
+#include <util/generic/singleton.h> 
+#include <util/generic/algorithm.h> 
+#include <util/generic/mem_copy.h> 
+ 
+using namespace NBlockCodecs; 
+ 
+namespace { 
+ 
+    struct TCodecFactory { 
+        inline TCodecFactory() { 
+            Add(&Null); 
+        } 
+ 
+        inline const ICodec* Find(const TStringBuf& name) const { 
+            auto it = Registry.find(name); 
+ 
+            if (it == Registry.end()) { 
+                ythrow TNotFound() << "can not found " << name << " codec"; 
+            } 
+ 
+            return it->second; 
+        } 
+ 
+        inline void ListCodecs(TCodecList& lst) const { 
             for (const auto& it : Registry) {
                 lst.push_back(it.first);
-            }
-
-            Sort(lst.begin(), lst.end());
-        }
-
-        inline void Add(ICodec* codec) {
-            Registry[codec->Name()] = codec;
-        }
-
+            } 
+ 
+            Sort(lst.begin(), lst.end()); 
+        } 
+ 
+        inline void Add(ICodec* codec) { 
+            Registry[codec->Name()] = codec; 
+        } 
+ 
         inline void Add(TCodecPtr codec) {
             Codecs.push_back(std::move(codec));
             Add(Codecs.back().Get());
         }
 
-        inline void Alias(TStringBuf from, TStringBuf to) {
-            Tmp.emplace_back(from);
-            Registry[Tmp.back()] = Registry[to];
-        }
-
+        inline void Alias(TStringBuf from, TStringBuf to) { 
+            Tmp.emplace_back(from); 
+            Registry[Tmp.back()] = Registry[to]; 
+        } 
+ 
         TDeque<TString> Tmp;
-        TNullCodec Null;
+        TNullCodec Null; 
         TVector<TCodecPtr> Codecs;
         typedef THashMap<TStringBuf, ICodec*> TRegistry;
-        TRegistry Registry;
+        TRegistry Registry; 
 
         // SEARCH-8344: Global decompressed size limiter (to prevent remote DoS)
         size_t MaxPossibleDecompressedLength = Max<size_t>();
-    };
-}
-
-const ICodec* NBlockCodecs::Codec(const TStringBuf& name) {
-    return Singleton<TCodecFactory>()->Find(name);
-}
-
-TCodecList NBlockCodecs::ListAllCodecs() {
-    TCodecList ret;
-
-    Singleton<TCodecFactory>()->ListCodecs(ret);
-
-    return ret;
-}
-
+    }; 
+} 
+ 
+const ICodec* NBlockCodecs::Codec(const TStringBuf& name) { 
+    return Singleton<TCodecFactory>()->Find(name); 
+} 
+ 
+TCodecList NBlockCodecs::ListAllCodecs() { 
+    TCodecList ret; 
+ 
+    Singleton<TCodecFactory>()->ListCodecs(ret); 
+ 
+    return ret; 
+} 
+ 
 TString NBlockCodecs::ListAllCodecsAsString() {
     return JoinSeq(TStringBuf(","), ListAllCodecs());
-}
-
+} 
+ 
 void NBlockCodecs::RegisterCodec(TCodecPtr codec) {
     Singleton<TCodecFactory>()->Add(std::move(codec));
 }
@@ -113,36 +113,36 @@ size_t ICodec::GetDecompressedLength(const TData& in) const {
     return len;
 }
 
-void ICodec::Encode(const TData& in, TBuffer& out) const {
-    const size_t maxLen = MaxCompressedLength(in);
-
-    out.Reserve(maxLen);
-    out.Resize(Compress(in, out.Data()));
-}
-
-void ICodec::Decode(const TData& in, TBuffer& out) const {
+void ICodec::Encode(const TData& in, TBuffer& out) const { 
+    const size_t maxLen = MaxCompressedLength(in); 
+ 
+    out.Reserve(maxLen); 
+    out.Resize(Compress(in, out.Data())); 
+} 
+ 
+void ICodec::Decode(const TData& in, TBuffer& out) const { 
     const size_t len = GetDecompressedLength(in);
-
-    out.Reserve(len);
-    out.Resize(Decompress(in, out.Data()));
-}
-
+ 
+    out.Reserve(len); 
+    out.Resize(Decompress(in, out.Data())); 
+} 
+ 
 void ICodec::Encode(const TData& in, TString& out) const {
-    const size_t maxLen = MaxCompressedLength(in);
+    const size_t maxLen = MaxCompressedLength(in); 
     out.ReserveAndResize(maxLen);
-
+ 
     size_t actualLen = Compress(in, out.begin());
     Y_ASSERT(actualLen <= maxLen);
     out.resize(actualLen);
-}
-
+} 
+ 
 void ICodec::Decode(const TData& in, TString& out) const {
     const size_t maxLen = GetDecompressedLength(in);
     out.ReserveAndResize(maxLen);
-
+ 
     size_t actualLen = Decompress(in, out.begin());
     Y_ASSERT(actualLen <= maxLen);
     out.resize(actualLen);
-}
-
+} 
+ 
 ICodec::~ICodec() = default;
diff --git a/library/cpp/blockcodecs/core/codecs.h b/library/cpp/blockcodecs/core/codecs.h
index 9c93c00274..90b2e1842c 100644
--- a/library/cpp/blockcodecs/core/codecs.h
+++ b/library/cpp/blockcodecs/core/codecs.h
@@ -1,14 +1,14 @@
-#pragma once
-
-#include <util/generic/buffer.h>
-#include <util/generic/strbuf.h>
+#pragma once 
+ 
+#include <util/generic/buffer.h> 
+#include <util/generic/strbuf.h> 
 #include <util/generic/string.h>
 #include <util/generic/typetraits.h>
-#include <util/generic/vector.h>
-#include <util/generic/yexception.h>
-
-namespace NBlockCodecs {
-    struct TData: public TStringBuf {
+#include <util/generic/vector.h> 
+#include <util/generic/yexception.h> 
+ 
+namespace NBlockCodecs { 
+    struct TData: public TStringBuf { 
         inline TData() = default;
 
         Y_HAS_MEMBER(Data);
@@ -18,68 +18,68 @@ namespace NBlockCodecs {
         inline TData(const T& t)
             : TStringBuf((const char*)t.data(), t.size())
         {
-        }
-
+        } 
+ 
         template <class T, std::enable_if_t<THasSize<T>::value && THasData<T>::value, int> = 0>
-        inline TData(const T& t)
+        inline TData(const T& t) 
             : TStringBuf((const char*)t.Data(), t.Size())
-        {
-        }
-    };
-
-    struct TCodecError: public yexception {
-    };
-
-    struct TNotFound: public TCodecError {
-    };
-
-    struct TDataError: public TCodecError {
-    };
-
-    struct ICodec {
-        virtual ~ICodec();
-
+        { 
+        } 
+    }; 
+ 
+    struct TCodecError: public yexception { 
+    }; 
+ 
+    struct TNotFound: public TCodecError { 
+    }; 
+ 
+    struct TDataError: public TCodecError { 
+    }; 
+ 
+    struct ICodec { 
+        virtual ~ICodec(); 
+ 
         // main interface
-        virtual size_t DecompressedLength(const TData& in) const = 0;
-        virtual size_t MaxCompressedLength(const TData& in) const = 0;
-        virtual size_t Compress(const TData& in, void* out) const = 0;
-        virtual size_t Decompress(const TData& in, void* out) const = 0;
-
+        virtual size_t DecompressedLength(const TData& in) const = 0; 
+        virtual size_t MaxCompressedLength(const TData& in) const = 0; 
+        virtual size_t Compress(const TData& in, void* out) const = 0; 
+        virtual size_t Decompress(const TData& in, void* out) const = 0; 
+ 
         virtual TStringBuf Name() const noexcept = 0;
-
+ 
         // some useful helpers
-        void Encode(const TData& in, TBuffer& out) const;
-        void Decode(const TData& in, TBuffer& out) const;
-
+        void Encode(const TData& in, TBuffer& out) const; 
+        void Decode(const TData& in, TBuffer& out) const; 
+ 
         void Encode(const TData& in, TString& out) const;
         void Decode(const TData& in, TString& out) const;
-
+ 
         inline TString Encode(const TData& in) const {
             TString out;
-
-            Encode(in, out);
-
-            return out;
-        }
-
+ 
+            Encode(in, out); 
+ 
+            return out; 
+        } 
+ 
         inline TString Decode(const TData& in) const {
             TString out;
-
-            Decode(in, out);
-
-            return out;
-        }
+ 
+            Decode(in, out); 
+ 
+            return out; 
+        } 
     private:
         size_t GetDecompressedLength(const TData& in) const;
-    };
-
+    }; 
+ 
     using TCodecPtr = THolder<ICodec>;
 
-    const ICodec* Codec(const TStringBuf& name);
-
+    const ICodec* Codec(const TStringBuf& name); 
+ 
     // some aux methods
     typedef TVector<TStringBuf> TCodecList;
-    TCodecList ListAllCodecs();
+    TCodecList ListAllCodecs(); 
     TString ListAllCodecsAsString();
 
     // SEARCH-8344: Get the size of max possible decompressed block
@@ -87,4 +87,4 @@ namespace NBlockCodecs {
     // SEARCH-8344: Globally set the size of max possible decompressed block
     void SetMaxPossibleDecompressedLength(size_t maxPossibleDecompressedLength);
 
-}
+} 
diff --git a/library/cpp/blockcodecs/core/common.h b/library/cpp/blockcodecs/core/common.h
index f05df4d334..33649cf567 100644
--- a/library/cpp/blockcodecs/core/common.h
+++ b/library/cpp/blockcodecs/core/common.h
@@ -1,105 +1,105 @@
 #pragma once
-
-#include "codecs.h"
-
-#include <util/ysaveload.h>
+ 
+#include "codecs.h" 
+ 
+#include <util/ysaveload.h> 
 #include <util/stream/null.h>
-#include <util/stream/mem.h>
-#include <util/string/cast.h>
-#include <util/string/join.h>
-#include <util/system/align.h>
-#include <util/system/unaligned_mem.h>
-#include <util/generic/hash.h>
-#include <util/generic/cast.h>
-#include <util/generic/buffer.h>
+#include <util/stream/mem.h> 
+#include <util/string/cast.h> 
+#include <util/string/join.h> 
+#include <util/system/align.h> 
+#include <util/system/unaligned_mem.h> 
+#include <util/generic/hash.h> 
+#include <util/generic/cast.h> 
+#include <util/generic/buffer.h> 
 #include <util/generic/array_ref.h>
-#include <util/generic/singleton.h>
-#include <util/generic/algorithm.h>
-#include <util/generic/mem_copy.h>
-
+#include <util/generic/singleton.h> 
+#include <util/generic/algorithm.h> 
+#include <util/generic/mem_copy.h> 
+ 
 namespace NBlockCodecs {
-    struct TDecompressError: public TDataError {
-        TDecompressError(int code) {
-            *this << "cannot decompress (errcode " << code << ")";
-        }
-
-        TDecompressError(size_t exp, size_t real) {
-            *this << "broken input (expected len: " << exp << ", got: " << real << ")";
-        }
+    struct TDecompressError: public TDataError { 
+        TDecompressError(int code) { 
+            *this << "cannot decompress (errcode " << code << ")"; 
+        } 
+ 
+        TDecompressError(size_t exp, size_t real) { 
+            *this << "broken input (expected len: " << exp << ", got: " << real << ")"; 
+        } 
     };
 
-    struct TCompressError: public TDataError {
-        TCompressError(int code) {
-            *this << "cannot compress (errcode " << code << ")";
-        }
+    struct TCompressError: public TDataError { 
+        TCompressError(int code) { 
+            *this << "cannot compress (errcode " << code << ")"; 
+        } 
     };
 
-    struct TNullCodec: public ICodec {
+    struct TNullCodec: public ICodec { 
         size_t DecompressedLength(const TData& in) const override {
             return in.size();
-        }
-
+        } 
+ 
         size_t MaxCompressedLength(const TData& in) const override {
             return in.size();
-        }
-
+        } 
+ 
         size_t Compress(const TData& in, void* out) const override {
             MemCopy((char*)out, in.data(), in.size());
-
+ 
             return in.size();
-        }
-
+        } 
+ 
         size_t Decompress(const TData& in, void* out) const override {
             MemCopy((char*)out, in.data(), in.size());
-
+ 
             return in.size();
-        }
-
+        } 
+ 
         TStringBuf Name() const noexcept override {
             return TStringBuf("null");
-        }
-    };
-
-    template <class T>
-    struct TAddLengthCodec: public ICodec {
-        static inline void Check(const TData& in) {
+        } 
+    }; 
+ 
+    template <class T> 
+    struct TAddLengthCodec: public ICodec { 
+        static inline void Check(const TData& in) { 
             if (in.size() < sizeof(ui64)) {
-                ythrow TDataError() << "too small input";
-            }
-        }
-
+                ythrow TDataError() << "too small input"; 
+            } 
+        } 
+ 
         size_t DecompressedLength(const TData& in) const override {
-            Check(in);
-
+            Check(in); 
+ 
             return ReadUnaligned<ui64>(in.data());
-        }
-
+        } 
+ 
         size_t MaxCompressedLength(const TData& in) const override {
             return T::DoMaxCompressedLength(in.size()) + sizeof(ui64);
-        }
-
+        } 
+ 
         size_t Compress(const TData& in, void* out) const override {
-            ui64* ptr = (ui64*)out;
-
+            ui64* ptr = (ui64*)out; 
+ 
             WriteUnaligned<ui64>(ptr, (ui64) in.size());
-
+ 
             return Base()->DoCompress(!in ? TData(TStringBuf("")) : in, ptr + 1) + sizeof(*ptr);
-        }
-
+        } 
+ 
         size_t Decompress(const TData& in, void* out) const override {
-            Check(in);
-
+            Check(in); 
+ 
             const auto len = ReadUnaligned<ui64>(in.data());
-
+ 
             if (!len)
                 return 0;
 
             Base()->DoDecompress(TData(in).Skip(sizeof(len)), out, len);
             return len;
-        }
-
+        } 
+ 
         inline const T* Base() const noexcept {
-            return static_cast<const T*>(this);
-        }
-    };
-}
+            return static_cast<const T*>(this); 
+        } 
+    }; 
+} 
diff --git a/library/cpp/blockcodecs/core/stream.cpp b/library/cpp/blockcodecs/core/stream.cpp
index 4f7db3c32b..c0134dea28 100644
--- a/library/cpp/blockcodecs/core/stream.cpp
+++ b/library/cpp/blockcodecs/core/stream.cpp
@@ -1,212 +1,212 @@
-#include "stream.h"
-#include "codecs.h"
-
-#include <util/digest/murmur.h>
-#include <util/generic/scope.h>
-#include <util/generic/cast.h>
-#include <util/generic/hash.h>
-#include <util/generic/singleton.h>
-#include <util/stream/mem.h>
-#include <util/ysaveload.h>
-
-using namespace NBlockCodecs;
-
-namespace {
+#include "stream.h" 
+#include "codecs.h" 
+ 
+#include <util/digest/murmur.h> 
+#include <util/generic/scope.h> 
+#include <util/generic/cast.h> 
+#include <util/generic/hash.h> 
+#include <util/generic/singleton.h> 
+#include <util/stream/mem.h> 
+#include <util/ysaveload.h> 
+ 
+using namespace NBlockCodecs; 
+ 
+namespace { 
     constexpr size_t MAX_BUF_LEN = 128 * 1024 * 1024;
-
-    typedef ui16 TCodecID;
-    typedef ui64 TBlockLen;
-
-    struct TIds {
-        inline TIds() {
-            const TCodecList lst = ListAllCodecs();
-
+ 
+    typedef ui16 TCodecID; 
+    typedef ui64 TBlockLen; 
+ 
+    struct TIds { 
+        inline TIds() { 
+            const TCodecList lst = ListAllCodecs(); 
+ 
             for (size_t i = 0; i < lst.size(); ++i) {
-                const ICodec* c = Codec(lst[i]);
-
-                ByID[CodecID(c)] = c;
-            }
-        }
-
-        static inline TCodecID CodecID(const ICodec* c) {
-            const TStringBuf name = c->Name();
-
-            union {
-                ui16 Parts[2];
-                ui32 Data;
-            } x;
-
+                const ICodec* c = Codec(lst[i]); 
+ 
+                ByID[CodecID(c)] = c; 
+            } 
+        } 
+ 
+        static inline TCodecID CodecID(const ICodec* c) { 
+            const TStringBuf name = c->Name(); 
+ 
+            union { 
+                ui16 Parts[2]; 
+                ui32 Data; 
+            } x; 
+ 
             x.Data = MurmurHash<ui32>(name.data(), name.size());
-
-            return x.Parts[1] ^ x.Parts[0];
-        }
-
-        inline const ICodec* Find(TCodecID id) const {
-            TByID::const_iterator it = ByID.find(id);
-
-            if (it != ByID.end()) {
-                return it->second;
-            }
-
-            ythrow yexception() << "can not find codec by id " << id;
-        }
-
+ 
+            return x.Parts[1] ^ x.Parts[0]; 
+        } 
+ 
+        inline const ICodec* Find(TCodecID id) const { 
+            TByID::const_iterator it = ByID.find(id); 
+ 
+            if (it != ByID.end()) { 
+                return it->second; 
+            } 
+ 
+            ythrow yexception() << "can not find codec by id " << id; 
+        } 
+ 
         typedef THashMap<TCodecID, const ICodec*> TByID;
-        TByID ByID;
-    };
-
+        TByID ByID; 
+    }; 
+ 
     TCodecID CodecID(const ICodec* c) {
-        return TIds::CodecID(c);
-    }
-
+        return TIds::CodecID(c); 
+    } 
+ 
     const ICodec* CodecByID(TCodecID id) {
-        return Singleton<TIds>()->Find(id);
-    }
-}
-
+        return Singleton<TIds>()->Find(id); 
+    } 
+} 
+ 
 TCodedOutput::TCodedOutput(IOutputStream* out, const ICodec* c, size_t bufLen)
-    : C_(c)
-    , D_(bufLen)
-    , S_(out)
-{
-    if (bufLen > MAX_BUF_LEN) {
+    : C_(c) 
+    , D_(bufLen) 
+    , S_(out) 
+{ 
+    if (bufLen > MAX_BUF_LEN) { 
         ythrow yexception() << TStringBuf("too big buffer size: ") << bufLen;
-    }
-}
-
+    } 
+} 
+ 
 TCodedOutput::~TCodedOutput() {
-    try {
-        Finish();
-    } catch (...) {
-    }
-}
-
-void TCodedOutput::DoWrite(const void* buf, size_t len) {
-    const char* in = (const char*)buf;
-
-    while (len) {
-        const size_t avail = D_.Avail();
-
-        if (len < avail) {
-            D_.Append(in, len);
-
-            return;
-        }
-
-        D_.Append(in, avail);
-
+    try { 
+        Finish(); 
+    } catch (...) { 
+    } 
+} 
+ 
+void TCodedOutput::DoWrite(const void* buf, size_t len) { 
+    const char* in = (const char*)buf; 
+ 
+    while (len) { 
+        const size_t avail = D_.Avail(); 
+ 
+        if (len < avail) { 
+            D_.Append(in, len); 
+ 
+            return; 
+        } 
+ 
+        D_.Append(in, avail); 
+ 
         Y_ASSERT(!D_.Avail());
-
-        in += avail;
-        len -= avail;
-
+ 
+        in += avail; 
+        len -= avail; 
+ 
         Y_VERIFY(FlushImpl(), "flush on writing failed");
-    }
-}
-
-bool TCodedOutput::FlushImpl() {
-    const bool ret = !D_.Empty();
-    const size_t payload = sizeof(TCodecID) + sizeof(TBlockLen);
-    O_.Reserve(C_->MaxCompressedLength(D_) + payload);
-
-    void* out = O_.Data() + payload;
-    const size_t olen = C_->Compress(D_, out);
-
-    {
-        TMemoryOutput mo(O_.Data(), payload);
-
-        ::Save(&mo, CodecID(C_));
-        ::Save(&mo, SafeIntegerCast<TBlockLen>(olen));
-    }
-
-    S_->Write(O_.Data(), payload + olen);
-
-    D_.Clear();
-    O_.Clear();
-
-    return ret;
-}
-
-void TCodedOutput::DoFlush() {
-    if (S_ && !D_.Empty()) {
-        FlushImpl();
-    }
-}
-
-void TCodedOutput::DoFinish() {
-    if (S_) {
-        Y_DEFER {
+    } 
+} 
+ 
+bool TCodedOutput::FlushImpl() { 
+    const bool ret = !D_.Empty(); 
+    const size_t payload = sizeof(TCodecID) + sizeof(TBlockLen); 
+    O_.Reserve(C_->MaxCompressedLength(D_) + payload); 
+ 
+    void* out = O_.Data() + payload; 
+    const size_t olen = C_->Compress(D_, out); 
+ 
+    { 
+        TMemoryOutput mo(O_.Data(), payload); 
+ 
+        ::Save(&mo, CodecID(C_)); 
+        ::Save(&mo, SafeIntegerCast<TBlockLen>(olen)); 
+    } 
+ 
+    S_->Write(O_.Data(), payload + olen); 
+ 
+    D_.Clear(); 
+    O_.Clear(); 
+ 
+    return ret; 
+} 
+ 
+void TCodedOutput::DoFlush() { 
+    if (S_ && !D_.Empty()) { 
+        FlushImpl(); 
+    } 
+} 
+ 
+void TCodedOutput::DoFinish() { 
+    if (S_) { 
+        Y_DEFER { 
             S_ = nullptr;
-        };
-
-        if (FlushImpl()) {
-            //always write zero-length block as eos marker
-            FlushImpl();
-        }
-    }
-}
-
+        }; 
+ 
+        if (FlushImpl()) { 
+            //always write zero-length block as eos marker 
+            FlushImpl(); 
+        } 
+    } 
+} 
+ 
 TDecodedInput::TDecodedInput(IInputStream* in)
-    : S_(in)
-    , C_(nullptr)
-{
-}
-
-TDecodedInput::TDecodedInput(IInputStream* in, const ICodec* codec)
-    : S_(in)
-    , C_(codec)
-{
-}
-
+    : S_(in) 
+    , C_(nullptr) 
+{ 
+} 
+ 
+TDecodedInput::TDecodedInput(IInputStream* in, const ICodec* codec) 
+    : S_(in) 
+    , C_(codec) 
+{ 
+} 
+ 
 TDecodedInput::~TDecodedInput() = default;
-
+ 
 size_t TDecodedInput::DoUnboundedNext(const void** ptr) {
-    if (!S_) {
+    if (!S_) { 
         return 0;
-    }
-
+    } 
+ 
     TCodecID codecId;
     TBlockLen blockLen;
-
-    {
-        const size_t payload = sizeof(TCodecID) + sizeof(TBlockLen);
-        char buf[32];
-
+ 
+    { 
+        const size_t payload = sizeof(TCodecID) + sizeof(TBlockLen); 
+        char buf[32]; 
+ 
         S_->LoadOrFail(buf, payload);
-
-        TMemoryInput in(buf, payload);
-
+ 
+        TMemoryInput in(buf, payload); 
+ 
         ::Load(&in, codecId);
         ::Load(&in, blockLen);
-    }
-
+    } 
+ 
     if (!blockLen) {
         S_ = nullptr;
-
+ 
         return 0;
-    }
-
+    } 
+ 
     if (Y_UNLIKELY(blockLen > 1024 * 1024 * 1024)) {
-        ythrow yexception() << "block size exceeds 1 GiB";
+        ythrow yexception() << "block size exceeds 1 GiB"; 
     }
 
-    TBuffer block;
+    TBuffer block; 
     block.Resize(blockLen);
-
+ 
     S_->LoadOrFail(block.Data(), blockLen);
-
-    auto codec = CodecByID(codecId);
-
-    if (C_) {
+ 
+    auto codec = CodecByID(codecId); 
+ 
+    if (C_) { 
         Y_ENSURE(C_->Name() == codec->Name(), TStringBuf("incorrect stream codec"));
-    }
-
-    if (codec->DecompressedLength(block) > MAX_BUF_LEN) {
-        ythrow yexception() << "broken stream";
-    }
-
-    codec->Decode(block, D_);
-    *ptr = D_.Data();
-
+    } 
+ 
+    if (codec->DecompressedLength(block) > MAX_BUF_LEN) { 
+        ythrow yexception() << "broken stream"; 
+    } 
+ 
+    codec->Decode(block, D_); 
+    *ptr = D_.Data(); 
+ 
     return D_.Size();
-}
+} 
diff --git a/library/cpp/blockcodecs/core/stream.h b/library/cpp/blockcodecs/core/stream.h
index fd44ef88f2..b0d7929f05 100644
--- a/library/cpp/blockcodecs/core/stream.h
+++ b/library/cpp/blockcodecs/core/stream.h
@@ -1,46 +1,46 @@
-#pragma once
-
-#include <util/stream/walk.h>
-#include <util/stream/input.h>
-#include <util/stream/output.h>
-#include <util/stream/zerocopy.h>
-#include <util/generic/buffer.h>
-
-namespace NBlockCodecs {
+#pragma once 
+ 
+#include <util/stream/walk.h> 
+#include <util/stream/input.h> 
+#include <util/stream/output.h> 
+#include <util/stream/zerocopy.h> 
+#include <util/generic/buffer.h> 
+ 
+namespace NBlockCodecs { 
     struct ICodec;
-
+ 
     class TCodedOutput: public IOutputStream {
-    public:
+    public: 
         TCodedOutput(IOutputStream* out, const ICodec* c, size_t bufLen);
         ~TCodedOutput() override;
-
-    private:
+ 
+    private: 
         void DoWrite(const void* buf, size_t len) override;
         void DoFlush() override;
         void DoFinish() override;
-
-        bool FlushImpl();
-
-    private:
-        const ICodec* C_;
-        TBuffer D_;
-        TBuffer O_;
+ 
+        bool FlushImpl(); 
+ 
+    private: 
+        const ICodec* C_; 
+        TBuffer D_; 
+        TBuffer O_; 
         IOutputStream* S_;
-    };
-
+    }; 
+ 
     class TDecodedInput: public IWalkInput {
-    public:
+    public: 
         TDecodedInput(IInputStream* in);
-        TDecodedInput(IInputStream* in, const ICodec* codec);
-
+        TDecodedInput(IInputStream* in, const ICodec* codec); 
+ 
         ~TDecodedInput() override;
-
-    private:
+ 
+    private: 
         size_t DoUnboundedNext(const void** ptr) override;
-
-    private:
-        TBuffer D_;
+ 
+    private: 
+        TBuffer D_; 
         IInputStream* S_;
-        const ICodec* C_;
-    };
-}
+        const ICodec* C_; 
+    }; 
+} 
diff --git a/library/cpp/blockcodecs/core/ya.make b/library/cpp/blockcodecs/core/ya.make
index 069e15927b..1956d7dc5e 100644
--- a/library/cpp/blockcodecs/core/ya.make
+++ b/library/cpp/blockcodecs/core/ya.make
@@ -1,10 +1,10 @@
-LIBRARY()
-
-OWNER(pg)
-
-SRCS(
-    codecs.cpp
-    stream.cpp
-)
-
-END()
+LIBRARY() 
+ 
+OWNER(pg) 
+ 
+SRCS( 
+    codecs.cpp 
+    stream.cpp 
+) 
+ 
+END()