diff --git a/alib2algo/src/stringology/query/BitParallelismFactors.cpp b/alib2algo/src/stringology/query/BitParallelismFactors.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58f41cfa4c5b2b03d5caaa0c733e04f951edc519
--- /dev/null
+++ b/alib2algo/src/stringology/query/BitParallelismFactors.cpp
@@ -0,0 +1,24 @@
+/*
+ * BitParallelismFactors.cpp
+ *
+ *  Created on: 2. 1. 2017
+ *      Author: Jan Travnicek
+ */
+
+#include "BitParallelismFactors.h"
+
+#include <string/LinearString.h>
+
+namespace stringology {
+
+namespace query {
+
+std::set < unsigned > BitParallelismFactors::query ( const indexes::BitParallelIndex < DefaultSymbolType > & bitParallelIndex, const string::String & string ) {
+	return dispatch ( bitParallelIndex, string.getData ( ) );
+}
+
+auto BitParallelismFactorsLinearString = BitParallelismFactors::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( BitParallelismFactors::query );
+
+} /* namespace query */
+
+} /* namespace stringology */
diff --git a/alib2algo/src/stringology/query/BitParallelismFactors.h b/alib2algo/src/stringology/query/BitParallelismFactors.h
new file mode 100644
index 0000000000000000000000000000000000000000..fcc5d8963e9d56bc302ed546d14c8b29ba1c388d
--- /dev/null
+++ b/alib2algo/src/stringology/query/BitParallelismFactors.h
@@ -0,0 +1,68 @@
+/*
+ * BitParallelismFactors.h
+ *
+ *  Created on: 2. 1. 2017
+ *      Author: Jan Travnicek
+ */
+
+#ifndef BIT_PARALLELISM_FACTORS_H_
+#define BIT_PARALLELISM_FACTORS_H_
+
+#include <indexes/BitParallelIndex.h>
+#include <string/String.h>
+#include <string/LinearString.h>
+#include <core/multipleDispatch.hpp>
+#include <global/GlobalData.h>
+
+namespace stringology {
+
+namespace query {
+
+/**
+ * Query bit parallel index for given string.
+ *
+ */
+
+class BitParallelismFactors : public std::SingleDispatchFirstStaticParam < BitParallelismFactors, std::set < unsigned >, const indexes::BitParallelIndex < DefaultSymbolType > &, const string::StringBase & > {
+
+public:
+	/**
+	 * Query a suffix trie
+	 * @param suffix trie to query
+	 * @param string string to query by
+	 * @return occurences of factors
+	 */
+	static std::set < unsigned > query ( const indexes::BitParallelIndex < DefaultSymbolType > & bitParallelIndex, const string::String & string );
+
+	template < class SymbolType >
+	static std::set < unsigned > query ( const indexes::BitParallelIndex < SymbolType > & bitParallelIndex, const string::LinearString < SymbolType > & string );
+
+};
+
+template < class SymbolType >
+std::set < unsigned > BitParallelismFactors::query ( const indexes::BitParallelIndex < SymbolType > & bitParallelIndex, const string::LinearString < SymbolType > & string ) {
+	std::vector < bool > indexVector;
+	indexVector.resize ( bitParallelIndex.getData ( ).begin ( )->second.size ( ) + 1);
+	indexVector.flip ( );
+
+	for ( const SymbolType & symbol : string.getContent ( ) ) {
+		typename std::map < SymbolType, std::vector < bool > >::const_iterator symbolVectorIter = bitParallelIndex.getData ( ).find ( symbol );
+		if ( symbolVectorIter == bitParallelIndex.getData ( ).end ( ) )
+			return { };
+
+		indexVector = ( indexVector & symbolVectorIter->second ) << 1;
+	}
+
+	std::set < unsigned > res;
+	for ( unsigned i = 0; i < indexVector.size ( ); i++ )
+		if ( indexVector [ i ] )
+			res.insert ( i - string.getContent ( ).size ( ) );
+
+	return res;
+}
+
+} /* namespace query */
+
+} /* namespace stringology */
+
+#endif /* BIT_PARALLELISM_FACTORS_H_ */
diff --git a/alib2algo/src/stringology/query/PositionHeapFactors.cpp b/alib2algo/src/stringology/query/PositionHeapFactors.cpp
index 83424e8a1112e1dc413422916d8b4f3774bea5e9..75ee85ab40929c78fafb4583fe6f808667a4599d 100644
--- a/alib2algo/src/stringology/query/PositionHeapFactors.cpp
+++ b/alib2algo/src/stringology/query/PositionHeapFactors.cpp
@@ -13,8 +13,8 @@ namespace stringology {
 
 namespace query {
 
-std::set < unsigned > PositionHeapFactors::query ( const indexes::PositionHeap < DefaultSymbolType > & suffixTrie, const string::String & string ) {
-	return dispatch ( suffixTrie, string.getData ( ) );
+std::set < unsigned > PositionHeapFactors::query ( const indexes::PositionHeap < DefaultSymbolType > & positionHeap, const string::String & string ) {
+	return dispatch ( positionHeap, string.getData ( ) );
 }
 
 auto PositionHeapFactorsLinearString = PositionHeapFactors::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( PositionHeapFactors::query );
diff --git a/aquery2/src/aquery.cpp b/aquery2/src/aquery.cpp
index 7b1f9b34aeed917165c18504c0d6b12d9ec9fc17..9bef2cbad5102eff625638daea4b8366f5f1aaf7 100644
--- a/aquery2/src/aquery.cpp
+++ b/aquery2/src/aquery.cpp
@@ -18,6 +18,7 @@
 #include <stringology/query/SuffixTrieFactors.h>
 #include <stringology/query/SuffixArrayFactors.h>
 #include <stringology/query/PositionHeapFactors.h>
+#include <stringology/query/BitParallelismFactors.h>
 
 int main ( int argc, char * argv[] ) {
 	try {
@@ -30,6 +31,7 @@ int main ( int argc, char * argv[] ) {
 		allowed.push_back ( "suffixTrieFactors" );
 		allowed.push_back ( "suffixArrayFactors" );
 		allowed.push_back ( "positionHeapFactors" );
+		allowed.push_back ( "bitParallelismFactors" );
 		TCLAP::ValuesConstraint < std::string > allowedVals ( allowed );
 
 		TCLAP::ValueArg < std::string > query ( "q", "query", "Query index", false, "exactFactorMatch", & allowedVals );
@@ -95,6 +97,19 @@ int main ( int argc, char * argv[] ) {
 			measurements::end ( );
 			measurements::start ( "Output write", measurements::Type::AUXILIARY );
 
+			alib::XmlDataFactory::toStdout ( res );
+		} else if ( query.getValue ( ) == "bitParallelismFactors" ) {
+			indexes::BitParallelIndex < > bitParallelIndex = alib::XmlDataFactory::fromTokens < indexes::BitParallelIndex < > > ( sax::FromXMLParserHelper::parseInput ( indexInput ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
+
+			measurements::end ( );
+			measurements::start ( "Algorithm", measurements::Type::MAIN );
+
+			std::set < unsigned > res = stringology::query::BitParallelismFactors::query ( bitParallelIndex, pattern );
+
+			measurements::end ( );
+			measurements::start ( "Output write", measurements::Type::AUXILIARY );
+
 			alib::XmlDataFactory::toStdout ( res );
 		} else {
 			throw exception::CommonException ( "Invalid algorithm" );
diff --git a/tests.astringology.sh b/tests.astringology.sh
index 251e2a12d35c74b10893227dda0fd7b4d81dfd7c..d17db916b5c690ca923e285749bb78912ab82124 100755
--- a/tests.astringology.sh
+++ b/tests.astringology.sh
@@ -212,6 +212,7 @@ function runTest {
 	clearResults
 }
 
+runTest "Bit Parallelism Factors" "./astringology2 -a bitParallelIndex -s \"\$SUBJECT_FILE\" | ./aquery2 -q bitParallelismFactors -p \"\$PATTERN_FILE\" | ./astat2 -p size"
 runTest "Position Heap Factors" "./astringology2 -a positionHeap -s \"\$SUBJECT_FILE\" | ./aquery2 -q positionHeapFactors -p \"\$PATTERN_FILE\" | ./astat2 -p size"
 runTest "Suffix Array Factors" "./astringology2 -a suffixArray -s \"\$SUBJECT_FILE\" | ./aquery2 -q suffixArrayFactors -p \"\$PATTERN_FILE\" | ./astat2 -p size"
 runTest "Suffix Trie Factors" "./astringology2 -a suffixTrie -s \"\$SUBJECT_FILE\" | ./aquery2 -q suffixTrieFactors -p \"\$PATTERN_FILE\" | ./astat2 -p size"