diff --git a/alib2data/src/tree/TreeFeatures.h b/alib2data/src/tree/TreeFeatures.h
index 4d8bd712800be93aee6653aa4526fe012ff377a3..e8d521bad04b116d13df6411b4e17b18535090b1 100644
--- a/alib2data/src/tree/TreeFeatures.h
+++ b/alib2data/src/tree/TreeFeatures.h
@@ -32,7 +32,9 @@ class RankedNonlinearPattern;
 class PrefixRankedTree;
 class PrefixRankedBarTree;
 class PrefixRankedPattern;
+class PrefixRankedNonlinearPattern;
 class PrefixRankedBarPattern;
+class PrefixRankedBarNonlinearPattern;
 class UnrankedTree;
 class UnrankedPattern;
 class UnrankedNonlinearPattern;
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36908aad281f0185aca54d2ad1f9b799eebe9525
--- /dev/null
+++ b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.cpp
@@ -0,0 +1,303 @@
+/*
+ * PrefixRankedBarNonlinearPattern.cpp
+ *
+ *  Created on: Jul 20, 2016
+ *      Author: Jan Travnicek
+ */
+
+#include "PrefixRankedBarNonlinearPattern.h"
+#include "../TreeException.h"
+
+#include <sstream>
+#include <algorithm>
+#include <deque>
+
+#include "PrefixRankedBarTree.h"
+#include "PrefixRankedBarPattern.h"
+#include "RankedTree.h"
+#include "RankedPattern.h"
+#include "RankedNonlinearPattern.h"
+
+#include <sax/FromXMLParserHelper.h>
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../common/TreeAuxiliary.h"
+#include "../Tree.h"
+#include "../RankedTreeWrapper.h"
+#include <object/Object.h>
+#include <XmlApi.hpp>
+#include <cast/CastApi.hpp>
+
+#include "../../alphabet/BarSymbol.h"
+#include "../../alphabet/VariablesBarSymbol.h"
+#include "../../alphabet/SubtreeWildcardSymbol.h"
+
+namespace tree {
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( std::set < alphabet::RankedSymbol > bars, alphabet::RankedSymbol variablesBar, alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components < PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ), std::move ( bars ) ), std::make_tuple ( std::move ( subtreeWildcard ), std::move ( variablesBar ) ) ) {
+	setContent ( std::move ( data ) );
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( std::set < alphabet::RankedSymbol > bars, alphabet::RankedSymbol variablesBar, alphabet::RankedSymbol subtreeWildcard, std::vector < alphabet::RankedSymbol > data ) : PrefixRankedBarNonlinearPattern ( bars, variablesBar, subtreeWildcard, { }, std::set < alphabet::RankedSymbol > ( data.begin ( ), data.end ( ) ) + bars + std::set < alphabet::RankedSymbol > { variablesBar, subtreeWildcard }, data ) {
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, alphabet::RankedSymbol variablesBar, const RankedTree & tree ) : PrefixRankedBarNonlinearPattern ( TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < alphabet::RankedSymbol > { variablesBar }, variablesBar, alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL, { }, tree.getAlphabet ( ) + TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < alphabet::RankedSymbol > { variablesBar, alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL }, toPrefixRankedBar ( tree.getRoot ( ), alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL, { }, barBase, variablesBar ) ) {
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, alphabet::RankedSymbol variablesBar, const RankedPattern & tree ) : PrefixRankedBarNonlinearPattern ( TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < alphabet::RankedSymbol > { variablesBar }, variablesBar, tree.getSubtreeWildcard ( ), { }, tree.getAlphabet ( ) + TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < alphabet::RankedSymbol > { variablesBar, tree.getSubtreeWildcard ( ) }, toPrefixRankedBar ( tree.getRoot ( ), tree.getSubtreeWildcard ( ), { }, barBase, variablesBar ) ) {
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, alphabet::RankedSymbol variablesBar, const RankedNonlinearPattern & tree ) : PrefixRankedBarNonlinearPattern ( TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < alphabet::RankedSymbol > { variablesBar }, variablesBar, tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), tree.getAlphabet ( ) + TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < alphabet::RankedSymbol > { variablesBar, tree.getSubtreeWildcard ( ) } + tree.getNonlinearVariables ( ), toPrefixRankedBar ( tree.getRoot ( ), tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), barBase, variablesBar ) ) {
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const PrefixRankedBarTree & tree ) : PrefixRankedBarNonlinearPattern ( tree.getBars ( ) + std::set < alphabet::RankedSymbol > { alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL }, alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL, { }, tree.getAlphabet ( ) + std::set < alphabet::RankedSymbol > { alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL }, tree.getContent ( ) ) {
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const PrefixRankedBarPattern & tree ) : PrefixRankedBarNonlinearPattern ( tree.getBars ( ), tree.getVariablesBar ( ), tree.getSubtreeWildcard ( ), { }, tree.getAlphabet ( ), tree.getContent ( ) ) {
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const RankedTree & tree ) : PrefixRankedBarNonlinearPattern ( alphabet::BarSymbol::BAR_SYMBOL, alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, tree ) {
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const RankedPattern & tree ) : PrefixRankedBarNonlinearPattern ( alphabet::BarSymbol::BAR_SYMBOL, alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, tree ) {
+}
+
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const RankedNonlinearPattern & tree ) : PrefixRankedBarNonlinearPattern ( alphabet::BarSymbol::BAR_SYMBOL, alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, tree ) {
+}
+
+std::vector < alphabet::RankedSymbol > PrefixRankedBarNonlinearPattern::toPrefixRankedBar ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables, const alphabet::Symbol & barBase, const alphabet::RankedSymbol & variablesBar ) {
+	std::vector < alphabet::RankedSymbol > res;
+
+	toPrefixRankedBar ( node, subtreeWildcard, nonlinearVariables, barBase, variablesBar, res );
+	return res;
+}
+
+void PrefixRankedBarNonlinearPattern::toPrefixRankedBar ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables, const alphabet::Symbol & barBase, const alphabet::RankedSymbol & variablesBar, std::vector < alphabet::RankedSymbol > & linearNotation ) {
+	if ( ( node.getSymbol ( ) == subtreeWildcard ) || nonlinearVariables.count ( node.getSymbol ( ) ) ) {
+		linearNotation.push_back ( node.getSymbol ( ) );
+		linearNotation.push_back ( variablesBar );
+	} else {
+		linearNotation.push_back ( node.getSymbol ( ) );
+
+		for ( const std::smart_ptr < const RankedNode > & child : node.getChildren ( ) )
+			toPrefixRankedBar ( * child, subtreeWildcard, nonlinearVariables, barBase, variablesBar, linearNotation );
+
+		linearNotation.push_back ( alphabet::RankedSymbol ( barBase, node.getSymbol ( ).getRank ( ) ) );
+	}
+}
+
+RankedTreeBase * PrefixRankedBarNonlinearPattern::clone ( ) const {
+	return new PrefixRankedBarNonlinearPattern ( * this );
+}
+
+RankedTreeBase * PrefixRankedBarNonlinearPattern::plunder ( ) && {
+	return new PrefixRankedBarNonlinearPattern ( std::move ( * this ) );
+}
+
+const std::vector < alphabet::RankedSymbol > & PrefixRankedBarNonlinearPattern::getContent ( ) const {
+	return this->m_Data;
+}
+
+void PrefixRankedBarNonlinearPattern::setContent ( std::vector < alphabet::RankedSymbol > data ) {
+	arityChecksum ( data );
+
+	std::set < alphabet::RankedSymbol > minimalAlphabet ( data.begin ( ), data.end ( ) );
+	std::set < alphabet::RankedSymbol > unknownSymbols;
+	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), getAlphabet ( ).begin ( ), getAlphabet ( ).end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
+
+	if ( unknownSymbols.size ( ) > 0 )
+		throw TreeException ( "Input symbols not in the alphabet." );
+
+	this->m_Data = std::move ( data );
+}
+
+void PrefixRankedBarNonlinearPattern::arityChecksum ( const std::vector < alphabet::RankedSymbol > & data ) {
+	int arityChecksumTerminals = 1;
+	int arityChecksumBars = 1;
+	int arityChecksumTypes = 0;
+
+	for ( const alphabet::RankedSymbol & symbol : data ) {
+		if ( getBars ( ).count ( symbol ) || ( symbol == getVariablesBar ( ) ) ) {
+			arityChecksumBars += symbol.getRank ( ).getData ( );
+			arityChecksumBars -= 1;
+			arityChecksumTypes -= 1;
+		} else {
+			arityChecksumTerminals += symbol.getRank ( ).getData ( );
+			arityChecksumTerminals -= 1;
+			arityChecksumTypes += 1;
+		}
+	}
+
+	if ( ( arityChecksumTerminals != 0 ) || ( arityChecksumBars != 0 ) || ( arityChecksumTypes != 0 ) ) throw TreeException ( "The string does not form a tree" );
+
+	for ( unsigned i = 1; i < data.size ( ); ++i )
+		if ( ( data[i - 1] == getSubtreeWildcard ( ) ) && ( data[i] != getVariablesBar ( ) ) )
+			throw TreeException ( "Inconsystency of SubtreeWildcard and variablesBar" );
+
+}
+
+bool PrefixRankedBarNonlinearPattern::isEmpty ( ) const {
+	return this->m_Data.size ( ) == 0;
+}
+
+int PrefixRankedBarNonlinearPattern::compare ( const PrefixRankedBarNonlinearPattern & other ) const {
+	auto first = std::tie ( m_Data, getAlphabet ( ), getSubtreeWildcard ( ), getNonlinearVariables ( ), getBars ( ), getVariablesBar ( ) );
+	auto second = std::tie ( other.m_Data, other.getAlphabet ( ), other.getSubtreeWildcard ( ), other.getNonlinearVariables ( ), other.getBars ( ), other.getVariablesBar ( ) );
+
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
+}
+
+void PrefixRankedBarNonlinearPattern::operator >>( std::ostream & out ) const {
+	out << "(PrefixRankedBarNonlinearPattern ";
+
+	for ( const alphabet::RankedSymbol & symbol : this->m_Data )
+		out << symbol;
+
+	out << ")";
+}
+
+PrefixRankedBarNonlinearPattern::operator std::string ( ) const {
+	std::stringstream ss;
+	ss << "\"";
+
+	for ( const alphabet::RankedSymbol & symbol : this->m_Data )
+		ss << ( std::string ) symbol;
+
+	ss << "\"";
+	return std::move ( ss ).str ( );
+}
+
+PrefixRankedBarNonlinearPattern PrefixRankedBarNonlinearPattern::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, PrefixRankedBarNonlinearPattern::getXmlTagName ( ) );
+	std::set < alphabet::RankedSymbol > bars = TreeFromXMLParser::parseBars ( input );
+	alphabet::RankedSymbol variablesBarSymbol = TreeFromXMLParser::parseRankedVariablesBar ( input );
+	alphabet::RankedSymbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardRankedSymbol ( input );
+	std::set < alphabet::RankedSymbol > nonlinearVariables = TreeFromXMLParser::parseRankedNonlinearVariables ( input );
+	std::set < alphabet::RankedSymbol > rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet ( input );
+	std::vector < alphabet::RankedSymbol > data = TreeFromXMLParser::parseRankedContent ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, PrefixRankedBarNonlinearPattern::getXmlTagName ( ) );
+
+	return PrefixRankedBarNonlinearPattern ( std::move ( bars ), std::move ( variablesBarSymbol ), std::move ( subtreeWildcardSymbol ), std::move ( nonlinearVariables ), std::move ( rankedAlphabet ), std::move ( data ) );
+}
+
+void PrefixRankedBarNonlinearPattern::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( PrefixRankedBarNonlinearPattern::getXmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
+	TreeToXMLComposer::composeBars ( out, getBars ( ) );
+	TreeToXMLComposer::composeVariablesBar ( out, getVariablesBar ( ) );
+	TreeToXMLComposer::composeSubtreeWildcard ( out, getSubtreeWildcard ( ) );
+	TreeToXMLComposer::composeNonlinearVariables ( out, getNonlinearVariables ( ) );
+	TreeToXMLComposer::composeAlphabet ( out, getAlphabet ( ) );
+	TreeToXMLComposer::composeContent ( out, m_Data );
+	out.emplace_back ( PrefixRankedBarNonlinearPattern::getXmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace tree */
+
+namespace std {
+
+template < >
+bool tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedBarNonlinearPattern * pattern = static_cast < const tree::PrefixRankedBarNonlinearPattern * > ( this );
+	const std::vector < alphabet::RankedSymbol > & content = pattern->getContent ( );
+
+	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern->accessElement < tree::VariablesBarSymbol > ( ).get ( ) == symbol || pattern->accessComponent < tree::BarSymbols > ( ).get ( ).count ( symbol ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
+}
+
+template < >
+bool tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
+	return true;
+}
+
+template < >
+void tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
+}
+
+template < >
+bool tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::BarSymbols >::used ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedBarNonlinearPattern * pattern = static_cast < const tree::PrefixRankedBarNonlinearPattern * > ( this );
+	const std::vector < alphabet::RankedSymbol > & content = pattern->getContent ( );
+
+	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern->accessElement < tree::VariablesBarSymbol > ( ).get ( ) == symbol;
+}
+
+template < >
+bool tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::BarSymbols >::available ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedBarNonlinearPattern * pattern = static_cast < const tree::PrefixRankedBarNonlinearPattern * > ( this );
+
+	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::BarSymbols >::valid ( const alphabet::RankedSymbol & ) const {
+}
+
+template < >
+bool tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::used ( const alphabet::RankedSymbol & ) const {
+	return false;
+}
+
+template < >
+bool tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::available ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedBarNonlinearPattern * pattern = static_cast < const tree::PrefixRankedBarNonlinearPattern * > ( this );
+
+	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::PrefixRankedBarNonlinearPattern::Component < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::valid ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedBarNonlinearPattern * pattern = static_cast < const tree::PrefixRankedBarNonlinearPattern * > ( this );
+
+	if ( symbol.getRank ( ).getData ( ) != 0 )
+		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+
+	if ( pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
+		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
+}
+
+template < >
+bool tree::PrefixRankedBarNonlinearPattern::Element < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::available ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedBarNonlinearPattern * pattern = static_cast < const tree::PrefixRankedBarNonlinearPattern * > ( this );
+
+	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::PrefixRankedBarNonlinearPattern::Element < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::valid ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedBarNonlinearPattern * pattern = static_cast < const tree::PrefixRankedBarNonlinearPattern * > ( this );
+
+	if ( symbol.getRank ( ).getData ( ) != 0 )
+		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+
+	if ( pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
+		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
+}
+
+template < >
+bool tree::PrefixRankedBarNonlinearPattern::Element < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::VariablesBarSymbol >::available ( const alphabet::RankedSymbol & symbol ) const {
+	return static_cast < const tree::PrefixRankedBarNonlinearPattern * > ( this )->accessComponent < tree::BarSymbols > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::PrefixRankedBarNonlinearPattern::Element < tree::PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, tree::VariablesBarSymbol >::valid ( const alphabet::RankedSymbol & symbol ) const {
+	if ( symbol.getRank ( ).getData ( ) != 0 )
+		throw tree::TreeException ( "VariablesBarSymbol has nonzero arity" );
+}
+
+} /* namespace std */
+
+namespace alib {
+
+auto prefixRankedBarNonlinearPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedBarNonlinearPattern > ( );
+auto prefixRankedBarNonlinearPatternParserRegister2 = xmlApi < tree::RankedTreeWrapper >::ParserRegister < tree::PrefixRankedBarNonlinearPattern > ( );
+auto prefixRankedBarNonlinearPatternParserRegister3 = xmlApi < alib::Object >::ParserRegister < tree::PrefixRankedBarNonlinearPattern > ( );
+
+auto PrefixRankedBarNonlinearPatternFromRankedTree = castApi::CastRegister < tree::PrefixRankedBarNonlinearPattern, tree::RankedTree > ( );
+auto PrefixRankedBarNonlinearPatternFromRankedPattern = castApi::CastRegister < tree::PrefixRankedBarNonlinearPattern, tree::RankedPattern > ( );
+auto PrefixRankedBarNonlinearPatternFromRankedNonlinearPattern = castApi::CastRegister < tree::PrefixRankedBarNonlinearPattern, tree::RankedNonlinearPattern > ( );
+auto PrefixRankedBarNonlinearPatternFromPrefixRankedBarTree = castApi::CastRegister < tree::PrefixRankedBarNonlinearPattern, tree::PrefixRankedBarTree > ( );
+auto PrefixRankedBarNonlinearPatternFromPrefixRankedBarPattern = castApi::CastRegister < tree::PrefixRankedBarNonlinearPattern, tree::PrefixRankedBarPattern > ( );
+auto PrefixRankedBarNonlinearPatternCastBinder = castApi::CastPoolStringBinder < tree::PrefixRankedBarNonlinearPattern > ( tree::PrefixRankedBarNonlinearPattern::getXmlTagName ( ) );
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
new file mode 100644
index 0000000000000000000000000000000000000000..2d6a65df5597f0a20b3ddc50ca6a19ffcf32ab30
--- /dev/null
+++ b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
@@ -0,0 +1,121 @@
+/*
+ * PrefixRankedBarNonlinearPattern.h
+ *
+ *  Created on: Jul 20, 2016
+ *      Author: Jan Travnicek
+ */
+
+#ifndef PREFIX_RANKED_BAR_NONLINEAR_PATTERN_H_
+#define PREFIX_RANKED_BAR_NONLINEAR_PATTERN_H_
+
+#include <set>
+#include <vector>
+#include <core/components.hpp>
+
+#include "../../alphabet/RankedSymbol.h"
+#include "../RankedTreeBase.h"
+#include "RankedNode.h"
+
+namespace tree {
+
+class RankedTree;
+class RankedPattern;
+class RankedNonlinearPattern;
+class PrefixRankedBarTree;
+class PrefixRankedBarPattern;
+class GeneralAlphabet;
+class SubtreeWildcard;
+class BarSymbols;
+class VariablesBarSymbol;
+class NonlinearAlphabet;
+
+/**
+ * Represents regular expression parsed from the XML. Regular expression is stored
+ * as a tree of LinearStringElement.
+ */
+class PrefixRankedBarNonlinearPattern : public RankedTreeBase, public std::Components < PrefixRankedBarNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > {
+	std::vector < alphabet::RankedSymbol > m_Data;
+
+	static void toPrefixRankedBar ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables, const alphabet::Symbol & barBase, const alphabet::RankedSymbol & variablesBar, std::vector < alphabet::RankedSymbol > & linearNotation );
+	static std::vector < alphabet::RankedSymbol > toPrefixRankedBar ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables, const alphabet::Symbol & barBase, const alphabet::RankedSymbol & variablesBar );
+
+public:
+	explicit PrefixRankedBarNonlinearPattern ( std::set < alphabet::RankedSymbol > bar, alphabet::RankedSymbol variablesBar, alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data );
+	explicit PrefixRankedBarNonlinearPattern ( std::set < alphabet::RankedSymbol > bar, alphabet::RankedSymbol variablesBar, alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::vector < alphabet::RankedSymbol > data );
+	explicit PrefixRankedBarNonlinearPattern ( std::set < alphabet::RankedSymbol > bar, alphabet::RankedSymbol variablesBar, alphabet::RankedSymbol subtreeWildcard, std::vector < alphabet::RankedSymbol > data );
+	explicit PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, alphabet::RankedSymbol variablesBar, const RankedTree & tree );
+	explicit PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, alphabet::RankedSymbol variablesBar, const RankedPattern & tree );
+	explicit PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, alphabet::RankedSymbol variablesBar, const RankedNonlinearPattern & tree );
+	explicit PrefixRankedBarNonlinearPattern ( const PrefixRankedBarTree & tree );
+	explicit PrefixRankedBarNonlinearPattern ( const PrefixRankedBarPattern & tree );
+	explicit PrefixRankedBarNonlinearPattern ( const RankedTree & tree );
+	explicit PrefixRankedBarNonlinearPattern ( const RankedPattern & tree );
+	explicit PrefixRankedBarNonlinearPattern ( const RankedNonlinearPattern & tree );
+
+	virtual RankedTreeBase * clone ( ) const;
+	virtual RankedTreeBase * plunder ( ) &&;
+
+	/**
+	 * @return List of symbols forming tree (const version).
+	 */
+	const std::vector < alphabet::RankedSymbol > & getContent ( ) const;
+
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+		return accessComponent < GeneralAlphabet > ( ).get ( );
+	}
+
+	void extendAlphabet ( const std::set < alphabet::RankedSymbol > & symbols ) {
+		accessComponent < GeneralAlphabet > ( ).add ( symbols );
+	}
+
+	const std::set < alphabet::RankedSymbol > & getBars ( ) const {
+		return accessComponent < BarSymbols > ( ).get ( );
+	}
+
+	const alphabet::RankedSymbol & getSubtreeWildcard ( ) const {
+		return accessElement < SubtreeWildcard > ( ).get ( );
+	}
+
+	const std::set < alphabet::RankedSymbol > & getNonlinearVariables ( ) const {
+		return accessComponent < NonlinearAlphabet > ( ).get ( );
+	}
+
+	const alphabet::RankedSymbol & getVariablesBar ( ) const {
+		return accessElement < VariablesBarSymbol > ( ).get ( );
+	}
+
+	void setContent ( std::vector < alphabet::RankedSymbol > data );
+
+	void arityChecksum ( const std::vector < alphabet::RankedSymbol > & data );
+
+	/**
+	 * @return true if tree is an empty word (vector length is 0)
+	 */
+	bool isEmpty ( ) const;
+
+	virtual int compare ( const ObjectBase & other ) const {
+		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
+
+		return std::type_index ( typeid ( * this ) ) - std::type_index ( typeid ( other ) );
+	}
+
+	virtual int compare ( const PrefixRankedBarNonlinearPattern & other ) const;
+
+	virtual void operator >>( std::ostream & out ) const;
+
+	virtual explicit operator std::string ( ) const;
+
+	static const std::string & getXmlTagName ( ) {
+		static std::string xmlTagName = "PrefixRankedBarNonlinearPattern";
+
+		return xmlTagName;
+	}
+
+	static PrefixRankedBarNonlinearPattern parse ( std::deque < sax::Token >::iterator & input );
+
+	void compose ( std::deque < sax::Token > & out ) const;
+};
+
+} /* namespace tree */
+
+#endif /* PREFIX_RANKED_BAR_NONLINEAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..46152b78a734bd21fbdc8e19debe8b3ee4d715c2
--- /dev/null
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp
@@ -0,0 +1,248 @@
+/*
+ * PrefixRankedNonlinearPattern.cpp
+ *
+ *  Created on: Jul 20, 2016
+ *      Author: Jan Travnicek
+ */
+
+#include "PrefixRankedNonlinearPattern.h"
+#include "../TreeException.h"
+
+#include <sstream>
+#include <algorithm>
+#include <deque>
+
+#include "PrefixRankedTree.h"
+#include "PrefixRankedPattern.h"
+#include "RankedTree.h"
+#include "RankedPattern.h"
+#include "RankedNonlinearPattern.h"
+
+#include <sax/FromXMLParserHelper.h>
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../RankedTreeWrapper.h"
+#include <object/Object.h>
+#include <XmlApi.hpp>
+#include <cast/CastApi.hpp>
+
+#include "../../alphabet/SubtreeWildcardSymbol.h"
+
+namespace tree {
+
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components < PrefixRankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( subtreeWildcard ) ) {
+	setContent ( std::move ( data ) );
+}
+
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::vector < alphabet::RankedSymbol > data ) : PrefixRankedNonlinearPattern ( std::move ( subtreeWildcard ), std::move ( nonlinearVariables ), std::set < alphabet::RankedSymbol > ( data.begin ( ), data.end ( ) ) + std::set < alphabet::RankedSymbol > { subtreeWildcard } + nonlinearVariables, std::move ( data ) ) {
+}
+
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::vector < alphabet::RankedSymbol > data ) : PrefixRankedNonlinearPattern ( std::move ( subtreeWildcard ), {
+	}, std::set < alphabet::RankedSymbol > ( data.begin ( ), data.end ( ) ) + std::set < alphabet::RankedSymbol > { subtreeWildcard }, std::move ( data ) ) {
+}
+
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const PrefixRankedTree & tree ) : PrefixRankedNonlinearPattern ( alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL, {
+	}, tree.getAlphabet ( ), tree.getContent ( ) ) {
+}
+
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const PrefixRankedPattern & tree ) : PrefixRankedNonlinearPattern ( tree.getSubtreeWildcard ( ), {
+	}, tree.getAlphabet ( ), tree.getContent ( ) ) {
+}
+
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const RankedTree & tree ) : PrefixRankedNonlinearPattern ( alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL, {
+	}, tree.getAlphabet ( ), toPrefixRanked ( tree.getRoot ( ), alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL, { } ) ) {
+}
+
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const RankedPattern & tree ) : PrefixRankedNonlinearPattern ( tree.getSubtreeWildcard ( ), {
+	}, tree.getAlphabet ( ), toPrefixRanked ( tree.getRoot ( ), tree.getSubtreeWildcard ( ), { } ) ) {
+}
+
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const RankedNonlinearPattern & tree ) : PrefixRankedNonlinearPattern ( tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), tree.getAlphabet ( ), toPrefixRanked ( tree.getRoot ( ), tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ) ) ) {
+}
+
+std::vector < alphabet::RankedSymbol > PrefixRankedNonlinearPattern::toPrefixRanked ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables ) {
+	std::vector < alphabet::RankedSymbol > res;
+
+	toPrefixRanked ( node, subtreeWildcard, nonlinearVariables, res );
+	return res;
+}
+
+void PrefixRankedNonlinearPattern::toPrefixRanked ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables, std::vector < alphabet::RankedSymbol > & linearNotation ) {
+	if ( ( node.getSymbol ( ) == subtreeWildcard ) || nonlinearVariables.count ( node.getSymbol ( ) ) ) {
+		linearNotation.push_back ( node.getSymbol ( ) );
+	} else {
+		linearNotation.push_back ( node.getSymbol ( ) );
+
+		for ( const std::smart_ptr < const RankedNode > & child : node.getChildren ( ) )
+			toPrefixRanked ( * child, subtreeWildcard, nonlinearVariables, linearNotation );
+	}
+}
+
+RankedTreeBase * PrefixRankedNonlinearPattern::clone ( ) const {
+	return new PrefixRankedNonlinearPattern ( * this );
+}
+
+RankedTreeBase * PrefixRankedNonlinearPattern::plunder ( ) && {
+	return new PrefixRankedNonlinearPattern ( std::move ( * this ) );
+}
+
+const std::vector < alphabet::RankedSymbol > & PrefixRankedNonlinearPattern::getContent ( ) const {
+	return this->m_Data;
+}
+
+void PrefixRankedNonlinearPattern::setContent ( std::vector < alphabet::RankedSymbol > data ) {
+	arityChecksum ( data );
+
+	std::set < alphabet::RankedSymbol > minimalAlphabet ( data.begin ( ), data.end ( ) );
+	std::set < alphabet::RankedSymbol > unknownSymbols;
+	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), getAlphabet ( ).begin ( ), getAlphabet ( ).end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
+
+	if ( unknownSymbols.size ( ) > 0 )
+		throw TreeException ( "Input symbols not in the alphabet." );
+
+	this->m_Data = std::move ( data );
+}
+
+void PrefixRankedNonlinearPattern::arityChecksum ( const std::vector < alphabet::RankedSymbol > & data ) {
+	int arityChecksum = 1;
+
+	for ( const alphabet::RankedSymbol & symbol : data ) {
+		arityChecksum += symbol.getRank ( ).getData ( );
+		arityChecksum -= 1;
+	}
+
+	if ( arityChecksum != 0 ) throw TreeException ( "The string does not form a tree" );
+}
+
+bool PrefixRankedNonlinearPattern::isEmpty ( ) const {
+	return this->m_Data.size ( ) == 0;
+}
+
+int PrefixRankedNonlinearPattern::compare ( const PrefixRankedNonlinearPattern & other ) const {
+	auto first = std::tie ( m_Data, getAlphabet ( ), getSubtreeWildcard ( ), getNonlinearVariables ( ) );
+	auto second = std::tie ( other.m_Data, other.getAlphabet ( ), other.getSubtreeWildcard ( ), other.getNonlinearVariables ( ) );
+
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
+}
+
+void PrefixRankedNonlinearPattern::operator >>( std::ostream & out ) const {
+	out << "(PrefixRankedNonlinearPattern ";
+
+	for ( const alphabet::RankedSymbol & symbol : this->m_Data )
+		out << symbol;
+
+	out << ")";
+}
+
+PrefixRankedNonlinearPattern::operator std::string ( ) const {
+	std::stringstream ss;
+	ss << "\"";
+
+	for ( const alphabet::RankedSymbol & symbol : this->m_Data )
+		ss << ( std::string ) symbol;
+
+	ss << "\"";
+	return std::move ( ss ).str ( );
+}
+
+PrefixRankedNonlinearPattern PrefixRankedNonlinearPattern::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, PrefixRankedNonlinearPattern::getXmlTagName ( ) );
+	alphabet::RankedSymbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardRankedSymbol ( input );
+	std::set < alphabet::RankedSymbol > nonlinearVariables = TreeFromXMLParser::parseRankedNonlinearVariables ( input );
+	std::set < alphabet::RankedSymbol > rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet ( input );
+	std::vector < alphabet::RankedSymbol > data = TreeFromXMLParser::parseRankedContent ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, PrefixRankedNonlinearPattern::getXmlTagName ( ) );
+
+	return PrefixRankedNonlinearPattern ( std::move ( subtreeWildcardSymbol ), std::move ( nonlinearVariables ), std::move ( rankedAlphabet ), std::move ( data ) );
+}
+
+void PrefixRankedNonlinearPattern::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( PrefixRankedNonlinearPattern::getXmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
+	TreeToXMLComposer::composeSubtreeWildcard ( out, getSubtreeWildcard ( ) );
+	TreeToXMLComposer::composeNonlinearVariables ( out, getNonlinearVariables ( ) );
+	TreeToXMLComposer::composeAlphabet ( out, getAlphabet ( ) );
+	TreeToXMLComposer::composeContent ( out, m_Data );
+	out.emplace_back ( PrefixRankedNonlinearPattern::getXmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace tree */
+
+namespace std {
+
+template < >
+bool tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
+	const std::vector < alphabet::RankedSymbol > & content = pattern->getContent ( );
+
+	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
+}
+
+template < >
+bool tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
+	return true;
+}
+
+template < >
+void tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
+}
+
+template < >
+bool tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::used ( const alphabet::RankedSymbol & ) const {
+	return false;
+}
+
+template < >
+bool tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::available ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
+
+	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::valid ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
+
+	if ( symbol.getRank ( ).getData ( ) != 0 )
+		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+
+	if ( pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
+		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
+}
+
+template < >
+bool tree::PrefixRankedNonlinearPattern::Element < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::available ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
+
+	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::PrefixRankedNonlinearPattern::Element < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::valid ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
+
+	if ( symbol.getRank ( ).getData ( ) != 0 )
+		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+
+	if ( pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
+		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
+}
+
+} /* namespace std */
+
+namespace alib {
+
+auto prefixRankedNonlinearPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedNonlinearPattern > ( );
+auto prefixRankedNonlinearPatternParserRegister2 = xmlApi < tree::RankedTreeWrapper >::ParserRegister < tree::PrefixRankedNonlinearPattern > ( );
+auto prefixRankedNonlinearPatternParserRegister3 = xmlApi < alib::Object >::ParserRegister < tree::PrefixRankedNonlinearPattern > ( );
+
+auto PrefixRankedNonlinearPatternFromRankedTree = castApi::CastRegister < tree::PrefixRankedNonlinearPattern, tree::RankedTree > ( );
+auto PrefixRankedNonlinearPatternFromRankedPattern = castApi::CastRegister < tree::PrefixRankedNonlinearPattern, tree::RankedPattern > ( );
+auto PrefixRankedNonlinearPatternFromRankedNonlinearPattern = castApi::CastRegister < tree::PrefixRankedNonlinearPattern, tree::RankedNonlinearPattern > ( );
+auto PrefixRankedNonlinearPatternFromPrefixRankedTree = castApi::CastRegister < tree::PrefixRankedNonlinearPattern, tree::PrefixRankedTree > ( );
+auto PrefixRankedNonlinearPatternFromPrefixRankedPattern = castApi::CastRegister < tree::PrefixRankedNonlinearPattern, tree::PrefixRankedPattern > ( );
+auto PrefixRankedNonlinearPatternCastBinder = castApi::CastPoolStringBinder < tree::PrefixRankedNonlinearPattern > ( tree::PrefixRankedNonlinearPattern::getXmlTagName ( ) );
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
new file mode 100644
index 0000000000000000000000000000000000000000..f65e2647992c987c55f82a4260a9d1f64de8ed7f
--- /dev/null
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
@@ -0,0 +1,109 @@
+/*
+ * PrefixRankedNonlinearPattern.h
+ *
+ *  Created on: Jul 20, 2016
+ *      Author: Jan Travnicek
+ */
+
+#ifndef PREFIX_RANKED_NONLINEAR_PATTERN_H_
+#define PREFIX_RANKED_NONLINEAR_PATTERN_H_
+
+#include <set>
+#include <vector>
+#include <core/components.hpp>
+
+#include "../../alphabet/RankedSymbol.h"
+#include "../RankedTreeBase.h"
+#include "RankedNode.h"
+
+namespace tree {
+
+class RankedTree;
+class RankedPattern;
+class RankedNonlinearPattern;
+class PrefixRankedTree;
+class PrefixRankedPattern;
+
+class GeneralAlphabet;
+class SubtreeWildcard;
+class NonlinearAlphabet;
+
+/**
+ * Represents regular expression parsed from the XML. Regular expression is stored
+ * as a tree of LinearStringElement.
+ */
+class PrefixRankedNonlinearPattern : public RankedTreeBase, public std::Components < PrefixRankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
+	std::vector < alphabet::RankedSymbol > m_Data;
+
+	static std::vector < alphabet::RankedSymbol > toPrefixRanked ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables );
+	static void toPrefixRanked ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables, std::vector < alphabet::RankedSymbol > & linearNotation );
+
+public:
+	explicit PrefixRankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data );
+	explicit PrefixRankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::vector < alphabet::RankedSymbol > data );
+	explicit PrefixRankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::vector < alphabet::RankedSymbol > data );
+	explicit PrefixRankedNonlinearPattern ( const PrefixRankedTree & tree );
+	explicit PrefixRankedNonlinearPattern ( const PrefixRankedPattern & tree );
+	explicit PrefixRankedNonlinearPattern ( const RankedTree & tree );
+	explicit PrefixRankedNonlinearPattern ( const RankedPattern & tree );
+	explicit PrefixRankedNonlinearPattern ( const RankedNonlinearPattern & tree );
+
+	virtual RankedTreeBase * clone ( ) const;
+	virtual RankedTreeBase * plunder ( ) &&;
+
+	/**
+	 * @return List of symbols forming tree (const version).
+	 */
+	const std::vector < alphabet::RankedSymbol > & getContent ( ) const;
+
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+		return accessComponent < GeneralAlphabet > ( ).get ( );
+	}
+
+	void extendAlphabet ( const std::set < alphabet::RankedSymbol > & symbols ) {
+		accessComponent < GeneralAlphabet > ( ).add ( symbols );
+	}
+
+	const alphabet::RankedSymbol & getSubtreeWildcard ( ) const {
+		return accessElement < SubtreeWildcard > ( ).get ( );
+	}
+
+	const std::set < alphabet::RankedSymbol > & getNonlinearVariables ( ) const {
+		return accessComponent < NonlinearAlphabet > ( ).get ( );
+	}
+
+	void setContent ( std::vector < alphabet::RankedSymbol > data );
+
+	void arityChecksum ( const std::vector < alphabet::RankedSymbol > & data );
+
+	/**
+	 * @return true if tree is an empty word (vector length is 0)
+	 */
+	bool isEmpty ( ) const;
+
+	virtual int compare ( const ObjectBase & other ) const {
+		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
+
+		return std::type_index ( typeid ( * this ) ) - std::type_index ( typeid ( other ) );
+	}
+
+	virtual int compare ( const PrefixRankedNonlinearPattern & other ) const;
+
+	virtual void operator >>( std::ostream & out ) const;
+
+	virtual explicit operator std::string ( ) const;
+
+	static const std::string & getXmlTagName ( ) {
+		static std::string xmlTagName = "PrefixRankedNonlinearPattern";
+
+		return xmlTagName;
+	}
+
+	static PrefixRankedNonlinearPattern parse ( std::deque < sax::Token >::iterator & input );
+
+	void compose ( std::deque < sax::Token > & out ) const;
+};
+
+} /* namespace tree */
+
+#endif /* PREFIX_RANKED_NONLINEAR_PATTERN_H_ */