From 39ec697c07285030e2182844dbe74d97eb6e74a6 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Sun, 13 Aug 2017 19:14:57 +0200
Subject: [PATCH] split compare automata to compare and diff

---
 acompare2/src/acompare.cpp                    |    4 +-
 alib2aux/src/compare/AutomatonCompare.cpp     |   50 +-
 alib2aux/src/compare/AutomatonCompare.h       | 1062 +----------------
 alib2aux/src/compare/AutomatonDiff.cpp        |   40 +
 alib2aux/src/compare/AutomatonDiff.h          | 1044 ++++++++++++++++
 .../src/compare/{AuxCompare.h => DiffAux.h}   |   26 +-
 alib2aux/src/compare/GrammarCompare.h         |  188 +--
 alib2aux/src/compare/StringCompare.h          |   26 +-
 8 files changed, 1272 insertions(+), 1168 deletions(-)
 create mode 100644 alib2aux/src/compare/AutomatonDiff.cpp
 create mode 100644 alib2aux/src/compare/AutomatonDiff.h
 rename alib2aux/src/compare/{AuxCompare.h => DiffAux.h} (78%)

diff --git a/acompare2/src/acompare.cpp b/acompare2/src/acompare.cpp
index 71d7d4927a..9c5fcd1af0 100644
--- a/acompare2/src/acompare.cpp
+++ b/acompare2/src/acompare.cpp
@@ -13,7 +13,7 @@
 #include "exception/CommonException.h"
 #include "factory/XmlDataFactory.hpp"
 
-#include <compare/AutomatonCompare.h>
+#include <compare/AutomatonDiff.h>
 #include <compare/GrammarCompare.h>
 #include <compare/StringCompare.h>
 
@@ -59,7 +59,7 @@ int main ( int argc, char * * argv ) {
 			measurements::end ( );
 			measurements::start ( "Compare", measurements::Type::MAIN );
 
-			res = compare::AutomatonCompare::compare ( automaton1, automaton2, std::cout );
+			res = compare::AutomatonDiff::diff ( automaton1, automaton2, std::cout );
 		} else if ( alib::XmlDataFactory::first < grammar::Grammar > ( tokens1 ) && alib::XmlDataFactory::first < grammar::Grammar > ( tokens2 ) ) {
 			grammar::Grammar grammar1 = alib::XmlDataFactory::fromTokens ( std::move ( tokens1 ) );
 			grammar::Grammar grammar2 = alib::XmlDataFactory::fromTokens ( std::move ( tokens2 ) );
diff --git a/alib2aux/src/compare/AutomatonCompare.cpp b/alib2aux/src/compare/AutomatonCompare.cpp
index d5e15c3fd1..ed52eaa94a 100644
--- a/alib2aux/src/compare/AutomatonCompare.cpp
+++ b/alib2aux/src/compare/AutomatonCompare.cpp
@@ -10,31 +10,31 @@
 
 namespace compare {
 
-auto AutomatonCompareDFA = registration::OverloadRegister < AutomatonCompare, int, automaton::DFA < >, automaton::DFA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::NFA < > , automaton::NFA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareMultiInitialStateNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareEpsilonNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareExtendedNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareCompactNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::CompactNFA < >, automaton::CompactNFA < > > ( AutomatonCompare::compare );
-
-auto AutomatonCompareDFTA = registration::OverloadRegister < AutomatonCompare, int, automaton::DFTA < >, automaton::DFTA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareNFTA = registration::OverloadRegister < AutomatonCompare, int, automaton::NFTA < >, automaton::NFTA < > > ( AutomatonCompare::compare );
-
-auto AutomatonCompareDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::DPDA < >, automaton::DPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::NPDA < >, automaton::NPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareInputDrivenDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareInputDrivenNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::InputDrivenNPDA < >, automaton::InputDrivenNPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareVisiblyPushdownDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareVisiblyPushdownNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::VisiblyPushdownNPDA < >, automaton::VisiblyPushdownNPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareRealTimeHeightDeterministicDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareRealTimeHeightDeterministicNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::RealTimeHeightDeterministicNPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareSinglePopDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > > ( AutomatonCompare::compare );
-auto AutomatonCompareSinglePopNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::SinglePopNPDA < >, automaton::SinglePopNPDA < > > ( AutomatonCompare::compare );
-
-auto AutomatonCompareOneTapeDTM = registration::OverloadRegister < AutomatonCompare, int, automaton::OneTapeDTM < >, automaton::OneTapeDTM < > > ( AutomatonCompare::compare );
-
-int AutomatonCompare::compare(const automaton::Automaton& a, const automaton::Automaton& b, std::ostream & out ) {
-	return dispatch(a.getData(), b.getData(), out);
+auto AutomatonCompareDFA = registration::OverloadRegister < AutomatonCompare, bool, automaton::DFA < >, automaton::DFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareNFA = registration::OverloadRegister < AutomatonCompare, bool, automaton::NFA < > , automaton::NFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareMultiInitialStateNFA = registration::OverloadRegister < AutomatonCompare, bool, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareEpsilonNFA = registration::OverloadRegister < AutomatonCompare, bool, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareExtendedNFA = registration::OverloadRegister < AutomatonCompare, bool, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareCompactNFA = registration::OverloadRegister < AutomatonCompare, bool, automaton::CompactNFA < >, automaton::CompactNFA < > > ( AutomatonCompare::compare );
+
+auto AutomatonCompareDFTA = registration::OverloadRegister < AutomatonCompare, bool, automaton::DFTA < >, automaton::DFTA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareNFTA = registration::OverloadRegister < AutomatonCompare, bool, automaton::NFTA < >, automaton::NFTA < > > ( AutomatonCompare::compare );
+
+auto AutomatonCompareDPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::DPDA < >, automaton::DPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareNPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::NPDA < >, automaton::NPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareInputDrivenDPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareInputDrivenNPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::InputDrivenNPDA < >, automaton::InputDrivenNPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareVisiblyPushdownDPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareVisiblyPushdownNPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::VisiblyPushdownNPDA < >, automaton::VisiblyPushdownNPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareRealTimeHeightDeterministicDPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareRealTimeHeightDeterministicNPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::RealTimeHeightDeterministicNPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareSinglePopDPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareSinglePopNPDA = registration::OverloadRegister < AutomatonCompare, bool, automaton::SinglePopNPDA < >, automaton::SinglePopNPDA < > > ( AutomatonCompare::compare );
+
+auto AutomatonCompareOneTapeDTM = registration::OverloadRegister < AutomatonCompare, bool, automaton::OneTapeDTM < >, automaton::OneTapeDTM < > > ( AutomatonCompare::compare );
+
+bool AutomatonCompare::compare(const automaton::Automaton& a, const automaton::Automaton& b ) {
+	return dispatch(a.getData(), b.getData() );
 }
 
 } /* namespace compare */
diff --git a/alib2aux/src/compare/AutomatonCompare.h b/alib2aux/src/compare/AutomatonCompare.h
index 3a85be61dd..120c223b1d 100644
--- a/alib2aux/src/compare/AutomatonCompare.h
+++ b/alib2aux/src/compare/AutomatonCompare.h
@@ -10,18 +10,8 @@
 
 #include <core/multipleDispatch.hpp>
 
-#include <compare/AuxCompare.h>
-
 #include <automaton/Automaton.h>
 #include <automaton/AutomatonFeatures.h>
-#include <set>
-#include <list>
-#include <map>
-#include <utility>
-#include <vector>
-#include <iostream>
-#include <ostream>
-
 #include "automaton/FSM/DFA.h"
 #include "automaton/FSM/NFA.h"
 #include "automaton/FSM/MultiInitialStateNFA.h"
@@ -44,111 +34,70 @@
 
 namespace compare {
 
-class AutomatonCompare : public alib::MultipleDispatch < AutomatonCompare, int, ext::tuple < >, ext::tuple < const automaton::AutomatonBase &, const automaton::AutomatonBase & >, ext::tuple < std::ostream & > > {
-private:
-	template<class SymbolType, class StateType>
-	static bool testCompare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b);
+class AutomatonCompare : public alib::MultipleDispatch < AutomatonCompare, bool, ext::tuple < >, ext::tuple < const automaton::AutomatonBase &, const automaton::AutomatonBase & >, ext::tuple < > > {
+public:
 	template<class SymbolType, class StateType>
-	static void printCompare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b);
 
 	template<class SymbolType, class StateType>
-	static bool testCompare(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b);
-	template<class SymbolType, class StateType>
-	static void printCompare(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b);
 
 	template<class SymbolType, class StateType>
-	static bool testCompare(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b);
-	template<class SymbolType, class StateType>
-	static void printCompare(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b);
 
 	template<class SymbolType, class EpsilonType, class StateType>
-	static bool testCompare(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b);
-	template<class SymbolType, class EpsilonType, class StateType>
-	static void printCompare(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b);
 
 	template<class SymbolType, class StateType>
-	static bool testCompare(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b);
-	template<class SymbolType, class StateType>
-	static void printCompare(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b);
 
 	template<class SymbolType, class StateType>
-	static bool testCompare(const automaton::CompactNFA < SymbolType, StateType > & a, const automaton::CompactNFA < SymbolType, StateType > & b);
-	template<class SymbolType, class StateType>
-	static void printCompare(const automaton::CompactNFA < SymbolType, StateType > & a, const automaton::CompactNFA < SymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::CompactNFA < SymbolType, StateType > & a, const automaton::CompactNFA < SymbolType, StateType > & b);
 
 	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class SymbolType, class RankType, class StateType>
-	static bool testCompare(const automaton::DFTA < SymbolType, RankType, StateType > & a, const automaton::DFTA < SymbolType, RankType, StateType > & b);
-	template<class SymbolType, class RankType, class StateType>
-	static void printCompare(const automaton::DFTA < SymbolType, RankType, StateType > & a, const automaton::DFTA < SymbolType, RankType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::DFTA < SymbolType, RankType, StateType > & a, const automaton::DFTA < SymbolType, RankType, StateType > & b);
 
 	template<class SymbolType, class RankType, class StateType>
-	static bool testCompare(const automaton::NFTA < SymbolType, RankType, StateType > & a, const automaton::NFTA < SymbolType, RankType, StateType > & b);
-	template<class SymbolType, class RankType, class StateType>
-	static void printCompare(const automaton::NFTA < SymbolType, RankType, StateType > & a, const automaton::NFTA < SymbolType, RankType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::NFTA < SymbolType, RankType, StateType > & a, const automaton::NFTA < SymbolType, RankType, StateType > & b);
 
 	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static bool testCompare(const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
-	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-	static void printCompare(const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+	static bool compare(const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b);
 
 	template<class SymbolType, class StateType>
-	static bool testCompare(const automaton::OneTapeDTM < SymbolType, StateType > & a, const automaton::OneTapeDTM < SymbolType, StateType > & b);
-	template<class SymbolType, class StateType>
-	static void printCompare(const automaton::OneTapeDTM < SymbolType, StateType > & a, const automaton::OneTapeDTM < SymbolType, StateType > & b, std::ostream & out );
-public:
-	template<class T>
-	static int compare(const T & a, const T & b, std::ostream & out );
+	static bool compare(const automaton::OneTapeDTM < SymbolType, StateType > & a, const automaton::OneTapeDTM < SymbolType, StateType > & b);
 
-	static int compare(const automaton::Automaton& a, const automaton::Automaton& b, std::ostream & out );
+	static bool compare(const automaton::Automaton& a, const automaton::Automaton& b );
 };
 
 template<class SymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -157,7 +106,7 @@ bool AutomatonCompare::testCompare(const automaton::DFA < SymbolType, StateType
 }
 
 template<class SymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialStates()  == b.getInitialStates()  &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -166,7 +115,7 @@ bool AutomatonCompare::testCompare(const automaton::MultiInitialStateNFA < Symbo
 }
 
 template<class SymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -175,7 +124,7 @@ bool AutomatonCompare::testCompare(const automaton::NFA < SymbolType, StateType
 }
 
 template<class SymbolType, class EpsilonType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -184,7 +133,7 @@ bool AutomatonCompare::testCompare(const automaton::EpsilonNFA < SymbolType, Eps
 }
 
 template<class SymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -193,7 +142,7 @@ bool AutomatonCompare::testCompare(const automaton::ExtendedNFA < SymbolType, St
 }
 
 template<class SymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::CompactNFA < SymbolType, StateType > & a, const automaton::CompactNFA < SymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::CompactNFA < SymbolType, StateType > & a, const automaton::CompactNFA < SymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -202,7 +151,7 @@ bool AutomatonCompare::testCompare(const automaton::CompactNFA < SymbolType, Sta
 }
 
 template<class SymbolType, class RankType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::DFTA < SymbolType, RankType, StateType > & a, const automaton::DFTA < SymbolType, RankType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::DFTA < SymbolType, RankType, StateType > & a, const automaton::DFTA < SymbolType, RankType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
 			a.getStates()         == b.getStates()         &&
@@ -210,7 +159,7 @@ bool AutomatonCompare::testCompare(const automaton::DFTA < SymbolType, RankType,
 }
 
 template<class SymbolType, class RankType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::NFTA < SymbolType, RankType, StateType > & a, const automaton::NFTA < SymbolType, RankType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::NFTA < SymbolType, RankType, StateType > & a, const automaton::NFTA < SymbolType, RankType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
 			a.getStates()         == b.getStates()         &&
@@ -218,7 +167,7 @@ bool AutomatonCompare::testCompare(const automaton::NFTA < SymbolType, RankType,
 }
 
 template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -229,7 +178,7 @@ bool AutomatonCompare::testCompare(const automaton::DPDA < InputSymbolType, Epsi
 }
 
 template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -240,7 +189,7 @@ bool AutomatonCompare::testCompare(const automaton::NPDA < InputSymbolType, Epsi
 }
 
 template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()             == b.getFinalStates()             &&
 			a.getInitialState()            == b.getInitialState()            &&
 //			a.getInputAlphabet()           == b.getInputAlphabet()           &&
@@ -252,7 +201,7 @@ bool AutomatonCompare::testCompare(const automaton::InputDrivenDPDA < InputSymbo
 }
 
 template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()             == b.getFinalStates()             &&
 			a.getInitialState()            == b.getInitialState()            &&
 //			a.getInputAlphabet()           == b.getInputAlphabet()           &&
@@ -264,7 +213,7 @@ bool AutomatonCompare::testCompare(const automaton::InputDrivenNPDA < InputSymbo
 }
 
 template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()            == b.getFinalStates()            &&
 			a.getInitialState()           == b.getInitialState()           &&
 //			a.getCallInputAlphabet()      == b.getCallInputAlphabet()      &&
@@ -279,7 +228,7 @@ bool AutomatonCompare::testCompare(const automaton::VisiblyPushdownDPDA < InputS
 }
 
 template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()            == b.getFinalStates()            &&
 			a.getInitialStates()          == b.getInitialStates()          &&
 //			a.getCallInputAlphabet()      == b.getCallInputAlphabet()      &&
@@ -294,7 +243,7 @@ bool AutomatonCompare::testCompare(const automaton::VisiblyPushdownNPDA < InputS
 }
 
 template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()            == b.getFinalStates()            &&
 			a.getInitialState()           == b.getInitialState()           &&
 //			a.getInputAlphabet()          == b.getInputAlphabet()          &&
@@ -307,7 +256,7 @@ bool AutomatonCompare::testCompare(const automaton::RealTimeHeightDeterministicD
 }
 
 template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()            == b.getFinalStates()            &&
 			a.getInitialStates()          == b.getInitialStates()          &&
 //			a.getInputAlphabet()          == b.getInputAlphabet()          &&
@@ -320,7 +269,7 @@ bool AutomatonCompare::testCompare(const automaton::RealTimeHeightDeterministicN
 }
 
 template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -331,7 +280,7 @@ bool AutomatonCompare::testCompare(const automaton::SinglePopDPDA < InputSymbolT
 }
 
 template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -342,7 +291,7 @@ bool AutomatonCompare::testCompare(const automaton::SinglePopNPDA < InputSymbolT
 }
 
 template<class SymbolType, class StateType>
-bool AutomatonCompare::testCompare(const automaton::OneTapeDTM < SymbolType, StateType > & a, const automaton::OneTapeDTM < SymbolType, StateType > & b) {
+bool AutomatonCompare::compare(const automaton::OneTapeDTM < SymbolType, StateType > & a, const automaton::OneTapeDTM < SymbolType, StateType > & b) {
 	return  	a.getBlankSymbol()    == b.getBlankSymbol()    &&
 			a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
@@ -352,935 +301,6 @@ bool AutomatonCompare::testCompare(const automaton::OneTapeDTM < SymbolType, Sta
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-template<class SymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class SymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialStates() != b.getInitialStates()) {
-		out << "InitialStates" << std::endl;
-
-		AuxCompare::setCompare(a.getInitialStates(), b.getInitialStates());
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class SymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class SymbolType, class EpsilonType, class StateType>
-void AutomatonCompare::printCompare(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class SymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class SymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::CompactNFA < SymbolType, StateType > & a, const automaton::CompactNFA < SymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class SymbolType, class RankType, class StateType>
-void AutomatonCompare::printCompare(const automaton::DFTA < SymbolType, RankType, StateType > & a, const automaton::DFTA < SymbolType, RankType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class SymbolType, class RankType, class StateType>
-void AutomatonCompare::printCompare(const automaton::NFTA < SymbolType, RankType, StateType > & a, const automaton::NFTA < SymbolType, RankType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		out << "InitialSymbol" << std::endl;
-
-		out << "< " << a.getInitialSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		out << "InitialSymbol" << std::endl;
-
-		out << "< " << a.getInitialSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		out << "InitialSymbol" << std::endl;
-
-		out << "< " << a.getInitialSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getPushdownStoreOperations() != b.getPushdownStoreOperations()) {
-		out << "PushdownStoreOperations" << std::endl;
-
-		AuxCompare::mapCompare(a.getPushdownStoreOperations(), b.getPushdownStoreOperations());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		out << "InitialSymbol" << std::endl;
-
-		out << "< " << a.getInitialSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getPushdownStoreOperations() != b.getPushdownStoreOperations()) {
-		out << "PushdownStoreOperations" << std::endl;
-
-		AuxCompare::mapCompare(a.getPushdownStoreOperations(), b.getPushdownStoreOperations());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getCallInputAlphabet() != b.getCallInputAlphabet()) {
-		out << "CallInputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getCallInputAlphabet(), b.getCallInputAlphabet());
-	}
-
-	if(a.getReturnInputAlphabet() != b.getReturnInputAlphabet()) {
-		out << "ReturnInputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getReturnInputAlphabet(), b.getReturnInputAlphabet());
-	}
-
-	if(a.getLocalInputAlphabet() != b.getLocalInputAlphabet()) {
-		out << "LocalInputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getLocalInputAlphabet(), b.getLocalInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
-		out << "BottomOfTheStackSymbol" << std::endl;
-
-		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getCallTransitions() != b.getCallTransitions()) {
-		out << "CallTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getCallTransitions(), b.getCallTransitions());
-	}
-
-	if(a.getReturnTransitions() != b.getReturnTransitions()) {
-		out << "ReturnTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getReturnTransitions(), b.getReturnTransitions());
-	}
-
-	if(a.getLocalTransitions() != b.getLocalTransitions()) {
-		out << "LocalTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getLocalTransitions(), b.getLocalTransitions());
-	}
-}
-
-template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialStates() != b.getInitialStates()) {
-		out << "Initial states" << std::endl;
-
-		AuxCompare::setCompare(a.getInitialStates(), b.getInitialStates());
-	}
-
-	if(a.getCallInputAlphabet() != b.getCallInputAlphabet()) {
-		out << "CallInputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getCallInputAlphabet(), b.getCallInputAlphabet());
-	}
-
-	if(a.getReturnInputAlphabet() != b.getReturnInputAlphabet()) {
-		out << "ReturnInputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getReturnInputAlphabet(), b.getReturnInputAlphabet());
-	}
-
-	if(a.getLocalInputAlphabet() != b.getLocalInputAlphabet()) {
-		out << "LocalInputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getLocalInputAlphabet(), b.getLocalInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
-		out << "BottomOfTheStackSymbol" << std::endl;
-
-		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getCallTransitions() != b.getCallTransitions()) {
-		out << "CallTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getCallTransitions(), b.getCallTransitions());
-	}
-
-	if(a.getReturnTransitions() != b.getReturnTransitions()) {
-		out << "ReturnTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getReturnTransitions(), b.getReturnTransitions());
-	}
-
-	if(a.getLocalTransitions() != b.getLocalTransitions()) {
-		out << "LocalTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getLocalTransitions(), b.getLocalTransitions());
-	}
-}
-
-template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
-		out << "BottomOfTheStackSymbol" << std::endl;
-
-		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getCallTransitions() != b.getCallTransitions()) {
-		out << "CallTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getCallTransitions(), b.getCallTransitions());
-	}
-
-	if(a.getReturnTransitions() != b.getReturnTransitions()) {
-		out << "ReturnTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getReturnTransitions(), b.getReturnTransitions());
-	}
-
-	if(a.getLocalTransitions() != b.getLocalTransitions()) {
-		out << "LocalTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getLocalTransitions(), b.getLocalTransitions());
-	}
-}
-
-template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialStates() != b.getInitialStates()) {
-		out << "Initial states" << std::endl;
-
-		AuxCompare::setCompare(a.getInitialStates(), b.getInitialStates());
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
-		out << "BottomOfTheStackSymbol" << std::endl;
-
-		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getCallTransitions() != b.getCallTransitions()) {
-		out << "CallTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getCallTransitions(), b.getCallTransitions());
-	}
-
-	if(a.getReturnTransitions() != b.getReturnTransitions()) {
-		out << "ReturnTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getReturnTransitions(), b.getReturnTransitions());
-	}
-
-	if(a.getLocalTransitions() != b.getLocalTransitions()) {
-		out << "LocalTransitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getLocalTransitions(), b.getLocalTransitions());
-	}
-}
-
-template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		out << "InitialSymbol" << std::endl;
-
-		out << "< " << a.getInitialSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		out << "StackAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
-	}
-
-	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		out << "InitialSymbol" << std::endl;
-
-		out << "< " << a.getInitialSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialSymbol() << std::endl;
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template<class SymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::OneTapeDTM < SymbolType, StateType > & a, const automaton::OneTapeDTM < SymbolType, StateType > & b, std::ostream & out ) {
-	out << "AutomatonCompareer" << std::endl;
-
-	if(a.getBlankSymbol() != b.getBlankSymbol()) {
-		out << "Blank symbol" << std::endl;
-
-		out << "< " << a.getBlankSymbol() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getBlankSymbol() << std::endl;
-	}
-
-	if(a.getFinalStates() != b.getFinalStates()){
-		out << "FinalStates" << std::endl;
-
-		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
-	}
-
-	if(a.getInitialState() != b.getInitialState()) {
-		out << "Initial state" << std::endl;
-
-		out << "< " << a.getInitialState() << std::endl;
-		out << "---" << std::endl;
-		out << "> " << b.getInitialState() << std::endl;
-	}
-
-	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		out << "InputAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
-	}
-
-	if(a.getStates() != b.getStates()) {
-		out << "States" << std::endl;
-
-		AuxCompare::setCompare(a.getStates(), b.getStates());
-	}
-
-	if(a.getTapeAlphabet() != b.getTapeAlphabet()) {
-		out << "TapeAlphabet" << std::endl;
-
-		AuxCompare::setCompare(a.getTapeAlphabet(), b.getTapeAlphabet());
-	}
-
-	if(a.getTransitions() != b.getTransitions()) {
-		out << "Transitions" << std::endl;
-
-		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
-	}
-}
-
-template < class T>
-int AutomatonCompare::compare(const T & a, const T & b, std::ostream & out) {
-	if(!AutomatonCompare::testCompare(a, b)) {
-	  AutomatonCompare::printCompare(a, b, out);
-	  return 1;
-	} else {
-	  return 0;
-	}
-}
-
 } /* namespace compare */
 
 #endif /* AUTOMATON_COMPARE_H_ */
diff --git a/alib2aux/src/compare/AutomatonDiff.cpp b/alib2aux/src/compare/AutomatonDiff.cpp
new file mode 100644
index 0000000000..3dcd3b2395
--- /dev/null
+++ b/alib2aux/src/compare/AutomatonDiff.cpp
@@ -0,0 +1,40 @@
+/*
+ * AutomatonDiff.cpp
+ *
+ *  Created on: Apr 1, 2013
+ *      Author: martin
+ */
+
+#include "AutomatonDiff.h"
+#include <registration/AlgoRegistration.hpp>
+
+namespace compare {
+
+auto AutomatonDiffDFA = registration::OverloadRegister < AutomatonDiff, int, automaton::DFA < >, automaton::DFA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffNFA = registration::OverloadRegister < AutomatonDiff, int, automaton::NFA < > , automaton::NFA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffMultiInitialStateNFA = registration::OverloadRegister < AutomatonDiff, int, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffEpsilonNFA = registration::OverloadRegister < AutomatonDiff, int, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffExtendedNFA = registration::OverloadRegister < AutomatonDiff, int, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffCompactNFA = registration::OverloadRegister < AutomatonDiff, int, automaton::CompactNFA < >, automaton::CompactNFA < > > ( AutomatonDiff::diff );
+
+auto AutomatonDiffDFTA = registration::OverloadRegister < AutomatonDiff, int, automaton::DFTA < >, automaton::DFTA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffNFTA = registration::OverloadRegister < AutomatonDiff, int, automaton::NFTA < >, automaton::NFTA < > > ( AutomatonDiff::diff );
+
+auto AutomatonDiffDPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::DPDA < >, automaton::DPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffNPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::NPDA < >, automaton::NPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffInputDrivenDPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffInputDrivenNPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::InputDrivenNPDA < >, automaton::InputDrivenNPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffVisiblyPushdownDPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffVisiblyPushdownNPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::VisiblyPushdownNPDA < >, automaton::VisiblyPushdownNPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffRealTimeHeightDeterministicDPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffRealTimeHeightDeterministicNPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::RealTimeHeightDeterministicNPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffSinglePopDPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > > ( AutomatonDiff::diff );
+auto AutomatonDiffSinglePopNPDA = registration::OverloadRegister < AutomatonDiff, int, automaton::SinglePopNPDA < >, automaton::SinglePopNPDA < > > ( AutomatonDiff::diff );
+
+auto AutomatonDiffOneTapeDTM = registration::OverloadRegister < AutomatonDiff, int, automaton::OneTapeDTM < >, automaton::OneTapeDTM < > > ( AutomatonDiff::diff );
+
+int AutomatonDiff::diff(const automaton::Automaton& a, const automaton::Automaton& b, std::ostream & out ) {
+	return dispatch(a.getData(), b.getData(), out);
+}
+
+} /* namespace compare */
diff --git a/alib2aux/src/compare/AutomatonDiff.h b/alib2aux/src/compare/AutomatonDiff.h
new file mode 100644
index 0000000000..041c45e394
--- /dev/null
+++ b/alib2aux/src/compare/AutomatonDiff.h
@@ -0,0 +1,1044 @@
+/*
+ * AutomatonDiff.h
+ *
+ *  Created on: Apr 1, 2013
+ *      Author: honza
+ */
+
+#ifndef AUTOMATON_DIFF_H_
+#define AUTOMATON_DIFF_H_
+
+#include <core/multipleDispatch.hpp>
+
+#include <compare/DiffAux.h>
+#include <compare/AutomatonCompare.h>
+
+#include <automaton/Automaton.h>
+#include <automaton/AutomatonFeatures.h>
+#include <set>
+#include <list>
+#include <map>
+#include <utility>
+#include <vector>
+#include <iostream>
+#include <ostream>
+
+#include "automaton/FSM/DFA.h"
+#include "automaton/FSM/NFA.h"
+#include "automaton/FSM/MultiInitialStateNFA.h"
+#include "automaton/FSM/EpsilonNFA.h"
+#include "automaton/FSM/ExtendedNFA.h"
+#include "automaton/FSM/CompactNFA.h"
+#include "automaton/TA/DFTA.h"
+#include "automaton/TA/NFTA.h"
+#include "automaton/PDA/NPDA.h"
+#include "automaton/PDA/DPDA.h"
+#include "automaton/PDA/InputDrivenNPDA.h"
+#include "automaton/PDA/InputDrivenDPDA.h"
+#include "automaton/PDA/VisiblyPushdownNPDA.h"
+#include "automaton/PDA/VisiblyPushdownDPDA.h"
+#include "automaton/PDA/RealTimeHeightDeterministicNPDA.h"
+#include "automaton/PDA/RealTimeHeightDeterministicDPDA.h"
+#include "automaton/PDA/SinglePopNPDA.h"
+#include "automaton/PDA/SinglePopDPDA.h"
+#include "automaton/TM/OneTapeDTM.h"
+
+namespace compare {
+
+class AutomatonDiff : public alib::MultipleDispatch < AutomatonDiff, int, ext::tuple < >, ext::tuple < const automaton::AutomatonBase &, const automaton::AutomatonBase & >, ext::tuple < std::ostream & > > {
+private:
+	template<class SymbolType, class StateType>
+	static void printDiff(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b, std::ostream & out );
+
+	template<class SymbolType, class StateType>
+	static void printDiff(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b, std::ostream & out );
+
+	template<class SymbolType, class StateType>
+	static void printDiff(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b, std::ostream & out );
+
+	template<class SymbolType, class EpsilonType, class StateType>
+	static void printDiff(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b, std::ostream & out );
+
+	template<class SymbolType, class StateType>
+	static void printDiff(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b, std::ostream & out );
+
+	template<class SymbolType, class StateType>
+	static void printDiff(const automaton::CompactNFA < SymbolType, StateType > & a, const automaton::CompactNFA < SymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class SymbolType, class RankType, class StateType>
+	static void printDiff(const automaton::DFTA < SymbolType, RankType, StateType > & a, const automaton::DFTA < SymbolType, RankType, StateType > & b, std::ostream & out );
+
+	template<class SymbolType, class RankType, class StateType>
+	static void printDiff(const automaton::NFTA < SymbolType, RankType, StateType > & a, const automaton::NFTA < SymbolType, RankType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+	static void printDiff(const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out );
+
+	template<class SymbolType, class StateType>
+	static void printDiff(const automaton::OneTapeDTM < SymbolType, StateType > & a, const automaton::OneTapeDTM < SymbolType, StateType > & b, std::ostream & out );
+public:
+	template<class T>
+	static int diff(const T & a, const T & b, std::ostream & out );
+
+	static int diff(const automaton::Automaton& a, const automaton::Automaton& b, std::ostream & out );
+};
+
+template<class SymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class SymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialStates() != b.getInitialStates()) {
+		out << "InitialStates" << std::endl;
+
+		DiffAux::setDiff(a.getInitialStates(), b.getInitialStates());
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class SymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class SymbolType, class EpsilonType, class StateType>
+void AutomatonDiff::printDiff(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class SymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class SymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::CompactNFA < SymbolType, StateType > & a, const automaton::CompactNFA < SymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class SymbolType, class RankType, class StateType>
+void AutomatonDiff::printDiff(const automaton::DFTA < SymbolType, RankType, StateType > & a, const automaton::DFTA < SymbolType, RankType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class SymbolType, class RankType, class StateType>
+void AutomatonDiff::printDiff(const automaton::NFTA < SymbolType, RankType, StateType > & a, const automaton::NFTA < SymbolType, RankType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getInitialSymbol() != b.getInitialSymbol()) {
+		out << "InitialSymbol" << std::endl;
+
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getInitialSymbol() != b.getInitialSymbol()) {
+		out << "InitialSymbol" << std::endl;
+
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getInitialSymbol() != b.getInitialSymbol()) {
+		out << "InitialSymbol" << std::endl;
+
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getPushdownStoreOperations() != b.getPushdownStoreOperations()) {
+		out << "PushdownStoreOperations" << std::endl;
+
+		DiffAux::mapDiff(a.getPushdownStoreOperations(), b.getPushdownStoreOperations());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getInitialSymbol() != b.getInitialSymbol()) {
+		out << "InitialSymbol" << std::endl;
+
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getPushdownStoreOperations() != b.getPushdownStoreOperations()) {
+		out << "PushdownStoreOperations" << std::endl;
+
+		DiffAux::mapDiff(a.getPushdownStoreOperations(), b.getPushdownStoreOperations());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getCallInputAlphabet() != b.getCallInputAlphabet()) {
+		out << "CallInputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getCallInputAlphabet(), b.getCallInputAlphabet());
+	}
+
+	if(a.getReturnInputAlphabet() != b.getReturnInputAlphabet()) {
+		out << "ReturnInputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getReturnInputAlphabet(), b.getReturnInputAlphabet());
+	}
+
+	if(a.getLocalInputAlphabet() != b.getLocalInputAlphabet()) {
+		out << "LocalInputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getLocalInputAlphabet(), b.getLocalInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
+		out << "BottomOfTheStackSymbol" << std::endl;
+
+		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getCallTransitions() != b.getCallTransitions()) {
+		out << "CallTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getCallTransitions(), b.getCallTransitions());
+	}
+
+	if(a.getReturnTransitions() != b.getReturnTransitions()) {
+		out << "ReturnTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getReturnTransitions(), b.getReturnTransitions());
+	}
+
+	if(a.getLocalTransitions() != b.getLocalTransitions()) {
+		out << "LocalTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getLocalTransitions(), b.getLocalTransitions());
+	}
+}
+
+template<class InputSymbolType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & a, const automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialStates() != b.getInitialStates()) {
+		out << "Initial states" << std::endl;
+
+		DiffAux::setDiff(a.getInitialStates(), b.getInitialStates());
+	}
+
+	if(a.getCallInputAlphabet() != b.getCallInputAlphabet()) {
+		out << "CallInputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getCallInputAlphabet(), b.getCallInputAlphabet());
+	}
+
+	if(a.getReturnInputAlphabet() != b.getReturnInputAlphabet()) {
+		out << "ReturnInputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getReturnInputAlphabet(), b.getReturnInputAlphabet());
+	}
+
+	if(a.getLocalInputAlphabet() != b.getLocalInputAlphabet()) {
+		out << "LocalInputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getLocalInputAlphabet(), b.getLocalInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
+		out << "BottomOfTheStackSymbol" << std::endl;
+
+		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getCallTransitions() != b.getCallTransitions()) {
+		out << "CallTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getCallTransitions(), b.getCallTransitions());
+	}
+
+	if(a.getReturnTransitions() != b.getReturnTransitions()) {
+		out << "ReturnTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getReturnTransitions(), b.getReturnTransitions());
+	}
+
+	if(a.getLocalTransitions() != b.getLocalTransitions()) {
+		out << "LocalTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getLocalTransitions(), b.getLocalTransitions());
+	}
+}
+
+template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
+		out << "BottomOfTheStackSymbol" << std::endl;
+
+		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getCallTransitions() != b.getCallTransitions()) {
+		out << "CallTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getCallTransitions(), b.getCallTransitions());
+	}
+
+	if(a.getReturnTransitions() != b.getReturnTransitions()) {
+		out << "ReturnTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getReturnTransitions(), b.getReturnTransitions());
+	}
+
+	if(a.getLocalTransitions() != b.getLocalTransitions()) {
+		out << "LocalTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getLocalTransitions(), b.getLocalTransitions());
+	}
+}
+
+template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialStates() != b.getInitialStates()) {
+		out << "Initial states" << std::endl;
+
+		DiffAux::setDiff(a.getInitialStates(), b.getInitialStates());
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
+		out << "BottomOfTheStackSymbol" << std::endl;
+
+		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getCallTransitions() != b.getCallTransitions()) {
+		out << "CallTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getCallTransitions(), b.getCallTransitions());
+	}
+
+	if(a.getReturnTransitions() != b.getReturnTransitions()) {
+		out << "ReturnTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getReturnTransitions(), b.getReturnTransitions());
+	}
+
+	if(a.getLocalTransitions() != b.getLocalTransitions()) {
+		out << "LocalTransitions" << std::endl;
+
+		DiffAux::mapDiff(a.getLocalTransitions(), b.getLocalTransitions());
+	}
+}
+
+template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getInitialSymbol() != b.getInitialSymbol()) {
+		out << "InitialSymbol" << std::endl;
+
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & a, const automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
+		out << "StackAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
+	}
+
+	if(a.getInitialSymbol() != b.getInitialSymbol()) {
+		out << "InitialSymbol" << std::endl;
+
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template<class SymbolType, class StateType>
+void AutomatonDiff::printDiff(const automaton::OneTapeDTM < SymbolType, StateType > & a, const automaton::OneTapeDTM < SymbolType, StateType > & b, std::ostream & out ) {
+	out << "AutomatonCompareer" << std::endl;
+
+	if(a.getBlankSymbol() != b.getBlankSymbol()) {
+		out << "Blank symbol" << std::endl;
+
+		out << "< " << a.getBlankSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBlankSymbol() << std::endl;
+	}
+
+	if(a.getFinalStates() != b.getFinalStates()){
+		out << "FinalStates" << std::endl;
+
+		DiffAux::setDiff(a.getFinalStates(), b.getFinalStates());
+	}
+
+	if(a.getInitialState() != b.getInitialState()) {
+		out << "Initial state" << std::endl;
+
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
+	}
+
+	if(a.getInputAlphabet() != b.getInputAlphabet()) {
+		out << "InputAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+	}
+
+	if(a.getStates() != b.getStates()) {
+		out << "States" << std::endl;
+
+		DiffAux::setDiff(a.getStates(), b.getStates());
+	}
+
+	if(a.getTapeAlphabet() != b.getTapeAlphabet()) {
+		out << "TapeAlphabet" << std::endl;
+
+		DiffAux::setDiff(a.getTapeAlphabet(), b.getTapeAlphabet());
+	}
+
+	if(a.getTransitions() != b.getTransitions()) {
+		out << "Transitions" << std::endl;
+
+		DiffAux::mapDiff(a.getTransitions(), b.getTransitions());
+	}
+}
+
+template < class T>
+int AutomatonDiff::diff(const T & a, const T & b, std::ostream & out) {
+	if(!AutomatonCompare::compare(a, b)) {
+		AutomatonDiff::printDiff(a, b, out);
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+} /* namespace compare */
+
+#endif /* AUTOMATON_DIFF_H_ */
diff --git a/alib2aux/src/compare/AuxCompare.h b/alib2aux/src/compare/DiffAux.h
similarity index 78%
rename from alib2aux/src/compare/AuxCompare.h
rename to alib2aux/src/compare/DiffAux.h
index 48003d1648..fc4c0453db 100644
--- a/alib2aux/src/compare/AuxCompare.h
+++ b/alib2aux/src/compare/DiffAux.h
@@ -1,12 +1,12 @@
 /*
- * AuxCompare.h
+ * DiffAux.h
  *
  *  Created on: Apr 1, 2013
  *      Author: honza
  */
 
-#ifndef AUX_COMPARE_H_
-#define AUX_COMPARE_H_
+#ifndef _DIFF_AUX_H_
+#define _DIFF_AUX_H_
 
 #include <set>
 #include <list>
@@ -16,20 +16,20 @@
 
 namespace compare {
 
-class AuxCompare {
+class DiffAux {
 public:
 	template < class T >
-	static void setCompare ( const ext::set < T > & a, const ext::set < T > & b );
+	static void setDiff ( const ext::set < T > & a, const ext::set < T > & b );
 	template < class T >
-	static void vectorCompare ( const ext::vector < T > & a, const ext::vector < T > & b );
+	static void vectorDiff ( const ext::vector < T > & a, const ext::vector < T > & b );
 	template < class T >
-	static void listCompare ( const ext::list < T > & a, const ext::list < T > & b );
+	static void listDiff ( const ext::list < T > & a, const ext::list < T > & b );
 	template < class T, class R >
-	static void mapCompare ( const ext::map < T, R > & a, const ext::map < T, R > & b );
+	static void mapDiff ( const ext::map < T, R > & a, const ext::map < T, R > & b );
 };
 
 template <class T>
-void AuxCompare::setCompare(const ext::set<T> &a, const ext::set<T> &b) {
+void DiffAux::setDiff(const ext::set<T> &a, const ext::set<T> &b) {
 	ext::set<T> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -46,7 +46,7 @@ void AuxCompare::setCompare(const ext::set<T> &a, const ext::set<T> &b) {
 }
 
 template < class T >
-void AuxCompare::vectorCompare ( const ext::vector < T > & a, const ext::vector < T > & b ) {
+void DiffAux::vectorDiff ( const ext::vector < T > & a, const ext::vector < T > & b ) {
 	ext::vector < T > aMinusB;
 	std::set_difference ( a.begin ( ), a.end ( ), b.begin ( ), b.end ( ), std::inserter ( aMinusB, aMinusB.begin ( ) ) );
 
@@ -63,7 +63,7 @@ void AuxCompare::vectorCompare ( const ext::vector < T > & a, const ext::vector
 }
 
 template <class T>
-void AuxCompare::listCompare(const ext::list<T> &a, const ext::list<T> &b) {
+void DiffAux::listDiff(const ext::list<T> &a, const ext::list<T> &b) {
 	ext::list<T> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -80,7 +80,7 @@ void AuxCompare::listCompare(const ext::list<T> &a, const ext::list<T> &b) {
 }
 
 template <class T, class R>
-void AuxCompare::mapCompare(const ext::map<T, R> &a, const ext::map<T, R> &b) {
+void DiffAux::mapDiff(const ext::map<T, R> &a, const ext::map<T, R> &b) {
 	ext::map<T, R> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -98,4 +98,4 @@ void AuxCompare::mapCompare(const ext::map<T, R> &a, const ext::map<T, R> &b) {
 
 } /* namespace compare */
 
-#endif /* AUX_COMPARE_H_ */
+#endif /* _DIFF_AUX_H_ */
diff --git a/alib2aux/src/compare/GrammarCompare.h b/alib2aux/src/compare/GrammarCompare.h
index 8c141200c3..2736bd449a 100644
--- a/alib2aux/src/compare/GrammarCompare.h
+++ b/alib2aux/src/compare/GrammarCompare.h
@@ -10,7 +10,7 @@
 
 #include <core/multipleDispatch.hpp>
 
-#include <compare/AuxCompare.h>
+#include <compare/DiffAux.h>
 
 #include <grammar/Grammar.h>
 #include <grammar/GrammarFeatures.h>
@@ -43,69 +43,69 @@ namespace compare {
 class GrammarCompare : public alib::MultipleDispatch < GrammarCompare, int, ext::tuple < >, ext::tuple < const grammar::GrammarBase &, const grammar::GrammarBase & >, ext::tuple < std::ostream & > > {
 private:
 	template < class SymbolType >
-	static bool testCompare(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b);
+	static bool testDiff(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b);
+	static bool testDiff(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b);
+	static bool testDiff(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b);
+	static bool testDiff(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b);
+	static bool testDiff(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b);
+	static bool testDiff(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b);
+	static bool testDiff(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b);
+	static bool testDiff(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b);
+	static bool testDiff(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b);
+	static bool testDiff(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b);
+	static bool testDiff(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b);
+	static bool testDiff(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b);
+	static bool testDiff(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b);
 	template < class SymbolType >
-	static void printCompare(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b, std::ostream & out );
+	static void printDiff(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b, std::ostream & out );
 public:
 	template < class T >
 	static int compare(const T & a, const T & b, std::ostream & out );
@@ -114,7 +114,7 @@ public:
 };
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -122,7 +122,7 @@ bool GrammarCompare::testCompare(const grammar::LeftLG < SymbolType > & a, const
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -130,7 +130,7 @@ bool GrammarCompare::testCompare(const grammar::LeftRG < SymbolType > & a, const
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -138,7 +138,7 @@ bool GrammarCompare::testCompare(const grammar::RightLG < SymbolType > & a, cons
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -146,7 +146,7 @@ bool GrammarCompare::testCompare(const grammar::RightRG < SymbolType > & a, cons
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -154,7 +154,7 @@ bool GrammarCompare::testCompare(const grammar::LG < SymbolType > & a, const gra
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -162,7 +162,7 @@ bool GrammarCompare::testCompare(const grammar::CFG < SymbolType > & a, const gr
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -170,7 +170,7 @@ bool GrammarCompare::testCompare(const grammar::EpsilonFreeCFG < SymbolType > &
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -178,7 +178,7 @@ bool GrammarCompare::testCompare(const grammar::CNF < SymbolType > & a, const gr
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -186,7 +186,7 @@ bool GrammarCompare::testCompare(const grammar::GNF < SymbolType > & a, const gr
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -194,7 +194,7 @@ bool GrammarCompare::testCompare(const grammar::CSG < SymbolType > & a, const gr
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -202,7 +202,7 @@ bool GrammarCompare::testCompare(const grammar::NonContractingGrammar < SymbolTy
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -210,7 +210,7 @@ bool GrammarCompare::testCompare(const grammar::ContextPreservingUnrestrictedGra
 }
 
 template < class SymbolType >
-bool GrammarCompare::testCompare(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b) {
+bool GrammarCompare::testDiff(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 //			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    &&
@@ -218,19 +218,19 @@ bool GrammarCompare::testCompare(const grammar::UnrestrictedGrammar < SymbolType
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -244,24 +244,24 @@ void GrammarCompare::printCompare(const grammar::LeftLG < SymbolType > & a, cons
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -275,24 +275,24 @@ void GrammarCompare::printCompare(const grammar::LeftRG < SymbolType > & a, cons
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -306,24 +306,24 @@ void GrammarCompare::printCompare(const grammar::RightLG < SymbolType > & a, con
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -337,24 +337,24 @@ void GrammarCompare::printCompare(const grammar::RightRG < SymbolType > & a, con
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -368,24 +368,24 @@ void GrammarCompare::printCompare(const grammar::LG < SymbolType > & a, const gr
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -399,24 +399,24 @@ void GrammarCompare::printCompare(const grammar::CFG < SymbolType > & a, const g
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -430,24 +430,24 @@ void GrammarCompare::printCompare(const grammar::EpsilonFreeCFG < SymbolType > &
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -461,24 +461,24 @@ void GrammarCompare::printCompare(const grammar::CNF < SymbolType > & a, const g
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -492,24 +492,24 @@ void GrammarCompare::printCompare(const grammar::GNF < SymbolType > & a, const g
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -523,24 +523,24 @@ void GrammarCompare::printCompare(const grammar::CSG < SymbolType > & a, const g
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -554,24 +554,24 @@ void GrammarCompare::printCompare(const grammar::NonContractingGrammar < SymbolT
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -585,24 +585,24 @@ void GrammarCompare::printCompare(const grammar::ContextPreservingUnrestrictedGr
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b, std::ostream & out ) {
+void GrammarCompare::printDiff(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b, std::ostream & out ) {
 	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		out << "Nonterminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		DiffAux::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		out << "Rules" << std::endl;
 
-		AuxCompare::mapCompare(a.getRules(), b.getRules());
+		DiffAux::mapDiff(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -616,14 +616,14 @@ void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar < SymbolTyp
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		out << "Terminal alphabet" << std::endl;
 
-		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		DiffAux::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class T >
 int GrammarCompare::compare(const T & a, const T & b, std::ostream & out ) {
-	if(!GrammarCompare::testCompare(a, b)) {
-	  GrammarCompare::printCompare ( a, b, out );
+	if(!GrammarCompare::testDiff(a, b)) {
+	  GrammarCompare::printDiff ( a, b, out );
 	  return 1;
 	} else {
 	  return 0;
diff --git a/alib2aux/src/compare/StringCompare.h b/alib2aux/src/compare/StringCompare.h
index 61dc8c1a55..d5b0c5bf63 100644
--- a/alib2aux/src/compare/StringCompare.h
+++ b/alib2aux/src/compare/StringCompare.h
@@ -10,7 +10,7 @@
 
 #include <core/multipleDispatch.hpp>
 
-#include <compare/AuxCompare.h>
+#include <compare/DiffAux.h>
 
 #include <string/String.h>
 #include <string/StringFeatures.h>
@@ -26,14 +26,14 @@ namespace compare {
 class StringCompare : public alib::MultipleDispatch < StringCompare, int, ext::tuple < >, ext::tuple < const string::StringBase &, const string::StringBase & >, ext::tuple < std::ostream & > > {
 private:
 	template < class SymbolType >
-	static bool testCompare ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b );
+	static bool testDiff ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b );
 	template < class SymbolType >
-	static void printCompare ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b, std::ostream & out );
+	static void printDiff ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b, std::ostream & out );
 
 	template < class SymbolType >
-	static bool testCompare ( const string::CyclicString < SymbolType > & a, const string::CyclicString < SymbolType > & b );
+	static bool testDiff ( const string::CyclicString < SymbolType > & a, const string::CyclicString < SymbolType > & b );
 	template < class SymbolType >
-	static void printCompare ( const string::CyclicString < SymbolType > & a, const string::CyclicString < SymbolType > & b, std::ostream & out );
+	static void printDiff ( const string::CyclicString < SymbolType > & a, const string::CyclicString < SymbolType > & b, std::ostream & out );
 
 public:
 	template < class T >
@@ -43,42 +43,42 @@ public:
 };
 
 template < class SymbolType >
-bool StringCompare::testCompare ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b ) {
+bool StringCompare::testDiff ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b ) {
 	return		a.getAlphabet ( ) == b.getAlphabet ( ) &&
 			a.getContent ( ) == b.getContent ( ) ;
 }
 
 template < class SymbolType >
-bool StringCompare::testCompare ( const string::CyclicString < SymbolType > &, const string::CyclicString < SymbolType > & ) {
+bool StringCompare::testDiff ( const string::CyclicString < SymbolType > &, const string::CyclicString < SymbolType > & ) {
 	throw "NYI";
 }
 
 template < class SymbolType >
-void StringCompare::printCompare ( const string::CyclicString < SymbolType > &, const string::CyclicString < SymbolType > &, std::ostream & ) {
+void StringCompare::printDiff ( const string::CyclicString < SymbolType > &, const string::CyclicString < SymbolType > &, std::ostream & ) {
 	throw "NYI";
 }
 
 template < class SymbolType >
-void StringCompare::printCompare ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b, std::ostream & out ) {
+void StringCompare::printDiff ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b, std::ostream & out ) {
 	out << "StringCompare" << std::endl;
 
 	if ( a.getAlphabet ( ) != b.getAlphabet ( ) ) {
 		out << "Alphabet" << std::endl;
 
-		AuxCompare::setCompare ( a.getAlphabet ( ), b.getAlphabet ( ) );
+		DiffAux::setDiff ( a.getAlphabet ( ), b.getAlphabet ( ) );
 	}
 
 	if ( a.getContent ( ) != b.getContent ( ) ) {
 		out << "Content" << std::endl;
 
-		AuxCompare::vectorCompare ( a.getContent ( ), b.getContent ( ) );
+		DiffAux::vectorDiff ( a.getContent ( ), b.getContent ( ) );
 	}
 }
 
 template < class T >
 int StringCompare::compare ( const T & a, const T & b, std::ostream & out ) {
-	if ( !StringCompare::testCompare ( a, b ) ) {
-		StringCompare::printCompare ( a, b, out );
+	if ( !StringCompare::testDiff ( a, b ) ) {
+		StringCompare::printDiff ( a, b, out );
 		return 1;
 	} else {
 		return 0;
-- 
GitLab