Merge branch 'rightlib' into mergelibs-240325-1123

16 files changed, 1233 insertions, 88 deletions

diff --git a/library/cpp/monlib/encode/prometheus/prometheus.h b/library/cpp/monlib/encode/prometheus/prometheus.h
index 2e7fa31c28c..c6982996990 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus.h
+++ b/library/cpp/monlib/encode/prometheus/prometheus.h
@@ -11,8 +11,17 @@ namespace NMonitoring {
     class TPrometheusDecodeException: public yexception {
     };
 
+    enum class EPrometheusDecodeMode {
+        DEFAULT,
+        RAW
+    };
+
+    struct TPrometheusDecodeSettings {
+        EPrometheusDecodeMode Mode{EPrometheusDecodeMode::DEFAULT};
+    };
+
     IMetricEncoderPtr EncoderPrometheus(IOutputStream* out, TStringBuf metricNameLabel = "sensor");
 
-    void DecodePrometheus(TStringBuf data, IMetricConsumer* c, TStringBuf metricNameLabel = "sensor");
+    void DecodePrometheus(TStringBuf data, IMetricConsumer* c, TStringBuf metricNameLabel = "sensor", const TPrometheusDecodeSettings& settings = TPrometheusDecodeSettings{});
 
 }
diff --git a/library/cpp/monlib/encode/prometheus/prometheus_decoder.cpp b/library/cpp/monlib/encode/prometheus/prometheus_decoder.cpp
index d1d0d9e0f22..313651ba8fa 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus_decoder.cpp
+++ b/library/cpp/monlib/encode/prometheus/prometheus_decoder.cpp
@@ -71,6 +71,9 @@ namespace NMonitoring {
             using TBucketData = std::pair<TBucketBound, TBucketValue>;
             constexpr static TBucketData ZERO_BUCKET = { -std::numeric_limits<TBucketBound>::max(), 0 };
         public:
+            THistogramBuilder(TPrometheusDecodeSettings settings)
+                : Settings_(settings) {
+            }
             TStringBuf GetName() const noexcept {
                 return Name_;
             }
@@ -125,7 +128,6 @@ namespace NMonitoring {
 
                 Bounds_.push_back(bound);
                 Values_.push_back(value - PrevBucket_.second); // keep only delta between buckets
-
                 PrevBucket_ = { bound, value };
             }
 
@@ -150,6 +152,7 @@ namespace NMonitoring {
             TBucketBounds Bounds_;
             TBucketValues Values_;
             TBucketData PrevBucket_ = ZERO_BUCKET;
+            TPrometheusDecodeSettings Settings_;
         };
 
         ///////////////////////////////////////////////////////////////////////
@@ -168,10 +171,12 @@ namespace NMonitoring {
         ///////////////////////////////////////////////////////////////////////
         class TPrometheusReader {
         public:
-            TPrometheusReader(TStringBuf data, IMetricConsumer* c, TStringBuf metricNameLabel)
+            TPrometheusReader(TStringBuf data, IMetricConsumer* c, TStringBuf metricNameLabel, const TPrometheusDecodeSettings& settings = TPrometheusDecodeSettings{})
                 : Data_(data)
                 , Consumer_(c)
                 , MetricNameLabel_(metricNameLabel)
+                , Settings_(settings)
+                , HistogramBuilder_(settings)
             {
             }
 
@@ -272,12 +277,14 @@ namespace NMonitoring {
                 TStringBuf baseName = name;
                 EPrometheusMetricType type = EPrometheusMetricType::UNTYPED;
 
-                if (auto* seenType = SeenTypes_.FindPtr(name)) {
-                    type = *seenType;
-                } else {
-                    baseName = NPrometheus::ToBaseName(name);
-                    if (auto* baseType = SeenTypes_.FindPtr(baseName)) {
-                        type = *baseType;
+                if (Settings_.Mode != EPrometheusDecodeMode::RAW) {
+                    if (auto* seenType = SeenTypes_.FindPtr(name)) {
+                        type = *seenType;
+                    } else {
+                        baseName = NPrometheus::ToBaseName(name);
+                        if (auto* baseType = SeenTypes_.FindPtr(baseName)) {
+                            type = *baseType;
+                        }
                     }
                 }
 
@@ -584,6 +591,7 @@ namespace NMonitoring {
             TStringBuf Data_;
             IMetricConsumer* Consumer_;
             TStringBuf MetricNameLabel_;
+            TPrometheusDecodeSettings Settings_;
             THashMap<TString, EPrometheusMetricType> SeenTypes_;
             THistogramBuilder HistogramBuilder_;
 
@@ -593,8 +601,8 @@ namespace NMonitoring {
         };
     } // namespace
 
-void DecodePrometheus(TStringBuf data, IMetricConsumer* c, TStringBuf metricNameLabel) {
-    TPrometheusReader reader(data, c, metricNameLabel);
+void DecodePrometheus(TStringBuf data, IMetricConsumer* c, TStringBuf metricNameLabel, const TPrometheusDecodeSettings& settings) {
+    TPrometheusReader reader(data, c, metricNameLabel, settings);
     reader.Read();
 }
 
diff --git a/library/cpp/monlib/encode/prometheus/prometheus_decoder_ut.cpp b/library/cpp/monlib/encode/prometheus/prometheus_decoder_ut.cpp
index 49c2244fb4e..9299076f933 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus_decoder_ut.cpp
+++ b/library/cpp/monlib/encode/prometheus/prometheus_decoder_ut.cpp
@@ -36,11 +36,12 @@ using namespace NMonitoring;
 
 Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
 
-    NProto::TSingleSamplesList Decode(TStringBuf data) {
+    NProto::TSingleSamplesList Decode(TStringBuf data, const TPrometheusDecodeSettings& settings = TPrometheusDecodeSettings{}) {
         NProto::TSingleSamplesList samples;
+        ;
         {
             IMetricEncoderPtr e = EncoderProtobuf(&samples);
-            DecodePrometheus(data, e.Get());
+            DecodePrometheus(data, e.Get(), "sensor", settings);
         }
         return samples;
     }
@@ -97,33 +98,61 @@ Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
     }
 
     Y_UNIT_TEST(Counter) {
-        auto samples = Decode(
-                "# A normal comment.\n"
-                "#\n"
-                "# TYPE name counter\n"
-                "name{labelname=\"val1\",basename=\"basevalue\"} NaN\n"
-                "name {labelname=\"val2\",basename=\"basevalue\"} 2.3 1234567890\n"
-                "# HELP name two-line\\n doc  str\\\\ing\n");
-
-        UNIT_ASSERT_EQUAL(samples.SamplesSize(), 2);
-
-        {
-            auto& s = samples.GetSamples(0);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::RATE);
-            UNIT_ASSERT_EQUAL(s.LabelsSize(), 3);
-            ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
-            ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
-            ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val1");
-            ASSERT_UINT_POINT(s, TInstant::Zero(), ui64(0));
-        }
-        {
-            auto& s = samples.GetSamples(1);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::RATE);
-            UNIT_ASSERT_EQUAL(s.LabelsSize(), 3);
-            ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
-            ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
-            ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val2");
-            ASSERT_UINT_POINT(s, TInstant::MilliSeconds(1234567890), i64(2));
+        constexpr auto inputMetrics =
+            "# A normal comment.\n"
+            "#\n"
+            "# TYPE name counter\n"
+            "name{labelname=\"val1\",basename=\"basevalue\"} NaN\n"
+            "name {labelname=\"val2\",basename=\"basevalue\"} 2.3 1234567890\n"
+            "# HELP name two-line\\n doc  str\\\\ing\n";
+
+        {
+            auto samples = Decode(inputMetrics);
+            UNIT_ASSERT_EQUAL(samples.SamplesSize(), 2);
+
+            {
+                auto& s = samples.GetSamples(0);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::RATE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 3);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
+                ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
+                ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val1");
+                ASSERT_UINT_POINT(s, TInstant::Zero(), ui64(0));
+            }
+            {
+                auto& s = samples.GetSamples(1);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::RATE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 3);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
+                ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
+                ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val2");
+                ASSERT_UINT_POINT(s, TInstant::MilliSeconds(1234567890), i64(2));
+            }
+        }
+        {
+            TPrometheusDecodeSettings settings;
+            settings.Mode = EPrometheusDecodeMode::RAW;
+            auto samples = Decode(inputMetrics, settings);
+            UNIT_ASSERT_EQUAL(samples.SamplesSize(), 2);
+
+            {
+                auto& s = samples.GetSamples(0);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 3);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
+                ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
+                ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val1");
+                ASSERT_DOUBLE_POINT(s, TInstant::MilliSeconds(0), NAN);
+            }
+            {
+                auto& s = samples.GetSamples(1);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 3);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
+                ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
+                ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val2");
+                ASSERT_DOUBLE_POINT(s, TInstant::MilliSeconds(1234567890), 2.3);
+            }
         }
     }
 
@@ -210,43 +239,58 @@ Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
     }
 
     Y_UNIT_TEST(Histogram) {
-        auto samples = Decode(
-                "# HELP request_duration_microseconds The response latency.\n"
-                "# TYPE request_duration_microseconds histogram\n"
-                "request_duration_microseconds_bucket{le=\"0\"} 0\n"
-                "request_duration_microseconds_bucket{le=\"100\"} 123\n"
-                "request_duration_microseconds_bucket{le=\"120\"} 412\n"
-                "request_duration_microseconds_bucket{le=\"144\"} 592\n"
-                "request_duration_microseconds_bucket{le=\"172.8\"} 1524\n"
-                "request_duration_microseconds_bucket{le=\"+Inf\"} 2693\n"
-                "request_duration_microseconds_sum 1.7560473e+06\n"
-                "request_duration_microseconds_count 2693\n");
-
-        UNIT_ASSERT_EQUAL(samples.SamplesSize(), 3);
-
-        {
-            auto& s = samples.GetSamples(0);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
-            UNIT_ASSERT_EQUAL(s.LabelsSize(), 1);
-            ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "request_duration_microseconds_sum");
-            ASSERT_DOUBLE_POINT(s, TInstant::Zero(), 1756047.3);
-        }
-        {
-            auto& s = samples.GetSamples(1);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::RATE);
-            UNIT_ASSERT_EQUAL(s.LabelsSize(), 1);
-            ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "request_duration_microseconds_count");
-            ASSERT_UINT_POINT(s, TInstant::Zero(), 2693);
-        }
-        {
-            auto& s = samples.GetSamples(2);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::HIST_RATE);
-            UNIT_ASSERT_EQUAL(s.LabelsSize(), 1);
-            ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "request_duration_microseconds");
-            auto hist = ExplicitHistogramSnapshot(
-                    { 0, 100, 120, 144, 172.8, HISTOGRAM_INF_BOUND },
-                    { 0, 123, 289, 180, 932, 1169 });
-            ASSERT_HIST_POINT(s, TInstant::Zero(), *hist);
+        constexpr auto inputMetrics =
+            "# HELP request_duration_microseconds The response latency.\n"
+            "# TYPE request_duration_microseconds histogram\n"
+            "request_duration_microseconds_bucket{le=\"0\"} 0\n"
+            "request_duration_microseconds_bucket{le=\"100\"} 123\n"
+            "request_duration_microseconds_bucket{le=\"120\"} 412\n"
+            "request_duration_microseconds_bucket{le=\"144\"} 592\n"
+            "request_duration_microseconds_bucket{le=\"172.8\"} 1524\n"
+            "request_duration_microseconds_bucket{le=\"+Inf\"} 2693\n"
+            "request_duration_microseconds_sum 1.7560473e+06\n"
+            "request_duration_microseconds_count 2693\n";
+
+        {
+            auto samples = Decode(inputMetrics);
+            {
+                auto& s = samples.GetSamples(0);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 1);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "request_duration_microseconds_sum");
+                ASSERT_DOUBLE_POINT(s, TInstant::Zero(), 1756047.3);
+            }
+            {
+                auto& s = samples.GetSamples(1);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::RATE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 1);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "request_duration_microseconds_count");
+                ASSERT_UINT_POINT(s, TInstant::Zero(), 2693);
+            }
+            {
+                auto& s = samples.GetSamples(2);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::HIST_RATE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 1);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "request_duration_microseconds");
+                auto hist = ExplicitHistogramSnapshot(
+                    {0, 100, 120, 144, 172.8, HISTOGRAM_INF_BOUND},
+                    {0, 123, 289, 180, 932, 1169});
+                ASSERT_HIST_POINT(s, TInstant::Zero(), *hist);
+            }
+        }
+        {
+            TPrometheusDecodeSettings settings;
+            settings.Mode = EPrometheusDecodeMode::RAW;
+            auto samples = Decode(inputMetrics, settings);
+            UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 8);
+            {
+                auto& s = samples.GetSamples(0);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
+                UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "request_duration_microseconds_bucket");
+                ASSERT_LABEL_EQUAL(s.GetLabels(1), "le", "0");
+                ASSERT_DOUBLE_POINT(s, TInstant::Zero(), 0);
+            }
         }
     }
 
diff --git a/library/cpp/monlib/encode/prometheus/ya.make b/library/cpp/monlib/encode/prometheus/ya.make
index c43e4c5e882..0d008404c3a 100644
--- a/library/cpp/monlib/encode/prometheus/ya.make
+++ b/library/cpp/monlib/encode/prometheus/ya.make
@@ -10,6 +10,8 @@ PEERDIR(
     library/cpp/monlib/encode/buffered
 )
 
+GENERATE_ENUM_SERIALIZATION_WITH_HEADER(prometheus.h)
+
 END()
 
 RECURSE(
diff --git a/library/cpp/tld/tlds-alpha-by-domain.txt b/library/cpp/tld/tlds-alpha-by-domain.txt
index 751a75c74da..f723a347349 100644
--- a/library/cpp/tld/tlds-alpha-by-domain.txt
+++ b/library/cpp/tld/tlds-alpha-by-domain.txt
@@ -1,4 +1,4 @@
-# Version 2024030100, Last Updated Fri Mar  1 07:07:01 2024 UTC
+# Version 2024032200, Last Updated Fri Mar 22 07:07:01 2024 UTC
 AAA
 AARP
 ABB
@@ -510,7 +510,6 @@ GROUP
 GS
 GT
 GU
-GUARDIAN
 GUCCI
 GUGE
 GUIDE
diff --git a/library/cpp/type_info/fwd.h b/library/cpp/type_info/fwd.h
index 644932f677b..127bbbeebea 100644
--- a/library/cpp/type_info/fwd.h
+++ b/library/cpp/type_info/fwd.h
@@ -100,6 +100,18 @@ namespace NTi {
     class TUuidType;
     using TUuidTypePtr = TIntrusiveConstPtr<TUuidType>;
 
+    class TDate32Type;
+    using TDate32TypePtr = TIntrusiveConstPtr<TDate32Type>;
+
+    class TDatetime64Type;
+    using TDatetime64TypePtr = TIntrusiveConstPtr<TDatetime64Type>;
+
+    class TTimestamp64Type;
+    using TTimestamp64TypePtr = TIntrusiveConstPtr<TTimestamp64Type>;
+
+    class TInterval64Type;
+    using TInterval64TypePtr = TIntrusiveConstPtr<TInterval64Type>;
+
     class TOptionalType;
     using TOptionalTypePtr = TIntrusiveConstPtr<TOptionalType>;
 
diff --git a/library/cpp/type_info/type.cpp b/library/cpp/type_info/type.cpp
index fb084fa18b3..9197f31f2f7 100644
--- a/library/cpp/type_info/type.cpp
+++ b/library/cpp/type_info/type.cpp
@@ -864,6 +864,98 @@ namespace NTi {
         Y_UNUSED(factory);
     }
 
+    TDate32Type::TDate32Type()
+        : TPrimitiveType({}, EPrimitiveTypeName::Date32)
+    {
+    }
+
+    TDate32TypePtr TDate32Type::Instance() {
+        return InstanceRaw()->AsPtr();
+    }
+
+    const TDate32Type* TDate32Type::InstanceRaw() {
+        static auto singleton = TDate32Type();
+        return &singleton;
+    }
+
+    const TDate32Type* TDate32Type::Clone(ITypeFactoryInternal& factory) const noexcept {
+        Y_UNUSED(factory);
+        return InstanceRaw();
+    }
+
+    void TDate32Type::Drop(ITypeFactoryInternal& factory) noexcept {
+        Y_UNUSED(factory);
+    }
+
+    TDatetime64Type::TDatetime64Type()
+        : TPrimitiveType({}, EPrimitiveTypeName::Datetime64)
+    {
+    }
+
+    TDatetime64TypePtr TDatetime64Type::Instance() {
+        return InstanceRaw()->AsPtr();
+    }
+
+    const TDatetime64Type* TDatetime64Type::InstanceRaw() {
+        static auto singleton = TDatetime64Type();
+        return &singleton;
+    }
+
+    const TDatetime64Type* TDatetime64Type::Clone(ITypeFactoryInternal& factory) const noexcept {
+        Y_UNUSED(factory);
+        return InstanceRaw();
+    }
+
+    void TDatetime64Type::Drop(ITypeFactoryInternal& factory) noexcept {
+        Y_UNUSED(factory);
+    }
+
+    TTimestamp64Type::TTimestamp64Type()
+        : TPrimitiveType({}, EPrimitiveTypeName::Timestamp64)
+    {
+    }
+
+    TTimestamp64TypePtr TTimestamp64Type::Instance() {
+        return InstanceRaw()->AsPtr();
+    }
+
+    const TTimestamp64Type* TTimestamp64Type::InstanceRaw() {
+        static auto singleton = TTimestamp64Type();
+        return &singleton;
+    }
+
+    const TTimestamp64Type* TTimestamp64Type::Clone(ITypeFactoryInternal& factory) const noexcept {
+        Y_UNUSED(factory);
+        return InstanceRaw();
+    }
+
+    void TTimestamp64Type::Drop(ITypeFactoryInternal& factory) noexcept {
+        Y_UNUSED(factory);
+    }
+
+    TInterval64Type::TInterval64Type()
+        : TPrimitiveType({}, EPrimitiveTypeName::Interval64)
+    {
+    }
+
+    TInterval64TypePtr TInterval64Type::Instance() {
+        return InstanceRaw()->AsPtr();
+    }
+
+    const TInterval64Type* TInterval64Type::InstanceRaw() {
+        static auto singleton = TInterval64Type();
+        return &singleton;
+    }
+
+    const TInterval64Type* TInterval64Type::Clone(ITypeFactoryInternal& factory) const noexcept {
+        Y_UNUSED(factory);
+        return InstanceRaw();
+    }
+
+    void TInterval64Type::Drop(ITypeFactoryInternal& factory) noexcept {
+        Y_UNUSED(factory);
+    }
+
     TOptionalType::TOptionalType(TMaybe<ui64> hash, const TType* item) noexcept
         : TType(hash, ETypeName::Optional)
         , Item_(item)
@@ -1371,6 +1463,22 @@ namespace NTi {
         return NPrivate::GetDefaultHeapFactory()->Uuid();
     }
 
+    TDate32TypePtr Date32() {
+        return NPrivate::GetDefaultHeapFactory()->Date32();
+    }
+
+    TDatetime64TypePtr Datetime64() {
+        return NPrivate::GetDefaultHeapFactory()->Datetime64();
+    }
+
+    TTimestamp64TypePtr Timestamp64() {
+        return NPrivate::GetDefaultHeapFactory()->Timestamp64();
+    }
+
+    TInterval64TypePtr Interval64() {
+        return NPrivate::GetDefaultHeapFactory()->Interval64();
+    }
+
     TOptionalTypePtr Optional(TTypePtr item) {
         return NPrivate::GetDefaultHeapFactory()->Optional(std::move(item));
     }
@@ -1549,6 +1657,26 @@ Y_DECLARE_OUT_SPEC(, NTi::TUuidType, o, v) {
     o << "Uuid";
 }
 
+Y_DECLARE_OUT_SPEC(, NTi::TDate32Type, o, v) {
+    Y_UNUSED(v);
+    o << "Date32";
+}
+
+Y_DECLARE_OUT_SPEC(, NTi::TDatetime64Type, o, v) {
+    Y_UNUSED(v);
+    o << "Datetime64";
+}
+
+Y_DECLARE_OUT_SPEC(, NTi::TTimestamp64Type, o, v) {
+    Y_UNUSED(v);
+    o << "Timestamp64";
+}
+
+Y_DECLARE_OUT_SPEC(, NTi::TInterval64Type, o, v) {
+    Y_UNUSED(v);
+    o << "Interval64";
+}
+
 Y_DECLARE_OUT_SPEC(, NTi::TOptionalType, o, v) {
     o << "Optional<" << *v.GetItemTypeRaw() << ">";
 }
@@ -1651,6 +1779,10 @@ static_assert(std::is_trivially_destructible_v<NTi::TDecimalType>);
 static_assert(std::is_trivially_destructible_v<NTi::TJsonType>);
 static_assert(std::is_trivially_destructible_v<NTi::TYsonType>);
 static_assert(std::is_trivially_destructible_v<NTi::TUuidType>);
+static_assert(std::is_trivially_destructible_v<NTi::TDate32Type>);
+static_assert(std::is_trivially_destructible_v<NTi::TDatetime64Type>);
+static_assert(std::is_trivially_destructible_v<NTi::TTimestamp64Type>);
+static_assert(std::is_trivially_destructible_v<NTi::TInterval64Type>);
 static_assert(std::is_trivially_destructible_v<NTi::TOptionalType>);
 static_assert(std::is_trivially_destructible_v<NTi::TListType>);
 static_assert(std::is_trivially_destructible_v<NTi::TDictType>);
diff --git a/library/cpp/type_info/type.h b/library/cpp/type_info/type.h
index ea148c364d8..0176e4ce237 100644
--- a/library/cpp/type_info/type.h
+++ b/library/cpp/type_info/type.h
@@ -171,6 +171,22 @@ namespace NTi {
         inline TUuidTypePtr AsUuid() const noexcept;
         inline const TUuidType* AsUuidRaw() const noexcept;
 
+        inline bool IsDate32() const noexcept;
+        inline TDate32TypePtr AsDate32() const noexcept;
+        inline const TDate32Type* AsDate32Raw() const noexcept;
+
+        inline bool IsDatetime64() const noexcept;
+        inline TDatetime64TypePtr AsDatetime64() const noexcept;
+        inline const TDatetime64Type* AsDatetime64Raw() const noexcept;
+
+        inline bool IsTimestamp64() const noexcept;
+        inline TTimestamp64TypePtr AsTimestamp64() const noexcept;
+        inline const TTimestamp64Type* AsTimestamp64Raw() const noexcept;
+
+        inline bool IsInterval64() const noexcept;
+        inline TInterval64TypePtr AsInterval64() const noexcept;
+        inline const TInterval64Type* AsInterval64Raw() const noexcept;
+
         inline bool IsOptional() const noexcept;
         inline TOptionalTypePtr AsOptional() const noexcept;
         inline const TOptionalType* AsOptionalRaw() const noexcept;
@@ -952,7 +968,7 @@ namespace NTi {
         void Drop(ITypeFactoryInternal& factory) noexcept;
     };
 
-    /// An absolute point in time in range `[1970-01-01, 2106-01-01)`, precision up to microseconds.
+    /// An absolute point in time in range `[1970-01-01, 2106-01-01)`, precision up to milliseconds.
     class TTimestampType final: public TPrimitiveType {
         friend class TType;
         friend class ITypeFactoryInternal;
@@ -1189,6 +1205,102 @@ namespace NTi {
         void Drop(ITypeFactoryInternal& factory) noexcept;
     };
 
+    /// An absolute point in time in range `[-144169-01-01, 148108-01-01)`, precision up to days (Unix epoch 1970-01-01 - 0 days).
+    class TDate32Type final: public TPrimitiveType {
+        friend class TType;
+        friend class ITypeFactoryInternal;
+        friend class ITypeFactory;
+        friend class IPoolTypeFactory;
+
+    public:
+        TDate32TypePtr AsPtr() const noexcept {
+            return const_cast<TDate32Type*>(this);
+        }
+
+    private:
+        explicit TDate32Type();
+
+    public:
+        static TDate32TypePtr Instance();
+        static const TDate32Type* InstanceRaw();
+
+    protected:
+        const TDate32Type* Clone(ITypeFactoryInternal& factory) const noexcept;
+        void Drop(ITypeFactoryInternal& factory) noexcept;
+    };
+
+    /// An absolute point in time in range `[-144169-01-01, 148108-01-01)`, precision up to seconds (Unix epoch 1970-01-01 - 0 seconds).
+    class TDatetime64Type final: public TPrimitiveType {
+        friend class TType;
+        friend class ITypeFactoryInternal;
+        friend class ITypeFactory;
+        friend class IPoolTypeFactory;
+
+    public:
+        TDatetime64TypePtr AsPtr() const noexcept {
+            return const_cast<TDatetime64Type*>(this);
+        }
+
+    private:
+        explicit TDatetime64Type();
+
+    public:
+        static TDatetime64TypePtr Instance();
+        static const TDatetime64Type* InstanceRaw();
+
+    protected:
+        const TDatetime64Type* Clone(ITypeFactoryInternal& factory) const noexcept;
+        void Drop(ITypeFactoryInternal& factory) noexcept;
+    };
+
+    /// An absolute point in time in range `[-144169-01-01, 148108-01-01)`, precision up to milliseconds (Unix epoch 1970-01-01 - 0 milliseconds).
+    class TTimestamp64Type final: public TPrimitiveType {
+        friend class TType;
+        friend class ITypeFactoryInternal;
+        friend class ITypeFactory;
+        friend class IPoolTypeFactory;
+
+    public:
+        TTimestamp64TypePtr AsPtr() const noexcept {
+            return const_cast<TTimestamp64Type*>(this);
+        }
+
+    private:
+        explicit TTimestamp64Type();
+
+    public:
+        static TTimestamp64TypePtr Instance();
+        static const TTimestamp64Type* InstanceRaw();
+
+    protected:
+        const TTimestamp64Type* Clone(ITypeFactoryInternal& factory) const noexcept;
+        void Drop(ITypeFactoryInternal& factory) noexcept;
+    };
+
+    /// Signed delta between two timestamps64.
+    class TInterval64Type final: public TPrimitiveType {
+        friend class TType;
+        friend class ITypeFactoryInternal;
+        friend class ITypeFactory;
+        friend class IPoolTypeFactory;
+
+    public:
+        TInterval64TypePtr AsPtr() const noexcept {
+            return const_cast<TInterval64Type*>(this);
+        }
+
+    private:
+        explicit TInterval64Type();
+
+    public:
+        static TInterval64TypePtr Instance();
+        static const TInterval64Type* InstanceRaw();
+
+    protected:
+        const TInterval64Type* Clone(ITypeFactoryInternal& factory) const noexcept;
+        void Drop(ITypeFactoryInternal& factory) noexcept;
+    };
+
     /// Object which can store a value or a singular `NULL` value.
     ///
     /// This type is used to encode a value or its absence.
@@ -2040,6 +2152,58 @@ namespace NTi {
         return static_cast<const TUuidType*>(this);
     }
 
+    bool TType::IsDate32() const noexcept {
+        return TypeName_ == ETypeName::Date32;
+    }
+
+    TDate32TypePtr TType::AsDate32() const noexcept {
+        return AsDate32Raw()->AsPtr();
+    }
+
+    const TDate32Type* TType::AsDate32Raw() const noexcept {
+        Y_ABORT_UNLESS(IsDate32());
+        return static_cast<const TDate32Type*>(this);
+    }
+
+    bool TType::IsDatetime64() const noexcept {
+        return TypeName_ == ETypeName::Datetime64;
+    }
+
+    TDatetime64TypePtr TType::AsDatetime64() const noexcept {
+        return AsDatetime64Raw()->AsPtr();
+    }
+
+    const TDatetime64Type* TType::AsDatetime64Raw() const noexcept {
+        Y_ABORT_UNLESS(IsDatetime64());
+        return static_cast<const TDatetime64Type*>(this);
+    }
+
+    bool TType::IsTimestamp64() const noexcept {
+        return TypeName_ == ETypeName::Timestamp64;
+    }
+
+    TTimestamp64TypePtr TType::AsTimestamp64() const noexcept {
+        return AsTimestamp64Raw()->AsPtr();
+    }
+
+    const TTimestamp64Type* TType::AsTimestamp64Raw() const noexcept {
+        Y_ABORT_UNLESS(IsTimestamp64());
+        return static_cast<const TTimestamp64Type*>(this);
+    }
+
+    bool TType::IsInterval64() const noexcept {
+        return TypeName_ == ETypeName::Interval64;
+    }
+
+    TInterval64TypePtr TType::AsInterval64() const noexcept {
+        return AsInterval64Raw()->AsPtr();
+    }
+
+    const TInterval64Type* TType::AsInterval64Raw() const noexcept {
+        Y_ABORT_UNLESS(IsInterval64());
+        return static_cast<const TInterval64Type*>(this);
+    }
+
     bool TType::IsOptional() const noexcept {
         return TypeName_ == ETypeName::Optional;
     }
@@ -2186,6 +2350,14 @@ namespace NTi {
                 return std::forward<V>(visitor)(this->AsYson());
             case ETypeName::Uuid:
                 return std::forward<V>(visitor)(this->AsUuid());
+            case ETypeName::Date32:
+                return std::forward<V>(visitor)(this->AsDate32());
+            case ETypeName::Datetime64:
+                return std::forward<V>(visitor)(this->AsDatetime64());
+            case ETypeName::Timestamp64:
+                return std::forward<V>(visitor)(this->AsTimestamp64());
+            case ETypeName::Interval64:
+                return std::forward<V>(visitor)(this->AsInterval64());
             case ETypeName::Void:
                 return std::forward<V>(visitor)(this->AsVoid());
             case ETypeName::Null:
@@ -2260,6 +2432,14 @@ namespace NTi {
                 return std::forward<V>(visitor)(this->AsYsonRaw());
             case ETypeName::Uuid:
                 return std::forward<V>(visitor)(this->AsUuidRaw());
+            case ETypeName::Date32:
+                return std::forward<V>(visitor)(this->AsDate32Raw());
+            case ETypeName::Datetime64:
+                return std::forward<V>(visitor)(this->AsDatetime64Raw());
+            case ETypeName::Timestamp64:
+                return std::forward<V>(visitor)(this->AsTimestamp64Raw());
+            case ETypeName::Interval64:
+                return std::forward<V>(visitor)(this->AsInterval64Raw());
             case ETypeName::Void:
                 return std::forward<V>(visitor)(this->AsVoidRaw());
             case ETypeName::Null:
@@ -2334,6 +2514,14 @@ namespace NTi {
                 return std::forward<V>(visitor)(this->AsYson());
             case EPrimitiveTypeName::Uuid:
                 return std::forward<V>(visitor)(this->AsUuid());
+            case EPrimitiveTypeName::Date32:
+                return std::forward<V>(visitor)(this->AsDate32());
+            case EPrimitiveTypeName::Datetime64:
+                return std::forward<V>(visitor)(this->AsDatetime64());
+            case EPrimitiveTypeName::Timestamp64:
+                return std::forward<V>(visitor)(this->AsTimestamp64());
+            case EPrimitiveTypeName::Interval64:
+                return std::forward<V>(visitor)(this->AsInterval64());
         }
 
         Y_UNREACHABLE();
@@ -2390,6 +2578,14 @@ namespace NTi {
                 return std::forward<V>(visitor)(this->AsYsonRaw());
             case EPrimitiveTypeName::Uuid:
                 return std::forward<V>(visitor)(this->AsUuidRaw());
+            case NTi::EPrimitiveTypeName::Date32:
+                return std::forward<V>(visitor)(this->AsDate32Raw());
+            case NTi::EPrimitiveTypeName::Datetime64:
+                return std::forward<V>(visitor)(this->AsDatetime64Raw());
+            case NTi::EPrimitiveTypeName::Timestamp64:
+                return std::forward<V>(visitor)(this->AsTimestamp64Raw());
+            case NTi::EPrimitiveTypeName::Interval64:
+                return std::forward<V>(visitor)(this->AsInterval64Raw());
         }
 
         Y_UNREACHABLE();
diff --git a/library/cpp/type_info/type_complexity.cpp b/library/cpp/type_info/type_complexity.cpp
index b994cc2187b..572940bff8e 100644
--- a/library/cpp/type_info/type_complexity.cpp
+++ b/library/cpp/type_info/type_complexity.cpp
@@ -37,6 +37,10 @@ int ComputeTypeComplexity(const TType* type)
         case ETypeName::Json:
         case ETypeName::Yson:
         case ETypeName::Uuid:
+        case ETypeName::Date32:
+        case ETypeName::Datetime64:
+        case ETypeName::Timestamp64:
+        case ETypeName::Interval64:
         case ETypeName::Void:
         case ETypeName::Null:
             return 1;
diff --git a/library/cpp/type_info/type_constructors.h b/library/cpp/type_info/type_constructors.h
index 439d5a18879..50c48169a5d 100644
--- a/library/cpp/type_info/type_constructors.h
+++ b/library/cpp/type_info/type_constructors.h
@@ -80,6 +80,18 @@ namespace NTi {
     /// Create new `Uuid` type using the default heap factory.
     TUuidTypePtr Uuid();
 
+    /// Create new `Date32` type using the default heap factory.
+    TDate32TypePtr Date32();
+
+    /// Create new `Datetime64` type using the default heap factory.
+    TDatetime64TypePtr Datetime64();
+
+    /// Create new `Timestamp64` type using the default heap factory.
+    TTimestamp64TypePtr Timestamp64();
+
+    /// Create new `Interval64` type using the default heap factory.
+    TInterval64TypePtr Interval64();
+
     /// Create new `Optional` type using the default heap factory.
     TOptionalTypePtr Optional(TTypePtr item);
 
diff --git a/library/cpp/type_info/type_equivalence.cpp b/library/cpp/type_info/type_equivalence.cpp
index 9f22f0308cc..8288782cc74 100644
--- a/library/cpp/type_info/type_equivalence.cpp
+++ b/library/cpp/type_info/type_equivalence.cpp
@@ -150,6 +150,26 @@ namespace NTi::NEq {
         }
 
         template <bool IgnoreHash>
+        bool StrictlyEqual(const TDate32Type&, const TDate32Type&) {
+            return true;
+        }
+
+        template <bool IgnoreHash>
+        bool StrictlyEqual(const TDatetime64Type&, const TDatetime64Type&) {
+            return true;
+        }
+
+        template <bool IgnoreHash>
+        bool StrictlyEqual(const TTimestamp64Type&, const TTimestamp64Type&) {
+            return true;
+        }
+
+        template <bool IgnoreHash>
+        bool StrictlyEqual(const TInterval64Type&, const TInterval64Type&) {
+            return true;
+        }
+
+        template <bool IgnoreHash>
         bool StrictlyEqual(const TOptionalType& lhs, const TOptionalType& rhs) {
             return StrictlyEqual<IgnoreHash>(lhs.GetItemTypeRaw(), rhs.GetItemTypeRaw());
         }
diff --git a/library/cpp/type_info/type_factory.cpp b/library/cpp/type_info/type_factory.cpp
index cc4206e012f..661e31c7a90 100644
--- a/library/cpp/type_info/type_factory.cpp
+++ b/library/cpp/type_info/type_factory.cpp
@@ -217,6 +217,38 @@ namespace NTi {
         return TUuidType::InstanceRaw();
     }
 
+    TDate32TypePtr ITypeFactory::Date32() {
+        return TDate32Type::Instance();
+    }
+
+    const TDate32Type* IPoolTypeFactory::Date32Raw() {
+        return TDate32Type::InstanceRaw();
+    }
+
+    TDatetime64TypePtr ITypeFactory::Datetime64() {
+        return TDatetime64Type::Instance();
+    }
+
+    const TDatetime64Type* IPoolTypeFactory::Datetime64Raw() {
+        return TDatetime64Type::InstanceRaw();
+    }
+
+    TTimestamp64TypePtr ITypeFactory::Timestamp64() {
+        return TTimestamp64Type::Instance();
+    }
+
+    const TTimestamp64Type* IPoolTypeFactory::Timestamp64Raw() {
+        return TTimestamp64Type::InstanceRaw();
+    }
+
+    TInterval64TypePtr ITypeFactory::Interval64() {
+        return TInterval64Type::Instance();
+    }
+
+    const TInterval64Type* IPoolTypeFactory::Interval64Raw() {
+        return TInterval64Type::InstanceRaw();
+    }
+
     TOptionalTypePtr ITypeFactory::Optional(TTypePtr item) {
         return TOptionalType::Create(*this, std::move(item));
     }
diff --git a/library/cpp/type_info/type_factory.h b/library/cpp/type_info/type_factory.h
index df47c7082b5..1d21094355d 100644
--- a/library/cpp/type_info/type_factory.h
+++ b/library/cpp/type_info/type_factory.h
@@ -626,6 +626,18 @@ namespace NTi {
         /// Create a new `Uuid` type. See `NTi::TUuidType` for more info.
         TUuidTypePtr Uuid();
 
+        /// Create a new `Date32` type. See `NTi::TDate32Type` for more info.
+        TDate32TypePtr Date32();
+
+        /// Create a new `Datetime64` type. See `NTi::TDatetime64Type` for more info.
+        TDatetime64TypePtr Datetime64();
+
+        /// Create a new `Timestamp64` type. See `NTi::TTimestamp64Type` for more info.
+        TTimestamp64TypePtr Timestamp64();
+
+        /// Create a new `Interval64` type. See `NTi::TInterval64Type` for more info.
+        TInterval64TypePtr Interval64();
+
         /// Create a new `Optional` type. See `NTi::TOptionalType` for more info.
         /// If `item` is managed by some other factory, it will be deep-copied into this factory.
         TOptionalTypePtr Optional(TTypePtr item);
@@ -812,6 +824,22 @@ namespace NTi {
         /// The returned object will live for as long as this factory lives.
         const TUuidType* UuidRaw();
 
+        /// Create a new `Date32` type. See `NTi::TDate32Type` for more info.
+        /// The returned object will live for as long as this factory lives.
+        const TDate32Type* Date32Raw();
+
+        /// Create a new `Datetime64` type. See `NTi::TDatetime64Type` for more info.
+        /// The returned object will live for as long as this factory lives.
+        const TDatetime64Type* Datetime64Raw();
+
+        /// Create a new `Timestamp64` type. See `NTi::TTimestamp64Type` for more info.
+        /// The returned object will live for as long as this factory lives.
+        const TTimestamp64Type* Timestamp64Raw();
+
+        /// Create a new `Interval64` type. See `NTi::TInterval64Type` for more info.
+        /// The returned object will live for as long as this factory lives.
+        const TInterval64Type* Interval64Raw();
+
         /// Create a new `Optional` type. See `NTi::TOptionalType` for more info.
         /// The returned object will live for as long as this factory lives.
         const TOptionalType* OptionalRaw(const TType* item);
diff --git a/library/cpp/type_info/type_io.cpp b/library/cpp/type_info/type_io.cpp
index 90b98c8baa9..986a9d6264b 100644
--- a/library/cpp/type_info/type_io.cpp
+++ b/library/cpp/type_info/type_io.cpp
@@ -291,6 +291,18 @@ namespace NTi::NIo {
                     case ETypeName::Uuid:
                         type = TUuidType::InstanceRaw();
                         break;
+                    case ETypeName::Date32:
+                        type = TDate32Type::InstanceRaw();
+                        break;
+                    case ETypeName::Datetime64:
+                        type = TDatetime64Type::InstanceRaw();
+                        break;
+                    case ETypeName::Timestamp64:
+                        type = TTimestamp64Type::InstanceRaw();
+                        break;
+                    case ETypeName::Interval64:
+                        type = TInterval64Type::InstanceRaw();
+                        break;
                     case ETypeName::Void:
                         type = TVoidType::InstanceRaw();
                         break;
@@ -710,6 +722,18 @@ namespace NTi::NIo {
             [&consumer](const TUuidType*) {
                 consumer.OnScalarString("uuid");
             },
+            [&consumer](const TDate32Type*) {
+                consumer.OnScalarString("date32");
+            },
+            [&consumer](const TDatetime64Type*) {
+                consumer.OnScalarString("datetime64");
+            },
+            [&consumer](const TTimestamp64Type*) {
+                consumer.OnScalarString("timestamp64");
+            },
+            [&consumer](const TInterval64Type*) {
+                consumer.OnScalarString("interval64");
+            },
             [&consumer](const TDecimalType* t) {
                 consumer.OnBeginMap();
 
@@ -968,6 +992,18 @@ namespace NTi::NIo {
             [&consumer](const TUuidType*) {
                 WriteDataType(consumer, EPrimitiveTypeName::Uuid);
             },
+            [&consumer](const TDate32Type*) {
+                WriteDataType(consumer, EPrimitiveTypeName::Date32);
+            },
+            [&consumer](const TDatetime64Type*) {
+                WriteDataType(consumer, EPrimitiveTypeName::Datetime64);
+            },
+            [&consumer](const TTimestamp64Type*) {
+                WriteDataType(consumer, EPrimitiveTypeName::Timestamp64);
+            },
+            [&consumer](const TInterval64Type*) {
+                WriteDataType(consumer, EPrimitiveTypeName::Interval64);
+            },
             [&consumer](const TDecimalType* t) {
                 consumer.OnBeginList();
                 consumer.OnScalarString("DataType");
@@ -1142,6 +1178,10 @@ namespace NTi::NIo {
                 [](const TJsonType*) -> TStringBuf { return "string"; },
                 [](const TYsonType*) -> TStringBuf { return "any"; },
                 [](const TUuidType*) -> TStringBuf { return "string"; },
+                [](const TDate32Type*) -> TStringBuf { return "int64"; },
+                [](const TDatetime64Type*) -> TStringBuf { return "int64"; },
+                [](const TTimestamp64Type*) -> TStringBuf { return "int64"; },
+                [](const TInterval64Type*) -> TStringBuf { return "int64"; },
                 [](const TDecimalType*) -> TStringBuf { return "string"; },
                 [](const TOptionalType*) -> TStringBuf { return "any"; },
                 [](const TListType*) -> TStringBuf { return "any"; },
diff --git a/library/cpp/type_info/type_list.h b/library/cpp/type_info/type_list.h
index 8d0c1db88b8..2a4d13c27f7 100644
--- a/library/cpp/type_info/type_list.h
+++ b/library/cpp/type_info/type_list.h
@@ -59,6 +59,11 @@ namespace NTi {
         Json,
         Yson,
         Uuid,
+
+        Date32,
+        Datetime64,
+        Timestamp64,
+        Interval64,
     };
 
     /// Enum with names of all types, including primitives.
@@ -98,8 +103,13 @@ namespace NTi {
         Yson,
         Uuid,
 
+        Date32,
+        Datetime64,
+        Timestamp64,
+        Interval64,
+
         FIRST_PRIMITIVE = Bool,
-        LAST_PRIMITIVE = Uuid,
+        LAST_PRIMITIVE = Interval64,
 
         //
         // # Singular types
diff --git a/library/cpp/yt/misc/preprocessor-gen.h b/library/cpp/yt/misc/preprocessor-gen.h
index b809941bcdf..3e2805a1aae 100644
--- a/library/cpp/yt/misc/preprocessor-gen.h
+++ b/library/cpp/yt/misc/preprocessor-gen.h
@@ -1,11 +1,8 @@
-#pragma once
-
-// WARNING: This file was auto-generated.
-// Please, consider incorporating any changes into the generator.
-
-// Generated on Wed Dec  9 14:20:20 2015.
-
+// This file was GENERATED by command:
+//     pump.py preprocessor-gen.h.pump
+// DO NOT EDIT BY HAND!!!
 
+#pragma once
 /*!
   \internal
 */
@@ -220,6 +217,106 @@
 #define PP_COUNT_CONST_PP_COUNT_IMPL_197 197
 #define PP_COUNT_CONST_PP_COUNT_IMPL_198 198
 #define PP_COUNT_CONST_PP_COUNT_IMPL_199 199
+#define PP_COUNT_CONST_PP_COUNT_IMPL_200 200
+#define PP_COUNT_CONST_PP_COUNT_IMPL_201 201
+#define PP_COUNT_CONST_PP_COUNT_IMPL_202 202
+#define PP_COUNT_CONST_PP_COUNT_IMPL_203 203
+#define PP_COUNT_CONST_PP_COUNT_IMPL_204 204
+#define PP_COUNT_CONST_PP_COUNT_IMPL_205 205
+#define PP_COUNT_CONST_PP_COUNT_IMPL_206 206
+#define PP_COUNT_CONST_PP_COUNT_IMPL_207 207
+#define PP_COUNT_CONST_PP_COUNT_IMPL_208 208
+#define PP_COUNT_CONST_PP_COUNT_IMPL_209 209
+#define PP_COUNT_CONST_PP_COUNT_IMPL_210 210
+#define PP_COUNT_CONST_PP_COUNT_IMPL_211 211
+#define PP_COUNT_CONST_PP_COUNT_IMPL_212 212
+#define PP_COUNT_CONST_PP_COUNT_IMPL_213 213
+#define PP_COUNT_CONST_PP_COUNT_IMPL_214 214
+#define PP_COUNT_CONST_PP_COUNT_IMPL_215 215
+#define PP_COUNT_CONST_PP_COUNT_IMPL_216 216
+#define PP_COUNT_CONST_PP_COUNT_IMPL_217 217
+#define PP_COUNT_CONST_PP_COUNT_IMPL_218 218
+#define PP_COUNT_CONST_PP_COUNT_IMPL_219 219
+#define PP_COUNT_CONST_PP_COUNT_IMPL_220 220
+#define PP_COUNT_CONST_PP_COUNT_IMPL_221 221
+#define PP_COUNT_CONST_PP_COUNT_IMPL_222 222
+#define PP_COUNT_CONST_PP_COUNT_IMPL_223 223
+#define PP_COUNT_CONST_PP_COUNT_IMPL_224 224
+#define PP_COUNT_CONST_PP_COUNT_IMPL_225 225
+#define PP_COUNT_CONST_PP_COUNT_IMPL_226 226
+#define PP_COUNT_CONST_PP_COUNT_IMPL_227 227
+#define PP_COUNT_CONST_PP_COUNT_IMPL_228 228
+#define PP_COUNT_CONST_PP_COUNT_IMPL_229 229
+#define PP_COUNT_CONST_PP_COUNT_IMPL_230 230
+#define PP_COUNT_CONST_PP_COUNT_IMPL_231 231
+#define PP_COUNT_CONST_PP_COUNT_IMPL_232 232
+#define PP_COUNT_CONST_PP_COUNT_IMPL_233 233
+#define PP_COUNT_CONST_PP_COUNT_IMPL_234 234
+#define PP_COUNT_CONST_PP_COUNT_IMPL_235 235
+#define PP_COUNT_CONST_PP_COUNT_IMPL_236 236
+#define PP_COUNT_CONST_PP_COUNT_IMPL_237 237
+#define PP_COUNT_CONST_PP_COUNT_IMPL_238 238
+#define PP_COUNT_CONST_PP_COUNT_IMPL_239 239
+#define PP_COUNT_CONST_PP_COUNT_IMPL_240 240
+#define PP_COUNT_CONST_PP_COUNT_IMPL_241 241
+#define PP_COUNT_CONST_PP_COUNT_IMPL_242 242
+#define PP_COUNT_CONST_PP_COUNT_IMPL_243 243
+#define PP_COUNT_CONST_PP_COUNT_IMPL_244 244
+#define PP_COUNT_CONST_PP_COUNT_IMPL_245 245
+#define PP_COUNT_CONST_PP_COUNT_IMPL_246 246
+#define PP_COUNT_CONST_PP_COUNT_IMPL_247 247
+#define PP_COUNT_CONST_PP_COUNT_IMPL_248 248
+#define PP_COUNT_CONST_PP_COUNT_IMPL_249 249
+#define PP_COUNT_CONST_PP_COUNT_IMPL_250 250
+#define PP_COUNT_CONST_PP_COUNT_IMPL_251 251
+#define PP_COUNT_CONST_PP_COUNT_IMPL_252 252
+#define PP_COUNT_CONST_PP_COUNT_IMPL_253 253
+#define PP_COUNT_CONST_PP_COUNT_IMPL_254 254
+#define PP_COUNT_CONST_PP_COUNT_IMPL_255 255
+#define PP_COUNT_CONST_PP_COUNT_IMPL_256 256
+#define PP_COUNT_CONST_PP_COUNT_IMPL_257 257
+#define PP_COUNT_CONST_PP_COUNT_IMPL_258 258
+#define PP_COUNT_CONST_PP_COUNT_IMPL_259 259
+#define PP_COUNT_CONST_PP_COUNT_IMPL_260 260
+#define PP_COUNT_CONST_PP_COUNT_IMPL_261 261
+#define PP_COUNT_CONST_PP_COUNT_IMPL_262 262
+#define PP_COUNT_CONST_PP_COUNT_IMPL_263 263
+#define PP_COUNT_CONST_PP_COUNT_IMPL_264 264
+#define PP_COUNT_CONST_PP_COUNT_IMPL_265 265
+#define PP_COUNT_CONST_PP_COUNT_IMPL_266 266
+#define PP_COUNT_CONST_PP_COUNT_IMPL_267 267
+#define PP_COUNT_CONST_PP_COUNT_IMPL_268 268
+#define PP_COUNT_CONST_PP_COUNT_IMPL_269 269
+#define PP_COUNT_CONST_PP_COUNT_IMPL_270 270
+#define PP_COUNT_CONST_PP_COUNT_IMPL_271 271
+#define PP_COUNT_CONST_PP_COUNT_IMPL_272 272
+#define PP_COUNT_CONST_PP_COUNT_IMPL_273 273
+#define PP_COUNT_CONST_PP_COUNT_IMPL_274 274
+#define PP_COUNT_CONST_PP_COUNT_IMPL_275 275
+#define PP_COUNT_CONST_PP_COUNT_IMPL_276 276
+#define PP_COUNT_CONST_PP_COUNT_IMPL_277 277
+#define PP_COUNT_CONST_PP_COUNT_IMPL_278 278
+#define PP_COUNT_CONST_PP_COUNT_IMPL_279 279
+#define PP_COUNT_CONST_PP_COUNT_IMPL_280 280
+#define PP_COUNT_CONST_PP_COUNT_IMPL_281 281
+#define PP_COUNT_CONST_PP_COUNT_IMPL_282 282
+#define PP_COUNT_CONST_PP_COUNT_IMPL_283 283
+#define PP_COUNT_CONST_PP_COUNT_IMPL_284 284
+#define PP_COUNT_CONST_PP_COUNT_IMPL_285 285
+#define PP_COUNT_CONST_PP_COUNT_IMPL_286 286
+#define PP_COUNT_CONST_PP_COUNT_IMPL_287 287
+#define PP_COUNT_CONST_PP_COUNT_IMPL_288 288
+#define PP_COUNT_CONST_PP_COUNT_IMPL_289 289
+#define PP_COUNT_CONST_PP_COUNT_IMPL_290 290
+#define PP_COUNT_CONST_PP_COUNT_IMPL_291 291
+#define PP_COUNT_CONST_PP_COUNT_IMPL_292 292
+#define PP_COUNT_CONST_PP_COUNT_IMPL_293 293
+#define PP_COUNT_CONST_PP_COUNT_IMPL_294 294
+#define PP_COUNT_CONST_PP_COUNT_IMPL_295 295
+#define PP_COUNT_CONST_PP_COUNT_IMPL_296 296
+#define PP_COUNT_CONST_PP_COUNT_IMPL_297 297
+#define PP_COUNT_CONST_PP_COUNT_IMPL_298 298
+#define PP_COUNT_CONST_PP_COUNT_IMPL_299 299
 #define PP_COUNT_IMPL_0(_) PP_COUNT_IMPL_1
 #define PP_COUNT_IMPL_1(_) PP_COUNT_IMPL_2
 #define PP_COUNT_IMPL_2(_) PP_COUNT_IMPL_3
@@ -420,6 +517,106 @@
 #define PP_COUNT_IMPL_197(_) PP_COUNT_IMPL_198
 #define PP_COUNT_IMPL_198(_) PP_COUNT_IMPL_199
 #define PP_COUNT_IMPL_199(_) PP_COUNT_IMPL_200
+#define PP_COUNT_IMPL_200(_) PP_COUNT_IMPL_201
+#define PP_COUNT_IMPL_201(_) PP_COUNT_IMPL_202
+#define PP_COUNT_IMPL_202(_) PP_COUNT_IMPL_203
+#define PP_COUNT_IMPL_203(_) PP_COUNT_IMPL_204
+#define PP_COUNT_IMPL_204(_) PP_COUNT_IMPL_205
+#define PP_COUNT_IMPL_205(_) PP_COUNT_IMPL_206
+#define PP_COUNT_IMPL_206(_) PP_COUNT_IMPL_207
+#define PP_COUNT_IMPL_207(_) PP_COUNT_IMPL_208
+#define PP_COUNT_IMPL_208(_) PP_COUNT_IMPL_209
+#define PP_COUNT_IMPL_209(_) PP_COUNT_IMPL_210
+#define PP_COUNT_IMPL_210(_) PP_COUNT_IMPL_211
+#define PP_COUNT_IMPL_211(_) PP_COUNT_IMPL_212
+#define PP_COUNT_IMPL_212(_) PP_COUNT_IMPL_213
+#define PP_COUNT_IMPL_213(_) PP_COUNT_IMPL_214
+#define PP_COUNT_IMPL_214(_) PP_COUNT_IMPL_215
+#define PP_COUNT_IMPL_215(_) PP_COUNT_IMPL_216
+#define PP_COUNT_IMPL_216(_) PP_COUNT_IMPL_217
+#define PP_COUNT_IMPL_217(_) PP_COUNT_IMPL_218
+#define PP_COUNT_IMPL_218(_) PP_COUNT_IMPL_219
+#define PP_COUNT_IMPL_219(_) PP_COUNT_IMPL_220
+#define PP_COUNT_IMPL_220(_) PP_COUNT_IMPL_221
+#define PP_COUNT_IMPL_221(_) PP_COUNT_IMPL_222
+#define PP_COUNT_IMPL_222(_) PP_COUNT_IMPL_223
+#define PP_COUNT_IMPL_223(_) PP_COUNT_IMPL_224
+#define PP_COUNT_IMPL_224(_) PP_COUNT_IMPL_225
+#define PP_COUNT_IMPL_225(_) PP_COUNT_IMPL_226
+#define PP_COUNT_IMPL_226(_) PP_COUNT_IMPL_227
+#define PP_COUNT_IMPL_227(_) PP_COUNT_IMPL_228
+#define PP_COUNT_IMPL_228(_) PP_COUNT_IMPL_229
+#define PP_COUNT_IMPL_229(_) PP_COUNT_IMPL_230
+#define PP_COUNT_IMPL_230(_) PP_COUNT_IMPL_231
+#define PP_COUNT_IMPL_231(_) PP_COUNT_IMPL_232
+#define PP_COUNT_IMPL_232(_) PP_COUNT_IMPL_233
+#define PP_COUNT_IMPL_233(_) PP_COUNT_IMPL_234
+#define PP_COUNT_IMPL_234(_) PP_COUNT_IMPL_235
+#define PP_COUNT_IMPL_235(_) PP_COUNT_IMPL_236
+#define PP_COUNT_IMPL_236(_) PP_COUNT_IMPL_237
+#define PP_COUNT_IMPL_237(_) PP_COUNT_IMPL_238
+#define PP_COUNT_IMPL_238(_) PP_COUNT_IMPL_239
+#define PP_COUNT_IMPL_239(_) PP_COUNT_IMPL_240
+#define PP_COUNT_IMPL_240(_) PP_COUNT_IMPL_241
+#define PP_COUNT_IMPL_241(_) PP_COUNT_IMPL_242
+#define PP_COUNT_IMPL_242(_) PP_COUNT_IMPL_243
+#define PP_COUNT_IMPL_243(_) PP_COUNT_IMPL_244
+#define PP_COUNT_IMPL_244(_) PP_COUNT_IMPL_245
+#define PP_COUNT_IMPL_245(_) PP_COUNT_IMPL_246
+#define PP_COUNT_IMPL_246(_) PP_COUNT_IMPL_247
+#define PP_COUNT_IMPL_247(_) PP_COUNT_IMPL_248
+#define PP_COUNT_IMPL_248(_) PP_COUNT_IMPL_249
+#define PP_COUNT_IMPL_249(_) PP_COUNT_IMPL_250
+#define PP_COUNT_IMPL_250(_) PP_COUNT_IMPL_251
+#define PP_COUNT_IMPL_251(_) PP_COUNT_IMPL_252
+#define PP_COUNT_IMPL_252(_) PP_COUNT_IMPL_253
+#define PP_COUNT_IMPL_253(_) PP_COUNT_IMPL_254
+#define PP_COUNT_IMPL_254(_) PP_COUNT_IMPL_255
+#define PP_COUNT_IMPL_255(_) PP_COUNT_IMPL_256
+#define PP_COUNT_IMPL_256(_) PP_COUNT_IMPL_257
+#define PP_COUNT_IMPL_257(_) PP_COUNT_IMPL_258
+#define PP_COUNT_IMPL_258(_) PP_COUNT_IMPL_259
+#define PP_COUNT_IMPL_259(_) PP_COUNT_IMPL_260
+#define PP_COUNT_IMPL_260(_) PP_COUNT_IMPL_261
+#define PP_COUNT_IMPL_261(_) PP_COUNT_IMPL_262
+#define PP_COUNT_IMPL_262(_) PP_COUNT_IMPL_263
+#define PP_COUNT_IMPL_263(_) PP_COUNT_IMPL_264
+#define PP_COUNT_IMPL_264(_) PP_COUNT_IMPL_265
+#define PP_COUNT_IMPL_265(_) PP_COUNT_IMPL_266
+#define PP_COUNT_IMPL_266(_) PP_COUNT_IMPL_267
+#define PP_COUNT_IMPL_267(_) PP_COUNT_IMPL_268
+#define PP_COUNT_IMPL_268(_) PP_COUNT_IMPL_269
+#define PP_COUNT_IMPL_269(_) PP_COUNT_IMPL_270
+#define PP_COUNT_IMPL_270(_) PP_COUNT_IMPL_271
+#define PP_COUNT_IMPL_271(_) PP_COUNT_IMPL_272
+#define PP_COUNT_IMPL_272(_) PP_COUNT_IMPL_273
+#define PP_COUNT_IMPL_273(_) PP_COUNT_IMPL_274
+#define PP_COUNT_IMPL_274(_) PP_COUNT_IMPL_275
+#define PP_COUNT_IMPL_275(_) PP_COUNT_IMPL_276
+#define PP_COUNT_IMPL_276(_) PP_COUNT_IMPL_277
+#define PP_COUNT_IMPL_277(_) PP_COUNT_IMPL_278
+#define PP_COUNT_IMPL_278(_) PP_COUNT_IMPL_279
+#define PP_COUNT_IMPL_279(_) PP_COUNT_IMPL_280
+#define PP_COUNT_IMPL_280(_) PP_COUNT_IMPL_281
+#define PP_COUNT_IMPL_281(_) PP_COUNT_IMPL_282
+#define PP_COUNT_IMPL_282(_) PP_COUNT_IMPL_283
+#define PP_COUNT_IMPL_283(_) PP_COUNT_IMPL_284
+#define PP_COUNT_IMPL_284(_) PP_COUNT_IMPL_285
+#define PP_COUNT_IMPL_285(_) PP_COUNT_IMPL_286
+#define PP_COUNT_IMPL_286(_) PP_COUNT_IMPL_287
+#define PP_COUNT_IMPL_287(_) PP_COUNT_IMPL_288
+#define PP_COUNT_IMPL_288(_) PP_COUNT_IMPL_289
+#define PP_COUNT_IMPL_289(_) PP_COUNT_IMPL_290
+#define PP_COUNT_IMPL_290(_) PP_COUNT_IMPL_291
+#define PP_COUNT_IMPL_291(_) PP_COUNT_IMPL_292
+#define PP_COUNT_IMPL_292(_) PP_COUNT_IMPL_293
+#define PP_COUNT_IMPL_293(_) PP_COUNT_IMPL_294
+#define PP_COUNT_IMPL_294(_) PP_COUNT_IMPL_295
+#define PP_COUNT_IMPL_295(_) PP_COUNT_IMPL_296
+#define PP_COUNT_IMPL_296(_) PP_COUNT_IMPL_297
+#define PP_COUNT_IMPL_297(_) PP_COUNT_IMPL_298
+#define PP_COUNT_IMPL_298(_) PP_COUNT_IMPL_299
+#define PP_COUNT_IMPL_299(_) PP_COUNT_IMPL_300
 
 ////////////////////////////////////////////////////////////////////////////////
 #define PP_KILL_IMPL(seq, index) PP_CONCAT(PP_KILL_IMPL_, index) seq
@@ -624,6 +821,106 @@
 #define PP_KILL_IMPL_198(_) PP_KILL_IMPL_197
 #define PP_KILL_IMPL_199(_) PP_KILL_IMPL_198
 #define PP_KILL_IMPL_200(_) PP_KILL_IMPL_199
+#define PP_KILL_IMPL_201(_) PP_KILL_IMPL_200
+#define PP_KILL_IMPL_202(_) PP_KILL_IMPL_201
+#define PP_KILL_IMPL_203(_) PP_KILL_IMPL_202
+#define PP_KILL_IMPL_204(_) PP_KILL_IMPL_203
+#define PP_KILL_IMPL_205(_) PP_KILL_IMPL_204
+#define PP_KILL_IMPL_206(_) PP_KILL_IMPL_205
+#define PP_KILL_IMPL_207(_) PP_KILL_IMPL_206
+#define PP_KILL_IMPL_208(_) PP_KILL_IMPL_207
+#define PP_KILL_IMPL_209(_) PP_KILL_IMPL_208
+#define PP_KILL_IMPL_210(_) PP_KILL_IMPL_209
+#define PP_KILL_IMPL_211(_) PP_KILL_IMPL_210
+#define PP_KILL_IMPL_212(_) PP_KILL_IMPL_211
+#define PP_KILL_IMPL_213(_) PP_KILL_IMPL_212
+#define PP_KILL_IMPL_214(_) PP_KILL_IMPL_213
+#define PP_KILL_IMPL_215(_) PP_KILL_IMPL_214
+#define PP_KILL_IMPL_216(_) PP_KILL_IMPL_215
+#define PP_KILL_IMPL_217(_) PP_KILL_IMPL_216
+#define PP_KILL_IMPL_218(_) PP_KILL_IMPL_217
+#define PP_KILL_IMPL_219(_) PP_KILL_IMPL_218
+#define PP_KILL_IMPL_220(_) PP_KILL_IMPL_219
+#define PP_KILL_IMPL_221(_) PP_KILL_IMPL_220
+#define PP_KILL_IMPL_222(_) PP_KILL_IMPL_221
+#define PP_KILL_IMPL_223(_) PP_KILL_IMPL_222
+#define PP_KILL_IMPL_224(_) PP_KILL_IMPL_223
+#define PP_KILL_IMPL_225(_) PP_KILL_IMPL_224
+#define PP_KILL_IMPL_226(_) PP_KILL_IMPL_225
+#define PP_KILL_IMPL_227(_) PP_KILL_IMPL_226
+#define PP_KILL_IMPL_228(_) PP_KILL_IMPL_227
+#define PP_KILL_IMPL_229(_) PP_KILL_IMPL_228
+#define PP_KILL_IMPL_230(_) PP_KILL_IMPL_229
+#define PP_KILL_IMPL_231(_) PP_KILL_IMPL_230
+#define PP_KILL_IMPL_232(_) PP_KILL_IMPL_231
+#define PP_KILL_IMPL_233(_) PP_KILL_IMPL_232
+#define PP_KILL_IMPL_234(_) PP_KILL_IMPL_233
+#define PP_KILL_IMPL_235(_) PP_KILL_IMPL_234
+#define PP_KILL_IMPL_236(_) PP_KILL_IMPL_235
+#define PP_KILL_IMPL_237(_) PP_KILL_IMPL_236
+#define PP_KILL_IMPL_238(_) PP_KILL_IMPL_237
+#define PP_KILL_IMPL_239(_) PP_KILL_IMPL_238
+#define PP_KILL_IMPL_240(_) PP_KILL_IMPL_239
+#define PP_KILL_IMPL_241(_) PP_KILL_IMPL_240
+#define PP_KILL_IMPL_242(_) PP_KILL_IMPL_241
+#define PP_KILL_IMPL_243(_) PP_KILL_IMPL_242
+#define PP_KILL_IMPL_244(_) PP_KILL_IMPL_243
+#define PP_KILL_IMPL_245(_) PP_KILL_IMPL_244
+#define PP_KILL_IMPL_246(_) PP_KILL_IMPL_245
+#define PP_KILL_IMPL_247(_) PP_KILL_IMPL_246
+#define PP_KILL_IMPL_248(_) PP_KILL_IMPL_247
+#define PP_KILL_IMPL_249(_) PP_KILL_IMPL_248
+#define PP_KILL_IMPL_250(_) PP_KILL_IMPL_249
+#define PP_KILL_IMPL_251(_) PP_KILL_IMPL_250
+#define PP_KILL_IMPL_252(_) PP_KILL_IMPL_251
+#define PP_KILL_IMPL_253(_) PP_KILL_IMPL_252
+#define PP_KILL_IMPL_254(_) PP_KILL_IMPL_253
+#define PP_KILL_IMPL_255(_) PP_KILL_IMPL_254
+#define PP_KILL_IMPL_256(_) PP_KILL_IMPL_255
+#define PP_KILL_IMPL_257(_) PP_KILL_IMPL_256
+#define PP_KILL_IMPL_258(_) PP_KILL_IMPL_257
+#define PP_KILL_IMPL_259(_) PP_KILL_IMPL_258
+#define PP_KILL_IMPL_260(_) PP_KILL_IMPL_259
+#define PP_KILL_IMPL_261(_) PP_KILL_IMPL_260
+#define PP_KILL_IMPL_262(_) PP_KILL_IMPL_261
+#define PP_KILL_IMPL_263(_) PP_KILL_IMPL_262
+#define PP_KILL_IMPL_264(_) PP_KILL_IMPL_263
+#define PP_KILL_IMPL_265(_) PP_KILL_IMPL_264
+#define PP_KILL_IMPL_266(_) PP_KILL_IMPL_265
+#define PP_KILL_IMPL_267(_) PP_KILL_IMPL_266
+#define PP_KILL_IMPL_268(_) PP_KILL_IMPL_267
+#define PP_KILL_IMPL_269(_) PP_KILL_IMPL_268
+#define PP_KILL_IMPL_270(_) PP_KILL_IMPL_269
+#define PP_KILL_IMPL_271(_) PP_KILL_IMPL_270
+#define PP_KILL_IMPL_272(_) PP_KILL_IMPL_271
+#define PP_KILL_IMPL_273(_) PP_KILL_IMPL_272
+#define PP_KILL_IMPL_274(_) PP_KILL_IMPL_273
+#define PP_KILL_IMPL_275(_) PP_KILL_IMPL_274
+#define PP_KILL_IMPL_276(_) PP_KILL_IMPL_275
+#define PP_KILL_IMPL_277(_) PP_KILL_IMPL_276
+#define PP_KILL_IMPL_278(_) PP_KILL_IMPL_277
+#define PP_KILL_IMPL_279(_) PP_KILL_IMPL_278
+#define PP_KILL_IMPL_280(_) PP_KILL_IMPL_279
+#define PP_KILL_IMPL_281(_) PP_KILL_IMPL_280
+#define PP_KILL_IMPL_282(_) PP_KILL_IMPL_281
+#define PP_KILL_IMPL_283(_) PP_KILL_IMPL_282
+#define PP_KILL_IMPL_284(_) PP_KILL_IMPL_283
+#define PP_KILL_IMPL_285(_) PP_KILL_IMPL_284
+#define PP_KILL_IMPL_286(_) PP_KILL_IMPL_285
+#define PP_KILL_IMPL_287(_) PP_KILL_IMPL_286
+#define PP_KILL_IMPL_288(_) PP_KILL_IMPL_287
+#define PP_KILL_IMPL_289(_) PP_KILL_IMPL_288
+#define PP_KILL_IMPL_290(_) PP_KILL_IMPL_289
+#define PP_KILL_IMPL_291(_) PP_KILL_IMPL_290
+#define PP_KILL_IMPL_292(_) PP_KILL_IMPL_291
+#define PP_KILL_IMPL_293(_) PP_KILL_IMPL_292
+#define PP_KILL_IMPL_294(_) PP_KILL_IMPL_293
+#define PP_KILL_IMPL_295(_) PP_KILL_IMPL_294
+#define PP_KILL_IMPL_296(_) PP_KILL_IMPL_295
+#define PP_KILL_IMPL_297(_) PP_KILL_IMPL_296
+#define PP_KILL_IMPL_298(_) PP_KILL_IMPL_297
+#define PP_KILL_IMPL_299(_) PP_KILL_IMPL_298
+#define PP_KILL_IMPL_300(_) PP_KILL_IMPL_299
 
 ////////////////////////////////////////////////////////////////////////////////
 #define PP_ELEMENT_IMPL(seq, \
@@ -832,6 +1129,106 @@
 #define PP_ELEMENT_IMPL_198(_) PP_ELEMENT_IMPL_197
 #define PP_ELEMENT_IMPL_199(_) PP_ELEMENT_IMPL_198
 #define PP_ELEMENT_IMPL_200(_) PP_ELEMENT_IMPL_199
+#define PP_ELEMENT_IMPL_201(_) PP_ELEMENT_IMPL_200
+#define PP_ELEMENT_IMPL_202(_) PP_ELEMENT_IMPL_201
+#define PP_ELEMENT_IMPL_203(_) PP_ELEMENT_IMPL_202
+#define PP_ELEMENT_IMPL_204(_) PP_ELEMENT_IMPL_203
+#define PP_ELEMENT_IMPL_205(_) PP_ELEMENT_IMPL_204
+#define PP_ELEMENT_IMPL_206(_) PP_ELEMENT_IMPL_205
+#define PP_ELEMENT_IMPL_207(_) PP_ELEMENT_IMPL_206
+#define PP_ELEMENT_IMPL_208(_) PP_ELEMENT_IMPL_207
+#define PP_ELEMENT_IMPL_209(_) PP_ELEMENT_IMPL_208
+#define PP_ELEMENT_IMPL_210(_) PP_ELEMENT_IMPL_209
+#define PP_ELEMENT_IMPL_211(_) PP_ELEMENT_IMPL_210
+#define PP_ELEMENT_IMPL_212(_) PP_ELEMENT_IMPL_211
+#define PP_ELEMENT_IMPL_213(_) PP_ELEMENT_IMPL_212
+#define PP_ELEMENT_IMPL_214(_) PP_ELEMENT_IMPL_213
+#define PP_ELEMENT_IMPL_215(_) PP_ELEMENT_IMPL_214
+#define PP_ELEMENT_IMPL_216(_) PP_ELEMENT_IMPL_215
+#define PP_ELEMENT_IMPL_217(_) PP_ELEMENT_IMPL_216
+#define PP_ELEMENT_IMPL_218(_) PP_ELEMENT_IMPL_217
+#define PP_ELEMENT_IMPL_219(_) PP_ELEMENT_IMPL_218
+#define PP_ELEMENT_IMPL_220(_) PP_ELEMENT_IMPL_219
+#define PP_ELEMENT_IMPL_221(_) PP_ELEMENT_IMPL_220
+#define PP_ELEMENT_IMPL_222(_) PP_ELEMENT_IMPL_221
+#define PP_ELEMENT_IMPL_223(_) PP_ELEMENT_IMPL_222
+#define PP_ELEMENT_IMPL_224(_) PP_ELEMENT_IMPL_223
+#define PP_ELEMENT_IMPL_225(_) PP_ELEMENT_IMPL_224
+#define PP_ELEMENT_IMPL_226(_) PP_ELEMENT_IMPL_225
+#define PP_ELEMENT_IMPL_227(_) PP_ELEMENT_IMPL_226
+#define PP_ELEMENT_IMPL_228(_) PP_ELEMENT_IMPL_227
+#define PP_ELEMENT_IMPL_229(_) PP_ELEMENT_IMPL_228
+#define PP_ELEMENT_IMPL_230(_) PP_ELEMENT_IMPL_229
+#define PP_ELEMENT_IMPL_231(_) PP_ELEMENT_IMPL_230
+#define PP_ELEMENT_IMPL_232(_) PP_ELEMENT_IMPL_231
+#define PP_ELEMENT_IMPL_233(_) PP_ELEMENT_IMPL_232
+#define PP_ELEMENT_IMPL_234(_) PP_ELEMENT_IMPL_233
+#define PP_ELEMENT_IMPL_235(_) PP_ELEMENT_IMPL_234
+#define PP_ELEMENT_IMPL_236(_) PP_ELEMENT_IMPL_235
+#define PP_ELEMENT_IMPL_237(_) PP_ELEMENT_IMPL_236
+#define PP_ELEMENT_IMPL_238(_) PP_ELEMENT_IMPL_237
+#define PP_ELEMENT_IMPL_239(_) PP_ELEMENT_IMPL_238
+#define PP_ELEMENT_IMPL_240(_) PP_ELEMENT_IMPL_239
+#define PP_ELEMENT_IMPL_241(_) PP_ELEMENT_IMPL_240
+#define PP_ELEMENT_IMPL_242(_) PP_ELEMENT_IMPL_241
+#define PP_ELEMENT_IMPL_243(_) PP_ELEMENT_IMPL_242
+#define PP_ELEMENT_IMPL_244(_) PP_ELEMENT_IMPL_243
+#define PP_ELEMENT_IMPL_245(_) PP_ELEMENT_IMPL_244
+#define PP_ELEMENT_IMPL_246(_) PP_ELEMENT_IMPL_245
+#define PP_ELEMENT_IMPL_247(_) PP_ELEMENT_IMPL_246
+#define PP_ELEMENT_IMPL_248(_) PP_ELEMENT_IMPL_247
+#define PP_ELEMENT_IMPL_249(_) PP_ELEMENT_IMPL_248
+#define PP_ELEMENT_IMPL_250(_) PP_ELEMENT_IMPL_249
+#define PP_ELEMENT_IMPL_251(_) PP_ELEMENT_IMPL_250
+#define PP_ELEMENT_IMPL_252(_) PP_ELEMENT_IMPL_251
+#define PP_ELEMENT_IMPL_253(_) PP_ELEMENT_IMPL_252
+#define PP_ELEMENT_IMPL_254(_) PP_ELEMENT_IMPL_253
+#define PP_ELEMENT_IMPL_255(_) PP_ELEMENT_IMPL_254
+#define PP_ELEMENT_IMPL_256(_) PP_ELEMENT_IMPL_255
+#define PP_ELEMENT_IMPL_257(_) PP_ELEMENT_IMPL_256
+#define PP_ELEMENT_IMPL_258(_) PP_ELEMENT_IMPL_257
+#define PP_ELEMENT_IMPL_259(_) PP_ELEMENT_IMPL_258
+#define PP_ELEMENT_IMPL_260(_) PP_ELEMENT_IMPL_259
+#define PP_ELEMENT_IMPL_261(_) PP_ELEMENT_IMPL_260
+#define PP_ELEMENT_IMPL_262(_) PP_ELEMENT_IMPL_261
+#define PP_ELEMENT_IMPL_263(_) PP_ELEMENT_IMPL_262
+#define PP_ELEMENT_IMPL_264(_) PP_ELEMENT_IMPL_263
+#define PP_ELEMENT_IMPL_265(_) PP_ELEMENT_IMPL_264
+#define PP_ELEMENT_IMPL_266(_) PP_ELEMENT_IMPL_265
+#define PP_ELEMENT_IMPL_267(_) PP_ELEMENT_IMPL_266
+#define PP_ELEMENT_IMPL_268(_) PP_ELEMENT_IMPL_267
+#define PP_ELEMENT_IMPL_269(_) PP_ELEMENT_IMPL_268
+#define PP_ELEMENT_IMPL_270(_) PP_ELEMENT_IMPL_269
+#define PP_ELEMENT_IMPL_271(_) PP_ELEMENT_IMPL_270
+#define PP_ELEMENT_IMPL_272(_) PP_ELEMENT_IMPL_271
+#define PP_ELEMENT_IMPL_273(_) PP_ELEMENT_IMPL_272
+#define PP_ELEMENT_IMPL_274(_) PP_ELEMENT_IMPL_273
+#define PP_ELEMENT_IMPL_275(_) PP_ELEMENT_IMPL_274
+#define PP_ELEMENT_IMPL_276(_) PP_ELEMENT_IMPL_275
+#define PP_ELEMENT_IMPL_277(_) PP_ELEMENT_IMPL_276
+#define PP_ELEMENT_IMPL_278(_) PP_ELEMENT_IMPL_277
+#define PP_ELEMENT_IMPL_279(_) PP_ELEMENT_IMPL_278
+#define PP_ELEMENT_IMPL_280(_) PP_ELEMENT_IMPL_279
+#define PP_ELEMENT_IMPL_281(_) PP_ELEMENT_IMPL_280
+#define PP_ELEMENT_IMPL_282(_) PP_ELEMENT_IMPL_281
+#define PP_ELEMENT_IMPL_283(_) PP_ELEMENT_IMPL_282
+#define PP_ELEMENT_IMPL_284(_) PP_ELEMENT_IMPL_283
+#define PP_ELEMENT_IMPL_285(_) PP_ELEMENT_IMPL_284
+#define PP_ELEMENT_IMPL_286(_) PP_ELEMENT_IMPL_285
+#define PP_ELEMENT_IMPL_287(_) PP_ELEMENT_IMPL_286
+#define PP_ELEMENT_IMPL_288(_) PP_ELEMENT_IMPL_287
+#define PP_ELEMENT_IMPL_289(_) PP_ELEMENT_IMPL_288
+#define PP_ELEMENT_IMPL_290(_) PP_ELEMENT_IMPL_289
+#define PP_ELEMENT_IMPL_291(_) PP_ELEMENT_IMPL_290
+#define PP_ELEMENT_IMPL_292(_) PP_ELEMENT_IMPL_291
+#define PP_ELEMENT_IMPL_293(_) PP_ELEMENT_IMPL_292
+#define PP_ELEMENT_IMPL_294(_) PP_ELEMENT_IMPL_293
+#define PP_ELEMENT_IMPL_295(_) PP_ELEMENT_IMPL_294
+#define PP_ELEMENT_IMPL_296(_) PP_ELEMENT_IMPL_295
+#define PP_ELEMENT_IMPL_297(_) PP_ELEMENT_IMPL_296
+#define PP_ELEMENT_IMPL_298(_) PP_ELEMENT_IMPL_297
+#define PP_ELEMENT_IMPL_299(_) PP_ELEMENT_IMPL_298
+#define PP_ELEMENT_IMPL_300(_) PP_ELEMENT_IMPL_299
 
 ////////////////////////////////////////////////////////////////////////////////
 #define PP_HEAD_IMPL(seq) PP_ELEMENT_IMPL(seq, 0)
@@ -1243,6 +1640,206 @@
     seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_198(what, PP_TAIL(seq))
 #define PP_FOR_EACH_IMPL_200(what, \
     seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_199(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_201(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_200(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_202(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_201(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_203(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_202(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_204(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_203(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_205(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_204(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_206(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_205(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_207(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_206(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_208(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_207(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_209(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_208(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_210(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_209(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_211(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_210(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_212(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_211(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_213(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_212(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_214(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_213(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_215(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_214(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_216(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_215(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_217(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_216(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_218(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_217(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_219(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_218(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_220(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_219(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_221(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_220(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_222(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_221(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_223(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_222(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_224(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_223(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_225(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_224(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_226(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_225(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_227(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_226(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_228(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_227(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_229(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_228(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_230(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_229(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_231(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_230(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_232(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_231(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_233(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_232(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_234(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_233(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_235(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_234(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_236(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_235(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_237(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_236(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_238(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_237(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_239(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_238(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_240(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_239(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_241(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_240(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_242(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_241(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_243(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_242(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_244(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_243(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_245(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_244(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_246(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_245(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_247(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_246(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_248(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_247(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_249(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_248(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_250(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_249(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_251(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_250(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_252(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_251(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_253(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_252(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_254(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_253(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_255(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_254(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_256(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_255(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_257(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_256(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_258(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_257(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_259(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_258(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_260(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_259(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_261(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_260(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_262(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_261(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_263(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_262(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_264(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_263(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_265(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_264(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_266(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_265(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_267(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_266(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_268(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_267(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_269(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_268(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_270(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_269(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_271(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_270(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_272(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_271(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_273(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_272(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_274(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_273(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_275(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_274(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_276(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_275(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_277(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_276(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_278(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_277(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_279(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_278(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_280(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_279(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_281(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_280(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_282(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_281(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_283(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_282(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_284(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_283(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_285(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_284(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_286(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_285(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_287(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_286(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_288(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_287(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_289(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_288(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_290(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_289(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_291(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_290(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_292(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_291(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_293(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_292(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_294(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_293(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_295(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_294(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_296(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_295(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_297(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_296(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_298(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_297(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_299(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_298(what, PP_TAIL(seq))
+#define PP_FOR_EACH_IMPL_300(what, \
+    seq) what(PP_HEAD(seq)) PP_FOR_EACH_IMPL_299(what, PP_TAIL(seq))
 ////////////////////////////////////////////////////////////////////////////////
 /*!
   \endinternal