diff --git a/adiff2/makefile b/acompare2/makefile
similarity index 99%
rename from adiff2/makefile
rename to acompare2/makefile
index 37258c8aa489d608622f0f5a0e21d0bdc019d599..d942de9eb3a05457a3d3aaf5a78a9b90f640a6cd 100644
--- a/adiff2/makefile
+++ b/acompare2/makefile
@@ -1,5 +1,5 @@
 SHELL:=/bin/bash
-EXECUTABLE:=adiff2
+EXECUTABLE:=acompare2
 
 define NEW_LINE
 
diff --git a/adiff2/src/AutomatonDiff.cpp b/acompare2/src/AutomatonCompare.cpp
similarity index 61%
rename from adiff2/src/AutomatonDiff.cpp
rename to acompare2/src/AutomatonCompare.cpp
index 028602b3463b677d7945c069e23e0cbedb46eb8d..cec31280d9ca97de7388ecd935e1d89bba0b334d 100644
--- a/adiff2/src/AutomatonDiff.cpp
+++ b/acompare2/src/AutomatonCompare.cpp
@@ -1,11 +1,11 @@
 /*
- * AutomatonDiff.cpp
+ * AutomatonCompare.cpp
  *
  *  Created on: Apr 1, 2013
  *      Author: martin
  */
 
-#include "AutomatonDiff.h"
+#include "AutomatonCompare.h"
 #include "automaton/common/State.h"
 
 #include "automaton/Automaton.h"
@@ -31,7 +31,7 @@
 
 #include "exception/AlibException.h"
 
-bool AutomatonDiff::testDiff(const automaton::DFA& a, const automaton::DFA& b) {
+bool AutomatonCompare::testCompare(const automaton::DFA& a, const automaton::DFA& b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -39,7 +39,7 @@ bool AutomatonDiff::testDiff(const automaton::DFA& a, const automaton::DFA& b) {
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-bool AutomatonDiff::testDiff(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b) {
+bool AutomatonCompare::testCompare(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialStates()  == b.getInitialStates()  &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -47,7 +47,7 @@ bool AutomatonDiff::testDiff(const automaton::MultiInitialStateNFA& a, const aut
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-bool AutomatonDiff::testDiff(const automaton::NFA& a, const automaton::NFA& b) {
+bool AutomatonCompare::testCompare(const automaton::NFA& a, const automaton::NFA& b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -55,7 +55,7 @@ bool AutomatonDiff::testDiff(const automaton::NFA& a, const automaton::NFA& b) {
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-bool AutomatonDiff::testDiff(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b) {
+bool AutomatonCompare::testCompare(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -63,7 +63,7 @@ bool AutomatonDiff::testDiff(const automaton::EpsilonNFA& a, const automaton::Ep
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-bool AutomatonDiff::testDiff(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b) {
+bool AutomatonCompare::testCompare(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -71,7 +71,7 @@ bool AutomatonDiff::testDiff(const automaton::ExtendedNFA& a, const automaton::E
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-bool AutomatonDiff::testDiff(const automaton::CompactNFA& a, const automaton::CompactNFA& b) {
+bool AutomatonCompare::testCompare(const automaton::CompactNFA& a, const automaton::CompactNFA& b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -79,7 +79,7 @@ bool AutomatonDiff::testDiff(const automaton::CompactNFA& a, const automaton::Co
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-bool AutomatonDiff::testDiff(const automaton::NPDA& a, const automaton::NPDA& b) {
+bool AutomatonCompare::testCompare(const automaton::NPDA& a, const automaton::NPDA& b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialStates()  == b.getInitialStates()  &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -89,7 +89,7 @@ bool AutomatonDiff::testDiff(const automaton::NPDA& a, const automaton::NPDA& b)
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-bool AutomatonDiff::testDiff(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b) {
+bool AutomatonCompare::testCompare(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b) {
 	return  	a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialStates()  == b.getInitialStates()  &&
 //			a.getInputAlphabet()  == b.getInputAlphabet()  &&
@@ -99,7 +99,7 @@ bool AutomatonDiff::testDiff(const automaton::SinglePopNPDA& a, const automaton:
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-bool AutomatonDiff::testDiff(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b) {
+bool AutomatonCompare::testCompare(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b) {
 	return  	a.getBlankSymbol()    == b.getBlankSymbol()    &&
 			a.getFinalStates()    == b.getFinalStates()    &&
 			a.getInitialState()   == b.getInitialState()   &&
@@ -109,7 +109,7 @@ bool AutomatonDiff::testDiff(const automaton::OneTapeDTM& a, const automaton::On
 			a.getTransitions()    == b.getTransitions()    ;
 }
 
-template <class T> void AutomatonDiff::setDiff(const std::set<T> a, const std::set<T> b) {
+template <class T> void AutomatonCompare::setCompare(const std::set<T> a, const std::set<T> b) {
 	std::set<T> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -125,7 +125,7 @@ template <class T> void AutomatonDiff::setDiff(const std::set<T> a, const std::s
 	}
 }
 
-template <class T> void AutomatonDiff::listDiff(const std::list<T> a, const std::list<T> b) {
+template <class T> void AutomatonCompare::listCompare(const std::list<T> a, const std::list<T> b) {
 	std::list<T> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -141,7 +141,7 @@ template <class T> void AutomatonDiff::listDiff(const std::list<T> a, const std:
 	}
 }
 
-template <class T, class R> void AutomatonDiff::mapDiff(const std::map<T, R> a, const std::map<T, R> b) {
+template <class T, class R> void AutomatonCompare::mapCompare(const std::map<T, R> a, const std::map<T, R> b) {
 	std::map<T, R> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -157,13 +157,13 @@ template <class T, class R> void AutomatonDiff::mapDiff(const std::map<T, R> a,
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::DFA& a, const automaton::DFA& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::DFA& a, const automaton::DFA& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
@@ -177,63 +177,63 @@ void AutomatonDiff::printDiff(const automaton::DFA& a, const automaton::DFA& b)
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialStates() != b.getInitialStates()) {
 		std::cout << "InitialStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInitialStates(), b.getInitialStates());
+		AutomatonCompare::setCompare(a.getInitialStates(), b.getInitialStates());
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::NFA& a, const automaton::NFA& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::NFA& a, const automaton::NFA& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
@@ -247,29 +247,29 @@ void AutomatonDiff::printDiff(const automaton::NFA& a, const automaton::NFA& b)
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
@@ -283,29 +283,29 @@ void AutomatonDiff::printDiff(const automaton::EpsilonNFA& a, const automaton::E
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
@@ -319,29 +319,29 @@ void AutomatonDiff::printDiff(const automaton::ExtendedNFA& a, const automaton::
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::CompactNFA& a, const automaton::CompactNFA& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::CompactNFA& a, const automaton::CompactNFA& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
@@ -355,116 +355,116 @@ void AutomatonDiff::printDiff(const automaton::CompactNFA& a, const automaton::C
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::NPDA& a, const automaton::NPDA& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::NPDA& a, const automaton::NPDA& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialStates() != b.getInitialStates()){
 		std::cout << "InitialStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInitialStates(), b.getInitialStates());
+		AutomatonCompare::setCompare(a.getInitialStates(), b.getInitialStates());
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStackAlphabet() != b.getStackAlphabet()) {
 		std::cout << "StackAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStackAlphabet(), b.getStackAlphabet());
+		AutomatonCompare::setCompare(a.getStackAlphabet(), b.getStackAlphabet());
 	}
 
 	if(a.getInitialSymbols() != b.getInitialSymbols()) {
 		std::cout << "InitialSymbols" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInitialSymbols(), b.getInitialSymbols());
+		AutomatonCompare::setCompare(a.getInitialSymbols(), b.getInitialSymbols());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialStates() != b.getInitialStates()){
 		std::cout << "InitialStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInitialStates(), b.getInitialStates());
+		AutomatonCompare::setCompare(a.getInitialStates(), b.getInitialStates());
 	}
 
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStackAlphabet() != b.getStackAlphabet()) {
 		std::cout << "StackAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStackAlphabet(), b.getStackAlphabet());
+		AutomatonCompare::setCompare(a.getStackAlphabet(), b.getStackAlphabet());
 	}
 
 	if(a.getInitialSymbols() != b.getInitialSymbols()) {
 		std::cout << "InitialSymbols" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInitialSymbols(), b.getInitialSymbols());
+		AutomatonCompare::setCompare(a.getInitialSymbols(), b.getInitialSymbols());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-void AutomatonDiff::printDiff(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b) {
-	std::cout << "AutomataDiffer" << std::endl;
+void AutomatonCompare::printCompare(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b) {
+	std::cout << "AutomataCompareer" << std::endl;
 
 	if(a.getBlankSymbol() != b.getBlankSymbol()) {
 		std::cout << "Blank symbol" << std::endl;
@@ -477,7 +477,7 @@ void AutomatonDiff::printDiff(const automaton::OneTapeDTM& a, const automaton::O
 	if(a.getFinalStates() != b.getFinalStates()){
 		std::cout << "FinalStates" << std::endl;
 
-		AutomatonDiff::setDiff(a.getFinalStates(), b.getFinalStates());
+		AutomatonCompare::setCompare(a.getFinalStates(), b.getFinalStates());
 	}
 
 	if(a.getInitialState() != b.getInitialState()) {
@@ -491,103 +491,103 @@ void AutomatonDiff::printDiff(const automaton::OneTapeDTM& a, const automaton::O
 	if(a.getInputAlphabet() != b.getInputAlphabet()) {
 		std::cout << "InputAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getInputAlphabet(), b.getInputAlphabet());
+		AutomatonCompare::setCompare(a.getInputAlphabet(), b.getInputAlphabet());
 	}
 
 	if(a.getStates() != b.getStates()) {
 		std::cout << "States" << std::endl;
 
-		AutomatonDiff::setDiff(a.getStates(), b.getStates());
+		AutomatonCompare::setCompare(a.getStates(), b.getStates());
 	}
 
 	if(a.getTapeAlphabet() != b.getTapeAlphabet()) {
 		std::cout << "TapeAlphabet" << std::endl;
 
-		AutomatonDiff::setDiff(a.getTapeAlphabet(), b.getTapeAlphabet());
+		AutomatonCompare::setCompare(a.getTapeAlphabet(), b.getTapeAlphabet());
 	}
 
 	if(a.getTransitions() != b.getTransitions()) {
 		std::cout << "Transitions" << std::endl;
 
-		AutomatonDiff::mapDiff(a.getTransitions(), b.getTransitions());
+		AutomatonCompare::mapCompare(a.getTransitions(), b.getTransitions());
 	}
 }
 
-int AutomatonDiff::diff(const automaton::DFA& a, const automaton::DFA& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::DFA& a, const automaton::DFA& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int AutomatonDiff::diff(const automaton::NFA& a, const automaton::NFA& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::NFA& a, const automaton::NFA& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int AutomatonDiff::diff(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int AutomatonDiff::diff(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int AutomatonDiff::diff(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int AutomatonDiff::diff(const automaton::CompactNFA& a, const automaton::CompactNFA& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::CompactNFA& a, const automaton::CompactNFA& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int AutomatonDiff::diff(const automaton::NPDA& a, const automaton::NPDA& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::NPDA& a, const automaton::NPDA& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int AutomatonDiff::diff(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int AutomatonDiff::diff(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b) {
-	if(!AutomatonDiff::testDiff(a, b)) {
-	  AutomatonDiff::printDiff(a, b);
+int AutomatonCompare::compare(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b) {
+	if(!AutomatonCompare::testCompare(a, b)) {
+	  AutomatonCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
@@ -595,14 +595,14 @@ int AutomatonDiff::diff(const automaton::OneTapeDTM& a, const automaton::OneTape
 }
 
 template<typename T>
-int AutomatonDiff::dynamicDiff(const automaton::Automaton& a, const automaton::Automaton& b) {
+int AutomatonCompare::dynamicCompare(const automaton::Automaton& a, const automaton::Automaton& b) {
 	const T* ap = dynamic_cast<const T*>(&a.getData());
 	const T* bp = dynamic_cast<const T*>(&b.getData());
 
 	if(ap && bp) {
-		return diff(*ap, *bp);
+		return compare(*ap, *bp);
 	} else if(ap || bp) {
-		std::cout << "AutomataDifferByType" << std::endl;
+		std::cout << "AutomataCompareerByType" << std::endl;
 		return 1;
 	} else {
 		return -1;
@@ -610,42 +610,42 @@ int AutomatonDiff::dynamicDiff(const automaton::Automaton& a, const automaton::A
 
 }
 
-int AutomatonDiff::diff(const automaton::Automaton& a, const automaton::Automaton& b) {
+int AutomatonCompare::compare(const automaton::Automaton& a, const automaton::Automaton& b) {
 	int res;
 
-	res = dynamicDiff<automaton::DFA>(a, b);
+	res = dynamicCompare<automaton::DFA>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<automaton::NFA>(a, b);
+	res = dynamicCompare<automaton::NFA>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<automaton::MultiInitialStateNFA>(a, b);
+	res = dynamicCompare<automaton::MultiInitialStateNFA>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<automaton::EpsilonNFA>(a, b);
+	res = dynamicCompare<automaton::EpsilonNFA>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<automaton::ExtendedNFA>(a, b);
+	res = dynamicCompare<automaton::ExtendedNFA>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<automaton::CompactNFA>(a, b);
+	res = dynamicCompare<automaton::CompactNFA>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<automaton::NPDA>(a, b);
+	res = dynamicCompare<automaton::NPDA>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<automaton::SinglePopNPDA>(a, b);
+	res = dynamicCompare<automaton::SinglePopNPDA>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<automaton::OneTapeDTM>(a, b);
+	res = dynamicCompare<automaton::OneTapeDTM>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
diff --git a/acompare2/src/AutomatonCompare.h b/acompare2/src/AutomatonCompare.h
new file mode 100644
index 0000000000000000000000000000000000000000..df7b8d0b76b862b54294858e5bd96352f4f0530b
--- /dev/null
+++ b/acompare2/src/AutomatonCompare.h
@@ -0,0 +1,67 @@
+/*
+ * AutomatonCompare.h
+ *
+ *  Created on: Apr 1, 2013
+ *      Author: honza
+ */
+
+#ifndef AUTOMATON_COMPARE_H_
+#define AUTOMATON_COMPARE_H_
+
+#include <ostream>
+
+#include <automaton/Automaton.h>
+#include <set>
+#include <list>
+#include <map>
+#include <utility>
+
+class AutomatonCompare {
+	static bool testCompare(const automaton::DFA& a, const automaton::DFA& b);
+	static void printCompare(const automaton::DFA& a, const automaton::DFA& b);
+
+	static bool testCompare(const automaton::NFA& a, const automaton::NFA& b);
+	static void printCompare(const automaton::NFA& a, const automaton::NFA& b);
+
+	static bool testCompare(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b);
+	static void printCompare(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b);
+
+	static bool testCompare(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b);
+	static void printCompare(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b);
+
+	static bool testCompare(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b);
+	static void printCompare(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b);
+
+	static bool testCompare(const automaton::CompactNFA& a, const automaton::CompactNFA& b);
+	static void printCompare(const automaton::CompactNFA& a, const automaton::CompactNFA& b);
+
+	static bool testCompare(const automaton::NPDA& a, const automaton::NPDA& b);
+	static void printCompare(const automaton::NPDA& a, const automaton::NPDA& b);
+
+	static bool testCompare(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b);
+	static void printCompare(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b);
+
+	static bool testCompare(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b);
+	static void printCompare(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b);
+
+	template <class T> static void setCompare(const std::set<T> a, const std::set<T> b);
+	template <class T> static void listCompare(const std::list<T> a, const std::list<T> b);
+	template <class T, class R> static void mapCompare(const std::map<T, R> a, const std::map<T, R> b);
+public:
+	static int compare(const automaton::DFA& a, const automaton::DFA& b);
+	static int compare(const automaton::NFA& a, const automaton::NFA& b);
+	static int compare(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b);
+	static int compare(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b);
+	static int compare(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b);
+	static int compare(const automaton::CompactNFA& a, const automaton::CompactNFA& b);
+	static int compare(const automaton::NPDA& a, const automaton::NPDA& b);
+	static int compare(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b);
+	static int compare(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b);
+
+	template<typename T>
+	static int dynamicCompare(const automaton::Automaton& a, const automaton::Automaton& b);
+
+	static int compare(const automaton::Automaton& a, const automaton::Automaton& b);
+};
+
+#endif /* AUTOMATON_COMPARE_H_ */
diff --git a/adiff2/src/GrammarDiff.cpp b/acompare2/src/GrammarCompare.cpp
similarity index 63%
rename from adiff2/src/GrammarDiff.cpp
rename to acompare2/src/GrammarCompare.cpp
index c060d9ef6f54b8da9a12ea9add7b34ceb27e36ff..417e779dd2f99b13df7f7075158c27e5a6face18 100644
--- a/adiff2/src/GrammarDiff.cpp
+++ b/acompare2/src/GrammarCompare.cpp
@@ -1,11 +1,11 @@
 /*
- * GrammarDiff.cpp
+ * GrammarCompare.cpp
  *
  *  Created on: Apr 1, 2013
  *      Author: honza
  */
 
-#include "GrammarDiff.h"
+#include "GrammarCompare.h"
 
 #include <set>
 #include <map>
@@ -34,98 +34,98 @@
 
 #include "exception/AlibException.h"
 
-bool GrammarDiff::testDiff(const grammar::LeftLG& a, const grammar::LeftLG& b) {
+bool GrammarCompare::testCompare(const grammar::LeftLG& a, const grammar::LeftLG& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::LeftRG& a, const grammar::LeftRG& b) {
+bool GrammarCompare::testCompare(const grammar::LeftRG& a, const grammar::LeftRG& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::RightLG& a, const grammar::RightLG& b) {
+bool GrammarCompare::testCompare(const grammar::RightLG& a, const grammar::RightLG& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::RightRG& a, const grammar::RightRG& b) {
+bool GrammarCompare::testCompare(const grammar::RightRG& a, const grammar::RightRG& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::LG& a, const grammar::LG& b) {
+bool GrammarCompare::testCompare(const grammar::LG& a, const grammar::LG& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::CFG& a, const grammar::CFG& b) {
+bool GrammarCompare::testCompare(const grammar::CFG& a, const grammar::CFG& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b) {
+bool GrammarCompare::testCompare(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::CNF& a, const grammar::CNF& b) {
+bool GrammarCompare::testCompare(const grammar::CNF& a, const grammar::CNF& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::GNF& a, const grammar::GNF& b) {
+bool GrammarCompare::testCompare(const grammar::GNF& a, const grammar::GNF& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::CSG& a, const grammar::CSG& b) {
+bool GrammarCompare::testCompare(const grammar::CSG& a, const grammar::CSG& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b) {
+bool GrammarCompare::testCompare(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
+bool GrammarCompare::testCompare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarDiff::testDiff(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
+bool GrammarCompare::testCompare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-template <class T> void GrammarDiff::setDiff(const std::set<T> a, const std::set<T> b) {
+template <class T> void GrammarCompare::setCompare(const std::set<T> a, const std::set<T> b) {
 	std::set<T> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -141,7 +141,7 @@ template <class T> void GrammarDiff::setDiff(const std::set<T> a, const std::set
 	}
 }
 
-template <class T> void GrammarDiff::listDiff(const std::list<T> a, const std::list<T> b) {
+template <class T> void GrammarCompare::listCompare(const std::list<T> a, const std::list<T> b) {
 	std::list<T> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -157,7 +157,7 @@ template <class T> void GrammarDiff::listDiff(const std::list<T> a, const std::l
 	}
 }
 
-template <class T, class R> void GrammarDiff::mapDiff(const std::map<T, R> a, const std::map<T, R> b) {
+template <class T, class R> void GrammarCompare::mapCompare(const std::map<T, R> a, const std::map<T, R> b) {
 	std::map<T, R> aMinusB;
 	std::set_difference(a.begin(), a.end(), b.begin(), b.end(), std::inserter(aMinusB, aMinusB.begin()));
 
@@ -173,19 +173,19 @@ template <class T, class R> void GrammarDiff::mapDiff(const std::map<T, R> a, co
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::LeftLG& a, const grammar::LeftLG& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::LeftLG& a, const grammar::LeftLG& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -199,23 +199,23 @@ void GrammarDiff::printDiff(const grammar::LeftLG& a, const grammar::LeftLG& b)
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::LeftRG& a, const grammar::LeftRG& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::LeftRG& a, const grammar::LeftRG& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -229,23 +229,23 @@ void GrammarDiff::printDiff(const grammar::LeftRG& a, const grammar::LeftRG& b)
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::RightLG& a, const grammar::RightLG& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::RightLG& a, const grammar::RightLG& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -259,23 +259,23 @@ void GrammarDiff::printDiff(const grammar::RightLG& a, const grammar::RightLG& b
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::RightRG& a, const grammar::RightRG& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::RightRG& a, const grammar::RightRG& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -289,23 +289,23 @@ void GrammarDiff::printDiff(const grammar::RightRG& a, const grammar::RightRG& b
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::LG& a, const grammar::LG& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::LG& a, const grammar::LG& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -319,23 +319,23 @@ void GrammarDiff::printDiff(const grammar::LG& a, const grammar::LG& b) {
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::CFG& a, const grammar::CFG& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::CFG& a, const grammar::CFG& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -349,23 +349,23 @@ void GrammarDiff::printDiff(const grammar::CFG& a, const grammar::CFG& b) {
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -379,23 +379,23 @@ void GrammarDiff::printDiff(const grammar::EpsilonFreeCFG& a, const grammar::Eps
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::CNF& a, const grammar::CNF& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::CNF& a, const grammar::CNF& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -409,23 +409,23 @@ void GrammarDiff::printDiff(const grammar::CNF& a, const grammar::CNF& b) {
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::GNF& a, const grammar::GNF& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::GNF& a, const grammar::GNF& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -439,23 +439,23 @@ void GrammarDiff::printDiff(const grammar::GNF& a, const grammar::GNF& b) {
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::CSG& a, const grammar::CSG& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::CSG& a, const grammar::CSG& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -469,23 +469,23 @@ void GrammarDiff::printDiff(const grammar::CSG& a, const grammar::CSG& b) {
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -499,23 +499,23 @@ void GrammarDiff::printDiff(const grammar::NonContractingGrammar& a, const gramm
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -529,23 +529,23 @@ void GrammarDiff::printDiff(const grammar::ContextPreservingUnrestrictedGrammar&
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-void GrammarDiff::printDiff(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
-	std::cout << "GrammarDiffer" << std::endl;
+void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
+	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
 		std::cout << "Nonterminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
+		GrammarCompare::setCompare(a.getNonterminalAlphabet(), b.getNonterminalAlphabet());
 	}
 
 	if(a.getRules() != b.getRules()){
 		std::cout << "Rules" << std::endl;
 
-		GrammarDiff::mapDiff(a.getRules(), b.getRules());
+		GrammarCompare::mapCompare(a.getRules(), b.getRules());
 	}
 
 	if(a.getInitialSymbol() != b.getInitialSymbol()){
@@ -559,121 +559,121 @@ void GrammarDiff::printDiff(const grammar::UnrestrictedGrammar& a, const grammar
 	if(a.getTerminalAlphabet() != b.getTerminalAlphabet()) {
 		std::cout << "Terminal alphabet" << std::endl;
 
-		GrammarDiff::setDiff(a.getTerminalAlphabet(), b.getTerminalAlphabet());
+		GrammarCompare::setCompare(a.getTerminalAlphabet(), b.getTerminalAlphabet());
 	}
 }
 
-int GrammarDiff::diff(const grammar::LeftLG& a, const grammar::LeftLG& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::LeftLG& a, const grammar::LeftLG& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::LeftRG& a, const grammar::LeftRG& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::LeftRG& a, const grammar::LeftRG& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::RightLG& a, const grammar::RightLG& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::RightLG& a, const grammar::RightLG& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::RightRG& a, const grammar::RightRG& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::RightRG& a, const grammar::RightRG& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::LG& a, const grammar::LG& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::LG& a, const grammar::LG& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::CFG& a, const grammar::CFG& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::CFG& a, const grammar::CFG& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::CNF& a, const grammar::CNF& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::CNF& a, const grammar::CNF& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::GNF& a, const grammar::GNF& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::GNF& a, const grammar::GNF& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::CSG& a, const grammar::CSG& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::CSG& a, const grammar::CSG& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
 	}
 }
 
-int GrammarDiff::diff(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
-	if(!GrammarDiff::testDiff(a, b)) {
-	  GrammarDiff::printDiff(a, b);
+int GrammarCompare::compare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
+	if(!GrammarCompare::testCompare(a, b)) {
+	  GrammarCompare::printCompare(a, b);
 	  return 1;
 	} else {
 	  return 0;
@@ -681,14 +681,14 @@ int GrammarDiff::diff(const grammar::UnrestrictedGrammar& a, const grammar::Unre
 }
 
 template<typename T>
-int GrammarDiff::dynamicDiff(const grammar::Grammar& a, const grammar::Grammar& b) {
+int GrammarCompare::dynamicCompare(const grammar::Grammar& a, const grammar::Grammar& b) {
 	const T* ap = dynamic_cast<const T*>(&a.getData());
 	const T* bp = dynamic_cast<const T*>(&b.getData());
 
 	if(ap && bp) {
-		return diff(*ap, *bp);
+		return compare(*ap, *bp);
 	} else if(ap || bp) {
-		std::cout << "GrammarsDifferByType" << std::endl;
+		std::cout << "GrammarsCompareerByType" << std::endl;
 		return 1;
 	} else {
 		return -1;
@@ -696,58 +696,58 @@ int GrammarDiff::dynamicDiff(const grammar::Grammar& a, const grammar::Grammar&
 
 }
 
-int GrammarDiff::diff(const grammar::Grammar& a, const grammar::Grammar& b) {
+int GrammarCompare::compare(const grammar::Grammar& a, const grammar::Grammar& b) {
 	int res;
 
-	res = dynamicDiff<grammar::LeftLG>(a, b);
+	res = dynamicCompare<grammar::LeftLG>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::LeftRG>(a, b);
+	res = dynamicCompare<grammar::LeftRG>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::RightLG>(a, b);
+	res = dynamicCompare<grammar::RightLG>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::RightRG>(a, b);
+	res = dynamicCompare<grammar::RightRG>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::LG>(a, b);
+	res = dynamicCompare<grammar::LG>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::CFG>(a, b);
+	res = dynamicCompare<grammar::CFG>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::EpsilonFreeCFG>(a, b);
+	res = dynamicCompare<grammar::EpsilonFreeCFG>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::CNF>(a, b);
+	res = dynamicCompare<grammar::CNF>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::GNF>(a, b);
+	res = dynamicCompare<grammar::GNF>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::CSG>(a, b);
+	res = dynamicCompare<grammar::CSG>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::NonContractingGrammar>(a, b);
+	res = dynamicCompare<grammar::NonContractingGrammar>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::ContextPreservingUnrestrictedGrammar>(a, b);
+	res = dynamicCompare<grammar::ContextPreservingUnrestrictedGrammar>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
-	res = dynamicDiff<grammar::UnrestrictedGrammar>(a, b);
+	res = dynamicCompare<grammar::UnrestrictedGrammar>(a, b);
 	if(res == 0) return 0;
 	if(res == 1) return 1;
 
diff --git a/acompare2/src/GrammarCompare.h b/acompare2/src/GrammarCompare.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa91c36668d2eff15467f212a6517bfe8d13fc84
--- /dev/null
+++ b/acompare2/src/GrammarCompare.h
@@ -0,0 +1,83 @@
+/*
+ * GrammarCompare.h
+ *
+ *  Created on: Apr 1, 2013
+ *      Author: honza
+ */
+
+#ifndef GRAMMAR_COMPARE_H_
+#define GRAMMAR_COMPARE_H_
+
+#include <ostream>
+
+#include <grammar/Grammar.h>
+#include <set>
+#include <list>
+#include <map>
+#include <utility>
+
+class GrammarCompare {
+	static bool testCompare(const grammar::LeftLG& a, const grammar::LeftLG& b);
+	static void printCompare(const grammar::LeftLG& a, const grammar::LeftLG& b);
+
+	static bool testCompare(const grammar::LeftRG& a, const grammar::LeftRG& b);
+	static void printCompare(const grammar::LeftRG& a, const grammar::LeftRG& b);
+
+	static bool testCompare(const grammar::RightLG& a, const grammar::RightLG& b);
+	static void printCompare(const grammar::RightLG& a, const grammar::RightLG& b);
+
+	static bool testCompare(const grammar::RightRG& a, const grammar::RightRG& b);
+	static void printCompare(const grammar::RightRG& a, const grammar::RightRG& b);
+
+	static bool testCompare(const grammar::LG& a, const grammar::LG& b);
+	static void printCompare(const grammar::LG& a, const grammar::LG& b);
+
+	static bool testCompare(const grammar::CFG& a, const grammar::CFG& b);
+	static void printCompare(const grammar::CFG& a, const grammar::CFG& b);
+
+	static bool testCompare(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b);
+	static void printCompare(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b);
+
+	static bool testCompare(const grammar::CNF& a, const grammar::CNF& b);
+	static void printCompare(const grammar::CNF& a, const grammar::CNF& b);
+
+	static bool testCompare(const grammar::GNF& a, const grammar::GNF& b);
+	static void printCompare(const grammar::GNF& a, const grammar::GNF& b);
+
+	static bool testCompare(const grammar::CSG& a, const grammar::CSG& b);
+	static void printCompare(const grammar::CSG& a, const grammar::CSG& b);
+
+	static bool testCompare(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b);
+	static void printCompare(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b);
+
+	static bool testCompare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
+	static void printCompare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
+
+	static bool testCompare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
+	static void printCompare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
+
+	template <class T> static void setCompare(const std::set<T> a, const std::set<T> b);
+	template <class T> static void listCompare(const std::list<T> a, const std::list<T> b);
+	template <class T, class R> static void mapCompare(const std::map<T, R> a, const std::map<T, R> b);
+public:
+	static int compare(const grammar::LeftLG& a, const grammar::LeftLG& b);
+	static int compare(const grammar::LeftRG& a, const grammar::LeftRG& b);
+	static int compare(const grammar::RightLG& a, const grammar::RightLG& b);
+	static int compare(const grammar::RightRG& a, const grammar::RightRG& b);
+	static int compare(const grammar::LG& a, const grammar::LG& b);
+	static int compare(const grammar::CFG& a, const grammar::CFG& b);
+	static int compare(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b);
+	static int compare(const grammar::CNF& a, const grammar::CNF& b);
+	static int compare(const grammar::GNF& a, const grammar::GNF& b);
+	static int compare(const grammar::CSG& a, const grammar::CSG& b);
+	static int compare(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b);
+	static int compare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
+	static int compare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
+	
+	template<typename T>
+	static int dynamicCompare(const grammar::Grammar& a, const grammar::Grammar& b);
+
+	static int compare(const grammar::Grammar& a, const grammar::Grammar& b);
+};
+
+#endif /* GRAMMAR_COMPARE_H_ */
diff --git a/adiff2/src/adiff.cpp b/acompare2/src/acompare.cpp
similarity index 90%
rename from adiff2/src/adiff.cpp
rename to acompare2/src/acompare.cpp
index dd40602209b5f3a92c43b482004eb0169ae5a4ee..a9069c7487e4c861051a462c9d141f84e083ec89 100644
--- a/adiff2/src/adiff.cpp
+++ b/acompare2/src/acompare.cpp
@@ -1,5 +1,5 @@
 /*
- * adiff.cpp
+ * acompare.cpp
  *
  *  Created on: 24. 2. 2014
  *      Author: Jan Travnicek
@@ -10,8 +10,8 @@
 #include "factory/DataFactory.hpp"
 #include "exception/AlibException.h"
 
-#include "AutomatonDiff.h"
-#include "GrammarDiff.h"
+#include "AutomatonCompare.h"
+#include "GrammarCompare.h"
 
 int main(int argc, char** argv) {
 
@@ -19,10 +19,10 @@ int main(int argc, char** argv) {
 
 		TCLAP::CmdLine cmd("Regexp derivative compute binary", ' ', "0.01");
 
-		TCLAP::UnlabeledValueArg<std::string> input1(	"input1",	"The first input to diff",	true,	"-",		"file");
+		TCLAP::UnlabeledValueArg<std::string> input1(	"input1",	"The first input to compare",	true,	"-",		"file");
 		cmd.add( input1 );
 
-		TCLAP::UnlabeledValueArg<std::string> input2(	"input2",	"The second input to diff",	true,	"-",		"file");
+		TCLAP::UnlabeledValueArg<std::string> input2(	"input2",	"The second input to compare",	true,	"-",		"file");
 		cmd.add( input2 );
 
 		cmd.parse(argc, argv);
@@ -61,17 +61,17 @@ int main(int argc, char** argv) {
 			automaton::Automaton automaton1 = alib::DataFactory::fromTokens<automaton::Automaton>(tokens1);
 			automaton::Automaton automaton2 = alib::DataFactory::fromTokens<automaton::Automaton>(tokens2);
 
-			return AutomatonDiff::diff(automaton1, automaton2);
+			return AutomatonCompare::compare(automaton1, automaton2);
 		}
 
 		if(alib::FromXMLParsers::grammarParser.first(tokens1) && alib::FromXMLParsers::grammarParser.first(tokens2)) {
 			grammar::Grammar grammar1 = alib::DataFactory::fromTokens<grammar::Grammar>(tokens1);
 			grammar::Grammar grammar2 = alib::DataFactory::fromTokens<grammar::Grammar>(tokens2);
 
-			return GrammarDiff::diff(grammar1, grammar2);
+			return GrammarCompare::compare(grammar1, grammar2);
 		}
 
-		throw exception::AlibException("Only automata and grammars can be differenciated.");
+		throw exception::AlibException("Only automata and grammars can be compared.");
 
 		return 2;
 	} catch (const exception::AlibException& exception) {
diff --git a/adiff2/src/AutomatonDiff.h b/adiff2/src/AutomatonDiff.h
deleted file mode 100644
index e9a52c9a5256518edbe2c83311a1d34036352e0b..0000000000000000000000000000000000000000
--- a/adiff2/src/AutomatonDiff.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * AutomatonDiff.h
- *
- *  Created on: Apr 1, 2013
- *      Author: honza
- */
-
-#ifndef AUTOMATON_DIFF_H_
-#define AUTOMATON_DIFF_H_
-
-#include <ostream>
-
-#include <automaton/Automaton.h>
-#include <set>
-#include <list>
-#include <map>
-#include <utility>
-
-class AutomatonDiff {
-	static bool testDiff(const automaton::DFA& a, const automaton::DFA& b);
-	static void printDiff(const automaton::DFA& a, const automaton::DFA& b);
-
-	static bool testDiff(const automaton::NFA& a, const automaton::NFA& b);
-	static void printDiff(const automaton::NFA& a, const automaton::NFA& b);
-
-	static bool testDiff(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b);
-	static void printDiff(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b);
-
-	static bool testDiff(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b);
-	static void printDiff(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b);
-
-	static bool testDiff(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b);
-	static void printDiff(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b);
-
-	static bool testDiff(const automaton::CompactNFA& a, const automaton::CompactNFA& b);
-	static void printDiff(const automaton::CompactNFA& a, const automaton::CompactNFA& b);
-
-	static bool testDiff(const automaton::NPDA& a, const automaton::NPDA& b);
-	static void printDiff(const automaton::NPDA& a, const automaton::NPDA& b);
-
-	static bool testDiff(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b);
-	static void printDiff(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b);
-
-	static bool testDiff(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b);
-	static void printDiff(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b);
-
-	template <class T> static void setDiff(const std::set<T> a, const std::set<T> b);
-	template <class T> static void listDiff(const std::list<T> a, const std::list<T> b);
-	template <class T, class R> static void mapDiff(const std::map<T, R> a, const std::map<T, R> b);
-public:
-	static int diff(const automaton::DFA& a, const automaton::DFA& b);
-	static int diff(const automaton::NFA& a, const automaton::NFA& b);
-	static int diff(const automaton::MultiInitialStateNFA& a, const automaton::MultiInitialStateNFA& b);
-	static int diff(const automaton::EpsilonNFA& a, const automaton::EpsilonNFA& b);
-	static int diff(const automaton::ExtendedNFA& a, const automaton::ExtendedNFA& b);
-	static int diff(const automaton::CompactNFA& a, const automaton::CompactNFA& b);
-	static int diff(const automaton::NPDA& a, const automaton::NPDA& b);
-	static int diff(const automaton::SinglePopNPDA& a, const automaton::SinglePopNPDA& b);
-	static int diff(const automaton::OneTapeDTM& a, const automaton::OneTapeDTM& b);
-
-	template<typename T>
-	static int dynamicDiff(const automaton::Automaton& a, const automaton::Automaton& b);
-
-	static int diff(const automaton::Automaton& a, const automaton::Automaton& b);
-};
-
-#endif /* AUTOMATON_DIFF_H_ */
diff --git a/adiff2/src/GrammarDiff.h b/adiff2/src/GrammarDiff.h
deleted file mode 100644
index 1af254357a2993d78d3429760f25a921ad342b33..0000000000000000000000000000000000000000
--- a/adiff2/src/GrammarDiff.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * GrammarDiff.h
- *
- *  Created on: Apr 1, 2013
- *      Author: honza
- */
-
-#ifndef GRAMMAR_DIFF_H_
-#define GRAMMAR_DIFF_H_
-
-#include <ostream>
-
-#include <grammar/Grammar.h>
-#include <set>
-#include <list>
-#include <map>
-#include <utility>
-
-class GrammarDiff {
-	static bool testDiff(const grammar::LeftLG& a, const grammar::LeftLG& b);
-	static void printDiff(const grammar::LeftLG& a, const grammar::LeftLG& b);
-
-	static bool testDiff(const grammar::LeftRG& a, const grammar::LeftRG& b);
-	static void printDiff(const grammar::LeftRG& a, const grammar::LeftRG& b);
-
-	static bool testDiff(const grammar::RightLG& a, const grammar::RightLG& b);
-	static void printDiff(const grammar::RightLG& a, const grammar::RightLG& b);
-
-	static bool testDiff(const grammar::RightRG& a, const grammar::RightRG& b);
-	static void printDiff(const grammar::RightRG& a, const grammar::RightRG& b);
-
-	static bool testDiff(const grammar::LG& a, const grammar::LG& b);
-	static void printDiff(const grammar::LG& a, const grammar::LG& b);
-
-	static bool testDiff(const grammar::CFG& a, const grammar::CFG& b);
-	static void printDiff(const grammar::CFG& a, const grammar::CFG& b);
-
-	static bool testDiff(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b);
-	static void printDiff(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b);
-
-	static bool testDiff(const grammar::CNF& a, const grammar::CNF& b);
-	static void printDiff(const grammar::CNF& a, const grammar::CNF& b);
-
-	static bool testDiff(const grammar::GNF& a, const grammar::GNF& b);
-	static void printDiff(const grammar::GNF& a, const grammar::GNF& b);
-
-	static bool testDiff(const grammar::CSG& a, const grammar::CSG& b);
-	static void printDiff(const grammar::CSG& a, const grammar::CSG& b);
-
-	static bool testDiff(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b);
-	static void printDiff(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b);
-
-	static bool testDiff(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
-	static void printDiff(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
-
-	static bool testDiff(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
-	static void printDiff(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
-
-	template <class T> static void setDiff(const std::set<T> a, const std::set<T> b);
-	template <class T> static void listDiff(const std::list<T> a, const std::list<T> b);
-	template <class T, class R> static void mapDiff(const std::map<T, R> a, const std::map<T, R> b);
-public:
-	static int diff(const grammar::LeftLG& a, const grammar::LeftLG& b);
-	static int diff(const grammar::LeftRG& a, const grammar::LeftRG& b);
-	static int diff(const grammar::RightLG& a, const grammar::RightLG& b);
-	static int diff(const grammar::RightRG& a, const grammar::RightRG& b);
-	static int diff(const grammar::LG& a, const grammar::LG& b);
-	static int diff(const grammar::CFG& a, const grammar::CFG& b);
-	static int diff(const grammar::EpsilonFreeCFG& a, const grammar::EpsilonFreeCFG& b);
-	static int diff(const grammar::CNF& a, const grammar::CNF& b);
-	static int diff(const grammar::GNF& a, const grammar::GNF& b);
-	static int diff(const grammar::CSG& a, const grammar::CSG& b);
-	static int diff(const grammar::NonContractingGrammar& a, const grammar::NonContractingGrammar& b);
-	static int diff(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
-	static int diff(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
-	
-	template<typename T>
-	static int dynamicDiff(const grammar::Grammar& a, const grammar::Grammar& b);
-
-	static int diff(const grammar::Grammar& a, const grammar::Grammar& b);
-};
-
-#endif /* GRAMMAR_DIFF_H_ */
diff --git a/acat2/makefile b/aecho2/makefile
similarity index 99%
rename from acat2/makefile
rename to aecho2/makefile
index aa2f4ba566867ff0f997eff82692fd5335b183b3..971a9eeffb347b1e99bf5dabaf81478f8389ef84 100644
--- a/acat2/makefile
+++ b/aecho2/makefile
@@ -1,5 +1,5 @@
 SHELL:=/bin/bash
-EXECUTABLE:=acat2
+EXECUTABLE:=aecho2
 
 define NEW_LINE
 
diff --git a/acat2/src/acat.cpp b/aecho2/src/aecho.cpp
similarity index 92%
rename from acat2/src/acat.cpp
rename to aecho2/src/aecho.cpp
index 549c52bc75fd0ad54622e7be1aed6c69753289c9..f4c31a5102bda43398ee31cd97ae9e82cbf204f4 100644
--- a/acat2/src/acat.cpp
+++ b/aecho2/src/aecho.cpp
@@ -1,5 +1,5 @@
 /*
- * acat.cpp
+ * aecho.cpp
  *
  *  Created on: 24. 2. 2014
  *      Author: Martin Zak
@@ -17,7 +17,7 @@ int main(int argc, char** argv) {
 	try {
 		TCLAP::CmdLine cmd("Cat binary", ' ', "0.01");
 
-		TCLAP::ValueArg<std::string> input(	"i",	"input",	"Input to cat",		false,	"-",		"file");
+		TCLAP::ValueArg<std::string> input(	"i",	"input",	"Input to echo",		false,	"-",		"file");
 		cmd.add( input );
 
 		cmd.parse(argc, argv);
diff --git a/makefile b/makefile
index a7efa5c1a5b973de046b89dcd0b9580dd7a6195d..0d9c6b4d220e3aa83d3c255aae06909e3241c489 100644
--- a/makefile
+++ b/makefile
@@ -4,12 +4,12 @@ BINFOLDER = bin
 
 CORE_LIB = alib2data
 SUBDIRS_LIBS = alib2algo
-SUBDIRS_BINS = acat2 \
+SUBDIRS_BINS = aecho2 \
 		aconversions2 \
 		aconvert2 \
 		aderivation2 \
 		adeterminize2 \
-		adiff2 \
+		acompare2 \
 		aepsilon2 \
 		aintegral2 \
 		alangop2 \
diff --git a/tests.aconversion.sh b/tests.aconversion.sh
index adbf309a1e67db0dae20bdf8347c6fb3befff12b..1e7defbdd67b924560d0d6ab31172079ee40167e 100755
--- a/tests.aconversion.sh
+++ b/tests.aconversion.sh
@@ -11,7 +11,7 @@ RAND_STATES=18
 RAND_DENSITY="2.5"
 RAND_ALPHABET=4
 
-EXECUTABLES="arand2 aepsilon2 atrim2 adeterminize2 aminimize2 anormalize2 adiff2 aconversions2"
+EXECUTABLES="arand2 aepsilon2 atrim2 adeterminize2 aminimize2 anormalize2 acompare2 aconversions2"
 TESTS_DIR="../examples2/automaton"
 
 RES_GOOD=0
@@ -61,7 +61,7 @@ function runTest2 {
 	TMPNFA="nfa.xml"
 	echo "$2" > $TMPNFA
 
-	OUT=`timeout $TESTCASE_TIMEOUT bash -c "./adiff2 <(cat $TMPNFA | $1 | $MDFA ) <(cat $TMPNFA | $MDFA)"`
+	OUT=`timeout $TESTCASE_TIMEOUT bash -c "./acompare2 <(cat $TMPNFA | $1 | $MDFA ) <(cat $TMPNFA | $MDFA)"`
 	RET=$?
 
 	if [ $RET == 0 ]; then # ok
diff --git a/tests.aderivation.aintegral.sh b/tests.aderivation.aintegral.sh
index 81c16d7bc9ad4a43449616b3f262c9928832e0a3..a7b5b0ef6c4c704bfd52f5a39a8e0d6473c161b6 100755
--- a/tests.aderivation.aintegral.sh
+++ b/tests.aderivation.aintegral.sh
@@ -4,7 +4,7 @@
 
 set -o pipefail
 
-EXECUTABLES="aepsilon2 atrim2 adeterminize2 aminimize2 anormalize2 adiff2 aderivations2 aintegral2 aconversions2"
+EXECUTABLES="aepsilon2 atrim2 adeterminize2 aminimize2 anormalize2 acompare2 aderivations2 aintegral2 aconversions2"
 TESTS_DIR="../examples2/regexp"
 
 # ----------------------------
@@ -29,7 +29,7 @@ function compareRegexp {
     regexpToMDFA "$2" > tmp2.xml
 
 	# relies on ret code by adiff.automaton
-	./adiff2 tmp1.xml tmp2.xml > /dev/null
+	./acompare2 tmp1.xml tmp2.xml > /dev/null
 	RET=$?
 	rm tmp1.xml tmp2.xml