diff --git a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
index b480989440dcfa2834738db5e1288d0bca645f32..188a9f70ca617ace104b0866187a9cf5a7b72fd1 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
@@ -47,7 +47,7 @@ automaton::DFA<> ToAutomatonDerivation::convert(const T& regexp) {
 		for(const auto& dregexp : Qi.at(i - 1)) {
 
 			for(const auto& a : regexp.getAlphabet()) {
-				string::LinearString < > string(std::vector<alphabet::Symbol>{a});
+				string::LinearString < > string(std::vector<DefaultSymbolType>{a});
 				regexp::RegExp derived = regexp::RegExpDerivation::derivation(dregexp, string);
 				derived = regexp::simplify::RegExpOptimize::optimize(derived);
 
@@ -61,11 +61,11 @@ automaton::DFA<> ToAutomatonDerivation::convert(const T& regexp) {
 		i += 1;
 	}
 
-	std::map<regexp::RegExp, label::Label> stateMap;
+	std::map<regexp::RegExp, DefaultStateType> stateMap;
 	int stateId = 0;
 
 	for(const auto& r : Q) {
-		label::Label q = label::Label (std::toBase26(stateId++));
+		DefaultStateType q = DefaultStateType (std::toBase26(stateId++));
 		stateMap.insert(std::make_pair(r, q));
 	}
 
@@ -83,7 +83,7 @@ automaton::DFA<> ToAutomatonDerivation::convert(const T& regexp) {
 	for(const auto& r : Q) {
 
 		for(const auto& a: regexp.getAlphabet()) {
-			string::LinearString < > string(std::vector<alphabet::Symbol>{a});
+			string::LinearString < > string(std::vector<DefaultSymbolType>{a});
 			regexp::RegExp derived = regexp::RegExpDerivation::derivation(r, string);
 			derived = regexp::simplify::RegExpOptimize::optimize(derived);
 
diff --git a/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
index 590ffe74d2c7a188e2d4773eefa34eb7de39da2c..6f6a716d2e22dcbb8ab7dbc98327cda70ee58de0 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
@@ -20,18 +20,18 @@ automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::RegExp& reg
 automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::FormalRegExp < > & regexp) {
 	//FIXME use actual algorithms that implement product alternation and iteration of re over automata and remove terrible TERRIBLE hack with dummy initial state
 	int nextState = 1;
-	const label::Label * headArg = nullptr;
-	const label::Label * tailArg = nullptr;
+	const DefaultStateType * headArg = nullptr;
+	const DefaultStateType * tailArg = nullptr;
 
-	automaton::EpsilonNFA < > automaton ( label::Label ( 0 ) );
+	automaton::EpsilonNFA < > automaton ( DefaultStateType ( 0 ) );
 	automaton.setInputAlphabet(regexp.getAlphabet());
 
-	regexp.getRegExp().getStructure().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+	regexp.getRegExp().getStructure().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 
 	automaton.setInitialState ( * headArg );
-	automaton.setFinalStates ( std::set < label::Label > { * tailArg } );
+	automaton.setFinalStates ( std::set < DefaultStateType > { * tailArg } );
 
-	automaton.removeState(label::Label(0));
+	automaton.removeState(DefaultStateType(0));
 
 	return automaton;
 }
@@ -41,18 +41,18 @@ auto ToAutomatonThompsonFormalRegExp = ToAutomatonThompson::RegistratorWrapper<a
 automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::UnboundedRegExp < > & regexp) {
 	//FIXME use actual algorithms that implement product alternation and iteration of re over automata and remove terrible TERRIBLE hack with dummy initial state
 	int nextState = 1;
-	const label::Label * headArg = nullptr;
-	const label::Label * tailArg = nullptr;
+	const DefaultStateType * headArg = nullptr;
+	const DefaultStateType * tailArg = nullptr;
 
-	automaton::EpsilonNFA < > automaton ( label::Label ( 0 ) );
+	automaton::EpsilonNFA < > automaton ( DefaultStateType ( 0 ) );
 	automaton.setInputAlphabet(regexp.getAlphabet());
 
-	regexp.getRegExp().getStructure().accept < void, ToAutomatonThompson::Unbounded, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+	regexp.getRegExp().getStructure().accept < void, ToAutomatonThompson::Unbounded, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 
 	automaton.setInitialState ( * headArg );
-	automaton.setFinalStates ( std::set < label::Label > { * tailArg } );
+	automaton.setFinalStates ( std::set < DefaultStateType > { * tailArg } );
 
-	automaton.removeState(label::Label(0));
+	automaton.removeState(DefaultStateType(0));
 
 	return automaton;
 }
@@ -61,17 +61,17 @@ auto ToAutomatonThompsonUnboundedRegExp = ToAutomatonThompson::RegistratorWrappe
 
 // ----------------------------------------------------------------------------
 
-void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpAlternation < alphabet::Symbol > & alternation, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpAlternation < DefaultSymbolType > & alternation, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
-	alternation.getLeftElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+	alternation.getLeftElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 	automaton.addTransition(head, string::Epsilon < >::EPSILON, *headArg);
 	automaton.addTransition(*tailArg, string::Epsilon < >::EPSILON, tail);
 
-	alternation.getRightElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+	alternation.getRightElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 	automaton.addTransition(head, string::Epsilon < >::EPSILON, *headArg);
 	automaton.addTransition(*tailArg, string::Epsilon < >::EPSILON, tail);
 
@@ -79,25 +79,25 @@ void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpAlternation <
 	tailArg = &(*automaton.getStates().find(tail));
 }
 
-void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpConcatenation < alphabet::Symbol > & concatenation, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	concatenation.getLeftElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
-	const label::Label* leftHead = headArg;
-	const label::Label* leftTail = tailArg;
+void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpConcatenation < DefaultSymbolType > & concatenation, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	concatenation.getLeftElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
+	const DefaultStateType* leftHead = headArg;
+	const DefaultStateType* leftTail = tailArg;
 
-	concatenation.getRightElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+	concatenation.getRightElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 	automaton.addTransition(*leftTail, string::Epsilon < >::EPSILON, *headArg);
 
 	headArg = &(*automaton.getStates().find(*leftHead));
 	// tailArg = tailArg;
 }
 
-void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpIteration < alphabet::Symbol > & iteration, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpIteration < DefaultSymbolType > & iteration, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
-	iteration.getElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+	iteration.getElement().accept < void, ToAutomatonThompson::Formal, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 	automaton.addTransition(head, string::Epsilon < >::EPSILON, *headArg);
 	automaton.addTransition(head, string::Epsilon < >::EPSILON, tail);
 	automaton.addTransition(*tailArg, string::Epsilon < >::EPSILON, tail);
@@ -107,9 +107,9 @@ void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpIteration < al
 	tailArg = &(*automaton.getStates().find(tail));
 }
 
-void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpSymbol < alphabet::Symbol > & symbol, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpSymbol < DefaultSymbolType > & symbol, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
@@ -118,9 +118,9 @@ void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpSymbol < alpha
 	tailArg = &(*automaton.getStates().find(tail));
 }
 
-void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpEpsilon < alphabet::Symbol > &, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpEpsilon < DefaultSymbolType > &, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
@@ -129,9 +129,9 @@ void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpEpsilon < alph
 	tailArg = &(*automaton.getStates().find(tail));
 }
 
-void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpEmpty < alphabet::Symbol > &, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpEmpty < DefaultSymbolType > &, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
@@ -141,14 +141,14 @@ void ToAutomatonThompson::Formal::visit(const regexp::FormalRegExpEmpty < alphab
 
 // ----------------------------------------------------------------------------
 
-void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpAlternation < alphabet::Symbol > & alternation, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpAlternation < DefaultSymbolType > & alternation, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
 	for(const auto& element : alternation.getElements()) {
-		element->accept < void, ToAutomatonThompson::Unbounded, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+		element->accept < void, ToAutomatonThompson::Unbounded, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 		automaton.addTransition(head, string::Epsilon < >::EPSILON, *headArg);
 		automaton.addTransition(*tailArg, string::Epsilon < >::EPSILON, tail);
 	}
@@ -157,10 +157,10 @@ void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpAlternat
 	tailArg = &(*automaton.getStates().find(tail));
 }
 
-void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpConcatenation < alphabet::Symbol > & concatenation, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	std::vector<std::pair<const label::Label*, const label::Label*>> tails;
+void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpConcatenation < DefaultSymbolType > & concatenation, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	std::vector<std::pair<const DefaultStateType*, const DefaultStateType*>> tails;
 	for(const auto& element : concatenation.getElements()) {
-		element->accept < void, ToAutomatonThompson::Unbounded, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+		element->accept < void, ToAutomatonThompson::Unbounded, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 		tails.push_back(std::make_pair(headArg, tailArg));
 	}
 
@@ -171,13 +171,13 @@ void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpConcaten
 	tailArg = tails[tails.size()-1].second;
 }
 
-void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpIteration < alphabet::Symbol > & iteration, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpIteration < DefaultSymbolType > & iteration, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
-	iteration.getElement().accept < void, ToAutomatonThompson::Unbounded, automaton::EpsilonNFA < > &, int &, const label::Label * &, const label::Label * & >(automaton, nextState, headArg, tailArg);
+	iteration.getElement().accept < void, ToAutomatonThompson::Unbounded, automaton::EpsilonNFA < > &, int &, const DefaultStateType * &, const DefaultStateType * & >(automaton, nextState, headArg, tailArg);
 	automaton.addTransition(head, string::Epsilon < >::EPSILON, *headArg);
 	automaton.addTransition(head, string::Epsilon < >::EPSILON, tail);
 	automaton.addTransition(*tailArg, string::Epsilon < >::EPSILON, tail);
@@ -187,9 +187,9 @@ void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpIteratio
 	tailArg = &(*automaton.getStates().find(tail));
 }
 
-void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpSymbol < alphabet::Symbol > & symbol, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpSymbol < DefaultSymbolType > & symbol, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
@@ -198,9 +198,9 @@ void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpSymbol <
 	tailArg = &(*automaton.getStates().find(tail));
 }
 
-void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpEpsilon < alphabet::Symbol > &, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpEpsilon < DefaultSymbolType > &, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
@@ -209,9 +209,9 @@ void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpEpsilon
 	tailArg = &(*automaton.getStates().find(tail));
 }
 
-void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpEmpty < alphabet::Symbol > &, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg) {
-	label::Label head = label::Label(nextState++);
-	label::Label tail = label::Label(nextState++);
+void ToAutomatonThompson::Unbounded::visit(const regexp::UnboundedRegExpEmpty < DefaultSymbolType > &, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg) {
+	DefaultStateType head = DefaultStateType(nextState++);
+	DefaultStateType tail = DefaultStateType(nextState++);
 	automaton.addState(head);
 	automaton.addState(tail);
 
diff --git a/alib2algo/src/regexp/convert/ToAutomatonThompson.h b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
index 1772e3e5aa74d5fac9ed47e62137d93c032108ba..4438a02e11c35ab0da72d3717539e881a79312cf 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonThompson.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
@@ -43,22 +43,22 @@ public:
 
 	class Unbounded {
 	public:
-		static void visit(const regexp::UnboundedRegExpAlternation < alphabet::Symbol > & alternation, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::UnboundedRegExpConcatenation < alphabet::Symbol > & concatenation, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::UnboundedRegExpIteration < alphabet::Symbol > & iteration, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::UnboundedRegExpSymbol < alphabet::Symbol > & symbol, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::UnboundedRegExpEpsilon < alphabet::Symbol > & epsilon, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::UnboundedRegExpEmpty < alphabet::Symbol > & empty, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
+		static void visit(const regexp::UnboundedRegExpAlternation < DefaultSymbolType > & alternation, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::UnboundedRegExpConcatenation < DefaultSymbolType > & concatenation, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::UnboundedRegExpIteration < DefaultSymbolType > & iteration, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::UnboundedRegExpSymbol < DefaultSymbolType > & symbol, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::UnboundedRegExpEpsilon < DefaultSymbolType > & epsilon, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::UnboundedRegExpEmpty < DefaultSymbolType > & empty, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
 	};
 
 	class Formal {
 	public:
-		static void visit(const regexp::FormalRegExpAlternation < alphabet::Symbol > & alternation, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::FormalRegExpConcatenation < alphabet::Symbol > & concatenation, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::FormalRegExpIteration < alphabet::Symbol > & iteration, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::FormalRegExpSymbol < alphabet::Symbol > & symbol, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::FormalRegExpEpsilon < alphabet::Symbol > & epsilon, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
-		static void visit(const regexp::FormalRegExpEmpty < alphabet::Symbol > & empty, automaton::EpsilonNFA < > & automaton , int & nextState, const label::Label * & headArg, const label::Label * & tailArg);
+		static void visit(const regexp::FormalRegExpAlternation < DefaultSymbolType > & alternation, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::FormalRegExpConcatenation < DefaultSymbolType > & concatenation, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::FormalRegExpIteration < DefaultSymbolType > & iteration, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::FormalRegExpSymbol < DefaultSymbolType > & symbol, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::FormalRegExpEpsilon < DefaultSymbolType > & epsilon, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
+		static void visit(const regexp::FormalRegExpEmpty < DefaultSymbolType > & empty, automaton::EpsilonNFA < > & automaton , int & nextState, const DefaultStateType * & headArg, const DefaultStateType * & tailArg);
 	};
 
 };