From d69f4972893ee9bec57123f17de596dfeb51c481 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Sun, 13 Aug 2017 18:22:38 +0200
Subject: [PATCH] parametrized output stream on compare

---
 acompare2/src/acompare.cpp                |   6 +-
 alib2aux/src/compare/AutomatonCompare.cpp |   4 +-
 alib2aux/src/compare/AutomatonCompare.h   | 532 +++++++++++-----------
 alib2aux/src/compare/GrammarCompare.cpp   |   4 +-
 alib2aux/src/compare/GrammarCompare.h     | 270 +++++------
 alib2aux/src/compare/StringCompare.cpp    |   4 +-
 alib2aux/src/compare/StringCompare.h      |  24 +-
 7 files changed, 422 insertions(+), 422 deletions(-)

diff --git a/acompare2/src/acompare.cpp b/acompare2/src/acompare.cpp
index 5ff3e796cf..71d7d4927a 100644
--- a/acompare2/src/acompare.cpp
+++ b/acompare2/src/acompare.cpp
@@ -59,7 +59,7 @@ int main ( int argc, char * * argv ) {
 			measurements::end ( );
 			measurements::start ( "Compare", measurements::Type::MAIN );
 
-			res = compare::AutomatonCompare::compare ( automaton1, automaton2 );
+			res = compare::AutomatonCompare::compare ( 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 ) );
@@ -67,7 +67,7 @@ int main ( int argc, char * * argv ) {
 			measurements::end ( );
 			measurements::start ( "Compare", measurements::Type::MAIN );
 
-			res = compare::GrammarCompare::compare ( grammar1, grammar2 );
+			res = compare::GrammarCompare::compare ( grammar1, grammar2, std::cout );
 		} else if ( alib::XmlDataFactory::first < string::String > ( tokens1 ) && alib::XmlDataFactory::first < string::String > ( tokens2 ) ) {
 			string::String string1 = alib::XmlDataFactory::fromTokens ( std::move ( tokens1 ) );
 			string::String string2 = alib::XmlDataFactory::fromTokens ( std::move ( tokens2 ) );
@@ -75,7 +75,7 @@ int main ( int argc, char * * argv ) {
 			measurements::end ( );
 			measurements::start ( "Compare", measurements::Type::MAIN );
 
-			res = compare::StringCompare::compare ( string1, string2 );
+			res = compare::StringCompare::compare ( string1, string2, std::cout );
 		} else {
 			throw exception::CommonException ( "Only automata, grammars and strings can be compared." );
 		}
diff --git a/alib2aux/src/compare/AutomatonCompare.cpp b/alib2aux/src/compare/AutomatonCompare.cpp
index 1e95efbf0e..d5e15c3fd1 100644
--- a/alib2aux/src/compare/AutomatonCompare.cpp
+++ b/alib2aux/src/compare/AutomatonCompare.cpp
@@ -33,8 +33,8 @@ auto AutomatonCompareSinglePopNPDA = registration::OverloadRegister < AutomatonC
 
 auto AutomatonCompareOneTapeDTM = registration::OverloadRegister < AutomatonCompare, int, automaton::OneTapeDTM < >, automaton::OneTapeDTM < > > ( AutomatonCompare::compare );
 
-int AutomatonCompare::compare(const automaton::Automaton& a, const automaton::Automaton& b) {
-	return dispatch(a.getData(), b.getData());
+int AutomatonCompare::compare(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/AutomatonCompare.h b/alib2aux/src/compare/AutomatonCompare.h
index c5fff1bad8..3a85be61dd 100644
--- a/alib2aux/src/compare/AutomatonCompare.h
+++ b/alib2aux/src/compare/AutomatonCompare.h
@@ -44,107 +44,107 @@
 
 namespace compare {
 
-class AutomatonCompare : public alib::DoubleDispatch<AutomatonCompare, int, const automaton::AutomatonBase &, const automaton::AutomatonBase &> {
+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);
 	template<class SymbolType, class StateType>
-	static void printCompare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b);
+	static void printCompare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b, std::ostream & out );
 
 	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);
+	static void printCompare(const automaton::NFA < SymbolType, StateType > & a, const automaton::NFA < SymbolType, StateType > & b, std::ostream & out );
 
 	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);
+	static void printCompare(const automaton::MultiInitialStateNFA < SymbolType, StateType > & a, const automaton::MultiInitialStateNFA < SymbolType, StateType > & b, std::ostream & out );
 
 	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);
+	static void printCompare(const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & a, const automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > & b, std::ostream & out );
 
 	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);
+	static void printCompare(const automaton::ExtendedNFA < SymbolType, StateType > & a, const automaton::ExtendedNFA < SymbolType, StateType > & b, std::ostream & out );
 
 	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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	static void printCompare(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 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);
+	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);
+	static int compare(const T & a, const T & b, std::ostream & out );
 
-	static int compare(const automaton::Automaton& a, const automaton::Automaton& b);
+	static int compare(const automaton::Automaton& a, const automaton::Automaton& b, std::ostream & out );
 };
 
 template<class SymbolType, class StateType>
@@ -353,928 +353,928 @@ bool AutomatonCompare::testCompare(const automaton::OneTapeDTM < SymbolType, Sta
 }
 
 template<class SymbolType, class StateType>
-void AutomatonCompare::printCompare(const automaton::DFA < SymbolType, StateType > & a, const automaton::DFA < SymbolType, StateType > & b) {
-	std::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialStates() != b.getInitialStates()) {
-		std::cout << "InitialStates" << std::endl;
+		out << "InitialStates" << std::endl;
 
 		AuxCompare::setCompare(a.getInitialStates(), b.getInitialStates());
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		std::cout << "InitialSymbol" << std::endl;
+		out << "InitialSymbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		std::cout << "InitialSymbol" << std::endl;
+		out << "InitialSymbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		std::cout << "InitialSymbol" << std::endl;
+		out << "InitialSymbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getPushdownStoreOperations() != b.getPushdownStoreOperations()) {
-		std::cout << "PushdownStoreOperations" << std::endl;
+		out << "PushdownStoreOperations" << std::endl;
 
 		AuxCompare::mapCompare(a.getPushdownStoreOperations(), b.getPushdownStoreOperations());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		std::cout << "InitialSymbol" << std::endl;
+		out << "InitialSymbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getPushdownStoreOperations() != b.getPushdownStoreOperations()) {
-		std::cout << "PushdownStoreOperations" << std::endl;
+		out << "PushdownStoreOperations" << std::endl;
 
 		AuxCompare::mapCompare(a.getPushdownStoreOperations(), b.getPushdownStoreOperations());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getCallInputAlphabet() != b.getCallInputAlphabet()) {
-		std::cout << "CallInputAlphabet" << std::endl;
+		out << "CallInputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getCallInputAlphabet(), b.getCallInputAlphabet());
 	}
 
 	if(a.getReturnInputAlphabet() != b.getReturnInputAlphabet()) {
-		std::cout << "ReturnInputAlphabet" << std::endl;
+		out << "ReturnInputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getReturnInputAlphabet(), b.getReturnInputAlphabet());
 	}
 
 	if(a.getLocalInputAlphabet() != b.getLocalInputAlphabet()) {
-		std::cout << "LocalInputAlphabet" << std::endl;
+		out << "LocalInputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getLocalInputAlphabet(), b.getLocalInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
-		std::cout << "BottomOfTheStackSymbol" << std::endl;
+		out << "BottomOfTheStackSymbol" << std::endl;
 
-		std::cout << "< " << a.getBottomOfTheStackSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getBottomOfTheStackSymbol() << std::endl;
+		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getCallTransitions() != b.getCallTransitions()) {
-		std::cout << "CallTransitions" << std::endl;
+		out << "CallTransitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getCallTransitions(), b.getCallTransitions());
 	}
 
 	if(a.getReturnTransitions() != b.getReturnTransitions()) {
-		std::cout << "ReturnTransitions" << std::endl;
+		out << "ReturnTransitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getReturnTransitions(), b.getReturnTransitions());
 	}
 
 	if(a.getLocalTransitions() != b.getLocalTransitions()) {
-		std::cout << "LocalTransitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialStates() != b.getInitialStates()) {
-		std::cout << "Initial states" << std::endl;
+		out << "Initial states" << std::endl;
 
 		AuxCompare::setCompare(a.getInitialStates(), b.getInitialStates());
 	}
 
 	if(a.getCallInputAlphabet() != b.getCallInputAlphabet()) {
-		std::cout << "CallInputAlphabet" << std::endl;
+		out << "CallInputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getCallInputAlphabet(), b.getCallInputAlphabet());
 	}
 
 	if(a.getReturnInputAlphabet() != b.getReturnInputAlphabet()) {
-		std::cout << "ReturnInputAlphabet" << std::endl;
+		out << "ReturnInputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getReturnInputAlphabet(), b.getReturnInputAlphabet());
 	}
 
 	if(a.getLocalInputAlphabet() != b.getLocalInputAlphabet()) {
-		std::cout << "LocalInputAlphabet" << std::endl;
+		out << "LocalInputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getLocalInputAlphabet(), b.getLocalInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
-		std::cout << "BottomOfTheStackSymbol" << std::endl;
+		out << "BottomOfTheStackSymbol" << std::endl;
 
-		std::cout << "< " << a.getBottomOfTheStackSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getBottomOfTheStackSymbol() << std::endl;
+		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getCallTransitions() != b.getCallTransitions()) {
-		std::cout << "CallTransitions" << std::endl;
+		out << "CallTransitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getCallTransitions(), b.getCallTransitions());
 	}
 
 	if(a.getReturnTransitions() != b.getReturnTransitions()) {
-		std::cout << "ReturnTransitions" << std::endl;
+		out << "ReturnTransitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getReturnTransitions(), b.getReturnTransitions());
 	}
 
 	if(a.getLocalTransitions() != b.getLocalTransitions()) {
-		std::cout << "LocalTransitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
-		std::cout << "BottomOfTheStackSymbol" << std::endl;
+		out << "BottomOfTheStackSymbol" << std::endl;
 
-		std::cout << "< " << a.getBottomOfTheStackSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getBottomOfTheStackSymbol() << std::endl;
+		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getCallTransitions() != b.getCallTransitions()) {
-		std::cout << "CallTransitions" << std::endl;
+		out << "CallTransitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getCallTransitions(), b.getCallTransitions());
 	}
 
 	if(a.getReturnTransitions() != b.getReturnTransitions()) {
-		std::cout << "ReturnTransitions" << std::endl;
+		out << "ReturnTransitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getReturnTransitions(), b.getReturnTransitions());
 	}
 
 	if(a.getLocalTransitions() != b.getLocalTransitions()) {
-		std::cout << "LocalTransitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialStates() != b.getInitialStates()) {
-		std::cout << "Initial states" << std::endl;
+		out << "Initial states" << std::endl;
 
 		AuxCompare::setCompare(a.getInitialStates(), b.getInitialStates());
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getBottomOfTheStackSymbol() != b.getBottomOfTheStackSymbol()) {
-		std::cout << "BottomOfTheStackSymbol" << std::endl;
+		out << "BottomOfTheStackSymbol" << std::endl;
 
-		std::cout << "< " << a.getBottomOfTheStackSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getBottomOfTheStackSymbol() << std::endl;
+		out << "< " << a.getBottomOfTheStackSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBottomOfTheStackSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getCallTransitions() != b.getCallTransitions()) {
-		std::cout << "CallTransitions" << std::endl;
+		out << "CallTransitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getCallTransitions(), b.getCallTransitions());
 	}
 
 	if(a.getReturnTransitions() != b.getReturnTransitions()) {
-		std::cout << "ReturnTransitions" << std::endl;
+		out << "ReturnTransitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getReturnTransitions(), b.getReturnTransitions());
 	}
 
 	if(a.getLocalTransitions() != b.getLocalTransitions()) {
-		std::cout << "LocalTransitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		std::cout << "InitialSymbol" << std::endl;
+		out << "InitialSymbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getPushdownStoreAlphabet() != b.getPushdownStoreAlphabet()) {
-		std::cout << "StackAlphabet" << std::endl;
+		out << "StackAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getPushdownStoreAlphabet(), b.getPushdownStoreAlphabet());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()) {
-		std::cout << "InitialSymbol" << std::endl;
+		out << "InitialSymbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		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::cout << "AutomatonCompareer" << std::endl;
+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()) {
-		std::cout << "Blank symbol" << std::endl;
+		out << "Blank symbol" << std::endl;
 
-		std::cout << "< " << a.getBlankSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getBlankSymbol() << std::endl;
+		out << "< " << a.getBlankSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getBlankSymbol() << std::endl;
 	}
 
 	if(a.getFinalStates() != b.getFinalStates()){
-		std::cout << "FinalStates" << std::endl;
+		out << "FinalStates" << std::endl;
 
 		AuxCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
-		std::cout << "Initial state" << std::endl;
+		out << "Initial state" << std::endl;
 
-		std::cout << "< " << a.getInitialState() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialState() << std::endl;
+		out << "< " << a.getInitialState() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialState() << std::endl;
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
-		std::cout << "InputAlphabet" << std::endl;
+		out << "InputAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
-		std::cout << "States" << std::endl;
+		out << "States" << std::endl;
 
 		AuxCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTapeAlphabet() != b.getTapeAlphabet()) {
-		std::cout << "TapeAlphabet" << std::endl;
+		out << "TapeAlphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTapeAlphabet(), b.getTapeAlphabet());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
-		std::cout << "Transitions" << std::endl;
+		out << "Transitions" << std::endl;
 
 		AuxCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
 template < class T>
-int AutomatonCompare::compare(const T & a, const T & b) {
+int AutomatonCompare::compare(const T & a, const T & b, std::ostream & out) {
 	if(!AutomatonCompare::testCompare(a, b)) {
-	  AutomatonCompare::printCompare(a, b);
+	  AutomatonCompare::printCompare(a, b, out);
 	  return 1;
 	} else {
 	  return 0;
diff --git a/alib2aux/src/compare/GrammarCompare.cpp b/alib2aux/src/compare/GrammarCompare.cpp
index eb4f6399f6..c19a7ab88a 100644
--- a/alib2aux/src/compare/GrammarCompare.cpp
+++ b/alib2aux/src/compare/GrammarCompare.cpp
@@ -27,8 +27,8 @@ auto GrammarCompareContextPreservingUnrestrictedGrammar = registration::Overload
 
 auto GrammarCompareUnrestrictedGrammar = registration::OverloadRegister < GrammarCompare, int, grammar::UnrestrictedGrammar < >, grammar::UnrestrictedGrammar < > > ( GrammarCompare::compare );
 
-int GrammarCompare::compare(const grammar::Grammar& a, const grammar::Grammar& b) {
-	return dispatch(a.getData(), b.getData());
+int GrammarCompare::compare(const grammar::Grammar& a, const grammar::Grammar& b, std::ostream & out ) {
+	return dispatch(a.getData(), b.getData(), out);
 }
 
 } /* namespace compare */
diff --git a/alib2aux/src/compare/GrammarCompare.h b/alib2aux/src/compare/GrammarCompare.h
index 586503e0e4..8c141200c3 100644
--- a/alib2aux/src/compare/GrammarCompare.h
+++ b/alib2aux/src/compare/GrammarCompare.h
@@ -40,77 +40,77 @@
 
 namespace compare {
 
-class GrammarCompare : public alib::DoubleDispatch<GrammarCompare, int, const grammar::GrammarBase &, const grammar::GrammarBase &> {
+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);
 	template < class SymbolType >
-	static void printCompare(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b);
+	static void printCompare(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);
 	template < class SymbolType >
-	static void printCompare(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b);
+	static void printCompare(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);
+	static int compare(const T & a, const T & b, std::ostream & out );
 
-	static int compare(const grammar::Grammar& a, const grammar::Grammar& b);
+	static int compare(const grammar::Grammar& a, const grammar::Grammar& b, std::ostream & out );
 };
 
 template < class SymbolType >
@@ -218,412 +218,412 @@ bool GrammarCompare::testCompare(const grammar::UnrestrictedGrammar < SymbolType
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::LeftLG < SymbolType > & a, const grammar::LeftLG < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::LeftRG < SymbolType > & a, const grammar::LeftRG < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::RightLG < SymbolType > & a, const grammar::RightLG < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::RightRG < SymbolType > & a, const grammar::RightRG < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::LG < SymbolType > & a, const grammar::LG < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::CFG < SymbolType > & a, const grammar::CFG < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::EpsilonFreeCFG < SymbolType > & a, const grammar::EpsilonFreeCFG < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::CNF < SymbolType > & a, const grammar::CNF < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::GNF < SymbolType > & a, const grammar::GNF < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::CSG < SymbolType > & a, const grammar::CSG < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::NonContractingGrammar < SymbolType > & a, const grammar::NonContractingGrammar < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & a, const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class SymbolType >
-void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b) {
-	std::cout << "GrammarCompareer" << std::endl;
+void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar < SymbolType > & a, const grammar::UnrestrictedGrammar < SymbolType > & b, std::ostream & out ) {
+	out << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
-		std::cout << "Nonterminal alphabet" << std::endl;
+		out << "Nonterminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
-		std::cout << "Rules" << std::endl;
+		out << "Rules" << std::endl;
 
 		AuxCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
-		std::cout << "Initial symbol" << std::endl;
+		out << "Initial symbol" << std::endl;
 
-		std::cout << "< " << a.getInitialSymbol() << std::endl;
-		std::cout << "---" << std::endl;
-		std::cout << "> " << b.getInitialSymbol() << std::endl;
+		out << "< " << a.getInitialSymbol() << std::endl;
+		out << "---" << std::endl;
+		out << "> " << b.getInitialSymbol() << std::endl;
 	}
 
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
-		std::cout << "Terminal alphabet" << std::endl;
+		out << "Terminal alphabet" << std::endl;
 
 		AuxCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
 template < class T >
-int GrammarCompare::compare(const T & a, const T & b) {
+int GrammarCompare::compare(const T & a, const T & b, std::ostream & out ) {
 	if(!GrammarCompare::testCompare(a, b)) {
-	  GrammarCompare::printCompare(a, b);
+	  GrammarCompare::printCompare ( a, b, out );
 	  return 1;
 	} else {
 	  return 0;
diff --git a/alib2aux/src/compare/StringCompare.cpp b/alib2aux/src/compare/StringCompare.cpp
index 5322a7f2ea..ab1226a913 100644
--- a/alib2aux/src/compare/StringCompare.cpp
+++ b/alib2aux/src/compare/StringCompare.cpp
@@ -13,8 +13,8 @@ namespace compare {
 auto StringCompareLinear = registration::OverloadRegister < StringCompare, int, string::LinearString < >, string::LinearString < > > ( StringCompare::compare );
 auto StringCompareCyclic = registration::OverloadRegister < StringCompare, int, string::CyclicString < >, string::CyclicString < > > ( StringCompare::compare );
 
-int StringCompare::compare ( const string::String & a, const string::String & b ) {
-	return dispatch ( a.getData ( ), b.getData ( ) );
+int StringCompare::compare ( const string::String & a, const string::String & b, std::ostream & out ) {
+	return dispatch ( a.getData ( ), b.getData ( ), out );
 }
 
 } /* namespace compare */
diff --git a/alib2aux/src/compare/StringCompare.h b/alib2aux/src/compare/StringCompare.h
index aa3bd1356e..61dc8c1a55 100644
--- a/alib2aux/src/compare/StringCompare.h
+++ b/alib2aux/src/compare/StringCompare.h
@@ -23,23 +23,23 @@
 
 namespace compare {
 
-class StringCompare : public alib::DoubleDispatch < StringCompare, int, const string::StringBase &, const string::StringBase & > {
+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 );
 	template < class SymbolType >
-	static void printCompare ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b );
+	static void printCompare ( 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 );
 	template < class SymbolType >
-	static void printCompare ( const string::CyclicString < SymbolType > & a, const string::CyclicString < SymbolType > & b );
+	static void printCompare ( const string::CyclicString < SymbolType > & a, const string::CyclicString < SymbolType > & b, std::ostream & out );
 
 public:
 	template < class T >
-	static int compare ( const T & a, const T & b );
+	static int compare ( const T & a, const T & b, std::ostream & out );
 
-	static int compare ( const string::String & a, const string::String & b );
+	static int compare ( const string::String & a, const string::String & b, std::ostream & out );
 };
 
 template < class SymbolType >
@@ -54,31 +54,31 @@ bool StringCompare::testCompare ( const string::CyclicString < SymbolType > &, c
 }
 
 template < class SymbolType >
-void StringCompare::printCompare ( const string::CyclicString < SymbolType > &, const string::CyclicString < SymbolType > & ) {
+void StringCompare::printCompare ( 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::cout << "StringCompare" << std::endl;
+void StringCompare::printCompare ( const string::LinearString < SymbolType > & a, const string::LinearString < SymbolType > & b, std::ostream & out ) {
+	out << "StringCompare" << std::endl;
 
 	if ( a.getAlphabet ( ) != b.getAlphabet ( ) ) {
-		std::cout << "Alphabet" << std::endl;
+		out << "Alphabet" << std::endl;
 
 		AuxCompare::setCompare ( a.getAlphabet ( ), b.getAlphabet ( ) );
 	}
 
 	if ( a.getContent ( ) != b.getContent ( ) ) {
-		std::cout << "Content" << std::endl;
+		out << "Content" << std::endl;
 
 		AuxCompare::vectorCompare ( a.getContent ( ), b.getContent ( ) );
 	}
 }
 
 template < class T >
-int StringCompare::compare ( const T & a, const T & b ) {
+int StringCompare::compare ( const T & a, const T & b, std::ostream & out ) {
 	if ( !StringCompare::testCompare ( a, b ) ) {
-		StringCompare::printCompare ( a, b );
+		StringCompare::printCompare ( a, b, out );
 		return 1;
 	} else {
 		return 0;
-- 
GitLab