diff --git a/acompaction2/src/acompaction.cpp b/acompaction2/src/acompaction.cpp
index bf1e8fb96f344250d2ec336f8f681649f6179e56..04c3d201d0bd731f9ecb46e756989a2323b98bb6 100644
--- a/acompaction2/src/acompaction.cpp
+++ b/acompaction2/src/acompaction.cpp
@@ -22,7 +22,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/acompare2/src/acompare.cpp b/acompare2/src/acompare.cpp
index d016d36384902e91b8afb559d3f02e798e18f218..31b7dd18c564692464a17770d79b7919c5e23e5d 100644
--- a/acompare2/src/acompare.cpp
+++ b/acompare2/src/acompare.cpp
@@ -27,7 +27,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens1;
+		std::deque<sax::Token> tokens1;
 		if(input1.isSet()) {
 			if(input1.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens1);
@@ -38,7 +38,7 @@ int main(int argc, char** argv) {
 			sax::SaxParseInterface::parseStdin(tokens1);
 		}
 
-		std::list<sax::Token> tokens2;
+		std::deque<sax::Token> tokens2;
 		if(input2.isSet()) {
 			if(input2.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens2);
diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index 2c3bb6a39d7b51d81c498ea73e900af9952d00d8..47e081e4c803e7b00cb85996e108f98a1ac6afa3 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -25,7 +25,7 @@
 
 #include <factory/XmlDataFactory.hpp>
 
-ConversionHandler::ConversionHandler( std::list<sax::Token> & tokens, const std::string & target, const std::string & algorithm ) :
+ConversionHandler::ConversionHandler( std::deque<sax::Token> & tokens, const std::string & target, const std::string & algorithm ) :
 	m_tokens( tokens ),
 	m_source( parseFormalismFromTokens( ) ),
 	m_target( parseFormalismFromString( target ) ),
diff --git a/aconversions2/src/ConversionHandler.h b/aconversions2/src/ConversionHandler.h
index 9c2fbc77e64aeff553188cc44e584d388485d335..bb6e5cf46343add5431acd8833cc05a812c11402 100644
--- a/aconversions2/src/ConversionHandler.h
+++ b/aconversions2/src/ConversionHandler.h
@@ -8,7 +8,7 @@
 #ifndef ALGORITHMCHOOSER_H_
 #define ALGORITHMCHOOSER_H_
 
-#include <list>
+#include <deque>
 #include <sax/Token.h>
 #include <exception/AlibException.h>
 
@@ -46,7 +46,7 @@ public:
         REGULAR_EXPRESSION
     };
 
-    ConversionHandler( std::list<sax::Token> & tokens, const std::string & target, const std::string & algorithm );
+    ConversionHandler( std::deque<sax::Token> & tokens, const std::string & target, const std::string & algorithm );
     void convert( void );
 
 private:
@@ -66,7 +66,7 @@ private:
     void convertRGtoFA( void );
     void convertRGtoRE( void );
 
-    std::list<sax::Token> & m_tokens;
+    std::deque<sax::Token> & m_tokens;
     TFormalism m_source, m_target;
     TAlgorithm m_algorithm;
 };
diff --git a/aconversions2/src/aconversion.cpp b/aconversions2/src/aconversion.cpp
index ca27793bcec035a8fa4b036a33255497d2a9399e..d09f53c805cb841cba0745abd8ffeda0cf96fa00 100644
--- a/aconversions2/src/aconversion.cpp
+++ b/aconversions2/src/aconversion.cpp
@@ -33,7 +33,7 @@ int main(int argc, char* argv[])
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> inputTokens;
+		std::deque<sax::Token> inputTokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(inputTokens);
diff --git a/aderivation2/src/aderivation.cpp b/aderivation2/src/aderivation.cpp
index 0f39f2759f7d01ba941488bc14e97912f10020d7..c1da231f4114d51f4059a51040e1c017319a4b42 100644
--- a/aderivation2/src/aderivation.cpp
+++ b/aderivation2/src/aderivation.cpp
@@ -23,7 +23,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> stringTokens;
+		std::deque<sax::Token> stringTokens;
 		if(string.isSet()) {
 			if(string.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(stringTokens);
@@ -34,7 +34,7 @@ int main(int argc, char** argv) {
 			sax::SaxParseInterface::parseStdin(stringTokens);
 		}
 
-		std::list<sax::Token> regexpTokens;
+		std::deque<sax::Token> regexpTokens;
 		if(regexp.isSet()) {
 			if(regexp.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(regexpTokens);
diff --git a/adeterminize2/src/adeterminize.cpp b/adeterminize2/src/adeterminize.cpp
index 04106c58cbddc924e09d1f4e3ef21159efd5d929..ec5c98a6944af1d42a72bbec985650eb0042856b 100644
--- a/adeterminize2/src/adeterminize.cpp
+++ b/adeterminize2/src/adeterminize.cpp
@@ -21,7 +21,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/aecho2/src/aecho.cpp b/aecho2/src/aecho.cpp
index 0f8f05bec2f1033dee0b333fec737b83fea28d36..8232766a714f9d095bc71e083a2c4c764dc70354 100644
--- a/aecho2/src/aecho.cpp
+++ b/aecho2/src/aecho.cpp
@@ -22,7 +22,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/aepsilon2/src/aepsilon.cpp b/aepsilon2/src/aepsilon.cpp
index 2188fc904f1e523cb48867d0cd5c356337b2732e..32e8ec60cb70bb121cc26080f01090a7e2025502 100644
--- a/aepsilon2/src/aepsilon.cpp
+++ b/aepsilon2/src/aepsilon.cpp
@@ -34,7 +34,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/agenerate2/src/agenerate.cpp b/agenerate2/src/agenerate.cpp
index 60e719d2ab63b3e99346e13e550a4f52c610be47..7d040e00546b567ac523ed55a85dd49c24676f00 100644
--- a/agenerate2/src/agenerate.cpp
+++ b/agenerate2/src/agenerate.cpp
@@ -26,7 +26,7 @@ int main(int argc, char* argv[]) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> grammarTokens;
+		std::deque<sax::Token> grammarTokens;
 		if(grammar.isSet()) {
 			if(grammar.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(grammarTokens);
diff --git a/aintegral2/src/aintegral.cpp b/aintegral2/src/aintegral.cpp
index 9d4157f701ef746836ba9fabe91697a339f2aa4d..30621e0b6d5d3e7e75a4d15c0ee39a54d193989e 100644
--- a/aintegral2/src/aintegral.cpp
+++ b/aintegral2/src/aintegral.cpp
@@ -23,7 +23,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> stringTokens;
+		std::deque<sax::Token> stringTokens;
 		if(string.isSet()) {
 			if(string.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(stringTokens);
@@ -34,7 +34,7 @@ int main(int argc, char** argv) {
 			sax::SaxParseInterface::parseStdin(stringTokens);
 		}
 
-		std::list<sax::Token> regexpTokens;
+		std::deque<sax::Token> regexpTokens;
 		if(regexp.isSet()) {
 			if(regexp.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(regexpTokens);
diff --git a/alangop2/src/alangop.cpp b/alangop2/src/alangop.cpp
index 7165bddaee0d7e75d5e4e384f9d305a680dffdce..d6dea3a435a03bc592e66223f3ff62ff05b8fdcf 100644
--- a/alangop2/src/alangop.cpp
+++ b/alangop2/src/alangop.cpp
@@ -40,12 +40,12 @@ int main(int argc, char* argv[]) {
 
 		TCLAP::ValueArg<std::string> a1(	"i",	"input1",	"First automaton",	false,	"-",	"file");
 		TCLAP::ValueArg<std::string> a2(	"j",	"input2",	"Second automaton",	false,	"-",	"file");
-        cmd.add( a1 );
-        cmd.add( a2 );
+		cmd.add( a1 );
+		cmd.add( a2 );
 
 		cmd.parse(argc,argv);
 
-		std::list<sax::Token> a1Tokens, a2Tokens;
+		std::deque<sax::Token> a1Tokens, a2Tokens;
 		if(a1.isSet()) {
 			if(a1.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(a1Tokens);
diff --git a/alib2data/src/XmlApi.cpp b/alib2data/src/XmlApi.cpp
index 6ec73911c9643241aa3106c9c7eb3d2a3852376d..0cdd3c7054ec5fd02786276a6304ad246168826e 100644
--- a/alib2data/src/XmlApi.cpp
+++ b/alib2data/src/XmlApi.cpp
@@ -103,1259 +103,1259 @@ const std::string Names::PRIMITIVE_CHARACTER = "Character";
 const std::string Names::PRIMITIVE_UNSIGNED = "Unsigned";
 const std::string Names::PRIMITIVE_BOOL = "Bool";
 
-Void xmlApi<Void>::parse(std::list<sax::Token>& input) {
+Void xmlApi<Void>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::objectParser.parseVoid(input);
 }
 
-bool xmlApi<Void>::first(const std::list<sax::Token>& input) {
+bool xmlApi<Void>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALIB_VOID);
 }
 
-void xmlApi<Void>::compose(std::list<sax::Token>& output, const Void& data) {
+void xmlApi<Void>::compose(std::deque<sax::Token>& output, const Void& data) {
 	ToXMLComposers::objectComposer.compose(output, data);
 }
 
-container::Container xmlApi<container::Container>::parse(std::list<sax::Token>& input) {
+container::Container xmlApi<container::Container>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseContainer(input);
 }
 
-bool xmlApi<container::Container>::first(const std::list<sax::Token>& input) {
+bool xmlApi<container::Container>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.first(input);
 }
 
-void xmlApi<container::Container>::compose(std::list<sax::Token>& output, const container::Container& data) {
+void xmlApi<container::Container>::compose(std::deque<sax::Token>& output, const container::Container& data) {
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-container::ObjectsSet xmlApi<container::ObjectsSet>::parse(std::list<sax::Token>& input) {
+container::ObjectsSet xmlApi<container::ObjectsSet>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseObjectsSet(input);
 }
 
-bool xmlApi<container::ObjectsSet>::first(const std::list<sax::Token>& input) {
+bool xmlApi<container::ObjectsSet>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_SET);
 }
 
-void xmlApi<container::ObjectsSet>::compose(std::list<sax::Token>& output, const container::ObjectsSet& data) {
+void xmlApi<container::ObjectsSet>::compose(std::deque<sax::Token>& output, const container::ObjectsSet& data) {
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-container::ObjectsVector xmlApi<container::ObjectsVector>::parse(std::list<sax::Token>& input) {
+container::ObjectsVector xmlApi<container::ObjectsVector>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseObjectsVector(input);
 }
 
-bool xmlApi<container::ObjectsVector>::first(const std::list<sax::Token>& input) {
+bool xmlApi<container::ObjectsVector>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_VECTOR);
 }
 
-void xmlApi<container::ObjectsVector>::compose(std::list<sax::Token>& output, const container::ObjectsVector& data) {
+void xmlApi<container::ObjectsVector>::compose(std::deque<sax::Token>& output, const container::ObjectsVector& data) {
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-container::ObjectsPair xmlApi<container::ObjectsPair>::parse(std::list<sax::Token>& input) {
+container::ObjectsPair xmlApi<container::ObjectsPair>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseObjectsPair(input);
 }
 
-bool xmlApi<container::ObjectsPair>::first(const std::list<sax::Token>& input) {
+bool xmlApi<container::ObjectsPair>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_PAIR);
 }
 
-void xmlApi<container::ObjectsPair>::compose(std::list<sax::Token>& output, const container::ObjectsPair& data) {
+void xmlApi<container::ObjectsPair>::compose(std::deque<sax::Token>& output, const container::ObjectsPair& data) {
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-container::ObjectsMap xmlApi<container::ObjectsMap>::parse(std::list<sax::Token>& input) {
+container::ObjectsMap xmlApi<container::ObjectsMap>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseObjectsMap(input);
 }
 
-bool xmlApi<container::ObjectsMap>::first(const std::list<sax::Token>& input) {
+bool xmlApi<container::ObjectsMap>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::CONTAINER_OBJECTS_MAP);
 }
 
-void xmlApi<container::ObjectsMap>::compose(std::list<sax::Token>& output, const container::ObjectsMap& data) {
+void xmlApi<container::ObjectsMap>::compose(std::deque<sax::Token>& output, const container::ObjectsMap& data) {
 	ToXMLComposers::containerComposer.compose(output, data);
 }
 
-alib::Object xmlApi<alib::Object>::parse(std::list<sax::Token>& input) {
+alib::Object xmlApi<alib::Object>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::objectParser.parseObject(input);
 }
 
-bool xmlApi<alib::Object>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alib::Object>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::objectParser.first(input);
 }
 
-void xmlApi<alib::Object>::compose(std::list<sax::Token>& output, const alib::Object& data) {
+void xmlApi<alib::Object>::compose(std::deque<sax::Token>& output, const alib::Object& data) {
 	ToXMLComposers::objectComposer.compose(output, data);
 }
 
-exception::AlibException xmlApi<exception::AlibException>::parse(std::list<sax::Token>& input) {
+exception::AlibException xmlApi<exception::AlibException>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::exceptionParser.parseException(input);
 }
 
-bool xmlApi<exception::AlibException>::first(const std::list<sax::Token>& input) {
+bool xmlApi<exception::AlibException>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::EXCEPTION_ALIB_EXCEPTION);
 }
 
-void xmlApi<exception::AlibException>::compose(std::list<sax::Token>& output, const exception::AlibException& data) {
+void xmlApi<exception::AlibException>::compose(std::deque<sax::Token>& output, const exception::AlibException& data) {
 	ToXMLComposers::exceptionComposer.compose(output, data);
 }
 
-alphabet::Symbol xmlApi<alphabet::Symbol>::parse(std::list<sax::Token>& input) {
+alphabet::Symbol xmlApi<alphabet::Symbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseSymbol(input);
 }
 
-bool xmlApi<alphabet::Symbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::Symbol>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.first(input);
 }
 
-void xmlApi<alphabet::Symbol>::compose(std::list<sax::Token>& output, const alphabet::Symbol& data) {
+void xmlApi<alphabet::Symbol>::compose(std::deque<sax::Token>& output, const alphabet::Symbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::LabeledSymbol xmlApi<alphabet::LabeledSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::LabeledSymbol xmlApi<alphabet::LabeledSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseLabeledSymbol(input);
 }
 
-bool xmlApi<alphabet::LabeledSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::LabeledSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_LABELED_SYMBOL);
 }
 
-void xmlApi<alphabet::LabeledSymbol>::compose(std::list<sax::Token>& output, const alphabet::LabeledSymbol& data) {
+void xmlApi<alphabet::LabeledSymbol>::compose(std::deque<sax::Token>& output, const alphabet::LabeledSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::BlankSymbol xmlApi<alphabet::BlankSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::BlankSymbol xmlApi<alphabet::BlankSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseBlankSymbol(input);
 }
 
-bool xmlApi<alphabet::BlankSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::BlankSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BLANK_SYMBOL);
 }
 
-void xmlApi<alphabet::BlankSymbol>::compose(std::list<sax::Token>& output, const alphabet::BlankSymbol& data) {
+void xmlApi<alphabet::BlankSymbol>::compose(std::deque<sax::Token>& output, const alphabet::BlankSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::BottomOfTheStackSymbol xmlApi<alphabet::BottomOfTheStackSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::BottomOfTheStackSymbol xmlApi<alphabet::BottomOfTheStackSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseBottomOfTheStackSymbol(input);
 }
 
-bool xmlApi<alphabet::BottomOfTheStackSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::BottomOfTheStackSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL);
 }
 
-void xmlApi<alphabet::BottomOfTheStackSymbol>::compose(std::list<sax::Token>& output, const alphabet::BottomOfTheStackSymbol& data) {
+void xmlApi<alphabet::BottomOfTheStackSymbol>::compose(std::deque<sax::Token>& output, const alphabet::BottomOfTheStackSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::EndSymbol xmlApi<alphabet::EndSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::EndSymbol xmlApi<alphabet::EndSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseEndSymbol(input);
 }
 
-bool xmlApi<alphabet::EndSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::EndSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_END_SYMBOL);
 }
 
-void xmlApi<alphabet::EndSymbol>::compose(std::list<sax::Token>& output, const alphabet::EndSymbol& data) {
+void xmlApi<alphabet::EndSymbol>::compose(std::deque<sax::Token>& output, const alphabet::EndSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::StartSymbol xmlApi<alphabet::StartSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::StartSymbol xmlApi<alphabet::StartSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseStartSymbol(input);
 }
 
-bool xmlApi<alphabet::StartSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::StartSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_START_SYMBOL);
 }
 
-void xmlApi<alphabet::StartSymbol>::compose(std::list<sax::Token>& output, const alphabet::StartSymbol& data) {
+void xmlApi<alphabet::StartSymbol>::compose(std::deque<sax::Token>& output, const alphabet::StartSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::RankedSymbol xmlApi<alphabet::RankedSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::RankedSymbol xmlApi<alphabet::RankedSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseRankedSymbol(input);
 }
 
-bool xmlApi<alphabet::RankedSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::RankedSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_RANKED_SYMBOL);
 }
 
-void xmlApi<alphabet::RankedSymbol>::compose(std::list<sax::Token>& output, const alphabet::RankedSymbol& data) {
+void xmlApi<alphabet::RankedSymbol>::compose(std::deque<sax::Token>& output, const alphabet::RankedSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::BarSymbol xmlApi<alphabet::BarSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::BarSymbol xmlApi<alphabet::BarSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseBarSymbol(input);
 }
 
-bool xmlApi<alphabet::BarSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::BarSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_BAR_SYMBOL);
 }
 
-void xmlApi<alphabet::BarSymbol>::compose(std::list<sax::Token>& output, const alphabet::BarSymbol& data) {
+void xmlApi<alphabet::BarSymbol>::compose(std::deque<sax::Token>& output, const alphabet::BarSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::RankedBarSymbol xmlApi<alphabet::RankedBarSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::RankedBarSymbol xmlApi<alphabet::RankedBarSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseRankedBarSymbol(input);
 }
 
-bool xmlApi<alphabet::RankedBarSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::RankedBarSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_RANKED_BAR_SYMBOL);
 }
 
-void xmlApi<alphabet::RankedBarSymbol>::compose(std::list<sax::Token>& output, const alphabet::RankedBarSymbol& data) {
+void xmlApi<alphabet::RankedBarSymbol>::compose(std::deque<sax::Token>& output, const alphabet::RankedBarSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::SubtreeWildcardSymbol xmlApi<alphabet::SubtreeWildcardSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::SubtreeWildcardSymbol xmlApi<alphabet::SubtreeWildcardSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseSubtreeWildcardSymbol(input);
 }
 
-bool xmlApi<alphabet::SubtreeWildcardSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::SubtreeWildcardSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL);
 }
 
-void xmlApi<alphabet::SubtreeWildcardSymbol>::compose(std::list<sax::Token>& output, const alphabet::SubtreeWildcardSymbol& data) {
+void xmlApi<alphabet::SubtreeWildcardSymbol>::compose(std::deque<sax::Token>& output, const alphabet::SubtreeWildcardSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::SymbolSetSymbol xmlApi<alphabet::SymbolSetSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::SymbolSetSymbol xmlApi<alphabet::SymbolSetSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseSymbolSetSymbol(input);
 }
 
-bool xmlApi<alphabet::SymbolSetSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::SymbolSetSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_SYMBOL_SET_SYMBOL);
 }
 
-void xmlApi<alphabet::SymbolSetSymbol>::compose(std::list<sax::Token>& output, const alphabet::SymbolSetSymbol& data) {
+void xmlApi<alphabet::SymbolSetSymbol>::compose(std::deque<sax::Token>& output, const alphabet::SymbolSetSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::SymbolPairSymbol xmlApi<alphabet::SymbolPairSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::SymbolPairSymbol xmlApi<alphabet::SymbolPairSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseSymbolPairSymbol(input);
 }
 
-bool xmlApi<alphabet::SymbolPairSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::SymbolPairSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_SYMBOL_PAIR_SYMBOL);
 }
 
-void xmlApi<alphabet::SymbolPairSymbol>::compose(std::list<sax::Token>& output, const alphabet::SymbolPairSymbol& data) {
+void xmlApi<alphabet::SymbolPairSymbol>::compose(std::deque<sax::Token>& output, const alphabet::SymbolPairSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
-alphabet::UniqueSymbol xmlApi<alphabet::UniqueSymbol>::parse(std::list<sax::Token>& input) {
+alphabet::UniqueSymbol xmlApi<alphabet::UniqueSymbol>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::symbolParser.parseUniqueSymbol(input);
 }
 
-bool xmlApi<alphabet::UniqueSymbol>::first(const std::list<sax::Token>& input) {
+bool xmlApi<alphabet::UniqueSymbol>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::ALPHABET_UNIQUE_SYMBOL);
 }
 
-void xmlApi<alphabet::UniqueSymbol>::compose(std::list<sax::Token>& output, const alphabet::UniqueSymbol& data) {
+void xmlApi<alphabet::UniqueSymbol>::compose(std::deque<sax::Token>& output, const alphabet::UniqueSymbol& data) {
 	ToXMLComposers::symbolComposer.compose(output, data);
 }
 
 
-automaton::Automaton xmlApi<automaton::Automaton>::parse(std::list<sax::Token>& input) {
+automaton::Automaton xmlApi<automaton::Automaton>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseAutomaton(input);
 }
 
-bool xmlApi<automaton::Automaton>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::Automaton>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.first(input);
 }
 
-void xmlApi<automaton::Automaton>::compose(std::list<sax::Token>& output, const automaton::Automaton& data) {
+void xmlApi<automaton::Automaton>::compose(std::deque<sax::Token>& output, const automaton::Automaton& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::EpsilonNFA xmlApi<automaton::EpsilonNFA>::parse(std::list<sax::Token>& input) {
+automaton::EpsilonNFA xmlApi<automaton::EpsilonNFA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseEpsilonNFA(input);
 }
 
-bool xmlApi<automaton::EpsilonNFA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::EpsilonNFA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_EPSILON_NFA);
 }
 
-void xmlApi<automaton::EpsilonNFA>::compose(std::list<sax::Token>& output, const automaton::EpsilonNFA& data) {
+void xmlApi<automaton::EpsilonNFA>::compose(std::deque<sax::Token>& output, const automaton::EpsilonNFA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::MultiInitialStateNFA xmlApi<automaton::MultiInitialStateNFA>::parse(std::list<sax::Token>& input) {
+automaton::MultiInitialStateNFA xmlApi<automaton::MultiInitialStateNFA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseMultiInitialStateNFA(input);
 }
 
-bool xmlApi<automaton::MultiInitialStateNFA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::MultiInitialStateNFA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_MULTI_INITIAL_STATE_NFA);
 }
 
-void xmlApi<automaton::MultiInitialStateNFA>::compose(std::list<sax::Token>& output, const automaton::MultiInitialStateNFA& data) {
+void xmlApi<automaton::MultiInitialStateNFA>::compose(std::deque<sax::Token>& output, const automaton::MultiInitialStateNFA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::NFA xmlApi<automaton::NFA>::parse(std::list<sax::Token>& input) {
+automaton::NFA xmlApi<automaton::NFA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseNFA(input);
 }
 
-bool xmlApi<automaton::NFA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::NFA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_NFA);
 }
 
-void xmlApi<automaton::NFA>::compose(std::list<sax::Token>& output, const automaton::NFA& data) {
+void xmlApi<automaton::NFA>::compose(std::deque<sax::Token>& output, const automaton::NFA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::DFA xmlApi<automaton::DFA>::parse(std::list<sax::Token>& input) {
+automaton::DFA xmlApi<automaton::DFA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseDFA(input);
 }
 
-bool xmlApi<automaton::DFA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::DFA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_DFA);
 }
 
-void xmlApi<automaton::DFA>::compose(std::list<sax::Token>& output, const automaton::DFA& data) {
+void xmlApi<automaton::DFA>::compose(std::deque<sax::Token>& output, const automaton::DFA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::ExtendedNFA xmlApi<automaton::ExtendedNFA>::parse(std::list<sax::Token>& input) {
+automaton::ExtendedNFA xmlApi<automaton::ExtendedNFA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseExtendedNFA(input);
 }
 
-bool xmlApi<automaton::ExtendedNFA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::ExtendedNFA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_EXTENDED_NFA);
 }
 
-void xmlApi<automaton::ExtendedNFA>::compose(std::list<sax::Token>& output, const automaton::ExtendedNFA& data) {
+void xmlApi<automaton::ExtendedNFA>::compose(std::deque<sax::Token>& output, const automaton::ExtendedNFA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::CompactNFA xmlApi<automaton::CompactNFA>::parse(std::list<sax::Token>& input) {
+automaton::CompactNFA xmlApi<automaton::CompactNFA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseCompactNFA(input);
 }
 
-bool xmlApi<automaton::CompactNFA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::CompactNFA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_COMPACT_NFA);
 }
 
-void xmlApi<automaton::CompactNFA>::compose(std::list<sax::Token>& output, const automaton::CompactNFA& data) {
+void xmlApi<automaton::CompactNFA>::compose(std::deque<sax::Token>& output, const automaton::CompactNFA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::DPDA xmlApi<automaton::DPDA>::parse(std::list<sax::Token>& input) {
+automaton::DPDA xmlApi<automaton::DPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseDPDA(input);
 }
 
-bool xmlApi<automaton::DPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::DPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_DPDA);
 }
 
-void xmlApi<automaton::DPDA>::compose(std::list<sax::Token>& output, const automaton::DPDA& data) {
+void xmlApi<automaton::DPDA>::compose(std::deque<sax::Token>& output, const automaton::DPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::SinglePopDPDA xmlApi<automaton::SinglePopDPDA>::parse(std::list<sax::Token>& input) {
+automaton::SinglePopDPDA xmlApi<automaton::SinglePopDPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseSinglePopDPDA(input);
 }
 
-bool xmlApi<automaton::SinglePopDPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::SinglePopDPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_SINGLE_POP_DPDA);
 }
 
-void xmlApi<automaton::SinglePopDPDA>::compose(std::list<sax::Token>& output, const automaton::SinglePopDPDA& data) {
+void xmlApi<automaton::SinglePopDPDA>::compose(std::deque<sax::Token>& output, const automaton::SinglePopDPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::InputDrivenDPDA xmlApi<automaton::InputDrivenDPDA>::parse(std::list<sax::Token>& input) {
+automaton::InputDrivenDPDA xmlApi<automaton::InputDrivenDPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseInputDrivenDPDA(input);
 }
 
-bool xmlApi<automaton::InputDrivenDPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::InputDrivenDPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_INPUT_DRIVEN_DPDA);
 }
 
-void xmlApi<automaton::InputDrivenDPDA>::compose(std::list<sax::Token>& output, const automaton::InputDrivenDPDA& data) {
+void xmlApi<automaton::InputDrivenDPDA>::compose(std::deque<sax::Token>& output, const automaton::InputDrivenDPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::InputDrivenNPDA xmlApi<automaton::InputDrivenNPDA>::parse(std::list<sax::Token>& input) {
+automaton::InputDrivenNPDA xmlApi<automaton::InputDrivenNPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseInputDrivenNPDA(input);
 }
 
-bool xmlApi<automaton::InputDrivenNPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::InputDrivenNPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_INPUT_DRIVEN_NPDA);
 }
 
-void xmlApi<automaton::InputDrivenNPDA>::compose(std::list<sax::Token>& output, const automaton::InputDrivenNPDA& data) {
+void xmlApi<automaton::InputDrivenNPDA>::compose(std::deque<sax::Token>& output, const automaton::InputDrivenNPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::VisiblyPushdownDPDA xmlApi<automaton::VisiblyPushdownDPDA>::parse(std::list<sax::Token>& input) {
+automaton::VisiblyPushdownDPDA xmlApi<automaton::VisiblyPushdownDPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseVisiblyPushdownDPDA(input);
 }
 
-bool xmlApi<automaton::VisiblyPushdownDPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::VisiblyPushdownDPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA);
 }
 
-void xmlApi<automaton::VisiblyPushdownDPDA>::compose(std::list<sax::Token>& output, const automaton::VisiblyPushdownDPDA& data) {
+void xmlApi<automaton::VisiblyPushdownDPDA>::compose(std::deque<sax::Token>& output, const automaton::VisiblyPushdownDPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::VisiblyPushdownNPDA xmlApi<automaton::VisiblyPushdownNPDA>::parse(std::list<sax::Token>& input) {
+automaton::VisiblyPushdownNPDA xmlApi<automaton::VisiblyPushdownNPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseVisiblyPushdownNPDA(input);
 }
 
-bool xmlApi<automaton::VisiblyPushdownNPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::VisiblyPushdownNPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA);
 }
 
-void xmlApi<automaton::VisiblyPushdownNPDA>::compose(std::list<sax::Token>& output, const automaton::VisiblyPushdownNPDA& data) {
+void xmlApi<automaton::VisiblyPushdownNPDA>::compose(std::deque<sax::Token>& output, const automaton::VisiblyPushdownNPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::RealTimeHeightDeterministicDPDA xmlApi<automaton::RealTimeHeightDeterministicDPDA>::parse(std::list<sax::Token>& input) {
+automaton::RealTimeHeightDeterministicDPDA xmlApi<automaton::RealTimeHeightDeterministicDPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseRealTimeHeightDeterministicDPDA(input);
 }
 
-bool xmlApi<automaton::RealTimeHeightDeterministicDPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::RealTimeHeightDeterministicDPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA);
 }
 
-void xmlApi<automaton::RealTimeHeightDeterministicDPDA>::compose(std::list<sax::Token>& output, const automaton::RealTimeHeightDeterministicDPDA& data) {
+void xmlApi<automaton::RealTimeHeightDeterministicDPDA>::compose(std::deque<sax::Token>& output, const automaton::RealTimeHeightDeterministicDPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::RealTimeHeightDeterministicNPDA xmlApi<automaton::RealTimeHeightDeterministicNPDA>::parse(std::list<sax::Token>& input) {
+automaton::RealTimeHeightDeterministicNPDA xmlApi<automaton::RealTimeHeightDeterministicNPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseRealTimeHeightDeterministicNPDA(input);
 }
 
-bool xmlApi<automaton::RealTimeHeightDeterministicNPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::RealTimeHeightDeterministicNPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA);
 }
 
-void xmlApi<automaton::RealTimeHeightDeterministicNPDA>::compose(std::list<sax::Token>& output, const automaton::RealTimeHeightDeterministicNPDA& data) {
+void xmlApi<automaton::RealTimeHeightDeterministicNPDA>::compose(std::deque<sax::Token>& output, const automaton::RealTimeHeightDeterministicNPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::NPDA xmlApi<automaton::NPDA>::parse(std::list<sax::Token>& input) {
+automaton::NPDA xmlApi<automaton::NPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseNPDA(input);
 }
 
-bool xmlApi<automaton::NPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::NPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_NPDA);
 }
 
-void xmlApi<automaton::NPDA>::compose(std::list<sax::Token>& output, const automaton::NPDA& data) {
+void xmlApi<automaton::NPDA>::compose(std::deque<sax::Token>& output, const automaton::NPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::SinglePopNPDA xmlApi<automaton::SinglePopNPDA>::parse(std::list<sax::Token>& input) {
+automaton::SinglePopNPDA xmlApi<automaton::SinglePopNPDA>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseSinglePopNPDA(input);
 }
 
-bool xmlApi<automaton::SinglePopNPDA>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::SinglePopNPDA>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_SINGLE_POP_NPDA);
 }
 
-void xmlApi<automaton::SinglePopNPDA>::compose(std::list<sax::Token>& output, const automaton::SinglePopNPDA& data) {
+void xmlApi<automaton::SinglePopNPDA>::compose(std::deque<sax::Token>& output, const automaton::SinglePopNPDA& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::OneTapeDTM xmlApi<automaton::OneTapeDTM>::parse(std::list<sax::Token>& input) {
+automaton::OneTapeDTM xmlApi<automaton::OneTapeDTM>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseOneTapeDTM(input);
 }
 
-bool xmlApi<automaton::OneTapeDTM>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::OneTapeDTM>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_ONE_TAPE_DTM);
 }
 
-void xmlApi<automaton::OneTapeDTM>::compose(std::list<sax::Token>& output, const automaton::OneTapeDTM& data) {
+void xmlApi<automaton::OneTapeDTM>::compose(std::deque<sax::Token>& output, const automaton::OneTapeDTM& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
-automaton::State xmlApi<automaton::State>::parse(std::list<sax::Token>& input) {
+automaton::State xmlApi<automaton::State>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::automatonParser.parseState(input);
 }
 
-bool xmlApi<automaton::State>::first(const std::list<sax::Token>& input) {
+bool xmlApi<automaton::State>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::AUTOMATON_STATE);
 }
 
-void xmlApi<automaton::State>::compose(std::list<sax::Token>& output, const automaton::State& data) {
+void xmlApi<automaton::State>::compose(std::deque<sax::Token>& output, const automaton::State& data) {
 	ToXMLComposers::automatonComposer.compose(output, data);
 }
 
 
-grammar::Grammar xmlApi<grammar::Grammar>::parse(std::list<sax::Token>& input) {
+grammar::Grammar xmlApi<grammar::Grammar>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseGrammar(input);
 }
 
-bool xmlApi<grammar::Grammar>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::Grammar>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.first(input);
 }
 
-void xmlApi<grammar::Grammar>::compose(std::list<sax::Token>& output, const grammar::Grammar& data) {
+void xmlApi<grammar::Grammar>::compose(std::deque<sax::Token>& output, const grammar::Grammar& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::LeftLG xmlApi<grammar::LeftLG>::parse(std::list<sax::Token>& input) {
+grammar::LeftLG xmlApi<grammar::LeftLG>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseLeftLG(input);
 }
 
-bool xmlApi<grammar::LeftLG>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::LeftLG>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LEFT_LG);
 }
 
-void xmlApi<grammar::LeftLG>::compose(std::list<sax::Token>& output, const grammar::LeftLG& data) {
+void xmlApi<grammar::LeftLG>::compose(std::deque<sax::Token>& output, const grammar::LeftLG& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::LeftRG xmlApi<grammar::LeftRG>::parse(std::list<sax::Token>& input) {
+grammar::LeftRG xmlApi<grammar::LeftRG>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseLeftRG(input);
 }
 
-bool xmlApi<grammar::LeftRG>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::LeftRG>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LEFT_RG);
 }
 
-void xmlApi<grammar::LeftRG>::compose(std::list<sax::Token>& output, const grammar::LeftRG& data) {
+void xmlApi<grammar::LeftRG>::compose(std::deque<sax::Token>& output, const grammar::LeftRG& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::RightLG xmlApi<grammar::RightLG>::parse(std::list<sax::Token>& input) {
+grammar::RightLG xmlApi<grammar::RightLG>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseRightLG(input);
 }
 
-bool xmlApi<grammar::RightLG>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::RightLG>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_RIGHT_LG);
 }
 
-void xmlApi<grammar::RightLG>::compose(std::list<sax::Token>& output, const grammar::RightLG& data) {
+void xmlApi<grammar::RightLG>::compose(std::deque<sax::Token>& output, const grammar::RightLG& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::RightRG xmlApi<grammar::RightRG>::parse(std::list<sax::Token>& input) {
+grammar::RightRG xmlApi<grammar::RightRG>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseRightRG(input);
 }
 
-bool xmlApi<grammar::RightRG>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::RightRG>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_RIGHT_RG);
 }
 
-void xmlApi<grammar::RightRG>::compose(std::list<sax::Token>& output, const grammar::RightRG& data) {
+void xmlApi<grammar::RightRG>::compose(std::deque<sax::Token>& output, const grammar::RightRG& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::LG xmlApi<grammar::LG>::parse(std::list<sax::Token>& input) {
+grammar::LG xmlApi<grammar::LG>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseLG(input);
 }
 
-bool xmlApi<grammar::LG>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::LG>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LG);
 }
 
-void xmlApi<grammar::LG>::compose(std::list<sax::Token>& output, const grammar::LG& data) {
+void xmlApi<grammar::LG>::compose(std::deque<sax::Token>& output, const grammar::LG& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::CFG xmlApi<grammar::CFG>::parse(std::list<sax::Token>& input) {
+grammar::CFG xmlApi<grammar::CFG>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseCFG(input);
 }
 
-bool xmlApi<grammar::CFG>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::CFG>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CFG);
 }
 
-void xmlApi<grammar::CFG>::compose(std::list<sax::Token>& output, const grammar::CFG& data) {
+void xmlApi<grammar::CFG>::compose(std::deque<sax::Token>& output, const grammar::CFG& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::EpsilonFreeCFG xmlApi<grammar::EpsilonFreeCFG>::parse(std::list<sax::Token>& input) {
+grammar::EpsilonFreeCFG xmlApi<grammar::EpsilonFreeCFG>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseEpsilonFreeCFG(input);
 }
 
-bool xmlApi<grammar::EpsilonFreeCFG>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::EpsilonFreeCFG>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_EPSILON_FREE_CFG);
 }
 
-void xmlApi<grammar::EpsilonFreeCFG>::compose(std::list<sax::Token>& output, const grammar::EpsilonFreeCFG& data) {
+void xmlApi<grammar::EpsilonFreeCFG>::compose(std::deque<sax::Token>& output, const grammar::EpsilonFreeCFG& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::CNF xmlApi<grammar::CNF>::parse(std::list<sax::Token>& input) {
+grammar::CNF xmlApi<grammar::CNF>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseCNF(input);
 }
 
-bool xmlApi<grammar::CNF>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::CNF>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CNF);
 }
 
-void xmlApi<grammar::CNF>::compose(std::list<sax::Token>& output, const grammar::CNF& data) {
+void xmlApi<grammar::CNF>::compose(std::deque<sax::Token>& output, const grammar::CNF& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::GNF xmlApi<grammar::GNF>::parse(std::list<sax::Token>& input) {
+grammar::GNF xmlApi<grammar::GNF>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseGNF(input);
 }
 
-bool xmlApi<grammar::GNF>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::GNF>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_GNF);
 }
 
-void xmlApi<grammar::GNF>::compose(std::list<sax::Token>& output, const grammar::GNF& data) {
+void xmlApi<grammar::GNF>::compose(std::deque<sax::Token>& output, const grammar::GNF& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::CSG xmlApi<grammar::CSG>::parse(std::list<sax::Token>& input) {
+grammar::CSG xmlApi<grammar::CSG>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseCSG(input);
 }
 
-bool xmlApi<grammar::CSG>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::CSG>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CSG);
 }
 
-void xmlApi<grammar::CSG>::compose(std::list<sax::Token>& output, const grammar::CSG& data) {
+void xmlApi<grammar::CSG>::compose(std::deque<sax::Token>& output, const grammar::CSG& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::NonContractingGrammar xmlApi<grammar::NonContractingGrammar>::parse(std::list<sax::Token>& input) {
+grammar::NonContractingGrammar xmlApi<grammar::NonContractingGrammar>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseNonContractingGrammar(input);
 }
 
-bool xmlApi<grammar::NonContractingGrammar>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::NonContractingGrammar>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
 }
 
-void xmlApi<grammar::NonContractingGrammar>::compose(std::list<sax::Token>& output, const grammar::NonContractingGrammar& data) {
+void xmlApi<grammar::NonContractingGrammar>::compose(std::deque<sax::Token>& output, const grammar::NonContractingGrammar& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::ContextPreservingUnrestrictedGrammar xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::parse(std::list<sax::Token>& input) {
+grammar::ContextPreservingUnrestrictedGrammar xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseContextPreservingUnrestrictedGrammar(input);
 }
 
-bool xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
 }
 
-void xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::compose(std::list<sax::Token>& output, const grammar::ContextPreservingUnrestrictedGrammar& data) {
+void xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::compose(std::deque<sax::Token>& output, const grammar::ContextPreservingUnrestrictedGrammar& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
-grammar::UnrestrictedGrammar xmlApi<grammar::UnrestrictedGrammar>::parse(std::list<sax::Token>& input) {
+grammar::UnrestrictedGrammar xmlApi<grammar::UnrestrictedGrammar>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::grammarParser.parseUnrestrictedGrammar(input);
 }
 
-bool xmlApi<grammar::UnrestrictedGrammar>::first(const std::list<sax::Token>& input) {
+bool xmlApi<grammar::UnrestrictedGrammar>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
 }
 
-void xmlApi<grammar::UnrestrictedGrammar>::compose(std::list<sax::Token>& output, const grammar::UnrestrictedGrammar& data) {
+void xmlApi<grammar::UnrestrictedGrammar>::compose(std::deque<sax::Token>& output, const grammar::UnrestrictedGrammar& data) {
 	ToXMLComposers::grammarComposer.compose(output, data);
 }
 
 
-graph::Graph xmlApi<graph::Graph>::parse(std::list<sax::Token>& input) {
+graph::Graph xmlApi<graph::Graph>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::graphParser.parseGraph(input);
 }
 
-bool xmlApi<graph::Graph>::first(const std::list<sax::Token>& input) {
+bool xmlApi<graph::Graph>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::graphParser.first(input);
 }
 
-void xmlApi<graph::Graph>::compose(std::list<sax::Token>& output, const graph::Graph& data) {
+void xmlApi<graph::Graph>::compose(std::deque<sax::Token>& output, const graph::Graph& data) {
 	ToXMLComposers::graphComposer.compose(output, data);
 }
 
-graph::DirectedGraph xmlApi<graph::DirectedGraph>::parse(std::list<sax::Token>& input) {
+graph::DirectedGraph xmlApi<graph::DirectedGraph>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::graphParser.parseDirectedGraph(input);
 }
 
-bool xmlApi<graph::DirectedGraph>::first(const std::list<sax::Token>& input) {
+bool xmlApi<graph::DirectedGraph>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAPH_DIRECTED_GRAPH);
 }
 
-void xmlApi<graph::DirectedGraph>::compose(std::list<sax::Token>& output, const graph::DirectedGraph& data) {
+void xmlApi<graph::DirectedGraph>::compose(std::deque<sax::Token>& output, const graph::DirectedGraph& data) {
 	ToXMLComposers::graphComposer.compose(output, data);
 }
 
-graph::UndirectedGraph xmlApi<graph::UndirectedGraph>::parse(std::list<sax::Token>& input) {
+graph::UndirectedGraph xmlApi<graph::UndirectedGraph>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::graphParser.parseUndirectedGraph(input);
 }
 
-bool xmlApi<graph::UndirectedGraph>::first(const std::list<sax::Token>& input) {
+bool xmlApi<graph::UndirectedGraph>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAPH_UNDIRECTED_GRAPH);
 }
 
-void xmlApi<graph::UndirectedGraph>::compose(std::list<sax::Token>& output, const graph::UndirectedGraph& data) {
+void xmlApi<graph::UndirectedGraph>::compose(std::deque<sax::Token>& output, const graph::UndirectedGraph& data) {
 	ToXMLComposers::graphComposer.compose(output, data);
 }
 
 
-label::Label xmlApi<label::Label>::parse(std::list<sax::Token>& input) {
+label::Label xmlApi<label::Label>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::labelParser.parseLabel(input);
 }
 
-bool xmlApi<label::Label>::first(const std::list<sax::Token>& input) {
+bool xmlApi<label::Label>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::labelParser.first(input);
 }
 
-void xmlApi<label::Label>::compose(std::list<sax::Token>& output, const label::Label& data) {
+void xmlApi<label::Label>::compose(std::deque<sax::Token>& output, const label::Label& data) {
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::PrimitiveLabel xmlApi<label::PrimitiveLabel>::parse(std::list<sax::Token>& input) {
+label::PrimitiveLabel xmlApi<label::PrimitiveLabel>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::labelParser.parsePrimitiveLabel(input);
 }
 
-bool xmlApi<label::PrimitiveLabel>::first(const std::list<sax::Token>& input) {
+bool xmlApi<label::PrimitiveLabel>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_PRIMITIVE_LABEL);
 }
 
-void xmlApi<label::PrimitiveLabel>::compose(std::list<sax::Token>& output, const label::PrimitiveLabel& data) {
+void xmlApi<label::PrimitiveLabel>::compose(std::deque<sax::Token>& output, const label::PrimitiveLabel& data) {
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::HexavigesimalLabel xmlApi<label::HexavigesimalLabel>::parse(std::list<sax::Token>& input) {
+label::HexavigesimalLabel xmlApi<label::HexavigesimalLabel>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::labelParser.parseHexavigesimalLabel(input);
 }
 
-bool xmlApi<label::HexavigesimalLabel>::first(const std::list<sax::Token>& input) {
+bool xmlApi<label::HexavigesimalLabel>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_PRIMITIVE_LABEL);
 }
 
-void xmlApi<label::HexavigesimalLabel>::compose(std::list<sax::Token>& output, const label::HexavigesimalLabel& data) {
+void xmlApi<label::HexavigesimalLabel>::compose(std::deque<sax::Token>& output, const label::HexavigesimalLabel& data) {
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::ObjectLabel xmlApi<label::ObjectLabel>::parse(std::list<sax::Token>& input) {
+label::ObjectLabel xmlApi<label::ObjectLabel>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::labelParser.parseObjectLabel(input);
 }
 
-bool xmlApi<label::ObjectLabel>::first(const std::list<sax::Token>& input) {
+bool xmlApi<label::ObjectLabel>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_OBJECT_LABEL);
 }
 
-void xmlApi<label::ObjectLabel>::compose(std::list<sax::Token>& output, const label::ObjectLabel& data) {
+void xmlApi<label::ObjectLabel>::compose(std::deque<sax::Token>& output, const label::ObjectLabel& data) {
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::LabelSetLabel xmlApi<label::LabelSetLabel>::parse(std::list<sax::Token>& input) {
+label::LabelSetLabel xmlApi<label::LabelSetLabel>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::labelParser.parseLabelSetLabel(input);
 }
 
-bool xmlApi<label::LabelSetLabel>::first(const std::list<sax::Token>& input) {
+bool xmlApi<label::LabelSetLabel>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_LABEL_SET_LABEL);
 }
 
-void xmlApi<label::LabelSetLabel>::compose(std::list<sax::Token>& output, const label::LabelSetLabel& data) {
+void xmlApi<label::LabelSetLabel>::compose(std::deque<sax::Token>& output, const label::LabelSetLabel& data) {
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::LabelPairLabel xmlApi<label::LabelPairLabel>::parse(std::list<sax::Token>& input) {
+label::LabelPairLabel xmlApi<label::LabelPairLabel>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::labelParser.parseLabelPairLabel(input);
 }
 
-bool xmlApi<label::LabelPairLabel>::first(const std::list<sax::Token>& input) {
+bool xmlApi<label::LabelPairLabel>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_LABEL_PAIR_LABEL);
 }
 
-void xmlApi<label::LabelPairLabel>::compose(std::list<sax::Token>& output, const label::LabelPairLabel& data) {
+void xmlApi<label::LabelPairLabel>::compose(std::deque<sax::Token>& output, const label::LabelPairLabel& data) {
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
-label::UniqueLabel xmlApi<label::UniqueLabel>::parse(std::list<sax::Token>& input) {
+label::UniqueLabel xmlApi<label::UniqueLabel>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::labelParser.parseUniqueLabel(input);
 }
 
-bool xmlApi<label::UniqueLabel>::first(const std::list<sax::Token>& input) {
+bool xmlApi<label::UniqueLabel>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::LABEL_UNIQUE_LABEL);
 }
 
-void xmlApi<label::UniqueLabel>::compose(std::list<sax::Token>& output, const label::UniqueLabel& data) {
+void xmlApi<label::UniqueLabel>::compose(std::deque<sax::Token>& output, const label::UniqueLabel& data) {
 	ToXMLComposers::labelComposer.compose(output, data);
 }
 
 
-regexp::RegExp xmlApi<regexp::RegExp>::parse(std::list<sax::Token>& input) {
+regexp::RegExp xmlApi<regexp::RegExp>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::regexpParser.parseRegExp(input);
 }
 
-bool xmlApi<regexp::RegExp>::first(const std::list<sax::Token>& input) {
+bool xmlApi<regexp::RegExp>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::regexpParser.first(input);
 }
 
-void xmlApi<regexp::RegExp>::compose(std::list<sax::Token>& output, const regexp::RegExp& data) {
+void xmlApi<regexp::RegExp>::compose(std::deque<sax::Token>& output, const regexp::RegExp& data) {
 	ToXMLComposers::regexpComposer.compose(output, data);
 }
 
-regexp::UnboundedRegExp xmlApi<regexp::UnboundedRegExp>::parse(std::list<sax::Token>& input) {
+regexp::UnboundedRegExp xmlApi<regexp::UnboundedRegExp>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::regexpParser.parseUnboundedRegExp(input);
 }
 
-bool xmlApi<regexp::UnboundedRegExp>::first(const std::list<sax::Token>& input) {
+bool xmlApi<regexp::UnboundedRegExp>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::REGEXP_UNBOUNDED_REGEXP);
 }
 
-void xmlApi<regexp::UnboundedRegExp>::compose(std::list<sax::Token>& output, const regexp::UnboundedRegExp& data) {
+void xmlApi<regexp::UnboundedRegExp>::compose(std::deque<sax::Token>& output, const regexp::UnboundedRegExp& data) {
 	ToXMLComposers::regexpComposer.compose(output, data);
 }
 
-regexp::FormalRegExp xmlApi<regexp::FormalRegExp>::parse(std::list<sax::Token>& input) {
+regexp::FormalRegExp xmlApi<regexp::FormalRegExp>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::regexpParser.parseFormalRegExp(input);
 }
 
-bool xmlApi<regexp::FormalRegExp>::first(const std::list<sax::Token>& input) {
+bool xmlApi<regexp::FormalRegExp>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::REGEXP_FORMAL_REGEXP);
 }
 
-void xmlApi<regexp::FormalRegExp>::compose(std::list<sax::Token>& output, const regexp::FormalRegExp& data) {
+void xmlApi<regexp::FormalRegExp>::compose(std::deque<sax::Token>& output, const regexp::FormalRegExp& data) {
 	ToXMLComposers::regexpComposer.compose(output, data);
 }
 
 
-string::String xmlApi<string::String>::parse(std::list<sax::Token>& input) {
+string::String xmlApi<string::String>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::stringParser.parseString(input);
 }
 
-bool xmlApi<string::String>::first(const std::list<sax::Token>& input) {
+bool xmlApi<string::String>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::stringParser.first(input);
 }
 
-void xmlApi<string::String>::compose(std::list<sax::Token>& output, const string::String& data) {
+void xmlApi<string::String>::compose(std::deque<sax::Token>& output, const string::String& data) {
 	ToXMLComposers::stringComposer.compose(output, data);
 }
 
-string::LinearString xmlApi<string::LinearString>::parse(std::list<sax::Token>& input) {
+string::LinearString xmlApi<string::LinearString>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::stringParser.parseLinearString(input);
 }
 
-bool xmlApi<string::LinearString>::first(const std::list<sax::Token>& input) {
+bool xmlApi<string::LinearString>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_LINEAR_STRING);
 }
 
-void xmlApi<string::LinearString>::compose(std::list<sax::Token>& output, const string::LinearString& data) {
+void xmlApi<string::LinearString>::compose(std::deque<sax::Token>& output, const string::LinearString& data) {
 	ToXMLComposers::stringComposer.compose(output, data);
 }
 
-string::CyclicString xmlApi<string::CyclicString>::parse(std::list<sax::Token>& input) {
+string::CyclicString xmlApi<string::CyclicString>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::stringParser.parseCyclicString(input);
 }
 
-bool xmlApi<string::CyclicString>::first(const std::list<sax::Token>& input) {
+bool xmlApi<string::CyclicString>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_CYCLIC_STRING);
 }
 
-void xmlApi<string::CyclicString>::compose(std::list<sax::Token>& output, const string::CyclicString& data) {
+void xmlApi<string::CyclicString>::compose(std::deque<sax::Token>& output, const string::CyclicString& data) {
 	ToXMLComposers::stringComposer.compose(output, data);
 }
 
-string::Epsilon xmlApi<string::Epsilon>::parse(std::list<sax::Token>& input) {
+string::Epsilon xmlApi<string::Epsilon>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::stringParser.parseEpsilon(input);
 }
 
-bool xmlApi<string::Epsilon>::first(const std::list<sax::Token>& input) {
+bool xmlApi<string::Epsilon>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::STRING_EPSILON);
 }
 
-void xmlApi<string::Epsilon>::compose(std::list<sax::Token>& output, const string::Epsilon& data) {
+void xmlApi<string::Epsilon>::compose(std::deque<sax::Token>& output, const string::Epsilon& data) {
 	ToXMLComposers::stringComposer.compose(output, data);
 }
 
 
-primitive::Primitive xmlApi<primitive::Primitive>::parse(std::list<sax::Token>& input) {
+primitive::Primitive xmlApi<primitive::Primitive>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parsePrimitive(input);
 }
 
-bool xmlApi<primitive::Primitive>::first(const std::list<sax::Token>& input) {
+bool xmlApi<primitive::Primitive>::first(const std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.first(input);
 }
 
-void xmlApi<primitive::Primitive>::compose(std::list<sax::Token>& output, const primitive::Primitive& data) {
+void xmlApi<primitive::Primitive>::compose(std::deque<sax::Token>& output, const primitive::Primitive& data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::String xmlApi<primitive::String>::parse(std::list<sax::Token>& input) {
+primitive::String xmlApi<primitive::String>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseString(input);
 }
 
-bool xmlApi<primitive::String>::first(const std::list<sax::Token>& input) {
+bool xmlApi<primitive::String>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_STRING);
 }
 
-void xmlApi<primitive::String>::compose(std::list<sax::Token>& output, const primitive::String& data) {
+void xmlApi<primitive::String>::compose(std::deque<sax::Token>& output, const primitive::String& data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-std::string xmlApi<std::string>::parse(std::list<sax::Token>& input) {
+std::string xmlApi<std::string>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseStringRaw(input);
 }
 
-bool xmlApi<std::string>::first(const std::list<sax::Token>& input) {
+bool xmlApi<std::string>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_STRING);
 }
 
-void xmlApi<std::string>::compose(std::list<sax::Token>& output, const std::string& data) {
+void xmlApi<std::string>::compose(std::deque<sax::Token>& output, const std::string& data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::Integer xmlApi<primitive::Integer>::parse(std::list<sax::Token>& input) {
+primitive::Integer xmlApi<primitive::Integer>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseInteger(input);
 }
 
-bool xmlApi<primitive::Integer>::first(const std::list<sax::Token>& input) {
+bool xmlApi<primitive::Integer>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_INTEGER);
 }
 
-void xmlApi<primitive::Integer>::compose(std::list<sax::Token>& output, const primitive::Integer& data) {
+void xmlApi<primitive::Integer>::compose(std::deque<sax::Token>& output, const primitive::Integer& data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-int xmlApi<int>::parse(std::list<sax::Token>& input) {
+int xmlApi<int>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseIntegerRaw(input);
 }
 
-bool xmlApi<int>::first(const std::list<sax::Token>& input) {
+bool xmlApi<int>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_INTEGER);
 }
 
-void xmlApi<int>::compose(std::list<sax::Token>& output, int data) {
+void xmlApi<int>::compose(std::deque<sax::Token>& output, int data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::Character xmlApi<primitive::Character>::parse(std::list<sax::Token>& input) {
+primitive::Character xmlApi<primitive::Character>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseCharacter(input);
 }
 
-bool xmlApi<primitive::Character>::first(const std::list<sax::Token>& input) {
+bool xmlApi<primitive::Character>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
 }
 
-void xmlApi<primitive::Character>::compose(std::list<sax::Token>& output, const primitive::Character& data) {
+void xmlApi<primitive::Character>::compose(std::deque<sax::Token>& output, const primitive::Character& data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::Unsigned xmlApi<primitive::Unsigned>::parse(std::list<sax::Token>& input) {
+primitive::Unsigned xmlApi<primitive::Unsigned>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseUnsigned(input);
 }
 
-bool xmlApi<primitive::Unsigned>::first(const std::list<sax::Token>& input) {
+bool xmlApi<primitive::Unsigned>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_UNSIGNED);
 }
 
-void xmlApi<primitive::Unsigned>::compose(std::list<sax::Token>& output, const primitive::Unsigned& data) {
+void xmlApi<primitive::Unsigned>::compose(std::deque<sax::Token>& output, const primitive::Unsigned& data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-primitive::Bool xmlApi<primitive::Bool>::parse(std::list<sax::Token>& input) {
+primitive::Bool xmlApi<primitive::Bool>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseBool(input);
 }
 
-bool xmlApi<primitive::Bool>::first(const std::list<sax::Token>& input) {
+bool xmlApi<primitive::Bool>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_BOOL);
 }
 
-void xmlApi<primitive::Bool>::compose(std::list<sax::Token>& output, const primitive::Bool& data) {
+void xmlApi<primitive::Bool>::compose(std::deque<sax::Token>& output, const primitive::Bool& data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-char xmlApi<char>::parse(std::list<sax::Token>& input) {
+char xmlApi<char>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
 }
 
-bool xmlApi<char>::first(const std::list<sax::Token>& input) {
+bool xmlApi<char>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
 }
 
-void xmlApi<char>::compose(std::list<sax::Token>& output, char data) {
+void xmlApi<char>::compose(std::deque<sax::Token>& output, char data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-unsigned xmlApi<unsigned>::parse(std::list<sax::Token>& input) {
+unsigned xmlApi<unsigned>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
 }
 
-bool xmlApi<unsigned>::first(const std::list<sax::Token>& input) {
+bool xmlApi<unsigned>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
 }
 
-void xmlApi<unsigned>::compose(std::list<sax::Token>& output, unsigned data) {
+void xmlApi<unsigned>::compose(std::deque<sax::Token>& output, unsigned data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
-bool xmlApi<bool>::parse(std::list<sax::Token>& input) {
+bool xmlApi<bool>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::primitiveParser.parseCharacterRaw(input);
 }
 
-bool xmlApi<bool>::first(const std::list<sax::Token>& input) {
+bool xmlApi<bool>::first(const std::deque<sax::Token>& input) {
 	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::PRIMITIVE_CHARACTER);
 }
 
-void xmlApi<bool>::compose(std::list<sax::Token>& output, bool data) {
+void xmlApi<bool>::compose(std::deque<sax::Token>& output, bool data) {
 	ToXMLComposers::primitiveComposer.compose(output, data);
 }
 
 void ToXMLComposers::Visit(void* data, const Void& voidObject) const {
-	xmlApi<Void>::compose(*((std::list<sax::Token>*) data), voidObject);
+	xmlApi<Void>::compose(*((std::deque<sax::Token>*) data), voidObject);
 }
 
 void ToXMLComposers::Visit(void* data, const container::ObjectsSet& container) const {
-	xmlApi<container::ObjectsSet>::compose(*((std::list<sax::Token>*) data), container);
+	xmlApi<container::ObjectsSet>::compose(*((std::deque<sax::Token>*) data), container);
 }
 
 void ToXMLComposers::Visit(void* data, const container::ObjectsVector& container) const {
-	xmlApi<container::ObjectsVector>::compose(*((std::list<sax::Token>*) data), container);
+	xmlApi<container::ObjectsVector>::compose(*((std::deque<sax::Token>*) data), container);
 }
 
 void ToXMLComposers::Visit(void* data, const container::ObjectsPair& container) const {
-	xmlApi<container::ObjectsPair>::compose(*((std::list<sax::Token>*) data), container);
+	xmlApi<container::ObjectsPair>::compose(*((std::deque<sax::Token>*) data), container);
 }
 
 void ToXMLComposers::Visit(void* data, const container::ObjectsMap& container) const {
-	xmlApi<container::ObjectsMap>::compose(*((std::list<sax::Token>*) data), container);
+	xmlApi<container::ObjectsMap>::compose(*((std::deque<sax::Token>*) data), container);
 }
 
 void ToXMLComposers::Visit(void* data, const exception::AlibException& symbol) const {
-	xmlApi<exception::AlibException>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<exception::AlibException>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::BlankSymbol& symbol) const {
-	xmlApi<alphabet::BlankSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::BlankSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::BottomOfTheStackSymbol& symbol) const {
-	xmlApi<alphabet::BottomOfTheStackSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::BottomOfTheStackSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::EndSymbol& symbol) const {
-	xmlApi<alphabet::EndSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::EndSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::StartSymbol& symbol) const {
-	xmlApi<alphabet::StartSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::StartSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::RankedSymbol& symbol) const {
-	xmlApi<alphabet::RankedSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::RankedSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::BarSymbol& symbol) const {
-	xmlApi<alphabet::BarSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::BarSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::RankedBarSymbol& symbol) const {
-	xmlApi<alphabet::RankedBarSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::RankedBarSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::SubtreeWildcardSymbol& symbol) const {
-	xmlApi<alphabet::SubtreeWildcardSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::SubtreeWildcardSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::LabeledSymbol& symbol) const {
-	xmlApi<alphabet::LabeledSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::LabeledSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::SymbolSetSymbol& symbol) const {
-	xmlApi<alphabet::SymbolSetSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::SymbolSetSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::SymbolPairSymbol& symbol) const {
-	xmlApi<alphabet::SymbolPairSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::SymbolPairSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const alphabet::UniqueSymbol& symbol) const {
-	xmlApi<alphabet::UniqueSymbol>::compose(*((std::list<sax::Token>*) data), symbol);
+	xmlApi<alphabet::UniqueSymbol>::compose(*((std::deque<sax::Token>*) data), symbol);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::EpsilonNFA& automaton) const {
-	xmlApi<automaton::EpsilonNFA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::EpsilonNFA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::MultiInitialStateNFA& automaton) const {
-	xmlApi<automaton::MultiInitialStateNFA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::MultiInitialStateNFA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::NFA& automaton) const {
-	xmlApi<automaton::NFA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::NFA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::DFA& automaton) const {
-	xmlApi<automaton::DFA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::DFA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::ExtendedNFA& automaton) const {
-	xmlApi<automaton::ExtendedNFA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::ExtendedNFA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::CompactNFA& automaton) const {
-	xmlApi<automaton::CompactNFA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::CompactNFA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::DPDA& automaton) const {
-	xmlApi<automaton::DPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::DPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::SinglePopDPDA& automaton) const {
-	xmlApi<automaton::SinglePopDPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::SinglePopDPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::InputDrivenDPDA& automaton) const {
-	xmlApi<automaton::InputDrivenDPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::InputDrivenDPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::InputDrivenNPDA& automaton) const {
-	xmlApi<automaton::InputDrivenNPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::InputDrivenNPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::VisiblyPushdownDPDA& automaton) const {
-	xmlApi<automaton::VisiblyPushdownDPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::VisiblyPushdownDPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::VisiblyPushdownNPDA& automaton) const {
-	xmlApi<automaton::VisiblyPushdownNPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::VisiblyPushdownNPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::RealTimeHeightDeterministicDPDA& automaton) const {
-	xmlApi<automaton::RealTimeHeightDeterministicDPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::RealTimeHeightDeterministicDPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::RealTimeHeightDeterministicNPDA& automaton) const {
-	xmlApi<automaton::RealTimeHeightDeterministicNPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::RealTimeHeightDeterministicNPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::NPDA& automaton) const {
-	xmlApi<automaton::NPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::NPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::SinglePopNPDA& automaton) const {
-	xmlApi<automaton::SinglePopNPDA>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::SinglePopNPDA>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const automaton::OneTapeDTM& automaton) const {
-	xmlApi<automaton::OneTapeDTM>::compose(*((std::list<sax::Token>*) data), automaton);
+	xmlApi<automaton::OneTapeDTM>::compose(*((std::deque<sax::Token>*) data), automaton);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::LeftLG& grammar) const {
-	xmlApi<grammar::LeftLG>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::LeftLG>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::LeftRG& grammar) const {
-	xmlApi<grammar::LeftRG>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::LeftRG>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::RightLG& grammar) const {
-	xmlApi<grammar::RightLG>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::RightLG>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::RightRG& grammar) const {
-	xmlApi<grammar::RightRG>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::RightRG>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::LG& grammar) const {
-	xmlApi<grammar::LG>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::LG>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::CFG& grammar) const {
-	xmlApi<grammar::CFG>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::CFG>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::EpsilonFreeCFG& grammar) const {
-	xmlApi<grammar::EpsilonFreeCFG>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::EpsilonFreeCFG>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::CNF& grammar) const {
-	xmlApi<grammar::CNF>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::CNF>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::GNF& grammar) const {
-	xmlApi<grammar::GNF>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::GNF>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::CSG& grammar) const {
-	xmlApi<grammar::CSG>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::CSG>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::NonContractingGrammar& grammar) const {
-	xmlApi<grammar::NonContractingGrammar>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::NonContractingGrammar>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::ContextPreservingUnrestrictedGrammar& grammar) const {
-	xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const grammar::UnrestrictedGrammar& grammar) const {
-	xmlApi<grammar::UnrestrictedGrammar>::compose(*((std::list<sax::Token>*) data), grammar);
+	xmlApi<grammar::UnrestrictedGrammar>::compose(*((std::deque<sax::Token>*) data), grammar);
 }
 
 void ToXMLComposers::Visit(void* data, const graph::DirectedGraph& graph) const {
-	xmlApi<graph::DirectedGraph>::compose(*((std::list<sax::Token>*) data), graph);
+	xmlApi<graph::DirectedGraph>::compose(*((std::deque<sax::Token>*) data), graph);
 }
 
 void ToXMLComposers::Visit(void* data, const graph::UndirectedGraph& graph) const {
-	xmlApi<graph::UndirectedGraph>::compose(*((std::list<sax::Token>*) data), graph);
+	xmlApi<graph::UndirectedGraph>::compose(*((std::deque<sax::Token>*) data), graph);
 }
 
 void ToXMLComposers::Visit(void* data, const label::PrimitiveLabel& label) const {
-	xmlApi<label::PrimitiveLabel>::compose(*((std::list<sax::Token>*) data), label);
+	xmlApi<label::PrimitiveLabel>::compose(*((std::deque<sax::Token>*) data), label);
 }
 
 void ToXMLComposers::Visit(void* data, const label::HexavigesimalLabel& label) const {
-	xmlApi<label::HexavigesimalLabel>::compose(*((std::list<sax::Token>*) data), label);
+	xmlApi<label::HexavigesimalLabel>::compose(*((std::deque<sax::Token>*) data), label);
 }
 
 void ToXMLComposers::Visit(void* data, const label::ObjectLabel& label) const {
-	xmlApi<label::ObjectLabel>::compose(*((std::list<sax::Token>*) data), label);
+	xmlApi<label::ObjectLabel>::compose(*((std::deque<sax::Token>*) data), label);
 }
 
 void ToXMLComposers::Visit(void* data, const label::LabelSetLabel& label) const {
-	xmlApi<label::LabelSetLabel>::compose(*((std::list<sax::Token>*) data), label);
+	xmlApi<label::LabelSetLabel>::compose(*((std::deque<sax::Token>*) data), label);
 }
 
 void ToXMLComposers::Visit(void* data, const label::LabelPairLabel& label) const {
-	xmlApi<label::LabelPairLabel>::compose(*((std::list<sax::Token>*) data), label);
+	xmlApi<label::LabelPairLabel>::compose(*((std::deque<sax::Token>*) data), label);
 }
 
 void ToXMLComposers::Visit(void* data, const label::UniqueLabel& label) const {
-	xmlApi<label::UniqueLabel>::compose(*((std::list<sax::Token>*) data), label);
+	xmlApi<label::UniqueLabel>::compose(*((std::deque<sax::Token>*) data), label);
 }
 
 void ToXMLComposers::Visit(void* data, const regexp::UnboundedRegExp& regexp) const {
-	xmlApi<regexp::UnboundedRegExp>::compose(*((std::list<sax::Token>*) data), regexp);
+	xmlApi<regexp::UnboundedRegExp>::compose(*((std::deque<sax::Token>*) data), regexp);
 }
 
 void ToXMLComposers::Visit(void* data, const regexp::FormalRegExp& regexp) const {
-	xmlApi<regexp::FormalRegExp>::compose(*((std::list<sax::Token>*) data), regexp);
+	xmlApi<regexp::FormalRegExp>::compose(*((std::deque<sax::Token>*) data), regexp);
 }
 
 void ToXMLComposers::Visit(void* data, const string::Epsilon& string) const {
-	xmlApi<string::Epsilon>::compose(*((std::list<sax::Token>*) data), string);
+	xmlApi<string::Epsilon>::compose(*((std::deque<sax::Token>*) data), string);
 }
 
 void ToXMLComposers::Visit(void* data, const string::CyclicString& string) const {
-	xmlApi<string::CyclicString>::compose(*((std::list<sax::Token>*) data), string);
+	xmlApi<string::CyclicString>::compose(*((std::deque<sax::Token>*) data), string);
 }
 
 void ToXMLComposers::Visit(void* data, const string::LinearString& string) const {
-	xmlApi<string::LinearString>::compose(*((std::list<sax::Token>*) data), string);
+	xmlApi<string::LinearString>::compose(*((std::deque<sax::Token>*) data), string);
 }
 
 void ToXMLComposers::Visit(void* data, const primitive::String& primitive) const {
-	xmlApi<primitive::String>::compose(*((std::list<sax::Token>*) data), primitive);
+	xmlApi<primitive::String>::compose(*((std::deque<sax::Token>*) data), primitive);
 }
 
 void ToXMLComposers::Visit(void* data, const primitive::Integer& primitive) const {
-	xmlApi<primitive::Integer>::compose(*((std::list<sax::Token>*) data), primitive);
+	xmlApi<primitive::Integer>::compose(*((std::deque<sax::Token>*) data), primitive);
 }
 
 void ToXMLComposers::Visit(void* data, const primitive::Character& primitive) const {
-	xmlApi<primitive::Character>::compose(*((std::list<sax::Token>*) data), primitive);
+	xmlApi<primitive::Character>::compose(*((std::deque<sax::Token>*) data), primitive);
 }
 
 void ToXMLComposers::Visit(void* data, const primitive::Unsigned& primitive) const {
-	xmlApi<primitive::Unsigned>::compose(*((std::list<sax::Token>*) data), primitive);
+	xmlApi<primitive::Unsigned>::compose(*((std::deque<sax::Token>*) data), primitive);
 }
 
 void ToXMLComposers::Visit(void* data, const primitive::Bool& primitive) const {
-	xmlApi<primitive::Bool>::compose(*((std::list<sax::Token>*) data), primitive);
+	xmlApi<primitive::Bool>::compose(*((std::deque<sax::Token>*) data), primitive);
 }
 
 } /* namespace alib */
diff --git a/alib2data/src/XmlApi.hpp b/alib2data/src/XmlApi.hpp
index 8a327e44239ba2442810ec6ac60787f6fc6e675b..7afbb7405606fad1e5a0f15beec7145469a491bc 100644
--- a/alib2data/src/XmlApi.hpp
+++ b/alib2data/src/XmlApi.hpp
@@ -108,80 +108,80 @@ public:
 
 template<typename T>
 struct xmlApi {
-	static T parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const T& data);
+	static T parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const T& data);
 };
 
 template<>
 struct xmlApi<Void> {
-	static Void parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const Void& data);
+	static Void parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const Void& data);
 };
 
 template<typename T>
 struct xmlApi<std::set<T>> {
-	static std::set<T> parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const std::set<T>& data);
+	static std::set<T> parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const std::set<T>& data);
 };
 
 template<>
 struct xmlApi<container::ObjectsSet> {
-	static container::ObjectsSet parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const container::ObjectsSet& data);
+	static container::ObjectsSet parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const container::ObjectsSet& data);
 };
 
 template<typename T>
 struct xmlApi<std::vector<T>> {
-	static std::vector<T> parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const std::vector<T>& data);
+	static std::vector<T> parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const std::vector<T>& data);
 };
 
 template<>
 struct xmlApi<container::ObjectsVector> {
-	static container::ObjectsVector parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const container::ObjectsVector& data);
+	static container::ObjectsVector parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const container::ObjectsVector& data);
 };
 
 template<typename T, typename R>
 struct xmlApi<std::pair<T, R>> {
-	static std::pair<T, R> parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const std::pair<T, R>& data);
+	static std::pair<T, R> parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const std::pair<T, R>& data);
 };
 
 template<>
 struct xmlApi<container::ObjectsPair> {
-	static container::ObjectsPair parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const container::ObjectsPair& data);
+	static container::ObjectsPair parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const container::ObjectsPair& data);
 };
 
 template<typename T, typename R>
 struct xmlApi<std::map<T, R>> {
-	static std::map<T, R> parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const std::map<T, R>& data);
+	static std::map<T, R> parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const std::map<T, R>& data);
 };
 
 template<>
 struct xmlApi<container::ObjectsMap> {
-	static container::ObjectsMap parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const container::ObjectsMap& data);
+	static container::ObjectsMap parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const container::ObjectsMap& data);
 };
 
 /* TODO for gcc-4.9 uncomment
 template<typename ... Ts>
 struct xmlApi<std::variant<Ts...>> {
-	static std::variant<Ts...> parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const std::variant<Ts...>& data);
+	static std::variant<Ts...> parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const std::variant<Ts...>& data);
 };
 
 TODO tuple
@@ -191,542 +191,542 @@ TODO tuple
 
 template<>
 struct xmlApi<Object> {
-	static Object parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const Object& data);
+	static Object parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const Object& data);
 };
 
 
 template<>
 struct xmlApi<exception::AlibException> {
-	static exception::AlibException parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const exception::AlibException& data);
+	static exception::AlibException parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const exception::AlibException& data);
 };
 
 
 template<>
 struct xmlApi<alphabet::Symbol> {
-	static alphabet::Symbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::Symbol& data);
+	static alphabet::Symbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::Symbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::LabeledSymbol> {
-	static alphabet::LabeledSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::LabeledSymbol& data);
+	static alphabet::LabeledSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::LabeledSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::BlankSymbol> {
-	static alphabet::BlankSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::BlankSymbol& data);
+	static alphabet::BlankSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::BlankSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::BottomOfTheStackSymbol> {
-	static alphabet::BottomOfTheStackSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::BottomOfTheStackSymbol& data);
+	static alphabet::BottomOfTheStackSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::BottomOfTheStackSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::EndSymbol> {
-	static alphabet::EndSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::EndSymbol& data);
+	static alphabet::EndSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::EndSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::StartSymbol> {
-	static alphabet::StartSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::StartSymbol& data);
+	static alphabet::StartSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::StartSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::RankedSymbol> {
-	static alphabet::RankedSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::RankedSymbol& data);
+	static alphabet::RankedSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::RankedSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::BarSymbol> {
-	static alphabet::BarSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::BarSymbol& data);
+	static alphabet::BarSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::BarSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::RankedBarSymbol> {
-	static alphabet::RankedBarSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::RankedBarSymbol& data);
+	static alphabet::RankedBarSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::RankedBarSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::SubtreeWildcardSymbol> {
-	static alphabet::SubtreeWildcardSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::SubtreeWildcardSymbol& data);
+	static alphabet::SubtreeWildcardSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::SubtreeWildcardSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::SymbolSetSymbol> {
-	static alphabet::SymbolSetSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::SymbolSetSymbol& data);
+	static alphabet::SymbolSetSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::SymbolSetSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::SymbolPairSymbol> {
-	static alphabet::SymbolPairSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::SymbolPairSymbol& data);
+	static alphabet::SymbolPairSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::SymbolPairSymbol& data);
 };
 
 template<>
 struct xmlApi<alphabet::UniqueSymbol> {
-	static alphabet::UniqueSymbol parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const alphabet::UniqueSymbol& data);
+	static alphabet::UniqueSymbol parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const alphabet::UniqueSymbol& data);
 };
 
 
 template<>
 struct xmlApi<automaton::Automaton> {
-	static automaton::Automaton parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::Automaton& data);
+	static automaton::Automaton parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::Automaton& data);
 };
 
 template<>
 struct xmlApi<automaton::EpsilonNFA> {
-	static automaton::EpsilonNFA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::EpsilonNFA& data);
+	static automaton::EpsilonNFA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::EpsilonNFA& data);
 };
 
 template<>
 struct xmlApi<automaton::MultiInitialStateNFA> {
-	static automaton::MultiInitialStateNFA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::MultiInitialStateNFA& data);
+	static automaton::MultiInitialStateNFA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::MultiInitialStateNFA& data);
 };
 
 template<>
 struct xmlApi<automaton::NFA> {
-	static automaton::NFA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::NFA& data);
+	static automaton::NFA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::NFA& data);
 };
 
 template<>
 struct xmlApi<automaton::DFA> {
-	static automaton::DFA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::DFA& data);
+	static automaton::DFA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::DFA& data);
 };
 
 template<>
 struct xmlApi<automaton::ExtendedNFA> {
-	static automaton::ExtendedNFA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::ExtendedNFA& data);
+	static automaton::ExtendedNFA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::ExtendedNFA& data);
 };
 
 template<>
 struct xmlApi<automaton::CompactNFA> {
-	static automaton::CompactNFA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::CompactNFA& data);
+	static automaton::CompactNFA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::CompactNFA& data);
 };
 
 template<>
 struct xmlApi<automaton::DPDA> {
-	static automaton::DPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::DPDA& data);
+	static automaton::DPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::DPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::SinglePopDPDA> {
-	static automaton::SinglePopDPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::SinglePopDPDA& data);
+	static automaton::SinglePopDPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::SinglePopDPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::InputDrivenDPDA> {
-	static automaton::InputDrivenDPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::InputDrivenDPDA& data);
+	static automaton::InputDrivenDPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::InputDrivenDPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::InputDrivenNPDA> {
-	static automaton::InputDrivenNPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::InputDrivenNPDA& data);
+	static automaton::InputDrivenNPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::InputDrivenNPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::VisiblyPushdownDPDA> {
-	static automaton::VisiblyPushdownDPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::VisiblyPushdownDPDA& data);
+	static automaton::VisiblyPushdownDPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::VisiblyPushdownDPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::VisiblyPushdownNPDA> {
-	static automaton::VisiblyPushdownNPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::VisiblyPushdownNPDA& data);
+	static automaton::VisiblyPushdownNPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::VisiblyPushdownNPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::RealTimeHeightDeterministicDPDA> {
-	static automaton::RealTimeHeightDeterministicDPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::RealTimeHeightDeterministicDPDA& data);
+	static automaton::RealTimeHeightDeterministicDPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::RealTimeHeightDeterministicDPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::RealTimeHeightDeterministicNPDA> {
-	static automaton::RealTimeHeightDeterministicNPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::RealTimeHeightDeterministicNPDA& data);
+	static automaton::RealTimeHeightDeterministicNPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::RealTimeHeightDeterministicNPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::NPDA> {
-	static automaton::NPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::NPDA& data);
+	static automaton::NPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::NPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::SinglePopNPDA> {
-	static automaton::SinglePopNPDA parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::SinglePopNPDA& data);
+	static automaton::SinglePopNPDA parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::SinglePopNPDA& data);
 };
 
 template<>
 struct xmlApi<automaton::OneTapeDTM> {
-	static automaton::OneTapeDTM parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::OneTapeDTM& data);
+	static automaton::OneTapeDTM parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::OneTapeDTM& data);
 };
 
 template<>
 struct xmlApi<automaton::State> {
-	static automaton::State parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const automaton::State& data);
+	static automaton::State parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const automaton::State& data);
 };
 
 template<>
 struct xmlApi<grammar::Grammar> {
-	static grammar::Grammar parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::Grammar& data);
+	static grammar::Grammar parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::Grammar& data);
 };
 
 template<>
 struct xmlApi<grammar::LeftLG> {
-	static grammar::LeftLG parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::LeftLG& data);
+	static grammar::LeftLG parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::LeftLG& data);
 };
 
 template<>
 struct xmlApi<grammar::LeftRG> {
-	static grammar::LeftRG parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::LeftRG& data);
+	static grammar::LeftRG parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::LeftRG& data);
 };
 
 template<>
 struct xmlApi<grammar::RightLG> {
-	static grammar::RightLG parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::RightLG& data);
+	static grammar::RightLG parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::RightLG& data);
 };
 
 template<>
 struct xmlApi<grammar::RightRG> {
-	static grammar::RightRG parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::RightRG& data);
+	static grammar::RightRG parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::RightRG& data);
 };
 
 template<>
 struct xmlApi<grammar::LG> {
-	static grammar::LG parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::LG& data);
+	static grammar::LG parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::LG& data);
 };
 
 template<>
 struct xmlApi<grammar::CFG> {
-	static grammar::CFG parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::CFG& data);
+	static grammar::CFG parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::CFG& data);
 };
 
 template<>
 struct xmlApi<grammar::EpsilonFreeCFG> {
-	static grammar::EpsilonFreeCFG parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::EpsilonFreeCFG& data);
+	static grammar::EpsilonFreeCFG parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::EpsilonFreeCFG& data);
 };
 
 template<>
 struct xmlApi<grammar::CNF> {
-	static grammar::CNF parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::CNF& data);
+	static grammar::CNF parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::CNF& data);
 };
 
 template<>
 struct xmlApi<grammar::GNF> {
-	static grammar::GNF parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::GNF& data);
+	static grammar::GNF parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::GNF& data);
 };
 
 template<>
 struct xmlApi<grammar::CSG> {
-	static grammar::CSG parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::CSG& data);
+	static grammar::CSG parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::CSG& data);
 };
 
 template<>
 struct xmlApi<grammar::NonContractingGrammar> {
-	static grammar::NonContractingGrammar parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::NonContractingGrammar& data);
+	static grammar::NonContractingGrammar parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::NonContractingGrammar& data);
 };
 
 template<>
 struct xmlApi<grammar::ContextPreservingUnrestrictedGrammar> {
-	static grammar::ContextPreservingUnrestrictedGrammar parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::ContextPreservingUnrestrictedGrammar& data);
+	static grammar::ContextPreservingUnrestrictedGrammar parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::ContextPreservingUnrestrictedGrammar& data);
 };
 
 template<>
 struct xmlApi<grammar::UnrestrictedGrammar> {
-	static grammar::UnrestrictedGrammar parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const grammar::UnrestrictedGrammar& data);
+	static grammar::UnrestrictedGrammar parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const grammar::UnrestrictedGrammar& data);
 };
 
 
 template<>
 struct xmlApi<graph::Graph> {
-	static graph::Graph parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const graph::Graph& data);
+	static graph::Graph parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const graph::Graph& data);
 };
 
 template<>
 struct xmlApi<graph::DirectedGraph> {
-	static graph::DirectedGraph parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const graph::DirectedGraph& data);
+	static graph::DirectedGraph parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const graph::DirectedGraph& data);
 };
 
 template<>
 struct xmlApi<graph::UndirectedGraph> {
-	static graph::UndirectedGraph parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const graph::UndirectedGraph& data);
+	static graph::UndirectedGraph parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const graph::UndirectedGraph& data);
 };
 
 
 template<>
 struct xmlApi<label::Label> {
-	static label::Label parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const label::Label& data);
+	static label::Label parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const label::Label& data);
 };
 
 template<>
 struct xmlApi<label::PrimitiveLabel> {
-	static label::PrimitiveLabel parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const label::PrimitiveLabel& data);
+	static label::PrimitiveLabel parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const label::PrimitiveLabel& data);
 };
 
 template<>
 struct xmlApi<label::HexavigesimalLabel> {
-	static label::HexavigesimalLabel parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const label::HexavigesimalLabel& data);
+	static label::HexavigesimalLabel parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const label::HexavigesimalLabel& data);
 };
 
 template<>
 struct xmlApi<label::ObjectLabel> {
-	static label::ObjectLabel parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const label::ObjectLabel& data);
+	static label::ObjectLabel parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const label::ObjectLabel& data);
 };
 
 template<>
 struct xmlApi<label::LabelSetLabel> {
-	static label::LabelSetLabel parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const label::LabelSetLabel& data);
+	static label::LabelSetLabel parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const label::LabelSetLabel& data);
 };
 
 template<>
 struct xmlApi<label::LabelPairLabel> {
-	static label::LabelPairLabel parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const label::LabelPairLabel& data);
+	static label::LabelPairLabel parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const label::LabelPairLabel& data);
 };
 
 template<>
 struct xmlApi<label::UniqueLabel> {
-	static label::UniqueLabel parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const label::UniqueLabel& data);
+	static label::UniqueLabel parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const label::UniqueLabel& data);
 };
 
 
 template<>
 struct xmlApi<regexp::RegExp> {
-	static regexp::RegExp parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const regexp::RegExp& data);
+	static regexp::RegExp parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const regexp::RegExp& data);
 };
 
 template<>
 struct xmlApi<regexp::UnboundedRegExp> {
-	static regexp::UnboundedRegExp parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const regexp::UnboundedRegExp& data);
+	static regexp::UnboundedRegExp parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const regexp::UnboundedRegExp& data);
 };
 
 template<>
 struct xmlApi<regexp::FormalRegExp> {
-	static regexp::FormalRegExp parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const regexp::FormalRegExp& data);
+	static regexp::FormalRegExp parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const regexp::FormalRegExp& data);
 };
 
 
 template<>
 struct xmlApi<string::String> {
-	static string::String parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const string::String& data);
+	static string::String parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const string::String& data);
 };
 
 template<>
 struct xmlApi<string::LinearString> {
-	static string::LinearString parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const string::LinearString& data);
+	static string::LinearString parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const string::LinearString& data);
 };
 
 template<>
 struct xmlApi<string::CyclicString> {
-	static string::CyclicString parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const string::CyclicString& data);
+	static string::CyclicString parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const string::CyclicString& data);
 };
 
 template<>
 struct xmlApi<string::Epsilon> {
-	static string::Epsilon parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const string::Epsilon& data);
+	static string::Epsilon parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const string::Epsilon& data);
 };
 
 
 template<>
 struct xmlApi<primitive::Primitive> {
-	static primitive::Primitive parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const primitive::Primitive& data);
+	static primitive::Primitive parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Primitive& data);
 };
 
 template<>
 struct xmlApi<primitive::String> {
-	static primitive::String parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const primitive::String& data);
+	static primitive::String parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::String& data);
 };
 
 template<>
 struct xmlApi<std::string> {
-	static std::string parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const std::string& data);
+	static std::string parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const std::string& data);
 };
 
 template<>
 struct xmlApi<primitive::Integer> {
-	static primitive::Integer parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const primitive::Integer& data);
+	static primitive::Integer parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Integer& data);
 };
 
 template<>
 struct xmlApi<int> {
-	static int parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, int data);
+	static int parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, int data);
 };
 
 template<>
 struct xmlApi<primitive::Character> {
-	static primitive::Character parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const primitive::Character& data);
+	static primitive::Character parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Character& data);
 };
 
 template<>
 struct xmlApi<char> {
-	static char parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, char data);
+	static char parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, char data);
 };
 
 template<>
 struct xmlApi<primitive::Unsigned> {
-	static primitive::Unsigned parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const primitive::Unsigned& data);
+	static primitive::Unsigned parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Unsigned& data);
 };
 
 template<>
 struct xmlApi<unsigned> {
-	static unsigned parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, unsigned data);
+	static unsigned parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, unsigned data);
 };
 
 template<>
 struct xmlApi<primitive::Bool> {
-	static primitive::Bool parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const primitive::Bool& data);
+	static primitive::Bool parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const primitive::Bool& data);
 };
 
 template<>
 struct xmlApi<bool> {
-	static bool parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, bool data);
+	static bool parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, bool data);
 };
 
 } /* namespace alib */
@@ -739,9 +739,9 @@ namespace alib {
 
 template<>
 struct xmlApi<container::Container> {
-	static container::Container parse(std::list<sax::Token>& input);
-	static bool first(const std::list<sax::Token>& input);
-	static void compose(std::list<sax::Token>& output, const container::Container& data);
+	static container::Container parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const container::Container& data);
 };
 
 /**
@@ -859,78 +859,78 @@ public:
 };
 
 template<typename T>
-std::set<T> xmlApi<std::set<T>>::parse(std::list<sax::Token>& input) {
+std::set<T> xmlApi<std::set<T>>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseSet<T>(input);
 }
 
 template<typename T>
-bool xmlApi<std::set<T>>::first(const std::list<sax::Token>& input) {
+bool xmlApi<std::set<T>>::first(const std::deque<sax::Token>& input) {
 	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_SET;
 }
 
 template<typename T>
-void xmlApi<std::set<T>>::compose(std::list<sax::Token>& output, const std::set<T>& input) {
+void xmlApi<std::set<T>>::compose(std::deque<sax::Token>& output, const std::set<T>& input) {
 	return ToXMLComposers::containerComposer.compose<T>(output, input);
 }
 
 template<typename T>
-std::vector<T> xmlApi<std::vector<T>>::parse(std::list<sax::Token>& input) {
+std::vector<T> xmlApi<std::vector<T>>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseVector<T>(input);
 }
 
 template<typename T>
-bool xmlApi<std::vector<T>>::first(const std::list<sax::Token>& input) {
+bool xmlApi<std::vector<T>>::first(const std::deque<sax::Token>& input) {
 	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_VECTOR;
 }
 
 template<typename T>
-void xmlApi<std::vector<T>>::compose(std::list<sax::Token>& output, const std::vector<T>& input) {
+void xmlApi<std::vector<T>>::compose(std::deque<sax::Token>& output, const std::vector<T>& input) {
 	return ToXMLComposers::containerComposer.compose<T>(output, input);
 }
 
 template<typename T, typename R>
-std::pair<T, R> xmlApi<std::pair<T, R>>::parse(std::list<sax::Token>& input) {
+std::pair<T, R> xmlApi<std::pair<T, R>>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parsePair<T, R>(input);
 }
 
 template<typename T, typename R>
-bool xmlApi<std::pair<T, R>>::first(const std::list<sax::Token>& input) {
+bool xmlApi<std::pair<T, R>>::first(const std::deque<sax::Token>& input) {
 	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_PAIR;
 }
 
 template<typename T, typename R>
-void xmlApi<std::pair<T, R>>::compose(std::list<sax::Token>& output, const std::pair<T, R>& input) {
+void xmlApi<std::pair<T, R>>::compose(std::deque<sax::Token>& output, const std::pair<T, R>& input) {
 	return ToXMLComposers::containerComposer.compose<T, R>(output, input);
 }
 
 template<typename T, typename R>
-std::map<T, R> xmlApi<std::map<T, R>>::parse(std::list<sax::Token>& input) {
+std::map<T, R> xmlApi<std::map<T, R>>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseMap<T, R>(input);
 }
 
 template<typename T, typename R>
-bool xmlApi<std::map<T, R>>::first(const std::list<sax::Token>& input) {
+bool xmlApi<std::map<T, R>>::first(const std::deque<sax::Token>& input) {
 	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_MAP;
 }
 
 template<typename T, typename R>
-void xmlApi<std::map<T, R>>::compose(std::list<sax::Token>& output, const std::map<T, R>& input) {
+void xmlApi<std::map<T, R>>::compose(std::deque<sax::Token>& output, const std::map<T, R>& input) {
 	return ToXMLComposers::containerComposer.compose<T, R>(output, input);
 }
 
 /* TODO For gcc-4.9 uncomment
 template<typename ... Ts>
-std::variant<Ts...> xmlApi<std::variant<Ts...>>::parse(std::list<sax::Token>& input) {
+std::variant<Ts...> xmlApi<std::variant<Ts...>>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::containerParser.parseVariant<Ts...>(input);
 }
 
 template<typename ... Ts>
-bool xmlApi<std::variant<Ts...>>::first(const std::list<sax::Token>& input) {
+bool xmlApi<std::variant<Ts...>>::first(const std::deque<sax::Token>& input) {
 	return input.front().getType() == sax::Token::TokenType::START_ELEMENT && input.front().getData() == Names::CONTAINER_OBJECTS_VARIANT;
 }
 
 template<typename ... Ts>
-std::list<sax::Token> xmlApi<std::variant<Ts...>>::compose(std::list<sax::Token>& output, const std::variant<Ts...>& input) {
+std::deque<sax::Token> xmlApi<std::variant<Ts...>>::compose(std::deque<sax::Token>& output, const std::variant<Ts...>& input) {
 	return ToXMLComposers::containerComposer.compose<Ts...>(input);
 }
 */
diff --git a/alib2data/src/alphabet/SymbolFromXMLParser.cpp b/alib2data/src/alphabet/SymbolFromXMLParser.cpp
index f5a68a763cba20ea9494d1ab82082c7770e06271..3089546ffe69016d86b13e8b6a488388bff4ab1c 100644
--- a/alib2data/src/alphabet/SymbolFromXMLParser.cpp
+++ b/alib2data/src/alphabet/SymbolFromXMLParser.cpp
@@ -14,11 +14,11 @@
 
 namespace alphabet {
 
-Symbol SymbolFromXMLParser::parseSymbol(std::list<sax::Token>& input) const {
+Symbol SymbolFromXMLParser::parseSymbol(std::deque<sax::Token>& input) const {
 	return parseSymbol(input, std::set<FEATURES>({FEATURES::LABELED, FEATURES::BLANK, FEATURES::BOTTOM, FEATURES::END, FEATURES::RANKED, FEATURES::BAR, FEATURES::RANKED_BAR, FEATURES::SUBTREE_WILDCARD, FEATURES::SYMBOL_PAIR_SYMBOL, FEATURES::SYMBOL_SET_SYMBOL, FEATURES::UNIQUE_SYMBOL, FEATURES::START}));
 }
 
-Symbol SymbolFromXMLParser::parseSymbol(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+Symbol SymbolFromXMLParser::parseSymbol(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<LabeledSymbol>::first(input)) {
 		if(!features.count(FEATURES::LABELED)) throw exception::AlibException();
 		return Symbol(parseLabeledSymbol(input));
@@ -60,7 +60,7 @@ Symbol SymbolFromXMLParser::parseSymbol(std::list<sax::Token>& input, const std:
 	}
 }
 
-bool SymbolFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool SymbolFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<LabeledSymbol>::first(input) || alib::xmlApi<BlankSymbol>::first(input) || alib::xmlApi<BottomOfTheStackSymbol>::first(input) || alib::xmlApi<EndSymbol>::first(input) || alib::xmlApi<StartSymbol>::first(input) || alib::xmlApi<RankedSymbol>::first(input) || alib::xmlApi<BarSymbol>::first(input) || alib::xmlApi<RankedBarSymbol>::first(input) || alib::xmlApi<SubtreeWildcardSymbol>::first(input) || alib::xmlApi<SymbolPairSymbol>::first(input) || alib::xmlApi<SymbolSetSymbol>::first(input)) {
 		return true;
 	} else {
@@ -68,38 +68,38 @@ bool SymbolFromXMLParser::first(const std::list<sax::Token>& input) const {
 	}
 }
 
-LabeledSymbol SymbolFromXMLParser::parseLabeledSymbol(std::list<sax::Token>& input) const {
+LabeledSymbol SymbolFromXMLParser::parseLabeledSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL);
 	label::Label data = alib::xmlApi<label::Label>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_LABELED_SYMBOL);
 	return LabeledSymbol(std::move(data));
 }
 
-BlankSymbol SymbolFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input) const {
+BlankSymbol SymbolFromXMLParser::parseBlankSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_BLANK_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_BLANK_SYMBOL);
 	return BlankSymbol();
 }
 
-BottomOfTheStackSymbol SymbolFromXMLParser::parseBottomOfTheStackSymbol(std::list<sax::Token>& input) const {
+BottomOfTheStackSymbol SymbolFromXMLParser::parseBottomOfTheStackSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL);
 	return BottomOfTheStackSymbol();
 }
 
-EndSymbol SymbolFromXMLParser::parseEndSymbol(std::list<sax::Token>& input) const {
+EndSymbol SymbolFromXMLParser::parseEndSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_END_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_END_SYMBOL);
 	return EndSymbol();
 }
 
-StartSymbol SymbolFromXMLParser::parseStartSymbol(std::list<sax::Token>& input) const {
+StartSymbol SymbolFromXMLParser::parseStartSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_END_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_END_SYMBOL);
 	return StartSymbol();
 }
 
-RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::list<sax::Token>& input) const {
+RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_RANKED_SYMBOL);
 	label::Label data = alib::xmlApi<label::Label>::parse(input);
 	primitive::Integer rank = alib::xmlApi<primitive::Integer>::parse(input);
@@ -107,26 +107,26 @@ RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::list<sax::Token>& input
 	return RankedSymbol(std::move(data), std::move(rank));
 }
 
-BarSymbol SymbolFromXMLParser::parseBarSymbol(std::list<sax::Token>& input) const {
+BarSymbol SymbolFromXMLParser::parseBarSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_START_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_START_SYMBOL);
 	return BarSymbol();
 }
 
-RankedBarSymbol SymbolFromXMLParser::parseRankedBarSymbol(std::list<sax::Token>& input) const {
+RankedBarSymbol SymbolFromXMLParser::parseRankedBarSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_RANKED_BAR_SYMBOL);
 	primitive::Integer rank = alib::xmlApi<primitive::Integer>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_RANKED_BAR_SYMBOL);
 	return RankedBarSymbol(std::move(rank));
 }
 
-SubtreeWildcardSymbol SymbolFromXMLParser::parseSubtreeWildcardSymbol(std::list<sax::Token>& input) const {
+SubtreeWildcardSymbol SymbolFromXMLParser::parseSubtreeWildcardSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL);
 	return SubtreeWildcardSymbol();
 }
 
-SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::list<sax::Token>& input) const {
+SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_SYMBOL_SET_SYMBOL);
 	std::set<Symbol> labels;
 	while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -136,7 +136,7 @@ SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::list<sax::Token>&
 	return SymbolSetSymbol(std::move(labels));
 }
 
-SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::list<sax::Token>& input) const {
+SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL);
 
 	Symbol firstSymbol = parseSymbol(input);
@@ -146,7 +146,7 @@ SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::list<sax::Token
 	return SymbolPairSymbol(std::make_pair(std::move(firstSymbol), std::move(secondSymbol)));
 }
 
-UniqueSymbol SymbolFromXMLParser::parseUniqueSymbol(std::list<sax::Token>& input) const {
+UniqueSymbol SymbolFromXMLParser::parseUniqueSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_UNIQUE_SYMBOL);
 
 	Symbol firstSymbol = parseSymbol(input);
diff --git a/alib2data/src/alphabet/SymbolFromXMLParser.h b/alib2data/src/alphabet/SymbolFromXMLParser.h
index 5553de2b2b423eabc7da991770a9a894fb30d0ef..71c2811736409e1bdd53b8a18c787774ae30abed 100644
--- a/alib2data/src/alphabet/SymbolFromXMLParser.h
+++ b/alib2data/src/alphabet/SymbolFromXMLParser.h
@@ -42,25 +42,25 @@ namespace alphabet {
  * Parser used to get String from XML parsed into list of tokens.
  */
 class SymbolFromXMLParser : public sax::FromXMLParserHelper {
-	Symbol parseSymbol(std::list<sax::Token>& input) const;
-	Symbol parseSymbol(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+	Symbol parseSymbol(std::deque<sax::Token>& input) const;
+	Symbol parseSymbol(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
 
-	LabeledSymbol parseLabeledSymbol(std::list<sax::Token>& input) const;
-	BlankSymbol parseBlankSymbol(std::list<sax::Token>& input) const;
-	BottomOfTheStackSymbol parseBottomOfTheStackSymbol(std::list<sax::Token>& input) const;
-	EndSymbol parseEndSymbol(std::list<sax::Token>& input) const;
-	StartSymbol parseStartSymbol(std::list<sax::Token>& input) const;
-	RankedSymbol parseRankedSymbol(std::list<sax::Token>& input) const;
-	BarSymbol parseBarSymbol(std::list<sax::Token>& input) const;
-	RankedBarSymbol parseRankedBarSymbol(std::list<sax::Token>& input) const;
-	SubtreeWildcardSymbol parseSubtreeWildcardSymbol(std::list<sax::Token>& input) const;
-	SymbolPairSymbol parseSymbolPairSymbol(std::list<sax::Token>& input) const;
-	SymbolSetSymbol parseSymbolSetSymbol(std::list<sax::Token>& input) const;
-	UniqueSymbol parseUniqueSymbol(std::list<sax::Token>& input) const;
+	LabeledSymbol parseLabeledSymbol(std::deque<sax::Token>& input) const;
+	BlankSymbol parseBlankSymbol(std::deque<sax::Token>& input) const;
+	BottomOfTheStackSymbol parseBottomOfTheStackSymbol(std::deque<sax::Token>& input) const;
+	EndSymbol parseEndSymbol(std::deque<sax::Token>& input) const;
+	StartSymbol parseStartSymbol(std::deque<sax::Token>& input) const;
+	RankedSymbol parseRankedSymbol(std::deque<sax::Token>& input) const;
+	BarSymbol parseBarSymbol(std::deque<sax::Token>& input) const;
+	RankedBarSymbol parseRankedBarSymbol(std::deque<sax::Token>& input) const;
+	SubtreeWildcardSymbol parseSubtreeWildcardSymbol(std::deque<sax::Token>& input) const;
+	SymbolPairSymbol parseSymbolPairSymbol(std::deque<sax::Token>& input) const;
+	SymbolSetSymbol parseSymbolSetSymbol(std::deque<sax::Token>& input) const;
+	UniqueSymbol parseUniqueSymbol(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace alphabet */
diff --git a/alib2data/src/alphabet/SymbolToXMLComposer.cpp b/alib2data/src/alphabet/SymbolToXMLComposer.cpp
index e3b6755dcfffed46834eaafff5625b4f1e7f481a..fd984eaf9d39cf7b796456db3ed1bba1ff752bfe 100644
--- a/alib2data/src/alphabet/SymbolToXMLComposer.cpp
+++ b/alib2data/src/alphabet/SymbolToXMLComposer.cpp
@@ -11,64 +11,64 @@
 
 namespace alphabet {
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const Symbol& symbol) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const Symbol& symbol) const {
 	symbol.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const SymbolBase& symbol) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const SymbolBase& symbol) const {
 	symbol.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const LabeledSymbol& symbol) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const LabeledSymbol& symbol) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_LABELED_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<label::Label>::compose(out, symbol.getLabel());
 	out.push_back(sax::Token(alib::Names::ALPHABET_LABELED_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const BlankSymbol&) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const BlankSymbol&) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_BLANK_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(alib::Names::ALPHABET_BLANK_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const BottomOfTheStackSymbol&) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const BottomOfTheStackSymbol&) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(alib::Names::ALPHABET_BOTTOM_OF_THE_STACK_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const EndSymbol&) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const EndSymbol&) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_END_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(alib::Names::ALPHABET_END_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const StartSymbol&) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const StartSymbol&) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_START_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(alib::Names::ALPHABET_START_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const RankedSymbol& symbol) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const RankedSymbol& symbol) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<label::Label>::compose(out, symbol.getLabel());
 	alib::xmlApi<primitive::Integer>::compose(out, symbol.getRank());
 	out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const BarSymbol&) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const BarSymbol&) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_BAR_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(alib::Names::ALPHABET_BAR_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const RankedBarSymbol& symbol) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const RankedBarSymbol& symbol) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_BAR_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<primitive::Integer>::compose(out, symbol.getRank());
 	out.push_back(sax::Token(alib::Names::ALPHABET_RANKED_BAR_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const SubtreeWildcardSymbol&) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const SubtreeWildcardSymbol&) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(alib::Names::ALPHABET_SUBTREE_WILDCARD_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const SymbolSetSymbol& symbol) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const SymbolSetSymbol& symbol) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_SYMBOL_SET_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	for(const Symbol& innerSymbol : symbol.getData()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, innerSymbol);
@@ -76,14 +76,14 @@ void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const SymbolSetSym
 	out.push_back(sax::Token(alib::Names::ALPHABET_SYMBOL_SET_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const SymbolPairSymbol& symbol) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const SymbolPairSymbol& symbol) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol.getData().first);
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol.getData().second);
 	out.push_back(sax::Token(alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void SymbolToXMLComposer::compose(std::list<sax::Token>& out, const UniqueSymbol& symbol) const {
+void SymbolToXMLComposer::compose(std::deque<sax::Token>& out, const UniqueSymbol& symbol) const {
 	out.push_back(sax::Token(alib::Names::ALPHABET_UNIQUE_SYMBOL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol.getSymbol());
 	alib::xmlApi<primitive::Integer>::compose(out, symbol.getId());
diff --git a/alib2data/src/alphabet/SymbolToXMLComposer.h b/alib2data/src/alphabet/SymbolToXMLComposer.h
index a7030b17c5339fed5eef8cb01d4fce4015577d76..6b9540369bf2834668e446612fe0956b88e79347 100644
--- a/alib2data/src/alphabet/SymbolToXMLComposer.h
+++ b/alib2data/src/alphabet/SymbolToXMLComposer.h
@@ -8,7 +8,7 @@
 #ifndef SYMBOL_TO_XML_COMPOSER_H_
 #define SYMBOL_TO_XML_COMPOSER_H_
 
-#include <list>
+#include <deque>
 #include "Symbol.h"
 #include "../sax/Token.h"
 #include "../label/Label.h"
@@ -31,27 +31,27 @@ class SymbolToXMLComposer {
 	 * @param automaton automaton to print
 	 * @return list of xml tokens representing the automaton
 	 */
-	void compose(std::list<sax::Token>& output, const SymbolBase& symbol) const;
+	void compose(std::deque<sax::Token>& output, const SymbolBase& symbol) const;
 
 	/**
 	 * Prints XML representation of String to the output stream.
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& output, const Symbol& symbol) const;
-
-	void compose(std::list<sax::Token>& output, const LabeledSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const BlankSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const BottomOfTheStackSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const EndSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const StartSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const RankedSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const BarSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const RankedBarSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const SubtreeWildcardSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const SymbolPairSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const SymbolSetSymbol& symbol) const;
-	void compose(std::list<sax::Token>& output, const UniqueSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const Symbol& symbol) const;
+
+	void compose(std::deque<sax::Token>& output, const LabeledSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const BlankSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const BottomOfTheStackSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const EndSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const StartSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const RankedSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const BarSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const RankedBarSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const SubtreeWildcardSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const SymbolPairSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const SymbolSetSymbol& symbol) const;
+	void compose(std::deque<sax::Token>& output, const UniqueSymbol& symbol) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/automaton/AutomatonFromXMLParser.cpp b/alib2data/src/automaton/AutomatonFromXMLParser.cpp
index 6dd8b9a98418c571bae997f1b1a4db54090bbc41..d57e4e0bdc0d68c6afa164ac010eadc45384c5d6 100644
--- a/alib2data/src/automaton/AutomatonFromXMLParser.cpp
+++ b/alib2data/src/automaton/AutomatonFromXMLParser.cpp
@@ -15,11 +15,11 @@
 
 namespace automaton {
 
-Automaton AutomatonFromXMLParser::parseAutomaton(std::list<sax::Token> &input) const {
+Automaton AutomatonFromXMLParser::parseAutomaton(std::deque<sax::Token> &input) const {
 	return parseAutomaton(input, std::set<FEATURES>({FEATURES::EPSILON_NFA, FEATURES::MULTI_INITIAL_STATE_NFA, FEATURES::NFA, FEATURES::DFA, FEATURES::COMPACT_NFA, FEATURES::EXTENDED_NFA, FEATURES::DPDA, FEATURES::SINGLE_POP_DPDA, FEATURES::INPUT_DRIVEN_DPDA, FEATURES::INPUT_DRIVEN_NPDA, FEATURES::VISIBLY_PUSHDOWN_DPDA, FEATURES::VISIBLY_PUSHDOWN_NPDA, FEATURES::REAL_TIME_HEIGHT_DETERMINISTIC_DPDA,  FEATURES::REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, FEATURES::NPDA, FEATURES::SINGLE_POP_NPDA, FEATURES::ONE_TAPE_DTM}));
 }
 
-Automaton AutomatonFromXMLParser::parseAutomaton(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+Automaton AutomatonFromXMLParser::parseAutomaton(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<EpsilonNFA>::first(input)) {
 		if(!features.count(FEATURES::EPSILON_NFA)) throw exception::AlibException();
 		return Automaton(parseEpsilonNFA(input));
@@ -75,7 +75,7 @@ Automaton AutomatonFromXMLParser::parseAutomaton(std::list<sax::Token>& input, c
 		throw sax::ParserException(sax::Token("Automaton / EpsilonNFA / NFA / DFA / CompactNFA / ExtendedNFA / DPDA / SinglePopDPDA / InputDrivenDPDA / InputDrivenNPDA / VisiblyPushdownDPDA / VisiblyPushdownNPDA / RealTimeHeightDeterministicDPDA / RealTimeHeightDeterministicNPDA / NPDA / SinglePopNPDA / OneTapeDTM", sax::Token::TokenType::START_ELEMENT), input.front());
 }
 
-bool AutomatonFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool AutomatonFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<EpsilonNFA>::first(input) || alib::xmlApi<NFA>::first(input) || alib::xmlApi<DFA>::first(input) || alib::xmlApi<CompactNFA>::first(input) || alib::xmlApi<ExtendedNFA>::first(input) || alib::xmlApi<DPDA>::first(input) || alib::xmlApi<SinglePopDPDA>::first(input) || alib::xmlApi<InputDrivenDPDA>::first(input) || alib::xmlApi<InputDrivenNPDA>::first(input) || alib::xmlApi<VisiblyPushdownDPDA>::first(input)  || alib::xmlApi<VisiblyPushdownNPDA>::first(input) || alib::xmlApi<RealTimeHeightDeterministicDPDA>::first(input) || alib::xmlApi<RealTimeHeightDeterministicNPDA>::first(input) || alib::xmlApi<NPDA>::first(input) || alib::xmlApi<SinglePopNPDA>::first(input) || alib::xmlApi<OneTapeDTM>::first(input)) {
 		return true;
 	} else {
@@ -84,7 +84,7 @@ bool AutomatonFromXMLParser::first(const std::list<sax::Token>& input) const {
 }
 
 template<class T>
-void AutomatonFromXMLParser::parseTransitions(std::list<sax::Token> &input, T& automaton) const {
+void AutomatonFromXMLParser::parseTransitions(std::deque<sax::Token> &input, T& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transitions");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		parseTransition(input, automaton);
@@ -92,7 +92,7 @@ void AutomatonFromXMLParser::parseTransitions(std::list<sax::Token> &input, T& a
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transitions");
 }
 
-DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const {
+DFA AutomatonFromXMLParser::parseDFA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_DFA);
 
 	std::set<State> states = parseStates(input);
@@ -111,7 +111,7 @@ DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const {
 	return automaton;
 }
 
-NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const {
+NFA AutomatonFromXMLParser::parseNFA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -130,7 +130,7 @@ NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const {
 	return automaton;
 }
 
-MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::list<sax::Token>& input) const {
+MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -150,7 +150,7 @@ MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::list
 	return automaton;
 }
 
-EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input) const {
+EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_EPSILON_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -169,7 +169,7 @@ EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input)
 	return automaton;
 }
 
-CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::list<sax::Token>& input) const {
+CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_COMPACT_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -188,7 +188,7 @@ CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::list<sax::Token>& input)
 	return automaton;
 }
 
-ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::list<sax::Token>& input) const {
+ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_EXTENDED_NFA);
 
 	std::set<State> states = parseStates(input);
@@ -207,7 +207,7 @@ ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::list<sax::Token>& inpu
 	return automaton;
 }
 
-DPDA AutomatonFromXMLParser::parseDPDA(std::list<sax::Token>& input) const {
+DPDA AutomatonFromXMLParser::parseDPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -230,7 +230,7 @@ DPDA AutomatonFromXMLParser::parseDPDA(std::list<sax::Token>& input) const {
 	return automaton;
 }
 
-SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::list<sax::Token>& input) const {
+SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_SINGLE_POP_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -253,7 +253,7 @@ SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::list<sax::Token>&
 	return automaton;
 }
 
-InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::list<sax::Token>& input) const {
+InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_INPUT_DRIVEN_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -277,7 +277,7 @@ InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::list<sax::Toke
 	return automaton;
 }
 
-InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::list<sax::Token>& input) const {
+InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -301,7 +301,7 @@ InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::list<sax::Toke
 	return automaton;
 }
 
-VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::list<sax::Token>& input) const {
+VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -328,7 +328,7 @@ VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::list<s
 	return automaton;
 }
 
-VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::list<sax::Token>& input) const {
+VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -356,7 +356,7 @@ VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::list<s
 	return automaton;
 }
 
-RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicDPDA(std::list<sax::Token>& input) const {
+RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicDPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA);
 
 	std::set<State> states = parseStates(input);
@@ -379,7 +379,7 @@ RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
 	return automaton;
 }
 
-RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicNPDA(std::list<sax::Token>& input) const {
+RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeterministicNPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -403,7 +403,7 @@ RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
 	return automaton;
 }
 
-NPDA AutomatonFromXMLParser::parseNPDA(std::list<sax::Token>& input) const {
+NPDA AutomatonFromXMLParser::parseNPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -426,7 +426,7 @@ NPDA AutomatonFromXMLParser::parseNPDA(std::list<sax::Token>& input) const {
 	return automaton;
 }
 
-SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::list<sax::Token>& input) const {
+SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_SINGLE_POP_NPDA);
 
 	std::set<State> states = parseStates(input);
@@ -449,7 +449,7 @@ SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::list<sax::Token>&
 	return automaton;
 }
 
-OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::list<sax::Token>& input) const {
+OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::AUTOMATON_ONE_TAPE_DTM);
 
 	std::set<State> states = parseStates(input);
@@ -472,7 +472,7 @@ OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::list<sax::Token>& input)
 	return automaton;
 }
 
-std::set<State> AutomatonFromXMLParser::parseStates(std::list<sax::Token> &input) const {
+std::set<State> AutomatonFromXMLParser::parseStates(std::deque<sax::Token> &input) const {
 	std::set<State> states;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "states");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -482,11 +482,11 @@ std::set<State> AutomatonFromXMLParser::parseStates(std::list<sax::Token> &input
 	return states;
 }
 
-State AutomatonFromXMLParser::parseState(std::list<sax::Token> &input) const {
+State AutomatonFromXMLParser::parseState(std::deque<sax::Token> &input) const {
 	return State(alib::xmlApi<label::Label>::parse(input));
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseCallInputAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseCallInputAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "callInputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -496,7 +496,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseCallInputAlphabet(std::l
 	return inputSymbols;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseReturnInputAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseReturnInputAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "returnInputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -506,7 +506,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseReturnInputAlphabet(std:
 	return inputSymbols;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseLocalInputAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseLocalInputAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "localInputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -516,7 +516,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseLocalInputAlphabet(std::
 	return inputSymbols;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInputAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInputAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "inputAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -526,14 +526,14 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInputAlphabet(std::list<
 	return inputSymbols;
 }
 
-State AutomatonFromXMLParser::parseInitialState(std::list<sax::Token> &input) const {
+State AutomatonFromXMLParser::parseInitialState(std::deque<sax::Token> &input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialState");
 	State state(alib::xmlApi<label::Label>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialState");
 	return state;
 }
 
-std::set<State> AutomatonFromXMLParser::parseInitialStates(std::list<sax::Token> &input) const {
+std::set<State> AutomatonFromXMLParser::parseInitialStates(std::deque<sax::Token> &input) const {
 	std::set<State> initialStates;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialStates");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -543,7 +543,7 @@ std::set<State> AutomatonFromXMLParser::parseInitialStates(std::list<sax::Token>
 	return initialStates;
 }
 
-std::set<State> AutomatonFromXMLParser::parseFinalStates(std::list<sax::Token> &input) const {
+std::set<State> AutomatonFromXMLParser::parseFinalStates(std::deque<sax::Token> &input) const {
 	std::set<State> finalStates;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "finalStates");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -553,7 +553,7 @@ std::set<State> AutomatonFromXMLParser::parseFinalStates(std::list<sax::Token> &
 	return finalStates;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseStackAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseStackAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> stackSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "stackAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -563,7 +563,7 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseStackAlphabet(std::list<
 	return stackSymbols;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInitialStackSymbols(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInitialStackSymbols(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> initialSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialStackSymbols");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -573,14 +573,14 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInitialStackSymbols(std:
 	return initialSymbols;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseInitialStackSymbol(std::list<sax::Token> &input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseInitialStackSymbol(std::deque<sax::Token> &input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialStackSymbol");
 	alphabet::Symbol initialSymbol(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialStackSymbol");
 	return initialSymbol;
 }
 
-std::set<alphabet::Symbol> AutomatonFromXMLParser::parseTapeAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> AutomatonFromXMLParser::parseTapeAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> tapeSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "tapeAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -590,21 +590,21 @@ std::set<alphabet::Symbol> AutomatonFromXMLParser::parseTapeAlphabet(std::list<s
 	return tapeSymbols;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseBlankSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "blankSymbol");
 	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "blankSymbol");
 	return blank;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseBottomOfTheStackSymbol(std::list<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseBottomOfTheStackSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "bottomOfTheStackSymbol");
 	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "bottomOfTheStackSymbol");
 	return blank;
 }
 
-void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::Token>& input, automaton::InputDrivenDPDA& automaton) const {
+void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::deque<sax::Token>& input, automaton::InputDrivenDPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "inputToPushdownStoreOperations");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "operation");
@@ -621,7 +621,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::T
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "inputToPushdownStoreOperations");
 }
 
-void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::Token>& input, automaton::InputDrivenNPDA& automaton) const {
+void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::deque<sax::Token>& input, automaton::InputDrivenNPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "inputToPushdownStoreOperations");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "operation");
@@ -638,7 +638,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::T
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "inputToPushdownStoreOperations");
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, DFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -648,7 +648,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DFA&
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, MultiInitialStateNFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, MultiInitialStateNFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -658,7 +658,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Multi
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, NFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -668,7 +668,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA&
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, EpsilonNFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, EpsilonNFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputVariant = parseTransitionInputEpsilonSymbol(input);
@@ -678,7 +678,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Epsil
 	automaton.addTransition(std::move(from), std::move(inputVariant), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, CompactNFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, CompactNFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	string::LinearString inputString = parseTransitionInputString(input);
@@ -688,7 +688,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Compa
 	automaton.addTransition(std::move(from), std::move(inputString), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, ExtendedNFA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, ExtendedNFA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	regexp::RegExp inputRegexp = parseTransitionInputRegexp(input);
@@ -698,7 +698,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Exten
 	automaton.addTransition(std::move(from), std::move(inputRegexp), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, DPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
@@ -710,7 +710,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DPDA&
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, SinglePopDPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, SinglePopDPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
@@ -722,7 +722,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Singl
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, InputDrivenDPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, InputDrivenDPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -732,7 +732,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Input
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, InputDrivenNPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, InputDrivenNPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -742,7 +742,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Input
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, VisiblyPushdownDPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, VisiblyPushdownDPDA& automaton) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
 		State from = parseTransitionFrom(input);
@@ -772,7 +772,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
 	}
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, VisiblyPushdownNPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, VisiblyPushdownNPDA& automaton) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
 		State from = parseTransitionFrom(input);
@@ -802,7 +802,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
 	}
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealTimeHeightDeterministicDPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, RealTimeHeightDeterministicDPDA& automaton) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
 		State from = parseTransitionFrom(input);
@@ -832,7 +832,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
 	}
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealTimeHeightDeterministicNPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, RealTimeHeightDeterministicNPDA& automaton) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "callTransition");
 		State from = parseTransitionFrom(input);
@@ -862,7 +862,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
 	}
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, NPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
@@ -874,7 +874,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NPDA&
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, SinglePopNPDA& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, SinglePopNPDA& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
@@ -886,7 +886,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Singl
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to), std::move(push));
 }
 
-void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, OneTapeDTM& automaton) const {
+void AutomatonFromXMLParser::parseTransition(std::deque<sax::Token>& input, OneTapeDTM& automaton) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 	State from = parseTransitionFrom(input);
 	alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
@@ -898,21 +898,21 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, OneTa
 	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(outputSymbol), shift);
 }
 
-State AutomatonFromXMLParser::parseTransitionTo(std::list<sax::Token> &input) const {
+State AutomatonFromXMLParser::parseTransitionTo(std::deque<sax::Token> &input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "to");
 	State state(alib::xmlApi<label::Label>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "to");
 	return state;
 }
 
-State AutomatonFromXMLParser::parseTransitionFrom(std::list<sax::Token> &input) const {
+State AutomatonFromXMLParser::parseTransitionFrom(std::deque<sax::Token> &input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "from");
 	State state(alib::xmlApi<label::Label>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "from");
 	return state;
 }
 
-Shift AutomatonFromXMLParser::parseTransitionShift(std::list<sax::Token>& input) const {
+Shift AutomatonFromXMLParser::parseTransitionShift(std::deque<sax::Token>& input) const {
 	Shift shift;
 
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "shift");
@@ -931,7 +931,7 @@ Shift AutomatonFromXMLParser::parseTransitionShift(std::list<sax::Token>& input)
 	return shift;
 }
 
-std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPop(std::list<sax::Token>& input) const {
+std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPop(std::deque<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> pops;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "pop");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -941,14 +941,14 @@ std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPop(std::li
 	return pops;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseTransitionSinglePop(std::list<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseTransitionSinglePop(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "pop");
 	alphabet::Symbol pop = alib::xmlApi<alphabet::Symbol>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "pop");
 	return pop;
 }
 
-std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPush(std::list<sax::Token>& input) const {
+std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPush(std::deque<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> pushes;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "push");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -958,28 +958,28 @@ std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPush(std::l
 	return pushes;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseTransitionSinglePush(std::list<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseTransitionSinglePush(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "push");
 	alphabet::Symbol push = alib::xmlApi<alphabet::Symbol>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "push");
 	return push;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseTransitionInputSymbol(std::list<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseTransitionInputSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	alphabet::Symbol result(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 	return result;
 }
 
-alphabet::Symbol AutomatonFromXMLParser::parseTransitionOutputSymbol(std::list<sax::Token>& input) const {
+alphabet::Symbol AutomatonFromXMLParser::parseTransitionOutputSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "output");
 	alphabet::Symbol result(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "output");
 	return result;
 }
 
-std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(std::list<sax::Token>& input) const {
+std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -995,7 +995,7 @@ std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTra
 	}
 }
 
-std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionOutputEpsilonSymbol(std::list<sax::Token>& input) const {
+std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionOutputEpsilonSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "output");
 
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -1011,14 +1011,14 @@ std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTra
 	}
 }
 
-string::LinearString AutomatonFromXMLParser::parseTransitionInputString(std::list<sax::Token>& input) const {
+string::LinearString AutomatonFromXMLParser::parseTransitionInputString(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	string::LinearString result(alib::xmlApi<string::LinearString>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 	return result;
 }
 
-regexp::RegExp AutomatonFromXMLParser::parseTransitionInputRegexp(std::list<sax::Token>& input) const {
+regexp::RegExp AutomatonFromXMLParser::parseTransitionInputRegexp(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	regexp::RegExp result(alib::xmlApi<regexp::RegExp>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
diff --git a/alib2data/src/automaton/AutomatonFromXMLParser.h b/alib2data/src/automaton/AutomatonFromXMLParser.h
index c032da9819ee00aff8a921a3e2ed0c22e74a7764..5dd4f29fde67a2126064750d73559f37b449ab79 100644
--- a/alib2data/src/automaton/AutomatonFromXMLParser.h
+++ b/alib2data/src/automaton/AutomatonFromXMLParser.h
@@ -47,90 +47,90 @@ namespace automaton {
  * Parser used to get general FSM or EpsilonNFA, NFA, DFA from XML parsed into list of Tokens.
  */
 class AutomatonFromXMLParser : public sax::FromXMLParserHelper {
-	std::set<State> parseStates(std::list<sax::Token> &input) const;
-	State parseState(std::list<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseInputAlphabet(std::list<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseCallInputAlphabet(std::list<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseReturnInputAlphabet(std::list<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseLocalInputAlphabet(std::list<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseStackAlphabet(std::list<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseInitialStackSymbols(std::list<sax::Token> &input) const;
-	alphabet::Symbol parseInitialStackSymbol(std::list<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseTapeAlphabet(std::list<sax::Token> &input) const;
-	State parseInitialState(std::list<sax::Token> &input) const;
-	std::set<State> parseInitialStates(std::list<sax::Token> &input) const;
-	std::set<State> parseFinalStates(std::list<sax::Token> &input) const;
-	alphabet::Symbol parseBlankSymbol(std::list<sax::Token> &input) const;
-	alphabet::Symbol parseBottomOfTheStackSymbol(std::list<sax::Token> &input) const;
-	void parseInputToPushdownStoreOperation(std::list<sax::Token>& input, automaton::InputDrivenDPDA& automaton) const;
-	void parseInputToPushdownStoreOperation(std::list<sax::Token>& input, automaton::InputDrivenNPDA& automaton) const;
-
-	State parseTransitionFrom(std::list<sax::Token>& input) const;
-	State parseTransitionTo(std::list<sax::Token>& input) const;
-	Shift parseTransitionShift(std::list<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseTransitionPop(std::list<sax::Token>& input) const;
-	alphabet::Symbol parseTransitionSinglePop(std::list<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseTransitionPush(std::list<sax::Token>& input) const;
-	alphabet::Symbol parseTransitionSinglePush(std::list<sax::Token>& input) const;
+	std::set<State> parseStates(std::deque<sax::Token> &input) const;
+	State parseState(std::deque<sax::Token> &input) const;
+	std::set<alphabet::Symbol> parseInputAlphabet(std::deque<sax::Token> &input) const;
+	std::set<alphabet::Symbol> parseCallInputAlphabet(std::deque<sax::Token> &input) const;
+	std::set<alphabet::Symbol> parseReturnInputAlphabet(std::deque<sax::Token> &input) const;
+	std::set<alphabet::Symbol> parseLocalInputAlphabet(std::deque<sax::Token> &input) const;
+	std::set<alphabet::Symbol> parseStackAlphabet(std::deque<sax::Token> &input) const;
+	std::set<alphabet::Symbol> parseInitialStackSymbols(std::deque<sax::Token> &input) const;
+	alphabet::Symbol parseInitialStackSymbol(std::deque<sax::Token> &input) const;
+	std::set<alphabet::Symbol> parseTapeAlphabet(std::deque<sax::Token> &input) const;
+	State parseInitialState(std::deque<sax::Token> &input) const;
+	std::set<State> parseInitialStates(std::deque<sax::Token> &input) const;
+	std::set<State> parseFinalStates(std::deque<sax::Token> &input) const;
+	alphabet::Symbol parseBlankSymbol(std::deque<sax::Token> &input) const;
+	alphabet::Symbol parseBottomOfTheStackSymbol(std::deque<sax::Token> &input) const;
+	void parseInputToPushdownStoreOperation(std::deque<sax::Token>& input, automaton::InputDrivenDPDA& automaton) const;
+	void parseInputToPushdownStoreOperation(std::deque<sax::Token>& input, automaton::InputDrivenNPDA& automaton) const;
+
+	State parseTransitionFrom(std::deque<sax::Token>& input) const;
+	State parseTransitionTo(std::deque<sax::Token>& input) const;
+	Shift parseTransitionShift(std::deque<sax::Token>& input) const;
+	std::vector<alphabet::Symbol> parseTransitionPop(std::deque<sax::Token>& input) const;
+	alphabet::Symbol parseTransitionSinglePop(std::deque<sax::Token>& input) const;
+	std::vector<alphabet::Symbol> parseTransitionPush(std::deque<sax::Token>& input) const;
+	alphabet::Symbol parseTransitionSinglePush(std::deque<sax::Token>& input) const;
 
 	template<class T>
-	void parseTransitions(std::list<sax::Token> &input, T& automaton) const;
-
-	void parseTransition(std::list<sax::Token>& input, EpsilonNFA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, MultiInitialStateNFA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, NFA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, DFA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, CompactNFA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, ExtendedNFA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, DPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, SinglePopDPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, InputDrivenDPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, InputDrivenNPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, VisiblyPushdownDPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, VisiblyPushdownNPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, RealTimeHeightDeterministicDPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, RealTimeHeightDeterministicNPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, NPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, SinglePopNPDA& automaton) const;
-	void parseTransition(std::list<sax::Token>& input, OneTapeDTM& automaton) const;
-
-	alphabet::Symbol parseTransitionInputSymbol(std::list<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionInputEpsilonSymbol(std::list<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionInputBlankEpsilonSymbol(std::list<sax::Token> &input) const;
-	string::LinearString parseTransitionInputString(std::list<sax::Token> &input) const;
-	regexp::RegExp parseTransitionInputRegexp(std::list<sax::Token> &input) const;
-
-	alphabet::Symbol parseTransitionOutputSymbol(std::list<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionOutputEpsilonSymbol(std::list<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionOutputBlankEpsilonSymbol(std::list<sax::Token> &input) const;
-
-	alphabet::Symbol parseSymbolIO(std::list<sax::Token> &input) const;
-	std::variant<string::Epsilon, alphabet::Symbol> parseEpsilonSymbolIO(std::list<sax::Token> &input) const;
-
-	Automaton parseAutomaton(std::list<sax::Token>& input) const;
-	Automaton parseAutomaton(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
-
-	EpsilonNFA parseEpsilonNFA(std::list<sax::Token>& input) const;
-	MultiInitialStateNFA parseMultiInitialStateNFA(std::list<sax::Token>& input) const;
-	NFA parseNFA(std::list<sax::Token>& input) const;
-	DFA parseDFA(std::list<sax::Token>& input) const;
-	CompactNFA parseCompactNFA(std::list<sax::Token>& input) const;
-	ExtendedNFA parseExtendedNFA(std::list<sax::Token>& input) const;
-	DPDA parseDPDA(std::list<sax::Token>& input) const;
-	SinglePopDPDA parseSinglePopDPDA(std::list<sax::Token>& input) const;
-	InputDrivenNPDA parseInputDrivenNPDA(std::list<sax::Token>& input) const;
-	InputDrivenDPDA parseInputDrivenDPDA(std::list<sax::Token>& input) const;
-	VisiblyPushdownDPDA parseVisiblyPushdownDPDA(std::list<sax::Token>& input) const;
-	VisiblyPushdownNPDA parseVisiblyPushdownNPDA(std::list<sax::Token>& input) const;
-	RealTimeHeightDeterministicDPDA parseRealTimeHeightDeterministicDPDA(std::list<sax::Token>& input) const;
-	RealTimeHeightDeterministicNPDA parseRealTimeHeightDeterministicNPDA(std::list<sax::Token>& input) const;
-	NPDA parseNPDA(std::list<sax::Token>& input) const;
-	SinglePopNPDA parseSinglePopNPDA(std::list<sax::Token>& input) const;
-	OneTapeDTM parseOneTapeDTM(std::list<sax::Token>& input) const;
+	void parseTransitions(std::deque<sax::Token> &input, T& automaton) const;
+
+	void parseTransition(std::deque<sax::Token>& input, EpsilonNFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, MultiInitialStateNFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, NFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, DFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, CompactNFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, ExtendedNFA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, DPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, SinglePopDPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, InputDrivenDPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, InputDrivenNPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, VisiblyPushdownDPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, VisiblyPushdownNPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, RealTimeHeightDeterministicDPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, RealTimeHeightDeterministicNPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, NPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, SinglePopNPDA& automaton) const;
+	void parseTransition(std::deque<sax::Token>& input, OneTapeDTM& automaton) const;
+
+	alphabet::Symbol parseTransitionInputSymbol(std::deque<sax::Token> &input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionInputEpsilonSymbol(std::deque<sax::Token> &input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionInputBlankEpsilonSymbol(std::deque<sax::Token> &input) const;
+	string::LinearString parseTransitionInputString(std::deque<sax::Token> &input) const;
+	regexp::RegExp parseTransitionInputRegexp(std::deque<sax::Token> &input) const;
+
+	alphabet::Symbol parseTransitionOutputSymbol(std::deque<sax::Token> &input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionOutputEpsilonSymbol(std::deque<sax::Token> &input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseTransitionOutputBlankEpsilonSymbol(std::deque<sax::Token> &input) const;
+
+	alphabet::Symbol parseSymbolIO(std::deque<sax::Token> &input) const;
+	std::variant<string::Epsilon, alphabet::Symbol> parseEpsilonSymbolIO(std::deque<sax::Token> &input) const;
+
+	Automaton parseAutomaton(std::deque<sax::Token>& input) const;
+	Automaton parseAutomaton(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
+
+	EpsilonNFA parseEpsilonNFA(std::deque<sax::Token>& input) const;
+	MultiInitialStateNFA parseMultiInitialStateNFA(std::deque<sax::Token>& input) const;
+	NFA parseNFA(std::deque<sax::Token>& input) const;
+	DFA parseDFA(std::deque<sax::Token>& input) const;
+	CompactNFA parseCompactNFA(std::deque<sax::Token>& input) const;
+	ExtendedNFA parseExtendedNFA(std::deque<sax::Token>& input) const;
+	DPDA parseDPDA(std::deque<sax::Token>& input) const;
+	SinglePopDPDA parseSinglePopDPDA(std::deque<sax::Token>& input) const;
+	InputDrivenNPDA parseInputDrivenNPDA(std::deque<sax::Token>& input) const;
+	InputDrivenDPDA parseInputDrivenDPDA(std::deque<sax::Token>& input) const;
+	VisiblyPushdownDPDA parseVisiblyPushdownDPDA(std::deque<sax::Token>& input) const;
+	VisiblyPushdownNPDA parseVisiblyPushdownNPDA(std::deque<sax::Token>& input) const;
+	RealTimeHeightDeterministicDPDA parseRealTimeHeightDeterministicDPDA(std::deque<sax::Token>& input) const;
+	RealTimeHeightDeterministicNPDA parseRealTimeHeightDeterministicNPDA(std::deque<sax::Token>& input) const;
+	NPDA parseNPDA(std::deque<sax::Token>& input) const;
+	SinglePopNPDA parseSinglePopNPDA(std::deque<sax::Token>& input) const;
+	OneTapeDTM parseOneTapeDTM(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace automaton */
diff --git a/alib2data/src/automaton/AutomatonToXMLComposer.cpp b/alib2data/src/automaton/AutomatonToXMLComposer.cpp
index b4cd57b1ff87d24c059f4f49d18beaa81b12b354..283407882314fd033c10f7ec41642fcdfa74b9b3 100644
--- a/alib2data/src/automaton/AutomatonToXMLComposer.cpp
+++ b/alib2data/src/automaton/AutomatonToXMLComposer.cpp
@@ -12,7 +12,7 @@
 
 namespace automaton {
 
-void AutomatonToXMLComposer::composeStates(std::list<sax::Token>& out, const std::set<State>& states) const {
+void AutomatonToXMLComposer::composeStates(std::deque<sax::Token>& out, const std::set<State>& states) const {
 	out.push_back(sax::Token("states", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& state : states) {
 		alib::xmlApi<label::Label>::compose(out, state.getName());
@@ -20,7 +20,7 @@ void AutomatonToXMLComposer::composeStates(std::list<sax::Token>& out, const std
 	out.push_back(sax::Token("states", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeInputAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeInputAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("inputAlphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -28,7 +28,7 @@ void AutomatonToXMLComposer::composeInputAlphabet(std::list<sax::Token>& out, co
 	out.push_back(sax::Token("inputAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeCallInputAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeCallInputAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("callInputAlphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -36,7 +36,7 @@ void AutomatonToXMLComposer::composeCallInputAlphabet(std::list<sax::Token>& out
 	out.push_back(sax::Token("callInputAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeReturnInputAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeReturnInputAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("returnInputAlphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -44,7 +44,7 @@ void AutomatonToXMLComposer::composeReturnInputAlphabet(std::list<sax::Token>& o
 	out.push_back(sax::Token("returnInputAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeLocalInputAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeLocalInputAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("localInputAlphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -52,7 +52,7 @@ void AutomatonToXMLComposer::composeLocalInputAlphabet(std::list<sax::Token>& ou
 	out.push_back(sax::Token("localInputAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeInitialStates(std::list<sax::Token>& out, const std::set<State>& states) const {
+void AutomatonToXMLComposer::composeInitialStates(std::deque<sax::Token>& out, const std::set<State>& states) const {
 	out.push_back(sax::Token("initialStates", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& state : states) {
 		alib::xmlApi<label::Label>::compose(out, state.getName());
@@ -60,13 +60,13 @@ void AutomatonToXMLComposer::composeInitialStates(std::list<sax::Token>& out, co
 	out.push_back(sax::Token("initialStates", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeInitialState(std::list<sax::Token>& out, const State& state) const {
+void AutomatonToXMLComposer::composeInitialState(std::deque<sax::Token>& out, const State& state) const {
 	out.push_back(sax::Token("initialState", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<label::Label>::compose(out, state.getName());
 	out.push_back(sax::Token("initialState", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeFinalStates(std::list<sax::Token>& out, const std::set<State>& states) const {
+void AutomatonToXMLComposer::composeFinalStates(std::deque<sax::Token>& out, const std::set<State>& states) const {
 	out.push_back(sax::Token("finalStates", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& state : states) {
 		alib::xmlApi<label::Label>::compose(out, state.getName());
@@ -74,7 +74,7 @@ void AutomatonToXMLComposer::composeFinalStates(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("finalStates", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeStackAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeStackAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("stackAlphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -82,7 +82,7 @@ void AutomatonToXMLComposer::composeStackAlphabet(std::list<sax::Token>& out, co
 	out.push_back(sax::Token("stackAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeInitialStackSymbols(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeInitialStackSymbols(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("initialStackSymbols", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -90,13 +90,13 @@ void AutomatonToXMLComposer::composeInitialStackSymbols(std::list<sax::Token>& o
 	out.push_back(sax::Token("initialStackSymbols", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeInitialStackSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void AutomatonToXMLComposer::composeInitialStackSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("initialStackSymbol", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("initialStackSymbol", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTapeAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeTapeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("tapeAlphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -104,19 +104,19 @@ void AutomatonToXMLComposer::composeTapeAlphabet(std::list<sax::Token>& out, con
 	out.push_back(sax::Token("tapeAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeBlankSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void AutomatonToXMLComposer::composeBlankSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("blankSymbol", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("blankSymbol", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeBottomOfTheStackSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void AutomatonToXMLComposer::composeBottomOfTheStackSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("bottomOfTheStackSymbol", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("bottomOfTheStackSymbol", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::list<sax::Token>& out, const automaton::InputDrivenDPDA& automaton) const {
+void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::deque<sax::Token>& out, const automaton::InputDrivenDPDA& automaton) const {
 	out.push_back(sax::Token("inputToPushdownStoreOperations", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& pushdownStoreOperation : automaton.getPushdownStoreOperations()) {
 		out.push_back(sax::Token("operation", sax::Token::TokenType::START_ELEMENT));
@@ -131,7 +131,7 @@ void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::list<sax:
 	out.push_back(sax::Token("inputToPushdownStoreOperations", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::list<sax::Token>& out, const automaton::InputDrivenNPDA& automaton) const {
+void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::deque<sax::Token>& out, const automaton::InputDrivenNPDA& automaton) const {
 	out.push_back(sax::Token("inputToPushdownStoreOperations", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& pushdownStoreOperation : automaton.getPushdownStoreOperations()) {
 		out.push_back(sax::Token("operation", sax::Token::TokenType::START_ELEMENT));
@@ -146,7 +146,7 @@ void AutomatonToXMLComposer::composeInputToPushdownStoreOperation(std::list<sax:
 	out.push_back(sax::Token("inputToPushdownStoreOperations", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const DFA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const DFA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
@@ -161,7 +161,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const NFA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const NFA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
@@ -178,7 +178,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const MultiInitialStateNFA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const MultiInitialStateNFA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
@@ -195,7 +195,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const EpsilonNFA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const EpsilonNFA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
@@ -212,7 +212,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const CompactNFA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const CompactNFA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
@@ -229,7 +229,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const ExtendedNFA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const ExtendedNFA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& targetState: transition.second) {
@@ -246,7 +246,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const DPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const DPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
@@ -263,7 +263,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const SinglePopDPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const SinglePopDPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
@@ -280,7 +280,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const InputDrivenDPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const InputDrivenDPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
@@ -295,7 +295,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const InputDrivenNPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const InputDrivenNPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& target: transition.second) {
@@ -312,7 +312,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const VisiblyPushdownDPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const VisiblyPushdownDPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getCallTransitions()) {
 		out.push_back(sax::Token("callTransition", sax::Token::TokenType::START_ELEMENT));
@@ -346,7 +346,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const VisiblyPushdownNPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const VisiblyPushdownNPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getCallTransitions()) {
 		for(const auto& target: transition.second) {
@@ -386,7 +386,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const RealTimeHeightDeterministicDPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const RealTimeHeightDeterministicDPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getCallTransitions()) {
 		out.push_back(sax::Token("callTransition", sax::Token::TokenType::START_ELEMENT));
@@ -420,7 +420,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const RealTimeHeightDeterministicNPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const RealTimeHeightDeterministicNPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getCallTransitions()) {
 		for(const auto& target: transition.second) {
@@ -460,7 +460,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const NPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const NPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& target: transition.second) {
@@ -479,7 +479,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const SinglePopNPDA& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const SinglePopNPDA& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		for(const auto& target: transition.second) {
@@ -498,7 +498,7 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, const OneTapeDTM& automaton) const {
+void AutomatonToXMLComposer::composeTransitions(std::deque<sax::Token>& out, const OneTapeDTM& automaton) const {
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& transition : automaton.getTransitions()) {
 		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
@@ -515,25 +515,25 @@ void AutomatonToXMLComposer::composeTransitions(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionTo(std::list<sax::Token>& out, const State& state) const {
+void AutomatonToXMLComposer::composeTransitionTo(std::deque<sax::Token>& out, const State& state) const {
 	out.push_back(sax::Token("to", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<label::Label>::compose(out, state.getName());
 	out.push_back(sax::Token("to", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionFrom(std::list<sax::Token>& out, const State& state) const {
+void AutomatonToXMLComposer::composeTransitionFrom(std::deque<sax::Token>& out, const State& state) const {
 	out.push_back(sax::Token("from", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<label::Label>::compose(out, state.getName());
 	out.push_back(sax::Token("from", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionShift(std::list<sax::Token>& out, const Shift shift) const {
+void AutomatonToXMLComposer::composeTransitionShift(std::deque<sax::Token>& out, const Shift shift) const {
 	out.push_back(sax::Token("shift", sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(SHIFT_NAMES [shift], sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token("shift", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionPop(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeTransitionPop(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("pop", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -541,13 +541,13 @@ void AutomatonToXMLComposer::composeTransitionPop(std::list<sax::Token>& out, co
 	out.push_back(sax::Token("pop", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionSinglePop(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void AutomatonToXMLComposer::composeTransitionSinglePop(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("pop", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("pop", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionPush(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
+void AutomatonToXMLComposer::composeTransitionPush(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("push", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -555,25 +555,25 @@ void AutomatonToXMLComposer::composeTransitionPush(std::list<sax::Token>& out, c
 	out.push_back(sax::Token("push", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionSinglePush(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void AutomatonToXMLComposer::composeTransitionSinglePush(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("push", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("push", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionInputSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void AutomatonToXMLComposer::composeTransitionInputSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("input", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("input", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionOutputSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void AutomatonToXMLComposer::composeTransitionOutputSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("output", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("output", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol(std::list<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol) const {
+void AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol(std::deque<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol) const {
 	out.push_back(sax::Token("input", sax::Token::TokenType::START_ELEMENT));
 	if(symbol.is<string::Epsilon>()) {
 		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
@@ -584,7 +584,7 @@ void AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol(std::list<sax::
 	out.push_back(sax::Token("input", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionOutputEpsilonSymbol(std::list<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol) const {
+void AutomatonToXMLComposer::composeTransitionOutputEpsilonSymbol(std::deque<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol) const {
 	out.push_back(sax::Token("output", sax::Token::TokenType::START_ELEMENT));
 	if(symbol.is<string::Epsilon>()) {
 		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
@@ -595,27 +595,27 @@ void AutomatonToXMLComposer::composeTransitionOutputEpsilonSymbol(std::list<sax:
 	out.push_back(sax::Token("output", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionInputString(std::list<sax::Token>& out, const string::LinearString& string) const {
+void AutomatonToXMLComposer::composeTransitionInputString(std::deque<sax::Token>& out, const string::LinearString& string) const {
 	out.push_back(sax::Token("input", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<string::LinearString>::compose(out, string);
 	out.push_back(sax::Token("input", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::composeTransitionInputRegexp(std::list<sax::Token>& out, const regexp::RegExp& regexp) const {
+void AutomatonToXMLComposer::composeTransitionInputRegexp(std::deque<sax::Token>& out, const regexp::RegExp& regexp) const {
 	out.push_back(sax::Token("input", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<regexp::RegExp>::compose(out, regexp);
 	out.push_back(sax::Token("input", sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const Automaton& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const Automaton& automaton) const {
 	automaton.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const AutomatonBase& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const AutomatonBase& automaton) const {
 	automaton.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const DFA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const DFA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_DFA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -627,7 +627,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const DFA& auto
 	out.push_back(sax::Token(alib::Names::AUTOMATON_DFA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const NFA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const NFA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_NFA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -639,7 +639,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const NFA& auto
 	out.push_back(sax::Token(alib::Names::AUTOMATON_NFA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const MultiInitialStateNFA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const MultiInitialStateNFA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -651,7 +651,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const MultiInit
 	out.push_back(sax::Token(alib::Names::AUTOMATON_MULTI_INITIAL_STATE_NFA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const EpsilonNFA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const EpsilonNFA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_EPSILON_NFA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -663,7 +663,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const EpsilonNF
 	out.push_back(sax::Token(alib::Names::AUTOMATON_EPSILON_NFA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const ExtendedNFA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const ExtendedNFA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_EXTENDED_NFA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -675,7 +675,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const ExtendedN
 	out.push_back(sax::Token(alib::Names::AUTOMATON_EXTENDED_NFA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const CompactNFA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const CompactNFA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_COMPACT_NFA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -687,7 +687,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const CompactNF
 	out.push_back(sax::Token(alib::Names::AUTOMATON_COMPACT_NFA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const DPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const DPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_DPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -701,7 +701,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const DPDA& aut
 	out.push_back(sax::Token(alib::Names::AUTOMATON_DPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const SinglePopDPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const SinglePopDPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_DPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -715,7 +715,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const SinglePop
 	out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_DPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const InputDrivenDPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const InputDrivenDPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_DPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -730,7 +730,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const InputDriv
 	out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_DPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const InputDrivenNPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const InputDrivenNPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -745,7 +745,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const InputDriv
 	out.push_back(sax::Token(alib::Names::AUTOMATON_INPUT_DRIVEN_NPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const VisiblyPushdownDPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const VisiblyPushdownDPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -761,7 +761,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const VisiblyPu
 	out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_DPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const VisiblyPushdownNPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const VisiblyPushdownNPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -777,7 +777,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const VisiblyPu
 	out.push_back(sax::Token(alib::Names::AUTOMATON_VISIBLY_PUSHDOWN_NPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const RealTimeHeightDeterministicDPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const RealTimeHeightDeterministicDPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -791,7 +791,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const RealTimeH
 	out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_DPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const RealTimeHeightDeterministicNPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const RealTimeHeightDeterministicNPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -805,7 +805,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const RealTimeH
 	out.push_back(sax::Token(alib::Names::AUTOMATON_REAL_TIME_HEIGHT_DETERMINISTIC_NPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const NPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const NPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_NPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -819,7 +819,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const NPDA& aut
 	out.push_back(sax::Token(alib::Names::AUTOMATON_NPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const SinglePopNPDA& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const SinglePopNPDA& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_NPDA, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -833,7 +833,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const SinglePop
 	out.push_back(sax::Token(alib::Names::AUTOMATON_SINGLE_POP_NPDA, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const OneTapeDTM& automaton) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const OneTapeDTM& automaton) const {
 	out.push_back(sax::Token(alib::Names::AUTOMATON_ONE_TAPE_DTM, sax::Token::TokenType::START_ELEMENT));
 
 	composeStates(out, automaton.getStates());
@@ -847,7 +847,7 @@ void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const OneTapeDT
 	out.push_back(sax::Token(alib::Names::AUTOMATON_ONE_TAPE_DTM, sax::Token::TokenType::END_ELEMENT));
 }
 
-void AutomatonToXMLComposer::compose(std::list<sax::Token>& out, const State& state) const {
+void AutomatonToXMLComposer::compose(std::deque<sax::Token>& out, const State& state) const {
 	alib::xmlApi<label::Label>::compose(out, state.getName());
 }
 
diff --git a/alib2data/src/automaton/AutomatonToXMLComposer.h b/alib2data/src/automaton/AutomatonToXMLComposer.h
index 34a2eaa9a163b85e1daf80dbcdeae177c147469c..ab43de162ff544f1abd524a34c257c5354a73f60 100644
--- a/alib2data/src/automaton/AutomatonToXMLComposer.h
+++ b/alib2data/src/automaton/AutomatonToXMLComposer.h
@@ -9,7 +9,7 @@
 #define AUTOMATON_TO_XML_COMPOSER_H_
 
 #include <string>
-#include <list>
+#include <deque>
 #include "Automaton.h"
 #include "FSM/EpsilonNFA.h"
 #include "FSM/MultiInitialStateNFA.h"
@@ -41,83 +41,83 @@ namespace automaton {
  * This class contains methods to print XML representation of automata to the output stream.
  */
 class AutomatonToXMLComposer {
-	void composeStates(std::list<sax::Token>&, const std::set<State>& states) const;
-	void composeInputAlphabet(std::list<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
-	void composeCallInputAlphabet(std::list<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
-	void composeReturnInputAlphabet(std::list<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
-	void composeLocalInputAlphabet(std::list<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
-	void composeInitialStates(std::list<sax::Token>&, const std::set<State>& states) const;
-	void composeInitialState(std::list<sax::Token>&, const State& state) const;
-	void composeFinalStates(std::list<sax::Token>&, const std::set<State>& states) const;
-	void composeStackAlphabet(std::list<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
-	void composeInitialStackSymbols(std::list<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
-	void composeInitialStackSymbol(std::list<sax::Token>&, const alphabet::Symbol& symbols) const;
-	void composeTapeAlphabet(std::list<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
-	void composeBlankSymbol(std::list<sax::Token>&, const alphabet::Symbol& symbol) const;
-	void composeBottomOfTheStackSymbol(std::list<sax::Token>&, const alphabet::Symbol& symbol) const;
-	void composeInputToPushdownStoreOperation(std::list<sax::Token>&, const automaton::InputDrivenDPDA& automaton) const;
-	void composeInputToPushdownStoreOperation(std::list<sax::Token>&, const automaton::InputDrivenNPDA& automaton) const;
-
-	void composeTransitions(std::list<sax::Token>&, const EpsilonNFA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const CompactNFA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const ExtendedNFA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const MultiInitialStateNFA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const NFA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const DFA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const DPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const SinglePopDPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const InputDrivenDPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const InputDrivenNPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const VisiblyPushdownDPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const VisiblyPushdownNPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const RealTimeHeightDeterministicDPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const RealTimeHeightDeterministicNPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const NPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const SinglePopNPDA& automaton) const;
-	void composeTransitions(std::list<sax::Token>&, const OneTapeDTM& automaton) const;
-
-	void composeTransitionTo(std::list<sax::Token>&, const State& state) const;
-	void composeTransitionFrom(std::list<sax::Token>&, const State& state) const;
-	void composeTransitionShift(std::list<sax::Token>&, const Shift shift) const;
-	void composeTransitionPop(std::list<sax::Token>&, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeTransitionSinglePop(std::list<sax::Token>&, const alphabet::Symbol& symbol) const;
-	void composeTransitionPush(std::list<sax::Token>&, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeTransitionSinglePush(std::list<sax::Token>&, const alphabet::Symbol& symbol) const;
-	void composeTransitionInputSymbol(std::list<sax::Token>&, const alphabet::Symbol& symbol) const;
-	void composeTransitionInputEpsilonSymbol(std::list<sax::Token>&, const std::variant<string::Epsilon, alphabet::Symbol>&) const;
-	void composeTransitionOutputSymbol(std::list<sax::Token>&, const alphabet::Symbol& symbol) const;
-	void composeTransitionOutputEpsilonSymbol(std::list<sax::Token>&, const std::variant<string::Epsilon, alphabet::Symbol>&) const;
-	void composeTransitionInputString(std::list<sax::Token>&, const string::LinearString& string) const;
-	void composeTransitionInputRegexp(std::list<sax::Token>&, const regexp::RegExp& regexp) const;
+	void composeStates(std::deque<sax::Token>&, const std::set<State>& states) const;
+	void composeInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
+	void composeCallInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
+	void composeReturnInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
+	void composeLocalInputAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
+	void composeInitialStates(std::deque<sax::Token>&, const std::set<State>& states) const;
+	void composeInitialState(std::deque<sax::Token>&, const State& state) const;
+	void composeFinalStates(std::deque<sax::Token>&, const std::set<State>& states) const;
+	void composeStackAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
+	void composeInitialStackSymbols(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
+	void composeInitialStackSymbol(std::deque<sax::Token>&, const alphabet::Symbol& symbols) const;
+	void composeTapeAlphabet(std::deque<sax::Token>&, const std::set<alphabet::Symbol>& symbols) const;
+	void composeBlankSymbol(std::deque<sax::Token>&, const alphabet::Symbol& symbol) const;
+	void composeBottomOfTheStackSymbol(std::deque<sax::Token>&, const alphabet::Symbol& symbol) const;
+	void composeInputToPushdownStoreOperation(std::deque<sax::Token>&, const automaton::InputDrivenDPDA& automaton) const;
+	void composeInputToPushdownStoreOperation(std::deque<sax::Token>&, const automaton::InputDrivenNPDA& automaton) const;
+
+	void composeTransitions(std::deque<sax::Token>&, const EpsilonNFA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const CompactNFA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const ExtendedNFA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const MultiInitialStateNFA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const NFA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const DFA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const DPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const SinglePopDPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const InputDrivenDPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const InputDrivenNPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const VisiblyPushdownDPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const VisiblyPushdownNPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const RealTimeHeightDeterministicDPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const RealTimeHeightDeterministicNPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const NPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const SinglePopNPDA& automaton) const;
+	void composeTransitions(std::deque<sax::Token>&, const OneTapeDTM& automaton) const;
+
+	void composeTransitionTo(std::deque<sax::Token>&, const State& state) const;
+	void composeTransitionFrom(std::deque<sax::Token>&, const State& state) const;
+	void composeTransitionShift(std::deque<sax::Token>&, const Shift shift) const;
+	void composeTransitionPop(std::deque<sax::Token>&, const std::vector<alphabet::Symbol>& symbols) const;
+	void composeTransitionSinglePop(std::deque<sax::Token>&, const alphabet::Symbol& symbol) const;
+	void composeTransitionPush(std::deque<sax::Token>&, const std::vector<alphabet::Symbol>& symbols) const;
+	void composeTransitionSinglePush(std::deque<sax::Token>&, const alphabet::Symbol& symbol) const;
+	void composeTransitionInputSymbol(std::deque<sax::Token>&, const alphabet::Symbol& symbol) const;
+	void composeTransitionInputEpsilonSymbol(std::deque<sax::Token>&, const std::variant<string::Epsilon, alphabet::Symbol>&) const;
+	void composeTransitionOutputSymbol(std::deque<sax::Token>&, const alphabet::Symbol& symbol) const;
+	void composeTransitionOutputEpsilonSymbol(std::deque<sax::Token>&, const std::variant<string::Epsilon, alphabet::Symbol>&) const;
+	void composeTransitionInputString(std::deque<sax::Token>&, const string::LinearString& string) const;
+	void composeTransitionInputRegexp(std::deque<sax::Token>&, const regexp::RegExp& regexp) const;
 
 	/**
 	 * Prints XML representation of Automaton to the output stream.
 	 * @param automaton automaton to print
 	 * @return list of xml tokens representing the automaton
 	 */
-	void compose(std::list<sax::Token>& output, const AutomatonBase& automaton) const;
+	void compose(std::deque<sax::Token>& output, const AutomatonBase& automaton) const;
 
-	void compose(std::list<sax::Token>& output, const Automaton& automaton) const;
+	void compose(std::deque<sax::Token>& output, const Automaton& automaton) const;
 	
-	void compose(std::list<sax::Token>& output, const DFA& automaton) const;
-	void compose(std::list<sax::Token>& output, const NFA& automaton) const;
-	void compose(std::list<sax::Token>& output, const MultiInitialStateNFA& automaton) const;
-	void compose(std::list<sax::Token>& output, const EpsilonNFA& automaton) const;
-	void compose(std::list<sax::Token>& output, const ExtendedNFA& automaton) const;
-	void compose(std::list<sax::Token>& output, const CompactNFA& automaton) const;
-	void compose(std::list<sax::Token>& output, const DPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const SinglePopDPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const InputDrivenDPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const InputDrivenNPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const VisiblyPushdownNPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const VisiblyPushdownDPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const RealTimeHeightDeterministicNPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const RealTimeHeightDeterministicDPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const NPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const SinglePopNPDA& automaton) const;
-	void compose(std::list<sax::Token>& output, const OneTapeDTM& automaton) const;
-
-	void compose(std::list<sax::Token>& output, const State& state) const;
+	void compose(std::deque<sax::Token>& output, const DFA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const NFA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const MultiInitialStateNFA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const EpsilonNFA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const ExtendedNFA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const CompactNFA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const DPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const SinglePopDPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const InputDrivenDPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const InputDrivenNPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const VisiblyPushdownNPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const VisiblyPushdownDPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const RealTimeHeightDeterministicNPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const RealTimeHeightDeterministicDPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const NPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const SinglePopNPDA& automaton) const;
+	void compose(std::deque<sax::Token>& output, const OneTapeDTM& automaton) const;
+
+	void compose(std::deque<sax::Token>& output, const State& state) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/container/ContainerFromXMLParser.cpp b/alib2data/src/container/ContainerFromXMLParser.cpp
index 8e2abb99013a38c91798e2d4f9bd612ea840a734..8a6289370fb368834682c704c16e0b3cdf80b56a 100644
--- a/alib2data/src/container/ContainerFromXMLParser.cpp
+++ b/alib2data/src/container/ContainerFromXMLParser.cpp
@@ -10,11 +10,11 @@
 
 namespace container {
 
-Container ContainerFromXMLParser::parseContainer(std::list<sax::Token>& input) const {
+Container ContainerFromXMLParser::parseContainer(std::deque<sax::Token>& input) const {
 	return parseContainer(input, std::set<FEATURES>({FEATURES::SET, FEATURES::VECTOR, FEATURES::PAIR, FEATURES::MAP}));
 }
 
-Container ContainerFromXMLParser::parseContainer(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+Container ContainerFromXMLParser::parseContainer(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<ObjectsSet>::first(input)) {
 		if(!features.count(FEATURES::SET)) throw exception::AlibException();
 		return Container(parseObjectsSet(input));
@@ -32,7 +32,7 @@ Container ContainerFromXMLParser::parseContainer(std::list<sax::Token>& input, c
 	}
 }
 
-bool ContainerFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool ContainerFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<ObjectsSet>::first(input) || alib::xmlApi<ObjectsVector>::first(input) || alib::xmlApi<ObjectsPair>::first(input) || alib::xmlApi<ObjectsMap>::first(input)) {
 		return true;
 	} else {
@@ -40,7 +40,7 @@ bool ContainerFromXMLParser::first(const std::list<sax::Token>& input) const {
 	}
 }
 
-ObjectsSet ContainerFromXMLParser::parseObjectsSet(std::list<sax::Token>& input) const {
+ObjectsSet ContainerFromXMLParser::parseObjectsSet(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_SET);
 
 	ObjectsSet set;
@@ -53,7 +53,7 @@ ObjectsSet ContainerFromXMLParser::parseObjectsSet(std::list<sax::Token>& input)
 	return set;
 }
 
-ObjectsVector ContainerFromXMLParser::parseObjectsVector(std::list<sax::Token>& input) const {
+ObjectsVector ContainerFromXMLParser::parseObjectsVector(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_VECTOR);
 
 	ObjectsVector vector;
@@ -66,7 +66,7 @@ ObjectsVector ContainerFromXMLParser::parseObjectsVector(std::list<sax::Token>&
 	return vector;
 }
 
-ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::list<sax::Token>& input) const {
+ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
 
 	alib::Object first = alib::xmlApi<alib::Object>::parse(input);
@@ -78,7 +78,7 @@ ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::list<sax::Token>& inpu
 	return pair;
 }
 
-ObjectsMap ContainerFromXMLParser::parseObjectsMap(std::list<sax::Token>& input) const {
+ObjectsMap ContainerFromXMLParser::parseObjectsMap(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_MAP);
 
 	ObjectsMap map;
diff --git a/alib2data/src/container/ContainerFromXMLParser.hpp b/alib2data/src/container/ContainerFromXMLParser.hpp
index 6138e1c0d7005951102b714152001bd9d1cec796..84dc6df0199378214bfcd3f6476e2f81e2bf152d 100644
--- a/alib2data/src/container/ContainerFromXMLParser.hpp
+++ b/alib2data/src/container/ContainerFromXMLParser.hpp
@@ -34,36 +34,36 @@ namespace container {
  * Parser used to get general FSM or EpsilonNFA, NFA, DFA from XML parsed into list of Tokens.
  */
 class ContainerFromXMLParser : public sax::FromXMLParserHelper {
-	Container parseContainer(std::list<sax::Token>& input) const;
-	Container parseContainer(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+	Container parseContainer(std::deque<sax::Token>& input) const;
+	Container parseContainer(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
 
 	template<typename T>
-	std::set<T> parseSet(std::list<sax::Token>& input) const;
+	std::set<T> parseSet(std::deque<sax::Token>& input) const;
 
-	ObjectsSet parseObjectsSet(std::list<sax::Token>& input) const;
+	ObjectsSet parseObjectsSet(std::deque<sax::Token>& input) const;
 
 	template<typename T>
-	std::vector<T> parseVector(std::list<sax::Token>& input) const;
+	std::vector<T> parseVector(std::deque<sax::Token>& input) const;
 
-	ObjectsVector parseObjectsVector(std::list<sax::Token>& input) const;
+	ObjectsVector parseObjectsVector(std::deque<sax::Token>& input) const;
 
 	template<typename T, typename R>
-	std::pair<T, R> parsePair(std::list<sax::Token>& input) const;
+	std::pair<T, R> parsePair(std::deque<sax::Token>& input) const;
 
-	ObjectsPair parseObjectsPair(std::list<sax::Token>& input) const;
+	ObjectsPair parseObjectsPair(std::deque<sax::Token>& input) const;
 
 	template<typename T, typename R>
-	std::map<T, R> parseMap(std::list<sax::Token>& input) const;
+	std::map<T, R> parseMap(std::deque<sax::Token>& input) const;
 
-	ObjectsMap parseObjectsMap(std::list<sax::Token>& input) const;
+	ObjectsMap parseObjectsMap(std::deque<sax::Token>& input) const;
 
 	template<typename ... Ts>
-	std::variant<Ts...> parseVariant(std::list<sax::Token>& input) const;
+	std::variant<Ts...> parseVariant(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace container */
@@ -73,7 +73,7 @@ public:
 namespace container {
 
 template<typename T>
-std::set<T> ContainerFromXMLParser::parseSet(std::list<sax::Token>& input) const {
+std::set<T> ContainerFromXMLParser::parseSet(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_SET);
 
 	std::set<T> set;
@@ -87,7 +87,7 @@ std::set<T> ContainerFromXMLParser::parseSet(std::list<sax::Token>& input) const
 }
 
 template<typename T>
-std::vector<T> ContainerFromXMLParser::parseVector(std::list<sax::Token>& input) const {
+std::vector<T> ContainerFromXMLParser::parseVector(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_VECTOR);
 
 	std::vector<T> vector;
@@ -101,7 +101,7 @@ std::vector<T> ContainerFromXMLParser::parseVector(std::list<sax::Token>& input)
 }
 
 template<typename T, typename R>
-std::pair<T, R> ContainerFromXMLParser::parsePair(std::list<sax::Token>& input) const {
+std::pair<T, R> ContainerFromXMLParser::parsePair(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
 
 	T first = alib::xmlApi<T>::parse(input);
@@ -112,7 +112,7 @@ std::pair<T, R> ContainerFromXMLParser::parsePair(std::list<sax::Token>& input)
 }
 
 template<typename T, typename R>
-std::map<T, R> ContainerFromXMLParser::parseMap(std::list<sax::Token>& input) const {
+std::map<T, R> ContainerFromXMLParser::parseMap(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::CONTAINER_OBJECTS_MAP);
 
 	std::map<T, R> map;
@@ -127,18 +127,18 @@ std::map<T, R> ContainerFromXMLParser::parseMap(std::list<sax::Token>& input) co
 
 /* TODO for gcc-4.9 uncoment this
 template<typename T>
-T parseVariantHelper(std::list<sax::Token>&) {
+T parseVariantHelper(std::deque<sax::Token>&) {
 	throw exception::AlibException("Can't parse variant type");
 }
 
 template<typename T, typename R, typename ... Ts>
-T parseVariantHelper(std::list<sax::Token>& input) {
+T parseVariantHelper(std::deque<sax::Token>& input) {
 	if(alib::xmlApi<R>::first(input)) return T(alib::xmlApi<R>::parse(input));
 	return parseVariantHelper<T, Ts...>(input);
 }
 
 template<typename ... Ts>
-std::variant<Ts...> ContainerFromXMLParser::parseVariant(std::list<sax::Token>& input) const {
+std::variant<Ts...> ContainerFromXMLParser::parseVariant(std::deque<sax::Token>& input) const {
 	return parseVariantHelper<std::variant<Ts...>, Ts...>(input);
 }
 */
diff --git a/alib2data/src/container/ContainerToXMLComposer.cpp b/alib2data/src/container/ContainerToXMLComposer.cpp
index 7f0aa75b7927f48386061130f394d3838b320f81..32220914e4cad944970eb7f00f60d38196221ebf 100644
--- a/alib2data/src/container/ContainerToXMLComposer.cpp
+++ b/alib2data/src/container/ContainerToXMLComposer.cpp
@@ -9,15 +9,15 @@
 
 namespace container {
 
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const ContainerBase& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ContainerBase& container) const {
 	container.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const Container& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const Container& container) const {
 	container.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const ObjectsSet& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectsSet& container) const {
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::START_ELEMENT));
 
 	for(const alib::Object& item : container) {
@@ -27,7 +27,7 @@ void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const ObjectsSe
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::END_ELEMENT));
 }
 
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const ObjectsVector& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectsVector& container) const {
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::START_ELEMENT));
 
 	for(const alib::Object& item : container) {
@@ -37,7 +37,7 @@ void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const ObjectsVe
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::END_ELEMENT));
 }
 
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const ObjectsPair& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectsPair& container) const {
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::START_ELEMENT));
 
 	alib::xmlApi<alib::Object>::compose(out, container.first);
@@ -46,7 +46,7 @@ void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const ObjectsPa
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::END_ELEMENT));
 }
 
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const ObjectsMap& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectsMap& container) const {
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::START_ELEMENT));
 
 	for(const std::pair<alib::Object, alib::Object>& item : container) {
diff --git a/alib2data/src/container/ContainerToXMLComposer.hpp b/alib2data/src/container/ContainerToXMLComposer.hpp
index 87d1d7628baba554a4556bfc9d97b92a26d2a477..86dcc3af5fe18ea257658904703e0b69cfb19991 100644
--- a/alib2data/src/container/ContainerToXMLComposer.hpp
+++ b/alib2data/src/container/ContainerToXMLComposer.hpp
@@ -8,7 +8,7 @@
 #ifndef CONTAINER_TO_XML_COMPOSER_H_
 #define CONTAINER_TO_XML_COMPOSER_H_
 
-#include <list>
+#include <deque>
 #include "../std/variant.hpp"
 #include "../sax/Token.h"
 
@@ -35,37 +35,37 @@ class ContainerToXMLComposer {
 	 * @param automaton automaton to print
 	 * @return list of xml tokens representing the automaton
 	 */
-	void compose(std::list<sax::Token>& output, const ContainerBase& container) const;
+	void compose(std::deque<sax::Token>& output, const ContainerBase& container) const;
 
 	/**
 	 * Prints XML representation of String to the output stream.
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& output, const Container& container) const;
+	void compose(std::deque<sax::Token>& output, const Container& container) const;
 
 	template<typename T>
-	void compose(std::list<sax::Token>& output, const std::set<T>& container) const;
+	void compose(std::deque<sax::Token>& output, const std::set<T>& container) const;
 
-	void compose(std::list<sax::Token>& output, const ObjectsSet& container) const;
+	void compose(std::deque<sax::Token>& output, const ObjectsSet& container) const;
 
 	template<typename T>
-	void compose(std::list<sax::Token>& output, const std::vector<T>& container) const;
+	void compose(std::deque<sax::Token>& output, const std::vector<T>& container) const;
 
-	void compose(std::list<sax::Token>& output, const ObjectsVector& container) const;
+	void compose(std::deque<sax::Token>& output, const ObjectsVector& container) const;
 
 	template<typename T, typename R>
-	void compose(std::list<sax::Token>& output, const std::pair<T, R>& container) const;
+	void compose(std::deque<sax::Token>& output, const std::pair<T, R>& container) const;
 
-	void compose(std::list<sax::Token>& output, const ObjectsPair& container) const;
+	void compose(std::deque<sax::Token>& output, const ObjectsPair& container) const;
 
 	template<typename T, typename R>
-	void compose(std::list<sax::Token>& output, const std::map<T, R>& container) const;
+	void compose(std::deque<sax::Token>& output, const std::map<T, R>& container) const;
 
-	void compose(std::list<sax::Token>& output, const ObjectsMap& container) const;
+	void compose(std::deque<sax::Token>& output, const ObjectsMap& container) const;
 
 	template<typename ... Ts>
-	void compose(std::list<sax::Token>& output, const std::variant<Ts...>& container) const;
+	void compose(std::deque<sax::Token>& output, const std::variant<Ts...>& container) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
@@ -77,7 +77,7 @@ class ContainerToXMLComposer {
 namespace container {
 
 template<typename T>
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const std::set<T>& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::set<T>& container) const {
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_SET, sax::Token::TokenType::START_ELEMENT));
 
 	for(const T& item : container) {
@@ -88,7 +88,7 @@ void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const std::set<
 }
 
 template<typename T>
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const std::vector<T>& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::vector<T>& container) const {
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_VECTOR, sax::Token::TokenType::START_ELEMENT));
 
 	for(const T& item : container) {
@@ -99,7 +99,7 @@ void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const std::vect
 }
 
 template<typename T, typename R>
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const std::pair<T, R>& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::pair<T, R>& container) const {
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_PAIR, sax::Token::TokenType::START_ELEMENT));
 
 	alib::xmlApi<T>::compose(out, container.first);
@@ -109,7 +109,7 @@ void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const std::pair
 }
 
 template<typename T, typename R>
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const std::map<T, R>& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::map<T, R>& container) const {
 	out.push_back(sax::Token(alib::Names::CONTAINER_OBJECTS_MAP, sax::Token::TokenType::START_ELEMENT));
 
 	for(const std::pair<T, R>& item : container) {
@@ -126,13 +126,13 @@ void composeVariantHelper(const T&) {
 }
 
 template<typename T, typename R, typename ... Ts>
-void composeVariantHelper(std::list<sax::Token>& out, const T& container) {
+void composeVariantHelper(std::deque<sax::Token>& out, const T& container) {
 	if(container.template is<R>()) return alib::xmlApi<R>::compose(out, container.template get<R>());
 	composeVariantHelper<T, Ts...>(out, container);
 }
 
 template<typename ... Ts>
-void ContainerToXMLComposer::compose(std::list<sax::Token>& out, const std::variant<Ts...>& container) const {
+void ContainerToXMLComposer::compose(std::deque<sax::Token>& out, const std::variant<Ts...>& container) const {
 	composeVariantHelper<std::variant<Ts...>, Ts...>(out, container);
 }
 */
diff --git a/alib2data/src/exception/ExceptionFromXMLParser.cpp b/alib2data/src/exception/ExceptionFromXMLParser.cpp
index 6986e878203ba115678f6e57f890679ad20ecbd7..6aacffaecdf2aaebb5932aac717d8b9c8d71b5c8 100644
--- a/alib2data/src/exception/ExceptionFromXMLParser.cpp
+++ b/alib2data/src/exception/ExceptionFromXMLParser.cpp
@@ -13,11 +13,11 @@
 
 namespace exception {
 
-AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& input) const {
+AlibException ExceptionFromXMLParser::parseException(std::deque<sax::Token>& input) const {
 	return parseException(input, std::set<FEATURES>({FEATURES::ALIB_EXCEPTION}));
 }
 
-AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+AlibException ExceptionFromXMLParser::parseException(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(!features.count(FEATURES::ALIB_EXCEPTION)) throw exception::AlibException();
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::EXCEPTION_ALIB_EXCEPTION);
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "cause");
@@ -38,7 +38,7 @@ AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& inpu
 	return AlibException(std::move(cause), std::move(backtrace));
 }
 
-bool ExceptionFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool ExceptionFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<AlibException>::first(input)) {
 		return true;
 	} else {
diff --git a/alib2data/src/exception/ExceptionFromXMLParser.h b/alib2data/src/exception/ExceptionFromXMLParser.h
index 5ca438f0a372d2c8cf3309a9e4e52f609a8e659a..c945181d83864abb376bb051816f09fa2addcc17 100644
--- a/alib2data/src/exception/ExceptionFromXMLParser.h
+++ b/alib2data/src/exception/ExceptionFromXMLParser.h
@@ -8,7 +8,7 @@
 #ifndef EXCEPTION_FROM_XML_PARSER_H_
 #define EXCEPTION_FROM_XML_PARSER_H_
 
-#include <list>
+#include <deque>
 #include <set>
 #include "../sax/FromXMLParserHelper.h"
 #include "ExceptionFeatures.h"
@@ -27,11 +27,11 @@ namespace exception {
  * Parser used to get String from XML parsed into list of tokens.
  */
 class ExceptionFromXMLParser : public sax::FromXMLParserHelper {
-	AlibException parseException(std::list<sax::Token>& input) const;
-	AlibException parseException(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+	AlibException parseException(std::deque<sax::Token>& input) const;
+	AlibException parseException(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
 
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/exception/ExceptionToXMLComposer.cpp b/alib2data/src/exception/ExceptionToXMLComposer.cpp
index eac482b29f602bcf62c0bc4d0b138f6c6d438f90..90c9d7d76506f148f03727c336f77ae5b4e63e4d 100644
--- a/alib2data/src/exception/ExceptionToXMLComposer.cpp
+++ b/alib2data/src/exception/ExceptionToXMLComposer.cpp
@@ -11,7 +11,7 @@
 
 namespace exception {
 
-void ExceptionToXMLComposer::compose(std::list<sax::Token>& out, const AlibException& exception) const {
+void ExceptionToXMLComposer::compose(std::deque<sax::Token>& out, const AlibException& exception) const {
 	out.push_back(sax::Token(alib::Names::EXCEPTION_ALIB_EXCEPTION, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token("cause", sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(exception.getCause(), sax::Token::TokenType::CHARACTER));
diff --git a/alib2data/src/exception/ExceptionToXMLComposer.h b/alib2data/src/exception/ExceptionToXMLComposer.h
index 10d805bfe1ee1b643cb6b3274128959f1e072ff1..e669286ee75a58d2763f48201b20703fd49a45f1 100644
--- a/alib2data/src/exception/ExceptionToXMLComposer.h
+++ b/alib2data/src/exception/ExceptionToXMLComposer.h
@@ -8,7 +8,7 @@
 #ifndef EXCEPTION_TO_XML_COMPOSER_H_
 #define EXCEPTION_TO_XML_COMPOSER_H_
 
-#include <list>
+#include <deque>
 #include "AlibException.h"
 #include "../sax/Token.h"
 
@@ -30,7 +30,7 @@ class ExceptionToXMLComposer {
 	 * @param string Exception to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const AlibException& exception) const;
+	void compose(std::deque<sax::Token>& out, const AlibException& exception) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/factory/XmlDataFactory.hpp b/alib2data/src/factory/XmlDataFactory.hpp
index ce15081d4ef69f0ff988129ee1ec14372f5111ce..d82d0e8b9b5903da1812bf0632651c39c131926f 100644
--- a/alib2data/src/factory/XmlDataFactory.hpp
+++ b/alib2data/src/factory/XmlDataFactory.hpp
@@ -9,7 +9,7 @@
 #define DATA_FACTORY_H_
 
 #include <string>
-#include <list>
+#include <deque>
 
 #include "../sax/Token.h"
 #include "../sax/SaxParseInterface.h"
@@ -30,7 +30,7 @@ public:
 	 */
 	template<class T>
 	static T fromFile(const std::string& filename) {
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		sax::SaxParseInterface::parseFile(filename, tokens);
 		return fromTokens<T>(tokens);
 	}
@@ -42,7 +42,7 @@ public:
 	 */
 	template<class T>
 	static T fromString(const std::string& str) {
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		sax::SaxParseInterface::parseMemory(str, tokens);
 		return fromTokens<T>(tokens);
 	}
@@ -53,7 +53,7 @@ public:
 	 */
 	template<class T>
 	static T fromStdin() {
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		sax::SaxParseInterface::parseStdin(tokens);
 		return fromTokens<T>(tokens);
 	}
@@ -64,7 +64,7 @@ public:
 	 */
 	template<class T>
 	static T fromStream(std::istream& in) {
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		sax::SaxParseInterface::parseStream(in, tokens);
 		return fromTokens<T>(tokens);
 	}
@@ -75,7 +75,7 @@ public:
 	 * @return parsed String
 	 */
 	template<class T>
-	static T fromTokens(std::list<sax::Token>& tokens) {
+	static T fromTokens(std::deque<sax::Token>& tokens) {
 		if(tokens.size() == 0) throw exception::AlibException("Empty tokens list");
 
 		if(alib::xmlApi<exception::AlibException>::first(tokens)) throw alib::xmlApi<exception::AlibException>::parse(tokens);
@@ -91,7 +91,7 @@ public:
 	 * @return bool
 	 */
 	template<class T>
-	static bool first(const std::list<sax::Token>& tokens) {
+	static bool first(const std::deque<sax::Token>& tokens) {
 		return alib::xmlApi<exception::AlibException>::first(tokens) || alib::xmlApi<T>::first(tokens);
 	}
 
@@ -102,7 +102,7 @@ public:
 	 */
 	template<class T>
 	static void toFile(const T& data, const std::string& filename) {
-		std::list<sax::Token> tokens = toTokens<T>(data);
+		std::deque<sax::Token> tokens = toTokens<T>(data);
 		sax::SaxComposeInterface::printFile(filename, tokens);
 	}
 
@@ -113,7 +113,7 @@ public:
 	 */
 	template<class T>
 	static std::string toString(const T& data) {
-		std::list<sax::Token> tokens = toTokens<T>(data);
+		std::deque<sax::Token> tokens = toTokens<T>(data);
 		std::string str;
 		sax::SaxComposeInterface::printMemory(str, tokens);
 		return str;
@@ -125,7 +125,7 @@ public:
 	 */
 	template<class T>
 	static void toStdout(const T& data) {
-		std::list<sax::Token> tokens = toTokens<T>(data);
+		std::deque<sax::Token> tokens = toTokens<T>(data);
 		sax::SaxComposeInterface::printStdout(tokens);
 	}
 	
@@ -135,7 +135,7 @@ public:
 	 */
 	template<class T>
 	static void toStream(const T& data, std::ostream& out) {
-		std::list<sax::Token> tokens = toTokens<T>(data);
+		std::deque<sax::Token> tokens = toTokens<T>(data);
 		sax::SaxComposeInterface::printStream(out, tokens);
 	}
 
@@ -145,8 +145,8 @@ public:
 	 * @return parsed String
 	 */
 	template<class T>
-	static std::list<sax::Token> toTokens(const T& data) {
-		std::list<sax::Token> res;
+	static std::deque<sax::Token> toTokens(const T& data) {
+		std::deque<sax::Token> res;
 		alib::xmlApi<T>::compose(res, data);
 		return res;
 	}
@@ -154,12 +154,12 @@ public:
 };
 
 template<>
-inline bool XmlDataFactory::first<exception::AlibException>(const std::list<sax::Token>& tokens) {
+inline bool XmlDataFactory::first<exception::AlibException>(const std::deque<sax::Token>& tokens) {
 	return alib::xmlApi<exception::AlibException>::first(tokens);
 }
 
 template<>
-inline exception::AlibException XmlDataFactory::fromTokens<exception::AlibException>(std::list<sax::Token>& tokens) {
+inline exception::AlibException XmlDataFactory::fromTokens<exception::AlibException>(std::deque<sax::Token>& tokens) {
 	if(tokens.size() == 0) throw exception::AlibException("Empty tokens list");
 
 	exception::AlibException res = alib::xmlApi<exception::AlibException>::parse(tokens);
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.cpp b/alib2data/src/grammar/GrammarFromXMLParser.cpp
index 9b8e12b75bfe7f19a715c47e7f8a0e494bf67bc9..b936cc22f7b57d102063a0f9ddf02dff3b9e388f 100644
--- a/alib2data/src/grammar/GrammarFromXMLParser.cpp
+++ b/alib2data/src/grammar/GrammarFromXMLParser.cpp
@@ -14,11 +14,11 @@
 
 namespace grammar {
 
-Grammar GrammarFromXMLParser::parseGrammar(std::list<sax::Token> &input) const {
+Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token> &input) const {
 	return parseGrammar(input, std::set<FEATURES>({FEATURES::LEFT_LG, FEATURES::LEFT_RG, FEATURES::RIGHT_LG, FEATURES::RIGHT_RG, FEATURES::LG, FEATURES::CFG, FEATURES::EPSILON_FREE_CFG, FEATURES::CNF, FEATURES::GNF, FEATURES::CSG, FEATURES::NON_CONTRACTING_GRAMMAR, FEATURES::CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, FEATURES::UNRESTRICTED_GRAMMAR}));
 }
 
-Grammar GrammarFromXMLParser::parseGrammar(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<UnrestrictedGrammar>::first(input)) {
 		if(!features.count(FEATURES::UNRESTRICTED_GRAMMAR)) throw exception::AlibException();
 		return Grammar(parseUnrestrictedGrammar(input));
@@ -62,7 +62,7 @@ Grammar GrammarFromXMLParser::parseGrammar(std::list<sax::Token>& input, const s
 		throw sax::ParserException(sax::Token("Grammar / UnrestrictedGrammar", sax::Token::TokenType::START_ELEMENT), input.front());
 }
 
-bool GrammarFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool GrammarFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<UnrestrictedGrammar>::first(input) || alib::xmlApi<ContextPreservingUnrestrictedGrammar>::first(input) || alib::xmlApi<NonContractingGrammar>::first(input) || alib::xmlApi<CSG>::first(input) || alib::xmlApi<GNF>::first(input) || alib::xmlApi<CNF>::first(input) || alib::xmlApi<EpsilonFreeCFG>::first(input) || alib::xmlApi<CFG>::first(input) || alib::xmlApi<LG>::first(input) || alib::xmlApi<RightRG>::first(input) || alib::xmlApi<RightLG>::first(input) || alib::xmlApi<LeftLG>::first(input) || alib::xmlApi<LeftRG>::first(input)) {
 		return true;
 	} else {
@@ -70,7 +70,7 @@ bool GrammarFromXMLParser::first(const std::list<sax::Token>& input) const {
 	}
 }
 
-UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::list<sax::Token>& input) const {
+UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -87,7 +87,7 @@ UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::list<sax
 	return grammar;
 }
 
-ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservingUnrestrictedGrammar(std::list<sax::Token>& input) const {
+ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservingUnrestrictedGrammar(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -104,7 +104,7 @@ ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservin
 	return grammar;
 }
 
-NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::list<sax::Token>& input) const {
+NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -124,7 +124,7 @@ NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::list
 	return grammar;
 }
 
-CSG GrammarFromXMLParser::parseCSG(std::list<sax::Token>& input) const {
+CSG GrammarFromXMLParser::parseCSG(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CSG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -144,7 +144,7 @@ CSG GrammarFromXMLParser::parseCSG(std::list<sax::Token>& input) const {
 	return grammar;
 }
 
-GNF GrammarFromXMLParser::parseGNF(std::list<sax::Token>& input) const {
+GNF GrammarFromXMLParser::parseGNF(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_GNF);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -164,7 +164,7 @@ GNF GrammarFromXMLParser::parseGNF(std::list<sax::Token>& input) const {
 	return grammar;
 }
 
-CNF GrammarFromXMLParser::parseCNF(std::list<sax::Token>& input) const {
+CNF GrammarFromXMLParser::parseCNF(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CNF);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -184,7 +184,7 @@ CNF GrammarFromXMLParser::parseCNF(std::list<sax::Token>& input) const {
 	return grammar;
 }
 
-EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::list<sax::Token>& input) const {
+EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_EPSILON_FREE_CFG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -204,7 +204,7 @@ EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::list<sax::Token>&
 	return grammar;
 }
 
-CFG GrammarFromXMLParser::parseCFG(std::list<sax::Token>& input) const {
+CFG GrammarFromXMLParser::parseCFG(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CFG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -221,7 +221,7 @@ CFG GrammarFromXMLParser::parseCFG(std::list<sax::Token>& input) const {
 	return grammar;
 }
 
-LG GrammarFromXMLParser::parseLG(std::list<sax::Token>& input) const {
+LG GrammarFromXMLParser::parseLG(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -238,7 +238,7 @@ LG GrammarFromXMLParser::parseLG(std::list<sax::Token>& input) const {
 	return grammar;
 }
 
-RightRG GrammarFromXMLParser::parseRightRG(std::list<sax::Token>& input) const {
+RightRG GrammarFromXMLParser::parseRightRG(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_RIGHT_RG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -258,7 +258,7 @@ RightRG GrammarFromXMLParser::parseRightRG(std::list<sax::Token>& input) const {
 	return grammar;
 }
 
-RightLG GrammarFromXMLParser::parseRightLG(std::list<sax::Token>& input) const {
+RightLG GrammarFromXMLParser::parseRightLG(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_RIGHT_LG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -275,7 +275,7 @@ RightLG GrammarFromXMLParser::parseRightLG(std::list<sax::Token>& input) const {
 	return grammar;
 }
 
-LeftRG GrammarFromXMLParser::parseLeftRG(std::list<sax::Token>& input) const {
+LeftRG GrammarFromXMLParser::parseLeftRG(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LEFT_RG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -295,7 +295,7 @@ LeftRG GrammarFromXMLParser::parseLeftRG(std::list<sax::Token>& input) const {
 	return grammar;
 }
 
-LeftLG GrammarFromXMLParser::parseLeftLG(std::list<sax::Token>& input) const {
+LeftLG GrammarFromXMLParser::parseLeftLG(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LEFT_LG);
 
 	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
@@ -313,7 +313,7 @@ LeftLG GrammarFromXMLParser::parseLeftLG(std::list<sax::Token>& input) const {
 }
 
 
-std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "nonterminalAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -323,7 +323,7 @@ std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::l
 	return inputSymbols;
 }
 
-std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "terminalAlphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -333,14 +333,14 @@ std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::list
 	return inputSymbols;
 }
 
-alphabet::Symbol GrammarFromXMLParser::parseInitialSymbol(std::list<sax::Token>& input) const {
+alphabet::Symbol GrammarFromXMLParser::parseInitialSymbol(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialSymbol");
 	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialSymbol");
 	return blank;
 }
 
-bool GrammarFromXMLParser::parseGeneratesEpsilon(std::list<sax::Token>& input) const {
+bool GrammarFromXMLParser::parseGeneratesEpsilon(std::deque<sax::Token>& input) const {
 	bool generatesEpsilon;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "generatesEpsilon");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "true")) {
@@ -357,7 +357,7 @@ bool GrammarFromXMLParser::parseGeneratesEpsilon(std::list<sax::Token>& input) c
 }
 
 template<class T>
-void GrammarFromXMLParser::parseRules(std::list<sax::Token> &input, T& grammar) const {
+void GrammarFromXMLParser::parseRules(std::deque<sax::Token> &input, T& grammar) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rules");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "rule");
@@ -367,13 +367,13 @@ void GrammarFromXMLParser::parseRules(std::list<sax::Token> &input, T& grammar)
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "rules");
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, UnrestrictedGrammar& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, UnrestrictedGrammar& grammar) const {
 	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const {
 	std::vector<alphabet::Symbol> lContext = parseRuleLContext(input);
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
@@ -381,13 +381,13 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreser
 	grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, NonContractingGrammar& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, NonContractingGrammar& grammar) const {
 	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, CSG& grammar) const {
 	std::vector<alphabet::Symbol> lContext = parseRuleLContext(input);
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
@@ -395,62 +395,62 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar)
 	grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, GNF& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, GNF& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> rhs = parseRuleGNFRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CNF& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, CNF& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, EpsilonFreeCFG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, EpsilonFreeCFG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CFG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, CFG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, LG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightRG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, RightRG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightLG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, RightLG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftRG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, LeftRG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
 	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftLG& grammar) const {
+void GrammarFromXMLParser::parseRule(std::deque<sax::Token>& input, LeftLG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
 	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
 
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::list<sax::Token>& input) const {
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::deque<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> lContext;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "lContext");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -463,7 +463,7 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::list<
 	return lContext;
 }
 
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::list<sax::Token>& input) const {
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::deque<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> lhs;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -476,14 +476,14 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::list<sax::
 	return lhs;
 }
 
-alphabet::Symbol GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::list<sax::Token>& input) const {
+alphabet::Symbol GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
 	alphabet::Symbol lhs = alib::xmlApi<alphabet::Symbol>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
 	return lhs;
 }
 
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::list<sax::Token>& input) const {
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::deque<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> rContext;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rContext");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -496,7 +496,7 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::list<
 	return rContext;
 }
 
-std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser::parseRuleGNFRHS(std::list<sax::Token>& input) const {
+std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser::parseRuleGNFRHS(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
 	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
 	std::vector<alphabet::Symbol> second;
@@ -507,7 +507,7 @@ std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser:
 	return std::make_pair(std::move(first), std::move(second));
 }
 
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::list<sax::Token>& input) const {
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::deque<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> rhs;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -520,7 +520,7 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::list<sax::
 	return rhs;
 }
 
-std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::list<sax::Token>& input) const {
+std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
 	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
 	if(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.h b/alib2data/src/grammar/GrammarFromXMLParser.h
index b900ef188b0ad3adca915aff110cc002ac0cfbe2..44ffacb3b9820f806bde2cf8d811c208b97885bc 100644
--- a/alib2data/src/grammar/GrammarFromXMLParser.h
+++ b/alib2data/src/grammar/GrammarFromXMLParser.h
@@ -25,7 +25,7 @@
 #include "Unrestricted/ContextPreservingUnrestrictedGrammar.h"
 #include "Unrestricted/UnrestrictedGrammar.h"
 
-#include <list>
+#include <deque>
 #include <set>
 #include "../std/variant.hpp"
 #include "../sax/Token.h"
@@ -43,56 +43,56 @@ namespace grammar {
  * Parser used to get general FSM or EpsilonNFA, NFA, DFA from XML parsed into list of Tokens.
  */
 class GrammarFromXMLParser : public sax::FromXMLParserHelper {
-	std::set<alphabet::Symbol> parseNonterminalAlphabet(std::list<sax::Token> &input) const;
-	std::set<alphabet::Symbol> parseTerminalAlphabet(std::list<sax::Token> &input) const;
-	alphabet::Symbol parseInitialSymbol(std::list<sax::Token> &input) const;
-	bool parseGeneratesEpsilon(std::list<sax::Token> &input) const;
-
-	std::vector<alphabet::Symbol> parseRuleLContext(std::list<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseRuleLHS(std::list<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseRuleRContext(std::list<sax::Token>& input) const;
-	alphabet::Symbol parseRuleSingleSymbolLHS(std::list<sax::Token>& input) const;
-	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> parseRuleGNFRHS(std::list<sax::Token>& input) const;
-	std::vector<alphabet::Symbol> parseRuleRHS(std::list<sax::Token>& input) const;
-	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> parseRuleOneOrTwoSymbolsRHS(std::list<sax::Token>& input) const;
+	std::set<alphabet::Symbol> parseNonterminalAlphabet(std::deque<sax::Token> &input) const;
+	std::set<alphabet::Symbol> parseTerminalAlphabet(std::deque<sax::Token> &input) const;
+	alphabet::Symbol parseInitialSymbol(std::deque<sax::Token> &input) const;
+	bool parseGeneratesEpsilon(std::deque<sax::Token> &input) const;
+
+	std::vector<alphabet::Symbol> parseRuleLContext(std::deque<sax::Token>& input) const;
+	std::vector<alphabet::Symbol> parseRuleLHS(std::deque<sax::Token>& input) const;
+	std::vector<alphabet::Symbol> parseRuleRContext(std::deque<sax::Token>& input) const;
+	alphabet::Symbol parseRuleSingleSymbolLHS(std::deque<sax::Token>& input) const;
+	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> parseRuleGNFRHS(std::deque<sax::Token>& input) const;
+	std::vector<alphabet::Symbol> parseRuleRHS(std::deque<sax::Token>& input) const;
+	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& input) const;
 
 	template<class T>
-	void parseRules(std::list<sax::Token> &input, T& grammar) const;
-
-	void parseRule(std::list<sax::Token>& input, UnrestrictedGrammar& grammar) const;
-	void parseRule(std::list<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const;
-	void parseRule(std::list<sax::Token>& input, NonContractingGrammar& grammar) const;
-	void parseRule(std::list<sax::Token>& input, CSG& grammar) const;
-	void parseRule(std::list<sax::Token>& input, GNF& grammar) const;
-	void parseRule(std::list<sax::Token>& input, CNF& grammar) const;
-	void parseRule(std::list<sax::Token>& input, EpsilonFreeCFG& grammar) const;
-	void parseRule(std::list<sax::Token>& input, CFG& grammar) const;
-	void parseRule(std::list<sax::Token>& input, LG& grammar) const;
-	void parseRule(std::list<sax::Token>& input, RightRG& grammar) const;
-	void parseRule(std::list<sax::Token>& input, RightLG& grammar) const;
-	void parseRule(std::list<sax::Token>& input, LeftRG& grammar) const;
-	void parseRule(std::list<sax::Token>& input, LeftLG& grammar) const;
-
-	Grammar parseGrammar(std::list<sax::Token>& input) const;
-	Grammar parseGrammar(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
-
-	UnrestrictedGrammar parseUnrestrictedGrammar(std::list<sax::Token>& input) const;
-	ContextPreservingUnrestrictedGrammar parseContextPreservingUnrestrictedGrammar(std::list<sax::Token>& input) const;
-	NonContractingGrammar parseNonContractingGrammar(std::list<sax::Token>& input) const;
-	CSG parseCSG(std::list<sax::Token>& input) const;
-	GNF parseGNF(std::list<sax::Token>& input) const;
-	CNF parseCNF(std::list<sax::Token>& input) const;
-	EpsilonFreeCFG parseEpsilonFreeCFG(std::list<sax::Token>& input) const;
-	CFG parseCFG(std::list<sax::Token>& input) const;
-	LG parseLG(std::list<sax::Token>& input) const;
-	RightRG parseRightRG(std::list<sax::Token>& input) const;
-	RightLG parseRightLG(std::list<sax::Token>& input) const;
-	LeftRG parseLeftRG(std::list<sax::Token>& input) const;
-	LeftLG parseLeftLG(std::list<sax::Token>& input) const;
+	void parseRules(std::deque<sax::Token> &input, T& grammar) const;
+
+	void parseRule(std::deque<sax::Token>& input, UnrestrictedGrammar& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, NonContractingGrammar& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, CSG& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, GNF& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, CNF& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, EpsilonFreeCFG& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, CFG& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, LG& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, RightRG& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, RightLG& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, LeftRG& grammar) const;
+	void parseRule(std::deque<sax::Token>& input, LeftLG& grammar) const;
+
+	Grammar parseGrammar(std::deque<sax::Token>& input) const;
+	Grammar parseGrammar(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
+
+	UnrestrictedGrammar parseUnrestrictedGrammar(std::deque<sax::Token>& input) const;
+	ContextPreservingUnrestrictedGrammar parseContextPreservingUnrestrictedGrammar(std::deque<sax::Token>& input) const;
+	NonContractingGrammar parseNonContractingGrammar(std::deque<sax::Token>& input) const;
+	CSG parseCSG(std::deque<sax::Token>& input) const;
+	GNF parseGNF(std::deque<sax::Token>& input) const;
+	CNF parseCNF(std::deque<sax::Token>& input) const;
+	EpsilonFreeCFG parseEpsilonFreeCFG(std::deque<sax::Token>& input) const;
+	CFG parseCFG(std::deque<sax::Token>& input) const;
+	LG parseLG(std::deque<sax::Token>& input) const;
+	RightRG parseRightRG(std::deque<sax::Token>& input) const;
+	RightLG parseRightLG(std::deque<sax::Token>& input) const;
+	LeftRG parseLeftRG(std::deque<sax::Token>& input) const;
+	LeftLG parseLeftLG(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/GrammarToXMLComposer.cpp b/alib2data/src/grammar/GrammarToXMLComposer.cpp
index 0eab80b1bc0c334be3a2cd7232bd40216f3c639d..8fa4f35f27859c793eb542bd288ae7292a1de139 100644
--- a/alib2data/src/grammar/GrammarToXMLComposer.cpp
+++ b/alib2data/src/grammar/GrammarToXMLComposer.cpp
@@ -12,15 +12,15 @@
 
 namespace grammar {
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const GrammarBase& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const GrammarBase& grammar) const {
 	grammar.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const Grammar& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const Grammar& grammar) const {
 	grammar.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const LeftLG& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LeftLG& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -31,7 +31,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const LeftLG& gra
 	out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const LeftRG& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LeftRG& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -43,7 +43,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const LeftRG& gra
 	out.push_back(sax::Token(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const RightLG& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const RightLG& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -54,7 +54,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const RightLG& gr
 	out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const RightRG& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const RightRG& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -66,7 +66,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const RightRG& gr
 	out.push_back(sax::Token(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const LG& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LG& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_LG, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -77,7 +77,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const LG& grammar
 	out.push_back(sax::Token(alib::Names::GRAMMAR_LG, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const CFG& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CFG& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -88,7 +88,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const CFG& gramma
 	out.push_back(sax::Token(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const EpsilonFreeCFG& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -100,7 +100,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const EpsilonFree
 	out.push_back(sax::Token(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const CNF& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CNF& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -112,7 +112,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const CNF& gramma
 	out.push_back(sax::Token(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const GNF& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const GNF& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -124,7 +124,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const GNF& gramma
 	out.push_back(sax::Token(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const CSG& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CSG& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -136,7 +136,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const CSG& gramma
 	out.push_back(sax::Token(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const NonContractingGrammar& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -148,7 +148,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const NonContract
 	out.push_back(sax::Token(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -159,7 +159,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const ContextPres
 	out.push_back(sax::Token(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const UnrestrictedGrammar& grammar) const {
+void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const {
 	out.push_back(sax::Token(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT));
 
 	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
@@ -170,7 +170,7 @@ void GrammarToXMLComposer::compose(std::list<sax::Token>& out, const Unrestricte
 	out.push_back(sax::Token(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeNonterminalAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void GrammarToXMLComposer::composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("nonterminalAlphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -178,7 +178,7 @@ void GrammarToXMLComposer::composeNonterminalAlphabet(std::list<sax::Token>& out
 	out.push_back(sax::Token("nonterminalAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeTerminalAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
+void GrammarToXMLComposer::composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("terminalAlphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol : symbols) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
@@ -186,13 +186,13 @@ void GrammarToXMLComposer::composeTerminalAlphabet(std::list<sax::Token>& out, c
 	out.push_back(sax::Token("terminalAlphabet", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeInitialSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void GrammarToXMLComposer::composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("initialSymbol", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("initialSymbol", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeGeneratesEpsilon(std::list<sax::Token>& out, bool generatesEpsilon) const {
+void GrammarToXMLComposer::composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon) const {
 	out.push_back(sax::Token("generatesEpsilon", sax::Token::TokenType::START_ELEMENT));
 	if(generatesEpsilon) {
 		out.push_back(sax::Token("true", sax::Token::TokenType::START_ELEMENT));
@@ -205,7 +205,7 @@ void GrammarToXMLComposer::composeGeneratesEpsilon(std::list<sax::Token>& out, b
 }
 
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const UnrestrictedGrammar& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -222,7 +222,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const Unrest
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -241,7 +241,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const Contex
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const NonContractingGrammar& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -258,7 +258,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const NonCon
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const CSG& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CSG& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -277,7 +277,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const CSG& g
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const GNF& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const GNF& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -294,7 +294,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const GNF& g
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const CNF& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CNF& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -311,7 +311,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const CNF& g
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const EpsilonFreeCFG& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -328,7 +328,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const Epsilo
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const CFG& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CFG& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -345,7 +345,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const CFG& g
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const LG& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LG& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -362,7 +362,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const LG& gr
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const RightLG& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const RightLG& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -379,7 +379,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const RightL
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const RightRG& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const RightRG& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -396,7 +396,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const RightR
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const LeftLG& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LeftLG& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -413,7 +413,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const LeftLG
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const LeftRG& grammar) const {
+void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LeftRG& grammar) const {
 	out.push_back(sax::Token("rules", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& rule : grammar.getRules()) {
 
@@ -430,7 +430,7 @@ void GrammarToXMLComposer::composeRules(std::list<sax::Token>& out, const LeftRG
 	out.push_back(sax::Token("rules", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleLContext(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
+void GrammarToXMLComposer::composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("lContext", sax::Token::TokenType::START_ELEMENT));
 	if(symbols.size() == 0) {
 		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
@@ -441,7 +441,7 @@ void GrammarToXMLComposer::composeRuleLContext(std::list<sax::Token>& out, const
 	out.push_back(sax::Token("lContext", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleLHS(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
+void GrammarToXMLComposer::composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("lhs", sax::Token::TokenType::START_ELEMENT));
 	if(symbols.size() == 0) {
 		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
@@ -452,7 +452,7 @@ void GrammarToXMLComposer::composeRuleLHS(std::list<sax::Token>& out, const std:
 	out.push_back(sax::Token("lhs", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleRContext(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
+void GrammarToXMLComposer::composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("rContext", sax::Token::TokenType::START_ELEMENT));
 	if(symbols.size() == 0) {
 		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
@@ -463,13 +463,13 @@ void GrammarToXMLComposer::composeRuleRContext(std::list<sax::Token>& out, const
 	out.push_back(sax::Token("rContext", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleSingleSymbolLHS(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const {
+void GrammarToXMLComposer::composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
 	out.push_back(sax::Token("lhs", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
 	out.push_back(sax::Token("lhs", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleRHS(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
+void GrammarToXMLComposer::composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
 	if(symbols.size() == 0) {
 		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
@@ -480,7 +480,7 @@ void GrammarToXMLComposer::composeRuleRHS(std::list<sax::Token>& out, const std:
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::list<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) const {
+void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) const {
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
 	if(symbols.is<alphabet::Symbol>()) {
 		alib::xmlApi<alphabet::Symbol>::compose(out, symbols.get<alphabet::Symbol>());
@@ -492,7 +492,7 @@ void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::list<sax::Token>&
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleGNFRHS(std::list<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) const {
+void GrammarToXMLComposer::composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) const {
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
 
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbols.first);
@@ -504,7 +504,7 @@ void GrammarToXMLComposer::composeRuleGNFRHS(std::list<sax::Token>& out, const s
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleLGRHS(std::list<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const {
+void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const {
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
 	if(symbols.is<std::vector<alphabet::Symbol>>()) {
 		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
@@ -527,7 +527,7 @@ void GrammarToXMLComposer::composeRuleLGRHS(std::list<sax::Token>& out, const st
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleLeftLGRHS(std::list<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const {
+void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const {
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
 	if(symbols.is<std::vector<alphabet::Symbol>>()) {
 		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
@@ -547,7 +547,7 @@ void GrammarToXMLComposer::composeRuleLeftLGRHS(std::list<sax::Token>& out, cons
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GrammarToXMLComposer::composeRuleRightLGRHS(std::list<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) const {
+void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) const {
 	out.push_back(sax::Token("rhs", sax::Token::TokenType::START_ELEMENT));
 	if(symbols.is<std::vector<alphabet::Symbol>>()) {
 		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
diff --git a/alib2data/src/grammar/GrammarToXMLComposer.h b/alib2data/src/grammar/GrammarToXMLComposer.h
index c25421bb99a4ca1a07f736614378b26559eebb8a..02ed0798a81ec427a43ac37539538e380ee08720 100644
--- a/alib2data/src/grammar/GrammarToXMLComposer.h
+++ b/alib2data/src/grammar/GrammarToXMLComposer.h
@@ -9,7 +9,7 @@
 #define GRAMMAR_TO_XML_COMPOSER_H_
 
 #include <string>
-#include <list>
+#include <deque>
 #include "Grammar.h"
 #include "Regular/LeftLG.h"
 #include "Regular/LeftRG.h"
@@ -39,58 +39,58 @@ namespace grammar {
  * This class contains methods to print XML representation of automata to the output stream.
  */
 class GrammarToXMLComposer {
-	void composeNonterminalAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const;
-	void composeTerminalAlphabet(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const;
-	void composeInitialSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const;
-	void composeGeneratesEpsilon(std::list<sax::Token>& out, bool generatesEpsilon) const;
+	void composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const;
+	void composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const;
+	void composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const;
+	void composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon) const;
 	
-	void composeRules(std::list<sax::Token>& out, const UnrestrictedGrammar& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const NonContractingGrammar& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const CSG& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const GNF& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const CNF& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const EpsilonFreeCFG& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const CFG& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const LG& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const LeftLG& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const LeftRG& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const RightLG& grammar) const;
-	void composeRules(std::list<sax::Token>& out, const RightRG& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const CSG& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const GNF& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const CNF& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const CFG& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const LG& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const LeftLG& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const LeftRG& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const RightLG& grammar) const;
+	void composeRules(std::deque<sax::Token>& out, const RightRG& grammar) const;
 
-	void composeRuleLContext(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeRuleLHS(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeRuleRContext(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeRuleSingleSymbolLHS(std::list<sax::Token>& out, const alphabet::Symbol& symbol) const;
-	void composeRuleRHS(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeRuleOneOrTwoSymbolsRHS(std::list<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) const;
-	void composeRuleGNFRHS(std::list<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) const;
-	void composeRuleLeftLGRHS(std::list<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const;
-	void composeRuleRightLGRHS(std::list<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) const;
-	void composeRuleLGRHS(std::list<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const;
+	void composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
+	void composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
+	void composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
+	void composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const;
+	void composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
+	void composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) const;
+	void composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) const;
+	void composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const;
+	void composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) const;
+	void composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const;
 	
 	/**
 	 * Prints XML representation of Grammar to the output stream.
 	 * @param grammar grammar to print
 	 * @return list of xml tokens representing the grammar
 	 */
-	void compose(std::list<sax::Token>& out, const GrammarBase& grammar) const;
+	void compose(std::deque<sax::Token>& out, const GrammarBase& grammar) const;
 
-	void compose(std::list<sax::Token>& out, const Grammar& grammar) const;
+	void compose(std::deque<sax::Token>& out, const Grammar& grammar) const;
 
-	void compose(std::list<sax::Token>& out, const LeftLG& grammar) const;
-	void compose(std::list<sax::Token>& out, const LeftRG& grammar) const;
-	void compose(std::list<sax::Token>& out, const RightLG& grammar) const;
-	void compose(std::list<sax::Token>& out, const RightRG& grammar) const;
-	void compose(std::list<sax::Token>& out, const LG& grammar) const;
-	void compose(std::list<sax::Token>& out, const CFG& grammar) const;
-	void compose(std::list<sax::Token>& out, const EpsilonFreeCFG& grammar) const;
-	void compose(std::list<sax::Token>& out, const CNF& grammar) const;
-	void compose(std::list<sax::Token>& out, const GNF& grammar) const;
-	void compose(std::list<sax::Token>& out, const CSG& grammar) const;
-	void compose(std::list<sax::Token>& out, const NonContractingGrammar& grammar) const;
-	void compose(std::list<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const;
-	void compose(std::list<sax::Token>& out, const UnrestrictedGrammar& grammar) const;
+	void compose(std::deque<sax::Token>& out, const LeftLG& grammar) const;
+	void compose(std::deque<sax::Token>& out, const LeftRG& grammar) const;
+	void compose(std::deque<sax::Token>& out, const RightLG& grammar) const;
+	void compose(std::deque<sax::Token>& out, const RightRG& grammar) const;
+	void compose(std::deque<sax::Token>& out, const LG& grammar) const;
+	void compose(std::deque<sax::Token>& out, const CFG& grammar) const;
+	void compose(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const;
+	void compose(std::deque<sax::Token>& out, const CNF& grammar) const;
+	void compose(std::deque<sax::Token>& out, const GNF& grammar) const;
+	void compose(std::deque<sax::Token>& out, const CSG& grammar) const;
+	void compose(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const;
+	void compose(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const;
+	void compose(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/graph/GraphFromXMLParser.cpp b/alib2data/src/graph/GraphFromXMLParser.cpp
index b130e988f95f99bf380b4d8e40d65afbcfe005b7..c7ab41870e37526e15d83e3f46ef5326c35c77d7 100644
--- a/alib2data/src/graph/GraphFromXMLParser.cpp
+++ b/alib2data/src/graph/GraphFromXMLParser.cpp
@@ -5,7 +5,7 @@
 
 namespace graph {
 
-bool GraphFromXMLParser::first(const std::list<sax::Token> &input) const
+bool GraphFromXMLParser::first(const std::deque<sax::Token> &input) const
 {
 	if (alib::xmlApi<DirectedGraph>::first(input)) {
 		return true;
@@ -14,7 +14,7 @@ bool GraphFromXMLParser::first(const std::list<sax::Token> &input) const
 	return false;
 }
 
-Graph GraphFromXMLParser::parseGraph(std::list<sax::Token> &input) const
+Graph GraphFromXMLParser::parseGraph(std::deque<sax::Token> &input) const
 {
 	if (alib::xmlApi<DirectedGraph>::first(input)) {
 		return Graph(parseDirectedGraph(input));
@@ -25,7 +25,7 @@ Graph GraphFromXMLParser::parseGraph(std::list<sax::Token> &input) const
 	throw exception::AlibException();
 }
 
-DirectedGraph GraphFromXMLParser::parseDirectedGraph(std::list<sax::Token> &input) const
+DirectedGraph GraphFromXMLParser::parseDirectedGraph(std::deque<sax::Token> &input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAPH_DIRECTED_GRAPH);
 
@@ -39,7 +39,7 @@ DirectedGraph GraphFromXMLParser::parseDirectedGraph(std::list<sax::Token> &inpu
 	return graph;
 }
 
-UndirectedGraph GraphFromXMLParser::parseUndirectedGraph(std::list<sax::Token> &input) const
+UndirectedGraph GraphFromXMLParser::parseUndirectedGraph(std::deque<sax::Token> &input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAPH_UNDIRECTED_GRAPH);
 
@@ -53,7 +53,7 @@ UndirectedGraph GraphFromXMLParser::parseUndirectedGraph(std::list<sax::Token> &
 	return graph;
 }
 
-REPRESENTATION GraphFromXMLParser::parseRepresentation(std::list<sax::Token> &input) const
+REPRESENTATION GraphFromXMLParser::parseRepresentation(std::deque<sax::Token> &input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "representation");
 
@@ -63,7 +63,7 @@ REPRESENTATION GraphFromXMLParser::parseRepresentation(std::list<sax::Token> &in
 	return r;
 }
 
-Node GraphFromXMLParser::parseNode(std::list<sax::Token> &input) const
+Node GraphFromXMLParser::parseNode(std::deque<sax::Token> &input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "node");
 
@@ -73,7 +73,7 @@ Node GraphFromXMLParser::parseNode(std::list<sax::Token> &input) const
 	return n;
 }
 
-DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::list<sax::Token> &input) const
+DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::deque<sax::Token> &input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edge");
 
@@ -91,7 +91,7 @@ DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::list<sax::Token> &input)
 	return DirectedEdge(std::move(from), std::move(to), std::move(name));
 }
 
-UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::list<sax::Token> &input) const
+UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::deque<sax::Token> &input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edge");
 
@@ -109,7 +109,7 @@ UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::list<sax::Token> &in
 	return UndirectedEdge(std::move(first), std::move(second), std::move(name));
 }
 
-int GraphFromXMLParser::parseValue(std::list<sax::Token> &input) const
+int GraphFromXMLParser::parseValue(std::deque<sax::Token> &input) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "value");
 
@@ -120,7 +120,7 @@ int GraphFromXMLParser::parseValue(std::list<sax::Token> &input) const
 }
 
 template<typename T>
-void GraphFromXMLParser::parseNodes(std::list<sax::Token> &input, T &graph) const
+void GraphFromXMLParser::parseNodes(std::deque<sax::Token> &input, T &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "nodes");
 
@@ -131,7 +131,7 @@ void GraphFromXMLParser::parseNodes(std::list<sax::Token> &input, T &graph) cons
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "nodes");
 }
 
-void GraphFromXMLParser::parseDirectedEdges(std::list<sax::Token> &input, DirectedGraph &graph) const
+void GraphFromXMLParser::parseDirectedEdges(std::deque<sax::Token> &input, DirectedGraph &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edges");
 
@@ -142,7 +142,7 @@ void GraphFromXMLParser::parseDirectedEdges(std::list<sax::Token> &input, Direct
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "edges");
 }
 
-void GraphFromXMLParser::parseUndirectedEdges(std::list<sax::Token> &input, UndirectedGraph &graph) const
+void GraphFromXMLParser::parseUndirectedEdges(std::deque<sax::Token> &input, UndirectedGraph &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edges");
 
@@ -154,7 +154,7 @@ void GraphFromXMLParser::parseUndirectedEdges(std::list<sax::Token> &input, Undi
 }
 
 template<typename T>
-void GraphFromXMLParser::parseNodeValues(std::list<sax::Token> &input, T &graph) const
+void GraphFromXMLParser::parseNodeValues(std::deque<sax::Token> &input, T &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "nodevalues");
 
@@ -168,7 +168,7 @@ void GraphFromXMLParser::parseNodeValues(std::list<sax::Token> &input, T &graph)
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "nodevalues");
 }
 
-void GraphFromXMLParser::parseDirectedEdgeValues(std::list<sax::Token> &input, DirectedGraph &graph) const
+void GraphFromXMLParser::parseDirectedEdgeValues(std::deque<sax::Token> &input, DirectedGraph &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edgevalues");
 
@@ -182,7 +182,7 @@ void GraphFromXMLParser::parseDirectedEdgeValues(std::list<sax::Token> &input, D
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
 }
 
-void GraphFromXMLParser::parseUndirectedEdgeValues(std::list<sax::Token> &input, UndirectedGraph &graph) const
+void GraphFromXMLParser::parseUndirectedEdgeValues(std::deque<sax::Token> &input, UndirectedGraph &graph) const
 {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "edgevalues");
 
diff --git a/alib2data/src/graph/GraphFromXMLParser.h b/alib2data/src/graph/GraphFromXMLParser.h
index 6dff7588316f8e958f8666a078a1443de3b3f096..44af1e37ac7373955f0f8bc9036280a887152fee 100644
--- a/alib2data/src/graph/GraphFromXMLParser.h
+++ b/alib2data/src/graph/GraphFromXMLParser.h
@@ -22,28 +22,28 @@ namespace graph {
 class GraphFromXMLParser : public sax::FromXMLParserHelper
 {
 public:
-	bool first(const std::list<sax::Token> &input) const;
+	bool first(const std::deque<sax::Token> &input) const;
 
 private:
-	Graph parseGraph(std::list<sax::Token> &input) const;
-	DirectedGraph parseDirectedGraph(std::list<sax::Token> &input) const;
-	UndirectedGraph parseUndirectedGraph(std::list<sax::Token> &input) const;
+	Graph parseGraph(std::deque<sax::Token> &input) const;
+	DirectedGraph parseDirectedGraph(std::deque<sax::Token> &input) const;
+	UndirectedGraph parseUndirectedGraph(std::deque<sax::Token> &input) const;
 
-	REPRESENTATION parseRepresentation(std::list<sax::Token> &input) const;
-	Node parseNode(std::list<sax::Token> &input) const;
-	DirectedEdge parseDirectedEdge(std::list<sax::Token> &input) const;
-	UndirectedEdge parseUndirectedEdge(std::list<sax::Token> &input) const;
-	int parseValue(std::list<sax::Token> &input) const;
+	REPRESENTATION parseRepresentation(std::deque<sax::Token> &input) const;
+	Node parseNode(std::deque<sax::Token> &input) const;
+	DirectedEdge parseDirectedEdge(std::deque<sax::Token> &input) const;
+	UndirectedEdge parseUndirectedEdge(std::deque<sax::Token> &input) const;
+	int parseValue(std::deque<sax::Token> &input) const;
 
 	template<typename T>
-	void parseNodes(std::list<sax::Token> &input, T &graph) const;
-	void parseDirectedEdges(std::list<sax::Token> &input, DirectedGraph &graph) const;
-	void parseUndirectedEdges(std::list<sax::Token> &input, UndirectedGraph &graph) const;
+	void parseNodes(std::deque<sax::Token> &input, T &graph) const;
+	void parseDirectedEdges(std::deque<sax::Token> &input, DirectedGraph &graph) const;
+	void parseUndirectedEdges(std::deque<sax::Token> &input, UndirectedGraph &graph) const;
 
 	template<typename T>
-	void parseNodeValues(std::list<sax::Token> &input, T &graph) const;
-	void parseDirectedEdgeValues(std::list<sax::Token> &input, DirectedGraph &graph) const;
-	void parseUndirectedEdgeValues(std::list<sax::Token> &input, UndirectedGraph &graph) const;
+	void parseNodeValues(std::deque<sax::Token> &input, T &graph) const;
+	void parseDirectedEdgeValues(std::deque<sax::Token> &input, DirectedGraph &graph) const;
+	void parseUndirectedEdgeValues(std::deque<sax::Token> &input, UndirectedGraph &graph) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/graph/GraphToXMLComposer.cpp b/alib2data/src/graph/GraphToXMLComposer.cpp
index 47b8bcde2dfd3c2ad302508e56aa7ef6d50411ed..d2ab66f617f26f1212752cf53e0c7d6f4f73f795 100644
--- a/alib2data/src/graph/GraphToXMLComposer.cpp
+++ b/alib2data/src/graph/GraphToXMLComposer.cpp
@@ -8,7 +8,7 @@ namespace graph {
 
 void GraphToXMLComposer::Visit(void *data, const Node &node) const
 {
-	std::list<sax::Token> &out = *static_cast<std::list<sax::Token>*>(data);
+	std::deque<sax::Token> &out = *static_cast<std::deque<sax::Token>*>(data);
 
 	out.push_back(sax::Token("node", sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<label::Label>::compose(out, node.getName());
@@ -17,7 +17,7 @@ void GraphToXMLComposer::Visit(void *data, const Node &node) const
 
 void GraphToXMLComposer::Visit(void *data, const DirectedEdge &edge) const
 {
-	std::list<sax::Token> &out = *static_cast<std::list<sax::Token>*>(data);
+	std::deque<sax::Token> &out = *static_cast<std::deque<sax::Token>*>(data);
 
 	out.push_back(sax::Token("edge", sax::Token::TokenType::START_ELEMENT));
 
@@ -36,7 +36,7 @@ void GraphToXMLComposer::Visit(void *data, const DirectedEdge &edge) const
 
 void GraphToXMLComposer::Visit(void *data, const UndirectedEdge &edge) const
 {
-	std::list<sax::Token> &out = *static_cast<std::list<sax::Token>*>(data);
+	std::deque<sax::Token> &out = *static_cast<std::deque<sax::Token>*>(data);
 
 	out.push_back(sax::Token("edge", sax::Token::TokenType::START_ELEMENT));
 
@@ -53,17 +53,17 @@ void GraphToXMLComposer::Visit(void *data, const UndirectedEdge &edge) const
 	out.push_back(sax::Token("edge", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GraphToXMLComposer::compose(std::list<sax::Token> &out, const GraphBase &graph) const
+void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const GraphBase &graph) const
 {
 	graph.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void GraphToXMLComposer::compose(std::list<sax::Token> &out, const Graph &graph) const
+void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const Graph &graph) const
 {
 	graph.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void GraphToXMLComposer::compose(std::list<sax::Token> &out, const DirectedGraph &graph) const
+void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const DirectedGraph &graph) const
 {
 	out.push_back(sax::Token(alib::Names::GRAPH_DIRECTED_GRAPH, sax::Token::TokenType::START_ELEMENT));
 
@@ -76,7 +76,7 @@ void GraphToXMLComposer::compose(std::list<sax::Token> &out, const DirectedGraph
 	out.push_back(sax::Token(alib::Names::GRAPH_DIRECTED_GRAPH, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GraphToXMLComposer::compose(std::list<sax::Token> &out, const UndirectedGraph &graph) const
+void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const UndirectedGraph &graph) const
 {
 	out.push_back(sax::Token(alib::Names::GRAPH_UNDIRECTED_GRAPH, sax::Token::TokenType::START_ELEMENT));
 
@@ -89,14 +89,14 @@ void GraphToXMLComposer::compose(std::list<sax::Token> &out, const UndirectedGra
 	out.push_back(sax::Token(alib::Names::GRAPH_UNDIRECTED_GRAPH, sax::Token::TokenType::END_ELEMENT));
 }
 
-void GraphToXMLComposer::composeRepresentation(std::list<sax::Token> &out, const std::string &representation) const
+void GraphToXMLComposer::composeRepresentation(std::deque<sax::Token> &out, const std::string &representation) const
 {
 	out.push_back(sax::Token("representation", sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(representation, sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token("representation", sax::Token::TokenType::END_ELEMENT));
 }
 
-void GraphToXMLComposer::composeNodes(std::list<sax::Token> &out, const std::set<Node> &nodes) const
+void GraphToXMLComposer::composeNodes(std::deque<sax::Token> &out, const std::set<Node> &nodes) const
 {
 	out.push_back(sax::Token("nodes", sax::Token::TokenType::START_ELEMENT));
 	for (const Node &node : nodes) {
@@ -106,7 +106,7 @@ void GraphToXMLComposer::composeNodes(std::list<sax::Token> &out, const std::set
 }
 
 template<typename T>
-void GraphToXMLComposer::composeEdges(std::list<sax::Token> &out, const std::set<T> &edges) const
+void GraphToXMLComposer::composeEdges(std::deque<sax::Token> &out, const std::set<T> &edges) const
 {
 	out.push_back(sax::Token("edges", sax::Token::TokenType::START_ELEMENT));
 	for (const auto &edge : edges) {
@@ -116,7 +116,7 @@ void GraphToXMLComposer::composeEdges(std::list<sax::Token> &out, const std::set
 }
 
 template<typename T>
-void GraphToXMLComposer::composeNodeValues(std::list<sax::Token> &out, const T &graph) const
+void GraphToXMLComposer::composeNodeValues(std::deque<sax::Token> &out, const T &graph) const
 {
 	out.push_back(sax::Token("nodevalues", sax::Token::TokenType::START_ELEMENT));
 	for (auto i : graph.nodeValues) {
@@ -129,7 +129,7 @@ void GraphToXMLComposer::composeNodeValues(std::list<sax::Token> &out, const T &
 }
 
 template<typename T>
-void GraphToXMLComposer::composeEdgeValues(std::list<sax::Token> &out, const T &graph) const
+void GraphToXMLComposer::composeEdgeValues(std::deque<sax::Token> &out, const T &graph) const
 {
 	out.push_back(sax::Token("edgevalues", sax::Token::TokenType::START_ELEMENT));
 	for (auto &i : graph.edgeValues) {
diff --git a/alib2data/src/graph/GraphToXMLComposer.h b/alib2data/src/graph/GraphToXMLComposer.h
index 79bd1df88259d41893bb7bb211d87c9662de1742..f1b32c46ea7b862c944ab9041733d6f5af8232fd 100644
--- a/alib2data/src/graph/GraphToXMLComposer.h
+++ b/alib2data/src/graph/GraphToXMLComposer.h
@@ -2,7 +2,7 @@
 #define GRAPH_TO_XML_COMPOSER_H_
 
 #include <set>
-#include <list>
+#include <deque>
 
 #include "Graph.h"
 #include "common/GraphElement.h"
@@ -28,21 +28,21 @@ private:
 	void Visit(void *data, const DirectedEdge &edge) const;
 	void Visit(void *data, const UndirectedEdge &edge) const;
 
-	void compose(std::list<sax::Token> &out, const GraphBase &graph) const;
-	void compose(std::list<sax::Token> &out, const Graph &graph) const;
-	void compose(std::list<sax::Token> &out, const DirectedGraph &graph) const;
-	void compose(std::list<sax::Token> &out, const UndirectedGraph &graph) const;
+	void compose(std::deque<sax::Token> &out, const GraphBase &graph) const;
+	void compose(std::deque<sax::Token> &out, const Graph &graph) const;
+	void compose(std::deque<sax::Token> &out, const DirectedGraph &graph) const;
+	void compose(std::deque<sax::Token> &out, const UndirectedGraph &graph) const;
 
-	void composeRepresentation(std::list<sax::Token> &out, const std::string &representation) const;
-	void composeNodes(std::list<sax::Token> &out, const std::set<Node> &nodes) const;
+	void composeRepresentation(std::deque<sax::Token> &out, const std::string &representation) const;
+	void composeNodes(std::deque<sax::Token> &out, const std::set<Node> &nodes) const;
 
 	template<typename T>
-	void composeEdges(std::list<sax::Token> &out, const std::set<T> &edges) const;
+	void composeEdges(std::deque<sax::Token> &out, const std::set<T> &edges) const;
 
 	template<typename T>
-	void composeNodeValues(std::list<sax::Token> &out, const T &graph) const;
+	void composeNodeValues(std::deque<sax::Token> &out, const T &graph) const;
 	template<typename T>
-	void composeEdgeValues(std::list<sax::Token> &out, const T &graph) const;
+	void composeEdgeValues(std::deque<sax::Token> &out, const T &graph) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/label/LabelFromXMLParser.cpp b/alib2data/src/label/LabelFromXMLParser.cpp
index 9cfbbcc1699e661ff0ff77b5d137f9d307ada0a4..f3e3e61566447d3b423b41d3b37d6e03cce127ff 100644
--- a/alib2data/src/label/LabelFromXMLParser.cpp
+++ b/alib2data/src/label/LabelFromXMLParser.cpp
@@ -12,11 +12,11 @@
 
 namespace label {
 
-Label LabelFromXMLParser::parseLabel(std::list<sax::Token>& input) const {
+Label LabelFromXMLParser::parseLabel(std::deque<sax::Token>& input) const {
 	return parseLabel(input, std::set<FEATURES>({FEATURES::PRIMITIVE, FEATURES::HEXAVIGESIMAL, FEATURES::OBJECT, FEATURES::LABEL_SET, FEATURES::LABEL_PAIR, FEATURES::UNIQUE_LABEL}));
 }
 
-Label LabelFromXMLParser::parseLabel(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+Label LabelFromXMLParser::parseLabel(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<PrimitiveLabel>::first(input)) {
 		if(!features.count(FEATURES::PRIMITIVE)) throw exception::AlibException();
 		return Label(parsePrimitiveLabel(input));
@@ -40,7 +40,7 @@ Label LabelFromXMLParser::parseLabel(std::list<sax::Token>& input, const std::se
 	}
 }
 
-bool LabelFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool LabelFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<PrimitiveLabel>::first(input) || alib::xmlApi<ObjectLabel>::first(input) || alib::xmlApi<LabelSetLabel>::first(input) || alib::xmlApi<LabelPairLabel>::first(input)) {
 		return true;
 	} else {
@@ -48,28 +48,28 @@ bool LabelFromXMLParser::first(const std::list<sax::Token>& input) const {
 	}
 }
 
-PrimitiveLabel LabelFromXMLParser::parsePrimitiveLabel(std::list<sax::Token>& input) const {
+PrimitiveLabel LabelFromXMLParser::parsePrimitiveLabel(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_PRIMITIVE_LABEL);
 	PrimitiveLabel data(alib::xmlApi<primitive::Primitive>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_PRIMITIVE_LABEL);
 	return data;
 }
 
-HexavigesimalLabel LabelFromXMLParser::parseHexavigesimalLabel(std::list<sax::Token>& input) const {
+HexavigesimalLabel LabelFromXMLParser::parseHexavigesimalLabel(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_HEXAVIGESIMAL_LABEL);
 	HexavigesimalLabel data(std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER)));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_HEXAVIGESIMAL_LABEL);
 	return data;
 }
 
-ObjectLabel LabelFromXMLParser::parseObjectLabel(std::list<sax::Token>& input) const {
+ObjectLabel LabelFromXMLParser::parseObjectLabel(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_OBJECT_LABEL);
 	ObjectLabel data(alib::xmlApi<alib::Object>::parse(input));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_OBJECT_LABEL);
 	return data;
 }
 
-LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::list<sax::Token>& input) const {
+LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_LABEL_SET_LABEL);
 	std::set<Label> labels;
 	while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -80,7 +80,7 @@ LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::list<sax::Token>& inpu
 	return data;
 }
 
-LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::list<sax::Token>& input) const {
+LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_LABEL_PAIR_LABEL);
 
 	Label firstLabel = parseLabel(input);
@@ -91,7 +91,7 @@ LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::list<sax::Token>& in
 	return data;
 }
 
-UniqueLabel LabelFromXMLParser::parseUniqueLabel(std::list<sax::Token>& input) const {
+UniqueLabel LabelFromXMLParser::parseUniqueLabel(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::LABEL_UNIQUE_LABEL);
 
 	Label firstLabel = parseLabel(input);
diff --git a/alib2data/src/label/LabelFromXMLParser.h b/alib2data/src/label/LabelFromXMLParser.h
index 4f9382a66fbd8dbd414ed7525fa03cfdfad7b6fc..d7be430e0a2bf5714d0c90a36201451fbc5b3da7 100644
--- a/alib2data/src/label/LabelFromXMLParser.h
+++ b/alib2data/src/label/LabelFromXMLParser.h
@@ -34,19 +34,19 @@ namespace label {
  * Parser used to transform sequence of xml tokens to internal representation of Label.
  */
 class LabelFromXMLParser : public sax::FromXMLParserHelper {
-	Label parseLabel(std::list<sax::Token>& input, const std::set<FEATURES>&) const;
-	Label parseLabel(std::list<sax::Token>& input) const;
+	Label parseLabel(std::deque<sax::Token>& input, const std::set<FEATURES>&) const;
+	Label parseLabel(std::deque<sax::Token>& input) const;
 
-	PrimitiveLabel parsePrimitiveLabel(std::list<sax::Token>& input) const;
-	HexavigesimalLabel parseHexavigesimalLabel(std::list<sax::Token>& input) const;
-	ObjectLabel parseObjectLabel(std::list<sax::Token>& input) const;
-	LabelSetLabel parseLabelSetLabel(std::list<sax::Token>& input) const;
-	LabelPairLabel parseLabelPairLabel(std::list<sax::Token>& input) const;
-	UniqueLabel parseUniqueLabel(std::list<sax::Token>& input) const;
+	PrimitiveLabel parsePrimitiveLabel(std::deque<sax::Token>& input) const;
+	HexavigesimalLabel parseHexavigesimalLabel(std::deque<sax::Token>& input) const;
+	ObjectLabel parseObjectLabel(std::deque<sax::Token>& input) const;
+	LabelSetLabel parseLabelSetLabel(std::deque<sax::Token>& input) const;
+	LabelPairLabel parseLabelPairLabel(std::deque<sax::Token>& input) const;
+	UniqueLabel parseUniqueLabel(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace label */
diff --git a/alib2data/src/label/LabelToXMLComposer.cpp b/alib2data/src/label/LabelToXMLComposer.cpp
index ea652e9b04f056dd91d30b616c388585b5cf3d66..b59ef2cdd7db5e47c09317fa7e82668d4a6ee4e1 100644
--- a/alib2data/src/label/LabelToXMLComposer.cpp
+++ b/alib2data/src/label/LabelToXMLComposer.cpp
@@ -12,33 +12,33 @@
 
 namespace label {
 
-void LabelToXMLComposer::compose(std::list<sax::Token>& out, const Label& label) const {
+void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const Label& label) const {
 	label.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void LabelToXMLComposer::compose(std::list<sax::Token>& out, const LabelBase& label) const {
+void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const LabelBase& label) const {
 	label.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void LabelToXMLComposer::compose(std::list<sax::Token>& out, const PrimitiveLabel& label) const {
+void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const PrimitiveLabel& label) const {
 	out.push_back(sax::Token(alib::Names::LABEL_PRIMITIVE_LABEL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<primitive::Primitive>::compose(out, label.getData());
 	out.push_back(sax::Token(alib::Names::LABEL_PRIMITIVE_LABEL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void LabelToXMLComposer::compose(std::list<sax::Token>& out, const HexavigesimalLabel& label) const {
+void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const HexavigesimalLabel& label) const {
 	out.push_back(sax::Token(alib::Names::LABEL_HEXAVIGESIMAL_LABEL, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(std::itos(label.getData()), sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::LABEL_HEXAVIGESIMAL_LABEL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void LabelToXMLComposer::compose(std::list<sax::Token>& out, const ObjectLabel& label) const {
+void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectLabel& label) const {
 	out.push_back(sax::Token(alib::Names::LABEL_OBJECT_LABEL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<alib::Object>::compose(out, label.getData());
 	out.push_back(sax::Token(alib::Names::LABEL_OBJECT_LABEL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void LabelToXMLComposer::compose(std::list<sax::Token>& out, const LabelSetLabel& label) const {
+void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const LabelSetLabel& label) const {
 	out.push_back(sax::Token(alib::Names::LABEL_LABEL_SET_LABEL, sax::Token::TokenType::START_ELEMENT));
 	for(const Label& innerLabel : label.getData()) {
 		alib::xmlApi<label::Label>::compose(out, innerLabel);
@@ -46,14 +46,14 @@ void LabelToXMLComposer::compose(std::list<sax::Token>& out, const LabelSetLabel
 	out.push_back(sax::Token(alib::Names::LABEL_LABEL_SET_LABEL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void LabelToXMLComposer::compose(std::list<sax::Token>& out, const LabelPairLabel& label) const {
+void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const LabelPairLabel& label) const {
 	out.push_back(sax::Token(alib::Names::LABEL_LABEL_PAIR_LABEL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<label::Label>::compose(out, label.getData().first);
 	alib::xmlApi<label::Label>::compose(out, label.getData().second);
 	out.push_back(sax::Token(alib::Names::LABEL_LABEL_PAIR_LABEL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void LabelToXMLComposer::compose(std::list<sax::Token>& out, const UniqueLabel& label) const {
+void LabelToXMLComposer::compose(std::deque<sax::Token>& out, const UniqueLabel& label) const {
 	out.push_back(sax::Token(alib::Names::LABEL_UNIQUE_LABEL, sax::Token::TokenType::START_ELEMENT));
 	alib::xmlApi<label::Label>::compose(out, label.getLabel());
 	alib::xmlApi<primitive::Integer>::compose(out, label.getId());
diff --git a/alib2data/src/label/LabelToXMLComposer.h b/alib2data/src/label/LabelToXMLComposer.h
index d1d07c2eefe720ca728ca0496072dbd94b2f1618..59082154ee6d0130b8940a3af1c14f726721a979 100644
--- a/alib2data/src/label/LabelToXMLComposer.h
+++ b/alib2data/src/label/LabelToXMLComposer.h
@@ -8,7 +8,7 @@
 #ifndef LABEL_TO_XML_COMPOSER_H_
 #define LABEL_TO_XML_COMPOSER_H_
 
-#include <list>
+#include <deque>
 #include "Label.h"
 #include "../sax/Token.h"
 
@@ -30,21 +30,21 @@ class LabelToXMLComposer {
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const LabelBase& label) const;
+	void compose(std::deque<sax::Token>& out, const LabelBase& label) const;
 
 	/**
 	 * Prints XML representation of String to the output stream.
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const Label& label) const;
-
-	void compose(std::list<sax::Token>& out, const PrimitiveLabel& label) const;
-	void compose(std::list<sax::Token>& out, const HexavigesimalLabel& label) const;
-	void compose(std::list<sax::Token>& out, const ObjectLabel& label) const;
-	void compose(std::list<sax::Token>& out, const LabelSetLabel& label) const;
-	void compose(std::list<sax::Token>& out, const LabelPairLabel& label) const;
-	void compose(std::list<sax::Token>& out, const UniqueLabel& label) const;
+	void compose(std::deque<sax::Token>& out, const Label& label) const;
+
+	void compose(std::deque<sax::Token>& out, const PrimitiveLabel& label) const;
+	void compose(std::deque<sax::Token>& out, const HexavigesimalLabel& label) const;
+	void compose(std::deque<sax::Token>& out, const ObjectLabel& label) const;
+	void compose(std::deque<sax::Token>& out, const LabelSetLabel& label) const;
+	void compose(std::deque<sax::Token>& out, const LabelPairLabel& label) const;
+	void compose(std::deque<sax::Token>& out, const UniqueLabel& label) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/object/ObjectFromXMLParser.cpp b/alib2data/src/object/ObjectFromXMLParser.cpp
index d5c7732c8dea18469431fe4c2ab5a874d2ff9363..e27b857f221684150bdcfece7285060e66f5941d 100644
--- a/alib2data/src/object/ObjectFromXMLParser.cpp
+++ b/alib2data/src/object/ObjectFromXMLParser.cpp
@@ -14,7 +14,7 @@
 
 namespace alib {
 
-Object ObjectFromXMLParser::parseObject(std::list<sax::Token>& input) const {
+Object ObjectFromXMLParser::parseObject(std::deque<sax::Token>& input) const {
 	if(alib::FromXMLParsers::symbolParser.first(input)) {
 		alphabet::Symbol symbol = alib::xmlApi<alphabet::Symbol>::parse(input);
 		Object res(std::move(symbol.getData()));
@@ -59,14 +59,14 @@ Object ObjectFromXMLParser::parseObject(std::list<sax::Token>& input) const {
 	}
 }
 
-Void ObjectFromXMLParser::parseVoid(std::list<sax::Token>& input) const {
+Void ObjectFromXMLParser::parseVoid(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALIB_VOID);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALIB_VOID);
 
 	return Void {};
 }
 
-bool ObjectFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool ObjectFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	return alib::FromXMLParsers::symbolParser.first(input) || alib::FromXMLParsers::exceptionParser.first(input) || alib::FromXMLParsers::labelParser.first(input) || alib::FromXMLParsers::regexpParser.first(input) || alib::FromXMLParsers::stringParser.first(input) || alib::FromXMLParsers::automatonParser.first(input) || alib::FromXMLParsers::grammarParser.first(input) || alib::FromXMLParsers::containerParser.first(input) || alib::xmlApi<Void>::first(input);
 }
 
diff --git a/alib2data/src/object/ObjectFromXMLParser.h b/alib2data/src/object/ObjectFromXMLParser.h
index bf8401a97ea93b2ecea15ebb4c802e4ebfdc655c..cdcf31d6dd969cab6ec2e0e87bc80a6bd849ac21 100644
--- a/alib2data/src/object/ObjectFromXMLParser.h
+++ b/alib2data/src/object/ObjectFromXMLParser.h
@@ -27,12 +27,12 @@ namespace alib {
  * Parser used to get String from XML parsed into list of tokens.
  */
 class ObjectFromXMLParser : public sax::FromXMLParserHelper {
-	Object parseObject(std::list<sax::Token>& input) const;
-	Void parseVoid(std::list<sax::Token>& input) const;
+	Object parseObject(std::deque<sax::Token>& input) const;
+	Void parseVoid(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace alib */
diff --git a/alib2data/src/object/ObjectToXMLComposer.cpp b/alib2data/src/object/ObjectToXMLComposer.cpp
index 4413f0d9d7d7c51b16406f23bf289118c891b9fa..7e080122a7b73abfb1b8532620806f22ba9f89de 100644
--- a/alib2data/src/object/ObjectToXMLComposer.cpp
+++ b/alib2data/src/object/ObjectToXMLComposer.cpp
@@ -11,16 +11,16 @@
 
 namespace alib {
 
-void ObjectToXMLComposer::compose(std::list<sax::Token>& out, const Object& object) const {
+void ObjectToXMLComposer::compose(std::deque<sax::Token>& out, const Object& object) const {
 	object.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void ObjectToXMLComposer::compose(std::list<sax::Token>& out, const Void&) const {
+void ObjectToXMLComposer::compose(std::deque<sax::Token>& out, const Void&) const {
 	out.push_back(sax::Token(alib::Names::ALIB_VOID, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(alib::Names::ALIB_VOID, sax::Token::TokenType::END_ELEMENT));
 }
 
-void ObjectToXMLComposer::compose(std::list<sax::Token>& out, const ObjectBase& object) const {
+void ObjectToXMLComposer::compose(std::deque<sax::Token>& out, const ObjectBase& object) const {
 	object.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
diff --git a/alib2data/src/object/ObjectToXMLComposer.h b/alib2data/src/object/ObjectToXMLComposer.h
index 2aca190cdf1d377186118f86aa5d7cf436430dcd..7e5ffc85d4b3004662c7bb287aafd604a5171ddf 100644
--- a/alib2data/src/object/ObjectToXMLComposer.h
+++ b/alib2data/src/object/ObjectToXMLComposer.h
@@ -8,7 +8,7 @@
 #ifndef OBJECT_TO_XML_COMPOSER_H_
 #define OBJECT_TO_XML_COMPOSER_H_
 
-#include <list>
+#include <deque>
 #include "Object.h"
 #include "Void.h"
 #include "../sax/Token.h"
@@ -32,21 +32,21 @@ class ObjectToXMLComposer {
 	 * @param automaton automaton to print
 	 * @return list of xml tokens representing the automaton
 	 */
-	void compose(std::list<sax::Token>& out, const ObjectBase& object) const;
+	void compose(std::deque<sax::Token>& out, const ObjectBase& object) const;
 
 	/**
 	 * Prints XML representation of String to the output stream.
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const Object& object) const;
+	void compose(std::deque<sax::Token>& out, const Object& object) const;
 
 	/**
 	 * Prints XML representation of String to the output stream.
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const Void& voidObject) const;
+	void compose(std::deque<sax::Token>& out, const Void& voidObject) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
index 14b1ff737c223c323262fd04e27dce2125b4ade1..39390e44853df0b78add486b5db37d92c3457928 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
@@ -14,11 +14,11 @@
 
 namespace primitive {
 
-Primitive PrimitiveFromXMLParser::parsePrimitive(std::list<sax::Token>& input) const {
+Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>& input) const {
 	return parsePrimitive(input, std::set<FEATURES>({FEATURES::STRING, FEATURES::CHAR, FEATURES::INTEGER, FEATURES::UNSIGNED, FEATURES::BOOL}));
 }
 
-Primitive PrimitiveFromXMLParser::parsePrimitive(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+Primitive PrimitiveFromXMLParser::parsePrimitive(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<Integer>::first(input)) {
 		if(!features.count(FEATURES::INTEGER)) throw exception::AlibException();
 		return Primitive(parseInteger(input));
@@ -39,7 +39,7 @@ Primitive PrimitiveFromXMLParser::parsePrimitive(std::list<sax::Token>& input, c
 	}
 }
 
-bool PrimitiveFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool PrimitiveFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<Integer>::first(input) || alib::xmlApi<String>::first(input) || alib::xmlApi<Character>::first(input) || alib::xmlApi<Unsigned>::first(input) || alib::xmlApi<Bool>::first(input)) {
 		return true;
 	} else {
@@ -47,21 +47,21 @@ bool PrimitiveFromXMLParser::first(const std::list<sax::Token>& input) const {
 	}
 }
 
-Integer PrimitiveFromXMLParser::parseInteger(std::list<sax::Token>& input) const {
+Integer PrimitiveFromXMLParser::parseInteger(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
 	Integer data(std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER)));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
 	return data;
 }
 
-Character PrimitiveFromXMLParser::parseCharacter(std::list<sax::Token>& input) const {
+Character PrimitiveFromXMLParser::parseCharacter(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
 	Character data(popTokenData(input, sax::Token::TokenType::CHARACTER)[0]);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
 	return data;
 }
 
-String PrimitiveFromXMLParser::parseString(std::list<sax::Token>& input) const {
+String PrimitiveFromXMLParser::parseString(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_STRING);
 	std::string data = "";
 	if( isTokenType(input, sax::Token::TokenType::CHARACTER))
@@ -70,14 +70,14 @@ String PrimitiveFromXMLParser::parseString(std::list<sax::Token>& input) const {
 	return String(std::move(data));
 }
 
-Unsigned PrimitiveFromXMLParser::parseUnsigned(std::list<sax::Token>& input) const {
+Unsigned PrimitiveFromXMLParser::parseUnsigned(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
 	Unsigned data(std::stou(popTokenData(input, sax::Token::TokenType::CHARACTER)));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
 	return data;
 }
 
-Bool PrimitiveFromXMLParser::parseBool(std::list<sax::Token>& input) const {
+Bool PrimitiveFromXMLParser::parseBool(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_BOOL);
 	std::string tmp = popTokenData(input, sax::Token::TokenType::CHARACTER);
 	bool data;
@@ -91,35 +91,35 @@ Bool PrimitiveFromXMLParser::parseBool(std::list<sax::Token>& input) const {
 	return Bool(data);
 }
 
-int PrimitiveFromXMLParser::parseIntegerRaw(std::list<sax::Token>& input) const {
+int PrimitiveFromXMLParser::parseIntegerRaw(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
 	int data = std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_INTEGER);
 	return data;
 }
 
-char PrimitiveFromXMLParser::parseCharacterRaw(std::list<sax::Token>& input) const {
+char PrimitiveFromXMLParser::parseCharacterRaw(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
 	char data = popTokenData(input, sax::Token::TokenType::CHARACTER)[0];
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_CHARACTER);
 	return data;
 }
 
-std::string PrimitiveFromXMLParser::parseStringRaw(std::list<sax::Token>& input) const {
+std::string PrimitiveFromXMLParser::parseStringRaw(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_STRING);
 	std::string data = popTokenData(input, sax::Token::TokenType::CHARACTER);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING);
 	return data;
 }
 
-unsigned PrimitiveFromXMLParser::parseUnsignedRaw(std::list<sax::Token>& input) const {
+unsigned PrimitiveFromXMLParser::parseUnsignedRaw(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
 	unsigned data = std::stou(popTokenData(input, sax::Token::TokenType::CHARACTER));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_UNSIGNED);
 	return data;
 }
 
-bool PrimitiveFromXMLParser::parseBoolRaw(std::list<sax::Token>& input) const {
+bool PrimitiveFromXMLParser::parseBoolRaw(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::PRIMITIVE_BOOL);
 	std::string tmp = popTokenData(input, sax::Token::TokenType::CHARACTER);
 	bool data;
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.h b/alib2data/src/primitive/PrimitiveFromXMLParser.h
index c83f5e976e04857eeb94eb85606eff1ee142622e..92575ceec2a62aa595a4d2a11784cd24c0642d24 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.h
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.h
@@ -32,24 +32,24 @@ namespace primitive {
  * Parser used to transform sequence of xml tokens to internal representation of Primitive.
  */
 class PrimitiveFromXMLParser : public sax::FromXMLParserHelper {
-	Primitive parsePrimitive(std::list<sax::Token>& input, const std::set<FEATURES>&) const;
-	Primitive parsePrimitive(std::list<sax::Token>& input) const;
+	Primitive parsePrimitive(std::deque<sax::Token>& input, const std::set<FEATURES>&) const;
+	Primitive parsePrimitive(std::deque<sax::Token>& input) const;
 
-	Integer parseInteger(std::list<sax::Token>& input) const;
-	Character parseCharacter(std::list<sax::Token>& input) const;
-	String parseString(std::list<sax::Token>& input) const;
-	Unsigned parseUnsigned(std::list<sax::Token>& input) const;
-	Bool parseBool(std::list<sax::Token>& input) const;
+	Integer parseInteger(std::deque<sax::Token>& input) const;
+	Character parseCharacter(std::deque<sax::Token>& input) const;
+	String parseString(std::deque<sax::Token>& input) const;
+	Unsigned parseUnsigned(std::deque<sax::Token>& input) const;
+	Bool parseBool(std::deque<sax::Token>& input) const;
 
-	int parseIntegerRaw(std::list<sax::Token>& input) const;
-	char parseCharacterRaw(std::list<sax::Token>& input) const;
-	std::string parseStringRaw(std::list<sax::Token>& input) const;
-	unsigned parseUnsignedRaw(std::list<sax::Token>& input) const;
-	bool parseBoolRaw(std::list<sax::Token>& input) const;
+	int parseIntegerRaw(std::deque<sax::Token>& input) const;
+	char parseCharacterRaw(std::deque<sax::Token>& input) const;
+	std::string parseStringRaw(std::deque<sax::Token>& input) const;
+	unsigned parseUnsignedRaw(std::deque<sax::Token>& input) const;
+	bool parseBoolRaw(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace primitive */
diff --git a/alib2data/src/primitive/PrimitiveToXMLComposer.cpp b/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
index 83a3361c694fa978b2cec3602e19ba68f9f49375..120ddf6d80949f5cf150207414006ae2761d5329 100644
--- a/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
+++ b/alib2data/src/primitive/PrimitiveToXMLComposer.cpp
@@ -16,33 +16,33 @@
 
 namespace primitive {
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const Primitive& primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Primitive& primitive) const {
 	primitive.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const PrimitiveBase& primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const PrimitiveBase& primitive) const {
 	primitive.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const Integer& primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Integer& primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(std::itos(primitive.getData()), sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const Character& primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Character& primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(std::string(1, primitive.getData()), sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const Unsigned& primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Unsigned& primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(std::utos(primitive.getData()), sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const Bool& primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const Bool& primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT));
 	if(primitive.getData())
 		out.push_back(sax::Token("true", sax::Token::TokenType::CHARACTER));
@@ -51,37 +51,37 @@ void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const Bool& pri
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const String& primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const String& primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(primitive.getData(), sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, int primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, int primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(std::itos(primitive), sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_INTEGER, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, char primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, char primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(std::string(1, primitive), sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_CHARACTER, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, const std::string& primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, const std::string& primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(primitive, sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_STRING, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, unsigned primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, unsigned primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token(std::utos(primitive), sax::Token::TokenType::CHARACTER));
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_UNSIGNED, sax::Token::TokenType::END_ELEMENT));
 }
 
-void PrimitiveToXMLComposer::compose(std::list<sax::Token>& out, bool primitive) const {
+void PrimitiveToXMLComposer::compose(std::deque<sax::Token>& out, bool primitive) const {
 	out.push_back(sax::Token(alib::Names::PRIMITIVE_BOOL, sax::Token::TokenType::START_ELEMENT));
 	if(primitive)
 		out.push_back(sax::Token("true", sax::Token::TokenType::CHARACTER));
diff --git a/alib2data/src/primitive/PrimitiveToXMLComposer.h b/alib2data/src/primitive/PrimitiveToXMLComposer.h
index 4d35fda16ee7ab772ceb6c14c52f58f8d20a1383..234ebc5acf054bb1fbea71df6a103d3cf0871b65 100644
--- a/alib2data/src/primitive/PrimitiveToXMLComposer.h
+++ b/alib2data/src/primitive/PrimitiveToXMLComposer.h
@@ -8,7 +8,7 @@
 #ifndef PRIMITIVE_TO_XML_COMPOSER_H_
 #define PRIMITIVE_TO_XML_COMPOSER_H_
 
-#include <list>
+#include <deque>
 #include <string>
 #include "Primitive.h"
 #include "../sax/Token.h"
@@ -32,26 +32,26 @@ class PrimitiveToXMLComposer {
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const PrimitiveBase& primitive) const;
+	void compose(std::deque<sax::Token>& out, const PrimitiveBase& primitive) const;
 
 	/**
 	 * Prints XML representation of String to the output stream.
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const Primitive& primitive) const;
-
-	void compose(std::list<sax::Token>& out, const String& primitive) const;
-	void compose(std::list<sax::Token>& out, const Integer& primitive) const;
-	void compose(std::list<sax::Token>& out, const Character& primitive) const;
-	void compose(std::list<sax::Token>& out, const Unsigned& primitive) const;
-	void compose(std::list<sax::Token>& out, const Bool& primitive) const;
-
-	void compose(std::list<sax::Token>& out, const std::string& primitive) const;
-	void compose(std::list<sax::Token>& out, int primitive) const;
-	void compose(std::list<sax::Token>& out, char primitive) const;
-	void compose(std::list<sax::Token>& out, unsigned primitive) const;
-	void compose(std::list<sax::Token>& out, bool primitive) const;
+	void compose(std::deque<sax::Token>& out, const Primitive& primitive) const;
+
+	void compose(std::deque<sax::Token>& out, const String& primitive) const;
+	void compose(std::deque<sax::Token>& out, const Integer& primitive) const;
+	void compose(std::deque<sax::Token>& out, const Character& primitive) const;
+	void compose(std::deque<sax::Token>& out, const Unsigned& primitive) const;
+	void compose(std::deque<sax::Token>& out, const Bool& primitive) const;
+
+	void compose(std::deque<sax::Token>& out, const std::string& primitive) const;
+	void compose(std::deque<sax::Token>& out, int primitive) const;
+	void compose(std::deque<sax::Token>& out, char primitive) const;
+	void compose(std::deque<sax::Token>& out, unsigned primitive) const;
+	void compose(std::deque<sax::Token>& out, bool primitive) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/regexp/RegExpFromXMLParser.cpp b/alib2data/src/regexp/RegExpFromXMLParser.cpp
index 1bb383987b1d85904360ed795935d45bda9de16d..9d17ba2a88b51ba18c7f9e92f3e1ff3944386c82 100644
--- a/alib2data/src/regexp/RegExpFromXMLParser.cpp
+++ b/alib2data/src/regexp/RegExpFromXMLParser.cpp
@@ -12,11 +12,11 @@
 
 namespace regexp {
 
-RegExp RegExpFromXMLParser::parseRegExp(std::list<sax::Token>& input) const {
+RegExp RegExpFromXMLParser::parseRegExp(std::deque<sax::Token>& input) const {
 	return parseRegExp(input, std::set<FEATURES>({FEATURES::FORMAL, FEATURES::UNBOUNDED}));
 }
 
-RegExp RegExpFromXMLParser::parseRegExp(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+RegExp RegExpFromXMLParser::parseRegExp(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<UnboundedRegExp>::first(input)) {
 		if(!features.count(FEATURES::UNBOUNDED)) throw exception::AlibException();
 		return RegExp(parseUnboundedRegExp(input));
@@ -27,7 +27,7 @@ RegExp RegExpFromXMLParser::parseRegExp(std::list<sax::Token>& input, const std:
 	throw exception::AlibException();
 }
 
-bool RegExpFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool RegExpFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<UnboundedRegExp>::first(input) || alib::xmlApi<FormalRegExp>::first(input)) {
 		return true;
 	} else {
@@ -35,7 +35,7 @@ bool RegExpFromXMLParser::first(const std::list<sax::Token>& input) const {
 	}
 }
 
-UnboundedRegExp RegExpFromXMLParser::parseUnboundedRegExp(std::list<sax::Token>& input) const {
+UnboundedRegExp RegExpFromXMLParser::parseUnboundedRegExp(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::REGEXP_UNBOUNDED_REGEXP);
 
 	UnboundedRegExp regexp;
@@ -49,7 +49,7 @@ UnboundedRegExp RegExpFromXMLParser::parseUnboundedRegExp(std::list<sax::Token>&
 	return regexp;
 }
 
-FormalRegExp RegExpFromXMLParser::parseFormalRegExp(std::list<sax::Token>& input) const {
+FormalRegExp RegExpFromXMLParser::parseFormalRegExp(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::REGEXP_FORMAL_REGEXP);
 
 	FormalRegExp regexp;
@@ -63,7 +63,7 @@ FormalRegExp RegExpFromXMLParser::parseFormalRegExp(std::list<sax::Token>& input
 	return regexp;
 }
 
-void RegExpFromXMLParser::parseAlphabet(std::list<sax::Token> &input, UnboundedRegExp& regexp) const {
+void RegExpFromXMLParser::parseAlphabet(std::deque<sax::Token> &input, UnboundedRegExp& regexp) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		regexp.addSymbolToAlphabet(alib::xmlApi<alphabet::Symbol>::parse(input));
@@ -71,7 +71,7 @@ void RegExpFromXMLParser::parseAlphabet(std::list<sax::Token> &input, UnboundedR
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
 }
 
-void RegExpFromXMLParser::parseAlphabet(std::list<sax::Token> &input, FormalRegExp& regexp) const {
+void RegExpFromXMLParser::parseAlphabet(std::deque<sax::Token> &input, FormalRegExp& regexp) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		regexp.addSymbolToAlphabet(alib::xmlApi<alphabet::Symbol>::parse(input));
@@ -79,7 +79,7 @@ void RegExpFromXMLParser::parseAlphabet(std::list<sax::Token> &input, FormalRegE
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
 }
 
-UnboundedRegExpElement* RegExpFromXMLParser::parseUnboundedRegExpElement(std::list<sax::Token>& input) const {
+UnboundedRegExpElement* RegExpFromXMLParser::parseUnboundedRegExpElement(std::deque<sax::Token>& input) const {
 	if (isToken(input, sax::Token::TokenType::START_ELEMENT, "empty")) {
 		return parseUnboundedRegExpEmpty(input);
 	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -95,7 +95,7 @@ UnboundedRegExpElement* RegExpFromXMLParser::parseUnboundedRegExpElement(std::li
 	}
 }
 
-UnboundedRegExpAlternation* RegExpFromXMLParser::parseUnboundedRegExpAlternation(std::list<sax::Token>& input) const {
+UnboundedRegExpAlternation* RegExpFromXMLParser::parseUnboundedRegExpAlternation(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alternation");
 
 	UnboundedRegExpAlternation* alternation = new UnboundedRegExpAlternation();
@@ -110,7 +110,7 @@ UnboundedRegExpAlternation* RegExpFromXMLParser::parseUnboundedRegExpAlternation
 	return alternation;
 }
 
-UnboundedRegExpConcatenation* RegExpFromXMLParser::parseUnboundedRegExpConcatenation(std::list<sax::Token>& input) const {
+UnboundedRegExpConcatenation* RegExpFromXMLParser::parseUnboundedRegExpConcatenation(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "concatenation");
 
 	UnboundedRegExpConcatenation* concatenation = new UnboundedRegExpConcatenation();
@@ -126,7 +126,7 @@ UnboundedRegExpConcatenation* RegExpFromXMLParser::parseUnboundedRegExpConcatena
 
 }
 
-UnboundedRegExpIteration* RegExpFromXMLParser::parseUnboundedRegExpIteration(std::list<sax::Token>& input) const {
+UnboundedRegExpIteration* RegExpFromXMLParser::parseUnboundedRegExpIteration(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "iteration");
 
 	UnboundedRegExpElement* element = parseUnboundedRegExpElement(input);
@@ -137,7 +137,7 @@ UnboundedRegExpIteration* RegExpFromXMLParser::parseUnboundedRegExpIteration(std
 	return iteration;
 }
 
-UnboundedRegExpEpsilon* RegExpFromXMLParser::parseUnboundedRegExpEpsilon(std::list<sax::Token>& input) const {
+UnboundedRegExpEpsilon* RegExpFromXMLParser::parseUnboundedRegExpEpsilon(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon");
 
 	UnboundedRegExpEpsilon* epsilon = new UnboundedRegExpEpsilon();
@@ -146,7 +146,7 @@ UnboundedRegExpEpsilon* RegExpFromXMLParser::parseUnboundedRegExpEpsilon(std::li
 	return epsilon;
 }
 
-UnboundedRegExpEmpty* RegExpFromXMLParser::parseUnboundedRegExpEmpty(std::list<sax::Token>& input) const {
+UnboundedRegExpEmpty* RegExpFromXMLParser::parseUnboundedRegExpEmpty(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "empty");
 
 	UnboundedRegExpEmpty* empty = new UnboundedRegExpEmpty();
@@ -155,7 +155,7 @@ UnboundedRegExpEmpty* RegExpFromXMLParser::parseUnboundedRegExpEmpty(std::list<s
 	return empty;
 }
 
-FormalRegExpElement* RegExpFromXMLParser::parseFormalRegExpElement(std::list<sax::Token>& input) const {
+FormalRegExpElement* RegExpFromXMLParser::parseFormalRegExpElement(std::deque<sax::Token>& input) const {
 	if (isToken(input, sax::Token::TokenType::START_ELEMENT, "empty")) {
 		return parseFormalRegExpEmpty(input);
 	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
@@ -171,7 +171,7 @@ FormalRegExpElement* RegExpFromXMLParser::parseFormalRegExpElement(std::list<sax
 	}
 }
 
-FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std::list<sax::Token>& input) const {
+FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alternation");
 
 	FormalRegExpElement* element1 = parseFormalRegExpElement(input);
@@ -186,7 +186,7 @@ FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std::
 	return alternation;
 }
 
-FormalRegExpConcatenation* RegExpFromXMLParser::parseFormalRegExpConcatenation(std::list<sax::Token>& input) const {
+FormalRegExpConcatenation* RegExpFromXMLParser::parseFormalRegExpConcatenation(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "concatenation");
 
 	FormalRegExpElement* element1 = parseFormalRegExpElement(input);
@@ -202,7 +202,7 @@ FormalRegExpConcatenation* RegExpFromXMLParser::parseFormalRegExpConcatenation(s
 
 }
 
-FormalRegExpIteration* RegExpFromXMLParser::parseFormalRegExpIteration(std::list<sax::Token>& input) const {
+FormalRegExpIteration* RegExpFromXMLParser::parseFormalRegExpIteration(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "iteration");
 
 	FormalRegExpElement* element = parseFormalRegExpElement(input);
@@ -213,7 +213,7 @@ FormalRegExpIteration* RegExpFromXMLParser::parseFormalRegExpIteration(std::list
 	return iteration;
 }
 
-FormalRegExpEpsilon* RegExpFromXMLParser::parseFormalRegExpEpsilon(std::list<sax::Token>& input) const {
+FormalRegExpEpsilon* RegExpFromXMLParser::parseFormalRegExpEpsilon(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon");
 
 	FormalRegExpEpsilon* epsilon = new FormalRegExpEpsilon();
@@ -222,7 +222,7 @@ FormalRegExpEpsilon* RegExpFromXMLParser::parseFormalRegExpEpsilon(std::list<sax
 	return epsilon;
 }
 
-FormalRegExpEmpty* RegExpFromXMLParser::parseFormalRegExpEmpty(std::list<sax::Token>& input) const {
+FormalRegExpEmpty* RegExpFromXMLParser::parseFormalRegExpEmpty(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "empty");
 
 	FormalRegExpEmpty* empty = new FormalRegExpEmpty();
diff --git a/alib2data/src/regexp/RegExpFromXMLParser.h b/alib2data/src/regexp/RegExpFromXMLParser.h
index 6e5fffdc723b99fa6e750a35c598c6e074f23c57..ccf05f6ae8e7603b0e20add610762f2b82982d47 100644
--- a/alib2data/src/regexp/RegExpFromXMLParser.h
+++ b/alib2data/src/regexp/RegExpFromXMLParser.h
@@ -29,34 +29,34 @@ namespace regexp {
  * Parser used to get RegExp from XML parsed into list of tokens.
  */
 class RegExpFromXMLParser : public sax::FromXMLParserHelper {
-	void parseAlphabet(std::list<sax::Token>& input, UnboundedRegExp& regexp) const;
-	void parseAlphabet(std::list<sax::Token>& input, FormalRegExp& regexp) const;
+	void parseAlphabet(std::deque<sax::Token>& input, UnboundedRegExp& regexp) const;
+	void parseAlphabet(std::deque<sax::Token>& input, FormalRegExp& regexp) const;
 
-	UnboundedRegExpElement* parseUnboundedRegExpElement(std::list<sax::Token>& input) const;
+	UnboundedRegExpElement* parseUnboundedRegExpElement(std::deque<sax::Token>& input) const;
 
-	UnboundedRegExpEpsilon* parseUnboundedRegExpEpsilon(std::list<sax::Token>& input) const;
-	UnboundedRegExpEmpty* parseUnboundedRegExpEmpty(std::list<sax::Token>& input) const;
-	UnboundedRegExpIteration* parseUnboundedRegExpIteration(std::list<sax::Token> &input) const;
-	UnboundedRegExpAlternation* parseUnboundedRegExpAlternation(std::list<sax::Token> &input) const;
-	UnboundedRegExpConcatenation* parseUnboundedRegExpConcatenation(std::list<sax::Token> &input) const;
+	UnboundedRegExpEpsilon* parseUnboundedRegExpEpsilon(std::deque<sax::Token>& input) const;
+	UnboundedRegExpEmpty* parseUnboundedRegExpEmpty(std::deque<sax::Token>& input) const;
+	UnboundedRegExpIteration* parseUnboundedRegExpIteration(std::deque<sax::Token> &input) const;
+	UnboundedRegExpAlternation* parseUnboundedRegExpAlternation(std::deque<sax::Token> &input) const;
+	UnboundedRegExpConcatenation* parseUnboundedRegExpConcatenation(std::deque<sax::Token> &input) const;
 
-	FormalRegExpElement* parseFormalRegExpElement(std::list<sax::Token>& input) const;
+	FormalRegExpElement* parseFormalRegExpElement(std::deque<sax::Token>& input) const;
 
-	FormalRegExpEpsilon* parseFormalRegExpEpsilon(std::list<sax::Token>& input) const;
-	FormalRegExpEmpty* parseFormalRegExpEmpty(std::list<sax::Token>& input) const;
-	FormalRegExpIteration* parseFormalRegExpIteration(std::list<sax::Token> &input) const;
-	FormalRegExpAlternation* parseFormalRegExpAlternation(std::list<sax::Token> &input) const;
-	FormalRegExpConcatenation* parseFormalRegExpConcatenation(std::list<sax::Token> &input) const;
+	FormalRegExpEpsilon* parseFormalRegExpEpsilon(std::deque<sax::Token>& input) const;
+	FormalRegExpEmpty* parseFormalRegExpEmpty(std::deque<sax::Token>& input) const;
+	FormalRegExpIteration* parseFormalRegExpIteration(std::deque<sax::Token> &input) const;
+	FormalRegExpAlternation* parseFormalRegExpAlternation(std::deque<sax::Token> &input) const;
+	FormalRegExpConcatenation* parseFormalRegExpConcatenation(std::deque<sax::Token> &input) const;
 
-	RegExp parseRegExp(std::list<sax::Token>& input) const;
-	RegExp parseRegExp(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+	RegExp parseRegExp(std::deque<sax::Token>& input) const;
+	RegExp parseRegExp(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
 
-	UnboundedRegExp parseUnboundedRegExp(std::list<sax::Token>& input) const;
-	FormalRegExp parseFormalRegExp(std::list<sax::Token>& input) const;
+	UnboundedRegExp parseUnboundedRegExp(std::deque<sax::Token>& input) const;
+	FormalRegExp parseFormalRegExp(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace regexp */
diff --git a/alib2data/src/regexp/RegExpToXMLComposer.cpp b/alib2data/src/regexp/RegExpToXMLComposer.cpp
index 250ee330e6592084a2c8207b2ff8541c74f4acfa..b83a9219cf379fc4adbecdfcb87227fdd390f915 100644
--- a/alib2data/src/regexp/RegExpToXMLComposer.cpp
+++ b/alib2data/src/regexp/RegExpToXMLComposer.cpp
@@ -12,7 +12,7 @@
 namespace regexp {
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpAlternation& alternation) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("alternation", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& element : alternation.getElements()) {
@@ -22,7 +22,7 @@ void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpAlternation
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpConcatenation& concatenation) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("concatenation", sax::Token::TokenType::START_ELEMENT));
 	for (auto element : concatenation.getElements()) {
@@ -33,7 +33,7 @@ void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpConcatenati
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpIteration& iteration) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("iteration", sax::Token::TokenType::START_ELEMENT));
 	iteration.getElement().Accept(userData, *this);
@@ -41,27 +41,27 @@ void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpIteration&
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpSymbol& symbol) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol.getSymbol());
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpEpsilon&) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const UnboundedRegExpEmpty&) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("empty", sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token("empty", sax::Token::TokenType::END_ELEMENT));
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpAlternation& alternation) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("alternation", sax::Token::TokenType::START_ELEMENT));
 	alternation.getLeftElement().Accept(userData, *this);
@@ -70,7 +70,7 @@ void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpAlternation& a
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpConcatenation& concatenation) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("concatenation", sax::Token::TokenType::START_ELEMENT));
 	concatenation.getLeftElement().Accept(userData, *this);
@@ -80,7 +80,7 @@ void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpConcatenation&
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpIteration& iteration) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("iteration", sax::Token::TokenType::START_ELEMENT));
 	iteration.getElement().Accept(userData, *this);
@@ -88,34 +88,34 @@ void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpIteration& ite
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpSymbol& symbol) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	alib::xmlApi<alphabet::Symbol>::compose(out, symbol.getSymbol());
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpEpsilon&) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const FormalRegExpEmpty&) const {
-	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
+	std::deque<sax::Token> &out = *((std::deque<sax::Token>*) userData);
 
 	out.push_back(sax::Token("empty", sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token("empty", sax::Token::TokenType::END_ELEMENT));
 }
 
-void RegExpToXMLComposer::compose(std::list<sax::Token>& out, const RegExp& regexp) const {
+void RegExpToXMLComposer::compose(std::deque<sax::Token>& out, const RegExp& regexp) const {
 	regexp.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void RegExpToXMLComposer::compose(std::list<sax::Token>& out, const RegExpBase& regexp) const {
+void RegExpToXMLComposer::compose(std::deque<sax::Token>& out, const RegExpBase& regexp) const {
 	regexp.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void RegExpToXMLComposer::compose(std::list<sax::Token>& out, const UnboundedRegExp& regexp) const {
+void RegExpToXMLComposer::compose(std::deque<sax::Token>& out, const UnboundedRegExp& regexp) const {
 	out.push_back(sax::Token(alib::Names::REGEXP_UNBOUNDED_REGEXP, sax::Token::TokenType::START_ELEMENT));
 	{
 		out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
@@ -128,7 +128,7 @@ void RegExpToXMLComposer::compose(std::list<sax::Token>& out, const UnboundedReg
 	out.push_back(sax::Token(alib::Names::REGEXP_UNBOUNDED_REGEXP, sax::Token::TokenType::END_ELEMENT));
 }
 
-void RegExpToXMLComposer::compose(std::list<sax::Token>& out, const FormalRegExp& regexp) const {
+void RegExpToXMLComposer::compose(std::deque<sax::Token>& out, const FormalRegExp& regexp) const {
 	out.push_back(sax::Token(alib::Names::REGEXP_FORMAL_REGEXP, sax::Token::TokenType::START_ELEMENT));
 	{
 		out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
diff --git a/alib2data/src/regexp/RegExpToXMLComposer.h b/alib2data/src/regexp/RegExpToXMLComposer.h
index f022c6c448fb5b46dee7380ea1fb303c0f82a8be..8a231d39917934ba0792fda379530109b302f81a 100644
--- a/alib2data/src/regexp/RegExpToXMLComposer.h
+++ b/alib2data/src/regexp/RegExpToXMLComposer.h
@@ -8,6 +8,7 @@
 #ifndef REG_EXP_TO_XML_COMPOSER_H_
 #define REG_EXP_TO_XML_COMPOSER_H_
 
+#include <deque>
 #include "RegExp.h"
 #include "unbounded/UnboundedRegExpElements.h"
 #include "formal/FormalRegExpElements.h"
@@ -48,17 +49,17 @@ class RegExpToXMLComposer :public UnboundedRegExpElement::const_visitor_type, pu
 	 * @param regexp RegExp to print
 	 * @returns list of xml tokens.
 	 */
-	void compose(std::list<sax::Token>& out, const RegExpBase& regexp) const;
+	void compose(std::deque<sax::Token>& out, const RegExpBase& regexp) const;
 
 	/**
 	 * Composes XML token representation of RegExp.
 	 * @param regexp RegExp to print
 	 * @returns list of xml tokens.
 	 */
-	void compose(std::list<sax::Token>& out, const RegExp& regexp) const;
+	void compose(std::deque<sax::Token>& out, const RegExp& regexp) const;
 
-	void compose(std::list<sax::Token>& out, const UnboundedRegExp& regexp) const;
-	void compose(std::list<sax::Token>& out, const FormalRegExp& regexp) const;
+	void compose(std::deque<sax::Token>& out, const UnboundedRegExp& regexp) const;
+	void compose(std::deque<sax::Token>& out, const FormalRegExp& regexp) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/src/sax/FromXMLParserHelper.cpp b/alib2data/src/sax/FromXMLParserHelper.cpp
index 1bd60a367543e0a21bf1bc42b227595274d0aeb6..0c6f33cdc5e141d6fbdade20a90a0e113be635bf 100644
--- a/alib2data/src/sax/FromXMLParserHelper.cpp
+++ b/alib2data/src/sax/FromXMLParserHelper.cpp
@@ -10,15 +10,15 @@
 
 namespace sax {
 
-bool FromXMLParserHelper::isToken(const std::list<Token>& input, Token::TokenType type, std::string data) {
+bool FromXMLParserHelper::isToken(const std::deque<Token>& input, Token::TokenType type, const std::string& data) {
 	return input.front().getType() == type && input.front().getData() == data;
 }
 
-bool FromXMLParserHelper::isTokenType(const std::list<Token>& input, Token::TokenType type) {
+bool FromXMLParserHelper::isTokenType(const std::deque<Token>& input, Token::TokenType type) {
 	return input.front().getType() == type;
 }
 
-void FromXMLParserHelper::popToken(std::list<Token>& input, Token::TokenType type, std::string data) {
+void FromXMLParserHelper::popToken(std::deque<Token>& input, Token::TokenType type, const std::string& data) {
 	if (isToken(input, type, data)) {
 		input.pop_front();
 	} else {
@@ -26,9 +26,9 @@ void FromXMLParserHelper::popToken(std::list<Token>& input, Token::TokenType typ
 	}
 }
 
-std::string FromXMLParserHelper::popTokenData(std::list<Token>& input, Token::TokenType type) {
+std::string FromXMLParserHelper::popTokenData(std::deque<Token>& input, Token::TokenType type) {
 	if(isTokenType(input, type)) {
-		std::string result = input.front().getData();
+		std::string result = std::move(input.front().getData());
 		input.pop_front();
 		return std::move(result);
 	} else {
diff --git a/alib2data/src/sax/FromXMLParserHelper.h b/alib2data/src/sax/FromXMLParserHelper.h
index ad85e3d317496af9f4e2f8f82526d32ec229fa8b..0813ba180b288eb832f5881ebeaabf605615f020 100644
--- a/alib2data/src/sax/FromXMLParserHelper.h
+++ b/alib2data/src/sax/FromXMLParserHelper.h
@@ -8,7 +8,7 @@
 #ifndef FROM_XML_PARSER_HELPER_H_
 #define FROM_XML_PARSER_HELPER_H_
 
-#include <list>
+#include <deque>
 #include "Token.h"
 
 namespace sax {
@@ -18,10 +18,10 @@ namespace sax {
  */
 class FromXMLParserHelper {
 public:
-	static bool isToken(const std::list<Token>& input, Token::TokenType type, std::string data);
-	static bool isTokenType(const std::list<Token>& input, Token::TokenType type);
-	static void popToken(std::list<Token>& input, Token::TokenType type, std::string data);
-	static std::string popTokenData(std::list<Token>& input, Token::TokenType type);
+	static bool isToken(const std::deque<Token>& input, Token::TokenType type, const std::string& data);
+	static bool isTokenType(const std::deque<Token>& input, Token::TokenType type);
+	static void popToken(std::deque<Token>& input, Token::TokenType type, const std::string& data);
+	static std::string popTokenData(std::deque<Token>& input, Token::TokenType type);
 
 };
 
diff --git a/alib2data/src/sax/SaxComposeInterface.cpp b/alib2data/src/sax/SaxComposeInterface.cpp
index d7ae20faf8c5ac8b48642d92b4a69c43e32ca4f8..bc27ecc1a32d3d6507f5a91fbb0bca52a70c0a6a 100644
--- a/alib2data/src/sax/SaxComposeInterface.cpp
+++ b/alib2data/src/sax/SaxComposeInterface.cpp
@@ -16,7 +16,7 @@
 
 namespace sax {
 
-void SaxComposeInterface::printMemory(std::string& xmlOut, const std::list<Token>& in) {
+void SaxComposeInterface::printMemory(std::string& xmlOut, const std::deque<Token>& in) {
 	xmlBufferPtr buf = xmlBufferCreate();
 	xmlTextWriterPtr writer = xmlNewTextWriterMemory(buf, 0);
 
@@ -27,7 +27,7 @@ void SaxComposeInterface::printMemory(std::string& xmlOut, const std::list<Token
 	xmlBufferFree(buf);
 }
 
-void SaxComposeInterface::printFile(const std::string& filename, const std::list<Token>& in) {
+void SaxComposeInterface::printFile(const std::string& filename, const std::deque<Token>& in) {
 	xmlTextWriterPtr writer = xmlNewTextWriterFilename(filename.c_str(), 0);
 
 	SaxComposeInterface::xmlSAXUserPrint(writer, in);
@@ -35,11 +35,11 @@ void SaxComposeInterface::printFile(const std::string& filename, const std::list
 	xmlFreeTextWriter(writer);
 }
 
-void SaxComposeInterface::printStdout(const std::list<Token>& in) {
+void SaxComposeInterface::printStdout(const std::deque<Token>& in) {
 	SaxComposeInterface::printFile("-", in);
 }
 
-void SaxComposeInterface::printStream(std::ostream& out, const std::list<Token>& in) {
+void SaxComposeInterface::printStream(std::ostream& out, const std::deque<Token>& in) {
 	xmlBufferPtr buf = xmlBufferCreate();
 	xmlTextWriterPtr writer = xmlNewTextWriterMemory(buf, 0);
 
@@ -50,7 +50,7 @@ void SaxComposeInterface::printStream(std::ostream& out, const std::list<Token>&
 	xmlBufferFree(buf);
 }
 
-void SaxComposeInterface::xmlSAXUserPrint(xmlTextWriterPtr writer, const std::list<Token>& in) {
+void SaxComposeInterface::xmlSAXUserPrint(xmlTextWriterPtr writer, const std::deque<Token>& in) {
 	xmlTextWriterStartDocument(writer, NULL, NULL, NULL);
 	std::deque<Token> stack;
 	for(const Token& token : in) {
diff --git a/alib2data/src/sax/SaxComposeInterface.h b/alib2data/src/sax/SaxComposeInterface.h
index 312eea82aa2b82ac6673aa051a23a85fb40317b2..78dce65402b09fff8e5223b213329785826d960d 100644
--- a/alib2data/src/sax/SaxComposeInterface.h
+++ b/alib2data/src/sax/SaxComposeInterface.h
@@ -9,7 +9,7 @@
 #define SAX_COMPOSE_INTERFACE_H_
 
 #include <libxml/xmlwriter.h>
-#include <list>
+#include <deque>
 #include "Token.h"
 
 namespace sax {
@@ -19,7 +19,7 @@ namespace sax {
  * methods for libxml SAX parser.
  */
 class SaxComposeInterface {
-	static void xmlSAXUserPrint(xmlTextWriterPtr writer, const std::list<Token>& in);
+	static void xmlSAXUserPrint(xmlTextWriterPtr writer, const std::deque<Token>& in);
 public:
 	/**
 	 * Parses the string containing XML.
@@ -27,7 +27,7 @@ public:
 	 * @param out list of tokens that are returned
 	 * @throws AlibException when an error occurs (e.g. XML is not valid)
 	 */
-	static void printMemory(std::string& xmlOut, const std::list<Token>& in);
+	static void printMemory(std::string& xmlOut, const std::deque<Token>& in);
 
 	/**
 	 * Parses the file containing XML.
@@ -35,20 +35,20 @@ public:
 	 * @param out list of tokens that are returned
 	 * @throws AlibException when an error occurs (e.g. file doesn't exist, XML is not valid)
 	 */
-	static void printFile(const std::string& filename, const std::list<Token>& in);
+	static void printFile(const std::string& filename, const std::deque<Token>& in);
 	
 	/**
 	 * Parses the XML from stdin.
 	 * @param out list of tokens that are returned
 	 */
-	static void printStdout(const std::list<Token>& in);
+	static void printStdout(const std::deque<Token>& in);
 	
 	/**
 	 * Parses the XML from stream.
 	 * @param in input XML
 	 * @param out list of tokens that are returned
 	 */
-	static void printStream(std::ostream& out, const std::list<Token>& in);
+	static void printStream(std::ostream& out, const std::deque<Token>& in);
 };
 
 } /* namespace sax */
diff --git a/alib2data/src/sax/SaxParseInterface.cpp b/alib2data/src/sax/SaxParseInterface.cpp
index 88c4968ad1d5b1a20d7156c88c345ca5b0fac2ac..bc7279c40d22851199e409d329f27ac5ce0638f8 100644
--- a/alib2data/src/sax/SaxParseInterface.cpp
+++ b/alib2data/src/sax/SaxParseInterface.cpp
@@ -25,7 +25,7 @@ void SaxParseInterface::initSAXHandler(xmlSAXHandler& handler) {
 	handler.characters = &sax::SaxParseInterface::characters;
 }
 
-void SaxParseInterface::parseMemory(const std::string& xmlIn, std::list<Token>& out) {
+void SaxParseInterface::parseMemory(const std::string& xmlIn, std::deque<Token>& out) {
 	xmlSAXHandler handler;
 	initSAXHandler(handler);
 
@@ -37,7 +37,7 @@ void SaxParseInterface::parseMemory(const std::string& xmlIn, std::list<Token>&
 	}
 }
 
-void SaxParseInterface::parseFile(const std::string& filename, std::list<Token>& out) {
+void SaxParseInterface::parseFile(const std::string& filename, std::deque<Token>& out) {
 	xmlSAXHandler handler;
 	initSAXHandler(handler);
 
@@ -49,24 +49,24 @@ void SaxParseInterface::parseFile(const std::string& filename, std::list<Token>&
 	}
 }
 
-void SaxParseInterface::parseStdin(std::list<Token>& out) {
+void SaxParseInterface::parseStdin(std::deque<Token>& out) {
 	SaxParseInterface::parseFile("-", out);
 }
 
-void SaxParseInterface::parseStream(std::istream& in, std::list<Token>& out) {
+void SaxParseInterface::parseStream(std::istream& in, std::deque<Token>& out) {
 	std::string input(std::istreambuf_iterator<char>(in), (std::istreambuf_iterator<char>()));
 	SaxParseInterface::parseMemory(input, out);
 }
 
 void SaxParseInterface::characters(void * userData, const xmlChar * ch, int len) {
-	std::list<Token> &out = *((std::list<Token>*) userData);
+	std::deque<Token> &out = *((std::deque<Token>*) userData);
 	std::string tmp((const char*) ch, len);
 
 	if(! std::all_of(tmp.begin(), tmp.end(), isspace)) out.push_back(Token(std::move(tmp), Token::TokenType::CHARACTER));
 }
 
 void SaxParseInterface::startElement(void* userData, const xmlChar* name, const xmlChar** attrs) {
-	std::list<Token> &out = *((std::list<Token>*) userData);
+	std::deque<Token> &out = *((std::deque<Token>*) userData);
 	out.push_back(Token((const char*) name, Token::TokenType::START_ELEMENT));
 
 	while(attrs && *attrs && *(attrs+1)) {
@@ -80,7 +80,7 @@ void SaxParseInterface::startElement(void* userData, const xmlChar* name, const
 }
 
 void SaxParseInterface::endElement(void * userData, const xmlChar * name) {
-	std::list<Token> &out = *((std::list<Token>*) userData);
+	std::deque<Token> &out = *((std::deque<Token>*) userData);
 	out.push_back(Token((const  char*) name, Token::TokenType::END_ELEMENT));
 }
 
diff --git a/alib2data/src/sax/SaxParseInterface.h b/alib2data/src/sax/SaxParseInterface.h
index 95d7ad45e10d42c6b3c76665afda617dc0cd65a9..345b89fed7d1475eb8ae4e43eac2ba0df5e24153 100644
--- a/alib2data/src/sax/SaxParseInterface.h
+++ b/alib2data/src/sax/SaxParseInterface.h
@@ -9,7 +9,7 @@
 #define SAX_PARSE_INTERFACE_H_
 
 #include <libxml/parser.h>
-#include <list>
+#include <deque>
 #include "Token.h"
 
 namespace sax {
@@ -19,7 +19,6 @@ namespace sax {
  * methods for libxml SAX parser.
  */
 class SaxParseInterface {
-
 protected:
 	/**
 	 * Initializes the SAX parser.
@@ -56,7 +55,7 @@ public:
 	 * @param out list of tokens that are returned
 	 * @throws AlibException when an error occurs (e.g. XML is not valid)
 	 */
-	static void parseMemory(const std::string& xmlIn, std::list<Token>& out);
+	static void parseMemory(const std::string& xmlIn, std::deque<Token>& out);
 
 	/**
 	 * Parses the file containing XML.
@@ -64,20 +63,20 @@ public:
 	 * @param out list of tokens that are returned
 	 * @throws AlibException when an error occurs (e.g. file doesn't exist, XML is not valid)
 	 */
-	static void parseFile(const std::string& filename, std::list<Token>& out);
+	static void parseFile(const std::string& filename, std::deque<Token>& out);
 	
 	/**
 	 * Parses the XML from stdin.
 	 * @param out list of tokens that are returned
 	 */
-	static void parseStdin(std::list<Token>& out);
+	static void parseStdin(std::deque<Token>& out);
 	
 	/**
 	 * Parses the XML from stream.
 	 * @param in input XML
 	 * @param out list of tokens that are returned
 	 */
-	static void parseStream(std::istream& in, std::list<Token>& out);
+	static void parseStream(std::istream& in, std::deque<Token>& out);
 };
 
 } /* namespace sax */
diff --git a/alib2data/src/std/deque.hpp b/alib2data/src/std/deque.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b649e2e06bd8d60a8111c5c12fd3d6a1bfb24c6f
--- /dev/null
+++ b/alib2data/src/std/deque.hpp
@@ -0,0 +1,41 @@
+#ifndef __DEQUE_HPP_
+#define __DEQUE_HPP_
+
+#include <deque>
+
+namespace std {
+
+template< class T >
+std::ostream& operator<<(std::ostream& out, const std::deque<T>& list);
+
+}
+
+#include "set.hpp"
+#include "map.hpp"
+#include "pair.hpp"
+#include "list.hpp"
+#include "tuple.hpp"
+#include "vector.hpp"
+#include <iostream>
+
+namespace std {
+
+template< class T >
+std::ostream& operator<<(std::ostream& out, const std::deque<T>& list) {
+	out << "[";
+
+	bool first = true;
+	for(const T& item : list) {
+		if(!first) out << ", ";
+		first = false;
+		out << item;
+	}
+
+	out << "]";
+	return out;
+}
+
+} /* namespace std */
+
+#endif /* __DEQUE_HPP_ */
+
diff --git a/alib2data/src/std/list.hpp b/alib2data/src/std/list.hpp
index 4eb2961e46d2772fc9c6723eb35e3d9abecc9e5a..4e37432e6292779910b9c065cd38a84039094799 100644
--- a/alib2data/src/std/list.hpp
+++ b/alib2data/src/std/list.hpp
@@ -10,6 +10,7 @@ std::ostream& operator<<(std::ostream& out, const std::list<T>& list);
 
 }
 
+#include "deque.hpp"
 #include "set.hpp"
 #include "map.hpp"
 #include "pair.hpp"
diff --git a/alib2data/src/std/map.hpp b/alib2data/src/std/map.hpp
index a67dc66080281ab30e4f648fac90fc1980e555df..c968dbf65e53019b1406e221269d20974c7b0de9 100644
--- a/alib2data/src/std/map.hpp
+++ b/alib2data/src/std/map.hpp
@@ -10,6 +10,7 @@ std::ostream& operator<<(std::ostream& out, const std::map<T, R>& map);
 
 }
 
+#include "deque.hpp"
 #include "set.hpp"
 #include "pair.hpp"
 #include "list.hpp"
diff --git a/alib2data/src/std/pair.hpp b/alib2data/src/std/pair.hpp
index e89d9da77db2fa54a43d742968b849c02be058ae..a1a7e4eb5245d72d058eda2bacbdbad8d90738d2 100644
--- a/alib2data/src/std/pair.hpp
+++ b/alib2data/src/std/pair.hpp
@@ -10,6 +10,7 @@ std::ostream& operator<<(std::ostream& out, const std::pair<T, R>& pair);
 
 }
 
+#include "deque.hpp"
 #include "set.hpp"
 #include "map.hpp"
 #include "list.hpp"
diff --git a/alib2data/src/std/set.hpp b/alib2data/src/std/set.hpp
index 80778d143db13a825d67673075ab173c4d1c13b1..968c901515a909705a0364cceac54428ec7d1876 100644
--- a/alib2data/src/std/set.hpp
+++ b/alib2data/src/std/set.hpp
@@ -10,6 +10,7 @@ std::ostream& operator<<(std::ostream& out, const std::set<T>& list);
 
 }
 
+#include "deque.hpp"
 #include "map.hpp"
 #include "pair.hpp"
 #include "list.hpp"
diff --git a/alib2data/src/std/tuple.hpp b/alib2data/src/std/tuple.hpp
index 93396f3188087e9196f02bbe6da33f2ea6f56ccc..1c10279aaf2f0e9fe2cb0b5477250389298a3208 100644
--- a/alib2data/src/std/tuple.hpp
+++ b/alib2data/src/std/tuple.hpp
@@ -10,6 +10,7 @@ std::ostream& operator<<(std::ostream& out, const std::tuple<Ts...>& tuple);
 
 }
 
+#include "deque.hpp"
 #include "set.hpp"
 #include "map.hpp"
 #include "list.hpp"
diff --git a/alib2data/src/std/vector.hpp b/alib2data/src/std/vector.hpp
index 3a996d2925164b8a99359588c3ed3ab672bbd3fb..f5c76371af3af2c86993b2476ab8eaab4ccf5478 100644
--- a/alib2data/src/std/vector.hpp
+++ b/alib2data/src/std/vector.hpp
@@ -10,6 +10,7 @@ std::ostream& operator<<(std::ostream& out, const std::vector<T>& vector);
 
 }
 
+#include "deque.hpp"
 #include "set.hpp"
 #include "map.hpp"
 #include "pair.hpp"
diff --git a/alib2data/src/string/StringFromXMLParser.cpp b/alib2data/src/string/StringFromXMLParser.cpp
index 6d7ab8b0844e90b56e98ad5d3e67a35d02e12066..62a8716dfb4e8699049c99374e1b7bc3cd3e8e4c 100644
--- a/alib2data/src/string/StringFromXMLParser.cpp
+++ b/alib2data/src/string/StringFromXMLParser.cpp
@@ -12,11 +12,11 @@
 
 namespace string {
 
-String StringFromXMLParser::parseString(std::list<sax::Token>& input) const {
+String StringFromXMLParser::parseString(std::deque<sax::Token>& input) const {
 	return parseString(input, std::set<FEATURES>({FEATURES::LINEAR, FEATURES::CYCLIC, FEATURES::EPSILON}));
 }
 
-String StringFromXMLParser::parseString(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+String StringFromXMLParser::parseString(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
 	if(alib::xmlApi<Epsilon>::first(input)) {
 		if(!features.count(FEATURES::EPSILON)) throw exception::AlibException();
 		return String(parseEpsilon(input));
@@ -31,7 +31,7 @@ String StringFromXMLParser::parseString(std::list<sax::Token>& input, const std:
 	}
 }
 
-bool StringFromXMLParser::first(const std::list<sax::Token>& input) const {
+bool StringFromXMLParser::first(const std::deque<sax::Token>& input) const {
 	if(alib::xmlApi<Epsilon>::first(input) || alib::xmlApi<LinearString>::first(input) || alib::xmlApi<CyclicString>::first(input)) {
 		return true;
 	} else {
@@ -39,7 +39,7 @@ bool StringFromXMLParser::first(const std::list<sax::Token>& input) const {
 	}
 }
 
-LinearString StringFromXMLParser::parseLinearString(std::list<sax::Token>& input) const {
+LinearString StringFromXMLParser::parseLinearString(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_LINEAR_STRING);
 
 	LinearString string;
@@ -50,7 +50,7 @@ LinearString StringFromXMLParser::parseLinearString(std::list<sax::Token>& input
 	return string;
 }
 
-CyclicString StringFromXMLParser::parseCyclicString(std::list<sax::Token>& input) const {
+CyclicString StringFromXMLParser::parseCyclicString(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_CYCLIC_STRING);
 
 	CyclicString string;
@@ -61,7 +61,7 @@ CyclicString StringFromXMLParser::parseCyclicString(std::list<sax::Token>& input
 	return string;
 }
 
-Epsilon StringFromXMLParser::parseEpsilon(std::list<sax::Token>& input) const {
+Epsilon StringFromXMLParser::parseEpsilon(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_EPSILON);
 
 	Epsilon epsilon;
@@ -71,7 +71,7 @@ Epsilon StringFromXMLParser::parseEpsilon(std::list<sax::Token>& input) const {
 	return epsilon;
 }
 
-std::set<alphabet::Symbol> StringFromXMLParser::parseAlphabet(std::list<sax::Token> &input) const {
+std::set<alphabet::Symbol> StringFromXMLParser::parseAlphabet(std::deque<sax::Token> &input) const {
 	std::set<alphabet::Symbol> alphabet;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
@@ -81,7 +81,7 @@ std::set<alphabet::Symbol> StringFromXMLParser::parseAlphabet(std::list<sax::Tok
 	return alphabet;
 }
 
-std::vector<alphabet::Symbol> StringFromXMLParser::parseContentData(std::list<sax::Token>& input) const {
+std::vector<alphabet::Symbol> StringFromXMLParser::parseContentData(std::deque<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> data;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "content");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
diff --git a/alib2data/src/string/StringFromXMLParser.h b/alib2data/src/string/StringFromXMLParser.h
index a0fee62b616edfbdec904fc891b6fd54db5dcc9e..de39d369fd0f71c3341cd56589b77982f0ce4e6e 100644
--- a/alib2data/src/string/StringFromXMLParser.h
+++ b/alib2data/src/string/StringFromXMLParser.h
@@ -32,19 +32,19 @@ namespace string {
  * Parser used to get String from XML parsed into list of tokens.
  */
 class StringFromXMLParser : public sax::FromXMLParserHelper {
-	std::vector<alphabet::Symbol> parseContentData(std::list<sax::Token>& input) const;
-	std::set<alphabet::Symbol> parseAlphabet(std::list<sax::Token> &input) const;
+	std::vector<alphabet::Symbol> parseContentData(std::deque<sax::Token>& input) const;
+	std::set<alphabet::Symbol> parseAlphabet(std::deque<sax::Token> &input) const;
 
-	String parseString(std::list<sax::Token>& input) const;
-	String parseString(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+	String parseString(std::deque<sax::Token>& input) const;
+	String parseString(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const;
 
-	LinearString parseLinearString(std::list<sax::Token>& input) const;
-	CyclicString parseCyclicString(std::list<sax::Token>& input) const;
-	Epsilon parseEpsilon(std::list<sax::Token>& input) const;
+	LinearString parseLinearString(std::deque<sax::Token>& input) const;
+	CyclicString parseCyclicString(std::deque<sax::Token>& input) const;
+	Epsilon parseEpsilon(std::deque<sax::Token>& input) const;
 
 	template<typename T> friend class alib::xmlApi;
 public:
-	bool first(const std::list<sax::Token>& input) const;
+	bool first(const std::deque<sax::Token>& input) const;
 };
 
 } /* namespace string */
diff --git a/alib2data/src/string/StringToXMLComposer.cpp b/alib2data/src/string/StringToXMLComposer.cpp
index 92cf2938e61c40929f6b74c29dd15e0da4b1efe6..1a69ab25ad618510bba856c5826c3a8bd9d3fdd2 100644
--- a/alib2data/src/string/StringToXMLComposer.cpp
+++ b/alib2data/src/string/StringToXMLComposer.cpp
@@ -14,15 +14,15 @@
 
 namespace string {
 
-void StringToXMLComposer::compose(std::list<sax::Token>& out, const String& string) const {
+void StringToXMLComposer::compose(std::deque<sax::Token>& out, const String& string) const {
 	string.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void StringToXMLComposer::compose(std::list<sax::Token>& out, const StringBase& string) const {
+void StringToXMLComposer::compose(std::deque<sax::Token>& out, const StringBase& string) const {
 	string.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
 }
 
-void StringToXMLComposer::compose(std::list<sax::Token>& out, const LinearString& string) const {
+void StringToXMLComposer::compose(std::deque<sax::Token>& out, const LinearString& string) const {
 	out.push_back(sax::Token(alib::Names::STRING_LINEAR_STRING, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol: string.getAlphabet()) {
@@ -38,7 +38,7 @@ void StringToXMLComposer::compose(std::list<sax::Token>& out, const LinearString
 	out.push_back(sax::Token(alib::Names::STRING_LINEAR_STRING, sax::Token::TokenType::END_ELEMENT));
 }
 
-void StringToXMLComposer::compose(std::list<sax::Token>& out, const CyclicString& string) const {
+void StringToXMLComposer::compose(std::deque<sax::Token>& out, const CyclicString& string) const {
 	out.push_back(sax::Token(alib::Names::STRING_CYCLIC_STRING, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol: string.getAlphabet()) {
@@ -54,7 +54,7 @@ void StringToXMLComposer::compose(std::list<sax::Token>& out, const CyclicString
 	out.push_back(sax::Token(alib::Names::STRING_CYCLIC_STRING, sax::Token::TokenType::END_ELEMENT));
 }
 
-void StringToXMLComposer::compose(std::list<sax::Token>& out, const Epsilon& string) const {
+void StringToXMLComposer::compose(std::deque<sax::Token>& out, const Epsilon& string) const {
 	out.push_back(sax::Token(alib::Names::STRING_EPSILON, sax::Token::TokenType::START_ELEMENT));
 	out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& symbol: string.getAlphabet()) {
diff --git a/alib2data/src/string/StringToXMLComposer.h b/alib2data/src/string/StringToXMLComposer.h
index 3403bf14efa07972ccd0943842616d126e4e679c..5ad49d53377baa2009b745e1f220727b580380cc 100644
--- a/alib2data/src/string/StringToXMLComposer.h
+++ b/alib2data/src/string/StringToXMLComposer.h
@@ -8,7 +8,7 @@
 #ifndef STRING_TO_XML_COMPOSER_H_
 #define STRING_TO_XML_COMPOSER_H_
 
-#include <list>
+#include <deque>
 #include "String.h"
 #include "../sax/Token.h"
 #include "../alphabet/Symbol.h"
@@ -31,18 +31,18 @@ class StringToXMLComposer {
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const StringBase& string) const;
+	void compose(std::deque<sax::Token>& out, const StringBase& string) const;
 
 	/**
 	 * Prints XML representation of String to the output stream.
 	 * @param string String to print
 	 * @param out output stream to which print the String
 	 */
-	void compose(std::list<sax::Token>& out, const String& string) const;
+	void compose(std::deque<sax::Token>& out, const String& string) const;
 
-	void compose(std::list<sax::Token>& out, const LinearString& string) const;
-	void compose(std::list<sax::Token>& out, const CyclicString& string) const;
-	void compose(std::list<sax::Token>& out, const Epsilon& string) const;
+	void compose(std::deque<sax::Token>& out, const LinearString& string) const;
+	void compose(std::deque<sax::Token>& out, const CyclicString& string) const;
+	void compose(std::deque<sax::Token>& out, const Epsilon& string) const;
 
 	template<typename T> friend class alib::xmlApi;
 };
diff --git a/alib2data/test-src/alphabet/SymbolTest.cpp b/alib2data/test-src/alphabet/SymbolTest.cpp
index 3bb705d236ec9372e6f1a31ec381d773bb60dcb4..abdec2a3cd47845efcb048ea1136a3b8300d3866 100644
--- a/alib2data/test-src/alphabet/SymbolTest.cpp
+++ b/alib2data/test-src/alphabet/SymbolTest.cpp
@@ -79,11 +79,11 @@ void SymbolTest::testXMLParser() {
 	alphabet::Symbol symbol = alphabet::symbolFrom("1");
 
 	{
-		std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(symbol);
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(symbol);
 		std::string tmp;
 		sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-		std::list<sax::Token> tokens2;
+		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
 		alphabet::Symbol symbol2 = alib::XmlDataFactory::fromTokens<alphabet::Symbol>(tokens2);
 
diff --git a/alib2data/test-src/automaton/AutomatonTest.cpp b/alib2data/test-src/automaton/AutomatonTest.cpp
index d631faa845b46d5981862d583f15660addb6529a..8b571818cfe0a00baf47069d06c8e4e65d8946cd 100644
--- a/alib2data/test-src/automaton/AutomatonTest.cpp
+++ b/alib2data/test-src/automaton/AutomatonTest.cpp
@@ -47,11 +47,11 @@ void AutomatonTest::testDFAParser() {
 
 	CPPUNIT_ASSERT( automaton == automaton );
 	{
-		std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(automaton);
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(automaton);
 		std::string tmp;
 		sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-		std::list<sax::Token> tokens2;
+		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
 		automaton::DFA automaton2 = alib::XmlDataFactory::fromTokens<automaton::DFA>(tokens2);
 
diff --git a/alib2data/test-src/grammar/GrammarTest.cpp b/alib2data/test-src/grammar/GrammarTest.cpp
index cfad5bd05e74c32ff257eb627f20e8ce5a7ea75c..a905842685e7334d85d42174e063512737f9749d 100644
--- a/alib2data/test-src/grammar/GrammarTest.cpp
+++ b/alib2data/test-src/grammar/GrammarTest.cpp
@@ -120,11 +120,11 @@ void GrammarTest::testUnrestrictedParser() {
 
 	CPPUNIT_ASSERT( grammar == grammar );
 	{
-		std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 		std::string tmp;
 		sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-		std::list<sax::Token> tokens2;
+		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
 		grammar::UnrestrictedGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::UnrestrictedGrammar>(tokens2);
 
@@ -146,11 +146,11 @@ void GrammarTest::testUnrestrictedParser() {
 		grammar.addRule(std::vector<alphabet::Symbol> {}, alphabet::symbolFrom(2), std::vector<alphabet::Symbol> {}, std::vector<alphabet::Symbol> {});
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::ContextPreservingUnrestrictedGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::ContextPreservingUnrestrictedGrammar>(tokens2);
 
@@ -174,11 +174,11 @@ void GrammarTest::testRegularParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::RightRG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightRG>(tokens2);
 
@@ -202,13 +202,13 @@ void GrammarTest::testRegularParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
 			std::cout << tmp << std::endl;
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::RightLG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightLG>(tokens2);
 
@@ -234,11 +234,11 @@ void GrammarTest::testContextFreeParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::LG grammar2 = alib::XmlDataFactory::fromTokens<grammar::LG>(tokens2);
 
@@ -262,11 +262,11 @@ void GrammarTest::testContextFreeParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::EpsilonFreeCFG grammar2 = alib::XmlDataFactory::fromTokens<grammar::EpsilonFreeCFG>(tokens2);
 
@@ -290,11 +290,11 @@ void GrammarTest::testContextFreeParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::CFG grammar2 = alib::XmlDataFactory::fromTokens<grammar::CFG>(tokens2);
 
@@ -318,11 +318,11 @@ void GrammarTest::testContextFreeParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::CNF grammar2 = alib::XmlDataFactory::fromTokens<grammar::CNF>(tokens2);
 
@@ -346,11 +346,11 @@ void GrammarTest::testContextFreeParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::GNF grammar2 = alib::XmlDataFactory::fromTokens<grammar::GNF>(tokens2);
 
@@ -376,11 +376,11 @@ void GrammarTest::testContextSensitiveParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::CSG grammar2 = alib::XmlDataFactory::fromTokens<grammar::CSG>(tokens2);
 
@@ -403,11 +403,11 @@ void GrammarTest::testContextSensitiveParser() {
 
 		CPPUNIT_ASSERT( grammar == grammar );
 		{
-			std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+			std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-			std::list<sax::Token> tokens2;
+			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::NonContractingGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::NonContractingGrammar>(tokens2);
 
diff --git a/alib2data/test-src/label/LabelTest.cpp b/alib2data/test-src/label/LabelTest.cpp
index 1bad0384c6e905b39a22f30a20f89f20d5560728..9ddb568e3d926dcd526a73208dc026d494f1f278 100644
--- a/alib2data/test-src/label/LabelTest.cpp
+++ b/alib2data/test-src/label/LabelTest.cpp
@@ -94,21 +94,21 @@ void LabelTest::testXMLParser() {
 	label::Label label = label::labelFrom("1");
 
 	{
-	std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(label);
-	std::string tmp;
-	sax::SaxComposeInterface::printMemory(tmp, tokens);
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(label);
+		std::string tmp;
+		sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-	std::list<sax::Token> tokens2;
-	sax::SaxParseInterface::parseMemory(tmp, tokens2);
-	label::Label label2 = alib::XmlDataFactory::fromTokens<label::Label>(tokens2);
+		std::deque<sax::Token> tokens2;
+		sax::SaxParseInterface::parseMemory(tmp, tokens2);
+		label::Label label2 = alib::XmlDataFactory::fromTokens<label::Label>(tokens2);
 
-	CPPUNIT_ASSERT( label == label2 );
+		CPPUNIT_ASSERT( label == label2 );
 	}
 	{
-	std::string tmp = alib::XmlDataFactory::toString(label);
-	label::Label label2 = alib::XmlDataFactory::fromString<label::Label>(tmp);
+		std::string tmp = alib::XmlDataFactory::toString(label);
+		label::Label label2 = alib::XmlDataFactory::fromString<label::Label>(tmp);
 
-	CPPUNIT_ASSERT( label == label2 );
+		CPPUNIT_ASSERT( label == label2 );
 	}
 }
 
diff --git a/alib2data/test-src/primitive/PrimitiveTest.cpp b/alib2data/test-src/primitive/PrimitiveTest.cpp
index 2ea33701f430c817a5b7f1fda9aadeeec44f3d2c..53a597993ef1729b9f5e25d970f95e0931eaccba 100644
--- a/alib2data/test-src/primitive/PrimitiveTest.cpp
+++ b/alib2data/test-src/primitive/PrimitiveTest.cpp
@@ -27,12 +27,12 @@ void PrimitiveTest::testXMLParser() {
 	std::cout << primitive << std::endl;
 
 	{
-		std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(primitive);
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(primitive);
 		std::cout << tokens << std::endl;
 		std::string tmp;
 		sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-		std::list<sax::Token> tokens2;
+		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
 		primitive::Primitive primitive2 = alib::XmlDataFactory::fromTokens<primitive::Primitive>(tokens2);
 
diff --git a/alib2data/test-src/regexp/RegExpTest.cpp b/alib2data/test-src/regexp/RegExpTest.cpp
index d8ed5f7d589d7100c1b9210dff118cbb4d2d9f39..19c56cfbd09232f19c0243d3152a4a38cc77a3a5 100644
--- a/alib2data/test-src/regexp/RegExpTest.cpp
+++ b/alib2data/test-src/regexp/RegExpTest.cpp
@@ -135,21 +135,21 @@ void RegExpTest::testXMLParser() {
 	regexp::RegExp regexp(unboundedRegexp);
 
 	{
-	std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(regexp);
-	std::string tmp;
-	sax::SaxComposeInterface::printMemory(tmp, tokens);
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(regexp);
+		std::string tmp;
+		sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-	std::list<sax::Token> tokens2;
-	sax::SaxParseInterface::parseMemory(tmp, tokens2);
-	regexp::RegExp regexp2 = alib::XmlDataFactory::fromTokens<regexp::RegExp>(tokens2);
+		std::deque<sax::Token> tokens2;
+		sax::SaxParseInterface::parseMemory(tmp, tokens2);
+		regexp::RegExp regexp2 = alib::XmlDataFactory::fromTokens<regexp::RegExp>(tokens2);
 
-	CPPUNIT_ASSERT( regexp == regexp2 );
+		CPPUNIT_ASSERT( regexp == regexp2 );
 	}
 	{
-	std::string tmp = alib::XmlDataFactory::toString(regexp);
-	regexp::RegExp regexp2 = alib::XmlDataFactory::fromString<regexp::RegExp>(tmp);
+		std::string tmp = alib::XmlDataFactory::toString(regexp);
+		regexp::RegExp regexp2 = alib::XmlDataFactory::fromString<regexp::RegExp>(tmp);
 
-	CPPUNIT_ASSERT( regexp == regexp2 );
+		CPPUNIT_ASSERT( regexp == regexp2 );
 	}
 }
 
diff --git a/alib2data/test-src/sax/SaxTest.cpp b/alib2data/test-src/sax/SaxTest.cpp
index db2dff393c4588260e135a570a0e569d03322f1d..5f33b9cf59cd10fee452b3077d94864ffedf054d 100644
--- a/alib2data/test-src/sax/SaxTest.cpp
+++ b/alib2data/test-src/sax/SaxTest.cpp
@@ -18,8 +18,8 @@ void SaxTest::tearDown() {
 
 void SaxTest::testSax() {
 	std::string tmp = "<?xml version=\"1.0\"?>\n<aa bb=\"cc\"><xx/>dd</aa>\n";
-	
-	std::list<sax::Token> tokens;
+
+	std::deque<sax::Token> tokens;
 	sax::SaxParseInterface::parseMemory(tmp, tokens);
 
 	std::string tmp2;
@@ -27,7 +27,7 @@ void SaxTest::testSax() {
 
 	CPPUNIT_ASSERT( tmp == tmp2 );
 
-	std::list<sax::Token> tokens2;
+	std::deque<sax::Token> tokens2;
 	sax::SaxParseInterface::parseMemory(tmp2, tokens2);
 
 	CPPUNIT_ASSERT( tokens == tokens2 );
diff --git a/alib2data/test-src/string/StringTest.cpp b/alib2data/test-src/string/StringTest.cpp
index d5bcc9a1c0ebd405349454839963809aa5a0aafb..3f22c807121e5dd7aea7df1a89789504c8ade8b7 100644
--- a/alib2data/test-src/string/StringTest.cpp
+++ b/alib2data/test-src/string/StringTest.cpp
@@ -88,21 +88,21 @@ void StringTest::testXMLParser() {
 
 	string::String string(linearString);
 	{
-	std::list<sax::Token> tokens = alib::XmlDataFactory::toTokens(string);
-	std::string tmp;
-	sax::SaxComposeInterface::printMemory(tmp, tokens);
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(string);
+		std::string tmp;
+		sax::SaxComposeInterface::printMemory(tmp, tokens);
 
-	std::list<sax::Token> tokens2;
-	sax::SaxParseInterface::parseMemory(tmp, tokens2);
-	string::String string2 = alib::XmlDataFactory::fromTokens<string::String>(tokens2);
+		std::deque<sax::Token> tokens2;
+		sax::SaxParseInterface::parseMemory(tmp, tokens2);
+		string::String string2 = alib::XmlDataFactory::fromTokens<string::String>(tokens2);
 
-	CPPUNIT_ASSERT( string == string2 );
+		CPPUNIT_ASSERT( string == string2 );
 	}
 	{
-	std::string tmp = alib::XmlDataFactory::toString(string);
-	string::String string2 = alib::XmlDataFactory::fromString<string::String>(tmp);
+		std::string tmp = alib::XmlDataFactory::toString(string);
+		string::String string2 = alib::XmlDataFactory::fromString<string::String>(tmp);
 
-	CPPUNIT_ASSERT( string == string2 );
+		CPPUNIT_ASSERT( string == string2 );
 	}
 }
 
diff --git a/aminimize2/src/aminimize.cpp b/aminimize2/src/aminimize.cpp
index 14ca9a8e62101de4b1d4e64690fcd771b7a4730b..1290a94677b78a982173cca99889aeba2819e510 100644
--- a/aminimize2/src/aminimize.cpp
+++ b/aminimize2/src/aminimize.cpp
@@ -28,7 +28,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/anormalize2/src/anormalize.cpp b/anormalize2/src/anormalize.cpp
index c7a56779872e8aa328f52369c2403b35ab38b3f3..b70a34215e9725ea296ec8da89df8a46679234a7 100644
--- a/anormalize2/src/anormalize.cpp
+++ b/anormalize2/src/anormalize.cpp
@@ -45,7 +45,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/arename2/src/arename.cpp b/arename2/src/arename.cpp
index c397faeb9651825fb7cbcf8aa2b2cc421eb11a26..af46fc99d647dddc7eee9dd62f09d79f7e621503 100644
--- a/arename2/src/arename.cpp
+++ b/arename2/src/arename.cpp
@@ -21,7 +21,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/areverse2/src/areverse.cpp b/areverse2/src/areverse.cpp
index 4c0ce749e749b30aa6819c0dd02712f2f1d6d427..1ced05b83760aaa98be37fbc0d91afb3f4e769b7 100644
--- a/areverse2/src/areverse.cpp
+++ b/areverse2/src/areverse.cpp
@@ -22,7 +22,7 @@ int main(int argc, char** argv) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/arun2/src/arun.cpp b/arun2/src/arun.cpp
index 6edb891bd7cde12a8e7ee6da628b5419a8276af5..8b6c58ba593a3eff73d908e925e5af15c1af4c31 100644
--- a/arun2/src/arun.cpp
+++ b/arun2/src/arun.cpp
@@ -37,7 +37,7 @@ int main(int argc, char* argv[]) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> inputTokens;
+		std::deque<sax::Token> inputTokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(inputTokens);
@@ -48,7 +48,7 @@ int main(int argc, char* argv[]) {
 			sax::SaxParseInterface::parseStdin(inputTokens);
 		}
 
-		std::list<sax::Token> automatonTokens;
+		std::deque<sax::Token> automatonTokens;
 		if(automaton.isSet()) {
 			if(automaton.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(automatonTokens);
diff --git a/astat2/src/astat.cpp b/astat2/src/astat.cpp
index 1b5ee749a7ba3fa7b0bd22e77f6cfb9f6ef53835..e5da34a2331ac4ce0cfc050fcb84d855cb6eba69 100644
--- a/astat2/src/astat.cpp
+++ b/astat2/src/astat.cpp
@@ -60,7 +60,7 @@ int main(int argc, char* argv[]) {
 
 		PrintingOptions printingOption = translatePrintingOptions(presentation.getValue());
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(file.isSet()) {
 			if(file.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);
diff --git a/astringology2/src/astringology.cpp b/astringology2/src/astringology.cpp
index 0cee72f59a765ba174271a4a5d0a685ede05bc63..c87d86ecbb201e8f5cf79190a3742a020dc0eb65 100644
--- a/astringology2/src/astringology.cpp
+++ b/astringology2/src/astringology.cpp
@@ -70,10 +70,10 @@ int main(int argc, char* argv[]) {
 		} else {
 		}
 
-		std::list<std::list<sax::Token>> subjectTokens;
+		std::deque<std::deque<sax::Token>> subjectTokens;
 		if(subject.isSet()) {
 			for(const std::string& fileName : subject.getValue()) {
-				std::list<sax::Token> tmp;
+				std::deque<sax::Token> tmp;
 				if(fileName == "-") {
 					sax::SaxParseInterface::parseStdin(tmp);
 				} else {
@@ -82,15 +82,15 @@ int main(int argc, char* argv[]) {
 				subjectTokens.emplace_back(std::move(tmp));
 			}
 		} else if(needSubject) {
-			std::list<sax::Token> tmp;
+			std::deque<sax::Token> tmp;
 			sax::SaxParseInterface::parseStdin(tmp);
 			subjectTokens.emplace_back(std::move(tmp));
 		}
 
-		std::list<std::list<sax::Token>> patternTokens;
+		std::deque<std::deque<sax::Token>> patternTokens;
 		if(pattern.isSet()) {
 			for(const std::string& fileName : pattern.getValue()) {
-				std::list<sax::Token> tmp;
+				std::deque<sax::Token> tmp;
 				if(fileName == "-") {
 					sax::SaxParseInterface::parseStdin(tmp);
 				} else {
@@ -99,7 +99,7 @@ int main(int argc, char* argv[]) {
 				patternTokens.emplace_back(std::move(tmp));
 			}
 		} else if(needPattern) {
-			std::list<sax::Token> tmp;
+			std::deque<sax::Token> tmp;
 			sax::SaxParseInterface::parseStdin(tmp);
 			patternTokens.emplace_back(std::move(tmp));
 		}
@@ -138,7 +138,7 @@ int main(int argc, char* argv[]) {
 			return 0;
 		} else if( algorithm.getValue() == "exactMultiNondeterministicSubsequenceAutomaton") {
 			std::set<string::String> subjects;
-			for(std::list<sax::Token>& tokens : subjectTokens) {
+			for(std::deque<sax::Token>& tokens : subjectTokens) {
 				subjects.insert(alib::XmlDataFactory::fromTokens<string::String>(tokens));
 			}
 			automaton::Automaton automaton = stringology::exact::ExactMultiNondeterministicSubsequenceAutomaton::construct(subjects);
diff --git a/atrim2/src/atrim.cpp b/atrim2/src/atrim.cpp
index 927ca8a8f01fc608e99f3fadf1de7d4f3fa9eaba..55363ffc7bb4d2fc1c0e778f92de4dce5e45a32f 100644
--- a/atrim2/src/atrim.cpp
+++ b/atrim2/src/atrim.cpp
@@ -76,7 +76,7 @@ int main(int argc, char* argv[]) {
 
 		cmd.parse(argc, argv);
 
-		std::list<sax::Token> tokens;
+		std::deque<sax::Token> tokens;
 		if(input.isSet()) {
 			if(input.getValue() == "-") {
 				sax::SaxParseInterface::parseStdin(tokens);