From b378434838a04e1d5bb499bc084a82859c380c07 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Sat, 19 Dec 2015 12:40:25 +0100
Subject: [PATCH] implement TikZ converter

---
 aconvert2/src/DotConverter.cpp  |   16 +-
 aconvert2/src/TikZConverter.cpp | 1985 +++++++++++++++++++++++++++++++
 aconvert2/src/TikZConverter.h   |   72 ++
 aconvert2/src/aconvert.cpp      |   20 +-
 4 files changed, 2083 insertions(+), 10 deletions(-)
 create mode 100644 aconvert2/src/TikZConverter.cpp
 create mode 100644 aconvert2/src/TikZConverter.h

diff --git a/aconvert2/src/DotConverter.cpp b/aconvert2/src/DotConverter.cpp
index 145489c6fd..d3eafc7ee9 100644
--- a/aconvert2/src/DotConverter.cpp
+++ b/aconvert2/src/DotConverter.cpp
@@ -914,8 +914,8 @@ void DotConverter::transitions(const automaton::NFTA& fta, const std::map<automa
 	}
 
 	//Print auxilary dots
-	for (unsigned i = states.size() + 1; i < transitions.size(); i++) {
-		out << "node [shape = point, label=\"\"]; " << i << ";\n";
+	for (unsigned i = 1; i < transitions.size(); i++) {
+		out << "node [shape = point, label=\"\"]; " << states.size() + i << ";\n";
 	}
 
 	//print the map
@@ -925,8 +925,8 @@ void DotConverter::transitions(const automaton::NFTA& fta, const std::map<automa
 		replace(transition.second, "\n", "\\n");
 		out << "[label=\"" << transition.second << "\"]\n";
 		unsigned j = 0;
-		for(int to : transition.first.second) {
-			out << to << " -> " << i;
+		for(int from : transition.first.second) {
+			out << from << " -> " << i;
 			out << "[label=\"" << j << "\"]\n";
 			j++;
 		}
@@ -963,8 +963,8 @@ void DotConverter::transitions(const automaton::DFTA& fta, const std::map<automa
 	}
 
 	//Print auxilary dots
-	for (unsigned i = states.size() + 1; i < transitions.size(); i++) {
-		out << "node [shape = point, label=\"\"]; " << i << ";\n";
+	for (unsigned i = 1; i < transitions.size(); i++) {
+		out << "node [shape = point, label=\"\"]; " << states.size() + i << ";\n";
 	}
 
 	//print the map
@@ -974,8 +974,8 @@ void DotConverter::transitions(const automaton::DFTA& fta, const std::map<automa
 		replace(transition.second, "\n", "\\n");
 		out << "[label=\"" << transition.second << "\"]\n";
 		unsigned j = 0;
-		for(int to : transition.first.second) {
-			out << to << " -> " << i;
+		for(int from : transition.first.second) {
+			out << from << " -> " << i;
 			out << "[label=\"" << j << "\"]\n";
 			j++;
 		}
diff --git a/aconvert2/src/TikZConverter.cpp b/aconvert2/src/TikZConverter.cpp
new file mode 100644
index 0000000000..047bff868c
--- /dev/null
+++ b/aconvert2/src/TikZConverter.cpp
@@ -0,0 +1,1985 @@
+/*
+ * TikZConverter.cpp
+ *
+ *  Created on: Dec 1, 2015
+ *      Author: Jan Travnicek
+ */
+
+#include "TikZConverter.h"
+#include "automaton/common/State.h"
+
+#include <automaton/FSM/NFA.h>
+#include <automaton/FSM/EpsilonNFA.h>
+#include <automaton/FSM/MultiInitialStateNFA.h>
+#include <automaton/FSM/DFA.h>
+#include <automaton/FSM/ExtendedNFA.h>
+#include <automaton/FSM/CompactNFA.h>
+#include <automaton/TA/NFTA.h>
+#include <automaton/TA/DFTA.h>
+#include <automaton/PDA/NPDA.h>
+#include <automaton/PDA/SinglePopNPDA.h>
+#include <automaton/PDA/InputDrivenDPDA.h>
+#include <automaton/PDA/InputDrivenNPDA.h>
+#include <automaton/PDA/VisiblyPushdownDPDA.h>
+#include <automaton/PDA/VisiblyPushdownNPDA.h>
+#include <automaton/PDA/RealTimeHeightDeterministicDPDA.h>
+#include <automaton/PDA/RealTimeHeightDeterministicNPDA.h>
+#include <automaton/PDA/DPDA.h>
+#include <automaton/PDA/SinglePopDPDA.h>
+#include <automaton/TM/OneTapeDTM.h>
+
+#include <factory/StringDataFactory.hpp>
+
+#include <exception/AlibException.h>
+
+#include <set>
+#include <map>
+#include <list>
+#include <utility>
+#include <vector>
+#include <typeinfo>
+
+auto replace = [] ( std::string & str, const std::string & what, const std::string & with ) {
+				   size_t index = 0;
+
+				   while ( ( index = str.find ( what, index ) ) != std::string::npos ) {
+					   str.replace ( index, what.length ( ), with );
+					   index += with.length ( );
+				   }
+			   };
+
+void TikZConverter::convert ( std::ostream & out, const automaton::Automaton & a ) {
+	getInstance ( ).dispatch ( out, a.getData ( ) );
+}
+
+void TikZConverter::convert ( std::ostream & out, const automaton::EpsilonNFA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::EpsilonNFA > TikZConverterEpsilonNFA = TikZConverter::RegistratorWrapper < void, automaton::EpsilonNFA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::MultiInitialStateNFA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialStates ( ).count ( state.first ) )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::MultiInitialStateNFA > TikZConverterMultiInitialStateNFA = TikZConverter::RegistratorWrapper < void, automaton::MultiInitialStateNFA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::NFA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::NFA > TikZConverterNFA = TikZConverter::RegistratorWrapper < void, automaton::NFA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::DFA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::DFA > TikZConverterDFA = TikZConverter::RegistratorWrapper < void, automaton::DFA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::ExtendedNFA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::ExtendedNFA > TikZConverterExtendedNFA = TikZConverter::RegistratorWrapper < void, automaton::ExtendedNFA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::CompactNFA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::CompactNFA > TikZConverterCompactNFA = TikZConverter::RegistratorWrapper < void, automaton::CompactNFA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::NFTA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::NFTA > TikZConverterNFTA = TikZConverter::RegistratorWrapper < void, automaton::NFTA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::DFTA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::DFTA > TikZConverterDFTA = TikZConverter::RegistratorWrapper < void, automaton::DFTA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::DPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::DPDA > TikZConverterDPDA = TikZConverter::RegistratorWrapper < void, automaton::DPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::SinglePopDPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::SinglePopDPDA > TikZConverterSinglePopDPDA = TikZConverter::RegistratorWrapper < void, automaton::SinglePopDPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::InputDrivenDPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::InputDrivenDPDA > TikZConverterInputDrivenDPDA = TikZConverter::RegistratorWrapper < void, automaton::InputDrivenDPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::InputDrivenNPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::InputDrivenNPDA > TikZConverterInputDrivenNPDA = TikZConverter::RegistratorWrapper < void, automaton::InputDrivenNPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::VisiblyPushdownDPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::VisiblyPushdownDPDA > TikZConverterVisiblyPushdownDPDA = TikZConverter::RegistratorWrapper < void, automaton::VisiblyPushdownDPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::VisiblyPushdownNPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialStates ( ).count ( state.first ) )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::VisiblyPushdownNPDA > TikZConverterVisiblyPushdownNPDA = TikZConverter::RegistratorWrapper < void, automaton::VisiblyPushdownNPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::RealTimeHeightDeterministicDPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::RealTimeHeightDeterministicDPDA > TikZConverterRealTimeHeightDeterministicDPDA = TikZConverter::RegistratorWrapper < void, automaton::RealTimeHeightDeterministicDPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::RealTimeHeightDeterministicNPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialStates ( ).count ( state.first ) )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::RealTimeHeightDeterministicNPDA > TikZConverterRealTimeHeightDeterministicNPDA = TikZConverter::RegistratorWrapper < void, automaton::RealTimeHeightDeterministicNPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::NPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::NPDA > TikZConverterNPDA = TikZConverter::RegistratorWrapper < void, automaton::NPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::SinglePopNPDA & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::SinglePopNPDA > TikZConverterSinglePopNPDA = TikZConverter::RegistratorWrapper < void, automaton::SinglePopNPDA > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::convert ( std::ostream & out, const automaton::OneTapeDTM & a ) {
+	out << "\\begin{tikzpicture}\n";
+	int cnt = 1;
+
+	 // Map states to indices
+	std::map < automaton::State, int > states;
+
+	for ( const automaton::State & state : a.getStates ( ) )
+		states.insert ( std::make_pair ( state, cnt++ ) );
+
+	 // Print states
+	for ( const auto & state : states ) {
+		std::string mods;
+
+		if ( a.getFinalStates ( ).count ( state.first ) )
+			mods += ",accepting";
+
+		if ( a.getInitialState ( ) == state.first )
+			mods += ",initial";
+
+		out << "\\node[state" + mods + "] (" << state.second << ") {" << alib::StringDataFactory::toString ( state.first.getName ( ) ) << "}\n";
+	}
+
+	transitions ( a, states, out );
+	out << "\\end{tikzpicture}";
+}
+
+TikZConverter::RegistratorWrapper < void, automaton::OneTapeDTM > TikZConverterOneTapeDTM = TikZConverter::RegistratorWrapper < void, automaton::OneTapeDTM > ( TikZConverter::getInstance ( ), TikZConverter::convert );
+
+void TikZConverter::transitions ( const automaton::EpsilonNFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	 // put transitions from automaton to "transitions"
+	for ( const auto & transition : fsm.getTransitions ( ) ) {
+		std::string symbol;
+
+		if ( transition.first.second.is < string::Epsilon > ( ) )
+			symbol = "&epsilon;";
+		else
+			symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ).get < alphabet::Symbol > ( ) );
+
+		for ( const automaton::State & to : transition.second ) {
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::MultiInitialStateNFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	 // put transitions from automaton to "transitions"
+	for ( const auto & transition : fsm.getTransitions ( ) ) {
+		std::string symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		for ( const automaton::State & to : transition.second ) {
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::NFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	 // put transitions from automaton to "transitions"
+	for ( const auto & transition : fsm.getTransitions ( ) ) {
+		std::string symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		for ( const automaton::State & to : transition.second ) {
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::DFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	 // put transitions from automaton to "transitions"
+	for ( const auto & transition : fsm.getTransitions ( ) ) {
+		std::string symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( transition.second )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::ExtendedNFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	 // put transitions from automaton to "transitions"
+	for ( const auto & transition : fsm.getTransitions ( ) ) {
+		std::string symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		for ( const automaton::State & to : transition.second ) {
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::CompactNFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	 // put transitions from automaton to "transitions"
+	for ( const auto & transition : fsm.getTransitions ( ) ) {
+		std::string symbol = alib::StringDataFactory::toString ( string::String { transition.first.second } );
+
+		for ( const automaton::State & to : transition.second ) {
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::NFTA & fta, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, std::vector < int > >, std::string > transitions;
+
+	 // put transitions from automaton to "transitions"
+	for ( const auto & transition : fta.getTransitions ( ) ) {
+		std::string symbol = alib::StringDataFactory::toString ( transition.first.first.getSymbol ( ) );
+		symbol += std::utos ( transition.first.first.getRank ( ).getData ( ) );
+
+		for ( const automaton::State & to : transition.second ) {
+			std::pair < int, std::vector < int > > key ( states.find ( to )->second, { } );
+
+			for ( const automaton::State & state : transition.first.second )
+				key.second.push_back ( states.find ( state )->second );
+
+			std::map < std::pair < int, std::vector < int > >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol;
+			}
+		}
+	}
+
+	 // Print auxilary dots
+	for ( unsigned i = 1; i < transitions.size ( ); i++ )
+		out << "\\node[draw=none,fill=none] (" << states.size ( ) + i << ") {}\n";
+
+	out << "\\path[->]";
+
+	 // print the map
+	unsigned i = states.size ( ) + 1;
+
+	for ( std::pair < const std::pair < int, std::vector < int > >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << i << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.first << ")\n";
+
+		unsigned j = 0;
+
+		for ( int from : transition.first.second ) {
+			out << "(" << from << ") edge [left] node [align=center] ";
+			out << "{$" << j << "$}";
+			out << "(" << i << ")\n";
+
+			j++;
+		}
+
+		i++;
+	}
+}
+
+void TikZConverter::transitions ( const automaton::DFTA & fta, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, std::vector < int > >, std::string > transitions;
+
+	 // put transitions from automaton to "transitions"
+	for ( const auto & transition : fta.getTransitions ( ) ) {
+		std::string symbol = alib::StringDataFactory::toString ( transition.first.first.getSymbol ( ) );
+		symbol += std::utos ( transition.first.first.getRank ( ).getData ( ) );
+
+		std::pair < int, std::vector < int > > key ( states.find ( transition.second )->second, { } );
+
+		for ( const automaton::State & state : transition.first.second )
+			key.second.push_back ( states.find ( state )->second );
+
+		std::map < std::pair < int, std::vector < int > >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	 // Print auxilary dots
+	for ( unsigned i = 1; i < transitions.size ( ); i++ )
+		out << "\\node[draw=none,fill=none] (" << states.size ( ) + i << ") {}\n";
+
+	out << "\\path[->]";
+
+	 // print the map
+	unsigned i = states.size ( ) + 1;
+
+	for ( std::pair < const std::pair < int, std::vector < int > >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << i << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.first << ")\n";
+
+		unsigned j = 0;
+
+		for ( int from : transition.first.second ) {
+			out << "(" << from << ") edge [left] node [align=center] ";
+			out << "{$" << j << "$}";
+			out << "(" << i << ")\n";
+
+			j++;
+		}
+
+		i++;
+	}
+}
+
+void TikZConverter::transitions ( const automaton::DPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : pda.getTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( std::get < 1 > ( transition.first ).is < string::Epsilon > ( ) )
+			symbol = "&epsilon;";
+		else
+			symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ).get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		if ( std::get < 2 > ( transition.first ).size ( ) == 0 )
+			symbol += " &epsilon;";
+		else
+			for ( alphabet::Symbol symb : std::get < 2 > ( transition.first ) )
+				symbol += " " + alib::StringDataFactory::toString ( symb );
+
+		symbol += " ->";
+
+		 // Push part
+		if ( transition.second.second.size ( ) == 0 )
+			symbol += " &epsilon;";
+		else
+			for ( alphabet::Symbol symb : transition.second.second )
+				symbol += " " + alib::StringDataFactory::toString ( symb );
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( std::get < 0 > ( transition.first ) )->second, states.find ( transition.second.first )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::SinglePopDPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : pda.getTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( std::get < 1 > ( transition.first ).is < string::Epsilon > ( ) )
+			symbol = "&epsilon;";
+		else
+			symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ).get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " " + alib::StringDataFactory::toString ( std::get < 2 > ( transition.first ) );
+
+		symbol += " ->";
+
+		 // Push part
+		if ( transition.second.second.size ( ) == 0 )
+			symbol += " &epsilon;";
+		else
+			for ( alphabet::Symbol symb : transition.second.second )
+				symbol += " " + alib::StringDataFactory::toString ( symb );
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( std::get < 0 > ( transition.first ) )->second, states.find ( transition.second.first )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::InputDrivenDPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	const auto & symbolToPDSOperation = pda.getPushdownStoreOperations ( );
+
+	for ( const auto & transition : pda.getTransitions ( ) ) {
+		const auto & pop  = symbolToPDSOperation.find ( transition.first.second )->second.first;
+		const auto & push = symbolToPDSOperation.find ( transition.first.second )->second.second;
+
+		std::string symbol;
+
+		 // input symbol
+		symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		symbol += " |";
+
+		 // Pop part
+		if ( pop.size ( ) == 0 )
+			symbol += " &epsilon;";
+		else
+			for ( alphabet::Symbol symb : pop )
+				symbol += " " + alib::StringDataFactory::toString ( symb );
+
+		symbol += " ->";
+
+		const auto & to = transition.second;
+
+		 // Push part
+		if ( push.size ( ) == 0 )
+			symbol += " &epsilon;";
+		else
+			for ( alphabet::Symbol symb : push )
+				symbol += " " + alib::StringDataFactory::toString ( symb );
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::InputDrivenNPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	const auto & symbolToPDSOperation = pda.getPushdownStoreOperations ( );
+
+	for ( const auto & transition : pda.getTransitions ( ) ) {
+		const auto & pop  = symbolToPDSOperation.find ( transition.first.second )->second.first;
+		const auto & push = symbolToPDSOperation.find ( transition.first.second )->second.second;
+
+		std::string symbol;
+
+		 // input symbol
+		symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		symbol += " |";
+
+		 // Pop part
+		if ( pop.size ( ) == 0 )
+			symbol += " &epsilon;";
+		else
+			for ( alphabet::Symbol symb : pop )
+				symbol += " " + alib::StringDataFactory::toString ( symb );
+
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2 = symbol;
+
+			 // Push part
+			if ( push.size ( ) == 0 )
+				symbol2 += " &epsilon;";
+			else
+				for ( alphabet::Symbol symb : push )
+					symbol2 += " " + alib::StringDataFactory::toString ( symb );
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::VisiblyPushdownDPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : pda.getCallTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " &epsilon;";
+		symbol += " ->";
+
+		symbol += " " + alib::StringDataFactory::toString ( transition.second.second );
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( transition.second.first )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	for ( const auto & transition : pda.getReturnTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " " + alib::StringDataFactory::toString ( std::get < 2 > ( transition.first ) );
+		symbol += " ->";
+
+		symbol += " &epsilon;";
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( std::get < 0 > ( transition.first ) )->second, states.find ( transition.second )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	for ( const auto & transition : pda.getLocalTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " &epsilon;";
+		symbol += " ->";
+
+		symbol += " &epsilon;";
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( transition.second )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::VisiblyPushdownNPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : pda.getCallTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " &epsilon;";
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2	 = symbol;
+			symbol2 += " " + alib::StringDataFactory::toString ( to.second );
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to.first )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	for ( const auto & transition : pda.getReturnTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " " + alib::StringDataFactory::toString ( std::get < 2 > ( transition.first ) );
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2	 = symbol;
+			symbol2 += " &epsilon;";
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( std::get < 0 > ( transition.first ) )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	for ( const auto & transition : pda.getLocalTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		symbol = alib::StringDataFactory::toString ( transition.first.second );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " &epsilon;";
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2	 = symbol;
+			symbol2 += " &epsilon;";
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::RealTimeHeightDeterministicDPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : pda.getCallTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( transition.first.second.is < string::Epsilon > ( ) )
+			symbol = "&epsilon";
+		else
+			symbol = alib::StringDataFactory::toString ( transition.first.second.get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " &epsilon;";
+		symbol += " ->";
+
+		symbol += " " + alib::StringDataFactory::toString ( transition.second.second );
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( transition.second.first )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	for ( const auto & transition : pda.getReturnTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( std::get < 1 > ( transition.first ).is < string::Epsilon > ( ) )
+			symbol = "&epsilon";
+		else
+			symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ).get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " " + alib::StringDataFactory::toString ( std::get < 2 > ( transition.first ) );
+		symbol += " ->";
+
+		symbol += " &epsilon;";
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( std::get < 0 > ( transition.first ) )->second, states.find ( transition.second )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	for ( const auto & transition : pda.getLocalTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( transition.first.second.is < string::Epsilon > ( ) )
+			symbol = "&epsilon";
+		else
+			symbol = alib::StringDataFactory::toString ( transition.first.second.get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " &epsilon;";
+		symbol += " ->";
+
+		symbol += " &epsilon;";
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( transition.second )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::RealTimeHeightDeterministicNPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : pda.getCallTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( transition.first.second.is < string::Epsilon > ( ) )
+			symbol = "&epsilon";
+		else
+			symbol = alib::StringDataFactory::toString ( transition.first.second.get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " &epsilon;";
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2	 = symbol;
+			symbol2 += " " + alib::StringDataFactory::toString ( to.second );
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to.first )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	for ( const auto & transition : pda.getReturnTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( std::get < 1 > ( transition.first ).is < string::Epsilon > ( ) )
+			symbol = "&epsilon;";
+		else
+			symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ).get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " " + alib::StringDataFactory::toString ( std::get < 2 > ( transition.first ) );
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2	 = symbol;
+			symbol2 += " &epsilon;";
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( std::get < 0 > ( transition.first ) )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	for ( const auto & transition : pda.getLocalTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( transition.first.second.is < string::Epsilon > ( ) )
+			symbol = "&epsilon;";
+		else
+			symbol = alib::StringDataFactory::toString ( transition.first.second.get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " &epsilon;";
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2	 = symbol;
+			symbol2 += " &epsilon;";
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( to )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::NPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : pda.getTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( std::get < 1 > ( transition.first ).is < string::Epsilon > ( ) )
+			symbol = "&epsilon;";
+		else
+			symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ).get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		if ( std::get < 2 > ( transition.first ).size ( ) == 0 )
+			symbol += " &epsilon;";
+		else
+			for ( alphabet::Symbol symb : std::get < 2 > ( transition.first ) )
+				symbol += " " + alib::StringDataFactory::toString ( symb );
+
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2 = symbol;
+
+			 // Push part
+			if ( to.second.size ( ) == 0 )
+				symbol2 += " &epsilon;";
+			else
+				for ( alphabet::Symbol symb : to.second )
+					symbol2 += " " + alib::StringDataFactory::toString ( symb );
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( std::get < 0 > ( transition.first ) )->second, states.find ( to.first )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::SinglePopNPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : pda.getTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		if ( std::get < 1 > ( transition.first ).is < string::Epsilon > ( ) )
+			symbol = "&epsilon;";
+		else
+			symbol = alib::StringDataFactory::toString ( std::get < 1 > ( transition.first ).get < alphabet::Symbol > ( ) );
+
+		symbol += " |";
+
+		 // Pop part
+		symbol += " " + alib::StringDataFactory::toString ( std::get < 2 > ( transition.first ) );
+
+		symbol += " ->";
+
+		std::string symbol2;
+
+		for ( const auto & to : transition.second ) {
+			symbol2 = symbol;
+
+			 // Push part
+			if ( to.second.size ( ) == 0 )
+				symbol2 += " &epsilon;";
+			else
+				for ( alphabet::Symbol symb : to.second )
+					symbol2 += " " + alib::StringDataFactory::toString ( symb );
+
+			 // Insert into map
+			std::pair < int, int > key ( states.find ( std::get < 0 > ( transition.first ) )->second, states.find ( to.first )->second );
+			std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+			if ( mapit == transitions.end ( ) ) {
+				transitions.insert ( std::make_pair ( key, symbol2 ) );
+			} else {
+				mapit->second += ",";
+
+				size_t pos = mapit->second.find_last_of ( "\n" );
+
+				if ( pos == std::string::npos ) pos = 0;
+
+				if ( mapit->second.size ( ) - pos > 100 )
+					mapit->second += "\n";
+				else
+					mapit->second += " ";
+
+				mapit->second += symbol2;
+			}
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
+
+void TikZConverter::transitions ( const automaton::OneTapeDTM & tm, const std::map < automaton::State, int > & states, std::ostream & out ) {
+	std::map < std::pair < int, int >, std::string > transitions;
+
+	for ( const auto & transition : tm.getTransitions ( ) ) {
+		std::string symbol;
+
+		 // input symbol
+		symbol	= "(";
+		symbol += alib::StringDataFactory::toString ( transition.first.second );
+		symbol += ", ";
+		symbol += alib::StringDataFactory::toString ( std::get < 1 > ( transition.second ) );
+		symbol += " ";
+
+		switch ( std::get < 2 > ( transition.second ) ) {
+		case automaton::Shift::LEFT:
+			symbol += "&larr;";
+			break;
+
+		case automaton::Shift::RIGHT:
+			symbol += "&rarr;";
+			break;
+
+		case automaton::Shift::NONE:
+			symbol += "&times;";
+			break;
+
+		default:
+			throw exception::AlibException ( "Unexpected shift direction" );
+		}
+
+		 // Insert into map
+		std::pair < int, int > key ( states.find ( transition.first.first )->second, states.find ( std::get < 0 > ( transition.second ) )->second );
+		std::map < std::pair < int, int >, std::string >::iterator mapit = transitions.find ( key );
+
+		if ( mapit == transitions.end ( ) ) {
+			transitions.insert ( std::make_pair ( key, symbol ) );
+		} else {
+			mapit->second += ",";
+
+			size_t pos = mapit->second.find_last_of ( "\n" );
+
+			if ( pos == std::string::npos ) pos = 0;
+
+			if ( mapit->second.size ( ) - pos > 100 )
+				mapit->second += "\n";
+			else
+				mapit->second += " ";
+
+			mapit->second += symbol;
+		}
+	}
+
+	out << "\\path[->]";
+
+	 // print the map
+	for ( std::pair < const std::pair < int, int >, std::string > & transition : transitions ) {
+		replace ( transition.second, "\n", "\\n" );
+
+		out << "(" << transition.first.first << ") edge [left] node [align=center] ";
+		out << "{$" << transition.second << "$}";
+		out << "(" << transition.first.second << ")\n";
+	}
+}
diff --git a/aconvert2/src/TikZConverter.h b/aconvert2/src/TikZConverter.h
new file mode 100644
index 0000000000..8efa573326
--- /dev/null
+++ b/aconvert2/src/TikZConverter.h
@@ -0,0 +1,72 @@
+/*
+ * TikZConverter.h
+ *
+ *  Created on: Dec 1, 2015
+ *      Author: Jan Travnicek
+ */
+
+#ifndef TIKZ_CONVERTER_H_
+#define TIKZ_CONVERTER_H_
+
+#include <ostream>
+#include <common/multipleDispatch.hpp>
+
+#include <automaton/Automaton.h>
+#include <automaton/AutomatonFeatures.h>
+
+#include <map>
+#include <utility>
+
+class TikZConverter : public std::SingleDispatchFirstStaticParam < void, std::ostream &, automaton::AutomatonBase > {
+	static void transitions ( const automaton::EpsilonNFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::MultiInitialStateNFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::NFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::DFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::ExtendedNFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::CompactNFA & fsm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::NFTA & fsm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::DFTA & fsm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::DPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::SinglePopDPDA & tm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::InputDrivenDPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::InputDrivenNPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::VisiblyPushdownDPDA & tm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::VisiblyPushdownNPDA & tm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::RealTimeHeightDeterministicDPDA & tm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::RealTimeHeightDeterministicNPDA & tm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::NPDA & pda, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::SinglePopNPDA & tm, const std::map < automaton::State, int > & states, std::ostream & out );
+	static void transitions ( const automaton::OneTapeDTM & tm, const std::map < automaton::State, int > & states, std::ostream & out );
+
+public:
+	static void convert ( std::ostream & out, const automaton::Automaton & a );
+
+	static void convert ( std::ostream & out, const automaton::EpsilonNFA & a );
+	static void convert ( std::ostream & out, const automaton::MultiInitialStateNFA & a );
+	static void convert ( std::ostream & out, const automaton::NFA & a );
+	static void convert ( std::ostream & out, const automaton::DFA & a );
+	static void convert ( std::ostream & out, const automaton::ExtendedNFA & a );
+	static void convert ( std::ostream & out, const automaton::CompactNFA & a );
+	static void convert ( std::ostream & out, const automaton::NFTA & a );
+	static void convert ( std::ostream & out, const automaton::DFTA & a );
+	static void convert ( std::ostream & out, const automaton::DPDA & a );
+	static void convert ( std::ostream & out, const automaton::SinglePopDPDA & a );
+	static void convert ( std::ostream & out, const automaton::InputDrivenDPDA & a );
+	static void convert ( std::ostream & out, const automaton::InputDrivenNPDA & a );
+	static void convert ( std::ostream & out, const automaton::VisiblyPushdownDPDA & a );
+	static void convert ( std::ostream & out, const automaton::VisiblyPushdownNPDA & a );
+	static void convert ( std::ostream & out, const automaton::RealTimeHeightDeterministicDPDA & a );
+	static void convert ( std::ostream & out, const automaton::RealTimeHeightDeterministicNPDA & a );
+	static void convert ( std::ostream & out, const automaton::NPDA & a );
+	static void convert ( std::ostream & out, const automaton::SinglePopNPDA & a );
+	static void convert ( std::ostream & out, const automaton::OneTapeDTM & a );
+
+	static TikZConverter & getInstance ( ) {
+		static TikZConverter res;
+
+		return res;
+	}
+
+};
+
+#endif /* TIKZ_CONVERTER_H_ */
diff --git a/aconvert2/src/aconvert.cpp b/aconvert2/src/aconvert.cpp
index f613befa26..9c2965ea8a 100644
--- a/aconvert2/src/aconvert.cpp
+++ b/aconvert2/src/aconvert.cpp
@@ -15,6 +15,7 @@
 
 #include "DotConverter.h"
 #include "GasTexConverter.h"
+#include "TikZConverter.h"
 
 void automatonFromString ( std::istream & in, std::ostream & out ) {
 	automaton::Automaton automaton = alib::StringDataFactory::fromStream < automaton::Automaton > ( in );
@@ -124,6 +125,15 @@ void automatonToGasTex ( std::istream & in, std::ostream & out ) {
 	GasTexConverter::convert ( out, automaton );
 }
 
+void automatonToTikZ ( std::istream & in, std::ostream & out ) {
+	automaton::Automaton automaton = alib::XmlDataFactory::fromStream < automaton::Automaton > ( in );
+
+	std::chrono::measurements::end ( );
+	std::chrono::measurements::start ( "Output write", std::chrono::measurements::Type::AUXILARY );
+
+	TikZConverter::convert ( out, automaton );
+}
+
 int main ( int argc, char * argv[] ) {
 	try {
 		TCLAP::CmdLine cmd ( "Convert binary", ' ', "0.01" );
@@ -140,6 +150,9 @@ int main ( int argc, char * argv[] ) {
 		TCLAP::SwitchArg automaton_to_gastex ( "", "automaton_to_gastex", "Convert automaton to gastex representation" );
 		cmd.add ( automaton_to_gastex );
 
+		TCLAP::SwitchArg automaton_to_tikz ( "", "automaton_to_tikz", "Convert automaton to tikz representation" );
+		cmd.add ( automaton_to_tikz );
+
 		TCLAP::SwitchArg grammar_from_string ( "", "grammar_from_string", "Convert grammar from string representation" );
 		cmd.add ( grammar_from_string );
 
@@ -175,9 +188,10 @@ int main ( int argc, char * argv[] ) {
 
 		cmd.parse ( argc, argv );
 
-		if(verbose.isSet())
+		if ( verbose.isSet ( ) )
 			common::GlobalData::verbose = true;
-		if(measure.isSet())
+
+		if ( measure.isSet ( ) )
 			common::GlobalData::measure = true;
 
 		std::chrono::measurements::start ( "Overal", std::chrono::measurements::Type::OVERALL );
@@ -202,6 +216,8 @@ int main ( int argc, char * argv[] ) {
 			automatonToDot ( * in, std::cout );
 		else if ( automaton_to_gastex.getValue ( ) )
 			automatonToGasTex ( * in, std::cout );
+		else if ( automaton_to_tikz.getValue ( ) )
+			automatonToTikZ ( * in, std::cout );
 		else if ( grammar_from_string.getValue ( ) )
 			grammarFromString ( * in, std::cout );
 		else if ( grammar_to_string.getValue ( ) )
-- 
GitLab