diff --git a/eland/dataframe.py b/eland/dataframe.py
index 524467a..53649b8 100644
--- a/eland/dataframe.py
+++ b/eland/dataframe.py
@@ -469,4 +469,53 @@ class DataFrame(NDFrame):
     def keys(self):
         return self.columns
 
+    def to_csv(
+        self,
+        path_or_buf=None,
+        sep=",",
+        na_rep="",
+        float_format=None,
+        columns=None,
+        header=True,
+        index=True,
+        index_label=None,
+        mode="w",
+        encoding=None,
+        compression="infer",
+        quoting=None,
+        quotechar='"',
+        line_terminator=None,
+        chunksize=None,
+        tupleize_cols=None,
+        date_format=None,
+        doublequote=True,
+        escapechar=None,
+        decimal=".",
+        *args,
+        **kwargs
+    ):
+        kwargs = {
+            "path_or_buf": path_or_buf,
+            "sep": sep,
+            "na_rep": na_rep,
+            "float_format": float_format,
+            "columns": columns,
+            "header": header,
+            "index": index,
+            "index_label": index_label,
+            "mode": mode,
+            "encoding": encoding,
+            "compression": compression,
+            "quoting": quoting,
+            "quotechar": quotechar,
+            "line_terminator": line_terminator,
+            "chunksize": chunksize,
+            "tupleize_cols": tupleize_cols,
+            "date_format": date_format,
+            "doublequote": doublequote,
+            "escapechar": escapechar,
+            "decimal": decimal,
+        }
+
+
     hist = gfx.ed_hist_frame
diff --git a/eland/docs/dataframe_supported.rst b/eland/docs/dataframe_supported.rst
index 44abfdc..a9353ef 100644
--- a/eland/docs/dataframe_supported.rst
+++ b/eland/docs/dataframe_supported.rst
@@ -27,7 +27,7 @@ https://github.com/adgirish/kaggleScape/blob/master/results/annotResults.csv rep
 +-------------------------+-------+------------------------------------------------+
 | df.head                 | 783   | y                                              |
 +-------------------------+-------+------------------------------------------------+
-| df.drop                 | 761   |                                                |
+| df.drop                 | 761   | y                                              |
 +-------------------------+-------+------------------------------------------------+
 | df.sum                  | 755   | y                                              |
 +-------------------------+-------+------------------------------------------------+
diff --git a/eland/operations.py b/eland/operations.py
index e12667e..8b226cb 100644
--- a/eland/operations.py
+++ b/eland/operations.py
@@ -70,6 +70,9 @@ class Operations:
     def set_columns(self, columns):
         # Setting columns at different phases of the task list may result in different
         # operations. So instead of setting columns once, set when it happens in call chain
+        if type(columns) is not list:
+            columns = list(columns)
+
         # TODO - column renaming
         # TODO - validate we are setting columns to a subset of last columns?
         task = ('columns', columns)
@@ -483,6 +486,7 @@ class Operations:
                 df = df.iloc[index_indexer, column_indexer]
             elif action[0] == 'squeeze':
                 df = df.squeeze(axis=action[1])
+            # columns could be in here (and we ignore it)
 
         return df
 
diff --git a/eland/query_compiler.py b/eland/query_compiler.py
index 2b973bc..db2e1f5 100644
--- a/eland/query_compiler.py
+++ b/eland/query_compiler.py
@@ -11,6 +11,36 @@ from pandas.core.indexes.range import RangeIndex
 
 
 class ElandQueryCompiler(BaseQueryCompiler):
+    """
+    Some notes on what can and can not be mapped:
+
+    1. df.head(10)
+
+    /_search?size=10
+
+    2. df.tail(10)
+
+    /_search?size=10&sort=_doc:desc
+    + post_process results (sort_index)
+
+    3. df[['OriginAirportID', 'AvgTicketPrice', 'Carrier']]
+
+    /_search
+    { '_source': ['OriginAirportID', 'AvgTicketPrice', 'Carrier']}
+
+    4. df.drop(['1', '2'])
+
+    /_search
+    {'query': {'bool': {'must': [], 'must_not': [{'ids': {'values': ['1', '2']}}]}}, 'aggs': {}}
+
+    This doesn't work is size is set (e.g. head/tail) as we don't know in Elasticsearch if values '1' or '2' are
+    in the first/last n fields.
+
+    A way to mitigate this would be to post process this drop - TODO
+
+
+
+    """
 
     def __init__(self,
                  client=None,
@@ -155,45 +185,6 @@ class ElandQueryCompiler(BaseQueryCompiler):
         if results is None:
             return self._empty_pd_ef()
 
-        def flatten_dict(y):
-            out = {}
-
-            def flatten(x, name=''):
-                # We flatten into source fields e.g. if type=geo_point
-                # location: {lat=52.38, lon=4.90}
-                if name == '':
-                    is_source_field = False
-                    pd_dtype = 'object'
-                else:
-                    is_source_field, pd_dtype = self._mappings.source_field_pd_dtype(name[:-1])
-
-                if not is_source_field and type(x) is dict:
-                    for a in x:
-                        flatten(x[a], name + a + '.')
-                elif not is_source_field and type(x) is list:
-                    for a in x:
-                        flatten(a, name)
-                elif is_source_field == True:  # only print source fields from mappings (TODO - not so efficient for large number of fields and filtered mapping)
-                    field_name = name[:-1]
-
-                    # Coerce types - for now just datetime
-                    if pd_dtype == 'datetime64[ns]':
-                        x = pd.to_datetime(x)
-
-                    # Elasticsearch can have multiple values for a field. These are represented as lists, so
-                    # create lists for this pivot (see notes above)
-                    if field_name in out:
-                        if type(out[field_name]) is not list:
-                            l = [out[field_name]]
-                            out[field_name] = l
-                        out[field_name].append(x)
-                    else:
-                        out[field_name] = x
-
-            flatten(y)
-
-            return out
-
         rows = []
         index = []
         if isinstance(results, dict):
@@ -212,7 +203,7 @@ class ElandQueryCompiler(BaseQueryCompiler):
             index.append(index_field)
 
             # flatten row to map correctly to 2D DataFrame
-            rows.append(flatten_dict(row))
+            rows.append(self._flatten_dict(row))
 
         # Create pandas DataFrame
         df = pd.DataFrame(data=rows, index=index)
@@ -232,6 +223,100 @@ class ElandQueryCompiler(BaseQueryCompiler):
 
         return df
 
+    def _to_csv(self, results, **kwargs):
+        # Very similar to _es_results_to_pandas except we create partial pandas.DataFrame
+        # and write these to csv
+
+        # Use chunksize in kwargs do determine size of partial data frame
+        if 'chunksize' in kwargs:
+            chunksize = kwargs['chunksize']
+        else:
+            # If no default chunk, set to 1000
+            chunksize = 1000
+
+        if results is None:
+            return self._empty_pd_ef()
+
+        rows = []
+        index = []
+        if isinstance(results, dict):
+            iterator = results['hits']['hits']
+        else:
+            iterator = results
+
+        i = 0
+        for hit in iterator:
+            row = hit['_source']
+
+            # get index value - can be _id or can be field value in source
+            if self._index.is_source_field:
+                index_field = row[self._index.index_field]
+            else:
+                index_field = hit[self._index.index_field]
+            index.append(index_field)
+
+            # flatten row to map correctly to 2D DataFrame
+            rows.append(self._flatten_dict(row))
+
+            i = i + 1
+            if i % chunksize == 0:
+                # Create pandas DataFrame
+                df = pd.DataFrame(data=rows, index=index)
+
+                # _source may not contain all columns in the mapping
+                # therefore, fill in missing columns
+                # (note this returns self.columns NOT IN df.columns)
+                missing_columns = list(set(self.columns) - set(df.columns))
+
+                for missing in missing_columns:
+                    is_source_field, pd_dtype = self._mappings.source_field_pd_dtype(missing)
+                    df[missing] = None
+                    df[missing].astype(pd_dtype)
+
+                # Sort columns in mapping order
+                df = df[self.columns]
+
+        return df
+
+    def _flatten_dict(self, y):
+        out = {}
+
+        def flatten(x, name=''):
+            # We flatten into source fields e.g. if type=geo_point
+            # location: {lat=52.38, lon=4.90}
+            if name == '':
+                is_source_field = False
+                pd_dtype = 'object'
+            else:
+                is_source_field, pd_dtype = self._mappings.source_field_pd_dtype(name[:-1])
+
+            if not is_source_field and type(x) is dict:
+                for a in x:
+                    flatten(x[a], name + a + '.')
+            elif not is_source_field and type(x) is list:
+                for a in x:
+                    flatten(a, name)
+            elif is_source_field == True:  # only print source fields from mappings (TODO - not so efficient for large number of fields and filtered mapping)
+                field_name = name[:-1]
+
+                # Coerce types - for now just datetime
+                if pd_dtype == 'datetime64[ns]':
+                    x = pd.to_datetime(x)
+
+                # Elasticsearch can have multiple values for a field. These are represented as lists, so
+                # create lists for this pivot (see notes above)
+                if field_name in out:
+                    if type(out[field_name]) is not list:
+                        l = [out[field_name]]
+                        out[field_name] = l
+                    out[field_name].append(x)
+                else:
+                    out[field_name] = x
+
+        flatten(y)
+
+        return out
+
     def _index_count(self):
         """
         Returns
diff --git a/eland/tests/__init__.py b/eland/tests/__init__.py
index d0b1ad8..1be1a2a 100644
--- a/eland/tests/__init__.py
+++ b/eland/tests/__init__.py
@@ -99,6 +99,11 @@ FLIGHTS_MAPPING = { "mappings" : {
 FLIGHTS_FILE_NAME = ROOT_DIR + '/flights.json.gz'
 FLIGHTS_DF_FILE_NAME = ROOT_DIR + '/flights_df.json.gz'
 
+FLIGHTS_SMALL_INDEX_NAME = 'flights_small'
+FLIGHTS_SMALL_MAPPING = FLIGHTS_MAPPING
+FLIGHTS_SMALL_FILE_NAME = ROOT_DIR + '/flights_small.json.gz'
+FLIGHTS_SMALL_DF_FILE_NAME = ROOT_DIR + '/flights_small_df.json.gz'
+
 ECOMMERCE_INDEX_NAME = 'ecommerce'
 ECOMMERCE_MAPPING = { "mappings" : {
       "properties" : {
diff --git a/eland/tests/common.py b/eland/tests/common.py
index 03123e6..ada3e43 100644
--- a/eland/tests/common.py
+++ b/eland/tests/common.py
@@ -12,6 +12,7 @@ ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
 # Create pandas and eland data frames
 from eland.tests import ELASTICSEARCH_HOST
 from eland.tests import FLIGHTS_DF_FILE_NAME, FLIGHTS_INDEX_NAME,\
+    FLIGHTS_SMALL_INDEX_NAME,\
     ECOMMERCE_DF_FILE_NAME, ECOMMERCE_INDEX_NAME
 
 _pd_flights = pd.read_json(FLIGHTS_DF_FILE_NAME).sort_index()
@@ -20,6 +21,9 @@ _pd_flights['timestamp'] = \
 _pd_flights.index = _pd_flights.index.map(str) # make index 'object' not int
 _ed_flights = ed.read_es(ELASTICSEARCH_HOST, FLIGHTS_INDEX_NAME)
 
+_pd_flights_small = _pd_flights.head(48)
+_ed_flights_small = ed.read_es(ELASTICSEARCH_HOST, FLIGHTS_SMALL_INDEX_NAME)
+
 _pd_ecommerce = pd.read_json(ECOMMERCE_DF_FILE_NAME).sort_index()
 _pd_ecommerce['order_date'] = \
     pd.to_datetime(_pd_ecommerce['order_date'])
@@ -38,6 +42,13 @@ class TestData:
     def ed_flights(self):
         return _ed_flights
 
+    def pd_flights_small(self):
+        return _pd_flights_small
+
+    def ed_flights_small(self):
+        return _ed_flights_small
+
+
     def pd_ecommerce(self):
         return _pd_ecommerce
 
diff --git a/eland/tests/dataframe/test_describe_pytest.py b/eland/tests/dataframe/test_describe_pytest.py
index 1a05455..34ce3b1 100644
--- a/eland/tests/dataframe/test_describe_pytest.py
+++ b/eland/tests/dataframe/test_describe_pytest.py
@@ -31,14 +31,5 @@ class TestDataFrameDescribe(TestData):
         # don't match the mapping types. This is mainly because the products field is
         # nested and so can be treated as a multi-field in ES, but not in pandas
 
-    def test_to_describe2(self):
-        pd_flights = self.pd_flights().head()
-        ed_flights = self.ed_flights().head()
-
-        pd_describe = pd_flights.describe()
-        # This fails as we can not run 'describe' on a truncate ed dataframe
-        ed_describe = ed_flights.describe()
-
-        print(pd_describe)
-        print(ed_describe)
+        # We can not also run 'describe' on a truncate ed dataframe
 
diff --git a/eland/tests/dataframe/test_drop_pytest.py b/eland/tests/dataframe/test_drop_pytest.py
index e410851..e63df92 100644
--- a/eland/tests/dataframe/test_drop_pytest.py
+++ b/eland/tests/dataframe/test_drop_pytest.py
@@ -14,8 +14,8 @@ import numpy as np
 class TestDataFrameDrop(TestData):
 
     def test_drop1(self):
-        ed_flights = self.ed_flights()
-        pd_flights = self.pd_flights()
+        ed_flights_small = self.ed_flights_small()
+        pd_flights_small = self.pd_flights_small()
 
         # ['AvgTicketPrice', 'Cancelled', 'Carrier', 'Dest', 'DestAirportID',
         #        'DestCityName', 'DestCountry', 'DestLocation', 'DestRegion',
@@ -24,33 +24,17 @@ class TestDataFrameDrop(TestData):
         #        'FlightTimeMin', 'Origin', 'OriginAirportID', 'OriginCityName',
         #        'OriginCountry', 'OriginLocation', 'OriginRegion', 'OriginWeather',
         #        'dayOfWeek', 'timestamp']
-        pd_col0 = pd_flights.drop(['Carrier', 'DestCityName'], axis=1)
-        pd_col1 = pd_flights.drop(columns=['Carrier', 'DestCityName'])
+        pd_col0 = pd_flights_small.drop(['Carrier', 'DestCityName'], axis=1)
+        pd_col1 = pd_flights_small.drop(columns=['Carrier', 'DestCityName'])
 
-        ed_col0 = ed_flights.drop(['Carrier', 'DestCityName'], axis=1)
-        ed_col1 = ed_flights.drop(columns=['Carrier', 'DestCityName'])
+        ed_col0 = ed_flights_small.drop(['Carrier', 'DestCityName'], axis=1)
+        ed_col1 = ed_flights_small.drop(columns=['Carrier', 'DestCityName'])
 
-        #assert_pandas_eland_frame_equal(pd_col0, ed_col0)
-        #assert_pandas_eland_frame_equal(pd_col1, ed_col1)
+        assert_pandas_eland_frame_equal(pd_col0, ed_col0)
+        assert_pandas_eland_frame_equal(pd_col1, ed_col1)
 
         # Drop rows by index
-        pd_idx0 = pd_flights.drop(['1', '2'])
-        ed_idx0 = ed_flights.drop(['1', '2'])
-
-        print(pd_idx0.info())
-        print(ed_idx0.info())
+        pd_idx0 = pd_flights_small.drop(['1', '2'])
+        ed_idx0 = ed_flights_small.drop(['1', '2'])
 
         assert_pandas_eland_frame_equal(pd_idx0, ed_idx0)
-
-        """
-        #assert_pandas_eland_frame_equal(pd_iloc0, ed_iloc0) # pd_iloc0 is Series
-        assert_pandas_eland_frame_equal(pd_iloc1, ed_iloc1)
-        assert_pandas_eland_frame_equal(pd_iloc2, ed_iloc2)
-        assert_pandas_eland_frame_equal(pd_iloc3, ed_iloc3)
-        assert_pandas_eland_frame_equal(pd_iloc4, ed_iloc4)
-        #assert_pandas_eland_frame_equal(pd_iloc5, ed_iloc5) # pd_iloc5 is numpy_bool
-        assert_pandas_eland_frame_equal(pd_iloc6, ed_iloc6)
-        assert_pandas_eland_frame_equal(pd_iloc7, ed_iloc7)
-        assert_pandas_eland_frame_equal(pd_iloc8, ed_iloc8)
-        assert_pandas_eland_frame_equal(pd_iloc9, ed_iloc9)
-        """
diff --git a/eland/tests/dataframe/test_hist_pytest.py b/eland/tests/dataframe/test_hist_pytest.py
index 2139b84..c1490af 100644
--- a/eland/tests/dataframe/test_hist_pytest.py
+++ b/eland/tests/dataframe/test_hist_pytest.py
@@ -30,3 +30,15 @@ class TestDataFrameHist(TestData):
         # Numbers are slightly different
         assert_almost_equal(pd_bins, ed_bins)
         assert_almost_equal(pd_weights, ed_weights)
+
+    def test_hist2(self):
+        pd_df = self.pd_flights()[['DistanceKilometers', 'DistanceMiles', 'FlightDelayMin', 'FlightTimeHour']]
+        ed_df = self.ed_flights()[['DistanceKilometers', 'DistanceMiles', 'FlightDelayMin', 'FlightTimeHour']]
+
+        num_bins = 10
+
+        ed_bins, ed_weights = ed_df._hist(num_bins=num_bins)
+
+        print(ed_bins)
+
+
diff --git a/eland/tests/dataframe/test_reviews_pytest.py b/eland/tests/dataframe/test_reviews_pytest.py
index 8f9b253..5c7d789 100644
--- a/eland/tests/dataframe/test_reviews_pytest.py
+++ b/eland/tests/dataframe/test_reviews_pytest.py
@@ -1,8 +1,11 @@
 # File called _pytest for PyCharm compatability
 
-from eland.tests.common import TestData
+import gzip
+
+import pandas as pd
 
 import eland as ed
+from eland.tests.common import TestData
 
 
 class TestDataFrameReviews(TestData):
@@ -13,5 +16,16 @@ class TestDataFrameReviews(TestData):
         print(ed_reviews.head())
         print(ed_reviews.describe())
         print(ed_reviews.info())
-        print(ed_reviews.hist(column="rating", bins = 5))
-        #print(ed_reviews.head().info_es())
+        print(ed_reviews.hist(column="rating", bins=5))
+        # print(ed_reviews.head().info_es())
+
+    def test_review(self):
+        csv_handle = gzip.open('../anonreviews.csv.gz')
+
+        reviews = pd.read_csv(csv_handle)
+
+        reviews['date'] = pd.to_datetime(reviews['date'])
+
+        g = reviews.groupby('reviewerId')
+
+        print(g.describe())
diff --git a/eland/tests/dataframe/test_to_csv_pytest.py b/eland/tests/dataframe/test_to_csv_pytest.py
new file mode 100644
index 0000000..a6deabe
--- /dev/null
+++ b/eland/tests/dataframe/test_to_csv_pytest.py
@@ -0,0 +1,14 @@
+# File called _pytest for PyCharm compatability
+
+import numpy as np
+import pandas as pd
+
+import eland as ed
+from eland.tests.common import ELASTICSEARCH_HOST
+from eland.tests.common import TestData
+
+
+class TestDataFrameToCSV(TestData):
+
+    def test_to_csv(self):
+        print("TODO")
diff --git a/eland/tests/flights.json.gz b/eland/tests/flights.json.gz
index df976e6..9a7b962 100644
Binary files a/eland/tests/flights.json.gz and b/eland/tests/flights.json.gz differ
diff --git a/eland/tests/flights_df.json.gz b/eland/tests/flights_df.json.gz
index 5aed61e..0cb2e29 100644
Binary files a/eland/tests/flights_df.json.gz and b/eland/tests/flights_df.json.gz differ
diff --git a/eland/tests/flights_small.json.gz b/eland/tests/flights_small.json.gz
new file mode 100644
index 0000000..c18373b
Binary files /dev/null and b/eland/tests/flights_small.json.gz differ
diff --git a/eland/tests/pivot_review_data_pandas.ipynb b/eland/tests/pivot_review_data_pandas.ipynb
index 2084ecd..e412c96 100644
--- a/eland/tests/pivot_review_data_pandas.ipynb
+++ b/eland/tests/pivot_review_data_pandas.ipynb
@@ -300,14 +300,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {
     "pycharm": {
      "is_executing": true,
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "#align = {str} 'center'\n",
     "#bottom = {ndarray} [0. 0. 0. 0. 0.]\n",
@@ -321,7 +334,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -341,7 +354,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -350,7 +363,7 @@
        "<BarContainer object of 5 artists>"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -373,7 +386,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -382,9 +395,59 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.series.Series'>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "IOPub data rate exceeded.\n",
+      "The notebook server will temporarily stop sending output\n",
+      "to the client in order to avoid crashing it.\n",
+      "To change this limit, set the config variable\n",
+      "`--NotebookApp.iopub_data_rate_limit`.\n",
+      "\n",
+      "Current values:\n",
+      "NotebookApp.iopub_data_rate_limit=1000000.0 (bytes/sec)\n",
+      "NotebookApp.rate_limit_window=3.0 (secs)\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "g = reviews.groupby('reviewerId')['vendorId'].nunique()\n",
+    "\n",
+    "print(type(g))\n",
+    "\n",
+    "print(reviews.groupby('reviewerId').indices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.plot(reviews.groupby('reviewerId')['vendorId'].nunique(), '.')\n",
     "plt.xlabel('reviewerId')\n",
@@ -403,7 +466,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -419,27 +482,218 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>avg_rating</th>\n",
+       "      <th>dc_vendorId</th>\n",
+       "      <th>count</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>reviewerId</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>7</td>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>4.000000</td>\n",
+       "      <td>5</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4.571429</td>\n",
+       "      <td>7</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            avg_rating  dc_vendorId  count\n",
+       "reviewerId                                \n",
+       "0             5.000000            1      1\n",
+       "1             5.000000            7      9\n",
+       "2             4.000000            5      5\n",
+       "3             4.571429            7      7\n",
+       "4             5.000000            1      1"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "grouped.head()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>avg_rating</th>\n",
+       "      <th>dc_vendorId</th>\n",
+       "      <th>count</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>count</th>\n",
+       "      <td>400141.000000</td>\n",
+       "      <td>400141.000000</td>\n",
+       "      <td>400141.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mean</th>\n",
+       "      <td>4.643846</td>\n",
+       "      <td>1.357017</td>\n",
+       "      <td>1.446503</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>std</th>\n",
+       "      <td>0.813586</td>\n",
+       "      <td>0.989413</td>\n",
+       "      <td>1.541802</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25%</th>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50%</th>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75%</th>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max</th>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>32.000000</td>\n",
+       "      <td>168.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          avg_rating    dc_vendorId          count\n",
+       "count  400141.000000  400141.000000  400141.000000\n",
+       "mean        4.643846       1.357017       1.446503\n",
+       "std         0.813586       0.989413       1.541802\n",
+       "min         0.000000       1.000000       1.000000\n",
+       "25%         5.000000       1.000000       1.000000\n",
+       "50%         5.000000       1.000000       1.000000\n",
+       "75%         5.000000       1.000000       1.000000\n",
+       "max         5.000000      32.000000     168.000000"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "grouped.describe()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 9 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.rcParams[\"figure.figsize\"] = (10,10)\n",
     "\n",
@@ -458,9 +712,154 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>avg_rating</th>\n",
+       "      <th>dc_vendorId</th>\n",
+       "      <th>count</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>reviewerId</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>10392</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>94</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17033</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>51</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21046</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11479</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27448</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>19</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8185</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17602</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13984</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>228129</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25267</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>53432</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19813</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11987</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>135506</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            avg_rating  dc_vendorId  count\n",
+       "reviewerId                                \n",
+       "10392              0.0            1     94\n",
+       "17033              0.0            1     51\n",
+       "21046              0.0            1     25\n",
+       "11479              0.0            1     20\n",
+       "27448              0.0            1     19\n",
+       "8185               0.0            1     15\n",
+       "17602              0.0            1     15\n",
+       "13984              0.0            1     10\n",
+       "228129             0.0            1      9\n",
+       "25267              0.0            1      8\n",
+       "53432              0.0            1      8\n",
+       "19813              0.0            1      7\n",
+       "11987              0.0            1      6\n",
+       "135506             0.0            1      6"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "grouped[ \n",
     "    (grouped['dc_vendorId'] == 1) & \n",
@@ -478,9 +877,90 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>reviewerId</th>\n",
+       "      <th>vendorId</th>\n",
+       "      <th>rating</th>\n",
+       "      <th>date</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>12340</th>\n",
+       "      <td>10392</td>\n",
+       "      <td>122</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2006-04-05 15:38:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12341</th>\n",
+       "      <td>10392</td>\n",
+       "      <td>122</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2006-04-06 09:24:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12342</th>\n",
+       "      <td>10392</td>\n",
+       "      <td>122</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2006-04-06 20:24:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12343</th>\n",
+       "      <td>10392</td>\n",
+       "      <td>122</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2006-04-11 07:43:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12344</th>\n",
+       "      <td>10392</td>\n",
+       "      <td>122</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2006-04-11 15:53:00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       reviewerId  vendorId  rating                date\n",
+       "12340       10392       122       0 2006-04-05 15:38:00\n",
+       "12341       10392       122       0 2006-04-06 09:24:00\n",
+       "12342       10392       122       0 2006-04-06 20:24:00\n",
+       "12343       10392       122       0 2006-04-11 07:43:00\n",
+       "12344       10392       122       0 2006-04-11 15:53:00"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "reviews[reviews['reviewerId'] == 10392].head()"
    ]
@@ -496,9 +976,273 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>avg_rating</th>\n",
+       "      <th>dc_vendorId</th>\n",
+       "      <th>count</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>reviewerId</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>183751</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>73</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>260225</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>69</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>205864</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>35</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345080</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>23</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>179944</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>22</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345082</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>21</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345081</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345068</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345069</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>19</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345086</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>18</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345083</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>18</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345070</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>18</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345085</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>17</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>345084</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>17</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>264635</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>321206</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12539</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>159035</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>114661</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39655</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22515</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>180082</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>58447</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>180085</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>168143</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>160018</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75010</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>35048</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>30474</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28814</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>393237</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            avg_rating  dc_vendorId  count\n",
+       "reviewerId                                \n",
+       "183751             5.0            1     73\n",
+       "260225             5.0            1     69\n",
+       "205864             5.0            1     35\n",
+       "345080             5.0            1     23\n",
+       "179944             5.0            1     22\n",
+       "345082             5.0            1     21\n",
+       "345081             5.0            1     20\n",
+       "345068             5.0            1     20\n",
+       "345069             5.0            1     19\n",
+       "345086             5.0            1     18\n",
+       "345083             5.0            1     18\n",
+       "345070             5.0            1     18\n",
+       "345085             5.0            1     17\n",
+       "345084             5.0            1     17\n",
+       "264635             5.0            1     13\n",
+       "321206             5.0            1     12\n",
+       "12539              5.0            1     11\n",
+       "159035             5.0            1     10\n",
+       "114661             5.0            1      9\n",
+       "39655              5.0            1      8\n",
+       "22515              5.0            1      7\n",
+       "180082             5.0            1      7\n",
+       "58447              5.0            1      7\n",
+       "180085             5.0            1      6\n",
+       "168143             5.0            1      6\n",
+       "160018             5.0            1      6\n",
+       "75010              5.0            1      6\n",
+       "35048              5.0            1      6\n",
+       "30474              5.0            1      6\n",
+       "28814              5.0            1      6\n",
+       "393237             5.0            1      6"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "grouped[ \n",
     "    (grouped['dc_vendorId'] == 1) & \n",
@@ -516,9 +1260,90 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>reviewerId</th>\n",
+       "      <th>vendorId</th>\n",
+       "      <th>rating</th>\n",
+       "      <th>date</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>261469</th>\n",
+       "      <td>183751</td>\n",
+       "      <td>190</td>\n",
+       "      <td>5</td>\n",
+       "      <td>2006-09-22 16:36:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>261470</th>\n",
+       "      <td>183751</td>\n",
+       "      <td>190</td>\n",
+       "      <td>5</td>\n",
+       "      <td>2006-09-22 16:36:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>261471</th>\n",
+       "      <td>183751</td>\n",
+       "      <td>190</td>\n",
+       "      <td>5</td>\n",
+       "      <td>2006-09-22 16:35:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>261474</th>\n",
+       "      <td>183751</td>\n",
+       "      <td>190</td>\n",
+       "      <td>5</td>\n",
+       "      <td>2006-09-22 15:53:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>261475</th>\n",
+       "      <td>183751</td>\n",
+       "      <td>190</td>\n",
+       "      <td>5</td>\n",
+       "      <td>2006-09-22 15:53:00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        reviewerId  vendorId  rating                date\n",
+       "261469      183751       190       5 2006-09-22 16:36:00\n",
+       "261470      183751       190       5 2006-09-22 16:36:00\n",
+       "261471      183751       190       5 2006-09-22 16:35:00\n",
+       "261474      183751       190       5 2006-09-22 15:53:00\n",
+       "261475      183751       190       5 2006-09-22 15:53:00"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "reviews[reviews['reviewerId'] == 183751].head()"
    ]
@@ -545,13 +1370,13 @@
   "pycharm": {
    "stem_cell": {
     "cell_type": "raw",
-    "source": [],
     "metadata": {
      "collapsed": false
-    }
+    },
+    "source": []
    }
   }
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
\ No newline at end of file
+}
diff --git a/eland/tests/plotting/test_dataframe_hist_pytest.ipynb b/eland/tests/plotting/test_dataframe_hist_pytest.ipynb
index 1609477..cf5fee5 100644
--- a/eland/tests/plotting/test_dataframe_hist_pytest.ipynb
+++ b/eland/tests/plotting/test_dataframe_hist_pytest.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 1,
    "metadata": {
     "pycharm": {
      "is_executing": false
@@ -10,6 +10,8 @@
    },
    "outputs": [],
    "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
     "from eland.tests.common import TestData\n",
     "\n",
     "test_data = TestData()\n",
@@ -20,7 +22,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 2,
    "metadata": {
     "pycharm": {
      "is_executing": false
@@ -29,16 +31,10 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x11e26a630>,\n        <matplotlib.axes._subplots.AxesSubplot object at 0x11e2734e0>],\n       [<matplotlib.axes._subplots.AxesSubplot object at 0x11e264a20>,\n        <matplotlib.axes._subplots.AxesSubplot object at 0x11e2725f8>]],\n      dtype=object)"
-     },
-     "metadata": {},
-     "output_type": "execute_result",
-     "execution_count": 36
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 720x720 with 4 Axes>",
-      "image/png": "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\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 4 Axes>"
+      ]
      },
      "metadata": {
       "needs_background": "light"
@@ -47,12 +43,14 @@
     }
    ],
    "source": [
-    "pd_flights.hist(figsize=[10,10])"
+    "pd_flights.hist(figsize=[10,10])\n",
+    "\n",
+    "plt.show()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 3,
    "metadata": {
     "pycharm": {
      "is_executing": false,
@@ -62,16 +60,10 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x11dfd07f0>,\n        <matplotlib.axes._subplots.AxesSubplot object at 0x11dfaf9e8>],\n       [<matplotlib.axes._subplots.AxesSubplot object at 0x11e14d5c0>,\n        <matplotlib.axes._subplots.AxesSubplot object at 0x11e3ef4e0>]],\n      dtype=object)"
-     },
-     "metadata": {},
-     "output_type": "execute_result",
-     "execution_count": 37
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 720x720 with 4 Axes>",
-      "image/png": "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\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 4 Axes>"
+      ]
      },
      "metadata": {
       "needs_background": "light"
@@ -80,44 +72,29 @@
     }
    ],
    "source": [
-    "ed_flights.hist(figsize=[10,10])"
+    "ed_flights.hist(figsize=[10,10])\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Change flight columns"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "text": [
-      "RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.\n"
-     ],
-     "output_type": "stream"
-    },
-    {
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
-      "\u001b[0;32m/anaconda3/envs/eland/lib/python3.6/site-packages/numpy/lib/histograms.py\u001b[0m in \u001b[0;36m_unsigned_subtract\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m    341\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 342\u001b[0;31m         \u001b[0mdt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msigned_to_unsigned\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    343\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mKeyError\u001b[0m: <class 'numpy.bool_'>",
-      "\nDuring handling of the above exception, another exception occurred:\n",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-38-a8a6dc53a547>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtest_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpd_flights\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/anaconda3/envs/eland/lib/python3.6/site-packages/pandas/plotting/_core.py\u001b[0m in \u001b[0;36mhist_frame\u001b[0;34m(data, column, by, grid, xlabelsize, xrot, ylabelsize, yrot, ax, sharex, sharey, figsize, layout, bins, **kwds)\u001b[0m\n\u001b[1;32m   2408\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtry_sort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2409\u001b[0m         \u001b[0max\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_axes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2410\u001b[0;31m         \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcol\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdropna\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbins\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbins\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2411\u001b[0m         \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_title\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcol\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2412\u001b[0m         \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgrid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/anaconda3/envs/eland/lib/python3.6/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1587\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1588\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1589\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1590\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1591\u001b[0m         \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/anaconda3/envs/eland/lib/python3.6/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mhist\u001b[0;34m(self, x, bins, range, density, weights, cumulative, bottom, histtype, align, orientation, rwidth, log, color, label, stacked, normed, **kwargs)\u001b[0m\n\u001b[1;32m   6751\u001b[0m             \u001b[0;31m# this will automatically overwrite bins,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6752\u001b[0m             \u001b[0;31m# so that each histogram uses the same bins\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 6753\u001b[0;31m             \u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbins\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhistogram\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbins\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweights\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mhist_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   6754\u001b[0m             \u001b[0mm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# causes problems later if it's an int\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6755\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mmlast\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/anaconda3/envs/eland/lib/python3.6/site-packages/numpy/lib/histograms.py\u001b[0m in \u001b[0;36mhistogram\u001b[0;34m(a, bins, range, normed, weights, density)\u001b[0m\n\u001b[1;32m    808\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    809\u001b[0m         \u001b[0;31m# Pre-compute histogram scaling factor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 810\u001b[0;31m         \u001b[0mnorm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mn_equal_bins\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0m_unsigned_subtract\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlast_edge\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfirst_edge\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    811\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    812\u001b[0m         \u001b[0;31m# We iterate over blocks here for two reasons: the first is that for\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m/anaconda3/envs/eland/lib/python3.6/site-packages/numpy/lib/histograms.py\u001b[0m in \u001b[0;36m_unsigned_subtract\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m    342\u001b[0m         \u001b[0mdt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msigned_to_unsigned\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    343\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 344\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubtract\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    345\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    346\u001b[0m         \u001b[0;31m# we know the inputs are integers, and we are deliberately casting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: numpy boolean subtract, the `-` operator, is deprecated, use the bitwise_xor, the `^` operator, or the logical_xor function instead."
-     ],
-     "ename": "TypeError",
-     "evalue": "numpy boolean subtract, the `-` operator, is deprecated, use the bitwise_xor, the `^` operator, or the logical_xor function instead.",
-     "output_type": "error"
-    },
     {
      "data": {
-      "text/plain": "<Figure size 432x288 with 9 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEICAYAAACwDehOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAdHklEQVR4nO3df5Ac5Z3f8ffnJItzFP8QIOtAEpbWq1siy5iCFZC6C1bi2AI5JznBuCQ7seSYKBcvReVMVSzuEuPDsYNTuaLCiZgIm4ArPgGmfGVB2MX8OMWxLyBWLoylI1gLCLQCjIQwAexIaP3NH937aDSamZ0d9c6v/byqpjTd/Uz30/vZ2e90T/cjRQRmZmYAv9XqDpiZWftwUTAzs8RFwczMEhcFMzNLXBTMzCxxUTAzs8RFoU6S/ljSN+tod5ukf9+MPlXY9qcl/aAV2zaz7tDRRUHSdkmvSjqlgHW9UfL4jaRfl0x/OiK+FhFXFNHvKttfIWm0bN6XJb2V9+GXkv5a0t+tto6I+E5EfHSq+mhm3a9ji4KkRcDfAwJYfbLri4i/Pf4Angf+oGTed052/SfhzrxPc4EfAd+TpPJGkmY2vWdm1nU6tigAnwEeAW4D1gNIukjSS5JmjDeS9I8lPZE/f7uk2/Ojiycl/ZvyT+fV5J/a/3vJ9O/nn9x/KWmfpA0VXvMOSX8l6UZlTpH0nyQ9L+kXkm7O+zQbGATOLDk6ObN0XRHxFnA78DvAaZI2SPqxpBskHQK+nM/7Ucn23y/pAUmH8u39cT7/tyRtkvS0pFck3SXp1Lp+6mbW1Tq9KHwnf6yUNC8iHgHeBP5BSbtPAX+RP78WWAT0AB8B/mkjG5Z0Ftkf8T8n+wR/LvB4WZvTgIeAH0fEVZGNJ/J14Hfz9r3AfOBLEfEmcCnwQsnRyQtl6zsF2ACMRsTBfPaFwDPAe4CvlrV/B/AgMAScmW/voXzxVcDHgQ/ly14FbmrkZ2Fm3aUji4Kk3wfeC9wVETuBp8n++ANsBdbl7d4BrMrnAXwS+FpEvBoRo8CNDXbh08CDEbE1It6KiFciorQonAn8T+C7EfFv874I+BfAH0XEoYh4HfgasHaCbX1S0i+BfcD5ZH/Mx70QEX8eEUcj4tdlr/tHwEsR8WcR8f8i4vWIeDRf9i+BP4mI0Yg4DHwZ+IRPQZlZp/4RWA/8oOQT81/k827In/+1pH8F/BPgJxHxXN7uTLI/ruNKn0/GQrJCVM3HgDeAm0vmzQX+FrCz5CsBATOo7a6IqHZEU6v/tfr4XuAvJf2mZN4YMA/YP0F/zKyLdVxRkPR2sk/8MyS9lM8+BXi3pA9GxE8lPUd2Oqb01BHAi8AC4G/y6YUNdmMfcEGN5bcAc4D7JF2Snx46CPwaeH9EVPrD28hwtbVes4/8iKnKsn8eET9uYJtm1sU68fTRx8k+1S4lOzd/LvB3gP9F9j0DZIXgKuBi4Lslr70LuEbSHEnzgSsb7MN3gH8o6ZOSZko6TdK5ZW2uBJ4C7pX09oj4DVmxuEHSewAkzZe0Mm//C7IvkN/VYJ/K3Qv8jqR/nX/B/Q5JF+bLbga+Kum9eT/mSlpT0HbNrIN1YlFYD/y3iHg+Il4afwCbgU/n58W3AiuAh0tOMQFcB4wCz5J9CXs3cHiyHYiI58m+q7gaOET2JfMHy9oEsJHsU/n3Jf028EVgBHhE0v/N+9CXt/8/eb+fya9oOu7qowb6+DrZl+l/ALwE7AH+fr74PwPbgB9Iep3sKq4LK63HzKYXTef/ZCf/3mFtRHyo1X0xM2sHnXik0DBJZ0j6vfw6/T6yT/p/2ep+mZm1i2lVFIBZwH8FXgceBr4P/JeW9qjNSbpV0suSdlVZrvzmvBFJT0g6r9l9tMlzrlbNtCoKEfFcRCyLiNkRMT8iro6II63uV5u7DbikxvJLgSX5YyPwjSb0yU7ebThXq2BaFQWbvIj4IdmX6dWsAb4dmUfILg0+ozm9s0Y5V6umre9TOP3002PRokWt7sZx3nzzTWbPnt3qbtRUdB+XLVvGrl27xqosns/xN9GN5vNeLG0kaSPZJ05mz559/tlnn11Y/6wxReQKzrYd7dy582BEzG3ktW1dFBYtWsTw8HCru3Gc7du3s2LFilZ3o6ai+7h3714WL178VpXFJ4zYSoWb6iJiC7AFoL+/P9ot1+moiFzB2baj/Abehvj0kZ2sUY6/M3wB8EKVttY5nOs01dZHCtPJok3/o+byvdd/rEk9mbRtwJWS7iC7Ae61iDjhFIN1HOc6TbkoWE3r1q1j+/btAKfk//fEtcDbACLiZuA+sru7R4BfAZ9tTU9tMpyrVeOi0AQTHQW0s61bs1HHJf0kIvrLl+fDeQw0u192cpyrVePvFMzMLHFRMDOzxKePOkQ9p6Da+MtoM+sQLgonqZO/LzAzK+fTR2ZmlrgomJlZ4qJgZmaJv1OoodL3BVd/4Cgb/D2CmXUpHymYmVniomBmZsm0PX3kS0nNzE7kIwUzM0tcFMzMLHFRMDOzxEXBzMwSFwUzM0u68uojX1lkZtYYHymYmVniomBmZomLgpmZJS4KZmaWTFgUJN0q6WVJu0rmnSrpAUl78n/n5PMl6UZJI5KekHReyWvW5+33SFo/NbtjZmYno54jhduAS8rmbQIeioglwEP5NMClwJL8sRH4BmRFBLgWuBC4ALh2vJCYmVn7mLAoRMQPgUNls9cAt+fPbwc+XjL/25F5BHi3pDOAlcADEXEoIl4FHuDEQmNtaGhoiL6+PoBlkjaVL5e0QdIBSY/njyua30ubLOdq1TT6ncK8iHgRIP/3Pfn8+cC+knaj+bxq862NjY2NMTAwwODgIMBuYJ2kpRWa3hkR5+aPbza3lzZZztVqKfrmNVWYFzXmn7gCaSPZqSfmzZvH9u3bJ92Jqz9wdNKvqde8t0/t+k/G+M/qjTfeaOjnVm737t2ceuqpPP/885DldQfZ0eDfnPTKrWV27NhBb28vPT094FytTKNF4ReSzoiIF/PTQy/n80eBhSXtFgAv5PNXlM3fXmnFEbEF2ALQ398fK1asqNSspqn87zKv/sBR/uxn7Xkj+N5PrwCy4tDIz63cwYMH+eAHP1i6rlGy74XKXSbpYuDnwB9FxL7yBqXF/qyzzjrpvlnj9u/fz8KFpW/TxnMFZ9ttGj19tA0Yv4JoPfD9kvmfya9Cugh4LT+9dD/wUUlz8i+YP5rPszYWUfFgrnzmPcCiiDgHeJBj3zWVr2tLRPRHRP/cuXOL7ahNSpG55utztl2knktStwL/G+iTNCrpc8D1wEck7QE+kk8D3Ac8A4wAtwCfB4iIQ8BXgMfyx3X5PGtjCxYsYN++4z4cjh/5JRHxSkQczidvAc5vUvesQc7VapnwPEhErKuy6MMV2gYwUGU9twK3Tqp31lLLly9nz549PPvss5B9L7QW+FRpm/HTiPnkauDJ5vbSJsu5Wi3teXK8Bo+A2jwzZ85k8+bNrFy5EuD9wFciYrek64DhiNgGXCVpNXCU7NLlDS3rsNXFuVotHVcUrLlWrVrFqlWrkLQrIr4KEBFfGl8eEdcA17Ssg9YQ52rVeOwjMzNLXBTMzCzx6aMuMv59y9UfOFr1Xo2913+smV0ysw7jIwUzM0tcFMzMLHFRMDOzxEXBzMwSFwUzM0tcFMzMLHFRMDOzxEXBzMwSFwUzM0t8R/M0U88os77r2Wz68pGCmZklLgpmZpa4KJiZWeKiYGZmiYuCmZklLgpmZpa4KJiZWeKiYGZmiYuCmZklLgpmZpY0vShIukTSU5JGJG1q9vZtcoaGhujr6wNYVikvSadIujPP81FJi5rdR2vM0NAQZLlWfC862+mpqUVB0gzgJuBSYCmwTtLSZvbB6jc2NsbAwACDg4MAu6mc1+eAVyOiF7gB+HqTu2kNGM8W+DnV34vOdhpq9pHCBcBIRDwTEUeAO4A1Te6D1WnHjh309vbS09MDEFTOaw1we/78buDDktS8XlojxrMFjtR4LzrbaajZo6TOB/aVTI8CF5Y2kLQR2JhPviHpqSb1rS5XwenAwVb3o5aT7aOOfR6cA7xT0nPAe6mQFyWZRsRRSa8Bp5VvvyzXw5J2Ndq/NtL2vws1zAHeCfTl0872mE7OdVzfxE0qa3ZRqPQpI46biNgCbGlOdyZP0nBE9Le6H7UU1UdJlwMrI+KKfPqfUZYXdWQKx+faCT/DenTyfoxnC5xbMtvZ0j370Ohrm336aBRYWDK9AHihyX2w+tWTV2ojaSbwLuBQU3pnJ8PZWkXNLgqPAUskLZY0C1gLbGtyH6x+9eS1DVifP/8E8HBEnPBp0trOY8ASYJaztVJNLQoRcRS4ErgfeBK4KyJ2N7MPBWjbU1slCuljtbwkXSdpdd7sW8BpkkaALwD1XGbcCT/DenTsfpRkOw9nW25a74Nc+M3MbJzvaDYzs8RFwczMEheFCiTtlfQzSY+PX9ol6VRJD0jak/87J58vSTfmQwE8Iem8KerTrZJeLr0GvJE+SVqft98jaX2lbRXY55pDmnTCMAp17MMGSQfy35XHJV3Rin7WUul3p2z5pH6HuyFX6Pxsi841iQg/yh7AXuD0snn/EdiUP98EfD1/vgoYJLum+yLg0Snq08XAecCuRvsEnAo8k/87J38+Z4r6OwN4GugBZgE/BZaWtfk8cHP+fC1wZ6uzb2AfNgCbW93Xyf7ulC2v+3e4G3LtlmyLzLX0UdiRwpRVrfZResv/7cDHS+Z/OzKPAO+WdEbRG4+IH3LiNeKT7dNK4IGIOBQRrwIPAJfU2u5J5FrPkCbtPoxCVwzLUul3pyzXir8vXZwrdEG2Vf4mlGrob1ORp49uo/YfmEvJroteQnZL/DcK3HbRAviBpJ3KbuEHmBcRLwLk/74nn19p6I75TernZPvUSF9vo7Fc69nWccMoAOPDKLSLen9el+V/OO+WtLDC8nZ0G8dyrbSfl9O9uUJ3Zzuuob9NhRWFqapaLfJ7EXEe2R+8AUkX12hb11AATVatT5Pu60nkWs+22vFnV6qe/t0DLIqIc4AHOfYJua2V5VppPz9E9+YKXZxtiYZyKPQ+hfwLpXsjYlmFZfcC10fEj/Lph4AvRsRwWbs0uNbs2bPPP/vsswvrnzXm8OHD7Nq1aywiThgrq1quwNuAL0fEynz+98gO2V9yru1hPFeym9S2R8RWAGWDUD4P/GkduV4DLAfOAr9n28XOnTsPAt/jxFxXjJ9dqKaZA+JNenCt/v7+GB5ueFwnK8jevXtZvHjxW1UWV8s1DZEB7AfeRza43m7n2h5Kct0GXCnpDrKRUl8DjlR4SaVc1wKfinxkAmfbHpSNbHxCrhMVBGjuJakeDK87Vcw1agyR0YI+Wm33kV2JNgLcQnb10KRz1bHhMaw9VMp1Qs0sCtuAz+RXq1xEnVXL2l7VXCPivoj43Yh4X0R8NZ/3pVZ21k6Uf28wkOf0gfyU7qRzjQgPbtlGquQ6ocJOH0naCqwATpc0ClxLdv6RiLiZrGqtIqtavwI+W9S2beqsW7eO7du3A5ziXLuHc7VqCisKEbFuguUBDBS1PWuOrVu3AiDpJ1HhPx5xrp3JuVo1HubCzMwSFwUzM0tcFMzMLHFRMDOzxEXBzMwSFwUzM0tcFMzMLHFRMDOzxEXBzMwSFwUzM0tcFMzMLHFRMDOzxEXBzMwSFwUzM0tcFMzMLHFRMDOzxEXBzMwSFwUzM0tcFMzMLHFRMDOzxEXBzMwSFwUzM0tcFMzMLCmsKEi6RNJTkkYkbaqwfIOkA5Iezx9XFLVtmzpDQ0P09fUBLHOu3cO5WjWFFAVJM4CbgEuBpcA6SUsrNL0zIs7NH98sYts2dcbGxhgYGGBwcBBgN861KzhXq6WoI4ULgJGIeCYijgB3AGsKWre1yI4dO+jt7aWnpwcgcK5dwblaLUUVhfnAvpLp0XxeucskPSHpbkkLK61I0kZJw5KGDxw4UFD3rBH79+9n4cLjYnKuXaDIXMHZdpuiioIqzIuy6XuARRFxDvAgcHulFUXElojoj4j+uXPnFtQ9a0REeYTZ7LJp59phisw1X5+z7SJFFYVRoPSTxALghdIGEfFKRBzOJ28Bzi9o2zZFFixYwL59+46bhXPteM7VaimqKDwGLJG0WNIsYC2wrbSBpDNKJlcDTxa0bZsiy5cvZ8+ePTz77LOQHQ061y7gXK2WmUWsJCKOSroSuB+YAdwaEbslXQcMR8Q24CpJq4GjwCFgQxHbtqkzc+ZMNm/ezMqVKwHeD3zFuXY+52q1qMr5xbbQ398fw8PDre6GAZJ2RkR/Eetyru2jyFzB2baLk8nVdzSbmVniomBmZomLgpmZJS4KZmaWuCiYmVniomBmZomLgpmZJS4KZmaWuCiYmVniomBmZomLgpmZJS4KZmaWuCiYmVniomBmZomLgpmZJS4KZmaWuCiYmVniomBmZomLgpmZJS4KZmaWuCiYmVniomBmZomLgpmZJYUVBUmXSHpK0oikTRWWnyLpznz5o5IWFbVtmzpDQ0P09fUBLHOu3WVoaAiyXP2etaSQoiBpBnATcCmwFFgnaWlZs88Br0ZEL3AD8PUitm1TZ2xsjIGBAQYHBwF241y7xni2wM/xe9ZKFHWkcAEwEhHPRMQR4A5gTVmbNcDt+fO7gQ9LUkHbtymwY8cOent76enpAQica9cYzxY44veslZpZ0HrmA/tKpkeBC6u1iYijkl4DTgMOljaStBHYmE8elrSroD620umU7WeHmAO8U9JzQB/OtVyn5gp5tmS5grMt1cm5juubuEllRRWFSp8eooE2RMQWYAuApOGI6D/57rVWp+6HpMuBlRFxhaThfLZzzXXyfoxnC5xbMtvZ0j370Ohrizp9NAosLJleALxQrY2kmcC7gEMFbd+mhnPtXs7WKiqqKDwGLJG0WNIsYC2wrazNNmB9/vwTwMMRccKnDmsrKVeyT43OtXs8BiwBZvk9a6UKKQoRcRS4ErgfeBK4KyJ2S7pO0uq82beA0ySNAF8ATrgEroItRfSvDXTkfpTluhDnWq5j96Mk23n4PVtuWu+DXPjNzGyc72g2M7PERcHMzJK2KArdMERGHfuwQdIBSY/njyta0c9aJN0q6eVq15krc2O+j09IOm+C9TnXNuBcK+v0bIvONYmIlj6AGcDTQA8wC/gpsLSszeeBm/Pna4E7W93vBvZhA7C51X2dYD8uBs4DdlVZvgoYJLsS6SLgUefqXDst127JtshcSx9FDojXaNXqhiEy6tmHthcRP6TsOvSyXNcA347MI8C7JZ3hXNubc62o47OtlGuZirlOtN4iTx/dBlxSY/mlZNdFLyG7Jf4b+fxKQ2TML3vtcbfbA+O327eLevYB4LL8DXa3pIUVlrej2ziWa6X9vBzn6lyP1+65QndnO67efTxOYUXhJKpWYUNktFA9/bsHWBQR5wAPcuyTVFsry7XSfn4I5+pcj9fuuUIXZ1uioRwKvU8h/0Lp3ohYVmHZvcD1EfGjfPoh4IvA24AvR8TKfP73yA7tXpo9e/b5Z599dmH9s8YcPnyYXbt2jZHdzLQ9IrYCSHoKeB74U+faeQrK9RpgOXAWgLNtDzt37jwIfI8Tc10RES/Wem1RA+LVo1rVKh1KYT/wPrJB2Hb39/fH8HDD4zpZQfbu3cvixYvfIhv24EpJd5CNqPkacKTCS5xrBygo17XApyJiN4CzbQ/KRjY+IdeJCgI095LUigNwRY0hMprYN6vPfcAzwAhwC9lVJs618xWSq44Nj2HtoVKuE2rmkULVqhUR95HtQBIRX+rv7/93TeyfTSCyc40DpfMkzcO5drSicgXo7+/oEae7SqVc61FYUZC0FVgBnC5pFLiW7PwjEXEz2S/RKrKq9Svgs0Vt26bOunXr2L59O8ApzrV7OFerprCiEBHrJljeUNWy1tq6dSsAkn4SFf7jEefamZyrVdMWw1yYmVl7cFEwM7PERcHMzBIXBTMzS1wUzMwscVEwM7PERcHMzBIXBTMzS1wUzMwscVEwM7PERcHMzBIXBTMzS1wUzMwscVEwM7PERcHMzBIXBTMzS1wUzMwscVEwM7PERcHMzBIXBTMzS1wUzMwscVEwM7PERcHMzJLCioKkSyQ9JWlE0qYKyzdIOiDp8fxxRVHbtqkzNDREX18fwDLn2j2cq1VTSFGQNAO4CbgUWAqsk7S0QtM7I+Lc/PHNIrZtU2dsbIyBgQEGBwcBduNcu4JztVqKOlK4ABiJiGci4ghwB7CmoHVbi+zYsYPe3l56enoAAufaFZyr1VJUUZgP7CuZHs3nlbtM0hOS7pa0sNKKJG2UNCxp+MCBAwV1zxqxf/9+Fi48Libn2gWKzBWcbbcpqiiowrwom74HWBQR5wAPArdXWlFEbImI/ojonzt3bkHds0ZElEeYzS6bdq4dpshc8/U52y5SVFEYBUo/SSwAXihtEBGvRMThfPIW4PyCtm1TZMGCBezbt++4WTjXjudcrZaiisJjwBJJiyXNAtYC20obSDqjZHI18GRB27Ypsnz5cvbs2cOzzz4L2dGgc+0CztVqmVnESiLiqKQrgfuBGcCtEbFb0nXAcERsA66StBo4ChwCNhSxbZs6M2fOZPPmzaxcuRLg/cBXnGvnc65Wi6qcX2wL/f39MTw83OpuGCBpZ0T0F7Eu59o+iswVnG27OJlcfUezmZklLgpmZpa4KJiZWeKiYGZmiYuCmZklLgpmZpa4KJiZWeKiYGZmiYuCmZklLgpmZpa4KJiZWeKiYGZmiYuCmZklLgpmZpa4KJiZWeKiYGZmiYuCmZklLgpmZpa4KJiZWeKiYGZmiYuCmZklLgpmZpa4KJiZWVJYUZB0iaSnJI1I2lRh+SmS7syXPyppUVHbtqkzNDREX18fwDLn2l2GhoYgy9XvWUsKKQqSZgA3AZcCS4F1kpaWNfsc8GpE9AI3AF8vYts2dcbGxhgYGGBwcBBgN861a4xnC/wcv2etRFFHChcAIxHxTEQcAe4A1pS1WQPcnj+/G/iwJBW0fZsCO3bsoLe3l56eHoDAuXaN8WyBI37PWqmZBa1nPrCvZHoUuLBam4g4Kuk14DTgYGkjSRuBjfnkYUm7CupjK51O2X52iDnAOyU9B/ThXMt1aq6QZ0uWKzjbUp2c67i+iZtUVlRRqPTpIRpoQ0RsAbYASBqOiP6T715rdep+SLocWBkRV0gazmc711wn78d4tsC5JbOdLd2zD42+tqjTR6PAwpLpBcAL1dpImgm8CzhU0PZtajjX7uVsraKiisJjwBJJiyXNAtYC28rabAPW588/ATwcESd86rC2knIl+9ToXLvHY8ASYJbfs1aqkKIQEUeBK4H7gSeBuyJit6TrJK3Om30LOE3SCPAF4IRL4CrYUkT/2kBH7kdZrgtxruU6dj9Ksp2H37PlpvU+yIXfzMzG+Y5mMzNLXBTMzCxpi6LQDUNk1LEPGyQdkPR4/riiFf2sRdKtkl6udp25Mjfm+/iEpPMmWJ9zbQPOtbJOz7boXJOIaOkDmAE8DfQAs4CfAkvL2nweuDl/vha4s9X9bmAfNgCbW93XCfbjYuA8YFeV5auAQbIrkS4CHnWuzrXTcu2WbIvMtfTRDkcK3TBERj370PYi4ofUvg59DfDtyDwCvFvSGVXaOtc24Vwr6vhsC841aYeiUGmIjPnV2kR2Kd347fbtop59ALgsP4y7W9LCCsvbXb37WW9b59oepluuMD2ynUyuSTsUhcKGyGihevp3D7AoIs4BHuTYJ6lOMpkcnGvnmG65wvTItqEc2qEodMPt9hPuQ0S8EhGH88lbgPOb1Lci1ZPVZNo61/Yw3XKF6ZHtZHJN2qEodMMQGRPuQ9m5vNVkd5F2mm3AZ/KrGi4CXouIF6u0da6dY7rlCtMj28nkekyrv0Ev+Zb852RXA/xJPu86YHX+/LeB7wIjwA6gp9V9bmAf/gPZf1TzU+CvgLNb3ecK+7AVeBF4i+xTxueAPwT+MF8usv9M6WngZ0C/c3WunZhrN2RbdK7jDw9zYWZmSTucPjIzszbhomBmZomLgpmZJS4KZmaWuCiYmVniomBmZomLgpmZJf8fjZPQ7dv/FYQAAAAASUVORK5CYII=\n"
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAJOCAYAAAAUOGurAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdf5wdZX33/9cbIhgRSDCwhpCyIKkVTEHcQiy96wrKbxv8PsQGqSRI79QWWm3T1oC9b1CIjb2LFCmiUSIBoiEiNClEIUVOra38FgkhUFaIZElMxITAilIWP98/5jpksjln9+zuOTtnz76fj8d5nJlrrpm5rjlnr/2cmWuuUURgZmZmZiNvt6ILYGZmZjZWORAzMzMzK4gDMTMzM7OCOBAzMzMzK4gDMTMzM7OCOBAzMzMzK4gDMasLSRdJ+moN+a6TdNlIlKnCvs+WdGcR+zaz4ZH0JUn/p+hy1EPftkhSSDqsyDJZcRyItTBJJUnbJO1Zh2315F6/lvTL3PzZEfHZiPjjepS7yv47JXX3SbtE0iupDM9L+i9J76q2jYhYGhEnNqqMZjZ0ktanduXF3N/zxyTtBhARH4uIS2vcznsbX+J+y9CegqtxaV6SrpL0uKQpzdAWVWpTrRgOxFqUpHbgfwEB/MFwtxcRbyy/gGeA9+fSlg53+8NwUyrT/sD3gVskqW+mcoNoZk3t/RGxN3AwsBD4JHBtsUUantQefRnoBN4dEc8WW6L6cJtaPw7EWtc5wD3AdcBsAEkzJP1U0u7lTJI+IOmRND1e0pJ0Fm2dpL+t9RdTOjt1Y27+99Iv2uclbZA0p8I6e0u6W9IX0i/GPSX9o6RnJG1OlyLGS9oL+DZwYO4s3IH5bUXEK8AS4M3AmyTNkfSfkq6QtBW4JKV9P7f/IyStlrQ17e+ilL6bpPmSfizp55KWS9qvpqNuZsMWEdsjYiXwh8BsSW/Pd2uQNEnSbal92SrpP9Lf7Q3AbwD/mtqJv035v5navu2SvifpiPK+0navlnR7Oht3r6S35JYPp53YnawN7gA6I2JzWnentihP0r6Srpf0M0k/kfR35bOCfdq15yU9Jel3U/oGSVskzc5ta1Btan910o6zfOdJegb4rqTXS7ox5X1e0v2S2ob+yY9NDsRa1znA0vQ6SVJbRNwD/AI4Ppfvw8DX0/TFQDtwKPA+4I+GsmNJv0H2R34V2Zmqo4CH++R5E3AX8J8R8ReRPWvrc8BvpvyHAVOA/xsRvwBOATbmzsJt7LO9PYE5QHdEPJeSjwWeAg4AFvTJvzfwb8B3gAPT/u5Ki/8COAN4d1q2Dbh6KMfCzIYuIu4DusnO7ufNS+n7A23ARVn2+Ag7n7H/h5T/28A0srbgIbJ2Me8s4NPARKCL1F7UoZ1YCvwWcHxE/LzGal8F7EvWDr+brC0/N7f8WOAR4E1kbfcy4HdS2f4I+GdJb0x5B9um1lKndwNvA04i+5G/LzA1ledjwC9rrKeVRYRfLfYCfg94BZiU5h8H/jJNXwYsTtN7kwVmB6f5p4CTctv5Y7LApu/21wPv7ZN2CXBjmr4QuLVK2a4DFgOPAn+TS1cqy1tyae8Cnk7TnX3Lkvb5P8DzwBbgu8A707I5wDN98s8Bvp+mzwJ+WKWM64ATcvOT0/EcV/Rn65dfrfqq1K6k9HuAT6W247KU9hlgBXBYrdvJLZ9A1mVj3zR/HfDV3PJTgcfT9JDaCbIftAG8AMyrsO5rbVGaD7JAaXfgZeDw3LI/AUq59Z7MLZue1m3Lpf2cLPAaSptaS50OzS3/KPBfwG8X/f0ZzS9f421Ns4E7Y8eZoa+ntCvS9H9J+lPg/wMeioifpHwHAhty28lPD8ZU4Mf9LD8N6AG+lEvbH3gD8KB2dPESWcPUn+URUe3MXX/l76+MBwO3Svp1Lu1Vsl/eLdG/w2wUmQJs7ZP2/8h+iN2Z2otFEbGw0srKumIsAM4ka2fKf9eTgO1p+qe5VV4CymeUhtpOlJ0O3CZpW0QsrrKdvEnAHsBPcmk/ITsGZZtz078EiHTJM5dW7jc72Da1ljrl29UbyI7RMkkTgBuBT0XWVcRq5EuTLUbSeOBDwLtTn4ifAn8JHCnpyIh4jOwP+xR2viwJsAk4KDc/dYjF2AC8pZ/lXyE71b8q9VUAeI6sATkiIiak176RdcSH7JfYYPW3Tn9l3ACckivHhIh4fbRIJ1uz0ULS75AFITv1p4qIFyNiXkQcCrwf+CtJJ5QX99nMh4GZwHvJLqO1lzdfQxGG2078VyrflZI+XMP+niM7A3VwLu03GNoPwKG0qbXU6bX1IuKViPh0RBwO/C5Z4HnOEMo6pjkQaz1nkP2COZzs9PRRZNfz/4MdfyBfJ+sL8PvAN3PrLgculDRR0hTggiGWYSnwXkkfkjRO0pskHdUnzwXAE2S/FsdHxK/JArQrJB0AIGmKpJNS/s1knfD3HWKZ+roNeLOkT6QOrXtLOjYt+xKwQNLBqRz7S5pZp/2a2QAk7SPpdLL+TzdGxJo+y0+XdJiyUz0vkLV5r6bFm8n6V5XtTXa57+dkZ4g+O4iiDLudiIh/J7v6sEjSB/vbWUS8StYOL0j7Ohj4K7IzTYMyxDZ1UG2fpPdImp7OOr5AFkS+Wi2/VeZArPXMBr4WEc9ExE/LL+CfgbOV3XL8DbL+Ad/NXb6ErN9FN/A0WQfVm8kasEGJiGfI+lnMI7uk8DBwZJ88Acwl+wW2QtLryW5V7wLukfRCKsNbU/7HU7mfSnfn7HTX5BDK+CLZDQnvJ7ss8STwnrT4SmAl2WWPF8n6qBxbaTtmVlf/mv7mNpD1C/s8O3dUL5tG1j70AD8AvhgRpbTs74G/S+3EXwPXk10FeBZ4jOzvuSb1aiciYjXZHaDXSXr/ALv9c7K+XU+RnQn8Olm/2qEYbJs62LbvzWT/J14g61/27wwhaBzrlP0/NNtV6kc2KyLeXXRZzMzMWpHPiNlrJE2WdFwaS+atZGe0bi26XGZmZq3Kd01a3h5kI0AfQjYkxDLgi4WWyMzMrIX50qSZmZlZQXxp0szMzKwgTX1pctKkSdHe3l5T3l/84hfstddeA2csULOX0eUbHpevugcffPC5iNi/kJ2PEq3W3g1VK9cNWrt+rVw3qK1+Q2nrmjoQa29v54EHHqgpb6lUorOzs7EFGqZmL6PLNzwuX3WSfjJwrrGt1dq7oWrlukFr16+V6wa11W8obZ0vTZqZJZJeL+k+ST+StFbSp1P6IZLulfSkpJsk7ZHS90zzXWl5e25bF6b0J3KDaJqZ7cSBmJnZDi8Dx0fEkWRPpThZ0gzgc8AVETEN2Aacl/KfB2yLiMPInuX6OQBJhwOzgCOAk4EvptHHzcx24kDMzCyJTE+afV16BXA82QjiAEvIHiUG2TMMl6Tpm4ET0mN3ZgLLIuLliHiabHTzY0agCmY2yjR1HzEzs5GWzlw9CBwGXA38GHg+InpTlm6yB1GT3jcARESvpO3Am1J6/lE6+XXy+5pL9qgv2traKJVKNZWxp6en5ryjTSvXDVq7fq1cN2hc/RyImZnlpAcvHyVpAtmTJd5WKVt6V5Vl1dL77msRsAigo6Mjau3o3Mqdolu5btDa9WvlukHj6udAzGyQ2uffXjF93vRe5lRZVov1C08b8rpWfxHxvKQSMAOYIGlcOit2ELAxZesGpgLdksYB+5I96L6cXpZfZ9jWPLt9WN+1avwdNBt5DsSsZVULmMyqkbQ/8EoKwsYD7yXrgH838EGyx37NBlakVVam+R+k5d+NiJC0Evi6pM8DBwLTgPtGtDI2ZI1qOxzoWiUOxMzMdpgMLEn9xHYDlkfEbZIeA5ZJugz4IXBtyn8tcIOkLrIzYbMAImKtpOXAY0AvcH665GlmthMHYmZmSUQ8AryjQvpTVLjrMSJ+BZxZZVsLgAX1LqOZtRYPX2FmZmZWEAdiZmZmZgVxIGZmZmZWEPcRM2sSvlPLzGzs8RkxMzMzs4I4EDMzMzMriC9NWuFqvSQ33JHrzczMmo3PiJmZmZkVxIGYmZmZWUEciJmZmZkVxIGYmZmZWUHcWd/MzEalRo29ZzaSfEbMzMzMrCAOxMzMzMwK4kuTVjNfBjAzM6svnxEzMzMzK8iAgZikxZK2SHo0l3aJpGclPZxep+aWXSipS9ITkk7KpZ+c0rokza9/VczMhk7SVEl3S1onaa2kj6d0t3dm1jC1XJq8Dvhn4Po+6VdExD/mEyQdDswCjgAOBP5N0m+mxVcD7wO6gfslrYyIx4ZRdjOzeuoF5kXEQ5L2Bh6UtDotc3tnZg0xYCAWEd+T1F7j9mYCyyLiZeBpSV3AMWlZV0Q8BSBpWcrrhsnMmkJEbAI2pekXJa0DpvSzits7Mxu24XTWv0DSOcADZL8it5E1Wvfk8nSzoyHb0Cf92EoblTQXmAvQ1tZGqVSqqTA9PT015y1Ks5dxoPLNm947coWpoG188WXoT7OWr/yZNvv3r5mkH5/vAO4FjqPJ2rtGfdea4fsxmO9pM/699adUKrX032Er1w0aV7+hBmLXAJcCkd4vBz4KqELeoHJftKi04YhYBCwC6OjoiM7OzpoKVCqVqDVvUZq9jAOVb07Bd03Om97L5Wua90bfZi3f+rM7geb//jULSW8EvgV8IiJekNR07d1VS1c05LtW/q4UaTDf06LbpMFaf3ZnS/8dtnLdoHH1G9JfckRsLk9L+gpwW5rtBqbmsh4EbEzT1dLNzJqCpNeRBWFLI+IWcHtnZo01pOErJE3OzX4AKN9RuRKYJWlPSYcA04D7gPuBaZIOkbQHWQfXlUMvtplZfUkScC2wLiI+n0t3e2dmDTPgGTFJ3wA6gUmSuoGLgU5JR5Gdbl8P/AlARKyVtJysU2ovcH5EvJq2cwFwB7A7sDgi1ta9NmZmQ3cc8BFgjaSHU9pFwFlu78ysUWq5a/KsCsnX9pN/AbCgQvoqYNWgSmdmNkIi4vtU7vdVtd1ye2dmw+WR9c3MzMwK0ny3eNmwDfWZkPOm9466u5DMzMxGM58RMzMzMyuIAzEzMzOzgjgQMzMzMyuIAzEzMzOzgjgQMzMzMyuIAzEzMzOzgjgQMzMzMyuIxxEr0FDH+zIzM7PW4DNiZmZmZgVxIGZmZmZWEAdiZmZmZgVxIGZmZmZWEAdiZmZmZgVxIGZmBkiaKuluSeskrZX08ZS+n6TVkp5M7xNTuiR9QVKXpEckHZ3b1uyU/0lJs4uqk5k1PwdiZmaZXmBeRLwNmAGcL+lwYD5wV0RMA+5K8wCnANPSay5wDWSBG3AxcCxwDHBxOXgzM+vLgZiZGRARmyLioTT9IrAOmALMBJakbEuAM9L0TOD6yNwDTJA0GTgJWB0RWyNiG7AaOHkEq2Jmo4gHdDUz60NSO/AO4F6gLSI2QRasSTogZZsCbMit1p3SqqVX2s9csrNptLW1USqVaipf23iYN723tsoMQq37b6Senp6ay9GIY9BIpVJpUPUbbVq5btC4+jkQMzPLkfRG4FvAJyLiBUlVs1ZIi37Sd02MWAQsAujo6IjOzs6aynjV0hVcvqb+zff6s2vbfyOVSiVqPQ5zRtnTSdaf3Tmo+o02rVw3aFz9fGnSzCyR9DqyIGxpRNySkjenS46k9y0pvRuYmlv9IGBjP+lmZrtwIGZmRnYXJHAtsC4iPp9btBIo3/k4G1iRSz8n3T05A9ieLmHeAZwoaWLqpH9iSjMz24UvTZqZZY4DPgKskfRwSrsIWAgsl3Qe8AxwZlq2CjgV6AJeAs4FiIitki4F7k/5PhMRW0emCmY22jgQMzMDIuL7VO7fBXBChfwBnF9lW4uBxfUrnZm1Kl+aNDMzMyuIAzEzMzOzgjgQMzMzMyuIAzEzMzOzgjgQMzMzMyuIAzEzMzOzgjgQMzMzMyvIgIGYpMWStkh6NJe2n6TVkp5M7xNTuiR9QVKXpEckHZ1bZ3bK/6Sk2ZX2ZWZmZjaW1HJG7Drg5D5p84G7ImIacFeaBzgFmJZec4FrIAvcgIuBY4FjgIvLwZuZmZnZWDVgIBYR3wP6Pp5jJrAkTS8BzsilXx+Ze4AJ6SG5JwGrI2JrRGwDVrNrcGdmZmY2pgz1EUdt6eG2RMQmSQek9CnAhly+7pRWLX0XkuaSnU2jra2NUqlUU4F6enpqzluUvmWcN723uMJU0Da++cqU5/INTfk7Nxr+RszMxpp6P2uy0nPaop/0XRMjFgGLADo6OqKzs7OmHZdKJWrNW5S+ZZwz//biClPBvOm9XL6meR8/6vINzfqzO4HR8TdiZjbWDPW/xmZJk9PZsMnAlpTeDUzN5TsI2JjSO/ukl4a4bzMbhPYU8M+b3lvX4H/9wtPqti0zs7FqqMNXrATKdz7OBlbk0s9Jd0/OALanS5h3ACdKmpg66Z+Y0szMzMzGrAHPiEn6BtnZrEmSusnuflwILJd0HvAMcGbKvgo4FegCXgLOBYiIrZIuBe5P+T4TEX1vADAzMzMbUwYMxCLirCqLTqiQN4Dzq2xnMbB4UKUzMxtBkhYDpwNbIuLtKe0S4H8DP0vZLoqIVWnZhcB5wKvAX0TEHSn9ZOBKYHfgqxGxcCTrYWajh0fWNzPb4ToqD61zRUQclV7lIOxwYBZwRFrni5J2l7Q7cDXZuIqHA2elvGZmu2i+W7zMzAoSEd+T1F5j9pnAsoh4GXhaUhfZgNUAXRHxFICkZSnvY3Uurpm1AAdiZmYDu0DSOcADwLw0MPUU4J5cnvz4iH3HTTy20kaHOm5io8asa4Zx5gYz3l0zjtvXn1Kp1NLj+bVy3aBx9XMgZmbWv2uAS8nGPrwUuBz4KNXHR6zU5aOu4yZetXRFQ8asK485V6TBjHfXbGMxDmT92Z0tPZ5fK9cNGlc/B2JmZv2IiM3laUlfAW5Ls9XGTaSfdDOznbizvplZP9Kg1WUfAB5N0yuBWZL2lHQIMA24j2yYnmmSDpG0B1mH/pUjWWYzGz18RszMLKkybmKnpKPILi+uB/4EICLWSlpO1gm/Fzg/Il5N27mAbNDq3YHFEbF2hKtiZqOEAzEzs6TKuInX9pN/AbCgQvoqsgGuzcz65UCsBu116hBa72f9mZmZ2ejmPmJmZmZmBXEgZmZmZlYQX5o0MzMbAe3zb29IF5X1C0+r6/ZsZPmMmJmZmVlBHIiZmZmZFcSBmJmZmVlBHIiZmZmZFcSBmJmZmVlBHIiZmZmZFcSBmJmZmVlBHIiZmZmZFcSBmJmZmVlBHIiZmZmZFcSBmJmZmVlBHIiZmZmZFcSBmJlZImmxpC2SHs2l7SdptaQn0/vElC5JX5DUJekRSUfn1pmd8j8paXYRdTGz0cGBmJnZDtcBJ/dJmw/cFRHTgLvSPMApwLT0mgtcA1ngBlwMHAscA1xcDt7MzPpyIGZmlkTE94CtfZJnAkvS9BLgjFz69ZG5B5ggaTJwErA6IrZGxDZgNbsGd2ZmAIwrugBmZk2uLSI2AUTEJkkHpPQpwIZcvu6UVi19F5Lmkp1No62tjVKpVFuBxsO86b2DqEJtat1/I/X09NRcjkYcg0ZrxGfXDJ8bDO6zG40aVT8HYmZmQ6MKadFP+q6JEYuARQAdHR3R2dlZ046vWrqCy9fUv/lef3Zt+2+kUqlErcdhzvzbG1uYBpg3vbfun10zfG4wuM9uNGpU/Xxp0sysf5vTJUfS+5aU3g1MzeU7CNjYT7qZ2S4ciJmZ9W8lUL7zcTawIpd+Trp7cgawPV3CvAM4UdLE1En/xJRmZrYLX5o0M0skfQPoBCZJ6ia7+3EhsFzSecAzwJkp+yrgVKALeAk4FyAitkq6FLg/5ftMRPS9AcDMDBhmICZpPfAi8CrQGxEd6dbtm4B2YD3woYjYJknAlWQN10vAnIh4aDj7NzOrp4g4q8qiEyrkDeD8KttZDCyuY9HMrEXV49LkeyLiqIjoSPODGnPHzMzMbKxqRB+xwY65Y2ZmZjYmDbePWAB3Sgrgy+lW7MGOubMpv8GhjqvTyPFL6jXmS6PG/qkXl294xlr5Wnm8IDOzkTLcQOy4iNiYgq3Vkh7vJ29NY+sMdVydRo5fUq+xahoxfkw9uXzDM9bK1yxjF5mZjWbDujQZERvT+xbgVrLnqg12zB0zMzOzMWnIP48l7QXsFhEvpukTgc+wY8ydhew65s4FkpaRPQy3POaOmZk1gfYGjVS/fuFpDdmuWSsYznWKNuDWbFQKxgFfj4jvSLqfQYy5Y2ZmZjZWDTkQi4ingCMrpP+cQY65Y2ZmrWswZ9rmTe8dlc+QNBsqP+LIzMzMrCAOxMzMzMwK4kDMzMzMrCDNO+iRmZmZDch3u45uPiNmZmZmVhAHYmZmZmYFcSBmZmZmVhAHYmZmNZC0XtIaSQ9LeiCl7SdptaQn0/vElC5JX5DUJekRSUcXW3oza1burG9mVrv3RMRzufn5wF0RsVDS/DT/SeAUYFp6HQtck97NRo3B3gRQ62C8vglgZz4jZmY2dDOBJWl6CXBGLv36yNwDTJA0uYgCmllz8xkxM7PaBHCnpAC+HBGLgLaI2AQQEZskHZDyTgE25NbtTmmb8huUNBeYC9DW1kapVKqpIG3js7MPraiV6watXb9a61br97zZ9PT0NKTsDsTMzGpzXERsTMHWakmP95NXFdJil4QsmFsE0NHREZ2dnTUV5KqlK7h8TWs23/Om97Zs3aC161dr3daf3dn4wjRAqVSi1r/RwfClSTOzGkTExvS+BbgVOAbYXL7kmN63pOzdwNTc6gcBG0eutGY2WrRmWG5mVkeS9gJ2i4gX0/SJwGeAlcBsYGF6X5FWWQlcIGkZWSf97eVLmGZjnZ8EsDMHYmZmA2sDbpUEWbv59Yj4jqT7geWSzgOeAc5M+VcBpwJdwEvAuSNfZDMbDRyImZkNICKeAo6skP5z4IQK6QGcPwJFM7NRzn3EzMzMzAriQMzMzMysIA7EzMzMzAriQMzMzMysIA7EzMzMzAriQMzMzMysIA7EzMzMzAriQMzMzMysIA7EzMzMzAriQMzMzMysIA7EzMzMzAriQMzMzMysIC3z0O81z25nzvzbiy6GmZmZWc1aJhAzMzOzsau9QSdj1i88rSHbLfOlSTMzM7OCjHggJulkSU9I6pI0f6T3b2Y2EtzWmVktRjQQk7Q7cDVwCnA4cJakw0eyDGZmjea2zsxqNdJnxI4BuiLiqYj4H2AZMHOEy2Bm1mhu68ysJoqIkduZ9EHg5Ij44zT/EeDYiLggl2cuMDfNvhV4osbNTwKeq2NxG6HZy+jyDY/LV93BEbF/QfsecbW0dSm9ldu7oWrlukFr16+V6wa11W/Qbd1I3zWpCmk7RYIRsQhYNOgNSw9ERMdQCzYSmr2MLt/wuHyWM2BbB63d3g1VK9cNWrt+rVw3aFz9RvrSZDcwNTd/ELBxhMtgZtZobuvMrCYjHYjdD0yTdIikPYBZwMoRLoOZWaO5rTOzmozopcmI6JV0AXAHsDuwOCLW1mnzgz69X4BmL6PLNzwunwENb+ugtT/LVq4btHb9Wrlu0KD6jWhnfTMzMzPbwSPrm5mZmRXEgZiZmZlZQVoiEGuGR4lImirpbknrJK2V9PGUvp+k1ZKeTO8TU7okfSGV+RFJR49QOXeX9ENJt6X5QyTdm8p3U+pYjKQ903xXWt4+AmWbIOlmSY+n4/iuZjp+kv4yfbaPSvqGpNcXffwkLZa0RdKjubRBHzNJs1P+JyXNbkRZbfiaoa0bKknrJa2R9LCkB1LaqPyuNvrvTtI707HqSutWGg5lpOt3iaRn0+f3sKRTc8suTGV9QtJJufSK39dq7eYI1a1u/6vr9vlFxKh+kXWE/TFwKLAH8CPg8ALKMRk4Ok3vDfw32aNN/gGYn9LnA59L06cC3yYbb2gGcO8IlfOvgK8Dt6X55cCsNP0l4E/T9J8BX0rTs4CbRqBsS4A/TtN7ABOa5fgBU4CngfG54zan6OMH/D5wNPBoLm1QxwzYD3gqvU9M0xNH4vvo16A+66Zo64ZR/vXApD5po/K72ui/O+A+4F1pnW8DpzRB/S4B/rpC3sPTd3FP4JD0Hd29v+9rtXZzhOpWl//V9fz8Cv/jrMNBfRdwR27+QuDCJijXCuB9ZCNlT859AZ5I018Gzsrlfy1fA8t0EHAXcDxwW/qSPAeM63ssye72eleaHpfyqYFl24cs0FGf9KY4fmSB2Ib0RzcuHb+TmuH4Ae3s3GAO6pgBZwFfzqXvlM+v5ng1a1s3iPKvZ9dAbNR+Vxv1d5eWPZ5L3ylfgfW7hMqB2E7fw3LbV+37Sj//dwr6HIf0v7qen18rXJos/4Ms605phUmXod4B3Au0RcQmgPR+QMpWRLn/Cfhb4Ndp/k3A8xHRW6EMr5UvLd+e8jfKocDPgK8pu3T6VUl70STHLyKeBf4ReAbYRHY8HqR5jl/eYI9Z0/0NWUWj/XMK4E5JDyp7tBO01ne1XnWZkqb7pjeDC9LlucXlS3cMvn79/d8ZUcP8X123z68VArGaHiUyUiS9EfgW8ImIeKG/rBXSGlZuSacDWyLiwRrLMNLHdRzZqfBrIuIdwC/ITg9XM9LHbyLZQ5sPAQ4E9gJO6acMTfW9TKqVqRnLarsa7Z/TcRFxNNnfzfmSfr+fvK30XR1sXZq1jtcAbwGOIvsxenlKH5X1q8P/6rrVrxUCsaZ5lIik15F9sEsj4paUvFnS5LR8MrAlpY90uY8D/kDSemAZ2eXJfwImSCoP7Jsvw2vlS8v3BbY2sHzdQHdE3JvmbyYLzJrl+L0XeDoifhYRrwC3AL9L8xy/vMEes6b5G7J+jerPKSI2pvctwK3AMbTWd7VedelO033TCxURmyPi1Yj4NfAVss8PBl+/56jebo6IOv2vrtvn1wqBWFM8SiTdFXEtsC4iPp9btBIo300xm+x6dDn9nHRHxgxge/m0aCNExIURcVBEtJMdo+9GxNnA3cAHq5SvXO4PpvwN+9USET8FNkh6a0o6AXiMJjl+ZJckZ0h6Q/qsy+VriuPXx2CP2R3AiZImpjN/J6Y0ay5N0dYNhaS9JO1dnib7jj1Ka31X61KXtOxFSTNSW3NObluFKQcpyQfIPj/I6jW7tE4AACAASURBVDdL2Z3ihwDTyDqrV/y+pnawWrvZcHX8X12/z6+oDnJ17mx3KtmdDz8GPlVQGX6P7PTjI8DD6XUq2fXwu4An0/t+Kb+Aq1OZ1wAdI1jWTnbcNXko2R9NF/BNYM+U/vo035WWHzoC5ToKeCAdw38huxOlaY4f8GngcbIG6Aayu4QKPX7AN8guE7xC9kvsvKEcM+CjqaxdwLkj9V30a9Cfd+Ft3RDLfSjZXXM/AtaWyz5av6uN/rsDOlI782Pgn2ngjVKDqN8NqfyPkAUnk3P5P5XK+gS5OwSrfV+rtZsjVLe6/a+u1+fnRxyZmZmZFaQVLk2amZmZjUoOxMzMzMwK4kDMzMzMrCAOxMzMzMwK4kDMzMzMrCAOxMzMzMwK4kDMzMzMrCAOxMzMzMwK4kDMzMzMrCAOxMzMzMwK4kDMzMzMrCAOxMzMzMwK4kDMzMzMrCAOxMY4SV+S9H+KLke9SVorqTNNXyLpxoKLZGYjRFK7pJA0Ls1/W9LsGtctSfrjxpaw2H1KukjSV0dqf9Y/B2ItTtJ6Sb+U9KKk5yX9l6SPSdoNICI+FhGX1rid9za+xP2Wody4PtQnfZKk/5G0vpwWEUdERGmky2hmIyvXxvWUX8CB+TwRcUpELKnDvnYK8FLaHEmv5vb/tKSvSfrN4e5vCOUrpfId2Sf9X1J6J0BEfDYiRjTYtOociI0N74+IvYGDgYXAJ4Friy3SsOwl6e25+Q8DTxdVGDMr3Psj4o3lF7BxhPf/g7TffYH3Ar8EHuzTTo2U/wbOKc9IehMwA/hZAWWxGjgQG0MiYntErAT+EJgt6e2SrpN0Gbx2Zum2dOZsq6T/kLSbpBuA3wD+Nf3i+9uU/5uSfippu6TvSTqivK+03asl3Z7Oxt0r6S255UdIWp32s1nSRSl9N0nzJf1Y0s8lLZe0X5+q3ADkLzOcA1yfz9DfGTxJM9KZwecl/aj8KzEtmyPpqVTmpyWdPegDbWZNJX/pT9Luki6X9Fz6G7+g71ku4GBJ/5nagTslTUrp30vvz6e28F35/UTEqxHx44j4M+DfgUtyZaja7vQp61skfTe1f89JWippQlr2N5K+1Sf/VZL+KZe0FPhDSbun+bOAW4H/ya3zWneN3Fm+2ZKeSfv81MBH1erFgdgYFBH3Ad3A/+qzaF5K3x9oAy7KssdHgGfY8avzH1L+bwPTgAOAh8gagLyzgE8DE4EuYAGApL2BfwO+Q3YJ4TDgrrTOXwBnAO9Oy7YBV/fZ7o3ArNSgvg3YG7i3lrpLmgLcDlwG7Af8NfAtSftL2gv4AnBKOoP4u8DDtWzXzEaN/w2cAhwFHE3W3vT1YeBcsrZtD7J2AuD30/uE1Bb+oJ/93EJqY/trdyqsJ+Dvydq/twFT2RHQ3QicnAvMxpH9sL4ht/5G4DHgxDS/yw/VKn4PeCtwAvB/U9tqI8CB2Ni1kaxByHsFmAwcHBGvRMR/RERU20BELI6IFyPiZbKG4khJ++ay3BIR90VEL1mQdlRKPx34aURcHhG/StsoB1J/AnwqIrpz2/1gn1+r3cATZJcAZlNbI1P2R8CqiFgVEb+OiNXAA8CpafmvgbdLGh8RmyJi7SC2bWbF+Jd0pul5Sf8yQN4PAVemNmYbWXeNvr4WEf8dEb8ElrOj7RqMfBs7ULvzmojoiojVEfFyRPwM+DzZD1MiYhPZWbkzU/aTgeci4sE+m7keOEfSW8mCxv4CxrJPR8QvI+JHwI+AIwdawerDgdjYNQXY2ift/5GdubozXZ6bX23ldDZqYbqE+AKwPi2alMv209z0S8Ab0/RU4MdVNn0wcGu5UQXWAa+SnaHLux6YQ3bWbTB3RB4MnJlrtJ8n+yU4OSJ+Qfbr8mPApnRZ9bcGsW0zK8YZETEhvSqd4co7ENiQm99QIU+1tmsw8m1s1Xan70qSDpC0TNKzqW29kZ3b1SVkgR3p/Ya+2yA7G3c88OdVlldSjzrbEDgQG4Mk/Q5ZI/H9fHo6MzUvIg4F3g/8laQTyov7bObDwEyys1L7Au3lzddQhA3AW/pZdkquUZ0QEa+PiGf75PsWcBrwVET8pIZ95rd/Q5/t7xURCwEi4o6IeB9ZA/k48JVBbNvMmt8m4KDc/NRBrFv1CkEFHwD+I0332+708fdpP78dEfuQBVv5dvVfgN9ONwKczq5dQoiIl8i6jvwptQdiVhAHYmOIpH0knQ4sA26MiDV9lp8u6TBJAl4gOxP1alq8GTg0l31v4GXg58AbgM8Ooii3AW+W9AlJe0raW9KxadmXgAWSDk5l2l/SzL4bSGevjgcGewv2jcD7JZ2Uzuq9XlKnpIMktUn6g9RX7GWghx31N7PWsBz4uKQpqa/VJwex7s/Iui8cWmlhalMOkXQV0EnWRxb6aXcqbGZvsrbn+dS37G/yCyPiV8DNwNeB+yLimSplvQh4d0SsH0T9rAAOxMaGf5X0Itmvsk+R9Tk4t0K+aWSd6HuAHwBfzI3F9ffA36XT6n9NdmnwJ8CzZB1D76m1MBHxIvA+srNuPwWeBN6TFl8JrCS7PPpi2u6xVbbzQERUu8RZbd8byM7kXUTWqG4ga+h2S695ZH07tpL1y/izwWzfzJreV4A7gUeAHwKrgF5q+NGVzjQtAP4ztYUz0qJ3KRu/7AWgBOwD/E75x+4A7U5fnya7iWA7WQf/WyrkWQJMp5+zXRGxMSK+X225NQ/10xfbzMyspUk6BfhSRBxcdFlqJek3yLpOvDkiXii6PDY8PiNmZmZjhqTxkk6VNC5d+ruYbJytUUHZU1H+CljmIKw1+IyYmZmNGZLeQDbY6m+RjYB/O/Dx0RDUpP6rm8m6hZycLnnaKOdAzMzMzKwgvjRpZmZmVpCmDsQkfafoMpjZ8Plv2cyssnEDZynOPvvsc1JHR0dN105/8YtfsNdeezW6SDVzefrXTOVpprJAy5an6fvfFG3SpEnR3t5eU94ivyNF7dt19r5Hw34ffPDB5yKi0jNEq4uIpn29853vjFrdfffdNecdCS5P/5qpPM1UlojWLA/wQDRBm9LMr9HS3hW1b9fZ+x4N+x1KWzfgpck0AvB9kn4kaa2kT6f0QyTdK+lJSTdJ2iOl75nmu9Ly9ty2LkzpT0g6aVARo5mZmVmLqaWP2MvA8RFxJNkT6E9Oowl/DrgiIqYB24DzUv7zgG0RcRhwRcqHpMOBWcARZE+M/6Kk3etZGTMzM7PRZMBALJ1t60mzr0uvIHvO380pfQlQfuL9zDRPWn5CenbhTLIB6F6OiKeBLuCYutTCzMzMbBSqqbN+OnP1IHAYcDXwY+D5iOhNWbqBKWl6CtlztIiIXknbgTel9PzzCPPr5Pc1F5gL0NbWRqlUqqkiPT09NecdCS5P/5qpPM1UFnB5RoKkxcDpwJaIeHtK2w+4CWgH1gMfioht6YfklcCpwEvAnIh4KK0zG/i7tNnLImJJSn8ncB0wnuxZhh9P/UfMzHZSUyAWEa8CR6Un1d8KvK1StvSuKsuqpffd1yJgEUBHR0d0dnbWUkRKpRK15h0JLk//mqk8zVQWcHlGyHXAP5M9vL5sPnBXRCyUND/NfxI4BZiWXscC1wDHpsDtYqCDrC17UNLKiNiW8swl+/G5iqw7xrdHoF5mNsoMaviKiHheUgmYAUyQNC6dFTsI2JiydQNTgW5J44B9ga259LL8OsO25tntzJl/e702t5P1C09ryHbNrBgR8b38jUTJTKAzTS8BSmSB2Ezg+nRG6x5JEyRNTnlXR8RWAEmryfrQloB9IuIHKf16sq4bdQvEGtXeua0zG3kDBmKS9gdeSUHYeOC9ZB3w7wY+CCwDZgMr0ior0/wP0vLvRkRIWgl8XdLngQPJfl3eV+f6WAO117Hhnze997V/JG78rUm0RcQmgIjYJOmAlP5ad4uk3K2iv/TuCum7GGpXjLbx2d9QvdWy/6IuVRd5idx1Hhv7Lmq/tZwRmwwsSf3EdgOWR8Rtkh4Dlkm6DPghcG3Kfy1wg6QusjNhswAiYq2k5cBjQC9wfrrkaWbWzAbb3aKmbhgw9K4YVy1dweVr6j8e9/qzB95/UZeqi7xE7jqPjX0Xtd8B/5Ij4hHgHRXSn6LCXY8R8SvgzCrbWgAsGHwxzcwabrOkyels2GRgS0qv1q2imx2XMsvppZR+UIX8Zma7aOpnTZqZjaBytwrYtbvFOcrMALanS5h3ACdKmihpInAicEda9qKkGemOy3Ny2zIz20lTP2vSzKwRJH2D7GzWJEndZHc/LgSWSzoPeIYdZ/ZXkQ1d0UU2fMW5ABGxVdKlwP0p32fKHfeBP2XH8BXfxndMmlkVDsTMbMyJiLOqLDqhQt4Azq+yncXA4grpDwBvH04ZzWxs8KVJMzMzs4I4EDMzMzMriAMxMzMzs4I4EDMzMzMriAMxMzMzs4I4EDMzMzMriAMxMzMzs4J4HLEWVOnh3PmHbJuZmVlz8BkxMzMzs4I4EDMzMzMriAMxMzMzs4I4EDMzMzMryICBmKSpku6WtE7SWkkfT+mXSHpW0sPpdWpunQsldUl6QtJJufSTU1qXpPmNqZKZmZnZ6FDLXZO9wLyIeEjS3sCDklanZVdExD/mM0s6HJgFHAEcCPybpN9Mi68G3gd0A/dLWhkRj9WjImZmZmajzYCBWERsAjal6RclrQOm9LPKTGBZRLwMPC2pCzgmLeuKiKcAJC1LeR2ImZmZ2Zg0qHHEJLUD7wDuBY4DLpB0DvAA2VmzbWRB2j251brZEbht6JN+bIV9zAXmArS1tVEqlWoqW9v4bKysRqi1DHk9PT1DWq8eKh2HRh6fociXp6jjVFbkZ1WJy2NmNnbUHIhJeiPwLeATEfGCpGuAS4FI75cDHwVUYfWgcn+02CUhYhGwCKCjoyM6OztrKt9VS1dw+ZrGjE+7/uzaypBXKpWotez1Vmng1nnText2fIYiX56hHN96KvKzqsTlMTMbO2r6zyzpdWRB2NKIuAUgIjbnln8FuC3NdgNTc6sfBGxM09XSzczMzMacWu6aFHAtsC4iPp9Ln5zL9gHg0TS9EpglaU9JhwDTgPuA+4Fpkg6RtAdZh/6V9amGmZmZ2ehTyzhixwEfAY7vM1TFP0haI+kR4D3AXwJExFpgOVkn/O8A50fEqxHRC1wA3AGsA5anvGZmTUHSX6Zheh6V9A1Jr08/Hu+V9KSkm9IPSdKPzZvScDz3pj605e1UHMLHzKyvWu6a/D6V+32t6medBcCCCumr+lvPzKwokqYAfwEcHhG/lLSc7Mz9qWRD9SyT9CXgPOCa9L4tIg6TNAv4HPCH1YbwiYhXC6iWmTU5j6xvZrbDOGC8pHHAG8iG7jkeuDktXwKckaZnpnnS8hNSV47XhvCJiKeB/BA+ZmY7aZ7b6MzMChQRz0r6R+AZ4JfAncCDwPOpawXsPBzPFNKQPBHRK2k78Cb6H8JnJ802XE8t+y9qOJMih1FxncfGvovarwMxMzNA0kSys1mHAM8D3wROqZC1POxOtaF6qqXvmthkw/XUMpRMUcOZFDmMius8NvZd1H59adLMLPNe4OmI+FlEvALcAvwuMCFdqoSdh915baietHxfYCv9D+FjZrYTB2JmZplngBmS3pD6ep1Advf33cAHU57ZwIo0vTLNk5Z/NyKC6kP4mJntwpcmzcyAiLhX0s3AQ0Av8EOyy4a3A8skXZbSrk2rXAvckJ6nu5XsTkkiYm264/KxtJ3zfcekmVXjQMzMLImIi4GL+yQ/RYW7HiPiV8CZVbZTcQgfM7O+fGnSzMzMrCAOxMzMzMwK4kDMzMzMrCAOxMzMzMwK4kDMzMzMrCAOxMzMzMwK4kDMzMzMrCAOxMzMzMwKMmAgJmmqpLslrZO0VtLHU/p+klZLejK9T0zpkvQFSV2SHpF0dG5bs1P+JyXNrrZPMzMzs7GgljNivcC8iHgbMAM4X9LhwHzgroiYBtyV5gFOIXu22jRgLnANZIEb2YjVx5KNUn1xOXgzMzMzG4sGDMQiYlNEPJSmXwTWAVOAmcCSlG0JcEaanglcH5l7gAmSJgMnAasjYmtEbANWAyfXtTZmZmZmo8ignjUpqR14B3Av0BYRmyAL1iQdkLJNATbkVutOadXS++5jLtmZNNra2iiVSjWVrW08zJveW3tlBqHWMuT19PQMab16qHQcGnl8hiJfnqKOU1mRn1UlLo+Z2dhRcyAm6Y3At4BPRMQLkqpmrZAW/aTvnBCxCFgE0NHREZ2dnTWV76qlK7h8TWOeYb7+7NrKkFcqlai17PU2Z/7tu6TNm97bsOMzFPnyDOX41lORn1UlLo+Z2dhR012Tkl5HFoQtjYhbUvLmdMmR9L4lpXcDU3OrHwRs7CfdzMzMbEyq5a5JAdcC6yLi87lFK4HynY+zgRW59HPS3ZMzgO3pEuYdwImSJqZO+iemNDMzM7MxqZZrVccBHwHWSHo4pV0ELASWSzoPeAY4My1bBZwKdAEvAecCRMRWSZcC96d8n4mIrXWphZmZmdkoNGAgFhHfp3L/LoATKuQP4Pwq21oMLB5MAc3MzMxalUfWNzMzMyuIAzEzMzOzgjgQMzMzMyuIAzEzs0TSBEk3S3o8PV/3XX6urpk1kgMxM7MdrgS+ExG/BRxJ9kg3P1fXzBrGgZiZGSBpH+D3ycZNJCL+JyKex8/VNbMGap5n3piZFetQ4GfA1yQdCTwIfJwGPVcXmu/ZurXsv6hnjxb5zFPXeWzsu6j9OhAzM8uMA44G/jwi7pV0JTsuQ1YyrOfqQvM9W7eW574W9ezRIp956jqPjX0XtV9fmjQzy3QD3RFxb5q/mSww83N1zaxhHIiZmQER8VNgg6S3pqQTgMfwc3XNrIF8adLMbIc/B5ZK2gN4iuxZubvh5+qaWYM4EDMzSyLiYaCjwiI/V9fMGsKXJs3MzMwK4kDMzMzMrCAOxMzMzMwK4kDMzMzMrCADBmKSFkvaIunRXNolkp6V9HB6nZpbdmF6CO4Tkk7KpZ+c0rok9TdIopmZmdmYUMsZseuo/Jy0KyLiqPRaBSDpcGAWcERa54uSdpe0O3A12UNyDwfOSnnNzMzMxqwBh6+IiO9Jaq9xezOBZRHxMvC0pC7gmLSsKyKeApC0LOV9bNAlNjMzM2sRwxlH7AJJ5wAPAPMiYhvZg23vyeXJP+y270Nwj6200WZ7CC7U9iDcvop8YGql49DI4zMU+fIUdZzKivysKnF5zMzGjqEGYtcAl5I9yPZS4HLgo1R/2G2lS6Cj4iG4UNuDcPsq8oGpc+bfvkvavOm9DTs+Q5Evz1CObz0V+VlV4vKYmY0dQ/rPHBGby9OSvgLclmb7e9itH4JrZmZmljOk4SskTc7NfgAo31G5EpglaU9JhwDTgPvInrk2TdIh6Rlus1JeMzMzszFrwDNikr4BdAKTJHUDFwOdko4iu7y4HvgTgIhYK2k5WSf8XuD8iHg1becC4A5gd2BxRKyte23MzMzMRpFa7po8q0Lytf3kXwAsqJC+Clg1qNKZmZmZtTCPrG9mZmZWEAdiZmZmZgVpnvEMbMxqrzDcRj2sX3haQ7ZrZmZWLz4jZmZmZlYQB2JmZmZmBXEgZmZmZlYQB2JmZjmSdpf0Q0m3pflDJN0r6UlJN6VBqUkDV98kqSstb89t48KU/oSkk4qpiZmNBg7EzMx29nFgXW7+c8AVETEN2Aacl9LPA7ZFxGHAFSkfkg4ne3rIEcDJwBcl7T5CZTezUcaBmJlZIukg4DTgq2lewPHAzSnLEuCMND0zzZOWn5DyzwSWRcTLEfE00AUcMzI1MLPRxsNXmJnt8E/A3wJ7p/k3Ac9HRG+a7wampOkpwAaAiOiVtD3lnwLck9tmfp2dSJoLzAVoa2ujVCrVVMi28TBveu/AGQeplv339PTUXM56Kmq/Re57LNa5yH0XtV8HYmZmgKTTgS0R8aCkznJyhawxwLL+1tk5MWIRsAigo6MjOjs7K2XbxVVLV3D5mvo33+vPHnj/pVKJWstZT0Xtt8h9j8U6F7nvovbrQMzMLHMc8AeSTgVeD+xDdoZsgqRx6azYQcDGlL8bmAp0SxoH7AtszaWX5dcxM9uJ+4iZmQERcWFEHBQR7WSd7b8bEWcDdwMfTNlmAyvS9Mo0T1r+3YiIlD4r3VV5CDANuG+EqmFmo4zPiJmZ9e+TwDJJlwE/BK5N6dcCN0jqIjsTNgsgItZKWg48BvQC50fEqyNfbDMbDRyImZn1EREloJSmn6LCXY8R8SvgzCrrLwAWNK6EZtYqBrw0KWmxpC2SHs2l7SdpdRrgcLWkiSldkr6QBjJ8RNLRuXVmp/xPSppdaV9mZmZmY0ktfcSuIxuUMG8+cFca4PCuNA9wCll/iGlkt2RfA1ngBlwMHEv2y/LicvBmZmZmNlYNGIhFxPfI+j/k5Qcy7DvA4fWRuYfsbqPJwEnA6ojYGhHbgNXsGtyZmZmZjSlD7SPWFhGbACJik6QDUvprAxwm5YEMq6XvotkGOITaBjnsq8jB8Codh0Yen6EYifLUevyL/KwqcXnMzMaOenfWb7kBDqG2QQ77KnIwvDnzb98lbd703oYdn6EYifLU+rkV+VlV4vKYmY0dQx1HbHO65Eh635LSqw1k6AEOzczMzPoYaiCWH8iw7wCH56S7J2cA29MlzDuAEyVNTJ30T0xpZmZmZmPWgNeGJH0D6AQmSeomu/txIbBc0nnAM+wYS2cVcCrQBbwEnAsQEVslXQrcn/J9JiL63gBgZmZmNqYMGIhFxFlVFp1QIW8A51fZzmJg8aBKZ2ZmZtbC/KxJMzMzs4I4EDMzMzMriAMxMzMzs4I4EDMzMzMriAMxMzMzs4I0z1DrTay9wkj1A5k3vbfiCPd56xeeNtQimZmZWQvwGTEzMzOzgjgQMzMzMyuIL00WaCiXPM3MzKx1+IyYmZmZWUEciJmZmZkVxJcmrWXVeum3ljtc83y3a2uSNBW4Hngz8GtgUURcKWk/4CagHVgPfCgitkkScCVwKvASMCciHkrbmg38Xdr0ZRGxZCTrYmajh8+ImZlleoF5EfE2YAZwvqTDgfnAXRExDbgrzQOcAkxLr7nANQApcLsYOBY4BrhY0sSRrIiZjR4OxMzMgIjYVD6jFREvAuuAKcBMoHxGawlwRpqeCVwfmXuACZImAycBqyNia0RsA1YDJ49gVcxsFPGlSTOzPiS1A+8A7gXaImITZMGapANStinAhtxq3SmtWnql/cwlO5tGW1sbpVKppvK1jc8uqddbLfvv6empuZz1VNR+i9z3WKxzkfsuar/DCsQkrQdeBF4FeiOiYyj9KczMmoWkNwLfAj4RES9kTVflrBXSop/0XRMjFgGLADo6OqKzs7OmMl61dAWXr6n/7+j1Zw+8/1KpRK3lrKei9lvkvsdinYvcd1H7rcelyfdExFER0ZHmB9WfwsysWUh6HVkQtjQibknJm9MlR9L7lpTeDUzNrX4QsLGfdDOzXTTi0uRMoDNNLwFKwCfJ9acA7pE0QdLk8il/s9GiUQPx+m7MYqWz9tcC6yLi87lFK4HZwML0viKXfoGkZWQd87enS5d3AJ/NddA/EbhwJOpgZqPPcAOxAO6UFMCX02n2wfan2CkQa7Y+E0Pl8vSvmcrTLGUpf9eL7JtRSbOVp4GOAz4CrJH0cEq7iCwAWy7pPOAZ4My0bBVZV4susu4W5/L/t3fv0ZKV5Z3Hv7/hJtJGcMAOt9iYkMQLEbGDZMxyNZpwMwm6lmZhiIKXkJmBiU7IGlEzETXMIol4jcFphQgRbRkV6VEMIrHHmCVyUaRBVFroaNuE1nDR9prGZ/6o90ilrXNOndNVtc/l+1mrVu397rf2++z3VO16zt7vrg1U1b1JXg/c0Oq9rqruncwmSFpsdjURe1pVbW3J1jVJvjRD3aHGTSy0MRPzdfYRO4xnBgspnoUSy9T4nC7HZgyy0OIZl6r6NIP3UwDPHFC/gDOnWdfFwMWji07SUrVLY8Sqamt73gZcQe83c+Y6nkKSJGlZmncilmSfJI+YmqY3DuJWHhpPAT89nuKF6TmGNp5i3pFLkiQtcrtyPmYlcEW7tHt34L1V9fdJbmAO4ykk9UxdBDDXWy7NxosAJGnhmnciVlV3Ak8aUP6vzHE8hSRJ0nLkLY4kSZI6YiImSZLUERMxSZKkjpiISZIkdcRETJIkqSMmYpIkSR0xEZMkSeqIiZgkSVJHTMQkSZI6YiImSZLUERMxSZKkjpiISZIkdWTeN/2WJElL16pzPjqW9W4+/1ljWe9iZSImLXG7ujM9+4gdnD5gHe5MNaxRfKEPeh8utvfgXPthus/ezhZbP4zLYt3XmYhJkrSIjePI1dlH7MAUYTIm3stJTgDeAuwGvKuqzp90DJI0botxXzfMF/qwR2kmYVynzna2kLZ5KZjt77bc+nuig/WT7Aa8HTgReDzw/CSPn2QMkjRu7uskDWvSV00eDWyqqjur6kfAOuDkCccgSePmvk7SUCadiB0MfL1vfksrk6SlxH2dpKGkqibXWPI84PiqemmbfwFwdFX9t746ZwBntNlfAr485Or3B741wnB3lfHMbCHFs5BigaUZz2Oq6oBRBLMYDLOva+WLcX/XVdtus20vhnbnvK+b9GD9LcChffOHAFv7K1TVWmDtXFec5MaqWr1r4Y2O8cxsIcWzkGIB41kiZt3XweLc33XVttts20u13UmfmrwBODzJYUn2BE4B1k84BkkaN/d1koYy0SNiVbUjyVnA1fQu6b64qm6bZAySNG7u6yQNa+K/I1ZVVwFXjWHVcz68P2bGM7OFFM9CigWMZ0kY474Ouv2bdNW222zbS7LdiQ7WlyRJ0kMmPUZMkiRJzZJIxJKckOTLSTYlOWdMbRya5JNJbk9yW5KXtfJHJbkmyR3teb9WniRvbTHdkuSovnWd1urfhT+CSAAAHgFJREFUkeS0XYxrtySfT/KRNn9Yks+2db+/DRQmyV5tflNbvqpvHa9s5V9OcvwuxLJvkg8k+VLrp1/rqn+S/Pf2d7o1yfuSPGySfZPk4iTbktzaVzayvkjylCQb22vemiTziOev2t/qliRXJNl3tu2e7rM2Xd9qtKbr/zG2t7m9z25OcmMrG/g+HkFbI/nMjKjdc5N8o233zUlO6ls2kv1lW9fIvldG1O7Ytzu9ffH1Sb7Q2n5tKx+4D8kM++cRtv3uJHf1bfeRrXxk77MZVdWiftAbCPtV4LHAnsAXgMePoZ0DgaPa9COAr9C7dclfAue08nOAv2jTJwEfAwIcA3y2lT8KuLM979em99uFuP4YeC/wkTZ/OXBKm34H8F/a9H8F3tGmTwHe36Yf3/psL+Cw1pe7zTOWS4CXtuk9gX276B96P5x5F7B3X5+cPsm+AZ4OHAXc2lc2sr4Argd+rb3mY8CJ84jnOGD3Nv0XffEM3G5m+KxN17c+RveYqf/H2OZmYP+dyga+j0fQ1i5/ZkbY7rnAnwyoO7L9ZVvfSL5XRtju2Le7xb6iTe8BfLZty5z2zyNu+93AcwfUH9n7bKbHUjgiNpFbiVTV3VX1uTb9HeB2el/4J9NLQGjPz27TJwOXVs91wL5JDgSOB66pqnur6j7gGuCE+cSU5BDgWcC72nyAZwAfmCaeqTg/ADyz1T8ZWFdVP6yqu4BN9Pp0rrH8DL0d2kUAVfWjqrqf7vpnd2DvJLsDDwfuZoJ9U1WfAu7dqXgkfdGW/UxVfaZ6e4tL+9Y1dDxV9fGq2tFmr6P3W1dT8Qza7oGftVnedxqdhXLbpOnex7tkRJ+ZUbU7nZHsL/vaHtX3yqjanc7ItrvFvr3N7tEexdz3z6Nsezoje5/NZCkkYhO/lUg7NPpketn0yqq6G3pvbuDRs8Q1ynjfDPwP4Mdt/j8C9/d9ufav+yfttuUPtPqjiuexwDeBv03vVOm7kuxDB/1TVd8A3gB8jV4C9gBwE931zZRR9cXBbXpUcQG8mN5/fvOJZ6b3nUani9smFfDxJDeldxcAmP59PA5z/cyM0lntdNTFfadfx9buLn6vjKpdmMB2pzek5mZgG71/ML/K3PfPI2m7qqa2+7y23W9KstfObQ+Ia2SWQiI2KDMe26WgSVYAHwReXlXfnqnqgLKaoXyucfwWsK2qbhqizbHHQ+8I1FHAhVX1ZOC79A6pT2ds8bSdx8n0DqEfBOwDnDjDesfdN7OZa/sjjSvJq4EdwGULIR5Nq4t+flpVHUXv83NmkqePub1hjbsvLgR+HjiS3j9zF4yz3RF8r4yq3Ylsd1U9WFVH0jsKfzTwuBnWP9a2kzwReCXwy8Cv0hsK8opxtD2dpZCIDXUrkVFIsge9N+1lVfWhVnzP1KHK9rxtlrhGFe/TgN9JspneKYpn0DtCtm87Hbfzun/Sblv+SHqH40cVzxZgS99/Fx+gl5h10T+/AdxVVd+sqn8DPgT8J7rrmymj6ostPHQacZfiSu8CgN8CTm2nOecTz7eYvm81OhPb102pqq3teRtwBb0vzenex+Mw18/MSFTVPe0L+8fAO3noNNzI2x3R98pI2p3kdrf27gc20Bt/Ndf986jaPqGdqq2q+iHwt4x5u3e2FBKxidxKpJ2Tvgi4vare2LdoPTB1NdtpwJV95S9sV10cAzzQDjFfDRyXZL925Oa4VjYnVfXKqjqkqlbR2+Z/qKpTgU8Cz50mnqk4n9vqVys/pV2ZchhwOL2B4HON51+Aryf5pVb0TOCLdNM/XwOOSfLw9nebiqWTvukzkr5oy76T5Ji2fS/sW9fQkpxA7z+/36mq7+0U56DtHvhZa301Xd9qdCZ626Qk+yR5xNQ0vfffrUz/Ph6HuX5mRmKncUDPobfdU+2ObJ8wwu+VkbQ7ie1OckDaFdpJ9qb3j/PtzH3/PKq2v9SX9Ibe2LT+7R7b++wnagxXAEz6Qe/Khq/QO8/86jG18ev0DkneAtzcHifRO1d9LXBHe35UPXR1xttbTBuB1X3rejG9wY6bgBeNILY1PHTV5GPpfUA2Af8H2KuVP6zNb2rLH9v3+le3OL/MLFffzRLHkcCNrY8+TO9Kv076B3gt8CV6H6i/o3e1z8T6BngfvUP7/0bvv6qXjLIvgNVt274K/DXtx5nnGM8meuMfpt7P75htu5nmszZd3/oY7WO6/h9TW4+ld6XcF4Dbptqb7n08gvZG8pkZUbt/19Z7C70v4wP76o9kf9nWNbLvlRG1O/btBn4F+Hxr41bgz/reb3PaP4+w7X9o230r8B4eurJyZO+zmR7+sr4kSVJHlsKpSUmSpEXJREySJKkjJmKSJEkdMRGTJEnqiImYJElSR0zEJEmSOmIiJkmS1BETMUmSpI6YiEmSJHXEREySJKkjJmKSJEkdMRGTJEnqiImYJElSR0zEJEmSOmIitgwkWZWkkuze5j+W5LQhX7shyUtHGMv2JI8d1fokSVrMTMSWmCSbk3y/JTzbk2wHDuqvU1UnVtUlI2hr5wTvVX3t/iDJg33zt7W2V1TVnbva9oBYzk3yngHlleQXRt2eJEmjYCK2NP12S3hWVNUKYOskGq2q/9XX5n8GPtMXxxMmEcOkJNmt6xgkSYufidgy1H+6McluSS5I8q0kdyU5q/8oV/OYJP+U5DtJPp5k/1b+qfZ8fzvq9WtDtP2TI1RJ3p3kb9qp0u2tjZ9N8uYk9yX5UpIn9732oCQfTPLNFusfzXG792rr3toeb06yV1t2epJPzxLrhUmuSvJd4Ni5tC1J0iAmYvoD4ETgSOAo4NkD6vwe8CLg0cCewJ+08qe3533bUa/PzKP93wX+FNgf+CHwGeBzbf4DwBsBkvwH4P8CXwAOBp4JvDzJ8XNo69XAMfS29UnA0a3tYf0ecB7wCODTs9SVJGlWJmJL04eT3N8eH56l7u8Cb6mqLVV1H3D+gDp/W1VfqarvA5fTS2RG5YqquqmqfgBcAfygqi6tqgeB9wNTR8R+FTigql5XVT9q48zeCZzSvy19231/kvt3autU4HVVta2qvgm8FnjBHGK9sqr+qap+3OKVJGmX7D57FS1Cz66qT0zNJFk1Q92DgK/3zX99QJ1/6Zv+HrBiV4LbyT19098fMD/V1mOAg3ZKrnYD/rFv/vKq+v3+lSepvtmDgH/um/9ndrqQYRaD+kaSpHkzEdPdwCF984fO4bU1e5WR+TpwV1Udvgvr2Eovobutzf8cD13I8F3g4VMVk/zsgNdPcnslScuApyZ1OfCyJAcn2Rd4xRxe+03gx8AkfhfseuDbSV6RZO92kcETk/zqHNbxPuBPkxzQLjj4M2DqJy++ADwhyZFJHgacO9LoJUkawERM7wQ+DtwCfB64CtgBPDjbC6vqe/QGr/9TG5N1zLiCbGPGfpve+LS7gG8B7wIeOYfV/DlwI71t3UjvooA/b+v/CvA64BPAHTgYX5I0AanybIsekuRE4B1V9ZiuY5EkaanziNgy107znZRk9yQHA6+hd/WiJEkaM4+ILXNJHg78P+CX6V2l+FHgZVX17U4DkyRpGTARkyRJ6oinJiVJkjqyoH9HbP/9969Vq1YNVfe73/0u++yzz3gDGpKxDGYsCzcOGG8sN91007eq6oCxrFySFrEFnYitWrWKG2+8cai6GzZsYM2aNeMNaEjGMpixLNw4YLyxJPnn2WtJ0vLjqUlJkqSOmIhJkiR1xERMkiSpIyZikiRJHTERkyRJ6siCvmpyqVt1zkfHst7N5z9rLOuVJEmj5RExSZKkjpiISZIkdcRETJIkqSMmYpIkSR0xEZMkSeqIiZgkSVJHZk3EkjwsyfVJvpDktiSvbeWHJflskjuSvD/Jnq18rza/qS1f1beuV7byLyc5flwbJUmStBgMc0Tsh8AzqupJwJHACUmOAf4CeFNVHQ7cB7yk1X8JcF9V/QLwplaPJI8HTgGeAJwA/E2S3Ua5MZIkSYvJrIlY9Wxvs3u0RwHPAD7Qyi8Bnt2mT27ztOXPTJJWvq6qflhVdwGbgKNHshWSJEmLUKpq9kq9I1c3Ab8AvB34K+C6dtSLJIcCH6uqJya5FTihqra0ZV8Fngqc217znlZ+UXvNB3Zq6wzgDICVK1c+Zd26dUNtyPbt21mxYsVQdcdt2Fg2fuOBsbR/xMGPnHMsk2AsCzcOGG8sxx577E1VtXosK5ekRWyoWxxV1YPAkUn2Ba4AHjeoWnvONMumK9+5rbXAWoDVq1fXmjVrhgmRDRs2MGzdcRs2ltPHdYujUx9qezH2yyQslFgWShywsGKRpOViTldNVtX9wAbgGGDfJFOJ3CHA1ja9BTgUoC1/JHBvf/mA10iSJC07w1w1eUA7EkaSvYHfAG4HPgk8t1U7DbiyTa9v87Tl/1C985/rgVPaVZWHAYcD149qQyRJkhabYU5NHghc0saJ/Qfg8qr6SJIvAuuS/DnweeCiVv8i4O+SbKJ3JOwUgKq6LcnlwBeBHcCZ7ZSnJEnSsjRrIlZVtwBPHlB+JwOueqyqHwDPm2Zd5wHnzT1MSZKkpcdf1pckSerIUFdNLgYbv/HA+K5CPP9ZY1mvJEla3jwiJkmS1BETMUmSpI6YiEmSJHXEREySJKkjJmKSJEkdMRGTJEnqiImYJElSR0zEJEmSOmIiJkmS1BETMUmSpI6YiEmSJHVk1ntNJjkUuBT4WeDHwNqqekuSc4E/AL7Zqr6qqq5qr3kl8BLgQeCPqurqVn4C8BZgN+BdVXX+aDdHAKv67rl59hE7RnYPTu+5KUnSaA1z0+8dwNlV9bkkjwBuSnJNW/amqnpDf+UkjwdOAZ4AHAR8IskvtsVvB34T2ALckGR9VX1xFBsiSZK02MyaiFXV3cDdbfo7SW4HDp7hJScD66rqh8BdSTYBR7dlm6rqToAk61pdEzFJkrQspaqGr5ysAj4FPBH4Y+B04NvAjfSOmt2X5K+B66rqPe01FwEfa6s4oape2spfADy1qs7aqY0zgDMAVq5c+ZR169YNFdu2ex/gnu8PvSlzcsTBj5xT/e3bt7NixYpZ6238xgPzDWloK/dmZP0y137Y2bD9MgkLJZaFEgeMN5Zjjz32pqpaPZaVS9IiNsypSQCSrAA+CLy8qr6d5ELg9UC15wuAFwMZ8PJi8IUBP5UFVtVaYC3A6tWra82aNUPF97bLruSCjUNvzpxsPnW4GKZs2LCBYeIe1ditmZx9xI6R9ctc+2Fnw/bLJCyUWBZKHLCwYpGk5WKob+gke9BLwi6rqg8BVNU9fcvfCXykzW4BDu17+SHA1jY9XbkkSdKyM+vPVyQJcBFwe1W9sa/8wL5qzwFubdPrgVOS7JXkMOBw4HrgBuDwJIcl2ZPegP71o9kMSZKkxWeYI2JPA14AbExycyt7FfD8JEfSO724GfhDgKq6Lcnl9Abh7wDOrKoHAZKcBVxN7+crLq6q20a4LZIkSYvKMFdNfprB476umuE15wHnDSi/aqbXSZIkLSf+sr4kSVJHTMQkSZI6YiImSZLUERMxSZKkjpiISZIkdcRETJIkqSMmYpIkSR0xEZMkSeqIiZgkSVJHTMQkSZI6YiImSZLUERMxSZKkjpiISZIkdcRETJIkqSOzJmJJDk3yySS3J7ktycta+aOSXJPkjva8XytPkrcm2ZTkliRH9a3rtFb/jiSnjW+zJEmSFr5hjojtAM6uqscBxwBnJnk8cA5wbVUdDlzb5gFOBA5vjzOAC6GXuAGvAZ4KHA28Zip5kyRJWo5mTcSq6u6q+lyb/g5wO3AwcDJwSat2CfDsNn0ycGn1XAfsm+RA4Hjgmqq6t6ruA64BThjp1kiSJC0iqarhKyergE8BTwS+VlX79i27r6r2S/IR4Pyq+nQrvxZ4BbAGeFhV/Xkr/5/A96vqDTu1cQa9I2msXLnyKevWrRsqtm33PsA93x96U+bkiIMfOaf627dvZ8WKFbPW2/iNB+Yb0tBW7s3I+mWu/bCzYftlEhZKLAslDhhvLMcee+xNVbV6LCuXpEVs92ErJlkBfBB4eVV9O8m0VQeU1Qzl/76gai2wFmD16tW1Zs2aoeJ722VXcsHGoTdnTjafOlwMUzZs2MAwcZ9+zkfnF9AcnH3EjpH1y1z7YWfD9sskLJRYFkocsLBikaTlYqirJpPsQS8Ju6yqPtSK72mnHGnP21r5FuDQvpcfAmydoVySJGlZGuaqyQAXAbdX1Rv7Fq0Hpq58PA24sq/8he3qyWOAB6rqbuBq4Lgk+7VB+se1MkmSpGVpmHNWTwNeAGxMcnMrexVwPnB5kpcAXwOe15ZdBZwEbAK+B7wIoKruTfJ64IZW73VVde9ItkKSJGkRmjURa4PupxsQ9swB9Qs4c5p1XQxcPJcAJUmSlip/WV+SJKkjJmKSJEkdMRGTJEnqiImYJElSR0zEJEmSOmIiJkmS1BETMUmSpI6YiEmSJHXEREySJKkjJmKSJEkdGeZek8veqnM+Oqf6Zx+xg9Pn+BpJkrT8eERMkiSpIyZikiRJHZk1EUtycZJtSW7tKzs3yTeS3NweJ/Ute2WSTUm+nOT4vvITWtmmJOeMflMkSZIWl2HGiL0b+Gvg0p3K31RVb+gvSPJ44BTgCcBBwCeS/GJb/HbgN4EtwA1J1lfVF3chdk3YXMfK7Wy6sXObz3/WLq1XkqTFatZErKo+lWTVkOs7GVhXVT8E7kqyCTi6LdtUVXcCJFnX6pqISZKkZWtXrpo8K8kLgRuBs6vqPuBg4Lq+OltaGcDXdyp/6qCVJjkDOANg5cqVbNiwYahgVu7dO+KyEBjLYNPFMuzfeJS2b9/eSbsLNQ5YWLFI0nIx30TsQuD1QLXnC4AXAxlQtxg8Fq0Grbiq1gJrAVavXl1r1qwZKqC3XXYlF2xcGL/GcfYRO4xlgOli2XzqmonHsmHDBoZ9by2HOGBhxSJJy8W8vqGr6p6p6STvBD7SZrcAh/ZVPQTY2qanK5ckSVqW5vXzFUkO7Jt9DjB1ReV64JQkeyU5DDgcuB64ATg8yWFJ9qQ3oH/9/MOWJEla/GY9IpbkfcAaYP8kW4DXAGuSHEnv9OJm4A8Bquq2JJfTG4S/Azizqh5s6zkLuBrYDbi4qm4b+dZIkiQtIsNcNfn8AcUXzVD/POC8AeVXAVfNKTpJkqQlzF/WlyRJ6oiJmCRJUkdMxCRJkjpiIiZJktQREzFJkqSOmIhJkiR1xERMkiSpIyZikiRJHTERkyRJ6oiJmCRJUkdMxCRJkjpiIiZJktQREzFJkqSOzJqIJbk4ybYkt/aVPSrJNUnuaM/7tfIkeWuSTUluSXJU32tOa/XvSHLaeDZHkiRp8RjmiNi7gRN2KjsHuLaqDgeubfMAJwKHt8cZwIXQS9yA1wBPBY4GXjOVvEmSJC1XsyZiVfUp4N6dik8GLmnTlwDP7iu/tHquA/ZNciBwPHBNVd1bVfcB1/DTyZ0kSdKysvs8X7eyqu4GqKq7kzy6lR8MfL2v3pZWNl35T0lyBr2jaaxcuZINGzYMF9DecPYRO+awCeNjLINNF8uwf+NR2r59eyftLtQ4YGHFIknLxXwTselkQFnNUP7ThVVrgbUAq1evrjVr1gzV8Nsuu5ILNo56c+bn7CN2GMsA08Wy+dQ1E49lw4YNDPveWg5xwMKKRZKWi/leNXlPO+VIe97WyrcAh/bVOwTYOkO5JEnSsjXfRGw9MHXl42nAlX3lL2xXTx4DPNBOYV4NHJdkvzZI/7hWJkmStGzNes4qyfuANcD+SbbQu/rxfODyJC8BvgY8r1W/CjgJ2AR8D3gRQFXdm+T1wA2t3uuqaucLACRJkpaVWROxqnr+NIueOaBuAWdOs56LgYvnFJ0kSdIS5i/rS5IkdcRETJIkqSMmYpIkSR0xEZMkSeqIiZgkSVJHTMQkSZI6YiImSZLUkYVxE0Ita6vO+ehY1rv5/GeNZb2SJI2KR8QkSZI6YiImSZLUERMxSZKkjpiISZIkdcRETJIkqSO7lIgl2ZxkY5Kbk9zYyh6V5Jokd7Tn/Vp5krw1yaYktyQ5ahQbIEmStFiN4ojYsVV1ZFWtbvPnANdW1eHAtW0e4ETg8PY4A7hwBG1LkiQtWuM4NXkycEmbvgR4dl/5pdVzHbBvkgPH0L4kSdKikKqa/4uTu4D7gAL+d1WtTXJ/Ve3bV+e+qtovyUeA86vq0638WuAVVXXjTus8g94RM1auXPmUdevWDRXLtnsf4J7vz3tTRmrl3hjLAJOO5YiDHzntsu3bt7NixYrJBbPA44DxxnLsscfe1HfUXJLU7Oov6z+tqrYmeTRwTZIvzVA3A8p+KgusqrXAWoDVq1fXmjVrhgrkbZddyQUbF8aNAs4+YoexDDDpWDafumbaZRs2bGDY99Y4LZQ4YGHFIknLxS6dmqyqre15G3AFcDRwz9Qpx/a8rVXfAhza9/JDgK270r4kSdJiNu9ELMk+SR4xNQ0cB9wKrAdOa9VOA65s0+uBF7arJ48BHqiqu+cduSRJ0iK3K+eJVgJXJJlaz3ur6u+T3ABcnuQlwNeA57X6VwEnAZuA7wEv2oW2JUmSFr15J2JVdSfwpAHl/wo8c0B5AWfOtz1JkqSlxl/WlyRJ6oiJmCRJUkdMxCRJkjqyMH5gShqDVed8dNplZx+xg9NnWD6Tzec/a74hSZL073hETJIkqSMmYpIkSR0xEZMkSeqIiZgkSVJHTMQkSZI6YiImSZLUEX++QpqjmX4WY676f0bDn8WQpOXHI2KSJEkdMRGTJEnqiImYJElSRyaeiCU5IcmXk2xKcs6k25ckSVooJjpYP8luwNuB3wS2ADckWV9VX5xkHNJCNMqLAPp5EYAkLVyTvmryaGBTVd0JkGQdcDJgIiaNybAJ3lxvhG6CJ0m7LlU1ucaS5wInVNVL2/wLgKdW1Vl9dc4AzmizvwR8ecjV7w98a4Th7gpjGcxYftpCiQPGG8tjquqAMa1bkhatSR8Ry4Cyf5cJVtVaYO2cV5zcWFWr5xvYKBnLYMaycOOAhRWLJC0Xkx6svwU4tG/+EGDrhGOQJElaECadiN0AHJ7ksCR7AqcA6yccgyRJ0oIw0VOTVbUjyVnA1cBuwMVVdduIVj/n05ljZCyDGctPWyhxwMKKRZKWhYkO1pckSdJD/GV9SZKkjpiISZIkdWRJJGIL6bZJSTYn2Zjk5iQ3Trjti5NsS3JrX9mjklyT5I72vF+HsZyb5Butb25OctIE4jg0ySeT3J7ktiQva+UT75cZYumiXx6W5PokX2ixvLaVH5bks61f3t8uqpEkjcmiHyPWbpv0FfpumwQ8v6vbJiXZDKyuqon/SGeSpwPbgUur6omt7C+Be6vq/Jak7ldVr+golnOB7VX1hnG33xfHgcCBVfW5JI8AbgKeDZzOhPtlhlh+l8n3S4B9qmp7kj2ATwMvA/4Y+FBVrUvyDuALVXXhpOKSpOVmKRwR+8ltk6rqR8DUbZOWnar6FHDvTsUnA5e06UvoffF3FcvEVdXdVfW5Nv0d4HbgYDrolxlimbjq2d5m92iPAp4BfKCVT+z9IknL1VJIxA4Gvt43v4WOvtyaAj6e5KZ2u6aurayqu6GXCACP7jies5Lc0k5dTuQ06ZQkq4AnA5+l437ZKRbooF+S7JbkZmAbcA3wVeD+qtrRqnT9WZKkJW8pJGKz3jZpwp5WVUcBJwJntlN06rkQ+HngSOBu4IJJNZxkBfBB4OVV9e1JtTtkLJ30S1U9WFVH0rvDxdHA4wZVm0QskrRcLYVEbEHdNqmqtrbnbcAV9L7gunRPG5s0NUZpW1eBVNU97cv/x8A7mVDftDFQHwQuq6oPteJO+mVQLF31y5Squh/YABwD7Jtk6oeevQWZJI3ZUkjEFsxtk5Ls0wZhk2Qf4Djg1plfNXbrgdPa9GnAlV0FMpX4NM9hAn3TBqVfBNxeVW/sWzTxfpkulo765YAk+7bpvYHfoDdm7ZPAc1u1Tt8vkrQcLPqrJgHa5f5v5qHbJp3XURyPpXcUDHq3j3rvJGNJ8j5gDbA/cA/wGuDDwOXAzwFfA55XVWMfRD9NLGvonX4rYDPwh1PjtMYYx68D/whsBH7cil9Fb2zWRPtlhliez+T75VfoDcbfjd4/ZJdX1evae3gd8Cjg88DvV9UPxxmLJC1nSyIRkyRJWoyWwqlJSZKkRclETJIkqSMmYpIkSR0xEZMkSeqIiZgkSVJHTMQkSZI6YiImSZLUkf8PrGE3PI3hPUoAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 720x720 with 6 Axes>"
+      ]
      },
      "metadata": {
       "needs_background": "light"
@@ -126,15 +103,19 @@
     }
    ],
    "source": [
-    "test_data.pd_flights().hist()\n"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n",
-     "is_executing": false
-    }
-   }
+    "ed_flights = test_data.ed_flights()[['AvgTicketPrice','DistanceKilometers', 'DistanceMiles', 'FlightDelayMin', 'FlightTimeHour']]\n",
+    "\n",
+    "ed_flights.hist(figsize=[10,10])\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -158,13 +139,13 @@
   "pycharm": {
    "stem_cell": {
     "cell_type": "raw",
-    "source": [],
     "metadata": {
      "collapsed": false
-    }
+    },
+    "source": []
    }
   }
  },
  "nbformat": 4,
  "nbformat_minor": 1
-}
\ No newline at end of file
+}
diff --git a/eland/tests/plotting/test_dataframe_hist_pytest.py b/eland/tests/plotting/test_dataframe_hist_pytest.py
index ee9fbb2..b1ce51f 100644
--- a/eland/tests/plotting/test_dataframe_hist_pytest.py
+++ b/eland/tests/plotting/test_dataframe_hist_pytest.py
@@ -5,7 +5,7 @@ from eland.tests.common import TestData
 from matplotlib.testing.decorators import check_figures_equal
 
 @check_figures_equal(extensions=['png'])
-def test_plot(fig_test, fig_ref):
+def test_plot_hist(fig_test, fig_ref):
     test_data = TestData()
 
     pd_flights = test_data.pd_flights()[['DistanceKilometers', 'DistanceMiles', 'FlightDelayMin', 'FlightTimeHour']]
@@ -16,4 +16,3 @@ def test_plot(fig_test, fig_ref):
 
     ed_ax = fig_test.subplots()
     ed_flights.hist(ax=ed_ax)
-
diff --git a/eland/tests/setup_tests.py b/eland/tests/setup_tests.py
index b60fa1e..701c14a 100644
--- a/eland/tests/setup_tests.py
+++ b/eland/tests/setup_tests.py
@@ -6,6 +6,7 @@ from eland.tests import *
 
 DATA_LIST = [
     (FLIGHTS_FILE_NAME, FLIGHTS_INDEX_NAME, FLIGHTS_MAPPING),
+    (FLIGHTS_SMALL_FILE_NAME, FLIGHTS_SMALL_INDEX_NAME, FLIGHTS_MAPPING),
     (ECOMMERCE_FILE_NAME, ECOMMERCE_INDEX_NAME, ECOMMERCE_MAPPING)
 ]