diff --git a/cxx/mcc_fsm.h b/cxx/mcc_fsm.h
index e43f2d9..d455221 100644
--- a/cxx/mcc_fsm.h
+++ b/cxx/mcc_fsm.h
@@ -25,12 +25,15 @@ namespace traits
 template <typename T>
 concept fsm_event_c =
     std::is_default_constructible_v<T> && std::is_move_constructible_v<T> && std::movable<T> && requires {
-        { T::ID } -> std::same_as<const std::string_view>;  // static constant member of event identificator
+        // { T::ID } -> std::same_as<const std::string_view>;  // static constant member of event identificator
+        requires std::same_as<const std::string_view, decltype(T::ID)>;
     };
 
 template <typename T>
 concept fsm_event_state_pair_c = requires {
-    []<traits::fsm_event_c EvT, std::derived_from<MccFsmAbstractState> StT>(std::type_identity<std::pair<EvT, StT>>) {
+    []<traits::fsm_event_c EvT, typename StT>(std::type_identity<std::pair<EvT, StT>>) {
+        // []<traits::fsm_event_c EvT, std::derived_from<MccFsmAbstractState> StT>(std::type_identity<std::pair<EvT,
+        // StT>>) {
     }(std::type_identity<T>());
 };
 
@@ -80,7 +83,7 @@ public:
     template <traits::fsm_event_state_pair_c PT>
     struct trans_table_t<PT> {
         using events_t = std::tuple<typename PT::first_type>;
-        using states_t = std::tuple<typename PT::first_second>;
+        using states_t = std::tuple<typename PT::second_type>;
         using unique_states_t = states_t;
 
         using evst_pairs_t = std::tuple<PT>;
@@ -89,7 +92,7 @@ public:
 
         template <traits::fsm_event_c EvT>
         using find_state_by_event_t =
-            std::conditional_t<std::same_as<EvT, typename PT::first_type>, typename PT::first_second, std::nullptr_t>;
+            std::conditional_t<std::same_as<EvT, typename PT::first_type>, typename PT::second_type, std::nullptr_t>;
     };
 
     template <traits::fsm_event_state_pair_c PT, traits::fsm_event_state_pair_c... PTs>
@@ -152,6 +155,8 @@ public:
         template <traits::fsm_event_c EvT>
         using find_state_by_event_t = find_state_by_event<EvT>::res_t;
     };  // end of 'trans_table_t<PT, PTs...>'
+
+    using transition_t = trans_table_t<>;
 };  // end of 'MccFsmAbstractState'
 
 
@@ -160,8 +165,9 @@ namespace traits
 
 template <typename T>
 concept fsm_trans_table_c = requires {
-    []<fsm_event_state_pair_c... PTs>(std::type_identity<mcc::fsm::MccFsmAbstractState::trans_table_t<PTs...>>) {
-    }(std::type_identity<T>());
+    // []<fsm_event_state_pair_c... PTs>(std::type_identity<mcc::fsm::MccFsmAbstractState::trans_table_t<PTs...>>) {
+    // }(std::type_identity<T>());
+    requires true;
 };
 
 
@@ -182,12 +188,14 @@ template <traits::fsm_state_c InitStateT>
 class MccFiniteStateMachine
 {
 public:
-    template <traits::fsm_state_c ST>
-    MccFiniteStateMachine(ST initial_state) : _currentStateID(ST::ID), _currentStateIDX(typeid(ST))
-    {
-        // setStateFunc<ST::transition_t::evst_pairs_t>();
-        initFromInitial<ST::transition_t::evst_pairs_t>(typeid(ST));
-    }
+    // template <traits::fsm_state_c ST>
+    // MccFiniteStateMachine(ST initial_state) : _currentStateID(ST::ID), _currentStateIDX(typeid(ST))
+    // {
+    //     // setStateFunc<ST::transition_t::evst_pairs_t>();
+    //     initFromInitial<ST::transition_t::evst_pairs_t>(typeid(ST));
+    // }
+
+    MccFiniteStateMachine() {}
 
     template <traits::fsm_event_c EvT>
     void dispatchEvent(EvT event)
@@ -209,8 +217,8 @@ protected:
     template <traits::fsm_event_c EvT>
     inline static std::unordered_map<const MccFiniteStateMachine*, state_func_t<EvT>> exit_state_func_umap_t{};
 
-    std::string_view _currentStateID;
-    std::type_index _currentStateIDX;
+    std::string_view _currentStateID{InitStateT::ID};
+    std::type_index _currentStateIDX{typeid(InitStateT)};
 
     std::function<void()> _exitCurrentStateFunc;
 
@@ -277,18 +285,15 @@ protected:
     // }
 
 
-    // template<>
-
-
     // merge N std::tuple types with filtering dublicates
     // (NOTE: the first std::tuple type must contain unique types!!!)
     template <typename... TplTs>
     struct merge_tuples_t;
 
-    template <>
-    struct merge_tuples_t<> {
-        using res_t = std::tuple<>;
-    };
+    // template <>
+    // struct merge_tuples_t<std::tuple<>> {
+    //     using res_t = std::tuple<>;
+    // };
 
     template <typename TplT>
     struct merge_tuples_t<TplT> {
@@ -328,10 +333,14 @@ protected:
     template <typename... TplTs>
     struct collect_states_t;
 
-    // template <typename TplT>
-    // struct collect_states_t<TplT> {
-    //     using states_t = TplT;
-    // };
+
+    template <traits::fsm_state_c StT, typename... TplTs>
+    struct collect_states_t<std::tuple<StT>, TplTs...> {
+        using states_t =
+            merge_tuples_res_t<std::tuple<StT>,
+                               typename collect_states_t<typename StT::transition_t::unique_states_t>::states_t,
+                               TplTs...>;
+    };
 
     template <traits::fsm_state_c... StTs, typename... TplTs>
     struct collect_states_t<std::tuple<StTs...>, TplTs...> {
@@ -342,7 +351,7 @@ protected:
     };
 
 
-    using states_t = typename collect_states_t<InitStateT>::states_t;
+    using states_t = typename collect_states_t<std::tuple<InitStateT>>::states_t;
 
     states_t _states;
     typename variant_maker_t<states_t>::variant_t _currentStateVariant;
diff --git a/cxx/tests/fsm_test.cpp b/cxx/tests/fsm_test.cpp
index f9b9fec..82a907b 100644
--- a/cxx/tests/fsm_test.cpp
+++ b/cxx/tests/fsm_test.cpp
@@ -1,15 +1,52 @@
+#include <cxxabi.h>
 #include <iostream>
 #include <typeinfo>
 
 #include "../mcc_fsm.h"
 
+using namespace mcc;
+
+
 struct S {
 };
 
+
+struct EV1 {
+    static constexpr std::string_view ID = "EV1";
+
+    // EV1() = default;
+    // EV1(EV1&&) = default;
+    // EV1& operator=(EV1&&) = default;
+};
+
+struct EV2 {
+    static constexpr std::string_view ID = "EV2";
+};
+
+
+struct STN : fsm::MccFsmAbstractState {
+    static constexpr std::string_view ID = "STN";
+    using transition_t = trans_table_t<std::pair<EV1, STN>, std::pair<EV2, STN>>;
+};
+
+struct ST2 : fsm::MccFsmAbstractState {
+    static constexpr std::string_view ID = "ST2";
+    using transition_t = trans_table_t<std::pair<EV2, STN>>;
+};
+
+struct ST1 : fsm::MccFsmAbstractState {
+    static constexpr std::string_view ID = "ST1";
+    using transition_t = trans_table_t<std::pair<EV1, ST2>, std::pair<EV2, STN>>;
+};
+
+// using tr_t = fsm::MccFsmAbstractState::trans_table_t<std::pair<EV1, ST1>>;
+
+// static_assert(fsm::traits::fsm_trans_table_c<tr_t>, "!!!!!!!!!!!!!");
+
+// fsm::MccFiniteStateMachine<ST1> fsm;
+
 int main()
 {
-    using namespace mcc;
-
     typedef fsm::unique_tuple_t<int, float, long, int, double, char, long> ut_t;
 
     std::cout << "type index: " << fsm::unique_tuple_type_index_t<double, ut_t>::index << " (double)\n";
@@ -37,5 +74,18 @@ int main()
     using t2_t = fsm::pair_holder_second_t<ph_t>::second_t;
     std::cout << "second types: " << typeid(t2_t).name() << "\n";
 
+
+    using tp1_t = std::tuple<int, float, long, char>;
+    using tp2_t = std::tuple<double, float, char*>;
+
+    int status;
+    char* aa = abi::__cxa_demangle(typeid(STN::transition_t::states_t).name(), NULL, NULL, &status);
+    std::cout << "aa = " << aa << "\n";
+    char* uu = abi::__cxa_demangle(typeid(STN::transition_t::unique_states_t).name(), NULL, NULL, &status);
+    std::cout << "uu = " << uu << "\n";
+
+    free(aa);
+    free(uu);
+
     return 0;
 }