diff --git a/include/mcc/mcc_keyvalue.h b/include/mcc/mcc_keyvalue.h
index c1de7da..6841048 100644
--- a/include/mcc/mcc_keyvalue.h
+++ b/include/mcc/mcc_keyvalue.h
@@ -290,7 +290,7 @@ public:
                                 return MccKeyValueHolderErrorCode::ERROR_DESERIAL;
                             }
 
-                            _changedKey.insert(key_hash);
+                            // _changedKey.insert(key_hash);
 
                             return MccKeyValueHolderErrorCode::ERROR_OK;
                         });
diff --git a/include/mcc/mcc_pzone.h b/include/mcc/mcc_pzone.h
index c34d956..a4fdcfd 100644
--- a/include/mcc/mcc_pzone.h
+++ b/include/mcc/mcc_pzone.h
@@ -111,6 +111,9 @@ public:
                                                   : KIND == MccAltLimitKind::MAX_ALT_LIMIT ? "MAXALT-ZONE"
                                                                                            : "ALTLIMIT-UNKNOWN";
 
+    MccAltLimitPZ& operator=(MccAltLimitPZ&&) = default;
+    MccAltLimitPZ& operator=(const MccAltLimitPZ&) = default;
+
     template <mcc_angle_c T>
     T altLimit() const
         requires(!std::derived_from<T, MccAngle>)
@@ -390,25 +393,28 @@ struct MccDeserializer<MccAltLimitPZ<KIND>> : MccDeserializerBase {
                        MccAltLimitPZ<KIND>& value,
                        ParamsT const& params = mcc_serialization_params_t{})
     {
-        std::string_view s;
+        std::vector<std::string_view> s;
         MccDeserializer<MccAngle> ades;
 
-        auto seq = std::views::split(params.seq_delim);
-        if (std::ranges::size(seq) < 2) {
-            s = utils::trimSpaces(seq, utils::TrimType::TRIM_BOTH);
+        auto seq = std::views::split(input, params.seq_delim);
+        if (std::ranges::distance(seq.begin(), seq.end()) < 2) {
+            for (auto const& seq_el : seq) {
+                s.push_back(utils::trimSpaces(seq_el, utils::TrimType::TRIM_BOTH));
+            }
+
             MccAngle alt, lat;
 
-            auto err = ades(input, alt, params);
+            auto err = ades(s[0], alt, params);
             if (err) {
                 return MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER;
             }
 
-            err = ades(input, lat, params);
+            err = ades(s[1], lat, params);
             if (err) {
                 return MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER;
             }
 
-            value = MccAltLimitPZ<KIND>{alt, lat};
+            value = MccAltLimitPZ<KIND>(alt, lat);
         } else {
             return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
         }
@@ -469,6 +475,11 @@ public:
         : axisKind == MccCoordKind::COORDS_KIND_DEC_OBS ? "DEC-AXIS-LIMITSWITCH-ZONE"
                                                         : "UKNOWN";
 
+    MccAxisLimitSwitchPZ(const MccAxisLimitSwitchPZ&) = default;
+    MccAxisLimitSwitchPZ(MccAxisLimitSwitchPZ&&) = default;
+
+    MccAxisLimitSwitchPZ& operator=(const MccAxisLimitSwitchPZ&) = default;
+    MccAxisLimitSwitchPZ& operator=(MccAxisLimitSwitchPZ&&) = default;
 
     template <mcc_angle_c T>
     T minLimit() const
@@ -645,26 +656,30 @@ struct MccDeserializer<MccAxisLimitSwitchPZ<AXIS_KIND>> : MccDeserializerBase {
                        MccAxisLimitSwitchPZ<AXIS_KIND>& value,
                        ParamsT const& params = mcc_serialization_params_t{})
     {
-        std::string_view s;
+        std::vector<std::string_view> s;
         MccDeserializer<MccAngle> ades;
 
-        auto seq = std::views::split(params.seq_delim);
-        if (std::ranges::size(seq) < 2) {
-            s = utils::trimSpaces(seq, utils::TrimType::TRIM_BOTH);
+        auto seq = std::views::split(input, params.seq_delim);
+        // if (std::ranges::size(seq) < 2) {
+        if (std::ranges::distance(seq.begin(), seq.end()) < 2) {
+            for (auto const& seq_el : seq) {
+                s.push_back(utils::trimSpaces(seq_el, utils::TrimType::TRIM_BOTH));
+            }
+
             MccAngle minLim, maxLim;
 
-            auto err = ades(input, minLim, params);
+            auto err = ades(s[0], minLim, params);
             if (err) {
                 return MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER;
             }
 
-            err = ades(input, maxLim, params);
+            err = ades(s[1], maxLim, params);
             if (err) {
                 return MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER;
             }
 
             // WARNING: the class below is created without the PCM-class pointer!!!
-            value = MccAxisLimitSwitchPZ<AXIS_KIND>{minLim, maxLim};
+            value = MccAxisLimitSwitchPZ<AXIS_KIND>(minLim, maxLim, nullptr);
         } else {
             return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
         }