From a35033d179569f88ce3bfc696a4126e75437e16f Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Fri, 19 Aug 2016 21:14:48 +0200
Subject: [PATCH] remove automaton::State in favour of label::Label from data

---
 alib2data/src/automaton/Automaton.cpp         |  19 --
 alib2data/src/automaton/Automaton.h           |   5 -
 alib2data/src/automaton/AutomatonFeatures.h   |   1 -
 alib2data/src/automaton/FSM/CompactNFA.cpp    |  58 +++---
 alib2data/src/automaton/FSM/CompactNFA.h      |  66 +++----
 alib2data/src/automaton/FSM/DFA.cpp           |  48 ++---
 alib2data/src/automaton/FSM/DFA.h             |  66 +++----
 alib2data/src/automaton/FSM/EpsilonNFA.cpp    | 116 ++++++------
 alib2data/src/automaton/FSM/EpsilonNFA.h      |  83 ++++-----
 alib2data/src/automaton/FSM/ExtendedNFA.cpp   |  60 +++----
 alib2data/src/automaton/FSM/ExtendedNFA.h     |  66 +++----
 .../automaton/FSM/MultiInitialStateNFA.cpp    |  46 ++---
 .../src/automaton/FSM/MultiInitialStateNFA.h  |  68 +++----
 alib2data/src/automaton/FSM/NFA.cpp           |  46 ++---
 alib2data/src/automaton/FSM/NFA.h             |  66 +++----
 alib2data/src/automaton/PDA/DPDA.cpp          |  68 +++----
 alib2data/src/automaton/PDA/DPDA.h            |  76 ++++----
 .../src/automaton/PDA/InputDrivenDPDA.cpp     |  50 +++---
 alib2data/src/automaton/PDA/InputDrivenDPDA.h |  66 +++----
 .../src/automaton/PDA/InputDrivenNPDA.cpp     |  48 ++---
 alib2data/src/automaton/PDA/InputDrivenNPDA.h |  66 +++----
 alib2data/src/automaton/PDA/NPDA.cpp          |  40 ++---
 alib2data/src/automaton/PDA/NPDA.h            |  76 ++++----
 alib2data/src/automaton/PDA/NPDTA.cpp         |  46 ++---
 alib2data/src/automaton/PDA/NPDTA.h           |  82 ++++-----
 .../PDA/RealTimeHeightDeterministicDPDA.cpp   | 104 +++++------
 .../PDA/RealTimeHeightDeterministicDPDA.h     | 114 ++++++------
 .../PDA/RealTimeHeightDeterministicNPDA.cpp   |  92 +++++-----
 .../PDA/RealTimeHeightDeterministicNPDA.h     | 126 ++++++-------
 alib2data/src/automaton/PDA/SinglePopDPDA.cpp |  52 +++---
 alib2data/src/automaton/PDA/SinglePopDPDA.h   |  72 ++++----
 alib2data/src/automaton/PDA/SinglePopNPDA.cpp |  40 ++---
 alib2data/src/automaton/PDA/SinglePopNPDA.h   |  76 ++++----
 .../src/automaton/PDA/VisiblyPushdownDPDA.cpp |  80 ++++-----
 .../src/automaton/PDA/VisiblyPushdownDPDA.h   |  90 +++++-----
 .../src/automaton/PDA/VisiblyPushdownNPDA.cpp |  68 +++----
 .../src/automaton/PDA/VisiblyPushdownNPDA.h   | 102 +++++------
 alib2data/src/automaton/TA/DFTA.cpp           |  26 +--
 alib2data/src/automaton/TA/DFTA.h             |  52 +++---
 alib2data/src/automaton/TA/NFTA.cpp           |  28 +--
 alib2data/src/automaton/TA/NFTA.h             |  52 +++---
 alib2data/src/automaton/TM/OneTapeDTM.cpp     |  36 ++--
 alib2data/src/automaton/TM/OneTapeDTM.h       |  62 +++----
 .../common/AutomatonFromXMLParser.cpp         |  37 ++--
 .../automaton/common/AutomatonFromXMLParser.h |  18 +-
 .../common/AutomatonToXMLComposer.cpp         |  30 ++--
 .../automaton/common/AutomatonToXMLComposer.h |  15 +-
 alib2data/src/automaton/common/State.cpp      |  92 ----------
 alib2data/src/automaton/common/State.h        |  81 ---------
 alib2data/src/grammar/parsing/LRParserTypes.h |   6 +-
 alib2data/src/label/Label.cpp                 |  15 ++
 alib2data/src/label/Label.h                   |   4 +
 .../test-src/automaton/AutomatonTest.cpp      | 169 +++++++++---------
 53 files changed, 1497 insertions(+), 1674 deletions(-)
 delete mode 100644 alib2data/src/automaton/common/State.cpp
 delete mode 100644 alib2data/src/automaton/common/State.h

diff --git a/alib2data/src/automaton/Automaton.cpp b/alib2data/src/automaton/Automaton.cpp
index 420fc3f02d..050570460d 100644
--- a/alib2data/src/automaton/Automaton.cpp
+++ b/alib2data/src/automaton/Automaton.cpp
@@ -6,28 +6,9 @@
  */
 
 #include "Automaton.h"
-#include "common/State.h"
-#include <climits>
 #include "AutomatonException.h"
 #include <XmlApi.hpp>
 
-namespace automaton {
-
-State createUniqueState ( State nextState, const std::set < State > & other ) {
-	int i = 0;
-
-	do {
-		if ( other.count ( nextState ) == 0 )
-			return nextState;
-
-		nextState.getName ( ).inc ( );
-	} while ( i++ < INT_MAX );
-
-	throw AutomatonException ( "Could not create unique state." );
-}
-
-} /* namespace automaton */
-
 namespace alib {
 
 auto AutomatonDeleter = xmlApi < automaton::Automaton >::InputContextDeleter ( );
diff --git a/alib2data/src/automaton/Automaton.h b/alib2data/src/automaton/Automaton.h
index 55c0603e75..d00e5515cb 100644
--- a/alib2data/src/automaton/Automaton.h
+++ b/alib2data/src/automaton/Automaton.h
@@ -11,9 +11,6 @@
 #include <base/WrapperBase.hpp>
 #include "AutomatonBase.h"
 
-#include "AutomatonFeatures.h"
-#include <set>
-
 namespace automaton {
 
 /**
@@ -30,8 +27,6 @@ public:
 	}
 };
 
-State createUniqueState ( State base, const std::set < State > & other );
-
 } /* namespace automaton */
 
 #endif /* AUTOMATON_H_ */
diff --git a/alib2data/src/automaton/AutomatonFeatures.h b/alib2data/src/automaton/AutomatonFeatures.h
index ec1eb6b9e3..f8264c73e9 100644
--- a/alib2data/src/automaton/AutomatonFeatures.h
+++ b/alib2data/src/automaton/AutomatonFeatures.h
@@ -34,7 +34,6 @@ enum class FEATURES {
 
 class Automaton;
 class AutomatonBase;
-class State;
 enum class Shift;
 
 class EpsilonNFA;
diff --git a/alib2data/src/automaton/FSM/CompactNFA.cpp b/alib2data/src/automaton/FSM/CompactNFA.cpp
index 0c041a9eaa..83d6712e7b 100644
--- a/alib2data/src/automaton/FSM/CompactNFA.cpp
+++ b/alib2data/src/automaton/FSM/CompactNFA.cpp
@@ -24,44 +24,44 @@
 
 namespace automaton {
 
-CompactNFA::CompactNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < CompactNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+CompactNFA::CompactNFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates ) : std::Components < CompactNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-CompactNFA::CompactNFA ( State initialState ) : CompactNFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
+CompactNFA::CompactNFA ( label::Label initialState ) : CompactNFA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < label::Label > { } ) {
 }
 
 CompactNFA::CompactNFA ( const EpsilonNFA & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
 		if ( transition.first.second.is < string::Epsilon > ( ) ) {
-			std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { } ) );
+			std::pair < label::Label, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { } ) );
 			transitions[key] = transition.second;
 		} else {
-			std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second.get < alphabet::Symbol > ( ) } ) );
+			std::pair < label::Label, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second.get < alphabet::Symbol > ( ) } ) );
 			transitions[key] = transition.second;
 		}
 	}
 }
 
-CompactNFA::CompactNFA ( const MultiInitialStateNFA & other ) : CompactNFA ( other.getStates ( ) + std::set < State > { automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
+CompactNFA::CompactNFA ( const MultiInitialStateNFA & other ) : CompactNFA ( other.getStates ( ) + std::set < label::Label > { label::createUniqueLabel ( label::labelFrom ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), label::createUniqueLabel ( label::labelFrom ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
+		std::pair < label::Label, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
 		transitions[key] = transition.second;
 	}
 
-	std::pair < State, string::LinearString > key = std::make_pair ( this->getInitialState ( ), string::LinearString ( std::vector < alphabet::Symbol > { } ) );
+	std::pair < label::Label, string::LinearString > key = std::make_pair ( this->getInitialState ( ), string::LinearString ( std::vector < alphabet::Symbol > { } ) );
 	transitions[key] = other.getInitialStates ( );
 }
 
 CompactNFA::CompactNFA ( const NFA & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
+		std::pair < label::Label, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
 		transitions[key] = transition.second;
 	}
 }
 
 CompactNFA::CompactNFA ( const DFA & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
+		std::pair < label::Label, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
 		transitions[key].insert ( transition.second );
 	}
 }
@@ -74,9 +74,9 @@ AutomatonBase * CompactNFA::plunder ( ) && {
 	return new CompactNFA ( std::move ( * this ) );
 }
 
-bool CompactNFA::addTransition ( State from, string::LinearString input, State to ) {
+bool CompactNFA::addTransition ( label::Label from, string::LinearString input, label::Label to ) {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist." );
 
 	const std::set < alphabet::Symbol > & inputStringAlphabet = input.getAlphabet ( );
 
@@ -85,43 +85,43 @@ bool CompactNFA::addTransition ( State from, string::LinearString input, State t
 		throw AutomatonException ( "Input string is over different alphabet than automaton" );
 
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist." );
 
-	std::pair < State, string::LinearString > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+	std::pair < label::Label, string::LinearString > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
 	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool CompactNFA::removeTransition ( const State & from, const string::LinearString & input, const State & to ) {
-	std::pair < State, string::LinearString > key = std::make_pair ( from, input );
+bool CompactNFA::removeTransition ( const label::Label & from, const string::LinearString & input, const label::Label & to ) {
+	std::pair < label::Label, string::LinearString > key = std::make_pair ( from, input );
 
 	return transitions[key].erase ( to );
 }
 
-const std::map < std::pair < State, string::LinearString >, std::set < State > > & CompactNFA::getTransitions ( ) const {
+const std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > & CompactNFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map < std::pair < State, string::LinearString >, std::set < State > > CompactNFA::getTransitionsFromState ( const State & from ) const {
+std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > CompactNFA::getTransitionsFromState ( const label::Label & from ) const {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist" );
 
-	std::map < std::pair < State, string::LinearString >, std::set < State > > transitionsFromState;
+	std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > transitionsFromState;
 
-	for ( const std::pair < const std::pair < State, string::LinearString >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, string::LinearString >, std::set < label::Label > > & transition : transitions )
 		if ( transition.first.first == from )
 			transitionsFromState.insert ( make_pair ( transition.first, transition.second ) );
 
 	return transitionsFromState;
 }
 
-std::map < std::pair < State, string::LinearString >, std::set < State > > CompactNFA::getTransitionsToState ( const State & to ) const {
+std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > CompactNFA::getTransitionsToState ( const label::Label & to ) const {
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist" );
 
-	std::map < std::pair < State, string::LinearString >, std::set < State > > transitionsToState;
+	std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > transitionsToState;
 
-	for ( const std::pair < const std::pair < State, string::LinearString >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, string::LinearString >, std::set < label::Label > > & transition : transitions )
 		if ( transition.second.find ( to ) != transition.second.end ( ) )
 			transitionsToState.insert ( make_pair ( transition.first, transition.second ) );
 
@@ -156,10 +156,10 @@ CompactNFA::operator std::string ( ) const {
 CompactNFA CompactNFA::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, CompactNFA::getXmlTagName() );
 
-	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < label::Label > states = AutomatonFromXMLParser::parseStates ( input );
 	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
-	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
-	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < label::Label > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
 	CompactNFA automaton ( std::move ( initialState ) );
 
@@ -175,9 +175,9 @@ CompactNFA CompactNFA::parse ( std::deque < sax::Token >::iterator & input ) {
 
 void CompactNFA::parseTransition ( std::deque < sax::Token >::iterator & input, CompactNFA & automaton ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
-	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom ( input );
 	string::LinearString inputString = AutomatonFromXMLParser::parseTransitionInputString ( input );
-	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo ( input );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
 	automaton.addTransition ( std::move ( from ), std::move ( inputString ), std::move ( to ) );
diff --git a/alib2data/src/automaton/FSM/CompactNFA.h b/alib2data/src/automaton/FSM/CompactNFA.h
index 25af1abaf6..bd0b1b0977 100644
--- a/alib2data/src/automaton/FSM/CompactNFA.h
+++ b/alib2data/src/automaton/FSM/CompactNFA.h
@@ -12,8 +12,8 @@
 #include <map>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/LinearString.h"
 #include "EpsilonNFA.h"
 #include "MultiInitialStateNFA.h"
@@ -31,13 +31,13 @@ class States;
 class FinalStates;
 class InitialState;
 
-class CompactNFA : public AutomatonBase, public std::Components < CompactNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class CompactNFA : public AutomatonBase, public std::Components < CompactNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, string::LinearString >, std::set < State > > transitions;
+	std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > transitions;
 
 public:
-	explicit CompactNFA ( State initialState );
-	explicit CompactNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates );
+	explicit CompactNFA ( label::Label initialState );
+	explicit CompactNFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates );
 	explicit CompactNFA ( const EpsilonNFA & other );
 	explicit CompactNFA ( const MultiInitialStateNFA & other );
 	explicit CompactNFA ( const NFA & other );
@@ -47,43 +47,43 @@ public:
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -114,29 +114,29 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State current, string::LinearString input, State next );
+	bool addTransition ( label::Label current, string::LinearString input, label::Label next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const string::LinearString & input, const State & next );
+	bool removeTransition ( const label::Label & current, const string::LinearString & input, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < State, string::LinearString >, std::set < State > > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > & getTransitions ( ) const;
 
 	/**
 	 * @return automaton transitions from state
 	 */
-	std::map < std::pair < State, string::LinearString >, std::set < State > > getTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > getTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton transitions to state
 	 */
-	std::map < std::pair < State, string::LinearString >, std::set < State > > getTransitionsToState ( const State & from ) const;
+	std::map < std::pair < label::Label, string::LinearString >, std::set < label::Label > > getTransitionsToState ( const label::Label & from ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -171,7 +171,7 @@ template < >
 class ComponentConstraint< automaton::CompactNFA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::CompactNFA & automaton, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const std::pair < automaton::State, ::string::LinearString >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, ::string::LinearString >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( transition.first.second.getAlphabet ( ).count ( symbol ) )
 				return true;
 
@@ -187,53 +187,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::CompactNFA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::CompactNFA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::CompactNFA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::CompactNFA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for ( const std::pair < const std::pair < automaton::State, ::string::LinearString >, std::set < automaton::State > > & t : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, ::string::LinearString >, std::set < label::Label > > & t : automaton.getTransitions ( ) )
 			if ( ( t.first.first == state ) || t.second.count ( state ) )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::CompactNFA &, const automaton::State & ) {
+	static bool available ( const automaton::CompactNFA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::CompactNFA &, const automaton::State & ) {
+	static void valid ( const automaton::CompactNFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::CompactNFA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::CompactNFA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::CompactNFA &, const automaton::State & ) {
+	static bool used ( const automaton::CompactNFA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::CompactNFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::CompactNFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::CompactNFA &, const automaton::State & ) {
+	static void valid ( const automaton::CompactNFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::CompactNFA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::CompactNFA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::CompactNFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::CompactNFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::CompactNFA &, const automaton::State & ) {
+	static void valid ( const automaton::CompactNFA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/FSM/DFA.cpp b/alib2data/src/automaton/FSM/DFA.cpp
index 16438c6a91..c9248776e2 100644
--- a/alib2data/src/automaton/FSM/DFA.cpp
+++ b/alib2data/src/automaton/FSM/DFA.cpp
@@ -18,10 +18,10 @@
 
 namespace automaton {
 
-DFA::DFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < DFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+DFA::DFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates ) : std::Components < DFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-DFA::DFA ( State initialState ) : DFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
+DFA::DFA ( label::Label initialState ) : DFA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < label::Label > { } ) {
 }
 
 AutomatonBase * DFA::clone ( ) const {
@@ -32,66 +32,66 @@ AutomatonBase * DFA::plunder ( ) && {
 	return new DFA ( std::move ( * this ) );
 }
 
-bool DFA::addTransition ( State from, alphabet::Symbol input, State to ) {
+bool DFA::addTransition ( label::Label from, alphabet::Symbol input, label::Label to ) {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist." );
 
 	if ( !getInputAlphabet ( ).count ( input ) )
 		throw AutomatonException ( "Input symbol \"" + ( std::string ) input + "\" doesn't exist." );
 
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist." );
 
-	std::pair < State, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+	std::pair < label::Label, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
 	if ( transitions.find ( key ) != transitions.end ( ) ) {
 		if ( transitions.find ( key )->second == to )
 			return false;
 		else
-			throw AutomatonException ( "Transition from this state and symbol already exists (\"" + ( std::string ) key.first.getName ( ) + "\", \"" + ( std::string ) key.second + "\") -> \"" + ( std::string ) to.getName ( ) + "\"." );
+			throw AutomatonException ( "Transition from this state and symbol already exists (\"" + ( std::string ) key.first + "\", \"" + ( std::string ) key.second + "\") -> \"" + ( std::string ) to + "\"." );
 	}
 
 	transitions.insert ( std::make_pair ( std::move ( key ), std::move ( to ) ) );
 	return true;
 }
 
-bool DFA::removeTransition ( const State & from, const alphabet::Symbol & input, const State & to ) {
-	std::pair < State, alphabet::Symbol > key = std::make_pair ( from, input );
+bool DFA::removeTransition ( const label::Label & from, const alphabet::Symbol & input, const label::Label & to ) {
+	std::pair < label::Label, alphabet::Symbol > key = std::make_pair ( from, input );
 
 	if ( transitions.find ( key ) == transitions.end ( ) )
 		return false;
 
 	if ( transitions.find ( key )->second != to )
-		throw AutomatonException ( "Transition (\"" + ( std::string ) from.getName ( ) + "\", \"" + ( std::string ) input + "\") -> \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "Transition (\"" + ( std::string ) from + "\", \"" + ( std::string ) input + "\") -> \"" + ( std::string ) to + "\" doesn't exist." );
 
 	transitions.erase ( key );
 	return true;
 }
 
-const std::map < std::pair < State, alphabet::Symbol >, State > & DFA::getTransitions ( ) const {
+const std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > & DFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, State > DFA::getTransitionsFromState ( const State & from ) const {
+std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > DFA::getTransitionsFromState ( const label::Label & from ) const {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist" );
 
-	std::map < std::pair < State, alphabet::Symbol >, State > transitionsFromState;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > transitionsFromState;
 
-	for ( const std::pair < const std::pair < State, alphabet::Symbol >, State > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, label::Label > & transition : transitions )
 		if ( transition.first.first == from )
 			transitionsFromState.insert ( transition );
 
 	return transitionsFromState;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, State > DFA::getTransitionsToState ( const State & to ) const {
+std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > DFA::getTransitionsToState ( const label::Label & to ) const {
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist" );
 
-	std::map < std::pair < State, alphabet::Symbol >, State > transitionsToState;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > transitionsToState;
 
-	for ( const std::pair < const std::pair < State, alphabet::Symbol >, State > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, label::Label > & transition : transitions )
 		if ( transition.second == to )
 			transitionsToState.insert ( transition );
 
@@ -130,10 +130,10 @@ DFA::operator std::string ( ) const {
 DFA DFA::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, DFA::getXmlTagName() );
 
-	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < label::Label > states = AutomatonFromXMLParser::parseStates ( input );
 	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
-	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
-	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < label::Label > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
 	DFA automaton ( std::move ( initialState ) );
 
@@ -149,9 +149,9 @@ DFA DFA::parse ( std::deque < sax::Token >::iterator & input ) {
 
 void DFA::parseTransition ( std::deque < sax::Token >::iterator & input, DFA & automaton ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
-	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom ( input );
 	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol ( input );
-	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo ( input );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
 	automaton.addTransition ( std::move ( from ), std::move ( inputSymbol ), std::move ( to ) );
diff --git a/alib2data/src/automaton/FSM/DFA.h b/alib2data/src/automaton/FSM/DFA.h
index fbee8070d0..940b49febb 100644
--- a/alib2data/src/automaton/FSM/DFA.h
+++ b/alib2data/src/automaton/FSM/DFA.h
@@ -12,8 +12,8 @@
 #include <map>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 
 namespace automaton {
 
@@ -26,55 +26,55 @@ class States;
 class FinalStates;
 class InitialState;
 
-class DFA : public AutomatonBase, public std::Components < DFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class DFA : public AutomatonBase, public std::Components < DFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, alphabet::Symbol >, State > transitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > transitions;
 
 public:
-	explicit DFA ( State initialState );
-	explicit DFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates );
+	explicit DFA ( label::Label initialState );
+	explicit DFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -105,29 +105,29 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State current, alphabet::Symbol input, const State next );
+	bool addTransition ( label::Label current, alphabet::Symbol input, const label::Label next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < State, alphabet::Symbol >, State > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > & getTransitions ( ) const;
 
 	/**
 	 * @return automaton transitions from state
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, State > getTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > getTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton transitions to state
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, State > getTransitionsToState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > getTransitionsToState ( const label::Label & from ) const;
 
 	/**
 	 * Determines whether DFA is total deterministic
@@ -171,7 +171,7 @@ template < >
 class ComponentConstraint< automaton::DFA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::DFA & automaton, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const std::pair < automaton::State, alphabet::Symbol >, automaton::State > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, label::Label > & transition : automaton.getTransitions ( ) )
 			if ( transition.first.second == symbol )
 				return true;
 
@@ -187,53 +187,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::DFA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::DFA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::DFA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::DFA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for ( const std::pair < const std::pair < automaton::State, alphabet::Symbol >, automaton::State > & t : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, label::Label > & t : automaton.getTransitions ( ) )
 			if ( ( t.first.first == state ) || ( t.second == state ) )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::DFA &, const automaton::State & ) {
+	static bool available ( const automaton::DFA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::DFA &, const automaton::State & ) {
+	static void valid ( const automaton::DFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::DFA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::DFA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::DFA &, const automaton::State & ) {
+	static bool used ( const automaton::DFA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::DFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::DFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::DFA &, const automaton::State & ) {
+	static void valid ( const automaton::DFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::DFA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::DFA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::DFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::DFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::DFA &, const automaton::State & ) {
+	static void valid ( const automaton::DFA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.cpp b/alib2data/src/automaton/FSM/EpsilonNFA.cpp
index a294db6d21..a888b666eb 100644
--- a/alib2data/src/automaton/FSM/EpsilonNFA.cpp
+++ b/alib2data/src/automaton/FSM/EpsilonNFA.cpp
@@ -22,32 +22,32 @@
 
 namespace automaton {
 
-EpsilonNFA::EpsilonNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < EpsilonNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+EpsilonNFA::EpsilonNFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates ) : std::Components < EpsilonNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-EpsilonNFA::EpsilonNFA ( State initialState ) : EpsilonNFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
+EpsilonNFA::EpsilonNFA ( label::Label initialState ) : EpsilonNFA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < label::Label > { } ) {
 }
 
-EpsilonNFA::EpsilonNFA ( const MultiInitialStateNFA & other ) : EpsilonNFA ( other.getStates ( ) + std::set < State > { automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
+EpsilonNFA::EpsilonNFA ( const MultiInitialStateNFA & other ) : EpsilonNFA ( other.getStates ( ) + std::set < label::Label > { label::createUniqueLabel ( label::labelFrom ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), label::createUniqueLabel ( label::labelFrom ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
+		std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
 		transitions[key] = transition.second;
 	}
 
-	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( this->getInitialState ( ), std::variant < string::Epsilon, alphabet::Symbol > ( string::Epsilon::EPSILON ) );
+	std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( this->getInitialState ( ), std::variant < string::Epsilon, alphabet::Symbol > ( string::Epsilon::EPSILON ) );
 	transitions[key] = other.getInitialStates ( );
 }
 
 EpsilonNFA::EpsilonNFA ( const NFA & other ) : EpsilonNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
+		std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
 		transitions[key] = transition.second;
 	}
 }
 
 EpsilonNFA::EpsilonNFA ( const DFA & other ) : EpsilonNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
+		std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
 		transitions[key].insert ( transition.second );
 	}
 }
@@ -60,90 +60,90 @@ AutomatonBase * EpsilonNFA::plunder ( ) && {
 	return new EpsilonNFA ( std::move ( * this ) );
 }
 
-bool EpsilonNFA::addTransition ( State from, std::variant < string::Epsilon, alphabet::Symbol > input, State to ) {
+bool EpsilonNFA::addTransition ( label::Label from, std::variant < string::Epsilon, alphabet::Symbol > input, label::Label to ) {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist." );
 
 	if ( input.is < alphabet::Symbol > ( ) && !getInputAlphabet ( ).count ( input.get < alphabet::Symbol > ( ) ) )
 		throw AutomatonException ( "Input symbol \"" + ( std::string ) input.get < alphabet::Symbol > ( ) + "\" doesn't exist." );
 
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist." );
 
-	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+	std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
 	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool EpsilonNFA::addTransition ( State from, alphabet::Symbol input, State to ) {
+bool EpsilonNFA::addTransition ( label::Label from, alphabet::Symbol input, label::Label to ) {
 	std::variant < string::Epsilon, alphabet::Symbol > inputVariant ( std::move ( input ) );
 
 	return addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
 }
 
-bool EpsilonNFA::addTransition ( State from, State to ) {
+bool EpsilonNFA::addTransition ( label::Label from, label::Label to ) {
 	std::variant < string::Epsilon, alphabet::Symbol > inputVariant ( string::Epsilon::EPSILON );
 
 	return addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
 }
 
-bool EpsilonNFA::removeTransition ( const State & from, const alphabet::Symbol & input, const State & to ) {
+bool EpsilonNFA::removeTransition ( const label::Label & from, const alphabet::Symbol & input, const label::Label & to ) {
 	std::variant < string::Epsilon, alphabet::Symbol > inputVariant ( input );
-	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( from, inputVariant );
+	std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( from, inputVariant );
 
 	return transitions[key].erase ( to );
 }
 
-bool EpsilonNFA::removeTransition ( const State & from, const State & to ) {
+bool EpsilonNFA::removeTransition ( const label::Label & from, const label::Label & to ) {
 	std::variant < string::Epsilon, alphabet::Symbol > inputVariant ( string::Epsilon::EPSILON );
-	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( from, inputVariant );
+	std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( from, inputVariant );
 
 	return transitions[key].erase ( to );
 }
 
-const std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & EpsilonNFA::getTransitions ( ) const {
+const std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & EpsilonNFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map < State, std::set < State > > EpsilonNFA::getEpsilonTransitions ( ) const {
-	std::map < State, std::set < State > > result;
+std::map < label::Label, std::set < label::Label > > EpsilonNFA::getEpsilonTransitions ( ) const {
+	std::map < label::Label, std::set < label::Label > > result;
 
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( transition.first.second.is < string::Epsilon > ( ) )
 			result[transition.first.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return result;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, std::set < State > > EpsilonNFA::getSymbolTransitions ( ) const {
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > result;
+std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > EpsilonNFA::getSymbolTransitions ( ) const {
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > result;
 
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( transition.first.second.is < alphabet::Symbol > ( ) )
-			result[std::pair < State, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
+			result[std::pair < label::Label, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return result;
 }
 
-std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > EpsilonNFA::getTransitionsFromState ( const State & from ) const {
+std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > EpsilonNFA::getTransitionsFromState ( const label::Label & from ) const {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist" );
 
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > transitionsFromState;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > transitionsFromState;
 
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( transition.first.first == from )
 			transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsFromState;
 }
 
-std::map < State, std::set < State > > EpsilonNFA::getEpsilonTransitionsFromState ( const State & from ) const {
+std::map < label::Label, std::set < label::Label > > EpsilonNFA::getEpsilonTransitionsFromState ( const label::Label & from ) const {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist" );
 
-	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key ( from, std::variant < string::Epsilon, alphabet::Symbol > ( string::Epsilon::EPSILON ) );
-	std::map < State, std::set < State > > res;
+	std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > > key ( from, std::variant < string::Epsilon, alphabet::Symbol > ( string::Epsilon::EPSILON ) );
+	std::map < label::Label, std::set < label::Label > > res;
 	auto transition = transitions.find ( key );
 
 	if ( transition != transitions.end ( ) )
@@ -152,60 +152,60 @@ std::map < State, std::set < State > > EpsilonNFA::getEpsilonTransitionsFromStat
 	return res;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, std::set < State > > EpsilonNFA::getSymbolTransitionsFromState ( const State & from ) const {
+std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > EpsilonNFA::getSymbolTransitionsFromState ( const label::Label & from ) const {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist" );
 
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsFromState;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitionsFromState;
 
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( ( transition.first.first == from ) && transition.first.second.is < alphabet::Symbol > ( ) )
-			transitionsFromState[std::pair < State, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
+			transitionsFromState[std::pair < label::Label, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsFromState;
 }
 
-std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > EpsilonNFA::getTransitionsToState ( const State & to ) const {
+std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > EpsilonNFA::getTransitionsToState ( const label::Label & to ) const {
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist" );
 
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > transitionsToState;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > transitionsToState;
 
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( transition.second.find ( to ) != transition.second.end ( ) )
 			transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsToState;
 }
 
-std::map < State, std::set < State > > EpsilonNFA::getEpsilonTransitionsToState ( const State & to ) const {
+std::map < label::Label, std::set < label::Label > > EpsilonNFA::getEpsilonTransitionsToState ( const label::Label & to ) const {
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist" );
 
-	std::map < State, std::set < State > > transitionsToState;
+	std::map < label::Label, std::set < label::Label > > transitionsToState;
 
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( ( transition.second.find ( to ) != transition.second.end ( ) ) && transition.first.second.is < string::Epsilon > ( ) )
 			transitionsToState[transition.first.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsToState;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, std::set < State > > EpsilonNFA::getSymbolTransitionsToState ( const State & to ) const {
+std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > EpsilonNFA::getSymbolTransitionsToState ( const label::Label & to ) const {
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist" );
 
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsToState;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitionsToState;
 
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( ( transition.second.find ( to ) != transition.second.end ( ) ) && transition.first.second.is < alphabet::Symbol > ( ) )
-			transitionsToState[std::pair < State, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
+			transitionsToState[std::pair < label::Label, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsToState;
 }
 
 bool EpsilonNFA::isEpsilonFree ( ) const {
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( transition.first.second.is < string::Epsilon > ( ) )
 			return false;
 
@@ -213,7 +213,7 @@ bool EpsilonNFA::isEpsilonFree ( ) const {
 }
 
 bool EpsilonNFA::isDeterministic ( ) const {
-	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : transitions )
 		if ( transition.second.size ( ) > 1 )
 			return false;
 
@@ -252,10 +252,10 @@ EpsilonNFA::operator std::string ( ) const {
 EpsilonNFA EpsilonNFA::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, EpsilonNFA::getXmlTagName() );
 
-	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < label::Label > states = AutomatonFromXMLParser::parseStates ( input );
 	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
-	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
-	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < label::Label > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
 	EpsilonNFA automaton ( std::move ( initialState ) );
 
@@ -271,9 +271,9 @@ EpsilonNFA EpsilonNFA::parse ( std::deque < sax::Token >::iterator & input ) {
 
 void EpsilonNFA::parseTransition ( std::deque < sax::Token >::iterator & input, EpsilonNFA & automaton ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
-	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom ( input );
 	std::variant < string::Epsilon, alphabet::Symbol > inputVariant = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol ( input );
-	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo ( input );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
 	automaton.addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.h b/alib2data/src/automaton/FSM/EpsilonNFA.h
index 8f6bb4e3e4..923ff7de07 100644
--- a/alib2data/src/automaton/FSM/EpsilonNFA.h
+++ b/alib2data/src/automaton/FSM/EpsilonNFA.h
@@ -14,6 +14,7 @@
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/Epsilon.h"
 #include "MultiInitialStateNFA.h"
 #include "NFA.h"
@@ -30,13 +31,13 @@ class States;
 class FinalStates;
 class InitialState;
 
-class EpsilonNFA : public AutomatonBase, public std::Components < EpsilonNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class EpsilonNFA : public AutomatonBase, public std::Components < EpsilonNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > transitions;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > transitions;
 
 public:
-	explicit EpsilonNFA ( State initialState );
-	explicit EpsilonNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates );
+	explicit EpsilonNFA ( label::Label initialState );
+	explicit EpsilonNFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates );
 	explicit EpsilonNFA ( const MultiInitialStateNFA & other );
 	explicit EpsilonNFA ( const NFA & other );
 	explicit EpsilonNFA ( const DFA & other );
@@ -45,43 +46,43 @@ public:
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -112,7 +113,7 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State from, std::variant < string::Epsilon, alphabet::Symbol > input, State to );
+	bool addTransition ( label::Label from, std::variant < string::Epsilon, alphabet::Symbol > input, label::Label to );
 
 	/**
 	 * Adds transition defined by parameters to the automaton.
@@ -121,7 +122,7 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State from, alphabet::Symbol input, State to );
+	bool addTransition ( label::Label from, alphabet::Symbol input, label::Label to );
 
 	/**
 	 * Adds transition defined by parameters to the automaton.
@@ -129,66 +130,66 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State from, State to );
+	bool addTransition ( label::Label from, label::Label to );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const State & next );
+	bool removeTransition ( const label::Label & current, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & getTransitions ( ) const;
 
 	/**
 	 * @return automaton epsilon transitions
 	 */
-	std::map < State, std::set < State > > getEpsilonTransitions ( ) const;
+	std::map < label::Label, std::set < label::Label > > getEpsilonTransitions ( ) const;
 
 	/**
 	 * @return automaton transitions reading some symbol
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getSymbolTransitions ( ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getSymbolTransitions ( ) const;
 
 	/**
 	 * @return automaton transitions from state
 	 */
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > getTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > getTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton epsilon transitions from state
 	 */
-	std::map < State, std::set < State > > getEpsilonTransitionsFromState ( const State & from ) const;
+	std::map < label::Label, std::set < label::Label > > getEpsilonTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton transitions from state reading some symbols
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getSymbolTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getSymbolTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton transitions to state
 	 */
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > getTransitionsToState ( const State & from ) const;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > getTransitionsToState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton epsilon transitions to state
 	 */
-	std::map < State, std::set < State > > getEpsilonTransitionsToState ( const State & to ) const;
+	std::map < label::Label, std::set < label::Label > > getEpsilonTransitionsToState ( const label::Label & to ) const;
 
 	/**
 	 * @return automaton transitions to state reading some symbols
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getSymbolTransitionsToState ( const State & to ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getSymbolTransitionsToState ( const label::Label & to ) const;
 
 	/**
 	 * Determines whether NFA is without epsilon transitions.
@@ -247,7 +248,7 @@ template < >
 class ComponentConstraint< automaton::EpsilonNFA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::EpsilonNFA & automaton, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const std::pair < automaton::State, std::variant < ::string::Epsilon, alphabet::Symbol > >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, std::variant < ::string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( transition.first.second.is < alphabet::Symbol > ( ) && ( transition.first.second.get < alphabet::Symbol > ( ) == symbol ) )
 				return true;
 
@@ -263,53 +264,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::EpsilonNFA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::EpsilonNFA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::EpsilonNFA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::EpsilonNFA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for ( const std::pair < const std::pair < automaton::State, std::variant < ::string::Epsilon, alphabet::Symbol > >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, std::variant < ::string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( ( transition.first.first == state ) || transition.second.count ( state ) )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::EpsilonNFA &, const automaton::State & ) {
+	static bool available ( const automaton::EpsilonNFA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::EpsilonNFA &, const automaton::State & ) {
+	static void valid ( const automaton::EpsilonNFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::EpsilonNFA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::EpsilonNFA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::EpsilonNFA &, const automaton::State & ) {
+	static bool used ( const automaton::EpsilonNFA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::EpsilonNFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::EpsilonNFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::EpsilonNFA &, const automaton::State & ) {
+	static void valid ( const automaton::EpsilonNFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::EpsilonNFA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::EpsilonNFA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::EpsilonNFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::EpsilonNFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::EpsilonNFA &, const automaton::State & ) {
+	static void valid ( const automaton::EpsilonNFA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/FSM/ExtendedNFA.cpp b/alib2data/src/automaton/FSM/ExtendedNFA.cpp
index eeb7ab28f5..e700710c1e 100644
--- a/alib2data/src/automaton/FSM/ExtendedNFA.cpp
+++ b/alib2data/src/automaton/FSM/ExtendedNFA.cpp
@@ -26,15 +26,15 @@
 
 namespace automaton {
 
-ExtendedNFA::ExtendedNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < ExtendedNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+ExtendedNFA::ExtendedNFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates ) : std::Components < ExtendedNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-ExtendedNFA::ExtendedNFA ( State initialState ) : ExtendedNFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
+ExtendedNFA::ExtendedNFA ( label::Label initialState ) : ExtendedNFA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < label::Label > { } ) {
 }
 
 ExtendedNFA::ExtendedNFA ( const CompactNFA & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
+		std::pair < label::Label, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
 		transitions[key] = transition.second;
 	}
 }
@@ -42,35 +42,35 @@ ExtendedNFA::ExtendedNFA ( const CompactNFA & other ) : ExtendedNFA ( other.getS
 ExtendedNFA::ExtendedNFA ( const EpsilonNFA & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
 		if ( transition.first.second.is < string::Epsilon > ( ) ) {
-			std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( string::LinearString ( std::vector < alphabet::Symbol > { } ) ) ) );
+			std::pair < label::Label, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( string::LinearString ( std::vector < alphabet::Symbol > { } ) ) ) );
 			transitions[key] = transition.second;
 		} else {
-			std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second.get < alphabet::Symbol > ( ) ) ) );
+			std::pair < label::Label, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second.get < alphabet::Symbol > ( ) ) ) );
 			transitions[key] = transition.second;
 		}
 	}
 }
 
-ExtendedNFA::ExtendedNFA ( const MultiInitialStateNFA & other ) : ExtendedNFA ( other.getStates ( ) + std::set < State > { automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
+ExtendedNFA::ExtendedNFA ( const MultiInitialStateNFA & other ) : ExtendedNFA ( other.getStates ( ) + std::set < label::Label > { label::createUniqueLabel ( label::labelFrom ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), label::createUniqueLabel ( label::labelFrom ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
+		std::pair < label::Label, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
 		transitions[key] = transition.second;
 	}
 
-	std::pair < State, regexp::RegExp > key = std::make_pair ( this->getInitialState ( ), regexp::RegExp ( regexp::regexpFrom ( string::LinearString ( std::vector < alphabet::Symbol > { } ) ) ) );
+	std::pair < label::Label, regexp::RegExp > key = std::make_pair ( this->getInitialState ( ), regexp::RegExp ( regexp::regexpFrom ( string::LinearString ( std::vector < alphabet::Symbol > { } ) ) ) );
 	transitions[key] = other.getInitialStates ( );
 }
 
 ExtendedNFA::ExtendedNFA ( const NFA & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
+		std::pair < label::Label, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
 		transitions[key] = transition.second;
 	}
 }
 
 ExtendedNFA::ExtendedNFA ( const DFA & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
 	for ( const auto & transition : other.getTransitions ( ) ) {
-		std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
+		std::pair < label::Label, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
 		transitions[key].insert ( transition.second );
 	}
 }
@@ -83,9 +83,9 @@ AutomatonBase * ExtendedNFA::plunder ( ) && {
 	return new ExtendedNFA ( std::move ( * this ) );
 }
 
-bool ExtendedNFA::addTransition ( State from, regexp::RegExp input, State to ) {
+bool ExtendedNFA::addTransition ( label::Label from, regexp::RegExp input, label::Label to ) {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist." );
 
 	const std::set < alphabet::Symbol > & inputRegExpAlphabet = input.getAlphabet ( );
 
@@ -94,43 +94,43 @@ bool ExtendedNFA::addTransition ( State from, regexp::RegExp input, State to ) {
 		throw AutomatonException ( "Input string is over different alphabet than automaton" );
 
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist." );
 
-	std::pair < State, regexp::RegExp > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+	std::pair < label::Label, regexp::RegExp > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
 	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool ExtendedNFA::removeTransition ( const State & from, const regexp::RegExp & input, const State & to ) {
-	std::pair < State, regexp::RegExp > key = std::make_pair ( from, input );
+bool ExtendedNFA::removeTransition ( const label::Label & from, const regexp::RegExp & input, const label::Label & to ) {
+	std::pair < label::Label, regexp::RegExp > key = std::make_pair ( from, input );
 
 	return transitions[key].erase ( to );
 }
 
-const std::map < std::pair < State, regexp::RegExp >, std::set < State > > & ExtendedNFA::getTransitions ( ) const {
+const std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > & ExtendedNFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map < std::pair < State, regexp::RegExp >, std::set < State > > ExtendedNFA::getTransitionsFromState ( const State & from ) const {
+std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > ExtendedNFA::getTransitionsFromState ( const label::Label & from ) const {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist" );
 
-	std::map < std::pair < State, regexp::RegExp >, std::set < State > > transitionsFromState;
+	std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > transitionsFromState;
 
-	for ( const std::pair < const std::pair < State, regexp::RegExp >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > & transition : transitions )
 		if ( transition.first.first == from )
 			transitionsFromState.insert ( make_pair ( transition.first, transition.second ) );
 
 	return transitionsFromState;
 }
 
-std::map < std::pair < State, regexp::RegExp >, std::set < State > > ExtendedNFA::getTransitionsToState ( const State & to ) const {
+std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > ExtendedNFA::getTransitionsToState ( const label::Label & to ) const {
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist" );
 
-	std::map < std::pair < State, regexp::RegExp >, std::set < State > > transitionsToState;
+	std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > transitionsToState;
 
-	for ( const std::pair < const std::pair < State, regexp::RegExp >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > & transition : transitions )
 		if ( transition.second.find ( to ) != transition.second.end ( ) )
 			transitionsToState.insert ( make_pair ( transition.first, transition.second ) );
 
@@ -165,10 +165,10 @@ ExtendedNFA::operator std::string ( ) const {
 ExtendedNFA ExtendedNFA::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, ExtendedNFA::getXmlTagName() );
 
-	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < label::Label > states = AutomatonFromXMLParser::parseStates ( input );
 	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
-	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
-	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < label::Label > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
 	ExtendedNFA automaton ( std::move ( initialState ) );
 
@@ -184,9 +184,9 @@ ExtendedNFA ExtendedNFA::parse ( std::deque < sax::Token >::iterator & input ) {
 
 void ExtendedNFA::parseTransition ( std::deque < sax::Token >::iterator & input, ExtendedNFA & automaton ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
-	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom ( input );
 	regexp::RegExp inputRegexp = AutomatonFromXMLParser::parseTransitionInputRegexp ( input );
-	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo ( input );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
 	automaton.addTransition ( std::move ( from ), std::move ( inputRegexp ), std::move ( to ) );
diff --git a/alib2data/src/automaton/FSM/ExtendedNFA.h b/alib2data/src/automaton/FSM/ExtendedNFA.h
index e2480b77a7..4b2d133c90 100644
--- a/alib2data/src/automaton/FSM/ExtendedNFA.h
+++ b/alib2data/src/automaton/FSM/ExtendedNFA.h
@@ -12,8 +12,8 @@
 #include <map>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../regexp/RegExp.h"
+#include "../../label/Label.h"
 #include "CompactNFA.h"
 #include "EpsilonNFA.h"
 #include "MultiInitialStateNFA.h"
@@ -31,13 +31,13 @@ class States;
 class FinalStates;
 class InitialState;
 
-class ExtendedNFA : public AutomatonBase, public std::Components < ExtendedNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class ExtendedNFA : public AutomatonBase, public std::Components < ExtendedNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, regexp::RegExp >, std::set < State > > transitions;
+	std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > transitions;
 
 public:
-	explicit ExtendedNFA ( State initialState );
-	explicit ExtendedNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates );
+	explicit ExtendedNFA ( label::Label initialState );
+	explicit ExtendedNFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates );
 	explicit ExtendedNFA ( const CompactNFA & other );
 	explicit ExtendedNFA ( const EpsilonNFA & other );
 	explicit ExtendedNFA ( const MultiInitialStateNFA & other );
@@ -48,43 +48,43 @@ public:
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -115,29 +115,29 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State current, regexp::RegExp input, State next );
+	bool addTransition ( label::Label current, regexp::RegExp input, label::Label next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const regexp::RegExp & input, const State & next );
+	bool removeTransition ( const label::Label & current, const regexp::RegExp & input, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < State, regexp::RegExp >, std::set < State > > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > & getTransitions ( ) const;
 
 	/**
 	 * @return automaton transitions from state
 	 */
-	std::map < std::pair < State, regexp::RegExp >, std::set < State > > getTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > getTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton transitions to state
 	 */
-	std::map < std::pair < State, regexp::RegExp >, std::set < State > > getTransitionsToState ( const State & from ) const;
+	std::map < std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > getTransitionsToState ( const label::Label & from ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -172,7 +172,7 @@ template < >
 class ComponentConstraint< automaton::ExtendedNFA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::ExtendedNFA & automaton, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const std::pair < automaton::State, regexp::RegExp >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( transition.first.second.getAlphabet ( ).count ( symbol ) == 1 )
 				return true;
 
@@ -188,53 +188,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::ExtendedNFA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::ExtendedNFA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::ExtendedNFA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::ExtendedNFA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for ( const std::pair < const std::pair < automaton::State, regexp::RegExp >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, regexp::RegExp >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( ( transition.first.first == state ) || ( transition.second.find ( state ) != transition.second.end ( ) ) )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::ExtendedNFA &, const automaton::State & ) {
+	static bool available ( const automaton::ExtendedNFA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::ExtendedNFA &, const automaton::State & ) {
+	static void valid ( const automaton::ExtendedNFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::ExtendedNFA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::ExtendedNFA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::ExtendedNFA &, const automaton::State & ) {
+	static bool used ( const automaton::ExtendedNFA &, const label::Label & ) {
 	return false;
 }
 
-	static bool available ( const automaton::ExtendedNFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::ExtendedNFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::ExtendedNFA &, const automaton::State & ) {
+	static void valid ( const automaton::ExtendedNFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::ExtendedNFA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::ExtendedNFA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::ExtendedNFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::ExtendedNFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::ExtendedNFA &, const automaton::State & ) {
+	static void valid ( const automaton::ExtendedNFA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp b/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
index 7874e4e8e0..92243808c4 100644
--- a/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
+++ b/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
@@ -21,10 +21,10 @@
 
 namespace automaton {
 
-MultiInitialStateNFA::MultiInitialStateNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < State > initialStates, std::set < State > finalStates ) : std::Components < MultiInitialStateNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+MultiInitialStateNFA::MultiInitialStateNFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < label::Label > initialStates, std::set < label::Label > finalStates ) : std::Components < MultiInitialStateNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
-MultiInitialStateNFA::MultiInitialStateNFA ( ) : MultiInitialStateNFA ( std::set < State > { }, std::set < alphabet::Symbol > { }, std::set < State > { }, std::set < State > { } ) {
+MultiInitialStateNFA::MultiInitialStateNFA ( ) : MultiInitialStateNFA ( std::set < label::Label > { }, std::set < alphabet::Symbol > { }, std::set < label::Label > { }, std::set < label::Label > { } ) {
 }
 
 MultiInitialStateNFA::MultiInitialStateNFA ( const DFA & other ) : MultiInitialStateNFA ( other.getStates ( ), other.getInputAlphabet ( ), { other.getInitialState ( ) }, other.getFinalStates ( ) ) {
@@ -45,51 +45,51 @@ AutomatonBase * MultiInitialStateNFA::plunder ( ) && {
 	return new MultiInitialStateNFA ( std::move ( * this ) );
 }
 
-bool MultiInitialStateNFA::addTransition ( State from, alphabet::Symbol input, State to ) {
+bool MultiInitialStateNFA::addTransition ( label::Label from, alphabet::Symbol input, label::Label to ) {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist." );
 
 	if ( !getInputAlphabet ( ).count ( input ) )
 		throw AutomatonException ( "Input symbol \"" + ( std::string ) input + "\" doesn't exist." );
 
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist." );
 
-	std::pair < State, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+	std::pair < label::Label, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
 	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool MultiInitialStateNFA::removeTransition ( const State & from, const alphabet::Symbol & input, const State & to ) {
-	std::pair < State, alphabet::Symbol > key = std::make_pair ( from, input );
+bool MultiInitialStateNFA::removeTransition ( const label::Label & from, const alphabet::Symbol & input, const label::Label & to ) {
+	std::pair < label::Label, alphabet::Symbol > key = std::make_pair ( from, input );
 
 	return transitions[key].erase ( to );
 }
 
-const std::map < std::pair < State, alphabet::Symbol >, std::set < State > > & MultiInitialStateNFA::getTransitions ( ) const {
+const std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & MultiInitialStateNFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, std::set < State > > MultiInitialStateNFA::getTransitionsFromState ( const State & from ) const {
+std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > MultiInitialStateNFA::getTransitionsFromState ( const label::Label & from ) const {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist" );
 
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsFromState;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitionsFromState;
 
-	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : transitions )
 		if ( transition.first.first == from )
 			transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsFromState;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, std::set < State > > MultiInitialStateNFA::getTransitionsToState ( const State & to ) const {
+std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > MultiInitialStateNFA::getTransitionsToState ( const label::Label & to ) const {
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist" );
 
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsToState;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitionsToState;
 
-	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : transitions )
 		if ( transition.second.find ( to ) != transition.second.end ( ) )
 			transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
@@ -97,7 +97,7 @@ std::map < std::pair < State, alphabet::Symbol >, std::set < State > > MultiInit
 }
 
 bool MultiInitialStateNFA::isDeterministic ( ) const {
-	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : transitions )
 		if ( transition.second.size ( ) > 1 )
 			return false;
 
@@ -145,10 +145,10 @@ MultiInitialStateNFA::operator std::string ( ) const {
 MultiInitialStateNFA MultiInitialStateNFA::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, MultiInitialStateNFA::getXmlTagName() );
 
-	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < label::Label > states = AutomatonFromXMLParser::parseStates ( input );
 	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
-	std::set < State > initialStates = AutomatonFromXMLParser::parseInitialStates ( input );
-	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
+	std::set < label::Label > initialStates = AutomatonFromXMLParser::parseInitialStates ( input );
+	std::set < label::Label > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
 	MultiInitialStateNFA automaton;
 
@@ -165,9 +165,9 @@ MultiInitialStateNFA MultiInitialStateNFA::parse ( std::deque < sax::Token >::it
 
 void MultiInitialStateNFA::parseTransition ( std::deque < sax::Token >::iterator & input, MultiInitialStateNFA & automaton ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
-	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom ( input );
 	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol ( input );
-	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo ( input );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
 	automaton.addTransition ( std::move ( from ), std::move ( inputSymbol ), std::move ( to ) );
diff --git a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
index 6525b93238..331f07532c 100644
--- a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
+++ b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
@@ -12,8 +12,8 @@
 #include <map>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "NFA.h"
 #include "DFA.h"
 
@@ -28,13 +28,13 @@ class States;
 class FinalStates;
 class InitialStates;
 
-class MultiInitialStateNFA : public AutomatonBase, public std::Components < MultiInitialStateNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class MultiInitialStateNFA : public AutomatonBase, public std::Components < MultiInitialStateNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitions;
 
 public:
 	explicit MultiInitialStateNFA ( );
-	explicit MultiInitialStateNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < State > initialStates, std::set < State > finalStates );
+	explicit MultiInitialStateNFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < label::Label > initialStates, std::set < label::Label > finalStates );
 	explicit MultiInitialStateNFA ( const NFA & other );
 	explicit MultiInitialStateNFA ( const DFA & other );
 
@@ -42,47 +42,47 @@ public:
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const std::set < State > & getInitialStates ( ) const {
+	const std::set < label::Label > & getInitialStates ( ) const {
 		return accessComponent < InitialStates > ( ).get ( );
 	}
 
-	bool addInitialState ( State state ) {
+	bool addInitialState ( label::Label state ) {
 		return accessComponent < InitialStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setInitialStates ( std::set < State > states ) {
+	void setInitialStates ( std::set < label::Label > states ) {
 		accessComponent < InitialStates > ( ).set ( std::move ( states ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -113,29 +113,29 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State current, alphabet::Symbol input, State next );
+	bool addTransition ( label::Label current, alphabet::Symbol input, label::Label next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < State, alphabet::Symbol >, std::set < State > > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & getTransitions ( ) const;
 
 	/**
 	 * @return automaton transitions from state
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton transitions to state
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getTransitionsToState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getTransitionsToState ( const label::Label & from ) const;
 
 	/**
 	 * Determines whether MultiInitialStateNFA is deterministic.
@@ -191,7 +191,7 @@ template < >
 class ComponentConstraint< automaton::MultiInitialStateNFA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::MultiInitialStateNFA & automaton, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const std::pair < automaton::State, alphabet::Symbol >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( transition.first.second == symbol )
 				return true;
 
@@ -207,57 +207,57 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::MultiInitialStateNFA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::MultiInitialStateNFA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::MultiInitialStateNFA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::MultiInitialStateNFA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialStates ( ).count ( state ) )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for ( const std::pair < const std::pair < automaton::State, alphabet::Symbol >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( ( transition.first.first == state ) || ( transition.second.find ( state ) != transition.second.end ( ) ) )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+	static bool available ( const automaton::MultiInitialStateNFA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+	static void valid ( const automaton::MultiInitialStateNFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::MultiInitialStateNFA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::MultiInitialStateNFA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+	static bool used ( const automaton::MultiInitialStateNFA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::MultiInitialStateNFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::MultiInitialStateNFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+	static void valid ( const automaton::MultiInitialStateNFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::MultiInitialStateNFA, automaton::State, automaton::InitialStates > {
+class ComponentConstraint< automaton::MultiInitialStateNFA, label::Label, automaton::InitialStates > {
 public:
-	static bool used ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+	static bool used ( const automaton::MultiInitialStateNFA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::MultiInitialStateNFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::MultiInitialStateNFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+	static void valid ( const automaton::MultiInitialStateNFA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/FSM/NFA.cpp b/alib2data/src/automaton/FSM/NFA.cpp
index a79148e42a..a3d3363ccd 100644
--- a/alib2data/src/automaton/FSM/NFA.cpp
+++ b/alib2data/src/automaton/FSM/NFA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-NFA::NFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < NFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NFA::NFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates ) : std::Components < NFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-NFA::NFA ( State initialState ) : NFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
+NFA::NFA ( label::Label initialState ) : NFA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < label::Label > { } ) {
 }
 
 NFA::NFA ( const DFA & other ) : NFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
@@ -38,51 +38,51 @@ AutomatonBase * NFA::plunder ( ) && {
 	return new NFA ( std::move ( * this ) );
 }
 
-bool NFA::addTransition ( State from, alphabet::Symbol input, State to ) {
+bool NFA::addTransition ( label::Label from, alphabet::Symbol input, label::Label to ) {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist." );
 
 	if ( !getInputAlphabet ( ).count ( input ) )
 		throw AutomatonException ( "Input symbol \"" + ( std::string ) input + "\" doesn't exist." );
 
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist." );
 
-	std::pair < State, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
+	std::pair < label::Label, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
 	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool NFA::removeTransition ( const State & from, const alphabet::Symbol & input, const State & to ) {
-	std::pair < State, alphabet::Symbol > key = std::make_pair ( from, input );
+bool NFA::removeTransition ( const label::Label & from, const alphabet::Symbol & input, const label::Label & to ) {
+	std::pair < label::Label, alphabet::Symbol > key = std::make_pair ( from, input );
 
 	return transitions[key].erase ( to );
 }
 
-const std::map < std::pair < State, alphabet::Symbol >, std::set < State > > & NFA::getTransitions ( ) const {
+const std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & NFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, std::set < State > > NFA::getTransitionsFromState ( const State & from ) const {
+std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > NFA::getTransitionsFromState ( const label::Label & from ) const {
 	if ( !getStates ( ).count ( from ) )
-		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) from + "\" doesn't exist" );
 
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsFromState;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitionsFromState;
 
-	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : transitions )
 		if ( transition.first.first == from )
 			transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsFromState;
 }
 
-std::map < std::pair < State, alphabet::Symbol >, std::set < State > > NFA::getTransitionsToState ( const State & to ) const {
+std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > NFA::getTransitionsToState ( const label::Label & to ) const {
 	if ( !getStates ( ).count ( to ) )
-		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+		throw AutomatonException ( "State \"" + ( std::string ) to + "\" doesn't exist" );
 
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsToState;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitionsToState;
 
-	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : transitions )
 		if ( transition.second.find ( to ) != transition.second.end ( ) )
 			transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
@@ -90,7 +90,7 @@ std::map < std::pair < State, alphabet::Symbol >, std::set < State > > NFA::getT
 }
 
 bool NFA::isDeterministic ( ) const {
-	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+	for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : transitions )
 		if ( transition.second.size ( ) > 1 )
 			return false;
 
@@ -138,10 +138,10 @@ NFA::operator std::string ( ) const {
 NFA NFA::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, NFA::getXmlTagName() );
 
-	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < label::Label > states = AutomatonFromXMLParser::parseStates ( input );
 	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
-	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
-	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < label::Label > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
 	NFA automaton ( std::move ( initialState ) );
 
@@ -157,9 +157,9 @@ NFA NFA::parse ( std::deque < sax::Token >::iterator & input ) {
 
 void NFA::parseTransition ( std::deque < sax::Token >::iterator & input, NFA & automaton ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
-	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom ( input );
 	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol ( input );
-	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo ( input );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
 	automaton.addTransition ( std::move ( from ), std::move ( inputSymbol ), std::move ( to ) );
diff --git a/alib2data/src/automaton/FSM/NFA.h b/alib2data/src/automaton/FSM/NFA.h
index cbfb015638..d85657225f 100644
--- a/alib2data/src/automaton/FSM/NFA.h
+++ b/alib2data/src/automaton/FSM/NFA.h
@@ -12,8 +12,8 @@
 #include <map>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 
 #include "DFA.h"
 
@@ -28,56 +28,56 @@ class States;
 class FinalStates;
 class InitialState;
 
-class NFA : public AutomatonBase, public std::Components < NFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NFA : public AutomatonBase, public std::Components < NFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitions;
 
 public:
-	explicit NFA ( State initialState );
-	explicit NFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates );
+	explicit NFA ( label::Label initialState );
+	explicit NFA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates );
 	explicit NFA ( const DFA & other );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -108,29 +108,29 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State current, alphabet::Symbol input, State next );
+	bool addTransition ( label::Label current, alphabet::Symbol input, label::Label next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < State, alphabet::Symbol >, std::set < State > > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & getTransitions ( ) const;
 
 	/**
 	 * @return automaton transitions from state
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton transitions to state
 	 */
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getTransitionsToState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getTransitionsToState ( const label::Label & from ) const;
 
 	/**
 	 * Determines whether NFA is deterministic.
@@ -185,7 +185,7 @@ template < >
 class ComponentConstraint< automaton::NFA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::NFA & automaton, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const std::pair < automaton::State, alphabet::Symbol >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( transition.first.second == symbol )
 				return true;
 
@@ -201,53 +201,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::NFA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::NFA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::NFA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::NFA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for ( const std::pair < const std::pair < automaton::State, alphabet::Symbol >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+		for ( const std::pair < const std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & transition : automaton.getTransitions ( ) )
 			if ( ( transition.first.first == state ) || ( transition.second.find ( state ) != transition.second.end ( ) ) )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::NFA &, const automaton::State & ) {
+	static bool available ( const automaton::NFA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::NFA &, const automaton::State & ) {
+	static void valid ( const automaton::NFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::NFA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::NFA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::NFA &, const automaton::State & ) {
+	static bool used ( const automaton::NFA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::NFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::NFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::NFA &, const automaton::State & ) {
+	static void valid ( const automaton::NFA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::NFA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::NFA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::NFA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::NFA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::NFA &, const automaton::State & ) {
+	static void valid ( const automaton::NFA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/DPDA.cpp b/alib2data/src/automaton/PDA/DPDA.cpp
index 2f46a33ec2..4a9fbe1d23 100644
--- a/alib2data/src/automaton/PDA/DPDA.cpp
+++ b/alib2data/src/automaton/PDA/DPDA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-DPDA::DPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < DPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+DPDA::DPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol initialSymbol, std::set < label::Label > finalStates ) : std::Components < DPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-DPDA::DPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : DPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
+DPDA::DPDA(label::Label initialState, alphabet::Symbol initialPushdownSymbol) : DPDA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* DPDA::clone() const {
@@ -33,9 +33,9 @@ AutomatonBase* DPDA::plunder() && {
 	return new DPDA(std::move(*this));
 }
 
-bool DPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push) {
+bool DPDA::addTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	if (! getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && ! getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -43,7 +43,7 @@ bool DPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Sym
 	}
 
 	if (! getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	for(const alphabet::Symbol& popSymbol : pop) {
@@ -58,22 +58,22 @@ bool DPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Sym
 		}
 	}
 
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(std::move(from), std::move(input), std::move(pop));
-	std::pair<automaton::State, std::vector<alphabet::Symbol> > value = std::make_pair(std::move(to), std::move(push));
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(std::move(from), std::move(input), std::move(pop));
+	std::pair<label::Label, std::vector<alphabet::Symbol> > value = std::make_pair(std::move(to), std::move(push));
 
 	if (transitions.find(key) != transitions.end()) {
 		if(transitions.find(key)->second == value)
 			return false;
 		else if (std::get<1>(key).is<alphabet::Symbol>())
 			throw AutomatonException(
-				"Transition (\"" + (std::string) std::get<0>(key).getName() + "\", \"" + (std::string) std::get<1>(key).get<alphabet::Symbol>() + "\", \"pop\") -> ?? already exists.");
+				"Transition (\"" + (std::string) std::get<0>(key) + "\", \"" + (std::string) std::get<1>(key).get<alphabet::Symbol>() + "\", \"pop\") -> ?? already exists.");
 		else
 			throw AutomatonException(
-				"Transition (\"" + (std::string) std::get<0>(key).getName() + "\", \"" + (std::string) std::get<1>(key).get<string::Epsilon>() + "\", \"pop\") -> ?? already exists.");
+				"Transition (\"" + (std::string) std::get<0>(key) + "\", \"" + (std::string) std::get<1>(key).get<string::Epsilon>() + "\", \"pop\") -> ?? already exists.");
 	}
 
 	if(std::get<1>(key).is<string::Epsilon>()) {
-		if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > > & transition) {
+		if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > > & transition) {
 				if(std::get<0>(transition.first) == std::get<0>(key)) {
 					const std::vector<alphabet::Symbol>& alpha = std::get<2>(transition.first);
 					const std::vector<alphabet::Symbol>& beta = std::get<2>(key);
@@ -90,7 +90,7 @@ bool DPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Sym
 			}))
 				throw AutomatonException("Conflicting transition");
 	} else {
-		if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > > & transition) {
+		if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<const std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > > & transition) {
 				if(std::get<0>(transition.first) == std::get<0>(key) && ( std::get<1>(transition.first) == std::get<1>(key) || std::get<1>(transition.first).is<string::Epsilon>() )) {
 					const std::vector<alphabet::Symbol>& alpha = std::get<2>(transition.first);
 					const std::vector<alphabet::Symbol>& beta = std::get<2>(key);
@@ -112,19 +112,19 @@ bool DPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Sym
 	return true;
 }
 
-bool DPDA::addTransition(State from, alphabet::Symbol input, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push) {
+bool DPDA::addTransition(label::Label from, alphabet::Symbol input, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
 }
 
-bool DPDA::addTransition(State from, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push) {
+bool DPDA::addTransition(label::Label from, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
 }
 
-bool DPDA::removeTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(from, input, pop);
-	std::pair<automaton::State, std::vector<alphabet::Symbol> > value = std::make_pair(to, push);
+bool DPDA::removeTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(from, input, pop);
+	std::pair<label::Label, std::vector<alphabet::Symbol> > value = std::make_pair(to, push);
 
 	if (transitions.find(key) == transitions.end())
 		return false;
@@ -132,36 +132,36 @@ bool DPDA::removeTransition(const State& from, const std::variant<string::Epsilo
 	if(transitions.find(key)->second != value) {
 		if (input.is<alphabet::Symbol>())
 			throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input.get<alphabet::Symbol>() + "\") -> \"to\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input.get<alphabet::Symbol>() + "\") -> \"to\" doesn't exist.");
 		else
 			throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input.get<string::Epsilon>() + "\") -> \"to\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input.get<string::Epsilon>() + "\") -> \"to\" doesn't exist.");
 	}
 
 	transitions.erase(key);
 	return true;
 }
 
-bool DPDA::removeTransition(const State& from, const alphabet::Symbol& input, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
+bool DPDA::removeTransition(const label::Label& from, const alphabet::Symbol& input, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeTransition(from, inputVariant, pop, to, push);
 }
 
-bool DPDA::removeTransition(const State& from, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
+bool DPDA::removeTransition(const label::Label& from, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeTransition(from, inputVariant, pop, to, push);
 }
 
-const std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<State, std::vector<alphabet::Symbol> > >& DPDA::getTransitions() const {
+const std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > >& DPDA::getTransitions() const {
 	return transitions;
 }
 
-std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<State, std::vector<alphabet::Symbol> > > DPDA::getTransitionsFromState(const State& from) const {
+std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > > DPDA::getTransitionsFromState(const label::Label& from) const {
 	if( ! getStates().count(from) )
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist");
 
-	std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<State, std::vector<alphabet::Symbol> > > transitionsFromState;
-	for (const std::pair<const std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<State, std::vector<alphabet::Symbol> > >& transition : transitions) {
+	std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > > transitionsFromState;
+	for (const std::pair<const std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > >& transition : transitions) {
 		if (std::get<0>(transition.first) == from) {
 			transitionsFromState.insert(std::make_pair(transition.first, transition.second));
 		}
@@ -170,12 +170,12 @@ std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std:
 	return transitionsFromState;
 }
 
-std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<State, std::vector<alphabet::Symbol> > > DPDA::getTransitionsToState(const State& to) const {
+std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > > DPDA::getTransitionsToState(const label::Label& to) const {
 	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist");
 
-	std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<State, std::vector<alphabet::Symbol> > > transitionsToState;
-	for (const std::pair<const std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<State, std::vector<alphabet::Symbol> > >& transition : transitions) {
+	std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > > transitionsToState;
+	for (const std::pair<const std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > >& transition : transitions) {
 		if (transition.second.first == to) {
 			transitionsToState.insert(std::make_pair(transition.first, transition.second));
 		}
@@ -213,12 +213,12 @@ DPDA::operator std::string () const {
 DPDA DPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, DPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> pushdownStoreSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol initialPushdownStoreSymbol = AutomatonFromXMLParser::parseInitialPushdownStoreSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	DPDA automaton(std::move(initialState), std::move(initialPushdownStoreSymbol));
 	automaton.setStates(std::move(states));
@@ -234,10 +234,10 @@ DPDA DPDA::parse(std::deque<sax::Token>::iterator& input) {
 
 void DPDA::parseTransition(std::deque<sax::Token>::iterator& input, DPDA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
 	std::vector<alphabet::Symbol> pop = AutomatonFromXMLParser::parseTransitionPop(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	std::vector<alphabet::Symbol> push = AutomatonFromXMLParser::parseTransitionPush(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
diff --git a/alib2data/src/automaton/PDA/DPDA.h b/alib2data/src/automaton/PDA/DPDA.h
index 5bbb972e10..d398f1aa58 100644
--- a/alib2data/src/automaton/PDA/DPDA.h
+++ b/alib2data/src/automaton/PDA/DPDA.h
@@ -15,8 +15,8 @@
 #include <variant>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/Epsilon.h"
 
 namespace automaton {
@@ -35,55 +35,55 @@ class InitialState;
  * if $\delta (q, a, \alpha) \neq \emptyset$, $\delta (q, a, \beta) \neq \emptyset$ and $\alpha \neq \beta$, then $\alpha$ is not suffix of $\beta$ and $\beta$ is not suffix of $\alpha$ (formally $\gamma \alpha \neq \beta and \alpha \neq \gamma \beta$).
  * if $\delta(q, a, \alpha) \neq \emptyset$, $\delta (q, \varepsilon, \beta) \neq \emptyset$, then $\alpha$ is not suffix of $\beta$ and $\beta$ is not suffix of $\alpha$ (fornally $\gamma \alpha \neq \beta and \alpha \neq \gamma \beta$).
  */
-class DPDA : public AutomatonBase, public std::Components < DPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class DPDA : public AutomatonBase, public std::Components < DPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < State, std::vector < alphabet::Symbol > > > transitions;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < label::Label, std::vector < alphabet::Symbol > > > transitions;
 
 public:
-	explicit DPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol initialPushdownSymbol, std::set < automaton::State > finalStates );
-	explicit DPDA ( State initialState, alphabet::Symbol initialPushdownSymbol );
+	explicit DPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol initialPushdownSymbol, std::set < label::Label > finalStates );
+	explicit DPDA ( label::Label initialState, alphabet::Symbol initialPushdownSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -141,37 +141,37 @@ public:
 	 * @throws AutomatonException when some part of the transition is not present
 	 * in the DPDA (state, input symbol, stack symbol) or when transition already exists
 	 */
-	bool addTransition ( State from, std::variant < string::Epsilon, alphabet::Symbol > input, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, std::variant < string::Epsilon, alphabet::Symbol > input, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push );
 
-	bool addTransition ( State from, alphabet::Symbol input, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, alphabet::Symbol input, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push );
 
-	bool addTransition ( State from, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push );
 
 	/**
 	 * Removes the transition from the DPDA.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition is not present in the DPDA
 	 */
-	bool removeTransition ( const State & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
-	bool removeTransition ( const State & from, const alphabet::Symbol & input, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const alphabet::Symbol & input, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
-	bool removeTransition ( const State & from, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
 	/**
 	 * @return DPDA transitions
 	 */
-	const std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < State, std::vector < alphabet::Symbol > > > & getTransitions ( ) const;
+	const std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < label::Label, std::vector < alphabet::Symbol > > > & getTransitions ( ) const;
 
 	/**
 	 * @return automaton transitions from state
 	 */
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < State, std::vector < alphabet::Symbol > > > getTransitionsFromState ( const State & from ) const;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < label::Label, std::vector < alphabet::Symbol > > > getTransitionsFromState ( const label::Label & from ) const;
 
 	/**
 	 * @return automaton transitions to state
 	 */
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < State, std::vector < alphabet::Symbol > > > getTransitionsToState ( const State & from ) const;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < label::Label, std::vector < alphabet::Symbol > > > getTransitionsToState ( const label::Label & from ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -206,7 +206,7 @@ template < >
 class ComponentConstraint< automaton::DPDA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::DPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
 			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
 				return true;
 
@@ -228,7 +228,7 @@ public:
 		if(automaton.getInitialSymbol() == symbol)
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions()) {
 			const auto & popSymbols = std::get<2>(transition.first);
 			const auto & pushSymbols = transition.second.second;
 			if(std::contains(popSymbols.begin(), popSymbols.end(), symbol ) || std::contains(pushSymbols.begin(), pushSymbols.end(), symbol))
@@ -258,53 +258,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::DPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::DPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::DPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::DPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<label::Label, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
 			if ( state == std::get<0>(transition.first) || transition.second.first == state )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::DPDA &, const automaton::State & ) {
+	static bool available ( const automaton::DPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::DPDA &, const automaton::State & ) {
+	static void valid ( const automaton::DPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::DPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::DPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::DPDA &, const automaton::State & ) {
+	static bool used ( const automaton::DPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::DPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::DPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::DPDA &, const automaton::State & ) {
+	static void valid ( const automaton::DPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::DPDA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::DPDA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::DPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::DPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::DPDA &, const automaton::State & ) {
+	static void valid ( const automaton::DPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/InputDrivenDPDA.cpp b/alib2data/src/automaton/PDA/InputDrivenDPDA.cpp
index ab6ba18350..b86975e6f4 100644
--- a/alib2data/src/automaton/PDA/InputDrivenDPDA.cpp
+++ b/alib2data/src/automaton/PDA/InputDrivenDPDA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-InputDrivenDPDA::InputDrivenDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < InputDrivenDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+InputDrivenDPDA::InputDrivenDPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol initialSymbol, std::set < label::Label > finalStates ) : std::Components < InputDrivenDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-InputDrivenDPDA::InputDrivenDPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : InputDrivenDPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
+InputDrivenDPDA::InputDrivenDPDA(label::Label initialState, alphabet::Symbol initialPushdownSymbol) : InputDrivenDPDA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* InputDrivenDPDA::clone() const {
@@ -72,7 +72,7 @@ void InputDrivenDPDA::setPushdownStoreOperations(std::map<alphabet::Symbol, std:
 }
 
 bool InputDrivenDPDA::clearPushdownStoreOperation(const alphabet::Symbol& input) {
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, State>& transition : transitions) {
+	for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, label::Label>& transition : transitions) {
 		if (transition.first.second == input)
 			throw AutomatonException("Input symbol \"" + (std::string) input + "\" is used.");
 	}
@@ -84,9 +84,9 @@ const std::map<alphabet::Symbol, std::pair<std::vector<alphabet::Symbol>, std::v
 	return inputSymbolToPushdownStoreOperation;
 }
 
-bool InputDrivenDPDA::addTransition(State from, alphabet::Symbol input, State to) {
+bool InputDrivenDPDA::addTransition(label::Label from, alphabet::Symbol input, label::Label to) {
 	if (!getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 
 	if (!getInputAlphabet().count(input))
 		throw AutomatonException("Input symbol \"" + (std::string) input + "\" doesn't exist.");
@@ -95,44 +95,44 @@ bool InputDrivenDPDA::addTransition(State from, alphabet::Symbol input, State to
 		throw AutomatonException("Input symbol \"" + (std::string) input + "\" doesn't exist.");
 
 	if (! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 
-	std::pair<State, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
 
 	if (transitions.find(key) != transitions.end()) {
 		if(transitions.find(key)->second == to)
 			return false;
 		else
-			throw AutomatonException( "Transition from this state and symbol already exists (\"" + (std::string) key.first.getName() + "\", \"" + (std::string) key.second + "\") -> \"" + (std::string) to.getName() + "\"." );
+			throw AutomatonException( "Transition from this state and symbol already exists (\"" + (std::string) key.first + "\", \"" + (std::string) key.second + "\") -> \"" + (std::string) to + "\"." );
 	}
 
 	transitions.insert(std::make_pair(std::move(key), std::move(to)));
 	return true;
 }
 
-bool InputDrivenDPDA::removeTransition(const State& from, const alphabet::Symbol& input, const State& to) {
-	std::pair<State, alphabet::Symbol> key = std::make_pair(from, input);
+bool InputDrivenDPDA::removeTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to) {
+	std::pair<label::Label, alphabet::Symbol> key = std::make_pair(from, input);
 
 	if (transitions.find(key) == transitions.end())
 		return false;
 
 	if(transitions.find(key)->second != to)
-		throw AutomatonException( "Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input + "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException( "Transition (\"" + (std::string) from + "\", \"" + (std::string) input + "\") -> \"" + (std::string) to + "\" doesn't exist.");
 
 	transitions.erase(key);
 	return true;
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, State>& InputDrivenDPDA::getTransitions() const {
+const std::map<std::pair<label::Label, alphabet::Symbol>, label::Label>& InputDrivenDPDA::getTransitions() const {
 	return transitions;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, State > InputDrivenDPDA::getTransitionsFromState(const State& from) const {
+std::map<std::pair<label::Label, alphabet::Symbol>, label::Label > InputDrivenDPDA::getTransitionsFromState(const label::Label& from) const {
 	if( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist");
 
-	std::map<std::pair<State, alphabet::Symbol>, State> transitionsFromState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, State>& transition : transitions) {
+	std::map<std::pair<label::Label, alphabet::Symbol>, label::Label> transitionsFromState;
+	for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, label::Label>& transition : transitions) {
 		if (transition.first.first == from) {
 			transitionsFromState.insert(transition);
 		}
@@ -141,12 +141,12 @@ std::map<std::pair<State, alphabet::Symbol>, State > InputDrivenDPDA::getTransit
 	return transitionsFromState;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, State> InputDrivenDPDA::getTransitionsToState(const State& to) const {
+std::map<std::pair<label::Label, alphabet::Symbol>, label::Label> InputDrivenDPDA::getTransitionsToState(const label::Label& to) const {
 	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist");
 
-	std::map<std::pair<State, alphabet::Symbol>, State> transitionsToState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, State>& transition : transitions) {
+	std::map<std::pair<label::Label, alphabet::Symbol>, label::Label> transitionsToState;
+	for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, label::Label>& transition : transitions) {
 		if (transition.second == to) {
 			transitionsToState.insert(transition);
 		}
@@ -185,12 +185,12 @@ InputDrivenDPDA::operator std::string () const {
 InputDrivenDPDA InputDrivenDPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, InputDrivenDPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> pushdownStoreSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol initialPushdownStoreSymbol = AutomatonFromXMLParser::parseInitialPushdownStoreSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	InputDrivenDPDA automaton(std::move(initialState), std::move(initialPushdownStoreSymbol));
 	automaton.setStates(std::move(states));
@@ -207,9 +207,9 @@ InputDrivenDPDA InputDrivenDPDA::parse(std::deque<sax::Token>::iterator& input)
 
 void InputDrivenDPDA::parseTransition(std::deque<sax::Token>::iterator& input, InputDrivenDPDA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
diff --git a/alib2data/src/automaton/PDA/InputDrivenDPDA.h b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
index b6d25612e6..c05677fcae 100644
--- a/alib2data/src/automaton/PDA/InputDrivenDPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
@@ -13,8 +13,8 @@
 #include <vector>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 
 namespace automaton {
 
@@ -29,58 +29,58 @@ class InitialState;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class InputDrivenDPDA : public AutomatonBase, public std::Components < InputDrivenDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class InputDrivenDPDA : public AutomatonBase, public std::Components < InputDrivenDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, alphabet::Symbol >, State > transitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > transitions;
 	std::map < alphabet::Symbol, std::pair < std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > inputSymbolToPushdownStoreOperation;
 
 	void checkPushdownStoreOperation ( const alphabet::Symbol & input, const std::vector < alphabet::Symbol > & pop, const std::vector < alphabet::Symbol > & push );
 
 public:
-	explicit InputDrivenDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol initialPushdownSymbol, std::set < automaton::State > finalStates );
-	explicit InputDrivenDPDA ( State initialState, alphabet::Symbol initialPushdownSymbol );
+	explicit InputDrivenDPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol initialPushdownSymbol, std::set < label::Label > finalStates );
+	explicit InputDrivenDPDA ( label::Label initialState, alphabet::Symbol initialPushdownSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -147,23 +147,23 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State current, alphabet::Symbol input, State next );
+	bool addTransition ( label::Label current, alphabet::Symbol input, label::Label next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < State, alphabet::Symbol >, State > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > & getTransitions ( ) const;
 
-	std::map < std::pair < State, alphabet::Symbol >, State > getTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > getTransitionsFromState ( const label::Label & from ) const;
 
-	std::map < std::pair < State, alphabet::Symbol >, State > getTransitionsToState ( const State & to ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > getTransitionsToState ( const label::Label & to ) const;
 
 	/**
 	 * Determines whether InputDrivenDPDA is deterministic.
@@ -208,7 +208,7 @@ template < >
 class ComponentConstraint< automaton::InputDrivenDPDA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::InputDrivenDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& transition : automaton.getTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, label::Label>& transition : automaton.getTransitions())
 			if (transition.first.second == symbol)
 				return true;
 
@@ -260,53 +260,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::InputDrivenDPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::InputDrivenDPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::InputDrivenDPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::InputDrivenDPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& t : automaton.getTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, label::Label>& t : automaton.getTransitions())
 			if (t.first.first == state || t.second == state)
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+	static bool available ( const automaton::InputDrivenDPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::InputDrivenDPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::InputDrivenDPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::InputDrivenDPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+	static bool used ( const automaton::InputDrivenDPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::InputDrivenDPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::InputDrivenDPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::InputDrivenDPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::InputDrivenDPDA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::InputDrivenDPDA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::InputDrivenDPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::InputDrivenDPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::InputDrivenDPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/InputDrivenNPDA.cpp b/alib2data/src/automaton/PDA/InputDrivenNPDA.cpp
index 539ce7a125..dc2e0b5418 100644
--- a/alib2data/src/automaton/PDA/InputDrivenNPDA.cpp
+++ b/alib2data/src/automaton/PDA/InputDrivenNPDA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-InputDrivenNPDA::InputDrivenNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < InputDrivenNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+InputDrivenNPDA::InputDrivenNPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol initialSymbol, std::set < label::Label > finalStates ) : std::Components < InputDrivenNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-InputDrivenNPDA::InputDrivenNPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : InputDrivenNPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
+InputDrivenNPDA::InputDrivenNPDA(label::Label initialState, alphabet::Symbol initialPushdownSymbol) : InputDrivenNPDA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* InputDrivenNPDA::clone() const {
@@ -72,7 +72,7 @@ void InputDrivenNPDA::setPushdownStoreOperations(std::map<alphabet::Symbol, std:
 }
 
 bool InputDrivenNPDA::clearPushdownStoreOperation(const alphabet::Symbol& input) {
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions) {
+	for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> >& transition : transitions) {
 		if (transition.first.second == input)
 			throw AutomatonException("Input symbol \"" + (std::string) input + "\" is used.");
 	}
@@ -84,9 +84,9 @@ const std::map<alphabet::Symbol, std::pair<std::vector<alphabet::Symbol>, std::v
 	return inputSymbolToPushdownStoreOperation;
 }
 
-bool InputDrivenNPDA::addTransition(State from, alphabet::Symbol input, State to) {
+bool InputDrivenNPDA::addTransition(label::Label from, alphabet::Symbol input, label::Label to) {
 	if (! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 
 	if (! getInputAlphabet().count(input))
 		throw AutomatonException("Input symbol \"" + (std::string) input + "\" doesn't exist.");
@@ -95,29 +95,29 @@ bool InputDrivenNPDA::addTransition(State from, alphabet::Symbol input, State to
 		throw AutomatonException("Input symbol \"" + (std::string) input + "\" doesn't exist.");
 
 	if (! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 
-	std::pair<State, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
 
 	return transitions[std::move(key)].insert(std::move(to)).second;
 }
 
-bool InputDrivenNPDA::removeTransition(const State& from, const alphabet::Symbol& input, const State& to) {
-	std::pair<State, alphabet::Symbol> key = std::make_pair(from, input);
+bool InputDrivenNPDA::removeTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to) {
+	std::pair<label::Label, alphabet::Symbol> key = std::make_pair(from, input);
 
 	return transitions[key].erase(to);
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, std::set<State> >& InputDrivenNPDA::getTransitions() const {
+const std::map<std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> >& InputDrivenNPDA::getTransitions() const {
 	return transitions;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > InputDrivenNPDA::getTransitionsFromState(const State& from) const {
+std::map<std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> > InputDrivenNPDA::getTransitionsFromState(const label::Label& from) const {
 	if (! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist");
 
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitionsFromState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions) {
+	std::map<std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> > transitionsFromState;
+	for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> >& transition : transitions) {
 		if (transition.first.first == from) {
 			transitionsFromState[transition.first].insert(transition.second.begin(), transition.second.end());
 		}
@@ -126,12 +126,12 @@ std::map<std::pair<State, alphabet::Symbol>, std::set<State> > InputDrivenNPDA::
 	return transitionsFromState;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > InputDrivenNPDA::getTransitionsToState(const State& to) const {
+std::map<std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> > InputDrivenNPDA::getTransitionsToState(const label::Label& to) const {
 	if (! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist");
 
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitionsToState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions) {
+	std::map<std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> > transitionsToState;
+	for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> >& transition : transitions) {
 		if (transition.second.find(to) != transition.second.end()) {
 			transitionsToState[transition.first].insert(transition.second.begin(), transition.second.end());
 		}
@@ -141,7 +141,7 @@ std::map<std::pair<State, alphabet::Symbol>, std::set<State> > InputDrivenNPDA::
 }
 
 bool InputDrivenNPDA::isDeterministic() const {
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions) {
+	for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> >& transition : transitions) {
 		if (transition.second.size() != 1 || transition.second.size() != 0) {
 			return false;
 		}
@@ -180,12 +180,12 @@ InputDrivenNPDA::operator std::string () const {
 InputDrivenNPDA InputDrivenNPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, InputDrivenNPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> pushdownStoreSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol initialPushdownStoreSymbol = AutomatonFromXMLParser::parseInitialPushdownStoreSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	InputDrivenNPDA automaton(std::move(initialState), std::move(initialPushdownStoreSymbol));
 	automaton.setStates(std::move(states));
@@ -202,9 +202,9 @@ InputDrivenNPDA InputDrivenNPDA::parse(std::deque<sax::Token>::iterator& input)
 
 void InputDrivenNPDA::parseTransition(std::deque<sax::Token>::iterator& input, InputDrivenNPDA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
diff --git a/alib2data/src/automaton/PDA/InputDrivenNPDA.h b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
index 942690987c..941c68cb8c 100644
--- a/alib2data/src/automaton/PDA/InputDrivenNPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
@@ -13,8 +13,8 @@
 #include <vector>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 
 namespace automaton {
 
@@ -29,58 +29,58 @@ class InitialState;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class InputDrivenNPDA : public AutomatonBase, public std::Components < InputDrivenNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class InputDrivenNPDA : public AutomatonBase, public std::Components < InputDrivenNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > transitions;
 	std::map < alphabet::Symbol, std::pair < std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > inputSymbolToPushdownStoreOperation;
 
 	void checkPushdownStoreOperation ( const alphabet::Symbol & input, const std::vector < alphabet::Symbol > & pop, const std::vector < alphabet::Symbol > & push );
 
 public:
-	explicit InputDrivenNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol initialPushdownSymbol, std::set < automaton::State > finalStates );
-	explicit InputDrivenNPDA ( State initialState, alphabet::Symbol initialPushdownSymbol );
+	explicit InputDrivenNPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol initialPushdownSymbol, std::set < label::Label > finalStates );
+	explicit InputDrivenNPDA ( label::Label initialState, alphabet::Symbol initialPushdownSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -147,23 +147,23 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( State current, alphabet::Symbol input, State next );
+	bool addTransition ( label::Label current, alphabet::Symbol input, label::Label next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < State, alphabet::Symbol >, std::set < State > > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & getTransitions ( ) const;
 
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getTransitionsFromState ( const State & from ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getTransitionsFromState ( const label::Label & from ) const;
 
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > getTransitionsToState ( const State & to ) const;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > getTransitionsToState ( const label::Label & to ) const;
 
 	/**
 	 * Determines whether InputDrivenNPDA is deterministic.
@@ -208,7 +208,7 @@ template < >
 class ComponentConstraint< automaton::InputDrivenNPDA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::InputDrivenNPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State>>& transition : automaton.getTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<label::Label>>& transition : automaton.getTransitions())
 			if (transition.first.second == symbol)
 				return true;
 
@@ -260,53 +260,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::InputDrivenNPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::InputDrivenNPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::InputDrivenNPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::InputDrivenNPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State> >& transition : automaton.getTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> >& transition : automaton.getTransitions())
 			if (transition.first.first == state || transition.second.find(state) != transition.second.end())
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+	static bool available ( const automaton::InputDrivenNPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::InputDrivenNPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::InputDrivenNPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::InputDrivenNPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+	static bool used ( const automaton::InputDrivenNPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::InputDrivenNPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::InputDrivenNPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::InputDrivenNPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::InputDrivenNPDA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::InputDrivenNPDA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::InputDrivenNPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::InputDrivenNPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::InputDrivenNPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/NPDA.cpp b/alib2data/src/automaton/PDA/NPDA.cpp
index 1c4b4c93ee..81b1a82427 100644
--- a/alib2data/src/automaton/PDA/NPDA.cpp
+++ b/alib2data/src/automaton/PDA/NPDA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-NPDA::NPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < NPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NPDA::NPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol initialSymbol, std::set < label::Label > finalStates ) : std::Components < NPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-NPDA::NPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : NPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
+NPDA::NPDA(label::Label initialState, alphabet::Symbol initialPushdownSymbol) : NPDA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* NPDA::clone() const {
@@ -33,15 +33,15 @@ AutomatonBase* NPDA::plunder() && {
 	return new NPDA(std::move(*this));
 }
 
-bool NPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push) {
+bool NPDA::addTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	if (! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 
 	if (input.is<alphabet::Symbol>() && ! getInputAlphabet().count(input.get<alphabet::Symbol>()))
 		throw AutomatonException("Input symbol \"" + (std::string) input.get<alphabet::Symbol>() + "\" doesn't exist.");
 
 	if (! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 
 	for(const alphabet::Symbol& popSymbol : pop)
 		if (! getPushdownStoreAlphabet().count(popSymbol))
@@ -51,40 +51,40 @@ bool NPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Sym
 		if (! getPushdownStoreAlphabet().count(pushSymbol))
 			throw AutomatonException("Pushdown store symbol \"" + (std::string) pushSymbol + "\" doesn't exist.");
 
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(std::move(from), std::move(input), std::move(pop));
-	std::pair<automaton::State, std::vector<alphabet::Symbol> > value = std::make_pair(std::move(to), std::move(push));
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(std::move(from), std::move(input), std::move(pop));
+	std::pair<label::Label, std::vector<alphabet::Symbol> > value = std::make_pair(std::move(to), std::move(push));
 
 	return transitions[std::move(key)].insert(std::move(value)).second;
 }
 
-bool NPDA::addTransition(State from, alphabet::Symbol input, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push) {
+bool NPDA::addTransition(label::Label from, alphabet::Symbol input, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
 }
 
-bool NPDA::addTransition(State from, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push) {
+bool NPDA::addTransition(label::Label from, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
 }
 
-bool NPDA::removeTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(from, input, pop);
-	std::pair<automaton::State, std::vector<alphabet::Symbol> > value = std::make_pair(to, push);
+bool NPDA::removeTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(from, input, pop);
+	std::pair<label::Label, std::vector<alphabet::Symbol> > value = std::make_pair(to, push);
 
 	return transitions[key].erase(value);
 }
 
-bool NPDA::removeTransition(const State& from, const alphabet::Symbol& input, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
+bool NPDA::removeTransition(const label::Label& from, const alphabet::Symbol& input, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeTransition(from, inputVariant, pop, to, push);
 }
 
-bool NPDA::removeTransition(const State& from, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
+bool NPDA::removeTransition(const label::Label& from, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeTransition(from, inputVariant, pop, to, push);
 }
 
-const std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<State, std::vector<alphabet::Symbol> > > >& NPDA::getTransitions() const {
+const std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<label::Label, std::vector<alphabet::Symbol> > > >& NPDA::getTransitions() const {
 	return transitions;
 }
 
@@ -117,12 +117,12 @@ NPDA::operator std::string () const {
 NPDA NPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, NPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> pushdownStoreSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol initialPushdownStoreSymbol = AutomatonFromXMLParser::parseInitialPushdownStoreSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	NPDA automaton(std::move(initialState), std::move(initialPushdownStoreSymbol));
 	automaton.setStates(std::move(states));
@@ -138,10 +138,10 @@ NPDA NPDA::parse(std::deque<sax::Token>::iterator& input) {
 
 void NPDA::parseTransition(std::deque<sax::Token>::iterator& input, NPDA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
 	std::vector<alphabet::Symbol> pop = AutomatonFromXMLParser::parseTransitionPop(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	std::vector<alphabet::Symbol> push = AutomatonFromXMLParser::parseTransitionPush(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
diff --git a/alib2data/src/automaton/PDA/NPDA.h b/alib2data/src/automaton/PDA/NPDA.h
index 47b8294fdf..076d736491 100644
--- a/alib2data/src/automaton/PDA/NPDA.h
+++ b/alib2data/src/automaton/PDA/NPDA.h
@@ -15,8 +15,8 @@
 #include <variant>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/Epsilon.h"
 
 namespace automaton {
@@ -31,55 +31,55 @@ class InitialState;
 /**
  * Push Down Automaton
  */
-class NPDA : public AutomatonBase, public std::Components < NPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NPDA : public AutomatonBase, public std::Components < NPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::pair < State, std::vector < alphabet::Symbol > > > > transitions;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::pair < label::Label, std::vector < alphabet::Symbol > > > > transitions;
 
 public:
-	explicit NPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol initialPushdownSymbol, std::set < automaton::State > finalStates );
-	explicit NPDA ( State initialState, alphabet::Symbol initialPushdownSymbol );
+	explicit NPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol initialPushdownSymbol, std::set < label::Label > finalStates );
+	explicit NPDA ( label::Label initialState, alphabet::Symbol initialPushdownSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -137,27 +137,27 @@ public:
 	 * @throws AutomatonException when some part of the transition is not present
 	 * in the NPDA (state, input symbol, stack symbol) or when transition already exists
 	 */
-	bool addTransition ( State from, std::variant < string::Epsilon, alphabet::Symbol > input, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, std::variant < string::Epsilon, alphabet::Symbol > input, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push );
 
-	bool addTransition ( State from, alphabet::Symbol input, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, alphabet::Symbol input, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push );
 
-	bool addTransition ( State from, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push );
 
 	/**
 	 * Removes the transition from the NPDA.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition is not present in the NPDA
 	 */
-	bool removeTransition ( const State & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
-	bool removeTransition ( const State & from, const alphabet::Symbol & input, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const alphabet::Symbol & input, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
-	bool removeTransition ( const State & from, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
 	/**
 	 * @return NPDA transitions
 	 */
-	const std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::pair < State, std::vector < alphabet::Symbol > > > > & getTransitions ( ) const;
+	const std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::pair < label::Label, std::vector < alphabet::Symbol > > > > & getTransitions ( ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -192,7 +192,7 @@ template < >
 class ComponentConstraint< automaton::NPDA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::NPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<label::Label, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
 			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
 				return true;
 
@@ -214,12 +214,12 @@ public:
 		if(automaton.getInitialSymbol() == symbol)
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<label::Label, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
 			for (const alphabet::Symbol& popSymbol : std::get<2>(transition.first))
 				if (symbol == popSymbol)
 					return true;
 
-			for (const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
+			for (const std::pair<label::Label, std::vector<alphabet::Symbol> >& target : transition.second)
 				if (std::find(target.second.begin(), target.second.end(), symbol) != target.second.end())
 					return true;
 		}
@@ -247,19 +247,19 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::NPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::NPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::NPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::NPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<label::Label, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
 			if (state == std::get<0>(transition.first))
 				return true;
-			for(const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
+			for(const std::pair<label::Label, std::vector<alphabet::Symbol> >& target : transition.second)
 				if(target.first == state)
 					return true;
 		}
@@ -267,37 +267,37 @@ public:
 		return false;
 	}
 
-	static bool available ( const automaton::NPDA &, const automaton::State & ) {
+	static bool available ( const automaton::NPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::NPDA &, const automaton::State & ) {
+	static void valid ( const automaton::NPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::NPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::NPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::NPDA &, const automaton::State & ) {
+	static bool used ( const automaton::NPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::NPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::NPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::NPDA &, const automaton::State & ) {
+	static void valid ( const automaton::NPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::NPDA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::NPDA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::NPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::NPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::NPDA &, const automaton::State & ) {
+	static void valid ( const automaton::NPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/NPDTA.cpp b/alib2data/src/automaton/PDA/NPDTA.cpp
index 51cb90c197..22901096c2 100644
--- a/alib2data/src/automaton/PDA/NPDTA.cpp
+++ b/alib2data/src/automaton/PDA/NPDTA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-NPDTA::NPDTA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > outputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < NPDTA, alphabet::Symbol, std::tuple < InputAlphabet, OutputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( outputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NPDTA::NPDTA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > outputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol initialSymbol, std::set < label::Label > finalStates ) : std::Components < NPDTA, alphabet::Symbol, std::tuple < InputAlphabet, OutputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( outputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-NPDTA::NPDTA(State initialState, alphabet::Symbol initialPushdownSymbol) : NPDTA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
+NPDTA::NPDTA(label::Label initialState, alphabet::Symbol initialPushdownSymbol) : NPDTA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* NPDTA::clone() const {
@@ -33,9 +33,9 @@ AutomatonBase* NPDTA::plunder() && {
 	return new NPDTA(std::move(*this));
 }
 
-bool NPDTA::addTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push, std::vector<alphabet::Symbol> output) {
+bool NPDTA::addTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push, std::vector<alphabet::Symbol> output) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && !getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -43,7 +43,7 @@ bool NPDTA::addTransition(State from, std::variant<string::Epsilon, alphabet::Sy
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	for(const alphabet::Symbol& popSymbol : pop) {
@@ -64,48 +64,48 @@ bool NPDTA::addTransition(State from, std::variant<string::Epsilon, alphabet::Sy
 		}
 	}
 
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(std::move(from), std::move(input), std::move(pop));
-	std::tuple<State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > value(std::move(to), std::move(push), std::move(output));
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(std::move(from), std::move(input), std::move(pop));
+	std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > value(std::move(to), std::move(push), std::move(output));
 
 	return transitions[std::move(key)].insert(std::move(value)).second;
 }
 
-bool NPDTA::addTransition(State from, alphabet::Symbol input, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push, std::vector<alphabet::Symbol> output) {
+bool NPDTA::addTransition(label::Label from, alphabet::Symbol input, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push, std::vector<alphabet::Symbol> output) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push), std::move(output));
 }
 
-bool NPDTA::addTransition(State from, std::vector<alphabet::Symbol> pop, State to, std::vector<alphabet::Symbol> push, std::vector<alphabet::Symbol> output) {
+bool NPDTA::addTransition(label::Label from, std::vector<alphabet::Symbol> pop, label::Label to, std::vector<alphabet::Symbol> push, std::vector<alphabet::Symbol> output) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push), std::move(output));
 }
 
-bool NPDTA::removeTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push, const std::vector<alphabet::Symbol>& output) {
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(from, input, pop);
-	std::tuple<State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > value(to, push, output);
+bool NPDTA::removeTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push, const std::vector<alphabet::Symbol>& output) {
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> > key(from, input, pop);
+	std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > value(to, push, output);
 
 	return transitions[key].erase(value);
 }
 
-bool NPDTA::removeTransition(const State& from, const alphabet::Symbol& input, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push, const std::vector<alphabet::Symbol>& output) {
+bool NPDTA::removeTransition(const label::Label& from, const alphabet::Symbol& input, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push, const std::vector<alphabet::Symbol>& output) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeTransition(from, inputVariant, pop, to, push, output);
 }
 
-bool NPDTA::removeTransition(const State& from, const std::vector<alphabet::Symbol>& pop, const State& to, const std::vector<alphabet::Symbol>& push, const std::vector<alphabet::Symbol>& output) {
+bool NPDTA::removeTransition(const label::Label& from, const std::vector<alphabet::Symbol>& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push, const std::vector<alphabet::Symbol>& output) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeTransition(from, inputVariant, pop, to, push, output);
 }
 
-const std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& NPDTA::getTransitions() const {
+const std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& NPDTA::getTransitions() const {
 	return transitions;
 }
 
-std::set < std::pair < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::tuple < State, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > NPDTA::getTransitionsFromState ( const State & from ) const {
+std::set < std::pair < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::tuple < label::Label, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > NPDTA::getTransitionsFromState ( const label::Label & from ) const {
 	if( !getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist");
 
-	std::set < std::pair < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::tuple < State, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > transitionsFromState;
+	std::set < std::pair < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::tuple < label::Label, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > transitionsFromState;
 	for ( auto transition: transitions ) {
 		for ( auto iter: transition.second ) {
 			if ( std::get<0>(transition.first) == from ) {
@@ -147,13 +147,13 @@ NPDTA::operator std::string () const {
 NPDTA NPDTA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, NPDTA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> stackSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
 	std::set<alphabet::Symbol> outputSymbols = AutomatonFromXMLParser::parseOutputAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol initialPushdownStoreSymbol = AutomatonFromXMLParser::parseInitialPushdownStoreSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	NPDTA automaton(std::move(initialState), std::move(initialPushdownStoreSymbol));
 	automaton.setStates(std::move(states));
@@ -170,10 +170,10 @@ NPDTA NPDTA::parse(std::deque<sax::Token>::iterator& input) {
 
 void NPDTA::parseTransition(std::deque<sax::Token>::iterator& input, NPDTA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
 	std::vector<alphabet::Symbol> pop = AutomatonFromXMLParser::parseTransitionPop(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	std::vector<alphabet::Symbol> push = AutomatonFromXMLParser::parseTransitionPush(input);
 	std::vector<alphabet::Symbol> output = AutomatonFromXMLParser::parseTransitionOutputSymbolMultiple(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
diff --git a/alib2data/src/automaton/PDA/NPDTA.h b/alib2data/src/automaton/PDA/NPDTA.h
index e1c9bffb87..4cdd49114a 100644
--- a/alib2data/src/automaton/PDA/NPDTA.h
+++ b/alib2data/src/automaton/PDA/NPDTA.h
@@ -15,8 +15,8 @@
 #include <variant>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/Epsilon.h"
 
 namespace automaton {
@@ -32,56 +32,56 @@ class InitialState;
 /**
  * Push Down Translation Automaton
  */
-class NPDTA : public AutomatonBase, public std::Components < NPDTA, alphabet::Symbol, std::tuple < InputAlphabet, OutputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NPDTA : public AutomatonBase, public std::Components < NPDTA, alphabet::Symbol, std::tuple < InputAlphabet, OutputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::tuple < State, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > transitions;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::tuple < label::Label, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > transitions;
 
 public:
-	explicit NPDTA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > outputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol initialPushdownSymbol, std::set < automaton::State > finalStates );
-	explicit NPDTA ( State initialState, alphabet::Symbol initialPushdownSymbol );
+	explicit NPDTA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > outputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol initialPushdownSymbol, std::set < label::Label > finalStates );
+	explicit NPDTA ( label::Label initialState, alphabet::Symbol initialPushdownSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -159,29 +159,29 @@ public:
 	 * @throws AutomatonException when some part of the transition is not present
 	 * in the NPDTA (state, input symbol, stack symbol, output symbol) or when transition already exists
 	 */
-	bool addTransition ( State from, std::variant < string::Epsilon, alphabet::Symbol > input, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push, std::vector < alphabet::Symbol > output );
+	bool addTransition ( label::Label from, std::variant < string::Epsilon, alphabet::Symbol > input, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push, std::vector < alphabet::Symbol > output );
 
-	bool addTransition ( State from, alphabet::Symbol input, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push, std::vector < alphabet::Symbol > output );
+	bool addTransition ( label::Label from, alphabet::Symbol input, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push, std::vector < alphabet::Symbol > output );
 
-	bool addTransition ( State from, std::vector < alphabet::Symbol > pop, State to, std::vector < alphabet::Symbol > push, std::vector < alphabet::Symbol > output );
+	bool addTransition ( label::Label from, std::vector < alphabet::Symbol > pop, label::Label to, std::vector < alphabet::Symbol > push, std::vector < alphabet::Symbol > output );
 
 	/**
 	 * Removes the transition from the NPDTA.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition is not present in the NPDTA
 	 */
-	bool removeTransition ( const State & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push, const std::vector < alphabet::Symbol > & output );
+	bool removeTransition ( const label::Label & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push, const std::vector < alphabet::Symbol > & output );
 
-	bool removeTransition ( const State & from, const alphabet::Symbol & input, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push, const std::vector < alphabet::Symbol > & output );
+	bool removeTransition ( const label::Label & from, const alphabet::Symbol & input, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push, const std::vector < alphabet::Symbol > & output );
 
-	bool removeTransition ( const State & from, const std::vector < alphabet::Symbol > & pop, const State & to, const std::vector < alphabet::Symbol > & push, const std::vector < alphabet::Symbol > & output );
+	bool removeTransition ( const label::Label & from, const std::vector < alphabet::Symbol > & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push, const std::vector < alphabet::Symbol > & output );
 
 	/**
 	 * @return NPDTA transitions
 	 */
-	const std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::tuple < State, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > & getTransitions ( ) const;
+	const std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::tuple < label::Label, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > & getTransitions ( ) const;
 
-	std::set < std::pair < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::tuple < State, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > getTransitionsFromState ( const State & from ) const;
+	std::set < std::pair < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::tuple < label::Label, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > getTransitionsFromState ( const label::Label & from ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -216,7 +216,7 @@ template < >
 class ComponentConstraint< automaton::NPDTA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::NPDTA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
 			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
 				return true;
 
@@ -235,8 +235,8 @@ template < >
 class ComponentConstraint< automaton::NPDTA, alphabet::Symbol, automaton::OutputAlphabet > {
 public:
 	static bool used ( const automaton::NPDTA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
-			for(const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
+			for(const std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
 				if (std::find(std::get<2>(target).begin(), std::get<2>(target).end(), symbol) != std::get<2>(target).end())
 					return true;
 
@@ -258,12 +258,12 @@ public:
 		if(automaton.getInitialSymbol() == symbol)
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
 			for (const alphabet::Symbol& popSymbol : std::get<2>(transition.first))
 				if (symbol == popSymbol)
 					return true;
 
-			for (const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
+			for (const std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
 				if (std::find(std::get<1>(target).begin(), std::get<1>(target).end(), symbol) != std::get<1>(target).end())
 					return true;
 		}
@@ -291,20 +291,20 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::NPDTA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::NPDTA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::NPDTA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::NPDTA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
 			if (state == std::get<0>(transition.first))
 				return true;
 
-			for(const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
+			for(const std::tuple<label::Label, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
 				if(std::get<0>(target) == state)
 					return true;
 		}
@@ -312,37 +312,37 @@ public:
 		return false;
 	}
 
-	static bool available ( const automaton::NPDTA &, const automaton::State & ) {
+	static bool available ( const automaton::NPDTA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::NPDTA &, const automaton::State & ) {
+	static void valid ( const automaton::NPDTA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::NPDTA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::NPDTA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::NPDTA &, const automaton::State & ) {
+	static bool used ( const automaton::NPDTA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::NPDTA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::NPDTA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::NPDTA &, const automaton::State & ) {
+	static void valid ( const automaton::NPDTA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::NPDTA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::NPDTA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::NPDTA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::NPDTA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::NPDTA &, const automaton::State & ) {
+	static void valid ( const automaton::NPDTA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.cpp b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.cpp
index e14c008aaa..228004b3d0 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.cpp
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-RealTimeHeightDeterministicDPDA::RealTimeHeightDeterministicDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components < RealTimeHeightDeterministicDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+RealTimeHeightDeterministicDPDA::RealTimeHeightDeterministicDPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < label::Label > finalStates ) : std::Components < RealTimeHeightDeterministicDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-RealTimeHeightDeterministicDPDA::RealTimeHeightDeterministicDPDA(State initialState, alphabet::Symbol bottomOfTheStackSymbol) : RealTimeHeightDeterministicDPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, initialState, bottomOfTheStackSymbol, std::set < automaton::State > { }) {
+RealTimeHeightDeterministicDPDA::RealTimeHeightDeterministicDPDA(label::Label initialState, alphabet::Symbol bottomOfTheStackSymbol) : RealTimeHeightDeterministicDPDA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, initialState, bottomOfTheStackSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* RealTimeHeightDeterministicDPDA::clone() const {
@@ -33,9 +33,9 @@ AutomatonBase* RealTimeHeightDeterministicDPDA::plunder() && {
 	return new RealTimeHeightDeterministicDPDA(std::move(*this));
 }
 
-bool RealTimeHeightDeterministicDPDA::addCallTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, State to, alphabet::Symbol push) {
+bool RealTimeHeightDeterministicDPDA::addCallTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, label::Label to, alphabet::Symbol push) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && !getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -43,7 +43,7 @@ bool RealTimeHeightDeterministicDPDA::addCallTransition(State from, std::variant
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (!getPushdownStoreAlphabet().count(push)) {
@@ -53,8 +53,8 @@ bool RealTimeHeightDeterministicDPDA::addCallTransition(State from, std::variant
 	if(getBottomOfTheStackSymbol() == push)
 		throw AutomatonException("Pushdown store symbol \"" + (std::string) push + "\" is bottom of the stack.");
 
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>> key(std::move(from), std::move(input));
-	std::pair<automaton::State, alphabet::Symbol> value = std::make_pair(std::move(to), std::move(push));
+	std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>> key(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> value = std::make_pair(std::move(to), std::move(push));
 
 	if(callTransitions.find(key) != callTransitions.end() && callTransitions.find(key)->second == value)
 		return false;
@@ -89,19 +89,19 @@ bool RealTimeHeightDeterministicDPDA::addCallTransition(State from, std::variant
 	return true;
 }
 
-bool RealTimeHeightDeterministicDPDA::addCallTransition(State from, State to, alphabet::Symbol push) {
+bool RealTimeHeightDeterministicDPDA::addCallTransition(label::Label from, label::Label to, alphabet::Symbol push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addCallTransition(std::move(from), std::move(inputVariant), std::move(to), std::move(push));
 }
 
-bool RealTimeHeightDeterministicDPDA::addCallTransition(State from, alphabet::Symbol input, State to, alphabet::Symbol push) {
+bool RealTimeHeightDeterministicDPDA::addCallTransition(label::Label from, alphabet::Symbol input, label::Label to, alphabet::Symbol push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addCallTransition(std::move(from), std::move(inputVariant), std::move(to), std::move(push));
 }
 
-bool RealTimeHeightDeterministicDPDA::addReturnTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, alphabet::Symbol pop, State to) {
+bool RealTimeHeightDeterministicDPDA::addReturnTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, alphabet::Symbol pop, label::Label to) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && !getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -109,14 +109,14 @@ bool RealTimeHeightDeterministicDPDA::addReturnTransition(State from, std::varia
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (!getPushdownStoreAlphabet().count(pop)) {
 		throw AutomatonException("Pushdown store symbol \"" + (std::string) pop + "\" doesn't exist.");
 	}
 
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
 
 	if(returnTransitions.find(key) != returnTransitions.end() && returnTransitions.find(key)->second == to)
 		return false;
@@ -151,19 +151,19 @@ bool RealTimeHeightDeterministicDPDA::addReturnTransition(State from, std::varia
 	return true;
 }
 
-bool RealTimeHeightDeterministicDPDA::addReturnTransition(State from, alphabet::Symbol pop, State to) {
+bool RealTimeHeightDeterministicDPDA::addReturnTransition(label::Label from, alphabet::Symbol pop, label::Label to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addReturnTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
 }
 
-bool RealTimeHeightDeterministicDPDA::addReturnTransition(State from, alphabet::Symbol input, alphabet::Symbol pop, State to) {
+bool RealTimeHeightDeterministicDPDA::addReturnTransition(label::Label from, alphabet::Symbol input, alphabet::Symbol pop, label::Label to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addReturnTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
 }
 
-bool RealTimeHeightDeterministicDPDA::addLocalTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, State to) {
+bool RealTimeHeightDeterministicDPDA::addLocalTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, label::Label to) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && !getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -171,10 +171,10 @@ bool RealTimeHeightDeterministicDPDA::addLocalTransition(State from, std::varian
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>> key(std::move(from), std::move(input));
+	std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>> key(std::move(from), std::move(input));
 
 	if(localTransitions.find(key) != localTransitions.end() && localTransitions.find(key)->second == to)
 		return false;
@@ -209,101 +209,101 @@ bool RealTimeHeightDeterministicDPDA::addLocalTransition(State from, std::varian
 	return true;
 }
 
-bool RealTimeHeightDeterministicDPDA::addLocalTransition(State from, State to) {
+bool RealTimeHeightDeterministicDPDA::addLocalTransition(label::Label from, label::Label to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addLocalTransition(std::move(from), std::move(inputVariant), std::move(to));
 }
 
-bool RealTimeHeightDeterministicDPDA::addLocalTransition(State from, alphabet::Symbol input, State to) {
+bool RealTimeHeightDeterministicDPDA::addLocalTransition(label::Label from, alphabet::Symbol input, label::Label to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addLocalTransition(std::move(from), std::move(inputVariant), std::move(to));
 }
 
-bool RealTimeHeightDeterministicDPDA::removeCallTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const State& to, const alphabet::Symbol& push) {
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>> key(from, input);
-	std::pair<automaton::State, alphabet::Symbol> value = std::make_pair(to, push);
+bool RealTimeHeightDeterministicDPDA::removeCallTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const label::Label& to, const alphabet::Symbol& push) {
+	std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>> key(from, input);
+	std::pair<label::Label, alphabet::Symbol> value = std::make_pair(to, push);
 
 	if (callTransitions.find(key) == callTransitions.end())
 		return false;
 
 	if(callTransitions.find(key)->second != value)
 		throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input
-						+ "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input
+						+ "\") -> \"" + (std::string) to + "\" doesn't exist.");
 
 	callTransitions.erase(key);
 	return true;
 }
 
-bool RealTimeHeightDeterministicDPDA::removeCallTransition(const State& from, const State& to, const alphabet::Symbol& push) {
+bool RealTimeHeightDeterministicDPDA::removeCallTransition(const label::Label& from, const label::Label& to, const alphabet::Symbol& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeCallTransition(from, inputVariant, to, push);
 }
 
-bool RealTimeHeightDeterministicDPDA::removeCallTransition(const State& from, const alphabet::Symbol& input, const State& to, const alphabet::Symbol& push) {
+bool RealTimeHeightDeterministicDPDA::removeCallTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to, const alphabet::Symbol& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeCallTransition(from, inputVariant, to, push);
 }
 
-bool RealTimeHeightDeterministicDPDA::removeReturnTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& pop, const State& to) {
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(from, input, pop);
+bool RealTimeHeightDeterministicDPDA::removeReturnTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& pop, const label::Label& to) {
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(from, input, pop);
 
 	if (returnTransitions.find(key) == returnTransitions.end())
 		return false;
 
 	if(returnTransitions.find(key)->second != to)
 		throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input
-						+ "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input
+						+ "\") -> \"" + (std::string) to + "\" doesn't exist.");
 
 	returnTransitions.erase(key);
 	return true;
 }
 
-bool RealTimeHeightDeterministicDPDA::removeReturnTransition(const State& from, const alphabet::Symbol& pop, const State& to) {
+bool RealTimeHeightDeterministicDPDA::removeReturnTransition(const label::Label& from, const alphabet::Symbol& pop, const label::Label& to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeReturnTransition(from, inputVariant, pop, to);
 }
 
-bool RealTimeHeightDeterministicDPDA::removeReturnTransition(const State& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const State& to) {
+bool RealTimeHeightDeterministicDPDA::removeReturnTransition(const label::Label& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const label::Label& to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeReturnTransition(from, inputVariant, pop, to);
 }
 
-bool RealTimeHeightDeterministicDPDA::removeLocalTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const State& to) {
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>> key(from, input);
+bool RealTimeHeightDeterministicDPDA::removeLocalTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const label::Label& to) {
+	std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>> key(from, input);
 
 	if (localTransitions.find(key) == localTransitions.end())
 		return false;
 
 	if(localTransitions.find(key)->second != to)
 		throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input
-						+ "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input
+						+ "\") -> \"" + (std::string) to + "\" doesn't exist.");
 
 	localTransitions.erase(key);
 	return true;
 }
 
-bool RealTimeHeightDeterministicDPDA::removeLocalTransition(const State& from, const State& to) {
+bool RealTimeHeightDeterministicDPDA::removeLocalTransition(const label::Label& from, const label::Label& to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeLocalTransition(from, inputVariant, to);
 }
 
-bool RealTimeHeightDeterministicDPDA::removeLocalTransition(const State& from, const alphabet::Symbol& input, const State& to) {
+bool RealTimeHeightDeterministicDPDA::removeLocalTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeLocalTransition(from, inputVariant, to);
 }
 
-const std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>>, std::pair<State, alphabet::Symbol> >& RealTimeHeightDeterministicDPDA::getCallTransitions() const {
+const std::map<std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>>, std::pair<label::Label, alphabet::Symbol> >& RealTimeHeightDeterministicDPDA::getCallTransitions() const {
 	return callTransitions;
 }
 
-const std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, State>& RealTimeHeightDeterministicDPDA::getReturnTransitions() const {
+const std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, label::Label>& RealTimeHeightDeterministicDPDA::getReturnTransitions() const {
 	return returnTransitions;
 }
 
-const std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>>, State>& RealTimeHeightDeterministicDPDA::getLocalTransitions() const {
+const std::map<std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>>, label::Label>& RealTimeHeightDeterministicDPDA::getLocalTransitions() const {
 	return localTransitions;
 }
 
@@ -338,12 +338,12 @@ RealTimeHeightDeterministicDPDA::operator std::string () const {
 RealTimeHeightDeterministicDPDA RealTimeHeightDeterministicDPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, RealTimeHeightDeterministicDPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> stackSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol bottomOfTheStackSymbol = AutomatonFromXMLParser::parseBottomOfTheStackSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	RealTimeHeightDeterministicDPDA automaton(std::move(initialState), std::move(bottomOfTheStackSymbol));
 	automaton.setStates(std::move(states));
@@ -360,27 +360,27 @@ RealTimeHeightDeterministicDPDA RealTimeHeightDeterministicDPDA::parse(std::dequ
 void RealTimeHeightDeterministicDPDA::parseTransition(std::deque<sax::Token>::iterator& input, RealTimeHeightDeterministicDPDA& automaton) {
 	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 		alphabet::Symbol push = AutomatonFromXMLParser::parseTransitionSinglePush(input);
 
 		automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
 	} else if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
 		alphabet::Symbol pop = AutomatonFromXMLParser::parseTransitionSinglePop(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 
 		automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
 	} else {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 
 		automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
index c5d59a8765..8f6b03bafb 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
@@ -14,8 +14,8 @@
 #include <variant>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/Epsilon.h"
 
 namespace automaton {
@@ -31,57 +31,57 @@ class InitialState;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class RealTimeHeightDeterministicDPDA : public AutomatonBase, public std::Components < RealTimeHeightDeterministicDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class RealTimeHeightDeterministicDPDA : public AutomatonBase, public std::Components < RealTimeHeightDeterministicDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::pair < State, alphabet::Symbol > > callTransitions;
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, State > returnTransitions;
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, State > localTransitions;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::pair < label::Label, alphabet::Symbol > > callTransitions;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, label::Label > returnTransitions;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, label::Label > localTransitions;
 
 public:
-	explicit RealTimeHeightDeterministicDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < automaton::State > finalStates );
-	explicit RealTimeHeightDeterministicDPDA ( State initialState, alphabet::Symbol bottomOfTheStackSymbol );
+	explicit RealTimeHeightDeterministicDPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < label::Label > finalStates );
+	explicit RealTimeHeightDeterministicDPDA ( label::Label initialState, alphabet::Symbol bottomOfTheStackSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -140,9 +140,9 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addCallTransition ( State current, std::variant < string::Epsilon, alphabet::Symbol > input, State next, alphabet::Symbol push );
-	bool addCallTransition ( State current, State next, alphabet::Symbol push );
-	bool addCallTransition ( State current, alphabet::Symbol input, State next, alphabet::Symbol push );
+	bool addCallTransition ( label::Label current, std::variant < string::Epsilon, alphabet::Symbol > input, label::Label next, alphabet::Symbol push );
+	bool addCallTransition ( label::Label current, label::Label next, alphabet::Symbol push );
+	bool addCallTransition ( label::Label current, alphabet::Symbol input, label::Label next, alphabet::Symbol push );
 
 	/**
 	 * Adds return transition defined by parameters to the automaton.
@@ -151,9 +151,9 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addReturnTransition ( State current, std::variant < string::Epsilon, alphabet::Symbol > input, alphabet::Symbol pop, State next );
-	bool addReturnTransition ( State current, alphabet::Symbol pop, State next );
-	bool addReturnTransition ( State current, alphabet::Symbol input, alphabet::Symbol pop, State next );
+	bool addReturnTransition ( label::Label current, std::variant < string::Epsilon, alphabet::Symbol > input, alphabet::Symbol pop, label::Label next );
+	bool addReturnTransition ( label::Label current, alphabet::Symbol pop, label::Label next );
+	bool addReturnTransition ( label::Label current, alphabet::Symbol input, alphabet::Symbol pop, label::Label next );
 
 	/**
 	 * Adds local transition defined by parameters to the automaton.
@@ -162,42 +162,42 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addLocalTransition ( State current, std::variant < string::Epsilon, alphabet::Symbol > input, State next );
-	bool addLocalTransition ( State current, State next );
-	bool addLocalTransition ( State current, alphabet::Symbol input, State next );
+	bool addLocalTransition ( label::Label current, std::variant < string::Epsilon, alphabet::Symbol > input, label::Label next );
+	bool addLocalTransition ( label::Label current, label::Label next );
+	bool addLocalTransition ( label::Label current, alphabet::Symbol input, label::Label next );
 
 	/**
 	 * Removes call transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeCallTransition ( const State & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const State & next, const alphabet::Symbol & push );
-	bool removeCallTransition ( const State & current, const State & next, const alphabet::Symbol & push );
-	bool removeCallTransition ( const State & current, const alphabet::Symbol & input, const State & next, const alphabet::Symbol & push );
+	bool removeCallTransition ( const label::Label & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const label::Label & next, const alphabet::Symbol & push );
+	bool removeCallTransition ( const label::Label & current, const label::Label & next, const alphabet::Symbol & push );
+	bool removeCallTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next, const alphabet::Symbol & push );
 
 	/**
 	 * Removes return transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeReturnTransition ( const State & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const alphabet::Symbol & pop, const State & next );
-	bool removeReturnTransition ( const State & current, const alphabet::Symbol & pop, const State & next );
-	bool removeReturnTransition ( const State & current, const alphabet::Symbol & input, const alphabet::Symbol & pop, const State & next );
+	bool removeReturnTransition ( const label::Label & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const alphabet::Symbol & pop, const label::Label & next );
+	bool removeReturnTransition ( const label::Label & current, const alphabet::Symbol & pop, const label::Label & next );
+	bool removeReturnTransition ( const label::Label & current, const alphabet::Symbol & input, const alphabet::Symbol & pop, const label::Label & next );
 
 	/**
 	 * Removes transition local from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeLocalTransition ( const State & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const State & next );
-	bool removeLocalTransition ( const State & current, const State & next );
-	bool removeLocalTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeLocalTransition ( const label::Label & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const label::Label & next );
+	bool removeLocalTransition ( const label::Label & current, const label::Label & next );
+	bool removeLocalTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
-	const std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::pair < State, alphabet::Symbol > > & getCallTransitions ( ) const;
+	const std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::pair < label::Label, alphabet::Symbol > > & getCallTransitions ( ) const;
 
-	const std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, State > & getReturnTransitions ( ) const;
+	const std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, label::Label > & getReturnTransitions ( ) const;
 
-	const std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, State > & getLocalTransitions ( ) const;
+	const std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, label::Label > & getLocalTransitions ( ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -232,15 +232,15 @@ template < >
 class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<label::Label, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
 			if (callTransition.first.second.is<alphabet::Symbol>() && symbol == callTransition.first.second.get<alphabet::Symbol>())
 				return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, label::Label>& returnTransition : automaton.getReturnTransitions())
 			if (std::get<1>(returnTransition.first).is<alphabet::Symbol>() && symbol == std::get<1>(returnTransition.first).get<alphabet::Symbol>())
 				return true;
 
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, automaton::State>& localTransition : automaton.getLocalTransitions())
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, label::Label>& localTransition : automaton.getLocalTransitions())
 			if (localTransition.first.second.is<alphabet::Symbol>() && symbol == localTransition.first.second.get<alphabet::Symbol>())
 				return true;
 
@@ -259,11 +259,11 @@ template < >
 class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
 public:
 	static bool used ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<label::Label, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
 			if (symbol == callTransition.second.second)
 				return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, label::Label>& returnTransition : automaton.getReturnTransitions())
 			if (symbol == std::get<2>(returnTransition.first))
 				return true;
 
@@ -293,61 +293,61 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<label::Label, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
 			if (state == callTransition.first.first || callTransition.second.first == state)
 				return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, label::Label>& returnTransition : automaton.getReturnTransitions())
 			if (state == std::get<0>(returnTransition.first) || returnTransition.second == state)
 				return true;
 
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, automaton::State>& localTransition : automaton.getLocalTransitions())
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, label::Label>& localTransition : automaton.getLocalTransitions())
 			if (state == localTransition.first.first || localTransition.second == state)
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+	static bool used ( const automaton::RealTimeHeightDeterministicDPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::RealTimeHeightDeterministicDPDA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.cpp b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.cpp
index 3b946f4f09..3a0014923f 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.cpp
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-RealTimeHeightDeterministicNPDA::RealTimeHeightDeterministicNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, std::set < State > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components < RealTimeHeightDeterministicNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > { } ) {
+RealTimeHeightDeterministicNPDA::RealTimeHeightDeterministicNPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, std::set < label::Label > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < label::Label > finalStates ) : std::Components < RealTimeHeightDeterministicNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, label::Label, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > { } ) {
 }
 
-RealTimeHeightDeterministicNPDA::RealTimeHeightDeterministicNPDA(alphabet::Symbol bottomOfTheStackSymbol) : RealTimeHeightDeterministicNPDA ( std::set < State > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, std::set < State > {}, bottomOfTheStackSymbol, std::set < automaton::State > { }) {
+RealTimeHeightDeterministicNPDA::RealTimeHeightDeterministicNPDA(alphabet::Symbol bottomOfTheStackSymbol) : RealTimeHeightDeterministicNPDA ( std::set < label::Label > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, std::set < label::Label > {}, bottomOfTheStackSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* RealTimeHeightDeterministicNPDA::clone() const {
@@ -33,9 +33,9 @@ AutomatonBase* RealTimeHeightDeterministicNPDA::plunder() && {
 	return new RealTimeHeightDeterministicNPDA(std::move(*this));
 }
 
-bool RealTimeHeightDeterministicNPDA::addCallTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, State to, alphabet::Symbol push) {
+bool RealTimeHeightDeterministicNPDA::addCallTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, label::Label to, alphabet::Symbol push) {
 	if (! getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && ! getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -43,32 +43,32 @@ bool RealTimeHeightDeterministicNPDA::addCallTransition(State from, std::variant
 	}
 
 	if (! getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (! getPushdownStoreAlphabet().count(push)) {
 		throw AutomatonException("Pushdown store symbol \"" + (std::string) push + "\" doesn't exist.");
 	}
 
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>> key(std::move(from), std::move(input));
-	std::pair<automaton::State, alphabet::Symbol> value = std::make_pair(std::move(to), std::move(push));
+	std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>> key(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> value = std::make_pair(std::move(to), std::move(push));
 
 	return callTransitions[std::move(key)].insert(std::move(value)).second;
 }
 
-bool RealTimeHeightDeterministicNPDA::addCallTransition(State from, State to, alphabet::Symbol push) {
+bool RealTimeHeightDeterministicNPDA::addCallTransition(label::Label from, label::Label to, alphabet::Symbol push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addCallTransition(std::move(from), std::move(inputVariant), std::move(to), std::move(push));
 }
 
-bool RealTimeHeightDeterministicNPDA::addCallTransition(State from, alphabet::Symbol input, State to, alphabet::Symbol push) {
+bool RealTimeHeightDeterministicNPDA::addCallTransition(label::Label from, alphabet::Symbol input, label::Label to, alphabet::Symbol push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return addCallTransition(std::move(from), std::move(inputVariant), std::move(to), std::move(push));
 }
 
-bool RealTimeHeightDeterministicNPDA::addReturnTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, alphabet::Symbol pop, State to) {
+bool RealTimeHeightDeterministicNPDA::addReturnTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, alphabet::Symbol pop, label::Label to) {
 	if (! getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && !getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -76,31 +76,31 @@ bool RealTimeHeightDeterministicNPDA::addReturnTransition(State from, std::varia
 	}
 
 	if (! getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (! getPushdownStoreAlphabet().count(pop)) {
 		throw AutomatonException("Pushdown store symbol \"" + (std::string) pop + "\" doesn't exist.");
 	}
 
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
 
 	return returnTransitions[std::move(key)].insert(std::move(to)).second;
 }
 
-bool RealTimeHeightDeterministicNPDA::addReturnTransition(State from, alphabet::Symbol pop, State to) {
+bool RealTimeHeightDeterministicNPDA::addReturnTransition(label::Label from, alphabet::Symbol pop, label::Label to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addReturnTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
 }
 
-bool RealTimeHeightDeterministicNPDA::addReturnTransition(State from, alphabet::Symbol input, alphabet::Symbol pop, State to) {
+bool RealTimeHeightDeterministicNPDA::addReturnTransition(label::Label from, alphabet::Symbol input, alphabet::Symbol pop, label::Label to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addReturnTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to));
 }
 
-bool RealTimeHeightDeterministicNPDA::addLocalTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, State to) {
+bool RealTimeHeightDeterministicNPDA::addLocalTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, label::Label to) {
 	if (! getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && ! getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -108,82 +108,82 @@ bool RealTimeHeightDeterministicNPDA::addLocalTransition(State from, std::varian
 	}
 
 	if (! getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>> key(std::move(from), std::move(input));
+	std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>> key(std::move(from), std::move(input));
 
 	return localTransitions[std::move(key)].insert(std::move(to)).second;
 }
 
-bool RealTimeHeightDeterministicNPDA::addLocalTransition(State from, State to) {
+bool RealTimeHeightDeterministicNPDA::addLocalTransition(label::Label from, label::Label to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addLocalTransition(std::move(from), std::move(inputVariant), std::move(to));
 }
 
-bool RealTimeHeightDeterministicNPDA::addLocalTransition(State from, alphabet::Symbol input, State to) {
+bool RealTimeHeightDeterministicNPDA::addLocalTransition(label::Label from, alphabet::Symbol input, label::Label to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addLocalTransition(std::move(from), std::move(inputVariant), std::move(to));
 }
 
-bool RealTimeHeightDeterministicNPDA::removeCallTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const State& to, const alphabet::Symbol& push) {
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>> key(from, input);
-	std::pair<automaton::State, alphabet::Symbol> value = std::make_pair(to, push);
+bool RealTimeHeightDeterministicNPDA::removeCallTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const label::Label& to, const alphabet::Symbol& push) {
+	std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>> key(from, input);
+	std::pair<label::Label, alphabet::Symbol> value = std::make_pair(to, push);
 
 	return callTransitions[key].erase(value);
 }
 
-bool RealTimeHeightDeterministicNPDA::removeCallTransition(const State& from, const State& to, const alphabet::Symbol& push) {
+bool RealTimeHeightDeterministicNPDA::removeCallTransition(const label::Label& from, const label::Label& to, const alphabet::Symbol& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeCallTransition(from, inputVariant, to, push);
 }
 
-bool RealTimeHeightDeterministicNPDA::removeCallTransition(const State& from, const alphabet::Symbol& input, const State& to, const alphabet::Symbol& push) {
+bool RealTimeHeightDeterministicNPDA::removeCallTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to, const alphabet::Symbol& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeCallTransition(from, inputVariant, to, push);
 }
 
-bool RealTimeHeightDeterministicNPDA::removeReturnTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& pop, const State& to) {
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(from, input, pop);
+bool RealTimeHeightDeterministicNPDA::removeReturnTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& pop, const label::Label& to) {
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(from, input, pop);
 
 	return returnTransitions[key].erase(to);
 }
 
-bool RealTimeHeightDeterministicNPDA::removeReturnTransition(const State& from, const alphabet::Symbol& pop, const State& to) {
+bool RealTimeHeightDeterministicNPDA::removeReturnTransition(const label::Label& from, const alphabet::Symbol& pop, const label::Label& to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeReturnTransition(from, inputVariant, pop, to);
 }
 
-bool RealTimeHeightDeterministicNPDA::removeReturnTransition(const State& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const State& to) {
+bool RealTimeHeightDeterministicNPDA::removeReturnTransition(const label::Label& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const label::Label& to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeReturnTransition(from, inputVariant, pop, to);
 }
 
-bool RealTimeHeightDeterministicNPDA::removeLocalTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const State& to) {
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>> key(from, input);
+bool RealTimeHeightDeterministicNPDA::removeLocalTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const label::Label& to) {
+	std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>> key(from, input);
 
 	return localTransitions[key].erase(to);
 }
 
-bool RealTimeHeightDeterministicNPDA::removeLocalTransition(const State& from, const State& to) {
+bool RealTimeHeightDeterministicNPDA::removeLocalTransition(const label::Label& from, const label::Label& to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeLocalTransition(from, inputVariant, to);
 }
 
-bool RealTimeHeightDeterministicNPDA::removeLocalTransition(const State& from, const alphabet::Symbol& input, const State& to) {
+bool RealTimeHeightDeterministicNPDA::removeLocalTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeLocalTransition(from, inputVariant, to);
 }
 
-const std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>>, std::set<std::pair<State, alphabet::Symbol> > >& RealTimeHeightDeterministicNPDA::getCallTransitions() const {
+const std::map<std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>>, std::set<std::pair<label::Label, alphabet::Symbol> > >& RealTimeHeightDeterministicNPDA::getCallTransitions() const {
 	return callTransitions;
 }
 
-const std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<State> >& RealTimeHeightDeterministicNPDA::getReturnTransitions() const {
+const std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<label::Label> >& RealTimeHeightDeterministicNPDA::getReturnTransitions() const {
 	return returnTransitions;
 }
 
-const std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol>>, std::set<State> >& RealTimeHeightDeterministicNPDA::getLocalTransitions() const {
+const std::map<std::pair<label::Label, std::variant<string::Epsilon, alphabet::Symbol>>, std::set<label::Label> >& RealTimeHeightDeterministicNPDA::getLocalTransitions() const {
 	return localTransitions;
 }
 
@@ -218,12 +218,12 @@ RealTimeHeightDeterministicNPDA::operator std::string () const {
 RealTimeHeightDeterministicNPDA RealTimeHeightDeterministicNPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, RealTimeHeightDeterministicNPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> stackSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	std::set<State> initialStates = AutomatonFromXMLParser::parseInitialStates(input);
+	std::set<label::Label> initialStates = AutomatonFromXMLParser::parseInitialStates(input);
 	alphabet::Symbol bottomOfTheStackSymbol = AutomatonFromXMLParser::parseBottomOfTheStackSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	RealTimeHeightDeterministicNPDA automaton(std::move(bottomOfTheStackSymbol));
 	automaton.setStates(std::move(states));
@@ -241,27 +241,27 @@ RealTimeHeightDeterministicNPDA RealTimeHeightDeterministicNPDA::parse(std::dequ
 void RealTimeHeightDeterministicNPDA::parseTransition(std::deque<sax::Token>::iterator& input, RealTimeHeightDeterministicNPDA& automaton) {
 	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 		alphabet::Symbol push = AutomatonFromXMLParser::parseTransitionSinglePush(input);
 
 		automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
 	} else if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
 		alphabet::Symbol pop = AutomatonFromXMLParser::parseTransitionSinglePop(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 
 		automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
 	} else {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 
 		automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
index e42f3e7a0b..6d34a069ec 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
@@ -14,8 +14,8 @@
 #include <variant>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/Epsilon.h"
 
 namespace automaton {
@@ -31,65 +31,65 @@ class InitialStates;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class RealTimeHeightDeterministicNPDA : public AutomatonBase, public std::Components < RealTimeHeightDeterministicNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class RealTimeHeightDeterministicNPDA : public AutomatonBase, public std::Components < RealTimeHeightDeterministicNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, label::Label, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < std::pair < State, alphabet::Symbol > > > callTransitions;
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < State > > returnTransitions;
-	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > localTransitions;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < std::pair < label::Label, alphabet::Symbol > > > callTransitions;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < label::Label > > returnTransitions;
+	std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > localTransitions;
 
 public:
-	explicit RealTimeHeightDeterministicNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, std::set < State > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < automaton::State > finalStates );
+	explicit RealTimeHeightDeterministicNPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, std::set < label::Label > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < label::Label > finalStates );
 	explicit RealTimeHeightDeterministicNPDA ( alphabet::Symbol bottomOfTheStackSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getInitialStates ( ) const {
+	const std::set < label::Label > & getInitialStates ( ) const {
 		return accessComponent < InitialStates > ( ).get ( );
 	}
 
-	bool addInitialState ( State state ) {
+	bool addInitialState ( label::Label state ) {
 		return accessComponent < InitialStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setInitialStates ( std::set < State > states ) {
+	void setInitialStates ( std::set < label::Label > states ) {
 		accessComponent < InitialStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeInitialState ( const State & state ) {
+	void removeInitialState ( const label::Label & state ) {
 		accessComponent < InitialStates > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -148,9 +148,9 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addCallTransition ( State current, std::variant < string::Epsilon, alphabet::Symbol > input, State next, alphabet::Symbol push );
-	bool addCallTransition ( State current, State next, alphabet::Symbol push );
-	bool addCallTransition ( State current, alphabet::Symbol input, State next, alphabet::Symbol push );
+	bool addCallTransition ( label::Label current, std::variant < string::Epsilon, alphabet::Symbol > input, label::Label next, alphabet::Symbol push );
+	bool addCallTransition ( label::Label current, label::Label next, alphabet::Symbol push );
+	bool addCallTransition ( label::Label current, alphabet::Symbol input, label::Label next, alphabet::Symbol push );
 
 	/**
 	 * Adds return transition defined by parameters to the automaton.
@@ -159,9 +159,9 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addReturnTransition ( State current, std::variant < string::Epsilon, alphabet::Symbol > input, alphabet::Symbol pop, State next );
-	bool addReturnTransition ( State current, alphabet::Symbol pop, State next );
-	bool addReturnTransition ( State current, alphabet::Symbol input, alphabet::Symbol pop, State next );
+	bool addReturnTransition ( label::Label current, std::variant < string::Epsilon, alphabet::Symbol > input, alphabet::Symbol pop, label::Label next );
+	bool addReturnTransition ( label::Label current, alphabet::Symbol pop, label::Label next );
+	bool addReturnTransition ( label::Label current, alphabet::Symbol input, alphabet::Symbol pop, label::Label next );
 
 	/**
 	 * Adds local transition defined by parameters to the automaton.
@@ -170,42 +170,42 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addLocalTransition ( State current, std::variant < string::Epsilon, alphabet::Symbol > input, State next );
-	bool addLocalTransition ( State current, State next );
-	bool addLocalTransition ( State current, alphabet::Symbol input, State next );
+	bool addLocalTransition ( label::Label current, std::variant < string::Epsilon, alphabet::Symbol > input, label::Label next );
+	bool addLocalTransition ( label::Label current, label::Label next );
+	bool addLocalTransition ( label::Label current, alphabet::Symbol input, label::Label next );
 
 	/**
 	 * Removes call transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeCallTransition ( const State & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const State & next, const alphabet::Symbol & push );
-	bool removeCallTransition ( const State & current, const State & next, const alphabet::Symbol & push );
-	bool removeCallTransition ( const State & current, const alphabet::Symbol & input, const State & next, const alphabet::Symbol & push );
+	bool removeCallTransition ( const label::Label & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const label::Label & next, const alphabet::Symbol & push );
+	bool removeCallTransition ( const label::Label & current, const label::Label & next, const alphabet::Symbol & push );
+	bool removeCallTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next, const alphabet::Symbol & push );
 
 	/**
 	 * Removes return transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeReturnTransition ( const State & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const alphabet::Symbol & pop, const State & next );
-	bool removeReturnTransition ( const State & current, const alphabet::Symbol & pop, const State & next );
-	bool removeReturnTransition ( const State & current, const alphabet::Symbol & input, const alphabet::Symbol & pop, const State & next );
+	bool removeReturnTransition ( const label::Label & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const alphabet::Symbol & pop, const label::Label & next );
+	bool removeReturnTransition ( const label::Label & current, const alphabet::Symbol & pop, const label::Label & next );
+	bool removeReturnTransition ( const label::Label & current, const alphabet::Symbol & input, const alphabet::Symbol & pop, const label::Label & next );
 
 	/**
 	 * Removes transition local from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeLocalTransition ( const State & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const State & next );
-	bool removeLocalTransition ( const State & current, const State & next );
-	bool removeLocalTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeLocalTransition ( const label::Label & current, const std::variant < string::Epsilon, alphabet::Symbol > & input, const label::Label & next );
+	bool removeLocalTransition ( const label::Label & current, const label::Label & next );
+	bool removeLocalTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
-	const std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < std::pair < State, alphabet::Symbol > > > & getCallTransitions ( ) const;
+	const std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < std::pair < label::Label, alphabet::Symbol > > > & getCallTransitions ( ) const;
 
-	const std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < State > > & getReturnTransitions ( ) const;
+	const std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < label::Label > > & getReturnTransitions ( ) const;
 
-	const std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & getLocalTransitions ( ) const;
+	const std::map < std::pair < label::Label, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < label::Label > > & getLocalTransitions ( ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -240,15 +240,15 @@ template < >
 class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<label::Label, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
 			if (callTransition.first.second.is<alphabet::Symbol>() && symbol == callTransition.first.second.get<alphabet::Symbol>())
 				return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<label::Label> >& returnTransition : automaton.getReturnTransitions())
 			if (std::get<1>(returnTransition.first).is<alphabet::Symbol>() && symbol == std::get<1>(returnTransition.first).get<alphabet::Symbol>())
 				return true;
 
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<automaton::State> >& localTransition : automaton.getLocalTransitions())
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<label::Label> >& localTransition : automaton.getLocalTransitions())
 			if (localTransition.first.second.is<alphabet::Symbol>() && symbol == localTransition.first.second.get<alphabet::Symbol>())
 				return true;
 
@@ -270,12 +270,12 @@ public:
 		if(automaton.getBottomOfTheStackSymbol() == symbol)
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
-			for(const std::pair<automaton::State, alphabet::Symbol>& to : callTransition.second)
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<label::Label, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
+			for(const std::pair<label::Label, alphabet::Symbol>& to : callTransition.second)
 				if (symbol == to.second)
 					return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<label::Label> >& returnTransition : automaton.getReturnTransitions())
 			if (symbol == std::get<2>(returnTransition.first))
 				return true;
 
@@ -302,38 +302,38 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialStates ( ).count ( state ) )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions()) {
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<label::Label, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions()) {
 			if (state == callTransition.first.first)
 				return true;
 
-			for(const std::pair<automaton::State, alphabet::Symbol>& target : callTransition.second)
+			for(const std::pair<label::Label, alphabet::Symbol>& target : callTransition.second)
 				if(target.first == state)
 					return true;
 		}
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<label::Label> >& returnTransition : automaton.getReturnTransitions()) {
 			if (state == std::get<0>(returnTransition.first))
 				return true;
 
-			for(const automaton::State& target : returnTransition.second)
+			for(const label::Label& target : returnTransition.second)
 				if(target == state)
 					return true;
 		}
 
-		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<automaton::State> >& localTransition : automaton.getLocalTransitions()) {
+		for (const std::pair<const std::pair<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<label::Label> >& localTransition : automaton.getLocalTransitions()) {
 			if (state == localTransition.first.first)
 				return true;
 
-			for(const automaton::State& target : localTransition.second)
+			for(const label::Label& target : localTransition.second)
 				if(target == state)
 					return true;
 		}
@@ -341,41 +341,41 @@ public:
 		return false;
 	}
 
-	static bool available ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	static bool used ( const automaton::RealTimeHeightDeterministicNPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::InitialStates > {
+class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA, label::Label, automaton::InitialStates > {
 public:
-	static bool used ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	static bool used ( const automaton::RealTimeHeightDeterministicNPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/SinglePopDPDA.cpp b/alib2data/src/automaton/PDA/SinglePopDPDA.cpp
index 1890b5dd84..e31b8f4e5d 100644
--- a/alib2data/src/automaton/PDA/SinglePopDPDA.cpp
+++ b/alib2data/src/automaton/PDA/SinglePopDPDA.cpp
@@ -19,10 +19,10 @@
 
 namespace automaton {
 
-SinglePopDPDA::SinglePopDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < SinglePopDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+SinglePopDPDA::SinglePopDPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol initialSymbol, std::set < label::Label > finalStates ) : std::Components < SinglePopDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-SinglePopDPDA::SinglePopDPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : SinglePopDPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
+SinglePopDPDA::SinglePopDPDA(label::Label initialState, alphabet::Symbol initialPushdownSymbol) : SinglePopDPDA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < label::Label > { }) {
 }
 
 
@@ -34,9 +34,9 @@ AutomatonBase* SinglePopDPDA::plunder() && {
 	return new SinglePopDPDA(std::move(*this));
 }
 
-bool SinglePopDPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, alphabet::Symbol pop, State to, std::vector<alphabet::Symbol> push) {
+bool SinglePopDPDA::addTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, alphabet::Symbol pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && ! getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -44,7 +44,7 @@ bool SinglePopDPDA::addTransition(State from, std::variant<string::Epsilon, alph
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (!getPushdownStoreAlphabet().count(pop)) {
@@ -57,28 +57,28 @@ bool SinglePopDPDA::addTransition(State from, std::variant<string::Epsilon, alph
 		}
 	}
 
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
-	std::pair<automaton::State, std::vector<alphabet::Symbol> > value = std::make_pair(std::move(to), std::move(push));
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
+	std::pair<label::Label, std::vector<alphabet::Symbol> > value = std::make_pair(std::move(to), std::move(push));
 
 	if (transitions.find(key) != transitions.end()) {
 		if(transitions.find(key)->second == value)
 			return false;
 		else if (input.is<alphabet::Symbol>())
 			throw AutomatonException(
-				"Transition (\"" + (std::string) std::get<0>(key).getName() + "\", \"" + (std::string) std::get<1>(key).get<alphabet::Symbol>() + "\", \"" + (std::string) std::get<2>(key) + "\") -> ?? already exists.");
+				"Transition (\"" + (std::string) std::get<0>(key) + "\", \"" + (std::string) std::get<1>(key).get<alphabet::Symbol>() + "\", \"" + (std::string) std::get<2>(key) + "\") -> ?? already exists.");
 		else
 			throw AutomatonException(
-				"Transition (\"" + (std::string) std::get<0>(key).getName() + "\", \"" + (std::string) std::get<1>(key).get<string::Epsilon>() + "\", \"" + (std::string) std::get<2>(key) + "\") -> ?? already exists.");
+				"Transition (\"" + (std::string) std::get<0>(key) + "\", \"" + (std::string) std::get<1>(key).get<string::Epsilon>() + "\", \"" + (std::string) std::get<2>(key) + "\") -> ?? already exists.");
 	}
 
 	if(input.is<string::Epsilon>()) {
-		if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > > & transition) {
+		if(std::any_of(transitions.begin(), transitions.end(), [&](const std::pair<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<label::Label, std::vector<alphabet::Symbol> > > & transition) {
 				if(std::get<0>(transition.first) == std::get<0>(key) && std::get<2>(transition.first) == std::get<2>(key)) return true;
 				return false;
 			}))
 				throw AutomatonException("Conflicting transition");
 	} else {
-		std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key2(std::get<0>(key), std::variant<string::Epsilon, alphabet::Symbol>{ string::Epsilon::EPSILON }, std::get<2>(key));
+		std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key2(std::get<0>(key), std::variant<string::Epsilon, alphabet::Symbol>{ string::Epsilon::EPSILON }, std::get<2>(key));
 		if(transitions.find(key2) != transitions.end())
 			throw AutomatonException("Conflicting transition");
 	}
@@ -87,19 +87,19 @@ bool SinglePopDPDA::addTransition(State from, std::variant<string::Epsilon, alph
 	return true;
 }
 
-bool SinglePopDPDA::addTransition(State from, alphabet::Symbol input, alphabet::Symbol pop, State to, std::vector<alphabet::Symbol> push) {
+bool SinglePopDPDA::addTransition(label::Label from, alphabet::Symbol input, alphabet::Symbol pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
 }
 
-bool SinglePopDPDA::addTransition(State from, alphabet::Symbol pop, State to, std::vector<alphabet::Symbol> push) {
+bool SinglePopDPDA::addTransition(label::Label from, alphabet::Symbol pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
 }
 
-bool SinglePopDPDA::removeTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(from, input, pop);
-	std::pair<automaton::State, std::vector<alphabet::Symbol> > value = std::make_pair(to, push);
+bool SinglePopDPDA::removeTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(from, input, pop);
+	std::pair<label::Label, std::vector<alphabet::Symbol> > value = std::make_pair(to, push);
 
 	if (transitions.find(key) == transitions.end())
 		return false;
@@ -107,27 +107,27 @@ bool SinglePopDPDA::removeTransition(const State& from, const std::variant<strin
 	if(transitions.find(key)->second != value) {
 		if (input.is<alphabet::Symbol>())
 			throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input.get<alphabet::Symbol>() + "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input.get<alphabet::Symbol>() + "\") -> \"" + (std::string) to + "\" doesn't exist.");
 		else
 			throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input.get<string::Epsilon>() + "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input.get<string::Epsilon>() + "\") -> \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	transitions.erase(key);
 	return true;
 }
 
-bool SinglePopDPDA::removeTransition(const State& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
+bool SinglePopDPDA::removeTransition(const label::Label& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeTransition(from, inputVariant, pop, to, push);
 }
 
-bool SinglePopDPDA::removeTransition(const State& from, const alphabet::Symbol& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
+bool SinglePopDPDA::removeTransition(const label::Label& from, const alphabet::Symbol& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeTransition(from, inputVariant, pop, to, push);
 }
 
-const std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<State, std::vector<alphabet::Symbol> > >& SinglePopDPDA::getTransitions() const {
+const std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<label::Label, std::vector<alphabet::Symbol> > >& SinglePopDPDA::getTransitions() const {
 	return transitions;
 }
 
@@ -160,12 +160,12 @@ SinglePopDPDA::operator std::string () const {
 SinglePopDPDA SinglePopDPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, SinglePopDPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> stackSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol initialPushdownStoreSymbol = AutomatonFromXMLParser::parseInitialPushdownStoreSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	SinglePopDPDA automaton(std::move(initialState), std::move(initialPushdownStoreSymbol));
 	automaton.setStates(std::move(states));
@@ -181,10 +181,10 @@ SinglePopDPDA SinglePopDPDA::parse(std::deque<sax::Token>::iterator& input) {
 
 void SinglePopDPDA::parseTransition(std::deque<sax::Token>::iterator& input, SinglePopDPDA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
 	alphabet::Symbol pop = AutomatonFromXMLParser::parseTransitionSinglePop(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	std::vector<alphabet::Symbol> push = AutomatonFromXMLParser::parseTransitionPush(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
diff --git a/alib2data/src/automaton/PDA/SinglePopDPDA.h b/alib2data/src/automaton/PDA/SinglePopDPDA.h
index 01309eaf50..c960ab48f7 100644
--- a/alib2data/src/automaton/PDA/SinglePopDPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopDPDA.h
@@ -15,8 +15,8 @@
 #include <variant>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/Epsilon.h"
 
 namespace automaton {
@@ -35,55 +35,55 @@ class InitialState;
  * if $\delta (q, a, r) \neq \emptyset$, $\delta (q, a, s) \neq \emptyset$ then $r \neq s$.
  * if $\delta(q, a, r) \neq \emptyset$, $\delta (q, \varepsilon, s) \neq \emptyset$, then $r \neq s$.
  */
-class SinglePopDPDA : public AutomatonBase, public std::Components < SinglePopDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class SinglePopDPDA : public AutomatonBase, public std::Components < SinglePopDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::pair < State, std::vector < alphabet::Symbol > > > transitions;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::pair < label::Label, std::vector < alphabet::Symbol > > > transitions;
 
 public:
-	explicit SinglePopDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol initialPushdownSymbol, std::set < automaton::State > finalStates );
-	explicit SinglePopDPDA ( State initialState, alphabet::Symbol initialPushdownSymbol );
+	explicit SinglePopDPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol initialPushdownSymbol, std::set < label::Label > finalStates );
+	explicit SinglePopDPDA ( label::Label initialState, alphabet::Symbol initialPushdownSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -141,27 +141,27 @@ public:
 	 * @throws AutomatonException when some part of the transition is not present
 	 * in the SinglePopDPDA (state, input symbol, stack symbol) or when transition already exists
 	 */
-	bool addTransition ( State from, std::variant < string::Epsilon, alphabet::Symbol > input, alphabet::Symbol pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, std::variant < string::Epsilon, alphabet::Symbol > input, alphabet::Symbol pop, label::Label to, std::vector < alphabet::Symbol > push );
 
-	bool addTransition ( State from, alphabet::Symbol input, alphabet::Symbol pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, alphabet::Symbol input, alphabet::Symbol pop, label::Label to, std::vector < alphabet::Symbol > push );
 
-	bool addTransition ( State from, alphabet::Symbol pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, alphabet::Symbol pop, label::Label to, std::vector < alphabet::Symbol > push );
 
 	/**
 	 * Removes the transition from the SinglePopDPDA.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition is not present in the SinglePopDPDA
 	 */
-	bool removeTransition ( const State & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const alphabet::Symbol & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const alphabet::Symbol & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
-	bool removeTransition ( const State & from, const alphabet::Symbol & input, const alphabet::Symbol & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const alphabet::Symbol & input, const alphabet::Symbol & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
-	bool removeTransition ( const State & from, const alphabet::Symbol & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const alphabet::Symbol & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
 	/**
 	 * @return SinglePopDPDA transitions
 	 */
-	const std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::pair < State, std::vector < alphabet::Symbol > > > & getTransitions ( ) const;
+	const std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::pair < label::Label, std::vector < alphabet::Symbol > > > & getTransitions ( ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -196,7 +196,7 @@ template < >
 class ComponentConstraint< automaton::SinglePopDPDA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::SinglePopDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<label::Label, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
 			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
 				return true;
 
@@ -215,7 +215,7 @@ template < >
 class ComponentConstraint< automaton::SinglePopDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
 public:
 	static bool used ( const automaton::SinglePopDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<label::Label, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
 			if (symbol == std::get<2>(transition.first) || std::find(transition.second.second.begin(), transition.second.second.end(), symbol) != transition.second.second.end())
 				return true;
 
@@ -245,53 +245,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::SinglePopDPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::SinglePopDPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::SinglePopDPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::SinglePopDPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<label::Label, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
 			if (state == std::get<0>(transition.first) || transition.second.first == state)
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+	static bool available ( const automaton::SinglePopDPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::SinglePopDPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::SinglePopDPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::SinglePopDPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+	static bool used ( const automaton::SinglePopDPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::SinglePopDPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::SinglePopDPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::SinglePopDPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::SinglePopDPDA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::SinglePopDPDA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::SinglePopDPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::SinglePopDPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::SinglePopDPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/SinglePopNPDA.cpp b/alib2data/src/automaton/PDA/SinglePopNPDA.cpp
index 171b9f7aec..485aa347c2 100644
--- a/alib2data/src/automaton/PDA/SinglePopNPDA.cpp
+++ b/alib2data/src/automaton/PDA/SinglePopNPDA.cpp
@@ -18,10 +18,10 @@
 
 namespace automaton {
 
-SinglePopNPDA::SinglePopNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < SinglePopNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+SinglePopNPDA::SinglePopNPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol initialSymbol, std::set < label::Label > finalStates ) : std::Components < SinglePopNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-SinglePopNPDA::SinglePopNPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : SinglePopNPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
+SinglePopNPDA::SinglePopNPDA(label::Label initialState, alphabet::Symbol initialPushdownSymbol) : SinglePopNPDA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* SinglePopNPDA::clone() const {
@@ -32,9 +32,9 @@ AutomatonBase* SinglePopNPDA::plunder() && {
 	return new SinglePopNPDA(std::move(*this));
 }
 
-bool SinglePopNPDA::addTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, alphabet::Symbol pop, State to, std::vector<alphabet::Symbol> push) {
+bool SinglePopNPDA::addTransition(label::Label from, std::variant<string::Epsilon, alphabet::Symbol> input, alphabet::Symbol pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	if (! getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (input.is<alphabet::Symbol>() && ! getInputAlphabet().count(input.get<alphabet::Symbol>())) {
@@ -42,7 +42,7 @@ bool SinglePopNPDA::addTransition(State from, std::variant<string::Epsilon, alph
 	}
 
 	if (! getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (! getPushdownStoreAlphabet().count(pop)) {
@@ -55,40 +55,40 @@ bool SinglePopNPDA::addTransition(State from, std::variant<string::Epsilon, alph
 		}
 	}
 
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
-	std::pair<automaton::State, std::vector<alphabet::Symbol> > value = std::make_pair(std::move(to), std::move(push));
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
+	std::pair<label::Label, std::vector<alphabet::Symbol> > value = std::make_pair(std::move(to), std::move(push));
 
 	return transitions[std::move(key)].insert(std::move(value)).second;
 }
 
-bool SinglePopNPDA::addTransition(State from, alphabet::Symbol input, alphabet::Symbol pop, State to, std::vector<alphabet::Symbol> push) {
+bool SinglePopNPDA::addTransition(label::Label from, alphabet::Symbol input, alphabet::Symbol pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
 }
 
-bool SinglePopNPDA::addTransition(State from, alphabet::Symbol pop, State to, std::vector<alphabet::Symbol> push) {
+bool SinglePopNPDA::addTransition(label::Label from, alphabet::Symbol pop, label::Label to, std::vector<alphabet::Symbol> push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return addTransition(std::move(from), std::move(inputVariant), std::move(pop), std::move(to), std::move(push));
 }
 
-bool SinglePopNPDA::removeTransition(const State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
-	std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(from, input, pop);
-	std::pair<automaton::State, std::vector<alphabet::Symbol> > value = std::make_pair(to, push);
+bool SinglePopNPDA::removeTransition(const label::Label& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
+	std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol> key(from, input, pop);
+	std::pair<label::Label, std::vector<alphabet::Symbol> > value = std::make_pair(to, push);
 
 	return transitions[key].erase(value);
 }
 
-bool SinglePopNPDA::removeTransition(const State& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
+bool SinglePopNPDA::removeTransition(const label::Label& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
 	return removeTransition(from, inputVariant, pop, to, push);
 }
 
-bool SinglePopNPDA::removeTransition(const State& from, const alphabet::Symbol& pop, const State& to, const std::vector<alphabet::Symbol>& push) {
+bool SinglePopNPDA::removeTransition(const label::Label& from, const alphabet::Symbol& pop, const label::Label& to, const std::vector<alphabet::Symbol>& push) {
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
 	return removeTransition(from, inputVariant, pop, to, push);
 }
 
-const std::map<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<State, std::vector<alphabet::Symbol> > > >& SinglePopNPDA::getTransitions() const {
+const std::map<std::tuple<label::Label, std::variant<string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<label::Label, std::vector<alphabet::Symbol> > > >& SinglePopNPDA::getTransitions() const {
 	return transitions;
 }
 
@@ -121,12 +121,12 @@ SinglePopNPDA::operator std::string () const {
 SinglePopNPDA SinglePopNPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, SinglePopNPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	std::set<alphabet::Symbol> stackSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol initialPushdownStoreSymbol = AutomatonFromXMLParser::parseInitialPushdownStoreSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	SinglePopNPDA automaton(std::move(initialState), std::move(initialPushdownStoreSymbol));
 	automaton.setStates(std::move(states));
@@ -142,10 +142,10 @@ SinglePopNPDA SinglePopNPDA::parse(std::deque<sax::Token>::iterator& input) {
 
 void SinglePopNPDA::parseTransition(std::deque<sax::Token>::iterator& input, SinglePopNPDA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
 	alphabet::Symbol pop = AutomatonFromXMLParser::parseTransitionSinglePop(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	std::vector<alphabet::Symbol> push = AutomatonFromXMLParser::parseTransitionPush(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
diff --git a/alib2data/src/automaton/PDA/SinglePopNPDA.h b/alib2data/src/automaton/PDA/SinglePopNPDA.h
index c716c22d74..116e46a2fd 100644
--- a/alib2data/src/automaton/PDA/SinglePopNPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopNPDA.h
@@ -15,8 +15,8 @@
 #include <variant>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../../string/Epsilon.h"
 
 namespace automaton {
@@ -31,55 +31,55 @@ class InitialState;
 /**
  * Push Down Automaton
  */
-class SinglePopNPDA : public AutomatonBase, public std::Components < SinglePopNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class SinglePopNPDA : public AutomatonBase, public std::Components < SinglePopNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < std::pair < State, std::vector < alphabet::Symbol > > > > transitions;
+	std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < std::pair < label::Label, std::vector < alphabet::Symbol > > > > transitions;
 
 public:
-	explicit SinglePopNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol initialPushdownSymbol, std::set < automaton::State > finalStates );
-	explicit SinglePopNPDA ( State initialState, alphabet::Symbol initialPushdownSymbol );
+	explicit SinglePopNPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol initialPushdownSymbol, std::set < label::Label > finalStates );
+	explicit SinglePopNPDA ( label::Label initialState, alphabet::Symbol initialPushdownSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -137,27 +137,27 @@ public:
 	 * @throws AutomatonException when some part of the transition is not present
 	 * in the SinglePopNPDA (state, input symbol, stack symbol) or when transition already exists
 	 */
-	bool addTransition ( State from, std::variant < string::Epsilon, alphabet::Symbol > input, alphabet::Symbol pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, std::variant < string::Epsilon, alphabet::Symbol > input, alphabet::Symbol pop, label::Label to, std::vector < alphabet::Symbol > push );
 
-	bool addTransition ( State from, alphabet::Symbol input, alphabet::Symbol pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, alphabet::Symbol input, alphabet::Symbol pop, label::Label to, std::vector < alphabet::Symbol > push );
 
-	bool addTransition ( State from, alphabet::Symbol pop, State to, std::vector < alphabet::Symbol > push );
+	bool addTransition ( label::Label from, alphabet::Symbol pop, label::Label to, std::vector < alphabet::Symbol > push );
 
 	/**
 	 * Removes the transition from the SinglePopNPDA.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition is not present in the SinglePopNPDA
 	 */
-	bool removeTransition ( const State & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const alphabet::Symbol & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const std::variant < string::Epsilon, alphabet::Symbol > & input, const alphabet::Symbol & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
-	bool removeTransition ( const State & from, const alphabet::Symbol & input, const alphabet::Symbol & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const alphabet::Symbol & input, const alphabet::Symbol & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
-	bool removeTransition ( const State & from, const alphabet::Symbol & pop, const State & to, const std::vector < alphabet::Symbol > & push );
+	bool removeTransition ( const label::Label & from, const alphabet::Symbol & pop, const label::Label & to, const std::vector < alphabet::Symbol > & push );
 
 	/**
 	 * @return SinglePopNPDA transitions
 	 */
-	const std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < std::pair < State, std::vector < alphabet::Symbol > > > > & getTransitions ( ) const;
+	const std::map < std::tuple < label::Label, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < std::pair < label::Label, std::vector < alphabet::Symbol > > > > & getTransitions ( ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -192,7 +192,7 @@ template < >
 class ComponentConstraint< automaton::SinglePopNPDA, alphabet::Symbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::SinglePopNPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<label::Label, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
 			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
 				return true;
 
@@ -214,11 +214,11 @@ public:
 		if(automaton.getInitialSymbol() == symbol)
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<label::Label, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
 			if (symbol == std::get<2>(transition.first))
 				return true;
 
-			for (const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
+			for (const std::pair<label::Label, std::vector<alphabet::Symbol> >& target : transition.second)
 				if (std::find(target.second.begin(), target.second.end(), symbol) != target.second.end())
 					return true;
 		}
@@ -246,20 +246,20 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::SinglePopNPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::SinglePopNPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::SinglePopNPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::SinglePopNPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<label::Label, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
 			if (state == std::get<0>(transition.first))
 				return true;
 
-			for(const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
+			for(const std::pair<label::Label, std::vector<alphabet::Symbol> >& target : transition.second)
 				if(target.first == state)
 					return true;
 		}
@@ -267,37 +267,37 @@ public:
 		return false;
 	}
 
-	static bool available ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+	static bool available ( const automaton::SinglePopNPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::SinglePopNPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::SinglePopNPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::SinglePopNPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+	static bool used ( const automaton::SinglePopNPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::SinglePopNPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::SinglePopNPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::SinglePopNPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::SinglePopNPDA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::SinglePopNPDA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::SinglePopNPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::SinglePopNPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::SinglePopNPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.cpp b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.cpp
index b94fb28776..0f45e582b1 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.cpp
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.cpp
@@ -18,10 +18,10 @@
 
 namespace automaton {
 
-VisiblyPushdownDPDA::VisiblyPushdownDPDA ( std::set < State > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components < VisiblyPushdownDPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+VisiblyPushdownDPDA::VisiblyPushdownDPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, label::Label initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < label::Label > finalStates ) : std::Components < VisiblyPushdownDPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
-VisiblyPushdownDPDA::VisiblyPushdownDPDA(State initialState, alphabet::Symbol bottomOfTheStackSymbol) : VisiblyPushdownDPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, initialState, bottomOfTheStackSymbol, std::set < automaton::State > { }) {
+VisiblyPushdownDPDA::VisiblyPushdownDPDA(label::Label initialState, alphabet::Symbol bottomOfTheStackSymbol) : VisiblyPushdownDPDA ( std::set < label::Label > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, initialState, bottomOfTheStackSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* VisiblyPushdownDPDA::clone() const {
@@ -32,9 +32,9 @@ AutomatonBase* VisiblyPushdownDPDA::plunder() && {
 	return new VisiblyPushdownDPDA(std::move(*this));
 }
 
-bool VisiblyPushdownDPDA::addCallTransition(State from, alphabet::Symbol input, State to, alphabet::Symbol push) {
+bool VisiblyPushdownDPDA::addCallTransition(label::Label from, alphabet::Symbol input, label::Label to, alphabet::Symbol push) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (!getCallInputAlphabet().count(input)) {
@@ -42,15 +42,15 @@ bool VisiblyPushdownDPDA::addCallTransition(State from, alphabet::Symbol input,
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (!getPushdownStoreAlphabet().count(push)) {
 		throw AutomatonException("Pushdown store symbol \"" + (std::string) push + "\" doesn't exist.");
 	}
 
-	std::pair<State, alphabet::Symbol> key(std::move(from), std::move(input));
-	std::pair<automaton::State, alphabet::Symbol> value = std::make_pair(std::move(to), std::move(push));
+	std::pair<label::Label, alphabet::Symbol> key(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> value = std::make_pair(std::move(to), std::move(push));
 
 	if(callTransitions.find(key) != callTransitions.end() && callTransitions.find(key)->second == value)
 		return false;
@@ -71,9 +71,9 @@ bool VisiblyPushdownDPDA::addCallTransition(State from, alphabet::Symbol input,
 	return true;
 }
 
-bool VisiblyPushdownDPDA::addReturnTransition(State from, alphabet::Symbol input, alphabet::Symbol pop, State to) {
+bool VisiblyPushdownDPDA::addReturnTransition(label::Label from, alphabet::Symbol input, alphabet::Symbol pop, label::Label to) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (!getReturnInputAlphabet().count(input)) {
@@ -81,14 +81,14 @@ bool VisiblyPushdownDPDA::addReturnTransition(State from, alphabet::Symbol input
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (!getPushdownStoreAlphabet().count(pop)) {
 		throw AutomatonException("Pushdown store symbol \"" + (std::string) pop + "\" doesn't exist.");
 	}
 
-	std::tuple<State, alphabet::Symbol, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
+	std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
 
 	if(returnTransitions.find(key) != returnTransitions.end() && returnTransitions.find(key)->second == to)
 		return false;
@@ -109,9 +109,9 @@ bool VisiblyPushdownDPDA::addReturnTransition(State from, alphabet::Symbol input
 	return true;
 }
 
-bool VisiblyPushdownDPDA::addLocalTransition(State from, alphabet::Symbol input, State to) {
+bool VisiblyPushdownDPDA::addLocalTransition(label::Label from, alphabet::Symbol input, label::Label to) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (!getLocalInputAlphabet().count(input)) {
@@ -119,10 +119,10 @@ bool VisiblyPushdownDPDA::addLocalTransition(State from, alphabet::Symbol input,
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
-	std::pair<State, alphabet::Symbol> key(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> key(std::move(from), std::move(input));
 
 	if(localTransitions.find(key) != localTransitions.end() && localTransitions.find(key)->second == to)
 		return false;
@@ -143,61 +143,61 @@ bool VisiblyPushdownDPDA::addLocalTransition(State from, alphabet::Symbol input,
 	return true;
 }
 
-bool VisiblyPushdownDPDA::removeCallTransition(const State& from, const alphabet::Symbol& input, const State& to, const alphabet::Symbol& push) {
-	std::pair<State, alphabet::Symbol> key(from, input);
-	std::pair<automaton::State, alphabet::Symbol> value = std::make_pair(to, push);
+bool VisiblyPushdownDPDA::removeCallTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to, const alphabet::Symbol& push) {
+	std::pair<label::Label, alphabet::Symbol> key(from, input);
+	std::pair<label::Label, alphabet::Symbol> value = std::make_pair(to, push);
 
 	if (callTransitions.find(key) == callTransitions.end())
 		return false;
 
 	if(callTransitions.find(key)->second != value)
 		throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input
-						+ "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input
+						+ "\") -> \"" + (std::string) to + "\" doesn't exist.");
 
 	callTransitions.erase(key);
 	return true;
 }
 
-bool VisiblyPushdownDPDA::removeReturnTransition(const State& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const State& to) {
-	std::tuple<State, alphabet::Symbol, alphabet::Symbol> key(from, input, pop);
+bool VisiblyPushdownDPDA::removeReturnTransition(const label::Label& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const label::Label& to) {
+	std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol> key(from, input, pop);
 
 	if (returnTransitions.find(key) == returnTransitions.end())
 		return false;
 
 	if(returnTransitions.find(key)->second != to)
 		throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input
-						+ "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input
+						+ "\") -> \"" + (std::string) to + "\" doesn't exist.");
 
 	returnTransitions.erase(key);
 	return true;
 }
 
-bool VisiblyPushdownDPDA::removeLocalTransition(const State& from, const alphabet::Symbol& input, const State& to) {
-	std::pair<State, alphabet::Symbol> key(from, input);
+bool VisiblyPushdownDPDA::removeLocalTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to) {
+	std::pair<label::Label, alphabet::Symbol> key(from, input);
 
 	if (localTransitions.find(key) == localTransitions.end())
 		return false;
 
 	if(localTransitions.find(key)->second != to)
 		throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input
-						+ "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+				"Transition (\"" + (std::string) from + "\", \"" + (std::string) input
+						+ "\") -> \"" + (std::string) to + "\" doesn't exist.");
 
 	localTransitions.erase(key);
 	return true;
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, std::pair<State, alphabet::Symbol> >& VisiblyPushdownDPDA::getCallTransitions() const {
+const std::map<std::pair<label::Label, alphabet::Symbol>, std::pair<label::Label, alphabet::Symbol> >& VisiblyPushdownDPDA::getCallTransitions() const {
 	return callTransitions;
 }
 
-const std::map<std::tuple<State, alphabet::Symbol, alphabet::Symbol>, State>& VisiblyPushdownDPDA::getReturnTransitions() const {
+const std::map<std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol>, label::Label>& VisiblyPushdownDPDA::getReturnTransitions() const {
 	return returnTransitions;
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, State>& VisiblyPushdownDPDA::getLocalTransitions() const {
+const std::map<std::pair<label::Label, alphabet::Symbol>, label::Label>& VisiblyPushdownDPDA::getLocalTransitions() const {
 	return localTransitions;
 }
 
@@ -234,14 +234,14 @@ VisiblyPushdownDPDA::operator std::string () const {
 VisiblyPushdownDPDA VisiblyPushdownDPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, VisiblyPushdownDPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> callAlphabet = AutomatonFromXMLParser::parseCallInputAlphabet(input);
 	std::set<alphabet::Symbol> returnAlphabet = AutomatonFromXMLParser::parseReturnInputAlphabet(input);
 	std::set<alphabet::Symbol> localAlphabet = AutomatonFromXMLParser::parseLocalInputAlphabet(input);
 	std::set<alphabet::Symbol> stackSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
 	alphabet::Symbol bottomOfTheStackSymbol = AutomatonFromXMLParser::parseBottomOfTheStackSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	VisiblyPushdownDPDA automaton(std::move(initialState), std::move(bottomOfTheStackSymbol));
 	automaton.setStates(std::move(states));
@@ -260,27 +260,27 @@ VisiblyPushdownDPDA VisiblyPushdownDPDA::parse(std::deque<sax::Token>::iterator&
 void VisiblyPushdownDPDA::parseTransition(std::deque<sax::Token>::iterator& input, VisiblyPushdownDPDA& automaton) {
 	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 		alphabet::Symbol push = AutomatonFromXMLParser::parseTransitionSinglePush(input);
 
 		automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
 	} else if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
 		alphabet::Symbol pop = AutomatonFromXMLParser::parseTransitionSinglePop(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 
 		automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
 	} else {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 
 		automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
index 3c0a49772c..3b5f5c04e3 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
@@ -13,8 +13,8 @@
 #include <vector>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 
 namespace automaton {
 
@@ -31,57 +31,57 @@ class InitialState;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class VisiblyPushdownDPDA : public AutomatonBase, public std::Components < VisiblyPushdownDPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class VisiblyPushdownDPDA : public AutomatonBase, public std::Components < VisiblyPushdownDPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, alphabet::Symbol >, std::pair < State, alphabet::Symbol > > callTransitions;
-	std::map < std::tuple < State, alphabet::Symbol, alphabet::Symbol >, State > returnTransitions;
-	std::map < std::pair < State, alphabet::Symbol >, State > localTransitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::pair < label::Label, alphabet::Symbol > > callTransitions;
+	std::map < std::tuple < label::Label, alphabet::Symbol, alphabet::Symbol >, label::Label > returnTransitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > localTransitions;
 
 public:
-	explicit VisiblyPushdownDPDA ( std::set < State > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, State initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < automaton::State > finalStates );
-	explicit VisiblyPushdownDPDA ( State initialSymbol, alphabet::Symbol bottomOfTheStackSymbol );
+	explicit VisiblyPushdownDPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, label::Label initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < label::Label > finalStates );
+	explicit VisiblyPushdownDPDA ( label::Label initialSymbol, alphabet::Symbol bottomOfTheStackSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	bool removeState ( const State & state ) {
+	bool removeState ( const label::Label & state ) {
 		return accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	bool removeFinalState ( const State & state ) {
+	bool removeFinalState ( const label::Label & state ) {
 		return accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -184,7 +184,7 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addCallTransition ( State current, alphabet::Symbol input, State next, alphabet::Symbol push );
+	bool addCallTransition ( label::Label current, alphabet::Symbol input, label::Label next, alphabet::Symbol push );
 
 	/**
 	 * Adds return transition defined by parameters to the automaton.
@@ -193,7 +193,7 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addReturnTransition ( State current, alphabet::Symbol input, alphabet::Symbol pop, State next );
+	bool addReturnTransition ( label::Label current, alphabet::Symbol input, alphabet::Symbol pop, label::Label next );
 
 	/**
 	 * Adds local transition defined by parameters to the automaton.
@@ -202,34 +202,34 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addLocalTransition ( State current, alphabet::Symbol input, State next );
+	bool addLocalTransition ( label::Label current, alphabet::Symbol input, label::Label next );
 
 	/**
 	 * Removes call transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeCallTransition ( const State & current, const alphabet::Symbol & input, const State & next, const alphabet::Symbol & push );
+	bool removeCallTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next, const alphabet::Symbol & push );
 
 	/**
 	 * Removes return transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeReturnTransition ( const State & current, const alphabet::Symbol & input, const alphabet::Symbol & pop, const State & next );
+	bool removeReturnTransition ( const label::Label & current, const alphabet::Symbol & input, const alphabet::Symbol & pop, const label::Label & next );
 
 	/**
 	 * Removes transition local from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeLocalTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeLocalTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
-	const std::map < std::pair < State, alphabet::Symbol >, std::pair < State, alphabet::Symbol > > & getCallTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, std::pair < label::Label, alphabet::Symbol > > & getCallTransitions ( ) const;
 
-	const std::map < std::tuple < State, alphabet::Symbol, alphabet::Symbol >, State > & getReturnTransitions ( ) const;
+	const std::map < std::tuple < label::Label, alphabet::Symbol, alphabet::Symbol >, label::Label > & getReturnTransitions ( ) const;
 
-	const std::map < std::pair < State, alphabet::Symbol >, State > & getLocalTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > & getLocalTransitions ( ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -264,7 +264,7 @@ template < >
 class ComponentConstraint< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::CallAlphabet > {
 public:
 	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::pair<label::Label, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
 			if (symbol == callTransition.first.second)
 				return true;
 
@@ -287,7 +287,7 @@ template < >
 class ComponentConstraint< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::ReturnAlphabet > {
 public:
 	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol>, label::Label>& returnTransition : automaton.getReturnTransitions())
 			if (symbol == std::get<1>(returnTransition.first))
 				return true;
 
@@ -310,7 +310,7 @@ template < >
 class ComponentConstraint< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::LocalAlphabet > {
 public:
 	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& localTransition : automaton.getLocalTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, label::Label>& localTransition : automaton.getLocalTransitions())
 			if (symbol == localTransition.first.second)
 				return true;
 
@@ -333,11 +333,11 @@ template < >
 class ComponentConstraint< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
 public:
 	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::pair<label::Label, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
 			if (symbol == callTransition.second.second)
 				return true;
 
-		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol>, label::Label>& returnTransition : automaton.getReturnTransitions())
 			if (symbol == std::get<2>(returnTransition.first))
 				return true;
 
@@ -367,61 +367,61 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::VisiblyPushdownDPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::VisiblyPushdownDPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::pair<label::Label, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
 			if (state == callTransition.first.first || callTransition.second.first == state)
 				return true;
 
-		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol>, label::Label>& returnTransition : automaton.getReturnTransitions())
 			if (state == std::get<0>(returnTransition.first) || returnTransition.second == state)
 				return true;
 
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& localTransition : automaton.getLocalTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, label::Label>& localTransition : automaton.getLocalTransitions())
 			if (state == localTransition.first.first || localTransition.second == state)
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+	static bool available ( const automaton::VisiblyPushdownDPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::VisiblyPushdownDPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::VisiblyPushdownDPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::VisiblyPushdownDPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+	static bool used ( const automaton::VisiblyPushdownDPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::VisiblyPushdownDPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::VisiblyPushdownDPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::VisiblyPushdownDPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::VisiblyPushdownDPDA, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::VisiblyPushdownDPDA, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::VisiblyPushdownDPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::VisiblyPushdownDPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+	static void valid ( const automaton::VisiblyPushdownDPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.cpp b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.cpp
index c37d2c7a50..76149ac92f 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.cpp
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.cpp
@@ -18,10 +18,10 @@
 
 namespace automaton {
 
-VisiblyPushdownNPDA::VisiblyPushdownNPDA ( std::set < State > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, std::set < State > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components < VisiblyPushdownNPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+VisiblyPushdownNPDA::VisiblyPushdownNPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, std::set < label::Label > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < label::Label > finalStates ) : std::Components < VisiblyPushdownNPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, label::Label, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
-VisiblyPushdownNPDA::VisiblyPushdownNPDA(alphabet::Symbol bottomOfTheStackSymbol) : VisiblyPushdownNPDA ( std::set < State > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, std::set < State > { }, bottomOfTheStackSymbol, std::set < automaton::State > { }) {
+VisiblyPushdownNPDA::VisiblyPushdownNPDA(alphabet::Symbol bottomOfTheStackSymbol) : VisiblyPushdownNPDA ( std::set < label::Label > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, std::set < label::Label > { }, bottomOfTheStackSymbol, std::set < label::Label > { }) {
 }
 
 AutomatonBase* VisiblyPushdownNPDA::clone() const {
@@ -32,9 +32,9 @@ AutomatonBase* VisiblyPushdownNPDA::plunder() && {
 	return new VisiblyPushdownNPDA(std::move(*this));
 }
 
-bool VisiblyPushdownNPDA::addCallTransition(State from, alphabet::Symbol input, State to, alphabet::Symbol push) {
+bool VisiblyPushdownNPDA::addCallTransition(label::Label from, alphabet::Symbol input, label::Label to, alphabet::Symbol push) {
 	if ( ! getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if ( ! getCallInputAlphabet().count(input)) {
@@ -42,22 +42,22 @@ bool VisiblyPushdownNPDA::addCallTransition(State from, alphabet::Symbol input,
 	}
 
 	if ( ! getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (! getPushdownStoreAlphabet().count(push)) {
 		throw AutomatonException("Pushdown store symbol \"" + (std::string) push + "\" doesn't exist.");
 	}
 
-	std::pair<State, alphabet::Symbol> key(std::move(from), std::move(input));
-	std::pair<automaton::State, alphabet::Symbol> value = std::make_pair(std::move(to), std::move(push));
+	std::pair<label::Label, alphabet::Symbol> key(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> value = std::make_pair(std::move(to), std::move(push));
 
 	return callTransitions[std::move(key)].insert(std::move(value)).second;
 }
 
-bool VisiblyPushdownNPDA::addReturnTransition(State from, alphabet::Symbol input, alphabet::Symbol pop, State to) {
+bool VisiblyPushdownNPDA::addReturnTransition(label::Label from, alphabet::Symbol input, alphabet::Symbol pop, label::Label to) {
 	if (! getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (! getReturnInputAlphabet().count(input)) {
@@ -65,21 +65,21 @@ bool VisiblyPushdownNPDA::addReturnTransition(State from, alphabet::Symbol input
 	}
 
 	if (! getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (! getPushdownStoreAlphabet().count(pop)) {
 		throw AutomatonException("Pushdown store symbol \"" + (std::string) pop + "\" doesn't exist.");
 	}
 
-	std::tuple<State, alphabet::Symbol, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
+	std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol> key(std::move(from), std::move(input), std::move(pop));
 
 	return returnTransitions[std::move(key)].insert(std::move(to)).second;
 }
 
-bool VisiblyPushdownNPDA::addLocalTransition(State from, alphabet::Symbol input, State to) {
+bool VisiblyPushdownNPDA::addLocalTransition(label::Label from, alphabet::Symbol input, label::Label to) {
 	if (! getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (! getLocalInputAlphabet().count(input)) {
@@ -87,42 +87,42 @@ bool VisiblyPushdownNPDA::addLocalTransition(State from, alphabet::Symbol input,
 	}
 
 	if (! getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
-	std::pair<State, alphabet::Symbol> key(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> key(std::move(from), std::move(input));
 
 	return localTransitions[std::move(key)].insert(std::move(to)).second;
 }
 
-bool VisiblyPushdownNPDA::removeCallTransition(const State& from, const alphabet::Symbol& input, const State& to, const alphabet::Symbol& push) {
-	std::pair<State, alphabet::Symbol> key(from, input);
-	std::pair<automaton::State, alphabet::Symbol> value = std::make_pair(to, push);
+bool VisiblyPushdownNPDA::removeCallTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to, const alphabet::Symbol& push) {
+	std::pair<label::Label, alphabet::Symbol> key(from, input);
+	std::pair<label::Label, alphabet::Symbol> value = std::make_pair(to, push);
 
 	return callTransitions[key].erase(value);
 }
 
-bool VisiblyPushdownNPDA::removeReturnTransition(const State& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const State& to) {
-	std::tuple<State, alphabet::Symbol, alphabet::Symbol> key(from, input, pop);
+bool VisiblyPushdownNPDA::removeReturnTransition(const label::Label& from, const alphabet::Symbol& input, const alphabet::Symbol& pop, const label::Label& to) {
+	std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol> key(from, input, pop);
 
 	return returnTransitions[key].erase(to);
 }
 
-bool VisiblyPushdownNPDA::removeLocalTransition(const State& from, const alphabet::Symbol& input, const State& to) {
-	std::pair<State, alphabet::Symbol> key(from, input);
+bool VisiblyPushdownNPDA::removeLocalTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to) {
+	std::pair<label::Label, alphabet::Symbol> key(from, input);
 
 	return localTransitions[key].erase(to);
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, std::set<std::pair<State, alphabet::Symbol> > >& VisiblyPushdownNPDA::getCallTransitions() const {
+const std::map<std::pair<label::Label, alphabet::Symbol>, std::set<std::pair<label::Label, alphabet::Symbol> > >& VisiblyPushdownNPDA::getCallTransitions() const {
 	return callTransitions;
 }
 
-const std::map<std::tuple<State, alphabet::Symbol, alphabet::Symbol>, std::set<State> >& VisiblyPushdownNPDA::getReturnTransitions() const {
+const std::map<std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol>, std::set<label::Label> >& VisiblyPushdownNPDA::getReturnTransitions() const {
 	return returnTransitions;
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, std::set<State> >& VisiblyPushdownNPDA::getLocalTransitions() const {
+const std::map<std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> >& VisiblyPushdownNPDA::getLocalTransitions() const {
 	return localTransitions;
 }
 
@@ -159,14 +159,14 @@ VisiblyPushdownNPDA::operator std::string () const {
 VisiblyPushdownNPDA VisiblyPushdownNPDA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, VisiblyPushdownNPDA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> callInputAlphabet = AutomatonFromXMLParser::parseCallInputAlphabet(input);
 	std::set<alphabet::Symbol> returnInputAlphabet = AutomatonFromXMLParser::parseReturnInputAlphabet(input);
 	std::set<alphabet::Symbol> localInputAlphabet = AutomatonFromXMLParser::parseLocalInputAlphabet(input);
 	std::set<alphabet::Symbol> stackSymbols = AutomatonFromXMLParser::parsePushdownStoreAlphabet(input);
-	std::set<State> initialStates = AutomatonFromXMLParser::parseInitialStates(input);
+	std::set<label::Label> initialStates = AutomatonFromXMLParser::parseInitialStates(input);
 	alphabet::Symbol bottomOfTheStackSymbol = AutomatonFromXMLParser::parseBottomOfTheStackSymbol(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	VisiblyPushdownNPDA automaton(std::move(bottomOfTheStackSymbol));
 	automaton.setStates(std::move(states));
@@ -186,27 +186,27 @@ VisiblyPushdownNPDA VisiblyPushdownNPDA::parse(std::deque<sax::Token>::iterator&
 void VisiblyPushdownNPDA::parseTransition(std::deque<sax::Token>::iterator& input, VisiblyPushdownNPDA& automaton) {
 	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 		alphabet::Symbol push = AutomatonFromXMLParser::parseTransitionSinglePush(input);
 
 		automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
 	} else if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
 		alphabet::Symbol pop = AutomatonFromXMLParser::parseTransitionSinglePop(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 
 		automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
 	} else {
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
-		State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+		label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 		alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-		State to = AutomatonFromXMLParser::parseTransitionTo(input);
+		label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 
 		automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
 		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
index 52a78371f4..9bc12f0979 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
@@ -13,8 +13,8 @@
 #include <vector>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 
 namespace automaton {
 
@@ -31,65 +31,65 @@ class InitialStates;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class VisiblyPushdownNPDA : public AutomatonBase, public std::Components < VisiblyPushdownNPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class VisiblyPushdownNPDA : public AutomatonBase, public std::Components < VisiblyPushdownNPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, label::Label, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
-	std::map < std::pair < State, alphabet::Symbol >, std::set < std::pair < State, alphabet::Symbol > > > callTransitions;
-	std::map < std::tuple < State, alphabet::Symbol, alphabet::Symbol >, std::set < State > > returnTransitions;
-	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > localTransitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < std::pair < label::Label, alphabet::Symbol > > > callTransitions;
+	std::map < std::tuple < label::Label, alphabet::Symbol, alphabet::Symbol >, std::set < label::Label > > returnTransitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > localTransitions;
 
 public:
-	explicit VisiblyPushdownNPDA ( std::set < State > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, std::set < State > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < automaton::State > finalStates );
+	explicit VisiblyPushdownNPDA ( std::set < label::Label > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreSymbol, std::set < label::Label > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < label::Label > finalStates );
 	explicit VisiblyPushdownNPDA ( alphabet::Symbol bottomOfTheStackSymbol );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const std::set < State > & getInitialStates ( ) const {
+	const std::set < label::Label > & getInitialStates ( ) const {
 		return accessComponent < InitialStates > ( ).get ( );
 	}
 
-	bool addInitialState ( State state ) {
+	bool addInitialState ( label::Label state ) {
 		return accessComponent < InitialStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setInitialStates ( std::set < State > states ) {
+	void setInitialStates ( std::set < label::Label > states ) {
 		accessComponent < InitialStates > ( ).set ( std::move ( states ) );
 	}
 
-	bool removeInitialState ( const State & state ) {
+	bool removeInitialState ( const label::Label & state ) {
 		return accessComponent < InitialStates > ( ).remove ( state );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	bool removeState ( const State & state ) {
+	bool removeState ( const label::Label & state ) {
 		return accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	bool removeFinalState ( const State & state ) {
+	bool removeFinalState ( const label::Label & state ) {
 		return accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -192,7 +192,7 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addCallTransition ( State current, alphabet::Symbol input, State next, alphabet::Symbol push );
+	bool addCallTransition ( label::Label current, alphabet::Symbol input, label::Label next, alphabet::Symbol push );
 
 	/**
 	 * Adds return transition defined by parameters to the automaton.
@@ -201,7 +201,7 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addReturnTransition ( State current, alphabet::Symbol input, alphabet::Symbol pop, State next );
+	bool addReturnTransition ( label::Label current, alphabet::Symbol input, alphabet::Symbol pop, label::Label next );
 
 	/**
 	 * Adds local transition defined by parameters to the automaton.
@@ -210,34 +210,34 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addLocalTransition ( State current, alphabet::Symbol input, State next );
+	bool addLocalTransition ( label::Label current, alphabet::Symbol input, label::Label next );
 
 	/**
 	 * Removes call transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeCallTransition ( const State & current, const alphabet::Symbol & input, const State & next, const alphabet::Symbol & push );
+	bool removeCallTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next, const alphabet::Symbol & push );
 
 	/**
 	 * Removes return transition from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeReturnTransition ( const State & current, const alphabet::Symbol & input, const alphabet::Symbol & pop, const State & next );
+	bool removeReturnTransition ( const label::Label & current, const alphabet::Symbol & input, const alphabet::Symbol & pop, const label::Label & next );
 
 	/**
 	 * Removes transition local from the automaton.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeLocalTransition ( const State & current, const alphabet::Symbol & input, const State & next );
+	bool removeLocalTransition ( const label::Label & current, const alphabet::Symbol & input, const label::Label & next );
 
-	const std::map < std::pair < State, alphabet::Symbol >, std::set < std::pair < State, alphabet::Symbol > > > & getCallTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, std::set < std::pair < label::Label, alphabet::Symbol > > > & getCallTransitions ( ) const;
 
-	const std::map < std::tuple < State, alphabet::Symbol, alphabet::Symbol >, std::set < State > > & getReturnTransitions ( ) const;
+	const std::map < std::tuple < label::Label, alphabet::Symbol, alphabet::Symbol >, std::set < label::Label > > & getReturnTransitions ( ) const;
 
-	const std::map < std::pair < State, alphabet::Symbol >, std::set < State > > & getLocalTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, std::set < label::Label > > & getLocalTransitions ( ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -272,7 +272,7 @@ template < >
 class ComponentConstraint< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::CallAlphabet > {
 public:
 	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set < std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set < std::pair<label::Label, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
 			if (symbol == callTransition.first.second)
 				return true;
 
@@ -295,7 +295,7 @@ template < >
 class ComponentConstraint< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::ReturnAlphabet > {
 public:
 	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set < automaton::State> >& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol>, std::set < label::Label> >& returnTransition : automaton.getReturnTransitions())
 			if (symbol == std::get<1>(returnTransition.first))
 				return true;
 
@@ -318,7 +318,7 @@ template < >
 class ComponentConstraint< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::LocalAlphabet > {
 public:
 	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set < automaton::State >>& localTransition : automaton.getLocalTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set < label::Label >>& localTransition : automaton.getLocalTransitions())
 			if (symbol == localTransition.first.second)
 				return true;
 
@@ -341,12 +341,12 @@ template < >
 class ComponentConstraint< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
 public:
 	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
-			for(const std::pair<automaton::State, alphabet::Symbol>& to : callTransition.second)
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<std::pair<label::Label, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
+			for(const std::pair<label::Label, alphabet::Symbol>& to : callTransition.second)
 				if (symbol == to.second)
 					return true;
 
-		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions())
+		for (const std::pair<const std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol>, std::set<label::Label> >& returnTransition : automaton.getReturnTransitions())
 			if (symbol == std::get<2>(returnTransition.first))
 				return true;
 
@@ -376,37 +376,37 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::VisiblyPushdownNPDA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::VisiblyPushdownNPDA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const label::Label & state ) {
 		if ( automaton.getInitialStates ( ).count ( state ) )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions()) {
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<std::pair<label::Label, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions()) {
 			if (state == callTransition.first.first)
 				return true;
-			for(const std::pair<automaton::State, alphabet::Symbol>& target : callTransition.second) {
+			for(const std::pair<label::Label, alphabet::Symbol>& target : callTransition.second) {
 				if(target.first == state)
 					return true;
 			}
 		}
 
-		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions()) {
+		for (const std::pair<const std::tuple<label::Label, alphabet::Symbol, alphabet::Symbol>, std::set<label::Label> >& returnTransition : automaton.getReturnTransitions()) {
 			if (state == std::get<0>(returnTransition.first))
 				return true;
-			for(const automaton::State& target : returnTransition.second) {
+			for(const label::Label& target : returnTransition.second) {
 				if(target == state)
 					return true;
 			}
 		}
 
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State> >& localTransition : automaton.getLocalTransitions()) {
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::set<label::Label> >& localTransition : automaton.getLocalTransitions()) {
 			if (state == localTransition.first.first)
 				return true;
-			for(const automaton::State& target : localTransition.second) {
+			for(const label::Label& target : localTransition.second) {
 				if(target == state)
 					return true;
 			}
@@ -415,41 +415,41 @@ public:
 		return false;
 	}
 
-	static bool available ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	static bool available ( const automaton::VisiblyPushdownNPDA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::VisiblyPushdownNPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::VisiblyPushdownNPDA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::VisiblyPushdownNPDA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	static bool used ( const automaton::VisiblyPushdownNPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::VisiblyPushdownNPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::VisiblyPushdownNPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::VisiblyPushdownNPDA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::VisiblyPushdownNPDA, automaton::State, automaton::InitialStates > {
+class ComponentConstraint< automaton::VisiblyPushdownNPDA, label::Label, automaton::InitialStates > {
 public:
-	static bool used ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	static bool used ( const automaton::VisiblyPushdownNPDA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::VisiblyPushdownNPDA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::VisiblyPushdownNPDA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	static void valid ( const automaton::VisiblyPushdownNPDA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/TA/DFTA.cpp b/alib2data/src/automaton/TA/DFTA.cpp
index 97e7398963..8fd9cfb55b 100644
--- a/alib2data/src/automaton/TA/DFTA.cpp
+++ b/alib2data/src/automaton/TA/DFTA.cpp
@@ -18,10 +18,10 @@
 
 namespace automaton {
 
-DFTA::DFTA ( std::set < State > states, std::set < alphabet::RankedSymbol > inputAlphabet, std::set < State > finalStates ) : std::Components < DFTA, alphabet::RankedSymbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+DFTA::DFTA ( std::set < label::Label > states, std::set < alphabet::RankedSymbol > inputAlphabet, std::set < label::Label > finalStates ) : std::Components < DFTA, alphabet::RankedSymbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
-DFTA::DFTA() : DFTA ( std::set < State > { }, std::set < alphabet::RankedSymbol > { }, std::set < State > { } ) {
+DFTA::DFTA() : DFTA ( std::set < label::Label > { }, std::set < alphabet::RankedSymbol > { }, std::set < label::Label > { } ) {
 }
 
 AutomatonBase* DFTA::clone() const {
@@ -32,7 +32,7 @@ AutomatonBase* DFTA::plunder() && {
 	return new DFTA(std::move(*this));
 }
 
-bool DFTA::addTransition(const alphabet::RankedSymbol & symbol, const std::vector<State> & prevStates, const State & next) {
+bool DFTA::addTransition(const alphabet::RankedSymbol & symbol, const std::vector<label::Label> & prevStates, const label::Label & next) {
 	if ( prevStates.size() != symbol.getRank().getData())
 		throw AutomatonException("Number of states doesn't match rank of the symbol");
 
@@ -40,14 +40,14 @@ bool DFTA::addTransition(const alphabet::RankedSymbol & symbol, const std::vecto
 		throw AutomatonException("Input symbol \"" + (std::string) symbol + "\" doesn't exist.");
 
 	if (! getStates().count(next))
-		throw AutomatonException("State \"" + (std::string) next.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) next + "\" doesn't exist.");
 
-	for (const State& it : prevStates) {
+	for (const label::Label& it : prevStates) {
 		if (! getStates().count(it))
-			throw AutomatonException("State \"" + (std::string) it . getName() + "\" doesn't exist.");
+			throw AutomatonException("State \"" + (std::string) it + "\" doesn't exist.");
 	}
 
-	std::pair<alphabet::RankedSymbol, std::vector<State> > key = std::make_pair(symbol, prevStates);
+	std::pair<alphabet::RankedSymbol, std::vector<label::Label> > key = std::make_pair(symbol, prevStates);
 	if ( transitions.find ( key ) != transitions.end ( ) ) {
 		if ( transitions.find ( key )->second == next )
 			return false;
@@ -59,8 +59,8 @@ bool DFTA::addTransition(const alphabet::RankedSymbol & symbol, const std::vecto
 	return true;
 }
 
-bool DFTA::removeTransition(const alphabet::RankedSymbol symbol, const std::vector<State> & states, const State & next) {
-	std::pair<alphabet::RankedSymbol, std::vector<State> > key = std::make_pair(symbol, states);
+bool DFTA::removeTransition(const alphabet::RankedSymbol symbol, const std::vector<label::Label> & states, const label::Label & next) {
+	std::pair<alphabet::RankedSymbol, std::vector<label::Label> > key = std::make_pair(symbol, states);
 
 	if ( transitions.find ( key ) == transitions.end ( ) )
 		return false;
@@ -98,9 +98,9 @@ DFTA::operator std::string () const {
 DFTA DFTA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, DFTA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::RankedSymbol> inputSymbols = AutomatonFromXMLParser::parseRankedInputAlphabet(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	DFTA automaton;
 	automaton.setStates(std::move(states));
@@ -116,8 +116,8 @@ DFTA DFTA::parse(std::deque<sax::Token>::iterator& input) {
 void DFTA::parseTransition(std::deque<sax::Token>::iterator& input, DFTA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	alphabet::RankedSymbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputRankedSymbol(input);
-	std::vector<State> from = AutomatonFromXMLParser::parseTransitionFromMultiple(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	std::vector<label::Label> from = AutomatonFromXMLParser::parseTransitionFromMultiple(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
 	automaton.addTransition(std::move(inputSymbol), std::move(from), std::move(to));
diff --git a/alib2data/src/automaton/TA/DFTA.h b/alib2data/src/automaton/TA/DFTA.h
index fd4b16d52f..a1c1c73cca 100644
--- a/alib2data/src/automaton/TA/DFTA.h
+++ b/alib2data/src/automaton/TA/DFTA.h
@@ -13,8 +13,8 @@
 #include <vector>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/RankedSymbol.h"
+#include "../../label/Label.h"
 
 namespace automaton {
 
@@ -26,46 +26,46 @@ class FinalStates;
  * Represents Finite Tree Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class DFTA : public AutomatonBase, public std::Components < DFTA, alphabet::RankedSymbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < > > {
-	std::map < std::pair < alphabet::RankedSymbol, std::vector < State > >, State > transitions;
+class DFTA : public AutomatonBase, public std::Components < DFTA, alphabet::RankedSymbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < > > {
+	std::map < std::pair < alphabet::RankedSymbol, std::vector < label::Label > >, label::Label > transitions;
 
 public:
 	explicit DFTA ( );
-	explicit DFTA ( std::set < State > states, std::set < alphabet::RankedSymbol > inputAlphabet, std::set < State > finalStates );
+	explicit DFTA ( std::set < label::Label > states, std::set < alphabet::RankedSymbol > inputAlphabet, std::set < label::Label > finalStates );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -96,20 +96,20 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( const alphabet::RankedSymbol & current, const std::vector < State > & children, const State & next );
+	bool addTransition ( const alphabet::RankedSymbol & current, const std::vector < label::Label > & children, const label::Label & next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const alphabet::RankedSymbol symbol, const std::vector < State > & states, const State & next );
+	bool removeTransition ( const alphabet::RankedSymbol symbol, const std::vector < label::Label > & states, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < alphabet::RankedSymbol, std::vector < State > >, State > & getTransitions ( ) const { return transitions; }
+	const std::map < std::pair < alphabet::RankedSymbol, std::vector < label::Label > >, label::Label > & getTransitions ( ) const { return transitions; }
 
-	std::set < State > getTransitionRightSide ( const alphabet::RankedSymbol symbol, const std::vector < State > & states );
+	std::set < label::Label > getTransitionRightSide ( const alphabet::RankedSymbol symbol, const std::vector < label::Label > & states );
 
 	unsigned transitionsSize ( ) const;
 
@@ -146,7 +146,7 @@ template < >
 class ComponentConstraint< automaton::DFTA, alphabet::RankedSymbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::DFTA & automaton, const alphabet::RankedSymbol & symbol ) {
-		for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<automaton::State> >, automaton::State>& t : automaton.getTransitions())
+		for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<label::Label> >, label::Label>& t : automaton.getTransitions())
 			if (t.first.first == symbol)
 				return true;
 
@@ -162,39 +162,39 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::DFTA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::DFTA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::DFTA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::DFTA & automaton, const label::Label & state ) {
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<automaton::State> >, automaton::State>& t : automaton.getTransitions())
+		for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<label::Label> >, label::Label>& t : automaton.getTransitions())
 			if(std::contains(t.first.second.begin(), t.first.second.end(), state ) || t.second == state)
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::DFTA &, const automaton::State & ) {
+	static bool available ( const automaton::DFTA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::DFTA &, const automaton::State & ) {
+	static void valid ( const automaton::DFTA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::DFTA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::DFTA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::DFTA &, const automaton::State & ) {
+	static bool used ( const automaton::DFTA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::DFTA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::DFTA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::DFTA &, const automaton::State & ) {
+	static void valid ( const automaton::DFTA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/TA/NFTA.cpp b/alib2data/src/automaton/TA/NFTA.cpp
index 514ac1f988..c35502f374 100644
--- a/alib2data/src/automaton/TA/NFTA.cpp
+++ b/alib2data/src/automaton/TA/NFTA.cpp
@@ -18,10 +18,10 @@
 
 namespace automaton {
 
-NFTA::NFTA ( std::set < State > states, std::set < alphabet::RankedSymbol > inputAlphabet, std::set < State > finalStates ) : std::Components < NFTA, alphabet::RankedSymbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+NFTA::NFTA ( std::set < label::Label > states, std::set < alphabet::RankedSymbol > inputAlphabet, std::set < label::Label > finalStates ) : std::Components < NFTA, alphabet::RankedSymbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
-NFTA::NFTA() : NFTA ( std::set < State > { }, std::set < alphabet::RankedSymbol > { }, std::set < State > { } ) {
+NFTA::NFTA() : NFTA ( std::set < label::Label > { }, std::set < alphabet::RankedSymbol > { }, std::set < label::Label > { } ) {
 }
 
 NFTA::NFTA(const DFTA& other) : NFTA ( other.getStates(), other.getInputAlphabet(), other.getFinalStates() ) {
@@ -38,7 +38,7 @@ AutomatonBase* NFTA::plunder() && {
 	return new NFTA(std::move(*this));
 }
 
-bool NFTA::addTransition(const alphabet::RankedSymbol & symbol, const std::vector<State> & prevStates, const State & next) {
+bool NFTA::addTransition(const alphabet::RankedSymbol & symbol, const std::vector<label::Label> & prevStates, const label::Label & next) {
 	if (prevStates.size() != symbol.getRank().getData())
 		throw AutomatonException("Number of states doesn't match rank of the symbol");
 
@@ -46,24 +46,24 @@ bool NFTA::addTransition(const alphabet::RankedSymbol & symbol, const std::vecto
 		throw AutomatonException("Input symbol \"" + (std::string) symbol + "\" doesn't exist.");
 
 	if (! getStates().count(next))
-		throw AutomatonException("State \"" + (std::string) next.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) next + "\" doesn't exist.");
 
-	for (const State& it : prevStates) {
+	for (const label::Label& it : prevStates) {
 		if (! getStates().count(it))
-			throw AutomatonException("State \"" + (std::string) it . getName() + "\" doesn't exist.");
+			throw AutomatonException("State \"" + (std::string) it + "\" doesn't exist.");
 	}
 
-	std::pair<alphabet::RankedSymbol, std::vector<State> > key = std::make_pair(symbol, prevStates);
+	std::pair<alphabet::RankedSymbol, std::vector<label::Label> > key = std::make_pair(symbol, prevStates);
 	return transitions[key].insert(next).second;
 }
 
-bool NFTA::removeTransition(const alphabet::RankedSymbol symbol, const std::vector<State> & states, const State & next) {
-	std::pair<alphabet::RankedSymbol, std::vector<State> > key = std::make_pair(symbol, states);
+bool NFTA::removeTransition(const alphabet::RankedSymbol symbol, const std::vector<label::Label> & states, const label::Label & next) {
+	std::pair<alphabet::RankedSymbol, std::vector<label::Label> > key = std::make_pair(symbol, states);
 	return transitions[key].erase(next);
 }
 
 bool NFTA::isDeterministic() const {
-	for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<State> >, std::set<State> >& t : transitions)
+	for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<label::Label> >, std::set<label::Label> >& t : transitions)
 		if (t . second.size() != 1 || t . second.size() != 0)
 			return false;
 
@@ -105,9 +105,9 @@ NFTA::operator std::string () const {
 NFTA NFTA::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, NFTA::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::RankedSymbol> inputSymbols = AutomatonFromXMLParser::parseRankedInputAlphabet(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	NFTA automaton;
 	automaton.setStates(std::move(states));
@@ -123,8 +123,8 @@ NFTA NFTA::parse(std::deque<sax::Token>::iterator& input) {
 void NFTA::parseTransition(std::deque<sax::Token>::iterator& input, NFTA& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	alphabet::RankedSymbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputRankedSymbol(input);
-	std::vector<State> from = AutomatonFromXMLParser::parseTransitionFromMultiple(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	std::vector<label::Label> from = AutomatonFromXMLParser::parseTransitionFromMultiple(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
 	automaton.addTransition(std::move(inputSymbol), std::move(from), std::move(to));
diff --git a/alib2data/src/automaton/TA/NFTA.h b/alib2data/src/automaton/TA/NFTA.h
index c432966577..895003e2c4 100644
--- a/alib2data/src/automaton/TA/NFTA.h
+++ b/alib2data/src/automaton/TA/NFTA.h
@@ -13,8 +13,8 @@
 #include <vector>
 #include <core/components.hpp>
 #include "../AutomatonBase.h"
-#include "../common/State.h"
 #include "../../alphabet/RankedSymbol.h"
+#include "../../label/Label.h"
 
 #include "DFTA.h"
 
@@ -28,47 +28,47 @@ class FinalStates;
  * Represents Finite Tree Automaton.
  * Can store nondeterministic finite tree automaton without epsilon transitions.
  */
-class NFTA : public AutomatonBase, public std::Components < NFTA, alphabet::RankedSymbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < > > {
-	std::map < std::pair < alphabet::RankedSymbol, std::vector < State > >, std::set < State > > transitions;
+class NFTA : public AutomatonBase, public std::Components < NFTA, alphabet::RankedSymbol, std::tuple < InputAlphabet >, std::tuple < >, label::Label, std::tuple < States, FinalStates >, std::tuple < > > {
+	std::map < std::pair < alphabet::RankedSymbol, std::vector < label::Label > >, std::set < label::Label > > transitions;
 
 public:
 	explicit NFTA ( );
-	explicit NFTA ( std::set < State > states, std::set < alphabet::RankedSymbol > inputAlphabet, std::set < State > finalStates );
+	explicit NFTA ( std::set < label::Label > states, std::set < alphabet::RankedSymbol > inputAlphabet, std::set < label::Label > finalStates );
 	explicit NFTA ( const DFTA & other );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -99,20 +99,20 @@ public:
 	 * @param next next state
 	 * @throws AutomatonException when transition already exists or when transition contains state or symbol not present in the automaton
 	 */
-	bool addTransition ( const alphabet::RankedSymbol & current, const std::vector < State > & children, const State & next );
+	bool addTransition ( const alphabet::RankedSymbol & current, const std::vector < label::Label > & children, const label::Label & next );
 
 	/**
 	 * Removes transition from the automaton.
 	 * @throws AutomatonException when transition doesn't exists.
 	 */
-	bool removeTransition ( const alphabet::RankedSymbol symbol, const std::vector < State > & states, const State & next );
+	bool removeTransition ( const alphabet::RankedSymbol symbol, const std::vector < label::Label > & states, const label::Label & next );
 
 	/**
 	 * @return automaton transitions
 	 */
-	const std::map < std::pair < alphabet::RankedSymbol, std::vector < State > >, std::set < State > > & getTransitions ( ) const { return transitions; }
+	const std::map < std::pair < alphabet::RankedSymbol, std::vector < label::Label > >, std::set < label::Label > > & getTransitions ( ) const { return transitions; }
 
-	std::set < State > getTransitionRightSide ( const alphabet::RankedSymbol symbol, const std::vector < State > & states );
+	std::set < label::Label > getTransitionRightSide ( const alphabet::RankedSymbol symbol, const std::vector < label::Label > & states );
 
 	/**
 	 * Determines whether NFTA is deterministic.
@@ -158,7 +158,7 @@ template < >
 class ComponentConstraint< automaton::NFTA, alphabet::RankedSymbol, automaton::InputAlphabet > {
 public:
 	static bool used ( const automaton::NFTA & automaton, const alphabet::RankedSymbol & symbol ) {
-		for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<automaton::State> >, std::set<automaton::State>>& t : automaton.getTransitions())
+		for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<label::Label> >, std::set<label::Label>>& t : automaton.getTransitions())
 			if (t.first.first == symbol)
 				return true;
 
@@ -174,39 +174,39 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::NFTA, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::NFTA, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::NFTA & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::NFTA & automaton, const label::Label & state ) {
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<automaton::State> >, std::set<automaton::State>>& t : automaton.getTransitions())
+		for (const std::pair<const std::pair<alphabet::RankedSymbol, std::vector<label::Label> >, std::set<label::Label>>& t : automaton.getTransitions())
 			if(std::contains(t.first.second.begin(), t.first.second.end(), state ) || t . second.count ( state ) )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::NFTA &, const automaton::State & ) {
+	static bool available ( const automaton::NFTA &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::NFTA &, const automaton::State & ) {
+	static void valid ( const automaton::NFTA &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::NFTA, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::NFTA, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::NFTA &, const automaton::State & ) {
+	static bool used ( const automaton::NFTA &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::NFTA & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::NFTA & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::NFTA &, const automaton::State & ) {
+	static void valid ( const automaton::NFTA &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/TM/OneTapeDTM.cpp b/alib2data/src/automaton/TM/OneTapeDTM.cpp
index 92ca252502..7cc4dd0e52 100644
--- a/alib2data/src/automaton/TM/OneTapeDTM.cpp
+++ b/alib2data/src/automaton/TM/OneTapeDTM.cpp
@@ -17,11 +17,11 @@
 
 namespace automaton {
 
-OneTapeDTM::OneTapeDTM ( std::set < State > states, std::set < alphabet::Symbol > tapeAlphabet, alphabet::Symbol blankSymbol, std::set< alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < OneTapeDTM, alphabet::Symbol, std::tuple < TapeAlphabet, InputAlphabet >, std::tuple < BlankSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( tapeAlphabet), std::move ( inputAlphabet ) ), std::make_tuple ( blankSymbol ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+OneTapeDTM::OneTapeDTM ( std::set < label::Label > states, std::set < alphabet::Symbol > tapeAlphabet, alphabet::Symbol blankSymbol, std::set< alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates ) : std::Components < OneTapeDTM, alphabet::Symbol, std::tuple < TapeAlphabet, InputAlphabet >, std::tuple < BlankSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( tapeAlphabet), std::move ( inputAlphabet ) ), std::make_tuple ( blankSymbol ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 
 }
 
-OneTapeDTM::OneTapeDTM(State initial, alphabet::Symbol blank) : OneTapeDTM(std::set<automaton::State>{initial}, std::set<alphabet::Symbol> {blank}, blank, std::set<alphabet::Symbol>{}, initial, std::set<automaton::State>{}) {
+OneTapeDTM::OneTapeDTM(label::Label initial, alphabet::Symbol blank) : OneTapeDTM(std::set<label::Label>{initial}, std::set<alphabet::Symbol> {blank}, blank, std::set<alphabet::Symbol>{}, initial, std::set<label::Label>{}) {
 
 }
 
@@ -33,9 +33,9 @@ AutomatonBase* OneTapeDTM::plunder() && {
 	return new OneTapeDTM(std::move(*this));
 }
 
-bool OneTapeDTM::addTransition(State from, alphabet::Symbol input, State to, alphabet::Symbol output, Shift shift) {
+bool OneTapeDTM::addTransition(label::Label from, alphabet::Symbol input, label::Label to, alphabet::Symbol output, Shift shift) {
 	if (!getStates().count(from)) {
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) from + "\" doesn't exist.");
 	}
 
 	if (!getTapeAlphabet().count(input)) {
@@ -43,43 +43,43 @@ bool OneTapeDTM::addTransition(State from, alphabet::Symbol input, State to, alp
 	}
 
 	if (!getStates().count(to)) {
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+		throw AutomatonException("State \"" + (std::string) to + "\" doesn't exist.");
 	}
 
 	if (!getTapeAlphabet().count(output)) {
 		throw AutomatonException("Tape symbol  \"" + (std::string) output + "\" doesn't exist.");
 	}
 
-	std::pair<State, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
+	std::pair<label::Label, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
 
-	std::tuple<State, alphabet::Symbol, Shift > value(std::move(to), std::move(output), shift);
+	std::tuple<label::Label, alphabet::Symbol, Shift > value(std::move(to), std::move(output), shift);
 
 	if (transitions.find(key) != transitions.end()) {
 		if(transitions.find(key)->second == value)
 			return false;
 		else
-			throw AutomatonException("Transition (\"" + (std::string) key.first.getName() + "\", \"" + (std::string) key.second + "\") -> ? already exists.");
+			throw AutomatonException("Transition (\"" + (std::string) key.first + "\", \"" + (std::string) key.second + "\") -> ? already exists.");
 	}
 
 	transitions.insert(std::make_pair(std::move(key), std::move(value)));
 	return true;
 }
 
-bool OneTapeDTM::removeTransition(const State& from, const alphabet::Symbol& input, const State& to, const alphabet::Symbol& output, const Shift& shift) {
-	std::pair<State, alphabet::Symbol> key = std::make_pair(from, input);
+bool OneTapeDTM::removeTransition(const label::Label& from, const alphabet::Symbol& input, const label::Label& to, const alphabet::Symbol& output, const Shift& shift) {
+	std::pair<label::Label, alphabet::Symbol> key = std::make_pair(from, input);
 
 	if (transitions.find(key) == transitions.end())
 		return false;
 
-	std::tuple<State, alphabet::Symbol, Shift > value(to, output, shift);
+	std::tuple<label::Label, alphabet::Symbol, Shift > value(to, output, shift);
 	if(transitions.find(key)->second != value) 
-		throw AutomatonException("Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input + "\") -> ? doesn't exists.");
+		throw AutomatonException("Transition (\"" + (std::string) from + "\", \"" + (std::string) input + "\") -> ? doesn't exists.");
 
 	transitions.erase(key);
 	return true;
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, std::tuple<State, alphabet::Symbol, Shift> >& OneTapeDTM::getTransitions() const {
+const std::map<std::pair<label::Label, alphabet::Symbol>, std::tuple<label::Label, alphabet::Symbol, Shift> >& OneTapeDTM::getTransitions() const {
 	return transitions;
 }
 
@@ -112,12 +112,12 @@ OneTapeDTM::operator std::string () const {
 OneTapeDTM OneTapeDTM::parse(std::deque<sax::Token>::iterator& input) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, OneTapeDTM::getXmlTagName());
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
+	std::set<label::Label> states = AutomatonFromXMLParser::parseStates(input);
 	std::set<alphabet::Symbol> tapeSymbols = AutomatonFromXMLParser::parseTapeAlphabet(input);
 	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
 	alphabet::Symbol blank = AutomatonFromXMLParser::parseBlankSymbol(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	label::Label initialState = AutomatonFromXMLParser::parseInitialState(input);
+	std::set<label::Label> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
 
 	OneTapeDTM automaton(std::move(initialState), std::move(blank));
 	automaton.setStates(std::move(states));
@@ -133,9 +133,9 @@ OneTapeDTM OneTapeDTM::parse(std::deque<sax::Token>::iterator& input) {
 
 void OneTapeDTM::parseTransition(std::deque<sax::Token>::iterator& input, OneTapeDTM& automaton) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
+	label::Label from = AutomatonFromXMLParser::parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
+	label::Label to = AutomatonFromXMLParser::parseTransitionTo(input);
 	alphabet::Symbol outputSymbol = AutomatonFromXMLParser::parseTransitionOutputSymbol(input);
 	Shift shift = AutomatonFromXMLParser::parseTransitionShift(input);
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
diff --git a/alib2data/src/automaton/TM/OneTapeDTM.h b/alib2data/src/automaton/TM/OneTapeDTM.h
index 16ea5660bf..dd2f221b14 100644
--- a/alib2data/src/automaton/TM/OneTapeDTM.h
+++ b/alib2data/src/automaton/TM/OneTapeDTM.h
@@ -11,8 +11,8 @@
 #include "../AutomatonException.h"
 #include "../AutomatonBase.h"
 #include <core/components.hpp>
-#include "../common/State.h"
 #include "../../alphabet/Symbol.h"
+#include "../../label/Label.h"
 #include "../common/Shift.h"
 
 #include <map>
@@ -31,56 +31,56 @@ class InitialState;
 /**
  * One tape turing machine
  */
-class OneTapeDTM : public AutomatonBase, public std::Components < OneTapeDTM, alphabet::Symbol, std::tuple < TapeAlphabet, InputAlphabet >, std::tuple < BlankSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class OneTapeDTM : public AutomatonBase, public std::Components < OneTapeDTM, alphabet::Symbol, std::tuple < TapeAlphabet, InputAlphabet >, std::tuple < BlankSymbol >, label::Label, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
-	std::map < std::pair < State, alphabet::Symbol >, std::tuple < State, alphabet::Symbol, Shift > > transitions;
+	std::map < std::pair < label::Label, alphabet::Symbol >, std::tuple < label::Label, alphabet::Symbol, Shift > > transitions;
 
 public:
-	explicit OneTapeDTM ( std::set < State > states, std::set < alphabet::Symbol > tapeAlphabet, alphabet::Symbol blankSymbol, std::set< alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates );
+	explicit OneTapeDTM ( std::set < label::Label > states, std::set < alphabet::Symbol > tapeAlphabet, alphabet::Symbol blankSymbol, std::set< alphabet::Symbol > inputAlphabet, label::Label initialState, std::set < label::Label > finalStates );
 
-	explicit OneTapeDTM ( State initialState, alphabet::Symbol blank );
+	explicit OneTapeDTM ( label::Label initialState, alphabet::Symbol blank );
 
 	virtual AutomatonBase * clone ( ) const;
 
 	virtual AutomatonBase * plunder ( ) &&;
 
-	const State & getInitialState ( ) const {
+	const label::Label & getInitialState ( ) const {
 		return accessElement < InitialState > ( ).get ( );
 	}
 
-	bool setInitialState ( State state ) {
+	bool setInitialState ( label::Label state ) {
 		return accessElement < InitialState > ( ).set ( std::move ( state ) );
 	}
 
-	const std::set < State > & getStates ( ) const {
+	const std::set < label::Label > & getStates ( ) const {
 		return accessComponent < States > ( ).get ( );
 	}
 
-	bool addState ( State state ) {
+	bool addState ( label::Label state ) {
 		return accessComponent < States > ( ).add ( std::move ( state ) );
 	}
 
-	void setStates ( std::set < State > states ) {
+	void setStates ( std::set < label::Label > states ) {
 		accessComponent < States > ( ).set ( std::move ( states ) );
 	}
 
-	void removeState ( const State & state ) {
+	void removeState ( const label::Label & state ) {
 		accessComponent < States > ( ).remove ( state );
 	}
 
-	const std::set < State > & getFinalStates ( ) const {
+	const std::set < label::Label > & getFinalStates ( ) const {
 		return accessComponent < FinalStates > ( ).get ( );
 	}
 
-	bool addFinalState ( State state ) {
+	bool addFinalState ( label::Label state ) {
 		return accessComponent < FinalStates > ( ).add ( std::move ( state ) );
 	}
 
-	void setFinalStates ( std::set < State > states ) {
+	void setFinalStates ( std::set < label::Label > states ) {
 		accessComponent < FinalStates > ( ).set ( std::move ( states ) );
 	}
 
-	void removeFinalState ( const State & state ) {
+	void removeFinalState ( const label::Label & state ) {
 		accessComponent < FinalStates > ( ).remove ( state );
 	}
 
@@ -138,19 +138,19 @@ public:
 	 * @throws AutomatonException when some part of the transition is not present
 	 * in the TM (state, tape symbol) or when transition already exists
 	 */
-	bool addTransition ( State from, alphabet::Symbol input, State to, alphabet::Symbol output, Shift shift );
+	bool addTransition ( label::Label from, alphabet::Symbol input, label::Label to, alphabet::Symbol output, Shift shift );
 
 	/**
 	 * Removes the transition from the TM.
 	 * @param transition transition to remove
 	 * @throws AutomatonException when transition is not present in the TM
 	 */
-	bool removeTransition ( const State & from, const alphabet::Symbol & input, const State & to, const alphabet::Symbol & output, const Shift & shift );
+	bool removeTransition ( const label::Label & from, const alphabet::Symbol & input, const label::Label & to, const alphabet::Symbol & output, const Shift & shift );
 
 	/**
 	 * @return TM transitions
 	 */
-	const std::map < std::pair < State, alphabet::Symbol >, std::tuple < State, alphabet::Symbol, Shift > > & getTransitions ( ) const;
+	const std::map < std::pair < label::Label, alphabet::Symbol >, std::tuple < label::Label, alphabet::Symbol, Shift > > & getTransitions ( ) const;
 
 	virtual int compare ( const ObjectBase & other ) const {
 		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
@@ -191,7 +191,7 @@ public:
 		if ( automaton.getInputAlphabet().count(symbol))
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::tuple<automaton::State, alphabet::Symbol, automaton::Shift> >& transition : automaton.getTransitions())
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::tuple<label::Label, alphabet::Symbol, automaton::Shift> >& transition : automaton.getTransitions())
 			if (symbol == transition.first.second || symbol == std::get<1>(transition.second))
 				return true;
 
@@ -238,53 +238,53 @@ public:
 };
 
 template < >
-class ComponentConstraint< automaton::OneTapeDTM, automaton::State, automaton::States > {
+class ComponentConstraint< automaton::OneTapeDTM, label::Label, automaton::States > {
 public:
-	static bool used ( const automaton::OneTapeDTM & automaton, const automaton::State & state ) {
+	static bool used ( const automaton::OneTapeDTM & automaton, const label::Label & state ) {
 		if ( automaton.getInitialState ( ) == state )
 			return true;
 
 		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::tuple<automaton::State, alphabet::Symbol, automaton::Shift> >& transition : automaton.getTransitions ( ) )
+		for (const std::pair<const std::pair<label::Label, alphabet::Symbol>, std::tuple<label::Label, alphabet::Symbol, automaton::Shift> >& transition : automaton.getTransitions ( ) )
 			if ( state == transition.first.first || state == std::get < 0 > ( transition.second ) )
 				return true;
 
 		return false;
 	}
 
-	static bool available ( const automaton::OneTapeDTM &, const automaton::State & ) {
+	static bool available ( const automaton::OneTapeDTM &, const label::Label & ) {
 		return true;
 	}
 
-	static void valid ( const automaton::OneTapeDTM &, const automaton::State & ) {
+	static void valid ( const automaton::OneTapeDTM &, const label::Label & ) {
 	}
 };
 
 template < >
-class ComponentConstraint< automaton::OneTapeDTM, automaton::State, automaton::FinalStates > {
+class ComponentConstraint< automaton::OneTapeDTM, label::Label, automaton::FinalStates > {
 public:
-	static bool used ( const automaton::OneTapeDTM &, const automaton::State & ) {
+	static bool used ( const automaton::OneTapeDTM &, const label::Label & ) {
 		return false;
 	}
 
-	static bool available ( const automaton::OneTapeDTM & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::OneTapeDTM & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::OneTapeDTM &, const automaton::State & ) {
+	static void valid ( const automaton::OneTapeDTM &, const label::Label & ) {
 	}
 };
 
 template < >
-class ElementConstraint< automaton::OneTapeDTM, automaton::State, automaton::InitialState > {
+class ElementConstraint< automaton::OneTapeDTM, label::Label, automaton::InitialState > {
 public:
-	static bool available ( const automaton::OneTapeDTM & automaton, const automaton::State & state ) {
+	static bool available ( const automaton::OneTapeDTM & automaton, const label::Label & state ) {
 		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
 	}
 
-	static void valid ( const automaton::OneTapeDTM &, const automaton::State & ) {
+	static void valid ( const automaton::OneTapeDTM &, const label::Label & ) {
 	}
 };
 
diff --git a/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp b/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp
index 89658fae52..d09ec443c6 100644
--- a/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp
+++ b/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp
@@ -8,6 +8,7 @@
 #include "AutomatonFromXMLParser.h"
 #include <sax/ParserException.h>
 #include <XmlApi.hpp>
+#include "../../label/Label.h"
 #include "../../alphabet/RankedSymbol.h"
 #include "Shift.h"
 #include "../../string/StringClasses.h"
@@ -15,12 +16,12 @@
 
 namespace automaton {
 
-std::set < State > AutomatonFromXMLParser::parseStates ( std::deque < sax::Token >::iterator & input ) {
-	std::set < State > states;
+std::set < label::Label > AutomatonFromXMLParser::parseStates ( std::deque < sax::Token >::iterator & input ) {
+	std::set < label::Label > states;
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "states" );
 
 	while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
-		states.insert ( State::parse ( input ) );
+		states.insert ( alib::xmlApi < label::Label >::parse ( input ) );
 
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "states" );
 	return states;
@@ -81,31 +82,31 @@ std::set < alphabet::RankedSymbol > AutomatonFromXMLParser::parseRankedInputAlph
 	return inputSymbols;
 }
 
-State AutomatonFromXMLParser::parseInitialState ( std::deque < sax::Token >::iterator & input ) {
+label::Label AutomatonFromXMLParser::parseInitialState ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "initialState" );
-	State state ( alib::xmlApi < label::Label >::parse ( input ) );
+	label::Label state ( alib::xmlApi < label::Label >::parse ( input ) );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "initialState" );
 
 	return state;
 }
 
-std::set < State > AutomatonFromXMLParser::parseInitialStates ( std::deque < sax::Token >::iterator & input ) {
-	std::set < State > initialStates;
+std::set < label::Label > AutomatonFromXMLParser::parseInitialStates ( std::deque < sax::Token >::iterator & input ) {
+	std::set < label::Label > initialStates;
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "initialStates" );
 
 	while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
-		initialStates.insert ( State::parse ( input ) );
+		initialStates.insert ( alib::xmlApi < label::Label >::parse ( input ) );
 
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "initialStates" );
 	return initialStates;
 }
 
-std::set < State > AutomatonFromXMLParser::parseFinalStates ( std::deque < sax::Token >::iterator & input ) {
-	std::set < State > finalStates;
+std::set < label::Label > AutomatonFromXMLParser::parseFinalStates ( std::deque < sax::Token >::iterator & input ) {
+	std::set < label::Label > finalStates;
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "finalStates" );
 
 	while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
-		finalStates.insert ( State::parse ( input ) );
+		finalStates.insert ( alib::xmlApi < label::Label >::parse ( input ) );
 
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "finalStates" );
 	return finalStates;
@@ -201,28 +202,28 @@ std::map < alphabet::Symbol, std::pair < std::vector < alphabet::Symbol >, std::
 	return operations;
 }
 
-State AutomatonFromXMLParser::parseTransitionTo ( std::deque < sax::Token >::iterator & input ) {
+label::Label AutomatonFromXMLParser::parseTransitionTo ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "to" );
-	State state ( alib::xmlApi < label::Label >::parse ( input ) );
+	label::Label state ( alib::xmlApi < label::Label >::parse ( input ) );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "to" );
 
 	return state;
 }
 
-State AutomatonFromXMLParser::parseTransitionFrom ( std::deque < sax::Token >::iterator & input ) {
+label::Label AutomatonFromXMLParser::parseTransitionFrom ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "from" );
-	State state ( alib::xmlApi < label::Label >::parse ( input ) );
+	label::Label state ( alib::xmlApi < label::Label >::parse ( input ) );
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "from" );
 
 	return state;
 }
 
-std::vector < State > AutomatonFromXMLParser::parseTransitionFromMultiple ( std::deque < sax::Token >::iterator & input ) {
+std::vector < label::Label > AutomatonFromXMLParser::parseTransitionFromMultiple ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "from" );
-	std::vector < State > states;
+	std::vector < label::Label > states;
 
 	while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
-		states.push_back ( State::parse ( input ) );
+		states.push_back ( alib::xmlApi < label::Label >::parse ( input ) );
 
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "from" );
 	return states;
diff --git a/alib2data/src/automaton/common/AutomatonFromXMLParser.h b/alib2data/src/automaton/common/AutomatonFromXMLParser.h
index ff85035ee2..659e7e5d06 100644
--- a/alib2data/src/automaton/common/AutomatonFromXMLParser.h
+++ b/alib2data/src/automaton/common/AutomatonFromXMLParser.h
@@ -13,10 +13,10 @@
 #include <vector>
 #include <variant>
 #include <map>
-#include "State.h"
 #include "../../regexp/RegExpFeatures.h"
 #include "../../alphabet/SymbolFeatures.h"
 #include "../../string/StringFeatures.h"
+#include "../../label/LabelFeatures.h"
 #include "Shift.h"
 
 namespace automaton {
@@ -26,8 +26,8 @@ namespace automaton {
  */
 class AutomatonFromXMLParser {
 public:
-	static std::set<State> parseStates(std::deque<sax::Token>::iterator& input);
-	static State parseState(std::deque<sax::Token>::iterator& input);
+	static std::set<label::Label> parseStates(std::deque<sax::Token>::iterator& input);
+	static label::Label parseState(std::deque<sax::Token>::iterator& input);
 	static std::set<alphabet::Symbol> parseInputAlphabet(std::deque<sax::Token>::iterator& input);
 	static std::set<alphabet::Symbol> parseCallInputAlphabet(std::deque<sax::Token>::iterator& input);
 	static std::set<alphabet::Symbol> parseReturnInputAlphabet(std::deque<sax::Token>::iterator& input);
@@ -38,16 +38,16 @@ public:
 	static alphabet::Symbol parseInitialPushdownStoreSymbol(std::deque<sax::Token>::iterator& input);
 	static std::set<alphabet::Symbol> parseOutputAlphabet(std::deque<sax::Token>::iterator& input);
 	static std::set<alphabet::Symbol> parseTapeAlphabet(std::deque<sax::Token>::iterator& input);
-	static State parseInitialState(std::deque<sax::Token>::iterator& input);
-	static std::set<State> parseInitialStates(std::deque<sax::Token>::iterator& input);
-	static std::set<State> parseFinalStates(std::deque<sax::Token>::iterator& input);
+	static label::Label parseInitialState(std::deque<sax::Token>::iterator& input);
+	static std::set<label::Label> parseInitialStates(std::deque<sax::Token>::iterator& input);
+	static std::set<label::Label> parseFinalStates(std::deque<sax::Token>::iterator& input);
 	static alphabet::Symbol parseBlankSymbol(std::deque<sax::Token>::iterator& input);
 	static alphabet::Symbol parseBottomOfTheStackSymbol(std::deque<sax::Token>::iterator& input);
 	static std::map<alphabet::Symbol, std::pair<std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > parseInputToPushdownStoreOperation(std::deque<sax::Token>::iterator& input);
 
-	static State parseTransitionFrom(std::deque<sax::Token>::iterator& input);
-	static std::vector<State> parseTransitionFromMultiple(std::deque<sax::Token>::iterator& input);
-	static State parseTransitionTo(std::deque<sax::Token>::iterator& input);
+	static label::Label parseTransitionFrom(std::deque<sax::Token>::iterator& input);
+	static std::vector<label::Label> parseTransitionFromMultiple(std::deque<sax::Token>::iterator& input);
+	static label::Label parseTransitionTo(std::deque<sax::Token>::iterator& input);
 	static Shift parseTransitionShift(std::deque<sax::Token>::iterator& input);
 	static std::vector<alphabet::Symbol> parseTransitionPop(std::deque<sax::Token>::iterator& input);
 	static alphabet::Symbol parseTransitionSinglePop(std::deque<sax::Token>::iterator& input);
diff --git a/alib2data/src/automaton/common/AutomatonToXMLComposer.cpp b/alib2data/src/automaton/common/AutomatonToXMLComposer.cpp
index f7a49cf7e6..704c8af4a6 100644
--- a/alib2data/src/automaton/common/AutomatonToXMLComposer.cpp
+++ b/alib2data/src/automaton/common/AutomatonToXMLComposer.cpp
@@ -8,7 +8,7 @@
 #include "AutomatonToXMLComposer.h"
 
 #include <XmlApi.hpp>
-#include "State.h"
+#include "../../label/Label.h"
 #include "../../alphabet/RankedSymbol.h"
 #include "Shift.h"
 #include "../../string/StringClasses.h"
@@ -16,10 +16,10 @@
 
 namespace automaton {
 
-void AutomatonToXMLComposer::composeStates(std::deque<sax::Token>& out, const std::set<State>& states) {
+void AutomatonToXMLComposer::composeStates(std::deque<sax::Token>& out, const std::set<label::Label>& states) {
 	out.emplace_back("states", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& state : states) {
-		alib::xmlApi<State>::compose(out, state);
+		alib::xmlApi<label::Label>::compose(out, state);
 	}
 	out.emplace_back("states", sax::Token::TokenType::END_ELEMENT);
 }
@@ -64,24 +64,24 @@ void AutomatonToXMLComposer::composeRankedInputAlphabet(std::deque<sax::Token>&
 	out.emplace_back(sax::Token("rankedInputAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeInitialStates(std::deque<sax::Token>& out, const std::set<State>& states) {
+void AutomatonToXMLComposer::composeInitialStates(std::deque<sax::Token>& out, const std::set<label::Label>& states) {
 	out.emplace_back("initialStates", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& state : states) {
-		alib::xmlApi<label::Label>::compose(out, state.getName());
+		alib::xmlApi<label::Label>::compose(out, state);
 	}
 	out.emplace_back("initialStates", sax::Token::TokenType::END_ELEMENT);
 }
 
-void AutomatonToXMLComposer::composeInitialState(std::deque<sax::Token>& out, const State& state) {
+void AutomatonToXMLComposer::composeInitialState(std::deque<sax::Token>& out, const label::Label& state) {
 	out.emplace_back("initialState", sax::Token::TokenType::START_ELEMENT);
-	alib::xmlApi<label::Label>::compose(out, state.getName());
+	alib::xmlApi<label::Label>::compose(out, state);
 	out.emplace_back("initialState", sax::Token::TokenType::END_ELEMENT);
 }
 
-void AutomatonToXMLComposer::composeFinalStates(std::deque<sax::Token>& out, const std::set<State>& states) {
+void AutomatonToXMLComposer::composeFinalStates(std::deque<sax::Token>& out, const std::set<label::Label>& states) {
 	out.emplace_back("finalStates", sax::Token::TokenType::START_ELEMENT);
 	for (const auto& state : states) {
-		alib::xmlApi<label::Label>::compose(out, state.getName());
+		alib::xmlApi<label::Label>::compose(out, state);
 	}
 	out.emplace_back("finalStates", sax::Token::TokenType::END_ELEMENT);
 }
@@ -151,22 +151,22 @@ void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::deque<sax
 	out.emplace_back("inputToPushdownStoreOperations", sax::Token::TokenType::END_ELEMENT);
 }
 
-void AutomatonToXMLComposer::composeTransitionTo(std::deque<sax::Token>& out, const State& state) {
+void AutomatonToXMLComposer::composeTransitionTo(std::deque<sax::Token>& out, const label::Label& state) {
 	out.emplace_back("to", sax::Token::TokenType::START_ELEMENT);
-	alib::xmlApi<label::Label>::compose(out, state.getName());
+	alib::xmlApi<label::Label>::compose(out, state);
 	out.emplace_back("to", sax::Token::TokenType::END_ELEMENT);
 }
 
-void AutomatonToXMLComposer::composeTransitionFrom(std::deque<sax::Token>& out, const State& state) {
+void AutomatonToXMLComposer::composeTransitionFrom(std::deque<sax::Token>& out, const label::Label& state) {
 	out.emplace_back("from", sax::Token::TokenType::START_ELEMENT);
-	alib::xmlApi<label::Label>::compose(out, state.getName());
+	alib::xmlApi<label::Label>::compose(out, state);
 	out.emplace_back("from", sax::Token::TokenType::END_ELEMENT);
 }
 
-void AutomatonToXMLComposer::composeTransitionFrom(std::deque<sax::Token>& out, const std::vector<State> & states) {
+void AutomatonToXMLComposer::composeTransitionFrom(std::deque<sax::Token>& out, const std::vector<label::Label> & states) {
 	out.emplace_back(sax::Token("from", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& state : states) {
-		alib::xmlApi<label::Label>::compose(out, state.getName());
+		alib::xmlApi<label::Label>::compose(out, state);
 	}
 	out.emplace_back(sax::Token("from", sax::Token::TokenType::END_ELEMENT));
 }
diff --git a/alib2data/src/automaton/common/AutomatonToXMLComposer.h b/alib2data/src/automaton/common/AutomatonToXMLComposer.h
index a1b380b5c2..92fc72f83c 100644
--- a/alib2data/src/automaton/common/AutomatonToXMLComposer.h
+++ b/alib2data/src/automaton/common/AutomatonToXMLComposer.h
@@ -18,6 +18,7 @@
 #include "../../regexp/RegExpFeatures.h"
 #include "../../alphabet/SymbolFeatures.h"
 #include "../../string/StringFeatures.h"
+#include "../../label/LabelFeatures.h"
 #include <sax/Token.h>
 
 namespace automaton {
@@ -27,15 +28,15 @@ namespace automaton {
  */
 class AutomatonToXMLComposer {
 public:
-	static void composeStates(std::deque<sax::Token>&, const std::set<State>& states);
+	static void composeStates(std::deque<sax::Token>&, const std::set<label::Label>& states);
 	static void composeInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols);
 	static void composeCallInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols);
 	static void composeReturnInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols);
 	static void composeLocalInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols);
 	static void composeRankedInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::RankedSymbol>& symbols);
-	static void composeInitialStates(std::deque<sax::Token>&, const std::set<State>& states);
-	static void composeInitialState(std::deque<sax::Token>&, const State& state);
-	static void composeFinalStates(std::deque<sax::Token>&, const std::set<State>& states);
+	static void composeInitialStates(std::deque<sax::Token>&, const std::set<label::Label>& states);
+	static void composeInitialState(std::deque<sax::Token>&, const label::Label& state);
+	static void composeFinalStates(std::deque<sax::Token>&, const std::set<label::Label>& states);
 	static void composePushdownStoreAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols);
 	static void composeInitialPushdownStoreSymbols(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols);
 	static void composeInitialPushdownStoreSymbol(std::deque<sax::Token>&, const alphabet::Symbol& symbols);
@@ -45,9 +46,9 @@ public:
 	static void composeBottomOfTheStackSymbol(std::deque<sax::Token>&, const alphabet::Symbol& symbol);
 	static void composeInputToPushdownStoreOperation(std::deque<sax::Token>&, const std::map<alphabet::Symbol, std::pair<std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > >& operations);
 
-	static void composeTransitionTo(std::deque<sax::Token>&, const State& state);
-	static void composeTransitionFrom(std::deque<sax::Token>&, const State& state);
-	static void composeTransitionFrom(std::deque<sax::Token>&, const std::vector<State> & states);
+	static void composeTransitionTo(std::deque<sax::Token>&, const label::Label& state);
+	static void composeTransitionFrom(std::deque<sax::Token>&, const label::Label& state);
+	static void composeTransitionFrom(std::deque<sax::Token>&, const std::vector<label::Label> & states);
 	static void composeTransitionShift(std::deque<sax::Token>&, Shift shift);
 	static void composeTransitionPop(std::deque<sax::Token>&, const std::vector<alphabet::Symbol>& symbols);
 	static void composeTransitionSinglePop(std::deque<sax::Token>&, const alphabet::Symbol& symbol);
diff --git a/alib2data/src/automaton/common/State.cpp b/alib2data/src/automaton/common/State.cpp
deleted file mode 100644
index 93114c833b..0000000000
--- a/alib2data/src/automaton/common/State.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * State.cpp
- *
- *  Created on: Mar 26, 2013
- *      Author: Martin Zak
- */
-
-#include "State.h"
-#include "../../label/Label.h"
-#include <XmlApi.hpp>
-
-namespace automaton {
-
-State::State(label::Label name) : name(std::move(name)) {
-}
-
-State::State(label::Label name1, label::Label name2) : name ( label::labelFrom ( std::move ( name1 ), std::move ( name2 ) ) ) {
-}
-
-State::State(int number) : name(label::labelFrom(number)) {
-}
-
-State::State(int number1, int number2) : name(label::labelFrom(number1, number2)) {
-}
-
-State::State(char character) : name(label::labelFrom(character)) {
-}
-
-State::State(std::string name) : name(label::labelFrom(std::move(name))) {
-}
-
-State::State(const char* name) : State((std::string) name) {
-}
-
-const label::Label& State::getName() const {
-	return name;
-}
-
-label::Label& State::getName() {
-	return name;
-}
-
-bool State::operator < (const State& other) const {
-	return this->compare(other) < 0;
-}
-
-bool State::operator == (const State& other) const {
-	return this->compare(other) == 0;
-}
-
-bool State::operator != (const State& other) const{
-	return !(*this == other);
-}
-
-int State::compare(const State& other) const {
-	return name.getData().compare(other.name.getData());
-}
-
-std::ostream& operator<<(std::ostream& out, const State& state) {
-	out << "(State " << state.name << ")";
-	return out;
-}
-
-State::operator std::string () const {
-	return (std::string) name;
-}
-
-State State::parse(std::deque<sax::Token>::iterator& input) {
-	return State(alib::xmlApi<label::Label>::parse(input));
-}
-
-void State::compose(std::deque<sax::Token>& out) const {
-	alib::xmlApi<label::Label>::compose(out, name);
-}
-
-} /* namespace automaton */
-
-namespace alib {
-
-automaton::State xmlApi<automaton::State>::parse(std::deque<sax::Token>::iterator& input) {
-	return automaton::State::parse(input);
-}
-
-bool xmlApi<automaton::State>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, automaton::State::getXmlTagName());
-}
-
-void xmlApi<automaton::State>::compose(std::deque<sax::Token>& output, const automaton::State& data) {
-	data.compose(output);
-}
-
-} /* namespace alib */
diff --git a/alib2data/src/automaton/common/State.h b/alib2data/src/automaton/common/State.h
deleted file mode 100644
index 64820f1727..0000000000
--- a/alib2data/src/automaton/common/State.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * State.h
- *
- *  Created on: Mar 26, 2013
- *      Author: Martin Zak
- */
-
-#ifndef STATE_H_
-#define STATE_H_
-
-#include <string>
-#include <ostream>
-
-#include "../../label/Label.h"
-#include <XmlApi.hpp>
-
-namespace automaton {
-
-/**
- * Class representing state in an automaton.
- */
-class State {
-private:
-	label::Label name;
-public:
-	explicit State(label::Label name);
-	explicit State(label::Label name1, label::Label name2);
-	explicit State(int number);
-	explicit State(int number1, int number2);
-	explicit State(char character);
-	explicit State(std::string name);
-	explicit State(const char* name);
-
-	const label::Label& getName() const;
-	label::Label& getName();
-
-	bool operator < (const State& other) const;
-	bool operator == (const State& other) const;
-	bool operator != (const State& other) const;
-	int compare(const State& other) const;
-
-	friend std::ostream& operator<<(std::ostream&, const State&);
-
-	explicit operator std::string () const;
-
-	static const std::string & getXmlTagName() {
-		static std::string xmlTagName = "State";
-
-		return xmlTagName;
-	}
-
-	static State parse(std::deque<sax::Token>::iterator& input);
-
-	void compose(std::deque<sax::Token>& out) const;
-};
-
-} /* namespace automaton */
-
-namespace std {
-
-template<>
-struct compare<automaton::State> {
-	int operator()(const automaton::State& first, const automaton::State& second) const {
-		return first.compare(second);
-	}
-};
-
-} /* namespace std */
-
-namespace alib {
-
-template<>
-struct xmlApi<automaton::State> {
-	static automaton::State parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const automaton::State& data);
-};
-
-} /* namespace alib */
-
-#endif /* STATE_H_ */
diff --git a/alib2data/src/grammar/parsing/LRParserTypes.h b/alib2data/src/grammar/parsing/LRParserTypes.h
index c950aa1d35..2047ff259e 100644
--- a/alib2data/src/grammar/parsing/LRParserTypes.h
+++ b/alib2data/src/grammar/parsing/LRParserTypes.h
@@ -9,7 +9,7 @@
 #define LR_PARSER_TYPES_H_
 
 #include "../../alphabet/Symbol.h"
-#include "../../automaton/common/State.h"
+#include "../../label/Label.h"
 
 #include <map>
 #include <set>
@@ -27,8 +27,8 @@ enum class LRAction {
 };
 
 typedef std::map < alphabet::Symbol, std::set < std::pair < unsigned, std::vector < alphabet::Symbol > > > > LR0Items;
-typedef std::map < std::pair < automaton::State, alphabet::Symbol >, std::pair < LRAction, std::variant < automaton::State, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > > > LRActionTable;
-typedef std::map < std::pair < automaton::State, alphabet::Symbol >, automaton::State > LRGotoTable;
+typedef std::map < std::pair < label::Label, alphabet::Symbol >, std::pair < LRAction, std::variant < label::Label, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > > > LRActionTable;
+typedef std::map < std::pair < label::Label, alphabet::Symbol >, label::Label > LRGotoTable;
 
 } /* namespace parsing */
 
diff --git a/alib2data/src/label/Label.cpp b/alib2data/src/label/Label.cpp
index dc96527f90..d5b9241bf1 100644
--- a/alib2data/src/label/Label.cpp
+++ b/alib2data/src/label/Label.cpp
@@ -10,6 +10,8 @@
 #include "LabelPairLabel.h"
 #include "../primitive/Primitive.h"
 #include <XmlApi.hpp>
+#include <exception/CommonException.h>
+#include <climits>
 
 namespace label {
 
@@ -25,6 +27,19 @@ void Label::inc ( ) {
 	this->setData ( res );
 }
 
+label::Label createUniqueLabel ( label::Label nextState, const std::set < label::Label > & other ) {
+	int i = 0;
+
+	do {
+		if ( other.count ( nextState ) == 0 )
+			return nextState;
+
+		nextState.inc ( );
+	} while ( i++ < INT_MAX );
+
+	throw exception::CommonException ( "Could not create unique label." );
+}
+
 label::Label labelFrom ( int number ) {
 	return label::Label {
 			   label::PrimitiveLabel {
diff --git a/alib2data/src/label/Label.h b/alib2data/src/label/Label.h
index 0949a5b5e6..7897fa6679 100644
--- a/alib2data/src/label/Label.h
+++ b/alib2data/src/label/Label.h
@@ -11,6 +11,8 @@
 #include <base/WrapperBase.hpp>
 #include "LabelBase.h"
 
+#include <set>
+
 namespace label {
 
 /**
@@ -30,6 +32,8 @@ public:
 	}
 };
 
+label::Label createUniqueLabel ( label::Label base, const std::set < label::Label > & other );
+
 label::Label labelFrom ( label::Label label1, label::Label label2 );
 label::Label labelFrom ( int number );
 label::Label labelFrom ( int number1, int number2 );
diff --git a/alib2data/test-src/automaton/AutomatonTest.cpp b/alib2data/test-src/automaton/AutomatonTest.cpp
index 2052587b3e..48f84367e3 100644
--- a/alib2data/test-src/automaton/AutomatonTest.cpp
+++ b/alib2data/test-src/automaton/AutomatonTest.cpp
@@ -34,18 +34,18 @@ void AutomatonTest::tearDown() {
 }
 
 void AutomatonTest::testDFAParser() {
-	automaton::DFA automaton(automaton::State(1));
+	automaton::DFA automaton(label::labelFrom(1));
 
-	automaton.addState(automaton::State(1));
-	automaton.addState(automaton::State(2));
-	automaton.addState(automaton::State(3));
+	automaton.addState(label::labelFrom(1));
+	automaton.addState(label::labelFrom(2));
+	automaton.addState(label::labelFrom(3));
 	automaton.addInputSymbol(alphabet::symbolFrom("a"));
 	automaton.addInputSymbol(alphabet::symbolFrom("b"));
 
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a"), automaton::State(2));
-	automaton.addTransition(automaton::State(2), alphabet::symbolFrom("b"), automaton::State(1));
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a"), label::labelFrom(2));
+	automaton.addTransition(label::labelFrom(2), alphabet::symbolFrom("b"), label::labelFrom(1));
 
-	automaton.addFinalState(automaton::State(3));
+	automaton.addFinalState(label::labelFrom(3));
 
 	CPPUNIT_ASSERT( automaton == automaton );
 	{
@@ -62,11 +62,11 @@ void AutomatonTest::testDFAParser() {
 }
 
 void AutomatonTest::SinglePopDPDATransitions() {
-	automaton::SinglePopDPDA automaton(automaton::State(1), alphabet::symbolFrom("S"));
+	automaton::SinglePopDPDA automaton(label::labelFrom(1), alphabet::symbolFrom("S"));
 
-	automaton.addState(automaton::State(1));
-	automaton.addState(automaton::State(2));
-	automaton.addState(automaton::State(3));
+	automaton.addState(label::labelFrom(1));
+	automaton.addState(label::labelFrom(2));
+	automaton.addState(label::labelFrom(3));
 
 	automaton.addInputSymbol(alphabet::symbolFrom("a"));
 	automaton.addInputSymbol(alphabet::symbolFrom("b"));
@@ -75,38 +75,37 @@ void AutomatonTest::SinglePopDPDATransitions() {
 	automaton.addPushdownStoreSymbol(alphabet::symbolFrom("X"));
 	automaton.addPushdownStoreSymbol(alphabet::symbolFrom("Y"));
 
-	automaton.addTransition(automaton::State(3), /* eps, */ alphabet::symbolFrom("X"), automaton::State(1), { alphabet::symbolFrom("X") } );
+	automaton.addTransition(label::labelFrom(3), /* eps, */ alphabet::symbolFrom("X"), label::labelFrom(1), { alphabet::symbolFrom("X") } );
 
-	CPPUNIT_ASSERT(!automaton.addTransition(automaton::State(3), /* eps, */ alphabet::symbolFrom("X"), automaton::State(1), { alphabet::symbolFrom("X") } ) );
+	CPPUNIT_ASSERT(!automaton.addTransition(label::labelFrom(3), /* eps, */ alphabet::symbolFrom("X"), label::labelFrom(1), { alphabet::symbolFrom("X") } ) );
 
-	automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a"), alphabet::symbolFrom("Y"), automaton::State(1), { alphabet::symbolFrom("X") } );
+	automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a"), alphabet::symbolFrom("Y"), label::labelFrom(1), { alphabet::symbolFrom("X") } );
 
 	CPPUNIT_ASSERT_THROW(
-		automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a"), alphabet::symbolFrom("X"), automaton::State(1), { alphabet::symbolFrom("X") } ),
+		automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a"), alphabet::symbolFrom("X"), label::labelFrom(1), { alphabet::symbolFrom("X") } ),
 		automaton::AutomatonException
 	);
 
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a"), alphabet::symbolFrom("X"), automaton::State(2), { alphabet::symbolFrom("Y") } );
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a"), alphabet::symbolFrom("X"), automaton::State(2), { alphabet::symbolFrom("Y") } );
-	automaton.addTransition(automaton::State(1), /* eps, */ alphabet::symbolFrom("Y"), automaton::State(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a"), alphabet::symbolFrom("X"), label::labelFrom(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a"), alphabet::symbolFrom("X"), label::labelFrom(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(1), /* eps, */ alphabet::symbolFrom("Y"), label::labelFrom(2), { alphabet::symbolFrom("Y") } );
 
-	automaton.addTransition(automaton::State(2), alphabet::symbolFrom("b"), alphabet::symbolFrom("X"), automaton::State(1), { alphabet::symbolFrom("X") } );
+	automaton.addTransition(label::labelFrom(2), alphabet::symbolFrom("b"), alphabet::symbolFrom("X"), label::labelFrom(1), { alphabet::symbolFrom("X") } );
 	CPPUNIT_ASSERT_THROW(
-		automaton.addTransition(automaton::State(2), /* eps, */ alphabet::symbolFrom("X"), automaton::State(1), { alphabet::symbolFrom("X") } ),
+		automaton.addTransition(label::labelFrom(2), /* eps, */ alphabet::symbolFrom("X"), label::labelFrom(1), { alphabet::symbolFrom("X") } ),
 		automaton::AutomatonException
 	);
 
-	automaton.addFinalState(automaton::State(3));
-
+	automaton.addFinalState(label::labelFrom(3));
 }
 
 void AutomatonTest::DPDATransitions() {
-	automaton::DPDA automaton(automaton::State(1), alphabet::symbolFrom("S"));
+	automaton::DPDA automaton(label::labelFrom(1), alphabet::symbolFrom("S"));
 
-	automaton.addState(automaton::State(1));
-	automaton.addState(automaton::State(2));
-	automaton.addState(automaton::State(3));
-	automaton.addState(automaton::State(4));
+	automaton.addState(label::labelFrom(1));
+	automaton.addState(label::labelFrom(2));
+	automaton.addState(label::labelFrom(3));
+	automaton.addState(label::labelFrom(4));
 
 	automaton.addInputSymbol(alphabet::symbolFrom("a"));
 	automaton.addInputSymbol(alphabet::symbolFrom("b"));
@@ -115,48 +114,48 @@ void AutomatonTest::DPDATransitions() {
 	automaton.addPushdownStoreSymbol(alphabet::symbolFrom("X"));
 	automaton.addPushdownStoreSymbol(alphabet::symbolFrom("Y"));
 
-	automaton.addTransition(automaton::State(3), /* eps, */ { alphabet::symbolFrom("X") }, automaton::State(1), { alphabet::symbolFrom("X") } );
+	automaton.addTransition(label::labelFrom(3), /* eps, */ { alphabet::symbolFrom("X") }, label::labelFrom(1), { alphabet::symbolFrom("X") } );
 
-	CPPUNIT_ASSERT(!automaton.addTransition(automaton::State(3), /* eps, */ { alphabet::symbolFrom("X") }, automaton::State(1), { alphabet::symbolFrom("X") } ) );
+	CPPUNIT_ASSERT(!automaton.addTransition(label::labelFrom(3), /* eps, */ { alphabet::symbolFrom("X") }, label::labelFrom(1), { alphabet::symbolFrom("X") } ) );
 
-	automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a"), { alphabet::symbolFrom("Y") }, automaton::State(1), { alphabet::symbolFrom("X") } );
+	automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a"), { alphabet::symbolFrom("Y") }, label::labelFrom(1), { alphabet::symbolFrom("X") } );
 
 	CPPUNIT_ASSERT_THROW(
-		automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X") }, automaton::State(1), { alphabet::symbolFrom("X") } ),
+		automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X") }, label::labelFrom(1), { alphabet::symbolFrom("X") } ),
 		automaton::AutomatonException
 	);
 
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X") }, automaton::State(2), { alphabet::symbolFrom("Y") } );
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X") }, automaton::State(2), { alphabet::symbolFrom("Y") } );
-	automaton.addTransition(automaton::State(1), /* eps, */ { alphabet::symbolFrom("Y") }, automaton::State(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(1), /* eps, */ { alphabet::symbolFrom("Y") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } );
 
-	automaton.addTransition(automaton::State(2), alphabet::symbolFrom("b"), { alphabet::symbolFrom("X") }, automaton::State(1), { alphabet::symbolFrom("X") } );
+	automaton.addTransition(label::labelFrom(2), alphabet::symbolFrom("b"), { alphabet::symbolFrom("X") }, label::labelFrom(1), { alphabet::symbolFrom("X") } );
 	CPPUNIT_ASSERT_THROW(
-		automaton.addTransition(automaton::State(2), /* eps, */ { alphabet::symbolFrom("X") }, automaton::State(1), { alphabet::symbolFrom("X") } ),
+		automaton.addTransition(label::labelFrom(2), /* eps, */ { alphabet::symbolFrom("X") }, label::labelFrom(1), { alphabet::symbolFrom("X") } ),
 		automaton::AutomatonException
 	);
 
-	automaton.addTransition(automaton::State(4), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X"), alphabet::symbolFrom("Y") }, automaton::State(2), { alphabet::symbolFrom("Y") } );
-	automaton.addTransition(automaton::State(4), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X"), alphabet::symbolFrom("S") }, automaton::State(2), { alphabet::symbolFrom("Y") } );
-	automaton.addTransition(automaton::State(4), /* eps, */ { alphabet::symbolFrom("X"), alphabet::symbolFrom("X") }, automaton::State(2), { alphabet::symbolFrom("Y") } );
-	CPPUNIT_ASSERT(!automaton.addTransition(automaton::State(4), /* eps, */ { alphabet::symbolFrom("X"), alphabet::symbolFrom("X") }, automaton::State(2), { alphabet::symbolFrom("Y") } ));
+	automaton.addTransition(label::labelFrom(4), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X"), alphabet::symbolFrom("Y") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(4), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X"), alphabet::symbolFrom("S") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(4), /* eps, */ { alphabet::symbolFrom("X"), alphabet::symbolFrom("X") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } );
+	CPPUNIT_ASSERT(!automaton.addTransition(label::labelFrom(4), /* eps, */ { alphabet::symbolFrom("X"), alphabet::symbolFrom("X") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } ));
 	CPPUNIT_ASSERT_THROW(
-		automaton.addTransition(automaton::State(4), /* eps, */ { alphabet::symbolFrom("X"), alphabet::symbolFrom("Y") }, automaton::State(2), { alphabet::symbolFrom("Y") } ),
+		automaton.addTransition(label::labelFrom(4), /* eps, */ { alphabet::symbolFrom("X"), alphabet::symbolFrom("Y") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } ),
 		automaton::AutomatonException
 	);
-	automaton.addTransition(automaton::State(4), alphabet::symbolFrom("b"), { alphabet::symbolFrom("X"), alphabet::symbolFrom("Y") }, automaton::State(2), { alphabet::symbolFrom("Y") } );
+	automaton.addTransition(label::labelFrom(4), alphabet::symbolFrom("b"), { alphabet::symbolFrom("X"), alphabet::symbolFrom("Y") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } );
 	CPPUNIT_ASSERT_THROW(
-		automaton.addTransition(automaton::State(4), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X") }, automaton::State(2), { alphabet::symbolFrom("Y") } ),
+		automaton.addTransition(label::labelFrom(4), alphabet::symbolFrom("a"), { alphabet::symbolFrom("X") }, label::labelFrom(2), { alphabet::symbolFrom("Y") } ),
 		automaton::AutomatonException
 	);
 
-	automaton.addFinalState(automaton::State(3));
+	automaton.addFinalState(label::labelFrom(3));
 }
 
 void AutomatonTest::testExtendedNFAAlphabet() {
-	automaton::ExtendedNFA automaton (automaton::State(0));
-	automaton::State s0(0);
-	automaton::State s1(1);
+	automaton::ExtendedNFA automaton (label::labelFrom(0));
+	label::Label s0 = label::labelFrom(0);
+	label::Label s1 = label::labelFrom(1);
 	automaton.addState(s0);
 	automaton.addState(s1);
 
@@ -181,35 +180,35 @@ void AutomatonTest::testExtendedNFAAlphabet() {
 }
 
 void AutomatonTest::testNPDATransitions() {
-	automaton::NPDA automaton(automaton::State(0), alphabet::symbolFrom("T"));
+	automaton::NPDA automaton(label::labelFrom(0), alphabet::symbolFrom("T"));
 
-	automaton.setStates({automaton::State(0), automaton::State(1), automaton::State(2), automaton::State(3), automaton::State(4)});
+	automaton.setStates({label::labelFrom(0), label::labelFrom(1), label::labelFrom(2), label::labelFrom(3), label::labelFrom(4)});
 	automaton.setInputAlphabet({alphabet::symbolFrom("a2"), alphabet::symbolFrom("a1"), alphabet::symbolFrom("a0")});
 	automaton.setPushdownStoreAlphabet({alphabet::symbolFrom("T"), alphabet::symbolFrom("R")});
 
-	automaton.addTransition(automaton::State(0), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("T")}, automaton::State(0), {alphabet::symbolFrom("T"), alphabet::symbolFrom("T")});
-	automaton.addTransition(automaton::State(0), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("T")}, automaton::State(0), {alphabet::symbolFrom("T")});
-	automaton.addTransition(automaton::State(0), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("T")}, automaton::State(0), {});
+	automaton.addTransition(label::labelFrom(0), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("T")}, label::labelFrom(0), {alphabet::symbolFrom("T"), alphabet::symbolFrom("T")});
+	automaton.addTransition(label::labelFrom(0), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("T")}, label::labelFrom(0), {alphabet::symbolFrom("T")});
+	automaton.addTransition(label::labelFrom(0), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("T")}, label::labelFrom(0), {});
 
-	automaton.addTransition(automaton::State(0), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("T")}, automaton::State(1), {alphabet::symbolFrom("R"), alphabet::symbolFrom("T")});
+	automaton.addTransition(label::labelFrom(0), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("T")}, label::labelFrom(1), {alphabet::symbolFrom("R"), alphabet::symbolFrom("T")});
 
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("T")}, automaton::State(1), {alphabet::symbolFrom("T"), alphabet::symbolFrom("T")});
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("R")}, automaton::State(1), {alphabet::symbolFrom("T"), alphabet::symbolFrom("R")});
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("T")}, automaton::State(1), {alphabet::symbolFrom("T")});
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("R")}, automaton::State(1), {alphabet::symbolFrom("R")});
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("T")}, automaton::State(1), {});
-	automaton.addTransition(automaton::State(1), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("R")}, automaton::State(2), {});
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("T")}, label::labelFrom(1), {alphabet::symbolFrom("T"), alphabet::symbolFrom("T")});
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("R")}, label::labelFrom(1), {alphabet::symbolFrom("T"), alphabet::symbolFrom("R")});
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("T")}, label::labelFrom(1), {alphabet::symbolFrom("T")});
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("R")}, label::labelFrom(1), {alphabet::symbolFrom("R")});
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("T")}, label::labelFrom(1), {});
+	automaton.addTransition(label::labelFrom(1), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("R")}, label::labelFrom(2), {});
 
-	automaton.addTransition(automaton::State(2), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("T")}, automaton::State(3), {alphabet::symbolFrom("R")});
+	automaton.addTransition(label::labelFrom(2), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("T")}, label::labelFrom(3), {alphabet::symbolFrom("R")});
 
-	automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("T")}, automaton::State(3), {alphabet::symbolFrom("T"), alphabet::symbolFrom("T")});
-	automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("R")}, automaton::State(3), {alphabet::symbolFrom("T"), alphabet::symbolFrom("R")});
-	automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("T")}, automaton::State(3), {alphabet::symbolFrom("T")});
-	automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("R")}, automaton::State(3), {alphabet::symbolFrom("R")});
-	automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("T")}, automaton::State(3), {});
-	automaton.addTransition(automaton::State(3), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("R")}, automaton::State(4), {});
+	automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("T")}, label::labelFrom(3), {alphabet::symbolFrom("T"), alphabet::symbolFrom("T")});
+	automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a2"), {alphabet::symbolFrom("R")}, label::labelFrom(3), {alphabet::symbolFrom("T"), alphabet::symbolFrom("R")});
+	automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("T")}, label::labelFrom(3), {alphabet::symbolFrom("T")});
+	automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a1"), {alphabet::symbolFrom("R")}, label::labelFrom(3), {alphabet::symbolFrom("R")});
+	automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("T")}, label::labelFrom(3), {});
+	automaton.addTransition(label::labelFrom(3), alphabet::symbolFrom("a0"), {alphabet::symbolFrom("R")}, label::labelFrom(4), {});
 
-	automaton.setFinalStates({automaton::State(4)});
+	automaton.setFinalStates({label::labelFrom(4)});
 	alib::XmlDataFactory::toStdout(automaton);
 
 	CPPUNIT_ASSERT(!(automaton < automaton));
@@ -218,17 +217,17 @@ void AutomatonTest::testNPDATransitions() {
 
 void AutomatonTest::testRHPDATransitions() {
 	automaton::RealTimeHeightDeterministicNPDA automaton{alphabet::BottomOfTheStackSymbol::BOTTOM_OF_THE_STACK_SYMBOL};
-	automaton.setStates({automaton::State(1), automaton::State(2), automaton::State(3)});
-	automaton.setInitialStates({automaton::State(1)});
+	automaton.setStates({label::labelFrom(1), label::labelFrom(2), label::labelFrom(3)});
+	automaton.setInitialStates({label::labelFrom(1)});
 
 	automaton.setInputAlphabet({alphabet::symbolFrom("a"), alphabet::symbolFrom("b")});
 	automaton.setPushdownStoreAlphabet({alphabet::BottomOfTheStackSymbol::BOTTOM_OF_THE_STACK_SYMBOL, alphabet::symbolFrom("X"), alphabet::symbolFrom("Y")});
 
-	automaton.addCallTransition(automaton::State(1), alphabet::symbolFrom("a"), automaton::State(2), alphabet::symbolFrom("X"));
-	automaton.addCallTransition(automaton::State(2), automaton::State(3), alphabet::symbolFrom("X"));
-	automaton.addReturnTransition(automaton::State(3), alphabet::symbolFrom("Y"), automaton::State(1));
+	automaton.addCallTransition(label::labelFrom(1), alphabet::symbolFrom("a"), label::labelFrom(2), alphabet::symbolFrom("X"));
+	automaton.addCallTransition(label::labelFrom(2), label::labelFrom(3), alphabet::symbolFrom("X"));
+	automaton.addReturnTransition(label::labelFrom(3), alphabet::symbolFrom("Y"), label::labelFrom(1));
 
-	automaton.setFinalStates({automaton::State(3)});
+	automaton.setFinalStates({label::labelFrom(3)});
 	alib::XmlDataFactory::toStdout(automaton);
 
 	CPPUNIT_ASSERT(!(automaton < automaton));
@@ -240,9 +239,9 @@ void AutomatonTest::testNFTAParser() {
 	alphabet::RankedSymbol b ('b', 1);
 	alphabet::RankedSymbol c ('c', 0);
 
-	automaton::State q2 ("q2");
-	automaton::State q1 ("q1");
-	automaton::State q0 ("q0");
+	label::Label q2 = label::labelFrom ("q2");
+	label::Label q1 = label::labelFrom ("q1");
+	label::Label q0 = label::labelFrom ("q0");
 
 	automaton::NFTA automaton;
 
@@ -253,13 +252,13 @@ void AutomatonTest::testNFTAParser() {
 	automaton.addInputSymbol(b);
 	automaton.addInputSymbol(c);
 
-	std::vector<automaton::State> states1 = {q1, q0};
+	std::vector<label::Label> states1 = {q1, q0};
 	automaton.addTransition(a, states1, q2);
 	automaton.addTransition(a, states1, q1);
-	std::vector<automaton::State> states2 = {q0};
+	std::vector<label::Label> states2 = {q0};
 	automaton.addTransition(b, states2, q1);
 	automaton.addTransition(b, states2, q0);
-	std::vector<automaton::State> states3 = {};
+	std::vector<label::Label> states3 = {};
 	automaton.addTransition(c, states3, q0);
 
 	automaton.addFinalState(q2);
@@ -285,9 +284,9 @@ void AutomatonTest::testNFTATransitions() {
 	alphabet::RankedSymbol c ('c', 0);
 	alphabet::RankedSymbol d ('d', 0);
 
-	automaton::State q2 ("q2");
-	automaton::State q1 ("q1");
-	automaton::State q0 ("q0");
+	label::Label q2 = label::labelFrom ("q2");
+	label::Label q1 = label::labelFrom ("q1");
+	label::Label q0 = label::labelFrom ("q0");
 
 	automaton::NFTA automaton;
 
@@ -298,13 +297,13 @@ void AutomatonTest::testNFTATransitions() {
 	automaton.addInputSymbol(b);
 	automaton.addInputSymbol(c);
 
-	std::vector<automaton::State> states1 = {q1, q0};
+	std::vector<label::Label> states1 = {q1, q0};
 	automaton.addTransition(a, states1, q2);
 	automaton.addTransition(a, states1, q1);
-	std::vector<automaton::State> states2 = {q0};
+	std::vector<label::Label> states2 = {q0};
 	automaton.addTransition(b, states2, q1);
 	automaton.addTransition(b, states2, q0);
-	std::vector<automaton::State> states3 = {};
+	std::vector<label::Label> states3 = {};
 	automaton.addTransition(c, states3, q0);
 
 	automaton.addFinalState(q2);
-- 
GitLab