diff --git a/alib2data/src/alphabet/SymbolFromXMLParser.cpp b/alib2data/src/alphabet/SymbolFromXMLParser.cpp
index 48fe89007c43781c730befe5c9c374fcd18c88b5..f5a68a763cba20ea9494d1ab82082c7770e06271 100644
--- a/alib2data/src/alphabet/SymbolFromXMLParser.cpp
+++ b/alib2data/src/alphabet/SymbolFromXMLParser.cpp
@@ -72,7 +72,7 @@ LabeledSymbol SymbolFromXMLParser::parseLabeledSymbol(std::list<sax::Token>& inp
 	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(data);
+	return LabeledSymbol(std::move(data));
 }
 
 BlankSymbol SymbolFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input) const {
@@ -104,7 +104,7 @@ RankedSymbol SymbolFromXMLParser::parseRankedSymbol(std::list<sax::Token>& input
 	label::Label data = alib::xmlApi<label::Label>::parse(input);
 	primitive::Integer rank = alib::xmlApi<primitive::Integer>::parse(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_RANKED_SYMBOL);
-	return RankedSymbol(data, rank);
+	return RankedSymbol(std::move(data), std::move(rank));
 }
 
 BarSymbol SymbolFromXMLParser::parseBarSymbol(std::list<sax::Token>& input) const {
@@ -117,7 +117,7 @@ RankedBarSymbol SymbolFromXMLParser::parseRankedBarSymbol(std::list<sax::Token>&
 	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(rank);
+	return RankedBarSymbol(std::move(rank));
 }
 
 SubtreeWildcardSymbol SymbolFromXMLParser::parseSubtreeWildcardSymbol(std::list<sax::Token>& input) const {
@@ -132,9 +132,8 @@ SymbolSetSymbol SymbolFromXMLParser::parseSymbolSetSymbol(std::list<sax::Token>&
 	while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		labels.insert(parseSymbol(input));
 	}
-	SymbolSetSymbol data(labels);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_SYMBOL_SET_SYMBOL);
-	return data;
+	return SymbolSetSymbol(std::move(labels));
 }
 
 SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::list<sax::Token>& input) const {
@@ -143,20 +142,18 @@ SymbolPairSymbol SymbolFromXMLParser::parseSymbolPairSymbol(std::list<sax::Token
 	Symbol firstSymbol = parseSymbol(input);
 	Symbol secondSymbol = parseSymbol(input);
 
-	SymbolPairSymbol data(std::make_pair(firstSymbol, secondSymbol));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_SYMBOL_PAIR_SYMBOL);
-	return data;
+	return SymbolPairSymbol(std::make_pair(std::move(firstSymbol), std::move(secondSymbol)));
 }
 
 UniqueSymbol SymbolFromXMLParser::parseUniqueSymbol(std::list<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::ALPHABET_UNIQUE_SYMBOL);
-	
+
 	Symbol firstSymbol = parseSymbol(input);
 	primitive::Integer secondSymbol = alib::xmlApi<primitive::Integer>::parse(input);
 
-	UniqueSymbol data(firstSymbol, secondSymbol);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::ALPHABET_UNIQUE_SYMBOL);
-	return data;
+	return UniqueSymbol(std::move(firstSymbol), std::move(secondSymbol));
 }
 
 } /* namespace alphabet */
diff --git a/alib2data/src/automaton/AutomatonFromXMLParser.cpp b/alib2data/src/automaton/AutomatonFromXMLParser.cpp
index 4434411026d578dc9d416de6a2b11a6d56ffd63a..6dd8b9a98418c571bae997f1b1a4db54090bbc41 100644
--- a/alib2data/src/automaton/AutomatonFromXMLParser.cpp
+++ b/alib2data/src/automaton/AutomatonFromXMLParser.cpp
@@ -100,10 +100,10 @@ DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const {
 	State initialState = parseInitialState(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	DFA automaton(initialState);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setFinalStates(finalStates);
+	DFA automaton(std::move(initialState));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<DFA>(input, automaton);
 
@@ -119,10 +119,10 @@ NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const {
 	State initialState = parseInitialState(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	NFA automaton(initialState);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setFinalStates(finalStates);
+	NFA automaton(std::move(initialState));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<NFA>(input, automaton);
 
@@ -139,10 +139,10 @@ MultiInitialStateNFA AutomatonFromXMLParser::parseMultiInitialStateNFA(std::list
 	std::set<State> finalStates = parseFinalStates(input);
 
 	MultiInitialStateNFA automaton;
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setInitialStates(initialStates);
-	automaton.setFinalStates(finalStates);
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setInitialStates(std::move(initialStates));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<MultiInitialStateNFA>(input, automaton);
 
@@ -158,10 +158,10 @@ EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input)
 	State initialState = parseInitialState(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	EpsilonNFA automaton(initialState);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setFinalStates(finalStates);
+	EpsilonNFA automaton(std::move(initialState));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<EpsilonNFA>(input, automaton);
 
@@ -177,10 +177,10 @@ CompactNFA AutomatonFromXMLParser::parseCompactNFA(std::list<sax::Token>& input)
 	State initialState = parseInitialState(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	CompactNFA automaton(initialState);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setFinalStates(finalStates);
+	CompactNFA automaton(std::move(initialState));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<CompactNFA>(input, automaton);
 
@@ -196,10 +196,10 @@ ExtendedNFA AutomatonFromXMLParser::parseExtendedNFA(std::list<sax::Token>& inpu
 	State initialState = parseInitialState(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	ExtendedNFA automaton(initialState);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setFinalStates(finalStates);
+	ExtendedNFA automaton(std::move(initialState));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<ExtendedNFA>(input, automaton);
 
@@ -217,11 +217,11 @@ DPDA AutomatonFromXMLParser::parseDPDA(std::list<sax::Token>& input) const {
 	alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	DPDA automaton(initialState, initialStackSymbol);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setFinalStates(finalStates);
+	DPDA automaton(std::move(initialState), std::move(initialStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<DPDA>(input, automaton);
 
@@ -240,11 +240,11 @@ SinglePopDPDA AutomatonFromXMLParser::parseSinglePopDPDA(std::list<sax::Token>&
 	alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	SinglePopDPDA automaton(initialState, initialStackSymbol);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setFinalStates(finalStates);
+	SinglePopDPDA automaton(std::move(initialState), std::move(initialStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<SinglePopDPDA>(input, automaton);
 
@@ -263,11 +263,11 @@ InputDrivenDPDA AutomatonFromXMLParser::parseInputDrivenDPDA(std::list<sax::Toke
 	alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	InputDrivenDPDA automaton(initialState, initialStackSymbol);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setFinalStates(finalStates);
+	InputDrivenDPDA automaton(std::move(initialState), std::move(initialStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseInputToPushdownStoreOperation(input, automaton);
 	parseTransitions<InputDrivenDPDA>(input, automaton);
@@ -287,11 +287,11 @@ InputDrivenNPDA AutomatonFromXMLParser::parseInputDrivenNPDA(std::list<sax::Toke
 	alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	InputDrivenNPDA automaton(initialState, initialStackSymbol);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setFinalStates(finalStates);
+	InputDrivenNPDA automaton(std::move(initialState), std::move(initialStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseInputToPushdownStoreOperation(input, automaton);
 	parseTransitions<InputDrivenNPDA>(input, automaton);
@@ -313,13 +313,13 @@ VisiblyPushdownDPDA AutomatonFromXMLParser::parseVisiblyPushdownDPDA(std::list<s
 	alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	VisiblyPushdownDPDA automaton(initialState, bottomOfTheStackSymbol);
-	automaton.setStates(states);
-	automaton.setCallInputAlphabet(callInputAlphabet);
-	automaton.setReturnInputAlphabet(returnInputAlphabet);
-	automaton.setLocalInputAlphabet(localInputAlphabet);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setFinalStates(finalStates);
+	VisiblyPushdownDPDA automaton(std::move(initialState), std::move(bottomOfTheStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setCallInputAlphabet(std::move(callInputAlphabet));
+	automaton.setReturnInputAlphabet(std::move(returnInputAlphabet));
+	automaton.setLocalInputAlphabet(std::move(localInputAlphabet));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<VisiblyPushdownDPDA>(input, automaton);
 
@@ -340,14 +340,14 @@ VisiblyPushdownNPDA AutomatonFromXMLParser::parseVisiblyPushdownNPDA(std::list<s
 	alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	VisiblyPushdownNPDA automaton(bottomOfTheStackSymbol);
-	automaton.setStates(states);
-	automaton.setCallInputAlphabet(callInputAlphabet);
-	automaton.setReturnInputAlphabet(returnInputAlphabet);
-	automaton.setLocalInputAlphabet(localInputAlphabet);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setInitialStates(initialStates);
-	automaton.setFinalStates(finalStates);
+	VisiblyPushdownNPDA automaton(std::move(bottomOfTheStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setCallInputAlphabet(std::move(callInputAlphabet));
+	automaton.setReturnInputAlphabet(std::move(returnInputAlphabet));
+	automaton.setLocalInputAlphabet(std::move(localInputAlphabet));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setInitialStates(std::move(initialStates));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<VisiblyPushdownNPDA>(input, automaton);
 
@@ -366,11 +366,11 @@ RealTimeHeightDeterministicDPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
 	alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	RealTimeHeightDeterministicDPDA automaton(initialState, bottomOfTheStackSymbol);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setFinalStates(finalStates);
+	RealTimeHeightDeterministicDPDA automaton(std::move(initialState), std::move(bottomOfTheStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<RealTimeHeightDeterministicDPDA>(input, automaton);
 
@@ -389,12 +389,12 @@ RealTimeHeightDeterministicNPDA AutomatonFromXMLParser::parseRealTimeHeightDeter
 	alphabet::Symbol bottomOfTheStackSymbol = parseBottomOfTheStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	RealTimeHeightDeterministicNPDA automaton(bottomOfTheStackSymbol);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setInitialStates(initialStates);
-	automaton.setFinalStates(finalStates);
+	RealTimeHeightDeterministicNPDA automaton(std::move(bottomOfTheStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setInitialStates(std::move(initialStates));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<RealTimeHeightDeterministicNPDA>(input, automaton);
 
@@ -413,11 +413,11 @@ NPDA AutomatonFromXMLParser::parseNPDA(std::list<sax::Token>& input) const {
 	alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	NPDA automaton(initialState, initialStackSymbol);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setFinalStates(finalStates);
+	NPDA automaton(std::move(initialState), std::move(initialStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<NPDA>(input, automaton);
 
@@ -436,11 +436,11 @@ SinglePopNPDA AutomatonFromXMLParser::parseSinglePopNPDA(std::list<sax::Token>&
 	alphabet::Symbol initialStackSymbol = parseInitialStackSymbol(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	SinglePopNPDA automaton(initialState, initialStackSymbol);
-	automaton.setStates(states);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setStackAlphabet(stackSymbols);
-	automaton.setFinalStates(finalStates);
+	SinglePopNPDA automaton(std::move(initialState), std::move(initialStackSymbol));
+	automaton.setStates(std::move(states));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setStackAlphabet(std::move(stackSymbols));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<SinglePopNPDA>(input, automaton);
 
@@ -459,12 +459,12 @@ OneTapeDTM AutomatonFromXMLParser::parseOneTapeDTM(std::list<sax::Token>& input)
 	State initialState = parseInitialState(input);
 	std::set<State> finalStates = parseFinalStates(input);
 
-	OneTapeDTM automaton(initialState, blank);
-	automaton.setStates(states);
-	automaton.setTapeAlphabet(tapeSymbols);
-	automaton.setInputAlphabet(inputSymbols);
-	automaton.setInitialState(initialState);
-	automaton.setFinalStates(finalStates);
+	OneTapeDTM automaton(std::move(initialState), std::move(blank));
+	automaton.setStates(std::move(states));
+	automaton.setTapeAlphabet(std::move(tapeSymbols));
+	automaton.setInputAlphabet(std::move(inputSymbols));
+	automaton.setInitialState(std::move(initialState));
+	automaton.setFinalStates(std::move(finalStates));
 
 	parseTransitions<OneTapeDTM>(input, automaton);
 
@@ -614,7 +614,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::T
 		std::vector<alphabet::Symbol> pop = parseTransitionPop(input);
 		std::vector<alphabet::Symbol> push = parseTransitionPush(input);
 
-		automaton.setPushdownStoreOperation(inputSymbol, pop, push);
+		automaton.setPushdownStoreOperation(std::move(inputSymbol), std::move(pop), std::move(push));
 
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "operation");
 	}
@@ -631,7 +631,7 @@ void AutomatonFromXMLParser::parseInputToPushdownStoreOperation(std::list<sax::T
 		std::vector<alphabet::Symbol> pop = parseTransitionPop(input);
 		std::vector<alphabet::Symbol> push = parseTransitionPush(input);
 
-		automaton.setPushdownStoreOperation(inputSymbol, pop, push);
+		automaton.setPushdownStoreOperation(std::move(inputSymbol), std::move(pop), std::move(push));
 
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "operation");
 	}
@@ -645,7 +645,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DFA&
 	State to = parseTransitionTo(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, to);
+	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, MultiInitialStateNFA& automaton) const {
@@ -655,7 +655,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Multi
 	State to = parseTransitionTo(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, to);
+	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA& automaton) const {
@@ -665,7 +665,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA&
 	State to = parseTransitionTo(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, to);
+	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, EpsilonNFA& automaton) const {
@@ -675,7 +675,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Epsil
 	State to = parseTransitionTo(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputVariant, to);
+	automaton.addTransition(std::move(from), std::move(inputVariant), std::move(to));
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, CompactNFA& automaton) const {
@@ -685,7 +685,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Compa
 	State to = parseTransitionTo(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputString, to);
+	automaton.addTransition(std::move(from), std::move(inputString), std::move(to));
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, ExtendedNFA& automaton) const {
@@ -695,7 +695,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Exten
 	State to = parseTransitionTo(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputRegexp, to);
+	automaton.addTransition(std::move(from), std::move(inputRegexp), std::move(to));
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DPDA& automaton) const {
@@ -707,7 +707,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DPDA&
 	std::vector<alphabet::Symbol> push = parseTransitionPush(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, pop, to, push);
+	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 {
@@ -719,7 +719,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Singl
 	std::vector<alphabet::Symbol> push = parseTransitionPush(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, pop, to, push);
+	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 {
@@ -729,7 +729,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Input
 	State to = parseTransitionTo(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, to);
+	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, InputDrivenNPDA& automaton) const {
@@ -739,7 +739,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Input
 	State to = parseTransitionTo(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, to);
+	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, VisiblyPushdownDPDA& automaton) const {
@@ -750,7 +750,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
 		State to = parseTransitionTo(input);
 		alphabet::Symbol push = parseTransitionSinglePush(input);
 
-		automaton.addCallTransition(from, inputSymbol, to, push);
+		automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
 	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
@@ -759,7 +759,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
 		alphabet::Symbol pop = parseTransitionSinglePop(input);
 		State to = parseTransitionTo(input);
 
-		automaton.addReturnTransition(from, inputSymbol, pop, to);
+		automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
 	} else {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
@@ -767,7 +767,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
 		alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
 		State to = parseTransitionTo(input);
 
-		automaton.addLocalTransition(from, inputSymbol, to);
+		automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
 	}
 }
@@ -780,7 +780,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
 		State to = parseTransitionTo(input);
 		alphabet::Symbol push = parseTransitionSinglePush(input);
 
-		automaton.addCallTransition(from, inputSymbol, to, push);
+		automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
 	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
@@ -789,7 +789,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
 		alphabet::Symbol pop = parseTransitionSinglePop(input);
 		State to = parseTransitionTo(input);
 
-		automaton.addReturnTransition(from, inputSymbol, pop, to);
+		automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
 	} else {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
@@ -797,7 +797,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Visib
 		alphabet::Symbol inputSymbol = parseTransitionInputSymbol(input);
 		State to = parseTransitionTo(input);
 
-		automaton.addLocalTransition(from, inputSymbol, to);
+		automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
 	}
 }
@@ -810,7 +810,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
 		State to = parseTransitionTo(input);
 		alphabet::Symbol push = parseTransitionSinglePush(input);
 
-		automaton.addCallTransition(from, inputSymbol, to, push);
+		automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
 	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
@@ -819,7 +819,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
 		alphabet::Symbol pop = parseTransitionSinglePop(input);
 		State to = parseTransitionTo(input);
 
-		automaton.addReturnTransition(from, inputSymbol, pop, to);
+		automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
 	} else {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
@@ -827,7 +827,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
 		std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
 		State to = parseTransitionTo(input);
 
-		automaton.addLocalTransition(from, inputSymbol, to);
+		automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
 	}
 }
@@ -840,7 +840,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
 		State to = parseTransitionTo(input);
 		alphabet::Symbol push = parseTransitionSinglePush(input);
 
-		automaton.addCallTransition(from, inputSymbol, to, push);
+		automaton.addCallTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(push));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "callTransition");
 	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition")) {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "returnTransition");
@@ -849,7 +849,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
 		alphabet::Symbol pop = parseTransitionSinglePop(input);
 		State to = parseTransitionTo(input);
 
-		automaton.addReturnTransition(from, inputSymbol, pop, to);
+		automaton.addReturnTransition(std::move(from), std::move(inputSymbol), std::move(pop), std::move(to));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "returnTransition");
 	} else {
 		popToken(input, sax::Token::TokenType::START_ELEMENT, "localTransition");
@@ -857,7 +857,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, RealT
 		std::variant<string::Epsilon, alphabet::Symbol> inputSymbol = parseTransitionInputEpsilonSymbol(input);
 		State to = parseTransitionTo(input);
 
-		automaton.addLocalTransition(from, inputSymbol, to);
+		automaton.addLocalTransition(std::move(from), std::move(inputSymbol), std::move(to));
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "localTransition");
 	}
 }
@@ -871,7 +871,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, NPDA&
 	std::vector<alphabet::Symbol> push = parseTransitionPush(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, pop, to, push);
+	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 {
@@ -883,7 +883,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Singl
 	std::vector<alphabet::Symbol> push = parseTransitionPush(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, pop, to, push);
+	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 {
@@ -895,7 +895,7 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, OneTa
 	Shift shift = parseTransitionShift(input);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 
-	automaton.addTransition(from, inputSymbol, to, outputSymbol, shift);
+	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to), std::move(outputSymbol), shift);
 }
 
 State AutomatonFromXMLParser::parseTransitionTo(std::list<sax::Token> &input) const {
diff --git a/alib2data/src/container/ContainerFromXMLParser.cpp b/alib2data/src/container/ContainerFromXMLParser.cpp
index 61c991a351f528e27a305eca3cf23c59757a0e5c..8e2abb99013a38c91798e2d4f9bd612ea840a734 100644
--- a/alib2data/src/container/ContainerFromXMLParser.cpp
+++ b/alib2data/src/container/ContainerFromXMLParser.cpp
@@ -72,7 +72,7 @@ ObjectsPair ContainerFromXMLParser::parseObjectsPair(std::list<sax::Token>& inpu
 	alib::Object first = alib::xmlApi<alib::Object>::parse(input);
 	alib::Object second = alib::xmlApi<alib::Object>::parse(input);
 
-	ObjectsPair pair(first, second);
+	ObjectsPair pair(std::move(first), std::move(second));
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
 	return pair;
diff --git a/alib2data/src/container/ContainerFromXMLParser.hpp b/alib2data/src/container/ContainerFromXMLParser.hpp
index 4005eac17b43b9a8171ec6dceefc26d7a2c4ae51..6138e1c0d7005951102b714152001bd9d1cec796 100644
--- a/alib2data/src/container/ContainerFromXMLParser.hpp
+++ b/alib2data/src/container/ContainerFromXMLParser.hpp
@@ -108,7 +108,7 @@ std::pair<T, R> ContainerFromXMLParser::parsePair(std::list<sax::Token>& input)
 	R second = alib::xmlApi<R>::parse(input);
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::CONTAINER_OBJECTS_PAIR);
-	return std::make_pair(first, second);
+	return std::make_pair(std::move(first), std::move(second));
 }
 
 template<typename T, typename R>
diff --git a/alib2data/src/exception/ExceptionFromXMLParser.cpp b/alib2data/src/exception/ExceptionFromXMLParser.cpp
index 9bf3a216945ac2d607b6767c5a5b0d0b19cc9040..6986e878203ba115678f6e57f890679ad20ecbd7 100644
--- a/alib2data/src/exception/ExceptionFromXMLParser.cpp
+++ b/alib2data/src/exception/ExceptionFromXMLParser.cpp
@@ -35,7 +35,7 @@ AlibException ExceptionFromXMLParser::parseException(std::list<sax::Token>& inpu
 	}
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "backtrace");
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::EXCEPTION_ALIB_EXCEPTION);
-	return AlibException(cause, backtrace);
+	return AlibException(std::move(cause), std::move(backtrace));
 }
 
 bool ExceptionFromXMLParser::first(const std::list<sax::Token>& input) const {
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.cpp b/alib2data/src/grammar/GrammarFromXMLParser.cpp
index e78391b2034e368117dc6af5c5743916c8f16511..9b8e12b75bfe7f19a715c47e7f8a0e494bf67bc9 100644
--- a/alib2data/src/grammar/GrammarFromXMLParser.cpp
+++ b/alib2data/src/grammar/GrammarFromXMLParser.cpp
@@ -77,9 +77,9 @@ UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::list<sax
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	UnrestrictedGrammar grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	UnrestrictedGrammar grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -94,9 +94,9 @@ ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservin
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	ContextPreservingUnrestrictedGrammar grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	ContextPreservingUnrestrictedGrammar grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -111,9 +111,9 @@ NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::list
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	NonContractingGrammar grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	NonContractingGrammar grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -131,9 +131,9 @@ CSG GrammarFromXMLParser::parseCSG(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	CSG grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	CSG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -151,9 +151,9 @@ GNF GrammarFromXMLParser::parseGNF(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	GNF grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	GNF grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -171,9 +171,9 @@ CNF GrammarFromXMLParser::parseCNF(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	CNF grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	CNF grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -191,9 +191,9 @@ EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::list<sax::Token>&
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	EpsilonFreeCFG grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	EpsilonFreeCFG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -211,9 +211,9 @@ CFG GrammarFromXMLParser::parseCFG(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	CFG grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	CFG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -228,9 +228,9 @@ LG GrammarFromXMLParser::parseLG(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	LG grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	LG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -245,9 +245,9 @@ RightRG GrammarFromXMLParser::parseRightRG(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	RightRG grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	RightRG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -265,9 +265,9 @@ RightLG GrammarFromXMLParser::parseRightLG(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	RightLG grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	RightLG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -282,9 +282,9 @@ LeftRG GrammarFromXMLParser::parseLeftRG(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	LeftRG grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	LeftRG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -302,9 +302,9 @@ LeftLG GrammarFromXMLParser::parseLeftLG(std::list<sax::Token>& input) const {
 	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
 	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
 
-	LeftLG grammar(initialSymbol);
-	grammar.setNonterminalAlphabet(nonterminalAlphabet);
-	grammar.setTerminalAlphabet(terminalAlphabet);
+	LeftLG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
 
 	parseRules(input, grammar);
 
@@ -370,7 +370,7 @@ void GrammarFromXMLParser::parseRules(std::list<sax::Token> &input, T& grammar)
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, UnrestrictedGrammar& grammar) const {
 	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(lhs, rhs);
+	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const {
@@ -378,13 +378,13 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreser
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(lContext, lhs, rContext, rhs);
+	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 {
 	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(lhs, rhs);
+	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar) const {
@@ -392,61 +392,61 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar)
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(lContext, lhs, rContext, rhs);
+	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 {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> rhs = parseRuleGNFRHS(input);
-	grammar.addRule(lhs, rhs);
+	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<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(lhs, rhs);
+	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, EpsilonFreeCFG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(lhs, rhs);
+	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CFG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(lhs, rhs);
+	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRawRule(lhs, rhs);
+	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<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(lhs, rhs);
+	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightLG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRawRule(lhs, rhs);
+	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<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(lhs, rhs);
+	grammar.addRule(std::move(lhs), std::move(rhs));
 }
 
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftLG& grammar) const {
 	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
 	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRawRule(lhs, rhs);
+	grammar.addRawRule(std::move(lhs), std::move(rhs));
 }
 
 
@@ -504,7 +504,7 @@ std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser:
 		second.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
 	}
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-	return std::make_pair(first, second);
+	return std::make_pair(std::move(first), std::move(second));
 }
 
 std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::list<sax::Token>& input) const {
@@ -526,10 +526,10 @@ std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> Gr
 	if(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		alphabet::Symbol second = alib::xmlApi<alphabet::Symbol>::parse(input);
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::make_pair(first, second));
+		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::make_pair(std::move(first), std::move(second)));
 	} else {
 		popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(first);
+		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::move(first));
 	}
 }
 
diff --git a/alib2data/src/graph/GraphFromXMLParser.cpp b/alib2data/src/graph/GraphFromXMLParser.cpp
index cb35275417e9c27886c7251b7d60a76cb2c4efdd..b130e988f95f99bf380b4d8e40d65afbcfe005b7 100644
--- a/alib2data/src/graph/GraphFromXMLParser.cpp
+++ b/alib2data/src/graph/GraphFromXMLParser.cpp
@@ -88,7 +88,7 @@ DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::list<sax::Token> &input)
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "to");
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "edge");
-	return DirectedEdge(from, to, name);
+	return DirectedEdge(std::move(from), std::move(to), std::move(name));
 }
 
 UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::list<sax::Token> &input) const
@@ -106,7 +106,7 @@ UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::list<sax::Token> &in
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "second");
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "edge");
-	return UndirectedEdge(first, second, name);
+	return UndirectedEdge(std::move(first), std::move(second), std::move(name));
 }
 
 int GraphFromXMLParser::parseValue(std::list<sax::Token> &input) const
@@ -162,7 +162,7 @@ void GraphFromXMLParser::parseNodeValues(std::list<sax::Token> &input, T &graph)
 		graph::Node node = parseNode(input);
 		int value = parseValue(input);
 
-		graph.setNodeValue(node, value);
+		graph.setNodeValue(std::move(node), value);
 	}
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "nodevalues");
@@ -176,7 +176,7 @@ void GraphFromXMLParser::parseDirectedEdgeValues(std::list<sax::Token> &input, D
 		graph::DirectedEdge edge = parseDirectedEdge(input);
 		int value = parseValue(input);
 
-		graph.setEdgeValue(edge, value);
+		graph.setEdgeValue(std::move(edge), value);
 	}
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
@@ -190,7 +190,7 @@ void GraphFromXMLParser::parseUndirectedEdgeValues(std::list<sax::Token> &input,
 		graph::UndirectedEdge edge = parseUndirectedEdge(input);
 		int value = parseValue(input);
 
-		graph.setEdgeValue(edge, value);
+		graph.setEdgeValue(std::move(edge), value);
 	}
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
diff --git a/alib2data/src/label/LabelFromXMLParser.cpp b/alib2data/src/label/LabelFromXMLParser.cpp
index 0da6f99a8f295b7b05e920ef0f619e1652de502c..9cfbbcc1699e661ff0ff77b5d137f9d307ada0a4 100644
--- a/alib2data/src/label/LabelFromXMLParser.cpp
+++ b/alib2data/src/label/LabelFromXMLParser.cpp
@@ -75,7 +75,7 @@ LabelSetLabel LabelFromXMLParser::parseLabelSetLabel(std::list<sax::Token>& inpu
 	while(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		labels.insert(parseLabel(input));
 	}
-	LabelSetLabel data(labels);
+	LabelSetLabel data(std::move(labels));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_LABEL_SET_LABEL);
 	return data;
 }
@@ -86,7 +86,7 @@ LabelPairLabel LabelFromXMLParser::parseLabelPairLabel(std::list<sax::Token>& in
 	Label firstLabel = parseLabel(input);
 	Label secondLabel = parseLabel(input);
 
-	LabelPairLabel data(std::make_pair(firstLabel, secondLabel));
+	LabelPairLabel data(std::make_pair(std::move(firstLabel), std::move(secondLabel)));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_LABEL_PAIR_LABEL);
 	return data;
 }
@@ -97,7 +97,7 @@ UniqueLabel LabelFromXMLParser::parseUniqueLabel(std::list<sax::Token>& input) c
 	Label firstLabel = parseLabel(input);
 	primitive::Integer secondLabel = alib::xmlApi<primitive::Integer>::parse(input);
 
-	UniqueLabel data(firstLabel, secondLabel);
+	UniqueLabel data(std::move(firstLabel), std::move(secondLabel));
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::LABEL_UNIQUE_LABEL);
 	return data;
 }
diff --git a/alib2data/src/label/UniqueLabel.cpp b/alib2data/src/label/UniqueLabel.cpp
index ac1e8b18c53f08a56189f6b9cb17711c1fa3a8d4..c2c72ed7d3900efec301ecb348ac1474223c66b6 100644
--- a/alib2data/src/label/UniqueLabel.cpp
+++ b/alib2data/src/label/UniqueLabel.cpp
@@ -11,7 +11,11 @@
 
 namespace label {
 
-UniqueLabel::UniqueLabel(const Label& label, primitive::Integer& id) : label(label), id(id) {
+UniqueLabel::UniqueLabel(const Label& label, const primitive::Integer& id) : label(label), id(id) {
+
+}
+
+UniqueLabel::UniqueLabel(Label&& label, primitive::Integer&& id) : label(std::move(label)), id(std::move(id)) {
 
 }
 
diff --git a/alib2data/src/label/UniqueLabel.h b/alib2data/src/label/UniqueLabel.h
index 3b89b2c08010ad7cbe8e84d3634b785c7a587264..bdd9305b3346aa3bfaff7620b44669e62831ba7e 100644
--- a/alib2data/src/label/UniqueLabel.h
+++ b/alib2data/src/label/UniqueLabel.h
@@ -31,7 +31,9 @@ public:
 	 * Creates new symbol with given name.
 	 * @param symbol name of the symbol
 	 */
-	explicit UniqueLabel(const Label& label, primitive::Integer& id);
+	explicit UniqueLabel(const Label& label, const primitive::Integer& id);
+
+	explicit UniqueLabel(Label&& label, primitive::Integer&& id);
 
 	virtual LabelBase* clone() const;
 
diff --git a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
index 04c9533882e7f79358e256e5990c318644ce103f..14b1ff737c223c323262fd04e27dce2125b4ade1 100644
--- a/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
+++ b/alib2data/src/primitive/PrimitiveFromXMLParser.cpp
@@ -67,7 +67,7 @@ String PrimitiveFromXMLParser::parseString(std::list<sax::Token>& input) const {
 	if( isTokenType(input, sax::Token::TokenType::CHARACTER))
 		data = popTokenData(input, sax::Token::TokenType::CHARACTER);
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::PRIMITIVE_STRING);
-	return String(data);
+	return String(std::move(data));
 }
 
 Unsigned PrimitiveFromXMLParser::parseUnsigned(std::list<sax::Token>& input) const {
diff --git a/alib2data/src/regexp/RegExpFromXMLParser.cpp b/alib2data/src/regexp/RegExpFromXMLParser.cpp
index 1736eb77e80029557c908232b71577b7d32555b8..1bb383987b1d85904360ed795935d45bda9de16d 100644
--- a/alib2data/src/regexp/RegExpFromXMLParser.cpp
+++ b/alib2data/src/regexp/RegExpFromXMLParser.cpp
@@ -176,7 +176,7 @@ FormalRegExpAlternation* RegExpFromXMLParser::parseFormalRegExpAlternation(std::
 
 	FormalRegExpElement* element1 = parseFormalRegExpElement(input);
 	FormalRegExpElement* element2 = parseFormalRegExpElement(input);
-	
+
 	FormalRegExpAlternation* alternation = new FormalRegExpAlternation(std::move(*element1), std::move(*element2));
 
 	delete element1;
diff --git a/alib2data/src/string/StringFromXMLParser.cpp b/alib2data/src/string/StringFromXMLParser.cpp
index 83f20ea5a1fccf5fd64107c7d7bdd809236fa319..6d7ab8b0844e90b56e98ad5d3e67a35d02e12066 100644
--- a/alib2data/src/string/StringFromXMLParser.cpp
+++ b/alib2data/src/string/StringFromXMLParser.cpp
@@ -43,11 +43,8 @@ LinearString StringFromXMLParser::parseLinearString(std::list<sax::Token>& input
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_LINEAR_STRING);
 
 	LinearString string;
-	std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
-	string.setAlphabet(alphabet);
-
-	std::vector<alphabet::Symbol> data = parseContentData(input);
-	string.setContent(data);
+	string.setAlphabet(parseAlphabet(input));
+	string.setContent(parseContentData(input));
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_LINEAR_STRING);
 	return string;
@@ -57,11 +54,8 @@ CyclicString StringFromXMLParser::parseCyclicString(std::list<sax::Token>& input
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_CYCLIC_STRING);
 
 	CyclicString string;
-	std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
-	string.setAlphabet(alphabet);
-
-	std::vector<alphabet::Symbol> data = parseContentData(input);
-	string.setContent(data);
+	string.setAlphabet(parseAlphabet(input));
+	string.setContent(parseContentData(input));
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_CYCLIC_STRING);
 	return string;
@@ -71,8 +65,7 @@ Epsilon StringFromXMLParser::parseEpsilon(std::list<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::STRING_EPSILON);
 
 	Epsilon epsilon;
-	std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
-	epsilon.setAlphabet(alphabet);
+	epsilon.setAlphabet(parseAlphabet(input));
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::STRING_EPSILON);
 	return epsilon;
diff --git a/alib2data/test-src/grammar/GrammarTest.cpp b/alib2data/test-src/grammar/GrammarTest.cpp
index c85c7d4f6931184aaa4a24933031a31f3124bf6d..cfad5bd05e74c32ff257eb627f20e8ce5a7ea75c 100644
--- a/alib2data/test-src/grammar/GrammarTest.cpp
+++ b/alib2data/test-src/grammar/GrammarTest.cpp
@@ -206,6 +206,8 @@ void GrammarTest::testRegularParser() {
 			std::string tmp;
 			sax::SaxComposeInterface::printMemory(tmp, tokens);
 
+			std::cout << tmp << std::endl;
+
 			std::list<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
 			grammar::RightLG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightLG>(tokens2);