Kafka non-blocking message read

5 files changed, 6004 insertions, 1494 deletions

diff --git a/ydb/core/kafkaproxy/kafka.h b/ydb/core/kafkaproxy/kafka.h
index b7d1ade2257..8e4f5651b24 100644
--- a/ydb/core/kafkaproxy/kafka.h
+++ b/ydb/core/kafkaproxy/kafka.h
@@ -1,8 +1,16 @@
 #pragma once
 
 #include <istream>
+#include <optional>
 #include <ostream>
 
+#include <ydb/library/yql/public/decimal/yql_wide_int.h>
+
+#include <util/generic/buffer.h>
+#include <util/generic/strbuf.h>
+#include <util/system/types.h>
+
+
 namespace NKafka {
 
 /*
@@ -47,6 +55,7 @@ using TKafkaRecords = std::optional<TKafkaRawBytes>;
 
 using TKafkaVersion = i16;
 
+
 void ErrorOnUnexpectedEnd(std::istream& is);
 
 class TKafkaWritable {
@@ -108,15 +117,49 @@ private:
 };
 
 
+struct TReadDemand {
+    constexpr TReadDemand()
+        : Buffer(nullptr)
+        , Length(0)
+    {}
+
+    constexpr TReadDemand(char* buffer, size_t length)
+        : Buffer(buffer)
+        , Length(length)
+    {}
+
+    constexpr TReadDemand(size_t length)
+        : Buffer(nullptr)
+        , Length(length)
+    {}
+
+    char* GetBuffer() const { return Buffer; }
+    size_t GetLength() const { return Length; }
+    explicit operator bool() const { return 0 < Length; }
+    bool Skip() const { return nullptr == Buffer; }
+
+
+    char* Buffer;
+    size_t Length;
+};
+
+static constexpr TReadDemand NoDemand;
+
+class TReadContext {
+public:
+    virtual ~TReadContext() = default;
+    virtual TReadDemand Next() = 0;
+};
+
+
 class TMessage {
 public:
     virtual ~TMessage() = default;
 
-    virtual i16 LowestSupportedVersion() const = 0;
-    virtual i16 HighestSupportedVersion() const = 0;
     virtual i32 Size(TKafkaVersion version) const = 0;
-    virtual void Read(TKafkaReadable& readable, TKafkaVersion version) = 0;
+    //virtual void Read(TKafkaReadable& readable, TKafkaVersion version) = 0;
     virtual void Write(TKafkaWritable& writable, TKafkaVersion version) const = 0;
+    virtual std::unique_ptr<TReadContext> CreateReadContext(TKafkaVersion version) = 0;
 
     bool operator==(const TMessage& other) const = default;
 };
diff --git a/ydb/core/kafkaproxy/kafka_messages.cpp b/ydb/core/kafkaproxy/kafka_messages.cpp
index 711a9723a3a..7c45f6719c1 100644
--- a/ydb/core/kafkaproxy/kafka_messages.cpp
+++ b/ydb/core/kafkaproxy/kafka_messages.cpp
@@ -127,31 +127,153 @@ const TRequestHeaderData::CorrelationIdMeta::Type TRequestHeaderData::Correlatio
 const TRequestHeaderData::ClientIdMeta::Type TRequestHeaderData::ClientIdMeta::Default = {""};
 
 TRequestHeaderData::TRequestHeaderData() 
-        : requestApiKey(RequestApiKeyMeta::Default)
-        , requestApiVersion(RequestApiVersionMeta::Default)
-        , correlationId(CorrelationIdMeta::Default)
-        , clientId(ClientIdMeta::Default)
+        : RequestApiKey(RequestApiKeyMeta::Default)
+        , RequestApiVersion(RequestApiVersionMeta::Default)
+        , CorrelationId(CorrelationIdMeta::Default)
+        , ClientId(ClientIdMeta::Default)
 {}
 
-void TRequestHeaderData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TRequestHeaderData";
-    }
-    NPrivate::Read<RequestApiKeyMeta>(_readable, _version, requestApiKey);
-    NPrivate::Read<RequestApiVersionMeta>(_readable, _version, requestApiVersion);
-    NPrivate::Read<CorrelationIdMeta>(_readable, _version, correlationId);
-    NPrivate::Read<ClientIdMeta>(_readable, _version, clientId);
+
+class TRequestHeaderData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TRequestHeaderData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TRequestHeaderData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<RequestApiKeyMeta> RequestApiKey;
+    NPrivate::TReadStrategy<RequestApiVersionMeta> RequestApiVersion;
+    NPrivate::TReadStrategy<CorrelationIdMeta> CorrelationId;
+    NPrivate::TReadStrategy<ClientIdMeta> ClientId;
+};
+
+TRequestHeaderData::TReadContext::TReadContext(TRequestHeaderData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , RequestApiKey()
+    , RequestApiVersion()
+    , CorrelationId()
+    , ClientId()
+{}
+
+
+TReadDemand TRequestHeaderData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                RequestApiKey.Init<NPrivate::ReadFieldRule<RequestApiKeyMeta>>(Value.RequestApiKey, Version);
+            }
+            case 1: {
+                auto demand = RequestApiKey.Next<NPrivate::ReadFieldRule<RequestApiKeyMeta>>(Value.RequestApiKey, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                RequestApiVersion.Init<NPrivate::ReadFieldRule<RequestApiVersionMeta>>(Value.RequestApiVersion, Version);
+            }
+            case 3: {
+                auto demand = RequestApiVersion.Next<NPrivate::ReadFieldRule<RequestApiVersionMeta>>(Value.RequestApiVersion, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                CorrelationId.Init<NPrivate::ReadFieldRule<CorrelationIdMeta>>(Value.CorrelationId, Version);
+            }
+            case 5: {
+                auto demand = CorrelationId.Next<NPrivate::ReadFieldRule<CorrelationIdMeta>>(Value.CorrelationId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                ClientId.Init<NPrivate::ReadFieldRule<ClientIdMeta>>(Value.ClientId, Version);
+            }
+            case 7: {
+                auto demand = ClientId.Next<NPrivate::ReadFieldRule<ClientIdMeta>>(Value.ClientId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                if (!NPrivate::VersionCheck<TRequestHeaderData::MessageMeta::FlexibleVersionMin, TRequestHeaderData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 9: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 11: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 13: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 10;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -161,10 +283,10 @@ void TRequestHeaderData::Write(TKafkaWritable& _writable, TKafkaVersion _version
         ythrow yexception() << "Can't write version " << _version << " of TRequestHeaderData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<RequestApiKeyMeta>(_collector, _writable, _version, requestApiKey);
-    NPrivate::Write<RequestApiVersionMeta>(_collector, _writable, _version, requestApiVersion);
-    NPrivate::Write<CorrelationIdMeta>(_collector, _writable, _version, correlationId);
-    NPrivate::Write<ClientIdMeta>(_collector, _writable, _version, clientId);
+    NPrivate::Write<RequestApiKeyMeta>(_collector, _writable, _version, RequestApiKey);
+    NPrivate::Write<RequestApiVersionMeta>(_collector, _writable, _version, RequestApiVersion);
+    NPrivate::Write<CorrelationIdMeta>(_collector, _writable, _version, CorrelationId);
+    NPrivate::Write<ClientIdMeta>(_collector, _writable, _version, ClientId);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -174,16 +296,19 @@ void TRequestHeaderData::Write(TKafkaWritable& _writable, TKafkaVersion _version
 
 i32 TRequestHeaderData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<RequestApiKeyMeta>(_collector, _version, requestApiKey);
-    NPrivate::Size<RequestApiVersionMeta>(_collector, _version, requestApiVersion);
-    NPrivate::Size<CorrelationIdMeta>(_collector, _version, correlationId);
-    NPrivate::Size<ClientIdMeta>(_collector, _version, clientId);
+    NPrivate::Size<RequestApiKeyMeta>(_collector, _version, RequestApiKey);
+    NPrivate::Size<RequestApiVersionMeta>(_collector, _version, RequestApiVersion);
+    NPrivate::Size<CorrelationIdMeta>(_collector, _version, CorrelationId);
+    NPrivate::Size<ClientIdMeta>(_collector, _version, ClientId);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TRequestHeaderData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -192,25 +317,108 @@ i32 TRequestHeaderData::Size(TKafkaVersion _version) const {
 const TResponseHeaderData::CorrelationIdMeta::Type TResponseHeaderData::CorrelationIdMeta::Default = 0;
 
 TResponseHeaderData::TResponseHeaderData() 
-        : correlationId(CorrelationIdMeta::Default)
+        : CorrelationId(CorrelationIdMeta::Default)
 {}
 
-void TResponseHeaderData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TResponseHeaderData";
-    }
-    NPrivate::Read<CorrelationIdMeta>(_readable, _version, correlationId);
+
+class TResponseHeaderData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TResponseHeaderData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TResponseHeaderData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<CorrelationIdMeta> CorrelationId;
+};
+
+TResponseHeaderData::TReadContext::TReadContext(TResponseHeaderData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , CorrelationId()
+{}
+
+
+TReadDemand TResponseHeaderData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                CorrelationId.Init<NPrivate::ReadFieldRule<CorrelationIdMeta>>(Value.CorrelationId, Version);
+            }
+            case 1: {
+                auto demand = CorrelationId.Next<NPrivate::ReadFieldRule<CorrelationIdMeta>>(Value.CorrelationId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                if (!NPrivate::VersionCheck<TResponseHeaderData::MessageMeta::FlexibleVersionMin, TResponseHeaderData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 3: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 5: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 7: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 4;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -220,7 +428,7 @@ void TResponseHeaderData::Write(TKafkaWritable& _writable, TKafkaVersion _versio
         ythrow yexception() << "Can't write version " << _version << " of TResponseHeaderData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<CorrelationIdMeta>(_collector, _writable, _version, correlationId);
+    NPrivate::Write<CorrelationIdMeta>(_collector, _writable, _version, CorrelationId);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -230,13 +438,16 @@ void TResponseHeaderData::Write(TKafkaWritable& _writable, TKafkaVersion _versio
 
 i32 TResponseHeaderData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<CorrelationIdMeta>(_collector, _version, correlationId);
+    NPrivate::Size<CorrelationIdMeta>(_collector, _version, CorrelationId);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TResponseHeaderData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -247,30 +458,152 @@ const TProduceRequestData::AcksMeta::Type TProduceRequestData::AcksMeta::Default
 const TProduceRequestData::TimeoutMsMeta::Type TProduceRequestData::TimeoutMsMeta::Default = 0;
 
 TProduceRequestData::TProduceRequestData() 
-        : transactionalId(TransactionalIdMeta::Default)
-        , acks(AcksMeta::Default)
-        , timeoutMs(TimeoutMsMeta::Default)
+        : TransactionalId(TransactionalIdMeta::Default)
+        , Acks(AcksMeta::Default)
+        , TimeoutMs(TimeoutMsMeta::Default)
 {}
 
-void TProduceRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TProduceRequestData";
-    }
-    NPrivate::Read<TransactionalIdMeta>(_readable, _version, transactionalId);
-    NPrivate::Read<AcksMeta>(_readable, _version, acks);
-    NPrivate::Read<TimeoutMsMeta>(_readable, _version, timeoutMs);
-    NPrivate::Read<TopicDataMeta>(_readable, _version, topicData);
+
+class TProduceRequestData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TProduceRequestData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TProduceRequestData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<TransactionalIdMeta> TransactionalId;
+    NPrivate::TReadStrategy<AcksMeta> Acks;
+    NPrivate::TReadStrategy<TimeoutMsMeta> TimeoutMs;
+    NPrivate::TReadStrategy<TopicDataMeta> TopicData;
+};
+
+TProduceRequestData::TReadContext::TReadContext(TProduceRequestData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , TransactionalId()
+    , Acks()
+    , TimeoutMs()
+    , TopicData()
+{}
+
+
+TReadDemand TProduceRequestData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                TransactionalId.Init<NPrivate::ReadFieldRule<TransactionalIdMeta>>(Value.TransactionalId, Version);
+            }
+            case 1: {
+                auto demand = TransactionalId.Next<NPrivate::ReadFieldRule<TransactionalIdMeta>>(Value.TransactionalId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                Acks.Init<NPrivate::ReadFieldRule<AcksMeta>>(Value.Acks, Version);
+            }
+            case 3: {
+                auto demand = Acks.Next<NPrivate::ReadFieldRule<AcksMeta>>(Value.Acks, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                TimeoutMs.Init<NPrivate::ReadFieldRule<TimeoutMsMeta>>(Value.TimeoutMs, Version);
+            }
+            case 5: {
+                auto demand = TimeoutMs.Next<NPrivate::ReadFieldRule<TimeoutMsMeta>>(Value.TimeoutMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                TopicData.Init<NPrivate::ReadFieldRule<TopicDataMeta>>(Value.TopicData, Version);
+            }
+            case 7: {
+                auto demand = TopicData.Next<NPrivate::ReadFieldRule<TopicDataMeta>>(Value.TopicData, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                if (!NPrivate::VersionCheck<TProduceRequestData::MessageMeta::FlexibleVersionMin, TProduceRequestData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 9: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 11: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 13: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 10;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -280,10 +613,10 @@ void TProduceRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _versio
         ythrow yexception() << "Can't write version " << _version << " of TProduceRequestData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<TransactionalIdMeta>(_collector, _writable, _version, transactionalId);
-    NPrivate::Write<AcksMeta>(_collector, _writable, _version, acks);
-    NPrivate::Write<TimeoutMsMeta>(_collector, _writable, _version, timeoutMs);
-    NPrivate::Write<TopicDataMeta>(_collector, _writable, _version, topicData);
+    NPrivate::Write<TransactionalIdMeta>(_collector, _writable, _version, TransactionalId);
+    NPrivate::Write<AcksMeta>(_collector, _writable, _version, Acks);
+    NPrivate::Write<TimeoutMsMeta>(_collector, _writable, _version, TimeoutMs);
+    NPrivate::Write<TopicDataMeta>(_collector, _writable, _version, TopicData);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -293,16 +626,19 @@ void TProduceRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _versio
 
 i32 TProduceRequestData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<TransactionalIdMeta>(_collector, _version, transactionalId);
-    NPrivate::Size<AcksMeta>(_collector, _version, acks);
-    NPrivate::Size<TimeoutMsMeta>(_collector, _version, timeoutMs);
-    NPrivate::Size<TopicDataMeta>(_collector, _version, topicData);
+    NPrivate::Size<TransactionalIdMeta>(_collector, _version, TransactionalId);
+    NPrivate::Size<AcksMeta>(_collector, _version, Acks);
+    NPrivate::Size<TimeoutMsMeta>(_collector, _version, TimeoutMs);
+    NPrivate::Size<TopicDataMeta>(_collector, _version, TopicData);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TProduceRequestData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -311,26 +647,122 @@ i32 TProduceRequestData::Size(TKafkaVersion _version) const {
 const TProduceRequestData::TTopicProduceData::NameMeta::Type TProduceRequestData::TTopicProduceData::NameMeta::Default = {""};
 
 TProduceRequestData::TTopicProduceData::TTopicProduceData() 
-        : name(NameMeta::Default)
+        : Name(NameMeta::Default)
 {}
 
-void TProduceRequestData::TTopicProduceData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TProduceRequestData::TTopicProduceData";
-    }
-    NPrivate::Read<NameMeta>(_readable, _version, name);
-    NPrivate::Read<PartitionDataMeta>(_readable, _version, partitionData);
+
+class TProduceRequestData::TTopicProduceData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TProduceRequestData::TTopicProduceData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TProduceRequestData::TTopicProduceData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<NameMeta> Name;
+    NPrivate::TReadStrategy<PartitionDataMeta> PartitionData;
+};
+
+TProduceRequestData::TTopicProduceData::TReadContext::TReadContext(TProduceRequestData::TTopicProduceData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Name()
+    , PartitionData()
+{}
+
+
+TReadDemand TProduceRequestData::TTopicProduceData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Name.Init<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+            }
+            case 1: {
+                auto demand = Name.Next<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                PartitionData.Init<NPrivate::ReadFieldRule<PartitionDataMeta>>(Value.PartitionData, Version);
+            }
+            case 3: {
+                auto demand = PartitionData.Next<NPrivate::ReadFieldRule<PartitionDataMeta>>(Value.PartitionData, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TProduceRequestData::TTopicProduceData::MessageMeta::FlexibleVersionMin, TProduceRequestData::TTopicProduceData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -340,8 +772,8 @@ void TProduceRequestData::TTopicProduceData::Write(TKafkaWritable& _writable, TK
         ythrow yexception() << "Can't write version " << _version << " of TProduceRequestData::TTopicProduceData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
-    NPrivate::Write<PartitionDataMeta>(_collector, _writable, _version, partitionData);
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, Name);
+    NPrivate::Write<PartitionDataMeta>(_collector, _writable, _version, PartitionData);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -351,14 +783,17 @@ void TProduceRequestData::TTopicProduceData::Write(TKafkaWritable& _writable, TK
 
 i32 TProduceRequestData::TTopicProduceData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<NameMeta>(_collector, _version, name);
-    NPrivate::Size<PartitionDataMeta>(_collector, _version, partitionData);
+    NPrivate::Size<NameMeta>(_collector, _version, Name);
+    NPrivate::Size<PartitionDataMeta>(_collector, _version, PartitionData);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TProduceRequestData::TTopicProduceData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -367,26 +802,122 @@ i32 TProduceRequestData::TTopicProduceData::Size(TKafkaVersion _version) const {
 const TProduceRequestData::TTopicProduceData::TPartitionProduceData::IndexMeta::Type TProduceRequestData::TTopicProduceData::TPartitionProduceData::IndexMeta::Default = 0;
 
 TProduceRequestData::TTopicProduceData::TPartitionProduceData::TPartitionProduceData() 
-        : index(IndexMeta::Default)
+        : Index(IndexMeta::Default)
 {}
 
-void TProduceRequestData::TTopicProduceData::TPartitionProduceData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TProduceRequestData::TTopicProduceData::TPartitionProduceData";
-    }
-    NPrivate::Read<IndexMeta>(_readable, _version, index);
-    NPrivate::Read<RecordsMeta>(_readable, _version, records);
+
+class TProduceRequestData::TTopicProduceData::TPartitionProduceData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TProduceRequestData::TTopicProduceData::TPartitionProduceData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TProduceRequestData::TTopicProduceData::TPartitionProduceData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<IndexMeta> Index;
+    NPrivate::TReadStrategy<RecordsMeta> Records;
+};
+
+TProduceRequestData::TTopicProduceData::TPartitionProduceData::TReadContext::TReadContext(TProduceRequestData::TTopicProduceData::TPartitionProduceData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Index()
+    , Records()
+{}
+
+
+TReadDemand TProduceRequestData::TTopicProduceData::TPartitionProduceData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Index.Init<NPrivate::ReadFieldRule<IndexMeta>>(Value.Index, Version);
+            }
+            case 1: {
+                auto demand = Index.Next<NPrivate::ReadFieldRule<IndexMeta>>(Value.Index, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                Records.Init<NPrivate::ReadFieldRule<RecordsMeta>>(Value.Records, Version);
+            }
+            case 3: {
+                auto demand = Records.Next<NPrivate::ReadFieldRule<RecordsMeta>>(Value.Records, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TProduceRequestData::TTopicProduceData::TPartitionProduceData::MessageMeta::FlexibleVersionMin, TProduceRequestData::TTopicProduceData::TPartitionProduceData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -396,8 +927,8 @@ void TProduceRequestData::TTopicProduceData::TPartitionProduceData::Write(TKafka
         ythrow yexception() << "Can't write version " << _version << " of TProduceRequestData::TTopicProduceData::TPartitionProduceData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<IndexMeta>(_collector, _writable, _version, index);
-    NPrivate::Write<RecordsMeta>(_collector, _writable, _version, records);
+    NPrivate::Write<IndexMeta>(_collector, _writable, _version, Index);
+    NPrivate::Write<RecordsMeta>(_collector, _writable, _version, Records);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -407,14 +938,17 @@ void TProduceRequestData::TTopicProduceData::TPartitionProduceData::Write(TKafka
 
 i32 TProduceRequestData::TTopicProduceData::TPartitionProduceData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<IndexMeta>(_collector, _version, index);
-    NPrivate::Size<RecordsMeta>(_collector, _version, records);
+    NPrivate::Size<IndexMeta>(_collector, _version, Index);
+    NPrivate::Size<RecordsMeta>(_collector, _version, Records);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TProduceRequestData::TTopicProduceData::TPartitionProduceData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -423,26 +957,122 @@ i32 TProduceRequestData::TTopicProduceData::TPartitionProduceData::Size(TKafkaVe
 const TProduceResponseData::ThrottleTimeMsMeta::Type TProduceResponseData::ThrottleTimeMsMeta::Default = 0;
 
 TProduceResponseData::TProduceResponseData() 
-        : throttleTimeMs(ThrottleTimeMsMeta::Default)
+        : ThrottleTimeMs(ThrottleTimeMsMeta::Default)
 {}
 
-void TProduceResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TProduceResponseData";
-    }
-    NPrivate::Read<ResponsesMeta>(_readable, _version, responses);
-    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
+
+class TProduceResponseData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TProduceResponseData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TProduceResponseData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ResponsesMeta> Responses;
+    NPrivate::TReadStrategy<ThrottleTimeMsMeta> ThrottleTimeMs;
+};
+
+TProduceResponseData::TReadContext::TReadContext(TProduceResponseData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Responses()
+    , ThrottleTimeMs()
+{}
+
+
+TReadDemand TProduceResponseData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Responses.Init<NPrivate::ReadFieldRule<ResponsesMeta>>(Value.Responses, Version);
+            }
+            case 1: {
+                auto demand = Responses.Next<NPrivate::ReadFieldRule<ResponsesMeta>>(Value.Responses, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                ThrottleTimeMs.Init<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+            }
+            case 3: {
+                auto demand = ThrottleTimeMs.Next<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TProduceResponseData::MessageMeta::FlexibleVersionMin, TProduceResponseData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -452,8 +1082,8 @@ void TProduceResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _versi
         ythrow yexception() << "Can't write version " << _version << " of TProduceResponseData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ResponsesMeta>(_collector, _writable, _version, responses);
-    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
+    NPrivate::Write<ResponsesMeta>(_collector, _writable, _version, Responses);
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, ThrottleTimeMs);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -463,14 +1093,17 @@ void TProduceResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _versi
 
 i32 TProduceResponseData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ResponsesMeta>(_collector, _version, responses);
-    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
+    NPrivate::Size<ResponsesMeta>(_collector, _version, Responses);
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, ThrottleTimeMs);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TProduceResponseData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -479,26 +1112,122 @@ i32 TProduceResponseData::Size(TKafkaVersion _version) const {
 const TProduceResponseData::TTopicProduceResponse::NameMeta::Type TProduceResponseData::TTopicProduceResponse::NameMeta::Default = {""};
 
 TProduceResponseData::TTopicProduceResponse::TTopicProduceResponse() 
-        : name(NameMeta::Default)
+        : Name(NameMeta::Default)
 {}
 
-void TProduceResponseData::TTopicProduceResponse::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TProduceResponseData::TTopicProduceResponse";
-    }
-    NPrivate::Read<NameMeta>(_readable, _version, name);
-    NPrivate::Read<PartitionResponsesMeta>(_readable, _version, partitionResponses);
+
+class TProduceResponseData::TTopicProduceResponse::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TProduceResponseData::TTopicProduceResponse& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TProduceResponseData::TTopicProduceResponse& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<NameMeta> Name;
+    NPrivate::TReadStrategy<PartitionResponsesMeta> PartitionResponses;
+};
+
+TProduceResponseData::TTopicProduceResponse::TReadContext::TReadContext(TProduceResponseData::TTopicProduceResponse& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Name()
+    , PartitionResponses()
+{}
+
+
+TReadDemand TProduceResponseData::TTopicProduceResponse::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Name.Init<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+            }
+            case 1: {
+                auto demand = Name.Next<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                PartitionResponses.Init<NPrivate::ReadFieldRule<PartitionResponsesMeta>>(Value.PartitionResponses, Version);
+            }
+            case 3: {
+                auto demand = PartitionResponses.Next<NPrivate::ReadFieldRule<PartitionResponsesMeta>>(Value.PartitionResponses, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TProduceResponseData::TTopicProduceResponse::MessageMeta::FlexibleVersionMin, TProduceResponseData::TTopicProduceResponse::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -508,8 +1237,8 @@ void TProduceResponseData::TTopicProduceResponse::Write(TKafkaWritable& _writabl
         ythrow yexception() << "Can't write version " << _version << " of TProduceResponseData::TTopicProduceResponse";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
-    NPrivate::Write<PartitionResponsesMeta>(_collector, _writable, _version, partitionResponses);
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, Name);
+    NPrivate::Write<PartitionResponsesMeta>(_collector, _writable, _version, PartitionResponses);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -519,14 +1248,17 @@ void TProduceResponseData::TTopicProduceResponse::Write(TKafkaWritable& _writabl
 
 i32 TProduceResponseData::TTopicProduceResponse::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<NameMeta>(_collector, _version, name);
-    NPrivate::Size<PartitionResponsesMeta>(_collector, _version, partitionResponses);
+    NPrivate::Size<NameMeta>(_collector, _version, Name);
+    NPrivate::Size<PartitionResponsesMeta>(_collector, _version, PartitionResponses);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TProduceResponseData::TTopicProduceResponse::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -540,36 +1272,197 @@ const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::Lo
 const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::ErrorMessageMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::ErrorMessageMeta::Default = std::nullopt;
 
 TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TPartitionProduceResponse() 
-        : index(IndexMeta::Default)
-        , errorCode(ErrorCodeMeta::Default)
-        , baseOffset(BaseOffsetMeta::Default)
-        , logAppendTimeMs(LogAppendTimeMsMeta::Default)
-        , logStartOffset(LogStartOffsetMeta::Default)
-        , errorMessage(ErrorMessageMeta::Default)
+        : Index(IndexMeta::Default)
+        , ErrorCode(ErrorCodeMeta::Default)
+        , BaseOffset(BaseOffsetMeta::Default)
+        , LogAppendTimeMs(LogAppendTimeMsMeta::Default)
+        , LogStartOffset(LogStartOffsetMeta::Default)
+        , ErrorMessage(ErrorMessageMeta::Default)
 {}
 
-void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse";
-    }
-    NPrivate::Read<IndexMeta>(_readable, _version, index);
-    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
-    NPrivate::Read<BaseOffsetMeta>(_readable, _version, baseOffset);
-    NPrivate::Read<LogAppendTimeMsMeta>(_readable, _version, logAppendTimeMs);
-    NPrivate::Read<LogStartOffsetMeta>(_readable, _version, logStartOffset);
-    NPrivate::Read<RecordErrorsMeta>(_readable, _version, recordErrors);
-    NPrivate::Read<ErrorMessageMeta>(_readable, _version, errorMessage);
-    
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+
+class TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse& Value;
+    TKafkaVersion Version;
+    size_t Step;
+    
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<IndexMeta> Index;
+    NPrivate::TReadStrategy<ErrorCodeMeta> ErrorCode;
+    NPrivate::TReadStrategy<BaseOffsetMeta> BaseOffset;
+    NPrivate::TReadStrategy<LogAppendTimeMsMeta> LogAppendTimeMs;
+    NPrivate::TReadStrategy<LogStartOffsetMeta> LogStartOffset;
+    NPrivate::TReadStrategy<RecordErrorsMeta> RecordErrors;
+    NPrivate::TReadStrategy<ErrorMessageMeta> ErrorMessage;
+};
+
+TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TReadContext::TReadContext(TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Index()
+    , ErrorCode()
+    , BaseOffset()
+    , LogAppendTimeMs()
+    , LogStartOffset()
+    , RecordErrors()
+    , ErrorMessage()
+{}
+
+
+TReadDemand TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Index.Init<NPrivate::ReadFieldRule<IndexMeta>>(Value.Index, Version);
+            }
+            case 1: {
+                auto demand = Index.Next<NPrivate::ReadFieldRule<IndexMeta>>(Value.Index, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                ErrorCode.Init<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+            }
+            case 3: {
+                auto demand = ErrorCode.Next<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                BaseOffset.Init<NPrivate::ReadFieldRule<BaseOffsetMeta>>(Value.BaseOffset, Version);
+            }
+            case 5: {
+                auto demand = BaseOffset.Next<NPrivate::ReadFieldRule<BaseOffsetMeta>>(Value.BaseOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                LogAppendTimeMs.Init<NPrivate::ReadFieldRule<LogAppendTimeMsMeta>>(Value.LogAppendTimeMs, Version);
+            }
+            case 7: {
+                auto demand = LogAppendTimeMs.Next<NPrivate::ReadFieldRule<LogAppendTimeMsMeta>>(Value.LogAppendTimeMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                LogStartOffset.Init<NPrivate::ReadFieldRule<LogStartOffsetMeta>>(Value.LogStartOffset, Version);
+            }
+            case 9: {
+                auto demand = LogStartOffset.Next<NPrivate::ReadFieldRule<LogStartOffsetMeta>>(Value.LogStartOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                RecordErrors.Init<NPrivate::ReadFieldRule<RecordErrorsMeta>>(Value.RecordErrors, Version);
+            }
+            case 11: {
+                auto demand = RecordErrors.Next<NPrivate::ReadFieldRule<RecordErrorsMeta>>(Value.RecordErrors, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                ++Step;
+                ErrorMessage.Init<NPrivate::ReadFieldRule<ErrorMessageMeta>>(Value.ErrorMessage, Version);
+            }
+            case 13: {
+                auto demand = ErrorMessage.Next<NPrivate::ReadFieldRule<ErrorMessageMeta>>(Value.ErrorMessage, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 14: {
+                if (!NPrivate::VersionCheck<TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::MessageMeta::FlexibleVersionMin, TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 15: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 16: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 17: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 18: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 19: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 16;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -579,13 +1472,13 @@ void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::Wri
         ythrow yexception() << "Can't write version " << _version << " of TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<IndexMeta>(_collector, _writable, _version, index);
-    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
-    NPrivate::Write<BaseOffsetMeta>(_collector, _writable, _version, baseOffset);
-    NPrivate::Write<LogAppendTimeMsMeta>(_collector, _writable, _version, logAppendTimeMs);
-    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, logStartOffset);
-    NPrivate::Write<RecordErrorsMeta>(_collector, _writable, _version, recordErrors);
-    NPrivate::Write<ErrorMessageMeta>(_collector, _writable, _version, errorMessage);
+    NPrivate::Write<IndexMeta>(_collector, _writable, _version, Index);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, ErrorCode);
+    NPrivate::Write<BaseOffsetMeta>(_collector, _writable, _version, BaseOffset);
+    NPrivate::Write<LogAppendTimeMsMeta>(_collector, _writable, _version, LogAppendTimeMs);
+    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, LogStartOffset);
+    NPrivate::Write<RecordErrorsMeta>(_collector, _writable, _version, RecordErrors);
+    NPrivate::Write<ErrorMessageMeta>(_collector, _writable, _version, ErrorMessage);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -595,19 +1488,22 @@ void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::Wri
 
 i32 TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<IndexMeta>(_collector, _version, index);
-    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
-    NPrivate::Size<BaseOffsetMeta>(_collector, _version, baseOffset);
-    NPrivate::Size<LogAppendTimeMsMeta>(_collector, _version, logAppendTimeMs);
-    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, logStartOffset);
-    NPrivate::Size<RecordErrorsMeta>(_collector, _version, recordErrors);
-    NPrivate::Size<ErrorMessageMeta>(_collector, _version, errorMessage);
+    NPrivate::Size<IndexMeta>(_collector, _version, Index);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, ErrorCode);
+    NPrivate::Size<BaseOffsetMeta>(_collector, _version, BaseOffset);
+    NPrivate::Size<LogAppendTimeMsMeta>(_collector, _version, LogAppendTimeMs);
+    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, LogStartOffset);
+    NPrivate::Size<RecordErrorsMeta>(_collector, _version, RecordErrors);
+    NPrivate::Size<ErrorMessageMeta>(_collector, _version, ErrorMessage);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -617,27 +1513,123 @@ const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TB
 const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::BatchIndexErrorMessageMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::BatchIndexErrorMessageMeta::Default = std::nullopt;
 
 TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::TBatchIndexAndErrorMessage() 
-        : batchIndex(BatchIndexMeta::Default)
-        , batchIndexErrorMessage(BatchIndexErrorMessageMeta::Default)
+        : BatchIndex(BatchIndexMeta::Default)
+        , BatchIndexErrorMessage(BatchIndexErrorMessageMeta::Default)
 {}
 
-void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage";
-    }
-    NPrivate::Read<BatchIndexMeta>(_readable, _version, batchIndex);
-    NPrivate::Read<BatchIndexErrorMessageMeta>(_readable, _version, batchIndexErrorMessage);
+
+class TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<BatchIndexMeta> BatchIndex;
+    NPrivate::TReadStrategy<BatchIndexErrorMessageMeta> BatchIndexErrorMessage;
+};
+
+TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::TReadContext::TReadContext(TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , BatchIndex()
+    , BatchIndexErrorMessage()
+{}
+
+
+TReadDemand TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                BatchIndex.Init<NPrivate::ReadFieldRule<BatchIndexMeta>>(Value.BatchIndex, Version);
+            }
+            case 1: {
+                auto demand = BatchIndex.Next<NPrivate::ReadFieldRule<BatchIndexMeta>>(Value.BatchIndex, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                BatchIndexErrorMessage.Init<NPrivate::ReadFieldRule<BatchIndexErrorMessageMeta>>(Value.BatchIndexErrorMessage, Version);
+            }
+            case 3: {
+                auto demand = BatchIndexErrorMessage.Next<NPrivate::ReadFieldRule<BatchIndexErrorMessageMeta>>(Value.BatchIndexErrorMessage, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::MessageMeta::FlexibleVersionMin, TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -647,8 +1639,8 @@ void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBa
         ythrow yexception() << "Can't write version " << _version << " of TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<BatchIndexMeta>(_collector, _writable, _version, batchIndex);
-    NPrivate::Write<BatchIndexErrorMessageMeta>(_collector, _writable, _version, batchIndexErrorMessage);
+    NPrivate::Write<BatchIndexMeta>(_collector, _writable, _version, BatchIndex);
+    NPrivate::Write<BatchIndexErrorMessageMeta>(_collector, _writable, _version, BatchIndexErrorMessage);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -658,14 +1650,17 @@ void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBa
 
 i32 TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<BatchIndexMeta>(_collector, _version, batchIndex);
-    NPrivate::Size<BatchIndexErrorMessageMeta>(_collector, _version, batchIndexErrorMessage);
+    NPrivate::Size<BatchIndexMeta>(_collector, _version, BatchIndex);
+    NPrivate::Size<BatchIndexErrorMessageMeta>(_collector, _version, BatchIndexErrorMessage);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -682,46 +1677,264 @@ const TFetchRequestData::SessionEpochMeta::Type TFetchRequestData::SessionEpochM
 const TFetchRequestData::RackIdMeta::Type TFetchRequestData::RackIdMeta::Default = {""};
 
 TFetchRequestData::TFetchRequestData() 
-        : clusterId(ClusterIdMeta::Default)
-        , replicaId(ReplicaIdMeta::Default)
-        , maxWaitMs(MaxWaitMsMeta::Default)
-        , minBytes(MinBytesMeta::Default)
-        , maxBytes(MaxBytesMeta::Default)
-        , isolationLevel(IsolationLevelMeta::Default)
-        , sessionId(SessionIdMeta::Default)
-        , sessionEpoch(SessionEpochMeta::Default)
-        , rackId(RackIdMeta::Default)
-{}
-
-void TFetchRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchRequestData";
-    }
-    NPrivate::Read<ClusterIdMeta>(_readable, _version, clusterId);
-    NPrivate::Read<ReplicaIdMeta>(_readable, _version, replicaId);
-    NPrivate::Read<MaxWaitMsMeta>(_readable, _version, maxWaitMs);
-    NPrivate::Read<MinBytesMeta>(_readable, _version, minBytes);
-    NPrivate::Read<MaxBytesMeta>(_readable, _version, maxBytes);
-    NPrivate::Read<IsolationLevelMeta>(_readable, _version, isolationLevel);
-    NPrivate::Read<SessionIdMeta>(_readable, _version, sessionId);
-    NPrivate::Read<SessionEpochMeta>(_readable, _version, sessionEpoch);
-    NPrivate::Read<TopicsMeta>(_readable, _version, topics);
-    NPrivate::Read<ForgottenTopicsDataMeta>(_readable, _version, forgottenTopicsData);
-    NPrivate::Read<RackIdMeta>(_readable, _version, rackId);
-    
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                case ClusterIdMeta::Tag:
-                    NPrivate::ReadTag<ClusterIdMeta>(_readable, _version, clusterId);
-                    break;
-                default:
-                    _readable.skip(_size); // skip unknown tag
+        : ClusterId(ClusterIdMeta::Default)
+        , ReplicaId(ReplicaIdMeta::Default)
+        , MaxWaitMs(MaxWaitMsMeta::Default)
+        , MinBytes(MinBytesMeta::Default)
+        , MaxBytes(MaxBytesMeta::Default)
+        , IsolationLevel(IsolationLevelMeta::Default)
+        , SessionId(SessionIdMeta::Default)
+        , SessionEpoch(SessionEpochMeta::Default)
+        , RackId(RackIdMeta::Default)
+{}
+
+
+class TFetchRequestData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchRequestData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchRequestData& Value;
+    TKafkaVersion Version;
+    size_t Step;
+    
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ClusterIdMeta> ClusterId;
+    NPrivate::TReadStrategy<ReplicaIdMeta> ReplicaId;
+    NPrivate::TReadStrategy<MaxWaitMsMeta> MaxWaitMs;
+    NPrivate::TReadStrategy<MinBytesMeta> MinBytes;
+    NPrivate::TReadStrategy<MaxBytesMeta> MaxBytes;
+    NPrivate::TReadStrategy<IsolationLevelMeta> IsolationLevel;
+    NPrivate::TReadStrategy<SessionIdMeta> SessionId;
+    NPrivate::TReadStrategy<SessionEpochMeta> SessionEpoch;
+    NPrivate::TReadStrategy<TopicsMeta> Topics;
+    NPrivate::TReadStrategy<ForgottenTopicsDataMeta> ForgottenTopicsData;
+    NPrivate::TReadStrategy<RackIdMeta> RackId;
+};
+
+TFetchRequestData::TReadContext::TReadContext(TFetchRequestData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ClusterId()
+    , ReplicaId()
+    , MaxWaitMs()
+    , MinBytes()
+    , MaxBytes()
+    , IsolationLevel()
+    , SessionId()
+    , SessionEpoch()
+    , Topics()
+    , ForgottenTopicsData()
+    , RackId()
+{}
+
+
+TReadDemand TFetchRequestData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ClusterId.Init<NPrivate::ReadFieldRule<ClusterIdMeta>>(Value.ClusterId, Version);
+            }
+            case 1: {
+                auto demand = ClusterId.Next<NPrivate::ReadFieldRule<ClusterIdMeta>>(Value.ClusterId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                ReplicaId.Init<NPrivate::ReadFieldRule<ReplicaIdMeta>>(Value.ReplicaId, Version);
+            }
+            case 3: {
+                auto demand = ReplicaId.Next<NPrivate::ReadFieldRule<ReplicaIdMeta>>(Value.ReplicaId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                MaxWaitMs.Init<NPrivate::ReadFieldRule<MaxWaitMsMeta>>(Value.MaxWaitMs, Version);
+            }
+            case 5: {
+                auto demand = MaxWaitMs.Next<NPrivate::ReadFieldRule<MaxWaitMsMeta>>(Value.MaxWaitMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                MinBytes.Init<NPrivate::ReadFieldRule<MinBytesMeta>>(Value.MinBytes, Version);
+            }
+            case 7: {
+                auto demand = MinBytes.Next<NPrivate::ReadFieldRule<MinBytesMeta>>(Value.MinBytes, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                MaxBytes.Init<NPrivate::ReadFieldRule<MaxBytesMeta>>(Value.MaxBytes, Version);
+            }
+            case 9: {
+                auto demand = MaxBytes.Next<NPrivate::ReadFieldRule<MaxBytesMeta>>(Value.MaxBytes, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                IsolationLevel.Init<NPrivate::ReadFieldRule<IsolationLevelMeta>>(Value.IsolationLevel, Version);
+            }
+            case 11: {
+                auto demand = IsolationLevel.Next<NPrivate::ReadFieldRule<IsolationLevelMeta>>(Value.IsolationLevel, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                ++Step;
+                SessionId.Init<NPrivate::ReadFieldRule<SessionIdMeta>>(Value.SessionId, Version);
+            }
+            case 13: {
+                auto demand = SessionId.Next<NPrivate::ReadFieldRule<SessionIdMeta>>(Value.SessionId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 14: {
+                ++Step;
+                SessionEpoch.Init<NPrivate::ReadFieldRule<SessionEpochMeta>>(Value.SessionEpoch, Version);
+            }
+            case 15: {
+                auto demand = SessionEpoch.Next<NPrivate::ReadFieldRule<SessionEpochMeta>>(Value.SessionEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 16: {
+                ++Step;
+                Topics.Init<NPrivate::ReadFieldRule<TopicsMeta>>(Value.Topics, Version);
+            }
+            case 17: {
+                auto demand = Topics.Next<NPrivate::ReadFieldRule<TopicsMeta>>(Value.Topics, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 18: {
+                ++Step;
+                ForgottenTopicsData.Init<NPrivate::ReadFieldRule<ForgottenTopicsDataMeta>>(Value.ForgottenTopicsData, Version);
+            }
+            case 19: {
+                auto demand = ForgottenTopicsData.Next<NPrivate::ReadFieldRule<ForgottenTopicsDataMeta>>(Value.ForgottenTopicsData, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 20: {
+                ++Step;
+                RackId.Init<NPrivate::ReadFieldRule<RackIdMeta>>(Value.RackId, Version);
+            }
+            case 21: {
+                auto demand = RackId.Next<NPrivate::ReadFieldRule<RackIdMeta>>(Value.RackId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 22: {
+                if (!NPrivate::VersionCheck<TFetchRequestData::MessageMeta::FlexibleVersionMin, TFetchRequestData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 23: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 24: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 25: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 26: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 27: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    case 0: {
+                        if (!TagInitialized_) {
+                            TagInitialized_=true;
+                            ClusterId.Init<NPrivate::ReadTaggedFieldRule<ClusterIdMeta>>(Value.ClusterId, Version);
+                        }
+                        demand = ClusterId.Next<NPrivate::ReadTaggedFieldRule<ClusterIdMeta>>(Value.ClusterId, Version);
+                        break;
+                    }
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 24;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -731,44 +1944,47 @@ void TFetchRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _version)
         ythrow yexception() << "Can't write version " << _version << " of TFetchRequestData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ClusterIdMeta>(_collector, _writable, _version, clusterId);
-    NPrivate::Write<ReplicaIdMeta>(_collector, _writable, _version, replicaId);
-    NPrivate::Write<MaxWaitMsMeta>(_collector, _writable, _version, maxWaitMs);
-    NPrivate::Write<MinBytesMeta>(_collector, _writable, _version, minBytes);
-    NPrivate::Write<MaxBytesMeta>(_collector, _writable, _version, maxBytes);
-    NPrivate::Write<IsolationLevelMeta>(_collector, _writable, _version, isolationLevel);
-    NPrivate::Write<SessionIdMeta>(_collector, _writable, _version, sessionId);
-    NPrivate::Write<SessionEpochMeta>(_collector, _writable, _version, sessionEpoch);
-    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, topics);
-    NPrivate::Write<ForgottenTopicsDataMeta>(_collector, _writable, _version, forgottenTopicsData);
-    NPrivate::Write<RackIdMeta>(_collector, _writable, _version, rackId);
+    NPrivate::Write<ClusterIdMeta>(_collector, _writable, _version, ClusterId);
+    NPrivate::Write<ReplicaIdMeta>(_collector, _writable, _version, ReplicaId);
+    NPrivate::Write<MaxWaitMsMeta>(_collector, _writable, _version, MaxWaitMs);
+    NPrivate::Write<MinBytesMeta>(_collector, _writable, _version, MinBytes);
+    NPrivate::Write<MaxBytesMeta>(_collector, _writable, _version, MaxBytes);
+    NPrivate::Write<IsolationLevelMeta>(_collector, _writable, _version, IsolationLevel);
+    NPrivate::Write<SessionIdMeta>(_collector, _writable, _version, SessionId);
+    NPrivate::Write<SessionEpochMeta>(_collector, _writable, _version, SessionEpoch);
+    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, Topics);
+    NPrivate::Write<ForgottenTopicsDataMeta>(_collector, _writable, _version, ForgottenTopicsData);
+    NPrivate::Write<RackIdMeta>(_collector, _writable, _version, RackId);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
         
-        NPrivate::WriteTag<ClusterIdMeta>(_writable, _version, clusterId);
+        NPrivate::WriteTag<ClusterIdMeta>(_writable, _version, ClusterId);
     }
 }
 
 i32 TFetchRequestData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ClusterIdMeta>(_collector, _version, clusterId);
-    NPrivate::Size<ReplicaIdMeta>(_collector, _version, replicaId);
-    NPrivate::Size<MaxWaitMsMeta>(_collector, _version, maxWaitMs);
-    NPrivate::Size<MinBytesMeta>(_collector, _version, minBytes);
-    NPrivate::Size<MaxBytesMeta>(_collector, _version, maxBytes);
-    NPrivate::Size<IsolationLevelMeta>(_collector, _version, isolationLevel);
-    NPrivate::Size<SessionIdMeta>(_collector, _version, sessionId);
-    NPrivate::Size<SessionEpochMeta>(_collector, _version, sessionEpoch);
-    NPrivate::Size<TopicsMeta>(_collector, _version, topics);
-    NPrivate::Size<ForgottenTopicsDataMeta>(_collector, _version, forgottenTopicsData);
-    NPrivate::Size<RackIdMeta>(_collector, _version, rackId);
+    NPrivate::Size<ClusterIdMeta>(_collector, _version, ClusterId);
+    NPrivate::Size<ReplicaIdMeta>(_collector, _version, ReplicaId);
+    NPrivate::Size<MaxWaitMsMeta>(_collector, _version, MaxWaitMs);
+    NPrivate::Size<MinBytesMeta>(_collector, _version, MinBytes);
+    NPrivate::Size<MaxBytesMeta>(_collector, _version, MaxBytes);
+    NPrivate::Size<IsolationLevelMeta>(_collector, _version, IsolationLevel);
+    NPrivate::Size<SessionIdMeta>(_collector, _version, SessionId);
+    NPrivate::Size<SessionEpochMeta>(_collector, _version, SessionEpoch);
+    NPrivate::Size<TopicsMeta>(_collector, _version, Topics);
+    NPrivate::Size<ForgottenTopicsDataMeta>(_collector, _version, ForgottenTopicsData);
+    NPrivate::Size<RackIdMeta>(_collector, _version, RackId);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchRequestData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -778,28 +1994,137 @@ const TFetchRequestData::TFetchTopic::TopicMeta::Type TFetchRequestData::TFetchT
 const TFetchRequestData::TFetchTopic::TopicIdMeta::Type TFetchRequestData::TFetchTopic::TopicIdMeta::Default = TKafkaUuid(0, 0);
 
 TFetchRequestData::TFetchTopic::TFetchTopic() 
-        : topic(TopicMeta::Default)
-        , topicId(TopicIdMeta::Default)
+        : Topic(TopicMeta::Default)
+        , TopicId(TopicIdMeta::Default)
 {}
 
-void TFetchRequestData::TFetchTopic::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchRequestData::TFetchTopic";
-    }
-    NPrivate::Read<TopicMeta>(_readable, _version, topic);
-    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
-    NPrivate::Read<PartitionsMeta>(_readable, _version, partitions);
+
+class TFetchRequestData::TFetchTopic::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchRequestData::TFetchTopic& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchRequestData::TFetchTopic& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<TopicMeta> Topic;
+    NPrivate::TReadStrategy<TopicIdMeta> TopicId;
+    NPrivate::TReadStrategy<PartitionsMeta> Partitions;
+};
+
+TFetchRequestData::TFetchTopic::TReadContext::TReadContext(TFetchRequestData::TFetchTopic& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Topic()
+    , TopicId()
+    , Partitions()
+{}
+
+
+TReadDemand TFetchRequestData::TFetchTopic::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Topic.Init<NPrivate::ReadFieldRule<TopicMeta>>(Value.Topic, Version);
+            }
+            case 1: {
+                auto demand = Topic.Next<NPrivate::ReadFieldRule<TopicMeta>>(Value.Topic, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                TopicId.Init<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+            }
+            case 3: {
+                auto demand = TopicId.Next<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                Partitions.Init<NPrivate::ReadFieldRule<PartitionsMeta>>(Value.Partitions, Version);
+            }
+            case 5: {
+                auto demand = Partitions.Next<NPrivate::ReadFieldRule<PartitionsMeta>>(Value.Partitions, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                if (!NPrivate::VersionCheck<TFetchRequestData::TFetchTopic::MessageMeta::FlexibleVersionMin, TFetchRequestData::TFetchTopic::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 7: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 9: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 11: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 8;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -809,9 +2134,9 @@ void TFetchRequestData::TFetchTopic::Write(TKafkaWritable& _writable, TKafkaVers
         ythrow yexception() << "Can't write version " << _version << " of TFetchRequestData::TFetchTopic";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<TopicMeta>(_collector, _writable, _version, topic);
-    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
-    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, partitions);
+    NPrivate::Write<TopicMeta>(_collector, _writable, _version, Topic);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, TopicId);
+    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, Partitions);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -821,15 +2146,18 @@ void TFetchRequestData::TFetchTopic::Write(TKafkaWritable& _writable, TKafkaVers
 
 i32 TFetchRequestData::TFetchTopic::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<TopicMeta>(_collector, _version, topic);
-    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
-    NPrivate::Size<PartitionsMeta>(_collector, _version, partitions);
+    NPrivate::Size<TopicMeta>(_collector, _version, Topic);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, TopicId);
+    NPrivate::Size<PartitionsMeta>(_collector, _version, Partitions);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchRequestData::TFetchTopic::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -843,35 +2171,183 @@ const TFetchRequestData::TFetchTopic::TFetchPartition::LogStartOffsetMeta::Type
 const TFetchRequestData::TFetchTopic::TFetchPartition::PartitionMaxBytesMeta::Type TFetchRequestData::TFetchTopic::TFetchPartition::PartitionMaxBytesMeta::Default = 0;
 
 TFetchRequestData::TFetchTopic::TFetchPartition::TFetchPartition() 
-        : partition(PartitionMeta::Default)
-        , currentLeaderEpoch(CurrentLeaderEpochMeta::Default)
-        , fetchOffset(FetchOffsetMeta::Default)
-        , lastFetchedEpoch(LastFetchedEpochMeta::Default)
-        , logStartOffset(LogStartOffsetMeta::Default)
-        , partitionMaxBytes(PartitionMaxBytesMeta::Default)
+        : Partition(PartitionMeta::Default)
+        , CurrentLeaderEpoch(CurrentLeaderEpochMeta::Default)
+        , FetchOffset(FetchOffsetMeta::Default)
+        , LastFetchedEpoch(LastFetchedEpochMeta::Default)
+        , LogStartOffset(LogStartOffsetMeta::Default)
+        , PartitionMaxBytes(PartitionMaxBytesMeta::Default)
 {}
 
-void TFetchRequestData::TFetchTopic::TFetchPartition::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchRequestData::TFetchTopic::TFetchPartition";
-    }
-    NPrivate::Read<PartitionMeta>(_readable, _version, partition);
-    NPrivate::Read<CurrentLeaderEpochMeta>(_readable, _version, currentLeaderEpoch);
-    NPrivate::Read<FetchOffsetMeta>(_readable, _version, fetchOffset);
-    NPrivate::Read<LastFetchedEpochMeta>(_readable, _version, lastFetchedEpoch);
-    NPrivate::Read<LogStartOffsetMeta>(_readable, _version, logStartOffset);
-    NPrivate::Read<PartitionMaxBytesMeta>(_readable, _version, partitionMaxBytes);
-    
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+
+class TFetchRequestData::TFetchTopic::TFetchPartition::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchRequestData::TFetchTopic::TFetchPartition& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchRequestData::TFetchTopic::TFetchPartition& Value;
+    TKafkaVersion Version;
+    size_t Step;
+    
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<PartitionMeta> Partition;
+    NPrivate::TReadStrategy<CurrentLeaderEpochMeta> CurrentLeaderEpoch;
+    NPrivate::TReadStrategy<FetchOffsetMeta> FetchOffset;
+    NPrivate::TReadStrategy<LastFetchedEpochMeta> LastFetchedEpoch;
+    NPrivate::TReadStrategy<LogStartOffsetMeta> LogStartOffset;
+    NPrivate::TReadStrategy<PartitionMaxBytesMeta> PartitionMaxBytes;
+};
+
+TFetchRequestData::TFetchTopic::TFetchPartition::TReadContext::TReadContext(TFetchRequestData::TFetchTopic::TFetchPartition& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Partition()
+    , CurrentLeaderEpoch()
+    , FetchOffset()
+    , LastFetchedEpoch()
+    , LogStartOffset()
+    , PartitionMaxBytes()
+{}
+
+
+TReadDemand TFetchRequestData::TFetchTopic::TFetchPartition::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Partition.Init<NPrivate::ReadFieldRule<PartitionMeta>>(Value.Partition, Version);
+            }
+            case 1: {
+                auto demand = Partition.Next<NPrivate::ReadFieldRule<PartitionMeta>>(Value.Partition, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                CurrentLeaderEpoch.Init<NPrivate::ReadFieldRule<CurrentLeaderEpochMeta>>(Value.CurrentLeaderEpoch, Version);
+            }
+            case 3: {
+                auto demand = CurrentLeaderEpoch.Next<NPrivate::ReadFieldRule<CurrentLeaderEpochMeta>>(Value.CurrentLeaderEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                FetchOffset.Init<NPrivate::ReadFieldRule<FetchOffsetMeta>>(Value.FetchOffset, Version);
+            }
+            case 5: {
+                auto demand = FetchOffset.Next<NPrivate::ReadFieldRule<FetchOffsetMeta>>(Value.FetchOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                LastFetchedEpoch.Init<NPrivate::ReadFieldRule<LastFetchedEpochMeta>>(Value.LastFetchedEpoch, Version);
+            }
+            case 7: {
+                auto demand = LastFetchedEpoch.Next<NPrivate::ReadFieldRule<LastFetchedEpochMeta>>(Value.LastFetchedEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                LogStartOffset.Init<NPrivate::ReadFieldRule<LogStartOffsetMeta>>(Value.LogStartOffset, Version);
+            }
+            case 9: {
+                auto demand = LogStartOffset.Next<NPrivate::ReadFieldRule<LogStartOffsetMeta>>(Value.LogStartOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                PartitionMaxBytes.Init<NPrivate::ReadFieldRule<PartitionMaxBytesMeta>>(Value.PartitionMaxBytes, Version);
+            }
+            case 11: {
+                auto demand = PartitionMaxBytes.Next<NPrivate::ReadFieldRule<PartitionMaxBytesMeta>>(Value.PartitionMaxBytes, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                if (!NPrivate::VersionCheck<TFetchRequestData::TFetchTopic::TFetchPartition::MessageMeta::FlexibleVersionMin, TFetchRequestData::TFetchTopic::TFetchPartition::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 13: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 14: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 15: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 16: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 17: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 14;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -881,12 +2357,12 @@ void TFetchRequestData::TFetchTopic::TFetchPartition::Write(TKafkaWritable& _wri
         ythrow yexception() << "Can't write version " << _version << " of TFetchRequestData::TFetchTopic::TFetchPartition";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<PartitionMeta>(_collector, _writable, _version, partition);
-    NPrivate::Write<CurrentLeaderEpochMeta>(_collector, _writable, _version, currentLeaderEpoch);
-    NPrivate::Write<FetchOffsetMeta>(_collector, _writable, _version, fetchOffset);
-    NPrivate::Write<LastFetchedEpochMeta>(_collector, _writable, _version, lastFetchedEpoch);
-    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, logStartOffset);
-    NPrivate::Write<PartitionMaxBytesMeta>(_collector, _writable, _version, partitionMaxBytes);
+    NPrivate::Write<PartitionMeta>(_collector, _writable, _version, Partition);
+    NPrivate::Write<CurrentLeaderEpochMeta>(_collector, _writable, _version, CurrentLeaderEpoch);
+    NPrivate::Write<FetchOffsetMeta>(_collector, _writable, _version, FetchOffset);
+    NPrivate::Write<LastFetchedEpochMeta>(_collector, _writable, _version, LastFetchedEpoch);
+    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, LogStartOffset);
+    NPrivate::Write<PartitionMaxBytesMeta>(_collector, _writable, _version, PartitionMaxBytes);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -896,18 +2372,21 @@ void TFetchRequestData::TFetchTopic::TFetchPartition::Write(TKafkaWritable& _wri
 
 i32 TFetchRequestData::TFetchTopic::TFetchPartition::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<PartitionMeta>(_collector, _version, partition);
-    NPrivate::Size<CurrentLeaderEpochMeta>(_collector, _version, currentLeaderEpoch);
-    NPrivate::Size<FetchOffsetMeta>(_collector, _version, fetchOffset);
-    NPrivate::Size<LastFetchedEpochMeta>(_collector, _version, lastFetchedEpoch);
-    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, logStartOffset);
-    NPrivate::Size<PartitionMaxBytesMeta>(_collector, _version, partitionMaxBytes);
+    NPrivate::Size<PartitionMeta>(_collector, _version, Partition);
+    NPrivate::Size<CurrentLeaderEpochMeta>(_collector, _version, CurrentLeaderEpoch);
+    NPrivate::Size<FetchOffsetMeta>(_collector, _version, FetchOffset);
+    NPrivate::Size<LastFetchedEpochMeta>(_collector, _version, LastFetchedEpoch);
+    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, LogStartOffset);
+    NPrivate::Size<PartitionMaxBytesMeta>(_collector, _version, PartitionMaxBytes);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchRequestData::TFetchTopic::TFetchPartition::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -917,28 +2396,137 @@ const TFetchRequestData::TForgottenTopic::TopicMeta::Type TFetchRequestData::TFo
 const TFetchRequestData::TForgottenTopic::TopicIdMeta::Type TFetchRequestData::TForgottenTopic::TopicIdMeta::Default = TKafkaUuid(0, 0);
 
 TFetchRequestData::TForgottenTopic::TForgottenTopic() 
-        : topic(TopicMeta::Default)
-        , topicId(TopicIdMeta::Default)
+        : Topic(TopicMeta::Default)
+        , TopicId(TopicIdMeta::Default)
 {}
 
-void TFetchRequestData::TForgottenTopic::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchRequestData::TForgottenTopic";
-    }
-    NPrivate::Read<TopicMeta>(_readable, _version, topic);
-    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
-    NPrivate::Read<PartitionsMeta>(_readable, _version, partitions);
+
+class TFetchRequestData::TForgottenTopic::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchRequestData::TForgottenTopic& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchRequestData::TForgottenTopic& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<TopicMeta> Topic;
+    NPrivate::TReadStrategy<TopicIdMeta> TopicId;
+    NPrivate::TReadStrategy<PartitionsMeta> Partitions;
+};
+
+TFetchRequestData::TForgottenTopic::TReadContext::TReadContext(TFetchRequestData::TForgottenTopic& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Topic()
+    , TopicId()
+    , Partitions()
+{}
+
+
+TReadDemand TFetchRequestData::TForgottenTopic::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Topic.Init<NPrivate::ReadFieldRule<TopicMeta>>(Value.Topic, Version);
+            }
+            case 1: {
+                auto demand = Topic.Next<NPrivate::ReadFieldRule<TopicMeta>>(Value.Topic, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                TopicId.Init<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+            }
+            case 3: {
+                auto demand = TopicId.Next<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                Partitions.Init<NPrivate::ReadFieldRule<PartitionsMeta>>(Value.Partitions, Version);
+            }
+            case 5: {
+                auto demand = Partitions.Next<NPrivate::ReadFieldRule<PartitionsMeta>>(Value.Partitions, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                if (!NPrivate::VersionCheck<TFetchRequestData::TForgottenTopic::MessageMeta::FlexibleVersionMin, TFetchRequestData::TForgottenTopic::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 7: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 9: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 11: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 8;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -948,9 +2536,9 @@ void TFetchRequestData::TForgottenTopic::Write(TKafkaWritable& _writable, TKafka
         ythrow yexception() << "Can't write version " << _version << " of TFetchRequestData::TForgottenTopic";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<TopicMeta>(_collector, _writable, _version, topic);
-    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
-    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, partitions);
+    NPrivate::Write<TopicMeta>(_collector, _writable, _version, Topic);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, TopicId);
+    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, Partitions);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -960,15 +2548,18 @@ void TFetchRequestData::TForgottenTopic::Write(TKafkaWritable& _writable, TKafka
 
 i32 TFetchRequestData::TForgottenTopic::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<TopicMeta>(_collector, _version, topic);
-    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
-    NPrivate::Size<PartitionsMeta>(_collector, _version, partitions);
+    NPrivate::Size<TopicMeta>(_collector, _version, Topic);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, TopicId);
+    NPrivate::Size<PartitionsMeta>(_collector, _version, Partitions);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchRequestData::TForgottenTopic::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -979,30 +2570,152 @@ const TFetchResponseData::ErrorCodeMeta::Type TFetchResponseData::ErrorCodeMeta:
 const TFetchResponseData::SessionIdMeta::Type TFetchResponseData::SessionIdMeta::Default = 0;
 
 TFetchResponseData::TFetchResponseData() 
-        : throttleTimeMs(ThrottleTimeMsMeta::Default)
-        , errorCode(ErrorCodeMeta::Default)
-        , sessionId(SessionIdMeta::Default)
+        : ThrottleTimeMs(ThrottleTimeMsMeta::Default)
+        , ErrorCode(ErrorCodeMeta::Default)
+        , SessionId(SessionIdMeta::Default)
 {}
 
-void TFetchResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData";
-    }
-    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
-    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
-    NPrivate::Read<SessionIdMeta>(_readable, _version, sessionId);
-    NPrivate::Read<ResponsesMeta>(_readable, _version, responses);
+
+class TFetchResponseData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchResponseData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchResponseData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ThrottleTimeMsMeta> ThrottleTimeMs;
+    NPrivate::TReadStrategy<ErrorCodeMeta> ErrorCode;
+    NPrivate::TReadStrategy<SessionIdMeta> SessionId;
+    NPrivate::TReadStrategy<ResponsesMeta> Responses;
+};
+
+TFetchResponseData::TReadContext::TReadContext(TFetchResponseData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ThrottleTimeMs()
+    , ErrorCode()
+    , SessionId()
+    , Responses()
+{}
+
+
+TReadDemand TFetchResponseData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ThrottleTimeMs.Init<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+            }
+            case 1: {
+                auto demand = ThrottleTimeMs.Next<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                ErrorCode.Init<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+            }
+            case 3: {
+                auto demand = ErrorCode.Next<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                SessionId.Init<NPrivate::ReadFieldRule<SessionIdMeta>>(Value.SessionId, Version);
+            }
+            case 5: {
+                auto demand = SessionId.Next<NPrivate::ReadFieldRule<SessionIdMeta>>(Value.SessionId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                Responses.Init<NPrivate::ReadFieldRule<ResponsesMeta>>(Value.Responses, Version);
+            }
+            case 7: {
+                auto demand = Responses.Next<NPrivate::ReadFieldRule<ResponsesMeta>>(Value.Responses, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                if (!NPrivate::VersionCheck<TFetchResponseData::MessageMeta::FlexibleVersionMin, TFetchResponseData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 9: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 11: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 13: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 10;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1012,10 +2725,10 @@ void TFetchResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _version
         ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
-    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
-    NPrivate::Write<SessionIdMeta>(_collector, _writable, _version, sessionId);
-    NPrivate::Write<ResponsesMeta>(_collector, _writable, _version, responses);
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, ThrottleTimeMs);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, ErrorCode);
+    NPrivate::Write<SessionIdMeta>(_collector, _writable, _version, SessionId);
+    NPrivate::Write<ResponsesMeta>(_collector, _writable, _version, Responses);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1025,16 +2738,19 @@ void TFetchResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _version
 
 i32 TFetchResponseData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
-    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
-    NPrivate::Size<SessionIdMeta>(_collector, _version, sessionId);
-    NPrivate::Size<ResponsesMeta>(_collector, _version, responses);
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, ThrottleTimeMs);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, ErrorCode);
+    NPrivate::Size<SessionIdMeta>(_collector, _version, SessionId);
+    NPrivate::Size<ResponsesMeta>(_collector, _version, Responses);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchResponseData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1044,28 +2760,137 @@ const TFetchResponseData::TFetchableTopicResponse::TopicMeta::Type TFetchRespons
 const TFetchResponseData::TFetchableTopicResponse::TopicIdMeta::Type TFetchResponseData::TFetchableTopicResponse::TopicIdMeta::Default = TKafkaUuid(0, 0);
 
 TFetchResponseData::TFetchableTopicResponse::TFetchableTopicResponse() 
-        : topic(TopicMeta::Default)
-        , topicId(TopicIdMeta::Default)
+        : Topic(TopicMeta::Default)
+        , TopicId(TopicIdMeta::Default)
 {}
 
-void TFetchResponseData::TFetchableTopicResponse::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse";
-    }
-    NPrivate::Read<TopicMeta>(_readable, _version, topic);
-    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
-    NPrivate::Read<PartitionsMeta>(_readable, _version, partitions);
+
+class TFetchResponseData::TFetchableTopicResponse::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchResponseData::TFetchableTopicResponse& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchResponseData::TFetchableTopicResponse& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<TopicMeta> Topic;
+    NPrivate::TReadStrategy<TopicIdMeta> TopicId;
+    NPrivate::TReadStrategy<PartitionsMeta> Partitions;
+};
+
+TFetchResponseData::TFetchableTopicResponse::TReadContext::TReadContext(TFetchResponseData::TFetchableTopicResponse& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Topic()
+    , TopicId()
+    , Partitions()
+{}
+
+
+TReadDemand TFetchResponseData::TFetchableTopicResponse::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Topic.Init<NPrivate::ReadFieldRule<TopicMeta>>(Value.Topic, Version);
+            }
+            case 1: {
+                auto demand = Topic.Next<NPrivate::ReadFieldRule<TopicMeta>>(Value.Topic, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                TopicId.Init<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+            }
+            case 3: {
+                auto demand = TopicId.Next<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                Partitions.Init<NPrivate::ReadFieldRule<PartitionsMeta>>(Value.Partitions, Version);
+            }
+            case 5: {
+                auto demand = Partitions.Next<NPrivate::ReadFieldRule<PartitionsMeta>>(Value.Partitions, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                if (!NPrivate::VersionCheck<TFetchResponseData::TFetchableTopicResponse::MessageMeta::FlexibleVersionMin, TFetchResponseData::TFetchableTopicResponse::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 7: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 9: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 11: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 8;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1075,9 +2900,9 @@ void TFetchResponseData::TFetchableTopicResponse::Write(TKafkaWritable& _writabl
         ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<TopicMeta>(_collector, _writable, _version, topic);
-    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
-    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, partitions);
+    NPrivate::Write<TopicMeta>(_collector, _writable, _version, Topic);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, TopicId);
+    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, Partitions);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1087,15 +2912,18 @@ void TFetchResponseData::TFetchableTopicResponse::Write(TKafkaWritable& _writabl
 
 i32 TFetchResponseData::TFetchableTopicResponse::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<TopicMeta>(_collector, _version, topic);
-    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
-    NPrivate::Size<PartitionsMeta>(_collector, _version, partitions);
+    NPrivate::Size<TopicMeta>(_collector, _version, Topic);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, TopicId);
+    NPrivate::Size<PartitionsMeta>(_collector, _version, Partitions);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchResponseData::TFetchableTopicResponse::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1109,49 +2937,277 @@ const TFetchResponseData::TFetchableTopicResponse::TPartitionData::LogStartOffse
 const TFetchResponseData::TFetchableTopicResponse::TPartitionData::PreferredReadReplicaMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::PreferredReadReplicaMeta::Default = -1;
 
 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TPartitionData() 
-        : partitionIndex(PartitionIndexMeta::Default)
-        , errorCode(ErrorCodeMeta::Default)
-        , highWatermark(HighWatermarkMeta::Default)
-        , lastStableOffset(LastStableOffsetMeta::Default)
-        , logStartOffset(LogStartOffsetMeta::Default)
-        , preferredReadReplica(PreferredReadReplicaMeta::Default)
+        : PartitionIndex(PartitionIndexMeta::Default)
+        , ErrorCode(ErrorCodeMeta::Default)
+        , HighWatermark(HighWatermarkMeta::Default)
+        , LastStableOffset(LastStableOffsetMeta::Default)
+        , LogStartOffset(LogStartOffsetMeta::Default)
+        , PreferredReadReplica(PreferredReadReplicaMeta::Default)
 {}
 
-void TFetchResponseData::TFetchableTopicResponse::TPartitionData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData";
-    }
-    NPrivate::Read<PartitionIndexMeta>(_readable, _version, partitionIndex);
-    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
-    NPrivate::Read<HighWatermarkMeta>(_readable, _version, highWatermark);
-    NPrivate::Read<LastStableOffsetMeta>(_readable, _version, lastStableOffset);
-    NPrivate::Read<LogStartOffsetMeta>(_readable, _version, logStartOffset);
-    NPrivate::Read<DivergingEpochMeta>(_readable, _version, divergingEpoch);
-    NPrivate::Read<CurrentLeaderMeta>(_readable, _version, currentLeader);
-    NPrivate::Read<SnapshotIdMeta>(_readable, _version, snapshotId);
-    NPrivate::Read<AbortedTransactionsMeta>(_readable, _version, abortedTransactions);
-    NPrivate::Read<PreferredReadReplicaMeta>(_readable, _version, preferredReadReplica);
-    NPrivate::Read<RecordsMeta>(_readable, _version, records);
-    
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                case DivergingEpochMeta::Tag:
-                    NPrivate::ReadTag<DivergingEpochMeta>(_readable, _version, divergingEpoch);
-                    break;
-                case CurrentLeaderMeta::Tag:
-                    NPrivate::ReadTag<CurrentLeaderMeta>(_readable, _version, currentLeader);
-                    break;
-                case SnapshotIdMeta::Tag:
-                    NPrivate::ReadTag<SnapshotIdMeta>(_readable, _version, snapshotId);
-                    break;
-                default:
-                    _readable.skip(_size); // skip unknown tag
+
+class TFetchResponseData::TFetchableTopicResponse::TPartitionData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchResponseData::TFetchableTopicResponse::TPartitionData& Value;
+    TKafkaVersion Version;
+    size_t Step;
+    
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<PartitionIndexMeta> PartitionIndex;
+    NPrivate::TReadStrategy<ErrorCodeMeta> ErrorCode;
+    NPrivate::TReadStrategy<HighWatermarkMeta> HighWatermark;
+    NPrivate::TReadStrategy<LastStableOffsetMeta> LastStableOffset;
+    NPrivate::TReadStrategy<LogStartOffsetMeta> LogStartOffset;
+    NPrivate::TReadStrategy<DivergingEpochMeta> DivergingEpoch;
+    NPrivate::TReadStrategy<CurrentLeaderMeta> CurrentLeader;
+    NPrivate::TReadStrategy<SnapshotIdMeta> SnapshotId;
+    NPrivate::TReadStrategy<AbortedTransactionsMeta> AbortedTransactions;
+    NPrivate::TReadStrategy<PreferredReadReplicaMeta> PreferredReadReplica;
+    NPrivate::TReadStrategy<RecordsMeta> Records;
+};
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TReadContext::TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , PartitionIndex()
+    , ErrorCode()
+    , HighWatermark()
+    , LastStableOffset()
+    , LogStartOffset()
+    , DivergingEpoch()
+    , CurrentLeader()
+    , SnapshotId()
+    , AbortedTransactions()
+    , PreferredReadReplica()
+    , Records()
+{}
+
+
+TReadDemand TFetchResponseData::TFetchableTopicResponse::TPartitionData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                PartitionIndex.Init<NPrivate::ReadFieldRule<PartitionIndexMeta>>(Value.PartitionIndex, Version);
+            }
+            case 1: {
+                auto demand = PartitionIndex.Next<NPrivate::ReadFieldRule<PartitionIndexMeta>>(Value.PartitionIndex, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                ErrorCode.Init<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+            }
+            case 3: {
+                auto demand = ErrorCode.Next<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                HighWatermark.Init<NPrivate::ReadFieldRule<HighWatermarkMeta>>(Value.HighWatermark, Version);
+            }
+            case 5: {
+                auto demand = HighWatermark.Next<NPrivate::ReadFieldRule<HighWatermarkMeta>>(Value.HighWatermark, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                LastStableOffset.Init<NPrivate::ReadFieldRule<LastStableOffsetMeta>>(Value.LastStableOffset, Version);
+            }
+            case 7: {
+                auto demand = LastStableOffset.Next<NPrivate::ReadFieldRule<LastStableOffsetMeta>>(Value.LastStableOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                LogStartOffset.Init<NPrivate::ReadFieldRule<LogStartOffsetMeta>>(Value.LogStartOffset, Version);
+            }
+            case 9: {
+                auto demand = LogStartOffset.Next<NPrivate::ReadFieldRule<LogStartOffsetMeta>>(Value.LogStartOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                DivergingEpoch.Init<NPrivate::ReadFieldRule<DivergingEpochMeta>>(Value.DivergingEpoch, Version);
+            }
+            case 11: {
+                auto demand = DivergingEpoch.Next<NPrivate::ReadFieldRule<DivergingEpochMeta>>(Value.DivergingEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                ++Step;
+                CurrentLeader.Init<NPrivate::ReadFieldRule<CurrentLeaderMeta>>(Value.CurrentLeader, Version);
+            }
+            case 13: {
+                auto demand = CurrentLeader.Next<NPrivate::ReadFieldRule<CurrentLeaderMeta>>(Value.CurrentLeader, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 14: {
+                ++Step;
+                SnapshotId.Init<NPrivate::ReadFieldRule<SnapshotIdMeta>>(Value.SnapshotId, Version);
+            }
+            case 15: {
+                auto demand = SnapshotId.Next<NPrivate::ReadFieldRule<SnapshotIdMeta>>(Value.SnapshotId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 16: {
+                ++Step;
+                AbortedTransactions.Init<NPrivate::ReadFieldRule<AbortedTransactionsMeta>>(Value.AbortedTransactions, Version);
+            }
+            case 17: {
+                auto demand = AbortedTransactions.Next<NPrivate::ReadFieldRule<AbortedTransactionsMeta>>(Value.AbortedTransactions, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 18: {
+                ++Step;
+                PreferredReadReplica.Init<NPrivate::ReadFieldRule<PreferredReadReplicaMeta>>(Value.PreferredReadReplica, Version);
+            }
+            case 19: {
+                auto demand = PreferredReadReplica.Next<NPrivate::ReadFieldRule<PreferredReadReplicaMeta>>(Value.PreferredReadReplica, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 20: {
+                ++Step;
+                Records.Init<NPrivate::ReadFieldRule<RecordsMeta>>(Value.Records, Version);
+            }
+            case 21: {
+                auto demand = Records.Next<NPrivate::ReadFieldRule<RecordsMeta>>(Value.Records, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 22: {
+                if (!NPrivate::VersionCheck<TFetchResponseData::TFetchableTopicResponse::TPartitionData::MessageMeta::FlexibleVersionMin, TFetchResponseData::TFetchableTopicResponse::TPartitionData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 23: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 24: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 25: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 26: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 27: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    case 0: {
+                        if (!TagInitialized_) {
+                            TagInitialized_=true;
+                            DivergingEpoch.Init<NPrivate::ReadTaggedFieldRule<DivergingEpochMeta>>(Value.DivergingEpoch, Version);
+                        }
+                        demand = DivergingEpoch.Next<NPrivate::ReadTaggedFieldRule<DivergingEpochMeta>>(Value.DivergingEpoch, Version);
+                        break;
+                    }
+                    case 1: {
+                        if (!TagInitialized_) {
+                            TagInitialized_=true;
+                            CurrentLeader.Init<NPrivate::ReadTaggedFieldRule<CurrentLeaderMeta>>(Value.CurrentLeader, Version);
+                        }
+                        demand = CurrentLeader.Next<NPrivate::ReadTaggedFieldRule<CurrentLeaderMeta>>(Value.CurrentLeader, Version);
+                        break;
+                    }
+                    case 2: {
+                        if (!TagInitialized_) {
+                            TagInitialized_=true;
+                            SnapshotId.Init<NPrivate::ReadTaggedFieldRule<SnapshotIdMeta>>(Value.SnapshotId, Version);
+                        }
+                        demand = SnapshotId.Next<NPrivate::ReadTaggedFieldRule<SnapshotIdMeta>>(Value.SnapshotId, Version);
+                        break;
+                    }
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 24;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1161,46 +3217,49 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::Write(TKafkaWr
         ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<PartitionIndexMeta>(_collector, _writable, _version, partitionIndex);
-    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
-    NPrivate::Write<HighWatermarkMeta>(_collector, _writable, _version, highWatermark);
-    NPrivate::Write<LastStableOffsetMeta>(_collector, _writable, _version, lastStableOffset);
-    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, logStartOffset);
-    NPrivate::Write<DivergingEpochMeta>(_collector, _writable, _version, divergingEpoch);
-    NPrivate::Write<CurrentLeaderMeta>(_collector, _writable, _version, currentLeader);
-    NPrivate::Write<SnapshotIdMeta>(_collector, _writable, _version, snapshotId);
-    NPrivate::Write<AbortedTransactionsMeta>(_collector, _writable, _version, abortedTransactions);
-    NPrivate::Write<PreferredReadReplicaMeta>(_collector, _writable, _version, preferredReadReplica);
-    NPrivate::Write<RecordsMeta>(_collector, _writable, _version, records);
+    NPrivate::Write<PartitionIndexMeta>(_collector, _writable, _version, PartitionIndex);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, ErrorCode);
+    NPrivate::Write<HighWatermarkMeta>(_collector, _writable, _version, HighWatermark);
+    NPrivate::Write<LastStableOffsetMeta>(_collector, _writable, _version, LastStableOffset);
+    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, LogStartOffset);
+    NPrivate::Write<DivergingEpochMeta>(_collector, _writable, _version, DivergingEpoch);
+    NPrivate::Write<CurrentLeaderMeta>(_collector, _writable, _version, CurrentLeader);
+    NPrivate::Write<SnapshotIdMeta>(_collector, _writable, _version, SnapshotId);
+    NPrivate::Write<AbortedTransactionsMeta>(_collector, _writable, _version, AbortedTransactions);
+    NPrivate::Write<PreferredReadReplicaMeta>(_collector, _writable, _version, PreferredReadReplica);
+    NPrivate::Write<RecordsMeta>(_collector, _writable, _version, Records);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
         
-        NPrivate::WriteTag<DivergingEpochMeta>(_writable, _version, divergingEpoch);
-        NPrivate::WriteTag<CurrentLeaderMeta>(_writable, _version, currentLeader);
-        NPrivate::WriteTag<SnapshotIdMeta>(_writable, _version, snapshotId);
+        NPrivate::WriteTag<DivergingEpochMeta>(_writable, _version, DivergingEpoch);
+        NPrivate::WriteTag<CurrentLeaderMeta>(_writable, _version, CurrentLeader);
+        NPrivate::WriteTag<SnapshotIdMeta>(_writable, _version, SnapshotId);
     }
 }
 
 i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<PartitionIndexMeta>(_collector, _version, partitionIndex);
-    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
-    NPrivate::Size<HighWatermarkMeta>(_collector, _version, highWatermark);
-    NPrivate::Size<LastStableOffsetMeta>(_collector, _version, lastStableOffset);
-    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, logStartOffset);
-    NPrivate::Size<DivergingEpochMeta>(_collector, _version, divergingEpoch);
-    NPrivate::Size<CurrentLeaderMeta>(_collector, _version, currentLeader);
-    NPrivate::Size<SnapshotIdMeta>(_collector, _version, snapshotId);
-    NPrivate::Size<AbortedTransactionsMeta>(_collector, _version, abortedTransactions);
-    NPrivate::Size<PreferredReadReplicaMeta>(_collector, _version, preferredReadReplica);
-    NPrivate::Size<RecordsMeta>(_collector, _version, records);
+    NPrivate::Size<PartitionIndexMeta>(_collector, _version, PartitionIndex);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, ErrorCode);
+    NPrivate::Size<HighWatermarkMeta>(_collector, _version, HighWatermark);
+    NPrivate::Size<LastStableOffsetMeta>(_collector, _version, LastStableOffset);
+    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, LogStartOffset);
+    NPrivate::Size<DivergingEpochMeta>(_collector, _version, DivergingEpoch);
+    NPrivate::Size<CurrentLeaderMeta>(_collector, _version, CurrentLeader);
+    NPrivate::Size<SnapshotIdMeta>(_collector, _version, SnapshotId);
+    NPrivate::Size<AbortedTransactionsMeta>(_collector, _version, AbortedTransactions);
+    NPrivate::Size<PreferredReadReplicaMeta>(_collector, _version, PreferredReadReplica);
+    NPrivate::Size<RecordsMeta>(_collector, _version, Records);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchResponseData::TFetchableTopicResponse::TPartitionData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1210,27 +3269,123 @@ const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffs
 const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::EndOffsetMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::EndOffsetMeta::Default = -1;
 
 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::TEpochEndOffset() 
-        : epoch(EpochMeta::Default)
-        , endOffset(EndOffsetMeta::Default)
+        : Epoch(EpochMeta::Default)
+        , EndOffset(EndOffsetMeta::Default)
 {}
 
-void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset";
-    }
-    NPrivate::Read<EpochMeta>(_readable, _version, epoch);
-    NPrivate::Read<EndOffsetMeta>(_readable, _version, endOffset);
+
+class TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<EpochMeta> Epoch;
+    NPrivate::TReadStrategy<EndOffsetMeta> EndOffset;
+};
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::TReadContext::TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Epoch()
+    , EndOffset()
+{}
+
+
+TReadDemand TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Epoch.Init<NPrivate::ReadFieldRule<EpochMeta>>(Value.Epoch, Version);
+            }
+            case 1: {
+                auto demand = Epoch.Next<NPrivate::ReadFieldRule<EpochMeta>>(Value.Epoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                EndOffset.Init<NPrivate::ReadFieldRule<EndOffsetMeta>>(Value.EndOffset, Version);
+            }
+            case 3: {
+                auto demand = EndOffset.Next<NPrivate::ReadFieldRule<EndOffsetMeta>>(Value.EndOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::MessageMeta::FlexibleVersionMin, TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1240,8 +3395,8 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffse
         ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<EpochMeta>(_collector, _writable, _version, epoch);
-    NPrivate::Write<EndOffsetMeta>(_collector, _writable, _version, endOffset);
+    NPrivate::Write<EpochMeta>(_collector, _writable, _version, Epoch);
+    NPrivate::Write<EndOffsetMeta>(_collector, _writable, _version, EndOffset);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1251,14 +3406,17 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffse
 
 i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<EpochMeta>(_collector, _version, epoch);
-    NPrivate::Size<EndOffsetMeta>(_collector, _version, endOffset);
+    NPrivate::Size<EpochMeta>(_collector, _version, Epoch);
+    NPrivate::Size<EndOffsetMeta>(_collector, _version, EndOffset);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1268,27 +3426,123 @@ const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndE
 const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::LeaderEpochMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::LeaderEpochMeta::Default = -1;
 
 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::TLeaderIdAndEpoch() 
-        : leaderId(LeaderIdMeta::Default)
-        , leaderEpoch(LeaderEpochMeta::Default)
+        : LeaderId(LeaderIdMeta::Default)
+        , LeaderEpoch(LeaderEpochMeta::Default)
 {}
 
-void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch";
-    }
-    NPrivate::Read<LeaderIdMeta>(_readable, _version, leaderId);
-    NPrivate::Read<LeaderEpochMeta>(_readable, _version, leaderEpoch);
+
+class TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<LeaderIdMeta> LeaderId;
+    NPrivate::TReadStrategy<LeaderEpochMeta> LeaderEpoch;
+};
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::TReadContext::TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , LeaderId()
+    , LeaderEpoch()
+{}
+
+
+TReadDemand TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                LeaderId.Init<NPrivate::ReadFieldRule<LeaderIdMeta>>(Value.LeaderId, Version);
+            }
+            case 1: {
+                auto demand = LeaderId.Next<NPrivate::ReadFieldRule<LeaderIdMeta>>(Value.LeaderId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                LeaderEpoch.Init<NPrivate::ReadFieldRule<LeaderEpochMeta>>(Value.LeaderEpoch, Version);
+            }
+            case 3: {
+                auto demand = LeaderEpoch.Next<NPrivate::ReadFieldRule<LeaderEpochMeta>>(Value.LeaderEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::MessageMeta::FlexibleVersionMin, TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1298,8 +3552,8 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEp
         ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<LeaderIdMeta>(_collector, _writable, _version, leaderId);
-    NPrivate::Write<LeaderEpochMeta>(_collector, _writable, _version, leaderEpoch);
+    NPrivate::Write<LeaderIdMeta>(_collector, _writable, _version, LeaderId);
+    NPrivate::Write<LeaderEpochMeta>(_collector, _writable, _version, LeaderEpoch);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1309,14 +3563,17 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEp
 
 i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<LeaderIdMeta>(_collector, _version, leaderId);
-    NPrivate::Size<LeaderEpochMeta>(_collector, _version, leaderEpoch);
+    NPrivate::Size<LeaderIdMeta>(_collector, _version, LeaderId);
+    NPrivate::Size<LeaderEpochMeta>(_collector, _version, LeaderEpoch);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1326,27 +3583,123 @@ const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::
 const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::EpochMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::EpochMeta::Default = -1;
 
 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::TSnapshotId() 
-        : endOffset(EndOffsetMeta::Default)
-        , epoch(EpochMeta::Default)
+        : EndOffset(EndOffsetMeta::Default)
+        , Epoch(EpochMeta::Default)
 {}
 
-void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId";
-    }
-    NPrivate::Read<EndOffsetMeta>(_readable, _version, endOffset);
-    NPrivate::Read<EpochMeta>(_readable, _version, epoch);
+
+class TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<EndOffsetMeta> EndOffset;
+    NPrivate::TReadStrategy<EpochMeta> Epoch;
+};
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::TReadContext::TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , EndOffset()
+    , Epoch()
+{}
+
+
+TReadDemand TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                EndOffset.Init<NPrivate::ReadFieldRule<EndOffsetMeta>>(Value.EndOffset, Version);
+            }
+            case 1: {
+                auto demand = EndOffset.Next<NPrivate::ReadFieldRule<EndOffsetMeta>>(Value.EndOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                Epoch.Init<NPrivate::ReadFieldRule<EpochMeta>>(Value.Epoch, Version);
+            }
+            case 3: {
+                auto demand = Epoch.Next<NPrivate::ReadFieldRule<EpochMeta>>(Value.Epoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::MessageMeta::FlexibleVersionMin, TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1356,8 +3709,8 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::W
         ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<EndOffsetMeta>(_collector, _writable, _version, endOffset);
-    NPrivate::Write<EpochMeta>(_collector, _writable, _version, epoch);
+    NPrivate::Write<EndOffsetMeta>(_collector, _writable, _version, EndOffset);
+    NPrivate::Write<EpochMeta>(_collector, _writable, _version, Epoch);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1367,14 +3720,17 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::W
 
 i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<EndOffsetMeta>(_collector, _version, endOffset);
-    NPrivate::Size<EpochMeta>(_collector, _version, epoch);
+    NPrivate::Size<EndOffsetMeta>(_collector, _version, EndOffset);
+    NPrivate::Size<EpochMeta>(_collector, _version, Epoch);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1384,27 +3740,123 @@ const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTrans
 const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::FirstOffsetMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::FirstOffsetMeta::Default = 0;
 
 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::TAbortedTransaction() 
-        : producerId(ProducerIdMeta::Default)
-        , firstOffset(FirstOffsetMeta::Default)
+        : ProducerId(ProducerIdMeta::Default)
+        , FirstOffset(FirstOffsetMeta::Default)
 {}
 
-void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction";
-    }
-    NPrivate::Read<ProducerIdMeta>(_readable, _version, producerId);
-    NPrivate::Read<FirstOffsetMeta>(_readable, _version, firstOffset);
+
+class TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ProducerIdMeta> ProducerId;
+    NPrivate::TReadStrategy<FirstOffsetMeta> FirstOffset;
+};
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::TReadContext::TReadContext(TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ProducerId()
+    , FirstOffset()
+{}
+
+
+TReadDemand TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ProducerId.Init<NPrivate::ReadFieldRule<ProducerIdMeta>>(Value.ProducerId, Version);
+            }
+            case 1: {
+                auto demand = ProducerId.Next<NPrivate::ReadFieldRule<ProducerIdMeta>>(Value.ProducerId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                FirstOffset.Init<NPrivate::ReadFieldRule<FirstOffsetMeta>>(Value.FirstOffset, Version);
+            }
+            case 3: {
+                auto demand = FirstOffset.Next<NPrivate::ReadFieldRule<FirstOffsetMeta>>(Value.FirstOffset, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::MessageMeta::FlexibleVersionMin, TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1414,8 +3866,8 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransa
         ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, producerId);
-    NPrivate::Write<FirstOffsetMeta>(_collector, _writable, _version, firstOffset);
+    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, ProducerId);
+    NPrivate::Write<FirstOffsetMeta>(_collector, _writable, _version, FirstOffset);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1425,14 +3877,17 @@ void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransa
 
 i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ProducerIdMeta>(_collector, _version, producerId);
-    NPrivate::Size<FirstOffsetMeta>(_collector, _version, firstOffset);
+    NPrivate::Size<ProducerIdMeta>(_collector, _version, ProducerId);
+    NPrivate::Size<FirstOffsetMeta>(_collector, _version, FirstOffset);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1443,30 +3898,152 @@ const TMetadataRequestData::IncludeClusterAuthorizedOperationsMeta::Type TMetada
 const TMetadataRequestData::IncludeTopicAuthorizedOperationsMeta::Type TMetadataRequestData::IncludeTopicAuthorizedOperationsMeta::Default = false;
 
 TMetadataRequestData::TMetadataRequestData() 
-        : allowAutoTopicCreation(AllowAutoTopicCreationMeta::Default)
-        , includeClusterAuthorizedOperations(IncludeClusterAuthorizedOperationsMeta::Default)
-        , includeTopicAuthorizedOperations(IncludeTopicAuthorizedOperationsMeta::Default)
+        : AllowAutoTopicCreation(AllowAutoTopicCreationMeta::Default)
+        , IncludeClusterAuthorizedOperations(IncludeClusterAuthorizedOperationsMeta::Default)
+        , IncludeTopicAuthorizedOperations(IncludeTopicAuthorizedOperationsMeta::Default)
 {}
 
-void TMetadataRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TMetadataRequestData";
-    }
-    NPrivate::Read<TopicsMeta>(_readable, _version, topics);
-    NPrivate::Read<AllowAutoTopicCreationMeta>(_readable, _version, allowAutoTopicCreation);
-    NPrivate::Read<IncludeClusterAuthorizedOperationsMeta>(_readable, _version, includeClusterAuthorizedOperations);
-    NPrivate::Read<IncludeTopicAuthorizedOperationsMeta>(_readable, _version, includeTopicAuthorizedOperations);
+
+class TMetadataRequestData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TMetadataRequestData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TMetadataRequestData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<TopicsMeta> Topics;
+    NPrivate::TReadStrategy<AllowAutoTopicCreationMeta> AllowAutoTopicCreation;
+    NPrivate::TReadStrategy<IncludeClusterAuthorizedOperationsMeta> IncludeClusterAuthorizedOperations;
+    NPrivate::TReadStrategy<IncludeTopicAuthorizedOperationsMeta> IncludeTopicAuthorizedOperations;
+};
+
+TMetadataRequestData::TReadContext::TReadContext(TMetadataRequestData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Topics()
+    , AllowAutoTopicCreation()
+    , IncludeClusterAuthorizedOperations()
+    , IncludeTopicAuthorizedOperations()
+{}
+
+
+TReadDemand TMetadataRequestData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Topics.Init<NPrivate::ReadFieldRule<TopicsMeta>>(Value.Topics, Version);
+            }
+            case 1: {
+                auto demand = Topics.Next<NPrivate::ReadFieldRule<TopicsMeta>>(Value.Topics, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                AllowAutoTopicCreation.Init<NPrivate::ReadFieldRule<AllowAutoTopicCreationMeta>>(Value.AllowAutoTopicCreation, Version);
+            }
+            case 3: {
+                auto demand = AllowAutoTopicCreation.Next<NPrivate::ReadFieldRule<AllowAutoTopicCreationMeta>>(Value.AllowAutoTopicCreation, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                IncludeClusterAuthorizedOperations.Init<NPrivate::ReadFieldRule<IncludeClusterAuthorizedOperationsMeta>>(Value.IncludeClusterAuthorizedOperations, Version);
+            }
+            case 5: {
+                auto demand = IncludeClusterAuthorizedOperations.Next<NPrivate::ReadFieldRule<IncludeClusterAuthorizedOperationsMeta>>(Value.IncludeClusterAuthorizedOperations, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                IncludeTopicAuthorizedOperations.Init<NPrivate::ReadFieldRule<IncludeTopicAuthorizedOperationsMeta>>(Value.IncludeTopicAuthorizedOperations, Version);
+            }
+            case 7: {
+                auto demand = IncludeTopicAuthorizedOperations.Next<NPrivate::ReadFieldRule<IncludeTopicAuthorizedOperationsMeta>>(Value.IncludeTopicAuthorizedOperations, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                if (!NPrivate::VersionCheck<TMetadataRequestData::MessageMeta::FlexibleVersionMin, TMetadataRequestData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 9: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 11: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 13: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 10;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1476,10 +4053,10 @@ void TMetadataRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _versi
         ythrow yexception() << "Can't write version " << _version << " of TMetadataRequestData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, topics);
-    NPrivate::Write<AllowAutoTopicCreationMeta>(_collector, _writable, _version, allowAutoTopicCreation);
-    NPrivate::Write<IncludeClusterAuthorizedOperationsMeta>(_collector, _writable, _version, includeClusterAuthorizedOperations);
-    NPrivate::Write<IncludeTopicAuthorizedOperationsMeta>(_collector, _writable, _version, includeTopicAuthorizedOperations);
+    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, Topics);
+    NPrivate::Write<AllowAutoTopicCreationMeta>(_collector, _writable, _version, AllowAutoTopicCreation);
+    NPrivate::Write<IncludeClusterAuthorizedOperationsMeta>(_collector, _writable, _version, IncludeClusterAuthorizedOperations);
+    NPrivate::Write<IncludeTopicAuthorizedOperationsMeta>(_collector, _writable, _version, IncludeTopicAuthorizedOperations);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1489,16 +4066,19 @@ void TMetadataRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _versi
 
 i32 TMetadataRequestData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<TopicsMeta>(_collector, _version, topics);
-    NPrivate::Size<AllowAutoTopicCreationMeta>(_collector, _version, allowAutoTopicCreation);
-    NPrivate::Size<IncludeClusterAuthorizedOperationsMeta>(_collector, _version, includeClusterAuthorizedOperations);
-    NPrivate::Size<IncludeTopicAuthorizedOperationsMeta>(_collector, _version, includeTopicAuthorizedOperations);
+    NPrivate::Size<TopicsMeta>(_collector, _version, Topics);
+    NPrivate::Size<AllowAutoTopicCreationMeta>(_collector, _version, AllowAutoTopicCreation);
+    NPrivate::Size<IncludeClusterAuthorizedOperationsMeta>(_collector, _version, IncludeClusterAuthorizedOperations);
+    NPrivate::Size<IncludeTopicAuthorizedOperationsMeta>(_collector, _version, IncludeTopicAuthorizedOperations);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TMetadataRequestData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1508,27 +4088,123 @@ const TMetadataRequestData::TMetadataRequestTopic::TopicIdMeta::Type TMetadataRe
 const TMetadataRequestData::TMetadataRequestTopic::NameMeta::Type TMetadataRequestData::TMetadataRequestTopic::NameMeta::Default = {""};
 
 TMetadataRequestData::TMetadataRequestTopic::TMetadataRequestTopic() 
-        : topicId(TopicIdMeta::Default)
-        , name(NameMeta::Default)
+        : TopicId(TopicIdMeta::Default)
+        , Name(NameMeta::Default)
 {}
 
-void TMetadataRequestData::TMetadataRequestTopic::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TMetadataRequestData::TMetadataRequestTopic";
-    }
-    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
-    NPrivate::Read<NameMeta>(_readable, _version, name);
+
+class TMetadataRequestData::TMetadataRequestTopic::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TMetadataRequestData::TMetadataRequestTopic& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TMetadataRequestData::TMetadataRequestTopic& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<TopicIdMeta> TopicId;
+    NPrivate::TReadStrategy<NameMeta> Name;
+};
+
+TMetadataRequestData::TMetadataRequestTopic::TReadContext::TReadContext(TMetadataRequestData::TMetadataRequestTopic& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , TopicId()
+    , Name()
+{}
+
+
+TReadDemand TMetadataRequestData::TMetadataRequestTopic::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                TopicId.Init<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+            }
+            case 1: {
+                auto demand = TopicId.Next<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                Name.Init<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+            }
+            case 3: {
+                auto demand = Name.Next<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TMetadataRequestData::TMetadataRequestTopic::MessageMeta::FlexibleVersionMin, TMetadataRequestData::TMetadataRequestTopic::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1538,8 +4214,8 @@ void TMetadataRequestData::TMetadataRequestTopic::Write(TKafkaWritable& _writabl
         ythrow yexception() << "Can't write version " << _version << " of TMetadataRequestData::TMetadataRequestTopic";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
-    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, TopicId);
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, Name);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1549,14 +4225,17 @@ void TMetadataRequestData::TMetadataRequestTopic::Write(TKafkaWritable& _writabl
 
 i32 TMetadataRequestData::TMetadataRequestTopic::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
-    NPrivate::Size<NameMeta>(_collector, _version, name);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, TopicId);
+    NPrivate::Size<NameMeta>(_collector, _version, Name);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TMetadataRequestData::TMetadataRequestTopic::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1568,33 +4247,181 @@ const TMetadataResponseData::ControllerIdMeta::Type TMetadataResponseData::Contr
 const TMetadataResponseData::ClusterAuthorizedOperationsMeta::Type TMetadataResponseData::ClusterAuthorizedOperationsMeta::Default = -2147483648;
 
 TMetadataResponseData::TMetadataResponseData() 
-        : throttleTimeMs(ThrottleTimeMsMeta::Default)
-        , clusterId(ClusterIdMeta::Default)
-        , controllerId(ControllerIdMeta::Default)
-        , clusterAuthorizedOperations(ClusterAuthorizedOperationsMeta::Default)
+        : ThrottleTimeMs(ThrottleTimeMsMeta::Default)
+        , ClusterId(ClusterIdMeta::Default)
+        , ControllerId(ControllerIdMeta::Default)
+        , ClusterAuthorizedOperations(ClusterAuthorizedOperationsMeta::Default)
 {}
 
-void TMetadataResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TMetadataResponseData";
-    }
-    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
-    NPrivate::Read<BrokersMeta>(_readable, _version, brokers);
-    NPrivate::Read<ClusterIdMeta>(_readable, _version, clusterId);
-    NPrivate::Read<ControllerIdMeta>(_readable, _version, controllerId);
-    NPrivate::Read<TopicsMeta>(_readable, _version, topics);
-    NPrivate::Read<ClusterAuthorizedOperationsMeta>(_readable, _version, clusterAuthorizedOperations);
-    
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+
+class TMetadataResponseData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TMetadataResponseData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TMetadataResponseData& Value;
+    TKafkaVersion Version;
+    size_t Step;
+    
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ThrottleTimeMsMeta> ThrottleTimeMs;
+    NPrivate::TReadStrategy<BrokersMeta> Brokers;
+    NPrivate::TReadStrategy<ClusterIdMeta> ClusterId;
+    NPrivate::TReadStrategy<ControllerIdMeta> ControllerId;
+    NPrivate::TReadStrategy<TopicsMeta> Topics;
+    NPrivate::TReadStrategy<ClusterAuthorizedOperationsMeta> ClusterAuthorizedOperations;
+};
+
+TMetadataResponseData::TReadContext::TReadContext(TMetadataResponseData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ThrottleTimeMs()
+    , Brokers()
+    , ClusterId()
+    , ControllerId()
+    , Topics()
+    , ClusterAuthorizedOperations()
+{}
+
+
+TReadDemand TMetadataResponseData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ThrottleTimeMs.Init<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+            }
+            case 1: {
+                auto demand = ThrottleTimeMs.Next<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                Brokers.Init<NPrivate::ReadFieldRule<BrokersMeta>>(Value.Brokers, Version);
+            }
+            case 3: {
+                auto demand = Brokers.Next<NPrivate::ReadFieldRule<BrokersMeta>>(Value.Brokers, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                ClusterId.Init<NPrivate::ReadFieldRule<ClusterIdMeta>>(Value.ClusterId, Version);
+            }
+            case 5: {
+                auto demand = ClusterId.Next<NPrivate::ReadFieldRule<ClusterIdMeta>>(Value.ClusterId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                ControllerId.Init<NPrivate::ReadFieldRule<ControllerIdMeta>>(Value.ControllerId, Version);
+            }
+            case 7: {
+                auto demand = ControllerId.Next<NPrivate::ReadFieldRule<ControllerIdMeta>>(Value.ControllerId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                Topics.Init<NPrivate::ReadFieldRule<TopicsMeta>>(Value.Topics, Version);
+            }
+            case 9: {
+                auto demand = Topics.Next<NPrivate::ReadFieldRule<TopicsMeta>>(Value.Topics, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                ClusterAuthorizedOperations.Init<NPrivate::ReadFieldRule<ClusterAuthorizedOperationsMeta>>(Value.ClusterAuthorizedOperations, Version);
+            }
+            case 11: {
+                auto demand = ClusterAuthorizedOperations.Next<NPrivate::ReadFieldRule<ClusterAuthorizedOperationsMeta>>(Value.ClusterAuthorizedOperations, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                if (!NPrivate::VersionCheck<TMetadataResponseData::MessageMeta::FlexibleVersionMin, TMetadataResponseData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 13: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 14: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 15: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 16: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 17: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 14;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1604,12 +4431,12 @@ void TMetadataResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _vers
         ythrow yexception() << "Can't write version " << _version << " of TMetadataResponseData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
-    NPrivate::Write<BrokersMeta>(_collector, _writable, _version, brokers);
-    NPrivate::Write<ClusterIdMeta>(_collector, _writable, _version, clusterId);
-    NPrivate::Write<ControllerIdMeta>(_collector, _writable, _version, controllerId);
-    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, topics);
-    NPrivate::Write<ClusterAuthorizedOperationsMeta>(_collector, _writable, _version, clusterAuthorizedOperations);
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, ThrottleTimeMs);
+    NPrivate::Write<BrokersMeta>(_collector, _writable, _version, Brokers);
+    NPrivate::Write<ClusterIdMeta>(_collector, _writable, _version, ClusterId);
+    NPrivate::Write<ControllerIdMeta>(_collector, _writable, _version, ControllerId);
+    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, Topics);
+    NPrivate::Write<ClusterAuthorizedOperationsMeta>(_collector, _writable, _version, ClusterAuthorizedOperations);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1619,18 +4446,21 @@ void TMetadataResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _vers
 
 i32 TMetadataResponseData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
-    NPrivate::Size<BrokersMeta>(_collector, _version, brokers);
-    NPrivate::Size<ClusterIdMeta>(_collector, _version, clusterId);
-    NPrivate::Size<ControllerIdMeta>(_collector, _version, controllerId);
-    NPrivate::Size<TopicsMeta>(_collector, _version, topics);
-    NPrivate::Size<ClusterAuthorizedOperationsMeta>(_collector, _version, clusterAuthorizedOperations);
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, ThrottleTimeMs);
+    NPrivate::Size<BrokersMeta>(_collector, _version, Brokers);
+    NPrivate::Size<ClusterIdMeta>(_collector, _version, ClusterId);
+    NPrivate::Size<ControllerIdMeta>(_collector, _version, ControllerId);
+    NPrivate::Size<TopicsMeta>(_collector, _version, Topics);
+    NPrivate::Size<ClusterAuthorizedOperationsMeta>(_collector, _version, ClusterAuthorizedOperations);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TMetadataResponseData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1642,31 +4472,153 @@ const TMetadataResponseData::TMetadataResponseBroker::PortMeta::Type TMetadataRe
 const TMetadataResponseData::TMetadataResponseBroker::RackMeta::Type TMetadataResponseData::TMetadataResponseBroker::RackMeta::Default = std::nullopt;
 
 TMetadataResponseData::TMetadataResponseBroker::TMetadataResponseBroker() 
-        : nodeId(NodeIdMeta::Default)
-        , host(HostMeta::Default)
-        , port(PortMeta::Default)
-        , rack(RackMeta::Default)
+        : NodeId(NodeIdMeta::Default)
+        , Host(HostMeta::Default)
+        , Port(PortMeta::Default)
+        , Rack(RackMeta::Default)
 {}
 
-void TMetadataResponseData::TMetadataResponseBroker::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TMetadataResponseData::TMetadataResponseBroker";
-    }
-    NPrivate::Read<NodeIdMeta>(_readable, _version, nodeId);
-    NPrivate::Read<HostMeta>(_readable, _version, host);
-    NPrivate::Read<PortMeta>(_readable, _version, port);
-    NPrivate::Read<RackMeta>(_readable, _version, rack);
+
+class TMetadataResponseData::TMetadataResponseBroker::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TMetadataResponseData::TMetadataResponseBroker& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TMetadataResponseData::TMetadataResponseBroker& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<NodeIdMeta> NodeId;
+    NPrivate::TReadStrategy<HostMeta> Host;
+    NPrivate::TReadStrategy<PortMeta> Port;
+    NPrivate::TReadStrategy<RackMeta> Rack;
+};
+
+TMetadataResponseData::TMetadataResponseBroker::TReadContext::TReadContext(TMetadataResponseData::TMetadataResponseBroker& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , NodeId()
+    , Host()
+    , Port()
+    , Rack()
+{}
+
+
+TReadDemand TMetadataResponseData::TMetadataResponseBroker::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                NodeId.Init<NPrivate::ReadFieldRule<NodeIdMeta>>(Value.NodeId, Version);
+            }
+            case 1: {
+                auto demand = NodeId.Next<NPrivate::ReadFieldRule<NodeIdMeta>>(Value.NodeId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                Host.Init<NPrivate::ReadFieldRule<HostMeta>>(Value.Host, Version);
+            }
+            case 3: {
+                auto demand = Host.Next<NPrivate::ReadFieldRule<HostMeta>>(Value.Host, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                Port.Init<NPrivate::ReadFieldRule<PortMeta>>(Value.Port, Version);
+            }
+            case 5: {
+                auto demand = Port.Next<NPrivate::ReadFieldRule<PortMeta>>(Value.Port, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                Rack.Init<NPrivate::ReadFieldRule<RackMeta>>(Value.Rack, Version);
+            }
+            case 7: {
+                auto demand = Rack.Next<NPrivate::ReadFieldRule<RackMeta>>(Value.Rack, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                if (!NPrivate::VersionCheck<TMetadataResponseData::TMetadataResponseBroker::MessageMeta::FlexibleVersionMin, TMetadataResponseData::TMetadataResponseBroker::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 9: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 11: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 13: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 10;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1676,10 +4628,10 @@ void TMetadataResponseData::TMetadataResponseBroker::Write(TKafkaWritable& _writ
         ythrow yexception() << "Can't write version " << _version << " of TMetadataResponseData::TMetadataResponseBroker";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<NodeIdMeta>(_collector, _writable, _version, nodeId);
-    NPrivate::Write<HostMeta>(_collector, _writable, _version, host);
-    NPrivate::Write<PortMeta>(_collector, _writable, _version, port);
-    NPrivate::Write<RackMeta>(_collector, _writable, _version, rack);
+    NPrivate::Write<NodeIdMeta>(_collector, _writable, _version, NodeId);
+    NPrivate::Write<HostMeta>(_collector, _writable, _version, Host);
+    NPrivate::Write<PortMeta>(_collector, _writable, _version, Port);
+    NPrivate::Write<RackMeta>(_collector, _writable, _version, Rack);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1689,16 +4641,19 @@ void TMetadataResponseData::TMetadataResponseBroker::Write(TKafkaWritable& _writ
 
 i32 TMetadataResponseData::TMetadataResponseBroker::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<NodeIdMeta>(_collector, _version, nodeId);
-    NPrivate::Size<HostMeta>(_collector, _version, host);
-    NPrivate::Size<PortMeta>(_collector, _version, port);
-    NPrivate::Size<RackMeta>(_collector, _version, rack);
+    NPrivate::Size<NodeIdMeta>(_collector, _version, NodeId);
+    NPrivate::Size<HostMeta>(_collector, _version, Host);
+    NPrivate::Size<PortMeta>(_collector, _version, Port);
+    NPrivate::Size<RackMeta>(_collector, _version, Rack);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TMetadataResponseData::TMetadataResponseBroker::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1711,34 +4666,182 @@ const TMetadataResponseData::TMetadataResponseTopic::IsInternalMeta::Type TMetad
 const TMetadataResponseData::TMetadataResponseTopic::TopicAuthorizedOperationsMeta::Type TMetadataResponseData::TMetadataResponseTopic::TopicAuthorizedOperationsMeta::Default = -2147483648;
 
 TMetadataResponseData::TMetadataResponseTopic::TMetadataResponseTopic() 
-        : errorCode(ErrorCodeMeta::Default)
-        , name(NameMeta::Default)
-        , topicId(TopicIdMeta::Default)
-        , isInternal(IsInternalMeta::Default)
-        , topicAuthorizedOperations(TopicAuthorizedOperationsMeta::Default)
+        : ErrorCode(ErrorCodeMeta::Default)
+        , Name(NameMeta::Default)
+        , TopicId(TopicIdMeta::Default)
+        , IsInternal(IsInternalMeta::Default)
+        , TopicAuthorizedOperations(TopicAuthorizedOperationsMeta::Default)
 {}
 
-void TMetadataResponseData::TMetadataResponseTopic::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TMetadataResponseData::TMetadataResponseTopic";
-    }
-    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
-    NPrivate::Read<NameMeta>(_readable, _version, name);
-    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
-    NPrivate::Read<IsInternalMeta>(_readable, _version, isInternal);
-    NPrivate::Read<PartitionsMeta>(_readable, _version, partitions);
-    NPrivate::Read<TopicAuthorizedOperationsMeta>(_readable, _version, topicAuthorizedOperations);
-    
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+
+class TMetadataResponseData::TMetadataResponseTopic::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TMetadataResponseData::TMetadataResponseTopic& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TMetadataResponseData::TMetadataResponseTopic& Value;
+    TKafkaVersion Version;
+    size_t Step;
+    
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ErrorCodeMeta> ErrorCode;
+    NPrivate::TReadStrategy<NameMeta> Name;
+    NPrivate::TReadStrategy<TopicIdMeta> TopicId;
+    NPrivate::TReadStrategy<IsInternalMeta> IsInternal;
+    NPrivate::TReadStrategy<PartitionsMeta> Partitions;
+    NPrivate::TReadStrategy<TopicAuthorizedOperationsMeta> TopicAuthorizedOperations;
+};
+
+TMetadataResponseData::TMetadataResponseTopic::TReadContext::TReadContext(TMetadataResponseData::TMetadataResponseTopic& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ErrorCode()
+    , Name()
+    , TopicId()
+    , IsInternal()
+    , Partitions()
+    , TopicAuthorizedOperations()
+{}
+
+
+TReadDemand TMetadataResponseData::TMetadataResponseTopic::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ErrorCode.Init<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+            }
+            case 1: {
+                auto demand = ErrorCode.Next<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                Name.Init<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+            }
+            case 3: {
+                auto demand = Name.Next<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                TopicId.Init<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+            }
+            case 5: {
+                auto demand = TopicId.Next<NPrivate::ReadFieldRule<TopicIdMeta>>(Value.TopicId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                IsInternal.Init<NPrivate::ReadFieldRule<IsInternalMeta>>(Value.IsInternal, Version);
+            }
+            case 7: {
+                auto demand = IsInternal.Next<NPrivate::ReadFieldRule<IsInternalMeta>>(Value.IsInternal, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                Partitions.Init<NPrivate::ReadFieldRule<PartitionsMeta>>(Value.Partitions, Version);
+            }
+            case 9: {
+                auto demand = Partitions.Next<NPrivate::ReadFieldRule<PartitionsMeta>>(Value.Partitions, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                TopicAuthorizedOperations.Init<NPrivate::ReadFieldRule<TopicAuthorizedOperationsMeta>>(Value.TopicAuthorizedOperations, Version);
+            }
+            case 11: {
+                auto demand = TopicAuthorizedOperations.Next<NPrivate::ReadFieldRule<TopicAuthorizedOperationsMeta>>(Value.TopicAuthorizedOperations, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                if (!NPrivate::VersionCheck<TMetadataResponseData::TMetadataResponseTopic::MessageMeta::FlexibleVersionMin, TMetadataResponseData::TMetadataResponseTopic::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 13: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 14: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 15: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 16: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 17: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 14;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1748,12 +4851,12 @@ void TMetadataResponseData::TMetadataResponseTopic::Write(TKafkaWritable& _writa
         ythrow yexception() << "Can't write version " << _version << " of TMetadataResponseData::TMetadataResponseTopic";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
-    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
-    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
-    NPrivate::Write<IsInternalMeta>(_collector, _writable, _version, isInternal);
-    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, partitions);
-    NPrivate::Write<TopicAuthorizedOperationsMeta>(_collector, _writable, _version, topicAuthorizedOperations);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, ErrorCode);
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, Name);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, TopicId);
+    NPrivate::Write<IsInternalMeta>(_collector, _writable, _version, IsInternal);
+    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, Partitions);
+    NPrivate::Write<TopicAuthorizedOperationsMeta>(_collector, _writable, _version, TopicAuthorizedOperations);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1763,18 +4866,21 @@ void TMetadataResponseData::TMetadataResponseTopic::Write(TKafkaWritable& _writa
 
 i32 TMetadataResponseData::TMetadataResponseTopic::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
-    NPrivate::Size<NameMeta>(_collector, _version, name);
-    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
-    NPrivate::Size<IsInternalMeta>(_collector, _version, isInternal);
-    NPrivate::Size<PartitionsMeta>(_collector, _version, partitions);
-    NPrivate::Size<TopicAuthorizedOperationsMeta>(_collector, _version, topicAuthorizedOperations);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, ErrorCode);
+    NPrivate::Size<NameMeta>(_collector, _version, Name);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, TopicId);
+    NPrivate::Size<IsInternalMeta>(_collector, _version, IsInternal);
+    NPrivate::Size<PartitionsMeta>(_collector, _version, Partitions);
+    NPrivate::Size<TopicAuthorizedOperationsMeta>(_collector, _version, TopicAuthorizedOperations);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TMetadataResponseData::TMetadataResponseTopic::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1786,34 +4892,195 @@ const TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition:
 const TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::LeaderEpochMeta::Type TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::LeaderEpochMeta::Default = -1;
 
 TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::TMetadataResponsePartition() 
-        : errorCode(ErrorCodeMeta::Default)
-        , partitionIndex(PartitionIndexMeta::Default)
-        , leaderId(LeaderIdMeta::Default)
-        , leaderEpoch(LeaderEpochMeta::Default)
+        : ErrorCode(ErrorCodeMeta::Default)
+        , PartitionIndex(PartitionIndexMeta::Default)
+        , LeaderId(LeaderIdMeta::Default)
+        , LeaderEpoch(LeaderEpochMeta::Default)
 {}
 
-void TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition";
-    }
-    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
-    NPrivate::Read<PartitionIndexMeta>(_readable, _version, partitionIndex);
-    NPrivate::Read<LeaderIdMeta>(_readable, _version, leaderId);
-    NPrivate::Read<LeaderEpochMeta>(_readable, _version, leaderEpoch);
-    NPrivate::Read<ReplicaNodesMeta>(_readable, _version, replicaNodes);
-    NPrivate::Read<IsrNodesMeta>(_readable, _version, isrNodes);
-    NPrivate::Read<OfflineReplicasMeta>(_readable, _version, offlineReplicas);
-    
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+
+class TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition& Value;
+    TKafkaVersion Version;
+    size_t Step;
+    
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ErrorCodeMeta> ErrorCode;
+    NPrivate::TReadStrategy<PartitionIndexMeta> PartitionIndex;
+    NPrivate::TReadStrategy<LeaderIdMeta> LeaderId;
+    NPrivate::TReadStrategy<LeaderEpochMeta> LeaderEpoch;
+    NPrivate::TReadStrategy<ReplicaNodesMeta> ReplicaNodes;
+    NPrivate::TReadStrategy<IsrNodesMeta> IsrNodes;
+    NPrivate::TReadStrategy<OfflineReplicasMeta> OfflineReplicas;
+};
+
+TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::TReadContext::TReadContext(TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ErrorCode()
+    , PartitionIndex()
+    , LeaderId()
+    , LeaderEpoch()
+    , ReplicaNodes()
+    , IsrNodes()
+    , OfflineReplicas()
+{}
+
+
+TReadDemand TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ErrorCode.Init<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+            }
+            case 1: {
+                auto demand = ErrorCode.Next<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                PartitionIndex.Init<NPrivate::ReadFieldRule<PartitionIndexMeta>>(Value.PartitionIndex, Version);
+            }
+            case 3: {
+                auto demand = PartitionIndex.Next<NPrivate::ReadFieldRule<PartitionIndexMeta>>(Value.PartitionIndex, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                LeaderId.Init<NPrivate::ReadFieldRule<LeaderIdMeta>>(Value.LeaderId, Version);
+            }
+            case 5: {
+                auto demand = LeaderId.Next<NPrivate::ReadFieldRule<LeaderIdMeta>>(Value.LeaderId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                LeaderEpoch.Init<NPrivate::ReadFieldRule<LeaderEpochMeta>>(Value.LeaderEpoch, Version);
+            }
+            case 7: {
+                auto demand = LeaderEpoch.Next<NPrivate::ReadFieldRule<LeaderEpochMeta>>(Value.LeaderEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                ReplicaNodes.Init<NPrivate::ReadFieldRule<ReplicaNodesMeta>>(Value.ReplicaNodes, Version);
+            }
+            case 9: {
+                auto demand = ReplicaNodes.Next<NPrivate::ReadFieldRule<ReplicaNodesMeta>>(Value.ReplicaNodes, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                IsrNodes.Init<NPrivate::ReadFieldRule<IsrNodesMeta>>(Value.IsrNodes, Version);
+            }
+            case 11: {
+                auto demand = IsrNodes.Next<NPrivate::ReadFieldRule<IsrNodesMeta>>(Value.IsrNodes, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                ++Step;
+                OfflineReplicas.Init<NPrivate::ReadFieldRule<OfflineReplicasMeta>>(Value.OfflineReplicas, Version);
+            }
+            case 13: {
+                auto demand = OfflineReplicas.Next<NPrivate::ReadFieldRule<OfflineReplicasMeta>>(Value.OfflineReplicas, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 14: {
+                if (!NPrivate::VersionCheck<TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::MessageMeta::FlexibleVersionMin, TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 15: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 16: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 17: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 18: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 19: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 16;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1823,13 +5090,13 @@ void TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::
         ythrow yexception() << "Can't write version " << _version << " of TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
-    NPrivate::Write<PartitionIndexMeta>(_collector, _writable, _version, partitionIndex);
-    NPrivate::Write<LeaderIdMeta>(_collector, _writable, _version, leaderId);
-    NPrivate::Write<LeaderEpochMeta>(_collector, _writable, _version, leaderEpoch);
-    NPrivate::Write<ReplicaNodesMeta>(_collector, _writable, _version, replicaNodes);
-    NPrivate::Write<IsrNodesMeta>(_collector, _writable, _version, isrNodes);
-    NPrivate::Write<OfflineReplicasMeta>(_collector, _writable, _version, offlineReplicas);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, ErrorCode);
+    NPrivate::Write<PartitionIndexMeta>(_collector, _writable, _version, PartitionIndex);
+    NPrivate::Write<LeaderIdMeta>(_collector, _writable, _version, LeaderId);
+    NPrivate::Write<LeaderEpochMeta>(_collector, _writable, _version, LeaderEpoch);
+    NPrivate::Write<ReplicaNodesMeta>(_collector, _writable, _version, ReplicaNodes);
+    NPrivate::Write<IsrNodesMeta>(_collector, _writable, _version, IsrNodes);
+    NPrivate::Write<OfflineReplicasMeta>(_collector, _writable, _version, OfflineReplicas);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1839,19 +5106,22 @@ void TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::
 
 i32 TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
-    NPrivate::Size<PartitionIndexMeta>(_collector, _version, partitionIndex);
-    NPrivate::Size<LeaderIdMeta>(_collector, _version, leaderId);
-    NPrivate::Size<LeaderEpochMeta>(_collector, _version, leaderEpoch);
-    NPrivate::Size<ReplicaNodesMeta>(_collector, _version, replicaNodes);
-    NPrivate::Size<IsrNodesMeta>(_collector, _version, isrNodes);
-    NPrivate::Size<OfflineReplicasMeta>(_collector, _version, offlineReplicas);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, ErrorCode);
+    NPrivate::Size<PartitionIndexMeta>(_collector, _version, PartitionIndex);
+    NPrivate::Size<LeaderIdMeta>(_collector, _version, LeaderId);
+    NPrivate::Size<LeaderEpochMeta>(_collector, _version, LeaderEpoch);
+    NPrivate::Size<ReplicaNodesMeta>(_collector, _version, ReplicaNodes);
+    NPrivate::Size<IsrNodesMeta>(_collector, _version, IsrNodes);
+    NPrivate::Size<OfflineReplicasMeta>(_collector, _version, OfflineReplicas);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1861,27 +5131,123 @@ const TApiVersionsRequestData::ClientSoftwareNameMeta::Type TApiVersionsRequestD
 const TApiVersionsRequestData::ClientSoftwareVersionMeta::Type TApiVersionsRequestData::ClientSoftwareVersionMeta::Default = {""};
 
 TApiVersionsRequestData::TApiVersionsRequestData() 
-        : clientSoftwareName(ClientSoftwareNameMeta::Default)
-        , clientSoftwareVersion(ClientSoftwareVersionMeta::Default)
+        : ClientSoftwareName(ClientSoftwareNameMeta::Default)
+        , ClientSoftwareVersion(ClientSoftwareVersionMeta::Default)
 {}
 
-void TApiVersionsRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsRequestData";
-    }
-    NPrivate::Read<ClientSoftwareNameMeta>(_readable, _version, clientSoftwareName);
-    NPrivate::Read<ClientSoftwareVersionMeta>(_readable, _version, clientSoftwareVersion);
+
+class TApiVersionsRequestData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TApiVersionsRequestData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TApiVersionsRequestData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ClientSoftwareNameMeta> ClientSoftwareName;
+    NPrivate::TReadStrategy<ClientSoftwareVersionMeta> ClientSoftwareVersion;
+};
+
+TApiVersionsRequestData::TReadContext::TReadContext(TApiVersionsRequestData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ClientSoftwareName()
+    , ClientSoftwareVersion()
+{}
+
+
+TReadDemand TApiVersionsRequestData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ClientSoftwareName.Init<NPrivate::ReadFieldRule<ClientSoftwareNameMeta>>(Value.ClientSoftwareName, Version);
+            }
+            case 1: {
+                auto demand = ClientSoftwareName.Next<NPrivate::ReadFieldRule<ClientSoftwareNameMeta>>(Value.ClientSoftwareName, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                ClientSoftwareVersion.Init<NPrivate::ReadFieldRule<ClientSoftwareVersionMeta>>(Value.ClientSoftwareVersion, Version);
+            }
+            case 3: {
+                auto demand = ClientSoftwareVersion.Next<NPrivate::ReadFieldRule<ClientSoftwareVersionMeta>>(Value.ClientSoftwareVersion, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                if (!NPrivate::VersionCheck<TApiVersionsRequestData::MessageMeta::FlexibleVersionMin, TApiVersionsRequestData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 5: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 7: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 9: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 6;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1891,8 +5257,8 @@ void TApiVersionsRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _ve
         ythrow yexception() << "Can't write version " << _version << " of TApiVersionsRequestData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ClientSoftwareNameMeta>(_collector, _writable, _version, clientSoftwareName);
-    NPrivate::Write<ClientSoftwareVersionMeta>(_collector, _writable, _version, clientSoftwareVersion);
+    NPrivate::Write<ClientSoftwareNameMeta>(_collector, _writable, _version, ClientSoftwareName);
+    NPrivate::Write<ClientSoftwareVersionMeta>(_collector, _writable, _version, ClientSoftwareVersion);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -1902,14 +5268,17 @@ void TApiVersionsRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _ve
 
 i32 TApiVersionsRequestData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ClientSoftwareNameMeta>(_collector, _version, clientSoftwareName);
-    NPrivate::Size<ClientSoftwareVersionMeta>(_collector, _version, clientSoftwareVersion);
+    NPrivate::Size<ClientSoftwareNameMeta>(_collector, _version, ClientSoftwareName);
+    NPrivate::Size<ClientSoftwareVersionMeta>(_collector, _version, ClientSoftwareVersion);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TApiVersionsRequestData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -1921,46 +5290,227 @@ const TApiVersionsResponseData::FinalizedFeaturesEpochMeta::Type TApiVersionsRes
 const TApiVersionsResponseData::ZkMigrationReadyMeta::Type TApiVersionsResponseData::ZkMigrationReadyMeta::Default = false;
 
 TApiVersionsResponseData::TApiVersionsResponseData() 
-        : errorCode(ErrorCodeMeta::Default)
-        , throttleTimeMs(ThrottleTimeMsMeta::Default)
-        , finalizedFeaturesEpoch(FinalizedFeaturesEpochMeta::Default)
-        , zkMigrationReady(ZkMigrationReadyMeta::Default)
+        : ErrorCode(ErrorCodeMeta::Default)
+        , ThrottleTimeMs(ThrottleTimeMsMeta::Default)
+        , FinalizedFeaturesEpoch(FinalizedFeaturesEpochMeta::Default)
+        , ZkMigrationReady(ZkMigrationReadyMeta::Default)
 {}
 
-void TApiVersionsResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsResponseData";
-    }
-    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
-    NPrivate::Read<ApiKeysMeta>(_readable, _version, apiKeys);
-    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
-    NPrivate::Read<SupportedFeaturesMeta>(_readable, _version, supportedFeatures);
-    NPrivate::Read<FinalizedFeaturesEpochMeta>(_readable, _version, finalizedFeaturesEpoch);
-    NPrivate::Read<FinalizedFeaturesMeta>(_readable, _version, finalizedFeatures);
-    NPrivate::Read<ZkMigrationReadyMeta>(_readable, _version, zkMigrationReady);
-    
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                case SupportedFeaturesMeta::Tag:
-                    NPrivate::ReadTag<SupportedFeaturesMeta>(_readable, _version, supportedFeatures);
-                    break;
-                case FinalizedFeaturesEpochMeta::Tag:
-                    NPrivate::ReadTag<FinalizedFeaturesEpochMeta>(_readable, _version, finalizedFeaturesEpoch);
-                    break;
-                case FinalizedFeaturesMeta::Tag:
-                    NPrivate::ReadTag<FinalizedFeaturesMeta>(_readable, _version, finalizedFeatures);
-                    break;
-                case ZkMigrationReadyMeta::Tag:
-                    NPrivate::ReadTag<ZkMigrationReadyMeta>(_readable, _version, zkMigrationReady);
-                    break;
-                default:
-                    _readable.skip(_size); // skip unknown tag
+
+class TApiVersionsResponseData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TApiVersionsResponseData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TApiVersionsResponseData& Value;
+    TKafkaVersion Version;
+    size_t Step;
+    
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ErrorCodeMeta> ErrorCode;
+    NPrivate::TReadStrategy<ApiKeysMeta> ApiKeys;
+    NPrivate::TReadStrategy<ThrottleTimeMsMeta> ThrottleTimeMs;
+    NPrivate::TReadStrategy<SupportedFeaturesMeta> SupportedFeatures;
+    NPrivate::TReadStrategy<FinalizedFeaturesEpochMeta> FinalizedFeaturesEpoch;
+    NPrivate::TReadStrategy<FinalizedFeaturesMeta> FinalizedFeatures;
+    NPrivate::TReadStrategy<ZkMigrationReadyMeta> ZkMigrationReady;
+};
+
+TApiVersionsResponseData::TReadContext::TReadContext(TApiVersionsResponseData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ErrorCode()
+    , ApiKeys()
+    , ThrottleTimeMs()
+    , SupportedFeatures()
+    , FinalizedFeaturesEpoch()
+    , FinalizedFeatures()
+    , ZkMigrationReady()
+{}
+
+
+TReadDemand TApiVersionsResponseData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ErrorCode.Init<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+            }
+            case 1: {
+                auto demand = ErrorCode.Next<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                ApiKeys.Init<NPrivate::ReadFieldRule<ApiKeysMeta>>(Value.ApiKeys, Version);
+            }
+            case 3: {
+                auto demand = ApiKeys.Next<NPrivate::ReadFieldRule<ApiKeysMeta>>(Value.ApiKeys, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                ThrottleTimeMs.Init<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+            }
+            case 5: {
+                auto demand = ThrottleTimeMs.Next<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                SupportedFeatures.Init<NPrivate::ReadFieldRule<SupportedFeaturesMeta>>(Value.SupportedFeatures, Version);
+            }
+            case 7: {
+                auto demand = SupportedFeatures.Next<NPrivate::ReadFieldRule<SupportedFeaturesMeta>>(Value.SupportedFeatures, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                FinalizedFeaturesEpoch.Init<NPrivate::ReadFieldRule<FinalizedFeaturesEpochMeta>>(Value.FinalizedFeaturesEpoch, Version);
+            }
+            case 9: {
+                auto demand = FinalizedFeaturesEpoch.Next<NPrivate::ReadFieldRule<FinalizedFeaturesEpochMeta>>(Value.FinalizedFeaturesEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                FinalizedFeatures.Init<NPrivate::ReadFieldRule<FinalizedFeaturesMeta>>(Value.FinalizedFeatures, Version);
+            }
+            case 11: {
+                auto demand = FinalizedFeatures.Next<NPrivate::ReadFieldRule<FinalizedFeaturesMeta>>(Value.FinalizedFeatures, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                ++Step;
+                ZkMigrationReady.Init<NPrivate::ReadFieldRule<ZkMigrationReadyMeta>>(Value.ZkMigrationReady, Version);
+            }
+            case 13: {
+                auto demand = ZkMigrationReady.Next<NPrivate::ReadFieldRule<ZkMigrationReadyMeta>>(Value.ZkMigrationReady, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 14: {
+                if (!NPrivate::VersionCheck<TApiVersionsResponseData::MessageMeta::FlexibleVersionMin, TApiVersionsResponseData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 15: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 16: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 17: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 18: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 19: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    case 0: {
+                        if (!TagInitialized_) {
+                            TagInitialized_=true;
+                            SupportedFeatures.Init<NPrivate::ReadTaggedFieldRule<SupportedFeaturesMeta>>(Value.SupportedFeatures, Version);
+                        }
+                        demand = SupportedFeatures.Next<NPrivate::ReadTaggedFieldRule<SupportedFeaturesMeta>>(Value.SupportedFeatures, Version);
+                        break;
+                    }
+                    case 1: {
+                        if (!TagInitialized_) {
+                            TagInitialized_=true;
+                            FinalizedFeaturesEpoch.Init<NPrivate::ReadTaggedFieldRule<FinalizedFeaturesEpochMeta>>(Value.FinalizedFeaturesEpoch, Version);
+                        }
+                        demand = FinalizedFeaturesEpoch.Next<NPrivate::ReadTaggedFieldRule<FinalizedFeaturesEpochMeta>>(Value.FinalizedFeaturesEpoch, Version);
+                        break;
+                    }
+                    case 2: {
+                        if (!TagInitialized_) {
+                            TagInitialized_=true;
+                            FinalizedFeatures.Init<NPrivate::ReadTaggedFieldRule<FinalizedFeaturesMeta>>(Value.FinalizedFeatures, Version);
+                        }
+                        demand = FinalizedFeatures.Next<NPrivate::ReadTaggedFieldRule<FinalizedFeaturesMeta>>(Value.FinalizedFeatures, Version);
+                        break;
+                    }
+                    case 3: {
+                        if (!TagInitialized_) {
+                            TagInitialized_=true;
+                            ZkMigrationReady.Init<NPrivate::ReadTaggedFieldRule<ZkMigrationReadyMeta>>(Value.ZkMigrationReady, Version);
+                        }
+                        demand = ZkMigrationReady.Next<NPrivate::ReadTaggedFieldRule<ZkMigrationReadyMeta>>(Value.ZkMigrationReady, Version);
+                        break;
+                    }
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 16;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -1970,39 +5520,42 @@ void TApiVersionsResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _v
         ythrow yexception() << "Can't write version " << _version << " of TApiVersionsResponseData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
-    NPrivate::Write<ApiKeysMeta>(_collector, _writable, _version, apiKeys);
-    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
-    NPrivate::Write<SupportedFeaturesMeta>(_collector, _writable, _version, supportedFeatures);
-    NPrivate::Write<FinalizedFeaturesEpochMeta>(_collector, _writable, _version, finalizedFeaturesEpoch);
-    NPrivate::Write<FinalizedFeaturesMeta>(_collector, _writable, _version, finalizedFeatures);
-    NPrivate::Write<ZkMigrationReadyMeta>(_collector, _writable, _version, zkMigrationReady);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, ErrorCode);
+    NPrivate::Write<ApiKeysMeta>(_collector, _writable, _version, ApiKeys);
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, ThrottleTimeMs);
+    NPrivate::Write<SupportedFeaturesMeta>(_collector, _writable, _version, SupportedFeatures);
+    NPrivate::Write<FinalizedFeaturesEpochMeta>(_collector, _writable, _version, FinalizedFeaturesEpoch);
+    NPrivate::Write<FinalizedFeaturesMeta>(_collector, _writable, _version, FinalizedFeatures);
+    NPrivate::Write<ZkMigrationReadyMeta>(_collector, _writable, _version, ZkMigrationReady);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
         
-        NPrivate::WriteTag<SupportedFeaturesMeta>(_writable, _version, supportedFeatures);
-        NPrivate::WriteTag<FinalizedFeaturesEpochMeta>(_writable, _version, finalizedFeaturesEpoch);
-        NPrivate::WriteTag<FinalizedFeaturesMeta>(_writable, _version, finalizedFeatures);
-        NPrivate::WriteTag<ZkMigrationReadyMeta>(_writable, _version, zkMigrationReady);
+        NPrivate::WriteTag<SupportedFeaturesMeta>(_writable, _version, SupportedFeatures);
+        NPrivate::WriteTag<FinalizedFeaturesEpochMeta>(_writable, _version, FinalizedFeaturesEpoch);
+        NPrivate::WriteTag<FinalizedFeaturesMeta>(_writable, _version, FinalizedFeatures);
+        NPrivate::WriteTag<ZkMigrationReadyMeta>(_writable, _version, ZkMigrationReady);
     }
 }
 
 i32 TApiVersionsResponseData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
-    NPrivate::Size<ApiKeysMeta>(_collector, _version, apiKeys);
-    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
-    NPrivate::Size<SupportedFeaturesMeta>(_collector, _version, supportedFeatures);
-    NPrivate::Size<FinalizedFeaturesEpochMeta>(_collector, _version, finalizedFeaturesEpoch);
-    NPrivate::Size<FinalizedFeaturesMeta>(_collector, _version, finalizedFeatures);
-    NPrivate::Size<ZkMigrationReadyMeta>(_collector, _version, zkMigrationReady);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, ErrorCode);
+    NPrivate::Size<ApiKeysMeta>(_collector, _version, ApiKeys);
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, ThrottleTimeMs);
+    NPrivate::Size<SupportedFeaturesMeta>(_collector, _version, SupportedFeatures);
+    NPrivate::Size<FinalizedFeaturesEpochMeta>(_collector, _version, FinalizedFeaturesEpoch);
+    NPrivate::Size<FinalizedFeaturesMeta>(_collector, _version, FinalizedFeatures);
+    NPrivate::Size<ZkMigrationReadyMeta>(_collector, _version, ZkMigrationReady);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TApiVersionsResponseData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -2013,29 +5566,138 @@ const TApiVersionsResponseData::TApiVersion::MinVersionMeta::Type TApiVersionsRe
 const TApiVersionsResponseData::TApiVersion::MaxVersionMeta::Type TApiVersionsResponseData::TApiVersion::MaxVersionMeta::Default = 0;
 
 TApiVersionsResponseData::TApiVersion::TApiVersion() 
-        : apiKey(ApiKeyMeta::Default)
-        , minVersion(MinVersionMeta::Default)
-        , maxVersion(MaxVersionMeta::Default)
+        : ApiKey(ApiKeyMeta::Default)
+        , MinVersion(MinVersionMeta::Default)
+        , MaxVersion(MaxVersionMeta::Default)
 {}
 
-void TApiVersionsResponseData::TApiVersion::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsResponseData::TApiVersion";
-    }
-    NPrivate::Read<ApiKeyMeta>(_readable, _version, apiKey);
-    NPrivate::Read<MinVersionMeta>(_readable, _version, minVersion);
-    NPrivate::Read<MaxVersionMeta>(_readable, _version, maxVersion);
+
+class TApiVersionsResponseData::TApiVersion::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TApiVersionsResponseData::TApiVersion& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TApiVersionsResponseData::TApiVersion& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ApiKeyMeta> ApiKey;
+    NPrivate::TReadStrategy<MinVersionMeta> MinVersion;
+    NPrivate::TReadStrategy<MaxVersionMeta> MaxVersion;
+};
+
+TApiVersionsResponseData::TApiVersion::TReadContext::TReadContext(TApiVersionsResponseData::TApiVersion& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ApiKey()
+    , MinVersion()
+    , MaxVersion()
+{}
+
+
+TReadDemand TApiVersionsResponseData::TApiVersion::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ApiKey.Init<NPrivate::ReadFieldRule<ApiKeyMeta>>(Value.ApiKey, Version);
+            }
+            case 1: {
+                auto demand = ApiKey.Next<NPrivate::ReadFieldRule<ApiKeyMeta>>(Value.ApiKey, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                MinVersion.Init<NPrivate::ReadFieldRule<MinVersionMeta>>(Value.MinVersion, Version);
+            }
+            case 3: {
+                auto demand = MinVersion.Next<NPrivate::ReadFieldRule<MinVersionMeta>>(Value.MinVersion, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                MaxVersion.Init<NPrivate::ReadFieldRule<MaxVersionMeta>>(Value.MaxVersion, Version);
+            }
+            case 5: {
+                auto demand = MaxVersion.Next<NPrivate::ReadFieldRule<MaxVersionMeta>>(Value.MaxVersion, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                if (!NPrivate::VersionCheck<TApiVersionsResponseData::TApiVersion::MessageMeta::FlexibleVersionMin, TApiVersionsResponseData::TApiVersion::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 7: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 9: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 11: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 8;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -2045,9 +5707,9 @@ void TApiVersionsResponseData::TApiVersion::Write(TKafkaWritable& _writable, TKa
         ythrow yexception() << "Can't write version " << _version << " of TApiVersionsResponseData::TApiVersion";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ApiKeyMeta>(_collector, _writable, _version, apiKey);
-    NPrivate::Write<MinVersionMeta>(_collector, _writable, _version, minVersion);
-    NPrivate::Write<MaxVersionMeta>(_collector, _writable, _version, maxVersion);
+    NPrivate::Write<ApiKeyMeta>(_collector, _writable, _version, ApiKey);
+    NPrivate::Write<MinVersionMeta>(_collector, _writable, _version, MinVersion);
+    NPrivate::Write<MaxVersionMeta>(_collector, _writable, _version, MaxVersion);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -2057,15 +5719,18 @@ void TApiVersionsResponseData::TApiVersion::Write(TKafkaWritable& _writable, TKa
 
 i32 TApiVersionsResponseData::TApiVersion::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ApiKeyMeta>(_collector, _version, apiKey);
-    NPrivate::Size<MinVersionMeta>(_collector, _version, minVersion);
-    NPrivate::Size<MaxVersionMeta>(_collector, _version, maxVersion);
+    NPrivate::Size<ApiKeyMeta>(_collector, _version, ApiKey);
+    NPrivate::Size<MinVersionMeta>(_collector, _version, MinVersion);
+    NPrivate::Size<MaxVersionMeta>(_collector, _version, MaxVersion);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TApiVersionsResponseData::TApiVersion::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -2076,29 +5741,138 @@ const TApiVersionsResponseData::TSupportedFeatureKey::MinVersionMeta::Type TApiV
 const TApiVersionsResponseData::TSupportedFeatureKey::MaxVersionMeta::Type TApiVersionsResponseData::TSupportedFeatureKey::MaxVersionMeta::Default = 0;
 
 TApiVersionsResponseData::TSupportedFeatureKey::TSupportedFeatureKey() 
-        : name(NameMeta::Default)
-        , minVersion(MinVersionMeta::Default)
-        , maxVersion(MaxVersionMeta::Default)
+        : Name(NameMeta::Default)
+        , MinVersion(MinVersionMeta::Default)
+        , MaxVersion(MaxVersionMeta::Default)
 {}
 
-void TApiVersionsResponseData::TSupportedFeatureKey::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsResponseData::TSupportedFeatureKey";
-    }
-    NPrivate::Read<NameMeta>(_readable, _version, name);
-    NPrivate::Read<MinVersionMeta>(_readable, _version, minVersion);
-    NPrivate::Read<MaxVersionMeta>(_readable, _version, maxVersion);
+
+class TApiVersionsResponseData::TSupportedFeatureKey::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TApiVersionsResponseData::TSupportedFeatureKey& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TApiVersionsResponseData::TSupportedFeatureKey& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<NameMeta> Name;
+    NPrivate::TReadStrategy<MinVersionMeta> MinVersion;
+    NPrivate::TReadStrategy<MaxVersionMeta> MaxVersion;
+};
+
+TApiVersionsResponseData::TSupportedFeatureKey::TReadContext::TReadContext(TApiVersionsResponseData::TSupportedFeatureKey& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Name()
+    , MinVersion()
+    , MaxVersion()
+{}
+
+
+TReadDemand TApiVersionsResponseData::TSupportedFeatureKey::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Name.Init<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+            }
+            case 1: {
+                auto demand = Name.Next<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                MinVersion.Init<NPrivate::ReadFieldRule<MinVersionMeta>>(Value.MinVersion, Version);
+            }
+            case 3: {
+                auto demand = MinVersion.Next<NPrivate::ReadFieldRule<MinVersionMeta>>(Value.MinVersion, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                MaxVersion.Init<NPrivate::ReadFieldRule<MaxVersionMeta>>(Value.MaxVersion, Version);
+            }
+            case 5: {
+                auto demand = MaxVersion.Next<NPrivate::ReadFieldRule<MaxVersionMeta>>(Value.MaxVersion, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                if (!NPrivate::VersionCheck<TApiVersionsResponseData::TSupportedFeatureKey::MessageMeta::FlexibleVersionMin, TApiVersionsResponseData::TSupportedFeatureKey::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 7: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 9: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 11: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 8;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -2108,9 +5882,9 @@ void TApiVersionsResponseData::TSupportedFeatureKey::Write(TKafkaWritable& _writ
         ythrow yexception() << "Can't write version " << _version << " of TApiVersionsResponseData::TSupportedFeatureKey";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
-    NPrivate::Write<MinVersionMeta>(_collector, _writable, _version, minVersion);
-    NPrivate::Write<MaxVersionMeta>(_collector, _writable, _version, maxVersion);
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, Name);
+    NPrivate::Write<MinVersionMeta>(_collector, _writable, _version, MinVersion);
+    NPrivate::Write<MaxVersionMeta>(_collector, _writable, _version, MaxVersion);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -2120,15 +5894,18 @@ void TApiVersionsResponseData::TSupportedFeatureKey::Write(TKafkaWritable& _writ
 
 i32 TApiVersionsResponseData::TSupportedFeatureKey::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<NameMeta>(_collector, _version, name);
-    NPrivate::Size<MinVersionMeta>(_collector, _version, minVersion);
-    NPrivate::Size<MaxVersionMeta>(_collector, _version, maxVersion);
+    NPrivate::Size<NameMeta>(_collector, _version, Name);
+    NPrivate::Size<MinVersionMeta>(_collector, _version, MinVersion);
+    NPrivate::Size<MaxVersionMeta>(_collector, _version, MaxVersion);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TApiVersionsResponseData::TSupportedFeatureKey::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -2139,29 +5916,138 @@ const TApiVersionsResponseData::TFinalizedFeatureKey::MaxVersionLevelMeta::Type
 const TApiVersionsResponseData::TFinalizedFeatureKey::MinVersionLevelMeta::Type TApiVersionsResponseData::TFinalizedFeatureKey::MinVersionLevelMeta::Default = 0;
 
 TApiVersionsResponseData::TFinalizedFeatureKey::TFinalizedFeatureKey() 
-        : name(NameMeta::Default)
-        , maxVersionLevel(MaxVersionLevelMeta::Default)
-        , minVersionLevel(MinVersionLevelMeta::Default)
+        : Name(NameMeta::Default)
+        , MaxVersionLevel(MaxVersionLevelMeta::Default)
+        , MinVersionLevel(MinVersionLevelMeta::Default)
 {}
 
-void TApiVersionsResponseData::TFinalizedFeatureKey::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsResponseData::TFinalizedFeatureKey";
-    }
-    NPrivate::Read<NameMeta>(_readable, _version, name);
-    NPrivate::Read<MaxVersionLevelMeta>(_readable, _version, maxVersionLevel);
-    NPrivate::Read<MinVersionLevelMeta>(_readable, _version, minVersionLevel);
+
+class TApiVersionsResponseData::TFinalizedFeatureKey::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TApiVersionsResponseData::TFinalizedFeatureKey& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TApiVersionsResponseData::TFinalizedFeatureKey& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<NameMeta> Name;
+    NPrivate::TReadStrategy<MaxVersionLevelMeta> MaxVersionLevel;
+    NPrivate::TReadStrategy<MinVersionLevelMeta> MinVersionLevel;
+};
+
+TApiVersionsResponseData::TFinalizedFeatureKey::TReadContext::TReadContext(TApiVersionsResponseData::TFinalizedFeatureKey& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , Name()
+    , MaxVersionLevel()
+    , MinVersionLevel()
+{}
+
+
+TReadDemand TApiVersionsResponseData::TFinalizedFeatureKey::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                Name.Init<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+            }
+            case 1: {
+                auto demand = Name.Next<NPrivate::ReadFieldRule<NameMeta>>(Value.Name, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                MaxVersionLevel.Init<NPrivate::ReadFieldRule<MaxVersionLevelMeta>>(Value.MaxVersionLevel, Version);
+            }
+            case 3: {
+                auto demand = MaxVersionLevel.Next<NPrivate::ReadFieldRule<MaxVersionLevelMeta>>(Value.MaxVersionLevel, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                MinVersionLevel.Init<NPrivate::ReadFieldRule<MinVersionLevelMeta>>(Value.MinVersionLevel, Version);
+            }
+            case 5: {
+                auto demand = MinVersionLevel.Next<NPrivate::ReadFieldRule<MinVersionLevelMeta>>(Value.MinVersionLevel, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                if (!NPrivate::VersionCheck<TApiVersionsResponseData::TFinalizedFeatureKey::MessageMeta::FlexibleVersionMin, TApiVersionsResponseData::TFinalizedFeatureKey::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 7: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 9: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 11: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 8;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -2171,9 +6057,9 @@ void TApiVersionsResponseData::TFinalizedFeatureKey::Write(TKafkaWritable& _writ
         ythrow yexception() << "Can't write version " << _version << " of TApiVersionsResponseData::TFinalizedFeatureKey";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
-    NPrivate::Write<MaxVersionLevelMeta>(_collector, _writable, _version, maxVersionLevel);
-    NPrivate::Write<MinVersionLevelMeta>(_collector, _writable, _version, minVersionLevel);
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, Name);
+    NPrivate::Write<MaxVersionLevelMeta>(_collector, _writable, _version, MaxVersionLevel);
+    NPrivate::Write<MinVersionLevelMeta>(_collector, _writable, _version, MinVersionLevel);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -2183,15 +6069,18 @@ void TApiVersionsResponseData::TFinalizedFeatureKey::Write(TKafkaWritable& _writ
 
 i32 TApiVersionsResponseData::TFinalizedFeatureKey::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<NameMeta>(_collector, _version, name);
-    NPrivate::Size<MaxVersionLevelMeta>(_collector, _version, maxVersionLevel);
-    NPrivate::Size<MinVersionLevelMeta>(_collector, _version, minVersionLevel);
+    NPrivate::Size<NameMeta>(_collector, _version, Name);
+    NPrivate::Size<MaxVersionLevelMeta>(_collector, _version, MaxVersionLevel);
+    NPrivate::Size<MinVersionLevelMeta>(_collector, _version, MinVersionLevel);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TApiVersionsResponseData::TFinalizedFeatureKey::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -2203,31 +6092,153 @@ const TInitProducerIdRequestData::ProducerIdMeta::Type TInitProducerIdRequestDat
 const TInitProducerIdRequestData::ProducerEpochMeta::Type TInitProducerIdRequestData::ProducerEpochMeta::Default = -1;
 
 TInitProducerIdRequestData::TInitProducerIdRequestData() 
-        : transactionalId(TransactionalIdMeta::Default)
-        , transactionTimeoutMs(TransactionTimeoutMsMeta::Default)
-        , producerId(ProducerIdMeta::Default)
-        , producerEpoch(ProducerEpochMeta::Default)
+        : TransactionalId(TransactionalIdMeta::Default)
+        , TransactionTimeoutMs(TransactionTimeoutMsMeta::Default)
+        , ProducerId(ProducerIdMeta::Default)
+        , ProducerEpoch(ProducerEpochMeta::Default)
 {}
 
-void TInitProducerIdRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TInitProducerIdRequestData";
-    }
-    NPrivate::Read<TransactionalIdMeta>(_readable, _version, transactionalId);
-    NPrivate::Read<TransactionTimeoutMsMeta>(_readable, _version, transactionTimeoutMs);
-    NPrivate::Read<ProducerIdMeta>(_readable, _version, producerId);
-    NPrivate::Read<ProducerEpochMeta>(_readable, _version, producerEpoch);
+
+class TInitProducerIdRequestData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TInitProducerIdRequestData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TInitProducerIdRequestData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<TransactionalIdMeta> TransactionalId;
+    NPrivate::TReadStrategy<TransactionTimeoutMsMeta> TransactionTimeoutMs;
+    NPrivate::TReadStrategy<ProducerIdMeta> ProducerId;
+    NPrivate::TReadStrategy<ProducerEpochMeta> ProducerEpoch;
+};
+
+TInitProducerIdRequestData::TReadContext::TReadContext(TInitProducerIdRequestData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , TransactionalId()
+    , TransactionTimeoutMs()
+    , ProducerId()
+    , ProducerEpoch()
+{}
+
+
+TReadDemand TInitProducerIdRequestData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                TransactionalId.Init<NPrivate::ReadFieldRule<TransactionalIdMeta>>(Value.TransactionalId, Version);
+            }
+            case 1: {
+                auto demand = TransactionalId.Next<NPrivate::ReadFieldRule<TransactionalIdMeta>>(Value.TransactionalId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                TransactionTimeoutMs.Init<NPrivate::ReadFieldRule<TransactionTimeoutMsMeta>>(Value.TransactionTimeoutMs, Version);
+            }
+            case 3: {
+                auto demand = TransactionTimeoutMs.Next<NPrivate::ReadFieldRule<TransactionTimeoutMsMeta>>(Value.TransactionTimeoutMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                ProducerId.Init<NPrivate::ReadFieldRule<ProducerIdMeta>>(Value.ProducerId, Version);
+            }
+            case 5: {
+                auto demand = ProducerId.Next<NPrivate::ReadFieldRule<ProducerIdMeta>>(Value.ProducerId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                ProducerEpoch.Init<NPrivate::ReadFieldRule<ProducerEpochMeta>>(Value.ProducerEpoch, Version);
+            }
+            case 7: {
+                auto demand = ProducerEpoch.Next<NPrivate::ReadFieldRule<ProducerEpochMeta>>(Value.ProducerEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                if (!NPrivate::VersionCheck<TInitProducerIdRequestData::MessageMeta::FlexibleVersionMin, TInitProducerIdRequestData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 9: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 11: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 13: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 10;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -2237,10 +6248,10 @@ void TInitProducerIdRequestData::Write(TKafkaWritable& _writable, TKafkaVersion
         ythrow yexception() << "Can't write version " << _version << " of TInitProducerIdRequestData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<TransactionalIdMeta>(_collector, _writable, _version, transactionalId);
-    NPrivate::Write<TransactionTimeoutMsMeta>(_collector, _writable, _version, transactionTimeoutMs);
-    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, producerId);
-    NPrivate::Write<ProducerEpochMeta>(_collector, _writable, _version, producerEpoch);
+    NPrivate::Write<TransactionalIdMeta>(_collector, _writable, _version, TransactionalId);
+    NPrivate::Write<TransactionTimeoutMsMeta>(_collector, _writable, _version, TransactionTimeoutMs);
+    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, ProducerId);
+    NPrivate::Write<ProducerEpochMeta>(_collector, _writable, _version, ProducerEpoch);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -2250,16 +6261,19 @@ void TInitProducerIdRequestData::Write(TKafkaWritable& _writable, TKafkaVersion
 
 i32 TInitProducerIdRequestData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<TransactionalIdMeta>(_collector, _version, transactionalId);
-    NPrivate::Size<TransactionTimeoutMsMeta>(_collector, _version, transactionTimeoutMs);
-    NPrivate::Size<ProducerIdMeta>(_collector, _version, producerId);
-    NPrivate::Size<ProducerEpochMeta>(_collector, _version, producerEpoch);
+    NPrivate::Size<TransactionalIdMeta>(_collector, _version, TransactionalId);
+    NPrivate::Size<TransactionTimeoutMsMeta>(_collector, _version, TransactionTimeoutMs);
+    NPrivate::Size<ProducerIdMeta>(_collector, _version, ProducerId);
+    NPrivate::Size<ProducerEpochMeta>(_collector, _version, ProducerEpoch);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TInitProducerIdRequestData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 
 
 //
@@ -2271,31 +6285,153 @@ const TInitProducerIdResponseData::ProducerIdMeta::Type TInitProducerIdResponseD
 const TInitProducerIdResponseData::ProducerEpochMeta::Type TInitProducerIdResponseData::ProducerEpochMeta::Default = 0;
 
 TInitProducerIdResponseData::TInitProducerIdResponseData() 
-        : throttleTimeMs(ThrottleTimeMsMeta::Default)
-        , errorCode(ErrorCodeMeta::Default)
-        , producerId(ProducerIdMeta::Default)
-        , producerEpoch(ProducerEpochMeta::Default)
+        : ThrottleTimeMs(ThrottleTimeMsMeta::Default)
+        , ErrorCode(ErrorCodeMeta::Default)
+        , ProducerId(ProducerIdMeta::Default)
+        , ProducerEpoch(ProducerEpochMeta::Default)
 {}
 
-void TInitProducerIdResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
-    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
-        ythrow yexception() << "Can't read version " << _version << " of TInitProducerIdResponseData";
-    }
-    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
-    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
-    NPrivate::Read<ProducerIdMeta>(_readable, _version, producerId);
-    NPrivate::Read<ProducerEpochMeta>(_readable, _version, producerEpoch);
+
+class TInitProducerIdResponseData::TReadContext : public NKafka::TReadContext {
+public:
+    TReadContext(TInitProducerIdResponseData& value, TKafkaVersion version);
+    TReadDemand Next() override;
+private:
+    TInitProducerIdResponseData& Value;
+    TKafkaVersion Version;
+    size_t Step;
     
-    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
-        int _numTaggedFields = _readable.readUnsignedVarint();
-        for (int _i = 0; _i < _numTaggedFields; ++_i) {
-            int _tag = _readable.readUnsignedVarint();
-            int _size = _readable.readUnsignedVarint();
-            switch (_tag) {
-                default:
-                    _readable.skip(_size); // skip unknown tag
+    NPrivate::ReadUnsignedVarintStrategy NumTaggedFields_;
+    NPrivate::ReadUnsignedVarintStrategy Tag_;
+    NPrivate::ReadUnsignedVarintStrategy TagSize_;
+    bool TagInitialized_;
+    
+    NPrivate::TReadStrategy<ThrottleTimeMsMeta> ThrottleTimeMs;
+    NPrivate::TReadStrategy<ErrorCodeMeta> ErrorCode;
+    NPrivate::TReadStrategy<ProducerIdMeta> ProducerId;
+    NPrivate::TReadStrategy<ProducerEpochMeta> ProducerEpoch;
+};
+
+TInitProducerIdResponseData::TReadContext::TReadContext(TInitProducerIdResponseData& value, TKafkaVersion version)
+    : Value(value)
+    , Version(version)
+    , Step(0)
+    , ThrottleTimeMs()
+    , ErrorCode()
+    , ProducerId()
+    , ProducerEpoch()
+{}
+
+
+TReadDemand TInitProducerIdResponseData::TReadContext::Next() {
+    while(true) {
+        switch(Step) {
+            case 0: {
+                ++Step;
+                ThrottleTimeMs.Init<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+            }
+            case 1: {
+                auto demand = ThrottleTimeMs.Next<NPrivate::ReadFieldRule<ThrottleTimeMsMeta>>(Value.ThrottleTimeMs, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 2: {
+                ++Step;
+                ErrorCode.Init<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+            }
+            case 3: {
+                auto demand = ErrorCode.Next<NPrivate::ReadFieldRule<ErrorCodeMeta>>(Value.ErrorCode, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 4: {
+                ++Step;
+                ProducerId.Init<NPrivate::ReadFieldRule<ProducerIdMeta>>(Value.ProducerId, Version);
+            }
+            case 5: {
+                auto demand = ProducerId.Next<NPrivate::ReadFieldRule<ProducerIdMeta>>(Value.ProducerId, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 6: {
+                ++Step;
+                ProducerEpoch.Init<NPrivate::ReadFieldRule<ProducerEpochMeta>>(Value.ProducerEpoch, Version);
+            }
+            case 7: {
+                auto demand = ProducerEpoch.Next<NPrivate::ReadFieldRule<ProducerEpochMeta>>(Value.ProducerEpoch, Version);
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 8: {
+                if (!NPrivate::VersionCheck<TInitProducerIdResponseData::MessageMeta::FlexibleVersionMin, TInitProducerIdResponseData::MessageMeta::FlexibleVersionMax>(Version)) return NoDemand;
+                ++Step;
+                NumTaggedFields_.Init();
+            }
+            case 9: {
+                auto demand = NumTaggedFields_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 10: {
+                ++Step;
+                if (NumTaggedFields_.Value <= 0) return NoDemand;
+                --NumTaggedFields_.Value;
+                Tag_.Init();
+                TagSize_.Init();
+                TagInitialized_=false;
+            }
+            case 11: {
+                auto demand = Tag_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 12: {
+                auto demand = TagSize_.Next();
+                if (demand) {
+                    return demand;
+                } else {
+                    ++Step;
+                }
+            }
+            case 13: {
+                TReadDemand demand;
+                switch(Tag_.Value) {
+                    default: {
+                        if (!TagInitialized_) {
+                            TagInitialized_ = true;
+                            demand = TReadDemand(TagSize_.Value);
+                        } else {
+                            demand = NoDemand;
+                        }
+                    }
+                }
+                if (demand) {
+                    return demand;
+                } else {
+                    Step = 10;
                     break;
+                }
             }
+            default:
+                return NoDemand;
         }
     }
 }
@@ -2305,10 +6441,10 @@ void TInitProducerIdResponseData::Write(TKafkaWritable& _writable, TKafkaVersion
         ythrow yexception() << "Can't write version " << _version << " of TInitProducerIdResponseData";
     }
     NPrivate::TWriteCollector _collector;
-    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
-    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
-    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, producerId);
-    NPrivate::Write<ProducerEpochMeta>(_collector, _writable, _version, producerEpoch);
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, ThrottleTimeMs);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, ErrorCode);
+    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, ProducerId);
+    NPrivate::Write<ProducerEpochMeta>(_collector, _writable, _version, ProducerEpoch);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _writable.writeUnsignedVarint(_collector.NumTaggedFields);
@@ -2318,14 +6454,17 @@ void TInitProducerIdResponseData::Write(TKafkaWritable& _writable, TKafkaVersion
 
 i32 TInitProducerIdResponseData::Size(TKafkaVersion _version) const {
     NPrivate::TSizeCollector _collector;
-    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
-    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
-    NPrivate::Size<ProducerIdMeta>(_collector, _version, producerId);
-    NPrivate::Size<ProducerEpochMeta>(_collector, _version, producerEpoch);
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, ThrottleTimeMs);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, ErrorCode);
+    NPrivate::Size<ProducerIdMeta>(_collector, _version, ProducerId);
+    NPrivate::Size<ProducerEpochMeta>(_collector, _version, ProducerEpoch);
     
     if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
         _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
     }
     return _collector.Size;
 }
+std::unique_ptr<NKafka::TReadContext> TInitProducerIdResponseData::CreateReadContext(TKafkaVersion _version) {
+    return std::unique_ptr<NKafka::TReadContext>(new TReadContext(*this, _version));
+}
 } //namespace NKafka
diff --git a/ydb/core/kafkaproxy/kafka_messages.h b/ydb/core/kafkaproxy/kafka_messages.h
index ffa7052b361..c070177e7ff 100644
--- a/ydb/core/kafkaproxy/kafka_messages.h
+++ b/ydb/core/kafkaproxy/kafka_messages.h
@@ -57,7 +57,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    RequestApiKeyMeta::Type requestApiKey;
+    RequestApiKeyMeta::Type RequestApiKey;
     
     struct RequestApiVersionMeta {
         using Type = TKafkaInt16;
@@ -76,7 +76,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    RequestApiVersionMeta::Type requestApiVersion;
+    RequestApiVersionMeta::Type RequestApiVersion;
     
     struct CorrelationIdMeta {
         using Type = TKafkaInt32;
@@ -95,7 +95,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    CorrelationIdMeta::Type correlationId;
+    CorrelationIdMeta::Type CorrelationId;
     
     struct ClientIdMeta {
         using Type = TKafkaString;
@@ -109,19 +109,18 @@ public:
         static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion TaggedVersionMin = 0;
         static constexpr TKafkaVersion TaggedVersionMax = -1;
-        static constexpr TKafkaVersion NullableVersionMin = 1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = -1;
     };
-    ClientIdMeta::Type clientId;
+    ClientIdMeta::Type ClientId;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return HEADER; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TRequestHeaderData& other) const = default;
@@ -157,14 +156,13 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 1;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    CorrelationIdMeta::Type correlationId;
+    CorrelationIdMeta::Type CorrelationId;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return HEADER; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TResponseHeaderData& other) const = default;
@@ -224,7 +222,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            IndexMeta::Type index;
+            IndexMeta::Type Index;
             
             struct RecordsMeta {
                 using Type = TKafkaRecords;
@@ -242,13 +240,12 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            RecordsMeta::Type records;
+            RecordsMeta::Type Records;
             
+            class TReadContext;
             
-            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
             i32 Size(TKafkaVersion version) const override;
-            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
             void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
             
             bool operator==(const TPartitionProduceData& other) const = default;
@@ -271,9 +268,11 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        NameMeta::Type name;
+        NameMeta::Type Name;
         
         struct PartitionDataMeta {
+            using ItemType = TPartitionProduceData;
+            using ItemTypeDesc = NPrivate::TKafkaStructDesc;
             using Type = std::vector<TPartitionProduceData>;
             using TypeDesc = NPrivate::TKafkaArrayDesc;
             
@@ -289,15 +288,12 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        PartitionDataMeta::Type partitionData;
+        PartitionDataMeta::Type PartitionData;
         
-        i32 next;
-        i32 prev;
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TTopicProduceData& other) const = default;
@@ -315,12 +311,12 @@ public:
         static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion TaggedVersionMin = 0;
         static constexpr TKafkaVersion TaggedVersionMax = -1;
-        static constexpr TKafkaVersion NullableVersionMin = 3;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    TransactionalIdMeta::Type transactionalId;
+    TransactionalIdMeta::Type TransactionalId;
     
     struct AcksMeta {
         using Type = TKafkaInt16;
@@ -339,7 +335,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    AcksMeta::Type acks;
+    AcksMeta::Type Acks;
     
     struct TimeoutMsMeta {
         using Type = TKafkaInt32;
@@ -358,9 +354,11 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    TimeoutMsMeta::Type timeoutMs;
+    TimeoutMsMeta::Type TimeoutMs;
     
     struct TopicDataMeta {
+        using ItemType = TTopicProduceData;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TTopicProduceData>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -376,14 +374,13 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    TopicDataMeta::Type topicData;
+    TopicDataMeta::Type TopicData;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return PRODUCE; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TProduceRequestData& other) const = default;
@@ -446,7 +443,7 @@ public:
                     static constexpr const char* About = "The batch index of the record that cause the batch to be dropped";
                     static const Type Default; // = 0;
                     
-                    static constexpr TKafkaVersion PresentVersionMin = 8;
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
                     static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion TaggedVersionMin = 0;
                     static constexpr TKafkaVersion TaggedVersionMax = -1;
@@ -455,7 +452,7 @@ public:
                     static constexpr TKafkaVersion FlexibleVersionMin = 9;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                BatchIndexMeta::Type batchIndex;
+                BatchIndexMeta::Type BatchIndex;
                 
                 struct BatchIndexErrorMessageMeta {
                     using Type = TKafkaString;
@@ -465,22 +462,21 @@ public:
                     static constexpr const char* About = "The error message of the record that caused the batch to be dropped";
                     static const Type Default; // = std::nullopt;
                     
-                    static constexpr TKafkaVersion PresentVersionMin = 8;
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
                     static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion TaggedVersionMin = 0;
                     static constexpr TKafkaVersion TaggedVersionMax = -1;
-                    static constexpr TKafkaVersion NullableVersionMin = 8;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
                     static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion FlexibleVersionMin = 9;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                BatchIndexErrorMessageMeta::Type batchIndexErrorMessage;
+                BatchIndexErrorMessageMeta::Type BatchIndexErrorMessage;
                 
+                class TReadContext;
                 
-                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
                 i32 Size(TKafkaVersion version) const override;
-                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
                 void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
                 
                 bool operator==(const TBatchIndexAndErrorMessage& other) const = default;
@@ -503,7 +499,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            IndexMeta::Type index;
+            IndexMeta::Type Index;
             
             struct ErrorCodeMeta {
                 using Type = TKafkaInt16;
@@ -522,7 +518,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            ErrorCodeMeta::Type errorCode;
+            ErrorCodeMeta::Type ErrorCode;
             
             struct BaseOffsetMeta {
                 using Type = TKafkaInt64;
@@ -541,7 +537,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            BaseOffsetMeta::Type baseOffset;
+            BaseOffsetMeta::Type BaseOffset;
             
             struct LogAppendTimeMsMeta {
                 using Type = TKafkaInt64;
@@ -560,7 +556,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            LogAppendTimeMsMeta::Type logAppendTimeMs;
+            LogAppendTimeMsMeta::Type LogAppendTimeMs;
             
             struct LogStartOffsetMeta {
                 using Type = TKafkaInt64;
@@ -579,9 +575,11 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            LogStartOffsetMeta::Type logStartOffset;
+            LogStartOffsetMeta::Type LogStartOffset;
             
             struct RecordErrorsMeta {
+                using ItemType = TBatchIndexAndErrorMessage;
+                using ItemTypeDesc = NPrivate::TKafkaStructDesc;
                 using Type = std::vector<TBatchIndexAndErrorMessage>;
                 using TypeDesc = NPrivate::TKafkaArrayDesc;
                 
@@ -597,7 +595,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            RecordErrorsMeta::Type recordErrors;
+            RecordErrorsMeta::Type RecordErrors;
             
             struct ErrorMessageMeta {
                 using Type = TKafkaString;
@@ -611,18 +609,17 @@ public:
                 static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                 static constexpr TKafkaVersion TaggedVersionMin = 0;
                 static constexpr TKafkaVersion TaggedVersionMax = -1;
-                static constexpr TKafkaVersion NullableVersionMin = 8;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
                 static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            ErrorMessageMeta::Type errorMessage;
+            ErrorMessageMeta::Type ErrorMessage;
             
+            class TReadContext;
             
-            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
             i32 Size(TKafkaVersion version) const override;
-            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
             void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
             
             bool operator==(const TPartitionProduceResponse& other) const = default;
@@ -645,9 +642,11 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        NameMeta::Type name;
+        NameMeta::Type Name;
         
         struct PartitionResponsesMeta {
+            using ItemType = TPartitionProduceResponse;
+            using ItemTypeDesc = NPrivate::TKafkaStructDesc;
             using Type = std::vector<TPartitionProduceResponse>;
             using TypeDesc = NPrivate::TKafkaArrayDesc;
             
@@ -663,21 +662,20 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        PartitionResponsesMeta::Type partitionResponses;
+        PartitionResponsesMeta::Type PartitionResponses;
         
-        i32 next;
-        i32 prev;
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TTopicProduceResponse& other) const = default;
     };
     
     struct ResponsesMeta {
+        using ItemType = TTopicProduceResponse;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TTopicProduceResponse>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -693,7 +691,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ResponsesMeta::Type responses;
+    ResponsesMeta::Type Responses;
     
     struct ThrottleTimeMsMeta {
         using Type = TKafkaInt32;
@@ -712,14 +710,13 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ThrottleTimeMsMeta::Type throttleTimeMs;
+    ThrottleTimeMsMeta::Type ThrottleTimeMs;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return PRODUCE; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TProduceResponseData& other) const = default;
@@ -779,7 +776,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            PartitionMeta::Type partition;
+            PartitionMeta::Type Partition;
             
             struct CurrentLeaderEpochMeta {
                 using Type = TKafkaInt32;
@@ -798,7 +795,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            CurrentLeaderEpochMeta::Type currentLeaderEpoch;
+            CurrentLeaderEpochMeta::Type CurrentLeaderEpoch;
             
             struct FetchOffsetMeta {
                 using Type = TKafkaInt64;
@@ -817,7 +814,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            FetchOffsetMeta::Type fetchOffset;
+            FetchOffsetMeta::Type FetchOffset;
             
             struct LastFetchedEpochMeta {
                 using Type = TKafkaInt32;
@@ -833,10 +830,10 @@ public:
                 static constexpr TKafkaVersion TaggedVersionMax = -1;
                 static constexpr TKafkaVersion NullableVersionMin = 0;
                 static constexpr TKafkaVersion NullableVersionMax = -1;
-                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMin = 0;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            LastFetchedEpochMeta::Type lastFetchedEpoch;
+            LastFetchedEpochMeta::Type LastFetchedEpoch;
             
             struct LogStartOffsetMeta {
                 using Type = TKafkaInt64;
@@ -855,7 +852,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            LogStartOffsetMeta::Type logStartOffset;
+            LogStartOffsetMeta::Type LogStartOffset;
             
             struct PartitionMaxBytesMeta {
                 using Type = TKafkaInt32;
@@ -874,13 +871,12 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            PartitionMaxBytesMeta::Type partitionMaxBytes;
+            PartitionMaxBytesMeta::Type PartitionMaxBytes;
             
+            class TReadContext;
             
-            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
             i32 Size(TKafkaVersion version) const override;
-            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
             void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
             
             bool operator==(const TFetchPartition& other) const = default;
@@ -903,7 +899,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 12;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicMeta::Type topic;
+        TopicMeta::Type Topic;
         
         struct TopicIdMeta {
             using Type = TKafkaUuid;
@@ -919,12 +915,14 @@ public:
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicIdMeta::Type topicId;
+        TopicIdMeta::Type TopicId;
         
         struct PartitionsMeta {
+            using ItemType = TFetchPartition;
+            using ItemTypeDesc = NPrivate::TKafkaStructDesc;
             using Type = std::vector<TFetchPartition>;
             using TypeDesc = NPrivate::TKafkaArrayDesc;
             
@@ -940,13 +938,12 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 12;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        PartitionsMeta::Type partitions;
+        PartitionsMeta::Type Partitions;
         
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TFetchTopic& other) const = default;
@@ -972,7 +969,7 @@ public:
             static constexpr const char* About = "The topic name.";
             static const Type Default; // = {""};
             
-            static constexpr TKafkaVersion PresentVersionMin = 7;
+            static constexpr TKafkaVersion PresentVersionMin = 0;
             static constexpr TKafkaVersion PresentVersionMax = 12;
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
@@ -981,7 +978,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 12;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicMeta::Type topic;
+        TopicMeta::Type Topic;
         
         struct TopicIdMeta {
             using Type = TKafkaUuid;
@@ -997,19 +994,21 @@ public:
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicIdMeta::Type topicId;
+        TopicIdMeta::Type TopicId;
         
         struct PartitionsMeta {
+            using ItemType = TKafkaInt32;
+            using ItemTypeDesc = NPrivate::TKafkaInt32Desc;
             using Type = std::vector<TKafkaInt32>;
             using TypeDesc = NPrivate::TKafkaArrayDesc;
             
             static constexpr const char* Name = "partitions";
             static constexpr const char* About = "The partitions indexes to forget.";
             
-            static constexpr TKafkaVersion PresentVersionMin = 7;
+            static constexpr TKafkaVersion PresentVersionMin = 0;
             static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
@@ -1018,13 +1017,12 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 12;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        PartitionsMeta::Type partitions;
+        PartitionsMeta::Type Partitions;
         
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TForgottenTopic& other) const = default;
@@ -1041,14 +1039,14 @@ public:
         
         static constexpr TKafkaVersion PresentVersionMin = 12;
         static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
-        static constexpr TKafkaVersion TaggedVersionMin = 12;
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
         static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
-        static constexpr TKafkaVersion NullableVersionMin = 12;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
-        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ClusterIdMeta::Type clusterId;
+    ClusterIdMeta::Type ClusterId;
     
     struct ReplicaIdMeta {
         using Type = TKafkaInt32;
@@ -1067,7 +1065,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ReplicaIdMeta::Type replicaId;
+    ReplicaIdMeta::Type ReplicaId;
     
     struct MaxWaitMsMeta {
         using Type = TKafkaInt32;
@@ -1086,7 +1084,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    MaxWaitMsMeta::Type maxWaitMs;
+    MaxWaitMsMeta::Type MaxWaitMs;
     
     struct MinBytesMeta {
         using Type = TKafkaInt32;
@@ -1105,7 +1103,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    MinBytesMeta::Type minBytes;
+    MinBytesMeta::Type MinBytes;
     
     struct MaxBytesMeta {
         using Type = TKafkaInt32;
@@ -1124,7 +1122,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    MaxBytesMeta::Type maxBytes;
+    MaxBytesMeta::Type MaxBytes;
     
     struct IsolationLevelMeta {
         using Type = TKafkaInt8;
@@ -1143,7 +1141,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    IsolationLevelMeta::Type isolationLevel;
+    IsolationLevelMeta::Type IsolationLevel;
     
     struct SessionIdMeta {
         using Type = TKafkaInt32;
@@ -1162,7 +1160,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    SessionIdMeta::Type sessionId;
+    SessionIdMeta::Type SessionId;
     
     struct SessionEpochMeta {
         using Type = TKafkaInt32;
@@ -1181,9 +1179,11 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    SessionEpochMeta::Type sessionEpoch;
+    SessionEpochMeta::Type SessionEpoch;
     
     struct TopicsMeta {
+        using ItemType = TFetchTopic;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TFetchTopic>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -1199,9 +1199,11 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    TopicsMeta::Type topics;
+    TopicsMeta::Type Topics;
     
     struct ForgottenTopicsDataMeta {
+        using ItemType = TForgottenTopic;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TForgottenTopic>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -1217,7 +1219,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ForgottenTopicsDataMeta::Type forgottenTopicsData;
+    ForgottenTopicsDataMeta::Type ForgottenTopicsData;
     
     struct RackIdMeta {
         using Type = TKafkaString;
@@ -1236,14 +1238,13 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    RackIdMeta::Type rackId;
+    RackIdMeta::Type RackId;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return FETCH; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TFetchRequestData& other) const = default;
@@ -1291,7 +1292,7 @@ public:
                 struct MessageMeta {
                     static constexpr TKafkaVersion PresentVersionMin = 12;
                     static constexpr TKafkaVersion PresentVersionMax = 13;
-                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 0;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
                 
@@ -1306,16 +1307,16 @@ public:
                     static constexpr const char* About = "";
                     static const Type Default; // = -1;
                     
-                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
                     static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion TaggedVersionMin = 0;
                     static constexpr TKafkaVersion TaggedVersionMax = -1;
                     static constexpr TKafkaVersion NullableVersionMin = 0;
                     static constexpr TKafkaVersion NullableVersionMax = -1;
-                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 0;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                EpochMeta::Type epoch;
+                EpochMeta::Type Epoch;
                 
                 struct EndOffsetMeta {
                     using Type = TKafkaInt64;
@@ -1325,22 +1326,21 @@ public:
                     static constexpr const char* About = "";
                     static const Type Default; // = -1;
                     
-                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
                     static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion TaggedVersionMin = 0;
                     static constexpr TKafkaVersion TaggedVersionMax = -1;
                     static constexpr TKafkaVersion NullableVersionMin = 0;
                     static constexpr TKafkaVersion NullableVersionMax = -1;
-                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 0;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                EndOffsetMeta::Type endOffset;
+                EndOffsetMeta::Type EndOffset;
                 
+                class TReadContext;
                 
-                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
                 i32 Size(TKafkaVersion version) const override;
-                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
                 void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
                 
                 bool operator==(const TEpochEndOffset& other) const = default;
@@ -1351,7 +1351,7 @@ public:
                 struct MessageMeta {
                     static constexpr TKafkaVersion PresentVersionMin = 12;
                     static constexpr TKafkaVersion PresentVersionMax = 13;
-                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 0;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
                 
@@ -1366,16 +1366,16 @@ public:
                     static constexpr const char* About = "The ID of the current leader or -1 if the leader is unknown.";
                     static const Type Default; // = -1;
                     
-                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
                     static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion TaggedVersionMin = 0;
                     static constexpr TKafkaVersion TaggedVersionMax = -1;
                     static constexpr TKafkaVersion NullableVersionMin = 0;
                     static constexpr TKafkaVersion NullableVersionMax = -1;
-                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 0;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                LeaderIdMeta::Type leaderId;
+                LeaderIdMeta::Type LeaderId;
                 
                 struct LeaderEpochMeta {
                     using Type = TKafkaInt32;
@@ -1385,22 +1385,21 @@ public:
                     static constexpr const char* About = "The latest known leader epoch";
                     static const Type Default; // = -1;
                     
-                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
                     static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion TaggedVersionMin = 0;
                     static constexpr TKafkaVersion TaggedVersionMax = -1;
                     static constexpr TKafkaVersion NullableVersionMin = 0;
                     static constexpr TKafkaVersion NullableVersionMax = -1;
-                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 0;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                LeaderEpochMeta::Type leaderEpoch;
+                LeaderEpochMeta::Type LeaderEpoch;
                 
+                class TReadContext;
                 
-                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
                 i32 Size(TKafkaVersion version) const override;
-                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
                 void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
                 
                 bool operator==(const TLeaderIdAndEpoch& other) const = default;
@@ -1411,7 +1410,7 @@ public:
                 struct MessageMeta {
                     static constexpr TKafkaVersion PresentVersionMin = 12;
                     static constexpr TKafkaVersion PresentVersionMax = 13;
-                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 0;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
                 
@@ -1435,7 +1434,7 @@ public:
                     static constexpr TKafkaVersion FlexibleVersionMin = 12;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                EndOffsetMeta::Type endOffset;
+                EndOffsetMeta::Type EndOffset;
                 
                 struct EpochMeta {
                     using Type = TKafkaInt32;
@@ -1454,13 +1453,12 @@ public:
                     static constexpr TKafkaVersion FlexibleVersionMin = 12;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                EpochMeta::Type epoch;
+                EpochMeta::Type Epoch;
                 
+                class TReadContext;
                 
-                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
                 i32 Size(TKafkaVersion version) const override;
-                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
                 void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
                 
                 bool operator==(const TSnapshotId& other) const = default;
@@ -1486,7 +1484,7 @@ public:
                     static constexpr const char* About = "The producer id associated with the aborted transaction.";
                     static const Type Default; // = 0;
                     
-                    static constexpr TKafkaVersion PresentVersionMin = 4;
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
                     static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion TaggedVersionMin = 0;
                     static constexpr TKafkaVersion TaggedVersionMax = -1;
@@ -1495,7 +1493,7 @@ public:
                     static constexpr TKafkaVersion FlexibleVersionMin = 12;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                ProducerIdMeta::Type producerId;
+                ProducerIdMeta::Type ProducerId;
                 
                 struct FirstOffsetMeta {
                     using Type = TKafkaInt64;
@@ -1505,7 +1503,7 @@ public:
                     static constexpr const char* About = "The first offset in the aborted transaction.";
                     static const Type Default; // = 0;
                     
-                    static constexpr TKafkaVersion PresentVersionMin = 4;
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
                     static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                     static constexpr TKafkaVersion TaggedVersionMin = 0;
                     static constexpr TKafkaVersion TaggedVersionMax = -1;
@@ -1514,13 +1512,12 @@ public:
                     static constexpr TKafkaVersion FlexibleVersionMin = 12;
                     static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
                 };
-                FirstOffsetMeta::Type firstOffset;
+                FirstOffsetMeta::Type FirstOffset;
                 
+                class TReadContext;
                 
-                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
                 i32 Size(TKafkaVersion version) const override;
-                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
                 void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
                 
                 bool operator==(const TAbortedTransaction& other) const = default;
@@ -1543,7 +1540,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            PartitionIndexMeta::Type partitionIndex;
+            PartitionIndexMeta::Type PartitionIndex;
             
             struct ErrorCodeMeta {
                 using Type = TKafkaInt16;
@@ -1562,7 +1559,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            ErrorCodeMeta::Type errorCode;
+            ErrorCodeMeta::Type ErrorCode;
             
             struct HighWatermarkMeta {
                 using Type = TKafkaInt64;
@@ -1581,7 +1578,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            HighWatermarkMeta::Type highWatermark;
+            HighWatermarkMeta::Type HighWatermark;
             
             struct LastStableOffsetMeta {
                 using Type = TKafkaInt64;
@@ -1600,7 +1597,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            LastStableOffsetMeta::Type lastStableOffset;
+            LastStableOffsetMeta::Type LastStableOffset;
             
             struct LogStartOffsetMeta {
                 using Type = TKafkaInt64;
@@ -1619,7 +1616,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            LogStartOffsetMeta::Type logStartOffset;
+            LogStartOffsetMeta::Type LogStartOffset;
             
             struct DivergingEpochMeta {
                 using Type = TEpochEndOffset;
@@ -1631,14 +1628,14 @@ public:
                 
                 static constexpr TKafkaVersion PresentVersionMin = 12;
                 static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
-                static constexpr TKafkaVersion TaggedVersionMin = 12;
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
                 static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
                 static constexpr TKafkaVersion NullableVersionMin = 0;
                 static constexpr TKafkaVersion NullableVersionMax = -1;
-                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMin = 0;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            DivergingEpochMeta::Type divergingEpoch;
+            DivergingEpochMeta::Type DivergingEpoch;
             
             struct CurrentLeaderMeta {
                 using Type = TLeaderIdAndEpoch;
@@ -1650,14 +1647,14 @@ public:
                 
                 static constexpr TKafkaVersion PresentVersionMin = 12;
                 static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
-                static constexpr TKafkaVersion TaggedVersionMin = 12;
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
                 static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
                 static constexpr TKafkaVersion NullableVersionMin = 0;
                 static constexpr TKafkaVersion NullableVersionMax = -1;
-                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMin = 0;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            CurrentLeaderMeta::Type currentLeader;
+            CurrentLeaderMeta::Type CurrentLeader;
             
             struct SnapshotIdMeta {
                 using Type = TSnapshotId;
@@ -1669,16 +1666,18 @@ public:
                 
                 static constexpr TKafkaVersion PresentVersionMin = 12;
                 static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
-                static constexpr TKafkaVersion TaggedVersionMin = 12;
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
                 static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
                 static constexpr TKafkaVersion NullableVersionMin = 0;
                 static constexpr TKafkaVersion NullableVersionMax = -1;
-                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMin = 0;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            SnapshotIdMeta::Type snapshotId;
+            SnapshotIdMeta::Type SnapshotId;
             
             struct AbortedTransactionsMeta {
+                using ItemType = TAbortedTransaction;
+                using ItemTypeDesc = NPrivate::TKafkaStructDesc;
                 using Type = std::vector<TAbortedTransaction>;
                 using TypeDesc = NPrivate::TKafkaArrayDesc;
                 
@@ -1689,12 +1688,12 @@ public:
                 static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
                 static constexpr TKafkaVersion TaggedVersionMin = 0;
                 static constexpr TKafkaVersion TaggedVersionMax = -1;
-                static constexpr TKafkaVersion NullableVersionMin = 4;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
                 static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            AbortedTransactionsMeta::Type abortedTransactions;
+            AbortedTransactionsMeta::Type AbortedTransactions;
             
             struct PreferredReadReplicaMeta {
                 using Type = TKafkaInt32;
@@ -1713,7 +1712,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            PreferredReadReplicaMeta::Type preferredReadReplica;
+            PreferredReadReplicaMeta::Type PreferredReadReplica;
             
             struct RecordsMeta {
                 using Type = TKafkaRecords;
@@ -1731,13 +1730,12 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 12;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            RecordsMeta::Type records;
+            RecordsMeta::Type Records;
             
+            class TReadContext;
             
-            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
             i32 Size(TKafkaVersion version) const override;
-            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
             void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
             
             bool operator==(const TPartitionData& other) const = default;
@@ -1760,7 +1758,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 12;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicMeta::Type topic;
+        TopicMeta::Type Topic;
         
         struct TopicIdMeta {
             using Type = TKafkaUuid;
@@ -1776,12 +1774,14 @@ public:
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicIdMeta::Type topicId;
+        TopicIdMeta::Type TopicId;
         
         struct PartitionsMeta {
+            using ItemType = TPartitionData;
+            using ItemTypeDesc = NPrivate::TKafkaStructDesc;
             using Type = std::vector<TPartitionData>;
             using TypeDesc = NPrivate::TKafkaArrayDesc;
             
@@ -1797,13 +1797,12 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 12;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        PartitionsMeta::Type partitions;
+        PartitionsMeta::Type Partitions;
         
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TFetchableTopicResponse& other) const = default;
@@ -1826,7 +1825,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ThrottleTimeMsMeta::Type throttleTimeMs;
+    ThrottleTimeMsMeta::Type ThrottleTimeMs;
     
     struct ErrorCodeMeta {
         using Type = TKafkaInt16;
@@ -1845,7 +1844,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ErrorCodeMeta::Type errorCode;
+    ErrorCodeMeta::Type ErrorCode;
     
     struct SessionIdMeta {
         using Type = TKafkaInt32;
@@ -1864,9 +1863,11 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    SessionIdMeta::Type sessionId;
+    SessionIdMeta::Type SessionId;
     
     struct ResponsesMeta {
+        using ItemType = TFetchableTopicResponse;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TFetchableTopicResponse>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -1882,14 +1883,13 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 12;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ResponsesMeta::Type responses;
+    ResponsesMeta::Type Responses;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return FETCH; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TFetchResponseData& other) const = default;
@@ -1934,10 +1934,10 @@ public:
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicIdMeta::Type topicId;
+        TopicIdMeta::Type TopicId;
         
         struct NameMeta {
             using Type = TKafkaString;
@@ -1956,19 +1956,20 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        NameMeta::Type name;
+        NameMeta::Type Name;
         
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TMetadataRequestTopic& other) const = default;
     };
     
     struct TopicsMeta {
+        using ItemType = TMetadataRequestTopic;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TMetadataRequestTopic>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -1984,7 +1985,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    TopicsMeta::Type topics;
+    TopicsMeta::Type Topics;
     
     struct AllowAutoTopicCreationMeta {
         using Type = TKafkaBool;
@@ -2003,7 +2004,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    AllowAutoTopicCreationMeta::Type allowAutoTopicCreation;
+    AllowAutoTopicCreationMeta::Type AllowAutoTopicCreation;
     
     struct IncludeClusterAuthorizedOperationsMeta {
         using Type = TKafkaBool;
@@ -2022,7 +2023,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    IncludeClusterAuthorizedOperationsMeta::Type includeClusterAuthorizedOperations;
+    IncludeClusterAuthorizedOperationsMeta::Type IncludeClusterAuthorizedOperations;
     
     struct IncludeTopicAuthorizedOperationsMeta {
         using Type = TKafkaBool;
@@ -2041,14 +2042,13 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    IncludeTopicAuthorizedOperationsMeta::Type includeTopicAuthorizedOperations;
+    IncludeTopicAuthorizedOperationsMeta::Type IncludeTopicAuthorizedOperations;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return METADATA; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TMetadataRequestData& other) const = default;
@@ -2096,7 +2096,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        NodeIdMeta::Type nodeId;
+        NodeIdMeta::Type NodeId;
         
         struct HostMeta {
             using Type = TKafkaString;
@@ -2115,7 +2115,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        HostMeta::Type host;
+        HostMeta::Type Host;
         
         struct PortMeta {
             using Type = TKafkaInt32;
@@ -2134,7 +2134,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        PortMeta::Type port;
+        PortMeta::Type Port;
         
         struct RackMeta {
             using Type = TKafkaString;
@@ -2148,20 +2148,17 @@ public:
             static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
-            static constexpr TKafkaVersion NullableVersionMin = 1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        RackMeta::Type rack;
+        RackMeta::Type Rack;
         
-        i32 next;
-        i32 prev;
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TMetadataResponseBroker& other) const = default;
@@ -2208,7 +2205,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            ErrorCodeMeta::Type errorCode;
+            ErrorCodeMeta::Type ErrorCode;
             
             struct PartitionIndexMeta {
                 using Type = TKafkaInt32;
@@ -2227,7 +2224,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            PartitionIndexMeta::Type partitionIndex;
+            PartitionIndexMeta::Type PartitionIndex;
             
             struct LeaderIdMeta {
                 using Type = TKafkaInt32;
@@ -2246,7 +2243,7 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            LeaderIdMeta::Type leaderId;
+            LeaderIdMeta::Type LeaderId;
             
             struct LeaderEpochMeta {
                 using Type = TKafkaInt32;
@@ -2265,9 +2262,11 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            LeaderEpochMeta::Type leaderEpoch;
+            LeaderEpochMeta::Type LeaderEpoch;
             
             struct ReplicaNodesMeta {
+                using ItemType = TKafkaInt32;
+                using ItemTypeDesc = NPrivate::TKafkaInt32Desc;
                 using Type = std::vector<TKafkaInt32>;
                 using TypeDesc = NPrivate::TKafkaArrayDesc;
                 
@@ -2283,9 +2282,11 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            ReplicaNodesMeta::Type replicaNodes;
+            ReplicaNodesMeta::Type ReplicaNodes;
             
             struct IsrNodesMeta {
+                using ItemType = TKafkaInt32;
+                using ItemTypeDesc = NPrivate::TKafkaInt32Desc;
                 using Type = std::vector<TKafkaInt32>;
                 using TypeDesc = NPrivate::TKafkaArrayDesc;
                 
@@ -2301,9 +2302,11 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            IsrNodesMeta::Type isrNodes;
+            IsrNodesMeta::Type IsrNodes;
             
             struct OfflineReplicasMeta {
+                using ItemType = TKafkaInt32;
+                using ItemTypeDesc = NPrivate::TKafkaInt32Desc;
                 using Type = std::vector<TKafkaInt32>;
                 using TypeDesc = NPrivate::TKafkaArrayDesc;
                 
@@ -2319,13 +2322,12 @@ public:
                 static constexpr TKafkaVersion FlexibleVersionMin = 9;
                 static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
             };
-            OfflineReplicasMeta::Type offlineReplicas;
+            OfflineReplicasMeta::Type OfflineReplicas;
             
+            class TReadContext;
             
-            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
             i32 Size(TKafkaVersion version) const override;
-            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
             void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
             
             bool operator==(const TMetadataResponsePartition& other) const = default;
@@ -2348,7 +2350,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        ErrorCodeMeta::Type errorCode;
+        ErrorCodeMeta::Type ErrorCode;
         
         struct NameMeta {
             using Type = TKafkaString;
@@ -2367,7 +2369,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        NameMeta::Type name;
+        NameMeta::Type Name;
         
         struct TopicIdMeta {
             using Type = TKafkaUuid;
@@ -2383,10 +2385,10 @@ public:
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicIdMeta::Type topicId;
+        TopicIdMeta::Type TopicId;
         
         struct IsInternalMeta {
             using Type = TKafkaBool;
@@ -2405,9 +2407,11 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        IsInternalMeta::Type isInternal;
+        IsInternalMeta::Type IsInternal;
         
         struct PartitionsMeta {
+            using ItemType = TMetadataResponsePartition;
+            using ItemTypeDesc = NPrivate::TKafkaStructDesc;
             using Type = std::vector<TMetadataResponsePartition>;
             using TypeDesc = NPrivate::TKafkaArrayDesc;
             
@@ -2423,7 +2427,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        PartitionsMeta::Type partitions;
+        PartitionsMeta::Type Partitions;
         
         struct TopicAuthorizedOperationsMeta {
             using Type = TKafkaInt32;
@@ -2442,15 +2446,12 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 9;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        TopicAuthorizedOperationsMeta::Type topicAuthorizedOperations;
+        TopicAuthorizedOperationsMeta::Type TopicAuthorizedOperations;
         
-        i32 next;
-        i32 prev;
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TMetadataResponseTopic& other) const = default;
@@ -2473,9 +2474,11 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ThrottleTimeMsMeta::Type throttleTimeMs;
+    ThrottleTimeMsMeta::Type ThrottleTimeMs;
     
     struct BrokersMeta {
+        using ItemType = TMetadataResponseBroker;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TMetadataResponseBroker>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -2491,7 +2494,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    BrokersMeta::Type brokers;
+    BrokersMeta::Type Brokers;
     
     struct ClusterIdMeta {
         using Type = TKafkaString;
@@ -2505,12 +2508,12 @@ public:
         static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion TaggedVersionMin = 0;
         static constexpr TKafkaVersion TaggedVersionMax = -1;
-        static constexpr TKafkaVersion NullableVersionMin = 2;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ClusterIdMeta::Type clusterId;
+    ClusterIdMeta::Type ClusterId;
     
     struct ControllerIdMeta {
         using Type = TKafkaInt32;
@@ -2529,9 +2532,11 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ControllerIdMeta::Type controllerId;
+    ControllerIdMeta::Type ControllerId;
     
     struct TopicsMeta {
+        using ItemType = TMetadataResponseTopic;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TMetadataResponseTopic>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -2547,7 +2552,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    TopicsMeta::Type topics;
+    TopicsMeta::Type Topics;
     
     struct ClusterAuthorizedOperationsMeta {
         using Type = TKafkaInt32;
@@ -2566,14 +2571,13 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 9;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ClusterAuthorizedOperationsMeta::Type clusterAuthorizedOperations;
+    ClusterAuthorizedOperationsMeta::Type ClusterAuthorizedOperations;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return METADATA; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TMetadataResponseData& other) const = default;
@@ -2606,10 +2610,10 @@ public:
         static constexpr TKafkaVersion TaggedVersionMax = -1;
         static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = -1;
-        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ClientSoftwareNameMeta::Type clientSoftwareName;
+    ClientSoftwareNameMeta::Type ClientSoftwareName;
     
     struct ClientSoftwareVersionMeta {
         using Type = TKafkaString;
@@ -2625,17 +2629,16 @@ public:
         static constexpr TKafkaVersion TaggedVersionMax = -1;
         static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = -1;
-        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ClientSoftwareVersionMeta::Type clientSoftwareVersion;
+    ClientSoftwareVersionMeta::Type ClientSoftwareVersion;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return API_VERSIONS; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TApiVersionsRequestData& other) const = default;
@@ -2683,7 +2686,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 3;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        ApiKeyMeta::Type apiKey;
+        ApiKeyMeta::Type ApiKey;
         
         struct MinVersionMeta {
             using Type = TKafkaInt16;
@@ -2702,7 +2705,7 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 3;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        MinVersionMeta::Type minVersion;
+        MinVersionMeta::Type MinVersion;
         
         struct MaxVersionMeta {
             using Type = TKafkaInt16;
@@ -2721,15 +2724,12 @@ public:
             static constexpr TKafkaVersion FlexibleVersionMin = 3;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        MaxVersionMeta::Type maxVersion;
+        MaxVersionMeta::Type MaxVersion;
         
-        i32 next;
-        i32 prev;
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TApiVersion& other) const = default;
@@ -2740,7 +2740,7 @@ public:
         struct MessageMeta {
             static constexpr TKafkaVersion PresentVersionMin = 3;
             static constexpr TKafkaVersion PresentVersionMax = 3;
-            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
         
@@ -2755,16 +2755,16 @@ public:
             static constexpr const char* About = "The name of the feature.";
             static const Type Default; // = {""};
             
-            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMin = 0;
             static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        NameMeta::Type name;
+        NameMeta::Type Name;
         
         struct MinVersionMeta {
             using Type = TKafkaInt16;
@@ -2774,16 +2774,16 @@ public:
             static constexpr const char* About = "The minimum supported version for the feature.";
             static const Type Default; // = 0;
             
-            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMin = 0;
             static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        MinVersionMeta::Type minVersion;
+        MinVersionMeta::Type MinVersion;
         
         struct MaxVersionMeta {
             using Type = TKafkaInt16;
@@ -2793,24 +2793,21 @@ public:
             static constexpr const char* About = "The maximum supported version for the feature.";
             static const Type Default; // = 0;
             
-            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMin = 0;
             static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        MaxVersionMeta::Type maxVersion;
+        MaxVersionMeta::Type MaxVersion;
         
-        i32 next;
-        i32 prev;
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TSupportedFeatureKey& other) const = default;
@@ -2821,7 +2818,7 @@ public:
         struct MessageMeta {
             static constexpr TKafkaVersion PresentVersionMin = 3;
             static constexpr TKafkaVersion PresentVersionMax = 3;
-            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
         
@@ -2836,16 +2833,16 @@ public:
             static constexpr const char* About = "The name of the feature.";
             static const Type Default; // = {""};
             
-            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMin = 0;
             static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        NameMeta::Type name;
+        NameMeta::Type Name;
         
         struct MaxVersionLevelMeta {
             using Type = TKafkaInt16;
@@ -2855,16 +2852,16 @@ public:
             static constexpr const char* About = "The cluster-wide finalized max version level for the feature.";
             static const Type Default; // = 0;
             
-            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMin = 0;
             static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        MaxVersionLevelMeta::Type maxVersionLevel;
+        MaxVersionLevelMeta::Type MaxVersionLevel;
         
         struct MinVersionLevelMeta {
             using Type = TKafkaInt16;
@@ -2874,24 +2871,21 @@ public:
             static constexpr const char* About = "The cluster-wide finalized min version level for the feature.";
             static const Type Default; // = 0;
             
-            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMin = 0;
             static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
             static constexpr TKafkaVersion TaggedVersionMin = 0;
             static constexpr TKafkaVersion TaggedVersionMax = -1;
             static constexpr TKafkaVersion NullableVersionMin = 0;
             static constexpr TKafkaVersion NullableVersionMax = -1;
-            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 0;
             static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
         };
-        MinVersionLevelMeta::Type minVersionLevel;
+        MinVersionLevelMeta::Type MinVersionLevel;
         
-        i32 next;
-        i32 prev;
+        class TReadContext;
         
-        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
         i32 Size(TKafkaVersion version) const override;
-        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
         void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
         
         bool operator==(const TFinalizedFeatureKey& other) const = default;
@@ -2914,9 +2908,11 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 3;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ErrorCodeMeta::Type errorCode;
+    ErrorCodeMeta::Type ErrorCode;
     
     struct ApiKeysMeta {
+        using ItemType = TApiVersion;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TApiVersion>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -2932,7 +2928,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 3;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ApiKeysMeta::Type apiKeys;
+    ApiKeysMeta::Type ApiKeys;
     
     struct ThrottleTimeMsMeta {
         using Type = TKafkaInt32;
@@ -2951,9 +2947,11 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 3;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ThrottleTimeMsMeta::Type throttleTimeMs;
+    ThrottleTimeMsMeta::Type ThrottleTimeMs;
     
     struct SupportedFeaturesMeta {
+        using ItemType = TSupportedFeatureKey;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TSupportedFeatureKey>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -2963,14 +2961,14 @@ public:
         
         static constexpr TKafkaVersion PresentVersionMin = 3;
         static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
-        static constexpr TKafkaVersion TaggedVersionMin = 3;
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
         static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = -1;
-        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    SupportedFeaturesMeta::Type supportedFeatures;
+    SupportedFeaturesMeta::Type SupportedFeatures;
     
     struct FinalizedFeaturesEpochMeta {
         using Type = TKafkaInt64;
@@ -2983,16 +2981,18 @@ public:
         
         static constexpr TKafkaVersion PresentVersionMin = 3;
         static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
-        static constexpr TKafkaVersion TaggedVersionMin = 3;
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
         static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = -1;
-        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    FinalizedFeaturesEpochMeta::Type finalizedFeaturesEpoch;
+    FinalizedFeaturesEpochMeta::Type FinalizedFeaturesEpoch;
     
     struct FinalizedFeaturesMeta {
+        using ItemType = TFinalizedFeatureKey;
+        using ItemTypeDesc = NPrivate::TKafkaStructDesc;
         using Type = std::vector<TFinalizedFeatureKey>;
         using TypeDesc = NPrivate::TKafkaArrayDesc;
         
@@ -3002,14 +3002,14 @@ public:
         
         static constexpr TKafkaVersion PresentVersionMin = 3;
         static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
-        static constexpr TKafkaVersion TaggedVersionMin = 3;
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
         static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = -1;
-        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    FinalizedFeaturesMeta::Type finalizedFeatures;
+    FinalizedFeaturesMeta::Type FinalizedFeatures;
     
     struct ZkMigrationReadyMeta {
         using Type = TKafkaBool;
@@ -3022,21 +3022,20 @@ public:
         
         static constexpr TKafkaVersion PresentVersionMin = 3;
         static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
-        static constexpr TKafkaVersion TaggedVersionMin = 3;
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
         static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
         static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = -1;
-        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ZkMigrationReadyMeta::Type zkMigrationReady;
+    ZkMigrationReadyMeta::Type ZkMigrationReady;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return API_VERSIONS; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TApiVersionsResponseData& other) const = default;
@@ -3072,7 +3071,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    TransactionalIdMeta::Type transactionalId;
+    TransactionalIdMeta::Type TransactionalId;
     
     struct TransactionTimeoutMsMeta {
         using Type = TKafkaInt32;
@@ -3091,7 +3090,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    TransactionTimeoutMsMeta::Type transactionTimeoutMs;
+    TransactionTimeoutMsMeta::Type TransactionTimeoutMs;
     
     struct ProducerIdMeta {
         using Type = TKafkaInt64;
@@ -3107,10 +3106,10 @@ public:
         static constexpr TKafkaVersion TaggedVersionMax = -1;
         static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = -1;
-        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ProducerIdMeta::Type producerId;
+    ProducerIdMeta::Type ProducerId;
     
     struct ProducerEpochMeta {
         using Type = TKafkaInt16;
@@ -3126,17 +3125,16 @@ public:
         static constexpr TKafkaVersion TaggedVersionMax = -1;
         static constexpr TKafkaVersion NullableVersionMin = 0;
         static constexpr TKafkaVersion NullableVersionMax = -1;
-        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ProducerEpochMeta::Type producerEpoch;
+    ProducerEpochMeta::Type ProducerEpoch;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return INIT_PRODUCER_ID; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TInitProducerIdRequestData& other) const = default;
@@ -3172,7 +3170,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ThrottleTimeMsMeta::Type throttleTimeMs;
+    ThrottleTimeMsMeta::Type ThrottleTimeMs;
     
     struct ErrorCodeMeta {
         using Type = TKafkaInt16;
@@ -3191,7 +3189,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ErrorCodeMeta::Type errorCode;
+    ErrorCodeMeta::Type ErrorCode;
     
     struct ProducerIdMeta {
         using Type = TKafkaInt64;
@@ -3210,7 +3208,7 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ProducerIdMeta::Type producerId;
+    ProducerIdMeta::Type ProducerId;
     
     struct ProducerEpochMeta {
         using Type = TKafkaInt16;
@@ -3229,14 +3227,13 @@ public:
         static constexpr TKafkaVersion FlexibleVersionMin = 2;
         static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
     };
-    ProducerEpochMeta::Type producerEpoch;
+    ProducerEpochMeta::Type ProducerEpoch;
     
+    class TReadContext;
     
     i16 ApiKey() const override { return INIT_PRODUCER_ID; };
-    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
-    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
     i32 Size(TKafkaVersion version) const override;
-    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    std::unique_ptr<NKafka::TReadContext> CreateReadContext(TKafkaVersion version) override /*{ return new TReadContext(*this, version); }*/;
     void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
     
     bool operator==(const TInitProducerIdResponseData& other) const = default;
diff --git a/ydb/core/kafkaproxy/kafka_messages_int.h b/ydb/core/kafkaproxy/kafka_messages_int.h
index f485cc5ebdd..077d8b46b0c 100644
--- a/ydb/core/kafkaproxy/kafka_messages_int.h
+++ b/ydb/core/kafkaproxy/kafka_messages_int.h
@@ -2,20 +2,13 @@
 
 #include <functional>
 #include <memory>
-#include <optional>
 #include <vector>
 
-#include <util/generic/buffer.h>
-#include <util/generic/strbuf.h>
-
 #include <util/generic/array_ref.h>
 #include <util/generic/yexception.h>
-#include <util/system/types.h>
 
 #include <contrib/libs/cxxsupp/libcxx/include/type_traits>
 
-#include <ydb/library/yql/public/decimal/yql_wide_int.h>
-
 #include "kafka.h"
 
 namespace NKafka {
@@ -126,7 +119,6 @@ struct TSizeCollector {
 };
 
 
-
 constexpr i32 SizeOfUnsignedVarint(i32 value) {
     int bytes = 1;
     while ((value & 0xffffff80) != 0L) {
@@ -162,7 +154,22 @@ inline bool VersionCheck(const TKafkaVersion value) {
     }
 }
 
+template<typename Meta>
+class ReadFieldRule {
+public:
+    static bool Apply(TKafkaVersion version) {
+        return VersionCheck<Meta::PresentVersionMin, Meta::PresentVersionMax>(version) 
+            && !VersionCheck<Meta::TaggedVersionMin, Meta::TaggedVersionMax>(version);
+    }
+};
 
+template<typename Meta>
+class ReadTaggedFieldRule {
+public:
+    static bool Apply(TKafkaVersion /*version*/) {
+        return true;
+    }
+};
 
 template<typename Meta>
 bool IsDefaultValue(const typename Meta::Type& value) {
@@ -225,6 +232,336 @@ inline TKafkaInt32 ReadArraySize(TKafkaReadable& readable, TKafkaVersion version
 }
 
 
+template<typename T>
+void NormalizeNumber(T& value) {
+#ifndef WORDS_BIGENDIAN
+        char* b = (char*)&value;
+        char* e = b + sizeof(T) - 1;
+        while(b < e) {
+            std::swap(*b, *e);
+            ++b;
+            --e;
+        }
+#endif
+}
+
+class ReadUnsignedVarintStrategy {
+public:
+    void Init() {
+        Finished = 0;
+        Shift = -1;
+        Value = 0;
+    }
+
+    TReadDemand Next() {
+        if (Finished) {
+            return NoDemand;
+        }
+        if (Shift >= 0) {
+            Finished = !(Buffer & 0x80);
+            ui32 v = Buffer & 0x7F;
+            Value |= v << Shift;
+            Shift += 7;
+        } else {
+            Shift = 0;
+        }
+
+        if (Finished) {
+            return NoDemand;
+        } else {
+            return TReadDemand(&Buffer, sizeof(char));
+        }
+    }
+
+    TKafkaInt32 Value;
+
+private:
+    bool Finished;
+    char Buffer;
+    i8 Shift;
+};
+
+
+
+template<typename Meta, typename TOldSizeType>
+class ReadSizeStrategy {
+public:
+    void Init() {
+        WasRead = false;
+        WasNormalized = false;
+        OldValue = 0;
+        UnsignedVarintStrategy.Init();
+    }
+
+    TReadDemand Next(TKafkaVersion version) {
+        if (VersionCheck<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(version)) {
+            return UnsignedVarintStrategy.Next();
+        } else {
+            if (WasRead) {
+                if (!WasNormalized) {
+                    WasNormalized = true;
+                    NormalizeNumber(OldValue);
+                }
+                return NoDemand;
+            }
+            WasRead = true;
+            return TReadDemand((char*)&OldValue, sizeof(TOldSizeType));
+        }
+    }
+
+    TKafkaInt32 Value(TKafkaVersion version) {
+        if (VersionCheck<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(version)) {
+            return UnsignedVarintStrategy.Value - 1;
+        } else {
+            return OldValue;
+        }
+    }
+
+private:
+    bool WasRead;
+    bool WasNormalized;
+    TOldSizeType OldValue;
+
+    ReadUnsignedVarintStrategy UnsignedVarintStrategy;
+};
+
+
+
+template<typename Meta,
+         typename TValueType = typename Meta::Type,
+         typename TTypeDesc = typename Meta::TypeDesc>
+class TReadStrategy {
+public:
+    template<typename Rule>
+    void Init(TValueType& /*value*/, TKafkaVersion /*version*/) {
+        WasRead = false;
+    }
+
+    template<typename Rule>
+    TReadDemand Next(TValueType& value, TKafkaVersion version) {
+        if (!Rule::Apply(version)) {
+            if constexpr (Meta::TypeDesc::Default) {
+                value = Meta::Default;
+            }
+            return NoDemand;
+        }
+        if (WasRead) {
+            NormalizeNumber(value);
+            return NoDemand;
+        }
+        WasRead = true;
+        return TReadDemand((char*)&value, sizeof(TValueType));
+    }
+
+private:
+    bool WasRead;
+};
+
+
+template<typename Meta, typename TValueType>
+class TReadStrategy<Meta, TValueType, TKafkaStructDesc> {
+public:
+    template<typename Rule>
+    void Init(TValueType& value, TKafkaVersion version) {
+        if (Rule::Apply(version)) {
+            Context = value.CreateReadContext(version);
+        }
+    }
+
+    template<typename Rule>
+    TReadDemand Next(TValueType& /*value*/, TKafkaVersion version) {
+        if (Rule::Apply(version)) {
+            return Context.get()->Next();
+        } else {
+            return NoDemand;
+        }
+    }
+
+private:
+    std::unique_ptr<TReadContext> Context;
+};
+
+
+template<typename Meta, typename TValueType>
+class TReadStrategy<Meta, TValueType, TKafkaUuidDesc> {
+public:
+    template<typename Rule>
+    void Init(TKafkaUuid& /*value*/, TKafkaVersion /*version*/) {
+        WasRead = false;
+    }
+
+    template<typename Rule>
+    TReadDemand Next(TKafkaUuid& value, TKafkaVersion version) {
+        if (!Rule::Apply(version)) {
+            return NoDemand;
+        }
+        if (WasRead) {
+            NormalizeNumber(Buffer[0]);
+            NormalizeNumber(Buffer[1]);
+            value = TKafkaUuid(Buffer[0], Buffer[1]);
+            return NoDemand;
+        }
+        WasRead = true;
+        return TReadDemand((char*)Buffer, sizeof(ui64) << 1);
+    }
+
+private:
+    bool WasRead;
+    ui64 Buffer[2];
+};
+
+
+
+template<typename Meta, typename TValueType>
+class TReadStrategy<Meta, TValueType, TKafkaStringDesc> {
+public:
+    template<typename Rule>
+    void Init(TKafkaString& /*value*/, TKafkaVersion /*version*/) {
+        WasRead = false;
+        Size.Init();
+    }
+
+    template<typename Rule>
+    TReadDemand Next(TKafkaString& value, TKafkaVersion version) {
+        if (WasRead || !Rule::Apply(version)) {
+            return NoDemand;
+        }
+        auto demand = Size.Next(version);
+        if (demand) {
+            return demand;
+        }
+        WasRead = true;
+        TKafkaInt32 length = Size.Value(version);
+
+        if (length < 0) {
+            if (VersionCheck<Meta::NullableVersionMin, Meta::NullableVersionMax>(version)) {
+                value = std::nullopt;
+                return NoDemand;
+            } else {
+                ythrow yexception() << "non-nullable field " << Meta::Name << " was serialized as null";
+            }
+        } else if (length > Max<i16>()){
+            ythrow yexception() << "string field " << Meta::Name << " had invalid length " << length;
+        }
+
+        value = TString();
+        value->ReserveAndResize(length);
+        return TReadDemand((char*)value->data(), length);
+    }
+
+private:
+    bool WasRead;
+
+    ReadSizeStrategy<Meta, TKafkaInt16> Size;
+};
+
+
+template<typename Meta, typename Desc>
+class TReadStrategy<Meta, TKafkaRecords, Desc> {
+public:
+    template<typename Rule>
+    void Init(TKafkaRecords& /*value*/, TKafkaVersion /*version*/) {
+        WasRead = false;
+        Size.Init();
+    }
+
+    template<typename Rule>
+    TReadDemand Next(TKafkaRecords& value, TKafkaVersion version) {
+        if (WasRead || !Rule::Apply(version)) {
+            return NoDemand;
+        }
+        auto demand = Size.Next(version);
+        if (demand) {
+            return demand;
+        }
+        WasRead = true;
+        TKafkaInt32 length = Size.Value(version);
+
+        if (length < 0) {
+            if (VersionCheck<Meta::NullableVersionMin, Meta::NullableVersionMax>(version)) {
+                value = std::nullopt;
+                return NoDemand;
+            } else {
+                ythrow yexception() << "non-nullable field " << Meta::Name << " was serialized as null";
+            }
+        }
+
+        value = TKafkaRawBytes();
+        value->Resize(length);
+        return TReadDemand(value->data(), length);
+    }
+
+private:
+    bool WasRead;
+
+    ReadSizeStrategy<Meta, TKafkaInt32> Size;
+};
+
+
+template<typename Meta, typename TValueType>
+class TReadStrategy<Meta, TValueType, TKafkaArrayDesc> {
+public:
+    template<typename Rule>
+    void Init(std::vector<typename Meta::ItemType>& /*value*/, TKafkaVersion /*version*/) {
+        ItemStep = -1;
+        Size.Init();
+    }
+
+    template<typename Rule>
+    TReadDemand Next(std::vector<typename Meta::ItemType>& value, TKafkaVersion version) {
+        if (!Rule::Apply(version)) {
+            return NoDemand;
+        }
+        auto demand = Size.Next(version);
+        if (demand) {
+            return demand;
+        }
+        if (-1 == ItemStep) {
+            TKafkaInt32 length = Size.Value(version);
+
+            if (length < 0) {
+                if (VersionCheck<Meta::NullableVersionMin, Meta::NullableVersionMax>(version)) {
+                    value.resize(0);
+                    return NoDemand;
+                } else {
+                    ythrow yexception() << "non-nullable field " << Meta::Name << " was serialized as null";
+                }
+            }
+
+            value.resize(length);
+            if (0 == length) {
+                return NoDemand;
+            }
+
+            ItemStep = 0;
+            ItemStrategy.template Init<Rule>(value[ItemStep], version);
+        } else if (ItemStep == (i32)value.size()) {
+            return NoDemand;
+        }
+
+        demand = ItemStrategy.template Next<Rule>(value[ItemStep], version);
+        if (demand) {
+            return demand;
+        }
+
+        ++ItemStep;
+        if (ItemStep == (i32)value.size()) {
+            return NoDemand;
+        }
+        ItemStrategy.template Init<Rule>(value[ItemStep], version);
+        return ItemStrategy.template Next<Rule>(value[ItemStep], version);
+    }
+
+private:
+    i32 ItemStep;
+
+    ReadSizeStrategy<Meta, TKafkaInt32> Size;
+    TReadStrategy<Meta, typename Meta::ItemType, typename Meta::ItemTypeDesc> ItemStrategy;
+};
+
+
+
+
 
 //
 // Common
diff --git a/ydb/core/kafkaproxy/ut/ut_serialization.cpp b/ydb/core/kafkaproxy/ut/ut_serialization.cpp
index 669799a35c0..3bca84033b2 100644
--- a/ydb/core/kafkaproxy/ut/ut_serialization.cpp
+++ b/ydb/core/kafkaproxy/ut/ut_serialization.cpp
@@ -6,34 +6,107 @@
 
 using namespace NKafka;
 
-void Print(std::stringstream& sb);
+void Print(std::string& sb);
+
+class TReadProcessor {
+public:
+    TReadProcessor(std::stringstream& buffer)
+        : Buffer(std::istreambuf_iterator<char>(buffer), {})
+        , Position(0)
+    {
+        Print(Buffer);
+    }
+
+    std::string Buffer;
+    size_t Position;
+
+    void Read(TMessage* msg, TKafkaVersion version) {
+        auto ctx = msg->CreateReadContext(version);
+
+
+        while(true) {
+            auto demand = ctx->Next();
+            Cerr << "TReadProcessor:: demand length=" << demand.GetLength() << ", position=" << Position << ", length=" << Buffer.length() << Endl;
+            if (!demand) {
+                break;
+            }
+
+            if (!(Buffer.length() >= Position + demand.GetLength())) {
+                EXPECT_TRUE(Buffer.length() >= Position + demand.GetLength());
+                return;
+            }
+
+            if (!demand.Skip()) {
+                memcpy(demand.GetBuffer(), Buffer.data() + Position, demand.GetLength());
+            }
+            Position += demand.Length;
+        }
+
+       EXPECT_FALSE(Position < Buffer.length());
+    }
+};
+
+template<typename Meta>
+class TFieldReadProcessor {
+public:
+    NKafka::NPrivate::TReadStrategy<Meta> strategy;
+
+    TFieldReadProcessor(std::stringstream& buffer)
+        : Buffer(std::istreambuf_iterator<char>(buffer), {})
+        , Position(0)
+    {
+        Print(Buffer);
+    }
+
+    std::string Buffer;
+    size_t Position;
+
+    void Read(typename Meta::Type& field, TKafkaVersion version) {
+        strategy.template Init<NKafka::NPrivate::ReadFieldRule<Meta>>(field, version);
+
+        while(true) {
+            auto demand =  strategy.template Next<NKafka::NPrivate::ReadFieldRule<Meta>>(field, version);
+            Cerr << "TFieldReadProcessor:: demand length=" << demand.GetLength() << ", position=" << Position << ", length=" << Buffer.length() << Endl;
+            if (!demand) {
+                break;
+            }
+
+            if (!(Buffer.length() >= Position + demand.GetLength())) {
+                EXPECT_TRUE(Buffer.length() >= Position + demand.GetLength());
+                return;
+            }
+
+            if (!demand.Skip()) {
+                memcpy(demand.GetBuffer(), Buffer.data() + Position, demand.GetLength());
+            }
+            Position += demand.Length;
+        }
+
+       EXPECT_FALSE(Position < Buffer.length());
+    }
+};
 
 TEST(Serialization, RequestHeader) {
     std::stringstream sb;
 
     TRequestHeaderData value;
 
-    value.requestApiKey = 3;
-    value.requestApiVersion = 7;
-    value.correlationId = 11;
-    value.clientId = { "clientId-value" };
+    value.RequestApiKey = 3;
+    value.RequestApiVersion = 7;
+    value.CorrelationId = 11;
+    value.ClientId = { "clientId-value" };
 
     TKafkaWritable writable(sb);
     value.Write(writable, 1);
 
-    //Print(sb);
-
+    TReadProcessor processor(sb);
     TRequestHeaderData result;
+    processor.Read(&result, 1);
 
-    //sb.seekg(0);
-
-    TKafkaReadable readable(sb);
-    result.Read(readable, 1);
-
-    EXPECT_EQ(result.requestApiKey, 3);
-    EXPECT_EQ(result.requestApiVersion, 7);
-    EXPECT_EQ(result.correlationId, 11);
-    EXPECT_EQ(*result.clientId, "clientId-value");
+    EXPECT_EQ(result.RequestApiKey, 3);
+    EXPECT_EQ(result.RequestApiVersion, 7);
+    EXPECT_EQ(result.CorrelationId, 11);
+    EXPECT_EQ(*result.ClientId, "clientId-value");
 }
 
 TEST(Serialization, ResponseHeader) {
@@ -41,19 +114,16 @@ TEST(Serialization, ResponseHeader) {
 
     TResponseHeaderData value;
 
-    value.correlationId = 13;
+    value.CorrelationId = 13;
 
     TKafkaWritable writable(sb);
     value.Write(writable, 0);
 
-    //Print(sb);
-
+    TReadProcessor processor(sb);
     TResponseHeaderData result;
+    processor.Read(&result, 0);
 
-    TKafkaReadable readable(sb);
-    result.Read(readable, 0);
-
-    EXPECT_EQ(result.correlationId, 13);
+    EXPECT_EQ(result.CorrelationId, 13);
 }
 
 TEST(Serialization, ApiVersionsRequest) {
@@ -61,21 +131,19 @@ TEST(Serialization, ApiVersionsRequest) {
 
     TApiVersionsRequestData value;
 
-    value.clientSoftwareName = { "apache-kafka-java" };
-    value.clientSoftwareVersion = { "3.4.0" };
+    value.ClientSoftwareName = { "apache-kafka-java" };
+    value.ClientSoftwareVersion = { "3.4.0" };
 
     TKafkaWritable writable(sb);
     value.Write(writable, 3);
 
-    //Print(sb);
 
+    TReadProcessor processor(sb);
     TApiVersionsRequestData result;
+    processor.Read(&result, 3);
 
-    TKafkaReadable readable(sb);
-    result.Read(readable, 3);
-
-    EXPECT_EQ(*result.clientSoftwareName, "apache-kafka-java");
-    EXPECT_EQ(*result.clientSoftwareVersion, "3.4.0");
+    EXPECT_EQ(*result.ClientSoftwareName, "apache-kafka-java");
+    EXPECT_EQ(*result.ClientSoftwareVersion, "3.4.0");
 }
 
 TEST(Serialization, ApiVersionsResponse) {
@@ -85,59 +153,58 @@ TEST(Serialization, ApiVersionsResponse) {
 
     TApiVersionsResponseData value;
 
-    value.errorCode = 7;
+    value.ErrorCode = 7;
 
     {
         TApiVersionsResponseData::TApiVersion version;
-        version.apiKey = 11;
-        version.minVersion = 13;
-        version.maxVersion = 17;
+        version.ApiKey = 11;
+        version.MinVersion = 13;
+        version.MaxVersion = 17;
 
-        value.apiKeys.push_back(version);
+        value.ApiKeys.push_back(version);
     }
     {
         TApiVersionsResponseData::TApiVersion version;
-        version.apiKey = 33;
-        version.minVersion = 37;
-        version.maxVersion = 41;
+        version.ApiKey = 33;
+        version.MinVersion = 37;
+        version.MaxVersion = 41;
 
-        value.apiKeys.push_back(version);
+        value.ApiKeys.push_back(version);
     }
 
     TApiVersionsResponseData::TFinalizedFeatureKey finalizeFeature;
-    finalizeFeature.name = { longString };
-    finalizeFeature.maxVersionLevel = 19;
-    finalizeFeature.minVersionLevel = 23;
+    finalizeFeature.Name = { longString };
+    finalizeFeature.MaxVersionLevel = 19;
+    finalizeFeature.MinVersionLevel = 23;
 
-    value.finalizedFeatures.push_back(finalizeFeature);
-    value.finalizedFeaturesEpoch = 29;
+    value.FinalizedFeatures.push_back(finalizeFeature);
+    value.FinalizedFeaturesEpoch = 29;
 
-    value.throttleTimeMs = 31;
-    value.zkMigrationReady = true;
+    value.ThrottleTimeMs = 31;
+    value.ZkMigrationReady = true;
 
     TKafkaWritable writable(sb);
     value.Write(writable, 3);
 
+    TReadProcessor processor(sb);
     TApiVersionsResponseData result;
-
-    TKafkaReadable readable(sb);
-    result.Read(readable, 3);
-
-    EXPECT_EQ(result.errorCode, 7);
-    EXPECT_EQ(result.apiKeys.size(), 2ul);
-    EXPECT_EQ(result.apiKeys[0].apiKey, 11);
-    EXPECT_EQ(result.apiKeys[0].minVersion, 13);
-    EXPECT_EQ(result.apiKeys[0].maxVersion, 17);
-    EXPECT_EQ(result.apiKeys[1].apiKey, 33);
-    EXPECT_EQ(result.apiKeys[1].minVersion, 37);
-    EXPECT_EQ(result.apiKeys[1].maxVersion, 41);
-    EXPECT_EQ(result.finalizedFeatures.size(), 1ul);
-    EXPECT_EQ(*result.finalizedFeatures[0].name, longString);
-    EXPECT_EQ(result.finalizedFeatures[0].maxVersionLevel, 19);
-    EXPECT_EQ(result.finalizedFeatures[0].minVersionLevel, 23);
-    EXPECT_EQ(result.finalizedFeaturesEpoch, 29l);
-    EXPECT_EQ(result.throttleTimeMs, 31);
-    EXPECT_EQ(result.zkMigrationReady, true);
+    processor.Read(&result, 3);
+
+    EXPECT_EQ(result.ErrorCode, 7);
+    EXPECT_EQ(result.ApiKeys.size(), 2ul);
+    EXPECT_EQ(result.ApiKeys[0].ApiKey, 11);
+    EXPECT_EQ(result.ApiKeys[0].MinVersion, 13);
+    EXPECT_EQ(result.ApiKeys[0].MaxVersion, 17);
+    EXPECT_EQ(result.ApiKeys[1].ApiKey, 33);
+    EXPECT_EQ(result.ApiKeys[1].MinVersion, 37);
+    EXPECT_EQ(result.ApiKeys[1].MaxVersion, 41);
+    EXPECT_EQ(result.FinalizedFeatures.size(), 1ul);
+    EXPECT_EQ(*result.FinalizedFeatures[0].Name, longString);
+    EXPECT_EQ(result.FinalizedFeatures[0].MaxVersionLevel, 19);
+    EXPECT_EQ(result.FinalizedFeatures[0].MinVersionLevel, 23);
+    EXPECT_EQ(result.FinalizedFeaturesEpoch, 29l);
+    EXPECT_EQ(result.ThrottleTimeMs, 31);
+    EXPECT_EQ(result.ZkMigrationReady, true);
 }
 
 TEST(Serialization, ProduceRequest) {
@@ -148,51 +215,50 @@ TEST(Serialization, ProduceRequest) {
 
     TProduceRequestData value;
 
-    value.transactionalId = { "transactional-id-value-123456" };
-    value.acks = 3;
-    value.timeoutMs = 5;
-    value.topicData.resize(2);
-    value.topicData[0].name = "/it/is/some/topic/name";
-    value.topicData[0].partitionData.resize(2);
-    value.topicData[0].partitionData[0].index = 0;
-    value.topicData[0].partitionData[0].records = { TBuffer(data0, sizeof(data0)) };
-    value.topicData[0].partitionData[1].index = 1;
-    value.topicData[0].partitionData[1].records = {};
-    value.topicData[1].name = "/it/is/other/topic/name";
-    value.topicData[1].partitionData.resize(1);
-    value.topicData[1].partitionData[0].index = 0;
-    value.topicData[1].partitionData[0].records = { TBuffer(data1, sizeof(data1)) };
+    value.TransactionalId = { "transactional-id-value-123456" };
+    value.Acks = 3;
+    value.TimeoutMs = 5;
+    value.TopicData.resize(2);
+    value.TopicData[0].Name = "/it/is/some/topic/name";
+    value.TopicData[0].PartitionData.resize(2);
+    value.TopicData[0].PartitionData[0].Index = 0;
+    value.TopicData[0].PartitionData[0].Records = { TBuffer(data0, sizeof(data0)) };
+    value.TopicData[0].PartitionData[1].Index = 1;
+    value.TopicData[0].PartitionData[1].Records = {};
+    value.TopicData[1].Name = "/it/is/other/topic/name";
+    value.TopicData[1].PartitionData.resize(1);
+    value.TopicData[1].PartitionData[0].Index = 0;
+    value.TopicData[1].PartitionData[0].Records = { TBuffer(data1, sizeof(data1)) };
 
     TKafkaWritable writable(sb);
     value.Write(writable, 3);
 
-    TProduceRequestData result;
 
-    TKafkaReadable readable(sb);
-    result.Read(readable, 3);
-
-    EXPECT_TRUE(result.transactionalId);
-    EXPECT_EQ(*result.transactionalId, "transactional-id-value-123456" );
-    EXPECT_EQ(result.acks, 3);
-    EXPECT_EQ(result.timeoutMs, 5);
-    EXPECT_EQ(result.topicData.size(), 2ul);
-    EXPECT_TRUE(result.topicData[0].name);
-    EXPECT_EQ(*result.topicData[0].name, "/it/is/some/topic/name");
-    EXPECT_EQ(result.topicData[0].partitionData.size(), 2ul);
-    EXPECT_EQ(result.topicData[0].partitionData[0].index, 0);
-    EXPECT_TRUE(result.topicData[0].partitionData[0].records);
-    EXPECT_EQ(*result.topicData[0].partitionData[0].records, TBuffer(data0, sizeof(data0)));
-    EXPECT_EQ(result.topicData[0].partitionData[1].index, 1);
-    EXPECT_EQ(result.topicData[0].partitionData[1].records, std::nullopt);
-    EXPECT_TRUE(result.topicData[1].name);
-    EXPECT_EQ(*result.topicData[1].name, "/it/is/other/topic/name");
-    EXPECT_EQ(result.topicData[1].partitionData.size(), 1ul);
-    EXPECT_EQ(result.topicData[1].partitionData[0].index, 0);
-    EXPECT_TRUE(result.topicData[1].partitionData[0].records);
-    EXPECT_EQ(*result.topicData[1].partitionData[0].records, TBuffer(data1, sizeof(data1)));
+    TReadProcessor processor(sb);
+    TProduceRequestData result;
+    processor.Read(&result, 3);
+
+    EXPECT_TRUE(result.TransactionalId);
+    EXPECT_EQ(*result.TransactionalId, "transactional-id-value-123456" );
+    EXPECT_EQ(result.Acks, 3);
+    EXPECT_EQ(result.TimeoutMs, 5);
+    EXPECT_EQ(result.TopicData.size(), 2ul);
+    EXPECT_TRUE(result.TopicData[0].Name);
+    EXPECT_EQ(*result.TopicData[0].Name, "/it/is/some/topic/name");
+    EXPECT_EQ(result.TopicData[0].PartitionData.size(), 2ul);
+    EXPECT_EQ(result.TopicData[0].PartitionData[0].Index, 0);
+    EXPECT_TRUE(result.TopicData[0].PartitionData[0].Records);
+    EXPECT_EQ(*result.TopicData[0].PartitionData[0].Records, TBuffer(data0, sizeof(data0)));
+    EXPECT_EQ(result.TopicData[0].PartitionData[1].Index, 1);
+    EXPECT_EQ(result.TopicData[0].PartitionData[1].Records, std::nullopt);
+    EXPECT_TRUE(result.TopicData[1].Name);
+    EXPECT_EQ(*result.TopicData[1].Name, "/it/is/other/topic/name");
+    EXPECT_EQ(result.TopicData[1].PartitionData.size(), 1ul);
+    EXPECT_EQ(result.TopicData[1].PartitionData[0].Index, 0);
+    EXPECT_TRUE(result.TopicData[1].PartitionData[0].Records);
+    EXPECT_EQ(*result.TopicData[1].PartitionData[0].Records, TBuffer(data1, sizeof(data1)));
 }
 
-
 TEST(Serialization, UnsignedVarint) {
     std::vector<ui32> values = {0, 1, 127, 128, 32191};
 
@@ -213,9 +279,7 @@ TEST(Serialization, UnsignedVarint) {
                                                     \
     std::stringstream sb;                           \
     TKafkaWritable writable(sb);                    \
-    TKafkaReadable readable(sb);                    \
                                                     \
-    Y_UNUSED(readable);                             \
     Y_UNUSED(result);                               \
                                                     \
     NKafka::NPrivate::TWriteCollector collector;
@@ -251,38 +315,23 @@ TEST(Serialization, TKafkaInt8_NotPresentVersion) {
     EXPECT_TRUE(sb.eof()); // For version 0 value is not serializable. Stream must be empty
     EXPECT_EQ(collector.NumTaggedFields, 0u);
 
-    NKafka::NPrivate::Read<Meta_TKafkaInt8>(readable, 0, result);
-    EXPECT_EQ(result, Meta_TKafkaInt8::Default); // For version 0 value is not serializable
+    TFieldReadProcessor<Meta_TKafkaInt8> processor(sb);
+    processor.Read(value, 0);
+
+    //EXPECT_EQ(result, Meta_TKafkaInt8::Default); // For version 0 value is not serializable
 }
 
 TEST(Serialization, TKafkaInt8_PresentVersion_NotTaggedVersion) {
     SIMPLE_HEAD(TKafkaInt8, 37);
 
     NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 3, value);
-    NKafka::NPrivate::Read<Meta_TKafkaInt8>(readable, 3, result);
+    TFieldReadProcessor<Meta_TKafkaInt8> processor(sb);
+    processor.Read(result, 3);
 
     EXPECT_EQ(collector.NumTaggedFields, 0u);
     EXPECT_EQ(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaInt8_PresentVersion_TaggedVersion) {
-    SIMPLE_HEAD(TKafkaInt8, 37);
-
-    NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 1u);
-
-    NKafka::NPrivate::WriteTag<Meta_TKafkaInt8>(writable, 11, value);
-
-    i32 tag = readable.readUnsignedVarint();
-    EXPECT_EQ(tag, Meta_TKafkaInt8::Tag);
-
-    ui32 size = readable.readUnsignedVarint();
-    EXPECT_EQ(size, sizeof(TKafkaInt8));
-
-    NKafka::NPrivate::ReadTag<Meta_TKafkaInt8>(readable, 11, result);
-    EXPECT_EQ(result, value); // Must read same that write
-}
-
 TEST(Serialization, TKafkaInt8_PresentVersion_TaggedVersion_Default) {
     SIMPLE_HEAD(TKafkaInt8, Meta_TKafkaInt8::Default);
 
@@ -290,7 +339,6 @@ TEST(Serialization, TKafkaInt8_PresentVersion_TaggedVersion_Default) {
     EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
 }
 
-
 struct Meta_TKafkaStruct {
     using Type = TRequestHeaderData;
     using TypeDesc = NKafka::NPrivate::TKafkaStructDesc;
@@ -314,11 +362,10 @@ TEST(Serialization, Struct_IsDefault) {
     TRequestHeaderData value;
     EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaStruct>(value)); // all fields have default values
 
-    value.requestApiKey = 123;
+    value.RequestApiKey = 123;
     EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaStruct>(value)); // field changed
 }
 
-
 struct Meta_TKafkaString {
     using Type = TKafkaString;
     using TypeDesc = NKafka::NPrivate::TKafkaStringDesc;
@@ -355,30 +402,13 @@ TEST(Serialization, TKafkaString_PresentVersion_NotTaggedVersion) {
     SIMPLE_HEAD(TKafkaString, { "some value" });
 
     NKafka::NPrivate::Write<Meta_TKafkaString>(collector, writable, 3, value);
-    NKafka::NPrivate::Read<Meta_TKafkaString>(readable, 3, result);
+    TFieldReadProcessor<Meta_TKafkaString> processor(sb);
+    processor.Read(result, 3);
 
     EXPECT_EQ(collector.NumTaggedFields, 0u);
     EXPECT_EQ(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaString_PresentVersion_TaggedVersion) {
-    SIMPLE_HEAD(TKafkaString, { "some value" });
-
-    NKafka::NPrivate::Write<Meta_TKafkaString>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 1u);
-
-    NKafka::NPrivate::WriteTag<Meta_TKafkaString>(writable, 11, value);
-
-    i32 tag = readable.readUnsignedVarint();
-    EXPECT_EQ(tag, Meta_TKafkaString::Tag);
-
-    ui32 size = readable.readUnsignedVarint();
-    EXPECT_EQ(size, value->size() + NKafka::NPrivate::SizeOfUnsignedVarint(value->size() + 1)); // "+1" because serialized as unsigned int, and null serialized with size equals 0
-
-    NKafka::NPrivate::ReadTag<Meta_TKafkaString>(readable, 11, result);
-    EXPECT_EQ(result, value); // Must read same that write
-}
-
 TEST(Serialization, TKafkaString_PresentVersion_TaggedVersion_Default) {
     SIMPLE_HEAD(TKafkaInt8, Meta_TKafkaInt8::Default);
 
@@ -387,10 +417,11 @@ TEST(Serialization, TKafkaString_PresentVersion_TaggedVersion_Default) {
 }
 
 
-
 struct Meta_TKafkaArray {
     using Type = std::vector<TKafkaString>;
     using TypeDesc = NKafka::NPrivate::TKafkaArrayDesc;
+    using ItemType = TKafkaString;
+    using ItemTypeDesc = NKafka::NPrivate::TKafkaStringDesc;
 
     static constexpr const char* Name = "value";
     static constexpr const char* About = "The test field.";
@@ -418,34 +449,13 @@ TEST(Serialization, TKafkaArray_PresentVersion_NotTaggedVersion) {
     SIMPLE_HEAD(TKafkaArray, { "some value" });
 
     NKafka::NPrivate::Write<Meta_TKafkaArray>(collector, writable, 3, value);
-    NKafka::NPrivate::Read<Meta_TKafkaArray>(readable, 3, result);
+    TFieldReadProcessor<Meta_TKafkaArray> processor(sb);
+    processor.Read(result, 3);
 
     EXPECT_EQ(collector.NumTaggedFields, 0u);
     EXPECT_EQ(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaArray_PresentVersion_TaggedVersion) {
-    TString v = "some value";
-    SIMPLE_HEAD(TKafkaArray, { v });
-
-    NKafka::NPrivate::Write<Meta_TKafkaArray>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 1u);
-
-    NKafka::NPrivate::WriteTag<Meta_TKafkaArray>(writable, 11, value);
-
-    i32 tag = readable.readUnsignedVarint();
-    EXPECT_EQ(tag, Meta_TKafkaArray::Tag);
-
-    ui32 size = readable.readUnsignedVarint();
-    EXPECT_EQ(size, v.length() // array element data
-        + NKafka::NPrivate::SizeOfUnsignedVarint(value.size()) // array size
-        + NKafka::NPrivate::SizeOfUnsignedVarint(v.length() + 1) // string size. +1 because null string serialize as 0-length
-    );
-
-    NKafka::NPrivate::ReadTag<Meta_TKafkaArray>(readable, 11, result);
-    EXPECT_EQ(result, value); // Must read same that write
-}
-
 TEST(Serialization, TKafkaArray_PresentVersion_TaggedVersion_Default) {
     SIMPLE_HEAD(TKafkaArray, {});
 
@@ -486,32 +496,13 @@ TEST(Serialization, TKafkaBytes_PresentVersion_NotTaggedVersion) {
     SIMPLE_HEAD(TKafkaBytes, TBuffer("0123456789", 10));
 
     NKafka::NPrivate::Write<Meta_TKafkaBytes>(collector, writable, 3, value);
-    NKafka::NPrivate::Read<Meta_TKafkaBytes>(readable, 3, result);
+    TFieldReadProcessor<Meta_TKafkaBytes> processor(sb);
+    processor.Read(result, 3);
 
     EXPECT_EQ(collector.NumTaggedFields, 0u);
     EXPECT_EQ(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaBytes_PresentVersion_TaggedVersion) {
-    SIMPLE_HEAD(TKafkaBytes, TBuffer("0123456789", 10));
-
-    NKafka::NPrivate::Write<Meta_TKafkaBytes>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 1u);
-
-    NKafka::NPrivate::WriteTag<Meta_TKafkaBytes>(writable, 11, value);
-
-    i32 tag = readable.readUnsignedVarint();
-    EXPECT_EQ(tag, Meta_TKafkaArray::Tag);
-
-    ui32 size = readable.readUnsignedVarint();
-    EXPECT_EQ(size, value->size() // byffer data
-        + NKafka::NPrivate::SizeOfUnsignedVarint(value->size() + 1) // buffer size. +1 because null value stored as size 0
-    );
-
-    NKafka::NPrivate::ReadTag<Meta_TKafkaBytes>(readable, 11, result);
-    EXPECT_EQ(result, value); // Must read same that write
-}
-
 TEST(Serialization, TKafkaBytes_PresentVersion_TaggedVersion_Default) {
     SIMPLE_HEAD(TKafkaBytes, std::nullopt);
 
@@ -522,17 +513,17 @@ TEST(Serialization, TKafkaBytes_PresentVersion_TaggedVersion_Default) {
 
 TEST(Serialization, TRequestHeaderData_reference) {
     // original kafka serialized value (java implementation)
-    ui8 reference[] = {0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x10, 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x2D, 0x69, 0x64, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x00};
+    ui8 reference[] = {0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x10, 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74,
+                       0x2D, 0x69, 0x64, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x00};
 
     std::stringstream sb;
     TKafkaWritable writable(sb);
-    TKafkaReadable readable(sb);
 
     TRequestHeaderData value;
-    value.requestApiKey = 3;
-    value.requestApiVersion = 7;
-    value.correlationId = 13;
-    value.clientId = "client-id-string";
+    value.RequestApiKey = 3;
+    value.RequestApiVersion = 7;
+    value.CorrelationId = 13;
+    value.ClientId = "client-id-string";
 
     value.Write(writable, 2);
 
@@ -543,12 +534,14 @@ TEST(Serialization, TRequestHeaderData_reference) {
 
     sb.write((char*)reference, sizeof(reference));
 
+    TReadProcessor processor(sb);
     TRequestHeaderData result;
-    result.Read(readable, 2);
-    EXPECT_EQ(result.requestApiKey, 3);
-    EXPECT_EQ(result.requestApiVersion, 7);
-    EXPECT_EQ(result.correlationId, 13);
-    EXPECT_EQ(result.clientId, "client-id-string");
+    processor.Read(&result, 2);
+
+    EXPECT_EQ(result.RequestApiKey, 3);
+    EXPECT_EQ(result.RequestApiVersion, 7);
+    EXPECT_EQ(result.CorrelationId, 13);
+    EXPECT_EQ(result.ClientId, "client-id-string");
 }
 
 struct Meta_TKafkaFloat64 {
@@ -579,7 +572,8 @@ TEST(Serialization, TKafkaFloat64_PresentVersion_NotTaggedVersion) {
     SIMPLE_HEAD(TKafkaFloat64, 3.1415);
 
     NKafka::NPrivate::Write<Meta_TKafkaFloat64>(collector, writable, 3, value);
-    NKafka::NPrivate::Read<Meta_TKafkaFloat64>(readable, 3, result);
+    TFieldReadProcessor<Meta_TKafkaFloat64> processor(sb);
+    processor.Read(result, 3);
 
     EXPECT_EQ(collector.NumTaggedFields, 0u);
     EXPECT_EQ(result, value); // Must read same that write
@@ -591,6 +585,8 @@ TEST(Serialization, TKafkaFloat64_PresentVersion_NotTaggedVersion) {
     }
 }
 
+
+
 TEST(Serialization, ProduceRequestData_reference) {
     // original kafka serialized value (java implementation)
     ui8 reference[] = {0x02, 0x37, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x03, 0x0D, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74,
@@ -606,19 +602,19 @@ TEST(Serialization, ProduceRequestData_reference) {
     TKafkaReadable readable(sb);
 
     TProduceRequestData value;
-    value.acks = 3;
-    value.timeoutMs = 5;
-    value.transactionalId = "7";
+    value.Acks = 3;
+    value.TimeoutMs = 5;
+    value.TransactionalId = "7";
 
-    value.topicData.resize(2);
-    value.topicData[0].name = "partition-11";
-    value.topicData[0].partitionData.resize(3);
-    value.topicData[0].partitionData[0].index = 13;
-    value.topicData[0].partitionData[0].records = TKafkaRawBytes("record-13-it-is-kafka-bytes", 27);
-    value.topicData[0].partitionData[1].index = 17;
-    value.topicData[0].partitionData[1].records = TKafkaRawBytes("record-17-it-is-kafka-bytes", 27);
+    value.TopicData.resize(2);
+    value.TopicData[0].Name = "partition-11";
+    value.TopicData[0].PartitionData.resize(3);
+    value.TopicData[0].PartitionData[0].Index = 13;
+    value.TopicData[0].PartitionData[0].Records = TKafkaRawBytes("record-13-it-is-kafka-bytes", 27);
+    value.TopicData[0].PartitionData[1].Index = 17;
+    value.TopicData[0].PartitionData[1].Records = TKafkaRawBytes("record-17-it-is-kafka-bytes", 27);
 
-    value.topicData[1].name = "partition-23";
+    value.TopicData[1].Name = "partition-23";
 
     value.Write(writable, 9);
 
@@ -631,41 +627,39 @@ TEST(Serialization, ProduceRequestData_reference) {
 
     sb.write((char*)reference, sizeof(reference));
 
+    TReadProcessor processor(sb);
     TProduceRequestData result;
-    result.Read(readable, 9);
-
-    EXPECT_EQ(result.acks, 3);
-    EXPECT_EQ(result.timeoutMs, 5);
-    EXPECT_EQ(result.transactionalId, "7");
-
-    EXPECT_EQ(result.topicData.size(), 2ul);
-    EXPECT_EQ(result.topicData[0].name, "partition-11");
-    EXPECT_EQ(result.topicData[0].partitionData.size(), 3ul);
-    EXPECT_EQ(result.topicData[0].partitionData[0].index, 13);
-    EXPECT_EQ(result.topicData[0].partitionData[0].records, TKafkaRawBytes("record-13-it-is-kafka-bytes", 27));
-    EXPECT_EQ(result.topicData[0].partitionData[1].index, 17);
-    EXPECT_EQ(result.topicData[0].partitionData[1].records, TKafkaRawBytes("record-17-it-is-kafka-bytes", 27));
-    EXPECT_EQ(result.topicData[0].partitionData[2].index, 0);
-    EXPECT_EQ(result.topicData[0].partitionData[2].records, std::nullopt);
-
-    EXPECT_EQ(result.topicData[1].name, "partition-23");
-    EXPECT_EQ(result.topicData[1].partitionData.size(), 0ul);
+    processor.Read(&result, 9);
+
+    EXPECT_EQ(result.Acks, 3);
+    EXPECT_EQ(result.TimeoutMs, 5);
+    EXPECT_EQ(result.TransactionalId, "7");
+
+    EXPECT_EQ(result.TopicData.size(), 2ul);
+    EXPECT_EQ(result.TopicData[0].Name, "partition-11");
+    EXPECT_EQ(result.TopicData[0].PartitionData.size(), 3ul);
+    EXPECT_EQ(result.TopicData[0].PartitionData[0].Index, 13);
+    EXPECT_EQ(result.TopicData[0].PartitionData[0].Records, TKafkaRawBytes("record-13-it-is-kafka-bytes", 27));
+    EXPECT_EQ(result.TopicData[0].PartitionData[1].Index, 17);
+    EXPECT_EQ(result.TopicData[0].PartitionData[1].Records, TKafkaRawBytes("record-17-it-is-kafka-bytes", 27));
+    EXPECT_EQ(result.TopicData[0].PartitionData[2].Index, 0);
+    EXPECT_EQ(result.TopicData[0].PartitionData[2].Records, std::nullopt);
+
+    EXPECT_EQ(result.TopicData[1].Name, "partition-23");
+    EXPECT_EQ(result.TopicData[1].PartitionData.size(), 0ul);
 }
 
-
 char Hex(const unsigned char c) {
     return c < 10 ? '0' + c : 'A' + c - 10;
 }
 
-void Print(std::stringstream& sb) {
-    while(true) {
-        char c = sb.get();
-        if (sb.eof()) {
-            break;
+void Print(std::string& sb) {
+    for(size_t i = 0; i < sb.length(); ++i) {
+        char c = sb.at(i);
+        if (i > 0) {
+            Cerr << ", ";
         }
-        Cerr << ", 0x" << Hex(c >> 4) << Hex(c & 0x0F);
+        Cerr << "0x" << Hex(c >> 4) << Hex(c & 0x0F);
     }
     Cerr << Endl;
-
-    sb.seekg(-sb.tellg());
 }