diff --git a/alib2data/src/automaton/common/AutomatonNormalize.h b/alib2data/src/automaton/common/AutomatonNormalize.h
new file mode 100644
index 0000000000000000000000000000000000000000..f19e88fa80dbc916295ede59113487949560f962
--- /dev/null
+++ b/alib2data/src/automaton/common/AutomatonNormalize.h
@@ -0,0 +1,139 @@
+/*
+ * AutomatonNormalize.h
+ *
+ *  Created on: Mar 31, 2017
+ *      Author: Jan Travnicek
+ */
+
+#ifndef AUTOMATON_NORMALIZE_H_
+#define AUTOMATON_NORMALIZE_H_
+
+#include <deque>
+#include <vector>
+#include <set>
+#include <variant>
+#include <map>
+
+#include <regexp/unbounded/UnboundedRegExpStructure.h>
+#include <alphabet/RankedSymbol.h>
+
+namespace automaton {
+
+/**
+ * This class contains methods to print XML representation of automata to the output stream.
+ */
+class AutomatonNormalize {
+public:
+	template < class StateType >
+	static std::set < DefaultStateType > normalizeStates ( std::set < StateType > && states );
+
+	template < class StateType >
+	static std::vector < DefaultStateType > normalizeStates ( std::vector < StateType > && states );
+
+	template < class StateType >
+	static DefaultStateType normalizeState ( StateType && state);
+
+	template < class SymbolType >
+	static std::set < DefaultSymbolType > normalizeAlphabet ( std::set < SymbolType > && symbols );
+
+	template < class SymbolType, class RankType >
+	static std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > normalizeRankedAlphabet ( std::set < std::ranked_symbol < SymbolType, RankType > > && symbols );
+
+	template < class SymbolType >
+	static DefaultSymbolType normalizeSymbol ( SymbolType && symbol );
+
+	template < class SymbolType, class RankType >
+	static std::ranked_symbol < DefaultSymbolType, DefaultRankType > normalizeRankedSymbol ( std::ranked_symbol < SymbolType, RankType > && symbol );
+
+	template < class InputSymbolType, class PushdownStoreSymbolType >
+	static std::map < DefaultSymbolType, std::pair < std::vector < DefaultSymbolType >, std::vector < DefaultSymbolType > > > normalizeInputToPushdownStoreOperation ( std::map < InputSymbolType, std::pair < std::vector < PushdownStoreSymbolType >, std::vector < PushdownStoreSymbolType > > > && operations );
+
+	template < class SymbolType >
+	static std::vector < DefaultSymbolType > normalizeSymbols ( std::vector < SymbolType > && symbols );
+
+	template < class EpsilonType, class SymbolType >
+	static std::variant < DefaultEpsilonType, DefaultSymbolType > normalizeSymbolEpsilon ( std::variant < EpsilonType, SymbolType > && symbol );
+
+	template < class SymbolType >
+	static regexp::UnboundedRegExpStructure < DefaultSymbolType > normalizeRegExp ( regexp::UnboundedRegExpStructure < SymbolType > && regexp );
+
+};
+
+template < class StateType >
+std::set < DefaultStateType > AutomatonNormalize::normalizeStates ( std::set < StateType > && states ) {
+	std::set < DefaultStateType > res;
+	for ( StateType && state : std::make_moveable_set ( states ) ) {
+		res.insert ( normalizeState ( std::move ( state ) ) );
+	}
+	return res;
+}
+
+template < class StateType >
+std::vector < DefaultStateType > AutomatonNormalize::normalizeStates ( std::vector < StateType > && states ) {
+	std::vector < DefaultStateType > res;
+	for ( StateType & state : states ) {
+		res.push_back ( normalizeState ( std::move ( state ) ) );
+	}
+	return res;
+}
+
+template < class StateType >
+DefaultStateType AutomatonNormalize::normalizeState ( StateType && state) {
+	return DefaultStateType ( alib::AnyObject < StateType > ( std::move ( state ) ) );
+}
+
+template < class SymbolType >
+std::set < DefaultSymbolType > AutomatonNormalize::normalizeAlphabet ( std::set < SymbolType > && symbols ) {
+	std::set < DefaultSymbolType > res;
+	for ( SymbolType && symbol : std::make_moveable_set ( symbols ) ) {
+		res.insert ( normalizeSymbol ( std::move ( symbol ) ) );
+	}
+	return res;
+}
+
+template < class SymbolType, class RankType >
+std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > AutomatonNormalize::normalizeRankedAlphabet ( std::set < std::ranked_symbol < SymbolType, RankType > > && symbols ) {
+	std::set < std::ranked_symbol < DefaultSymbolType > > res;
+	for ( std::ranked_symbol < SymbolType, RankType > && symbol : std::make_moveable_set ( symbols ) ) {
+		res.insert ( normalizeRankedSymbol ( std::move ( symbol ) ) );
+	}
+	return res;
+}
+
+template < class SymbolType >
+DefaultSymbolType AutomatonNormalize::normalizeSymbol ( SymbolType && symbol ) {
+	return DefaultSymbolType ( alib::AnyObject < SymbolType > ( std::move ( symbol ) ) );
+}
+
+template < class SymbolType, class RankType >
+std::ranked_symbol < DefaultSymbolType, DefaultRankType > AutomatonNormalize::normalizeRankedSymbol ( std::ranked_symbol < SymbolType, RankType > && symbol ) {
+	return std::ranked_symbol < DefaultSymbolType, DefaultRankType > ( DefaultSymbolType ( alib::AnyObject < SymbolType > ( std::move ( symbol.getSymbol ( ) ) ) ), DefaultRankType ( std::move ( symbol.getRank ( ) ) ) );
+}
+
+template < class SymbolType >
+std::vector < DefaultSymbolType > AutomatonNormalize::normalizeSymbols ( std::vector < SymbolType > && symbols ) {
+	std::vector < DefaultSymbolType > res;
+	for ( SymbolType & symbol : symbols ) {
+		res.push_back ( normalizeSymbol ( std::move ( symbol ) ) );
+	}
+	return res;
+}
+
+template < class EpsilonType, class SymbolType >
+std::variant < DefaultEpsilonType, DefaultSymbolType > AutomatonNormalize::normalizeSymbolEpsilon ( std::variant < EpsilonType, SymbolType > && symbol ) {
+	if ( symbol.template is < EpsilonType > ( ) )
+		return std::variant < DefaultEpsilonType, DefaultSymbolType >::template from < DefaultEpsilonType > ( );
+	else
+		return std::variant < DefaultEpsilonType, DefaultSymbolType > ( DefaultSymbolType ( alib::AnyObject < SymbolType > ( std::move ( symbol.template get < SymbolType > ( ) ) ) ) );
+}
+
+template < class SymbolType >
+regexp::UnboundedRegExpStructure < DefaultSymbolType > AutomatonNormalize::normalizeRegExp ( regexp::UnboundedRegExpStructure < SymbolType > && regexp ) {
+	return std::move ( regexp ).normalize ( );
+
+}
+
+} /* namespace automaton */
+
+#endif /* AUTOMATON_NORMALIZE_H_ */
+