diff --git a/docs/allclasses-frame.html b/docs/allclasses-frame.html
index 4dcb4c9..b0555f4 100644
--- a/docs/allclasses-frame.html
+++ b/docs/allclasses-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>All Classes</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
@@ -34,9 +34,11 @@
 <li><a href="org/apache/pirk/test/distributed/DistributedTestCLI.html" title="class in org.apache.pirk.test.distributed" target="classFrame">DistributedTestCLI</a></li>
 <li><a href="org/apache/pirk/test/distributed/DistributedTestDriver.html" title="class in org.apache.pirk.test.distributed" target="classFrame">DistributedTestDriver</a></li>
 <li><a href="org/apache/pirk/test/distributed/testsuite/DistTestSuite.html" title="class in org.apache.pirk.test.distributed.testsuite" target="classFrame">DistTestSuite</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">EncColMultBolt</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/EncColMultGroupedMapper.html" title="class in org.apache.pirk.responder.wideskies.spark" target="classFrame">EncColMultGroupedMapper</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/EncColMultReducer.html" title="class in org.apache.pirk.responder.wideskies.spark" target="classFrame">EncColMultReducer</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/EncRowCalc.html" title="class in org.apache.pirk.responder.wideskies.spark" target="classFrame">EncRowCalc</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">EncRowCalcBolt</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/EncRowCalcPrecomputedCache.html" title="class in org.apache.pirk.responder.wideskies.spark" target="classFrame">EncRowCalcPrecomputedCache</a></li>
 <li><a href="org/apache/pirk/querier/wideskies/encrypt/EncryptQuery.html" title="class in org.apache.pirk.querier.wideskies.encrypt" target="classFrame">EncryptQuery</a></li>
 <li><a href="org/apache/pirk/utils/EpochDateParser.html" title="class in org.apache.pirk.utils" target="classFrame">EpochDateParser</a></li>
@@ -67,6 +69,7 @@
 <li><a href="org/apache/pirk/inputformat/hadoop/json/JSONInputFormatBase.html" title="class in org.apache.pirk.inputformat.hadoop.json" target="classFrame">JSONInputFormatBase</a></li>
 <li><a href="org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html" title="class in org.apache.pirk.inputformat.hadoop.json" target="classFrame">JSONRecordReader</a></li>
 <li><a href="org/apache/pirk/serialization/JsonSerializer.html" title="class in org.apache.pirk.serialization" target="classFrame">JsonSerializer</a></li>
+<li><a href="org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm" target="classFrame">KafkaStormIntegrationTest</a></li>
 <li><a href="org/apache/pirk/utils/KeyedHash.html" title="class in org.apache.pirk.utils" target="classFrame">KeyedHash</a></li>
 <li><a href="org/apache/pirk/general/KeyedHashTest.html" title="class in org.apache.pirk.general" target="classFrame">KeyedHashTest</a></li>
 <li><a href="org/apache/pirk/schema/data/LoadDataSchemaTest.html" title="class in org.apache.pirk.schema.data" target="classFrame">LoadDataSchemaTest</a></li>
@@ -74,12 +77,16 @@
 <li><a href="org/apache/pirk/serialization/LocalFileSystemStore.html" title="class in org.apache.pirk.serialization" target="classFrame">LocalFileSystemStore</a></li>
 <li><a href="org/apache/pirk/encryption/ModPowAbstraction.html" title="class in org.apache.pirk.encryption" target="classFrame">ModPowAbstraction</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/mapreduce/MRStats.html" title="enum in org.apache.pirk.responder.wideskies.mapreduce" target="classFrame">MRStats</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">OutputBolt</a></li>
 <li><a href="org/apache/pirk/encryption/Paillier.html" title="class in org.apache.pirk.encryption" target="classFrame">Paillier</a></li>
 <li><a href="org/apache/pirk/benchmark/PaillierBenchmark.html" title="class in org.apache.pirk.benchmark" target="classFrame">PaillierBenchmark</a></li>
 <li><a href="org/apache/pirk/benchmark/PaillierBenchmark.PaillierBenchmarkState.html" title="class in org.apache.pirk.benchmark" target="classFrame">PaillierBenchmark.PaillierBenchmarkState</a></li>
 <li><a href="org/apache/pirk/general/PaillierTest.html" title="class in org.apache.pirk.general" target="classFrame">PaillierTest</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">PartitionDataBolt</a></li>
 <li><a href="org/apache/pirk/general/PartitionUtilsTest.html" title="class in org.apache.pirk.general" target="classFrame">PartitionUtilsTest</a></li>
 <li><a href="org/apache/pirk/utils/PIRException.html" title="class in org.apache.pirk.utils" target="classFrame">PIRException</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">PirkHashScheme</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">PirkTopology</a></li>
 <li><a href="org/apache/pirk/encryption/PrimeGenerator.html" title="class in org.apache.pirk.encryption" target="classFrame">PrimeGenerator</a></li>
 <li><a href="org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner" target="classFrame">PrimitiveTypePartitioner</a></li>
 <li><a href="org/apache/pirk/querier/wideskies/Querier.html" title="class in org.apache.pirk.querier.wideskies" target="classFrame">Querier</a></li>
@@ -110,8 +117,11 @@
 <li><a href="org/apache/pirk/schema/query/filter/StopListFilter.html" title="class in org.apache.pirk.schema.query.filter" target="classFrame">StopListFilter</a></li>
 <li><a href="org/apache/pirk/utils/StopListUtils.html" title="class in org.apache.pirk.utils" target="classFrame">StopListUtils</a></li>
 <li><a href="org/apache/pirk/serialization/Storable.html" title="interface in org.apache.pirk.serialization" target="classFrame"><i>Storable</i></a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">StormConstants</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">StormUtils</a></li>
 <li><a href="org/apache/pirk/utils/StringUtils.html" title="class in org.apache.pirk.utils" target="classFrame">StringUtils</a></li>
 <li><a href="org/apache/pirk/utils/SystemConfiguration.html" title="class in org.apache.pirk.utils" target="classFrame">SystemConfiguration</a></li>
+<li><a href="org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm" target="classFrame">SystemTime</a></li>
 <li><a href="org/apache/pirk/test/utils/TestUtils.html" title="class in org.apache.pirk.test.utils" target="classFrame">TestUtils</a></li>
 <li><a href="org/apache/pirk/inputformat/hadoop/TextArrayWritable.html" title="class in org.apache.pirk.inputformat.hadoop" target="classFrame">TextArrayWritable</a></li>
 </ul>
diff --git a/docs/allclasses-noframe.html b/docs/allclasses-noframe.html
index 9054f24..c35ccb0 100644
--- a/docs/allclasses-noframe.html
+++ b/docs/allclasses-noframe.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>All Classes</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
@@ -34,9 +34,11 @@
 <li><a href="org/apache/pirk/test/distributed/DistributedTestCLI.html" title="class in org.apache.pirk.test.distributed">DistributedTestCLI</a></li>
 <li><a href="org/apache/pirk/test/distributed/DistributedTestDriver.html" title="class in org.apache.pirk.test.distributed">DistributedTestDriver</a></li>
 <li><a href="org/apache/pirk/test/distributed/testsuite/DistTestSuite.html" title="class in org.apache.pirk.test.distributed.testsuite">DistTestSuite</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncColMultBolt</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/EncColMultGroupedMapper.html" title="class in org.apache.pirk.responder.wideskies.spark">EncColMultGroupedMapper</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/EncColMultReducer.html" title="class in org.apache.pirk.responder.wideskies.spark">EncColMultReducer</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/EncRowCalc.html" title="class in org.apache.pirk.responder.wideskies.spark">EncRowCalc</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncRowCalcBolt</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/EncRowCalcPrecomputedCache.html" title="class in org.apache.pirk.responder.wideskies.spark">EncRowCalcPrecomputedCache</a></li>
 <li><a href="org/apache/pirk/querier/wideskies/encrypt/EncryptQuery.html" title="class in org.apache.pirk.querier.wideskies.encrypt">EncryptQuery</a></li>
 <li><a href="org/apache/pirk/utils/EpochDateParser.html" title="class in org.apache.pirk.utils">EpochDateParser</a></li>
@@ -67,6 +69,7 @@
 <li><a href="org/apache/pirk/inputformat/hadoop/json/JSONInputFormatBase.html" title="class in org.apache.pirk.inputformat.hadoop.json">JSONInputFormatBase</a></li>
 <li><a href="org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html" title="class in org.apache.pirk.inputformat.hadoop.json">JSONRecordReader</a></li>
 <li><a href="org/apache/pirk/serialization/JsonSerializer.html" title="class in org.apache.pirk.serialization">JsonSerializer</a></li>
+<li><a href="org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm">KafkaStormIntegrationTest</a></li>
 <li><a href="org/apache/pirk/utils/KeyedHash.html" title="class in org.apache.pirk.utils">KeyedHash</a></li>
 <li><a href="org/apache/pirk/general/KeyedHashTest.html" title="class in org.apache.pirk.general">KeyedHashTest</a></li>
 <li><a href="org/apache/pirk/schema/data/LoadDataSchemaTest.html" title="class in org.apache.pirk.schema.data">LoadDataSchemaTest</a></li>
@@ -74,12 +77,16 @@
 <li><a href="org/apache/pirk/serialization/LocalFileSystemStore.html" title="class in org.apache.pirk.serialization">LocalFileSystemStore</a></li>
 <li><a href="org/apache/pirk/encryption/ModPowAbstraction.html" title="class in org.apache.pirk.encryption">ModPowAbstraction</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/mapreduce/MRStats.html" title="enum in org.apache.pirk.responder.wideskies.mapreduce">MRStats</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">OutputBolt</a></li>
 <li><a href="org/apache/pirk/encryption/Paillier.html" title="class in org.apache.pirk.encryption">Paillier</a></li>
 <li><a href="org/apache/pirk/benchmark/PaillierBenchmark.html" title="class in org.apache.pirk.benchmark">PaillierBenchmark</a></li>
 <li><a href="org/apache/pirk/benchmark/PaillierBenchmark.PaillierBenchmarkState.html" title="class in org.apache.pirk.benchmark">PaillierBenchmark.PaillierBenchmarkState</a></li>
 <li><a href="org/apache/pirk/general/PaillierTest.html" title="class in org.apache.pirk.general">PaillierTest</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">PartitionDataBolt</a></li>
 <li><a href="org/apache/pirk/general/PartitionUtilsTest.html" title="class in org.apache.pirk.general">PartitionUtilsTest</a></li>
 <li><a href="org/apache/pirk/utils/PIRException.html" title="class in org.apache.pirk.utils">PIRException</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkHashScheme</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkTopology</a></li>
 <li><a href="org/apache/pirk/encryption/PrimeGenerator.html" title="class in org.apache.pirk.encryption">PrimeGenerator</a></li>
 <li><a href="org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner">PrimitiveTypePartitioner</a></li>
 <li><a href="org/apache/pirk/querier/wideskies/Querier.html" title="class in org.apache.pirk.querier.wideskies">Querier</a></li>
@@ -110,8 +117,11 @@
 <li><a href="org/apache/pirk/schema/query/filter/StopListFilter.html" title="class in org.apache.pirk.schema.query.filter">StopListFilter</a></li>
 <li><a href="org/apache/pirk/utils/StopListUtils.html" title="class in org.apache.pirk.utils">StopListUtils</a></li>
 <li><a href="org/apache/pirk/serialization/Storable.html" title="interface in org.apache.pirk.serialization"><i>Storable</i></a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm">StormUtils</a></li>
 <li><a href="org/apache/pirk/utils/StringUtils.html" title="class in org.apache.pirk.utils">StringUtils</a></li>
 <li><a href="org/apache/pirk/utils/SystemConfiguration.html" title="class in org.apache.pirk.utils">SystemConfiguration</a></li>
+<li><a href="org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm">SystemTime</a></li>
 <li><a href="org/apache/pirk/test/utils/TestUtils.html" title="class in org.apache.pirk.test.utils">TestUtils</a></li>
 <li><a href="org/apache/pirk/inputformat/hadoop/TextArrayWritable.html" title="class in org.apache.pirk.inputformat.hadoop">TextArrayWritable</a></li>
 </ul>
diff --git a/docs/constant-values.html b/docs/constant-values.html
index 6b1e811..c67406f 100644
--- a/docs/constant-values.html
+++ b/docs/constant-values.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Constant Field Values</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
@@ -403,6 +403,258 @@
 <ul class="blockList">
 <li class="blockList">
 <table border="0" cellpadding="3" cellspacing="0" summary="Constant Field Values table, listing constant fields, and values">
+<caption><span>org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th scope="col">Constant Field</th>
+<th class="colLast" scope="col">Value</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ALLOW_ADHOC_QSCHEMAS_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ALLOW_ADHOC_QSCHEMAS_KEY">ALLOW_ADHOC_QSCHEMAS_KEY</a></code></td>
+<td class="colLast"><code>"allowAdHocQuerySchemas"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.COLUMN_INDEX_ECM_FIELD">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_INDEX_ECM_FIELD">COLUMN_INDEX_ECM_FIELD</a></code></td>
+<td class="colLast"><code>"colIndex"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.COLUMN_INDEX_ERC_FIELD">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_INDEX_ERC_FIELD">COLUMN_INDEX_ERC_FIELD</a></code></td>
+<td class="colLast"><code>"colIndexErc"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.COLUMN_PRODUCT_FIELD">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_PRODUCT_FIELD">COLUMN_PRODUCT_FIELD</a></code></td>
+<td class="colLast"><code>"colProduct"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.DEFAULT">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#DEFAULT">DEFAULT</a></code></td>
+<td class="colLast"><code>"default"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.DSCHEMA_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#DSCHEMA_KEY">DSCHEMA_KEY</a></code></td>
+<td class="colLast"><code>"dschema"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ENCCOLMULTBOLT_ID">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_ID">ENCCOLMULTBOLT_ID</a></code></td>
+<td class="colLast"><code>"enccolmultbolt"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ENCCOLMULTBOLT_PARALLELISM_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_PARALLELISM_KEY">ENCCOLMULTBOLT_PARALLELISM_KEY</a></code></td>
+<td class="colLast"><code>"enccolmultboltPar"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ENCCOLMULTBOLT_SESSION_END">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_SESSION_END">ENCCOLMULTBOLT_SESSION_END</a></code></td>
+<td class="colLast"><code>"enccolmultbolt_sess_end"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ENCROWCALCBOLT_DATASTREAM_ID">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_DATASTREAM_ID">ENCROWCALCBOLT_DATASTREAM_ID</a></code></td>
+<td class="colLast"><code>"encrowcalcbolt_datastream_id"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ENCROWCALCBOLT_FLUSH_SIG">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_FLUSH_SIG">ENCROWCALCBOLT_FLUSH_SIG</a></code></td>
+<td class="colLast"><code>"encrowcalcbolt_flush"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ENCROWCALCBOLT_ID">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_ID">ENCROWCALCBOLT_ID</a></code></td>
+<td class="colLast"><code>"encrowcalcbolt"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ENCROWCALCBOLT_PARALLELISM_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_PARALLELISM_KEY">ENCROWCALCBOLT_PARALLELISM_KEY</a></code></td>
+<td class="colLast"><code>"encrowcalcboltPar"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ENCRYPTED_VALUE_FIELD">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCRYPTED_VALUE_FIELD">ENCRYPTED_VALUE_FIELD</a></code></td>
+<td class="colLast"><code>"encRowValue"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.FLUSH">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#FLUSH">FLUSH</a></code></td>
+<td class="colLast"><code>"flush"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.HASH_FIELD">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#HASH_FIELD">HASH_FIELD</a></code></td>
+<td class="colLast"><code>"hash"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.HDFS_URI_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#HDFS_URI_KEY">HDFS_URI_KEY</a></code></td>
+<td class="colLast"><code>"hdfsUri"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.JSON_DATA_FIELD">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#JSON_DATA_FIELD">JSON_DATA_FIELD</a></code></td>
+<td class="colLast"><code>"data"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.LIMIT_HITS_PER_SEL_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#LIMIT_HITS_PER_SEL_KEY">LIMIT_HITS_PER_SEL_KEY</a></code></td>
+<td class="colLast"><code>"limitHitsPerSelector"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.MAX_HITS_PER_SEL_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#MAX_HITS_PER_SEL_KEY">MAX_HITS_PER_SEL_KEY</a></code></td>
+<td class="colLast"><code>"maxHitsPerSelector"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.N_SQUARED_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#N_SQUARED_KEY">N_SQUARED_KEY</a></code></td>
+<td class="colLast"><code>"nSquared"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.OUTPUT_FILE_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#OUTPUT_FILE_KEY">OUTPUT_FILE_KEY</a></code></td>
+<td class="colLast"><code>"output"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.OUTPUTBOLT_ID">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#OUTPUTBOLT_ID">OUTPUTBOLT_ID</a></code></td>
+<td class="colLast"><code>"outputbolt"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.PARTIONED_DATA_FIELD">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#PARTIONED_DATA_FIELD">PARTIONED_DATA_FIELD</a></code></td>
+<td class="colLast"><code>"parData"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.PARTITION_DATA_BOLT_ID">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#PARTITION_DATA_BOLT_ID">PARTITION_DATA_BOLT_ID</a></code></td>
+<td class="colLast"><code>"partitiondataBolt"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.QSCHEMA_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#QSCHEMA_KEY">QSCHEMA_KEY</a></code></td>
+<td class="colLast"><code>"qSchema"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.QUERY_FILE_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#QUERY_FILE_KEY">QUERY_FILE_KEY</a></code></td>
+<td class="colLast"><code>"queryFile"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.QUERY_INFO_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#QUERY_INFO_KEY">QUERY_INFO_KEY</a></code></td>
+<td class="colLast"><code>"queryInfo"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.ROW_DIVISIONS_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#ROW_DIVISIONS_KEY">ROW_DIVISIONS_KEY</a></code></td>
+<td class="colLast"><code>"rowDivisions"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.SALT">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#SALT">SALT</a></code></td>
+<td class="colLast"><code>"salt"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.SALT_COLUMNS_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#SALT_COLUMNS_KEY">SALT_COLUMNS_KEY</a></code></td>
+<td class="colLast"><code>"saltColumns"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.SPLIT_PARTITIONS_KEY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#SPLIT_PARTITIONS_KEY">SPLIT_PARTITIONS_KEY</a></code></td>
+<td class="colLast"><code>"splitPartitions"</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.SPOUT_ID">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#SPOUT_ID">SPOUT_ID</a></code></td>
+<td class="colLast"><code>"kafkaspout"</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.apache.pirk.responder.wideskies.storm.StormConstants.USE_HDFS">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;java.lang.String</code></td>
+<td><code><a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html#USE_HDFS">USE_HDFS</a></code></td>
+<td class="colLast"><code>"useHdfs"</code></td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+<ul class="blockList">
+<li class="blockList">
+<table border="0" cellpadding="3" cellspacing="0" summary="Constant Field Values table, listing constant fields, and values">
 <caption><span>org.apache.pirk.schema.data.partitioner.<a href="org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner">PrimitiveTypePartitioner</a></span><span class="tabEnd">&nbsp;</span></caption>
 <tr>
 <th class="colFirst" scope="col">Modifier and Type</th>
diff --git a/docs/deprecated-list.html b/docs/deprecated-list.html
index 931c63e..634f1ad 100644
--- a/docs/deprecated-list.html
+++ b/docs/deprecated-list.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>Deprecated List</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
diff --git a/docs/help-doc.html b/docs/help-doc.html
index bf29602..b465658 100644
--- a/docs/help-doc.html
+++ b/docs/help-doc.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>API Help</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
diff --git a/docs/index-files/index-1.html b/docs/index-files/index-1.html
index 659dc0b..1e4978b 100644
--- a/docs/index-files/index-1.html
+++ b/docs/index-files/index-1.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>A-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -87,6 +87,8 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/query/wideskies/QueryInfo.html#addQuerySchema(org.apache.pirk.schema.query.QuerySchema)">addQuerySchema(QuerySchema)</a></span> - Method in class org.apache.pirk.query.wideskies.<a href="../org/apache/pirk/query/wideskies/QueryInfo.html" title="class in org.apache.pirk.query.wideskies">QueryInfo</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ALLOW_ADHOC_QSCHEMAS_KEY">ALLOW_ADHOC_QSCHEMAS_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/inputformat/hadoop/InputFormatConst.html#ALLOWED_FORMATS">ALLOWED_FORMATS</a></span> - Static variable in class org.apache.pirk.inputformat.hadoop.<a href="../org/apache/pirk/inputformat/hadoop/InputFormatConst.html" title="class in org.apache.pirk.inputformat.hadoop">InputFormatConst</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#ALLOWEMBEDDEDQUERYSCHEMAS">ALLOWEMBEDDEDQUERYSCHEMAS</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
diff --git a/docs/index-files/index-10.html b/docs/index-files/index-10.html
index 5ccbee5..d3a8da3 100644
--- a/docs/index-files/index-10.html
+++ b/docs/index-files/index-10.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>J-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -71,6 +71,8 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/serialization/JavaSerializer.html#JavaSerializer()">JavaSerializer()</a></span> - Constructor for class org.apache.pirk.serialization.<a href="../org/apache/pirk/serialization/JavaSerializer.html" title="class in org.apache.pirk.serialization">JavaSerializer</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#JSON_DATA_FIELD">JSON_DATA_FIELD</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/distributed/DistributedTestDriver.html#JSON_PIR_INPUT_FILE_PROPERTY">JSON_PIR_INPUT_FILE_PROPERTY</a></span> - Static variable in class org.apache.pirk.test.distributed.<a href="../org/apache/pirk/test/distributed/DistributedTestDriver.html" title="class in org.apache.pirk.test.distributed">DistributedTestDriver</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/StringUtils.html#jsonArrayStringToArrayList(java.lang.String)">jsonArrayStringToArrayList(String)</a></span> - Static method in class org.apache.pirk.utils.<a href="../org/apache/pirk/utils/StringUtils.html" title="class in org.apache.pirk.utils">StringUtils</a></dt>
diff --git a/docs/index-files/index-11.html b/docs/index-files/index-11.html
index 48568d1..82d8894 100644
--- a/docs/index-files/index-11.html
+++ b/docs/index-files/index-11.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>K-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -67,6 +67,10 @@
 </a>
 <h2 class="title">K</h2>
 <dl>
+<dt><a href="../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm"><span class="strong">KafkaStormIntegrationTest</span></a> - Class in <a href="../org/apache/pirk/storm/package-summary.html">org.apache.pirk.storm</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/storm/KafkaStormIntegrationTest.html#KafkaStormIntegrationTest()">KafkaStormIntegrationTest()</a></span> - Constructor for class org.apache.pirk.storm.<a href="../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm">KafkaStormIntegrationTest</a></dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/utils/KeyedHash.html" title="class in org.apache.pirk.utils"><span class="strong">KeyedHash</span></a> - Class in <a href="../org/apache/pirk/utils/package-summary.html">org.apache.pirk.utils</a></dt>
 <dd>
 <div class="block">Class for the PIR keyed hash</div>
diff --git a/docs/index-files/index-12.html b/docs/index-files/index-12.html
index b222942..1651e8f 100644
--- a/docs/index-files/index-12.html
+++ b/docs/index-files/index-12.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>L-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -67,6 +67,10 @@
 </a>
 <h2 class="title">L</h2>
 <dl>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#latch">latch</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">OutputBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#LIMIT_HITS_PER_SEL_KEY">LIMIT_HITS_PER_SEL_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#LIMITHITSPERSELECTOR">LIMITHITSPERSELECTOR</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#loadCacheFromHDFS(org.apache.hadoop.fs.FileSystem,%20java.lang.String,%20org.apache.pirk.query.wideskies.Query)">loadCacheFromHDFS(FileSystem, String, Query)</a></span> - Static method in class org.apache.pirk.responder.wideskies.common.<a href="../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html" title="class in org.apache.pirk.responder.wideskies.common">ComputeEncryptedRow</a></dt>
diff --git a/docs/index-files/index-13.html b/docs/index-files/index-13.html
index dbc61de..b194d9a 100644
--- a/docs/index-files/index-13.html
+++ b/docs/index-files/index-13.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>M-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -91,10 +91,14 @@
 <dd>
 <div class="block">Method to convert a MapWritable into a JSON string</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#MAX_HITS_PER_SEL_KEY">MAX_HITS_PER_SEL_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#MAXBATCHES">MAXBATCHES</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#MAXHITSPERSELECTOR">MAXHITSPERSELECTOR</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/storm/SystemTime.html#milliseconds()">milliseconds()</a></span> - Method in class org.apache.pirk.storm.<a href="../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm">SystemTime</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/encryption/ModPowAbstraction.html#modPow(java.math.BigInteger,%20java.math.BigInteger,%20java.math.BigInteger)">modPow(BigInteger, BigInteger, BigInteger)</a></span> - Static method in class org.apache.pirk.encryption.<a href="../org/apache/pirk/encryption/ModPowAbstraction.html" title="class in org.apache.pirk.encryption">ModPowAbstraction</a></dt>
 <dd>
 <div class="block">Performs modPow: (<code>base</code>^<code>exponent</code>) mod <code>modulus</code>
diff --git a/docs/index-files/index-14.html b/docs/index-files/index-14.html
index bd1c017..dbd46a7 100644
--- a/docs/index-files/index-14.html
+++ b/docs/index-files/index-14.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>N-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -67,6 +67,10 @@
 </a>
 <h2 class="title">N</h2>
 <dl>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#N_SQUARED_KEY">N_SQUARED_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/storm/SystemTime.html#nanoseconds()">nanoseconds()</a></span> - Method in class org.apache.pirk.storm.<a href="../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm">SystemTime</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html#nextKeyValue()">nextKeyValue()</a></span> - Method in class org.apache.pirk.inputformat.hadoop.json.<a href="../org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html" title="class in org.apache.pirk.inputformat.hadoop.json">JSONRecordReader</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/spark/Accumulators.html#numBatchesGetValue()">numBatchesGetValue()</a></span> - Method in class org.apache.pirk.responder.wideskies.spark.<a href="../org/apache/pirk/responder/wideskies/spark/Accumulators.html" title="class in org.apache.pirk.responder.wideskies.spark">Accumulators</a></dt>
diff --git a/docs/index-files/index-15.html b/docs/index-files/index-15.html
index 5edcc92..5578bf5 100644
--- a/docs/index-files/index-15.html
+++ b/docs/index-files/index-15.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>O-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -97,6 +97,8 @@
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/responder/wideskies/standalone/package-summary.html">org.apache.pirk.responder.wideskies.standalone</a> - package org.apache.pirk.responder.wideskies.standalone</dt>
 <dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a> - package org.apache.pirk.responder.wideskies.storm</dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/response/wideskies/package-summary.html">org.apache.pirk.response.wideskies</a> - package org.apache.pirk.response.wideskies</dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/schema/data/package-summary.html">org.apache.pirk.schema.data</a> - package org.apache.pirk.schema.data</dt>
@@ -111,6 +113,8 @@
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/serialization/package-summary.html">org.apache.pirk.serialization</a> - package org.apache.pirk.serialization</dt>
 <dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/storm/package-summary.html">org.apache.pirk.storm</a> - package org.apache.pirk.storm</dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/test/distributed/package-summary.html">org.apache.pirk.test.distributed</a> - package org.apache.pirk.test.distributed</dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/test/distributed/testsuite/package-summary.html">org.apache.pirk.test.distributed.testsuite</a> - package org.apache.pirk.test.distributed.testsuite</dt>
@@ -123,6 +127,16 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/distributed/DistributedTestDriver.html#OUTPUT_DIRECTORY_PROPERTY">OUTPUT_DIRECTORY_PROPERTY</a></span> - Static variable in class org.apache.pirk.test.distributed.<a href="../org/apache/pirk/test/distributed/DistributedTestDriver.html" title="class in org.apache.pirk.test.distributed">DistributedTestDriver</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#OUTPUT_FILE_KEY">OUTPUT_FILE_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">OutputBolt</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></dt>
+<dd>
+<div class="block">Bolt to compute and output the final Response object for a query</div>
+</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#OutputBolt()">OutputBolt()</a></span> - Constructor for class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">OutputBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#OUTPUTBOLT_ID">OUTPUTBOLT_ID</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/querier/wideskies/QuerierProps.html#OUTPUTFILE">OUTPUTFILE</a></span> - Static variable in class org.apache.pirk.querier.wideskies.<a href="../org/apache/pirk/querier/wideskies/QuerierProps.html" title="class in org.apache.pirk.querier.wideskies">QuerierProps</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#OUTPUTFILE">OUTPUTFILE</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
diff --git a/docs/index-files/index-16.html b/docs/index-files/index-16.html
index 3cd1a02..b0e6b6e 100644
--- a/docs/index-files/index-16.html
+++ b/docs/index-files/index-16.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>P-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -103,10 +103,20 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/ISO8601DateParser.html#parseDate(java.lang.String)">parseDate(String)</a></span> - Static method in class org.apache.pirk.utils.<a href="../org/apache/pirk/utils/ISO8601DateParser.html" title="class in org.apache.pirk.utils">ISO8601DateParser</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#PARTIONED_DATA_FIELD">PARTIONED_DATA_FIELD</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#PARTITION_DATA_BOLT_ID">PARTITION_DATA_BOLT_ID</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html#partitionBits(java.math.BigInteger,%20int,%20java.math.BigInteger)">partitionBits(BigInteger, int, BigInteger)</a></span> - Static method in class org.apache.pirk.schema.data.partitioner.<a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner">PrimitiveTypePartitioner</a></dt>
 <dd>
 <div class="block">Splits the given BigInteger into partitions given by the partitionSize.</div>
 </dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PartitionDataBolt</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></dt>
+<dd>
+<div class="block">Bolt to extract the partitions of the data record and output <code>&lt;hash(selector), dataPartitions&gt;</code></div>
+</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html#PartitionDataBolt()">PartitionDataBolt()</a></span> - Constructor for class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">PartitionDataBolt</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/query/wideskies/QueryUtils.html#partitionDataElement(org.apache.pirk.schema.query.QuerySchema,%20org.json.simple.JSONObject,%20boolean)">partitionDataElement(QuerySchema, JSONObject, boolean)</a></span> - Static method in class org.apache.pirk.query.wideskies.<a href="../org/apache/pirk/query/wideskies/QueryUtils.html" title="class in org.apache.pirk.query.wideskies">QueryUtils</a></dt>
 <dd>
 <div class="block">Method to convert the given data element given by the JSONObject data element into the extracted BigInteger partitions based upon the given queryType</div>
@@ -163,8 +173,32 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/PIRException.html#PIRException(java.lang.String,%20java.lang.Throwable)">PIRException(String, Throwable)</a></span> - Constructor for exception org.apache.pirk.utils.<a href="../org/apache/pirk/utils/PIRException.html" title="class in org.apache.pirk.utils">PIRException</a></dt>
 <dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PirkHashScheme</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></dt>
+<dd>
+<div class="block">Scheme used by spout to retrieve and hash selector from JSON data on Kafka.</div>
+</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html#PirkHashScheme(org.apache.storm.Config)">PirkHashScheme(Config)</a></span> - Constructor for class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkHashScheme</a></dt>
+<dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PirkTopology</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></dt>
+<dd>
+<div class="block">Storm topology class for wideskies Pirk implementation</div>
+</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html#PirkTopology()">PirkTopology()</a></span> - Constructor for class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkTopology</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#PLATFORM">PLATFORM</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html#prepare(java.util.Map,%20org.apache.storm.task.TopologyContext,%20org.apache.storm.task.OutputCollector)">prepare(Map, TopologyContext, OutputCollector)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncColMultBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html#prepare(java.util.Map,%20org.apache.storm.task.TopologyContext,%20org.apache.storm.task.OutputCollector)">prepare(Map, TopologyContext, OutputCollector)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncRowCalcBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#prepare(java.util.Map,%20org.apache.storm.task.TopologyContext,%20org.apache.storm.task.OutputCollector)">prepare(Map, TopologyContext, OutputCollector)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">OutputBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html#prepare(java.util.Map,%20org.apache.storm.task.TopologyContext)">prepare(Map, TopologyContext)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">PartitionDataBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html#prepareQuery(java.util.Map)">prepareQuery(Map)</a></span> - Static method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm">StormUtils</a></dt>
+<dd>
+<div class="block">Method to read in and return a serialized Query object from the given file and initialize/load the query.schemas and data.schemas</div>
+</dd>
 <dt><a href="../org/apache/pirk/encryption/PrimeGenerator.html" title="class in org.apache.pirk.encryption"><span class="strong">PrimeGenerator</span></a> - Class in <a href="../org/apache/pirk/encryption/package-summary.html">org.apache.pirk.encryption</a></dt>
 <dd>
 <div class="block">Class to generate the primes used in the Paillier cryptosystem</div>
diff --git a/docs/index-files/index-17.html b/docs/index-files/index-17.html
index 3c52b8a..b52b6c5 100644
--- a/docs/index-files/index-17.html
+++ b/docs/index-files/index-17.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>Q-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -69,6 +69,8 @@
 <dl>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/Inputs.html#QNAME">QNAME</a></span> - Static variable in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/Inputs.html" title="class in org.apache.pirk.test.utils">Inputs</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#QSCHEMA_KEY">QSCHEMA_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/Inputs.html#QTYPE">QTYPE</a></span> - Static variable in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/Inputs.html" title="class in org.apache.pirk.test.utils">Inputs</a></dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/querier/wideskies/Querier.html" title="class in org.apache.pirk.querier.wideskies"><span class="strong">Querier</span></a> - Class in <a href="../org/apache/pirk/querier/wideskies/package-summary.html">org.apache.pirk.querier.wideskies</a></dt>
@@ -111,10 +113,14 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/query/wideskies/Query.html#Query(org.apache.pirk.query.wideskies.QueryInfo,%20java.math.BigInteger)">Query(QueryInfo, BigInteger)</a></span> - Constructor for class org.apache.pirk.query.wideskies.<a href="../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#QUERY_FILE_KEY">QUERY_FILE_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/querier/wideskies/QuerierConst.html#QUERY_FILETAG">QUERY_FILETAG</a></span> - Static variable in class org.apache.pirk.querier.wideskies.<a href="../org/apache/pirk/querier/wideskies/QuerierConst.html" title="class in org.apache.pirk.querier.wideskies">QuerierConst</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/response/QueryResponseJSON.html#QUERY_ID">QUERY_ID</a></span> - Static variable in class org.apache.pirk.schema.response.<a href="../org/apache/pirk/schema/response/QueryResponseJSON.html" title="class in org.apache.pirk.schema.response">QueryResponseJSON</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#QUERY_INFO_KEY">QUERY_INFO_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/BaseTests.html#queryIdentifier">queryIdentifier</a></span> - Static variable in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/BaseTests.html" title="class in org.apache.pirk.test.utils">BaseTests</a></dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/query/wideskies/QueryInfo.html" title="class in org.apache.pirk.query.wideskies"><span class="strong">QueryInfo</span></a> - Class in <a href="../org/apache/pirk/query/wideskies/package-summary.html">org.apache.pirk.query.wideskies</a></dt>
@@ -125,6 +131,8 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/query/wideskies/QueryInfo.html#QueryInfo(java.util.UUID,%20int,%20int,%20java.lang.String,%20int,%20java.lang.String,%20boolean,%20boolean,%20boolean)">QueryInfo(UUID, int, int, String, int, String, boolean, boolean, boolean)</a></span> - Constructor for class org.apache.pirk.query.wideskies.<a href="../org/apache/pirk/query/wideskies/QueryInfo.html" title="class in org.apache.pirk.query.wideskies">QueryInfo</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/query/wideskies/QueryInfo.html#QueryInfo(java.util.Map)">QueryInfo(Map)</a></span> - Constructor for class org.apache.pirk.query.wideskies.<a href="../org/apache/pirk/query/wideskies/QueryInfo.html" title="class in org.apache.pirk.query.wideskies">QueryInfo</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#QUERYINPUT">QUERYINPUT</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/utils/QueryParserUtils.html" title="class in org.apache.pirk.utils"><span class="strong">QueryParserUtils</span></a> - Class in <a href="../org/apache/pirk/utils/package-summary.html">org.apache.pirk.utils</a></dt>
diff --git a/docs/index-files/index-18.html b/docs/index-files/index-18.html
index bc95e60..1e7bcd1 100644
--- a/docs/index-files/index-18.html
+++ b/docs/index-files/index-18.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>R-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -179,6 +179,8 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/response/wideskies/Response.html#Response(org.apache.pirk.query.wideskies.QueryInfo)">Response(QueryInfo)</a></span> - Constructor for class org.apache.pirk.response.wideskies.<a href="../org/apache/pirk/response/wideskies/Response.html" title="class in org.apache.pirk.response.wideskies">Response</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ROW_DIVISIONS_KEY">ROW_DIVISIONS_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/responder/wideskies/mapreduce/RowCalcReducer.html" title="class in org.apache.pirk.responder.wideskies.mapreduce"><span class="strong">RowCalcReducer</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/mapreduce/package-summary.html">org.apache.pirk.responder.wideskies.mapreduce</a></dt>
 <dd>
 <div class="block">Reducer class to calculate the encrypted rows of the encrypted query</div>
@@ -195,6 +197,8 @@
 <dd>
 <div class="block">Determine if the argument was provided for the selected option, which determines if a test should or should not be run</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html#runPirkTopology()">runPirkTopology()</a></span> - Static method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkTopology</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/wideskies/standalone/StandaloneTest.html#runTests()">runTests()</a></span> - Method in class org.apache.pirk.wideskies.standalone.<a href="../org/apache/pirk/wideskies/standalone/StandaloneTest.html" title="class in org.apache.pirk.wideskies.standalone">StandaloneTest</a></dt>
 <dd>&nbsp;</dd>
 </dl>
diff --git a/docs/index-files/index-19.html b/docs/index-files/index-19.html
index 4d03277..03fd9ee 100644
--- a/docs/index-files/index-19.html
+++ b/docs/index-files/index-19.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>S-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -67,6 +67,10 @@
 </a>
 <h2 class="title">S</h2>
 <dl>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#SALT">SALT</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#SALT_COLUMNS_KEY">SALT_COLUMNS_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/response/QueryResponseJSON.html#SELECTOR">SELECTOR</a></span> - Static variable in class org.apache.pirk.schema.response.<a href="../org/apache/pirk/schema/response/QueryResponseJSON.html" title="class in org.apache.pirk.schema.response">QueryResponseJSON</a></dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/serialization/SerializationService.html" title="class in org.apache.pirk.serialization"><span class="strong">SerializationService</span></a> - Class in <a href="../org/apache/pirk/serialization/package-summary.html">org.apache.pirk.serialization</a></dt>
@@ -176,6 +180,12 @@
 <dd>
 <div class="block">Returns the number of elements in the underlying array</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/storm/SystemTime.html#sleep(long)">sleep(long)</a></span> - Method in class org.apache.pirk.storm.<a href="../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm">SystemTime</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#SPLIT_PARTITIONS_KEY">SPLIT_PARTITIONS_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#SPOUT_ID">SPOUT_ID</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/Inputs.html#SRCIP">SRCIP</a></span> - Static variable in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/Inputs.html" title="class in org.apache.pirk.test.utils">Inputs</a></dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/test/utils/StandaloneQuery.html" title="class in org.apache.pirk.test.utils"><span class="strong">StandaloneQuery</span></a> - Class in <a href="../org/apache/pirk/test/utils/package-summary.html">org.apache.pirk.test.utils</a></dt>
@@ -228,6 +238,16 @@
 <dd>
 <div class="block">Stores the given object at the given file location.</div>
 </dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">StormConstants</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#StormConstants()">StormConstants()</a></span> - Constructor for class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">StormUtils</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></dt>
+<dd>
+<div class="block">Utils class for the Storm implementation of Wideskies</div>
+</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html#StormUtils()">StormUtils()</a></span> - Constructor for class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm">StormUtils</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html#STRING">STRING</a></span> - Static variable in class org.apache.pirk.schema.data.partitioner.<a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner">PrimitiveTypePartitioner</a></dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/utils/StringUtils.html" title="class in org.apache.pirk.utils"><span class="strong">StringUtils</span></a> - Class in <a href="../org/apache/pirk/utils/package-summary.html">org.apache.pirk.utils</a></dt>
@@ -244,6 +264,10 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/SystemConfiguration.html#SystemConfiguration()">SystemConfiguration()</a></span> - Constructor for class org.apache.pirk.utils.<a href="../org/apache/pirk/utils/SystemConfiguration.html" title="class in org.apache.pirk.utils">SystemConfiguration</a></dt>
 <dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm"><span class="strong">SystemTime</span></a> - Class in <a href="../org/apache/pirk/storm/package-summary.html">org.apache.pirk.storm</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/storm/SystemTime.html#SystemTime()">SystemTime()</a></span> - Constructor for class org.apache.pirk.storm.<a href="../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm">SystemTime</a></dt>
+<dd>&nbsp;</dd>
 </dl>
 <a href="index-1.html">A</a>&nbsp;<a href="index-2.html">B</a>&nbsp;<a href="index-3.html">C</a>&nbsp;<a href="index-4.html">D</a>&nbsp;<a href="index-5.html">E</a>&nbsp;<a href="index-6.html">F</a>&nbsp;<a href="index-7.html">G</a>&nbsp;<a href="index-8.html">H</a>&nbsp;<a href="index-9.html">I</a>&nbsp;<a href="index-10.html">J</a>&nbsp;<a href="index-11.html">K</a>&nbsp;<a href="index-12.html">L</a>&nbsp;<a href="index-13.html">M</a>&nbsp;<a href="index-14.html">N</a>&nbsp;<a href="index-15.html">O</a>&nbsp;<a href="index-16.html">P</a>&nbsp;<a href="index-17.html">Q</a>&nbsp;<a href="index-18.html">R</a>&nbsp;<a href="index-19.html">S</a>&nbsp;<a href="index-20.html">T</a>&nbsp;<a href="index-21.html">U</a>&nbsp;<a href="index-22.html">V</a>&nbsp;<a href="index-23.html">W</a>&nbsp;</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
diff --git a/docs/index-files/index-2.html b/docs/index-files/index-2.html
index 1fe9b90..6a6ae0e 100644
--- a/docs/index-files/index-2.html
+++ b/docs/index-files/index-2.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>B-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
diff --git a/docs/index-files/index-20.html b/docs/index-files/index-20.html
index 804681a..d26d015 100644
--- a/docs/index-files/index-20.html
+++ b/docs/index-files/index-20.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>T-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -73,6 +73,8 @@
 <dd>
 <div class="block">Method to tear down necessary elements when app is complete</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/storm/KafkaStormIntegrationTest.html#tearDown()">tearDown()</a></span> - Static method in class org.apache.pirk.storm.<a href="../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm">KafkaStormIntegrationTest</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/wideskies/standalone/StandaloneTest.html#teardown()">teardown()</a></span> - Static method in class org.apache.pirk.wideskies.standalone.<a href="../org/apache/pirk/wideskies/standalone/StandaloneTest.html" title="class in org.apache.pirk.wideskies.standalone">StandaloneTest</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/distributed/DistributedTestDriver.html#test(org.apache.hadoop.fs.FileSystem,%20org.apache.pirk.test.distributed.DistributedTestCLI,%20java.util.List)">test(FileSystem, DistributedTestCLI, List&lt;JSONObject&gt;)</a></span> - Static method in class org.apache.pirk.test.distributed.<a href="../org/apache/pirk/test/distributed/DistributedTestDriver.html" title="class in org.apache.pirk.test.distributed">DistributedTestDriver</a></dt>
@@ -137,6 +139,8 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/serialization/SerializationTest.html#testJsonSerDe()">testJsonSerDe()</a></span> - Method in class org.apache.pirk.serialization.<a href="../org/apache/pirk/serialization/SerializationTest.html" title="class in org.apache.pirk.serialization">SerializationTest</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/storm/KafkaStormIntegrationTest.html#testKafkaStormIntegration()">testKafkaStormIntegration()</a></span> - Method in class org.apache.pirk.storm.<a href="../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm">KafkaStormIntegrationTest</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/general/KeyedHashTest.html#testKeyedHash()">testKeyedHash()</a></span> - Method in class org.apache.pirk.general.<a href="../org/apache/pirk/general/KeyedHashTest.html" title="class in org.apache.pirk.general">KeyedHashTest</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/general/KeyedHashTest.html#testKeyedHashWithType()">testKeyedHashWithType()</a></span> - Method in class org.apache.pirk.general.<a href="../org/apache/pirk/general/KeyedHashTest.html" title="class in org.apache.pirk.general">KeyedHashTest</a></dt>
@@ -209,6 +213,8 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/serialization/SerializationService.html#toBytes(org.apache.pirk.serialization.Storable)">toBytes(Storable)</a></span> - Method in class org.apache.pirk.serialization.<a href="../org/apache/pirk/serialization/SerializationService.html" title="class in org.apache.pirk.serialization">SerializationService</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/query/wideskies/QueryInfo.html#toMap()">toMap()</a></span> - Method in class org.apache.pirk.query.wideskies.<a href="../org/apache/pirk/query/wideskies/QueryInfo.html" title="class in org.apache.pirk.query.wideskies">QueryInfo</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html#toMapWritable(org.apache.hadoop.io.Text)">toMapWritable(Text)</a></span> - Method in class org.apache.pirk.inputformat.hadoop.json.<a href="../org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html" title="class in org.apache.pirk.inputformat.hadoop.json">JSONRecordReader</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/data/partitioner/DataPartitioner.html#toPartitions(java.lang.Object,%20java.lang.String)">toPartitions(Object, String)</a></span> - Method in interface org.apache.pirk.schema.data.partitioner.<a href="../org/apache/pirk/schema/data/partitioner/DataPartitioner.html" title="interface in org.apache.pirk.schema.data.partitioner">DataPartitioner</a></dt>
diff --git a/docs/index-files/index-21.html b/docs/index-files/index-21.html
index c03eb84..c28dc3b 100644
--- a/docs/index-files/index-21.html
+++ b/docs/index-files/index-21.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>U-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -67,6 +67,8 @@
 </a>
 <h2 class="title">U</h2>
 <dl>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#USE_HDFS">USE_HDFS</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#USEHDFSLOOKUPTABLE">USEHDFSLOOKUPTABLE</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#USELOCALCACHE">USELOCALCACHE</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
diff --git a/docs/index-files/index-22.html b/docs/index-files/index-22.html
index 0501aeb..b3b887f 100644
--- a/docs/index-files/index-22.html
+++ b/docs/index-files/index-22.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>V-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
diff --git a/docs/index-files/index-23.html b/docs/index-files/index-23.html
index fd8aeea..bb2398f 100644
--- a/docs/index-files/index-23.html
+++ b/docs/index-files/index-23.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>W-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
diff --git a/docs/index-files/index-3.html b/docs/index-files/index-3.html
index 948cca2..66ed0de 100644
--- a/docs/index-files/index-3.html
+++ b/docs/index-files/index-3.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>C-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -91,6 +91,8 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html#CHAR">CHAR</a></span> - Static variable in class org.apache.pirk.schema.data.partitioner.<a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner">PrimitiveTypePartitioner</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/test/utils/BaseTests.html#checkDNSHostnameQueryResults(java.util.List,%20boolean,%20int,%20boolean,%20java.util.List)">checkDNSHostnameQueryResults(List&lt;QueryResponseJSON&gt;, boolean, int, boolean, List&lt;JSONObject&gt;)</a></span> - Static method in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/BaseTests.html" title="class in org.apache.pirk.test.utils">BaseTests</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/StopListUtils.html#checkElement(java.lang.String,%20java.util.Set)">checkElement(String, Set&lt;String&gt;)</a></span> - Static method in class org.apache.pirk.utils.<a href="../org/apache/pirk/utils/StopListUtils.html" title="class in org.apache.pirk.utils">StopListUtils</a></dt>
 <dd>
 <div class="block">Checks to see whether an element (or subdomain of the given element) is contained in the HashSet If it is not in the set, returns true (keep)</div>
@@ -137,6 +139,12 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#COLMULTREDUCEBYKEY">COLMULTREDUCEBYKEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_INDEX_ECM_FIELD">COLUMN_INDEX_ECM_FIELD</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_INDEX_ERC_FIELD">COLUMN_INDEX_ERC_FIELD</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_PRODUCT_FIELD">COLUMN_PRODUCT_FIELD</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/responder/wideskies/mapreduce/ColumnMultMapper.html" title="class in org.apache.pirk.responder.wideskies.mapreduce"><span class="strong">ColumnMultMapper</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/mapreduce/package-summary.html">org.apache.pirk.responder.wideskies.mapreduce</a></dt>
 <dd>
 <div class="block">Pass through mapper for encrypted column multiplication</div>
@@ -157,6 +165,12 @@
 <dd>
 <div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of BytesArrayWritable</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(java.util.List,%20org.apache.pirk.query.wideskies.Query,%20int,%20int)">computeEncRow(List&lt;BigInteger&gt;, Query, int, int)</a></span> - Static method in class org.apache.pirk.responder.wideskies.common.<a href="../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html" title="class in org.apache.pirk.responder.wideskies.common">ComputeEncryptedRow</a></dt>
+<dd>
+<div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of ArrayList<<BigInteger>></div>
+</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(java.math.BigInteger,%20org.apache.pirk.query.wideskies.Query,%20int,%20int)">computeEncRow(BigInteger, Query, int, int)</a></span> - Static method in class org.apache.pirk.responder.wideskies.common.<a href="../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html" title="class in org.apache.pirk.responder.wideskies.common">ComputeEncryptedRow</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRowBI(java.lang.Iterable,%20org.apache.pirk.query.wideskies.Query,%20int,%20boolean,%20int,%20boolean)">computeEncRowBI(Iterable&lt;List&lt;BigInteger&gt;&gt;, Query, int, boolean, int, boolean)</a></span> - Static method in class org.apache.pirk.responder.wideskies.common.<a href="../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html" title="class in org.apache.pirk.responder.wideskies.common">ComputeEncryptedRow</a></dt>
 <dd>
 <div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of Iterable<code>* * * * </code></div>
@@ -256,6 +270,8 @@
 <dd>
 <div class="block">Creates stoplist file</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html#createStormConf()">createStormConf()</a></span> - Static method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkTopology</a></dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/utils/CSVOutputUtils.html" title="class in org.apache.pirk.utils"><span class="strong">CSVOutputUtils</span></a> - Class in <a href="../org/apache/pirk/utils/package-summary.html">org.apache.pirk.utils</a></dt>
 <dd>
 <div class="block">Utils class for CSV value output</div>
diff --git a/docs/index-files/index-4.html b/docs/index-files/index-4.html
index 6b695c6..00a876b 100644
--- a/docs/index-files/index-4.html
+++ b/docs/index-files/index-4.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>D-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -103,6 +103,14 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/Inputs.html#DATE">DATE</a></span> - Static variable in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/Inputs.html" title="class in org.apache.pirk.test.utils">Inputs</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html#declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">declareOutputFields(OutputFieldsDeclarer)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncColMultBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html#declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">declareOutputFields(OutputFieldsDeclarer)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncRowCalcBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">declareOutputFields(OutputFieldsDeclarer)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">OutputBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html#declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">declareOutputFields(OutputFieldsDeclarer)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">PartitionDataBolt</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html#decodeLineToJson(org.apache.hadoop.io.Text)">decodeLineToJson(Text)</a></span> - Method in class org.apache.pirk.inputformat.hadoop.json.<a href="../org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html" title="class in org.apache.pirk.inputformat.hadoop.json">JSONRecordReader</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/encryption/Paillier.html#decrypt(java.math.BigInteger)">decrypt(BigInteger)</a></span> - Method in class org.apache.pirk.encryption.<a href="../org/apache/pirk/encryption/Paillier.html" title="class in org.apache.pirk.encryption">Paillier</a></dt>
@@ -121,6 +129,8 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.html#DecryptResponse(org.apache.pirk.response.wideskies.Response,%20org.apache.pirk.querier.wideskies.Querier)">DecryptResponse(Response, Querier)</a></span> - Constructor for class org.apache.pirk.querier.wideskies.decrypt.<a href="../org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.html" title="class in org.apache.pirk.querier.wideskies.decrypt">DecryptResponse</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#DEFAULT">DEFAULT</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/Inputs.html#deleteESInput()">deleteESInput()</a></span> - Static method in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/Inputs.html" title="class in org.apache.pirk.test.utils">Inputs</a></dt>
 <dd>
 <div class="block">Delete the ElasticSearch indices that was used for functional testing</div>
@@ -131,6 +141,8 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/HDFS.html#deletePath(org.apache.hadoop.fs.FileSystem,%20java.lang.String)">deletePath(FileSystem, String)</a></span> - Static method in class org.apache.pirk.utils.<a href="../org/apache/pirk/utils/HDFS.html" title="class in org.apache.pirk.utils">HDFS</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html#deserialize(java.nio.ByteBuffer)">deserialize(ByteBuffer)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkHashScheme</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/FileConst.html#DETAILS">DETAILS</a></span> - Static variable in class org.apache.pirk.utils.<a href="../org/apache/pirk/utils/FileConst.html" title="class in org.apache.pirk.utils">FileConst</a></dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/test/distributed/DistributedTestCLI.html" title="class in org.apache.pirk.test.distributed"><span class="strong">DistributedTestCLI</span></a> - Class in <a href="../org/apache/pirk/test/distributed/package-summary.html">org.apache.pirk.test.distributed</a></dt>
@@ -185,6 +197,8 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html#DOUBLE">DOUBLE</a></span> - Static variable in class org.apache.pirk.schema.data.partitioner.<a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner">PrimitiveTypePartitioner</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#DSCHEMA_KEY">DSCHEMA_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/Inputs.html#DSTIP">DSTIP</a></span> - Static variable in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/Inputs.html" title="class in org.apache.pirk.test.utils">Inputs</a></dt>
 <dd>&nbsp;</dd>
 </dl>
diff --git a/docs/index-files/index-5.html b/docs/index-files/index-5.html
index f3a1a34..4855390 100644
--- a/docs/index-files/index-5.html
+++ b/docs/index-files/index-5.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>E-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -73,6 +73,18 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/CSVOutputUtils.html#EMPTYFIELD">EMPTYFIELD</a></span> - Static variable in class org.apache.pirk.utils.<a href="../org/apache/pirk/utils/CSVOutputUtils.html" title="class in org.apache.pirk.utils">CSVOutputUtils</a></dt>
 <dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">EncColMultBolt</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></dt>
+<dd>
+<div class="block">Bolt class to perform encrypted column multiplication</div>
+</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html#EncColMultBolt()">EncColMultBolt()</a></span> - Constructor for class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncColMultBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_ID">ENCCOLMULTBOLT_ID</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_PARALLELISM_KEY">ENCCOLMULTBOLT_PARALLELISM_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_SESSION_END">ENCCOLMULTBOLT_SESSION_END</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/responder/wideskies/spark/EncColMultGroupedMapper.html" title="class in org.apache.pirk.responder.wideskies.spark"><span class="strong">EncColMultGroupedMapper</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/spark/package-summary.html">org.apache.pirk.responder.wideskies.spark</a></dt>
 <dd>
 <div class="block">Class for performing encrypted column multiplication when all columns haven been grouped by column number</div>
@@ -91,6 +103,20 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/spark/EncRowCalc.html#EncRowCalc(org.apache.pirk.responder.wideskies.spark.Accumulators,%20org.apache.pirk.responder.wideskies.spark.BroadcastVars)">EncRowCalc(Accumulators, BroadcastVars)</a></span> - Constructor for class org.apache.pirk.responder.wideskies.spark.<a href="../org/apache/pirk/responder/wideskies/spark/EncRowCalc.html" title="class in org.apache.pirk.responder.wideskies.spark">EncRowCalc</a></dt>
 <dd>&nbsp;</dd>
+<dt><a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">EncRowCalcBolt</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></dt>
+<dd>
+<div class="block">Bolt class to perform the encrypted row calculation</div>
+</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html#EncRowCalcBolt()">EncRowCalcBolt()</a></span> - Constructor for class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncRowCalcBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_DATASTREAM_ID">ENCROWCALCBOLT_DATASTREAM_ID</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_FLUSH_SIG">ENCROWCALCBOLT_FLUSH_SIG</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_ID">ENCROWCALCBOLT_ID</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_PARALLELISM_KEY">ENCROWCALCBOLT_PARALLELISM_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/responder/wideskies/spark/EncRowCalcPrecomputedCache.html" title="class in org.apache.pirk.responder.wideskies.spark"><span class="strong">EncRowCalcPrecomputedCache</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/spark/package-summary.html">org.apache.pirk.responder.wideskies.spark</a></dt>
 <dd>
 <div class="block">Functionality for computing the encrypted rows using a pre-computed, passed in modular exponentiation lookup table</div>
@@ -113,6 +139,8 @@
 <dd>
 <div class="block">Encrypts the query described by the query information using Paillier encryption using the given number of threads.</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCRYPTED_VALUE_FIELD">ENCRYPTED_VALUE_FIELD</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/querier/wideskies/encrypt/EncryptQuery.html" title="class in org.apache.pirk.querier.wideskies.encrypt"><span class="strong">EncryptQuery</span></a> - Class in <a href="../org/apache/pirk/querier/wideskies/encrypt/package-summary.html">org.apache.pirk.querier.wideskies.encrypt</a></dt>
 <dd>
 <div class="block">Class to perform PIR encryption</div>
@@ -151,6 +179,14 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/response/QueryResponseJSON.html#EVENT_TYPE">EVENT_TYPE</a></span> - Static variable in class org.apache.pirk.schema.response.<a href="../org/apache/pirk/schema/response/QueryResponseJSON.html" title="class in org.apache.pirk.schema.response">QueryResponseJSON</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html#execute(org.apache.storm.tuple.Tuple)">execute(Tuple)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncColMultBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html#execute(org.apache.storm.tuple.Tuple)">execute(Tuple)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncRowCalcBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#execute(org.apache.storm.tuple.Tuple)">execute(Tuple)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">OutputBolt</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html#execute(org.apache.storm.tuple.Tuple,%20org.apache.storm.topology.BasicOutputCollector)">execute(Tuple, BasicOutputCollector)</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">PartitionDataBolt</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/TestUtils.html#executeCommand(java.lang.ProcessBuilder)">executeCommand(ProcessBuilder)</a></span> - Static method in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/TestUtils.html" title="class in org.apache.pirk.test.utils">TestUtils</a></dt>
 <dd>
 <div class="block">Method to execute process</div>
diff --git a/docs/index-files/index-6.html b/docs/index-files/index-6.html
index a6bee0d..b3d98b2 100644
--- a/docs/index-files/index-6.html
+++ b/docs/index-files/index-6.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>F-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -113,6 +113,8 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html#FLOAT">FLOAT</a></span> - Static variable in class org.apache.pirk.schema.data.partitioner.<a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner">PrimitiveTypePartitioner</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#FLUSH">FLUSH</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/serialization/SerializationTest.html#folder">folder</a></span> - Variable in class org.apache.pirk.serialization.<a href="../org/apache/pirk/serialization/SerializationTest.html" title="class in org.apache.pirk.serialization">SerializationTest</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html#formBitMask(int)">formBitMask(int)</a></span> - Static method in class org.apache.pirk.schema.data.partitioner.<a href="../org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner">PrimitiveTypePartitioner</a></dt>
diff --git a/docs/index-files/index-7.html b/docs/index-files/index-7.html
index d1f3f26..9520d4d 100644
--- a/docs/index-files/index-7.html
+++ b/docs/index-files/index-7.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>G-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -269,6 +269,8 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/spark/BroadcastVars.html#getOutput()">getOutput()</a></span> - Method in class org.apache.pirk.responder.wideskies.spark.<a href="../org/apache/pirk/responder/wideskies/spark/BroadcastVars.html" title="class in org.apache.pirk.responder.wideskies.spark">BroadcastVars</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html#getOutputFields()">getOutputFields()</a></span> - Method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkHashScheme</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/encryption/Paillier.html#getP()">getP()</a></span> - Method in class org.apache.pirk.encryption.<a href="../org/apache/pirk/encryption/Paillier.html" title="class in org.apache.pirk.encryption">Paillier</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/data/partitioner/DataPartitioner.html#getPaddedPartitions(java.lang.String)">getPaddedPartitions(String)</a></span> - Method in interface org.apache.pirk.schema.data.partitioner.<a href="../org/apache/pirk/schema/data/partitioner/DataPartitioner.html" title="interface in org.apache.pirk.schema.data.partitioner">DataPartitioner</a></dt>
@@ -297,6 +299,10 @@
 <dd>
 <div class="block">Returns the partitioner type name for a given element name.</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html#getPirkTopology(org.apache.storm.kafka.SpoutConfig)">getPirkTopology(SpoutConfig)</a></span> - Static method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkTopology</a></dt>
+<dd>
+<div class="block">Creates Pirk topology: KafkaSpout -> PartitionDataBolt -> EncRowCalcBolt -> EncColMultBolt -> OutputBolt Requires KafkaConfig to initialize KafkaSpout.</div>
+</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/encryption/PrimeGenerator.html#getPrimePair(int,%20int,%20java.util.Random)">getPrimePair(int, int, Random)</a></span> - Static method in class org.apache.pirk.encryption.<a href="../org/apache/pirk/encryption/PrimeGenerator.html" title="class in org.apache.pirk.encryption">PrimeGenerator</a></dt>
 <dd>
 <div class="block">This method returns a two-long array containing a viable RSA p and q meeting FIPS 186-4 and SP 800-56B</div>
@@ -317,6 +323,10 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/spark/BroadcastVars.html#getQuery()">getQuery()</a></span> - Method in class org.apache.pirk.responder.wideskies.spark.<a href="../org/apache/pirk/responder/wideskies/spark/BroadcastVars.html" title="class in org.apache.pirk.responder.wideskies.spark">BroadcastVars</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html#getQuery(boolean,%20java.lang.String,%20java.lang.String)">getQuery(boolean, String, String)</a></span> - Static method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm">StormUtils</a></dt>
+<dd>
+<div class="block">Method to read in serialized Query object from the given queryFile</div>
+</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/query/wideskies/Query.html#getQueryElement(int)">getQueryElement(int)</a></span> - Method in class org.apache.pirk.query.wideskies.<a href="../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/query/wideskies/Query.html#getQueryElements()">getQueryElements()</a></span> - Method in class org.apache.pirk.query.wideskies.<a href="../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a></dt>
diff --git a/docs/index-files/index-8.html b/docs/index-files/index-8.html
index dc1cb1c..29966ff 100644
--- a/docs/index-files/index-8.html
+++ b/docs/index-files/index-8.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>H-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -85,6 +85,8 @@
 <dd>
 <div class="block">Hash method to optionally specify a hash type other than the default java hashCode() hashType must be MD5, SHA-1, or SHA-256</div>
 </dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#HASH_FIELD">HASH_FIELD</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/BaseTests.html#hashBitSize">hashBitSize</a></span> - Static variable in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/BaseTests.html" title="class in org.apache.pirk.test.utils">BaseTests</a></dt>
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/schema/response/QueryResponseJSON.html#hashCode()">hashCode()</a></span> - Method in class org.apache.pirk.schema.response.<a href="../org/apache/pirk/schema/response/QueryResponseJSON.html" title="class in org.apache.pirk.schema.response">QueryResponseJSON</a></dt>
@@ -99,8 +101,8 @@
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/responder/wideskies/common/HashSelectorAndPartitionData.html" title="class in org.apache.pirk.responder.wideskies.common"><span class="strong">HashSelectorAndPartitionData</span></a> - Class in <a href="../org/apache/pirk/responder/wideskies/common/package-summary.html">org.apache.pirk.responder.wideskies.common</a></dt>
 <dd>
-<div class="block">Given a MapWritable dataElement, this class gives the common functionality to extract the selector by queryType from each dataElement, perform a keyed hash
- of the selector, extract the partitions of the dataElement, and outputs <code>&lt;hash(selector), dataPartitions&gt;</code></div>
+<div class="block">Given a MapWritable or JSON formatted dataElement, this class gives the common functionality to extract the selector by queryType from each dataElement,
+ perform a keyed hash of the selector, extract the partitions of the dataElement, and outputs <code>&lt;hash(selector), dataPartitions&gt;</code></div>
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/common/HashSelectorAndPartitionData.html#HashSelectorAndPartitionData()">HashSelectorAndPartitionData()</a></span> - Constructor for class org.apache.pirk.responder.wideskies.common.<a href="../org/apache/pirk/responder/wideskies/common/HashSelectorAndPartitionData.html" title="class in org.apache.pirk.responder.wideskies.common">HashSelectorAndPartitionData</a></dt>
 <dd>&nbsp;</dd>
@@ -141,6 +143,8 @@
 <dd>&nbsp;</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/test/utils/Inputs.html#HDFS_QUERY_FILES">HDFS_QUERY_FILES</a></span> - Static variable in class org.apache.pirk.test.utils.<a href="../org/apache/pirk/test/utils/Inputs.html" title="class in org.apache.pirk.test.utils">Inputs</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html#HDFS_URI_KEY">HDFS_URI_KEY</a></span> - Static variable in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></dt>
+<dd>&nbsp;</dd>
 </dl>
 <a href="index-1.html">A</a>&nbsp;<a href="index-2.html">B</a>&nbsp;<a href="index-3.html">C</a>&nbsp;<a href="index-4.html">D</a>&nbsp;<a href="index-5.html">E</a>&nbsp;<a href="index-6.html">F</a>&nbsp;<a href="index-7.html">G</a>&nbsp;<a href="index-8.html">H</a>&nbsp;<a href="index-9.html">I</a>&nbsp;<a href="index-10.html">J</a>&nbsp;<a href="index-11.html">K</a>&nbsp;<a href="index-12.html">L</a>&nbsp;<a href="index-13.html">M</a>&nbsp;<a href="index-14.html">N</a>&nbsp;<a href="index-15.html">O</a>&nbsp;<a href="index-16.html">P</a>&nbsp;<a href="index-17.html">Q</a>&nbsp;<a href="index-18.html">R</a>&nbsp;<a href="index-19.html">S</a>&nbsp;<a href="index-20.html">T</a>&nbsp;<a href="index-21.html">U</a>&nbsp;<a href="index-22.html">V</a>&nbsp;<a href="index-23.html">W</a>&nbsp;</div>
 <!-- ======= START OF BOTTOM NAVBAR ====== -->
diff --git a/docs/index-files/index-9.html b/docs/index-files/index-9.html
index ac76408..5753fa8 100644
--- a/docs/index-files/index-9.html
+++ b/docs/index-files/index-9.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>I-Index</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
@@ -103,6 +103,10 @@
 </dd>
 <dt><span class="strong"><a href="../org/apache/pirk/utils/SystemConfiguration.html#initialize()">initialize()</a></span> - Static method in class org.apache.pirk.utils.<a href="../org/apache/pirk/utils/SystemConfiguration.html" title="class in org.apache.pirk.utils">SystemConfiguration</a></dt>
 <dd>&nbsp;</dd>
+<dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html#initializeSchemas(java.util.Map,%20java.lang.String)">initializeSchemas(Map, String)</a></span> - Static method in class org.apache.pirk.responder.wideskies.storm.<a href="../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm">StormUtils</a></dt>
+<dd>
+<div class="block">Initialize data and query schema.</div>
+</dd>
 <dt><span class="strong"><a href="../org/apache/pirk/responder/wideskies/ResponderProps.html#INPUTDATA">INPUTDATA</a></span> - Static variable in class org.apache.pirk.responder.wideskies.<a href="../org/apache/pirk/responder/wideskies/ResponderProps.html" title="class in org.apache.pirk.responder.wideskies">ResponderProps</a></dt>
 <dd>&nbsp;</dd>
 <dt><a href="../org/apache/pirk/inputformat/hadoop/InputFormatConst.html" title="class in org.apache.pirk.inputformat.hadoop"><span class="strong">InputFormatConst</span></a> - Class in <a href="../org/apache/pirk/inputformat/hadoop/package-summary.html">org.apache.pirk.inputformat.hadoop</a></dt>
diff --git a/docs/index.html b/docs/index.html
index 90ffb2e..ce4834d 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>Generated Documentation (Untitled)</title>
 <script type="text/javascript">
     targetPage = "" + window.location.search;
diff --git a/docs/org/apache/pirk/benchmark/BenchmarkDriver.html b/docs/org/apache/pirk/benchmark/BenchmarkDriver.html
index 22f6fd4..aea5f27 100644
--- a/docs/org/apache/pirk/benchmark/BenchmarkDriver.html
+++ b/docs/org/apache/pirk/benchmark/BenchmarkDriver.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>BenchmarkDriver</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/PaillierBenchmark.PaillierBenchmarkState.html b/docs/org/apache/pirk/benchmark/PaillierBenchmark.PaillierBenchmarkState.html
index 9ab848c..9a91a95 100644
--- a/docs/org/apache/pirk/benchmark/PaillierBenchmark.PaillierBenchmarkState.html
+++ b/docs/org/apache/pirk/benchmark/PaillierBenchmark.PaillierBenchmarkState.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>PaillierBenchmark.PaillierBenchmarkState</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/PaillierBenchmark.html b/docs/org/apache/pirk/benchmark/PaillierBenchmark.html
index 8e2a237..1534d1c 100644
--- a/docs/org/apache/pirk/benchmark/PaillierBenchmark.html
+++ b/docs/org/apache/pirk/benchmark/PaillierBenchmark.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>PaillierBenchmark</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/class-use/BenchmarkDriver.html b/docs/org/apache/pirk/benchmark/class-use/BenchmarkDriver.html
index c7cb268..dfd1f89 100644
--- a/docs/org/apache/pirk/benchmark/class-use/BenchmarkDriver.html
+++ b/docs/org/apache/pirk/benchmark/class-use/BenchmarkDriver.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.benchmark.BenchmarkDriver</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/class-use/PaillierBenchmark.PaillierBenchmarkState.html b/docs/org/apache/pirk/benchmark/class-use/PaillierBenchmark.PaillierBenchmarkState.html
index 72bd471..4cbbfb7 100644
--- a/docs/org/apache/pirk/benchmark/class-use/PaillierBenchmark.PaillierBenchmarkState.html
+++ b/docs/org/apache/pirk/benchmark/class-use/PaillierBenchmark.PaillierBenchmarkState.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.benchmark.PaillierBenchmark.PaillierBenchmarkState</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/class-use/PaillierBenchmark.html b/docs/org/apache/pirk/benchmark/class-use/PaillierBenchmark.html
index f2eede0..4e2d6c3 100644
--- a/docs/org/apache/pirk/benchmark/class-use/PaillierBenchmark.html
+++ b/docs/org/apache/pirk/benchmark/class-use/PaillierBenchmark.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.benchmark.PaillierBenchmark</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/package-frame.html b/docs/org/apache/pirk/benchmark/package-frame.html
index a1bf6f2..d5fa4d9 100644
--- a/docs/org/apache/pirk/benchmark/package-frame.html
+++ b/docs/org/apache/pirk/benchmark/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.benchmark</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/package-summary.html b/docs/org/apache/pirk/benchmark/package-summary.html
index cf3dd66..7dd180a 100644
--- a/docs/org/apache/pirk/benchmark/package-summary.html
+++ b/docs/org/apache/pirk/benchmark/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.benchmark</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/package-tree.html b/docs/org/apache/pirk/benchmark/package-tree.html
index 0adff99..feb29f9 100644
--- a/docs/org/apache/pirk/benchmark/package-tree.html
+++ b/docs/org/apache/pirk/benchmark/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.benchmark Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/benchmark/package-use.html b/docs/org/apache/pirk/benchmark/package-use.html
index 64f4c3e..d189634 100644
--- a/docs/org/apache/pirk/benchmark/package-use.html
+++ b/docs/org/apache/pirk/benchmark/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.benchmark</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/ModPowAbstraction.html b/docs/org/apache/pirk/encryption/ModPowAbstraction.html
index 86d14b2..fe3681f 100644
--- a/docs/org/apache/pirk/encryption/ModPowAbstraction.html
+++ b/docs/org/apache/pirk/encryption/ModPowAbstraction.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>ModPowAbstraction</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/Paillier.html b/docs/org/apache/pirk/encryption/Paillier.html
index f15a1af..b54885f 100644
--- a/docs/org/apache/pirk/encryption/Paillier.html
+++ b/docs/org/apache/pirk/encryption/Paillier.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>Paillier</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/PrimeGenerator.html b/docs/org/apache/pirk/encryption/PrimeGenerator.html
index b0f2d69..024f91a 100644
--- a/docs/org/apache/pirk/encryption/PrimeGenerator.html
+++ b/docs/org/apache/pirk/encryption/PrimeGenerator.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>PrimeGenerator</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/class-use/ModPowAbstraction.html b/docs/org/apache/pirk/encryption/class-use/ModPowAbstraction.html
index 6c4573c..f92b57f 100644
--- a/docs/org/apache/pirk/encryption/class-use/ModPowAbstraction.html
+++ b/docs/org/apache/pirk/encryption/class-use/ModPowAbstraction.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.encryption.ModPowAbstraction</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/class-use/Paillier.html b/docs/org/apache/pirk/encryption/class-use/Paillier.html
index 6812d88..85a260d 100644
--- a/docs/org/apache/pirk/encryption/class-use/Paillier.html
+++ b/docs/org/apache/pirk/encryption/class-use/Paillier.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.encryption.Paillier</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/class-use/PrimeGenerator.html b/docs/org/apache/pirk/encryption/class-use/PrimeGenerator.html
index 332cc9c..16c4845 100644
--- a/docs/org/apache/pirk/encryption/class-use/PrimeGenerator.html
+++ b/docs/org/apache/pirk/encryption/class-use/PrimeGenerator.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.encryption.PrimeGenerator</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/package-frame.html b/docs/org/apache/pirk/encryption/package-frame.html
index 73fb29d..98fbb84 100644
--- a/docs/org/apache/pirk/encryption/package-frame.html
+++ b/docs/org/apache/pirk/encryption/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.encryption</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/package-summary.html b/docs/org/apache/pirk/encryption/package-summary.html
index b43f113..a5b57a3 100644
--- a/docs/org/apache/pirk/encryption/package-summary.html
+++ b/docs/org/apache/pirk/encryption/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.encryption</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/package-tree.html b/docs/org/apache/pirk/encryption/package-tree.html
index dd7b27b..f3bcec3 100644
--- a/docs/org/apache/pirk/encryption/package-tree.html
+++ b/docs/org/apache/pirk/encryption/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.encryption Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/encryption/package-use.html b/docs/org/apache/pirk/encryption/package-use.html
index 514f5b4..b453ea0 100644
--- a/docs/org/apache/pirk/encryption/package-use.html
+++ b/docs/org/apache/pirk/encryption/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.encryption</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/ISO8601DateParserTest.html b/docs/org/apache/pirk/general/ISO8601DateParserTest.html
index 3ddffbd..e2a344b 100644
--- a/docs/org/apache/pirk/general/ISO8601DateParserTest.html
+++ b/docs/org/apache/pirk/general/ISO8601DateParserTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>ISO8601DateParserTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/KeyedHashTest.html b/docs/org/apache/pirk/general/KeyedHashTest.html
index aa5f2cd..71bfc92 100644
--- a/docs/org/apache/pirk/general/KeyedHashTest.html
+++ b/docs/org/apache/pirk/general/KeyedHashTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>KeyedHashTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/PaillierTest.html b/docs/org/apache/pirk/general/PaillierTest.html
index e543f3c..64804d3 100644
--- a/docs/org/apache/pirk/general/PaillierTest.html
+++ b/docs/org/apache/pirk/general/PaillierTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>PaillierTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/PartitionUtilsTest.html b/docs/org/apache/pirk/general/PartitionUtilsTest.html
index 82e0167..776ce24 100644
--- a/docs/org/apache/pirk/general/PartitionUtilsTest.html
+++ b/docs/org/apache/pirk/general/PartitionUtilsTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>PartitionUtilsTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/QueryParserUtilsTest.html b/docs/org/apache/pirk/general/QueryParserUtilsTest.html
index 69166f2..1644b8f 100644
--- a/docs/org/apache/pirk/general/QueryParserUtilsTest.html
+++ b/docs/org/apache/pirk/general/QueryParserUtilsTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QueryParserUtilsTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/class-use/ISO8601DateParserTest.html b/docs/org/apache/pirk/general/class-use/ISO8601DateParserTest.html
index 51e04ad..961f8b4 100644
--- a/docs/org/apache/pirk/general/class-use/ISO8601DateParserTest.html
+++ b/docs/org/apache/pirk/general/class-use/ISO8601DateParserTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.general.ISO8601DateParserTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/class-use/KeyedHashTest.html b/docs/org/apache/pirk/general/class-use/KeyedHashTest.html
index 33e4eaa..4bb3290 100644
--- a/docs/org/apache/pirk/general/class-use/KeyedHashTest.html
+++ b/docs/org/apache/pirk/general/class-use/KeyedHashTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.general.KeyedHashTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/class-use/PaillierTest.html b/docs/org/apache/pirk/general/class-use/PaillierTest.html
index 1d1b384..c42c11b 100644
--- a/docs/org/apache/pirk/general/class-use/PaillierTest.html
+++ b/docs/org/apache/pirk/general/class-use/PaillierTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.general.PaillierTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/class-use/PartitionUtilsTest.html b/docs/org/apache/pirk/general/class-use/PartitionUtilsTest.html
index 314875e..c10183c 100644
--- a/docs/org/apache/pirk/general/class-use/PartitionUtilsTest.html
+++ b/docs/org/apache/pirk/general/class-use/PartitionUtilsTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.general.PartitionUtilsTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/class-use/QueryParserUtilsTest.html b/docs/org/apache/pirk/general/class-use/QueryParserUtilsTest.html
index 2f893bf..01f9335 100644
--- a/docs/org/apache/pirk/general/class-use/QueryParserUtilsTest.html
+++ b/docs/org/apache/pirk/general/class-use/QueryParserUtilsTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.general.QueryParserUtilsTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/package-frame.html b/docs/org/apache/pirk/general/package-frame.html
index 67e4ff0..6da13f2 100644
--- a/docs/org/apache/pirk/general/package-frame.html
+++ b/docs/org/apache/pirk/general/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.general</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/package-summary.html b/docs/org/apache/pirk/general/package-summary.html
index ae57291..bfcd19b 100644
--- a/docs/org/apache/pirk/general/package-summary.html
+++ b/docs/org/apache/pirk/general/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.general</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/package-tree.html b/docs/org/apache/pirk/general/package-tree.html
index 3780ff2..4a9de40 100644
--- a/docs/org/apache/pirk/general/package-tree.html
+++ b/docs/org/apache/pirk/general/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.general Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/general/package-use.html b/docs/org/apache/pirk/general/package-use.html
index 0040d15..08943c8 100644
--- a/docs/org/apache/pirk/general/package-use.html
+++ b/docs/org/apache/pirk/general/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.general</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/BaseInputFormat.html b/docs/org/apache/pirk/inputformat/hadoop/BaseInputFormat.html
index 4bb9d5b..b0ad907 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/BaseInputFormat.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/BaseInputFormat.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:43 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>BaseInputFormat</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html b/docs/org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html
index 2f94546..9109b36 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:43 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>BytesArrayWritable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/InputFormatConst.html b/docs/org/apache/pirk/inputformat/hadoop/InputFormatConst.html
index bee6368..f12c589 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/InputFormatConst.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/InputFormatConst.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:43 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>InputFormatConst</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/TextArrayWritable.html b/docs/org/apache/pirk/inputformat/hadoop/TextArrayWritable.html
index 79e6f2c..e7ad179 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/TextArrayWritable.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/TextArrayWritable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:43 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>TextArrayWritable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/class-use/BaseInputFormat.html b/docs/org/apache/pirk/inputformat/hadoop/class-use/BaseInputFormat.html
index 646c951..21b9b9b 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/class-use/BaseInputFormat.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/class-use/BaseInputFormat.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.inputformat.hadoop.BaseInputFormat</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/class-use/BytesArrayWritable.html b/docs/org/apache/pirk/inputformat/hadoop/class-use/BytesArrayWritable.html
index e3b26b2..4f5b375 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/class-use/BytesArrayWritable.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/class-use/BytesArrayWritable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.inputformat.hadoop.BytesArrayWritable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/class-use/InputFormatConst.html b/docs/org/apache/pirk/inputformat/hadoop/class-use/InputFormatConst.html
index e830a0f..52eaa6a 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/class-use/InputFormatConst.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/class-use/InputFormatConst.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.inputformat.hadoop.InputFormatConst</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/class-use/TextArrayWritable.html b/docs/org/apache/pirk/inputformat/hadoop/class-use/TextArrayWritable.html
index 54f207a..1f0eddf 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/class-use/TextArrayWritable.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/class-use/TextArrayWritable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.inputformat.hadoop.TextArrayWritable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/JSONInputFormat.html b/docs/org/apache/pirk/inputformat/hadoop/json/JSONInputFormat.html
index 51cbe9e..ad68195 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/JSONInputFormat.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/JSONInputFormat.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>JSONInputFormat</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/JSONInputFormatBase.html b/docs/org/apache/pirk/inputformat/hadoop/json/JSONInputFormatBase.html
index bd418e3..a34e1c6 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/JSONInputFormatBase.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/JSONInputFormatBase.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>JSONInputFormatBase</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html b/docs/org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html
index f6131a8..ac34053 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/JSONRecordReader.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>JSONRecordReader</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONInputFormat.html b/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONInputFormat.html
index 4c44f45..f4a2a8c 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONInputFormat.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONInputFormat.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.inputformat.hadoop.json.JSONInputFormat</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONInputFormatBase.html b/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONInputFormatBase.html
index dc6a196..c5598ff 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONInputFormatBase.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONInputFormatBase.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.inputformat.hadoop.json.JSONInputFormatBase</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONRecordReader.html b/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONRecordReader.html
index d1e6c4d..1ae52df 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONRecordReader.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/class-use/JSONRecordReader.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.inputformat.hadoop.json.JSONRecordReader</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/package-frame.html b/docs/org/apache/pirk/inputformat/hadoop/json/package-frame.html
index 5659ca8..eaae037 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/package-frame.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.inputformat.hadoop.json</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/package-summary.html b/docs/org/apache/pirk/inputformat/hadoop/json/package-summary.html
index 0c19dc4..318bb31 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/package-summary.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.inputformat.hadoop.json</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/package-tree.html b/docs/org/apache/pirk/inputformat/hadoop/json/package-tree.html
index 5a88784..3880826 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/package-tree.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.inputformat.hadoop.json Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/json/package-use.html b/docs/org/apache/pirk/inputformat/hadoop/json/package-use.html
index d74f51d..a34f480 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/json/package-use.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/json/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.inputformat.hadoop.json</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/package-frame.html b/docs/org/apache/pirk/inputformat/hadoop/package-frame.html
index 29d1689..ea40985 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/package-frame.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.inputformat.hadoop</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/package-summary.html b/docs/org/apache/pirk/inputformat/hadoop/package-summary.html
index 1f195cf..f584e9a 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/package-summary.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.inputformat.hadoop</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/package-tree.html b/docs/org/apache/pirk/inputformat/hadoop/package-tree.html
index c1fec58..6299b6a 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/package-tree.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.inputformat.hadoop Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/inputformat/hadoop/package-use.html b/docs/org/apache/pirk/inputformat/hadoop/package-use.html
index dfb858f..2b150ea 100644
--- a/docs/org/apache/pirk/inputformat/hadoop/package-use.html
+++ b/docs/org/apache/pirk/inputformat/hadoop/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.inputformat.hadoop</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/Querier.html b/docs/org/apache/pirk/querier/wideskies/Querier.html
index 32fbafa..19ff3d9 100644
--- a/docs/org/apache/pirk/querier/wideskies/Querier.html
+++ b/docs/org/apache/pirk/querier/wideskies/Querier.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>Querier</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/QuerierCLI.html b/docs/org/apache/pirk/querier/wideskies/QuerierCLI.html
index 1ea10e6..59611d7 100644
--- a/docs/org/apache/pirk/querier/wideskies/QuerierCLI.html
+++ b/docs/org/apache/pirk/querier/wideskies/QuerierCLI.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QuerierCLI</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/QuerierConst.html b/docs/org/apache/pirk/querier/wideskies/QuerierConst.html
index 635e23d..db62c0d 100644
--- a/docs/org/apache/pirk/querier/wideskies/QuerierConst.html
+++ b/docs/org/apache/pirk/querier/wideskies/QuerierConst.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QuerierConst</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/QuerierDriver.html b/docs/org/apache/pirk/querier/wideskies/QuerierDriver.html
index 7cc37e2..e4ae4d1 100644
--- a/docs/org/apache/pirk/querier/wideskies/QuerierDriver.html
+++ b/docs/org/apache/pirk/querier/wideskies/QuerierDriver.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QuerierDriver</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/QuerierProps.html b/docs/org/apache/pirk/querier/wideskies/QuerierProps.html
index fc9c6bc..546d4d4 100644
--- a/docs/org/apache/pirk/querier/wideskies/QuerierProps.html
+++ b/docs/org/apache/pirk/querier/wideskies/QuerierProps.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QuerierProps</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/class-use/Querier.html b/docs/org/apache/pirk/querier/wideskies/class-use/Querier.html
index 2a3d21d..073d1b9 100644
--- a/docs/org/apache/pirk/querier/wideskies/class-use/Querier.html
+++ b/docs/org/apache/pirk/querier/wideskies/class-use/Querier.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.querier.wideskies.Querier</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/class-use/QuerierCLI.html b/docs/org/apache/pirk/querier/wideskies/class-use/QuerierCLI.html
index 357d944..f1348b7 100644
--- a/docs/org/apache/pirk/querier/wideskies/class-use/QuerierCLI.html
+++ b/docs/org/apache/pirk/querier/wideskies/class-use/QuerierCLI.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.querier.wideskies.QuerierCLI</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/class-use/QuerierConst.html b/docs/org/apache/pirk/querier/wideskies/class-use/QuerierConst.html
index e76b8d2..88d3784 100644
--- a/docs/org/apache/pirk/querier/wideskies/class-use/QuerierConst.html
+++ b/docs/org/apache/pirk/querier/wideskies/class-use/QuerierConst.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.querier.wideskies.QuerierConst</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/class-use/QuerierDriver.html b/docs/org/apache/pirk/querier/wideskies/class-use/QuerierDriver.html
index 055d6a9..e1b2596 100644
--- a/docs/org/apache/pirk/querier/wideskies/class-use/QuerierDriver.html
+++ b/docs/org/apache/pirk/querier/wideskies/class-use/QuerierDriver.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.querier.wideskies.QuerierDriver</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/class-use/QuerierProps.html b/docs/org/apache/pirk/querier/wideskies/class-use/QuerierProps.html
index 1614c0b..a2bcced 100644
--- a/docs/org/apache/pirk/querier/wideskies/class-use/QuerierProps.html
+++ b/docs/org/apache/pirk/querier/wideskies/class-use/QuerierProps.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.querier.wideskies.QuerierProps</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.html b/docs/org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.html
index de4ca4f..bf72779 100644
--- a/docs/org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.html
+++ b/docs/org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>DecryptResponse</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/decrypt/class-use/DecryptResponse.html b/docs/org/apache/pirk/querier/wideskies/decrypt/class-use/DecryptResponse.html
index 9b287a5..b0773ac 100644
--- a/docs/org/apache/pirk/querier/wideskies/decrypt/class-use/DecryptResponse.html
+++ b/docs/org/apache/pirk/querier/wideskies/decrypt/class-use/DecryptResponse.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.querier.wideskies.decrypt.DecryptResponse</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/decrypt/package-frame.html b/docs/org/apache/pirk/querier/wideskies/decrypt/package-frame.html
index 8095c06..e2a6380 100644
--- a/docs/org/apache/pirk/querier/wideskies/decrypt/package-frame.html
+++ b/docs/org/apache/pirk/querier/wideskies/decrypt/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies.decrypt</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/decrypt/package-summary.html b/docs/org/apache/pirk/querier/wideskies/decrypt/package-summary.html
index 53a130a..94d35bb 100644
--- a/docs/org/apache/pirk/querier/wideskies/decrypt/package-summary.html
+++ b/docs/org/apache/pirk/querier/wideskies/decrypt/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies.decrypt</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/decrypt/package-tree.html b/docs/org/apache/pirk/querier/wideskies/decrypt/package-tree.html
index 2b17ad6..c3cdc1a 100644
--- a/docs/org/apache/pirk/querier/wideskies/decrypt/package-tree.html
+++ b/docs/org/apache/pirk/querier/wideskies/decrypt/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies.decrypt Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/decrypt/package-use.html b/docs/org/apache/pirk/querier/wideskies/decrypt/package-use.html
index f894736..92bbd26 100644
--- a/docs/org/apache/pirk/querier/wideskies/decrypt/package-use.html
+++ b/docs/org/apache/pirk/querier/wideskies/decrypt/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.querier.wideskies.decrypt</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/encrypt/EncryptQuery.html b/docs/org/apache/pirk/querier/wideskies/encrypt/EncryptQuery.html
index 6749e07..1b6a24e 100644
--- a/docs/org/apache/pirk/querier/wideskies/encrypt/EncryptQuery.html
+++ b/docs/org/apache/pirk/querier/wideskies/encrypt/EncryptQuery.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>EncryptQuery</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/encrypt/class-use/EncryptQuery.html b/docs/org/apache/pirk/querier/wideskies/encrypt/class-use/EncryptQuery.html
index a02ad3f..8d8e8d3 100644
--- a/docs/org/apache/pirk/querier/wideskies/encrypt/class-use/EncryptQuery.html
+++ b/docs/org/apache/pirk/querier/wideskies/encrypt/class-use/EncryptQuery.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.querier.wideskies.encrypt.EncryptQuery</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/encrypt/package-frame.html b/docs/org/apache/pirk/querier/wideskies/encrypt/package-frame.html
index 2c3c661..30d1219 100644
--- a/docs/org/apache/pirk/querier/wideskies/encrypt/package-frame.html
+++ b/docs/org/apache/pirk/querier/wideskies/encrypt/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies.encrypt</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/encrypt/package-summary.html b/docs/org/apache/pirk/querier/wideskies/encrypt/package-summary.html
index b878d6e..d7a218d 100644
--- a/docs/org/apache/pirk/querier/wideskies/encrypt/package-summary.html
+++ b/docs/org/apache/pirk/querier/wideskies/encrypt/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies.encrypt</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/encrypt/package-tree.html b/docs/org/apache/pirk/querier/wideskies/encrypt/package-tree.html
index 8169665..e646b9f 100644
--- a/docs/org/apache/pirk/querier/wideskies/encrypt/package-tree.html
+++ b/docs/org/apache/pirk/querier/wideskies/encrypt/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies.encrypt Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/encrypt/package-use.html b/docs/org/apache/pirk/querier/wideskies/encrypt/package-use.html
index bc6f112..3f2846b 100644
--- a/docs/org/apache/pirk/querier/wideskies/encrypt/package-use.html
+++ b/docs/org/apache/pirk/querier/wideskies/encrypt/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.querier.wideskies.encrypt</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/package-frame.html b/docs/org/apache/pirk/querier/wideskies/package-frame.html
index 2958233..3c2bd73 100644
--- a/docs/org/apache/pirk/querier/wideskies/package-frame.html
+++ b/docs/org/apache/pirk/querier/wideskies/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/package-summary.html b/docs/org/apache/pirk/querier/wideskies/package-summary.html
index ee1feca..ed58f0e 100644
--- a/docs/org/apache/pirk/querier/wideskies/package-summary.html
+++ b/docs/org/apache/pirk/querier/wideskies/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/package-tree.html b/docs/org/apache/pirk/querier/wideskies/package-tree.html
index 53bfb97..f2129b9 100644
--- a/docs/org/apache/pirk/querier/wideskies/package-tree.html
+++ b/docs/org/apache/pirk/querier/wideskies/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.querier.wideskies Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/querier/wideskies/package-use.html b/docs/org/apache/pirk/querier/wideskies/package-use.html
index 3e51ecb..26c842a 100644
--- a/docs/org/apache/pirk/querier/wideskies/package-use.html
+++ b/docs/org/apache/pirk/querier/wideskies/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.querier.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/query/wideskies/Query.html b/docs/org/apache/pirk/query/wideskies/Query.html
index 04a5766..00e58e8 100644
--- a/docs/org/apache/pirk/query/wideskies/Query.html
+++ b/docs/org/apache/pirk/query/wideskies/Query.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>Query</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/query/wideskies/QueryInfo.html b/docs/org/apache/pirk/query/wideskies/QueryInfo.html
index f97d030..a4e69af 100644
--- a/docs/org/apache/pirk/query/wideskies/QueryInfo.html
+++ b/docs/org/apache/pirk/query/wideskies/QueryInfo.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QueryInfo</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
@@ -136,6 +136,9 @@
          boolean&nbsp;useHDFSExpLookupTableInput)</code>&nbsp;</td>
 </tr>
 <tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../../../org/apache/pirk/query/wideskies/QueryInfo.html#QueryInfo(java.util.Map)">QueryInfo</a></strong>(java.util.Map&nbsp;queryInfoMap)</code>&nbsp;</td>
+</tr>
+<tr class="altColor">
 <td class="colOne"><code><strong><a href="../../../../../org/apache/pirk/query/wideskies/QueryInfo.html#QueryInfo(java.util.UUID,%20int,%20int,%20java.lang.String,%20int,%20java.lang.String,%20boolean,%20boolean,%20boolean)">QueryInfo</a></strong>(java.util.UUID&nbsp;identifierInput,
          int&nbsp;numSelectorsInput,
          int&nbsp;hashBitSizeInput,
@@ -221,6 +224,10 @@
 <td class="colFirst"><code>void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/query/wideskies/QueryInfo.html#printQueryInfo()">printQueryInfo</a></strong>()</code>&nbsp;</td>
 </tr>
+<tr class="rowColor">
+<td class="colFirst"><code>java.util.Map</code></td>
+<td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/query/wideskies/QueryInfo.html#toMap()">toMap</a></strong>()</code>&nbsp;</td>
+</tr>
 </table>
 <ul class="blockList">
 <li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
@@ -262,7 +269,7 @@
 <a name="QueryInfo(java.util.UUID, int, int, java.lang.String, int, java.lang.String, boolean, boolean, boolean)">
 <!--   -->
 </a>
-<ul class="blockListLast">
+<ul class="blockList">
 <li class="blockList">
 <h4>QueryInfo</h4>
 <pre>public&nbsp;QueryInfo(java.util.UUID&nbsp;identifierInput,
@@ -276,6 +283,15 @@
          boolean&nbsp;useHDFSExpLookupTableInput)</pre>
 </li>
 </ul>
+<a name="QueryInfo(java.util.Map)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>QueryInfo</h4>
+<pre>public&nbsp;QueryInfo(java.util.Map&nbsp;queryInfoMap)</pre>
+</li>
+</ul>
 </li>
 </ul>
 <!-- ============ METHOD DETAIL ========== -->
@@ -383,6 +399,15 @@
 <pre>public&nbsp;boolean&nbsp;getEmbedSelector()</pre>
 </li>
 </ul>
+<a name="toMap()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>toMap</h4>
+<pre>public&nbsp;java.util.Map&nbsp;toMap()</pre>
+</li>
+</ul>
 <a name="addQuerySchema(org.apache.pirk.schema.query.QuerySchema)">
 <!--   -->
 </a>
diff --git a/docs/org/apache/pirk/query/wideskies/QueryUtils.html b/docs/org/apache/pirk/query/wideskies/QueryUtils.html
index 73ceb8d..3ba9e6a 100644
--- a/docs/org/apache/pirk/query/wideskies/QueryUtils.html
+++ b/docs/org/apache/pirk/query/wideskies/QueryUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QueryUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/query/wideskies/class-use/Query.html b/docs/org/apache/pirk/query/wideskies/class-use/Query.html
index 7d220fd..d44e32a 100644
--- a/docs/org/apache/pirk/query/wideskies/class-use/Query.html
+++ b/docs/org/apache/pirk/query/wideskies/class-use/Query.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.query.wideskies.Query</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
@@ -91,6 +91,10 @@
 <td class="colFirst"><a href="#org.apache.pirk.responder.wideskies.standalone">org.apache.pirk.responder.wideskies.standalone</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
+<tr class="altColor">
+<td class="colFirst"><a href="#org.apache.pirk.responder.wideskies.storm">org.apache.pirk.responder.wideskies.storm</a></td>
+<td class="colLast">&nbsp;</td>
+</tr>
 </tbody>
 </table>
 </li>
@@ -141,6 +145,13 @@
 <tbody>
 <tr class="altColor">
 <td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
+<td class="colLast"><span class="strong">ComputeEncryptedRow.</span><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(java.math.BigInteger,%20org.apache.pirk.query.wideskies.Query,%20int,%20int)">computeEncRow</a></strong>(java.math.BigInteger&nbsp;part,
+             <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
+             int&nbsp;rowIndex,
+             int&nbsp;colIndex)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
 <td class="colLast"><span class="strong">ComputeEncryptedRow.</span><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(org.apache.pirk.inputformat.hadoop.BytesArrayWritable,%20org.apache.pirk.query.wideskies.Query,%20int,%20int)">computeEncRow</a></strong>(<a href="../../../../../../org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html" title="class in org.apache.pirk.inputformat.hadoop">BytesArrayWritable</a>&nbsp;dataPartitions,
              <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
              int&nbsp;rowIndex,
@@ -148,7 +159,7 @@
 <div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of BytesArrayWritable</div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
 <td class="colLast"><span class="strong">ComputeEncryptedRow.</span><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(java.lang.Iterable,%20org.apache.pirk.query.wideskies.Query,%20int,%20boolean,%20int,%20boolean)">computeEncRow</a></strong>(java.lang.Iterable&lt;<a href="../../../../../../org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html" title="class in org.apache.pirk.inputformat.hadoop">BytesArrayWritable</a>&gt;&nbsp;dataPartitionsIter,
              <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
@@ -159,6 +170,15 @@
 <div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of Iterable<BytesArrayWritable></div>
 </td>
 </tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
+<td class="colLast"><span class="strong">ComputeEncryptedRow.</span><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(java.util.List,%20org.apache.pirk.query.wideskies.Query,%20int,%20int)">computeEncRow</a></strong>(java.util.List&lt;java.math.BigInteger&gt;&nbsp;dataPartitions,
+             <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
+             int&nbsp;rowIndex,
+             int&nbsp;colIndex)</code>
+<div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of ArrayList<<BigInteger>></div>
+</td>
+</tr>
 <tr class="altColor">
 <td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
 <td class="colLast"><span class="strong">ComputeEncryptedRow.</span><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRowBI(java.lang.Iterable,%20org.apache.pirk.query.wideskies.Query,%20int,%20boolean,%20int,%20boolean)">computeEncRowBI</a></strong>(java.lang.Iterable&lt;java.util.List&lt;java.math.BigInteger&gt;&gt;&nbsp;dataPartitionsIter,
@@ -251,6 +271,34 @@
 </tbody>
 </table>
 </li>
+<li class="blockList"><a name="org.apache.pirk.responder.wideskies.storm">
+<!--   -->
+</a>
+<h3>Uses of <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a> in <a href="../../../../../../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></h3>
+<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
+<caption><span>Methods in <a href="../../../../../../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a> that return <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a></span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><code>static <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a></code></td>
+<td class="colLast"><span class="strong">StormUtils.</span><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html#getQuery(boolean,%20java.lang.String,%20java.lang.String)">getQuery</a></strong>(boolean&nbsp;useHdfs,
+        java.lang.String&nbsp;hdfsUri,
+        java.lang.String&nbsp;queryFile)</code>
+<div class="block">Method to read in serialized Query object from the given queryFile</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a></code></td>
+<td class="colLast"><span class="strong">StormUtils.</span><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html#prepareQuery(java.util.Map)">prepareQuery</a></strong>(java.util.Map&nbsp;map)</code>
+<div class="block">Method to read in and return a serialized Query object from the given file and initialize/load the query.schemas and data.schemas</div>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
 </ul>
 </li>
 </ul>
diff --git a/docs/org/apache/pirk/query/wideskies/class-use/QueryInfo.html b/docs/org/apache/pirk/query/wideskies/class-use/QueryInfo.html
index bd9feac..b1dee2a 100644
--- a/docs/org/apache/pirk/query/wideskies/class-use/QueryInfo.html
+++ b/docs/org/apache/pirk/query/wideskies/class-use/QueryInfo.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.query.wideskies.QueryInfo</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/query/wideskies/class-use/QueryUtils.html b/docs/org/apache/pirk/query/wideskies/class-use/QueryUtils.html
index c618f69..55f9bcd 100644
--- a/docs/org/apache/pirk/query/wideskies/class-use/QueryUtils.html
+++ b/docs/org/apache/pirk/query/wideskies/class-use/QueryUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.query.wideskies.QueryUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/query/wideskies/package-frame.html b/docs/org/apache/pirk/query/wideskies/package-frame.html
index 7d7df0a..7bbae76 100644
--- a/docs/org/apache/pirk/query/wideskies/package-frame.html
+++ b/docs/org/apache/pirk/query/wideskies/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.query.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/query/wideskies/package-summary.html b/docs/org/apache/pirk/query/wideskies/package-summary.html
index cf59a54..99eafce 100644
--- a/docs/org/apache/pirk/query/wideskies/package-summary.html
+++ b/docs/org/apache/pirk/query/wideskies/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.query.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/query/wideskies/package-tree.html b/docs/org/apache/pirk/query/wideskies/package-tree.html
index bd700c6..4969add 100644
--- a/docs/org/apache/pirk/query/wideskies/package-tree.html
+++ b/docs/org/apache/pirk/query/wideskies/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.query.wideskies Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/query/wideskies/package-use.html b/docs/org/apache/pirk/query/wideskies/package-use.html
index fd67f6c..cf5700c 100644
--- a/docs/org/apache/pirk/query/wideskies/package-use.html
+++ b/docs/org/apache/pirk/query/wideskies/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.query.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
@@ -100,10 +100,14 @@
 <td class="colLast">&nbsp;</td>
 </tr>
 <tr class="altColor">
-<td class="colFirst"><a href="#org.apache.pirk.response.wideskies">org.apache.pirk.response.wideskies</a></td>
+<td class="colFirst"><a href="#org.apache.pirk.responder.wideskies.storm">org.apache.pirk.responder.wideskies.storm</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
 <tr class="rowColor">
+<td class="colFirst"><a href="#org.apache.pirk.response.wideskies">org.apache.pirk.response.wideskies</a></td>
+<td class="colLast">&nbsp;</td>
+</tr>
+<tr class="altColor">
 <td class="colFirst"><a href="#org.apache.pirk.schema.response">org.apache.pirk.schema.response</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
@@ -222,6 +226,23 @@
 </tbody>
 </table>
 </li>
+<li class="blockList"><a name="org.apache.pirk.responder.wideskies.storm">
+<!--   -->
+</a>
+<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing classes, and an explanation">
+<caption><span>Classes in <a href="../../../../../org/apache/pirk/query/wideskies/package-summary.html">org.apache.pirk.query.wideskies</a> used by <a href="../../../../../org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Class and Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colOne"><a href="../../../../../org/apache/pirk/query/wideskies/class-use/Query.html#org.apache.pirk.responder.wideskies.storm">Query</a>
+<div class="block">Class to hold the PIR query vectors</div>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
 <li class="blockList"><a name="org.apache.pirk.response.wideskies">
 <!--   -->
 </a>
diff --git a/docs/org/apache/pirk/responder/wideskies/ResponderCLI.html b/docs/org/apache/pirk/responder/wideskies/ResponderCLI.html
index beeb63f..dec601f 100644
--- a/docs/org/apache/pirk/responder/wideskies/ResponderCLI.html
+++ b/docs/org/apache/pirk/responder/wideskies/ResponderCLI.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>ResponderCLI</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/ResponderDriver.html b/docs/org/apache/pirk/responder/wideskies/ResponderDriver.html
index 8dbcf40..adee7b4 100644
--- a/docs/org/apache/pirk/responder/wideskies/ResponderDriver.html
+++ b/docs/org/apache/pirk/responder/wideskies/ResponderDriver.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>ResponderDriver</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/ResponderProps.html b/docs/org/apache/pirk/responder/wideskies/ResponderProps.html
index 3e179fb..3d9bf39 100644
--- a/docs/org/apache/pirk/responder/wideskies/ResponderProps.html
+++ b/docs/org/apache/pirk/responder/wideskies/ResponderProps.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>ResponderProps</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/class-use/ResponderCLI.html b/docs/org/apache/pirk/responder/wideskies/class-use/ResponderCLI.html
index df0389c..17be450 100644
--- a/docs/org/apache/pirk/responder/wideskies/class-use/ResponderCLI.html
+++ b/docs/org/apache/pirk/responder/wideskies/class-use/ResponderCLI.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.ResponderCLI</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/class-use/ResponderDriver.html b/docs/org/apache/pirk/responder/wideskies/class-use/ResponderDriver.html
index a63fd05..047a9a8 100644
--- a/docs/org/apache/pirk/responder/wideskies/class-use/ResponderDriver.html
+++ b/docs/org/apache/pirk/responder/wideskies/class-use/ResponderDriver.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.ResponderDriver</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/class-use/ResponderProps.html b/docs/org/apache/pirk/responder/wideskies/class-use/ResponderProps.html
index 90ce1dd..157b6d0 100644
--- a/docs/org/apache/pirk/responder/wideskies/class-use/ResponderProps.html
+++ b/docs/org/apache/pirk/responder/wideskies/class-use/ResponderProps.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.ResponderProps</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html b/docs/org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html
index 607aac1..7045122 100644
--- a/docs/org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html
+++ b/docs/org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>ComputeEncryptedRow</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
@@ -136,6 +136,13 @@
 </tr>
 <tr class="altColor">
 <td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(java.math.BigInteger,%20org.apache.pirk.query.wideskies.Query,%20int,%20int)">computeEncRow</a></strong>(java.math.BigInteger&nbsp;part,
+             <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
+             int&nbsp;rowIndex,
+             int&nbsp;colIndex)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
 <td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(org.apache.pirk.inputformat.hadoop.BytesArrayWritable,%20org.apache.pirk.query.wideskies.Query,%20int,%20int)">computeEncRow</a></strong>(<a href="../../../../../../org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html" title="class in org.apache.pirk.inputformat.hadoop">BytesArrayWritable</a>&nbsp;dataPartitions,
              <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
              int&nbsp;rowIndex,
@@ -143,7 +150,7 @@
 <div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of BytesArrayWritable</div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
 <td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(java.lang.Iterable,%20org.apache.pirk.query.wideskies.Query,%20int,%20boolean,%20int,%20boolean)">computeEncRow</a></strong>(java.lang.Iterable&lt;<a href="../../../../../../org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html" title="class in org.apache.pirk.inputformat.hadoop">BytesArrayWritable</a>&gt;&nbsp;dataPartitionsIter,
              <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
@@ -154,6 +161,15 @@
 <div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of Iterable<BytesArrayWritable></div>
 </td>
 </tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRow(java.util.List,%20org.apache.pirk.query.wideskies.Query,%20int,%20int)">computeEncRow</a></strong>(java.util.List&lt;java.math.BigInteger&gt;&nbsp;dataPartitions,
+             <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
+             int&nbsp;rowIndex,
+             int&nbsp;colIndex)</code>
+<div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of ArrayList<<BigInteger>></div>
+</td>
+</tr>
 <tr class="altColor">
 <td class="colFirst"><code>static java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;</code></td>
 <td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.html#computeEncRowBI(java.lang.Iterable,%20org.apache.pirk.query.wideskies.Query,%20int,%20boolean,%20int,%20boolean)">computeEncRowBI</a></strong>(java.lang.Iterable&lt;java.util.List&lt;java.math.BigInteger&gt;&gt;&nbsp;dataPartitionsIter,
@@ -311,7 +327,7 @@
 <a name="computeEncRow(org.apache.pirk.inputformat.hadoop.BytesArrayWritable, org.apache.pirk.query.wideskies.Query, int, int)">
 <!--   -->
 </a>
-<ul class="blockListLast">
+<ul class="blockList">
 <li class="blockList">
 <h4>computeEncRow</h4>
 <pre>public static&nbsp;java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;&nbsp;computeEncRow(<a href="../../../../../../org/apache/pirk/inputformat/hadoop/BytesArrayWritable.html" title="class in org.apache.pirk.inputformat.hadoop">BytesArrayWritable</a>&nbsp;dataPartitions,
@@ -332,6 +348,45 @@
 <dd><code>java.io.IOException</code></dd></dl>
 </li>
 </ul>
+<a name="computeEncRow(java.util.List, org.apache.pirk.query.wideskies.Query, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>computeEncRow</h4>
+<pre>public static&nbsp;java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;&nbsp;computeEncRow(java.util.List&lt;java.math.BigInteger&gt;&nbsp;dataPartitions,
+                                                                              <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
+                                                                              int&nbsp;rowIndex,
+                                                                              int&nbsp;colIndex)
+                                                                                       throws java.io.IOException</pre>
+<div class="block">Method to compute the encrypted row elements for a query from extracted data partitions in the form of ArrayList<<BigInteger>>
+ <p>
+ For each row (as indicated by key = hash(selector)), iterates over the dataPartitions and calculates the column values.
+ <p>
+ Uses a static LRU cache for the modular exponentiation
+ <p>
+ Caller is responsible for keeping track of the colIndex and the the maxHitsPerSelector values
+ <p>
+ Emits <code>Tuple2&lt;&lt;colNum, colVal&gt;&gt;</code></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code>java.io.IOException</code></dd></dl>
+</li>
+</ul>
+<a name="computeEncRow(java.math.BigInteger, org.apache.pirk.query.wideskies.Query, int, int)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>computeEncRow</h4>
+<pre>public static&nbsp;java.util.List&lt;scala.Tuple2&lt;java.lang.Long,java.math.BigInteger&gt;&gt;&nbsp;computeEncRow(java.math.BigInteger&nbsp;part,
+                                                                              <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;query,
+                                                                              int&nbsp;rowIndex,
+                                                                              int&nbsp;colIndex)
+                                                                                       throws java.io.IOException</pre>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code>java.io.IOException</code></dd></dl>
+</li>
+</ul>
 </li>
 </ul>
 </li>
diff --git a/docs/org/apache/pirk/responder/wideskies/common/HashSelectorAndPartitionData.html b/docs/org/apache/pirk/responder/wideskies/common/HashSelectorAndPartitionData.html
index 3bdbfaa..757df19 100644
--- a/docs/org/apache/pirk/responder/wideskies/common/HashSelectorAndPartitionData.html
+++ b/docs/org/apache/pirk/responder/wideskies/common/HashSelectorAndPartitionData.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>HashSelectorAndPartitionData</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
@@ -98,8 +98,8 @@
 <br>
 <pre>public class <span class="strong">HashSelectorAndPartitionData</span>
 extends java.lang.Object</pre>
-<div class="block">Given a MapWritable dataElement, this class gives the common functionality to extract the selector by queryType from each dataElement, perform a keyed hash
- of the selector, extract the partitions of the dataElement, and outputs <code>&lt;hash(selector), dataPartitions&gt;</code></div>
+<div class="block">Given a MapWritable or JSON formatted dataElement, this class gives the common functionality to extract the selector by queryType from each dataElement,
+ perform a keyed hash of the selector, extract the partitions of the dataElement, and outputs <code>&lt;hash(selector), dataPartitions&gt;</code></div>
 </li>
 </ul>
 </div>
diff --git a/docs/org/apache/pirk/responder/wideskies/common/class-use/ComputeEncryptedRow.html b/docs/org/apache/pirk/responder/wideskies/common/class-use/ComputeEncryptedRow.html
index 13f132d..46bec7f 100644
--- a/docs/org/apache/pirk/responder/wideskies/common/class-use/ComputeEncryptedRow.html
+++ b/docs/org/apache/pirk/responder/wideskies/common/class-use/ComputeEncryptedRow.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.common.ComputeEncryptedRow</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/common/class-use/HashSelectorAndPartitionData.html b/docs/org/apache/pirk/responder/wideskies/common/class-use/HashSelectorAndPartitionData.html
index d881cb9..5573e4b 100644
--- a/docs/org/apache/pirk/responder/wideskies/common/class-use/HashSelectorAndPartitionData.html
+++ b/docs/org/apache/pirk/responder/wideskies/common/class-use/HashSelectorAndPartitionData.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.common.HashSelectorAndPartitionData</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/common/package-frame.html b/docs/org/apache/pirk/responder/wideskies/common/package-frame.html
index 9bf4614..198babe 100644
--- a/docs/org/apache/pirk/responder/wideskies/common/package-frame.html
+++ b/docs/org/apache/pirk/responder/wideskies/common/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.common</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/common/package-summary.html b/docs/org/apache/pirk/responder/wideskies/common/package-summary.html
index 9f0279a..4f0a29c 100644
--- a/docs/org/apache/pirk/responder/wideskies/common/package-summary.html
+++ b/docs/org/apache/pirk/responder/wideskies/common/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.common</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
@@ -84,8 +84,8 @@
 <tr class="rowColor">
 <td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/common/HashSelectorAndPartitionData.html" title="class in org.apache.pirk.responder.wideskies.common">HashSelectorAndPartitionData</a></td>
 <td class="colLast">
-<div class="block">Given a MapWritable dataElement, this class gives the common functionality to extract the selector by queryType from each dataElement, perform a keyed hash
- of the selector, extract the partitions of the dataElement, and outputs <code>&lt;hash(selector), dataPartitions&gt;</code></div>
+<div class="block">Given a MapWritable or JSON formatted dataElement, this class gives the common functionality to extract the selector by queryType from each dataElement,
+ perform a keyed hash of the selector, extract the partitions of the dataElement, and outputs <code>&lt;hash(selector), dataPartitions&gt;</code></div>
 </td>
 </tr>
 </tbody>
diff --git a/docs/org/apache/pirk/responder/wideskies/common/package-tree.html b/docs/org/apache/pirk/responder/wideskies/common/package-tree.html
index 1591fdc..3bcce45 100644
--- a/docs/org/apache/pirk/responder/wideskies/common/package-tree.html
+++ b/docs/org/apache/pirk/responder/wideskies/common/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.common Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/common/package-use.html b/docs/org/apache/pirk/responder/wideskies/common/package-use.html
index 5d27c76..63031f3 100644
--- a/docs/org/apache/pirk/responder/wideskies/common/package-use.html
+++ b/docs/org/apache/pirk/responder/wideskies/common/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.responder.wideskies.common</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/ColumnMultMapper.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/ColumnMultMapper.html
index ca22efc..7274004 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/ColumnMultMapper.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/ColumnMultMapper.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:43 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>ColumnMultMapper</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/ColumnMultReducer.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/ColumnMultReducer.html
index b763dae..0d0fccc 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/ColumnMultReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/ColumnMultReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:43 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>ColumnMultReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/ComputeResponseTool.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/ComputeResponseTool.html
index c49fe5f..f6e9219 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/ComputeResponseTool.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/ComputeResponseTool.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>ComputeResponseTool</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/ExpTableMapper.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/ExpTableMapper.html
index 5bed5e6..302f198 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/ExpTableMapper.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/ExpTableMapper.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>ExpTableMapper</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/ExpTableReducer.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/ExpTableReducer.html
index f2c3adf..a2ab16f 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/ExpTableReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/ExpTableReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>ExpTableReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/FinalResponseReducer.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/FinalResponseReducer.html
index d487b0a..9fd80df 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/FinalResponseReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/FinalResponseReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>FinalResponseReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/HashSelectorsAndPartitionDataMapper.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/HashSelectorsAndPartitionDataMapper.html
index 5a3051f..e9ea66f 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/HashSelectorsAndPartitionDataMapper.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/HashSelectorsAndPartitionDataMapper.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>HashSelectorsAndPartitionDataMapper</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/MRStats.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/MRStats.html
index ac34477..4e928ec 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/MRStats.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/MRStats.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>MRStats</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/RowCalcReducer.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/RowCalcReducer.html
index ebc5740..6e194c1 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/RowCalcReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/RowCalcReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>RowCalcReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ColumnMultMapper.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ColumnMultMapper.html
index 06a1cb9..1308072 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ColumnMultMapper.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ColumnMultMapper.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.ColumnMultMapper</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ColumnMultReducer.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ColumnMultReducer.html
index b3045de..efe71ee 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ColumnMultReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ColumnMultReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.ColumnMultReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ComputeResponseTool.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ComputeResponseTool.html
index bce88cd..68868ca 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ComputeResponseTool.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ComputeResponseTool.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.ComputeResponseTool</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ExpTableMapper.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ExpTableMapper.html
index 2033fbf..3595c59 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ExpTableMapper.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ExpTableMapper.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.ExpTableMapper</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ExpTableReducer.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ExpTableReducer.html
index ac4b21a..247b639 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ExpTableReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/ExpTableReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.ExpTableReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/FinalResponseReducer.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/FinalResponseReducer.html
index 44043f2..277c695 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/FinalResponseReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/FinalResponseReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.FinalResponseReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/HashSelectorsAndPartitionDataMapper.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/HashSelectorsAndPartitionDataMapper.html
index 2f4b57e..fe1bd03 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/HashSelectorsAndPartitionDataMapper.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/HashSelectorsAndPartitionDataMapper.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.HashSelectorsAndPartitionDataMapper</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/MRStats.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/MRStats.html
index a5f77fd..3a9e1da 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/MRStats.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/MRStats.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.MRStats</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/RowCalcReducer.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/RowCalcReducer.html
index 00d8527..1f360c0 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/RowCalcReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/class-use/RowCalcReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.mapreduce.RowCalcReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/package-frame.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/package-frame.html
index d2bc866..6a32d22 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/package-frame.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.mapreduce</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/package-summary.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/package-summary.html
index 4e26d85..79fdbca 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/package-summary.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.mapreduce</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/package-tree.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/package-tree.html
index e76efa3..575d58d 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/package-tree.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.mapreduce Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/mapreduce/package-use.html b/docs/org/apache/pirk/responder/wideskies/mapreduce/package-use.html
index d32c5bd..fac3212 100644
--- a/docs/org/apache/pirk/responder/wideskies/mapreduce/package-use.html
+++ b/docs/org/apache/pirk/responder/wideskies/mapreduce/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.responder.wideskies.mapreduce</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/package-frame.html b/docs/org/apache/pirk/responder/wideskies/package-frame.html
index 25d5a41..78519ba 100644
--- a/docs/org/apache/pirk/responder/wideskies/package-frame.html
+++ b/docs/org/apache/pirk/responder/wideskies/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/package-summary.html b/docs/org/apache/pirk/responder/wideskies/package-summary.html
index 789d4b1..b401b40 100644
--- a/docs/org/apache/pirk/responder/wideskies/package-summary.html
+++ b/docs/org/apache/pirk/responder/wideskies/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/package-tree.html b/docs/org/apache/pirk/responder/wideskies/package-tree.html
index d9833b5..ee399d1 100644
--- a/docs/org/apache/pirk/responder/wideskies/package-tree.html
+++ b/docs/org/apache/pirk/responder/wideskies/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/package-use.html b/docs/org/apache/pirk/responder/wideskies/package-use.html
index 0947c48..a64bd18 100644
--- a/docs/org/apache/pirk/responder/wideskies/package-use.html
+++ b/docs/org/apache/pirk/responder/wideskies/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.responder.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/Accumulators.html b/docs/org/apache/pirk/responder/wideskies/spark/Accumulators.html
index c16800f..1715054 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/Accumulators.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/Accumulators.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Accumulators</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/BroadcastVars.html b/docs/org/apache/pirk/responder/wideskies/spark/BroadcastVars.html
index e93b4ee..77cb792 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/BroadcastVars.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/BroadcastVars.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>BroadcastVars</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/ComputeExpLookupTable.html b/docs/org/apache/pirk/responder/wideskies/spark/ComputeExpLookupTable.html
index ce6a314..4c07186 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/ComputeExpLookupTable.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/ComputeExpLookupTable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>ComputeExpLookupTable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/ComputeResponse.html b/docs/org/apache/pirk/responder/wideskies/spark/ComputeResponse.html
index 48e74f1..bbdd0d9 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/ComputeResponse.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/ComputeResponse.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>ComputeResponse</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/EncColMultGroupedMapper.html b/docs/org/apache/pirk/responder/wideskies/spark/EncColMultGroupedMapper.html
index 7fe95b7..46fec27 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/EncColMultGroupedMapper.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/EncColMultGroupedMapper.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>EncColMultGroupedMapper</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/EncColMultReducer.html b/docs/org/apache/pirk/responder/wideskies/spark/EncColMultReducer.html
index f2279c6..b83e8c2 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/EncColMultReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/EncColMultReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>EncColMultReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/EncRowCalc.html b/docs/org/apache/pirk/responder/wideskies/spark/EncRowCalc.html
index c554b51..5b82153 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/EncRowCalc.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/EncRowCalc.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>EncRowCalc</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/EncRowCalcPrecomputedCache.html b/docs/org/apache/pirk/responder/wideskies/spark/EncRowCalcPrecomputedCache.html
index c1d6125..97ca8b7 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/EncRowCalcPrecomputedCache.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/EncRowCalcPrecomputedCache.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>EncRowCalcPrecomputedCache</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/ExpKeyFilenameMap.html b/docs/org/apache/pirk/responder/wideskies/spark/ExpKeyFilenameMap.html
index 83e38de..464537a 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/ExpKeyFilenameMap.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/ExpKeyFilenameMap.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>ExpKeyFilenameMap</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/ExpTableGenerator.html b/docs/org/apache/pirk/responder/wideskies/spark/ExpTableGenerator.html
index dca9a08..63d83a1 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/ExpTableGenerator.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/ExpTableGenerator.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>ExpTableGenerator</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/FilterData.html b/docs/org/apache/pirk/responder/wideskies/spark/FilterData.html
index bd65331..35ffbec 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/FilterData.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/FilterData.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>FilterData</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/HashSelectorsAndPartitionData.html b/docs/org/apache/pirk/responder/wideskies/spark/HashSelectorsAndPartitionData.html
index 5792e06..e965cf7 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/HashSelectorsAndPartitionData.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/HashSelectorsAndPartitionData.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>HashSelectorsAndPartitionData</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/Accumulators.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/Accumulators.html
index 86ac590..4dcba03 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/Accumulators.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/Accumulators.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.Accumulators</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/BroadcastVars.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/BroadcastVars.html
index d87fc63..d76f9c4 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/BroadcastVars.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/BroadcastVars.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.BroadcastVars</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/ComputeExpLookupTable.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/ComputeExpLookupTable.html
index 7110e5b..e45fff0 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/ComputeExpLookupTable.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/ComputeExpLookupTable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.ComputeExpLookupTable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/ComputeResponse.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/ComputeResponse.html
index 83673b5..66dbcc8 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/ComputeResponse.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/ComputeResponse.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.ComputeResponse</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncColMultGroupedMapper.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncColMultGroupedMapper.html
index e34789b..b815427 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncColMultGroupedMapper.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncColMultGroupedMapper.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.EncColMultGroupedMapper</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncColMultReducer.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncColMultReducer.html
index 927e6e1..6ae157e 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncColMultReducer.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncColMultReducer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.EncColMultReducer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncRowCalc.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncRowCalc.html
index 2c7cc14..0bd46fc 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncRowCalc.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncRowCalc.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.EncRowCalc</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncRowCalcPrecomputedCache.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncRowCalcPrecomputedCache.html
index 0d1083a..523ef80 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncRowCalcPrecomputedCache.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/EncRowCalcPrecomputedCache.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.EncRowCalcPrecomputedCache</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/ExpKeyFilenameMap.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/ExpKeyFilenameMap.html
index 9b7b2ba..6e26d89 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/ExpKeyFilenameMap.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/ExpKeyFilenameMap.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.ExpKeyFilenameMap</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/ExpTableGenerator.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/ExpTableGenerator.html
index 2d5757c..8c78ef5 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/ExpTableGenerator.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/ExpTableGenerator.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.ExpTableGenerator</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/FilterData.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/FilterData.html
index 0e1d94b..f3eed61 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/FilterData.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/FilterData.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.FilterData</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/class-use/HashSelectorsAndPartitionData.html b/docs/org/apache/pirk/responder/wideskies/spark/class-use/HashSelectorsAndPartitionData.html
index 793b2e4..606ebb5 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/class-use/HashSelectorsAndPartitionData.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/class-use/HashSelectorsAndPartitionData.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.HashSelectorsAndPartitionData</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/package-frame.html b/docs/org/apache/pirk/responder/wideskies/spark/package-frame.html
index ed25266..0bd6afc 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/package-frame.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.spark</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/package-summary.html b/docs/org/apache/pirk/responder/wideskies/spark/package-summary.html
index 955ecab..49f7048 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/package-summary.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.spark</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/package-tree.html b/docs/org/apache/pirk/responder/wideskies/spark/package-tree.html
index 7ac8782..ea1db12 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/package-tree.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.spark Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/package-use.html b/docs/org/apache/pirk/responder/wideskies/spark/package-use.html
index a38eccc..f8c954f 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/package-use.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.responder.wideskies.spark</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/streaming/ComputeStreamingResponse.html b/docs/org/apache/pirk/responder/wideskies/spark/streaming/ComputeStreamingResponse.html
index 795991a..e8ac5e8 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/streaming/ComputeStreamingResponse.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/streaming/ComputeStreamingResponse.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>ComputeStreamingResponse</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/streaming/FinalResponseFunction.html b/docs/org/apache/pirk/responder/wideskies/spark/streaming/FinalResponseFunction.html
index a15aa01..47c6c37 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/streaming/FinalResponseFunction.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/streaming/FinalResponseFunction.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>FinalResponseFunction</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/streaming/class-use/ComputeStreamingResponse.html b/docs/org/apache/pirk/responder/wideskies/spark/streaming/class-use/ComputeStreamingResponse.html
index c1def17..28c7466 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/streaming/class-use/ComputeStreamingResponse.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/streaming/class-use/ComputeStreamingResponse.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.streaming.ComputeStreamingResponse</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/streaming/class-use/FinalResponseFunction.html b/docs/org/apache/pirk/responder/wideskies/spark/streaming/class-use/FinalResponseFunction.html
index 0b9c324..b04d717 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/streaming/class-use/FinalResponseFunction.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/streaming/class-use/FinalResponseFunction.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.spark.streaming.FinalResponseFunction</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-frame.html b/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-frame.html
index 33dcdf8..3f15743 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-frame.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.spark.streaming</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-summary.html b/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-summary.html
index 4ecdd30..d568977 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-summary.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.spark.streaming</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-tree.html b/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-tree.html
index e1e59b6..8da84ef 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-tree.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.spark.streaming Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-use.html b/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-use.html
index 2ec1681..0b23fdd 100644
--- a/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-use.html
+++ b/docs/org/apache/pirk/responder/wideskies/spark/streaming/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.responder.wideskies.spark.streaming</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/standalone/Responder.html b/docs/org/apache/pirk/responder/wideskies/standalone/Responder.html
index b30b77b..690e0f6 100644
--- a/docs/org/apache/pirk/responder/wideskies/standalone/Responder.html
+++ b/docs/org/apache/pirk/responder/wideskies/standalone/Responder.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>Responder</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/standalone/class-use/Responder.html b/docs/org/apache/pirk/responder/wideskies/standalone/class-use/Responder.html
index d454d9e..6675836 100644
--- a/docs/org/apache/pirk/responder/wideskies/standalone/class-use/Responder.html
+++ b/docs/org/apache/pirk/responder/wideskies/standalone/class-use/Responder.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.responder.wideskies.standalone.Responder</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/standalone/package-frame.html b/docs/org/apache/pirk/responder/wideskies/standalone/package-frame.html
index 5e776a5..b32324a 100644
--- a/docs/org/apache/pirk/responder/wideskies/standalone/package-frame.html
+++ b/docs/org/apache/pirk/responder/wideskies/standalone/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.standalone</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/standalone/package-summary.html b/docs/org/apache/pirk/responder/wideskies/standalone/package-summary.html
index 8423f50..d35ab28 100644
--- a/docs/org/apache/pirk/responder/wideskies/standalone/package-summary.html
+++ b/docs/org/apache/pirk/responder/wideskies/standalone/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.standalone</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
@@ -37,7 +37,7 @@
 <div class="subNav">
 <ul class="navList">
 <li><a href="../../../../../../org/apache/pirk/responder/wideskies/spark/streaming/package-summary.html">Prev Package</a></li>
-<li><a href="../../../../../../org/apache/pirk/response/wideskies/package-summary.html">Next Package</a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/package-summary.html">Next Package</a></li>
 </ul>
 <ul class="navList">
 <li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/standalone/package-summary.html" target="_top">Frames</a></li>
@@ -106,7 +106,7 @@
 <div class="subNav">
 <ul class="navList">
 <li><a href="../../../../../../org/apache/pirk/responder/wideskies/spark/streaming/package-summary.html">Prev Package</a></li>
-<li><a href="../../../../../../org/apache/pirk/response/wideskies/package-summary.html">Next Package</a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/package-summary.html">Next Package</a></li>
 </ul>
 <ul class="navList">
 <li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/standalone/package-summary.html" target="_top">Frames</a></li>
diff --git a/docs/org/apache/pirk/responder/wideskies/standalone/package-tree.html b/docs/org/apache/pirk/responder/wideskies/standalone/package-tree.html
index 3eb8344..e16a6c9 100644
--- a/docs/org/apache/pirk/responder/wideskies/standalone/package-tree.html
+++ b/docs/org/apache/pirk/responder/wideskies/standalone/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.responder.wideskies.standalone Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
@@ -37,7 +37,7 @@
 <div class="subNav">
 <ul class="navList">
 <li><a href="../../../../../../org/apache/pirk/responder/wideskies/spark/streaming/package-tree.html">Prev</a></li>
-<li><a href="../../../../../../org/apache/pirk/response/wideskies/package-tree.html">Next</a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/package-tree.html">Next</a></li>
 </ul>
 <ul class="navList">
 <li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/standalone/package-tree.html" target="_top">Frames</a></li>
@@ -99,7 +99,7 @@
 <div class="subNav">
 <ul class="navList">
 <li><a href="../../../../../../org/apache/pirk/responder/wideskies/spark/streaming/package-tree.html">Prev</a></li>
-<li><a href="../../../../../../org/apache/pirk/response/wideskies/package-tree.html">Next</a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/package-tree.html">Next</a></li>
 </ul>
 <ul class="navList">
 <li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/standalone/package-tree.html" target="_top">Frames</a></li>
diff --git a/docs/org/apache/pirk/responder/wideskies/standalone/package-use.html b/docs/org/apache/pirk/responder/wideskies/standalone/package-use.html
index 997903b..0c9bf97 100644
--- a/docs/org/apache/pirk/responder/wideskies/standalone/package-use.html
+++ b/docs/org/apache/pirk/responder/wideskies/standalone/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.responder.wideskies.standalone</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html b/docs/org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html
new file mode 100644
index 0000000..d365361
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html
@@ -0,0 +1,334 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
+<title>EncColMultBolt</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="EncColMultBolt";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/EncColMultBolt.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev Class</li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" target="_top">Frames</a></li>
+<li><a href="EncColMultBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.responder.wideskies.storm</div>
+<h2 title="Class EncColMultBolt" class="title">Class EncColMultBolt</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.topology.base.BaseComponent</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.topology.base.BaseRichBolt</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.responder.wideskies.storm.EncColMultBolt</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Serializable, org.apache.storm.task.IBolt, org.apache.storm.topology.IComponent, org.apache.storm.topology.IRichBolt</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">EncColMultBolt</span>
+extends org.apache.storm.topology.base.BaseRichBolt</pre>
+<div class="block">Bolt class to perform encrypted column multiplication
+ <p>
+ Takes <code>&lt;columnIndex, columnValue&gt;</code> tuples as input and aggregates (multiplies) the columnValues for a given columnIndex as they are received.
+ <p>
+ EncRowCalcBolts send flush signals to the EncColMultBolts indicating that they have finished sending all tuples for a session. Whenever a flush signal is
+ received from a EncRowCalcBolt, the num of received flush signals is tallied until each EncRowCalcBolt has emitted a flush signal.
+ <p>
+ Once a flush signal has been received from each EncRowCalcBolt, all <code>&lt;columnIndex, aggregate colVal product&gt;</code> tuples are sent to the OutputBolt and a
+ session_end signal is sent back to each EncRowMultBolt.
+ <p>
+ The EncRowMultBolts buffer their output from the time that they send a flush signal to the EncColMultBolts until the time that they receive a session_end
+ signal from all of the EncColMultBolts.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../serialized-form.html#org.apache.pirk.responder.wideskies.storm.EncColMultBolt">Serialized Form</a></dd></dl>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html#EncColMultBolt()">EncColMultBolt</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html#declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">declareOutputFields</a></strong>(org.apache.storm.topology.OutputFieldsDeclarer&nbsp;outputFieldsDeclarer)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html#execute(org.apache.storm.tuple.Tuple)">execute</a></strong>(org.apache.storm.tuple.Tuple&nbsp;tuple)</code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html#prepare(java.util.Map,%20org.apache.storm.task.TopologyContext,%20org.apache.storm.task.OutputCollector)">prepare</a></strong>(java.util.Map&nbsp;map,
+       org.apache.storm.task.TopologyContext&nbsp;topologyContext,
+       org.apache.storm.task.OutputCollector&nbsp;collector)</code>&nbsp;</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.base.BaseRichBolt">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.topology.base.BaseRichBolt</h3>
+<code>cleanup</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.base.BaseComponent">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.topology.base.BaseComponent</h3>
+<code>getComponentConfiguration</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.IComponent">
+<!--   -->
+</a>
+<h3>Methods inherited from interface&nbsp;org.apache.storm.topology.IComponent</h3>
+<code>getComponentConfiguration</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="EncColMultBolt()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>EncColMultBolt</h4>
+<pre>public&nbsp;EncColMultBolt()</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="prepare(java.util.Map, org.apache.storm.task.TopologyContext, org.apache.storm.task.OutputCollector)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>prepare</h4>
+<pre>public&nbsp;void&nbsp;prepare(java.util.Map&nbsp;map,
+           org.apache.storm.task.TopologyContext&nbsp;topologyContext,
+           org.apache.storm.task.OutputCollector&nbsp;collector)</pre>
+</li>
+</ul>
+<a name="execute(org.apache.storm.tuple.Tuple)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>execute</h4>
+<pre>public&nbsp;void&nbsp;execute(org.apache.storm.tuple.Tuple&nbsp;tuple)</pre>
+</li>
+</ul>
+<a name="declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>declareOutputFields</h4>
+<pre>public&nbsp;void&nbsp;declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer&nbsp;outputFieldsDeclarer)</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/EncColMultBolt.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev Class</li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" target="_top">Frames</a></li>
+<li><a href="EncColMultBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html b/docs/org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html
new file mode 100644
index 0000000..8f018e1
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html
@@ -0,0 +1,330 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
+<title>EncRowCalcBolt</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="EncRowCalcBolt";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/EncRowCalcBolt.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" target="_top">Frames</a></li>
+<li><a href="EncRowCalcBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.responder.wideskies.storm</div>
+<h2 title="Class EncRowCalcBolt" class="title">Class EncRowCalcBolt</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.topology.base.BaseComponent</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.topology.base.BaseRichBolt</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Serializable, org.apache.storm.task.IBolt, org.apache.storm.topology.IComponent, org.apache.storm.topology.IRichBolt</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">EncRowCalcBolt</span>
+extends org.apache.storm.topology.base.BaseRichBolt</pre>
+<div class="block">Bolt class to perform the encrypted row calculation
+ <p>
+ Receives a <code>&lt;hash(selector), dataPartitions&gt;</code> tuple as input.
+ <p>
+ Encrypts the row data and emits a (column index, encrypted row-value) tuple for each encrypted block.
+ <p>
+ Every FLUSH_FREQUENCY seconds, it sends a signal to EncColMultBolt to flush its output and resets all counters. At that point, all outgoing (column index,
+ encrypted row-value) tuples are buffered until a SESSION_END signal is received back from each EncColMultBolt.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../serialized-form.html#org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt">Serialized Form</a></dd></dl>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html#EncRowCalcBolt()">EncRowCalcBolt</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html#declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">declareOutputFields</a></strong>(org.apache.storm.topology.OutputFieldsDeclarer&nbsp;outputFieldsDeclarer)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html#execute(org.apache.storm.tuple.Tuple)">execute</a></strong>(org.apache.storm.tuple.Tuple&nbsp;tuple)</code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html#prepare(java.util.Map,%20org.apache.storm.task.TopologyContext,%20org.apache.storm.task.OutputCollector)">prepare</a></strong>(java.util.Map&nbsp;map,
+       org.apache.storm.task.TopologyContext&nbsp;topologyContext,
+       org.apache.storm.task.OutputCollector&nbsp;coll)</code>&nbsp;</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.base.BaseRichBolt">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.topology.base.BaseRichBolt</h3>
+<code>cleanup</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.base.BaseComponent">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.topology.base.BaseComponent</h3>
+<code>getComponentConfiguration</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.IComponent">
+<!--   -->
+</a>
+<h3>Methods inherited from interface&nbsp;org.apache.storm.topology.IComponent</h3>
+<code>getComponentConfiguration</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="EncRowCalcBolt()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>EncRowCalcBolt</h4>
+<pre>public&nbsp;EncRowCalcBolt()</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="prepare(java.util.Map, org.apache.storm.task.TopologyContext, org.apache.storm.task.OutputCollector)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>prepare</h4>
+<pre>public&nbsp;void&nbsp;prepare(java.util.Map&nbsp;map,
+           org.apache.storm.task.TopologyContext&nbsp;topologyContext,
+           org.apache.storm.task.OutputCollector&nbsp;coll)</pre>
+</li>
+</ul>
+<a name="execute(org.apache.storm.tuple.Tuple)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>execute</h4>
+<pre>public&nbsp;void&nbsp;execute(org.apache.storm.tuple.Tuple&nbsp;tuple)</pre>
+</li>
+</ul>
+<a name="declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>declareOutputFields</h4>
+<pre>public&nbsp;void&nbsp;declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer&nbsp;outputFieldsDeclarer)</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/EncRowCalcBolt.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" target="_top">Frames</a></li>
+<li><a href="EncRowCalcBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/OutputBolt.html b/docs/org/apache/pirk/responder/wideskies/storm/OutputBolt.html
new file mode 100644
index 0000000..a07aee1
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/OutputBolt.html
@@ -0,0 +1,369 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
+<title>OutputBolt</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="OutputBolt";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/OutputBolt.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/OutputBolt.html" target="_top">Frames</a></li>
+<li><a href="OutputBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.responder.wideskies.storm</div>
+<h2 title="Class OutputBolt" class="title">Class OutputBolt</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.topology.base.BaseComponent</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.topology.base.BaseRichBolt</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.responder.wideskies.storm.OutputBolt</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Serializable, org.apache.storm.task.IBolt, org.apache.storm.topology.IComponent, org.apache.storm.topology.IRichBolt</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">OutputBolt</span>
+extends org.apache.storm.topology.base.BaseRichBolt</pre>
+<div class="block">Bolt to compute and output the final Response object for a query
+ <p>
+ Receives <code>&lt;colIndex, colProduct&gt;</code> tuples, computes the final column product for each colIndex, records the results in the final Response object, and
+ outputs the final Response object for the query.
+ <p>
+ Flush signals are sent to the OuputBolt from the EncColMultBolts via a tuple of the form <code>&lt;-1, 0&gt;</code>. Once a flush signal has been received from each
+ EncColMultBolt (or a timeout is reached), the final column product is computed and the final Response is formed and emitted.
+ <p>
+ Currently, the Responses are written to HDFS to location specified by the outputFile with the timestamp appended.
+ <p>
+ TODO: -- Enable other Response output locations</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../serialized-form.html#org.apache.pirk.responder.wideskies.storm.OutputBolt">Serialized Form</a></dd></dl>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- =========== FIELD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_summary">
+<!--   -->
+</a>
+<h3>Field Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
+<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Field and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.util.concurrent.CountDownLatch</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#latch">latch</a></strong></code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#OutputBolt()">OutputBolt</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">declareOutputFields</a></strong>(org.apache.storm.topology.OutputFieldsDeclarer&nbsp;outputFieldsDeclarer)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#execute(org.apache.storm.tuple.Tuple)">execute</a></strong>(org.apache.storm.tuple.Tuple&nbsp;tuple)</code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html#prepare(java.util.Map,%20org.apache.storm.task.TopologyContext,%20org.apache.storm.task.OutputCollector)">prepare</a></strong>(java.util.Map&nbsp;map,
+       org.apache.storm.task.TopologyContext&nbsp;topologyContext,
+       org.apache.storm.task.OutputCollector&nbsp;collector)</code>&nbsp;</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.base.BaseRichBolt">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.topology.base.BaseRichBolt</h3>
+<code>cleanup</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.base.BaseComponent">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.topology.base.BaseComponent</h3>
+<code>getComponentConfiguration</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.IComponent">
+<!--   -->
+</a>
+<h3>Methods inherited from interface&nbsp;org.apache.storm.topology.IComponent</h3>
+<code>getComponentConfiguration</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ============ FIELD DETAIL =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_detail">
+<!--   -->
+</a>
+<h3>Field Detail</h3>
+<a name="latch">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>latch</h4>
+<pre>public static&nbsp;java.util.concurrent.CountDownLatch latch</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="OutputBolt()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>OutputBolt</h4>
+<pre>public&nbsp;OutputBolt()</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="prepare(java.util.Map, org.apache.storm.task.TopologyContext, org.apache.storm.task.OutputCollector)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>prepare</h4>
+<pre>public&nbsp;void&nbsp;prepare(java.util.Map&nbsp;map,
+           org.apache.storm.task.TopologyContext&nbsp;topologyContext,
+           org.apache.storm.task.OutputCollector&nbsp;collector)</pre>
+</li>
+</ul>
+<a name="execute(org.apache.storm.tuple.Tuple)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>execute</h4>
+<pre>public&nbsp;void&nbsp;execute(org.apache.storm.tuple.Tuple&nbsp;tuple)</pre>
+</li>
+</ul>
+<a name="declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>declareOutputFields</h4>
+<pre>public&nbsp;void&nbsp;declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer&nbsp;outputFieldsDeclarer)</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/OutputBolt.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/OutputBolt.html" target="_top">Frames</a></li>
+<li><a href="OutputBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html b/docs/org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html
new file mode 100644
index 0000000..581819e
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html
@@ -0,0 +1,332 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
+<title>PartitionDataBolt</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="PartitionDataBolt";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/PartitionDataBolt.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" target="_top">Frames</a></li>
+<li><a href="PartitionDataBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.responder.wideskies.storm</div>
+<h2 title="Class PartitionDataBolt" class="title">Class PartitionDataBolt</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.topology.base.BaseComponent</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.topology.base.BaseBasicBolt</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.responder.wideskies.storm.PartitionDataBolt</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Serializable, org.apache.storm.topology.IBasicBolt, org.apache.storm.topology.IComponent</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">PartitionDataBolt</span>
+extends org.apache.storm.topology.base.BaseBasicBolt</pre>
+<div class="block">Bolt to extract the partitions of the data record and output <code>&lt;hash(selector), dataPartitions&gt;</code>
+ <p>
+ Currently receives a <code>&lt;hash(selector), JSON data record&gt;</code> as input.
+ <p></div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../serialized-form.html#org.apache.pirk.responder.wideskies.storm.PartitionDataBolt">Serialized Form</a></dd></dl>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html#PartitionDataBolt()">PartitionDataBolt</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html#declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">declareOutputFields</a></strong>(org.apache.storm.topology.OutputFieldsDeclarer&nbsp;outputFieldsDeclarer)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html#execute(org.apache.storm.tuple.Tuple,%20org.apache.storm.topology.BasicOutputCollector)">execute</a></strong>(org.apache.storm.tuple.Tuple&nbsp;tuple,
+       org.apache.storm.topology.BasicOutputCollector&nbsp;outputCollector)</code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html#prepare(java.util.Map,%20org.apache.storm.task.TopologyContext)">prepare</a></strong>(java.util.Map&nbsp;map,
+       org.apache.storm.task.TopologyContext&nbsp;context)</code>&nbsp;</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.base.BaseBasicBolt">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.topology.base.BaseBasicBolt</h3>
+<code>cleanup</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.base.BaseComponent">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.topology.base.BaseComponent</h3>
+<code>getComponentConfiguration</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.topology.IComponent">
+<!--   -->
+</a>
+<h3>Methods inherited from interface&nbsp;org.apache.storm.topology.IComponent</h3>
+<code>getComponentConfiguration</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="PartitionDataBolt()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>PartitionDataBolt</h4>
+<pre>public&nbsp;PartitionDataBolt()</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="prepare(java.util.Map, org.apache.storm.task.TopologyContext)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>prepare</h4>
+<pre>public&nbsp;void&nbsp;prepare(java.util.Map&nbsp;map,
+           org.apache.storm.task.TopologyContext&nbsp;context)</pre>
+<dl>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>prepare</code>&nbsp;in interface&nbsp;<code>org.apache.storm.topology.IBasicBolt</code></dd>
+<dt><strong>Overrides:</strong></dt>
+<dd><code>prepare</code>&nbsp;in class&nbsp;<code>org.apache.storm.topology.base.BaseBasicBolt</code></dd>
+</dl>
+</li>
+</ul>
+<a name="execute(org.apache.storm.tuple.Tuple, org.apache.storm.topology.BasicOutputCollector)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>execute</h4>
+<pre>public&nbsp;void&nbsp;execute(org.apache.storm.tuple.Tuple&nbsp;tuple,
+           org.apache.storm.topology.BasicOutputCollector&nbsp;outputCollector)</pre>
+</li>
+</ul>
+<a name="declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>declareOutputFields</h4>
+<pre>public&nbsp;void&nbsp;declareOutputFields(org.apache.storm.topology.OutputFieldsDeclarer&nbsp;outputFieldsDeclarer)</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/PartitionDataBolt.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" target="_top">Frames</a></li>
+<li><a href="PartitionDataBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html b/docs/org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html
new file mode 100644
index 0000000..e06d77f
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html
@@ -0,0 +1,315 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
+<title>PirkHashScheme</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="PirkHashScheme";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/PirkHashScheme.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" target="_top">Frames</a></li>
+<li><a href="PirkHashScheme.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#fields_inherited_from_class_org.apache.storm.kafka.StringScheme">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.responder.wideskies.storm</div>
+<h2 title="Class PirkHashScheme" class="title">Class PirkHashScheme</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.storm.kafka.StringScheme</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.responder.wideskies.storm.PirkHashScheme</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Serializable, org.apache.storm.spout.Scheme</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">PirkHashScheme</span>
+extends org.apache.storm.kafka.StringScheme
+implements org.apache.storm.spout.Scheme</pre>
+<div class="block">Scheme used by spout to retrieve and hash selector from JSON data on Kafka.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../serialized-form.html#org.apache.pirk.responder.wideskies.storm.PirkHashScheme">Serialized Form</a></dd></dl>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- =========== FIELD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_summary">
+<!--   -->
+</a>
+<h3>Field Summary</h3>
+<ul class="blockList">
+<li class="blockList"><a name="fields_inherited_from_class_org.apache.storm.kafka.StringScheme">
+<!--   -->
+</a>
+<h3>Fields inherited from class&nbsp;org.apache.storm.kafka.StringScheme</h3>
+<code>STRING_SCHEME_KEY</code></li>
+</ul>
+</li>
+</ul>
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html#PirkHashScheme(org.apache.storm.Config)">PirkHashScheme</a></strong>(org.apache.storm.Config&nbsp;conf)</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>java.util.List&lt;java.lang.Object&gt;</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html#deserialize(java.nio.ByteBuffer)">deserialize</a></strong>(java.nio.ByteBuffer&nbsp;bytes)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>org.apache.storm.tuple.Fields</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html#getOutputFields()">getOutputFields</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.apache.storm.kafka.StringScheme">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.apache.storm.kafka.StringScheme</h3>
+<code>deserializeString</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="PirkHashScheme(org.apache.storm.Config)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>PirkHashScheme</h4>
+<pre>public&nbsp;PirkHashScheme(org.apache.storm.Config&nbsp;conf)</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="deserialize(java.nio.ByteBuffer)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>deserialize</h4>
+<pre>public&nbsp;java.util.List&lt;java.lang.Object&gt;&nbsp;deserialize(java.nio.ByteBuffer&nbsp;bytes)</pre>
+<dl>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>deserialize</code>&nbsp;in interface&nbsp;<code>org.apache.storm.spout.Scheme</code></dd>
+<dt><strong>Overrides:</strong></dt>
+<dd><code>deserialize</code>&nbsp;in class&nbsp;<code>org.apache.storm.kafka.StringScheme</code></dd>
+</dl>
+</li>
+</ul>
+<a name="getOutputFields()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>getOutputFields</h4>
+<pre>public&nbsp;org.apache.storm.tuple.Fields&nbsp;getOutputFields()</pre>
+<dl>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>getOutputFields</code>&nbsp;in interface&nbsp;<code>org.apache.storm.spout.Scheme</code></dd>
+<dt><strong>Overrides:</strong></dt>
+<dd><code>getOutputFields</code>&nbsp;in class&nbsp;<code>org.apache.storm.kafka.StringScheme</code></dd>
+</dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/PirkHashScheme.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" target="_top">Frames</a></li>
+<li><a href="PirkHashScheme.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#fields_inherited_from_class_org.apache.storm.kafka.StringScheme">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/PirkTopology.html b/docs/org/apache/pirk/responder/wideskies/storm/PirkTopology.html
new file mode 100644
index 0000000..4c256cf
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/PirkTopology.html
@@ -0,0 +1,292 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
+<title>PirkTopology</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="PirkTopology";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/PirkTopology.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/PirkTopology.html" target="_top">Frames</a></li>
+<li><a href="PirkTopology.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.responder.wideskies.storm</div>
+<h2 title="Class PirkTopology" class="title">Class PirkTopology</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.responder.wideskies.storm.PirkTopology</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<br>
+<pre>public class <span class="strong">PirkTopology</span>
+extends java.lang.Object</pre>
+<div class="block">Storm topology class for wideskies Pirk implementation
+ <p></div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html#PirkTopology()">PirkTopology</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static org.apache.storm.Config</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html#createStormConf()">createStormConf</a></strong>()</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static org.apache.storm.generated.StormTopology</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html#getPirkTopology(org.apache.storm.kafka.SpoutConfig)">getPirkTopology</a></strong>(org.apache.storm.kafka.SpoutConfig&nbsp;kafkaConfig)</code>
+<div class="block">Creates Pirk topology: KafkaSpout -> PartitionDataBolt -> EncRowCalcBolt -> EncColMultBolt -> OutputBolt Requires KafkaConfig to initialize KafkaSpout.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html#runPirkTopology()">runPirkTopology</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="PirkTopology()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>PirkTopology</h4>
+<pre>public&nbsp;PirkTopology()</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="runPirkTopology()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>runPirkTopology</h4>
+<pre>public static&nbsp;void&nbsp;runPirkTopology()
+                            throws java.lang.Exception</pre>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code>java.lang.Exception</code></dd></dl>
+</li>
+</ul>
+<a name="getPirkTopology(org.apache.storm.kafka.SpoutConfig)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getPirkTopology</h4>
+<pre>public static&nbsp;org.apache.storm.generated.StormTopology&nbsp;getPirkTopology(org.apache.storm.kafka.SpoutConfig&nbsp;kafkaConfig)</pre>
+<div class="block">Creates Pirk topology: KafkaSpout -> PartitionDataBolt -> EncRowCalcBolt -> EncColMultBolt -> OutputBolt Requires KafkaConfig to initialize KafkaSpout.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>kafkaConfig</code> - </dd>
+<dt><span class="strong">Returns:</span></dt><dd></dd></dl>
+</li>
+</ul>
+<a name="createStormConf()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>createStormConf</h4>
+<pre>public static&nbsp;org.apache.storm.Config&nbsp;createStormConf()</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/PirkTopology.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/PirkTopology.html" target="_top">Frames</a></li>
+<li><a href="PirkTopology.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/StormConstants.html b/docs/org/apache/pirk/responder/wideskies/storm/StormConstants.html
new file mode 100644
index 0000000..3c84536
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/StormConstants.html
@@ -0,0 +1,727 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
+<title>StormConstants</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="StormConstants";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/StormConstants.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/StormConstants.html" target="_top">Frames</a></li>
+<li><a href="StormConstants.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#methods_inherited_from_class_java.lang.Object">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li>Method</li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.responder.wideskies.storm</div>
+<h2 title="Class StormConstants" class="title">Class StormConstants</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.responder.wideskies.storm.StormConstants</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<br>
+<pre>public class <span class="strong">StormConstants</span>
+extends java.lang.Object</pre>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- =========== FIELD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_summary">
+<!--   -->
+</a>
+<h3>Field Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
+<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Field and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ALLOW_ADHOC_QSCHEMAS_KEY">ALLOW_ADHOC_QSCHEMAS_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_INDEX_ECM_FIELD">COLUMN_INDEX_ECM_FIELD</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_INDEX_ERC_FIELD">COLUMN_INDEX_ERC_FIELD</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#COLUMN_PRODUCT_FIELD">COLUMN_PRODUCT_FIELD</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#DEFAULT">DEFAULT</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#DSCHEMA_KEY">DSCHEMA_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_ID">ENCCOLMULTBOLT_ID</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_PARALLELISM_KEY">ENCCOLMULTBOLT_PARALLELISM_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCCOLMULTBOLT_SESSION_END">ENCCOLMULTBOLT_SESSION_END</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_DATASTREAM_ID">ENCROWCALCBOLT_DATASTREAM_ID</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_FLUSH_SIG">ENCROWCALCBOLT_FLUSH_SIG</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_ID">ENCROWCALCBOLT_ID</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCROWCALCBOLT_PARALLELISM_KEY">ENCROWCALCBOLT_PARALLELISM_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ENCRYPTED_VALUE_FIELD">ENCRYPTED_VALUE_FIELD</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#FLUSH">FLUSH</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#HASH_FIELD">HASH_FIELD</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#HDFS_URI_KEY">HDFS_URI_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#JSON_DATA_FIELD">JSON_DATA_FIELD</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#LIMIT_HITS_PER_SEL_KEY">LIMIT_HITS_PER_SEL_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#MAX_HITS_PER_SEL_KEY">MAX_HITS_PER_SEL_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#N_SQUARED_KEY">N_SQUARED_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#OUTPUT_FILE_KEY">OUTPUT_FILE_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#OUTPUTBOLT_ID">OUTPUTBOLT_ID</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#PARTIONED_DATA_FIELD">PARTIONED_DATA_FIELD</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#PARTITION_DATA_BOLT_ID">PARTITION_DATA_BOLT_ID</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#QSCHEMA_KEY">QSCHEMA_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#QUERY_FILE_KEY">QUERY_FILE_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#QUERY_INFO_KEY">QUERY_INFO_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#ROW_DIVISIONS_KEY">ROW_DIVISIONS_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#SALT">SALT</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#SALT_COLUMNS_KEY">SALT_COLUMNS_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#SPLIT_PARTITIONS_KEY">SPLIT_PARTITIONS_KEY</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#SPOUT_ID">SPOUT_ID</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static java.lang.String</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#USE_HDFS">USE_HDFS</a></strong></code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html#StormConstants()">StormConstants</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ============ FIELD DETAIL =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_detail">
+<!--   -->
+</a>
+<h3>Field Detail</h3>
+<a name="SPOUT_ID">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SPOUT_ID</h4>
+<pre>public static final&nbsp;java.lang.String SPOUT_ID</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.SPOUT_ID">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PARTITION_DATA_BOLT_ID">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PARTITION_DATA_BOLT_ID</h4>
+<pre>public static final&nbsp;java.lang.String PARTITION_DATA_BOLT_ID</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.PARTITION_DATA_BOLT_ID">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ENCROWCALCBOLT_ID">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ENCROWCALCBOLT_ID</h4>
+<pre>public static final&nbsp;java.lang.String ENCROWCALCBOLT_ID</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ENCROWCALCBOLT_ID">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ENCCOLMULTBOLT_ID">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ENCCOLMULTBOLT_ID</h4>
+<pre>public static final&nbsp;java.lang.String ENCCOLMULTBOLT_ID</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ENCCOLMULTBOLT_ID">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OUTPUTBOLT_ID">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OUTPUTBOLT_ID</h4>
+<pre>public static final&nbsp;java.lang.String OUTPUTBOLT_ID</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.OUTPUTBOLT_ID">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="DEFAULT">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>DEFAULT</h4>
+<pre>public static final&nbsp;java.lang.String DEFAULT</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.DEFAULT">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ENCROWCALCBOLT_DATASTREAM_ID">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ENCROWCALCBOLT_DATASTREAM_ID</h4>
+<pre>public static final&nbsp;java.lang.String ENCROWCALCBOLT_DATASTREAM_ID</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ENCROWCALCBOLT_DATASTREAM_ID">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ENCROWCALCBOLT_FLUSH_SIG">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ENCROWCALCBOLT_FLUSH_SIG</h4>
+<pre>public static final&nbsp;java.lang.String ENCROWCALCBOLT_FLUSH_SIG</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ENCROWCALCBOLT_FLUSH_SIG">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ENCCOLMULTBOLT_SESSION_END">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ENCCOLMULTBOLT_SESSION_END</h4>
+<pre>public static final&nbsp;java.lang.String ENCCOLMULTBOLT_SESSION_END</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ENCCOLMULTBOLT_SESSION_END">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="HASH_FIELD">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>HASH_FIELD</h4>
+<pre>public static final&nbsp;java.lang.String HASH_FIELD</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.HASH_FIELD">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PARTIONED_DATA_FIELD">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PARTIONED_DATA_FIELD</h4>
+<pre>public static final&nbsp;java.lang.String PARTIONED_DATA_FIELD</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.PARTIONED_DATA_FIELD">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="JSON_DATA_FIELD">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>JSON_DATA_FIELD</h4>
+<pre>public static final&nbsp;java.lang.String JSON_DATA_FIELD</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.JSON_DATA_FIELD">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="COLUMN_INDEX_ERC_FIELD">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>COLUMN_INDEX_ERC_FIELD</h4>
+<pre>public static final&nbsp;java.lang.String COLUMN_INDEX_ERC_FIELD</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.COLUMN_INDEX_ERC_FIELD">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ENCRYPTED_VALUE_FIELD">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ENCRYPTED_VALUE_FIELD</h4>
+<pre>public static final&nbsp;java.lang.String ENCRYPTED_VALUE_FIELD</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ENCRYPTED_VALUE_FIELD">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="COLUMN_INDEX_ECM_FIELD">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>COLUMN_INDEX_ECM_FIELD</h4>
+<pre>public static final&nbsp;java.lang.String COLUMN_INDEX_ECM_FIELD</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.COLUMN_INDEX_ECM_FIELD">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="COLUMN_PRODUCT_FIELD">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>COLUMN_PRODUCT_FIELD</h4>
+<pre>public static final&nbsp;java.lang.String COLUMN_PRODUCT_FIELD</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.COLUMN_PRODUCT_FIELD">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="USE_HDFS">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>USE_HDFS</h4>
+<pre>public static final&nbsp;java.lang.String USE_HDFS</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.USE_HDFS">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="HDFS_URI_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>HDFS_URI_KEY</h4>
+<pre>public static final&nbsp;java.lang.String HDFS_URI_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.HDFS_URI_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="QUERY_FILE_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>QUERY_FILE_KEY</h4>
+<pre>public static final&nbsp;java.lang.String QUERY_FILE_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.QUERY_FILE_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="QUERY_INFO_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>QUERY_INFO_KEY</h4>
+<pre>public static final&nbsp;java.lang.String QUERY_INFO_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.QUERY_INFO_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ALLOW_ADHOC_QSCHEMAS_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ALLOW_ADHOC_QSCHEMAS_KEY</h4>
+<pre>public static final&nbsp;java.lang.String ALLOW_ADHOC_QSCHEMAS_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ALLOW_ADHOC_QSCHEMAS_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="QSCHEMA_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>QSCHEMA_KEY</h4>
+<pre>public static final&nbsp;java.lang.String QSCHEMA_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.QSCHEMA_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="DSCHEMA_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>DSCHEMA_KEY</h4>
+<pre>public static final&nbsp;java.lang.String DSCHEMA_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.DSCHEMA_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OUTPUT_FILE_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OUTPUT_FILE_KEY</h4>
+<pre>public static final&nbsp;java.lang.String OUTPUT_FILE_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.OUTPUT_FILE_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="LIMIT_HITS_PER_SEL_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>LIMIT_HITS_PER_SEL_KEY</h4>
+<pre>public static final&nbsp;java.lang.String LIMIT_HITS_PER_SEL_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.LIMIT_HITS_PER_SEL_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="MAX_HITS_PER_SEL_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>MAX_HITS_PER_SEL_KEY</h4>
+<pre>public static final&nbsp;java.lang.String MAX_HITS_PER_SEL_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.MAX_HITS_PER_SEL_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SALT_COLUMNS_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SALT_COLUMNS_KEY</h4>
+<pre>public static final&nbsp;java.lang.String SALT_COLUMNS_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.SALT_COLUMNS_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ROW_DIVISIONS_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ROW_DIVISIONS_KEY</h4>
+<pre>public static final&nbsp;java.lang.String ROW_DIVISIONS_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ROW_DIVISIONS_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SPLIT_PARTITIONS_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SPLIT_PARTITIONS_KEY</h4>
+<pre>public static final&nbsp;java.lang.String SPLIT_PARTITIONS_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.SPLIT_PARTITIONS_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="N_SQUARED_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>N_SQUARED_KEY</h4>
+<pre>public static final&nbsp;java.lang.String N_SQUARED_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.N_SQUARED_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ENCROWCALCBOLT_PARALLELISM_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ENCROWCALCBOLT_PARALLELISM_KEY</h4>
+<pre>public static final&nbsp;java.lang.String ENCROWCALCBOLT_PARALLELISM_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ENCROWCALCBOLT_PARALLELISM_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ENCCOLMULTBOLT_PARALLELISM_KEY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ENCCOLMULTBOLT_PARALLELISM_KEY</h4>
+<pre>public static final&nbsp;java.lang.String ENCCOLMULTBOLT_PARALLELISM_KEY</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.ENCCOLMULTBOLT_PARALLELISM_KEY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SALT">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SALT</h4>
+<pre>public static final&nbsp;java.lang.String SALT</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.SALT">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLUSH">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>FLUSH</h4>
+<pre>public static final&nbsp;java.lang.String FLUSH</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../constant-values.html#org.apache.pirk.responder.wideskies.storm.StormConstants.FLUSH">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="StormConstants()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>StormConstants</h4>
+<pre>public&nbsp;StormConstants()</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/StormConstants.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/StormConstants.html" target="_top">Frames</a></li>
+<li><a href="StormConstants.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#methods_inherited_from_class_java.lang.Object">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li>Method</li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/StormUtils.html b/docs/org/apache/pirk/responder/wideskies/storm/StormUtils.html
new file mode 100644
index 0000000..33e292b
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/StormUtils.html
@@ -0,0 +1,303 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
+<title>StormUtils</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="StormUtils";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/StormUtils.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li>Next Class</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/StormUtils.html" target="_top">Frames</a></li>
+<li><a href="StormUtils.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.responder.wideskies.storm</div>
+<h2 title="Class StormUtils" class="title">Class StormUtils</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.responder.wideskies.storm.StormUtils</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<br>
+<pre>public class <span class="strong">StormUtils</span>
+extends java.lang.Object</pre>
+<div class="block">Utils class for the Storm implementation of Wideskies</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html#StormUtils()">StormUtils</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a></code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html#getQuery(boolean,%20java.lang.String,%20java.lang.String)">getQuery</a></strong>(boolean&nbsp;useHdfs,
+        java.lang.String&nbsp;hdfsUri,
+        java.lang.String&nbsp;queryFile)</code>
+<div class="block">Method to read in serialized Query object from the given queryFile</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html#initializeSchemas(java.util.Map,%20java.lang.String)">initializeSchemas</a></strong>(java.util.Map&nbsp;conf,
+                 java.lang.String&nbsp;id)</code>
+<div class="block">Initialize data and query schema.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static <a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a></code></td>
+<td class="colLast"><code><strong><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html#prepareQuery(java.util.Map)">prepareQuery</a></strong>(java.util.Map&nbsp;map)</code>
+<div class="block">Method to read in and return a serialized Query object from the given file and initialize/load the query.schemas and data.schemas</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="StormUtils()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>StormUtils</h4>
+<pre>public&nbsp;StormUtils()</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="getQuery(boolean, java.lang.String, java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getQuery</h4>
+<pre>public static&nbsp;<a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;getQuery(boolean&nbsp;useHdfs,
+             java.lang.String&nbsp;hdfsUri,
+             java.lang.String&nbsp;queryFile)</pre>
+<div class="block">Method to read in serialized Query object from the given queryFile</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>useHdfs</code> - </dd><dd><code>hdfsUri</code> - </dd><dd><code>queryFile</code> - </dd>
+<dt><span class="strong">Returns:</span></dt><dd></dd></dl>
+</li>
+</ul>
+<a name="prepareQuery(java.util.Map)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>prepareQuery</h4>
+<pre>public static&nbsp;<a href="../../../../../../org/apache/pirk/query/wideskies/Query.html" title="class in org.apache.pirk.query.wideskies">Query</a>&nbsp;prepareQuery(java.util.Map&nbsp;map)</pre>
+<div class="block">Method to read in and return a serialized Query object from the given file and initialize/load the query.schemas and data.schemas</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>map</code> - </dd>
+<dt><span class="strong">Returns:</span></dt><dd></dd></dl>
+</li>
+</ul>
+<a name="initializeSchemas(java.util.Map, java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>initializeSchemas</h4>
+<pre>public static&nbsp;void&nbsp;initializeSchemas(java.util.Map&nbsp;conf,
+                     java.lang.String&nbsp;id)</pre>
+<div class="block">Initialize data and query schema. Conf requires values for USE_HDFS, HDFS_URI_KEY, DSCHEMA_KEY, and QSCHEMA_KEY</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>conf</code> - </dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/StormUtils.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">Prev Class</span></a></li>
+<li>Next Class</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/StormUtils.html" target="_top">Frames</a></li>
+<li><a href="StormUtils.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/class-use/EncColMultBolt.html b/docs/org/apache/pirk/responder/wideskies/storm/class-use/EncColMultBolt.html
new file mode 100644
index 0000000..97870c8
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/class-use/EncColMultBolt.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.responder.wideskies.storm.EncColMultBolt</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.responder.wideskies.storm.EncColMultBolt";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/EncColMultBolt.html" target="_top">Frames</a></li>
+<li><a href="EncColMultBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.responder.wideskies.storm.EncColMultBolt" class="title">Uses of Class<br>org.apache.pirk.responder.wideskies.storm.EncColMultBolt</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.responder.wideskies.storm.EncColMultBolt</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/EncColMultBolt.html" target="_top">Frames</a></li>
+<li><a href="EncColMultBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/class-use/EncRowCalcBolt.html b/docs/org/apache/pirk/responder/wideskies/storm/class-use/EncRowCalcBolt.html
new file mode 100644
index 0000000..c520ae3
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/class-use/EncRowCalcBolt.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/EncRowCalcBolt.html" target="_top">Frames</a></li>
+<li><a href="EncRowCalcBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt" class="title">Uses of Class<br>org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/EncRowCalcBolt.html" target="_top">Frames</a></li>
+<li><a href="EncRowCalcBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/class-use/OutputBolt.html b/docs/org/apache/pirk/responder/wideskies/storm/class-use/OutputBolt.html
new file mode 100644
index 0000000..2ea89e2
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/class-use/OutputBolt.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.responder.wideskies.storm.OutputBolt</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.responder.wideskies.storm.OutputBolt";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/OutputBolt.html" target="_top">Frames</a></li>
+<li><a href="OutputBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.responder.wideskies.storm.OutputBolt" class="title">Uses of Class<br>org.apache.pirk.responder.wideskies.storm.OutputBolt</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.responder.wideskies.storm.OutputBolt</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/OutputBolt.html" target="_top">Frames</a></li>
+<li><a href="OutputBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/class-use/PartitionDataBolt.html b/docs/org/apache/pirk/responder/wideskies/storm/class-use/PartitionDataBolt.html
new file mode 100644
index 0000000..e58eea7
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/class-use/PartitionDataBolt.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.responder.wideskies.storm.PartitionDataBolt</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.responder.wideskies.storm.PartitionDataBolt";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/PartitionDataBolt.html" target="_top">Frames</a></li>
+<li><a href="PartitionDataBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.responder.wideskies.storm.PartitionDataBolt" class="title">Uses of Class<br>org.apache.pirk.responder.wideskies.storm.PartitionDataBolt</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.responder.wideskies.storm.PartitionDataBolt</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/PartitionDataBolt.html" target="_top">Frames</a></li>
+<li><a href="PartitionDataBolt.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/class-use/PirkHashScheme.html b/docs/org/apache/pirk/responder/wideskies/storm/class-use/PirkHashScheme.html
new file mode 100644
index 0000000..a5028f6
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/class-use/PirkHashScheme.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.responder.wideskies.storm.PirkHashScheme</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.responder.wideskies.storm.PirkHashScheme";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/PirkHashScheme.html" target="_top">Frames</a></li>
+<li><a href="PirkHashScheme.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.responder.wideskies.storm.PirkHashScheme" class="title">Uses of Class<br>org.apache.pirk.responder.wideskies.storm.PirkHashScheme</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.responder.wideskies.storm.PirkHashScheme</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/PirkHashScheme.html" target="_top">Frames</a></li>
+<li><a href="PirkHashScheme.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/class-use/PirkTopology.html b/docs/org/apache/pirk/responder/wideskies/storm/class-use/PirkTopology.html
new file mode 100644
index 0000000..f97b68a
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/class-use/PirkTopology.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.responder.wideskies.storm.PirkTopology</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.responder.wideskies.storm.PirkTopology";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/PirkTopology.html" target="_top">Frames</a></li>
+<li><a href="PirkTopology.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.responder.wideskies.storm.PirkTopology" class="title">Uses of Class<br>org.apache.pirk.responder.wideskies.storm.PirkTopology</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.responder.wideskies.storm.PirkTopology</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/PirkTopology.html" target="_top">Frames</a></li>
+<li><a href="PirkTopology.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/class-use/StormConstants.html b/docs/org/apache/pirk/responder/wideskies/storm/class-use/StormConstants.html
new file mode 100644
index 0000000..eae614b
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/class-use/StormConstants.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.responder.wideskies.storm.StormConstants</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.responder.wideskies.storm.StormConstants";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/StormConstants.html" target="_top">Frames</a></li>
+<li><a href="StormConstants.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.responder.wideskies.storm.StormConstants" class="title">Uses of Class<br>org.apache.pirk.responder.wideskies.storm.StormConstants</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.responder.wideskies.storm.StormConstants</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/StormConstants.html" target="_top">Frames</a></li>
+<li><a href="StormConstants.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/class-use/StormUtils.html b/docs/org/apache/pirk/responder/wideskies/storm/class-use/StormUtils.html
new file mode 100644
index 0000000..bc7ba5a
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/class-use/StormUtils.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.responder.wideskies.storm.StormUtils</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.responder.wideskies.storm.StormUtils";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/StormUtils.html" target="_top">Frames</a></li>
+<li><a href="StormUtils.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.responder.wideskies.storm.StormUtils" class="title">Uses of Class<br>org.apache.pirk.responder.wideskies.storm.StormUtils</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.responder.wideskies.storm.StormUtils</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/class-use/StormUtils.html" target="_top">Frames</a></li>
+<li><a href="StormUtils.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/package-frame.html b/docs/org/apache/pirk/responder/wideskies/storm/package-frame.html
new file mode 100644
index 0000000..30137c7
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/package-frame.html
@@ -0,0 +1,26 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>org.apache.pirk.responder.wideskies.storm</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<h1 class="bar"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/package-summary.html" target="classFrame">org.apache.pirk.responder.wideskies.storm</a></h1>
+<div class="indexContainer">
+<h2 title="Classes">Classes</h2>
+<ul title="Classes">
+<li><a href="EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">EncColMultBolt</a></li>
+<li><a href="EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">EncRowCalcBolt</a></li>
+<li><a href="OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">OutputBolt</a></li>
+<li><a href="PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">PartitionDataBolt</a></li>
+<li><a href="PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">PirkHashScheme</a></li>
+<li><a href="PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">PirkTopology</a></li>
+<li><a href="StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">StormConstants</a></li>
+<li><a href="StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm" target="classFrame">StormUtils</a></li>
+</ul>
+</div>
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/package-summary.html b/docs/org/apache/pirk/responder/wideskies/storm/package-summary.html
new file mode 100644
index 0000000..cc3ac43
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/package-summary.html
@@ -0,0 +1,175 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>org.apache.pirk.responder.wideskies.storm</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="org.apache.pirk.responder.wideskies.storm";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li class="navBarCell1Rev">Package</li>
+<li>Class</li>
+<li><a href="package-use.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/standalone/package-summary.html">Prev Package</a></li>
+<li><a href="../../../../../../org/apache/pirk/response/wideskies/package-summary.html">Next Package</a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/package-summary.html" target="_top">Frames</a></li>
+<li><a href="package-summary.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 title="Package" class="title">Package&nbsp;org.apache.pirk.responder.wideskies.storm</h1>
+</div>
+<div class="contentContainer">
+<ul class="blockList">
+<li class="blockList">
+<table class="packageSummary" border="0" cellpadding="3" cellspacing="0" summary="Class Summary table, listing classes, and an explanation">
+<caption><span>Class Summary</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Class</th>
+<th class="colLast" scope="col">Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncColMultBolt</a></td>
+<td class="colLast">
+<div class="block">Bolt class to perform encrypted column multiplication</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">EncRowCalcBolt</a></td>
+<td class="colLast">
+<div class="block">Bolt class to perform the encrypted row calculation</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">OutputBolt</a></td>
+<td class="colLast">
+<div class="block">Bolt to compute and output the final Response object for a query</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">PartitionDataBolt</a></td>
+<td class="colLast">
+<div class="block">Bolt to extract the partitions of the data record and output <code>&lt;hash(selector), dataPartitions&gt;</code></div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkHashScheme</a></td>
+<td class="colLast">
+<div class="block">Scheme used by spout to retrieve and hash selector from JSON data on Kafka.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm">PirkTopology</a></td>
+<td class="colLast">
+<div class="block">Storm topology class for wideskies Pirk implementation</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm">StormConstants</a></td>
+<td class="colLast">&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm">StormUtils</a></td>
+<td class="colLast">
+<div class="block">Utils class for the Storm implementation of Wideskies</div>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li class="navBarCell1Rev">Package</li>
+<li>Class</li>
+<li><a href="package-use.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/standalone/package-summary.html">Prev Package</a></li>
+<li><a href="../../../../../../org/apache/pirk/response/wideskies/package-summary.html">Next Package</a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/package-summary.html" target="_top">Frames</a></li>
+<li><a href="package-summary.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/package-tree.html b/docs/org/apache/pirk/responder/wideskies/storm/package-tree.html
new file mode 100644
index 0000000..a9ca982
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/package-tree.html
@@ -0,0 +1,151 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>org.apache.pirk.responder.wideskies.storm Class Hierarchy</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="org.apache.pirk.responder.wideskies.storm Class Hierarchy";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li>Class</li>
+<li>Use</li>
+<li class="navBarCell1Rev">Tree</li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/standalone/package-tree.html">Prev</a></li>
+<li><a href="../../../../../../org/apache/pirk/response/wideskies/package-tree.html">Next</a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/package-tree.html" target="_top">Frames</a></li>
+<li><a href="package-tree.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 class="title">Hierarchy For Package org.apache.pirk.responder.wideskies.storm</h1>
+<span class="strong">Package Hierarchies:</span>
+<ul class="horizontal">
+<li><a href="../../../../../../overview-tree.html">All Packages</a></li>
+</ul>
+</div>
+<div class="contentContainer">
+<h2 title="Class Hierarchy">Class Hierarchy</h2>
+<ul>
+<li type="circle">java.lang.Object
+<ul>
+<li type="circle">org.apache.storm.topology.base.BaseComponent (implements org.apache.storm.topology.IComponent)
+<ul>
+<li type="circle">org.apache.storm.topology.base.BaseBasicBolt (implements org.apache.storm.topology.IBasicBolt)
+<ul>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PartitionDataBolt</span></a></li>
+</ul>
+</li>
+<li type="circle">org.apache.storm.topology.base.BaseRichBolt (implements org.apache.storm.topology.IRichBolt)
+<ul>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">EncColMultBolt</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="../../../../../../org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">EncRowCalcBolt</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="../../../../../../org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">OutputBolt</span></a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PirkTopology</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">StormConstants</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="../../../../../../org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">StormUtils</span></a></li>
+<li type="circle">org.apache.storm.kafka.StringScheme (implements org.apache.storm.spout.Scheme)
+<ul>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="../../../../../../org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PirkHashScheme</span></a> (implements org.apache.storm.spout.Scheme)</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li>Class</li>
+<li>Use</li>
+<li class="navBarCell1Rev">Tree</li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../../../org/apache/pirk/responder/wideskies/standalone/package-tree.html">Prev</a></li>
+<li><a href="../../../../../../org/apache/pirk/response/wideskies/package-tree.html">Next</a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/package-tree.html" target="_top">Frames</a></li>
+<li><a href="package-tree.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/responder/wideskies/storm/package-use.html b/docs/org/apache/pirk/responder/wideskies/storm/package-use.html
new file mode 100644
index 0000000..a4df35f
--- /dev/null
+++ b/docs/org/apache/pirk/responder/wideskies/storm/package-use.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Package org.apache.pirk.responder.wideskies.storm</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Package org.apache.pirk.responder.wideskies.storm";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li>Class</li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/package-use.html" target="_top">Frames</a></li>
+<li><a href="package-use.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 title="Uses of Package org.apache.pirk.responder.wideskies.storm" class="title">Uses of Package<br>org.apache.pirk.responder.wideskies.storm</h1>
+</div>
+<div class="contentContainer">No usage of org.apache.pirk.responder.wideskies.storm</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li>Class</li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../../index.html?org/apache/pirk/responder/wideskies/storm/package-use.html" target="_top">Frames</a></li>
+<li><a href="package-use.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/response/wideskies/Response.html b/docs/org/apache/pirk/response/wideskies/Response.html
index cbc428e..84c2022 100644
--- a/docs/org/apache/pirk/response/wideskies/Response.html
+++ b/docs/org/apache/pirk/response/wideskies/Response.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>Response</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/response/wideskies/class-use/Response.html b/docs/org/apache/pirk/response/wideskies/class-use/Response.html
index c7b960d..08bd21f 100644
--- a/docs/org/apache/pirk/response/wideskies/class-use/Response.html
+++ b/docs/org/apache/pirk/response/wideskies/class-use/Response.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.response.wideskies.Response</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/response/wideskies/package-frame.html b/docs/org/apache/pirk/response/wideskies/package-frame.html
index 1d38509..2f7ed3e 100644
--- a/docs/org/apache/pirk/response/wideskies/package-frame.html
+++ b/docs/org/apache/pirk/response/wideskies/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.response.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/response/wideskies/package-summary.html b/docs/org/apache/pirk/response/wideskies/package-summary.html
index c2ac01f..008c9f0 100644
--- a/docs/org/apache/pirk/response/wideskies/package-summary.html
+++ b/docs/org/apache/pirk/response/wideskies/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.response.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
@@ -36,7 +36,7 @@
 </div>
 <div class="subNav">
 <ul class="navList">
-<li><a href="../../../../../org/apache/pirk/responder/wideskies/standalone/package-summary.html">Prev Package</a></li>
+<li><a href="../../../../../org/apache/pirk/responder/wideskies/storm/package-summary.html">Prev Package</a></li>
 <li><a href="../../../../../org/apache/pirk/schema/data/package-summary.html">Next Package</a></li>
 </ul>
 <ul class="navList">
@@ -105,7 +105,7 @@
 </div>
 <div class="subNav">
 <ul class="navList">
-<li><a href="../../../../../org/apache/pirk/responder/wideskies/standalone/package-summary.html">Prev Package</a></li>
+<li><a href="../../../../../org/apache/pirk/responder/wideskies/storm/package-summary.html">Prev Package</a></li>
 <li><a href="../../../../../org/apache/pirk/schema/data/package-summary.html">Next Package</a></li>
 </ul>
 <ul class="navList">
diff --git a/docs/org/apache/pirk/response/wideskies/package-tree.html b/docs/org/apache/pirk/response/wideskies/package-tree.html
index d4aa6b8..2ed5872 100644
--- a/docs/org/apache/pirk/response/wideskies/package-tree.html
+++ b/docs/org/apache/pirk/response/wideskies/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.response.wideskies Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
@@ -36,7 +36,7 @@
 </div>
 <div class="subNav">
 <ul class="navList">
-<li><a href="../../../../../org/apache/pirk/responder/wideskies/standalone/package-tree.html">Prev</a></li>
+<li><a href="../../../../../org/apache/pirk/responder/wideskies/storm/package-tree.html">Prev</a></li>
 <li><a href="../../../../../org/apache/pirk/schema/data/package-tree.html">Next</a></li>
 </ul>
 <ul class="navList">
@@ -98,7 +98,7 @@
 </div>
 <div class="subNav">
 <ul class="navList">
-<li><a href="../../../../../org/apache/pirk/responder/wideskies/standalone/package-tree.html">Prev</a></li>
+<li><a href="../../../../../org/apache/pirk/responder/wideskies/storm/package-tree.html">Prev</a></li>
 <li><a href="../../../../../org/apache/pirk/schema/data/package-tree.html">Next</a></li>
 </ul>
 <ul class="navList">
diff --git a/docs/org/apache/pirk/response/wideskies/package-use.html b/docs/org/apache/pirk/response/wideskies/package-use.html
index 9178a7c..6906908 100644
--- a/docs/org/apache/pirk/response/wideskies/package-use.html
+++ b/docs/org/apache/pirk/response/wideskies/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.response.wideskies</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/DataSchema.html b/docs/org/apache/pirk/schema/data/DataSchema.html
index f6f87c9..6e0718b 100644
--- a/docs/org/apache/pirk/schema/data/DataSchema.html
+++ b/docs/org/apache/pirk/schema/data/DataSchema.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>DataSchema</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/DataSchemaLoader.html b/docs/org/apache/pirk/schema/data/DataSchemaLoader.html
index 1ab3d7a..40035b3 100644
--- a/docs/org/apache/pirk/schema/data/DataSchemaLoader.html
+++ b/docs/org/apache/pirk/schema/data/DataSchemaLoader.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>DataSchemaLoader</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/DataSchemaRegistry.html b/docs/org/apache/pirk/schema/data/DataSchemaRegistry.html
index d2c14a0..52c25e0 100644
--- a/docs/org/apache/pirk/schema/data/DataSchemaRegistry.html
+++ b/docs/org/apache/pirk/schema/data/DataSchemaRegistry.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>DataSchemaRegistry</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/LoadDataSchemaTest.html b/docs/org/apache/pirk/schema/data/LoadDataSchemaTest.html
index 70e3a9e..291a85d 100644
--- a/docs/org/apache/pirk/schema/data/LoadDataSchemaTest.html
+++ b/docs/org/apache/pirk/schema/data/LoadDataSchemaTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>LoadDataSchemaTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/class-use/DataSchema.html b/docs/org/apache/pirk/schema/data/class-use/DataSchema.html
index 6004d75..7ff9c1e 100644
--- a/docs/org/apache/pirk/schema/data/class-use/DataSchema.html
+++ b/docs/org/apache/pirk/schema/data/class-use/DataSchema.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.data.DataSchema</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/class-use/DataSchemaLoader.html b/docs/org/apache/pirk/schema/data/class-use/DataSchemaLoader.html
index ea7dad4..04ed2a7 100644
--- a/docs/org/apache/pirk/schema/data/class-use/DataSchemaLoader.html
+++ b/docs/org/apache/pirk/schema/data/class-use/DataSchemaLoader.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.data.DataSchemaLoader</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/class-use/DataSchemaRegistry.html b/docs/org/apache/pirk/schema/data/class-use/DataSchemaRegistry.html
index a44e595..f159a52 100644
--- a/docs/org/apache/pirk/schema/data/class-use/DataSchemaRegistry.html
+++ b/docs/org/apache/pirk/schema/data/class-use/DataSchemaRegistry.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.data.DataSchemaRegistry</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/class-use/LoadDataSchemaTest.html b/docs/org/apache/pirk/schema/data/class-use/LoadDataSchemaTest.html
index 1e60e4f..7fbfbbd 100644
--- a/docs/org/apache/pirk/schema/data/class-use/LoadDataSchemaTest.html
+++ b/docs/org/apache/pirk/schema/data/class-use/LoadDataSchemaTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.data.LoadDataSchemaTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/package-frame.html b/docs/org/apache/pirk/schema/data/package-frame.html
index edd8275..9999716 100644
--- a/docs/org/apache/pirk/schema/data/package-frame.html
+++ b/docs/org/apache/pirk/schema/data/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.data</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/package-summary.html b/docs/org/apache/pirk/schema/data/package-summary.html
index 06e43e6..f1405f2 100644
--- a/docs/org/apache/pirk/schema/data/package-summary.html
+++ b/docs/org/apache/pirk/schema/data/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.data</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/package-tree.html b/docs/org/apache/pirk/schema/data/package-tree.html
index 686f34a..73552e7 100644
--- a/docs/org/apache/pirk/schema/data/package-tree.html
+++ b/docs/org/apache/pirk/schema/data/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.data Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/package-use.html b/docs/org/apache/pirk/schema/data/package-use.html
index eff77e3..dd166a6 100644
--- a/docs/org/apache/pirk/schema/data/package-use.html
+++ b/docs/org/apache/pirk/schema/data/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.schema.data</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/DataPartitioner.html b/docs/org/apache/pirk/schema/data/partitioner/DataPartitioner.html
index 3aa2f07..d818b8b 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/DataPartitioner.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/DataPartitioner.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>DataPartitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/IPDataPartitioner.html b/docs/org/apache/pirk/schema/data/partitioner/IPDataPartitioner.html
index 41402bf..e7cc691 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/IPDataPartitioner.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/IPDataPartitioner.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>IPDataPartitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/ISO8601DatePartitioner.html b/docs/org/apache/pirk/schema/data/partitioner/ISO8601DatePartitioner.html
index 98075b5..bec3ae1 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/ISO8601DatePartitioner.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/ISO8601DatePartitioner.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>ISO8601DatePartitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html b/docs/org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html
index cc2786e..50394ae 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>PrimitiveTypePartitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/class-use/DataPartitioner.html b/docs/org/apache/pirk/schema/data/partitioner/class-use/DataPartitioner.html
index dc2b37f..62c6214 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/class-use/DataPartitioner.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/class-use/DataPartitioner.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Interface org.apache.pirk.schema.data.partitioner.DataPartitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/class-use/IPDataPartitioner.html b/docs/org/apache/pirk/schema/data/partitioner/class-use/IPDataPartitioner.html
index c6e34d9..6280c7b 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/class-use/IPDataPartitioner.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/class-use/IPDataPartitioner.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.data.partitioner.IPDataPartitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/class-use/ISO8601DatePartitioner.html b/docs/org/apache/pirk/schema/data/partitioner/class-use/ISO8601DatePartitioner.html
index 6a3a352..8c34222 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/class-use/ISO8601DatePartitioner.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/class-use/ISO8601DatePartitioner.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.data.partitioner.ISO8601DatePartitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/class-use/PrimitiveTypePartitioner.html b/docs/org/apache/pirk/schema/data/partitioner/class-use/PrimitiveTypePartitioner.html
index b8c1b4b..7ea5a2a 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/class-use/PrimitiveTypePartitioner.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/class-use/PrimitiveTypePartitioner.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.data.partitioner.PrimitiveTypePartitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/package-frame.html b/docs/org/apache/pirk/schema/data/partitioner/package-frame.html
index 1f8a798..ae8a42b 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/package-frame.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.data.partitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/package-summary.html b/docs/org/apache/pirk/schema/data/partitioner/package-summary.html
index 4adea05..7abfcd1 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/package-summary.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.data.partitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/package-tree.html b/docs/org/apache/pirk/schema/data/partitioner/package-tree.html
index 97335ad..9540107 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/package-tree.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.data.partitioner Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/data/partitioner/package-use.html b/docs/org/apache/pirk/schema/data/partitioner/package-use.html
index 4c1be4d..f210e15 100644
--- a/docs/org/apache/pirk/schema/data/partitioner/package-use.html
+++ b/docs/org/apache/pirk/schema/data/partitioner/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.schema.data.partitioner</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/LoadQuerySchemaTest.html b/docs/org/apache/pirk/schema/query/LoadQuerySchemaTest.html
index 9d1165c..cef30e0 100644
--- a/docs/org/apache/pirk/schema/query/LoadQuerySchemaTest.html
+++ b/docs/org/apache/pirk/schema/query/LoadQuerySchemaTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>LoadQuerySchemaTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/QuerySchema.html b/docs/org/apache/pirk/schema/query/QuerySchema.html
index 680f8a8..85d54a6 100644
--- a/docs/org/apache/pirk/schema/query/QuerySchema.html
+++ b/docs/org/apache/pirk/schema/query/QuerySchema.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>QuerySchema</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/QuerySchemaLoader.html b/docs/org/apache/pirk/schema/query/QuerySchemaLoader.html
index 23747f1..2eea9e8 100644
--- a/docs/org/apache/pirk/schema/query/QuerySchemaLoader.html
+++ b/docs/org/apache/pirk/schema/query/QuerySchemaLoader.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QuerySchemaLoader</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/QuerySchemaRegistry.html b/docs/org/apache/pirk/schema/query/QuerySchemaRegistry.html
index 767c066..d502ae4 100644
--- a/docs/org/apache/pirk/schema/query/QuerySchemaRegistry.html
+++ b/docs/org/apache/pirk/schema/query/QuerySchemaRegistry.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QuerySchemaRegistry</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/class-use/LoadQuerySchemaTest.html b/docs/org/apache/pirk/schema/query/class-use/LoadQuerySchemaTest.html
index eab75e7..bc1ba57 100644
--- a/docs/org/apache/pirk/schema/query/class-use/LoadQuerySchemaTest.html
+++ b/docs/org/apache/pirk/schema/query/class-use/LoadQuerySchemaTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.query.LoadQuerySchemaTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/class-use/QuerySchema.html b/docs/org/apache/pirk/schema/query/class-use/QuerySchema.html
index 446939d..2739b14 100644
--- a/docs/org/apache/pirk/schema/query/class-use/QuerySchema.html
+++ b/docs/org/apache/pirk/schema/query/class-use/QuerySchema.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.query.QuerySchema</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/class-use/QuerySchemaLoader.html b/docs/org/apache/pirk/schema/query/class-use/QuerySchemaLoader.html
index 2e59fd1..d34a3c7 100644
--- a/docs/org/apache/pirk/schema/query/class-use/QuerySchemaLoader.html
+++ b/docs/org/apache/pirk/schema/query/class-use/QuerySchemaLoader.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.query.QuerySchemaLoader</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/class-use/QuerySchemaRegistry.html b/docs/org/apache/pirk/schema/query/class-use/QuerySchemaRegistry.html
index 3c6bf31..4bc62a6 100644
--- a/docs/org/apache/pirk/schema/query/class-use/QuerySchemaRegistry.html
+++ b/docs/org/apache/pirk/schema/query/class-use/QuerySchemaRegistry.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.query.QuerySchemaRegistry</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/DataFilter.html b/docs/org/apache/pirk/schema/query/filter/DataFilter.html
index adc0bda..d16428a 100644
--- a/docs/org/apache/pirk/schema/query/filter/DataFilter.html
+++ b/docs/org/apache/pirk/schema/query/filter/DataFilter.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>DataFilter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/FilterFactory.html b/docs/org/apache/pirk/schema/query/filter/FilterFactory.html
index 1b251af..d5d660f 100644
--- a/docs/org/apache/pirk/schema/query/filter/FilterFactory.html
+++ b/docs/org/apache/pirk/schema/query/filter/FilterFactory.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>FilterFactory</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/StopListFilter.html b/docs/org/apache/pirk/schema/query/filter/StopListFilter.html
index a3382b4..cafac78 100644
--- a/docs/org/apache/pirk/schema/query/filter/StopListFilter.html
+++ b/docs/org/apache/pirk/schema/query/filter/StopListFilter.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>StopListFilter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/class-use/DataFilter.html b/docs/org/apache/pirk/schema/query/filter/class-use/DataFilter.html
index a22a387..6f2a42e 100644
--- a/docs/org/apache/pirk/schema/query/filter/class-use/DataFilter.html
+++ b/docs/org/apache/pirk/schema/query/filter/class-use/DataFilter.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Interface org.apache.pirk.schema.query.filter.DataFilter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/class-use/FilterFactory.html b/docs/org/apache/pirk/schema/query/filter/class-use/FilterFactory.html
index 26322be..4039fe7 100644
--- a/docs/org/apache/pirk/schema/query/filter/class-use/FilterFactory.html
+++ b/docs/org/apache/pirk/schema/query/filter/class-use/FilterFactory.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.query.filter.FilterFactory</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/class-use/StopListFilter.html b/docs/org/apache/pirk/schema/query/filter/class-use/StopListFilter.html
index 1be5ead..99c39e0 100644
--- a/docs/org/apache/pirk/schema/query/filter/class-use/StopListFilter.html
+++ b/docs/org/apache/pirk/schema/query/filter/class-use/StopListFilter.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.query.filter.StopListFilter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/package-frame.html b/docs/org/apache/pirk/schema/query/filter/package-frame.html
index bab5e49..6fb8c09 100644
--- a/docs/org/apache/pirk/schema/query/filter/package-frame.html
+++ b/docs/org/apache/pirk/schema/query/filter/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.query.filter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/package-summary.html b/docs/org/apache/pirk/schema/query/filter/package-summary.html
index 78e78f9..3457958 100644
--- a/docs/org/apache/pirk/schema/query/filter/package-summary.html
+++ b/docs/org/apache/pirk/schema/query/filter/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.query.filter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/package-tree.html b/docs/org/apache/pirk/schema/query/filter/package-tree.html
index d144c7e..c11a836 100644
--- a/docs/org/apache/pirk/schema/query/filter/package-tree.html
+++ b/docs/org/apache/pirk/schema/query/filter/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.query.filter Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/filter/package-use.html b/docs/org/apache/pirk/schema/query/filter/package-use.html
index 0bed975..7803890 100644
--- a/docs/org/apache/pirk/schema/query/filter/package-use.html
+++ b/docs/org/apache/pirk/schema/query/filter/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.schema.query.filter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/package-frame.html b/docs/org/apache/pirk/schema/query/package-frame.html
index 2472aa0..ee0acd0 100644
--- a/docs/org/apache/pirk/schema/query/package-frame.html
+++ b/docs/org/apache/pirk/schema/query/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.query</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/package-summary.html b/docs/org/apache/pirk/schema/query/package-summary.html
index ba3f9ff..b34bbbf 100644
--- a/docs/org/apache/pirk/schema/query/package-summary.html
+++ b/docs/org/apache/pirk/schema/query/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.query</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/package-tree.html b/docs/org/apache/pirk/schema/query/package-tree.html
index 4123b88..b976462 100644
--- a/docs/org/apache/pirk/schema/query/package-tree.html
+++ b/docs/org/apache/pirk/schema/query/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.query Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/query/package-use.html b/docs/org/apache/pirk/schema/query/package-use.html
index 82a4417..84abe8e 100644
--- a/docs/org/apache/pirk/schema/query/package-use.html
+++ b/docs/org/apache/pirk/schema/query/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.schema.query</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/response/QueryResponseJSON.html b/docs/org/apache/pirk/schema/response/QueryResponseJSON.html
index 6749fe5..d8699cc 100644
--- a/docs/org/apache/pirk/schema/response/QueryResponseJSON.html
+++ b/docs/org/apache/pirk/schema/response/QueryResponseJSON.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QueryResponseJSON</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/response/class-use/QueryResponseJSON.html b/docs/org/apache/pirk/schema/response/class-use/QueryResponseJSON.html
index f72d07d..63e0ab6 100644
--- a/docs/org/apache/pirk/schema/response/class-use/QueryResponseJSON.html
+++ b/docs/org/apache/pirk/schema/response/class-use/QueryResponseJSON.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.schema.response.QueryResponseJSON</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
@@ -196,6 +196,23 @@
 </tr>
 </tbody>
 </table>
+<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
+<caption><span>Method parameters in <a href="../../../../../../org/apache/pirk/test/utils/package-summary.html">org.apache.pirk.test.utils</a> with type arguments of type <a href="../../../../../../org/apache/pirk/schema/response/QueryResponseJSON.html" title="class in org.apache.pirk.schema.response">QueryResponseJSON</a></span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><code>static void</code></td>
+<td class="colLast"><span class="strong">BaseTests.</span><code><strong><a href="../../../../../../org/apache/pirk/test/utils/BaseTests.html#checkDNSHostnameQueryResults(java.util.List,%20boolean,%20int,%20boolean,%20java.util.List)">checkDNSHostnameQueryResults</a></strong>(java.util.List&lt;<a href="../../../../../../org/apache/pirk/schema/response/QueryResponseJSON.html" title="class in org.apache.pirk.schema.response">QueryResponseJSON</a>&gt;&nbsp;results,
+                            boolean&nbsp;isDistributed,
+                            int&nbsp;numExpectedResults,
+                            boolean&nbsp;testFalsePositive,
+                            java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements)</code>&nbsp;</td>
+</tr>
+</tbody>
+</table>
 </li>
 <li class="blockList"><a name="org.apache.pirk.utils">
 <!--   -->
diff --git a/docs/org/apache/pirk/schema/response/package-frame.html b/docs/org/apache/pirk/schema/response/package-frame.html
index b100bc2..491fdca 100644
--- a/docs/org/apache/pirk/schema/response/package-frame.html
+++ b/docs/org/apache/pirk/schema/response/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.response</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/response/package-summary.html b/docs/org/apache/pirk/schema/response/package-summary.html
index c9791dd..8cc1833 100644
--- a/docs/org/apache/pirk/schema/response/package-summary.html
+++ b/docs/org/apache/pirk/schema/response/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.response</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/response/package-tree.html b/docs/org/apache/pirk/schema/response/package-tree.html
index c6a5620..2946eba 100644
--- a/docs/org/apache/pirk/schema/response/package-tree.html
+++ b/docs/org/apache/pirk/schema/response/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.schema.response Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/schema/response/package-use.html b/docs/org/apache/pirk/schema/response/package-use.html
index f0a127b..bb69b42 100644
--- a/docs/org/apache/pirk/schema/response/package-use.html
+++ b/docs/org/apache/pirk/schema/response/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.schema.response</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/HadoopFileSystemStore.html b/docs/org/apache/pirk/serialization/HadoopFileSystemStore.html
index 293d14b..5af291a 100644
--- a/docs/org/apache/pirk/serialization/HadoopFileSystemStore.html
+++ b/docs/org/apache/pirk/serialization/HadoopFileSystemStore.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>HadoopFileSystemStore</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/JavaSerializer.html b/docs/org/apache/pirk/serialization/JavaSerializer.html
index 1524bb8..1ebf0e8 100644
--- a/docs/org/apache/pirk/serialization/JavaSerializer.html
+++ b/docs/org/apache/pirk/serialization/JavaSerializer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>JavaSerializer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/JsonSerializer.html b/docs/org/apache/pirk/serialization/JsonSerializer.html
index 43a84cd..e1c9d25 100644
--- a/docs/org/apache/pirk/serialization/JsonSerializer.html
+++ b/docs/org/apache/pirk/serialization/JsonSerializer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>JsonSerializer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/LocalFileSystemStore.html b/docs/org/apache/pirk/serialization/LocalFileSystemStore.html
index 87b2fc6..b8e317d 100644
--- a/docs/org/apache/pirk/serialization/LocalFileSystemStore.html
+++ b/docs/org/apache/pirk/serialization/LocalFileSystemStore.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>LocalFileSystemStore</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/SerializationService.html b/docs/org/apache/pirk/serialization/SerializationService.html
index 3d30277..4fdee49 100644
--- a/docs/org/apache/pirk/serialization/SerializationService.html
+++ b/docs/org/apache/pirk/serialization/SerializationService.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>SerializationService</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/SerializationTest.html b/docs/org/apache/pirk/serialization/SerializationTest.html
index b0eccdc..c19c8b5 100644
--- a/docs/org/apache/pirk/serialization/SerializationTest.html
+++ b/docs/org/apache/pirk/serialization/SerializationTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>SerializationTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/Storable.html b/docs/org/apache/pirk/serialization/Storable.html
index 25165cf..814a94d 100644
--- a/docs/org/apache/pirk/serialization/Storable.html
+++ b/docs/org/apache/pirk/serialization/Storable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Storable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/class-use/HadoopFileSystemStore.html b/docs/org/apache/pirk/serialization/class-use/HadoopFileSystemStore.html
index 70cd81a..099c4a1 100644
--- a/docs/org/apache/pirk/serialization/class-use/HadoopFileSystemStore.html
+++ b/docs/org/apache/pirk/serialization/class-use/HadoopFileSystemStore.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.serialization.HadoopFileSystemStore</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/class-use/JavaSerializer.html b/docs/org/apache/pirk/serialization/class-use/JavaSerializer.html
index 20803cf..1c9e4d7 100644
--- a/docs/org/apache/pirk/serialization/class-use/JavaSerializer.html
+++ b/docs/org/apache/pirk/serialization/class-use/JavaSerializer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.serialization.JavaSerializer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/class-use/JsonSerializer.html b/docs/org/apache/pirk/serialization/class-use/JsonSerializer.html
index 2167a0f..0640db8 100644
--- a/docs/org/apache/pirk/serialization/class-use/JsonSerializer.html
+++ b/docs/org/apache/pirk/serialization/class-use/JsonSerializer.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.serialization.JsonSerializer</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/class-use/LocalFileSystemStore.html b/docs/org/apache/pirk/serialization/class-use/LocalFileSystemStore.html
index 90b3d40..1ed1bec 100644
--- a/docs/org/apache/pirk/serialization/class-use/LocalFileSystemStore.html
+++ b/docs/org/apache/pirk/serialization/class-use/LocalFileSystemStore.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.serialization.LocalFileSystemStore</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/class-use/SerializationService.html b/docs/org/apache/pirk/serialization/class-use/SerializationService.html
index f7379bb..4d59daf 100644
--- a/docs/org/apache/pirk/serialization/class-use/SerializationService.html
+++ b/docs/org/apache/pirk/serialization/class-use/SerializationService.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.serialization.SerializationService</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/class-use/SerializationTest.html b/docs/org/apache/pirk/serialization/class-use/SerializationTest.html
index 1ce8cb9..a62de2c 100644
--- a/docs/org/apache/pirk/serialization/class-use/SerializationTest.html
+++ b/docs/org/apache/pirk/serialization/class-use/SerializationTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.serialization.SerializationTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/class-use/Storable.html b/docs/org/apache/pirk/serialization/class-use/Storable.html
index 1df5df1..5544468 100644
--- a/docs/org/apache/pirk/serialization/class-use/Storable.html
+++ b/docs/org/apache/pirk/serialization/class-use/Storable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Interface org.apache.pirk.serialization.Storable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/package-frame.html b/docs/org/apache/pirk/serialization/package-frame.html
index 2ecb369..52d3124 100644
--- a/docs/org/apache/pirk/serialization/package-frame.html
+++ b/docs/org/apache/pirk/serialization/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.serialization</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/serialization/package-summary.html b/docs/org/apache/pirk/serialization/package-summary.html
index c6058c7..61158ee 100644
--- a/docs/org/apache/pirk/serialization/package-summary.html
+++ b/docs/org/apache/pirk/serialization/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.serialization</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
@@ -37,7 +37,7 @@
 <div class="subNav">
 <ul class="navList">
 <li><a href="../../../../org/apache/pirk/schema/response/package-summary.html">Prev Package</a></li>
-<li><a href="../../../../org/apache/pirk/test/distributed/package-summary.html">Next Package</a></li>
+<li><a href="../../../../org/apache/pirk/storm/package-summary.html">Next Package</a></li>
 </ul>
 <ul class="navList">
 <li><a href="../../../../index.html?org/apache/pirk/serialization/package-summary.html" target="_top">Frames</a></li>
@@ -141,7 +141,7 @@
 <div class="subNav">
 <ul class="navList">
 <li><a href="../../../../org/apache/pirk/schema/response/package-summary.html">Prev Package</a></li>
-<li><a href="../../../../org/apache/pirk/test/distributed/package-summary.html">Next Package</a></li>
+<li><a href="../../../../org/apache/pirk/storm/package-summary.html">Next Package</a></li>
 </ul>
 <ul class="navList">
 <li><a href="../../../../index.html?org/apache/pirk/serialization/package-summary.html" target="_top">Frames</a></li>
diff --git a/docs/org/apache/pirk/serialization/package-tree.html b/docs/org/apache/pirk/serialization/package-tree.html
index 1e25157..7898a55 100644
--- a/docs/org/apache/pirk/serialization/package-tree.html
+++ b/docs/org/apache/pirk/serialization/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.serialization Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
@@ -37,7 +37,7 @@
 <div class="subNav">
 <ul class="navList">
 <li><a href="../../../../org/apache/pirk/schema/response/package-tree.html">Prev</a></li>
-<li><a href="../../../../org/apache/pirk/test/distributed/package-tree.html">Next</a></li>
+<li><a href="../../../../org/apache/pirk/storm/package-tree.html">Next</a></li>
 </ul>
 <ul class="navList">
 <li><a href="../../../../index.html?org/apache/pirk/serialization/package-tree.html" target="_top">Frames</a></li>
@@ -111,7 +111,7 @@
 <div class="subNav">
 <ul class="navList">
 <li><a href="../../../../org/apache/pirk/schema/response/package-tree.html">Prev</a></li>
-<li><a href="../../../../org/apache/pirk/test/distributed/package-tree.html">Next</a></li>
+<li><a href="../../../../org/apache/pirk/storm/package-tree.html">Next</a></li>
 </ul>
 <ul class="navList">
 <li><a href="../../../../index.html?org/apache/pirk/serialization/package-tree.html" target="_top">Frames</a></li>
diff --git a/docs/org/apache/pirk/serialization/package-use.html b/docs/org/apache/pirk/serialization/package-use.html
index 3b79ea9..565a195 100644
--- a/docs/org/apache/pirk/serialization/package-use.html
+++ b/docs/org/apache/pirk/serialization/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.serialization</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/storm/KafkaStormIntegrationTest.html b/docs/org/apache/pirk/storm/KafkaStormIntegrationTest.html
new file mode 100644
index 0000000..6b5f6b1
--- /dev/null
+++ b/docs/org/apache/pirk/storm/KafkaStormIntegrationTest.html
@@ -0,0 +1,275 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
+<title>KafkaStormIntegrationTest</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="KafkaStormIntegrationTest";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/KafkaStormIntegrationTest.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev Class</li>
+<li><a href="../../../../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/KafkaStormIntegrationTest.html" target="_top">Frames</a></li>
+<li><a href="KafkaStormIntegrationTest.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.storm</div>
+<h2 title="Class KafkaStormIntegrationTest" class="title">Class KafkaStormIntegrationTest</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.storm.KafkaStormIntegrationTest</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<br>
+<pre>public class <span class="strong">KafkaStormIntegrationTest</span>
+extends java.lang.Object</pre>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html#KafkaStormIntegrationTest()">KafkaStormIntegrationTest</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static void</code></td>
+<td class="colLast"><code><strong><a href="../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html#tearDown()">tearDown</a></strong>()</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html#testKafkaStormIntegration()">testKafkaStormIntegration</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="KafkaStormIntegrationTest()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>KafkaStormIntegrationTest</h4>
+<pre>public&nbsp;KafkaStormIntegrationTest()</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="testKafkaStormIntegration()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>testKafkaStormIntegration</h4>
+<pre>public&nbsp;void&nbsp;testKafkaStormIntegration()
+                               throws java.lang.Exception</pre>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code>java.lang.Exception</code></dd></dl>
+</li>
+</ul>
+<a name="tearDown()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>tearDown</h4>
+<pre>public static&nbsp;void&nbsp;tearDown()
+                     throws java.lang.Exception</pre>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code>java.lang.Exception</code></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/KafkaStormIntegrationTest.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev Class</li>
+<li><a href="../../../../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/KafkaStormIntegrationTest.html" target="_top">Frames</a></li>
+<li><a href="KafkaStormIntegrationTest.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/storm/SystemTime.html b/docs/org/apache/pirk/storm/SystemTime.html
new file mode 100644
index 0000000..6eadaf1
--- /dev/null
+++ b/docs/org/apache/pirk/storm/SystemTime.html
@@ -0,0 +1,299 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
+<title>SystemTime</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="SystemTime";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/SystemTime.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm"><span class="strong">Prev Class</span></a></li>
+<li>Next Class</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/SystemTime.html" target="_top">Frames</a></li>
+<li><a href="SystemTime.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.apache.pirk.storm</div>
+<h2 title="Class SystemTime" class="title">Class SystemTime</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.apache.pirk.storm.SystemTime</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>kafka.utils.Time</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">SystemTime</span>
+extends java.lang.Object
+implements kafka.utils.Time</pre>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../../org/apache/pirk/storm/SystemTime.html#SystemTime()">SystemTime</a></strong>()</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>long</code></td>
+<td class="colLast"><code><strong><a href="../../../../org/apache/pirk/storm/SystemTime.html#milliseconds()">milliseconds</a></strong>()</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>long</code></td>
+<td class="colLast"><code><strong><a href="../../../../org/apache/pirk/storm/SystemTime.html#nanoseconds()">nanoseconds</a></strong>()</code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../../org/apache/pirk/storm/SystemTime.html#sleep(long)">sleep</a></strong>(long&nbsp;arg0)</code>&nbsp;</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="SystemTime()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>SystemTime</h4>
+<pre>public&nbsp;SystemTime()</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="milliseconds()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>milliseconds</h4>
+<pre>public&nbsp;long&nbsp;milliseconds()</pre>
+<dl>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>milliseconds</code>&nbsp;in interface&nbsp;<code>kafka.utils.Time</code></dd>
+</dl>
+</li>
+</ul>
+<a name="nanoseconds()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>nanoseconds</h4>
+<pre>public&nbsp;long&nbsp;nanoseconds()</pre>
+<dl>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>nanoseconds</code>&nbsp;in interface&nbsp;<code>kafka.utils.Time</code></dd>
+</dl>
+</li>
+</ul>
+<a name="sleep(long)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>sleep</h4>
+<pre>public&nbsp;void&nbsp;sleep(long&nbsp;arg0)</pre>
+<dl>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>sleep</code>&nbsp;in interface&nbsp;<code>kafka.utils.Time</code></dd>
+</dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="class-use/SystemTime.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm"><span class="strong">Prev Class</span></a></li>
+<li>Next Class</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/SystemTime.html" target="_top">Frames</a></li>
+<li><a href="SystemTime.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/storm/class-use/KafkaStormIntegrationTest.html b/docs/org/apache/pirk/storm/class-use/KafkaStormIntegrationTest.html
new file mode 100644
index 0000000..b0bfb29
--- /dev/null
+++ b/docs/org/apache/pirk/storm/class-use/KafkaStormIntegrationTest.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.storm.KafkaStormIntegrationTest</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.storm.KafkaStormIntegrationTest";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../index.html?org/apache/pirk/storm/class-use/KafkaStormIntegrationTest.html" target="_top">Frames</a></li>
+<li><a href="KafkaStormIntegrationTest.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.storm.KafkaStormIntegrationTest" class="title">Uses of Class<br>org.apache.pirk.storm.KafkaStormIntegrationTest</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.storm.KafkaStormIntegrationTest</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../index.html?org/apache/pirk/storm/class-use/KafkaStormIntegrationTest.html" target="_top">Frames</a></li>
+<li><a href="KafkaStormIntegrationTest.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/storm/class-use/SystemTime.html b/docs/org/apache/pirk/storm/class-use/SystemTime.html
new file mode 100644
index 0000000..bce3a64
--- /dev/null
+++ b/docs/org/apache/pirk/storm/class-use/SystemTime.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Class org.apache.pirk.storm.SystemTime</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Class org.apache.pirk.storm.SystemTime";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../index.html?org/apache/pirk/storm/class-use/SystemTime.html" target="_top">Frames</a></li>
+<li><a href="SystemTime.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h2 title="Uses of Class org.apache.pirk.storm.SystemTime" class="title">Uses of Class<br>org.apache.pirk.storm.SystemTime</h2>
+</div>
+<div class="classUseContainer">No usage of org.apache.pirk.storm.SystemTime</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../../overview-summary.html">Overview</a></li>
+<li><a href="../package-summary.html">Package</a></li>
+<li><a href="../../../../../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm">Class</a></li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="../package-tree.html">Tree</a></li>
+<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../../index.html?org/apache/pirk/storm/class-use/SystemTime.html" target="_top">Frames</a></li>
+<li><a href="SystemTime.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/storm/package-frame.html b/docs/org/apache/pirk/storm/package-frame.html
new file mode 100644
index 0000000..4e4a291
--- /dev/null
+++ b/docs/org/apache/pirk/storm/package-frame.html
@@ -0,0 +1,20 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>org.apache.pirk.storm</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<h1 class="bar"><a href="../../../../org/apache/pirk/storm/package-summary.html" target="classFrame">org.apache.pirk.storm</a></h1>
+<div class="indexContainer">
+<h2 title="Classes">Classes</h2>
+<ul title="Classes">
+<li><a href="KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm" target="classFrame">KafkaStormIntegrationTest</a></li>
+<li><a href="SystemTime.html" title="class in org.apache.pirk.storm" target="classFrame">SystemTime</a></li>
+</ul>
+</div>
+</body>
+</html>
diff --git a/docs/org/apache/pirk/storm/package-summary.html b/docs/org/apache/pirk/storm/package-summary.html
new file mode 100644
index 0000000..c6223ed
--- /dev/null
+++ b/docs/org/apache/pirk/storm/package-summary.html
@@ -0,0 +1,137 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>org.apache.pirk.storm</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="org.apache.pirk.storm";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li class="navBarCell1Rev">Package</li>
+<li>Class</li>
+<li><a href="package-use.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../org/apache/pirk/serialization/package-summary.html">Prev Package</a></li>
+<li><a href="../../../../org/apache/pirk/test/distributed/package-summary.html">Next Package</a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/package-summary.html" target="_top">Frames</a></li>
+<li><a href="package-summary.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 title="Package" class="title">Package&nbsp;org.apache.pirk.storm</h1>
+</div>
+<div class="contentContainer">
+<ul class="blockList">
+<li class="blockList">
+<table class="packageSummary" border="0" cellpadding="3" cellspacing="0" summary="Class Summary table, listing classes, and an explanation">
+<caption><span>Class Summary</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Class</th>
+<th class="colLast" scope="col">Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm">KafkaStormIntegrationTest</a></td>
+<td class="colLast">&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="../../../../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm">SystemTime</a></td>
+<td class="colLast">&nbsp;</td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li class="navBarCell1Rev">Package</li>
+<li>Class</li>
+<li><a href="package-use.html">Use</a></li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../org/apache/pirk/serialization/package-summary.html">Prev Package</a></li>
+<li><a href="../../../../org/apache/pirk/test/distributed/package-summary.html">Next Package</a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/package-summary.html" target="_top">Frames</a></li>
+<li><a href="package-summary.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/storm/package-tree.html b/docs/org/apache/pirk/storm/package-tree.html
new file mode 100644
index 0000000..7042466
--- /dev/null
+++ b/docs/org/apache/pirk/storm/package-tree.html
@@ -0,0 +1,129 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>org.apache.pirk.storm Class Hierarchy</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="org.apache.pirk.storm Class Hierarchy";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li>Class</li>
+<li>Use</li>
+<li class="navBarCell1Rev">Tree</li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../org/apache/pirk/serialization/package-tree.html">Prev</a></li>
+<li><a href="../../../../org/apache/pirk/test/distributed/package-tree.html">Next</a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/package-tree.html" target="_top">Frames</a></li>
+<li><a href="package-tree.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 class="title">Hierarchy For Package org.apache.pirk.storm</h1>
+<span class="strong">Package Hierarchies:</span>
+<ul class="horizontal">
+<li><a href="../../../../overview-tree.html">All Packages</a></li>
+</ul>
+</div>
+<div class="contentContainer">
+<h2 title="Class Hierarchy">Class Hierarchy</h2>
+<ul>
+<li type="circle">java.lang.Object
+<ul>
+<li type="circle">org.apache.pirk.storm.<a href="../../../../org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm"><span class="strong">KafkaStormIntegrationTest</span></a></li>
+<li type="circle">org.apache.pirk.storm.<a href="../../../../org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm"><span class="strong">SystemTime</span></a> (implements kafka.utils.Time)</li>
+</ul>
+</li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li>Class</li>
+<li>Use</li>
+<li class="navBarCell1Rev">Tree</li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../../org/apache/pirk/serialization/package-tree.html">Prev</a></li>
+<li><a href="../../../../org/apache/pirk/test/distributed/package-tree.html">Next</a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/package-tree.html" target="_top">Frames</a></li>
+<li><a href="package-tree.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/storm/package-use.html b/docs/org/apache/pirk/storm/package-use.html
new file mode 100644
index 0000000..6099c56
--- /dev/null
+++ b/docs/org/apache/pirk/storm/package-use.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
+<title>Uses of Package org.apache.pirk.storm</title>
+<meta name="date" content="2016-08-30">
+<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    if (location.href.indexOf('is-external=true') == -1) {
+        parent.document.title="Uses of Package org.apache.pirk.storm";
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li>Class</li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/package-use.html" target="_top">Frames</a></li>
+<li><a href="package-use.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 title="Uses of Package org.apache.pirk.storm" class="title">Uses of Package<br>org.apache.pirk.storm</h1>
+</div>
+<div class="contentContainer">No usage of org.apache.pirk.storm</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../../overview-summary.html">Overview</a></li>
+<li><a href="package-summary.html">Package</a></li>
+<li>Class</li>
+<li class="navBarCell1Rev">Use</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../../index-files/index-1.html">Index</a></li>
+<li><a href="../../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../../index.html?org/apache/pirk/storm/package-use.html" target="_top">Frames</a></li>
+<li><a href="package-use.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/docs/org/apache/pirk/test/distributed/DistributedTestCLI.html b/docs/org/apache/pirk/test/distributed/DistributedTestCLI.html
index 2f73c7e..c34e94c 100644
--- a/docs/org/apache/pirk/test/distributed/DistributedTestCLI.html
+++ b/docs/org/apache/pirk/test/distributed/DistributedTestCLI.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:43 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>DistributedTestCLI</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/DistributedTestDriver.html b/docs/org/apache/pirk/test/distributed/DistributedTestDriver.html
index c1f22e0..3685683 100644
--- a/docs/org/apache/pirk/test/distributed/DistributedTestDriver.html
+++ b/docs/org/apache/pirk/test/distributed/DistributedTestDriver.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:43 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:31 EDT 2016 -->
 <title>DistributedTestDriver</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/class-use/DistributedTestCLI.html b/docs/org/apache/pirk/test/distributed/class-use/DistributedTestCLI.html
index 135e9c3..8733abc 100644
--- a/docs/org/apache/pirk/test/distributed/class-use/DistributedTestCLI.html
+++ b/docs/org/apache/pirk/test/distributed/class-use/DistributedTestCLI.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.test.distributed.DistributedTestCLI</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/class-use/DistributedTestDriver.html b/docs/org/apache/pirk/test/distributed/class-use/DistributedTestDriver.html
index 96a0360..2a86214 100644
--- a/docs/org/apache/pirk/test/distributed/class-use/DistributedTestDriver.html
+++ b/docs/org/apache/pirk/test/distributed/class-use/DistributedTestDriver.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.test.distributed.DistributedTestDriver</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/package-frame.html b/docs/org/apache/pirk/test/distributed/package-frame.html
index 62e7a70..ccfa46d 100644
--- a/docs/org/apache/pirk/test/distributed/package-frame.html
+++ b/docs/org/apache/pirk/test/distributed/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.distributed</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/package-summary.html b/docs/org/apache/pirk/test/distributed/package-summary.html
index 2877cc1..3332f9e 100644
--- a/docs/org/apache/pirk/test/distributed/package-summary.html
+++ b/docs/org/apache/pirk/test/distributed/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.distributed</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
@@ -36,7 +36,7 @@
 </div>
 <div class="subNav">
 <ul class="navList">
-<li><a href="../../../../../org/apache/pirk/serialization/package-summary.html">Prev Package</a></li>
+<li><a href="../../../../../org/apache/pirk/storm/package-summary.html">Prev Package</a></li>
 <li><a href="../../../../../org/apache/pirk/test/distributed/testsuite/package-summary.html">Next Package</a></li>
 </ul>
 <ul class="navList">
@@ -111,7 +111,7 @@
 </div>
 <div class="subNav">
 <ul class="navList">
-<li><a href="../../../../../org/apache/pirk/serialization/package-summary.html">Prev Package</a></li>
+<li><a href="../../../../../org/apache/pirk/storm/package-summary.html">Prev Package</a></li>
 <li><a href="../../../../../org/apache/pirk/test/distributed/testsuite/package-summary.html">Next Package</a></li>
 </ul>
 <ul class="navList">
diff --git a/docs/org/apache/pirk/test/distributed/package-tree.html b/docs/org/apache/pirk/test/distributed/package-tree.html
index 8076382..c850fa5 100644
--- a/docs/org/apache/pirk/test/distributed/package-tree.html
+++ b/docs/org/apache/pirk/test/distributed/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.distributed Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
@@ -36,7 +36,7 @@
 </div>
 <div class="subNav">
 <ul class="navList">
-<li><a href="../../../../../org/apache/pirk/serialization/package-tree.html">Prev</a></li>
+<li><a href="../../../../../org/apache/pirk/storm/package-tree.html">Prev</a></li>
 <li><a href="../../../../../org/apache/pirk/test/distributed/testsuite/package-tree.html">Next</a></li>
 </ul>
 <ul class="navList">
@@ -99,7 +99,7 @@
 </div>
 <div class="subNav">
 <ul class="navList">
-<li><a href="../../../../../org/apache/pirk/serialization/package-tree.html">Prev</a></li>
+<li><a href="../../../../../org/apache/pirk/storm/package-tree.html">Prev</a></li>
 <li><a href="../../../../../org/apache/pirk/test/distributed/testsuite/package-tree.html">Next</a></li>
 </ul>
 <ul class="navList">
diff --git a/docs/org/apache/pirk/test/distributed/package-use.html b/docs/org/apache/pirk/test/distributed/package-use.html
index ba26f80..f44aed8 100644
--- a/docs/org/apache/pirk/test/distributed/package-use.html
+++ b/docs/org/apache/pirk/test/distributed/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.test.distributed</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/testsuite/DistTestSuite.html b/docs/org/apache/pirk/test/distributed/testsuite/DistTestSuite.html
index 6af4327..4d4fd65 100644
--- a/docs/org/apache/pirk/test/distributed/testsuite/DistTestSuite.html
+++ b/docs/org/apache/pirk/test/distributed/testsuite/DistTestSuite.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>DistTestSuite</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/testsuite/class-use/DistTestSuite.html b/docs/org/apache/pirk/test/distributed/testsuite/class-use/DistTestSuite.html
index 59a0745..706b08c 100644
--- a/docs/org/apache/pirk/test/distributed/testsuite/class-use/DistTestSuite.html
+++ b/docs/org/apache/pirk/test/distributed/testsuite/class-use/DistTestSuite.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.test.distributed.testsuite.DistTestSuite</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/testsuite/package-frame.html b/docs/org/apache/pirk/test/distributed/testsuite/package-frame.html
index 17967f0..8c90e0a 100644
--- a/docs/org/apache/pirk/test/distributed/testsuite/package-frame.html
+++ b/docs/org/apache/pirk/test/distributed/testsuite/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.distributed.testsuite</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/testsuite/package-summary.html b/docs/org/apache/pirk/test/distributed/testsuite/package-summary.html
index 66f4daf..08f9f9e 100644
--- a/docs/org/apache/pirk/test/distributed/testsuite/package-summary.html
+++ b/docs/org/apache/pirk/test/distributed/testsuite/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.distributed.testsuite</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/testsuite/package-tree.html b/docs/org/apache/pirk/test/distributed/testsuite/package-tree.html
index 85f56dc..e07d03c 100644
--- a/docs/org/apache/pirk/test/distributed/testsuite/package-tree.html
+++ b/docs/org/apache/pirk/test/distributed/testsuite/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.distributed.testsuite Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/distributed/testsuite/package-use.html b/docs/org/apache/pirk/test/distributed/testsuite/package-use.html
index cb83b73..f517a4b 100644
--- a/docs/org/apache/pirk/test/distributed/testsuite/package-use.html
+++ b/docs/org/apache/pirk/test/distributed/testsuite/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.test.distributed.testsuite</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/BaseTests.html b/docs/org/apache/pirk/test/utils/BaseTests.html
index f4dc4e9..d4261b2 100644
--- a/docs/org/apache/pirk/test/utils/BaseTests.html
+++ b/docs/org/apache/pirk/test/utils/BaseTests.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>BaseTests</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
@@ -175,11 +175,19 @@
 </tr>
 <tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
+<td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#checkDNSHostnameQueryResults(java.util.List,%20boolean,%20int,%20boolean,%20java.util.List)">checkDNSHostnameQueryResults</a></strong>(java.util.List&lt;<a href="../../../../../org/apache/pirk/schema/response/QueryResponseJSON.html" title="class in org.apache.pirk.schema.response">QueryResponseJSON</a>&gt;&nbsp;results,
+                            boolean&nbsp;isDistributed,
+                            int&nbsp;numExpectedResults,
+                            boolean&nbsp;testFalsePositive,
+                            java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testDNSHostnameQuery(java.util.ArrayList,%20int,%20boolean)">testDNSHostnameQuery</a></strong>(java.util.ArrayList&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
                     int&nbsp;numThreads,
                     boolean&nbsp;testFalsePositive)</code>&nbsp;</td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testDNSHostnameQuery(java.util.List,%20org.apache.hadoop.fs.FileSystem,%20boolean,%20boolean,%20int)">testDNSHostnameQuery</a></strong>(java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
                     org.apache.hadoop.fs.FileSystem&nbsp;fs,
@@ -187,7 +195,7 @@
                     boolean&nbsp;isDistributed,
                     int&nbsp;numThreads)</code>&nbsp;</td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testDNSHostnameQuery(java.util.List,%20org.apache.hadoop.fs.FileSystem,%20boolean,%20boolean,%20int,%20boolean,%20boolean)">testDNSHostnameQuery</a></strong>(java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
                     org.apache.hadoop.fs.FileSystem&nbsp;fs,
@@ -197,12 +205,12 @@
                     boolean&nbsp;testFalsePositive,
                     boolean&nbsp;isStreaming)</code>&nbsp;</td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testDNSIPQuery(java.util.ArrayList,%20int)">testDNSIPQuery</a></strong>(java.util.ArrayList&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
               int&nbsp;numThreads)</code>&nbsp;</td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testDNSIPQuery(java.util.List,%20org.apache.hadoop.fs.FileSystem,%20boolean,%20boolean,%20int,%20boolean)">testDNSIPQuery</a></strong>(java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
               org.apache.hadoop.fs.FileSystem&nbsp;fs,
@@ -211,12 +219,12 @@
               int&nbsp;numThreads,
               boolean&nbsp;isStreaming)</code>&nbsp;</td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testDNSNXDOMAINQuery(java.util.ArrayList,%20int)">testDNSNXDOMAINQuery</a></strong>(java.util.ArrayList&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
                     int&nbsp;numThreads)</code>&nbsp;</td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testDNSNXDOMAINQuery(java.util.List,%20org.apache.hadoop.fs.FileSystem,%20boolean,%20boolean,%20int)">testDNSNXDOMAINQuery</a></strong>(java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
                     org.apache.hadoop.fs.FileSystem&nbsp;fs,
@@ -224,12 +232,12 @@
                     boolean&nbsp;isDistributed,
                     int&nbsp;numThreads)</code>&nbsp;</td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testSRCIPQuery(java.util.ArrayList,%20int)">testSRCIPQuery</a></strong>(java.util.ArrayList&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
               int&nbsp;numThreads)</code>&nbsp;</td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testSRCIPQuery(java.util.List,%20org.apache.hadoop.fs.FileSystem,%20boolean,%20boolean,%20int,%20boolean)">testSRCIPQuery</a></strong>(java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
               org.apache.hadoop.fs.FileSystem&nbsp;fs,
@@ -238,7 +246,7 @@
               int&nbsp;numThreads,
               boolean&nbsp;isStreaming)</code>&nbsp;</td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../../org/apache/pirk/test/utils/BaseTests.html#testSRCIPQueryNoFilter(java.util.List,%20org.apache.hadoop.fs.FileSystem,%20boolean,%20boolean,%20int,%20boolean)">testSRCIPQueryNoFilter</a></strong>(java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements,
                       org.apache.hadoop.fs.FileSystem&nbsp;fs,
@@ -401,6 +409,19 @@
 <dd><code>java.lang.Exception</code></dd></dl>
 </li>
 </ul>
+<a name="checkDNSHostnameQueryResults(java.util.List, boolean, int, boolean, java.util.List)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>checkDNSHostnameQueryResults</h4>
+<pre>public static&nbsp;void&nbsp;checkDNSHostnameQueryResults(java.util.List&lt;<a href="../../../../../org/apache/pirk/schema/response/QueryResponseJSON.html" title="class in org.apache.pirk.schema.response">QueryResponseJSON</a>&gt;&nbsp;results,
+                                boolean&nbsp;isDistributed,
+                                int&nbsp;numExpectedResults,
+                                boolean&nbsp;testFalsePositive,
+                                java.util.List&lt;org.json.simple.JSONObject&gt;&nbsp;dataElements)</pre>
+</li>
+</ul>
 <a name="testDNSIPQuery(java.util.ArrayList, int)">
 <!--   -->
 </a>
diff --git a/docs/org/apache/pirk/test/utils/Inputs.html b/docs/org/apache/pirk/test/utils/Inputs.html
index ef17f3d..bd389f7 100644
--- a/docs/org/apache/pirk/test/utils/Inputs.html
+++ b/docs/org/apache/pirk/test/utils/Inputs.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Inputs</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/StandaloneQuery.html b/docs/org/apache/pirk/test/utils/StandaloneQuery.html
index 5f9b74d..32c9d51 100644
--- a/docs/org/apache/pirk/test/utils/StandaloneQuery.html
+++ b/docs/org/apache/pirk/test/utils/StandaloneQuery.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>StandaloneQuery</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/TestUtils.html b/docs/org/apache/pirk/test/utils/TestUtils.html
index e0a2fce..b5f6ecc 100644
--- a/docs/org/apache/pirk/test/utils/TestUtils.html
+++ b/docs/org/apache/pirk/test/utils/TestUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>TestUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/class-use/BaseTests.html b/docs/org/apache/pirk/test/utils/class-use/BaseTests.html
index 0e015bd..f0521a3 100644
--- a/docs/org/apache/pirk/test/utils/class-use/BaseTests.html
+++ b/docs/org/apache/pirk/test/utils/class-use/BaseTests.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.test.utils.BaseTests</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/class-use/Inputs.html b/docs/org/apache/pirk/test/utils/class-use/Inputs.html
index 8b0515c..fa91877 100644
--- a/docs/org/apache/pirk/test/utils/class-use/Inputs.html
+++ b/docs/org/apache/pirk/test/utils/class-use/Inputs.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.test.utils.Inputs</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/class-use/StandaloneQuery.html b/docs/org/apache/pirk/test/utils/class-use/StandaloneQuery.html
index 3d3620b..e4126e1 100644
--- a/docs/org/apache/pirk/test/utils/class-use/StandaloneQuery.html
+++ b/docs/org/apache/pirk/test/utils/class-use/StandaloneQuery.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.test.utils.StandaloneQuery</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/class-use/TestUtils.html b/docs/org/apache/pirk/test/utils/class-use/TestUtils.html
index 0cf4870..6340663 100644
--- a/docs/org/apache/pirk/test/utils/class-use/TestUtils.html
+++ b/docs/org/apache/pirk/test/utils/class-use/TestUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.test.utils.TestUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/package-frame.html b/docs/org/apache/pirk/test/utils/package-frame.html
index ee35f26..21aa7c2 100644
--- a/docs/org/apache/pirk/test/utils/package-frame.html
+++ b/docs/org/apache/pirk/test/utils/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.utils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/package-summary.html b/docs/org/apache/pirk/test/utils/package-summary.html
index 0d06146..6507a78 100644
--- a/docs/org/apache/pirk/test/utils/package-summary.html
+++ b/docs/org/apache/pirk/test/utils/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.utils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/package-tree.html b/docs/org/apache/pirk/test/utils/package-tree.html
index 43e62e6..b58ce47 100644
--- a/docs/org/apache/pirk/test/utils/package-tree.html
+++ b/docs/org/apache/pirk/test/utils/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.test.utils Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/test/utils/package-use.html b/docs/org/apache/pirk/test/utils/package-use.html
index 89c41f4..42fd957 100644
--- a/docs/org/apache/pirk/test/utils/package-use.html
+++ b/docs/org/apache/pirk/test/utils/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.test.utils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/CSVOutputUtils.html b/docs/org/apache/pirk/utils/CSVOutputUtils.html
index 82d2736..7c2ec56 100644
--- a/docs/org/apache/pirk/utils/CSVOutputUtils.html
+++ b/docs/org/apache/pirk/utils/CSVOutputUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>CSVOutputUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/EpochDateParser.html b/docs/org/apache/pirk/utils/EpochDateParser.html
index 14e9b54..b18a370 100644
--- a/docs/org/apache/pirk/utils/EpochDateParser.html
+++ b/docs/org/apache/pirk/utils/EpochDateParser.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>EpochDateParser</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/FileConst.html b/docs/org/apache/pirk/utils/FileConst.html
index 2317116..6944a7a 100644
--- a/docs/org/apache/pirk/utils/FileConst.html
+++ b/docs/org/apache/pirk/utils/FileConst.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>FileConst</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/FileIOUtils.Callable.html b/docs/org/apache/pirk/utils/FileIOUtils.Callable.html
index e0c904e..92da177 100644
--- a/docs/org/apache/pirk/utils/FileIOUtils.Callable.html
+++ b/docs/org/apache/pirk/utils/FileIOUtils.Callable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>FileIOUtils.Callable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/FileIOUtils.html b/docs/org/apache/pirk/utils/FileIOUtils.html
index 33da5a8..468c819 100644
--- a/docs/org/apache/pirk/utils/FileIOUtils.html
+++ b/docs/org/apache/pirk/utils/FileIOUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>FileIOUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/HDFS.html b/docs/org/apache/pirk/utils/HDFS.html
index dd0b6f7..a853976 100644
--- a/docs/org/apache/pirk/utils/HDFS.html
+++ b/docs/org/apache/pirk/utils/HDFS.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>HDFS</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/ISO8601DateParser.html b/docs/org/apache/pirk/utils/ISO8601DateParser.html
index 3409c6a..30148bd 100644
--- a/docs/org/apache/pirk/utils/ISO8601DateParser.html
+++ b/docs/org/apache/pirk/utils/ISO8601DateParser.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>ISO8601DateParser</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/KeyedHash.html b/docs/org/apache/pirk/utils/KeyedHash.html
index bf3ff77..4708b0e 100644
--- a/docs/org/apache/pirk/utils/KeyedHash.html
+++ b/docs/org/apache/pirk/utils/KeyedHash.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>KeyedHash</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/PIRException.html b/docs/org/apache/pirk/utils/PIRException.html
index cdad624..db494f4 100644
--- a/docs/org/apache/pirk/utils/PIRException.html
+++ b/docs/org/apache/pirk/utils/PIRException.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>PIRException</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/QueryParserUtils.html b/docs/org/apache/pirk/utils/QueryParserUtils.html
index ef3e459..d9714ee 100644
--- a/docs/org/apache/pirk/utils/QueryParserUtils.html
+++ b/docs/org/apache/pirk/utils/QueryParserUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QueryParserUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/QueryResultsWriter.html b/docs/org/apache/pirk/utils/QueryResultsWriter.html
index a137cab..f074d6c 100644
--- a/docs/org/apache/pirk/utils/QueryResultsWriter.html
+++ b/docs/org/apache/pirk/utils/QueryResultsWriter.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>QueryResultsWriter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/StopListUtils.html b/docs/org/apache/pirk/utils/StopListUtils.html
index 2288c4c..c914a26 100644
--- a/docs/org/apache/pirk/utils/StopListUtils.html
+++ b/docs/org/apache/pirk/utils/StopListUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>StopListUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/StringUtils.html b/docs/org/apache/pirk/utils/StringUtils.html
index f2efb35..04e715a 100644
--- a/docs/org/apache/pirk/utils/StringUtils.html
+++ b/docs/org/apache/pirk/utils/StringUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>StringUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/SystemConfiguration.html b/docs/org/apache/pirk/utils/SystemConfiguration.html
index a0d2568..8fd91ba 100644
--- a/docs/org/apache/pirk/utils/SystemConfiguration.html
+++ b/docs/org/apache/pirk/utils/SystemConfiguration.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:44 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:32 EDT 2016 -->
 <title>SystemConfiguration</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/CSVOutputUtils.html b/docs/org/apache/pirk/utils/class-use/CSVOutputUtils.html
index 706f043..b1542e8 100644
--- a/docs/org/apache/pirk/utils/class-use/CSVOutputUtils.html
+++ b/docs/org/apache/pirk/utils/class-use/CSVOutputUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.CSVOutputUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/EpochDateParser.html b/docs/org/apache/pirk/utils/class-use/EpochDateParser.html
index 3084976..77aa8e7 100644
--- a/docs/org/apache/pirk/utils/class-use/EpochDateParser.html
+++ b/docs/org/apache/pirk/utils/class-use/EpochDateParser.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.EpochDateParser</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/FileConst.html b/docs/org/apache/pirk/utils/class-use/FileConst.html
index 8ab7f4a..4571c42 100644
--- a/docs/org/apache/pirk/utils/class-use/FileConst.html
+++ b/docs/org/apache/pirk/utils/class-use/FileConst.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.FileConst</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/FileIOUtils.Callable.html b/docs/org/apache/pirk/utils/class-use/FileIOUtils.Callable.html
index 0600e7b..beed893 100644
--- a/docs/org/apache/pirk/utils/class-use/FileIOUtils.Callable.html
+++ b/docs/org/apache/pirk/utils/class-use/FileIOUtils.Callable.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Interface org.apache.pirk.utils.FileIOUtils.Callable</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/FileIOUtils.html b/docs/org/apache/pirk/utils/class-use/FileIOUtils.html
index ed59883..dbe0322 100644
--- a/docs/org/apache/pirk/utils/class-use/FileIOUtils.html
+++ b/docs/org/apache/pirk/utils/class-use/FileIOUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.FileIOUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/HDFS.html b/docs/org/apache/pirk/utils/class-use/HDFS.html
index 92022ae..d96a21e 100644
--- a/docs/org/apache/pirk/utils/class-use/HDFS.html
+++ b/docs/org/apache/pirk/utils/class-use/HDFS.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.HDFS</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/ISO8601DateParser.html b/docs/org/apache/pirk/utils/class-use/ISO8601DateParser.html
index 47d2341..bc9c32a 100644
--- a/docs/org/apache/pirk/utils/class-use/ISO8601DateParser.html
+++ b/docs/org/apache/pirk/utils/class-use/ISO8601DateParser.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.ISO8601DateParser</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/KeyedHash.html b/docs/org/apache/pirk/utils/class-use/KeyedHash.html
index b904b1a..cb49df3 100644
--- a/docs/org/apache/pirk/utils/class-use/KeyedHash.html
+++ b/docs/org/apache/pirk/utils/class-use/KeyedHash.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.KeyedHash</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/PIRException.html b/docs/org/apache/pirk/utils/class-use/PIRException.html
index 70200cb..1d9f51b 100644
--- a/docs/org/apache/pirk/utils/class-use/PIRException.html
+++ b/docs/org/apache/pirk/utils/class-use/PIRException.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.PIRException</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/QueryParserUtils.html b/docs/org/apache/pirk/utils/class-use/QueryParserUtils.html
index a78b8ae..196381e 100644
--- a/docs/org/apache/pirk/utils/class-use/QueryParserUtils.html
+++ b/docs/org/apache/pirk/utils/class-use/QueryParserUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.QueryParserUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/QueryResultsWriter.html b/docs/org/apache/pirk/utils/class-use/QueryResultsWriter.html
index 7bb4795..1debbb4 100644
--- a/docs/org/apache/pirk/utils/class-use/QueryResultsWriter.html
+++ b/docs/org/apache/pirk/utils/class-use/QueryResultsWriter.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.QueryResultsWriter</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/StopListUtils.html b/docs/org/apache/pirk/utils/class-use/StopListUtils.html
index 6bea1b0..ffdf2d7 100644
--- a/docs/org/apache/pirk/utils/class-use/StopListUtils.html
+++ b/docs/org/apache/pirk/utils/class-use/StopListUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.StopListUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/StringUtils.html b/docs/org/apache/pirk/utils/class-use/StringUtils.html
index 82a1d7b..565748d 100644
--- a/docs/org/apache/pirk/utils/class-use/StringUtils.html
+++ b/docs/org/apache/pirk/utils/class-use/StringUtils.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.StringUtils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/class-use/SystemConfiguration.html b/docs/org/apache/pirk/utils/class-use/SystemConfiguration.html
index a0575ca..402a6c5 100644
--- a/docs/org/apache/pirk/utils/class-use/SystemConfiguration.html
+++ b/docs/org/apache/pirk/utils/class-use/SystemConfiguration.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.utils.SystemConfiguration</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/package-frame.html b/docs/org/apache/pirk/utils/package-frame.html
index 63c8c6c..a7c36ca 100644
--- a/docs/org/apache/pirk/utils/package-frame.html
+++ b/docs/org/apache/pirk/utils/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.utils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/package-summary.html b/docs/org/apache/pirk/utils/package-summary.html
index a3458ea..ca98137 100644
--- a/docs/org/apache/pirk/utils/package-summary.html
+++ b/docs/org/apache/pirk/utils/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.utils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/package-tree.html b/docs/org/apache/pirk/utils/package-tree.html
index f504ee6..7967d09 100644
--- a/docs/org/apache/pirk/utils/package-tree.html
+++ b/docs/org/apache/pirk/utils/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.utils Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/utils/package-use.html b/docs/org/apache/pirk/utils/package-use.html
index 5011a15..b3e1e1c 100644
--- a/docs/org/apache/pirk/utils/package-use.html
+++ b/docs/org/apache/pirk/utils/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.utils</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/wideskies/standalone/StandaloneTest.html b/docs/org/apache/pirk/wideskies/standalone/StandaloneTest.html
index b9b90ba..bc94400 100644
--- a/docs/org/apache/pirk/wideskies/standalone/StandaloneTest.html
+++ b/docs/org/apache/pirk/wideskies/standalone/StandaloneTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>StandaloneTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/wideskies/standalone/class-use/StandaloneTest.html b/docs/org/apache/pirk/wideskies/standalone/class-use/StandaloneTest.html
index 6487b28..aafc920 100644
--- a/docs/org/apache/pirk/wideskies/standalone/class-use/StandaloneTest.html
+++ b/docs/org/apache/pirk/wideskies/standalone/class-use/StandaloneTest.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Class org.apache.pirk.wideskies.standalone.StandaloneTest</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/wideskies/standalone/package-frame.html b/docs/org/apache/pirk/wideskies/standalone/package-frame.html
index 9e77680..4b68b09 100644
--- a/docs/org/apache/pirk/wideskies/standalone/package-frame.html
+++ b/docs/org/apache/pirk/wideskies/standalone/package-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.wideskies.standalone</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/wideskies/standalone/package-summary.html b/docs/org/apache/pirk/wideskies/standalone/package-summary.html
index 5a7a279..ef7f7f3 100644
--- a/docs/org/apache/pirk/wideskies/standalone/package-summary.html
+++ b/docs/org/apache/pirk/wideskies/standalone/package-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.wideskies.standalone</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/wideskies/standalone/package-tree.html b/docs/org/apache/pirk/wideskies/standalone/package-tree.html
index 3569bfc..d092cb9 100644
--- a/docs/org/apache/pirk/wideskies/standalone/package-tree.html
+++ b/docs/org/apache/pirk/wideskies/standalone/package-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>org.apache.pirk.wideskies.standalone Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/org/apache/pirk/wideskies/standalone/package-use.html b/docs/org/apache/pirk/wideskies/standalone/package-use.html
index 78c25bb..45770d3 100644
--- a/docs/org/apache/pirk/wideskies/standalone/package-use.html
+++ b/docs/org/apache/pirk/wideskies/standalone/package-use.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Uses of Package org.apache.pirk.wideskies.standalone</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
diff --git a/docs/overview-frame.html b/docs/overview-frame.html
index c6d72ab..37f06ee 100644
--- a/docs/overview-frame.html
+++ b/docs/overview-frame.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Overview List</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
@@ -27,6 +27,7 @@
 <li><a href="org/apache/pirk/responder/wideskies/spark/package-frame.html" target="packageFrame">org.apache.pirk.responder.wideskies.spark</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/streaming/package-frame.html" target="packageFrame">org.apache.pirk.responder.wideskies.spark.streaming</a></li>
 <li><a href="org/apache/pirk/responder/wideskies/standalone/package-frame.html" target="packageFrame">org.apache.pirk.responder.wideskies.standalone</a></li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/package-frame.html" target="packageFrame">org.apache.pirk.responder.wideskies.storm</a></li>
 <li><a href="org/apache/pirk/response/wideskies/package-frame.html" target="packageFrame">org.apache.pirk.response.wideskies</a></li>
 <li><a href="org/apache/pirk/schema/data/package-frame.html" target="packageFrame">org.apache.pirk.schema.data</a></li>
 <li><a href="org/apache/pirk/schema/data/partitioner/package-frame.html" target="packageFrame">org.apache.pirk.schema.data.partitioner</a></li>
@@ -34,6 +35,7 @@
 <li><a href="org/apache/pirk/schema/query/filter/package-frame.html" target="packageFrame">org.apache.pirk.schema.query.filter</a></li>
 <li><a href="org/apache/pirk/schema/response/package-frame.html" target="packageFrame">org.apache.pirk.schema.response</a></li>
 <li><a href="org/apache/pirk/serialization/package-frame.html" target="packageFrame">org.apache.pirk.serialization</a></li>
+<li><a href="org/apache/pirk/storm/package-frame.html" target="packageFrame">org.apache.pirk.storm</a></li>
 <li><a href="org/apache/pirk/test/distributed/package-frame.html" target="packageFrame">org.apache.pirk.test.distributed</a></li>
 <li><a href="org/apache/pirk/test/distributed/testsuite/package-frame.html" target="packageFrame">org.apache.pirk.test.distributed.testsuite</a></li>
 <li><a href="org/apache/pirk/test/utils/package-frame.html" target="packageFrame">org.apache.pirk.test.utils</a></li>
diff --git a/docs/overview-summary.html b/docs/overview-summary.html
index f586f6e..d88976f 100644
--- a/docs/overview-summary.html
+++ b/docs/overview-summary.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:34 EDT 2016 -->
 <title>Overview</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
@@ -131,33 +131,41 @@
 <td class="colLast">&nbsp;</td>
 </tr>
 <tr class="rowColor">
+<td class="colFirst"><a href="org/apache/pirk/responder/wideskies/storm/package-summary.html">org.apache.pirk.responder.wideskies.storm</a></td>
+<td class="colLast">&nbsp;</td>
+</tr>
+<tr class="altColor">
 <td class="colFirst"><a href="org/apache/pirk/response/wideskies/package-summary.html">org.apache.pirk.response.wideskies</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><a href="org/apache/pirk/schema/data/package-summary.html">org.apache.pirk.schema.data</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><a href="org/apache/pirk/schema/data/partitioner/package-summary.html">org.apache.pirk.schema.data.partitioner</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><a href="org/apache/pirk/schema/query/package-summary.html">org.apache.pirk.schema.query</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><a href="org/apache/pirk/schema/query/filter/package-summary.html">org.apache.pirk.schema.query.filter</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><a href="org/apache/pirk/schema/response/package-summary.html">org.apache.pirk.schema.response</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><a href="org/apache/pirk/serialization/package-summary.html">org.apache.pirk.serialization</a></td>
 <td class="colLast">&nbsp;</td>
 </tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="org/apache/pirk/storm/package-summary.html">org.apache.pirk.storm</a></td>
+<td class="colLast">&nbsp;</td>
+</tr>
 <tr class="altColor">
 <td class="colFirst"><a href="org/apache/pirk/test/distributed/package-summary.html">org.apache.pirk.test.distributed</a></td>
 <td class="colLast">&nbsp;</td>
diff --git a/docs/overview-tree.html b/docs/overview-tree.html
index 5894134..1e92bdc 100644
--- a/docs/overview-tree.html
+++ b/docs/overview-tree.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:46 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Class Hierarchy</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
@@ -81,6 +81,7 @@
 <li><a href="org/apache/pirk/responder/wideskies/spark/package-tree.html">org.apache.pirk.responder.wideskies.spark</a>, </li>
 <li><a href="org/apache/pirk/responder/wideskies/spark/streaming/package-tree.html">org.apache.pirk.responder.wideskies.spark.streaming</a>, </li>
 <li><a href="org/apache/pirk/responder/wideskies/standalone/package-tree.html">org.apache.pirk.responder.wideskies.standalone</a>, </li>
+<li><a href="org/apache/pirk/responder/wideskies/storm/package-tree.html">org.apache.pirk.responder.wideskies.storm</a>, </li>
 <li><a href="org/apache/pirk/response/wideskies/package-tree.html">org.apache.pirk.response.wideskies</a>, </li>
 <li><a href="org/apache/pirk/schema/data/package-tree.html">org.apache.pirk.schema.data</a>, </li>
 <li><a href="org/apache/pirk/schema/data/partitioner/package-tree.html">org.apache.pirk.schema.data.partitioner</a>, </li>
@@ -88,6 +89,7 @@
 <li><a href="org/apache/pirk/schema/query/filter/package-tree.html">org.apache.pirk.schema.query.filter</a>, </li>
 <li><a href="org/apache/pirk/schema/response/package-tree.html">org.apache.pirk.schema.response</a>, </li>
 <li><a href="org/apache/pirk/serialization/package-tree.html">org.apache.pirk.serialization</a>, </li>
+<li><a href="org/apache/pirk/storm/package-tree.html">org.apache.pirk.storm</a>, </li>
 <li><a href="org/apache/pirk/test/distributed/package-tree.html">org.apache.pirk.test.distributed</a>, </li>
 <li><a href="org/apache/pirk/test/distributed/testsuite/package-tree.html">org.apache.pirk.test.distributed.testsuite</a>, </li>
 <li><a href="org/apache/pirk/test/utils/package-tree.html">org.apache.pirk.test.utils</a>, </li>
@@ -107,6 +109,22 @@
 <li type="circle">org.apache.pirk.inputformat.hadoop.<a href="org/apache/pirk/inputformat/hadoop/TextArrayWritable.html" title="class in org.apache.pirk.inputformat.hadoop"><span class="strong">TextArrayWritable</span></a></li>
 </ul>
 </li>
+<li type="circle">org.apache.storm.topology.base.BaseComponent (implements org.apache.storm.topology.IComponent)
+<ul>
+<li type="circle">org.apache.storm.topology.base.BaseBasicBolt (implements org.apache.storm.topology.IBasicBolt)
+<ul>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PartitionDataBolt</span></a></li>
+</ul>
+</li>
+<li type="circle">org.apache.storm.topology.base.BaseRichBolt (implements org.apache.storm.topology.IRichBolt)
+<ul>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">EncColMultBolt</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">EncRowCalcBolt</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">OutputBolt</span></a></li>
+</ul>
+</li>
+</ul>
+</li>
 <li type="circle">org.apache.pirk.test.utils.<a href="org/apache/pirk/test/utils/BaseTests.html" title="class in org.apache.pirk.test.utils"><span class="strong">BaseTests</span></a></li>
 <li type="circle">org.apache.pirk.benchmark.<a href="org/apache/pirk/benchmark/BenchmarkDriver.html" title="class in org.apache.pirk.benchmark"><span class="strong">BenchmarkDriver</span></a></li>
 <li type="circle">org.apache.pirk.responder.wideskies.spark.<a href="org/apache/pirk/responder/wideskies/spark/BroadcastVars.html" title="class in org.apache.pirk.responder.wideskies.spark"><span class="strong">BroadcastVars</span></a> (implements java.io.Serializable)</li>
@@ -164,6 +182,7 @@
 <li type="circle">org.apache.pirk.utils.<a href="org/apache/pirk/utils/ISO8601DateParser.html" title="class in org.apache.pirk.utils"><span class="strong">ISO8601DateParser</span></a></li>
 <li type="circle">org.apache.pirk.general.<a href="org/apache/pirk/general/ISO8601DateParserTest.html" title="class in org.apache.pirk.general"><span class="strong">ISO8601DateParserTest</span></a></li>
 <li type="circle">org.apache.pirk.schema.data.partitioner.<a href="org/apache/pirk/schema/data/partitioner/ISO8601DatePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner"><span class="strong">ISO8601DatePartitioner</span></a> (implements org.apache.pirk.schema.data.partitioner.<a href="org/apache/pirk/schema/data/partitioner/DataPartitioner.html" title="interface in org.apache.pirk.schema.data.partitioner">DataPartitioner</a>)</li>
+<li type="circle">org.apache.pirk.storm.<a href="org/apache/pirk/storm/KafkaStormIntegrationTest.html" title="class in org.apache.pirk.storm"><span class="strong">KafkaStormIntegrationTest</span></a></li>
 <li type="circle">org.apache.pirk.utils.<a href="org/apache/pirk/utils/KeyedHash.html" title="class in org.apache.pirk.utils"><span class="strong">KeyedHash</span></a></li>
 <li type="circle">org.apache.pirk.general.<a href="org/apache/pirk/general/KeyedHashTest.html" title="class in org.apache.pirk.general"><span class="strong">KeyedHashTest</span></a></li>
 <li type="circle">org.apache.pirk.schema.data.<a href="org/apache/pirk/schema/data/LoadDataSchemaTest.html" title="class in org.apache.pirk.schema.data"><span class="strong">LoadDataSchemaTest</span></a></li>
@@ -182,6 +201,7 @@
 <li type="circle">org.apache.pirk.benchmark.<a href="org/apache/pirk/benchmark/PaillierBenchmark.PaillierBenchmarkState.html" title="class in org.apache.pirk.benchmark"><span class="strong">PaillierBenchmark.PaillierBenchmarkState</span></a></li>
 <li type="circle">org.apache.pirk.general.<a href="org/apache/pirk/general/PaillierTest.html" title="class in org.apache.pirk.general"><span class="strong">PaillierTest</span></a></li>
 <li type="circle">org.apache.pirk.general.<a href="org/apache/pirk/general/PartitionUtilsTest.html" title="class in org.apache.pirk.general"><span class="strong">PartitionUtilsTest</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/PirkTopology.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PirkTopology</span></a></li>
 <li type="circle">org.apache.pirk.encryption.<a href="org/apache/pirk/encryption/PrimeGenerator.html" title="class in org.apache.pirk.encryption"><span class="strong">PrimeGenerator</span></a></li>
 <li type="circle">org.apache.pirk.schema.data.partitioner.<a href="org/apache/pirk/schema/data/partitioner/PrimitiveTypePartitioner.html" title="class in org.apache.pirk.schema.data.partitioner"><span class="strong">PrimitiveTypePartitioner</span></a> (implements org.apache.pirk.schema.data.partitioner.<a href="org/apache/pirk/schema/data/partitioner/DataPartitioner.html" title="interface in org.apache.pirk.schema.data.partitioner">DataPartitioner</a>)</li>
 <li type="circle">org.apache.pirk.querier.wideskies.<a href="org/apache/pirk/querier/wideskies/Querier.html" title="class in org.apache.pirk.querier.wideskies"><span class="strong">Querier</span></a> (implements java.io.Serializable, org.apache.pirk.serialization.<a href="org/apache/pirk/serialization/Storable.html" title="interface in org.apache.pirk.serialization">Storable</a>)</li>
@@ -228,8 +248,16 @@
 <li type="circle">org.apache.pirk.wideskies.standalone.<a href="org/apache/pirk/wideskies/standalone/StandaloneTest.html" title="class in org.apache.pirk.wideskies.standalone"><span class="strong">StandaloneTest</span></a></li>
 <li type="circle">org.apache.pirk.schema.query.filter.<a href="org/apache/pirk/schema/query/filter/StopListFilter.html" title="class in org.apache.pirk.schema.query.filter"><span class="strong">StopListFilter</span></a> (implements org.apache.pirk.schema.query.filter.<a href="org/apache/pirk/schema/query/filter/DataFilter.html" title="interface in org.apache.pirk.schema.query.filter">DataFilter</a>)</li>
 <li type="circle">org.apache.pirk.utils.<a href="org/apache/pirk/utils/StopListUtils.html" title="class in org.apache.pirk.utils"><span class="strong">StopListUtils</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/StormConstants.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">StormConstants</span></a></li>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/StormUtils.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">StormUtils</span></a></li>
+<li type="circle">org.apache.storm.kafka.StringScheme (implements org.apache.storm.spout.Scheme)
+<ul>
+<li type="circle">org.apache.pirk.responder.wideskies.storm.<a href="org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm"><span class="strong">PirkHashScheme</span></a> (implements org.apache.storm.spout.Scheme)</li>
+</ul>
+</li>
 <li type="circle">org.apache.pirk.utils.<a href="org/apache/pirk/utils/StringUtils.html" title="class in org.apache.pirk.utils"><span class="strong">StringUtils</span></a></li>
 <li type="circle">org.apache.pirk.utils.<a href="org/apache/pirk/utils/SystemConfiguration.html" title="class in org.apache.pirk.utils"><span class="strong">SystemConfiguration</span></a></li>
+<li type="circle">org.apache.pirk.storm.<a href="org/apache/pirk/storm/SystemTime.html" title="class in org.apache.pirk.storm"><span class="strong">SystemTime</span></a> (implements kafka.utils.Time)</li>
 <li type="circle">org.apache.pirk.test.utils.<a href="org/apache/pirk/test/utils/TestUtils.html" title="class in org.apache.pirk.test.utils"><span class="strong">TestUtils</span></a></li>
 <li type="circle">java.lang.Throwable (implements java.io.Serializable)
 <ul>
diff --git a/docs/package-list b/docs/package-list
index d803e59..92eb193 100644
--- a/docs/package-list
+++ b/docs/package-list
@@ -13,6 +13,7 @@
 org.apache.pirk.responder.wideskies.spark
 org.apache.pirk.responder.wideskies.spark.streaming
 org.apache.pirk.responder.wideskies.standalone
+org.apache.pirk.responder.wideskies.storm
 org.apache.pirk.response.wideskies
 org.apache.pirk.schema.data
 org.apache.pirk.schema.data.partitioner
@@ -20,6 +21,7 @@
 org.apache.pirk.schema.query.filter
 org.apache.pirk.schema.response
 org.apache.pirk.serialization
+org.apache.pirk.storm
 org.apache.pirk.test.distributed
 org.apache.pirk.test.distributed.testsuite
 org.apache.pirk.test.utils
diff --git a/docs/serialized-form.html b/docs/serialized-form.html
index 6620279..37ff7e7 100644
--- a/docs/serialized-form.html
+++ b/docs/serialized-form.html
@@ -2,7 +2,7 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:50:45 EDT 2016 -->
+<!-- Generated by javadoc (version 1.7.0_80) on Tue Aug 30 09:57:33 EDT 2016 -->
 <title>Serialized Form</title>
 <meta name="date" content="2016-08-30">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
@@ -652,6 +652,289 @@
 </ul>
 </li>
 <li class="blockList">
+<h2 title="Package">Package&nbsp;org.apache.pirk.responder.wideskies.storm</h2>
+<ul class="blockList">
+<li class="blockList"><a name="org.apache.pirk.responder.wideskies.storm.EncColMultBolt">
+<!--   -->
+</a>
+<h3>Class <a href="org/apache/pirk/responder/wideskies/storm/EncColMultBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">org.apache.pirk.responder.wideskies.storm.EncColMultBolt</a> extends org.apache.storm.topology.base.BaseRichBolt implements Serializable</h3>
+<dl class="nameValue">
+<dt>serialVersionUID:</dt>
+<dd>1L</dd>
+</dl>
+<ul class="blockList">
+<li class="blockList"><a name="serializedForm">
+<!--   -->
+</a>
+<h3>Serialized Fields</h3>
+<ul class="blockList">
+<li class="blockList">
+<h4>outputCollector</h4>
+<pre>org.apache.storm.task.OutputCollector outputCollector</pre>
+</li>
+<li class="blockList">
+<h4>nSquared</h4>
+<pre>java.math.BigInteger nSquared</pre>
+</li>
+<li class="blockList">
+<h4>numFlushSignals</h4>
+<pre>long numFlushSignals</pre>
+</li>
+<li class="blockList">
+<h4>totalFlushSignals</h4>
+<pre>java.lang.Long totalFlushSignals</pre>
+</li>
+<li class="blockList">
+<h4>resultsMap</h4>
+<pre>java.util.Map&lt;K,V&gt; resultsMap</pre>
+</li>
+<li class="blockList">
+<h4>colVal1</h4>
+<pre>java.math.BigInteger colVal1</pre>
+</li>
+<li class="blockListLast">
+<h4>colMult</h4>
+<pre>java.math.BigInteger colMult</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="blockList"><a name="org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt">
+<!--   -->
+</a>
+<h3>Class <a href="org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">org.apache.pirk.responder.wideskies.storm.EncRowCalcBolt</a> extends org.apache.storm.topology.base.BaseRichBolt implements Serializable</h3>
+<dl class="nameValue">
+<dt>serialVersionUID:</dt>
+<dd>1L</dd>
+</dl>
+<ul class="blockList">
+<li class="blockList"><a name="serializedForm">
+<!--   -->
+</a>
+<h3>Serialized Fields</h3>
+<ul class="blockList">
+<li class="blockList">
+<h4>outputCollector</h4>
+<pre>org.apache.storm.task.OutputCollector outputCollector</pre>
+</li>
+<li class="blockList">
+<h4>limitHitsPerSelector</h4>
+<pre>java.lang.Boolean limitHitsPerSelector</pre>
+</li>
+<li class="blockList">
+<h4>maxHitsPerSelector</h4>
+<pre>java.lang.Long maxHitsPerSelector</pre>
+</li>
+<li class="blockList">
+<h4>totalEndSigs</h4>
+<pre>java.lang.Long totalEndSigs</pre>
+</li>
+<li class="blockList">
+<h4>rowDivisions</h4>
+<pre>int rowDivisions</pre>
+</li>
+<li class="blockList">
+<h4>saltColumns</h4>
+<pre>java.lang.Boolean saltColumns</pre>
+</li>
+<li class="blockList">
+<h4>splitPartitions</h4>
+<pre>java.lang.Boolean splitPartitions</pre>
+</li>
+<li class="blockList">
+<h4>rand</h4>
+<pre>java.util.Random rand</pre>
+</li>
+<li class="blockList">
+<h4>hitsByRow</h4>
+<pre>java.util.Map&lt;K,V&gt; hitsByRow</pre>
+</li>
+<li class="blockList">
+<h4>colIndexByRow</h4>
+<pre>java.util.Map&lt;K,V&gt; colIndexByRow</pre>
+</li>
+<li class="blockList">
+<h4>matrixElements</h4>
+<pre>java.util.List&lt;E&gt; matrixElements</pre>
+</li>
+<li class="blockList">
+<h4>dataArray</h4>
+<pre>java.util.List&lt;E&gt; dataArray</pre>
+</li>
+<li class="blockList">
+<h4>numEndSigs</h4>
+<pre>int numEndSigs</pre>
+</li>
+<li class="blockList">
+<h4>buffering</h4>
+<pre>boolean buffering</pre>
+</li>
+<li class="blockListLast">
+<h4>bufferedValues</h4>
+<pre>java.util.List&lt;E&gt; bufferedValues</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="blockList"><a name="org.apache.pirk.responder.wideskies.storm.OutputBolt">
+<!--   -->
+</a>
+<h3>Class <a href="org/apache/pirk/responder/wideskies/storm/OutputBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">org.apache.pirk.responder.wideskies.storm.OutputBolt</a> extends org.apache.storm.topology.base.BaseRichBolt implements Serializable</h3>
+<dl class="nameValue">
+<dt>serialVersionUID:</dt>
+<dd>1L</dd>
+</dl>
+<ul class="blockList">
+<li class="blockList"><a name="serializedForm">
+<!--   -->
+</a>
+<h3>Serialized Fields</h3>
+<ul class="blockList">
+<li class="blockList">
+<h4>outputCollector</h4>
+<pre>org.apache.storm.task.OutputCollector outputCollector</pre>
+</li>
+<li class="blockList">
+<h4>queryInfo</h4>
+<pre><a href="org/apache/pirk/query/wideskies/QueryInfo.html" title="class in org.apache.pirk.query.wideskies">QueryInfo</a> queryInfo</pre>
+</li>
+<li class="blockList">
+<h4>response</h4>
+<pre><a href="org/apache/pirk/response/wideskies/Response.html" title="class in org.apache.pirk.response.wideskies">Response</a> response</pre>
+</li>
+<li class="blockList">
+<h4>outputFile</h4>
+<pre>java.lang.String outputFile</pre>
+</li>
+<li class="blockList">
+<h4>hdfs</h4>
+<pre>boolean hdfs</pre>
+</li>
+<li class="blockList">
+<h4>hdfsUri</h4>
+<pre>java.lang.String hdfsUri</pre>
+</li>
+<li class="blockList">
+<h4>flushCounter</h4>
+<pre>java.lang.Integer flushCounter</pre>
+</li>
+<li class="blockList">
+<h4>tuplesToAck</h4>
+<pre>java.util.List&lt;E&gt; tuplesToAck</pre>
+</li>
+<li class="blockList">
+<h4>totalFlushSigs</h4>
+<pre>java.lang.Integer totalFlushSigs</pre>
+</li>
+<li class="blockList">
+<h4>localStore</h4>
+<pre><a href="org/apache/pirk/serialization/LocalFileSystemStore.html" title="class in org.apache.pirk.serialization">LocalFileSystemStore</a> localStore</pre>
+</li>
+<li class="blockList">
+<h4>hadoopStore</h4>
+<pre><a href="org/apache/pirk/serialization/HadoopFileSystemStore.html" title="class in org.apache.pirk.serialization">HadoopFileSystemStore</a> hadoopStore</pre>
+</li>
+<li class="blockList">
+<h4>resultsMap</h4>
+<pre>java.util.Map&lt;K,V&gt; resultsMap</pre>
+</li>
+<li class="blockList">
+<h4>colVal</h4>
+<pre>java.math.BigInteger colVal</pre>
+</li>
+<li class="blockList">
+<h4>colMult</h4>
+<pre>java.math.BigInteger colMult</pre>
+</li>
+<li class="blockListLast">
+<h4>nSquared</h4>
+<pre>java.math.BigInteger nSquared</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="blockList"><a name="org.apache.pirk.responder.wideskies.storm.PartitionDataBolt">
+<!--   -->
+</a>
+<h3>Class <a href="org/apache/pirk/responder/wideskies/storm/PartitionDataBolt.html" title="class in org.apache.pirk.responder.wideskies.storm">org.apache.pirk.responder.wideskies.storm.PartitionDataBolt</a> extends org.apache.storm.topology.base.BaseBasicBolt implements Serializable</h3>
+<dl class="nameValue">
+<dt>serialVersionUID:</dt>
+<dd>1L</dd>
+</dl>
+<ul class="blockList">
+<li class="blockList"><a name="serializedForm">
+<!--   -->
+</a>
+<h3>Serialized Fields</h3>
+<ul class="blockList">
+<li class="blockList">
+<h4>queryInfo</h4>
+<pre><a href="org/apache/pirk/query/wideskies/QueryInfo.html" title="class in org.apache.pirk.query.wideskies">QueryInfo</a> queryInfo</pre>
+</li>
+<li class="blockList">
+<h4>queryType</h4>
+<pre>java.lang.String queryType</pre>
+</li>
+<li class="blockList">
+<h4>qSchema</h4>
+<pre><a href="org/apache/pirk/schema/query/QuerySchema.html" title="class in org.apache.pirk.schema.query">QuerySchema</a> qSchema</pre>
+</li>
+<li class="blockList">
+<h4>embedSelector</h4>
+<pre>boolean embedSelector</pre>
+</li>
+<li class="blockList">
+<h4>splitPartitions</h4>
+<pre>boolean splitPartitions</pre>
+</li>
+<li class="blockList">
+<h4>json</h4>
+<pre>org.json.simple.JSONObject json</pre>
+</li>
+<li class="blockListLast">
+<h4>partitions</h4>
+<pre>java.util.List&lt;E&gt; partitions</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="blockList"><a name="org.apache.pirk.responder.wideskies.storm.PirkHashScheme">
+<!--   -->
+</a>
+<h3>Class <a href="org/apache/pirk/responder/wideskies/storm/PirkHashScheme.html" title="class in org.apache.pirk.responder.wideskies.storm">org.apache.pirk.responder.wideskies.storm.PirkHashScheme</a> extends org.apache.storm.kafka.StringScheme implements Serializable</h3>
+<ul class="blockList">
+<li class="blockList"><a name="serializedForm">
+<!--   -->
+</a>
+<h3>Serialized Fields</h3>
+<ul class="blockList">
+<li class="blockList">
+<h4>queryInfo</h4>
+<pre><a href="org/apache/pirk/query/wideskies/QueryInfo.html" title="class in org.apache.pirk.query.wideskies">QueryInfo</a> queryInfo</pre>
+</li>
+<li class="blockList">
+<h4>initialized</h4>
+<pre>boolean initialized</pre>
+</li>
+<li class="blockList">
+<h4>qSchema</h4>
+<pre><a href="org/apache/pirk/schema/query/QuerySchema.html" title="class in org.apache.pirk.schema.query">QuerySchema</a> qSchema</pre>
+</li>
+<li class="blockListLast">
+<h4>conf</h4>
+<pre>org.apache.storm.Config conf</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="blockList">
 <h2 title="Package">Package&nbsp;org.apache.pirk.response.wideskies</h2>
 <ul class="blockList">
 <li class="blockList"><a name="org.apache.pirk.response.wideskies.Response">
diff --git a/src/main/java/org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.java b/src/main/java/org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.java
index eae288f..dfa61ac 100644
--- a/src/main/java/org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.java
+++ b/src/main/java/org/apache/pirk/querier/wideskies/decrypt/DecryptResponse.java
@@ -89,7 +89,7 @@
   public Map<String,List<QueryResponseJSON>> decrypt(int numThreads) throws InterruptedException, PIRException
   {
     Map<String,List<QueryResponseJSON>> resultMap = new HashMap<>(); // selector -> ArrayList of hits
-    
+
     QueryInfo queryInfo = response.getQueryInfo();
 
     Paillier paillier = querier.getPaillier();
@@ -161,10 +161,10 @@
     }
 
     es.shutdown();
-    
+
     return resultMap;
   }
-  
+
   // Method to perform basic decryption of each raw response element - does not
   // extract and reconstruct the data elements
   private List<BigInteger> decryptElements(TreeMap<Integer,BigInteger> elements, Paillier paillier)
diff --git a/src/main/java/org/apache/pirk/responder/wideskies/ResponderProps.java b/src/main/java/org/apache/pirk/responder/wideskies/ResponderProps.java
index f5d24d7..55846fd 100644
--- a/src/main/java/org/apache/pirk/responder/wideskies/ResponderProps.java
+++ b/src/main/java/org/apache/pirk/responder/wideskies/ResponderProps.java
@@ -108,15 +108,15 @@
   static final String STORMSALTCOLUMNS = "storm.saltColumns";
   static final String STORMNUMROWDIVS = "storm.rowDivs";
 
-  static final String[] STORMPROPS = new String[]{HDFSURI, USEHDFS, KAFKATOPIC, KAFKACLIENTID, KAFKAZK, KAFKAFORCEFROMSTART, STORMTOPONAME, STORMWORKERS,
+  static final String[] STORMPROPS = new String[] {HDFSURI, USEHDFS, KAFKATOPIC, KAFKACLIENTID, KAFKAZK, KAFKAFORCEFROMSTART, STORMTOPONAME, STORMWORKERS,
       STORMNUMACKERS, STORMRECEIVEBUFFERS, STORMSENDBUFFERS, STORMTRANSFERBUFFERS, STORMMAXSPOUTPENDING, STORMHEAPMEMORY, STORMCHILDOPTS, STORMMAXWORKERHEAP,
-      STORMCOMPONENTONHEAP, STORMSPOUTPAR, STORMPARTITIONDATABOLTPAR, STORMENCROWCALCBOLTPAR, STORMENCCOLMULTBOLTPAR, STORMFLUSHFREQUENCY, STORMSPLITPARTITIONS,
-      STORMSALTCOLUMNS, STORMNUMROWDIVS};
+      STORMCOMPONENTONHEAP, STORMSPOUTPAR, STORMPARTITIONDATABOLTPAR, STORMENCROWCALCBOLTPAR, STORMENCCOLMULTBOLTPAR, STORMFLUSHFREQUENCY,
+      STORMSPLITPARTITIONS, STORMSALTCOLUMNS, STORMNUMROWDIVS};
 
-  static final List<String> PROPSLIST = Arrays.asList((String[]) ArrayUtils.addAll(new String[]{PLATFORM, QUERYINPUT, DATAINPUTFORMAT, INPUTDATA, BASEQUERY, ESRESOURCE, ESQUERY, OUTPUTFILE,
-      BASEINPUTFORMAT, STOPLISTFILE, NUMREDUCETASKS, USELOCALCACHE, LIMITHITSPERSELECTOR, MAXHITSPERSELECTOR, MAPMEMORY, REDUCEMEMORY, MAPJAVAOPTS,
-      REDUCEJAVAOPTS, QUERYSCHEMAS, DATASCHEMAS, NUMEXPLOOKUPPARTS, USEHDFSLOOKUPTABLE, NUMDATAPARTITIONS, NUMCOLMULTPARTITIONS, USEMODEXPJOIN,
-      COLMULTREDUCEBYKEY, ALLOWEMBEDDEDQUERYSCHEMAS, BATCHSECONDS, WINDOWLENGTH, USEQUEUESTREAM, MAXBATCHES, STOPGRACEFULLY}, STORMPROPS));
+  static final List<String> PROPSLIST = Arrays.asList((String[]) ArrayUtils.addAll(new String[] {PLATFORM, QUERYINPUT, DATAINPUTFORMAT, INPUTDATA, BASEQUERY,
+      ESRESOURCE, ESQUERY, OUTPUTFILE, BASEINPUTFORMAT, STOPLISTFILE, NUMREDUCETASKS, USELOCALCACHE, LIMITHITSPERSELECTOR, MAXHITSPERSELECTOR, MAPMEMORY,
+      REDUCEMEMORY, MAPJAVAOPTS, REDUCEJAVAOPTS, QUERYSCHEMAS, DATASCHEMAS, NUMEXPLOOKUPPARTS, USEHDFSLOOKUPTABLE, NUMDATAPARTITIONS, NUMCOLMULTPARTITIONS,
+      USEMODEXPJOIN, COLMULTREDUCEBYKEY, ALLOWEMBEDDEDQUERYSCHEMAS, BATCHSECONDS, WINDOWLENGTH, USEQUEUESTREAM, MAXBATCHES, STOPGRACEFULLY}, STORMPROPS));
 
   /**
    * Validates the responder properties
@@ -135,7 +135,8 @@
     }
 
     String platform = SystemConfiguration.getProperty(PLATFORM).toLowerCase();
-    if (!platform.equals("mapreduce") && !platform.equals("spark") && !platform.equals("sparkstreaming") && !platform.equals("storm") && !platform.equals("standalone"))
+    if (!platform.equals("mapreduce") && !platform.equals("spark") && !platform.equals("sparkstreaming") && !platform.equals("storm")
+        && !platform.equals("standalone"))
     {
       logger.info("Unsupported platform: " + platform);
       valid = false;
diff --git a/src/main/java/org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.java b/src/main/java/org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.java
index 0050e29..0065094 100644
--- a/src/main/java/org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.java
+++ b/src/main/java/org/apache/pirk/responder/wideskies/common/ComputeEncryptedRow.java
@@ -140,8 +140,8 @@
         {
           e.printStackTrace();
         }
-        logger.debug("rowIndex = {} colCounter = {} part = {} part binary = {} exp = {} i = {} partition = {} = {}",
-            rowIndex, colCounter, part.toString(), part.toString(2), exp, i, dataPartitions.getBigInteger(i), dataPartitions.getBigInteger(i).toString(2));
+        logger.debug("rowIndex = {} colCounter = {} part = {} part binary = {} exp = {} i = {} partition = {} = {}", rowIndex, colCounter, part.toString(),
+            part.toString(2), exp, i, dataPartitions.getBigInteger(i), dataPartitions.getBigInteger(i).toString(2));
 
         returnPairs.add(new Tuple2<>(colCounter, exp));
 
@@ -206,8 +206,8 @@
           e.printStackTrace();
         }
 
-        logger.debug("rowIndex = {} colCounter = {} part = {} part binary = {} exp = {} i = {}",
-            rowIndex, colCounter, part.toString(), part.toString(2), exp, i);
+        logger.debug("rowIndex = {} colCounter = {} part = {} part binary = {} exp = {} i = {}", rowIndex, colCounter, part.toString(), part.toString(2), exp,
+            i);
 
         returnPairs.add(new Tuple2<>(colCounter, exp));
 
@@ -306,8 +306,8 @@
         e.printStackTrace();
       }
 
-      logger.debug("rowIndex = {} colCounter = {} part = {} part binary = {} exp = {} i = {} partition = {} = {}",
-          rowIndex, colCounter, part.toString(), part.toString(2), exp, i, dataPartitions.getBigInteger(i), dataPartitions.getBigInteger(i).toString(2));
+      logger.debug("rowIndex = {} colCounter = {} part = {} part binary = {} exp = {} i = {} partition = {} = {}", rowIndex, colCounter, part.toString(),
+          part.toString(2), exp, i, dataPartitions.getBigInteger(i), dataPartitions.getBigInteger(i).toString(2));
 
       returnPairs.add(new Tuple2<>(colCounter, exp));
 
@@ -328,8 +328,7 @@
    * <p>
    * Emits {@code Tuple2<<colNum, colVal>>}
    */
-  public static List<Tuple2<Long,BigInteger>> computeEncRow(List<BigInteger> dataPartitions, Query query, int rowIndex, int colIndex)
-      throws IOException
+  public static List<Tuple2<Long,BigInteger>> computeEncRow(List<BigInteger> dataPartitions, Query query, int rowIndex, int colIndex) throws IOException
   {
     List<Tuple2<Long,BigInteger>> returnPairs = new ArrayList<>();
 
@@ -356,8 +355,8 @@
         break;
       }
 
-      logger.debug("rowIndex = {} colCounter = {} part = {} part binary = {} exp = {} i = {} partition = {} = {}",
-          rowIndex, colCounter, part.toString(), part.toString(2), exp, i, dataPartitions.get(i), dataPartitions.get(i).toString(2));
+      logger.debug("rowIndex = {} colCounter = {} part = {} part binary = {} exp = {} i = {} partition = {} = {}", rowIndex, colCounter, part.toString(),
+          part.toString(2), exp, i, dataPartitions.get(i), dataPartitions.get(i).toString(2));
 
       returnPairs.add(new Tuple2<Long,BigInteger>(colCounter, exp));
 
diff --git a/src/main/java/org/apache/pirk/responder/wideskies/storm/EncColMultBolt.java b/src/main/java/org/apache/pirk/responder/wideskies/storm/EncColMultBolt.java
index 08c9917..8831e4e 100644
--- a/src/main/java/org/apache/pirk/responder/wideskies/storm/EncColMultBolt.java
+++ b/src/main/java/org/apache/pirk/responder/wideskies/storm/EncColMultBolt.java
@@ -40,8 +40,8 @@
  * EncRowCalcBolts send flush signals to the EncColMultBolts indicating that they have finished sending all tuples for a session. Whenever a flush signal is
  * received from a EncRowCalcBolt, the num of received flush signals is tallied until each EncRowCalcBolt has emitted a flush signal.
  * <p>
- * Once a flush signal has been received from each EncRowCalcBolt, all {@code <columnIndex, aggregate colVal product>} tuples are sent to the OutputBolt and a session_end
- * signal is sent back to each EncRowMultBolt.
+ * Once a flush signal has been received from each EncRowCalcBolt, all {@code <columnIndex, aggregate colVal product>} tuples are sent to the OutputBolt and a
+ * session_end signal is sent back to each EncRowMultBolt.
  * <p>
  * The EncRowMultBolts buffer their output from the time that they send a flush signal to the EncColMultBolts until the time that they receive a session_end
  * signal from all of the EncColMultBolts.
@@ -123,8 +123,8 @@
   @Override
   public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer)
   {
-    outputFieldsDeclarer.declareStream(StormConstants.ENCCOLMULTBOLT_ID,
-        new Fields(StormConstants.COLUMN_INDEX_ECM_FIELD, StormConstants.COLUMN_PRODUCT_FIELD));
+    outputFieldsDeclarer
+        .declareStream(StormConstants.ENCCOLMULTBOLT_ID, new Fields(StormConstants.COLUMN_INDEX_ECM_FIELD, StormConstants.COLUMN_PRODUCT_FIELD));
     outputFieldsDeclarer.declareStream(StormConstants.ENCCOLMULTBOLT_SESSION_END, new Fields("finished"));
   }
 }
diff --git a/src/main/java/org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.java b/src/main/java/org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.java
index 639a52b..324fbf1 100644
--- a/src/main/java/org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.java
+++ b/src/main/java/org/apache/pirk/responder/wideskies/storm/EncRowCalcBolt.java
@@ -155,8 +155,8 @@
   @Override
   public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer)
   {
-    outputFieldsDeclarer.declareStream(StormConstants.ENCROWCALCBOLT_DATASTREAM_ID,
-        new Fields(StormConstants.COLUMN_INDEX_ERC_FIELD, StormConstants.ENCRYPTED_VALUE_FIELD, StormConstants.SALT));
+    outputFieldsDeclarer.declareStream(StormConstants.ENCROWCALCBOLT_DATASTREAM_ID, new Fields(StormConstants.COLUMN_INDEX_ERC_FIELD,
+        StormConstants.ENCRYPTED_VALUE_FIELD, StormConstants.SALT));
     outputFieldsDeclarer.declareStream(StormConstants.ENCROWCALCBOLT_FLUSH_SIG, new Fields(StormConstants.FLUSH));
   }
 
diff --git a/src/main/java/org/apache/pirk/responder/wideskies/storm/PirkTopology.java b/src/main/java/org/apache/pirk/responder/wideskies/storm/PirkTopology.java
index ddfca8b..6540ecc 100644
--- a/src/main/java/org/apache/pirk/responder/wideskies/storm/PirkTopology.java
+++ b/src/main/java/org/apache/pirk/responder/wideskies/storm/PirkTopology.java
@@ -120,7 +120,8 @@
     // b2.setMemoryLoad(5000);
     // b2.setCPULoad(150.0);
 
-    BoltDeclarer b3 = builder.setBolt(StormConstants.ENCCOLMULTBOLT_ID, ecmbolt, enccolmultboltParallelism)
+    BoltDeclarer b3 = builder
+        .setBolt(StormConstants.ENCCOLMULTBOLT_ID, ecmbolt, enccolmultboltParallelism)
         .fieldsGrouping(StormConstants.ENCROWCALCBOLT_ID, StormConstants.ENCROWCALCBOLT_DATASTREAM_ID,
             new Fields(StormConstants.COLUMN_INDEX_ERC_FIELD, StormConstants.SALT))
         .allGrouping(StormConstants.ENCROWCALCBOLT_ID, StormConstants.ENCROWCALCBOLT_FLUSH_SIG);
diff --git a/src/main/java/org/apache/pirk/test/utils/BaseTests.java b/src/main/java/org/apache/pirk/test/utils/BaseTests.java
index b0c9326..7536d8f 100644
--- a/src/main/java/org/apache/pirk/test/utils/BaseTests.java
+++ b/src/main/java/org/apache/pirk/test/utils/BaseTests.java
@@ -95,8 +95,8 @@
     logger.info("Completed testDNSHostnameQuery(): ");
   }
 
-  public static void checkDNSHostnameQueryResults(List<QueryResponseJSON> results, boolean isDistributed, int numExpectedResults,
-      boolean testFalsePositive, List<JSONObject> dataElements)
+  public static void checkDNSHostnameQueryResults(List<QueryResponseJSON> results, boolean isDistributed, int numExpectedResults, boolean testFalsePositive,
+      List<JSONObject> dataElements)
   {
     QuerySchema qSchema = QuerySchemaRegistry.get(Inputs.DNS_HOSTNAME_QUERY);
     logger.info("results:");
diff --git a/src/main/java/org/apache/pirk/test/utils/TestUtils.java b/src/main/java/org/apache/pirk/test/utils/TestUtils.java
index 6573a12..be01fb4 100644
--- a/src/main/java/org/apache/pirk/test/utils/TestUtils.java
+++ b/src/main/java/org/apache/pirk/test/utils/TestUtils.java
@@ -268,8 +268,9 @@
 
   /**
    * Converts the result file into an ArrayList of QueryResponseJSON objects
-   * @throws IOException 
-   * @throws FileNotFoundException 
+   * 
+   * @throws IOException
+   * @throws FileNotFoundException
    */
   public static List<QueryResponseJSON> readResultsFile(File file) throws FileNotFoundException, IOException
   {
diff --git a/src/main/java/org/apache/pirk/utils/QueryResultsWriter.java b/src/main/java/org/apache/pirk/utils/QueryResultsWriter.java
index 65470e4..2d37e6b 100644
--- a/src/main/java/org/apache/pirk/utils/QueryResultsWriter.java
+++ b/src/main/java/org/apache/pirk/utils/QueryResultsWriter.java
@@ -31,7 +31,6 @@
 public class QueryResultsWriter
 {
 
-
   /**
    * Writes elements of the resultMap to output file, one line for each element, where each line is a string representation of the corresponding
    * QueryResponseJSON object
diff --git a/src/test/java/org/apache/pirk/storm/KafkaStormIntegrationTest.java b/src/test/java/org/apache/pirk/storm/KafkaStormIntegrationTest.java
index 906c337..fc4e703 100644
--- a/src/test/java/org/apache/pirk/storm/KafkaStormIntegrationTest.java
+++ b/src/test/java/org/apache/pirk/storm/KafkaStormIntegrationTest.java
@@ -125,7 +125,6 @@
     KafkaProducer producer = new KafkaProducer<String,String>(createKafkaProducerConfig());
     loadTestData(producer);
 
-
     logger.info("Test (splitPartitions,saltColumns) = (true,true)");
     SystemConfiguration.setProperty("storm.splitPartitions", "true");
     SystemConfiguration.setProperty("storm.saltColumns", "true");
@@ -196,14 +195,15 @@
       {
         iLocalCluster.submitTopology("pirk_integration_test", config, topology);
         logger.info("Pausing for setup.");
-        //Thread.sleep(4000);
-        //KafkaProducer producer = new KafkaProducer<String,String>(createKafkaProducerConfig());
-        //loadTestData(producer);
-        //Thread.sleep(10000);
-        while(OutputBolt.latch.getCount() == testCountDown){
+        // Thread.sleep(4000);
+        // KafkaProducer producer = new KafkaProducer<String,String>(createKafkaProducerConfig());
+        // loadTestData(producer);
+        // Thread.sleep(10000);
+        while (OutputBolt.latch.getCount() == testCountDown)
+        {
           Thread.sleep(1000);
         }
-        testCountDown -=1;
+        testCountDown -= 1;
 
         logger.info("Finished...");
       }
@@ -248,7 +248,7 @@
 
     zkClient = new ZkClient(zookeeperLocalCluster.getConnectString(), 60000, 60000, ZKStringSerializer$.MODULE$);
     ZkUtils zkUtils = new ZkUtils(zkClient, new ZkConnection(zookeeperLocalCluster.getConnectString()), false);
-    //ZkUtils zkUtils = ZkUtils.apply(zookeeperLocalCluster.getConnectString(), 60000, 60000, false);
+    // ZkUtils zkUtils = ZkUtils.apply(zookeeperLocalCluster.getConnectString(), 60000, 60000, false);
     AdminUtils.createTopic(zkUtils, topic, 1, 1, new Properties());
   }
 
