diff --git a/alib2data/src/automaton/PDA/DPDA.h b/alib2data/src/automaton/PDA/DPDA.h
index ac1886daf3a4141f86c33aa3bde466498b01aac9..4d50b7e589355b846440d5818001ba63d7201060 100644
--- a/alib2data/src/automaton/PDA/DPDA.h
+++ b/alib2data/src/automaton/PDA/DPDA.h
@@ -215,18 +215,18 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::tuple < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType >, std::vector < DefaultSymbolType > >, std::pair < DefaultStateType, std::vector < DefaultSymbolType > > > new_transitions;
-		for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( transitions ) ) {
-			std::pair < DefaultStateType, std::vector < DefaultSymbolType > > target = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) ), AutomatonNormalize::normalizeSymbols ( std::move ( transition.second.second ) ) );
+		DPDA < > * res = new DPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
 
+		for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( transitions ) ) {
 			std::vector < DefaultSymbolType > pop = AutomatonNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( transition.first ) ) );
-			auto key = std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) ), std::move ( pop ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
 
-			new_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
-		}
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
+			std::vector < DefaultSymbolType > push = AutomatonNormalize::normalizeSymbols ( std::move ( transition.second.second ) );
 
-		DPDA < > * res = new DPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
-		res->transitions = std::move ( new_transitions );
+			res->addTransition ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ), std::move ( push ) );
+		}
 
 		return res;
 	}
diff --git a/alib2data/src/automaton/PDA/InputDrivenDPDA.h b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
index 4fde07b4a0b0c66541cdb80ce06b84b1b8312d71..50acae12b7c150b57a20f3b51469b7c77ef4ad81 100644
--- a/alib2data/src/automaton/PDA/InputDrivenDPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
@@ -219,26 +219,25 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > new_transitions;
+		InputDrivenDPDA < > * res = new InputDrivenDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::pair < StateType, InputSymbolType >, StateType > && transition : std::make_moveable_map ( transitions ) ) {
-			DefaultStateType target = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			DefaultSymbolType input = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
+
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
 
-			auto key = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) ), AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) ) );
-			new_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
+			res->addTransition ( std::move ( from ), std::move ( input ), std::move ( to ) );
 		}
 
-		std::map < DefaultSymbolType, std::pair < std::vector < DefaultSymbolType >, std::vector < DefaultSymbolType > > > new_inputSymbolToPushdownStoreOperation;
 		for ( std::pair < InputSymbolType, std::pair < std::vector < InputSymbolType >, std::vector < InputSymbolType > > > && pushdownOperation : std::make_moveable_map ( inputSymbolToPushdownStoreOperation ) ) {
+			DefaultSymbolType target = AutomatonNormalize::normalizeSymbol ( std::move ( pushdownOperation.first ) );
 			std::vector < DefaultSymbolType > pop = AutomatonNormalize::normalizeSymbols ( std::move ( pushdownOperation.second.first ) );
 			std::vector < DefaultSymbolType > push = AutomatonNormalize::normalizeSymbols ( std::move ( pushdownOperation.second.second ) );
 
-			new_inputSymbolToPushdownStoreOperation.insert ( std::make_pair ( AutomatonNormalize::normalizeSymbol ( std::move ( pushdownOperation.first ) ), std::make_pair ( std::move ( pop ), std::move ( push ) ) ) );
+			res->setPushdownStoreOperation ( std::move ( target ), std::move ( pop ), std::move ( push ) );
 		}
 
-		InputDrivenDPDA < > * res = new InputDrivenDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
-		res->transitions = std::move ( new_transitions );
-		res->inputSymbolToPushdownStoreOperation = new_inputSymbolToPushdownStoreOperation;
-
 		return res;
 	}
 };
diff --git a/alib2data/src/automaton/PDA/InputDrivenNPDA.h b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
index 45e28d8996662ff06838561d7cae081d7d52d863..8778a7a579daf68dbd23d6a7a0d229ac2c4e304b 100644
--- a/alib2data/src/automaton/PDA/InputDrivenNPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
@@ -228,26 +228,25 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::pair < DefaultStateType, DefaultSymbolType >, std::set < DefaultStateType > > new_transitions;
+		InputDrivenNPDA < > * res = new InputDrivenNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::pair < StateType, InputSymbolType >, std::set < StateType > > && transition : std::make_moveable_map ( transitions ) ) {
 			std::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
 
-			auto key = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) ), AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) ) );
-			new_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			DefaultSymbolType input = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
+
+			res->addTransitions ( std::move ( from ), std::move ( input ), std::move ( targets ) );
 		}
 
-		std::map < DefaultSymbolType, std::pair < std::vector < DefaultSymbolType >, std::vector < DefaultSymbolType > > > new_inputSymbolToPushdownStoreOperation;
 		for ( std::pair < InputSymbolType, std::pair < std::vector < InputSymbolType >, std::vector < InputSymbolType > > > && pushdownOperation : std::make_moveable_map ( inputSymbolToPushdownStoreOperation ) ) {
+			DefaultSymbolType target = AutomatonNormalize::normalizeSymbol ( std::move ( pushdownOperation.first ) );
 			std::vector < DefaultSymbolType > pop = AutomatonNormalize::normalizeSymbols ( std::move ( pushdownOperation.second.first ) );
 			std::vector < DefaultSymbolType > push = AutomatonNormalize::normalizeSymbols ( std::move ( pushdownOperation.second.second ) );
 
-			new_inputSymbolToPushdownStoreOperation.insert ( std::make_pair ( AutomatonNormalize::normalizeSymbol ( std::move ( pushdownOperation.first ) ), std::make_pair ( std::move ( pop ), std::move ( push ) ) ) );
+			res->setPushdownStoreOperation ( std::move ( target ), std::move ( pop ), std::move ( push ) );
 		}
 
-		InputDrivenNPDA < > * res = new InputDrivenNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
-		res->transitions = std::move ( new_transitions );
-		res->inputSymbolToPushdownStoreOperation = new_inputSymbolToPushdownStoreOperation;
-
 		return res;
 	}
 };
diff --git a/alib2data/src/automaton/PDA/NPDA.h b/alib2data/src/automaton/PDA/NPDA.h
index d0b75a5afec72d79d6bc5bd88979057a7f064525..2b0d043d2c6bc2aaf910ca9e23c4c7cfc67e1570 100644
--- a/alib2data/src/automaton/PDA/NPDA.h
+++ b/alib2data/src/automaton/PDA/NPDA.h
@@ -213,21 +213,20 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::tuple < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType >, std::vector < DefaultSymbolType > >, std::set < std::pair < DefaultStateType, std::vector < DefaultSymbolType > > > > new_transitions;
+		NPDA < > * res = new NPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
 			std::set < std::pair < DefaultStateType, std::vector < DefaultSymbolType > > > targets;
 			for ( std::pair < StateType, std::vector < PushdownStoreSymbolType > > && target : std::make_moveable_set ( transition.second ) )
 				targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), AutomatonNormalize::normalizeSymbols ( std::move ( target.second ) ) ) );
 
 			std::vector < DefaultSymbolType > pop = AutomatonNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( transition.first ) ) );
-			auto key = std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) ), std::move ( pop ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			std::variant < DefaultEpsilonType, DefaultStateType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
 
-			new_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			res->addTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( targets ) );
 		}
 
-		NPDA < > * res = new NPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
-		res->transitions = std::move ( new_transitions );
-
 		return res;
 	}
 };
diff --git a/alib2data/src/automaton/PDA/NPDTA.h b/alib2data/src/automaton/PDA/NPDTA.h
index bc625ac02e12fddf7ef4b68eb5f5c8fc578e56a0..b1d274e0495f1aba97e51681f7f28c99518602e2 100644
--- a/alib2data/src/automaton/PDA/NPDTA.h
+++ b/alib2data/src/automaton/PDA/NPDTA.h
@@ -238,21 +238,20 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::tuple < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType >, std::vector < DefaultSymbolType > >, std::set < std::tuple < DefaultStateType, std::vector < DefaultSymbolType >, std::vector < DefaultSymbolType > > > > new_transitions;
+		NPDTA < > * res = new NPDTA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( outputAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
 			std::set < std::tuple < DefaultStateType, std::vector < DefaultSymbolType >, std::vector < DefaultSymbolType > > > targets;
 			for ( std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > && target : std::make_moveable_set ( transition.second ) )
 				targets.insert ( std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( target ) ) ), AutomatonNormalize::normalizeSymbols ( std::move ( std::get < 1 > ( target ) ) ), AutomatonNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( target ) ) ) ) );
 
 			std::vector < DefaultSymbolType > pop = AutomatonNormalize::normalizeSymbols ( std::move ( std::get < 2 > ( transition.first ) ) );
-			auto key = std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) ), std::move ( pop ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
 
-			new_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			res->addTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( targets ) );
 		}
 
-		NPDTA < > * res = new NPDTA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( outputAlphabet ), std::move ( initialState ), std::move ( initialSymbol ), std::move ( finalStates ) );
-		res->transitions = std::move ( new_transitions );
-
 		return res;
 	}
 };
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
index 40cacc9c904017ce71b47eeb0dcd7982b9fc1138..8b211549583a650907a828e4a5720ca34ec3c82c 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
@@ -241,37 +241,36 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::pair < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType > >, std::pair < DefaultStateType, DefaultSymbolType > > new_call_transitions;
+		RealTimeHeightDeterministicDPDA < > * res = new RealTimeHeightDeterministicDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > && transition : std::make_moveable_map ( callTransitions ) ) {
-			std::pair < DefaultStateType, DefaultSymbolType > target = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) ), AutomatonNormalize::normalizeSymbol ( std::move ( transition.second.second ) ) );
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
+			DefaultSymbolType push = AutomatonNormalize::normalizeSymbol ( std::move ( transition.second.second ) );
+
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
 
-			auto key = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) ) );
-			new_call_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
+			res->addCallTransition ( std::move ( from ), std::move ( input ), std::move ( to ), std::move ( push ) );
 		}
 
-		std::map < std::tuple < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType >, DefaultSymbolType >, DefaultStateType > new_return_transitions;
 		for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > && transition : std::make_moveable_map ( returnTransitions ) ) {
-			DefaultStateType target = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
 
-			DefaultSymbolType popSymbol ( alib::AnyObject < PushdownStoreSymbolType > ( std::move ( std::get < 2 > ( transition.first ) ) ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
+			DefaultSymbolType pop ( alib::AnyObject < PushdownStoreSymbolType > ( std::move ( std::get < 2 > ( transition.first ) ) ) );
 
-			auto key = std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) ), std::move ( popSymbol ) );
-			new_return_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
+			res->addReturnTransition ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ) );
 		}
 
-		std::map < std::pair < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType > >, DefaultStateType > new_local_transitions;
 		for ( std::pair < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, StateType > && transition : std::make_moveable_map ( localTransitions ) ) {
-			DefaultStateType target = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
 
-			auto key = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) ) );
-			new_local_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
+			res->addLocalTransition ( std::move ( from ), std::move ( input ), std::move ( to ) );
 		}
 
-		RealTimeHeightDeterministicDPDA < > * res = new RealTimeHeightDeterministicDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
-		res->callTransitions = std::move ( new_call_transitions );
-		res->returnTransitions = std::move ( new_return_transitions );
-		res->localTransitions = std::move ( new_local_transitions );
-
 		return res;
 	}
 };
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
index 0a683c755b91a43bfd4951be02943bc9e6e1a7e8..08331d2f1e958b27d35719156668e0d7564c89fe 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
@@ -282,38 +282,36 @@ public:
 		std::set < DefaultStateType > initialStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < InitialStates > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::pair < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType > >, std::set < std::pair < DefaultStateType, DefaultSymbolType > > > new_call_transitions;
+		RealTimeHeightDeterministicNPDA < > * res = new RealTimeHeightDeterministicNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialStates ), std::move ( bottomSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( callTransitions ) ) {
 			std::set < std::pair < DefaultStateType, DefaultSymbolType > > targets;
 			for ( std::pair < StateType, PushdownStoreSymbolType > && target : std::make_moveable_set ( transition.second ) )
 				targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), AutomatonNormalize::normalizeSymbol ( std::move ( target.second ) ) ) );
 
-			auto key = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) ) );
-			new_call_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
+			res->addCallTransitions ( std::move ( from ), std::move ( input ), std::move ( targets ) );
 		}
 
-		std::map < std::tuple < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType >, DefaultSymbolType >, std::set < DefaultStateType > > new_return_transitions;
 		for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < StateType > > && transition : std::make_moveable_map ( returnTransitions ) ) {
 			std::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
 
 			DefaultSymbolType popSymbol ( alib::AnyObject < PushdownStoreSymbolType > ( std::move ( std::get < 2 > ( transition.first ) ) ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
 
-			auto key = std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) ), std::move ( popSymbol ) );
-			new_return_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			res->addReturnTransitions ( std::move ( from ), std::move ( input ), std::move ( popSymbol ), std::move ( targets ) );
 		}
 
-		std::map < std::pair < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType > >, std::set < DefaultStateType > > new_local_transitions;
 		for ( std::pair < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < StateType > > && transition : std::make_moveable_map ( localTransitions ) ) {
 			std::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
 
-			auto key = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) ) );
-			new_local_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
-		}
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( transition.first.second ) );
 
-		RealTimeHeightDeterministicNPDA < > * res = new RealTimeHeightDeterministicNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialStates ), std::move ( bottomSymbol ), std::move ( finalStates ) );
-		res->callTransitions = std::move ( new_call_transitions );
-		res->returnTransitions = std::move ( new_return_transitions );
-		res->localTransitions = std::move ( new_local_transitions );
+			res->addLocalTransitions ( std::move ( from ), std::move ( input ), std::move ( targets ) );
+		}
 
 		return res;
 	}
diff --git a/alib2data/src/automaton/PDA/SinglePopDPDA.h b/alib2data/src/automaton/PDA/SinglePopDPDA.h
index 0922fb2d5b3dd67d34e296d31b562e24b292a691..327b67fdd7a7596abb93d7ad5fbe6e5a5c954e4c 100644
--- a/alib2data/src/automaton/PDA/SinglePopDPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopDPDA.h
@@ -206,19 +206,19 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::tuple < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType >, DefaultSymbolType >, std::pair < DefaultStateType, std::vector < DefaultSymbolType > > > new_transitions;
+		SinglePopDPDA < > * res = new SinglePopDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( transitions ) ) {
-			std::pair < DefaultStateType, std::vector < DefaultSymbolType > > target = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) ), AutomatonNormalize::normalizeSymbols ( std::move ( transition.second.second ) ) );
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
+			std::vector < DefaultSymbolType > push = AutomatonNormalize::normalizeSymbols ( std::move ( transition.second.second ) );
 
 			DefaultSymbolType pop = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
-			auto key = std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) ), std::move ( pop ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
 
-			new_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
+			res->addTransition ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ), std::move ( push ) );
 		}
 
-		SinglePopDPDA < > * res = new SinglePopDPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
-		res->transitions = std::move ( new_transitions );
-
 		return res;
 	}
 };
diff --git a/alib2data/src/automaton/PDA/SinglePopNPDA.h b/alib2data/src/automaton/PDA/SinglePopNPDA.h
index 27cbec3b47d8f80530109d0baed9c560b060d005..4b8406f439e1cea8a64f2d603b2dd4607c2aad78 100644
--- a/alib2data/src/automaton/PDA/SinglePopNPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopNPDA.h
@@ -213,21 +213,20 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::tuple < DefaultStateType, std::variant < DefaultEpsilonType, DefaultSymbolType >, DefaultSymbolType >, std::set < std::pair < DefaultStateType, std::vector < DefaultSymbolType > > > > new_transitions;
+		SinglePopNPDA < > * res = new SinglePopNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > && transition : std::make_moveable_map ( transitions ) ) {
 			std::set < std::pair < DefaultStateType, std::vector < DefaultSymbolType > > > targets;
 			for ( std::pair < StateType, std::vector < PushdownStoreSymbolType > > && target : std::make_moveable_set ( transition.second ) )
 				targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), AutomatonNormalize::normalizeSymbols ( std::move ( target.second ) ) ) );
 
 			DefaultSymbolType pop = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
-			auto key = std::make_tuple ( AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) ), AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) ), std::move ( pop ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			std::variant < DefaultEpsilonType, DefaultSymbolType > input = AutomatonNormalize::normalizeSymbolEpsilon ( std::move ( std::get < 1 > ( transition.first ) ) );
 
-			new_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			res->addTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( targets ) );
 		}
 
-		SinglePopNPDA < > * res = new SinglePopNPDA < > ( std::move ( states ), std::move ( alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
-		res->transitions = std::move ( new_transitions );
-
 		return res;
 	}
 };
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
index 59aada779b65b072b48450fb1829bb30724622ca..a6d5504f9e937e8f9607fa8f039871c8168ac838 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
@@ -276,45 +276,37 @@ public:
 		DefaultStateType initialState = AutomatonNormalize::normalizeState ( std::move ( this->template accessElement < InitialState > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::pair < DefaultStateType, DefaultSymbolType >, std::pair < DefaultStateType, DefaultSymbolType > > new_call_transitions;
+		VisiblyPushdownDPDA < > * res = new VisiblyPushdownDPDA < > ( std::move ( states ), std::move ( call_alphabet ), std::move ( return_alphabet ), std::move ( local_alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::pair < StateType, InputSymbolType >, std::pair < StateType, PushdownStoreSymbolType > > && transition : std::make_moveable_map ( callTransitions ) ) {
-			std::pair < DefaultStateType, DefaultSymbolType > target = std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) ), AutomatonNormalize::normalizeSymbol ( std::move ( transition.second.second ) ) );
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second.first ) );
+			DefaultSymbolType push = AutomatonNormalize::normalizeSymbol ( std::move ( transition.second.second ) );
 
-			DefaultStateType fromState = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
-			DefaultSymbolType inputSymbol = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			DefaultSymbolType input = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
 
-			auto key = std::make_pair ( std::move ( fromState ), std::move ( inputSymbol ) );
-			new_call_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
+			res->addCallTransition ( std::move ( from ), std::move ( input ), std::move ( to ), std::move ( push ) );
 		}
 
-		std::map < std::tuple < DefaultStateType, DefaultSymbolType, DefaultSymbolType >, DefaultStateType > new_return_transitions;
 		for ( std::pair < std::tuple < StateType, InputSymbolType, PushdownStoreSymbolType >, StateType > && transition : std::make_moveable_map ( returnTransitions ) ) {
-			DefaultStateType target = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
 
-			DefaultStateType fromState = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
-			DefaultSymbolType inputSymbol = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 1 > ( transition.first ) ) );
-			DefaultSymbolType popSymbol = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			DefaultSymbolType input = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 1 > ( transition.first ) ) );
+			DefaultSymbolType pop = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
 
-			auto key = std::make_tuple ( std::move ( fromState ), std::move ( inputSymbol ), std::move ( popSymbol ) );
-			new_return_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
+			res->addReturnTransition ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ) );
 		}
 
-		std::map < std::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > new_local_transitions;
 		for ( std::pair < std::pair < StateType, InputSymbolType >, StateType > && transition : std::make_moveable_map ( localTransitions ) ) {
-			DefaultStateType target = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
+			DefaultStateType to = AutomatonNormalize::normalizeState ( std::move ( transition.second ) );
 
-			DefaultStateType fromState = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
-			DefaultSymbolType inputSymbol = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			DefaultSymbolType input = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
 
-			auto key = std::make_pair ( std::move ( fromState ), std::move ( inputSymbol ) );
-			new_local_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( target ) ) );
+			res->addLocalTransition ( std::move ( from ), std::move ( input ), std::move ( to ) );
 		}
 
-		VisiblyPushdownDPDA < > * res = new VisiblyPushdownDPDA < > ( std::move ( states ), std::move ( call_alphabet ), std::move ( return_alphabet ), std::move ( local_alphabet ), std::move ( pushdownAlphabet ), std::move ( initialState ), std::move ( bottomSymbol ), std::move ( finalStates ) );
-		res->callTransitions = std::move ( new_call_transitions );
-		res->returnTransitions = std::move ( new_return_transitions );
-		res->localTransitions = std::move ( new_local_transitions );
-
 		return res;
 	}
 };
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
index 34eb428298ba521c0a3010ccbd0447dfdfca46f0..5847406c47a491e85bdfafaae23b68457ee570ad 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
@@ -311,47 +311,38 @@ public:
 		std::set < DefaultStateType > initialStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < InitialStates > ( ).get ( ) ) );
 		std::set < DefaultStateType > finalStates = AutomatonNormalize::normalizeStates ( std::move ( this->template accessComponent < FinalStates > ( ).get ( ) ) );
 
-		std::map < std::pair < DefaultStateType, DefaultSymbolType >, std::set < std::pair < DefaultStateType, DefaultSymbolType > > > new_call_transitions;
+		VisiblyPushdownNPDA < > * res = new VisiblyPushdownNPDA < > ( std::move ( states ), std::move ( call_alphabet ), std::move ( return_alphabet ), std::move ( local_alphabet ), std::move ( pushdownAlphabet ), std::move ( initialStates ), std::move ( bottomSymbol ), std::move ( finalStates ) );
+
 		for ( std::pair < std::pair < StateType, InputSymbolType >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > && transition : std::make_moveable_map ( callTransitions ) ) {
 			std::set < std::pair < DefaultStateType, DefaultSymbolType > > targets;
 			for ( std::pair < StateType, PushdownStoreSymbolType > && target : std::make_moveable_set ( transition.second ) )
 				targets.insert ( std::make_pair ( AutomatonNormalize::normalizeState ( std::move ( target.first ) ), AutomatonNormalize::normalizeSymbol ( std::move ( target.second ) ) ) );
 
-			DefaultStateType fromState = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
-			DefaultSymbolType inputSymbol = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			DefaultSymbolType input = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
 
-			auto key = std::make_pair ( std::move ( fromState ), std::move ( inputSymbol ) );
-			new_call_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			res->addCallTransitions ( std::move ( from ), std::move ( input ), std::move ( targets ) );
 		}
 
-		std::map < std::tuple < DefaultStateType, DefaultSymbolType, DefaultSymbolType >, std::set < DefaultStateType > > new_return_transitions;
 		for ( std::pair < std::tuple < StateType, InputSymbolType, PushdownStoreSymbolType >, std::set < StateType > > && transition : std::make_moveable_map ( returnTransitions ) ) {
-			std::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
+			std::set < DefaultStateType > to = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
 
-			DefaultStateType fromState = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
-			DefaultSymbolType inputSymbol = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 1 > ( transition.first ) ) );
-			DefaultSymbolType popSymbol = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( std::get < 0 > ( transition.first ) ) );
+			DefaultSymbolType input = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 1 > ( transition.first ) ) );
+			DefaultSymbolType pop = AutomatonNormalize::normalizeSymbol ( std::move ( std::get < 2 > ( transition.first ) ) );
 
-			auto key = std::make_tuple ( std::move ( fromState ), std::move ( inputSymbol ), std::move ( popSymbol ) );
-			new_return_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			res->addReturnTransitions ( std::move ( from ), std::move ( input ), std::move ( pop ), std::move ( to ) );
 		}
 
-		std::map < std::pair < DefaultStateType, DefaultSymbolType >, std::set < DefaultStateType > > new_local_transitions;
 		for ( std::pair < std::pair < StateType, InputSymbolType >, std::set < StateType > > && transition : std::make_moveable_map ( localTransitions ) ) {
-			std::set < DefaultStateType > targets = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
+			std::set < DefaultStateType > to = AutomatonNormalize::normalizeStates ( std::move ( transition.second ) );
 
-			DefaultStateType fromState = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
-			DefaultSymbolType inputSymbol = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
+			DefaultStateType from = AutomatonNormalize::normalizeState ( std::move ( transition.first.first ) );
+			DefaultSymbolType input = AutomatonNormalize::normalizeSymbol ( std::move ( transition.first.second ) );
 
-			auto key = std::make_pair ( std::move ( fromState ), std::move ( inputSymbol ) );
-			new_local_transitions.insert ( std::make_pair ( std::move ( key ), std::move ( targets ) ) );
+			res->addLocalTransitions ( std::move ( from ), std::move ( input ), std::move ( to ) );
 		}
 
-		VisiblyPushdownNPDA < > * res = new VisiblyPushdownNPDA < > ( std::move ( states ), std::move ( call_alphabet ), std::move ( return_alphabet ), std::move ( local_alphabet ), std::move ( pushdownAlphabet ), std::move ( initialStates ), std::move ( bottomSymbol ), std::move ( finalStates ) );
-		res->callTransitions = std::move ( new_call_transitions );
-		res->returnTransitions = std::move ( new_return_transitions );
-		res->localTransitions = std::move ( new_local_transitions );
-
 		return res;
 	}
 };