diff --git a/alib2algo/src/automaton/determinize/Determinize.cpp b/alib2algo/src/automaton/determinize/Determinize.cpp
index b1813a529ccdcc35d7d579aaa70801bd8cacb38c..0673643be40811eb9def9de5db37cd4c59347bf3 100644
--- a/alib2algo/src/automaton/determinize/Determinize.cpp
+++ b/alib2algo/src/automaton/determinize/Determinize.cpp
@@ -6,8 +6,6 @@
  */
 
 #include "Determinize.h"
-#include <automaton/transform/PDAToRHPDA.h>
-#include <automaton/transform/RHPDAToPDA.h>
 #include <automaton/FSM/DFA.h>
 #include <automaton/FSM/MultiInitialStateNFA.h>
 #include <automaton/PDA/DPDA.h>
@@ -28,58 +26,37 @@ namespace determinize {
 
 auto DeterminizeDFA = registration::AbstractRegister < Determinize, automaton::DFA < >, const automaton::DFA < > & > ( Determinize::determinize );
 
-DPDA < > Determinize::determinize(const automaton::DPDA < > & automaton) {
-	return automaton;
-}
+auto DeterminizeNFA = registration::AbstractRegister < Determinize, automaton::DFA < DefaultSymbolType, ext::set < DefaultStateType > >, const automaton::NFA < > & > ( Determinize::determinize );
 
-auto DeterminizeDPDA = registration::AbstractRegister < Determinize, automaton::DPDA < >, const automaton::DPDA < > & > ( Determinize::determinize );
+auto DeterminizeMultiInitialStateNFA = registration::AbstractRegister < Determinize, automaton::DFA < DefaultSymbolType, ext::set < DefaultStateType > >, const automaton::MultiInitialStateNFA < > & > ( Determinize::determinize );
 
-SinglePopDPDA < > Determinize::determinize(const automaton::SinglePopDPDA < > & automaton) {
-	return automaton;
-}
 
-auto DeterminizeSinglePopDPDA = registration::AbstractRegister < Determinize, automaton::SinglePopDPDA < >, const automaton::SinglePopDPDA < > & > ( Determinize::determinize );
+auto DeterminizeDFTA = registration::AbstractRegister < Determinize, automaton::DFTA < >, const automaton::DFTA < > & > ( Determinize::determinize );
+
+auto DeterminizeNFTA = registration::AbstractRegister < Determinize, automaton::DFTA < DefaultSymbolType, DefaultRankType, ext::set < DefaultSymbolType > >, const automaton::NFTA < > & > ( Determinize::determinize );
+
 
 auto DeterminizeInputDrivenDPDA = registration::AbstractRegister < Determinize, automaton::InputDrivenDPDA < >, const automaton::InputDrivenDPDA < > & > ( Determinize::determinize );
 
-VisiblyPushdownDPDA < > Determinize::determinize(const automaton::VisiblyPushdownDPDA < > & automaton) {
-	return automaton;
-}
+auto DeterminizeInputDrivenNPDA = registration::AbstractRegister < Determinize, automaton::InputDrivenDPDA < DefaultSymbolType, DefaultSymbolType, ext::set < DefaultStateType > >, const automaton::InputDrivenNPDA < > & > ( Determinize::determinize );
+
 
 auto DeterminizeVisiblyPushdownDPDA = registration::AbstractRegister < Determinize, automaton::VisiblyPushdownDPDA < >, const automaton::VisiblyPushdownDPDA < > & > ( Determinize::determinize );
 
-RealTimeHeightDeterministicDPDA < > Determinize::determinize(const automaton::RealTimeHeightDeterministicDPDA < > & automaton) {
-	return automaton;
-}
 
 auto DeterminizeRealTimeHeightDeterministicDPDA = registration::AbstractRegister < Determinize, automaton::RealTimeHeightDeterministicDPDA < >, const automaton::RealTimeHeightDeterministicDPDA < > & > ( Determinize::determinize );
 
-DPDA < > Determinize::determinize(const automaton::NPDA < > & automaton) {
-	automaton::RealTimeHeightDeterministicNPDA < > rhpda = automaton::PDAToRHPDA::convert(automaton);
-	automaton::RealTimeHeightDeterministicDPDA < > dpda = Determinize::determinize(rhpda);
-	return automaton::RHPDAToPDA::convert(dpda);
-}
-
-auto DeterminizeNPDA = registration::AbstractRegister < Determinize, automaton::DPDA < >, const automaton::NPDA < > & > ( Determinize::determinize );
 
-OneTapeDTM<> Determinize::determinize(const automaton::OneTapeDTM<>& automaton) {
-	return automaton;
-}
-
-auto DeterminizeOneTapeDTM = registration::AbstractRegister < Determinize, automaton::OneTapeDTM < >, const automaton::OneTapeDTM < > & > ( Determinize::determinize );
+auto DeterminizeSinglePopDPDA = registration::AbstractRegister < Determinize, automaton::SinglePopDPDA < >, const automaton::SinglePopDPDA < > & > ( Determinize::determinize );
 
-DFTA < > Determinize::determinize(const automaton::DFTA < > & automaton) {
-	return automaton;
-}
 
-auto DeterminizeDFTA = registration::AbstractRegister < Determinize, automaton::DFTA < >, const automaton::DFTA < > & > ( Determinize::determinize );
+auto DeterminizeDPDA = registration::AbstractRegister < Determinize, automaton::DPDA < >, const automaton::DPDA < > & > ( Determinize::determinize );
 
+auto DeterminizeNPDA = registration::AbstractRegister < Determinize, automaton::DPDA < >, const automaton::NPDA < > & > ( Determinize::determinize );
 
 
-auto DeterminizeMultiInitialStateNFA = registration::AbstractRegister < Determinize, automaton::DFA < DefaultSymbolType, ext::set < DefaultStateType > >, const automaton::MultiInitialStateNFA < > & > ( Determinize::determinize );
-auto DeterminizeNFA = registration::AbstractRegister < Determinize, automaton::DFA < DefaultSymbolType, ext::set < DefaultStateType > >, const automaton::NFA < > & > ( Determinize::determinize );
+auto DeterminizeOneTapeDTM = registration::AbstractRegister < Determinize, automaton::OneTapeDTM < >, const automaton::OneTapeDTM < > & > ( Determinize::determinize );
 
-auto DeterminizeInputDrivenNPDA = registration::AbstractRegister < Determinize, automaton::InputDrivenDPDA < DefaultSymbolType, DefaultSymbolType, ext::set < DefaultStateType > >, const automaton::InputDrivenNPDA < > & > ( Determinize::determinize );
 
 } /* namespace determinize */
 
@@ -87,5 +64,4 @@ auto DeterminizeInputDrivenNPDA = registration::AbstractRegister < Determinize,
 
 #include "DeterminizeVPAPart.cxx"
 #include "DeterminizeRHDPDAPart.cxx"
-#include "DeterminizeNFTAPart.cxx"
 
diff --git a/alib2algo/src/automaton/determinize/Determinize.h b/alib2algo/src/automaton/determinize/Determinize.h
index 1bc68d96f0bcd0fe184cf39c05e219850de0655e..d1e4951a1c2fc32e3b07d2647c1bab0e65af9ea9 100644
--- a/alib2algo/src/automaton/determinize/Determinize.h
+++ b/alib2algo/src/automaton/determinize/Determinize.h
@@ -13,6 +13,9 @@
 #include <automaton/Automaton.h>
 #include <automaton/AutomatonFeatures.h>
 
+#include <automaton/transform/PDAToRHPDA.h>
+#include <automaton/transform/RHPDAToPDA.h>
+
 namespace automaton {
 
 namespace determinize {
@@ -31,16 +34,16 @@ public:
 	 * Runs determinization algorithm on nondeterministic fsm given in constructor.
 	 */
 	template < class SymbolType, class StateType >
-	static automaton::DFA < SymbolType, ext::set < StateType > > determinize(const automaton::NFA < SymbolType, StateType > & nfa);
+	static automaton::DFA < SymbolType, ext::set < StateType > > determinize ( const automaton::NFA < SymbolType, StateType > & nfa );
 
 	template < class SymbolType, class StateType >
-	static automaton::DFA < SymbolType, ext::set < StateType > > determinize(const automaton::MultiInitialStateNFA < SymbolType, StateType > & nfa);
+	static automaton::DFA < SymbolType, ext::set < StateType > > determinize ( const automaton::MultiInitialStateNFA < SymbolType, StateType > & nfa );
+
+	template < class SymbolType, class RankType, class StateType >
+	static automaton::DFTA < SymbolType, RankType, StateType > determinize ( const automaton::DFTA < SymbolType, RankType, StateType > & nfta );
 
-	static automaton::DPDA < > determinize(const automaton::DPDA < > & dpda);
-	static automaton::DPDA < > determinize(const automaton::NPDA < > & dpda);
-	static automaton::SinglePopDPDA < > determinize(const automaton::SinglePopDPDA < > & dpda);
-	static automaton::VisiblyPushdownDPDA < > determinize(const automaton::VisiblyPushdownDPDA < > & nondeterministic);
-	static automaton::VisiblyPushdownDPDA < > determinize(const automaton::VisiblyPushdownNPDA < > & nondeterministic);
+	template < class SymbolType, class RankType, class StateType >
+	static automaton::DFTA < SymbolType, RankType, ext::set < StateType > > determinize ( const automaton::NFTA < SymbolType, RankType, StateType > & nfta );
 
 	template < class InputSymbolType, class PushdownSymbolType, class StateType >
 	static automaton::InputDrivenDPDA < InputSymbolType, PushdownSymbolType, StateType > determinize ( const automaton::InputDrivenDPDA < InputSymbolType, PushdownSymbolType, StateType > & dpda );
@@ -48,12 +51,27 @@ public:
 	template < class InputSymbolType, class PushdownSymbolType, class StateType >
 	static automaton::InputDrivenDPDA < InputSymbolType, PushdownSymbolType, ext::set < StateType > > determinize ( const automaton::InputDrivenNPDA < InputSymbolType, PushdownSymbolType, StateType > & npda );
 
-	static automaton::RealTimeHeightDeterministicDPDA < > determinize(const automaton::RealTimeHeightDeterministicDPDA < > & nondeterministic);
-	static automaton::RealTimeHeightDeterministicDPDA < > determinize(const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic);
-	static automaton::DFTA < > determinize(const automaton::DFTA < > & nfta);
-	static automaton::DFTA < > determinize(const automaton::NFTA < > & nfta);
+	template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
+	static automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > determinize ( const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & nondeterministic );
+
+	static automaton::VisiblyPushdownDPDA < > determinize ( const automaton::VisiblyPushdownNPDA < > & nondeterministic );
+
+	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
+	static automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > determinize ( const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & nondeterministic );
+
+	static automaton::RealTimeHeightDeterministicDPDA < > determinize ( const automaton::RealTimeHeightDeterministicNPDA < > & nondeterministic );
+
+	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
+	static automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > determinize ( const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & dpda );
+
+	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
+	static automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > determinize ( const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & dpda );
+
+	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
+	static automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > determinize ( const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & dpda );
 
-	static automaton::OneTapeDTM<> determinize(const automaton::OneTapeDTM<>& nfta);
+	template < class SymbolType, class StateType >
+	static automaton::OneTapeDTM < SymbolType, StateType > determinize ( const automaton::OneTapeDTM < SymbolType, StateType > & nfta );
 };
 
 template < class SymbolType, class StateType >
@@ -61,16 +79,54 @@ automaton::DFA < SymbolType, StateType > Determinize::determinize ( const automa
 	return automaton;
 }
 
+template < class SymbolType, class RankType, class StateType >
+automaton::DFTA < SymbolType, RankType, StateType > Determinize::determinize ( const automaton::DFTA < SymbolType, RankType, StateType > & automaton ) {
+	return automaton;
+}
+
 template < class InputSymbolType, class PushdownSymbolType, class StateType >
 automaton::InputDrivenDPDA < InputSymbolType, PushdownSymbolType, StateType > Determinize::determinize ( const automaton::InputDrivenDPDA < InputSymbolType, PushdownSymbolType, StateType > & automaton ) {
 	return automaton;
 }
 
+template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
+automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > Determinize::determinize ( const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & automaton ) {
+	return automaton;
+}
+
+template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
+automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > Determinize::determinize ( const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton ) {
+	return automaton;
+}
+
+template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
+automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > Determinize::determinize ( const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton ) {
+	return automaton;
+}
+
+template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
+automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > Determinize::determinize ( const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton ) {
+	return automaton;
+}
+
+template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
+automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > Determinize::determinize ( const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & automaton ) {
+	automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > rhpda = automaton::PDAToRHPDA::convert(automaton);
+	automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > dpda = Determinize::determinize(rhpda);
+	return automaton::RHPDAToPDA::convert ( dpda );
+}
+
+template < class SymbolType, class StateType >
+automaton::OneTapeDTM < SymbolType, StateType > Determinize::determinize ( const automaton::OneTapeDTM < SymbolType, StateType > & automaton ) {
+	return automaton;
+}
+
 } /* namespace determinize */
 
 } /* namespace automaton */
 
 #include "DeterminizeNFAPart.hxx"
 #include "DeterminizeIDPDAPart.hxx"
+#include "DeterminizeNFTAPart.hxx"
 
 #endif /* DETERMINIZE_H_ */
diff --git a/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx
deleted file mode 100644
index 4e2ac96b612408c26212d82c9418234e7365fce9..0000000000000000000000000000000000000000
--- a/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * NFTADeterminizer.cpp
- *
- *  Created on: 30. 3. 2015
- *	  Author: Stepan Plachy
- */
-
-#include "common/NFACommon.h"
-
-#include <automaton/TA/NFTA.h>
-#include <alib/deque>
-#include <alib/algorithm>
-
-namespace automaton {
-
-namespace determinize {
-
-ext::set<DefaultStateType> getTransitionRightSide(const NFTA < > & nfta, const common::ranked_symbol < > & symbol, const ext::vector<DefaultStateType> & states) {
-	ext::set<DefaultStateType> res;
-	for (const auto & transition : nfta.getTransitions()) {
-		if (transition.first.first != symbol) continue;
-
-		unsigned i = ( unsigned ) symbol.getRank();
-		for (; i > 0; i--)
-			if (!recreateNFAStates(states[i - 1]).count(transition.first.second[i - 1])) break;
-
-		if (i == 0) res.insert(transition.second.begin(), transition.second.end());
-	}
-	return res;
-}
-
-DFTA < > Determinize::determinize(const NFTA < > & nfta) {
-	DFTA < > res;
-	res.setInputAlphabet(nfta.getInputAlphabet());
-	for (const auto & state : nfta.getStates()) res.addState(createDFAState({state}));
-	for (const auto & state : nfta.getFinalStates()) res.addFinalState(createDFAState({state}));
-
-	ext::deque<DefaultStateType> todo;
-
-	//ext::map<std::pair<common::ranked_symbol < >, ext::vector<DefaultStateType> >, ext::set<DefaultStateType> > transitions;
-	for (const auto & transition : nfta.getTransitions()) {
-		DefaultStateType state = createDFAState(transition.second);
-		ext::vector<DefaultStateType> states;
-		for (const auto & s : transition.first.second) states.push_back(createDFAState({s}));
-		if (transition.second.size() > 1 && res.addState(state)) todo.push_back(state);
-		res.addTransition(transition.first.first, states, state);
-	}
-	
-	while(!todo.empty()) {
-		DefaultStateType currentState = todo.front();
-		todo.pop_front();
-		ext::set<DefaultStateType> nftaStates = recreateNFAStates(currentState);
-
-		ext::deque<std::pair<std::pair<common::ranked_symbol < >, ext::vector<DefaultStateType> >, DefaultStateType> > transitions;
-		ext::deque<unsigned> stops;
-		for (const auto & transition : res.getTransitions()) {
-			transitions.push_back(transition);
-			stops.push_back(0);
-		}
-
-		while(!transitions.empty()) {
-			auto transition = transitions.front();
-			unsigned stop = stops.front();
-			transitions.pop_front();
-			stops.pop_front();
-			const ext::vector<DefaultStateType> & states = transition.first.second;
-
-			for (unsigned i = stop; i < states.size(); i++) {
-				if (recreateNFAStates(states[i]).size() != 1) continue;
-				DefaultStateType nftaState = *recreateNFAStates(states[i]).begin();
-				if (nftaStates.count(nftaState)) {
-					ext::vector<DefaultStateType> newStates = states;
-					newStates[i] = currentState;
-					
-					ext::set<DefaultStateType> newNextStates = getTransitionRightSide(nfta, transition.first.first, newStates);
-					if (!newNextStates.empty()) {
-						DefaultStateType newNextState = createDFAState(newNextStates);
-						if (res.addState(newNextState)) todo.push_back(newNextState);
-						if (res.addTransition(transition.first.first, newStates, newNextState) && i + 1!= states.size()) {
-							transitions.push_back(ext::make_pair(ext::make_pair(transition.first.first, newStates), newNextState));
-							stops.push_back(i + 1);
-						}
-					}
-				}
-			}
-		}
-
-		for (const auto & state : nftaStates) {
-			if (nfta.getFinalStates().count(state)) {res.addFinalState(currentState); break;}
-		}
-
-	}
-
-	return res;
-}
-
-auto DeterminizeNFTA = registration::AbstractRegister < Determinize, automaton::DFTA < >, const automaton::NFTA < > & > ( Determinize::determinize );
-
-} /* namespace determinize */
-
-} /* namespace automaton */
diff --git a/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.hxx b/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.hxx
new file mode 100644
index 0000000000000000000000000000000000000000..cc8a380bcc8056de2a52f7406e0ec601e81aeed8
--- /dev/null
+++ b/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.hxx
@@ -0,0 +1,122 @@
+/*
+ * NFTADeterminizer.hxx
+ *
+ *  Created on: 30. 3. 2015
+ *	  Author: Stepan Plachy
+ */
+
+#include "common/NFACommon.h"
+
+#include <automaton/TA/NFTA.h>
+#include <alib/deque>
+#include <alib/algorithm>
+
+namespace automaton {
+
+namespace determinize {
+
+template < class SymbolType, class RankType, class StateType >
+ext::set < StateType > getTransitionRightSide ( const NFTA < SymbolType, RankType, StateType > & nfta, const common::ranked_symbol < SymbolType, RankType > & symbol, const ext::vector< ext::set < StateType > > & states ) {
+	ext::set < StateType > res;
+
+	for ( const auto & transition : nfta.getTransitions ( ) ) {
+		if ( transition.first.first != symbol )
+			continue;
+
+		unsigned i = ( unsigned ) symbol.getRank ( );
+		for ( ; i > 0; --i )
+			if ( ! states [ i - 1 ].count ( transition.first.second [ i - 1 ] ) )
+				break;
+
+		if ( i == 0 )
+			res.insert ( transition.second.begin ( ), transition.second.end ( ) );
+	}
+
+	return res;
+}
+
+template < class SymbolType, class RankType, class StateType >
+automaton::DFTA < SymbolType, RankType, ext::set < StateType > > Determinize::determinize ( const NFTA < SymbolType, RankType, StateType > & nfta ) {
+	automaton::DFTA < SymbolType, RankType, ext::set < StateType > > res;
+
+	res.setInputAlphabet ( nfta.getInputAlphabet ( ) );
+	for ( const auto & state : nfta.getStates ( ) )
+		res.addState ( { state } );
+
+	for ( const auto & state : nfta.getFinalStates ( ) )
+		res.addFinalState ( { state } );
+
+	ext::deque < ext::set < StateType > > todo;
+
+	for ( const auto & transition : nfta.getTransitions ( ) ) {
+		ext::set < StateType > state = transition.second;
+		ext::vector < ext::set < StateType > > states;
+
+		for ( const auto & s : transition.first.second )
+			states.push_back ( { s } );
+
+		if ( transition.second.size ( ) > 1 && res.addState ( state ) )
+			todo.push_back ( state );
+
+		res.addTransition ( transition.first.first, states, state );
+	}
+
+	while ( ! todo.empty ( ) ) {
+		ext::set < StateType > currentState = todo.front();
+		todo.pop_front();
+
+		ext::deque < std::pair < std::pair < common::ranked_symbol < SymbolType, RankType >, ext::vector < ext::set < StateType > > >, ext::set < StateType > > > transitions;
+		ext::deque < unsigned > stops;
+
+		for ( const auto & transition : res.getTransitions ( ) ) {
+			transitions.push_back ( transition );
+			stops.push_back ( 0 );
+		}
+
+		while ( ! transitions.empty ( ) ) {
+			auto transition = transitions.front ( );
+			transitions.pop_front ( );
+
+			unsigned stop = stops.front ( );
+			stops.pop_front ( );
+
+			const ext::vector < ext::set < StateType > > & states = transition.first.second;
+
+			for ( unsigned i = stop; i < states.size ( ); ++i ) {
+				if ( states [ i ].size ( ) != 1 )
+					continue;
+
+				StateType nftaState = * states [ i ].begin ( );
+				if ( currentState.count ( nftaState ) ) {
+					ext::vector < ext::set < StateType > > newStates = states;
+					newStates [ i ] = currentState;
+
+					ext::set < StateType > newNextState = getTransitionRightSide ( nfta, transition.first.first, newStates );
+					if ( ! newNextState.empty ( ) ) {
+						if ( res.addState ( newNextState ) )
+							todo.push_back ( newNextState );
+
+						if ( res.addTransition ( transition.first.first, newStates, newNextState ) && i + 1 != states.size ( ) ) {
+							transitions.push_back ( ext::make_pair ( ext::make_pair ( transition.first.first, newStates ), newNextState ) );
+							stops.push_back(i + 1);
+						}
+					}
+				}
+			}
+		}
+
+		for ( const auto & state : currentState ) {
+			if ( nfta.getFinalStates ( ).count ( state ) ) {
+				res.addFinalState ( currentState );
+				break;
+			}
+		}
+
+	}
+
+	return res;
+}
+
+} /* namespace determinize */
+
+} /* namespace automaton */
diff --git a/alib2algo/test-src/automaton/determinize/determinizeTest.cpp b/alib2algo/test-src/automaton/determinize/determinizeTest.cpp
index c06a192ca2775b23a0e698bacd17f3bb3847d894..169f695eecf51d631dca6991d3abb3ca1c16ddb2 100644
--- a/alib2algo/test-src/automaton/determinize/determinizeTest.cpp
+++ b/alib2algo/test-src/automaton/determinize/determinizeTest.cpp
@@ -106,32 +106,32 @@ void determinizeTest::testDeterminizeVPA() {
 }
 
 void determinizeTest::testDeterminizeNFTA() {
-  automaton::NFTA < > automaton;
+  automaton::NFTA < char, unsigned, int> automaton;
 
-  const common::ranked_symbol < > a (DefaultSymbolType('a'), DefaultRankType(2));
-  const common::ranked_symbol < > b (DefaultSymbolType('b'), DefaultRankType(1));
-  const common::ranked_symbol < > c (DefaultSymbolType('c'), DefaultRankType(0));
-  const ext::set<common::ranked_symbol < > > alphabet {a, b, c};
+  const common::ranked_symbol < char, unsigned > a ('a', 2);
+  const common::ranked_symbol < char, unsigned > b ('b', 1);
+  const common::ranked_symbol < char, unsigned > c ('c', 0);
+  const ext::set<common::ranked_symbol < char, unsigned > > alphabet {a, b, c};
   automaton.setInputAlphabet(alphabet);
 
-  automaton.addState(DefaultStateType(1));
-  automaton.addState(DefaultStateType(2));
-  automaton.addState(DefaultStateType(3));
+  automaton.addState(1);
+  automaton.addState(2);
+  automaton.addState(3);
 
-  ext::vector<DefaultStateType> a1States = {DefaultStateType(1), DefaultStateType(3)};
-  automaton.addTransition(a, a1States, DefaultStateType(1));
-  automaton.addTransition(a, a1States, DefaultStateType(3));
-  ext::vector<DefaultStateType> a2States = {DefaultStateType(3), DefaultStateType(3)};
-  automaton.addTransition(a, a2States, DefaultStateType(2));
-  ext::vector<DefaultStateType> bStates = {DefaultStateType(2)};
-  automaton.addTransition(b, bStates, DefaultStateType(1));
-  ext::vector<DefaultStateType> cStates;
-  automaton.addTransition(c, cStates, DefaultStateType(3));
+  ext::vector<int> a1States = {1, 3};
+  automaton.addTransition(a, a1States, 1);
+  automaton.addTransition(a, a1States, 3);
+  ext::vector<int> a2States = {3, 3};
+  automaton.addTransition(a, a2States, 2);
+  ext::vector<int> bStates = {2};
+  automaton.addTransition(b, bStates, 1);
+  ext::vector<int> cStates;
+  automaton.addTransition(c, cStates, 3);
 
-  automaton.addFinalState(DefaultStateType(3));
+  automaton.addFinalState(3);
 
 
-  automaton::DFTA < > determinized = automaton::determinize::Determinize::determinize(automaton);
+  automaton::DFTA < char, unsigned, ext::set < int > > determinized = automaton::determinize::Determinize::determinize(automaton);
 
   CPPUNIT_ASSERT(determinized.getStates().size() == 5);
   CPPUNIT_ASSERT(determinized.getFinalStates().size() == 3);