diff --git a/aconvert2/src/DotConverter.cpp b/aconvert2/src/DotConverter.cpp
index 3e8fadcac87901de2bc7294eaf95a0e68d9807c5..c64c1bd9b4955d79bbddf22889b75dfec7665039 100644
--- a/aconvert2/src/DotConverter.cpp
+++ b/aconvert2/src/DotConverter.cpp
@@ -29,7 +29,7 @@ void DotConverter::convert(const automaton::Automaton& a, std::ostream& out) {
 }
 
 void DotConverter::convert(const automaton::UnknownAutomaton& a, std::ostream& out) {
-
+	// TODO
 }
 
 void DotConverter::convert(const automaton::EpsilonNFA& a, std::ostream& out) {
@@ -374,9 +374,11 @@ void DotConverter::transitions(const automaton::DFA& fsm, const std::map<automat
 }
 
 void DotConverter::transitions(const automaton::ExtendedNFA& fsm, const std::map<automaton::State, int>& states, std::ostream& out) {
+	// TODO
 }
 
 void DotConverter::transitions(const automaton::CompactNFA& fsm, const std::map<automaton::State, int>& states, std::ostream& out) {
+	// TODO
 }
 
 void DotConverter::transitions(const automaton::NPDA& pda, const std::map<automaton::State, int>& states, std::ostream& out) {
@@ -442,9 +444,11 @@ void DotConverter::transitions(const automaton::NPDA& pda, const std::map<automa
 }
 
 void DotConverter::transitions(const automaton::SinglePopNPDA& fsm, const std::map<automaton::State, int>& states, std::ostream& out) {
+	// TODO
 }
 
 void DotConverter::transitions(const automaton::OneTapeDTM& tm, const std::map<automaton::State, int>& states, std::ostream& out) {
+	// TODO
 	/*map<pair<int, int>, string> transitions;
 	const set<TransitionTM>& t = tm.getTransitions();
 
diff --git a/aconvert2/src/GasTexConverter.cpp b/aconvert2/src/GasTexConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69224ebacca95e3c1928c6f4dbbed164cf21f642
--- /dev/null
+++ b/aconvert2/src/GasTexConverter.cpp
@@ -0,0 +1,547 @@
+/*
+ * GasTexConverter.cpp
+ *
+ *  Created on: Jan 1, 2014
+ *      Author: Martin Zak
+ */
+
+#include "GasTexConverter.h"
+
+#include <automaton/FSM/NFA.h>
+#include <automaton/FSM/EpsilonNFA.h>
+#include <automaton/FSM/DFA.h>
+#include <automaton/FSM/ExtendedNFA.h>
+#include <automaton/FSM/CompactNFA.h>
+#include <automaton/PDA/NPDA.h>
+#include <automaton/PDA/SinglePopNPDA.h>
+#include <automaton/TM/OneTapeDTM.h>
+
+#include <set>
+#include <map>
+#include <typeinfo>
+#include "exception/AlibException.h"
+
+void GasTexConverter::convert(const automaton::Automaton& a, std::ostream& out) {
+	a.getData().Accept((void*) &out, GasTexConverter::instance);
+}
+
+void GasTexConverter::convert(const automaton::UnknownAutomaton& a, std::ostream& out) {
+	//TODO
+}
+
+void GasTexConverter::convert(const automaton::EpsilonNFA& a, std::ostream& out) {
+	out << "\\begin{center}\n";
+	out << "\\begin{picture}(,)(,)\n";
+
+	for (auto& state : a.getStates()) {
+		bool initial = false;
+		bool final = false;
+
+		if(a.getInitialStates().count(state)){
+			initial = true;
+		}
+		if(a.getFinalStates().count(state)){
+			final = true;
+		}
+
+		if(initial || final) {
+			out << "\\node[Nmarks=";
+			if(initial){
+				out << "i";
+			}
+			if(final){
+				out << "r";
+			}
+			out<<"](";
+		} else {
+			out <<"\\node(";
+		}
+
+		out << state.getName();
+		out << ")(,){";
+		out << state.getName();
+		out << "}\n";
+	}
+
+	transitions(a, out);
+	out << "\\end{center}\n";
+	out << "\\end{picture}\n";
+}
+
+void GasTexConverter::convert(const automaton::NFA& a, std::ostream& out) {
+	out << "\\begin{center}\n";
+	out << "\\begin{picture}(,)(,)\n";
+
+	for (auto& state : a.getStates()) {
+		bool initial = false;
+		bool final = false;
+
+		if(a.getInitialStates().count(state)){
+			initial = true;
+		}
+		if(a.getFinalStates().count(state)){
+			final = true;
+		}
+
+		if(initial || final) {
+			out << "\\node[Nmarks=";
+			if(initial){
+				out << "i";
+			}
+			if(final){
+				out << "r";
+			}
+			out<<"](";
+		} else {
+			out <<"\\node(";
+		}
+
+		out << state.getName();
+		out << ")(,){";
+		out << state.getName();
+		out << "}\n";
+	}
+
+	transitions(a, out);
+	out << "\\end{center}\n";
+	out << "\\end{picture}\n";
+}
+
+void GasTexConverter::convert(const automaton::DFA& a, std::ostream& out) {
+	out << "\\begin{center}\n";
+	out << "\\begin{picture}(,)(,)\n";
+
+	for (auto& state : a.getStates()) {
+		bool initial = false;
+		bool final = false;
+
+		if(a.getInitialState() == state){
+			initial = true;
+		}
+		if(a.getFinalStates().count(state)){
+			final = true;
+		}
+
+		if(initial || final) {
+			out << "\\node[Nmarks=";
+			if(initial){
+				out << "i";
+			}
+			if(final){
+				out << "r";
+			}
+			out<<"](";
+		} else {
+			out <<"\\node(";
+		}
+
+		out << state.getName();
+		out << ")(,){";
+		out << state.getName();
+		out << "}\n";
+	}
+
+	transitions(a, out);
+	out << "\\end{center}\n";
+	out << "\\end{picture}\n";
+}
+
+void GasTexConverter::convert(const automaton::ExtendedNFA& a, std::ostream& out) {
+	out << "\\begin{center}\n";
+	out << "\\begin{picture}(,)(,)\n";
+
+	for (auto& state : a.getStates()) {
+		bool initial = false;
+		bool final = false;
+
+		if(a.getInitialStates().count(state)){
+			initial = true;
+		}
+		if(a.getFinalStates().count(state)){
+			final = true;
+		}
+
+		if(initial || final) {
+			out << "\\node[Nmarks=";
+			if(initial){
+				out << "i";
+			}
+			if(final){
+				out << "r";
+			}
+			out<<"](";
+		} else {
+			out <<"\\node(";
+		}
+
+		out << state.getName();
+		out << ")(,){";
+		out << state.getName();
+		out << "}\n";
+	}
+
+	transitions(a, out);
+	out << "\\end{center}\n";
+	out << "\\end{picture}\n";
+}
+
+void GasTexConverter::convert(const automaton::CompactNFA& a, std::ostream& out) {
+	out << "\\begin{center}\n";
+	out << "\\begin{picture}(,)(,)\n";
+
+	for (auto& state : a.getStates()) {
+		bool initial = false;
+		bool final = false;
+
+		if(a.getInitialStates().count(state)){
+			initial = true;
+		}
+		if(a.getFinalStates().count(state)){
+			final = true;
+		}
+
+		if(initial || final) {
+			out << "\\node[Nmarks=";
+			if(initial){
+				out << "i";
+			}
+			if(final){
+				out << "r";
+			}
+			out<<"](";
+		} else {
+			out <<"\\node(";
+		}
+
+		out << state.getName();
+		out << ")(,){";
+		out << state.getName();
+		out << "}\n";
+	}
+
+	transitions(a, out);
+	out << "\\end{center}\n";
+	out << "\\end{picture}\n";
+}
+
+void GasTexConverter::convert(const automaton::NPDA& a, std::ostream& out) {
+	out << "\\begin{center}\n";
+	out << "\\begin{picture}(,)(,)\n";
+
+	for (auto& state : a.getStates()) {
+		bool initial = false;
+		bool final = false;
+
+		if(a.getInitialStates().count(state)){
+			initial = true;
+		}
+		if(a.getFinalStates().count(state)){
+			final = true;
+		}
+
+		if(initial || final) {
+			out << "\\node[Nmarks=";
+			if(initial){
+				out << "i";
+			}
+			if(final){
+				out << "r";
+			}
+			out<<"](";
+		} else {
+			out <<"\\node(";
+		}
+
+		out << state.getName();
+		out << ")(,){";
+		out << state.getName();
+		out << "}\n";
+	}
+
+	transitions(a, out);
+	out << "\\end{center}\n";
+	out << "\\end{picture}\n";
+}
+
+void GasTexConverter::convert(const automaton::SinglePopNPDA& a, std::ostream& out) {
+	out << "\\begin{center}\n";
+	out << "\\begin{picture}(,)(,)\n";
+
+	for (auto& state : a.getStates()) {
+		bool initial = false;
+		bool final = false;
+
+		if(a.getInitialStates().count(state)){
+			initial = true;
+		}
+		if(a.getFinalStates().count(state)){
+			final = true;
+		}
+
+		if(initial || final) {
+			out << "\\node[Nmarks=";
+			if(initial){
+				out << "i";
+			}
+			if(final){
+				out << "r";
+			}
+			out<<"](";
+		} else {
+			out <<"\\node(";
+		}
+
+		out << state.getName();
+		out << ")(,){";
+		out << state.getName();
+		out << "}\n";
+	}
+
+	transitions(a, out);
+	out << "\\end{center}\n";
+	out << "\\end{picture}\n";
+}
+
+void GasTexConverter::convert(const automaton::OneTapeDTM& a, std::ostream& out) {
+	out << "\\begin{center}\n";
+	out << "\\begin{picture}(,)(,)\n";
+
+	for (auto& state : a.getStates()) {
+		bool initial = false;
+		bool final = false;
+
+		if(a.getInitialState() == state){
+			initial = true;
+		}
+		if(a.getFinalStates().count(state)){
+			final = true;
+		}
+
+		if(initial || final) {
+			out << "\\node[Nmarks=";
+			if(initial){
+				out << "i";
+			}
+			if(final){
+				out << "r";
+			}
+			out<<"](";
+		} else {
+			out <<"\\node(";
+		}
+
+		out << state.getName();
+		out << ")(,){";
+		out << state.getName();
+		out << "}\n";
+	}
+
+	transitions(a, out);
+	out << "\\end{center}\n";
+	out << "\\end{picture}\n";
+}
+
+std::string GasTexConverter::getStackSymbols(const std::list<alphabet::Symbol>& stackSymbols) {
+	if (stackSymbols.size() == 0) {
+		return "$\\varepsilon$";
+	}
+
+	std::string symbols = "";
+	int i=0;
+	for (const auto& symbol : stackSymbols) {
+		if(i++ !=0) {
+			symbols +=" ";
+		}
+		symbols += (std::string) symbol.getData();
+	}
+	return symbols;
+}
+
+void GasTexConverter::printTransitionMap(const std::map<std::pair<std::string, std::string>, std::string> transitionMap, std::ostream& out) {
+	for (const auto& transition : transitionMap) {
+		std::string from = transition.first.first;
+		std::string to = transition.first.second;
+		std::string symbols = transition.second;
+
+		if (from == to) {
+			out << "\\drawloop(";
+			out << from;
+			out << "){";
+			out << symbols;
+			out << "}\n";
+
+		} else {
+			out << "\\drawedge(";
+			out << from;
+			out << ",";
+			out << to;
+			out << "){";
+			out << symbols;
+			out << "}\n";
+		}
+	}
+}
+
+void GasTexConverter::transitions(const automaton::EpsilonNFA& fsm, std::ostream& out) {
+	std::map<std::pair<std::string, std::string>, std::string> transitionMap;
+	for (const auto& transition : fsm.getTransitions()) {
+		for(const auto& to : transition.second) {
+			std::pair<std::string, std::string> key(transition.first.first.getName(), to.getName());
+
+			std::string symbol;
+			if (transition.first.second.is<string::Epsilon>()) {
+				symbol = "$\\varepsilon$";
+			} else {
+				symbol = (std::string) transition.first.second.get<alphabet::Symbol>();
+			}
+
+			auto mapIterator = transitionMap.find(key);
+			if (mapIterator == transitionMap.end()) {
+				transitionMap.insert(make_pair(key, symbol));
+			} else {
+				mapIterator->second += ", " + symbol;
+			}
+		}
+	}
+	printTransitionMap(transitionMap, out);
+}
+
+void GasTexConverter::transitions(const automaton::NFA& fsm, std::ostream& out) {
+	std::map<std::pair<std::string, std::string>, std::string> transitionMap;
+	for (const auto& transition : fsm.getTransitions()) {
+		for(const auto& to : transition.second) {
+			std::pair<std::string, std::string> key(transition.first.first.getName(), to.getName());
+
+			std::string symbol = (std::string) transition.first.second;
+
+			auto mapIterator = transitionMap.find(key);
+			if (mapIterator == transitionMap.end()) {
+				transitionMap.insert(make_pair(key, symbol));
+			} else {
+				mapIterator->second += ", " + symbol;
+			}
+		}
+	}
+	printTransitionMap(transitionMap, out);
+}
+
+void GasTexConverter::transitions(const automaton::DFA& fsm, std::ostream& out) {
+	std::map<std::pair<std::string, std::string>, std::string> transitionMap;
+	for (const auto& transition : fsm.getTransitions()) {
+		std::pair<std::string, std::string> key(transition.first.first.getName(), transition.second.getName());
+
+		std::string symbol = (std::string) transition.first.second;
+
+		auto mapIterator = transitionMap.find(key);
+		if (mapIterator == transitionMap.end()) {
+			transitionMap.insert(make_pair(key, symbol));
+		} else {
+			mapIterator->second += ", " + symbol;
+		}
+	}
+	printTransitionMap(transitionMap, out);
+}
+
+void GasTexConverter::transitions(const automaton::ExtendedNFA& pda, std::ostream& out) {
+	//TODO
+}
+
+void GasTexConverter::transitions(const automaton::CompactNFA& pda, std::ostream& out) {
+	// TODO
+}
+
+void GasTexConverter::transitions(const automaton::NPDA& pda, std::ostream& out) {
+	// TODO
+	/*map<pair<string, string>, string> transitionMap;
+
+	for (auto& transition : pda.getTransitions()) {
+
+		pair<string, string> key(transition.getFrom().getName(), transition.getTo().getName());
+		auto mapIterator = transitionMap.find(key);
+
+		string symbol = checkEpsilon(transition.getInput().getSymbol());
+
+		symbol += ",";
+
+
+		symbol += getStackSymbols(transition.getPop());
+		symbol += "/";
+		symbol += getStackSymbols(transition.getPush());
+
+		if (mapIterator == transitionMap.end()) {
+			transitionMap.insert(pair<pair<string, string>, string>(key, symbol));
+		} else {
+			mapIterator->second += "; " + symbol;
+		}
+	}
+
+	printTransitionMap(transitionMap, out);*/
+}
+
+void GasTexConverter::transitions(const automaton::SinglePopNPDA& tm, std::ostream& out) {
+	// TODO
+}
+
+void GasTexConverter::transitions(const automaton::OneTapeDTM& tm, std::ostream& out) {
+	// TODO
+	/*map<pair<string, string>, string> transitionMap;
+
+	for (auto& transition : tm.getTransitions()) {
+
+		pair<string, string> key(transition.getFrom().getName(), transition.getTo().getName());
+		auto mapIterator = transitionMap.find(key);
+
+		string symbol = checkEpsilon(transition.getInput().getSymbol());
+		symbol += "/";
+		symbol += checkEpsilon(transition.getOutput().getSymbol());
+		symbol += ",";
+		symbol += (std::string[] ) { "$\\leftarrow$", "$\\rightarrow$", "$\\times$" } [transition.getShift()];
+
+		if (mapIterator == transitionMap.end()) {
+			transitionMap.insert(pair<pair<string, string>, string>(key, symbol));
+		} else {
+			mapIterator->second += "; " + symbol;
+		}
+	}
+
+	printTransitionMap(transitionMap, out);*/
+}
+
+const GasTexConverter GasTexConverter::instance;
+
+void GasTexConverter::Visit(void* data, const automaton::UnknownAutomaton& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
+void GasTexConverter::Visit(void* data, const automaton::EpsilonNFA& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
+void GasTexConverter::Visit(void* data, const automaton::NFA& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
+void GasTexConverter::Visit(void* data, const automaton::DFA& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
+void GasTexConverter::Visit(void* data, const automaton::ExtendedNFA& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
+void GasTexConverter::Visit(void* data, const automaton::CompactNFA& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
+void GasTexConverter::Visit(void* data, const automaton::NPDA& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
+void GasTexConverter::Visit(void* data, const automaton::SinglePopNPDA& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
+void GasTexConverter::Visit(void* data, const automaton::OneTapeDTM& automaton) const {
+	GasTexConverter::convert(automaton, *((std::ostream*) data));
+}
+
diff --git a/aconvert2/src/GasTexConverter.cpp.tmp b/aconvert2/src/GasTexConverter.cpp.tmp
deleted file mode 100644
index c84af4fec2688b8a701f7d3bf30652109834b29d..0000000000000000000000000000000000000000
--- a/aconvert2/src/GasTexConverter.cpp.tmp
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * GasTexConverter.cpp
- *
- *  Created on: Jan 1, 2014
- *      Author: Martin Zak
- */
-
-#include "GasTexConverter.h"
-
-#include <set>
-#include <map>
-#include <typeinfo>
-#include "AlibException.h"
-
-using namespace std;
-
-void GasTexConverter::convert(const Automaton& a, ostream& out) {
-	out << "\\begin{center}\n";
-	out << "\\begin{picture}(,)(,)\n";
-
-	for (auto& state : a.getStates()) {
-		bool initial = false;
-		bool final = false;
-
-		if(a.getInitialStates().find(state) != a.getInitialStates().end()){
-			initial = true;
-		}
-		if(a.getFinalStates().find(state) != a.getFinalStates().end()){
-			final = true;
-		}
-
-		if(initial || final) {
-			out << "\\node[Nmarks=";
-			if(initial){
-				out << "i";
-			}
-			if(final){
-				out << "r";
-			}
-			out<<"](";
-		} else {
-			out <<"\\node(";
-		}
-
-		out << state.getName();
-		out << ")(,){";
-		out << state.getName();
-		out << "}\n";
-	}
-
-	try {
-		const FSM& fsm = dynamic_cast<const FSM&>(a);
-		transitions(fsm, out);
-		out << "\\end{center}\n";
-		out << "\\end{picture}\n";
-		return;
-	} catch (const bad_cast& e) {
-	}
-
-	try {
-		const PDA& pda = dynamic_cast<const PDA&>(a);
-		transitions(pda, out);
-		out << "\\end{center}\n";
-		out << "\\end{picture}\n";
-		return;
-	} catch (const bad_cast& e) {
-	}
-
-	try {
-		const TM& tm = dynamic_cast<const TM&>(a);
-		transitions(tm, out);
-		out << "\\end{center}\n";
-		out << "\\end{picture}\n";
-		return;
-	} catch (const bad_cast& e) {
-	}
-
-	throw new alib::AlibException("Unknown automaton type!");
-}
-
-
-string GasTexConverter::getStackSymbols(const list<Symbol>& stackSymbols) {
-	if (stackSymbols.size() == 0) {
-		return "$\\varepsilon$";
-	}
-
-	string symbols = "";
-	int i=0;
-	for (auto& popSymbol : stackSymbols) {
-		if(i++ !=0) {
-			symbols +=" ";
-		}
-		symbols +=  popSymbol.getSymbol();
-	}
-	return symbols;
-}
-
-string GasTexConverter::checkEpsilon(const string& inputSymbol) {
-	if (inputSymbol.compare("") == 0) {
-		return "$\\varepsilon$";
-	} else {
-		return inputSymbol;
-	}
-}
-
-void GasTexConverter::printTransitionMap(
-		const map<pair<string, string>, string> transitionMap, ostream& out) {
-	for (auto& transition : transitionMap) {
-		string from = transition.first.first;
-		string to = transition.first.second;
-		string symbols = transition.second;
-
-		if (from == to) {
-			out << "\\drawloop(";
-			out << from;
-			out << "){";
-			out << symbols;
-			out << "}\n";
-
-		} else {
-			out << "\\drawedge(";
-			out << from;
-			out << ",";
-			out << to;
-			out << "){";
-			out << symbols;
-			out << "}\n";
-		}
-	}
-}
-
-void GasTexConverter::transitions(const FSM& fsm, ostream& out) {
-	map<pair<string, string>, string> transitionMap;
-	for (auto& transition : fsm.getTransitions()) {
-		pair<string, string> key(transition.getFrom().getName(), transition.getTo().getName());
-		auto mapIterator = transitionMap.find(key);
-
-		string symbol = checkEpsilon(transition.getInput().getSymbol());
-
-		if (mapIterator == transitionMap.end()) {
-			transitionMap.insert(
-					pair<pair<string, string>, string>(key, symbol));
-		} else {
-			mapIterator->second += "," + symbol;
-		}
-	}
-	printTransitionMap(transitionMap, out);
-}
-
-void GasTexConverter::transitions(const PDA& pda, ostream& out) {
-	map<pair<string, string>, string> transitionMap;
-
-	for (auto& transition : pda.getTransitions()) {
-
-		pair<string, string> key(transition.getFrom().getName(), transition.getTo().getName());
-		auto mapIterator = transitionMap.find(key);
-
-		string symbol = checkEpsilon(transition.getInput().getSymbol());
-
-		symbol += ",";
-
-
-		symbol += getStackSymbols(transition.getPop());
-		symbol += "/";
-		symbol += getStackSymbols(transition.getPush());
-
-		if (mapIterator == transitionMap.end()) {
-			transitionMap.insert(pair<pair<string, string>, string>(key, symbol));
-		} else {
-			mapIterator->second += "; " + symbol;
-		}
-	}
-
-	printTransitionMap(transitionMap, out);
-
-}
-
-void GasTexConverter::transitions(const TM& tm, ostream& out) {
-	map<pair<string, string>, string> transitionMap;
-
-	for (auto& transition : tm.getTransitions()) {
-
-		pair<string, string> key(transition.getFrom().getName(), transition.getTo().getName());
-		auto mapIterator = transitionMap.find(key);
-
-		string symbol = checkEpsilon(transition.getInput().getSymbol());
-		symbol += "/";
-		symbol += checkEpsilon(transition.getOutput().getSymbol());
-		symbol += ",";
-		symbol += (std::string[] ) { "$\\leftarrow$", "$\\rightarrow$", "$\\times$" } [transition.getShift()];
-
-		if (mapIterator == transitionMap.end()) {
-			transitionMap.insert(pair<pair<string, string>, string>(key, symbol));
-		} else {
-			mapIterator->second += "; " + symbol;
-		}
-	}
-
-	printTransitionMap(transitionMap, out);
-
-}
-
diff --git a/aconvert2/src/GasTexConverter.h b/aconvert2/src/GasTexConverter.h
index 1a1f7e5254796669b5a391e5ea97bbea2b32018a..8ddff8716de039e9fafcd59c6eb7742f365837ea 100644
--- a/aconvert2/src/GasTexConverter.h
+++ b/aconvert2/src/GasTexConverter.h
@@ -11,20 +11,47 @@
 #include <ostream>
 #include <map>
 #include <utility>
-#include "automaton/FSM/NFA.h"
-#include "automaton/PDA/NPDA.h"
-#include "automaton/TM/OneTapeDTM.h"
+#include <list>
+#include "automaton/Automaton.h"
+#include "alphabet/Symbol.h"
+
+class GasTexConverter : public automaton::VisitableAutomatonBase::const_visitor_type {
+	void Visit(void*, const automaton::UnknownAutomaton& automaton) const;
+	void Visit(void*, const automaton::EpsilonNFA& automaton) const;
+	void Visit(void*, const automaton::NFA& automaton) const;
+	void Visit(void*, const automaton::DFA& automaton) const;
+	void Visit(void*, const automaton::ExtendedNFA& automaton) const;
+	void Visit(void*, const automaton::CompactNFA& automaton) const;
+	void Visit(void*, const automaton::NPDA& automaton) const;
+	void Visit(void*, const automaton::SinglePopNPDA& automaton) const;
+	void Visit(void*, const automaton::OneTapeDTM& automaton) const;
 
-class GasTexConverter {
-private:
 	static void printTransitionMap( const std::map<std::pair<std::string, std::string>, std::string> transitionMap, std::ostream& out);
-	static std::string checkEpsilon(const std::string& inputSymbol);
 	static std::string getStackSymbols(const std::list<alphabet::Symbol>& stackSymbols);
+
+	static void transitions(const automaton::UnknownAutomaton& fsm, std::ostream& out);
+	static void transitions(const automaton::EpsilonNFA& fsm, std::ostream& out);
 	static void transitions(const automaton::NFA& fsm, std::ostream& out);
+	static void transitions(const automaton::DFA& fsm, std::ostream& out);
+	static void transitions(const automaton::ExtendedNFA& fsm, std::ostream& out);
+	static void transitions(const automaton::CompactNFA& fsm, std::ostream& out);
 	static void transitions(const automaton::NPDA& pda, std::ostream& out);
+	static void transitions(const automaton::SinglePopNPDA& tm, std::ostream& out);
 	static void transitions(const automaton::OneTapeDTM& tm, std::ostream& out);
+
+	static const GasTexConverter instance;
 public:
 	static void convert(const automaton::Automaton& a, std::ostream& out);
+
+	static void convert(const automaton::UnknownAutomaton& a, std::ostream& out);
+	static void convert(const automaton::EpsilonNFA& a, std::ostream& out);
+	static void convert(const automaton::NFA& a, std::ostream& out);
+	static void convert(const automaton::DFA& a, std::ostream& out);
+	static void convert(const automaton::ExtendedNFA& a, std::ostream& out);
+	static void convert(const automaton::CompactNFA& a, std::ostream& out);
+	static void convert(const automaton::NPDA& a, std::ostream& out);
+	static void convert(const automaton::SinglePopNPDA& a, std::ostream& out);
+	static void convert(const automaton::OneTapeDTM& a, std::ostream& out);
 };
 
 #endif /* GAS_TEX_CONVERTER_H_ */
diff --git a/aconvert2/src/aconvert.cpp b/aconvert2/src/aconvert.cpp
index 264a7dd08aa0230ca78ae1c4693a96d9dfd38b37..2bad6ee5156cbcac142eb2fa428c05255dda3084 100644
--- a/aconvert2/src/aconvert.cpp
+++ b/aconvert2/src/aconvert.cpp
@@ -113,7 +113,7 @@ int automatonToDot(std::istream& in, std::ostream& out) {
 }
 
 int automatonToGasTex(std::istream& in, std::ostream& out) {
-	/* try {
+	try {
 
 		automaton::Automaton automaton = alib::DataFactory::fromStream<automaton::Automaton>(in);
 		GasTexConverter::convert(automaton, out);
@@ -122,7 +122,7 @@ int automatonToGasTex(std::istream& in, std::ostream& out) {
 		std::cerr << e.getCause() << std::endl;
 		return 1;
 	}
-	return 0; */
+	return 0;
 }
 
 int main(int argc, char* argv[]) {