working MSC nbs

7 files changed, 3821 insertions, 131 deletions

diff --git a/megapixels/notebooks/datasets/ibm_dif/images_per_embassy.ipynb b/megapixels/notebooks/datasets/ibm_dif/images_per_embassy.ipynb
new file mode 100644
index 00000000..4cd3a4fb
--- /dev/null
+++ b/megapixels/notebooks/datasets/ibm_dif/images_per_embassy.ipynb
@@ -0,0 +1,553 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Images Per Country-Embassy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob, iglob\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# list of embassy flickr image counts\n",
+    "fp_in = '/data_store/datasets/msc/embassies/embassy_counts.csv'\n",
+    "\n",
+    "# summary file\n",
+    "fp_out = '/data_store/datasets/msc/embassies/embassy_counts_summary.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_counts = pd.read_csv(fp_in)\n",
+    "records_counts = df_counts.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "75\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(records_counts))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "country_groups = df_counts.groupby('guest')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(country_groups))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# drop epmty NSIDs\n",
+    "df_meta_filepaths.drop_duplicates(subset='nsid', inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_meta_filepaths.to_csv(fp_meta_filepaths_adj, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nsid_filepaths = {}\n",
+    "dupes = []\n",
+    "for meta_filepath in meta_filepaths:\n",
+    "  nsid = meta_filepath['nsid']\n",
+    "  if nsid not in nsid_filepaths.keys():\n",
+    "    nsid_filepaths[nsid] = meta_filepath\n",
+    "  else:\n",
+    "    dupes.append(meta_filepath)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "98154\n",
+      "2284\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(nsid_filepaths))\n",
+    "print(len(dupes))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'filepath': '12537662393_247b2187ee.jpg', 'nsid': nan, 'photo_id': 12537662393, 'url': 'http://farm6.staticflickr.com/5476/12537662393_247b2187ee.jpg'}\n",
+      "{'filepath': '5837222502_29aaf5bb53.jpg', 'nsid': nan, 'photo_id': 5837222502, 'url': 'http://farm4.staticflickr.com/3089/5837222502_29aaf5bb53.jpg'}\n",
+      "{'filepath': '10859466623_4ceb1564dc.jpg', 'nsid': nan, 'photo_id': 10859466623, 'url': 'http://farm6.staticflickr.com/5530/10859466623_4ceb1564dc.jpg'}\n",
+      "{'filepath': '13719567455_fb96dc7ac6.jpg', 'nsid': nan, 'photo_id': 13719567455, 'url': 'http://farm4.staticflickr.com/3718/13719567455_fb96dc7ac6.jpg'}\n",
+      "{'filepath': '3486554266_ca1fc7d99c.jpg', 'nsid': nan, 'photo_id': 3486554266, 'url': 'http://farm4.staticflickr.com/3327/3486554266_ca1fc7d99c.jpg'}\n",
+      "{'filepath': '6168324261_d2fb7bbb60.jpg', 'nsid': nan, 'photo_id': 6168324261, 'url': 'http://farm7.staticflickr.com/6166/6168324261_d2fb7bbb60.jpg'}\n",
+      "{'filepath': '13938295982_0d950feba5.jpg', 'nsid': nan, 'photo_id': 13938295982, 'url': 'http://farm8.staticflickr.com/7162/13938295982_0d950feba5.jpg'}\n",
+      "{'filepath': '8881073633_546b6dbfe5.jpg', 'nsid': nan, 'photo_id': 8881073633, 'url': 'http://farm6.staticflickr.com/5459/8881073633_546b6dbfe5.jpg'}\n",
+      "{'filepath': '10918515734_404eb29879.jpg', 'nsid': nan, 'photo_id': 10918515734, 'url': 'http://farm6.staticflickr.com/5502/10918515734_404eb29879.jpg'}\n",
+      "{'filepath': '3236533532_05cacef8e9.jpg', 'nsid': nan, 'photo_id': 3236533532, 'url': 'http://farm4.staticflickr.com/3425/3236533532_05cacef8e9.jpg'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "for dupe in dupes[:10]:\n",
+    "  print(dupe)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100438\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(dupes))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "98153\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(nsid_groups))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100436\n"
+     ]
+    }
+   ],
+   "source": [
+    "fp_ims = glob('/data_store_hdd/datasets/people/ibm_dif/downloads/images/*.jpg')\n",
+    "print(len(fp_ims))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9314013316\n"
+     ]
+    }
+   ],
+   "source": [
+    "photo_ids = [Path(x).stem.split('_')[0] for x in fp_ims]\n",
+    "print(photo_ids[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "KeyError",
+     "evalue": "'photo_id'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m--------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m                           Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-45-fd2de6074950>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfilepath_photo_ids\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'photo_id'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmeta_flickr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m<ipython-input-45-fd2de6074950>\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfilepath_photo_ids\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'photo_id'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmeta_flickr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m: 'photo_id'"
+     ]
+    }
+   ],
+   "source": [
+    "filepath_photo_ids = [int(x['nsid']) for x in meta_flickr]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d7a9a78bf0e442a5b8445906bc85da99",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(IntProgress(value=0, max=100436), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# find which photo IDs are no longer accessible\n",
+    "missing_photo_ids = []\n",
+    "for photo_id in tqdm(photo_ids):\n",
+    "  photo_id = int(photo_id)\n",
+    "  if photo_id not in filepath_photo_ids:\n",
+    "    missing_photo_ids.append(photo_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "[]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(missing_photo_ids))\n",
+    "print(missing_photo_ids[0:10])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'df_flickr_meta' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m--------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                          Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-30-75e9fdbbbfbb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtotal\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf_flickr_meta\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'count'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\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      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtotal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'df_flickr_meta' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "total = df_flickr_meta['count'].sum()\n",
+    "print(total)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load ibm data and create count lookup with photoid\n",
+    "df_ibm_meta = pd.read_csv(fp_in_ibm_meta)\n",
+    "ibm_meta_records = df_ibm_meta.to_dict('records')\n",
+    "count_lookup = {}\n",
+    "for ibm_meta_record in ibm_meta_records:\n",
+    "  photo_id = int(Path(ibm_meta_record['url']).stem.split('_')[0])\n",
+    "  count_lookup[photo_id] = ibm_meta_record['count']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(count_lookup)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_flickr_meta = pd.read_csv(fp_in_flickr_meta, dtype={'count': int, 'username': str, 'sha256': str}).fillna('')\n",
+    "flickr_meta_records = df_flickr_meta.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load flickr data\n",
+    "for flickr_meta_record in flickr_meta_records:\n",
+    "  try:\n",
+    "    nsid = flickr_meta_record['nsid']\n",
+    "    photo_id = int(flickr_meta_record['photo_id'])\n",
+    "    count = count_lookup[photo_id]\n",
+    "  except Exception as e:\n",
+    "    print(f'Error: {e}, {flickr_meta_record}')\n",
+    "    continue\n",
+    "  obj = {\n",
+    "    'photo_id': photo_id,\n",
+    "    'nsid': nsid,\n",
+    "    'count': count \n",
+    "  }\n",
+    "  results.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_out = pd.DataFrame.from_dict(results)\n",
+    "df_out.to_csv(fp_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create meta count file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# photo ids and nsids\n",
+    "fp_flickr_api_dump = '/data_store_hdd/datasets/people/ibm_dif/research/flickr_api_query_dump.csv'\n",
+    "\n",
+    "# file urls\n",
+    "fp_ibm_urls = '/data_store_hdd/datasets/people/ibm_dif/research/ibm_dif_urls.csv'\n",
+    "\n",
+    "# flickr meta\n",
+    "fp_out_filepaths = '/data_store_hdd/datasets/people/ibm_dif/research/ibm_dif_filepaths.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_flickr_meta = pd.read_csv(fp_flickr_api_dump)\n",
+    "df_flickr_meta.fillna('', inplace=True)\n",
+    "flickr_metas = df_flickr_meta.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```\n",
+    "|filepath|nsid|photo_id|url|\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "photo_id_to_nsid = {}\n",
+    "for flickr_meta in flickr_metas:\n",
+    "  photo_id = flickr_meta.get('photo_id')\n",
+    "  if photo_id:\n",
+    "    photo_id = str(int(photo_id))\n",
+    "    photo_id_to_nsid[photo_id] = flickr_meta['nsid']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(list(photo_id_to_nsid.keys())[0:10])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_ibm_urls = pd.read_csv(fp_ibm_urls)\n",
+    "ibm_urls = df_ibm_urls.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "photo_id_to_url = {}\n",
+    "missed = []\n",
+    "for ibm_url in ibm_urls:\n",
+    "  photo_id = str(ibm_url['filepath'].split('_')[0])\n",
+    "  try:\n",
+    "    ibm_url['photo_id'] = photo_id\n",
+    "    ibm_url['nsid'] = photo_id_to_nsid[photo_id]\n",
+    "  except Exception as e:\n",
+    "#     print(e, photo_id)\n",
+    "    missed.append(photo_id)\n",
+    "print(f'missed: {len(missed)}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.DataFrame.from_dict(ibm_urls).to_csv(fp_out_filepaths, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/msc/images/fig1.png b/megapixels/notebooks/msc/images/fig1.png
new file mode 100644
index 00000000..a8a2493f
--- /dev/null
+++ b/megapixels/notebooks/msc/images/fig1.png
diff --git a/megapixels/notebooks/msc/images/scatter.png b/megapixels/notebooks/msc/images/scatter.png
new file mode 100644
index 00000000..ae9f7d30
--- /dev/null
+++ b/megapixels/notebooks/msc/images/scatter.png
diff --git a/megapixels/notebooks/msc/plot_plotly.ipynb b/megapixels/notebooks/msc/plot_plotly.ipynb
new file mode 100644
index 00000000..8b090005
--- /dev/null
+++ b/megapixels/notebooks/msc/plot_plotly.ipynb
@@ -0,0 +1,861 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Plot Data Previews"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from pathlib import Path\n",
+    "from glob import glob\n",
+    "import json\n",
+    "from pprint import pprint\n",
+    "\n",
+    "#import plotly.plotly as py\n",
+    "import plotly.offline as py\n",
+    "import plotly.graph_objs as go\n",
+    "from plotly import tools\n",
+    "\n",
+    "import matplotlib.ticker as ticker\n",
+    "import matplotlib.cm as cm\n",
+    "import matplotlib as mpl\n",
+    "from matplotlib.gridspec import GridSpec\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from PIL import Image, ImageDraw\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm_notebook as tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load files\n",
+    "fp_origins = '/data_store/datasets/msc/summaries/megapixels_origins.csv'\n",
+    "fp_origins_top = '/data_store/datasets/msc/summaries/megapixels_origins_top.csv'\n",
+    "fp_overview = '/data_store/datasets/msc/summaries/megapixels_overview.csv'\n",
+    "fp_sector = '/data_store/datasets/msc/summaries/summary_sector.csv'\n",
+    "fp_country = '/data_store/datasets/msc/summaries/summary_countries.csv'\n",
+    "fp_country_top = '/data_store/datasets/msc/summaries/summary_countries_top.csv'\n",
+    "fp_dir_out = '/data_store/datasets/msc/viz/'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_origins = pd.read_csv(fp_origins).fillna(0)\n",
+    "df_overview = pd.read_csv(fp_overview).fillna('')\n",
+    "df_country = pd.read_csv(fp_country).fillna('').set_index('country')\n",
+    "df_sector = pd.read_csv(fp_sector).fillna('')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_origins_plt = df_origins.drop(['images', 'videos', 'key', 'name_full'], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create custom color maps\n",
+    "import matplotlib as mpl\n",
+    "import matplotlib.cm as mplcm\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib import cm\n",
+    "\n",
+    "def get_color_map(cmap='prism', ncolors=20, as_hex=False, reverse=False, bgr=True):\n",
+    "  norm  = mpl.colors.Normalize(vmin=0, vmax=ncolors-1)\n",
+    "  scalars = mplcm.ScalarMappable(norm=norm, cmap=cmap)\n",
+    "  colors = [scalars.to_rgba(i) for i in range(ncolors)]\n",
+    "  colors = [(int(255*c[0]),int(255*c[1]),int(255*c[2])) for c in colors]  \n",
+    "  if reverse:\n",
+    "    colors = colors[::-1]\n",
+    "  if bgr:\n",
+    "    colors = [c[::-1] for c in colors]\n",
+    "  if as_hex:\n",
+    "    colors = ['#{:02x}{:02x}{:02x}'.format(c[0],c[1],c[2]) for c in colors]\n",
+    "  return colors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sums = {}\n",
+    "for k in df_origins_plt.keys():\n",
+    "  if not ('cooperative' in k.lower() or 'studio' in k.lower()):\n",
+    "    sums[k] = int(df_origins_plt[k].sum())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "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>images</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Search Engines</th>\n",
+       "      <td>15063600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Flickr.com</th>\n",
+       "      <td>5891944</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>IMDb.com</th>\n",
+       "      <td>2625705</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>CCTV</th>\n",
+       "      <td>463507</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Other Sources Combined</th>\n",
+       "      <td>176245</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                          images\n",
+       "Search Engines          15063600\n",
+       "Flickr.com               5891944\n",
+       "IMDb.com                 2625705\n",
+       "CCTV                      463507\n",
+       "Other Sources Combined    176245"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_sums = pd.DataFrame({'images':list(sums.values())}, index=sums.keys())\n",
+    "\n",
+    "# get top N\n",
+    "ntop = 4\n",
+    "k = 'images'\n",
+    "df_top = df_sums.nlargest(ntop, k)\n",
+    "df_bot = df_sums.nsmallest(len(df_sums) - ntop, k)\n",
+    "df_tmp = pd.DataFrame.from_dict({'tmp': ['Other Sources Combined'], k: df_bot[k].sum()}).set_index('tmp')\n",
+    "df_sums = df_top.append(df_tmp)\n",
+    "\n",
+    "df_sums.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['#ff0000', '#0056c3', '#ffd700', '#a200ce', '#54fe00']\n",
+      "['Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r', 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r']\n"
+     ]
+    }
+   ],
+   "source": [
+    "colors = get_color_map(ncolors=5, bgr=False, as_hex=True)\n",
+    "print(colors)\n",
+    "color_list = list(dir(mplcm))\n",
+    "print(color_list[:10])\n",
+    "colors_msc = ['#6d9438', '#d2dcbe', '#a7bb7e', '#aaaaaa','#999999', '#bbbbbb']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7EAAANRCAYAAAA1ZzvbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XmcHHWd//HXJwkhQCCBcMmVIIeAyKGglnigsgoigrviga4H4uraWt7n+vO+d3W1tVxdZb0v1FVRYfFaPFtEvFZROeQ+5AzhJiTf3x9VQ5ohk0ySmfl2db+ej0c/0jPVXf2u7p5Jv+f7rapIKSFJkiRJUhvMyh1AkiRJkqTJssRKkiRJklrDEitJkiRJag1LrCRJkiSpNSyxkiRJkqTWsMRKkiRJklrDEitpoEXEEyPikoi4KSIOzJ1nmEXEqRHxrNw51iYiDo2IP07ytidExOnTHGnGRMT/i4iPrmH5syLi1JnMtD4i4rkR8a2pvq0kaTSE54mV2iciHgq8F7gvsAL4E/DSlNKZWYNNg4g4H3h5SumbEyxPwB+A/VNKK5vvvR3YKaX07GnKdBzwcmAv4Ebgt8A7Uko/nY7Hmw4R8WZg95TSM2bgsRJwCzD2H86dKaWF0/24zWOfADwjpXToapbtDpwL3Nxkuwb4SErpX2ci24Yay59Siml+nGcBVfPlbGBj6tcTZvC1nA4RcSXwpDb97EqSHImVWicitgC+DXwI2ArYEXgLcPs0PNacqV7nelgMrG3UbQfgqTOQhYh4OfAB4J3AdsAuwEeAo2fi8SdjQF638fZPKc1vLgNVeppMm1O/h94SEY/MnWmQpJQ+PfbaAUcBF6/ptRzQ958kaYhYYqX22RMgpfTFlNKKlNKtKaXvppR+DxARsyLiDRFxUURcFRGfiYgFzbJDI+LS/pVFxIURcVhz/c0R8dWI+FxELAOeHRGzI+L1EXF+RNwYEWdFxM7N7feKiO9FxHUR8ZeIeHLfeh8XEWc397ksIl65uo2ZKG9EbBwRN1GP/PyuGZGdyHupy8dqPzxHxBMi4o8RsTQiTo+Ivcdt/ysj4vcRcUNEfDki5k2wngXAW4FOSum/U0o3p5SWp5S+lVJ6VXObjSPiAxFxeXP5QERs3LeO50XEec1zdnJE7NC3LEVEGRF/jYhrIuJfI2JW3/LjI+JPEXF9RJwWEYvH3bcTEedSjy4SER9spmIva163hzXfPxx4PfCUZpr275rvn95Mv924ea727Vv/NhFxa0Rs23z9+Ij4bXO7n0fEfmt4fVYrIhZFxCkRcXWzTd+KiB3HLf9URFzRLP9a8/3DIuLCvtu9oXnObmxe5yesaxaAlNIZwJ+BA/rWvVNEfL3JeEFEdPqWzYl6eu/5zXP8q7HXMyIe2nx9Q0T8MiIe1He/3SLip03e70bEf0TEp5pluzev5TMj4tLmcV/bd9+3j90W+HHzvZuay8Exbvr0WnL8NCLe0rx+N0bE/0TEVuvz3EXElc3P0R+BZc333tg8ZzdGxB8i4si+278gIr7fXJ/XbPPzmufy+oj49/W87ZyI6EbEtc3yMiLunOQ2vCAifhgRH26er3Mj4qCI+Keof4f9LSKe2nf7J0bE75rX/qKIeP249Z0QERc3r+Grm+fooc2y2c17Z+xn/fMRsbBZtllEfCnq3xFLI+KMiNhyPV4WSRpallipfc4BVkTEpyPiiNV8uHl2c3kkcG9gPvDhdVj/0cBXgYXA56mnzT4NeBywBXA8cEtEbAZ8D/gCsG1zm49ExH2b9ZwIPL8Z4doX+OEEj7favCml25uRH6hH8XZbQ+b/pv7g/OzxCyJiT+CLwEuBbYBTgG9FxNy+mz0ZOBzYFdhvdetpFMA84OtryPIvwIOpi9D+wAOBNzRZHgW8q3m8ewEXAV8ad/8nAgcB96d+LY5v7nsMdfH8+2Y7ftJsV79jgAcB+zRfn9nk2Ir6dfpKRMxLKf0P9Ujyl5vRtP37V5JSup36OX1a37efDPwopXRVRNwf+C/g+cAi4GPAydFX1idpFvBx6tHsxcBy4IN9y78AzG22Z7txy/qdAxwCLADeAXwhIrZblyBROwTYGziv+d5s6lkPZ1LPePg74FUR8ejmbq8CnkT93lkInADcFhFbA98B3kf9/HSBU/p+Vr8I/KxZ9nZgdVO6HwLsDjyW+g80e6zmNg+Hu0aS54/fnWASOQCOA55F/fxuRv3zvr6eQv0cLWq+/kuzHQuA9wBfajJN5AjgQOr3/nMi4tD1uO2LgEdQ/855IPXrsy4eBvy82YZvAF+jfk/sCjwP+I9Y9UeuZdTP30Lqn9tXRv0HIiLiAOD91D83OzWX/m1/FfAY4KHNsuXAWBk/AZhD/Z7butmmO9ZxOyRpuKWUvHjx0rIL9YeqTwGXAncCJwPbNct+ALyw77b3of6ANAc4FLh03LouBA5rrr8Z+PG45X8Bjl5NhqcAPxn3vY8Bb2quX0xdcrZYy7ZMmLf5OlHvuznR/RP1h/3HNY+5MXUx+FSz/P8BJ/XdfhZwGXBo3/Y/o2/5e4GPTvBYTweuXMv2nA88ru/rxwIXNtdPBN7bt2x+s61L+rbl8L7lLwR+0Fw/FXjuuO24BVjcd99HrSXb9dR/EBh7rT83bvnpwAnN9cOAv/Yt+xnwzOb6fwBvW8375BFreI2WAUubS3eC2x0EXN1c35n6vb1gNbc7bOw5nWA9fwCObK6fAJw+we12b7ItBW5trr+HVceLOKT/Oeh7P32877U+cjXrfQ7w83HfO5O6rN6beur/Jn3LvtT3fh3LtH3f8l9T77cJd39v7w6kcY9z1/auKUdz/afAa/uWlcC31/IeWu1zD1wJHLeW+/4ZeGxz/QXA95vr85ptPqjvtidT7+e/rrf9OfCsvmWPp95vd6JMVwIP7Xuc/+tbdnDzWAv6vnczsNcE6/oo8K7m+juBT/Yt2wJY2fdYFwCH9C3flfrnOah/7n8E7Lum59OLFy9eRvniSKzUQimlP6WUnp1S2ol6xGEH6v00aa5f1Hfzi6gL7GRHpi4Z9/XO1B/Wx1sMPKiZ7rY0IpZSl7ztm+X/QF0sL4qIH0VEMcHjbWheAFJKp1CX2H9a0/pTffCnS6hHOcZc2Xf9FupyOXa03rGpmk8HrgW2jjXv87e67dlhdctSSjc16+zP0v/89993MfDBvuf6OuoPvBPdl4h4RdTTj29o7rOAu48GrckPgU0i4kFRT1s+gFUj0IuBV4x77Xfuy7o6908pLWwuZZNvs4j4RDPlclnzmGP5dgauSSndsLagEfHsZlrnWJa91mE7SfV+nfOB11D/oWfs9V0M7DJuO1/Nqvf4RD8b498DNF/v2Cy7NqV0a9+y8T9zpJRW+55cR2vKMWYqHmfM+Pffc6Oepj/23O3Oml+Xdcky0W13GJfjHs/tWvyt7/qtwO3j3oO3sur3wyHN77arI+IG6hkcY9t3txwppWXADc39gvq9c0rfc/Mb6j9MLaL+Y9ePgK9GPaX8nc2sAElSwxIrtVxK6c/Uo7Jj+y9eTv3he8wu1CNaf6MeRdh0bEHzwWib8asc9/UlwOqm8l5CPb10Yd9lfkrpn5tcZ6aUjqaeavwN4KQJNmFNedfVG6in827a9727rb/vA+Rla1tZSumItGqq5ueBHnAb9bTdiaxuey6fIMtm1B9a+7PsPMF9L6Gent3/fG+SUvp5f+S+dT+MupQ9GdiyKWo3UBffu912dZqyfxL1lOLjqEfobuzL8o5xWTZNKY2f3rw2r6YegXpgSmkL4FF9yy6h/oPBFmtaQUTcm3pk+J+BRc12/plV2zkpqd6//L3Uz8vz+zKcO247N08pHdW3fHU/G+PfA1C/lpcBVwCL4u77Xe/M+lnb6QXWlGM69L//9qQ++Nw/AVs1r8t5rOPrsh6uoJ6eO2Z9n9vJOAn4MrBzSmkB9e/hse27W47mfbwAmqHz+jV41Lj31ryU0jWp3pXijSmlvainjB/LDB24TpLawhIrtUzUB1N6RUTs1Hy9M3XR+EVzky8CL4uIXSNiPqv2fbyTet/BeRFxZERsRF361rYf4yeAt0XEHs1+g/tFxCLqfQX3jIh/jIiNmsvBEbF3RMyNiKdHxIKU0nLqqaQrJlj/mvKuk5TS6cD/Ue/jN+Yk4MiIeHSzza+gns7583uuYa3rvwF4I1BFxDERsWmz3UdExHv7tucNUR8Iaevm9p9rln2Bev+9A5r9R98JnJFSurDvYV4VEVs2r+tLqD8kQz1V8XXR7HMc9cGvjl1D3M2p/xhwNTAnIt5IPaVxzN+AJdF34KjV+AL1tPGnN9fHfBx4QTNKG82I6pERsfka1jVRxluA65v31BvHFqSULgG+T/1cL2ye54evZh3zqcvT1dR/oziBeiR2fb0beG3z+vSAO5qft3lRH4znfhHxgOa2nwDeHvWBmqJ5Xbei/tm4b0Q8JeoDDR1HPQp5SkrpfOr36Juan5OHAkfeM8akXAWkpsivzoQ51vPx1sV86umzVwOzIuIFzWNPt5Oof59s37ynVntAuQ3V/DFsPvWo+m0R8RDqstmf4x+a34lzqQ8It7Jv+UeBd8eqg+RtGxFHNdcPi4h9mp/NZdQ/xxP9/pSkkWSJldrnRuqD95wRETdTl9c/UJczqA+481nqI5deQD1y+GK4q4S9kPrD92XUI7N3O1rxaryf+gPZd6k/UJ1IvT/fjdQHJnkq9YjPldT7E46V4n8ELox6mugLWP3Ba9aYdz29gfpARgCklP7SPPaHqM8DehRwVEppvQ6UklJ6P/XBb95A/QH9EuoDr3yjucnbgV8Bv6cuK79uvkdK6QfU+1R+jXqkZjfuOcLyTeAs6nPPfof6+Sal9HVWHRxnGfVrfsQaop5GvR/tOdRTSG/j7lMrv9L8e21E/HqCbT2D+j2yQ7Ouse//ivogNx+m3s/2PCY+GNaavJ96dOpa6j8qnDpu+dh75hzq0n2P90Wqj8rdBX5J/ZzuBZyxHlnGnAzcBBzf/CHlcdQHCLqQ+v3zMVb9MeBfqV/3H1D/bPwnMC+ldDXwBOqR8GuBlwGPTyld19zvadQjbNcCb6L+Q8U6nyKr+Rl8F/XvgqURcdC45WvLMW1SSr+mLmq/on5ddm2uT7cPU7+Xzqbe//fbTMPpx5rR1BcA/xYRN1LPKvhK3/LfUB+86eusGoG/oS/Le6n/SPPD5v4/pz5IFdTTvb9J/bv+D9R/dJhoJoskjaSxg1dIkjKLiATskVI6L3cWzZyoTx3025TS23JnGTYR8UTg3Sml+2TOsSX1fuw7pJSuyJlFkoaBI7GSJM2giHhgM31+VkQ8jvoIut/MnWsYRMTmEfGYZur3LtQzJtZ0SqzpzPKEiNik2U3i/dS7DlhgJWkKWGIlSZpZO1BPn7+R+tygz2umRWvDzaLer/kG6unEd03nz+BY6t0sLqWeIvz0TDkkaeg4nViSJEmS1BqOxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLGSJEmSpNawxEqSJEmSWsMSK0mSJElqDUusJEmSJKk1LLFSy0REiojdByDHqRHxrNw5JEmSNFossdIkRcRDI+LnEXFDRFwXET+LiINz51qTiHhzRCyPiJv6LkunYt0ppSNSSp+einVJkiRJk2WJlSYhIrYAvg18CNgK2BF4C3D7NDzWnCle5ZdTSvP7LguneP2SJEnSjLHESpOzJ0BK6YsppRUppVtTSt9NKf1+7AYRcXxE/Ckiro+I0yJicd+yD0bEJRGxLCLOioiH9S17c0R8NSI+FxHLgGdHxOyIeH1EnB8RNzb32bkvz2ERcW7zWFVExPpsVDM1+QWrW1eT4X0RcU1EXBARL2puP6dZfnpEnNBcf3ZE/DQi/q1ZzwURcUTf4yyIiBMj4oqIuCwi3h4Rs5tlu0fEj5oR7msi4svrsy2SJEkaDZZYaXLOAVZExKcj4oiI2LJ/YUQcA7we+HtgG+AnwBf7bnImcAD1KO4XgK9ExLy+5UcDXwUWAp8HXg48DXgcsAVwPHBL3+0fDxwM7A88GXjsBmzbROt6HnBEk/v+wDFrWc+DgL8AWwPvBU7sK9efBu4EdgcOBB4DnNAsexvwXWBLYCfq0W5JkiRptSyx0iSklJYBDwUS8HHg6og4OSK2a27yfOBdKaU/pZTuBN4JHDA2GptS+lxK6dqU0p0ppfcBGwP36XuIXkrpGymllSmlW6kL3htSSn9Jtd+llK7tu/27U0pLU0oXA/9LXTQn8uSIWNp3+d9xyyda15OBD6aULk0pXQ+8ey1P00UppY+nlFZQl9Z7Ads1z9ERwEtTSjenlK4C/h14anO/5cBiYIeU0m0ppZ+u5XEkSZI0wiyx0iQ1BfXZKaWdgH2BHYAPNIsXAx8cK4rAdUBQ7ztLRLyimWp8Q7N8AfWI5ZhLxj3czsD5a4hzZd/1W4D5a7jtSSmlhX2XR05yXTuMyzU+44SZUkpjo8bzqZ+bjYAr+p6fjwHbNrd5NfVz9cuI+GNEHL+Wx5EkSdIIm+oDyEgjIaX054j4FPUILNQF7x0ppc+Pv22z/+trgEcDf0wprYyI66mL212rHHe3S4DdgD9MdfZ1cAX19N4xO090w7W4hPoAWFs3o9R3k1K6knrqMhHxUOD7EfHjlNJ56/l4kiRJGmKOxEqTEBF7NaOpOzVf70y9z+ovmpt8FHhdRNy3Wb4gIo5tlm1OvT/o1cCciHgj9X6ua/IJ4G0RsUfU9ouIRVO8WWtzEvCSiNgxIhZSF/F1llK6gnqf1/dFxBYRMSsidouIRwBExLFjzytwPXWhXzEF+SVJkjSELLHS5NxIfeCiMyLiZury+gfgFQAppa8D7wG+1Bxh+A/U+4ECnAacSn1wqIuA21j71Nz3U5fI7wLLgBOBTdYz+1PGnSf2pojYdu134+PN4/8e+A1wCnUZX5+C+UxgLnA2dVH9KvU+s1AfVOqMiLgJOBl4SUrpgvV4DEmSJI2ASGn8LEZJuqfmlDkfTSktXuuNJUmSpGniSKyk1YqITSLicRExJyJ2BN4EfD13LkmSJI02R2IlrVZEbAr8CNgLuBX4DvVU32VZg6l1yqqYQ3007q2pzwc8l/rAghs1//ZfX9331rQc6qNq3wzc1Py7tuu3dDs9//OTJKmlLLGSpEkrq2IWsBWrSulkLguyhJ1Yov7DzOqK7g3Up4u6kvoI3f3X/9bt9O5xhG1JkjSzLLGSJOCugrozsDv1KZ52B+4NbM/dR1JHdVeUBFxDXWovoz5A2yXAxX2XS7qd3h3ZEkqSNAIssZI0Qpqpvbty96I6dlkCbJwt3HBIwN9YVW7PB/7YXP7U7fRuyZhNkqShYImVpCFTVsU8VhXU/qK6G7AL9f6kmnkrgQtZVWr7y+1tGXNJktQqllhJarGyKrYAHtBcDmr+3Q2InLm0TlYCf6U+v3R/uf1Lt9O7PWcwSZIGkSVWklqirIr5wIHUZXXssgcW1mG1AjiPuxfbX3Y7vQuyppIkKTNLrCQNoLIqNuGehfU+jO5BlbTKFcDPgJ82//7WoyZLkkaJJVaSMiurYmPgAFaV1QcA+wCzc+ZSa9wMnEFdaH8G9LqdnudzliQNLUusJM2wsipmU5fVw5rLQ4C5WUNpmKwE/o++0dpup3dx3kiSJE0dS6wkzYCyKvZkVWl9JLAwbyKNmEtYNVL7M+D33U5vRd5IkiStH0usJE2Dsiq2YVVpPYz61DbSoLgR+AnwHeDbjtRKktrEEitJU6Csik2Bh7OqtO6HRw1We/we+HZzOaPb6a3MnEeSpAlZYiVpPbhfq4bY1cCp1IX2NA8SJUkaNJZYSZqksirmAo8BjgWOArbMm0iadsuppx1/G/hWt9M7L3MeSZIssZK0JuOK69HAgryJpKzOYdW04594flpJUg6WWEkax+IqTcpS4Ls0pbbb6V2fOY8kaURYYiUJi6u0ge4ATgE+A3yn2+ndkTmPJGmIWWIljSyLqzQtrgNOAj7T7fR6ucNIkoaPJVbSSLG4SjPqPOBzwGe7nd5fc4eRJA0HS6ykkVBWxaHAs4FjsLhKOfwM+Czw5W6ntzR3GElSe1liJQ2tsiq2py6uxwN75E0jqXE79cGgPguc0u30lmfOI0lqGUuspKFSVsVs4AjgBOBIYE7eRJLW4Brgy9TTjc/IHUaS1A6WWElDoayKJcBzqUded8oaRtL6OId6dPa/up3e5bnDSJIGlyVWUmuVVTELeDzwQuqDNUXeRJKmwHLgK8AHup3embnDSJIGjyVWUuuUVbEt9XThfwIWZ44jafr0gA8A/93t9O7MHUaSNBgssZJao6yKQ6hHXZ8EzM0cR9LMuQT4CPCf3U7vutxhJEl5WWIlDbSyKjYFnkFdXvfPHEdSXrdQn3f2g91O7+zcYSRJeVhiJQ2ksiq2BErgxcCizHEkDZ7vUU81PrXb6flhRpJGiCVW0kBpzu36CuD5wOaZ40gafOcAXeBT3U7v5txhJEnTzxIraSCUVbEr8GrqU+TMy5tGUgstBU4EPtzt9C7MG0WSNJ0ssZKyKqtiH+B1wFOBOZnjSGq/FcDJwHu6nd4ZucNIkqaeJVZSFmVVHAz8C/AEPL+rpOlxCvDGbqd3Vu4gkqSpY4mVNKPKqngU8Hrg0bmzSBoZ36Qus7/PHUSStOEssZKmXVkVARxFPW34wZnjSBpNCfga8CZPzyNJ7WaJlTRtyqqYDTwFeC1wv8xxJAlgJfAl4C3dTu+c3GEkSevOEitpypVVMQt4JvAGYLfMcSRpdVYAnwPe2u30/po7jCRp8iyxkqZUWRV/B/wbsF/uLJI0CXcCnwLe1u30Ls6cRZI0CZZYSVOirIr7Af8KPDZ3FklaD3dQn2f2Hd1O77LcYSRJE7PEStogZVXsALwNeDYwK28aSdpgtwMfA97V7fSuzB1GknRPllhJ66WsivnAq4FXAJtmjiNJU+1W4CPUI7PX5w4jSVrFEitpnTRHHD4BeDOwfd40kjTtrqE+t/WJ3U5vZe4wkiRLrKR1UFbFkcB7gX1yZ5GkGXYW8OJup9fLHUSSRp0lVtJalVVxIPURhx+VO4skZZSAzwKvcX9ZScrHEitpQmVV7Ay8A3gGEJnjSNKgWAa8Feh2O73lucNI0qixxEq6h7IqtgBeB7wUmJc5jiQNqj8DZbfT+17uIJI0Siyxku6mrIrjgH8Hts2dRZJa4hvAy7qd3oWZc0jSSLDESgKgrIrFwH8AR+TOIkktdBv1ge/e3e30bs0dRpKGmSVWGnHNKXNK4G3AZpnjSFLbXQS8otvpfS13EEkaVpZYaYSVVXEA8HHgoNxZJGnI/IB6f9mzcweRpGFjiZVGUFkVmwBvBl4OzMmbRpKG1p3Ah4E3dju9G3OHkaRhYYmVRkxZFYcBHwV2y51FkkbEJcDzup3eabmDSNIwsMRKI6KsikXA+4Bn5c4iSSPqk8DLu53e0txBJKnNLLHSCCir4unUp83ZJncWSRpxlwPP73Z6384dRJLayhIrDbGyKpZQnzbn8MxRJEl39zngJd1O77rcQSSpbSyx0hBqTpvzUuAteNocSRpUVwIv7HZ6X88dRJLaxBIrDZmyKvYHTgQekDuLJGlSvkRdZq/PHUSS2sASKw2JsioCeBnwLmBu5jiSpHVzOXC8RzCWpLWzxEpDoKyKbYFP476vktR2HwFe1e30bskdRJIGlSVWarmyKh4DfAbYLncWSdKUOBf4x26nd0buIJI0iCyxUkuVVbER9dThlwOROY4kaWqtoP4d/9Zup7c8dxhJGiSWWKmFyqrYA/giHrxJkobdWcAzu53e2bmDSNKgmJU7gKR1U1bFs4BfY4GVpFHwAOBXze9+SRKOxEqtUVbFFsB/AMflziJJyuITwIu7nd5tuYNIUk6WWKkFyqp4EPAF4N65s0iSsvo18KRup3dB7iCSlIslVhpgZVXMAl4DvBWYkzmOJGkwLKXeT/ZbuYNIUg6WWGlAlVVxL+CzwKNzZ5EkDZwEvBf4l26ntyJ3GEmaSZZYaQCVVfF44JPA1rmzSJIG2unAU7ud3t9yB5GkmWKJlQZIWRVzgH8FXpo7iySpNa6gLrI/zh1EkmaCp9iRBkRZFVsB/4MFVpK0bu4F/KCsilflDiJJM8GRWGkAlFWxN3AysHvuLJKkVvsG8Oxup3dD7iCSNF0ciZUyK6viSOAXWGAlSRvuGOCssioOyB1EkqaLJVbKqKyK11CPwG6RO4skaWjsBvTKqjg+dxBJmg5OJ5YyKKtiHvBx4Bm5s0iShtongU6307s1dxBJmiqWWGmGlVWxA/B14IG5s0iSRsJZwOO7nd6VuYNI0lSwxEozqKyKg6kPurFD7iySpJFyEfC4bqd3du4gkrSh3CdWmiFlVTwd+DEWWEnSzFsM/Kz5mSjlAAAgAElEQVSsikfmDiJJG8qRWGmalVUxC3gn8JrcWSRJI+8O4IRup/fZ3EEkaX1ZYqVpVFbF5sAXgMfnziJJUp83dju9t+UOIUnrwxIrTZOyKnajPn3OPrmzSJK0Gp8Ent/t9JbnDiJJ68ISK02DsioeBXwF2Cp3FkmS1uD7wD90O71luYNI0mR5YCdpijUHcDoNC6wkafAdRn3Ap51zB5GkybLESlOorIoXAZ8F5uTOIknSJO0L/KKsigNyB5GkybDESlOkrIo3Ah8CIncWSZLW0Q7AT8qqOCJ3EElaG/eJlTZQWRUBvB94ae4skiRtoDuBTrfT+8/cQSRpIpZYaQOUVTEbOBF4Vu4skiRNoXcDr+92en5QlDRwLLHSeiqrYmPgy8DRubNIkjQNvgg8p9vp3Z47iCT1s8RK66GsivnAN4FH5c4iSdI0+l/gqG6nd3PuIJI0xhIrraOyKhYBpwIH584iSdIM+DFwZLfTuyl3EEkCS6y0Tsqq2BH4LrBP7iySJM2gnwFHdDu9G3MHkSRLrDRJZVXsDnwfWJw7iyRJGfwCOLzb6d2QO4ik0eZ5YqVJKKtif+CnWGAlSaPrwcD3yqpYmDuIpNFmiZXWoqyKQ4DTge0yR5EkKbeDgR+UVbFV7iCSRpclVlqDsioOp94H1r86S5JUuz91kV2UO4ik0WSJlSZQVsWTgJOBTXNnkSRpwBwA/LCsim1yB5E0ejywk7QaZVUcBfw3MCd3FkmSBtgfgUd3O72/5Q4iaXRYYqVxyqp4NPAdYOPcWSRJaoE/A4/qdnpX5A4iaTRYYqU+zUGcTgM2y51FkqQWOQd4ZLfTuzx3EEnDzxIrNcqquD/wQ2BB7iySJLXQedQjspfkDiJpuFliJaCsivsCPwI80qIkSevvAuoR2YtyB5E0vDw6sUZeWRW7A9/DAitJ0obaFfhRWRW75g4iaXg5EquRVlbFzsBPgMW5s0iSNEQuAgoP9iRpOjgSq5FVVsX2wA+wwEqSNNUWA/9TVoXHmZA05SyxGkllVWxFPYV4j9xZJEkaUvsB3yirwlPWSZpSlliNnLIqtqA+jc6+ubNIkjTkDgU+W1aFnzklTRl/oWiklFWxKfBt4KDcWSRJGhHHAh/MHULS8LDEamSUVTEX+DrwsNxZJEkaMS8qq+J1uUNIGg4enVgjoayKOcBXgGNyZ5EkaYQ9p9vpfSp3CEntZonV0Gv2w/kscFzuLJIkjbg7gaO7nd4puYNIai+nE2sUvB8LrCRJg2AO8JWyKh6UO4ik9nIkVkOtrIoXAR/KnUOSJN3NtcAh3U7vL7mDSGofS6yGVlkVRwLfBGbnziJJku7hQuAh3U7vitxBJLWLJVZDqayKA4CfAPNzZ5EkSRP6HfDwbqe3LHcQSe3hPrEaOmVV7Eh9LlgLrCRJg21/4JtlVWycO4ik9rDEaqiUVTGfusDumDuLJEmalEOBzzZnE5CktfKXhYZGWRWzgS8BB+TOIkmS1smxwAdyh5DUDpZYDZN/B47MHUKSJK2XF5dV8c+5Q0gafB7YSUOhrIrnAx/NnUOSJG2Q5cCh3U7v57mDSBpclli1XlkVjwC+B2yUO4skSdpgVwAP8NQ7kiZiiVWrlVWxK3AmsCh3FkmSNGV+Tj0iuzx3EEmDx31i1VplVWwOnIwFVpKkYfMQoJs7hKTBZIlVKzWH4f8csG/uLJIkaVq8oKyK5+YOIWnwWGLVVm8HnpA7hCRJmlZVWRUPzB1C0mBxn1i1TlkVTwO+kDuHJEmaEZdSH+jpqtxBJA0GS6xapayKA6gP9rBJ7iySJGnG/Bh4dLfTuzN3EEn5OZ1YrVFWxXzgJCywkiSNmocD78sdQtJgsMSqTT4G7JE7hCRJyqIsq+Ifc4eQlJ/TidUKZVUcD5yYO4ckScrqVuCQbqf3m9xBJOVjidXAK6tiH+BMYNPcWSRJUnYXUR/o6drcQSTl4XRiDbSyKjah3g/WAitJkgAWA18uq2J27iCS8rDEatB9CLhv7hCSJGmgPBp4d+4QkvJwOrEGVlkVxwGfz51DkiQNrCd1O72v5Q4haWZZYjWQyqrYHfg1sHnuLJIkaWBdB9yv2+ldnjuIpJnjdGINnLIqNqbeD9YCK0mS1mQr4FNlVUTuIJJmjiVWg+jfgANzh5AkSa3wd0CZO4SkmeN0Yg2UsiqeCPx37hySJKlVbgMO6nZ6f8wdRNL0s8RqYJRVsQT4DbAwcxRJktQ+vwUe1O307sgdRNL0cjqxBkJZFXOAL2KBlSRJ6+cA4K25Q0iafpZYDYp3Ag/OHUKSJLXaq8qqeHjuEJKml9OJlV1ZFUcA3wE8sqAkSdpQFwH7dTu9ZbmDSJoec3IH0Ggrq2Jb4NNYYDUEzvnVNfzy1Eu58fo72HSLjTjsGbsxe3bwi29fylWX3ETMCnbaYwse/qQlbLZg7j3uv2L5Sk4/6QIu+fMN3HbLnSzYZh7FUTuz5L5bAnDj9bdz6onnsvSqW9n7wdvysL9ffNd9v1n9iQc/fme2Wzx/xrZXkgbUYuDDwDNzB5E0PRyJVVZlVZwEHJs7h7ShLv7TUn74hb9y+PF7sN3i+dy8bDkA11x2M8tvX8nivRcQs4MfnXQhN99wB0d39r7HOpbfvoJff/9y9n7wNmy+5cZc+MelnPapcznu9fuxxaJ5nP7lC1i0wybsedDWfOk9/8fhz6kf65yzruHy827k0KfsOtObLUmD7MndTu8ruUNImnruE6tsyqo4BgushsQZp1zKwUfsxPa7bk7MCuYvnMv8hXNZct8t2eP+i5i7yRw2mjub/R6xPVf89cbVrmOjjWfzoCN3ZotF84hZwa7325ItFs3jqotvBuCGa29jpz0XsPEmc9hul/ksu/Z27rj1Ts763uUUR+08k5srSW3w0bIqdswdQtLUs8Qqi7IqFgIfyZ1DmgorVyauuvhmbr1pOZ9582/4rzf8mtNPuoA771h5j9teft4ytrrXppNa7y3L7mDpVbfedftF99qUi/98A7ffcidXXXwTW22/Cb/4zqUccOi92HhT9w6RpHG2Aj5VVoW7LElDxhKrXN4P3Ct3CGkq3LJsOStXJM7/zXX8w8vuy9Neez+uufRmzvyfS+92u2suu5lfnnophxyzy1rXuWLFSk779Hns9aBt2Gr7TQA46DE7cvn5y/jaB8/mfg/fnpUrEtdcdgu73m9LTvvkuXzt3//I73505bRsoyS11GFAmTuEpKllidWMK6vi74Dn5M4hTZU5c+tfpfs9Yns2WzCXTeZvxAGPvBcXnr30rtssvfo2Tv7In3n4k5aw4+5brHF9aWXie58+n9mzZ/GIJy+56/vzNpvDEcfvyXGv248DDt2eH33lQh5x7BLO+t5lbLXDphzz4r35w0//xnVX3DIt2ylJLfXusirumzuEpKljidWMKqtiM+A/c+eQptK8Tecwf+HcCY+xvey62/nGh87m4MN3Yq8HbrPGdaWU+MHn/8otNy7ncSfsyezZq/81/YefXcX2S+azaIdNuebyW9hul82YPWcWi3bYlGuvuHVDN0mShsk84HNlVdzzsPCSWskSq5n2TmBJ7hDSVNv7wdvw+x9dyS03Lue2W+7kt6dfya77bslNS+/g692z2e/h23O/h2231vWc/qULuO5vt/L4F9znrhHe8W65cTn/9+MreeCROwGwYNE8Lj1nGXfcvoKrLr6ZLRZtPKXbJklD4ADgrblDSJoanmJHM6asiocAP8E/nmgIrVixkp989SL+8qtrmDNnFrvffxGHHLMLZ33vcn55yqVsNK6QvuD9DwTgzNMu4/Lzl3H0C/dm2XW38+k3/obZc4JZs1YN6z7yaffmPgdvfdfX3/3Meey6b33UY2jOH/uJc1h61W3sXdz9/LGSpLusAB7Q7fR+lzuIpA1jidWMKKtiY+C3wF65s0iSpJHVAw7pdnp+AJZazBExzZQ3YoGVJEl5FcAJuUNI2jCOxGralVVxAHAm4IksJUlSbtcBe3U7vatzB5G0fhyJ1bQqq2IO8F9YYCVJ0mDYCnhv7hCS1p8lVtPtVcCBuUNIkiT1eVZZFQ/NHULS+nE6saZNWRX3AX4HeL4PSZI0aP4AHNjt9O7MHUTSunEkVtOirIpZwIlYYCVJ0mDaF3hZ7hCS1p0lVtOlAxySO4QkSdIavKmsil1yh5C0biyxmnJlVWwHvCN3DkmSpLXYDPhg7hCS1o0lVtPhHcDmuUNIkiRNwjFlVTw+dwhJk+eBnTSlmnPCnoV/IJEkSe1xIXDfbqd3S+4gktbOoqGp9n58X0mSpHZZArwhdwhJk+NIrKZMWRVHA9/InUOSJGk93AHs3+30/pw7iKQ1c8RMU6KsirnAv+XOIUmStJ7mAh/JHULS2lliNVVeBOyeO4QkSdIGeGRZFc/IHULSmjmdWBusrIqtgXOBhbmzSJIkbaCrgPt0O72luYNIWj1HYjUV3oIFVpIkDYdtgdflDiFpYo7EaoOUVbEP8Htgdu4skiRJU+Q2YM9up3dJ7iCS7smRWG2o92GBlSRJw2Ue8LbcISStniOxWm9lVRwOnJo7hyRJ0jRYCRzY7fR+nzuIpLtzJFbrpayKOdSjsJIkScNoFvCe3CEk3ZMlVuvr+cA+uUNIkiRNo8PLqnhU7hCS7s7pxFpnZVUsBM4DFuXOIkmSNM3OAg7udnp+aJYGhCOxWh//DwusJEkaDQ8Anpo7hKRVHInVOimrYg/gj8BGubNIkiTNkAuA+3Q7veW5g0hyJFbr7l1YYCVJ0mjZFTghdwhJNUdiNWllVewL/B6I3FkkSZJm2OXAbt1O77bcQaRR50is1sUbsMBKkqTRtAPwwtwhJDkSq0kqq2Iv6n1h/cOHJEkaVVcD9+52ejflDiKNMguJJuv1+H6RJEmjbRvgpblDSKPOkVitVVkVuwF/AWbnziJJkpTZDcCu3U7v+txBpFHlyJom4/VYYCVJkgAWAK/MHUIaZY7Eao3KqlgMnIun1ZEkSRpzM/W+sVflDiKNIkditTavxQIrSZLUbzPg1blDSKPKkVhNqKyKnYDzgbm5s0iSJA2YG4Gdu53eDbmDSKPGkVityauxwEqSJK3O5sDzc4eQRpEjsVqtsiq2By4A5uXOIkmSNKAupz5S8R25g0ijxJFYTeSVWGAlSZLWZAfguNwhpFFjidU9lFWxDfCC3DkkSZJa4BW5A0ijxhKr1Xk59VH3JEmStGb7llVxRO4Q0iixxOpuyqrYCujkziFJktQir8wdQBollliN9xLqo+1JkiRpch5VVsX9c4eQRoUlVncpq2IBUObOIUmS1EKOxkozxBKrfs8HFuYOIUmS1ELHllWxOHcIaRRYYgVAWRWz8IjEkiRJ62sO8NLcIaRRYInVmCOAXXOHkCRJarETyqpwVps0zSyxGuMRiSVJkjbMfJzZJk27SCnlzqDMyqq4N3Au/lFDkiRpQ10BLOl2enfkDiINK0uLAP4Z3wuSJElT4V7A03OHkIaZI7EjrqyKecClwKLcWSRJkobE2cC+3U7PD9rSNHD0TU/FAitJkjSV9gEelzuENKwssXph7gCSJElD6OW5A0jDyunEI6ysioOBX+bOIUmSNKT26HZ65+UOIQ0bR2JHm6OwkiRJ0+c5uQNIw8iR2BFVVsVWwGXAvNxZJEmShtRlwC7dTm9l7iDSMHEkdnQdjwVWkiRpOu0IPDZ3CGnYWGJHUFkVQX1uWEmSJE2v5+YOIA0bS+xoOhy4d+4QkiRJI+Cosiq2zh1CGiaW2NHUyR1AkiRpRMwFnpE7hDRMLLEjpqyKJcARuXNIkiSNEI9SLE0hS+zo+Wd83SVJkmbSfmVVHJQ7hDQsLDMjpKyKudRHJZYkSdLM8jOYNEUssaPlsYAHFpAkSZp5x5VVsUnuENIwsMSOlqfmDiBJkjSiFgB/nzuENAwssSOirIpNgaNz55AkSRphTimWpoAldnQcBWyWO4QkSdIIe2RzpghJG8ASOzqcSixJkpRX4Ol2pA0WKaXcGTTNyqpYAPwN2Dh3FkmSpBF3MbBrt9NbmTuI1FaOxI6GJ2KBlSRJGgS7AI/OHUJqM0vsaHha7gCSJEm6y3NzB5DazOnEQ66sim2AK4DZubNIkiQJgNuAbbqd3k25g0ht5Ejs8DsWC6wkSdIgmQccnjuE1FaW2OHnVGJJkqTB88TcAaS2cjrxECurYmfgIurDuUuSJGlwLAW27XZ6y3MHkdrGkdjh9hQssJIkSYNoIfDI3CGkNrLEDjenEkuSJA0upxRL68HpxEOqrIo9gHNy55AkSdKELgd26nZ6fiCX1oEjscPLUVhJkqTBtgPwoNwhpLaxxA6vp+YOIEmSpLU6JncAqW0ssUOorIr9gb1z55AkSdJauV+stI4sscPp2NwBJEmSNCl7llWxT+4QUptYYofTEbkDSJIkadKcUiytA0vskCmrYlvgwNw5JEmSNGlOKZbWgSV2+DwGiNwhJEmSNGkPKKtip9whpLawxA6fx+YOIEmSpHUSOKVYmjRL7BApqyKoR2IlSZLULk4plibJEjtcDgS2zR1CkiRJ6+zhZVVslTuE1AaW2OFyeO4AkiRJWi9zgMfnDiG1gSV2uLg/rCRJUnu5X6w0CZFSyp1BU6Csis2Ba4GNcmeRJEnSerkZWNjt9O7MHUQaZI7EDo9HY4GVJElqs82Ag3OHkAadJXZ4OJVYkiSp/R6RO4A06Cyxw8MSK0mS1H6H5g4gDTr3iR0CZVXsCfwldw5JkiRtsJuALd0vVpqYI7HDwVFYSZKk4TAfOCh3CGmQWWKHg+eHlSRJGh6H5g4gDTJLbMuVVbEx/qKTJEkaJh7cSVoDS2z7PQzYNHcISZIkTZlDyqqYkzuENKgsse3n/rCSJEnDZXPgAblDSIPKEtt+j8kdQJIkSVPu0NwBpEFliW2xsioWAPfLnUOSJElT7tDcAaRBZYlttwcDkTuEJEmSptwhZVXMzh1CGkSW2HYrcgeQJEnStHC/WGkClth2s8RKkiQNr0NzB5AGkSW2pcqqmAU8KHcOSZIkTZtDcweQBpEltr32ARbkDiFJkqRp81D3i5XuyRLbXg/JHUCSJEnTyv1ipdWwxLaX+8NKkiQNv0fkDiANGktsezkSK0mSNPweljuANGgssS1UVsVWwJ65c0iSJGnaHZg7gDRoLLHtdFDuAJIkSZoROzUDGJIalth2ssRKkiSNjgNyB5AGiSW2nSyxkiRJo2P/3AGkQWKJbSdLrCRJ0uhwJFbqY4ltmbIqtgN2zp1DkiRJM8aRWKmPJbZ9HIWVJEkaLfuUVTE3dwhpUFhi28cSK0mSNFo2AvbOHUIaFJbY9rHESpIkjR73i5Ualtj2eUDuAJIkSZpx7hcrNSyxLVJWxbbAvXLnkCRJ0oxzJFZqWGLb5T65A0iSJCkLR2KlhiW2XfbMHUCSJElZbFVWhadZlLDEto0jsZIkSaPL0VgJS2zbWGIlSZJGl/vFSlhi28bpxJIkSaPLkVgJS2xrlFUxG9gtdw5JkiRlY4mVsMS2ya7ARrlDSJIkKZvdyqqYnzuElJsltj3cH1aSJGm0zQLulzuElJsltj3cH1aSJEkObGjkWWLbw19YkiRJWpw7gJSbJbY9LLGSJElakjuAlJsltj2cTixJkiRHYjXyLLEt0ByFbofcOSRJkpTdktwBpNwsse3gKKwkSZIAdiqrws/wGmn+ALSD+8NKkiQJYCNgx9whpJwsse3gSKwkSZLGuF+sRpolth0ciZUkSdKYJbkDSDlZYtvBEitJkqQxjsRqpFli22GP3AEkSZI0MJbkDiDlZIkdcGVVLAQ2z51DkiRJA8ORWI00S+zg2zZ3AEmSJA2UJbkDSDlZYgffdrkDSJIkaaDsUlZF5A4h5WKJHXyWWEmSJPXbGNg+dwgpF0vs4HM6sSRJksZzv1iNLEvs4HMkVpIkSeMtyR1AysUSO/gssZIkSRrPkViNLEvs4HM6sSRJksZbkjuAlIsldvA5EitJkqTxHInVyLLEDj5LrCRJksZblDuAlIsldvBZYiVJkjTewtwBpFwssQOsrIpNgPm5c0iSJGngLMgdQMrFEjvYHIWVJEnS6jgSq5FliR1sllhJkiStzsZlVczLHULKwRI72Dy9jiRJkibilGKNJEvsYHMkVpIkSRNxSrFGkiV2sFliJUmSNBFLrEaSJXawOZ1YkiRJE3E6sUaSJXawORIrSZKkiTgSq5FkiR1sjsRKkiRpIpZYjSRL7GDbLHcASZIkDSynE2skWWIH28a5A0iSJGlgORKrkWSJHWyWWEmSJE3EEquRNKkSGxEviYgtonZiRPw6Ih4z3eFkiZUkSdKEnE6skTTZkdjjU0rLgMcA2wDPAd49bak0xhIrSZKkiTgSq5E02RIbzb+PAz6ZUvpd3/c0fSyxkiRJmoglViNpsiX2rIj4LnWJPS0iNgdWTl8sNSyxkiRJmojTiTWS5kzyds8FDgD+mlK6JSIWUU8p1vSyxEqSJGkijsRqJE12JDYB+wBl8/VmwLxpSSQAyqoIYKPcOSRJkjSwHInVSJpsif0IUABPa76+EaimJZHG/H/27jw+6vrOH/jr/Z0zM7nv+yAJ4b4JdxJttF71QMGAtdraWm1arQfSdvvbNt0e291Vu7Fud7u1ulpXW49q1WKt3RIQBhVQvLmFcN8BEnLMzOf3x3eCQ0hgAkk+c7yejwcPkjm+85oAw7zm8/l+PhyFJSIiIqIz4YAHxaRQpxNPU0pNEpF3AEApdVhE7IOYi1hiiYiIiOjMQh2QIooqof7F7xIRC8xpxRCRDHBhp8HGEktEREREZ2LRHYBIh1BLbCOAPwLIFJGfAHgDwE8HLRUBLLFEREREdGYciaWYFNJffKXUkwDuA/AzALsBXK2UemYwgxFLLBERERGdkQQWAyWKKSGdEysiqQD2AXgq6DKbUqprsIIRSywRERERnZUFgFd3CKKhFOoUhLUA9gPYAGBj4OutIrJWRCYPVrgYxxJLRERERGfDKcUUc0L9S/8qgMuUUulKqTQAlwL4A4BvwNx+hwYeSywRERERnQ0Xd6KYE2qJnaKU+kv3N0qp1wBUKaVWgWVrsDh1ByAiIiKisMeRWIo5oe4Te0hEFgN4OvD99QAOB7bd4VY7g4MfDhARBUmIS9mRaM9c7++yi/jsUArwK79AKUAJlIIBiAjARU4oohw/2mb9w2//Onz7lj0pTpejq+bSyVunV4/d3/N2v/6358fsat6f1P293+eX5NSEE3f/6ItrfF4ffvefS0Zs27w7NTsv7eiN37j84ziXwwcAS55bUWCzW/21X5i2cyifFw2NTnWMr3kUc0ItsQsB/ADACzDfHLwRuMwCYP7gRIt5Nt0BiIjCRUp85ta5s+5wHjm2x7374IZKKDkBb9w28boPi9fVBZ/TDWXNAZALhQ6lVKtS6oRSql0p1aGU6lRKeZVSXr/f71NK+ZVSCPwSpZQFgFUpZQNgU0o5YM6IiQPgCvziG0UaFC8+9xukJGTjzvvvw44dOxwPPfTQiMkjLhyRm5t7yu3+YfH4U76///77UVFR4cqwjJ+z+p3VSHZn4a4Hv4NHHnkk5RPPkZkXX3wxDhw4gF1bjmLRokWwWCzDhvJ50ZDhaxPFnJBKrFLqAIBv9XH1poGLQ0E6dQcgIgoH6Ym5G6+e8Y1kESMjNTE3p6OrrenQ0R3VsLWNUrY2qOAbK+M4vM7t4nUfMrwuX6DcZgPIE8g5v9FTSikA3cW4Lagcdymluvx+vzdQjIPLsREox5ZAObb3KMfuwO8Uwzo6OrB27Vr84Ac/gNPpRFlZGcaPH49Vq1Zh7ty5fd7vwIED2LhxI2666aaT3w8fPhwWiwUVFRXYudMcdH366adx3XXXwWLhaZNEFD1C3WInA+Y+saMRdK6mUurCQcpFQLvuAEREumUmF35y5bSvZwa2egMA5KSVVXd0tTa1njhcfdodxB/fd7mN2yZe12Hxun3wOdxQ1lyB5J52jF6IiABwi4j7fJ/TKbGU8gNoCxTj7pHjTqVUp9/v71JK+QK/ukmgHBswR4xtSik7zFNQ4vDZyDHXVYgQe/fuhWEYyMrKOnlZfn4+NmzYcMb7rVq1CuXl5UhPTwcA5OXlwePxYObMmVi/fj3Ky8vxzjvvID4+HmVlZYP6HEg7dfabhC8RWQrgd0qp3+jOQqcSEQWgXCl12qCliNwA4Cal1MWD8LhLcZa/E6FOJ34SwO8BXAHgNgA3wdxmhwbPCd0BiIh0yk0r/eCyKV8pEJGkntcVZY2r2rTzrZWdXSdmhnQw8cfD1jpa2Vqhgv/7UsYxeOO2i9d9SLwuf6Dc5gkkZ8CeyJliiRgA4kUkfiCPGyi+rTAL8gmlVIff7+8MnlYdNHIsQb+6R42tgVHj4HLsBmAfyJxkjsTGxZ06IB8XF4eOjo4z3m/VqlW47LLLTn4/ZswYbNy4ET/96U9RUlKCqVOn4sEHH8Sdd96JF154ARs3bkReXh7mz58PqzXUt38UIcJmfRoRuRnAPQBKARwF8EcA31VKHQlc/0MAZUqpLw5hptkA/gXmYJwPwMcAvq2UenuoMgwkEckB8GMAlwGIB7ATZk/7l8Dr/pBQSj0JsyNqEeqrWJpS6hERuVMp1QSgSUSaBjMYscQSUewqzBjx7sWTbizrq9yJiJTmTZ2yYbvnXZ+/a8I5P5D4Ez4rt0H8Rgt8cdvF624Rr8sHnyM+MHI7JOX2fImIRUQSASQO5HED06e7i3HwOcddQeW4W/e0akvglxXmlGo7zJFiJ8xRYzdCfz8SdRwOB06cOPW//Pb2djgcfa/vuGnTJhw9ehSTJk06eZmIYO7cuSenID/77LOoqqrCtm3bsG3bNtx777144oknsGLFClRXnz6JgSJal+4AACAi98CcuXkTgL8ByIO5FedfRWSWUmpQT5ULzJiRwJ16t+gAACAASURBVAyX7ssSAbwM4HaY24PaAcwBcOZPic7t8a1KKe9AH7fHY6QC8ABYCWCGUupTESkAcC/MDw7eG8zHDyeh/qfR/Y9jt4hcDmAXgPzBiUQBnE5MRDFpWPbYNReOrxslImc8X9QQw16eP61kffPKjUr5ywc0hOFPgtE6tvdy69ouXtcRc+TWmQBlyRVI9oA+fpgSEVtgZPy00fHzERghDp5W3b0YV1fgV/eocTej+5zjoPONg6dVd5fjsD8RNCsrC36/H3v37j05pXjHjh3ouahTMI/Hg4kTJ8Lp7H3W+M6dO7FlyxbMnTsXr732GgoLCyEiKC4uxo4dOwbleZBWg1qcQhEoiw0AvqKUejVw8aciMh/AFgBfFJFdAL5n3lyuBrBZKdW9WlmRiKwAMA5mSVsYWJMHIjIdwAMARgHYBuBOpdTSwHVLAawAUANgEoCxOHW9nuEAoJR6KvD9CQCvBeU2Apm+BvO141UA31JKtYhIDcwprflBt/8UwFeVUq8HRpXHwHzPfiWAu0XkUQCLAdwCIBPABgBXK6WaRWQEgIcATIY5o/X/KaX+EDjuZQD+DUABzBHsB5VS/9bLj/puAMcAfLG7rCulmgHcGZRxJoB/Dzz3DYGf18qgn9cbAC4M/Kz/DuBmAI0AvgBgPYB5SqlPgx7zMhH5NswPRR8FsFgp5Q+Mun9VKTU7cGwF88OCewCkA/hfAN9USqnA9V8BsAhANoC3ANyqlNoWuO6iwM8mB8ATCGGxslBL7I8D/2ndE3iARAB3hXhfOjcciSWimDM8b/JbVWPmjheRkLYZs1isSWV5U1s37nhzN8z//AaX4U+CcXyssh3vUW4tR4JGbv3wORKgLPkCyRz0TFFAROwiYgeQPJDHDZTh7gW5epZjr1LK5/f7u8uxKKUEgKGU6l6pOnjkOHha9YDty+lwODBx4kS89NJLuPHGG9Hc3Ix3330Xixcv7vX2nZ2dWLNmDW677ba+njOeeuopzJ8/H4ZhID09HX//+9/h9XqxYcMGFBYWDlR0Cg++W2+9NRzOiZ0J89/J88EXKqWOi8gSABcppRaIyE/R+3TihQAuBdAMYAnMkcXviEgegFcA3AizYH4OwHMiMkIp1X1uyI2B+67H6eVnAwCfiPwPzK1CVymlDgddf3Pg1wUA9gF4HMAvA8cMxVUA5gH4EswP0e4GsADmVN8NMItiW2A9hb8C+MdA1nEAXhORD5VSHwJ4BMB8pdRyEUkBUNLH49UCeD54tDlYYKT2FQB3AHgqkO0VESlTSh0M3KwOwOcBHID5gYEHwDdgjqD/FuaONF8OOuw1AKbAnLr8Osyfc1/nql4BYCrMrrgGwEsAXg18aPE9mEV5I4DvBPLNFJF0AM8B+AqAFwF8E+bpq0/08RgAQl+d+OXAly0w/5Bp8HEklohiyujCGZ4ZI6+YIiL92mLMbovLLcmdtGHrrrVuDPD02ZAZvmQYx5N7KbeH4Ytrli73EfG5FHyOxEC5zdCSM8aIiCPUD0T6I1CIWwPTqYPLcfc2Tt3Tqnvbxql7WvXJlaoXLFjgevzxx9333nsv3G43brjhBuTm5mLjxo146KGH0NjYePKx3333XcTFxaGioqLXbCtXrkRubi6Ki4sBABMnTsQ777yDe+65B8OGDUNVVdVA/zhIr3DZzSIdwIE+ptPuhjn6eCaPKqU2AICI/AHmyCYAfBHAn5VSfw58/1cRWQ2zJP5P4LLHAkXwNEqpo4FzYhcD+G8A2SLyZwBfU0rtBXADgAeUUlsCj/1dAB+IyJd7O14vPEqpFwJfnxCRrwK4Tym1PnDZusBxrwfwqVLq0cDla0XkOQDXAfgQ5qzXUSKyLlCyg4t2sDSYP8++XA5go1KquwA+JSJ3wCyPjwUue1QptTmQawmAUUqp1wPfPwPgn3oc8+dKqUMADonIL2CW9L5K7D8r8/znIyLydwATYH748HUAP1NKfRx4nJ8C+J6IFAGoBvCRUurZwHW/gDlwekahrk5cAnOLneLg+yilruzrPnTeOBJLRDFj/LDqFVPLL54uIuc0/dPlSBxekDl6bfO+D8cinPbZNnwpMI6n9FJuD8Hrahav66j4XH6W28giInFnm+7eHykpKfje976n8NlCXG1KqfaJEyd2PPLII6ds4zR79mz/rFmz+tzGadasWY5Zs2ad3MbJYrHEfe1rXxuoqBR+BvzcznN0AEB6H+eF5gSuP5M9QV+3wRz1A4AiAPNE5AtB19tgToPt1nymAweK080AEJjS+zsA3WUsF+YU5W7bYHadLISm52MXANjcy+2KAEwTkSNBl1nx2WjjtQC+D+CfReQ9AN9RSnl6Oc5BnHnWUc/ng8D3eUHf7w36+kQv3/dciyL4OW4LPEZfzvTn+O8icn/Q9RLIlRv8GEopJSJn/DMFQp9O/ALMYe6XEEYroEU5jsQSUUyYWn7x8vHDqmcHFuU4Z4nujEmZKcNW7Du8ZSZCOJ9GK8OXCvuxVGU/1rPcHjTLrfuoeOMAvyMJypInkHRdUWlocBsnOkfhUmI9MLPMhbmAEgAg8Pf5UphTSYH+bwfUDOAJpdSZPokJ+ZhKqU9E5DGYI4OAuc5PUdBNCmGeY7wXZrlydV8R+JC15weNPR+7GeYCSx/0cnmTUuqiPnK9DeCqwEykb8L8GRb0ctPXAVwjIg19TCnu+Xy6n9Orvdw2VAUwR4u7j7XrHI7RDOAnylzR+BQiUo6g5xp4LeztuZ8i1BLbrpRqPPvNaKA01nt8dzw8owvhNKJARDTAZo78QtPoohkDtlRqRnLhrI6u1qaW43sjc/lVw5cG+7G0XsrtAXhdO8xy6wL89iQoS4Hgs/1ziXozRNs4tSul2nvZxsnXY0o1t3EaeGFRYpW5EFIDgIdE5ChOXZ14Bz4bcdwL4CIRMfo6r7OH3wF4W0Q+D7PA2QBMB7BJKXXWVcoCI6+XA/i9UmpHYCXfBQBWBW7yFIDFgWm1+wH8NHBbr4hsAOAMLGr7GswifrbTE34D4J9E5COYC0yNhbkFzsswR1lvhHluLmBOtT0Oc+R2HoCXAz/HozC3AurNAzCnWP+PiHxfKbUtcN7wPTCnC/8Z5p/BQphF+FqYC2K93MfxQrFIRN6EOap6ZyBDf/0nzJ/Lu0qpDwNrLV2slHoG5jm8vxSRuQD+BKAe5uJPZxRqif13EfkBzD/Ak/9YlFJr+/sMqF/awRJLRFGqeux1S4fnTaoZ6OPmZ4ys7uw6sexEx9HoOfnP8KXDfiz99HJr3Q+va6d4XS3idUmg3BYKJEVXVIoN3MYpbLTpDtBNKfUvInIQ5iq73fvEvgDgBqVUd394BmYJOygiW5VSk3o/2sljNovIVTD3eX0KZrl7C+YquKE4BmAazJWDkwEcgVnoFgWu/y3MEddlMP++/AXmKZTdxfwbMIupJZDhbMX5AZhF9zWY5wl/AuAapdRBEbk4cP0DMBeHWwdzISjAXEjql4HR3vUwf0a9/TwOBVYf/jGANwMj3Tth/mw2KaXaROQKmKsT/wpmkb5CBVZ6PkcvwlykKQlmUX6kvwdQSv0x8EHa04HzYFtgLnT1jFLqgIjMg7lC8qMwP/BYcbZjilJnH4EXkZ/B/OFuxmfTiZVS6sL+PgkK3R0Pz9gLc3luIqKoctHEG5YWZ42uGazjK6V8G5tXrenydVQO1mOENb91X2Dk9ph444ygcjugq/8SRQoV+jZO/qBR457bONnw2UrV4bKN09pbb731bIsmEUWdUD+VugbAMDXImxTTabi4ExFFnUunfLkpP728ZjAfQ0QsZfmVY9ZvX/mhX/lGD+ZjhSXDmwn70UxlP9pz5HavOXLbXW4dyVBGoUAGdN9XonAzBNs4tQW+blc9tnFSSvn9fv/JadU4dRsnmwpaqRr938apdSCfD1GkCLXEroP5j37fIGah03FxJyKKJuoL076+PDulaEjOVzUMi6u8YFr2hu2eTxVU8VA8ZtgzvFmwH806vdza9og3bie87uPidRnw25OhjCKB6NmyiChCBG3jNKDnp6sQt3HCZwvuEMWUUEtsFoBPRORtnHpOLLfYGVwciSWiKCH+a2bWr0xPzB3S81StFntaad7U45t2vnUA5vlJ1BujK1vZu7LRs9z6bLvF59oFr6u73KYERm5ZbgfIq6++iqVLl2L79u2YNWsW6uvre71dV1cXnnzySXg8HnR2dmLWrFm4+eabYbWab+Uee+wxNDU1ITc3F/fccw9SU81OtXz5cmzatAlf/nKo215SOOjHNk57z34TougTaon9waCmoL5wJJaIIp6I4b1u1p1vJcdnzNbx+A67q6g4e/yHn+5Z50LQdgkUAktXjrK05MDe0rPc7hKvaxe87lbxxVngs6cARqFAEnRFjVQpKSmYO3cu1q1bh87Ovs/aeuGFF7Blyxbcf//98Pv9+PnPf47nn38e8+fPx6ZNm7Blyxb8+te/xtNPP40//vGPuOWWW9DW1oaXXnoJP/zhD4fuCdFQO6o7AJEOIZVYpVTTYAehXnEklogimiGWznlz7lqb6EqdqTOHOy5ldG56xVu7DqyfDP0LsUQ+S1eusrTkwhFUbhUU/Lad4nXtDiq3qYBRJBjYvU+jybRp0wAAW7ZswcGDB/u83Zo1a3DVVVchPt7cKefSSy/Fk08+ifnz52Pfvn0YMWIEbDYbxo4diyVLlgAAnnrqKVx55ZVwufjZTRRjiaWYdMYSKyJvKKVmi8gxnLqZr8BcnZjTiQYXR2KJKGJZDGv79VX3fuB2Jk7XnQUAUhJyKju72pYdaGmOnq13wolAYOnKU5aWvNPLrX2nOXLrahVfnJXltv+6t5MJ/v7gwYNoa2tDfn4+lixZgs7OTrz//vvIz8/H5s2bsWvXLtxyyy0aU9MQaNEdgEiHM5ZYpdTswO+cHqQHR2KJKCJZLfbWuqp7N8Q54qfozhIsK7W0qqOrrelY28EhWVyKECi3nXnK0pkHx5Ge5bY5MHJ7why5taUFyi2HDnuYOHEilixZgjFjxsDv958cbe3o6EBhYSGmTZuGf/iHf0Bubi5uueUW/Ou//iu+/vWv489//jPefPNNpKWl4ZZbboHbzc8NogxHYikmRevGz9HiuO4ARET9ZbM6ji6ovu9Thy1uou4svSnMGlu9acfbb3R0tWo5R5cCzHJboCydBT3KrR9++3bxuvbA624Tb5wNfnsaIEWCkBa6iUpz585Fa2srFi1aBJvNhs997nPYunUrkpLM3ZGuuOIKXHHFFQDMxaJGjBgBpRT+9re/4ec//zlefPFFvPDCC7jhhht0Pg0aeCyxFJNYYsMbtzQioojisLkO11Uv2m23OsbpznImpXmTp63f7lnr83dN0p2FehAYsHQWKktnYS/ldpt43XvhdXWX2/RAuXXqjDwU7HY7brnllpPTg19//XUMGzYMhnHqdqJHjhzB66+/jp/85CdYs2YNCgsLYbVaUVpaenL0lqIKpxNTTGKJDW97dAcgIgpVnD1+f131vYetFvso3VnORsSwlRdMK1u/feV6pfwVuvNQCMxyW6QsnUVwHO5Rbh3bAiO3J8Tr7C63xQJxaEwcEp/PB5/PB7/fD7/fj87OTlgsFlgsp64/dujQIQDmasYbN27Ec889h9tuu+204z3++OOYP38+HA4HMjMzsXnzZrS3t+Ojjz5CZmbmkDwnGlIciaWYxBIb3lhiiSgiuJ1Je66fc0+bxWIdrjtLqCyGNbE8v7JtQ/ObOwGVpzsPnSOBAUtHkbJ09Cy3PvgdW8Xr2guvu8McubV1j9yGTbl97rnn8Oyzz578fvny5bjuuutw4YUX4q677sKDDz6I9PR07NmzBw8//DBaWlqQlpaGhQsXYvz48acc64MPPkBraysqKysBAGVlZZg0aRJuv/125Obm4u677x7S50ZDgiWWYpIEr3RH4eWOh2dcCOBvunMQEZ1JQlzqjnlz7vJZDEuR7izn4kTHsc1bdq1JB5CkOwsNAbPcbhevey+6XO3ii7PDb8sIlFu77nhE/VQxb968DbpDEA01jsSGN47EElFYS3ZnbLt21h1WI0ILLADEORJKCzLHvNu874ORAMJmhI4GicACS0eJsnSUwHEoeOTWC59ji3jd++B1tYsvzhFUbm06IxOdAd8rUkxiiQ1vfGEiorCVmpC9+ZqZ34w3xMjSneV8JbrTJ2Snlq7cc2jzDJh7oVOsEVhh7RimrB3DgFPKbRd8zs3ide2H190uPqcDflsmIIUst6RZ27x58zidmGISpxOHuTsentEBgNObiCisZCQVrL9q+tfTRIx03VkG0q4D65sOH9vNPWTp7Mxyu0287v3idXXA53QGlVsOEtBQ2Dxv3rwy3SGIdOCLbPjbC6BAdwgiom45KSUfXV751VwRSdadZaDlpldUd3SdaGprP8IiS2cmsMHaXqas7WUKBz+7XEknfI6NgXLbCV+cE35rVqDcWvo+IFG/ccYexSyW2PC3GyyxRBQm8tOHv3fJ5JuKRSRRd5bBUpw9fs7GHW+u6vK2T9edhSKQKDus7eXK2l5+erl1bhGva7943Z3myC3LLZ2X3boDEOnCEhv++CkbEYWF4qzRa2snLBwhIi7dWQaTiBhleVMnrG/2vOf3e8fpzkNRQpQd1hPlynqiZ7ntgM+5SbzuA+J1eXuUW0NfYIoAfI9IMYslNvzxBYqItCvPnfh29djrxoqIU3eWoWAYFmd5/rSCDdtXblVQJbrzUBQT5YD1RIWynqg4ZZUSJe2Bc24PiNfVBZ/TBb8tG0A+yy0FcCSWYhZLbPhjiSUirUYVTFs1c9SVk0ViayVWq8WWUpo/tXXTjrf2AcjUnYdijChnH+X2BHxx28TrOiheVxe8TheULRtAgUC4snZsCZsSKyILAdwNYASAYwDeBfATpdQbIjIcwE8AXADABmAbgMcArAHwSvchALgAtAYd9hkAFqXUl3o81jgAbwPIUUodGqznROGNJTb8hc0LFBHFnnElc1ZUDr9kukhsnrPnsLnyi3Mmfvzp7ndcAOJ15yGCqDhY20Yoaxt6lNs2+OK2SZfrkHjd5sitsubAHLlluY1OYTHQISJ3A/gOgNsA/AVAJ4BLAFwlIrsBvAngUQBjlVK7RaQCwA8A/FYpFR84RjGArQCSlVLewGUzAPxVRG5XSgWX2y8BeJkFNraxxIa/sHiBIqLYM7msdvnE0gtmicT21EW3M2lkXsbI1Tv3fzwB/H+TwpUoF6xtI81ye+Czy5W0whu3TbzuQ4Fzbt2BcpvHchvxduoOICJJAH4E4MtKqeeDrnoJwEsi8jsAK5VSd3dfoZRaD2Dh2Y6tlPKIyE4A1wJ4PPB4lsB9bxu4Z0GRiP8Zhz+WWCIactNHXNY0pmhWlQjf5AJAcnzWlM6utuX7j2ybozsLUb+IcsPWNkrZeo7cGsfhdW4PlFtfULnNZbmNGNt1BwAwA4ATwB/7uL4WwHfP4/iPwxx5fTzoeDYAS87jmBQFWGLDH0ssEQ2pOaOvWTqiYGqN7hzhJjOlZE5HV9vSo637a3RnITpv4o/vo9wegzduu3hdh8Xr9sHncENZcwWSqysq9erYvHnzjugOASANwIHuKcB9XH8+p8Y9AeCHIpKvlNoBs9D+r1Kq6zyOSVGAJTb8scQS0ZC5cHzd0tKccTW6c4SrgszRNZt3rl7e3nmcI7IUncSfAFvraGVrhcL+zy5XxlGz3LqPmCO3DjeUNU8gOfrCxrRm3QECDgJIFxFrH0X2IIBz/juilNouIssAfFFEfgngagB8/SWW2HDXWO9pv+PhGUcAJOvOQkTR7fOTb1pamFFRoztHuBuWO2nGhuZVq72+zim6sxANGfEnwtY6xiy3QfxGC3wny60fPkcClDWH5XbQhcNUYgDwAGiHWS6f7eX612Ge0/roeTzG/8BcOGo3gK1KqbXncSyKEiyxkWEPWGKJaPCoKyq/tiwntaRGd5BIIGJYy/OnjVy/feXHfuUbqTsPkVaGPwlG69jey61ru3hdgXLrTICy5AkkS1fUKBMWJVYp1SIi/wjgYRHxAngNQBfMc1cvgLkK8dsi8q8A7ldK7RGRMgA/BPBNpVQoU6KfA/AwgIbA70QssRFiO8x9t4iIBpj4r55x+4qMpPxq3UkiiWFY3GX5lekbmlc1A6pAdx6isGP4k2AcH6tsx3uUW8uRwMhty2cjt5Z8gXAv5v4Jl+nEUEo9ICJ7AXwfwJMw94ldA3Of2M2BrXJ+DOBDEbEC+BTmyOyxEI/fKiLPAbgxcHwiltgIsR7AxbpDEFF0EYjv2tl3rEqJz+L5RefAZnVklOZN3rp55+pDAFJ15yGKCIYvGcbx5F7K7WH44rZLl/uo+Fx++ByJgXKboStqmAuLkdhuSqkn0UfBDGypM+8s9/8UQJ+rYiulbgZw8zkHpKjDEhsZPtEdgIiiiyFG17w5d61JdKXN0p0lkjnt8SVFWePe37b3PRfMbSaI6FwYvhQYx1N6KbeH4HU1i9fVIl4X4HckBqYlx3q5DasSSzTUWGIjA0ssEQ0Yw7B0XF9173vxzqTpurNEg3hX6tictPJVuw9urARg6M5DFFUMXyrsx1KV/VjPcnvQLLfuo+KN6y63BQJJ0xV1iLHEUkxjiY0MLLFENCCshq3t+upFn7gc8VN1Z4kmqYl50zu62poOHd3Jc4uJhoLhS4P9WNrp5da6H964nWa5dQF+e1Kg3EbTlP9OANt0hyDSSZRSZ78VaXfHwzNaACTqzkFEkctmcRyrq160xWl3jdedJVp9umddU+uJwyyyROHGb90Pr2uHeF1Hxesy4LcnQlkKBZKiO9o5+GjevHmjdYcg0okjsZFjPQCOnBDROXHY4o7UVS/aabc6WWAHUVHWuKpNO99a2dl1YqbuLEQUxPBmwH40Q9mP9hy53WeWW/cx8cYZ8DuSoYwCgYTz1oYf6w5ApBtLbOT4BCyxRHQOnHb3wbqqRQdsVjs/uR9kIiKleVOnbNjuedfn75qgOw8RnYXhzYT9aGYv5XYvvK6dPcptoUCSdEUNwtPMKOaxxEYOvmARUb+5HAn7rq+695jVYqvQnSVWGGLYy/MrS9Y3ezYp5S/TnYeIzoHhzYL9aNbp5da2W7yu3fC6jgWmJSdDGUUCGcpTvviekGIeS2zk4AsWEfVLfFzyrvlz7u60GNZS3VlijcViSyrLm9q6ccebewBk685DRAPE6MpR9pYc2FtOLbc+227xuXaiy90qvjhLULlNGIQUfE9IMY8lNnLwBYuIQpbkSt9+3ew7DcOwFOvOEqvstrjcktxJG7buWusCF+Yjim6Wrhxl6bXc7hKvaxe8gXLrs6cARpFA4s/xkRT4npCIJTaCbATgBf/MiOgsUuKzts6d9S2nIUaO7iyxzuVIHF6QOXpt874PxwKw6c5DREPM0pWrLC25cASVWwUFv22nOS35ZLlNDZRb91mOuHPevHnHBzk1UdjjFjsR5I6HZ6wHMFx3DiIKXxlJ+Ruumn5bioiRoTsLfWb/ke0r9h3eMkt3DiIKYwoKfnug3LragsptsUBcgVu9Pm/evIu05iQKAxzViyyfgCWWiPqQnVL08RWVt2aLROS+h1EtI7lwVkdXa1PL8b3cQ5aIeicQWDrzlaUzH44jPUZu7c3ide2Gz9mkMyJRuDB0B6B+4TkQRNSrvLSy96+ovDWXBTZ85WeMrI5zJC7TnYOIIoxZbguU40ilcu3ZqzsOUThgiY0sLLFEdJqizFHvXDrly8NEwmL/QjqDkpyJs2wWx1u6cxBRxPpAdwCicMASG1lYYonoFKU541dfNPGGESJnXQyEwoCIWMryK8cYYvlQdxYiijgKLLFEAFhiIw1LLBGdNCJ/6psXjJs/TkTidGeh0BmGxVVeMC0LkG26sxBRRNlWV9twTHcIonDAEhtBGus9hwHs052DiPQbUzRz5ezRV08WEbvuLNR/Vos9vSxvigA4oDsLEUWM93UHIAoXLLGR52PdAYhIr4mlF7wxfcTl00WEK8xHMIfdXVicPX4vgDbdWYgoInAqMVEAS2zkWas7ABHpU1lxybLJZbWzRISv31HAHZcyOje94gMAPt1ZiCjsrdMdgChc8E1Q5FmlOwAR6TFr1JVN40uqqkREdGehgZOSkFOZnlSwQncOIgp7XNmcKIAlNvKwxBLFoAvGzW8aVTi9WncOGhxZqaVVCXFpTbpzEFHY2l9X27BVdwiicMESG2Ea6z3bAezSnYOIhs7FE29cWpY7gQU2yhVmj6122NwckSWi3rytOwBROGGJjUwcjSWKEZdPvaWpKGtkje4cNDRK8yZXWgwb1z4gop44lZgoCEtsZGKJJYp+6qrpty/LTSvlCGwMETFs5QXTykSM9bqzEFFYYYklCsISG5lYYomimEB81866Y0VmckGV7iw09CyGNbE8vzIJPHWEiD7DEksUhCU2Mq0G0KU7BBENPBHDO2/OXW+lJmTP1p2F9LFZndnDcie3AWjRnYWItNtSV9twUHcIonDCEhuBGus9JwC8pzsHEQ0sw7B0XF91z9okd/oM3VlIvzhHQllB5pitADp1ZyEird7UHYAo3LDERi5OKSaKIhbDemJB1aL3E+JSKnVnofCR6E6fkJ1auhqA0p2FiLThVGKiHlhiIxdLLFGUsFrsxxfWLF7vciZO0Z2Fwk9aUsHMlIScZbpzEJE2LLFEPbDERi6P7gBEdP7sVmfLwprFW5129wTdWSh85aZXVLucSU26cxDRkPMC4LZbRD2wxEaoxnrPZgD7decgonPntLkOLaxZvMthixurOwuFv+LsCXNsVidn4RDFlvfrahvadYcgCjcssZGNJ/oTRag4R8L+BTWLD9qsjpG6s1BkEBGjLG/qBMOwvq87CxENGU4lJuoFS2xk4yfyRBEo3pm8e0H1ouNWi61cdxaKLIZhcZbnT8sXYBgU5gAAIABJREFUyFbdWYhoSCzXHYAoHLHERjaeF0sUYRJdaTuur7rHazGsJbqzUGSyWmwppflTbeApJUSx4P90ByAKRyyxke0tAH7dIYgoNMnuzE/nzbnLYhiWAt1ZKLI5bK784pwJBwAc152FiAbN+rraht26QxCFI5bYCNZY7zkO4EPdOYjo7NISczddO/sOlyFGju4sFB3czuSReRkjPoG5eikRRR+OwhL1gSU28vG8WKIwl5lc+Mk1M+pTDDEydWeh6JIcnz0lI7mIp5YQRSeWWKI+sMRGvjd0ByCivuWmDvvwymlfzxGRNN1ZKDplppTMSXRncA9ZouiiACzVHYIoXLHERr6/6g5ARL0rzKhYd9nUWwpFJEl3FopuBZmjq532eK5iShQ93q+rbTigOwRRuGKJjXCN9Z7dAD7QnYOITjUse+yaiyd9qVxEEnRnodgwLHfSDKvFvlp3DiIaEJxKTHQGLLHR4TXdAYjoM8PzJr914fi6MSLi0p2FYoeIYS3LrxwhYnysOwsRnTeWWKIzYImNDiyxRGFidOEMT9WYuRNFxKE7C8Uei2GNL8+flgbIDt1ZiOic+QAs0x2CKJyxxEaHZQDadYcginXjh1WvmDHyikoRsenOQrHLZnVkluZN7gJwWHcWIjona+tqG1p0hyAKZyyxUaCx3nMCXKWYSKup5Rcvn1p+8UwRsejOQuS0x5cUZo1rBj/gJIpEnEpMdBYssdGDU4qJNJk58gtNE0pr5oiI6M5C1C3BlTouJ638XQB+3VmIqF/+rjsAUbhjiY0ef9EdgCgWVY+9dunoohnVunMQ9SY1MW96amIet94hihwdAPhvlugsWGKjRGO95z0Ae3TnIIoltRMWLh2eN7lGdw6iM8lJK692O1OadOcgopD8X11tQ5vuEEThzqo7AA2oVwHcrDsEUSy4dMqXm/LTy2t05yAKRVH2uKpNO95a2ek9MVN3lnD3lxfeQtNr69D86T7MrBmD2++76uR1H6zdgkd/uQQH9rWgbEQeblt0FTKykns9zqeb9uCxh5dg+5Z9iHPZceFlk3DtjeakjYP7WvCLf3oWu3ceRPXFE3DjbRefvN/Pvvsk5t98AUorcgf3iVK4ekl3AKJIwJHY6PKK7gBEMUB9Ydqty/LTyzmFmCKGiEhp/tTJFsP6ru4s4S4lLQHX3DAHNZ+fcMrlR1va8EDDM5h30wX47+fvw7DhuWj88XN9HueXP3seI8cW4TfPL8I/3n8TXn95DVavXA8AeOHpFai6eDwan7gDq1eux+b1uwAAnqUfIjMnhQU2trHEEoWAJTa6/AVAl+4QRNFL/NfMqH8jO6W4SncSov4yxHCU508rETE2684SzirnjMTUWSMQnxh3yuVvv/Ex8oszML16FOx2K669sRrbtuzFzu0Hej3O/r1HMOtzY2FYDGTlpqJidAF2bNtvXrfnMEZPKIbL7URpRS727TmMttYOvPj0CtR95cJBf44Utt6pq23gHs9EIWCJjSKN9Z5j4ObYRINCxPBeN/vOVelJeXN0ZyE6VxaLLaksb2ocuIZCv+34dD+KhmWd/N4ZZ0dWbsrJYtrTpddMw/K/roPX68Ou5gPY+PEOjJ1UAgAoKM7E+2u2oPV4O7Zs2IX8wgw889jfcencaXDHO4fk+VBY+pPuAESRgiU2+rysOwBRtDHE0jl/zt2rU+IzeT4hRTy7LS63JGdSC4CjurNEkvb2TrjcjlMuc7kcaG/r6PX2k6YPx5vLP8ZNl/8U93zlP1BzyUSUVuQBAK6qm41PPtiOH93zP7j4yqnw+nzYvnUvJk8fjod++jwa7n4Mf3nhrUF/ThR2OJWYKERc2Cn6vATgQd0hiKKFxbC2X1917wduZ+J03VmIBorLmViRnzlq7Y59H40FYNOdJxI4nXa0tXWectmJtk44XY7Tbnv86An88/eexM3fvBSzLhyLI4eO4xc/egZJKW5cfOVUxCfG4c7vXwcA8PsVfnT3Y7jlzsvx4u/fQEFxBm5fdBW++41fY/TEEuQXZQzJ8yPtdtbVNqzRHYIoUnAkNso01ns2A1ivOwdRNLBa7K0Lqu/72O1MnKI7C9FAS3JnTspMKeFwX4jyizOwffNns7DbT3Ri7+5DvZbMvbsPwzAMVF00HhaLgbSMRMy4YDTefWvTabf92ytrUDYyDwUlmWjeug/DhufCarOgoDgTzZ/uG9TnRGGFM+mI+oElNjpxlWKi82SzOo4urFm8Oc4RP1F3FqLBkpFcNCvJncU9ZIP4fH50dnrh9yv4/ebXPp8fU2eNQPOn+/Hm8o/R2enF879bhsKSLOQVpp92jJz8NCilsOL/3offr3Dk0HGsWvrhKefUAkDL4Vb89U+rcd2XagAAGdkp+HDdp2g/0YmtG3YjMztlKJ4yhQeeD0vUD6KU0p2BBtgdD8+4AMD/6c5BFKkcNtfhuupFu+1WxyjdWYiGwpZda5ad6DjGVbcBPPv4Ujz3xKlrJF57YxWu+1IN3l+7BY/9cgn27zX3ib190VXIyDb3if3NL8zPj7/67csBAB+8sxVP/eZv2L3jIOwOKyZNH46bvnEJHM7PZm//x89fwKTpwzG92nypObivBQ/+0zPYs+MQqj9/6v6xFNVaAaTX1Ta06w5CFClYYqPQHQ/PsALYB4Af4RL1k9PuPrCgetEhq8U+XHcWoqGilPJtbF61psvXUak7C1EMeqGutuEa3SGIIgmnE0ehxnqPF8DzunMQRRq3M2nPgur7WlhgKdaIiKUsv3KMIZYPdWchikFclZion1hio9f/6g5AFEkS4lJ3Xl91b4fVYivVnYVIB8OwuMoLpmUBsk13FqIY4gcXdSLqN5bY6LUUwC7dIYgiQZI7fdv8OXfBYliKdGch0slqsaeX5U0BgIO6sxDFiL/X1TZwGWqifmKJjVKN9R4/gKd15yAKd6kJ2Zuvm/1th2FY8nRnIQoHDru7qCh7/B4AbbqzEMWAp3QHIIpELLHRjVOKic4gI6lg/dyZ30wyxMjWnYUonMTHpYzOTa/4AIBPdxaiKNYJ4DndIYgiEUtsFGus96wBsF53DqJwlJNS8tFV02/LEjFO3+SRiJCSkFOZllSwQncOoii2pK624YjuEESRiCU2+nE0lqiH/PTh711e+dV8EUnWnYUonGWnllbFx6U16c5BFKU4lZjoHLHERj+WWKIgxVmj114y+aZSEUnUnYUoEhRmjaly2FwckSUaWMcB/El3CKJIxRIb5RrrPZsAvK07B1E4KMud8HbthIWjRMStOwtRpBARKc2bUmkxbGt1ZyGKIi/W1Tac0B2CKFKxxMaGJ3UHINJtZMG0VTVj540XEafuLESRRsSwlRdMKxMxNujOQhQlOFOO6DywxMaG34MrTFIMG1c8Z8WsUVdOERG77ixEkcpiWBPL8isTwD3Iic7XAQCv6Q5BFMlYYmNAY71nD4C/685BpMOkss8tr6y4ZIaIWHVnIYp0dqszZ1ju5DYALbqzEEWwZ+tqG7y6QxBFMpbY2MFpKxRzplVctmxS6YWzRYSvdUQDJM6RUFaQOWYrzD0uiaj/uCox0XniG7vY8RyAdt0hiIbKnNFXN40rmV0lIqI7C1G0SXSnT8hKLV0NQOnOQhRhmgEs1x2CKNKxxMaIxnrPUQCv6M5BNBQuHF+3dERBZbXuHETRLD2pYGZyfM4y3TmIIszv62ob+OEP0XliiY0tnFJMUe/zk29aWpozrkZ3DqJYkJdRUe1yJjXpzkEUQR7RHYAoGrDExpZXwMU4KHqpKyq/1lSYUVGjOwhRLCnOnjDHZnWu0p2DKAIsr6tt+ER3CKJowBIbQxrrPR0wz40lijLiv3rGN97ISS3hFGKiISYiRlne1AmGYX1fdxaiMPffugMQRQuW2NjzuO4ARANJIL5rZ93hyUjKn6M7C1GsMgyLszy/Mk8gW3VnIQpThwE8ozsEUbRgiY0xjfWeJgAf6s5BNBAMMbrmzbn7rdSErFm6sxDFOqvFnlqaP9UKYL/uLERh6Im62gbuEkE0QFhiY9PDugMQnS/DsHRcX3XvO0nutBm6sxCRyWFzFRTnTDgAoFV3FqIw82vdAYiiCUtsbHocXOCJIpjVsLUtqL7vw/i45ErdWYjoVG5n8si8jBEfA/DqzkIUJlbW1TZwFhzRAGKJjUGN9Z5WAI/pzkF0LmwWx7EFNYs3uhwJk3RnIaLeJcdnT8lILvLozkEUJjgKSzTAWGJj18MAuNk2RRS71dmysGbxdqfdNV53FiI6s8yUkjmJrgzuIUux7giAP+gOQRRtWGJjVGO9ZyOA13TnIAqV0+4+uLDmO7vtNudo3VmIKDQFWaOrnfb4N3TnINLoybrahhO6QxBFG5bY2PZL3QGIQuFyJOxbUH3fYZvVPkJ3FiLqn2G5k6ZbLfbVunMQacKpxESDgCU2tv0ZwBbdIYjOJD4ueVdd9aI2q8VWpjsLEfWfiGEty68cIWJ8rDsL0RB7s6624T3dIYiiEUtsDGus9/gB/Ep3DqK+JLnSt18/5x6/xbAW685CROfOYljjy/OnpQGyQ3cWoiH0X7oDEEUrllh6BECb7hBEPaXEZ229bs63bYZhydedhYjOn83qyCzNm9wJ4LDuLERDYB+A/9UdgihascTGuMZ6z2HwRZbCTHpi3sZrZ30r3hAjR3cWIho4Tnv8sMKscc0A2nVnIRpkD9fVNnToDkEUrVhiCeACTxRGslOKPr56xjfSRIwM3VmIaOAluFLH5aSVvwvArzsL0SA5AeA/dIcgimYssYTGes86ANwCgbTLSyt7/4rKW3NFJFV3FiIaPKmJedNTE/KW685BNEger6ttOKA7BFE0Y4mlbhyNJa2KMke+e+mUL5eISJLuLEQ0+HLSy6vdzpQm3TmIBpgC8KDuEETRjiWWuj0PYJfuEBSbSnPGrb5o4hcrRCRedxYiGjpF2eOq7Na4lbpzEA2gV+pqG9brDkEU7VhiCQDQWO/pApeCJw0q8qe8ecG468eJSJzuLEQ0tERESvOnTrYY1nW6sxANkPt1ByCKBSyxFOy/AHTqDkGxY0zRzJVzRl8zWUTsurMQkR6GGI6y/GlFIsZm3VmIztPautqGpbpDEMUCllg6qbHesxfAs7pzUGyYWHrBG9NHXD5dRKy6sxCRXlaLLbksb6oTwB7dWYjOwwO6AxDFCpZY6ulnMBclIBo0lRWXLJtcVjtLRPgaREQAALstLq8kZ1ILgGO6sxCdgx0Afq87BFGs4BtIOkVjvecDmIs8EQ2KWaOubBpfUlUlIqI7CxGFF5czsSI/Y9QGAF26sxD1U2NdbYNXdwiiWMESS71pAEdjaRDUjJu/dFTh9GrdOYgofCXFZ07OTCl5U3cOon44DuDXukMQxRKWWDpNY73nfQB/1J2DostFE7/YVJ47oUZ3DiIKfxnJRbOT3JlLdecgCtGv62obWnSHIIolLLHUlx+Bo7E0QC6b+pWm4qxRHIElopDlZ46qiXMkLNOdg+gs2gD8i+4QRLGGJZZ61VjvWQfgRd05KOKpK6fftiwvrYwFloj6rSRn0iyrxfGW7hxEZ/CfdbUNe3WHIIo1LLF0Jj/SHYAil0B8c2d+a0VWcmGV7ixEFJlExFKeXznGEMtHurMQ9YKjsESasMRSnxrrPe8A+JPuHBR5RAzvdXO+/WZaYs5s3VmIKLIZhsVVlj8tA5BturMQ9cBRWCJNWGLpbBp0B6DIYoil8/qqe9YkuzNm6s5CRNHBZrVnlOZNUQAO6s5CFMBRWCKNWGLpjBrrPWsBvKw7B0UGi2E9saB60XsJcSnTdGchoujitLuLi7LH7wFwQncWInAUlkgrllgKxQ91B6DwZ7XYjy+sWbze5UycojsLEUWn+LiU0bnpFe8D8OnOQjGNo7BEmrHE0lk11nvWAHhFdw4KX3ars2VhzeKtTrt7gu4sRBTdUhJyKtMS81fozkExjaOwRJqxxFKoeG4s9cppcx1aWLN4l8MWN1Z3FiKKDdlpZVXxcalLdeegmMRRWKIwwBJLIWms97wNYInuHBRe4hwJ+xfULD5oszpG6s5CRLGlMGtstcPm4ogsDTWOwhKFAZZY6g+OxtJJbmfS7gXVi45bLbZy3VmIKPaIiJTmTam0GLa1urNQzOAoLFGYYImlkDXWe94E8BfdOUi/RFfqjuur7u2yGNYS3VmIKHaJGLbygmllIsYG3VkoJvyKo7BE4YEllvqLo7ExLtmd+em82XcbFsNSqDsLEZHFsCaW5VcmANitOwtFtRYAP9MdgohMLLHUL431Hg+AV3XnID3SEnM3XTv7DpdhGLm6sxARdbNbnTnDcicfh1k0iAbDP9fVNhzUHYKITCyxdC7uBffoizmZSQXrr5lRn2KIkak7CxFRT3GOhPKCzDFbAXTqzkJRpxnAL3SHIKLPsMRSvzXWez4E8J+6c9DQyU0d9uGV02/LFpE03VmIiPqS6E6fkJVauhqA0p2Foso/1tU2tOsOQUSfYYmlc/WPAA7pDkGDrzCjYt1lU28pFJEk3VmIiM4mPalgZnJ89jLdOShqvA/gcd0hiOhULLF0ThrrPYcA/FB3Dhpcw7LHrrl40pfKRSRBdxYiolDlZYyodjmSmnTnoKiwuK62wa87BBGdiiWWzsevAHykOwQNjuF5k966cHzdGBFx6c5CRNRfxTkT5tiszlW6c1BE+2tdbcMS3SGI6HQssXTOGus9XgB36c5BA29U4XRP1ZhrJ4qIQ3cWIqJzISJGWd7UCYZhfV93FopIPgB36w5BRL1jiaXz0ljveQ3Ay7pz0MAZX1K1YubIL1SKiE13FiKi82EYFmd5fmWeQLbqzkIR57d1tQ0f6A5BRL1jiaWBcA+ALt0h6PxNKb9o+dThn58hIhbdWYiIBoLVYk8tzZ9qBbBfdxaKGMcA/D/dIYiobyyxdN4a6z0bADykOwednxkjr2iaMKxmtojwdYGIoorD5ioozp6wH0Cr7iwUEX5WV9uwV3cIIuob36zSQPkR+Cl3xKoac+3SMUUzq0VEdGchIhoM7rjkUXkZIz4G4NWdhcLaNgAP6g5BRGfGEksDorHe0wLg+7pzUP/VTli4tCJ/co3uHEREgy05PntKenKRR3cOCmvfrqttaNcdgojOjCWWBtJvAKzTHYJCd8nkm5eWZI+p0Z2DiGioZKWUzElwpXMPWerNy3W1DS/oDkFEZ8cSSwOmsd7jB/Bt3TkoJOoL025dVpAxvEZ3ECKioVaYNabaaXe/oTsHhZUTAO7QHYKIQsMSSwOqsd6zFMDzunPQmYj/mhn1b2SnFFfpTkJEpMuw3MnTrRb7at05KGz8uK62Ieq3YhKRT0WkVncOovPFEkuD4V4AHbpD0OlEDO91s+9clZ6UN0d3FiIinUQMa1l+5QgR4xPdWUi7TwD8m+4QwbrLpojcLCJKRB7ocf3VgcsfC3xfHPj+eODXXhF5WUQu0vIEiAYZSywNuMZ6z1YAD5z1hjSkDLF0zp9z9+qU+MyZurMQEYUDi2GNL8+flgrIDt1ZSKtv1NU2dOoOcQabAVwvItagy74EYEMvt01WSsUDGA/grwD+KCI3D35EoqHFEkuD5acAdukOQSaLYW2vq753XaIrdbruLERE4cRmdWSW5k3uBHBEdxbS4sm62oa/6w5xFnsAvA/g8wAgIqkAZgL4U193UErtUUr9O4AfAvh5jz3gp4rIRyJyWEQeFRFnb8cQEYuIfE9ENovIMRFZIyIFgetmisjbItIS+H1m0P2WisiPRWRlYFT4JRFJE5EnReRo4PbF5/cjoVjHEkuDorHecxzAN3TnIMBqsbcuqL7vY7czaaruLERE4chpjx9WmDV2O3gqTKw5AuAe3SFC9DjM0VcAqAPwIkL7+/o8gEwAFUGX3QCzEJcCGI6+t0i8G8ACAJcBSATwFQBtgRL9CoBGAGkwZ9+9IiJpQfetA3AjgLzA43gAPAogFcDHAH4QQnaiPrHE0qBprPe8COBp3Tlimc3qOLqw5r7NcY74ibqzEBGFswRX2rjstLK1APy6s9CQ+X5dbcNe3SFC9EcANSKSBLPMPh7i/bpnxaUGXfZLpVSzUuoQgJ/ALKq9+SqA7yul1ivTOqXUQQCXA9iolHpCKeVVSj0F87ziLwTd91Gl1GalVAuAJQA2K6VeV0p5ATwDgO9L6LywxNJg+xaAfbpDxCKHLe7IwprFOxw21zjdWYiIIkFaYv6M1IS85bpz0JBYDeBXukOESil1Aubo5/cBpCulVoR417zA74eCLmsO+nobgNw+7lsA83zcnnID9wu2LeixACD4w4ETvXwf38djEoWEJZYGVWO95wCAb+rOEWucdveBBTWL99qtzlG6sxARRZKc9PJqtzO5SXcOGlR+ALfX1TZE2qj74zCnPz/Rj/tcA3MwYX3QZQVBXxei7zVMmmFOBe5pF4CiHpcVAtjZj1xE54UllgZdY73nGQDP6c4RK1yOxL0Lqu9rsVnsFWe/NRER9VSUPb7Kbo3z6M5Bg+ZXdbUNkbhHcBOAiwA8dLYbikiWiHwT5rmn31VKBRf2ehHJD5zb+j0Av+/jML8B8E8iUi6mcYHzXv8MYLiILBQRq4hcD2AUgJfP47kR9QtLLA2VegAHdYeIdglxKTvrqu9tt1psvX1ySkREIRARKc2fOsliWNfpzkID7lMA39Ed4lwEzkv9W+Bc1r4cEZFWmKsZXwZgnlLqtz1u878AXgOwJfDrxwAgIoWB1YQLA7d7AMAfArc9CuARAHGB82KvgDkqfBDAfQCuUEodGIjnSRQKUUrpzkAx4o6HZ9wA4He6c0SrJHf6tutm3Wk1DEve2W9NRERn4/V1HdnQ7DmolJ8fDEYHBaC2rrbh/3QHIaLzw5FYGjKN9Z4nAbykO0c0Sk3I3nzd7G87WGCJiAaO1WJLLsub6sSpi9JQ5PoVCyxRdGCJpaF2G7ih/IDKSCpYP3fmN5MMMbJ1ZyEiijZ2W1xeSc7EIwCO6c5C52ULzGmvRBQFWGJpSDXWe3bB3DybBkBOSslHV02/LUvESNedhYgoWrmcSRX5GaM2AOjSnYXOiQLw5brahlbdQYhoYLDE0pBrrPc8CuBV3TkiXX56+XuXV341X0SSdWchIop2SfGZkzOTi9/UnYPOSWNdbcMy3SGIaOCwxJIut8Jc6Y7OQXHWqHcumXxzqYgk6s5CRBQrMlKKZye5M7mHbGTZCOC7ukMQ0cBiiSUtGus9zQAW6c4RicpyJqyunXDDSBFx685CRBRr8jNHVcfZE5brzkEh8QO4ua624YTuIEQ0sFhiSZvGes+vAfxNd45IMqKgclXNuHnjRMSpOwsRUawqyZ0002pxvK07B53Vg3W1DSt1hyCigccSS7p9DQAXWgjB2OLZK2ePumqKiNh1ZyEiimUiYinPrxxliOUj3VmoT58A+L7uEEQ0OFhiSavGes9WAN/RnSPcTSr73PJpFZdOFxGr7ixERAQYhsVdlj8tA5BturPQaXwwpxG36w5CRIODJZbCwcPgtOI+Tau4bNmk0gtniwj/vRIRhRGb1Z5RmjdFATioOwud4md1tQ1cSZooivFNMWnXWO9RAL4IYK/uLOFmzuirm8aVzK4SEdGdhYiITue0u4uLssfvBsDFg8LDGwB+qDsEEQ0ullgKC43/v707j46qPNw4/tyZyWoSICFCQoDAkJCFISwKRtkG44ICRZEawYpWRQqKita9WvSntlWsxo1WrRbBoqAF0arVNiwKoiCEQEggI5tssggJJIQkc39/DKGRNUCSm0m+n3NyyNy5895nppziM+977x2/eLukkfJdSRCSBqZlzktq26u/1TkAACcXFtKiS2zLxJXi3zCr7ZE0MjNjUqXVQQDULUosGoys8Yv/K+kJq3M0BJf1uGGeM6brAKtzADV1qOyQHnvgGV3WL1MXpF2pXw4Zo4Xzj13N92rW39W100B9/dWyE45186iJ6n/+VUpPG6xrBt+i7M+/OvJcwRqPrrr8JvU7f5je/tvMI9vLyys0cvg4bd/6Y+2+MaCGWoTH9o6KiPvS6hxN3K8zMyZttjoEgLrHRWLQ0Dwuqa+kgVYHsYg5uNctC2IiOw6wOghwOioqK9UqJlp/e+d5xcSeq4Xzlui3Ex7X+x+/oTZxrSVJmzdu0eefLlD0uVEnHev+341Xx07xcjjsWrlijcaMvldzP5+q6HOj9MKzr2nig2OV2Lmjrhl8qwYNuVgtoyP19t9mKuOyfmode259vF3guFpHdepXVl4yf3/pHlbR1L+XMjMmzbE6BID6wUwsGpSs8Yu9kkapSZ4fa3iHpY/7MiayI//xA78TGhqicXfeqDZxrWWz2dR/YLraxMUob9XaI/s8NelF3X3frQoIOPn3p4lJTjkcdkmSYUgV5RXavs03w7rlh+3qfUF3tWodrXbt22jb1h3atnWHvvhsgX510zV19waBGmrXytUvKCD0q1PviVq0XNK9VocAUH8osWhwmuL5sYaMyuEX3bE4ullcX6uzALVh96492rh+szolxEuS/v2veQoIcKjvgAtq9Prbb31I56VcplHDx+u83t2U6uosSeqUEK9FXy7V9m07tXXLdrVtF6s/PP6S7r7vtlOWY6A+GIZhdGxz3vl2W8Byq7M0EfslZWZmTCqzOgiA+sO/+GiQssYv/u+El9OfkPSY1Vnqms2wlV/T5+6lzc6JusjqLEBtKC+v0AMTn9LQqy9TB2c7lRwoVdbkNzTlrT/VeIyXXntK5eUV+nrRMm3wbJLN5vvO9Z4Hx+r/Hn1eu3bu0W8fHqfly1bpnHNCFNcuRhNue0TFRft13a+G6dIrBtTRuwNOzWbYAhPiencs2LxonWl6E6zO08iNz8yYtPbUuwFoTCixaMga/fmxNpu97Nq+9+SEhTRPtzoLUBu8Xq8evvdpBQQ49OBjEyRJr7zwlgbeV8GKAAAgAElEQVQPu0RxbWNOa6yAAIf69u+t6W99oLh2sXJnXKTYNq31yht/kCSVlh7UDb+8Q1Pe/KOenvSiLrvSrX7u3rp60M3qfWEPNWseUevvD6gpu93RrFObXiXrfvh6m6TT+8uPmpqamTFpqtUhANQ/lhOjwWrs58c6bAEl1/W/b1VYSPNeVmcBaoNpmnrswWe0e9dPeu7lSUeW9y5Z/J3emfqB3BcMl/uC4dq+bafunfC4/vaXf9Ro3MrKSv2waesx2//y4lRdPeIKRbWM1Lq165XqSlR4eJhatY7Wpo1bavW9AWciMCA4pmNsz/2S9lmdpRFaK2mc1SEAWIMSiwatsZ4fG2APKr5uwP3rQoPCe1qdBagt//fo8/q+cJNe/OuTCg4OOrL9tanP6oN//U0z576mmXNfU/S5UXr0ibuVef2wY8ZY79mkhfOX6ODBMpWXV+ij2Z9r2bcr1bNX2s/286zboG+X5OiXo4ZKktrEtdY3i5dr96492rTxB8XEtqrbNwvUUEhQeELbc1O/l3TI6iyNSJmkazMzJh2wOggAaximaVqdATilCS+n/16N5PzYQEfwvuv63/dDYEBwqtVZgNqydct2Xd5/pAIDA2Q/fGVhSXr0iYm68hcZP9v38v7X6fdP3asLLvJ9h/PE7/4sSfrdE3fr+8KNeuT+P+r7wo2y22xqFx+nW34zUhdf+vNrnt08aqLu/O2t6totWZLv/rH33/V/2rPnJ90ydpRuuHlEXb5d4LTt2rd50Y49nnRJhtVZGoHxmRmTXrE6BADrUGLhFya8nG6T9Ln8/PzY4MBzdmf2++3OAEdgktVZAAD1a8vO/Pl792/nNmpn52+ZGZNutjoEAGuxnBh+oTGcHxsaFP7jdf3v+4kCCwBNU5vopP6hQRELrM7hx5aI82ABiBILP+LP58eGhTTfmtn/tyUOe0Anq7MAAKwTH9O9T4AjeInVOfzQdklXcz9YABIlFn4ma/zi/0p6wuocpyMiNGrztX3v8dptjnirswAArGUYhq1Tm/O72mz2XKuz+JFDkoZnZkw69jLlAJokSiz80eOSPrE6RE20CGu1fkTfux02mz3O6iwAgIbBZrOHJMT1bmPIWG91Fj8xITNj0iKrQwBoOCix8DuHz4+9VlKD/ha7ZUTsuuEX3RFmM2zc5B4A8DMOe2CkM+58u6SdVmdp4P6amTHpL1aHANCwUGLhl7LGLy6WNFi+c2QanFbN268Zlj4+yjBs0VZnAQA0TEEBoe3iW3fbKYn7nR7fIkl3WB0CQMNDiYXfyhq/eJOkoZJKrc5SXZuoTrlDeo+JNQwj0uosAICG7ZyQ5iltWiblSaq0OksDs1W+82APWR0EQMNDiYVfyxq/+FtJv5LUIG543P7c5BWDzrupg2EYzazOAgDwD83DW5/fslk7zvn8nzL5rkTcIFdbAbAeJRZ+L2v84vclPWx1DmdM16WXdL++s2EYYVZnAQD4l1aRHfuGh7acb3WOBmJ8ZsYkbkME4IQM02wQE1jAWZvwcvrfJN1kxbE7x523pG/qVd0Nwwi04vgAgMbBs+XbLw8eOtDH6hwWeiEzY9JdVocA0LAxE4vG5DZJ8+r7oKntL1zcN/WqnhRYAMDZ6hjb8wKHPXCZ1Tks8oGkiVaHANDwMROLRmXCy+ktJH0tKbE+jte9o/vLngkZ6YZh2OvjeACAxq/SW1FcsGnRFtP0JlmdpR4tlnRxZsakBnWxRgANEyUWjc6El9M7yVdko+ryOL0SL1vQtUO/voZhGHV5HABA01NeUbZj7eavyyUzzuos9aBQUnpmxqRdVgcB4B9YToxGJ2v84kJJV0mqs8vyX5g8ZH5ax/79KLAAgLoQ4Ahq5YztWSZpr9VZ6tguSYMosABOByUWjVLW+MULJd1aF2MPcI2Yl9o+vX9djA0AQJXgoDBnu1aujfLdcqYxKpU0JDNjUqHVQQD4F0osGq2s8YunSnqyNse8pPv18xLadB9Qm2MCAHAi4aFRaa2jOn2nBnI/9FrklTQqM2PS11YHAeB/KLFo7H4n6d3aGOiK8349P75VyoDaGAsAgJqKiohLbxEeu8DqHLXs7syMSf+0OgQA/8SFndDoTXg5PVhStqQLznAIc2jv2xa2atG+Xy3GAgDgtGzYtmL+gYN7G8PpLM9nZky62+oQAPwXM7Fo9LLGLz4o6ReSPKf7WkNG5dUX3vEVBRYAYLX2rdP6BTpCFlud4yy9L+keq0MA8G/MxKLJmPByerykhZJqdLsCw7BVXNPnzm+anxN9YZ0GAwCghrymt2ztpkX5ld6KNKuznIFF8t0L9qDVQQD4N0osmpQJL6d3lq/IRp9sP5thP/TLfhOXh4e06F0/yQAAqJmKyvK9azcv2m2aptPqLKdhuSR3ZsakfVYHAeD/WE6MJiVr/OICSZdJOuE/onabo/S6/r9dSYEFADREDntA805tegVJ2mF1lhrKk3QpBRZAbaHEosnJGr94uaQrJB04+jmHPXD/dQPuzw8Njjiv/pMBAFAzgQEhcR1iuu+VVGx1llMolJSRmTFpl9VBADQelFg0SVnjFy+SdJWq3UA+0BG8b+SA+9eHBJ7T3bpkAADUTGhws85x0SlrJZVbneUENsl3Duw2q4MAaFwosWiyssYv/lzSdZIqgwJCfxo54P6tQQEhLqtzAQBQU83Czu15bvP4JVbnOI7t8s3AbrI6CIDGhxKLJi1r/OJ/BtiDRo8ccN+PAY6gZKvzAABwuqJbxPdpds65863OUc1uSZdkZkxaZ3UQAI0TVycGJOV6sm+V9BdJhtVZAAA4E54tyxYePFTc1+IY++RbQrzM4hwAGjFmYgFJLqf7NUm3W50DAIAz1TG2x4UOe9C3FkY4IOlKCiyAukaJBQ5zOd2vSLrL6hwAAJwJwzDsCXG9UmyGPc+Cw5dJ+kVmxqSvLDg2gCaGEgtU43K6X5D0W6tzAABwJmw2+zmd4npHS0Z9XlCpXNKIzIxJ/6nHYwJowiixwFFcTvezkh62OgcAAGciwBEY7Wxznle+CyzVtYOSrsrMmDS3Ho4FAJIoscBxuZzupyQ9YnUOAADORHDgOfHtW3fdKqm0Dg9TImlwZsakj+vwGABwDEoscAIup/tJ+c6R5RLeAAC/ExYS6YqJSlwpyVsHwxdLuowlxACsQIkFTuLwObI3S6q0OgsAAKcrMiK2d1RE3Je1POxPkjIyMybV9rgAUCOUWOAUXE73m5Kuk+/CFQAA+JXWUZ36hYVEzq+l4XZKcmdmTPqmlsYDgNNGiQVqwOV0z5T0C9XtuUUAANSJdq1c/QIDQs/29jfbJA3IzJiUUxuZAOBMUWKBGnI53Z9Iuly+84AAAPAbhmEYzjbnnW+3BSw/wyE2SeqXmTHJinvQAsDPUGKB0+ByuhdIulj1c9sCAABqjc2wBSbE9e5oGLZ1p/nS7+UrsIV1kQsAThclFjhNLqf7W0n95VtWBQCA37DbHc06tekVppr/G5YvqW9mxqSNdRgLAE4LJRY4Ay6ne7WkvpI2WBwFAIDTEhgQHNMxtud+SftOsetySf0zMyZtrYdYAFBjlFjgDLmcbo98RbbA6iwAAJyOkKDwhLbnpn4v6dAJdvlCvgL7Yz3GAoAaocQCZ8HldP8gX5FdYXUWAABOR8Q50d1btej4rSTzqKfekXRFZsYkLmQIoEGixAJnyeV075Q0QL5vrQEA8Bstm7e7qHlY6+r3kJ0s6frMjEncGx1Ag2WY5tFfvgE4E7mebIekVyXdYnUWAABOx/qty+eVlO2bm5kx6TmrswDAqVBigVqW68m+X9LTkgyrswAAUAMHJY12Od3vWR0EAGqCEgvUgVxP9jWSpkoKsToLAAAnsVvSL1xO91dWBwGAmqLEAnUk15PdW9IcSa2szgIAwHEUSrrC5XSvszoIAJwOLuwE1BGX071E0gWS8qzOAgDAURZLSqfAAvBHlFigDrmc7g2SLhRXLgYANByzJA10Od27rA4CAGeCEgvUMZfTvU/SIEmvW50FANCkmZKelPRLl9N90OowAHCmOCcWqEe5nuz7JP1BXLkYAFC/9st3BeIPrA4CAGeLEgvUM65cDACoZ4WShrmc7tVWBwGA2sByYqCeuZzuWZL6S9psdRYAQKP3iaTzKbAAGhNKLGABl9P9raQe4oJPAIC687SkwS6ne6/VQQCgNrGcGLBQrifbJukJSQ+K82QBALVjv6QbXU73+1YHAYC6QIkFGoBcT/ZQSX+X1NzqLAAAv+aR9AuWDwNozFhODDQALqf7Q0nnScqxOgsAwG99Ks5/BdAEUGKBBsLldHskpct35WIAAE7HHyRd6XK6f7I6CADUNZYTAw1Qrif7NklZkgKtzgIAaNAOSLrJ5XTPtDoIANQXSizQQOV6ss+XNEtSO6uzAAAapBxJmS6nO9/qIABQn1hODDRQ1W7D87nVWQAADU6WpN4UWABNETOxQAN3+DY8kyQ9LG7DAwBN3S75lg9/ZHUQALAKJRbwE7me7IHy3YYnzuosAABL/EfSr1xO9zargwCAlVhODPgJl9P9X0ldJb1rdRYAQL2qkPSgpEspsADATCzgl3I92ddLeklSM6uzAADq1PeSrnM53d9YHQQAGgpmYgE/5HK6p0lKk7TA6iwAgDrzjqTuFFgA+DlmYgE/dviiT/dJelxSgMVxAAC1Y7+k8S6ne6rVQQCgIaLEAo1Arie7u6TpkpKtzgIAOCvL5Fs+vM7qIADQULGcGGgEXE73ckk95TtPFgDgf8olPSHpQgosAJwcM7FAI5Pryb5c0puSWludBQBQI99J+rXL6c6xOggA+ANmYoFGxuV0fyrJJemfVmcBAJxUmaSHJPWmwAJAzTETCzRiuZ7sEZKyxKwsADQ0iyTd7HK6860OAgD+hplYoBFzOd0z5bvY02uS+MYKAKxXIukuSX0psABwZpiJBZqIXE92X0l/lZRkdRYAaKL+K+lWl9P9vdVBAMCfUWKBJiTXkx0k3/lXD0gKtDgOADQVRZLudTndr1kdBAAaA0os0ATlerJT5JuVvcjqLADQyH0saazL6f7B6iAA0FhQYoEmKteTbUi6TdIfJDWzOA4ANDa7JN3tcrqnWR0EABobSizQxOV6smMlvSjpaquzAEAjUCnpFUmPupzuvVaHAYDGiBILQJKU68n+haSXJbWxOgsA+Kl5kia4nO5cq4MAQGNGiQVwRK4nO1zSw/Ld/iHI4jgA4C82y3fhpvesDgIATQElFsAxcj3ZHSQ9I2m41VkAoAErk+//K592Od0lVocBgKaCEgvghHI92f0k/VlSD6uzAEADM0fSRO75CgD1jxIL4KRyPdk2SaMlPSkpxuI4AGC1Akl3upzuz6wOAgBNFSUWQI3kerLDJD0g6R5JwRbHAYD6VizpcUkvuJzucqvDAEBTRokFcFpyPdntJP1RUqbVWQCgHnglTZX0kMvp3mZ1GAAAJRbAGcr1ZF8o3/myvazOAgB15J+SHnE53XlWBwEA/A8lFsAZy/VkG5JGSXpKUluL4wBAbflCvpnXb60OAgA4FiUWwFnL9WQHSRoj6UFx8ScA/muJpAddTne21UEAACdGiQVQa3I92cGSfiPpfkmtLI4DADW1Sr5lw3OsDgIAODVKLIBal+vJDpU0XtJ9klpaHAcATuR7SY9JesfldHutDgMAqBlKLIA6c/i2PHdIuldSpMVxAKDKNklPSHqd2+UAgP+hxAKoc7me7AhJd0qaKKm5xXEANF17JP1J0osup7vE6jAAgDNDiQVQb3I92c3lK7J3SoqwOA6ApmOzpOckveZyug9YHQYAcHYosQDqXa4nO1K+Jca3Swq3OA6AxitPvpnXd1g2DACNByUWgGVyPdnN5Ls1zwRJcRbHAdB4LJL0R0lzXU43/6EDAI0MJRaA5XI92QGSfinpHkndLY4DwD+Zkv4l6Q8up/tLq8MAAOoOJRZAg5LryXbLV2avkGRYHAdAw1ch6R+S/uRyuldZHQYAUPcosQAapFxPdrKkuyX9SlKwxXEANDwlkl6X9JzL6d5odRgAQP2hxAJo0HI92edKGi9pnKSWFscBYL3Nkv4q6VWX073b6jAAgPpHiQXgF3I92SGSbpDvFj2JFscBUL9MSZ9JelXSxy6nu9LiPAAAC1FiAfiVXE+2IelySbdKGiLJYW0iAHVol6S/SfqLy+n+3uowAICGgRILwG/lerJbS7pR0s2SOlmbBkAt+lK+Wdf3XU53mdVhAAANCyUWgN87PDs7QL7Z2aslBVkaCMCZKJb0tqQpLqc71+owAICGixILoFHJ9WRHyXdF41slpVgcB8Cp5cg36zrd5XTvtzoMAKDho8QCaLRyPdnp8pXZayWFWhwHwP/skvSepLddTvfXVocBAPgXSiyARi/Xkx0haaSkWyT1tDgO0FSVSJojabqkf7uc7nKL8wAA/BQlFkCTkuvJTpRvZvZaSakWxwEau0pJn8tXXGezXBgAUBsosQCarFxPdqr+V2i59yxQe76RNE3Suy6n+0erwwAAGhdKLABIyvVkd9P/Cm0Hi+MA/midfDOu011Od6HVYQAAjRclFgCOkuvJPl++MvtLSW0tjgM0ZGslzZVvxvVbq8MAAJoGSiwAnMDh+89eIF+hvUZSG2sTAZarlLRI0oeS5rqc7gKL8wAAmiBKLADUUK4nO03SFZIGSUqX5LA2EVAviiV9Kt+M679cTvdui/MAAJo4SiwAnIFcT3ZzSZfKV2gvl9Ta2kRArdooX2mdK2mey+k+ZHEeAACOoMQCwFk6vOy4h3yF9gpJvSXZLA0FnB5T0rfyldYPXU73SovzAABwQpRYAKhluZ7sKPlmaa+QdJmkaGsTAccwJeVKmnf4Z77L6d5jZSAAAGqKEgsAdSjXk22T1E1S38M/fSS1sjQUmiJT0mr5Cmu2fKWVc1sBAH6JEgsA9SzXk52gn5faTtYmQiOVp5+X1p3WxgEAoHZQYgHAYrme7NbyldmqYttVkt3SUPA3FfKV1q90eImwy+n+0dJEAADUEUosADQwuZ7sCPlu4dNX0oXyLUduYWkoNCSVktZIWipp2eE/c1xOd6mlqQAAqCeUWADwA7me7HbyldnqP/GSDAtjoe55JeXrf2V1qaQVLqe7xNJUAABYiBILAH4q15PdTL6lx9WLbaqkICtz4YyVSSqUtEL/m2Vd7nK691uaCgCABoYSCwCNSK4n2yEpWVLa4Z/OkpySOkoKtjAa/mebpAL5ZlgLqv1scDndXiuDAQDgDyixANAE5HqyDUmx8l0J2Vntp+pxc+vSNUqlktbq5yW1QNJal9NdZGUwAAD8HSUWAKBcT3akji227eW7p20rSZHi/NsqJZK2SNp61J9Vv2+WtNnldPMPLAAAdaDeSuyyZcvOdTgcr0vqIslWLwcFfLySVlVUVNzSs2dPbjkBnIHDy5Sj9b9S20rSuUc9rtoWLclhTdIz4pW0X9I+SUWHf37Uz4vpkd9dTvdei3ICAADVY4nNycn5sHXr1snR0dFFNpuNb6dRb7xer7Fz585m27dvz0tLSxtqdR6gsTu8dDlKviXKYZLCj/qz6vcQ+c7TrfozuNrjqotTec/w55CkYv28mFb/vfrj/cyaAgDgP+rzm/Iu0dHRP1FgUd9sNpsZHR29b/v27V2szgI0BYcL4a7DPwAAALWqPpf12iiwsMrhv3ssYwcAAAD8HP9RDwAAAADwG5ZdeGPCy+k9a3O8rPGLl51qn/vvv7/1+++/H2Wz2UybzaZXXnll48CBAw/UZo7qQkNDu5eUlCw/2T5ZWVlRjz32WFyrVq3Kq7ZNnz79+549ex483eNNnz692erVq0Oeeuqp7WeSFwAAAAAaOn+6euRZ+eKLL8757LPPmufm5uaFhISY27Ztc5SVlZ317SLKy8sVEBBwVmMMGTLkp6lTp2462yyjRo3aJ9+FSgAAAACgUWoyy4m3bNkSEBkZWRESEmJKUkxMTEV8fHy5JC1cuDD0/PPP75yamprcp0+fhI0bNwZI0uTJk1t26dIluXPnzimXXXaZs7i42CZJw4cPj7/lllvievfunThu3Li4ffv22a655pr4xMTElMTExJS33nqredVx77jjjjadO3dOSUtLS9q8eXONvzT46KOPwnv16tX58ssv79ihQ4fUoUOHdvB6vZKkd999t1mHDh1Se/bs2fnGG29s63a7O0m+Wd0bbrihXVXGG2+8sW337t2T4uLiXG+++WaLqrF/97vfterSpUtyYmJiyt133x0rSUVFRbYBAwZ06ty5c0pCQkLqa6+91uI4sQAAAADAUk2mxA4bNqxo69atgfHx8V2uv/76dh9//HGYJJWVlRkTJkxoN2fOHM/q1avXjB49ete9997bRpJGjRr106pVq9YUFBTkde7cuTQrK6tl1Xgejyf4q6++Wvvaa6/98MADD8RERERUrl27Nm/t2rV5V155ZbEklZaW2tLT0/cXFBTkpaen73/xxRejj5dt7ty5LZKSklKqfvbv329I0po1a0JefvnlzYWFhas3bdoU9Pnnn4eVlJQYd955Z/tPPvlk3bJlywp27959wmK8Y8eOgKVLl+bPmTNn3WOPPdZGkj744IOIwsLC4JUrV65Zs2ZN3ooVK0I/+eSTsA8++CCidevW5QUFBXnr1q1bffXVVxfV3qcPAAAAALWjySwnbtasmXfVqlV5n376afh//vOf8NGjRzsfffTRH9LT0w+sW7cuZODAgYmS5PV6FR0dXS5Jy5YtC3n00UfbFBcX2w8cOGDv37//kaW6V1999U8Oh+/jW7BgQcSMGTO+r3ouOjq6UpICAgLMzMzMfZLUs2fPA1988UXE8bKdaDmxy+U64HQ6yyUpNTW1xOPxBIaHh1e2bdu2LCkp6ZAkZWZm7nn99dePW46HDh261263q2fPngd3794dIEmffvppxIIFCyJSUlJSJKmkpMSWn58ffPHFFxc//PDDbX/zm9+0+cUvfrHv8ssv33/aHzIAAAAA1LEmU2IlyeFwaPDgwcWDBw8u7tq1a+nbb78ddcEFF5R06tSpdMWKFflH7z9mzJgOs2bNKkxPTy/NysqKmj9/fnjVc2FhYd6q303TlGEce3qtw+EwbTbbkWNXVFSc1jm4QUFBR25JZLfbVVFRYZhmze9SFBwcfGTnqteZpqm77rpr229/+9tj7t/43Xff5b3//vvNHn744TZffPFF0bPPPrvtdPICAAAAQF1rMsuJc3JygnJzc4OqHi9fvjwkLi7uUNeuXQ/u2bPH8cUXX5wj+ZYXL126NFjyzVK2a9euvKyszJgxY0bkicYeMGBA0XPPPXdu1eOdO3fa6+p9pKWlHdy8eXNQQUFBoCS9++67J8x1PIMGDSp6++23W+7bt88mSevXrw/YsmWLY8OGDQHh4eHecePG7bnrrrt2rFixIrQu8gMAAADA2bBsJrYmt8SpTUVFRfYJEya0KyoqstvtdjM+Pr7s73//+8bg4GBzxowZngkTJrQrLi62V1ZWGr/5zW92nHfeeQcfeOCBrb169Upu06bNoeTk5JL9+/cft5w+/fTT22666aZ2CQkJqTabzXzooYe2jh49em9Nsx0+Jzas6vGLL7648UT7hoWFmc8999zGyy+/PCEyMrKie/fup3WLoKuvvrpo9erVweeff36SJIWGhnqnT5++Pj8/P+jBBx+Ms9lscjgc5iuvvHLCDAAAAABgldNanno2cnJyNqSlpR2zhBWnb9++fbZmzZp5vV6vbrjhhnYJCQkHH3vssR+tztXQ5eTktExLS4u3OgcAAACAM9dklhM3Js8//3zLpKSklISEhNSioiL7xIkT+XIAAAAAQJPATCyaDGZiAQAAAP/HTCwAAAAAwG9QYgEAAAAAfoMSCwAAAADwG5RYAAAAAIDfsOw+sbme7J61OZ7L6T7lfWftdnvPhISE0qrHc+bMKVy3bl3Q5MmTW2VnZxdOnz692erVq0Oeeuqp7cd7fUFBQeDgwYMT1q1bt7o2swMAAAAAasayEmuFoKAgb35+fl71bevWrQuq+n3UqFH7JO07m2OUl5crICDgbIYAAAAAAJwAy4mrycrKirrhhhvaSdLmzZsdl1xyibNz584pnTt3Tvn888/Pqb5vXl5eYHJycsr8+fNDs7KyogYNGtRx4MCBnfr27Zt49LizZs2KSElJSe7cuXNKenp6oiTt2LHDnpGR4UxMTExJS0tLWrJkSYgkTZw4Mfbqq6+Ov+iiixLatGnj+vvf/9587NixcYmJiSl9+/ZNKCsrM+rjswAAAACAhqhJldiysjJbUlJSSlJSUsoll1ziPNm+Y8eObde3b9/igoKCvNWrV+f16NHjYNVzOTk5QcOHD+/0xhtvrO/fv3+JJH333Xdh//jHP9Z//fXXa6uPs3XrVsftt98e/8EHH3gKCgryZs+e7ZGk++67LzYtLa1k7dq1eU888cSW0aNHd6h6zcaNG4P++9//Fs6aNatw7NixHQYOHFi0du3avODgYO97773XrHY/FQAAAADwH01+OfGJLFq0KHzWrFnrJcnhcCgqKqpy165d9j179jiGDRvWaebMmZ7zzjvvSLHt27dvUatWrSqPHmfevHnn9OrVqzgpKemQJFXt880334S///77hZI0dOjQ4jFjxjh2795tl6SMjIx9QUFBZq9evUorKyuNa665pkiSUlNTS9evXx94tp8DAAAAAPirJjUTWxvCw8MrY2JiDs2bNy+s+vbQ0FDv8fY3TVOGcewKYNM0j9lmGIYpSUFBQaYk2e12ORwO02bz/c9ks9lUUVHBcmIAAAAATRYl9gQuuuii4meeeSZakioqKrRnzx6bJAUEBJiffvqp5x//+EfUlClTIk81jtvtPrBkyZLw/Pz8QMl3LqwkXXDBBcVvvvlmlCR99NFH4S1atKiIjDHskucAABVUSURBVIw8bhEGAAAAAPhYtpy4JrfEsdKrr7666cYbb2yfmJjY0maz6aWXXtrYtm3bckmKiIjwfvbZZ4UDBgxIDAsLO27xTEpKSsnPz8+LjY2tyMrK2nDVVVd18nq9ioqKKl+0aNG6P/7xj1tHjhwZn5iYmBISEuJ966231tfvOwQAAAAA/2Mcb1lrXcjJydmQlpa2q14OBhxHTk5Oy7S0tHircwA1YRhGvKT1kgJM06wwDOMTSTNM0/z7KV63QdItpml+UechAQAALNCkLuwEAA3R4eLZSlL1i8NdWn0f0zQH1WcmAACAhopzYgGgYRhimmZY1Y+krXV5MMMw+BITAAD4JUosAPgBwzDmGYZxS7XHtxqGscYwjGLDMPIMw+hxnNckGYax3jCMzMOPNxiGcb9hGCslHThekTUMo59hGF8bhrHPMIzNhmH86vD25oZhTDMMY+fhcR40Dl963TCMWwzDmG8YRpZhGHsNwyg0DKO3YRg3Hx5jh2EY19fZhwMAAJoUSiwA+BnDMEZI+r2kGyRFSBoqafdR+/SQ9G9Jd5imOaPaU9dJulJSc9M0K456TQdJH0t6TlKUpO6Scg8//YqkUEkdJQ2UdPPh41e5SNK3h183S9J7ktIkdZJ0k6SXDcMIPYu3DQAAIIkSCwANxezDs5h7DcOYfYp9b5H0J9M0vzV9Ck3T3Fjt+b6SPpQ02jTNj456bZZpmptN0yw9zrjXS/rUNM33TNOsME1zl2maKwzDCJD0S0kPmKZZbJrm95L+LOlX1V67zjTNt03TrJT0rqR2kiaZpllmmua/Du/TsUafBAAAwElwThQANAzDql9R+PDViU+krSTPSZ4fK2m+aZrZx3lu8xmMe64ku6TqRXmjpDbVHu+o9nuppErTNHcftS3sJMcGAACoEctK7IwvHutZm+NlZkw65X1nQ0NDu5eUlCwvKCgITEpKck2YMGHbCy+8sFWStm3b5mjbtm3XkSNH7po6deqmiRMnxk6bNq1lZGRkRWlpqa1z586lTz/99JaePXselKQ2bdq4li5duiYmJqbi5EcFgFq3WZLzJM+PlXS/YRh/Nk3z7qOeO9l91TZL6nqc7T/Kd+Xk9pLWHt7WTtKWmsUFAACoPU12OXFcXFzZv//97+ZVj6dOndqiU6dOB6vvM3bs2B35+fl5GzduXDVixIg9l112WeetW7cyew3Aaq9LutcwjJ6GTyfDMNpXe75Y0uWS+hmG8YfTGHeapMsNwxhuGIbDMIyWhmGkmaZZLt95rk8ZhhF2+NzZuw/vDwAAUK+abIkNDg42O3XqVLpgwYJQSXr//fcjhw0btudE+996660/9e3bd98bb7wRWbXt8ccfb+VyuZJdLlfyqlWrgo5+TUVFhcaMGROXmJiYkpiYmPLkk0+eK0lz5swJT05OTklMTEwZMWJEfGlpqSH5Zndvv/32Nt26dUvq0qVL8pdffhnap0+fhLZt23b505/+FF37nwIAf2Sa5kxJT0p6R77COltS5FH77JV0iaRBhmE8caKxDMP4t2EY9x1+zXpJQyTdL2mPpO8kuQ7vOk7SIUnrJc2X9HdJU2vvXQEAANRMk55VzMzM3DNt2rTINm3alNvtdjM2NrZ869atgSfav3v37iX5+fnBVY8jIiIqc3Nz17z00ktRd9xxR9vs7OzC6vtPnjw5euPGjUGrV6/OCwgI0I4dO+wlJSXGbbfd1uHf//53QdeuXcuuuuqq+GeeeSb60Ucf/VGS2rZte2jFihX5N998c9tf//rX8UuWLMkvLS21denSJfW+++7bWXefBgCrmKYZf5xtGyQZ1R4POOr5KZKmnGws0zT3yHeF4JMd59KjHs+T1Os4++2RNPIE+V+Xb3a46nG+jvr3xTTN1sd7LQAAwOlqsjOxkjR8+PCi+fPnR7z11luRw4cPP+EsbBXT/PmpZKNHj94jSbfeeuue5cuXH3PBkv/+978RY8eO3RkQECBJatWqVWVOTk5wXFxcWdeuXcsk6cYbb9z95Zdfhle95pe//OVeSXK5XCU9evQ40KJFC29sbGxFUFCQd9euXfazeb8AAAAA4O+adIkNDg42u3btWvLqq6+2vv7663861f4rVqwITU5OPnLerM32v4/PMIxjLpZimuYx248uwsfLVDV2YGDgkZ1tNpvKy8uNE78SAAAAABq/Jl1iJen+++/f/thjj/3QunXrypPt99ZbbzVfuHBhs1//+tdHZmynTp0aKUlvvPFGi+7dux84+jUZGRlFU6ZMiS4vL5ck7dixw96tW7eDW7ZsCaw6h3bq1KlRffv2La7VNwUAAAAAjZRl58TW5JY49eG88847eN555x083nNTpkxp9d5770WVlpbaEhMTSz/77LOC2NjYI7fUKSsrM7p27Zrk9XqNGTNmfC9J06dPb/btt9+e8/zzz2+9++67d65duzYoKSkp1eFwmKNHj9750EMP7ZwyZcqGESNGOCsrK5WWllZy7733cq4rAAAAANSAcarlrbUlJydnQ1pa2q56ORhwHDk5OS3T0tLirc4BAAAA4Mw1+eXEAAAAAAD/QYkFAAAAAPgNSiwAAAAAwG9QYgEAAAAAfoMSCwAAAADwG5RYAAAAAIDfsOw+sTNnzuxZm+ONGDGiRved3bRpk2PcuHHtcnJyQgMDA824uLiyF198cbMk3XHHHW3Xr18f7HA4zKSkpNKrrrrqp8mTJ8ccfl3QueeeWx4cHOzt0KHDwcWLF0d4PJ7cqKioyqqxMzIynJmZmXtuueWWn2rzvQEAAAAAfCwrsVbwer0aOnRop5EjR+7+6KOPvpekRYsWhWzdujXgtttui3/66ac3jxw5cp8kzZ07N7x169bl+fn5eZLUq1evzs8+++zmfv36lUjSkCFDOrzzzjvN77jjjt2StHv3bvuyZcvC/vnPf6636v0BAAAAQGPXpJYTf/TRR+EOh8O87777dlZtu/DCC0vz8/ODevTosb+qwErSkCFDis8///yDJxorMzNzz8yZMyOrHk+fPr15v379isLDw7119w4AAAAAoGlrUiV25cqVIWlpaSVHb1+1alVIjx49jtl+MsOHDy9atWpV6Pbt2+2SNHPmzMjrrrtuT21lBQAAAAAcq0mV2NoUHBxsXnLJJXvffvvtFtu2bXOsWbMm9KqrriqyOhcAAAAANGZN6pxYl8tVOnv27BZHb09NTT24YMGCsNMdb+TIkXueeuqpGNM0jUsvvXRvUFCQWTtJAQAAAADH06RmYocMGVJ86NAhY/LkyS2rts2fPz80MTHx4LJly8JmzJjRrGr7rFmzIr755puQk403ePDg4g0bNgS//vrr0SNHjmQpMQAAAADUMctmYmt6S5zaZLPZ9OGHH3rGjRvX9vnnn28dFBR05BY7c+bMKZwwYULb+++/v63D4TCTk5NLX3311U0nG89ut+uKK6746eOPP24xaNCg4vp6HwAAAADQVBmmWT8rYHNycjakpaXtqpeDAceRk5PTMi0tLd7qHAAAAADOXJNaTgwAAAAA8G+UWAAAAACA36DEAgAAAAD8BiUWAAAAAOA3KLEAAAAAAL9BiQUAAAAA+A3L7hP717/+tWdtjjdmzJhT3nfW4/EEjBkzpl1hYWGI1+tVRkbGvldfffWH4OBgc9GiRSGbN28OvPbaa/dJ0sSJE2PDwsIqH3/88R21ke8///nPOXfffXfbQ4cO2Q4dOmQMGzbsp+eee25rbYxd2/bt22f7zW9+03bhwoXhQUFBZvPmzSv+9Kc//TBw4MADZzPuiT7TDRs2BIwdO7btp59++v3ZJZc++uij8MmTJ7fKzs4uPNuxAAAAADQ8TWYm1uv1atiwYZ2GDh26d+PGjavWr1+/6sCBA7Y777yzjSQtXbo09OOPP25WW8erqKj42eObb765w1/+8peN+fn5eWvXrl09atSoPWd7DK/Xq8rKyrMd5hijRo2Kb9GiRcWGDRtWFRYWrp46der6H3/8sc6+8IiPjy+vjQILAAAAoPFrMiV27ty54UFBQd4777xztyQ5HA5NmTJl87vvvttyz549tqeffjp27ty5LZKSklJee+21FpK0Zs2akF69enWOi4tz/d///d+5VWO98sorkS6XKzkpKSll5MiR7asKa2hoaPe77rortmvXrkn/+c9/wqoff8+ePY527dqVVx27Z8+eByVpx44d9oyMDGdiYmJKWlpa0pIlS0Ik36zlo48+2qrq9QkJCakFBQWBBQUFgR07dky9/vrr26WmpqZ4PJ7AWbNmRaSkpCR37tw5JT09PVGSioqKbCNGjIjv0qVLcnJycsq0adOaS9LSpUuDq7InJiam5ObmBlXPuXr16qDly5ef88ILL2yx2+2SpJSUlEOZmZn7JOn3v/99q4SEhNSEhITUxx9//FxJKigoCOzQoUPqtdde2z4hISF16NChHWbPnh3eo0ePpPbt23fJzs4OrRp/5cqVoRdccEFi+/btu0yePLll1esTEhJSJSkrKyvq0ksvdfbt2zehffv2XcaOHRtX9doPPvggolu3bkkpKSnJgwYN6rhv3z6bJM2aNSuiQ4cOqT179uw8a9as5mf6dwQAAABAw9dkSmxubm5IWlpaSfVtkZGR3piYmEPr1q0LevDBB7cOGTLkp/z8/Lxbb731J0kqLCwMnj9//tpvv/12zbPPPhtbVlZmfPfdd8GzZs2KXLp0aX5+fn6ezWYzp0yZEiVJpaWlti5dupSuXLky/7LLLttf/VhjxozZkZyc3OWSSy5xPvPMMy1LSkoMSbrvvvti09LSStauXZv3xBNPbBk9enSHU72XDRs2BN90002716xZkxcWFua9/fbb4z/44ANPQUFB3uzZsz2S9NBDD8W43e6iVatWrVm4cGHBI488EldUVGR78cUXo8eNG7cjPz8/b+XKlWs6dOhwqPrYK1asCE5JSSlxOI6deF24cGHoO++8E7Vs2bI1S5cuXTN16tTor776KkSSNm/eHHzPPff8mJ+fv9rj8QRPnz49aunSpflPPvnkD08++WRM1Rhr1qwJ+eKLL9Z9/fXX+c8880zshg0bAo4+Tl5eXujs2bO/X7NmzeoPP/ywRWFhYcC2bdscTz31VMyCBQvW5uXlrenRo0fJE0880aqkpMS4/fbb4z/88MPCb7/9tuDHH388ZjwAAAAAjUeTKbGmacowDPME24/7mksvvXRvSEiIGRMTUxEZGVn+ww8/OD799NPwVatWhaalpSUnJSWlfPnllxHff/99kCTZ7XbdeOONPx1vrGeffXbb4sWL12RkZBS99957UQMGDEiUpG+++Sb85ptv3i1JQ4cOLd67d69j9+7d9pO9l5iYmEMXX3zxAUmaN2/eOb169SpOSko6JEmtWrWqPLw94s9//nNMUlJSSp8+fTqXlZUZhYWFgenp6QcmT54c8/DDD7det25dYFhY2DGfyYnMmzcv7IorrtgbERHhbdasmffKK6/8KTs7O1yS2rRpU9arV69Su92uxMTE0oEDBxbZbDb16NGj5Icffjgy2zto0KC9YWFhZkxMTEV6enrRwoULzzn6OH369CmKioqqDA0NNTt16nTQ4/EEzZs37xyPxxPcq1evpKSkpJQZM2ZEbdq0KXDFihXBcXFxZS6Xq8xms2nUqFG7a/p+AAAAAPgfyy7sVN9cLlfpnDlzWlTftmfPHtv27dsDk5OTy77++uvQo18TFBR0pODZ7XZVVFQYpmkaI0aM2P3yyy9vOXr/wMBA7/FmMKukpqaWpaam7pw4ceLOqKiobtu3b7eb5rEd0jAM0+FwmF6v98i2srKyI007NDT0yBMnKuGmaWrWrFmFaWlpZdW39+jR42Dfvn0P/POf/2w2aNCgxFdeeWXD0KFDi6ue79at28E1a9aEVlZWqmo5cfUxTyQwMPDIkzabTcHBwabk+9wqKyuPBDw66/GyVx/Lbreb5eXlhmma6tOnT9HcuXPXV9930aJFISf6EgIAAABA49NkZmKHDh1afPDgQdtLL70UJfkuvDRu3Li2I0aM2BUeHu6NiIio3L9//yk/j8svv7zoo48+arFlyxaH5Dunde3atYGnet2MGTOaVZXS3NzcYLvdbrZs2bLyggsuKH7zzTejJN+VdVu0aFERGRnpjY+PL1uxYsU5kvTll1+GbtmyJeh447rd7gNLliwJz8/PD6zKc3h70eTJk1tVHbNq2W9eXl5gcnJy2SOPPPLjpZdeunfFihUh1cdLTU0t69q164GJEyfGVssbNG3atOYDBw7c/69//at5cXGxraioyPavf/2rhdvtLtZp+OSTT5qXlJQY27dvt3/99dfhffr0qdEVjwcMGHBg6dKlYatWrQqSpOLiYtvKlSuDunXrdvCHH34IXL16ddDhzznydPIAAAAA8C+WzcTW5JY4tclms2n27NmFY8aMaf/MM8/EeL1eDRw4cF9WVtYWSRo0aFDxs88+G5OUlJRyzz33bDvROD179jz4yCOPbLn44osTvV6vAgICzKysrE2JiYmHTvQaSZo2bVrUAw880DY4ONjrcDjM119/fb3D4dAf//jHrSNHjoxPTExMCQkJ8b711lvrJemGG274afr06VFJSUkp3bp1O9C+ffuDxxs3Nja2Iisra8NVV13Vyev1KioqqnzRokXr/vCHP2wdM2ZMu6SkpBTTNI24uLiy7Ozswrfffjty5syZUQ6Hw4yOji5/+umnj7nNz7Rp0zaMGzeubfv27buEhIR4mzdvXvnMM89s7tOnT8nIkSN39+jRI1mSfvWrX+286KKLSgsKCk5Z4qt07979wMUXX5ywdevWwHvvvXdbfHx8eU1eHxsbW/GXv/xlQ2ZmZsdDhw4ZkvTYY49t6dq1a9mLL764cfDgwZ0iIyMrevfuvX/NmjUhpxoPAAAAgH8yTrZEtDbl5ORsSEtL21UvBwOOIycnp2VaWlq81TkAAAAAnLkms5wYAAAAAOD/KLEAAAAAAL9RnyXW6/V6uYwsLHH47573lDsCAAAAaNDqs8Su2rlzZzOKLOqb1+s1du7c2UzSKquzAAAAADg79XZ14oqKilu2b9/++vbt27uIZcyoX15JqyoqKm6xOggAAACAs1NvVycGAAAAAOBsMSMKAAAAAPAblFgAAAAAgN+gxAIAAAAA/AYlFgAAAADgNyixAAAAAAC/QYkFAAAAAPgNSiwAAAAAwG9QYgEAAAAAfoMSCwAAAADwG5RYAAAAAIDfoMQCAAAAAPwGJRYAAAAA4DcosQAAAAAAv0GJBQAAAAD4jf8H7vTNvnj2DNcAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 1080x1080 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "labels = ['IMDb.com', 'WikiMedia.com', 'Flickr.com', 'Search Engines', 'Livecams', 'CCTV', 'YouTube.com']\n",
+    "colors = get_color_map(cmap='Accent_r',ncolors=ntop+4, as_hex=True, bgr=False, reverse=False)\n",
+    "plot = df_sums.plot.pie(y='images',figsize=(15,15),\n",
+    "  title='Sources of Non-Cooperative Facial Recognition Training Images', colors=colors_msc,\n",
+    "                        autopct='%0.1f%%', fontsize=12, labeldistance=1.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Save PDF\n",
+    "fig = plot.get_figure()\n",
+    "fig.savefig(join(fp_dir_out,'summary_sources.pdf'))\n",
+    "fig.savefig(join(fp_dir_out,'summary_sources.png'))\n",
+    "\n",
+    "# Save CSV\n",
+    "df_sums.to_csv(fp_origins_top, index=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot Country"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x1080 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ntop = 5\n",
+    "df_top = df_country.nlargest(ntop, 'citations')\n",
+    "df_bot = df_country.nsmallest(len(df_country) - ntop, 'citations')\n",
+    "df_tmp = pd.DataFrame.from_dict({'country': ['Others'], 'citations': df_bot['citations'].sum()}).set_index('country')\n",
+    "df_top = df_top.append(df_tmp)\n",
+    "plot = df_top.plot.pie(y='citations', figsize=(15,15), autopct='%0.1f%%', colors=colors_msc,\n",
+    "                       fontsize=12, title='Public Face Recognition Research Citations by Country')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Save images\n",
+    "fig = plot.get_figure()\n",
+    "fig.savefig(join(fp_dir_out,'summary_countries.pdf'))\n",
+    "fig.savefig(join(fp_dir_out,'summary_countries.png'))\n",
+    "\n",
+    "# save CSV\n",
+    "df_top.to_csv(fp_country_top)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Testing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "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>ParticipantLine</th>\n",
+       "      <th>Source</th>\n",
+       "      <th>EatingOccasion</th>\n",
+       "      <th>AtHome</th>\n",
+       "      <th>Calories</th>\n",
+       "      <th>FoodCode</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>73570.015.0</td>\n",
+       "      <td>Store</td>\n",
+       "      <td>Dinner</td>\n",
+       "      <td>True</td>\n",
+       "      <td>428</td>\n",
+       "      <td>lemon (not cream or meringue)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>73598.015.0</td>\n",
+       "      <td>Restaurant with Waiter-Waitress</td>\n",
+       "      <td>Dinner</td>\n",
+       "      <td>False</td>\n",
+       "      <td>726</td>\n",
+       "      <td>pumpkin</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>73633.08.0</td>\n",
+       "      <td>Store</td>\n",
+       "      <td>Lunch</td>\n",
+       "      <td>False</td>\n",
+       "      <td>309</td>\n",
+       "      <td>pumpkin</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>73653.018.0</td>\n",
+       "      <td>From Somewhere Else-Gift</td>\n",
+       "      <td>Snack</td>\n",
+       "      <td>True</td>\n",
+       "      <td>123</td>\n",
+       "      <td>lemon (not cream or meringue)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>73726.017.0</td>\n",
+       "      <td>Bake Sale</td>\n",
+       "      <td>Snack</td>\n",
+       "      <td>True</td>\n",
+       "      <td>17</td>\n",
+       "      <td>blueberry</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  ParticipantLine                           Source EatingOccasion  AtHome  \\\n",
+       "0     73570.015.0                            Store         Dinner    True   \n",
+       "1     73598.015.0  Restaurant with Waiter-Waitress         Dinner   False   \n",
+       "2      73633.08.0                            Store          Lunch   False   \n",
+       "3     73653.018.0         From Somewhere Else-Gift          Snack    True   \n",
+       "4     73726.017.0                        Bake Sale          Snack    True   \n",
+       "\n",
+       "   Calories                       FoodCode  \n",
+       "0       428  lemon (not cream or meringue)  \n",
+       "1       726                        pumpkin  \n",
+       "2       309                        pumpkin  \n",
+       "3       123  lemon (not cream or meringue)  \n",
+       "4        17                      blueberry  "
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_pies = pd.read_csv('toy_data_pies.csv')\n",
+    "df_pies.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_pie_sources = df_pies.groupby('Source').agg('count')\n",
+    "df_pie_flavors = df_pies.groupby('FoodCode').agg('count')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "metadata": {},
+   "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>ParticipantLine</th>\n",
+       "      <th>Source</th>\n",
+       "      <th>EatingOccasion</th>\n",
+       "      <th>AtHome</th>\n",
+       "      <th>Calories</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FoodCode</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>blueberry</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>lemon (not cream or meringue)</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>pumpkin</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                               ParticipantLine  Source  EatingOccasion  \\\n",
+       "FoodCode                                                                 \n",
+       "blueberry                                    1       1               1   \n",
+       "lemon (not cream or meringue)                2       2               2   \n",
+       "pumpkin                                      2       2               2   \n",
+       "\n",
+       "                               AtHome  Calories  \n",
+       "FoodCode                                         \n",
+       "blueberry                           1         1  \n",
+       "lemon (not cream or meringue)       2         2  \n",
+       "pumpkin                             2         2  "
+      ]
+     },
+     "execution_count": 85,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_pie_flavors.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "source_labels = df_pie_sources.FoodCode.sort_values().index\n",
+    "source_counts = df_pie_sources.FoodCode.sort_values()\n",
+    "\n",
+    "flavor_labels = df_pie_flavors.Source.sort_values().index\n",
+    "flavor_counts = df_pie_flavors.Source.sort_values()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Make square figures and axes\n",
+    "plt.figure(1, figsize=(20,10))\n",
+    "the_grid = GridSpec(2, 2)\n",
+    "\n",
+    "\n",
+    "cmap = plt.get_cmap('Spectral')\n",
+    "colors = [cmap(i) for i in np.linspace(0, 1, 8)]\n",
+    "\n",
+    "\n",
+    "plt.subplot(the_grid[0, 1], aspect=1, title='Source of Pies')\n",
+    "\n",
+    "source_pie = plt.pie(source_counts, labels=source_labels, autopct='%1.1f%%', shadow=True, colors=colors)\n",
+    "\n",
+    "\n",
+    "plt.subplot(the_grid[0, 0], aspect=1, title='Selected Flavors of Pies')\n",
+    "\n",
+    "flavor_pie = plt.pie(flavor_counts,labels=flavor_labels, autopct='%.0f%%', shadow=True, colors=colors)\n",
+    "\n",
+    "plt.suptitle('Pie Consumption Patterns in the United States', fontsize=16)\n",
+    "\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#importing critical items\n",
+    "from IPython.core.display import HTML, SVG\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "#import xport \n",
+    "import IPython \n",
+    "from ipywidgets import Layout\n",
+    "from ipywidgets import widgets\n",
+    "from IPython.display import display\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.plotly.v1+json": {
+       "config": {
+        "linkText": "Export to plot.ly",
+        "plotlyServerURL": "https://plot.ly",
+        "showLink": false
+       },
+       "data": [
+        {
+         "domain": {
+          "x": [
+           0,
+           0.4
+          ],
+          "y": [
+           0,
+           1
+          ]
+         },
+         "labels": [
+          "Bake Sale",
+          "From Somewhere Else-Gift",
+          "Restaurant with Waiter-Waitress",
+          "Store"
+         ],
+         "marker": {
+          "colors": [
+           [
+            0.6196078431372549,
+            0.00392156862745098,
+            0.25882352941176473,
+            1
+           ],
+           [
+            0.8853517877739331,
+            0.3190311418685121,
+            0.29042675893886966,
+            1
+           ],
+           [
+            0.9873125720876587,
+            0.6473663975394078,
+            0.3642445213379469,
+            1
+           ],
+           [
+            0.9971549404075356,
+            0.9118031526336025,
+            0.6010765090349866,
+            1
+           ],
+           [
+            0.9288735101883892,
+            0.9715494040753557,
+            0.6380622837370243,
+            1
+           ],
+           [
+            0.6334486735870821,
+            0.8521337946943485,
+            0.6436755094194541,
+            1
+           ],
+           [
+            0.2800461361014994,
+            0.6269896193771626,
+            0.7024221453287197,
+            1
+           ],
+           [
+            0.3686274509803922,
+            0.30980392156862746,
+            0.6352941176470588,
+            1
+           ]
+          ],
+          "line": {
+           "color": "#FFF",
+           "width": 2
+          }
+         },
+         "name": "Sources of Pie",
+         "showlegend": false,
+         "textinfo": "label+percent",
+         "type": "pie",
+         "uid": "3e9e11c0-ca96-4e0f-800b-6b1bb12d4d86",
+         "values": [
+          1,
+          1,
+          1,
+          2
+         ]
+        },
+        {
+         "domain": {
+          "x": [
+           0.6,
+           1
+          ],
+          "y": [
+           0,
+           1
+          ]
+         },
+         "labels": [
+          "blueberry",
+          "lemon (not cream or meringue)",
+          "pumpkin"
+         ],
+         "marker": {
+          "colors": [
+           [
+            0.6196078431372549,
+            0.00392156862745098,
+            0.25882352941176473,
+            1
+           ],
+           [
+            0.8853517877739331,
+            0.3190311418685121,
+            0.29042675893886966,
+            1
+           ],
+           [
+            0.9873125720876587,
+            0.6473663975394078,
+            0.3642445213379469,
+            1
+           ],
+           [
+            0.9971549404075356,
+            0.9118031526336025,
+            0.6010765090349866,
+            1
+           ],
+           [
+            0.9288735101883892,
+            0.9715494040753557,
+            0.6380622837370243,
+            1
+           ],
+           [
+            0.6334486735870821,
+            0.8521337946943485,
+            0.6436755094194541,
+            1
+           ],
+           [
+            0.2800461361014994,
+            0.6269896193771626,
+            0.7024221453287197,
+            1
+           ],
+           [
+            0.3686274509803922,
+            0.30980392156862746,
+            0.6352941176470588,
+            1
+           ]
+          ],
+          "line": {
+           "color": "#FFF",
+           "width": 2
+          }
+         },
+         "name": "Flavors of Pie",
+         "showlegend": false,
+         "textinfo": "label+percent",
+         "type": "pie",
+         "uid": "a31ce595-4599-4049-90d5-f835a7a91734",
+         "values": [
+          1,
+          2,
+          2
+         ]
+        }
+       ],
+       "layout": {
+        "autosize": false,
+        "height": 600,
+        "title": {
+         "text": "Pie Consumption Patterns in the United States"
+        },
+        "width": 1000
+       }
+      }
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sources_pie = go.Pie(labels=source_counts.index, values=source_counts, marker=dict(colors=colors\n",
+    "                                                            , line=dict(color='#FFF', width=2)), \n",
+    "                                                            domain={'x': [0.0, .4], 'y': [0.0, 1]}\n",
+    "                                                            , showlegend=False, name='Sources of Pie', textinfo='label+percent')\n",
+    "\n",
+    "flavor_pie = go.Pie(labels=flavor_counts.index, values=flavor_counts, marker=dict(colors=colors\n",
+    "                                                            , line=dict(color='#FFF', width=2)), \n",
+    "                                                            domain={'x': [.6, 1], 'y': [0.0, 1]}\n",
+    "                                                            , showlegend=False, name='Flavors of Pie', textinfo='label+percent')\n",
+    "\n",
+    "layout = go.Layout(height = 600,\n",
+    "                   width = 1000,\n",
+    "                   autosize = False,\n",
+    "                   title = 'Pie Consumption Patterns in the United States')\n",
+    "fig = go.Figure(data = [sources_pie,flavor_pie ], layout = layout)\n",
+    "\n",
+    "\n",
+    "py.iplot(fig, filename='basic_pie_chart')\n",
+    "\n",
+    "#https://stackoverflow.com/questions/39629735/how-to-plot-pie-charts-as-subplots-with-custom-size-with-plotly-in-python\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/msc/plotter.ipynb b/megapixels/notebooks/msc/plotter.ipynb
index 68cf98c3..9da31a8b 100644..100755
--- a/megapixels/notebooks/msc/plotter.ipynb
+++ b/megapixels/notebooks/msc/plotter.ipynb
@@ -23,6 +23,18 @@
     "import json\n",
     "from pprint import pprint\n",
     "\n",
+    "#import plotly.plotly as py\n",
+    "import plotly.offline as py\n",
+    "import plotly.graph_objs as go\n",
+    "from plotly import tools\n",
+    "\n",
+    "import matplotlib.ticker as ticker\n",
+    "import matplotlib.cm as cm\n",
+    "import matplotlib as mpl\n",
+    "from matplotlib.gridspec import GridSpec\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
     "import numpy as np\n",
     "import pandas as pd\n",
     "from PIL import Image, ImageDraw\n",
@@ -33,162 +45,270 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Load files\n",
     "fp_origins = '/data_store/datasets/msc/summaries/megapixels_origins.csv'\n",
-    "fp_overview = '/data_store/datasets/msc/summaries/megapixels_overview.csv'"
+    "fp_origins_top = '/data_store/datasets/msc/summaries/megapixels_origins_top.csv'\n",
+    "fp_overview = '/data_store/datasets/msc/summaries/megapixels_overview.csv'\n",
+    "fp_sector = '/data_store/datasets/msc/summaries/summary_sector.csv'\n",
+    "fp_country = '/data_store/datasets/msc/summaries/summary_countries.csv'\n",
+    "fp_country_top = '/data_store/datasets/msc/summaries/summary_countries_top.csv'\n",
+    "fp_dir_out = '/data_store/datasets/msc/viz/'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
     "df_origins = pd.read_csv(fp_origins).fillna(0)\n",
-    "df_overview = pd.read_csv(fp_overview).fillna('')"
+    "df_overview = pd.read_csv(fp_overview).fillna('')\n",
+    "df_country = pd.read_csv(fp_country).fillna('').set_index('country')\n",
+    "df_sector = pd.read_csv(fp_sector).fillna('')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_origins_plt = df_origins.drop(['images', 'videos', 'key', 'name_full'], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create custom color maps\n",
+    "import matplotlib as mpl\n",
+    "import matplotlib.cm as mplcm\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib import cm\n",
+    "\n",
+    "def get_color_map(cmap='prism', ncolors=20, as_hex=False, reverse=False, bgr=True):\n",
+    "  norm  = mpl.colors.Normalize(vmin=0, vmax=ncolors-1)\n",
+    "  scalars = mplcm.ScalarMappable(norm=norm, cmap=cmap)\n",
+    "  colors = [scalars.to_rgba(i) for i in range(ncolors)]\n",
+    "  colors = [(int(255*c[0]),int(255*c[1]),int(255*c[2])) for c in colors]  \n",
+    "  if reverse:\n",
+    "    colors = colors[::-1]\n",
+    "  if bgr:\n",
+    "    colors = [c[::-1] for c in colors]\n",
+    "  if as_hex:\n",
+    "    colors = ['#{:02x}{:02x}{:02x}'.format(c[0],c[1],c[2]) for c in colors]\n",
+    "  return colors"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sums = {}\n",
+    "for k in df_origins_plt.keys():\n",
+    "  if not ('cooperative' in k.lower() or 'studio' in k.lower()):\n",
+    "    sums[k] = int(df_origins_plt[k].sum())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
    "metadata": {},
    "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>images</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Search Engines</th>\n",
+       "      <td>15063600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Flickr.com</th>\n",
+       "      <td>5891944</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>IMDb.com</th>\n",
+       "      <td>2625705</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>CCTV</th>\n",
+       "      <td>463507</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Other Sources Combined</th>\n",
+       "      <td>176245</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
       "text/plain": [
-       "0        26580.0\n",
-       "1            0.0\n",
-       "2      4753520.0\n",
-       "3            0.0\n",
-       "4            0.0\n",
-       "5            0.0\n",
-       "6            0.0\n",
-       "7            0.0\n",
-       "8            0.0\n",
-       "9            0.0\n",
-       "10           0.0\n",
-       "11           0.0\n",
-       "12         798.0\n",
-       "13        1609.0\n",
-       "14           0.0\n",
-       "15           0.0\n",
-       "16        2330.0\n",
-       "17     1070000.0\n",
-       "18           0.0\n",
-       "19       37107.0\n",
-       "20           0.0\n",
-       "21           0.0\n",
-       "22           0.0\n",
-       "23           0.0\n",
-       "24           0.0\n",
-       "25           0.0\n",
-       "26           0.0\n",
-       "27           0.0\n",
-       "28           0.0\n",
-       "29           0.0\n",
-       "         ...    \n",
-       "90           0.0\n",
-       "91           0.0\n",
-       "92           0.0\n",
-       "93           0.0\n",
-       "94           0.0\n",
-       "95           0.0\n",
-       "96           0.0\n",
-       "97           0.0\n",
-       "98           0.0\n",
-       "99           0.0\n",
-       "100          0.0\n",
-       "101          0.0\n",
-       "102          0.0\n",
-       "103          0.0\n",
-       "104          0.0\n",
-       "105          0.0\n",
-       "106          0.0\n",
-       "107          0.0\n",
-       "108          0.0\n",
-       "109          0.0\n",
-       "110          0.0\n",
-       "111          0.0\n",
-       "112          0.0\n",
-       "113          0.0\n",
-       "114          0.0\n",
-       "115          0.0\n",
-       "116          0.0\n",
-       "117          0.0\n",
-       "118          0.0\n",
-       "119          0.0\n",
-       "Name: flickr, Length: 120, dtype: float64"
+       "                          images\n",
+       "Search Engines          15063600\n",
+       "Flickr.com               5891944\n",
+       "IMDb.com                 2625705\n",
+       "CCTV                      463507\n",
+       "Other Sources Combined    176245"
       ]
      },
-     "execution_count": 52,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "df_origins_plt.flickr"
+    "df_sums = pd.DataFrame({'images':list(sums.values())}, index=sums.keys())\n",
+    "\n",
+    "# get top N\n",
+    "ntop = 4\n",
+    "k = 'images'\n",
+    "df_top = df_sums.nlargest(ntop, k)\n",
+    "df_bot = df_sums.nsmallest(len(df_sums) - ntop, k)\n",
+    "df_tmp = pd.DataFrame.from_dict({'tmp': ['Other Sources Combined'], k: df_bot[k].sum()}).set_index('tmp')\n",
+    "df_sums = df_top.append(df_tmp)\n",
+    "\n",
+    "df_sums.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['#ff0000', '#0056c3', '#ffd700', '#a200ce', '#54fe00']\n",
+      "['Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r', 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r']\n"
+     ]
+    }
+   ],
+   "source": [
+    "colors = get_color_map(ncolors=5, bgr=False, as_hex=True)\n",
+    "print(colors)\n",
+    "color_list = list(dir(mplcm))\n",
+    "print(color_list[:10])\n",
+    "colors_msc = ['#6d9438', '#d2dcbe', '#a7bb7e', '#aaaaaa','#999999', '#bbbbbb']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x1080 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "labels = ['IMDb.com', 'WikiMedia.com', 'Flickr.com', 'Search Engines', 'Livecams', 'CCTV', 'YouTube.com']\n",
+    "colors = get_color_map(cmap='Accent_r',ncolors=ntop+4, as_hex=True, bgr=False, reverse=False)\n",
+    "plot = df_sums.plot.pie(y='images',figsize=(15,15),\n",
+    "  title='Sources of Non-Cooperative Facial Recognition Training Images', colors=colors_msc,\n",
+    "                        autopct='%0.1f%%', fontsize=12, labeldistance=1.1)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
-    "df_origins_plt = df_origins.drop(['images', 'videos', 'key', 'name_full'], axis=1)\n",
-    "origins_plt = df_origins_plt.to_dict('records')"
+    "# Save PDF\n",
+    "fig = plot.get_figure()\n",
+    "fig.savefig(join(fp_dir_out,'summary_sources.pdf'))\n",
+    "fig.savefig(join(fp_dir_out,'summary_sources.png'))\n",
+    "\n",
+    "# Save CSV\n",
+    "df_sums.to_csv(fp_origins_top, index=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot Country"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "imdb\n",
-      "wikimedia\n",
-      "flickr\n",
-      "search engines\n"
-     ]
-    },
-    {
-     "ename": "TypeError",
-     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-53-aa9b7003a678>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdf_origins_plt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\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      3\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m   \u001b[0msums\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf_origins_plt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\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[0m",
-      "\u001b[0;32m~/anaconda3/envs/megapixels/lib/python3.6/site-packages/pandas/core/generic.py\u001b[0m in \u001b[0;36mstat_func\u001b[0;34m(self, axis, skipna, level, numeric_only, min_count, **kwargs)\u001b[0m\n\u001b[1;32m  10929\u001b[0m                                       skipna=skipna, min_count=min_count)\n\u001b[1;32m  10930\u001b[0m         return self._reduce(f, name, axis=axis, skipna=skipna,\n\u001b[0;32m> 10931\u001b[0;31m                             numeric_only=numeric_only, min_count=min_count)\n\u001b[0m\u001b[1;32m  10932\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m  10933\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mset_function_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstat_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\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/megapixels/lib/python3.6/site-packages/pandas/core/series.py\u001b[0m in \u001b[0;36m_reduce\u001b[0;34m(self, op, name, axis, skipna, numeric_only, filter_type, **kwds)\u001b[0m\n\u001b[1;32m   3628\u001b[0m                                           'numeric_only.'.format(name))\n\u001b[1;32m   3629\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrstate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mall\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'ignore'\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[0;32m-> 3630\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelegate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mskipna\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mskipna\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   3631\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3632\u001b[0m         \u001b[0;31m# TODO(EA) dispatch to Index\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/megapixels/lib/python3.6/site-packages/pandas/core/nanops.py\u001b[0m in \u001b[0;36m_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     74\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[1;32m     75\u001b[0m                 \u001b[0;32mwith\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrstate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minvalid\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'ignore'\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[0;32m---> 76\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mf\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[0m\u001b[1;32m     77\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     78\u001b[0m                 \u001b[0;31m# we want to transform an object array\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/megapixels/lib/python3.6/site-packages/pandas/core/nanops.py\u001b[0m in \u001b[0;36mnansum\u001b[0;34m(values, axis, skipna, min_count, mask)\u001b[0m\n\u001b[1;32m    433\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mis_timedelta64_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtype\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    434\u001b[0m         \u001b[0mdtype_sum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat64\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 435\u001b[0;31m     \u001b[0mthe_sum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdtype_sum\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    436\u001b[0m     \u001b[0mthe_sum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_maybe_null_out\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthe_sum\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmin_count\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmin_count\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    437\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/envs/megapixels/lib/python3.6/site-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial)\u001b[0m\n\u001b[1;32m     34\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m     35\u001b[0m          initial=_NoValue):\n\u001b[0;32m---> 36\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\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     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n",
-      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
-     ]
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x1080 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "sums = {}\n",
-    "for k in df_origins_plt.keys():\n",
-    "  print(k)\n",
-    "  sums[k] = int(df_origins_plt[k].sum())"
+    "ntop = 5\n",
+    "df_top = df_country.nlargest(ntop, 'citations')\n",
+    "df_bot = df_country.nsmallest(len(df_country) - ntop, 'citations')\n",
+    "df_tmp = pd.DataFrame.from_dict({'country': ['Others'], 'citations': df_bot['citations'].sum()}).set_index('country')\n",
+    "df_top = df_top.append(df_tmp)\n",
+    "plot = df_top.plot.pie(y='citations', figsize=(15,15), autopct='%0.1f%%', colors=colors_msc,\n",
+    "                       fontsize=12, title='Public Face Recognition Research Citations by Country')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
-    "df_sums = pd.DataFrame('')"
+    "# Save images\n",
+    "fig = plot.get_figure()\n",
+    "fig.savefig(join(fp_dir_out,'summary_countries.pdf'))\n",
+    "fig.savefig(join(fp_dir_out,'summary_countries.png'))\n",
+    "\n",
+    "# save CSV\n",
+    "df_top.to_csv(fp_country_top)"
    ]
   },
   {
@@ -196,9 +316,7 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "plot = df.plot.pie()"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -230,36 +348,478 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## IGNORE BELOW"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Matplotlib Pandas Bar Chart"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib\n",
+    "\n",
+    "# fivethirtyeight, bmh, grayscale, dark_background, ggplot\n",
+    "matplotlib.style.use('dark_background')\n",
+    "\n",
+    "\n",
+    "data = [[2000, 2000, 2000, 2001, 2001, 2001, 2002, 2002, 2002],\n",
+    "        ['Jan', 'Feb', 'Mar', 'Jan', 'Feb', 'Mar', 'Jan', 'Feb', 'Mar'],\n",
+    "        [1, 2, 3, 4, 5, 6, 7, 8, 9]]\n",
+    "\n",
+    "rows = zip(data[0], data[1], data[2])\n",
+    "headers = ['Year', 'Month', 'Value']\n",
+    "df = pd.DataFrame(rows, columns=headers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib as mpl\n",
+    "mpl.rcParams['font.family'] = 'Ubuntu'\n",
+    "\n",
+    "# fivethirtyeight, bmh, grayscale, dark_background, ggplot\n",
+    "matplotlib.style.use('dark_background')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "scrolled": false
+   },
    "outputs": [
     {
-     "ename": "TypeError",
-     "evalue": "__init__() got an unexpected keyword argument 'title'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-13-7f370064c964>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m df = pd.DataFrame({'mass': [0.33, 4.87, 5.97], 'radius': [2439.7, 6051.8, 6378.1]}, \n\u001b[0;32m----> 2\u001b[0;31m                   index=['Mercury', 'Venus', 'Eart'], title='test')\n\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m: __init__() got an unexpected keyword argument 'title'"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/adam/anaconda3/envs/megapixels/lib/python3.6/site-packages/matplotlib/__init__.py:886: MatplotlibDeprecationWarning:\n",
+      "\n",
+      "\n",
+      "examples.directory is deprecated; in the future, examples will be found relative to the 'datapath' directory.\n",
+      "\n"
      ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "KeysView(RcParams({'_internal.classic_mode': False,\n",
+       "          'agg.path.chunksize': 0,\n",
+       "          'animation.avconv_args': [],\n",
+       "          'animation.avconv_path': 'avconv',\n",
+       "          'animation.bitrate': -1,\n",
+       "          'animation.codec': 'h264',\n",
+       "          'animation.convert_args': [],\n",
+       "          'animation.convert_path': 'convert',\n",
+       "          'animation.embed_limit': 20.0,\n",
+       "          'animation.ffmpeg_args': [],\n",
+       "          'animation.ffmpeg_path': 'ffmpeg',\n",
+       "          'animation.frame_format': 'png',\n",
+       "          'animation.html': 'none',\n",
+       "          'animation.html_args': [],\n",
+       "          'animation.writer': 'ffmpeg',\n",
+       "          'axes.autolimit_mode': 'data',\n",
+       "          'axes.axisbelow': True,\n",
+       "          'axes.edgecolor': 'white',\n",
+       "          'axes.facecolor': 'black',\n",
+       "          'axes.formatter.limits': [-7, 7],\n",
+       "          'axes.formatter.min_exponent': 0,\n",
+       "          'axes.formatter.offset_threshold': 4,\n",
+       "          'axes.formatter.use_locale': False,\n",
+       "          'axes.formatter.use_mathtext': False,\n",
+       "          'axes.formatter.useoffset': True,\n",
+       "          'axes.grid': True,\n",
+       "          'axes.grid.axis': 'both',\n",
+       "          'axes.grid.which': 'major',\n",
+       "          'axes.labelcolor': 'white',\n",
+       "          'axes.labelpad': 4.0,\n",
+       "          'axes.labelsize': 'large',\n",
+       "          'axes.labelweight': 'normal',\n",
+       "          'axes.linewidth': 1.0,\n",
+       "          'axes.prop_cycle': cycler('color', ['#8dd3c7', '#feffb3', '#bfbbd9', '#fa8174', '#81b1d2', '#fdb462', '#b3de69', '#bc82bd', '#ccebc4', '#ffed6f']),\n",
+       "          'axes.spines.bottom': True,\n",
+       "          'axes.spines.left': True,\n",
+       "          'axes.spines.right': True,\n",
+       "          'axes.spines.top': True,\n",
+       "          'axes.titlepad': 6.0,\n",
+       "          'axes.titlesize': 'x-large',\n",
+       "          'axes.titleweight': 'normal',\n",
+       "          'axes.unicode_minus': True,\n",
+       "          'axes.xmargin': 0.05,\n",
+       "          'axes.ymargin': 0.05,\n",
+       "          'axes3d.grid': True,\n",
+       "          'backend': 'module://ipykernel.pylab.backend_inline',\n",
+       "          'backend.qt4': None,\n",
+       "          'backend.qt5': None,\n",
+       "          'backend_fallback': True,\n",
+       "          'boxplot.bootstrap': None,\n",
+       "          'boxplot.boxprops.color': 'black',\n",
+       "          'boxplot.boxprops.linestyle': '-',\n",
+       "          'boxplot.boxprops.linewidth': 1.0,\n",
+       "          'boxplot.capprops.color': 'black',\n",
+       "          'boxplot.capprops.linestyle': '-',\n",
+       "          'boxplot.capprops.linewidth': 1.0,\n",
+       "          'boxplot.flierprops.color': 'black',\n",
+       "          'boxplot.flierprops.linestyle': 'none',\n",
+       "          'boxplot.flierprops.linewidth': 1.0,\n",
+       "          'boxplot.flierprops.marker': 'o',\n",
+       "          'boxplot.flierprops.markeredgecolor': 'black',\n",
+       "          'boxplot.flierprops.markerfacecolor': 'none',\n",
+       "          'boxplot.flierprops.markersize': 6.0,\n",
+       "          'boxplot.meanline': False,\n",
+       "          'boxplot.meanprops.color': 'C2',\n",
+       "          'boxplot.meanprops.linestyle': '--',\n",
+       "          'boxplot.meanprops.linewidth': 1.0,\n",
+       "          'boxplot.meanprops.marker': '^',\n",
+       "          'boxplot.meanprops.markeredgecolor': 'C2',\n",
+       "          'boxplot.meanprops.markerfacecolor': 'C2',\n",
+       "          'boxplot.meanprops.markersize': 6.0,\n",
+       "          'boxplot.medianprops.color': 'C1',\n",
+       "          'boxplot.medianprops.linestyle': '-',\n",
+       "          'boxplot.medianprops.linewidth': 1.0,\n",
+       "          'boxplot.notch': False,\n",
+       "          'boxplot.patchartist': False,\n",
+       "          'boxplot.showbox': True,\n",
+       "          'boxplot.showcaps': True,\n",
+       "          'boxplot.showfliers': True,\n",
+       "          'boxplot.showmeans': False,\n",
+       "          'boxplot.vertical': True,\n",
+       "          'boxplot.whiskerprops.color': 'black',\n",
+       "          'boxplot.whiskerprops.linestyle': '-',\n",
+       "          'boxplot.whiskerprops.linewidth': 1.0,\n",
+       "          'boxplot.whiskers': 1.5,\n",
+       "          'contour.corner_mask': True,\n",
+       "          'contour.negative_linestyle': 'dashed',\n",
+       "          'datapath': '/home/adam/anaconda3/envs/megapixels/lib/python3.6/site-packages/matplotlib/mpl-data',\n",
+       "          'date.autoformatter.day': '%Y-%m-%d',\n",
+       "          'date.autoformatter.hour': '%m-%d %H',\n",
+       "          'date.autoformatter.microsecond': '%M:%S.%f',\n",
+       "          'date.autoformatter.minute': '%d %H:%M',\n",
+       "          'date.autoformatter.month': '%Y-%m',\n",
+       "          'date.autoformatter.second': '%H:%M:%S',\n",
+       "          'date.autoformatter.year': '%Y',\n",
+       "          'docstring.hardcopy': False,\n",
+       "          'errorbar.capsize': 0.0,\n",
+       "          'examples.directory': '',\n",
+       "          'figure.autolayout': False,\n",
+       "          'figure.constrained_layout.h_pad': 0.04167,\n",
+       "          'figure.constrained_layout.hspace': 0.02,\n",
+       "          'figure.constrained_layout.use': False,\n",
+       "          'figure.constrained_layout.w_pad': 0.04167,\n",
+       "          'figure.constrained_layout.wspace': 0.02,\n",
+       "          'figure.dpi': 72.0,\n",
+       "          'figure.edgecolor': 'black',\n",
+       "          'figure.facecolor': 'black',\n",
+       "          'figure.figsize': [6.0, 4.0],\n",
+       "          'figure.frameon': True,\n",
+       "          'figure.max_open_warning': 20,\n",
+       "          'figure.subplot.bottom': 0.125,\n",
+       "          'figure.subplot.hspace': 0.2,\n",
+       "          'figure.subplot.left': 0.125,\n",
+       "          'figure.subplot.right': 0.9,\n",
+       "          'figure.subplot.top': 0.88,\n",
+       "          'figure.subplot.wspace': 0.2,\n",
+       "          'figure.titlesize': 'large',\n",
+       "          'figure.titleweight': 'normal',\n",
+       "          'font.cursive': ['Apple Chancery',\n",
+       "                           'Textile',\n",
+       "                           'Zapf Chancery',\n",
+       "                           'Sand',\n",
+       "                           'Script MT',\n",
+       "                           'Felipa',\n",
+       "                           'cursive'],\n",
+       "          'font.family': ['Ubuntu'],\n",
+       "          'font.fantasy': ['Comic Sans MS',\n",
+       "                           'Chicago',\n",
+       "                           'Charcoal',\n",
+       "                           'Impact',\n",
+       "                           'Western',\n",
+       "                           'Humor Sans',\n",
+       "                           'xkcd',\n",
+       "                           'fantasy'],\n",
+       "          'font.monospace': ['DejaVu Sans Mono',\n",
+       "                             'Bitstream Vera Sans Mono',\n",
+       "                             'Computer Modern Typewriter',\n",
+       "                             'Andale Mono',\n",
+       "                             'Nimbus Mono L',\n",
+       "                             'Courier New',\n",
+       "                             'Courier',\n",
+       "                             'Fixed',\n",
+       "                             'Terminal',\n",
+       "                             'monospace'],\n",
+       "          'font.sans-serif': ['DejaVu Sans',\n",
+       "                              'Bitstream Vera Sans',\n",
+       "                              'Computer Modern Sans Serif',\n",
+       "                              'Lucida Grande',\n",
+       "                              'Verdana',\n",
+       "                              'Geneva',\n",
+       "                              'Lucid',\n",
+       "                              'Arial',\n",
+       "                              'Helvetica',\n",
+       "                              'Avant Garde',\n",
+       "                              'sans-serif'],\n",
+       "          'font.serif': ['DejaVu Serif',\n",
+       "                         'Bitstream Vera Serif',\n",
+       "                         'Computer Modern Roman',\n",
+       "                         'New Century Schoolbook',\n",
+       "                         'Century Schoolbook L',\n",
+       "                         'Utopia',\n",
+       "                         'ITC Bookman',\n",
+       "                         'Bookman',\n",
+       "                         'Nimbus Roman No9 L',\n",
+       "                         'Times New Roman',\n",
+       "                         'Times',\n",
+       "                         'Palatino',\n",
+       "                         'Charter',\n",
+       "                         'serif'],\n",
+       "          'font.size': 10.0,\n",
+       "          'font.stretch': 'normal',\n",
+       "          'font.style': 'normal',\n",
+       "          'font.variant': 'normal',\n",
+       "          'font.weight': 'normal',\n",
+       "          'grid.alpha': 1.0,\n",
+       "          'grid.color': 'white',\n",
+       "          'grid.linestyle': '-',\n",
+       "          'grid.linewidth': 0.8,\n",
+       "          'hatch.color': 'black',\n",
+       "          'hatch.linewidth': 1.0,\n",
+       "          'hist.bins': 10,\n",
+       "          'image.aspect': 'equal',\n",
+       "          'image.cmap': 'viridis',\n",
+       "          'image.composite_image': True,\n",
+       "          'image.interpolation': 'nearest',\n",
+       "          'image.lut': 256,\n",
+       "          'image.origin': 'upper',\n",
+       "          'image.resample': True,\n",
+       "          'interactive': True,\n",
+       "          'keymap.all_axes': ['a'],\n",
+       "          'keymap.back': ['left', 'c', 'backspace'],\n",
+       "          'keymap.copy': ['ctrl+c', 'cmd+c'],\n",
+       "          'keymap.forward': ['right', 'v'],\n",
+       "          'keymap.fullscreen': ['f', 'ctrl+f'],\n",
+       "          'keymap.grid': ['g'],\n",
+       "          'keymap.grid_minor': ['G'],\n",
+       "          'keymap.help': ['f1'],\n",
+       "          'keymap.home': ['h', 'r', 'home'],\n",
+       "          'keymap.pan': ['p'],\n",
+       "          'keymap.quit': ['ctrl+w', 'cmd+w', 'q'],\n",
+       "          'keymap.quit_all': ['W', 'cmd+W', 'Q'],\n",
+       "          'keymap.save': ['s', 'ctrl+s'],\n",
+       "          'keymap.xscale': ['k', 'L'],\n",
+       "          'keymap.yscale': ['l'],\n",
+       "          'keymap.zoom': ['o'],\n",
+       "          'legend.borderaxespad': 0.5,\n",
+       "          'legend.borderpad': 0.4,\n",
+       "          'legend.columnspacing': 2.0,\n",
+       "          'legend.edgecolor': '0.8',\n",
+       "          'legend.facecolor': 'inherit',\n",
+       "          'legend.fancybox': True,\n",
+       "          'legend.fontsize': 'medium',\n",
+       "          'legend.framealpha': 0.8,\n",
+       "          'legend.frameon': True,\n",
+       "          'legend.handleheight': 0.7,\n",
+       "          'legend.handlelength': 2.0,\n",
+       "          'legend.handletextpad': 0.8,\n",
+       "          'legend.labelspacing': 0.5,\n",
+       "          'legend.loc': 'best',\n",
+       "          'legend.markerscale': 1.0,\n",
+       "          'legend.numpoints': 1,\n",
+       "          'legend.scatterpoints': 1,\n",
+       "          'legend.shadow': False,\n",
+       "          'legend.title_fontsize': None,\n",
+       "          'lines.antialiased': True,\n",
+       "          'lines.color': 'white',\n",
+       "          'lines.dash_capstyle': 'butt',\n",
+       "          'lines.dash_joinstyle': 'round',\n",
+       "          'lines.dashdot_pattern': [6.4, 1.6, 1.0, 1.6],\n",
+       "          'lines.dashed_pattern': [3.7, 1.6],\n",
+       "          'lines.dotted_pattern': [1.0, 1.65],\n",
+       "          'lines.linestyle': '-',\n",
+       "          'lines.linewidth': 1.5,\n",
+       "          'lines.marker': 'None',\n",
+       "          'lines.markeredgecolor': 'auto',\n",
+       "          'lines.markeredgewidth': 1.0,\n",
+       "          'lines.markerfacecolor': 'auto',\n",
+       "          'lines.markersize': 6.0,\n",
+       "          'lines.scale_dashes': True,\n",
+       "          'lines.solid_capstyle': 'projecting',\n",
+       "          'lines.solid_joinstyle': 'round',\n",
+       "          'markers.fillstyle': 'full',\n",
+       "          'mathtext.bf': 'sans:bold',\n",
+       "          'mathtext.cal': 'cursive',\n",
+       "          'mathtext.default': 'it',\n",
+       "          'mathtext.fallback_to_cm': True,\n",
+       "          'mathtext.fontset': 'dejavusans',\n",
+       "          'mathtext.it': 'sans:italic',\n",
+       "          'mathtext.rm': 'sans',\n",
+       "          'mathtext.sf': 'sans',\n",
+       "          'mathtext.tt': 'monospace',\n",
+       "          'patch.antialiased': True,\n",
+       "          'patch.edgecolor': 'white',\n",
+       "          'patch.facecolor': '#348ABD',\n",
+       "          'patch.force_edgecolor': False,\n",
+       "          'patch.linewidth': 0.5,\n",
+       "          'path.effects': [],\n",
+       "          'path.simplify': True,\n",
+       "          'path.simplify_threshold': 0.1111111111111111,\n",
+       "          'path.sketch': None,\n",
+       "          'path.snap': True,\n",
+       "          'pdf.compression': 6,\n",
+       "          'pdf.fonttype': 3,\n",
+       "          'pdf.inheritcolor': False,\n",
+       "          'pdf.use14corefonts': False,\n",
+       "          'pgf.preamble': [],\n",
+       "          'pgf.rcfonts': True,\n",
+       "          'pgf.texsystem': 'xelatex',\n",
+       "          'polaraxes.grid': True,\n",
+       "          'ps.distiller.res': 6000,\n",
+       "          'ps.fonttype': 3,\n",
+       "          'ps.papersize': 'letter',\n",
+       "          'ps.useafm': False,\n",
+       "          'ps.usedistiller': False,\n",
+       "          'savefig.bbox': None,\n",
+       "          'savefig.directory': '~',\n",
+       "          'savefig.dpi': 'figure',\n",
+       "          'savefig.edgecolor': 'black',\n",
+       "          'savefig.facecolor': 'black',\n",
+       "          'savefig.format': 'png',\n",
+       "          'savefig.frameon': True,\n",
+       "          'savefig.jpeg_quality': 95,\n",
+       "          'savefig.orientation': 'portrait',\n",
+       "          'savefig.pad_inches': 0.1,\n",
+       "          'savefig.transparent': False,\n",
+       "          'scatter.marker': 'o',\n",
+       "          'svg.fonttype': 'path',\n",
+       "          'svg.hashsalt': None,\n",
+       "          'svg.image_inline': True,\n",
+       "          'text.antialiased': True,\n",
+       "          'text.color': 'white',\n",
+       "          'text.hinting': 'auto',\n",
+       "          'text.hinting_factor': 8,\n",
+       "          'text.latex.preamble': [],\n",
+       "          'text.latex.preview': False,\n",
+       "          'text.latex.unicode': True,\n",
+       "          'text.usetex': False,\n",
+       "          'timezone': 'UTC',\n",
+       "          'tk.window_focus': False,\n",
+       "          'toolbar': 'toolbar2',\n",
+       "          'verbose.fileo': 'sys.stdout',\n",
+       "          'verbose.level': 'silent',\n",
+       "          'webagg.address': '127.0.0.1',\n",
+       "          'webagg.open_in_browser': True,\n",
+       "          'webagg.port': 8988,\n",
+       "          'webagg.port_retries': 50,\n",
+       "          'xtick.alignment': 'center',\n",
+       "          'xtick.bottom': True,\n",
+       "          'xtick.color': 'white',\n",
+       "          'xtick.direction': 'out',\n",
+       "          'xtick.labelbottom': True,\n",
+       "          'xtick.labelsize': 'medium',\n",
+       "          'xtick.labeltop': False,\n",
+       "          'xtick.major.bottom': True,\n",
+       "          'xtick.major.pad': 3.5,\n",
+       "          'xtick.major.size': 3.5,\n",
+       "          'xtick.major.top': True,\n",
+       "          'xtick.major.width': 0.8,\n",
+       "          'xtick.minor.bottom': True,\n",
+       "          'xtick.minor.pad': 3.4,\n",
+       "          'xtick.minor.size': 2.0,\n",
+       "          'xtick.minor.top': True,\n",
+       "          'xtick.minor.visible': False,\n",
+       "          'xtick.minor.width': 0.6,\n",
+       "          'xtick.top': False,\n",
+       "          'ytick.alignment': 'center_baseline',\n",
+       "          'ytick.color': 'white',\n",
+       "          'ytick.direction': 'out',\n",
+       "          'ytick.labelleft': True,\n",
+       "          'ytick.labelright': False,\n",
+       "          'ytick.labelsize': 'medium',\n",
+       "          'ytick.left': True,\n",
+       "          'ytick.major.left': True,\n",
+       "          'ytick.major.pad': 3.5,\n",
+       "          'ytick.major.right': True,\n",
+       "          'ytick.major.size': 3.5,\n",
+       "          'ytick.major.width': 0.8,\n",
+       "          'ytick.minor.left': True,\n",
+       "          'ytick.minor.pad': 3.4,\n",
+       "          'ytick.minor.right': True,\n",
+       "          'ytick.minor.size': 2.0,\n",
+       "          'ytick.minor.visible': False,\n",
+       "          'ytick.minor.width': 0.6,\n",
+       "          'ytick.right': False}))"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "df = pd.DataFrame({'mass': [0.33, 4.87, 5.97], 'radius': [2439.7, 6051.8, 6378.1]}, \n",
-    "                  index=['Mercury', 'Venus', 'Eartn'])"
+    "mpl.rcParams.keys()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rcp = mpl.rcParams"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rcp['axes.facecolor'] = 'black'\n",
+    "rcp['axes.edgecolor'] = 'white'\n",
+    "rcp['axes.grid'] = True\n",
+    "rcp['axes.grid.axis'] = 'x'\n",
+    "rcp['legend.frameon'] = True\n",
+    "rcp['ps.papersize'] = 'A4'\n",
+    "rcp['figure.frameon'] = False\n",
+    "rcp['axes.spines.bottom'] = True\n",
+    "rcp['axes.spines.left'] = False\n",
+    "rcp['axes.spines.right'] = False\n",
+    "rcp['axes.spines.top'] = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 360x360 with 1 Axes>"
+       "<Figure size 720x504 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -267,45 +827,576 @@
     }
    ],
    "source": [
-    "plot = df.plot.pie(y='mass', figsize=(5,5), title='test')"
+    "\n",
+    "fig, ax = plt.subplots(figsize=(10,7))  \n",
+    "\n",
+    "months = df['Month'].drop_duplicates()\n",
+    "margin_bottom = np.zeros(len(df['Year'].drop_duplicates()))\n",
+    "colors = [\"#006D2C\", \"#31A354\",\"#74C476\"]\n",
+    "\n",
+    "for num, month in enumerate(months):\n",
+    "    values = list(df[df['Month'] == month].loc[:, 'Value'])\n",
+    "\n",
+    "    df[df['Month'] == month].plot.bar(x='Year',y='Value', ax=ax, stacked=True, \n",
+    "                                    bottom = margin_bottom, color=colors[num], label=month)\n",
+    "    margin_bottom += values\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Matplotlib Bar Chart"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xm8VVX9//HXW0QxQUS5mROifjE1UNSraZJSmkNapulXSxMsQxocfmZhM2bfb/HNqcE0nCBT09QszRwyESgTQWbBnFBRUDFRECnFz++PtS4cLufce4F7zuG638/H4z7uPmtPa++zz/7stdbeaysiMDOz4lqv3hkwM7P6ciAwMys4BwIzs4JzIDAzKzgHAjOzgnMgMDMrOAcCqxpJl0v6br3z0RJJAyXNrcN6T5R0T63Xa1aOA8E6TtKGkq6S9IykRZImSzq82TQHSZotaYmk+yVtVzLuvyX9PY8bU2b5H5X0iKTXJT0laUiFfGwpKSRtUZL27QppdwFExNCIOL+N2zlK0g/bMu3qkPQhSX/N++41SbdL2rW917O6IuK6iDikPZaVg8ri/PempHdKPi9uj3U0W9+XJP0zL39+3qcbtfd6rHYcCNZ96wPPAQcC3YHvAjdJ6g0gqSdwa07fDJgI3Fgy/7+AS4AfN1+wpM7A74Ff5WUfD1wkaffm00bEPOAJ4ICS5AOA2WXSxq72Vq4lSeuXSdsPuAf4A7AVsD0wFfibpB1qm8PqyUGla0R0BQ4HXmj6nNPajaRDge8An87L/gDpGGrPdazyXVZjHisREf7rYH/ANNIPEWAI8PeScRsDbwI7N5vnVGBMs7QtgADeU5L2MPCZCuu9Cvh5Hu4EvAQMbZb2OjAgfx4F/DAPDwTmAl/L880DTinZhreA/wCLgdtz+lbALcDLwNPAGSV5GQ7cDPwmr/PUMvkdB/yyTPqfgV+X5isPfx24pdm0PwcuycNjgB8Cf2/KJ7A5cF3Ow8NA75J5AzgDeApYAPwEWC+PGwyML5n2A8C9pMD9IvCtnL4PKbi/ntMvauXYWL49zdL75f2xMB8/h5eM+23ezvuBRcB9wNYVlv8d4LctrH9j4Geki5fXgAeA9fO4TwOP5jz8BehTMt984BxgJrAkp21LCuIL8j4cWjL9j4HrSRc9i4CTgP2ByXlfzQd+VO/fakf5q3sG/LeaX1g6eS8ln+iBnwKXNZtmBjlQlKStEghy+vXAV0gn8f1IJ+ltK6x7EDA1DzeSrvz7NEt7E9ggfx7FyoHgbeAHQGfg48ASoEfzafPn9YBJwPeADYAd8sng0Dx+OCl4fCpPu1GzvL4HWAZ8pMx2nALMK8lXUyDYEngD2DR/Xj/vj73y5zGkUtGOpBLUo8A/gYPztL8GrilZT5BOrpsBvfK0p+Zxg8mBAOhGCoxfA7rkzx/M4x4EPpeHuwL7tnJ8LN+ekrQuwDN5+Z2BQ0mBbPs8/rekk/N+edrLgb9UWP7B+Xv7Xp5+g2bjryKVwt5HOqY+nP/3JZ2wB+bv87vALFYEifmkQLoVsFGeZzowLE+/E/AscGCe/sfAv0nH0Xp5nsnAcSX79IP1/r12lD9XDXUguSrnOmB0RMzOyV1JV16lXiP9ENriBtKP+t+kK8ZvR8RzFaZ9AOgrqQfpBz4uIh4Hepak/SMi/lNh/reAH0TEWxFxJ+lk9P4K0+4NNETEDyLiPxHxFHAFcELJNA9GxG0R8U5EvNls/s1IJ4h5ZZY9D+jZPDFS9ddY4LicdBiwICImlUx2TUQ8GRGvkUoWT0bEXyLibeB3wB7NFjsiIv4VEc+Squg+UyY/RwLzI+LCiFgaEYsi4qE87i3gvyT1jIjFEfGPMvO35sP5/0V5399NKn0cXzLNbRHxYEQsBb4FHCSpofmCIuIvpO/gg8DdwAJJIyStl4/Pk4HTI2J+RCyLiHERsSxv9+8jYkw+Pv6X9B00liz+4oh4IX+XA4AuETEif///BK5h5e//gYi4s+T7fwvYSdLmzfahtcKBoIOQtB5wLan65KsloxYDmzSbfBPS1Vdry9yZVLQ+mXTV9QHgG5KOKDd9RMwhVe8MILUFjMujHixJa6l94JV8wmyyhBTIytkO2ErSwqY/0glqi5JpKgUsgFeBd0hX+c1tSapuKGc0qZqB/P/aZuNfLBl+s8zn5ttTmsdnSFe8zW0LPFkhP18gXQ3PlvSwpCMrTNeSrYBnI18ql+Rl63L5jIh/kY6rcnklIv4YEUcAm5KC5peAz5H26/qkklu5PDxTsoxlwPOV8kD6/ns3+/7PJpU0yk0PqcS6G/BPSQ/l9gxrAweCDkCSSEXuLUhVPm+VjJ4J7F4y7cakqouZbVh0X+CxiLg7X1U9BvyJ1OBYyTjSCX8/Ul15adoA1ryhuHk3uM8BT0fEpiV/3SLi4y3Ms2JExBukAHVcmdH/TaoHL+c2YDdJfUlX6te1eQvK27ZkuBfwQplpniN9Z6uIiMcj4jPAe4ERwM35O14dL+R1l+pFOhGvkk9Jm5ECWrnSVGne3smli7GkY2keqfqvXEP8C6STe9M6OpGCQGkeSr/P54DZZb7/oytMT0TMiojjSfvqZ8CtkjZoaRsscSDoGC4DdgE+UaYK5Pek6ppPS+pCquaZ1lR1JKlTTl8fWE9Sl1yEh1Sn2iffQipJO5JOflNbyMtYUgnihYh4PaeNz2ndSSffNfEiK59AJgCvSxomaaO8HX0l7b0ayzwXGCTpDEndJPXIt6juB5xXboZcNXIzqe1kQq7SWRtfz+vdFjiTle/oanIH8D5JZ+XbhbtJ+iCApJMkNUTEO6R6fEhtH6tjHOm7P0vS+pI+BhxCqspqcpSkD0rakNQgfn9EvNR8QZKOlXScpE3zMfMhUiPtP/IFyq+Bn0raIn9nA/JJ/0bgaEkH5OPvXOAVUkN4OePz+s7Kx+z6knaTtGeljZR0cq4WWkaqHg1SqdBa4UCwjlN6JuA0oD8wv+T+8BMBIuJl0t0Y/0OqDvkgK9ejfo5UZXEZqa74TVJdOxHxJPB50tXT66Q2gFtIpY9KHiBdcY0vSZtCaqybFBFL1nBTrwJ2zdUAt+Uf8yfydj9Nqsq5khRs2iQixpMaRo8hXa0+Q6rDH5DbNioZTbrLpnm10Jr4A6nRewqptLXKvo2IRcDHSNs7H3gc+EgefRgwMz8P8FPghBys2ixPfyRwLOnkexFwfP7+m/yG1AC7gHTRMajC4l4FvkyqynoduBo4LyJuyePPyOMm53WdDygippGquX5FugvsIOCoZlWFpXl+i9QQ/CHS9/Yy6Rhu6XbYI4HHJC0CfgT8d6Xl28q0crWhmUnqRXo+4n0lpZ41WU6QbpF8ot0yVwWSfgvMiIh2f6DPOgaXCMxK5Eb5s0n3yq9xEDDrSPw0nlmWG2FfJFVFHFbn7JjVjKuGzMwKzlVDZmYF1yGqhnr27Bm9e/eudzbMzDqUSZMmLYiIVZ4Qb65DBILevXszcWKl243NzKwcSc+0PpWrhszMCs+BwMys4BwIzMwKrkO0EZhZMb311lvMnTuXpUtXq1eNwunSpQvbbLMNnTt3bn3iMhwIzGydNXfuXLp160bv3r1JnfBacxHBK6+8wty5c9l+++3XaBmuGjKzddbSpUvZfPPNHQRaIInNN998rUpNDgRmtk5zEGjd2u4jBwIzs4JzG4GZdRyz27l0sHP79rU2ePBgjjzySI499tiV0seMGcMFF1zAHXfc0a7ray/v/kDQ3gdOe2vnA9HMbHW9+wOBmdlaOP/887nuuuvYdttt6dmzJ3vttRcHH3wwQ4cOZcmSJey4445cffXV9OjRY6X57rrrLs466yx69uzJnnuueMPmAw88wJlnngmkuv2xY8fSrVu3mm5Tc24jMDOrYOLEidxyyy1MnjyZW2+9dXmfZyeffDIjRoxg2rRp9OvXj/POW/kV2EuXLuWLX/wit99+O+PGjWP+/PnLx11wwQVceumlTJkyhXHjxrHRRhvVdJvKcSAwM6tg/PjxHHXUUWy00UZ069aNT3ziE7zxxhssXLiQAw88EIBBgwYxduzYleabPXs222+/PX369EESJ5100vJx+++/P2effTY/+9nPWLhwIeuvX/+KGQcCM7MK1ubFXZVu6Tz33HO58sorefPNN9l3332ZPXv2Gq+jvTgQmJlVMGDAAG6//XaWLl3K4sWL+dOf/sTGG29Mjx49GDduHADXXnvt8tJBk5133pmnn36aJ598EoAbbrhh+bgnn3ySfv36MWzYMBobG9eJQFD/MomZWVvV+C67vffem09+8pPsvvvubLfddjQ2NtK9e3dGjx69vLF4hx124Jprrllpvi5dujBy5EiOOOIIevbsyYABA5gxYwYAl1xyCffffz+dOnVi11135fDDD6/pNpXTId5Z3NjYGGv8YhrfPmrWYc2aNYtddtmlrnlYvHgxXbt2ZcmSJRxwwAGMHDlypbuA1hXl9pWkSRHR2Nq8LhGYmbVgyJAhPProoyxdupRBgwatk0FgbTkQmJm14Prrr693FqrOjcVmZgXnQGBmVnAOBGZmBVe1QCCpi6QJkqZKminpvJw+StLTkqbkv/7VyoOZmbWumo3F/wY+GhGLJXUGxkv6cx739Yi4uYrrNrN3oQceeKBdl9f8QbC2OPXUUzn77LPZdddd6d27NxMnTqRnz57tmq9aq1ogiPSAwuL8sXP+803zZtahXXnlle26vIggIlhvvfrV1Fd1zZI6SZoCvATcGxEP5VH/I2mapIslbVhh3iGSJkqa+PLLL1czm2ZmZb3xxhscccQR7L777vTt25cbb7yRgQMH0vwB12HDhvHLX/5y+efhw4dz4YUXAvCTn/yEvffem912243vf//7AMyZM4dddtmFL3/5y+y5554899xzDB48mL59+9KvXz8uvvji2m0kVQ4EEbEsIvoD2wD7SOoLfBPYGdgb2AwYVmHekRHRGBGNDQ0N1cymmVlZd911F1tttRVTp05lxowZHHbYYWWnO+GEE7jxxhuXf77ppps47rjjuOeee3j88ceZMGECU6ZMYdKkSct7Kn3sscc4+eSTmTx5MgsWLOD5559nxowZTJ8+nVNOOaUm29ekJmWRiFgIjAEOi4h5kfwbuAbYpxZ5MDNbXf369eMvf/kLw4YNY9y4cXTv3r3sdHvssQcvvfQSL7zwAlOnTqVHjx706tWLe+65h3vuuYc99tiDPffck9mzZ/P4448DsN1227HvvvsCsMMOO/DUU09x+umnc9ddd7HJJpvUbBuhim0EkhqAtyJioaSNgIOBEZK2jIh5Sn20fgqYUa08mJmtjZ122olJkyZx55138s1vfpNDDjmk4rTHHnssN998M/Pnz+eEE04AUv3/N7/5TU477bSVpp0zZw4bb7zx8s89evRg6tSp3H333Vx66aXcdNNNXH311dXZqDKqedfQlsBoSZ1IJY+bIuIOSX/NQULAFGBoFfNgZrbGXnjhBTbbbDNOOukkunbtyqhRoypOe8IJJ/DFL36RBQsWLL+76dBDD+W73/0uJ554Il27duX555+nc+fOq8y7YMECNthgAz796U+z4447Mnjw4CptUXnVvGtoGrBHmfSPVmudZvbutia3e66N6dOn8/Wvf5311luPzp07c9lll3HOOeeUnfYDH/gAixYtYuutt2bLLbcE4JBDDmHWrFnst99+AHTt2pXf/OY3dOrUaaV5n3/+eU455RTeeecdAH70ox9VcatW5W6o683dUJtVtC50Q91RrE031O5iwsys4BwIzMwKzoHAzKzgHAjMzArOgcDMrOAcCMzMCs7vLDazDuOR4Xu16/L2HD6pxfFz5szhyCOPZMaMd3cHCC4RmJmthWXLltU7C2vNgcDMrAVvv/02gwYNYrfdduPYY49lyZIl9O7dmx/84AcMGDCA3/3ud0yZMoV9992X3XbbjaOPPppXX30VgIEDBzJs2DD22WcfdtppJ8aNGwekl9v079+f/v3709DQwHnnnQeU77K6XFfY7c2BwMysBY899hhDhgxh2rRpbLLJJsvfO9ClSxfGjx/PCSecwMknn8yIESOYNm0a/fr1W35ihxRIJkyYwCWXXLI8/corr2TKlCn84Q9/YPPNN2fw4MEVu6xua1fYa8OBwMysBdtuuy37778/ACeddBLjx48H4PjjjwfgtddeY+HChcv7QRo0aNDydw4AHHPMMQDstddezJkzZ3n60qVLOe644/jFL37BdtttV7HL6rZ2hb023FhsZtaC1GP+qp9Lu5FuyYYbppcwdurUibfffnt5+tChQznmmGM4+OCDgcpdVgOrdIX9ve99b422pRKXCMzMWvDss8/y4IMPAnDDDTcwYMCAlcZ3796dHj16LK//v/baa1vtJfXSSy9l0aJFnHvuucvTDj30UK6++moWL06ven/++eeXv+zmPe95DyeddBLnnHMOjzzySHtuHuASgZl1IK3d7lkNu+yyC6NHj+a0006jT58+fOlLX+LnP//5StOMHj2aoUOHsmTJEnbYYQeuueaaFpd5wQUX0LlzZ/r37w+k0sHQoUPLdln9xBNPrNIVdntzN9T15m6ozSpyN9RttzbdULtEUBQOiGZWgdsIzMwKrmqBQFIXSRMkTZU0U9J5OX17SQ9JelzSjZI2qFYezKzj6wjV1/W2tvuomiWCfwMfjYjdgf7AYZL2BUYAF0dEH+BV4AtVzIOZdWBdunThlVdecTBoQUTwyiuv0KVLlzVeRjVfXh/A4vyxc/4L4KPAZ3P6aGA40P7N4GbW4W2zzTbMnTuXl19+ud5ZWad16dKFbbbZZo3nr2pjsaROwCTgv4BLgSeBhRHR9FTFXGDrCvMOAYYA9OrVq5rZNLN1VOfOndl+++3rnY13vao2FkfEsojoD2wD7AOUuw+sbJkvIkZGRGNENDY0NFQzm2ZmhVaTu4YiYiEwBtgX2FRSU0lkG+CFWuTBzMzKq+ZdQw2SNs3DGwEHA7OA+4Fj82SDgD9UKw9mZta6arYRbAmMzu0E6wE3RcQdkh4Ffivph8Bk4Koq5sHMzFpRzbuGpgF7lEl/itReYGZm6wB3MWHFsy53t+GuNqwO3MWEmVnBORCYmRWcA4GZWcE5EJiZFZwDgZlZwTkQmJkVnAOBmVnBORCYmRWcA4GZWcE5EJiZFZwDgZlZwTkQmJkVnAOBmVnBORCYmRWcA4GZWcE5EJiZFZwDgZlZwVXz5fXbSrpf0ixJMyWdmdOHS3pe0pT89/Fq5cHMzFpXzVdVvg18LSIekdQNmCTp3jzu4oi4oIrrNjOzNqrmy+vnAfPy8CJJs4Ctq7U+MzNbMzVpI5DUG9gDeCgnfVXSNElXS+pRizyYmVl5VQ8EkroCtwBnRcTrwGXAjkB/UonhwgrzDZE0UdLEl19+udrZNDMrrKoGAkmdSUHguoi4FSAiXoyIZRHxDnAFsE+5eSNiZEQ0RkRjQ0NDNbNpZlZo1bxrSMBVwKyIuKgkfcuSyY4GZlQrD2Zm1rpq3jW0P/A5YLqkKTntW8BnJPUHApgDnFbFPJiZWSuqedfQeEBlRt1ZrXWamdnqq2aJYJ3wwItj6p2FFh24c71zYGZF5y4mzMwKzoHAzKzgHAjMzArOgcDMrODe9Y3FZlbB7HI39a0jdo5656BQXCIwMys4BwIzs4JrUyCQdKakTZRcJekRSYdUO3NmZlZ9bS0RfD73HHoI0ACcAvy4arkyM7OaaWsgaGpV+jhwTURMpXz3EWZm1sG0NRBMknQPKRDcnV89+U71smVmZrXS1ttHv0B6kcxTEbFE0uak6iEzM+vgWgwEkvZslrRDes2AmZm9W7RWIij7GsksgI+2Y17MzKwOWgwEEfGRWmXEzMzqo81dTEjqC+wKdGlKi4hfVyNTZmZWO20KBJK+DwwkBYI7gcOB8YADgZlZB9fW20ePBQ4C5kfEKcDuwIZVy5WZmdVMWwPBmxHxDvC2pE2Al4AdWppB0raS7pc0S9JMSWfm9M0k3Svp8fy/x9ptgpmZrY22BoKJkjYFrgAmAY8AE1qZ523gaxGxC7Av8BVJuwLnAvdFRB/gvvzZzMzqpE1tBBHx5Tx4uaS7gE0iYlor88wD5uXhRZJmAVsDR5HaGwBGA2OAYaudczMzaxer+0DZSuMi4pG2rERSb2AP4CFgixwkiIh5kt5bYZ4hwBCAXr16tWU1Zmarb11+QQ/U5CU9bX2grAvQCDR1Nrcb6aQ+oLUVSOoK3AKcFRGvt/XJ5IgYCYwEaGxs9OuKzMyqpMU2goj4SH6o7Blgz4hojIi9SFf3T7S2cEmdSUHguoi4NSe/KGnLPH5LUsOzmZnVSVsbi3eOiOlNHyJiBqkTuoqULv2vAmZFxEUlo/4IDMrDg4A/tD27ZmbW3tr6ZPEsSVcCvyH1MXQSMKuVefYHPgdMlzQlp32L9EKbmyR9AXgWOG61c21mZu2mrYHgFOBLwJn581jgspZmiIjxVH55zUFtXK+ZmVVZW28fXSrpcuDOiHisynkyM7MaauvL6z8JTAHuyp/7S/pjNTNmZma10dbG4u8D+wALASJiCtC7SnkyM7MaamsgeDsiXqtqTszMrC7a2lg8Q9JngU6S+gBnAH+vXrbMzKxW2hoITge+DfwbuAG4Gzi/Wpkyq6YHXhxT7yxUdODO9c6BFVFb7xpaQgoE365udszMrNZa63SuxTuDIuKT7ZsdMzOrtdZKBPsBz5Gqgx6i8gNiZmbWQbUWCN4HfAz4DPBZ4E/ADRExs9oZMzOz2mgxEETEMtJDZHdJ2pAUEMZI+kFE/LwWGbT2sS43kIIbSc3qqdXG4hwAjiAFgd7Az4BbW5rHzMw6jtYai0cDfYE/A+fl7qfNzOxdpLUSweeAN4CdgDNK3i4mICJikyrmzczMaqC1NoK2dkFhZmYdlE/0ZmYF50BgZlZwDgRmZgVXtUAg6WpJL0maUZI2XNLzkqbkv49Xa/1mZtY21SwRjAIOK5N+cUT0z393VnH9ZmbWBlULBBExFvhXtZZvZmbtox5tBF+VNC1XHfWoNJGkIZImSpr48ssv1zJ/ZmaFUutAcBmwI9AfmAdcWGnCiBgZEY0R0djQ0FCr/JmZFU5NA0FEvBgRyyLiHeAKYJ9art/MzFZV00AgacuSj0cD7rvIzKzO2vrO4tUm6QZgINBT0lzg+8BASf2BAOYAp1Vr/WZm1jZVCwQR8ZkyyVdVa31mZrZmqhYIzGzdti6/rMgvKqotdzFhZlZwDgRmZgXnQGBmVnAOBGZmBedAYGZWcA4EZmYF50BgZlZwDgRmZgXnQGBmVnB+stjMCm1dfsIaavOUtUsEZmYF50BgZlZwDgRmZgXnQGBmVnAOBGZmBedAYGZWcA4EZmYFV7VAIOlqSS9JmlGStpmkeyU9nv/3qNb6zcysbapZIhgFHNYs7VzgvojoA9yXP5uZWR1VLRBExFjgX82SjwJG5+HRwKeqtX4zM2ubWncxsUVEzAOIiHmS3ltpQklDgCEAvXr1WuMVdrv/7DWetyYOnFTvHBTOOn1M+HiwOlhnG4sjYmRENEZEY0NDQ72zY2b2rlXrQPCipC0B8v+Xarx+MzNrptaB4I/AoDw8CPhDjddvZmbNVPP20RuAB4H3S5or6QvAj4GPSXoc+Fj+bGZmdVS1xuKI+EyFUQdVa51mZrb61tnGYjMzqw0HAjOzgnMgMDMrOAcCM7OCcyAwMys4BwIzs4JzIDAzKzgHAjOzgnMgMDMrOAcCM7OCcyAwMyu4Wr+YxupknX4ZC/iFLGZ15BKBmVnBORCYmRWcA4GZWcE5EJiZFZwbi80Kap2+gaCGNw+s0/sBarIvXCIwMyu4upQIJM0BFgHLgLcjorEe+TAzs/pWDX0kIhbUcf1mZoarhszMCq9egSCAeyRNkjSkTnkwMzPqVzW0f0S8IOm9wL2SZkfE2NIJcoAYAtCrV6965NHMrBDqUiKIiBfy/5eA3wP7lJlmZEQ0RkRjQ0NDrbNoZlYYNQ8EkjaW1K1pGDgEmFHrfJiZWVKPqqEtgN9Lalr/9RFxVx3yYWZm1CEQRMRTwO61Xq+ZmZXn20fNzArOgcDMrOAcCMzMCs6BwMys4BwIzMwKzoHAzKzgHAjMzArOgcDMrOAcCMzMCs6BwMys4BwIzMwKzoHAzKzgHAjMzArOgcDMrOAcCMzMCs6BwMys4BwIzMwKzoHAzKzgHAjMzAquLoFA0mGSHpP0hKRz65EHMzNLah4IJHUCLgUOB3YFPiNp11rnw8zMknqUCPYBnoiIpyLiP8BvgaPqkA8zMwMUEbVdoXQscFhEnJo/fw74YER8tdl0Q4Ah+eP7gcdqmtHKegIL6p2JdYD3Q+L9sIL3RbIu7YftIqKhtYnWr0VOmlGZtFWiUUSMBEZWPzurR9LEiGisdz7qzfsh8X5Ywfsi6Yj7oR5VQ3OBbUs+bwO8UId8mJkZ9QkEDwN9JG0vaQPgBOCPdciHmZlRh6qhiHhb0leBu4FOwNURMbPW+VgL61x1VZ14PyTeDyt4XyQdbj/UvLHYzMzWLX6y2Mys4BwIzMwKrjCBQFJIurDk8zmShtcxSzUjaQtJ10t6StIkSQ9KOrre+ao3Se+T9FtJT0p6VNKdknaq4voWV2m5vSXNaJY2XNI5rczXKOlneXigpA+twbrnSOpZJv3zkqZLmiZphqSjcvpgSVu1Ybltmq6VZaz2b775fpA0Kj/7tDb5KLuP1nBZVTmGChMIgH8Dx6zpFyKpHs9crDVJAm4DxkbEDhGxF+lOrW3aOH+nauavXvJ++T0wJiJ2jIhdgW8BW9Q3Z7UTERMj4oz8cSCw2oGgHEnbAN8GBkTEbsC+wLQ8ejDQlhN8W6dryZr85gfSfvtBkjrEObZDZLKdvE1qzf9/zUdI2k7Sffnq5T5JvXL6KEkXSbofGJGvcDbNX/Arkk7O010r6eB8ZTZO0iP570Ml448qWd91kj5Zk62GjwL/iYjLmxIi4pmI+LmkTpJ+IunhvO2n5fwNlHS/pOuB6Xm7Zku6Ml/dXZe392+SHpe0T55vH0l/lzQ5/39/Th8s6VZJd+Xp/y+nf0HSxSX75YuSLqrRfvkI8Faz/TKrFl2EAAAJl0lEQVQFmJyPgUfy9910Jdtb0ixJV0iaKekeSRuV5PthSVMl3SLpPTl9+1z6eljS+SXb2bXcOqpF0hhJIyRNkPRPSR/O6QMl3SGpNzAU+H+Spkj6sKSGvC0P57/98zyb522fLOlXlH9A9L3AImAxQEQsjoin85V1I3BdXs9Gkr6Xlz9D0sj82yo33V6SHlAq0d4tacucnzOUSnPTJP22WT5a+s2vsn3l9kOe/IB8PD+lktKBpK+X/HbOy2lNx8kvgUdY+ZkpJN2Wt2GmUu8JTemLJf1PPob+IWmLnF7pGNpS0ticzxkleV0zEVGIP9JBuQkwB+gOnAMMz+NuBwbl4c8Dt+XhUcAdQKf8+XLgCKAv6XmIK3L640BX4D1Al5zWB5iYhw8sWWZ34Glg/Rpt9xnAxRXGDQG+k4c3BCYC25Ouit4Ats/jepN+VP1IFw+TgKtJJ4GjSrZtk6btAg4GbsnDg4Gn8rZ3AZ4h/UA2Bp4EOufp/g70q+d+Id1SvUke7gk8kbezaR/0z+NuAk7Kw5uXzP9D4PQ8/Efg5Dz8FWBxS+tYi23pDcxoljYcOCcPjwEuzMMfB/6ShwcCdzSfPn++nnRFD9ALmJWHfwZ8Lw8fQeoVoGezdXci3R7+LHAN8ImScWOAxpLPm5UMX9s0bel0QOd8bDTkz8eTbjuH9DDqhnl409X4zVfavub7YRTwO9JxvyupnzSAQ0hBRnncHcAB+bt4B9i3ZBlzmvZR0/YCGwEzyMdO3o9N2/5/rPhdVjqGvgZ8u2R/d1ub30OHrO5YUxHxuqRfk04Cb5aM2g84Jg9fS/oimvwuIpbl4XGkL/sZ4DJgiKStgX9FxGJJ3YFfSOoPLAN2yut9QNKlkt6b13NLRLxdna1smaRLgQHAf/J27FZyldOdFMD+A0yIiKdLZn06IqbnZcwE7ouIkDSddPA3zT9aUh/Sgd25ZP77IuK1PP+jpD5QnpP0V+BISbNIAWF6+2/1ahHwv5IOIP2gt2ZFddHTkUoNkIJh7zzcV9IPgU1JFwR35/T9gU/n4WuBEa2sY/4a5rnSPeCl6beWyXdLDgZ2lZZf8G8iqRvp+D8GICL+JOnVVVYasUzSYcDewEHAxZL2iojhZdbzEUnfIF1EbQbMJF2YlXo/6eLr3pyfTsC8PG4aqeRwG6kKtHleKv3mK21fObdFxDvAo01X6qRAcAgwOX/uSvrtPAs8ExH/qLCsM7SifW7bPM8rpN/cHTl9EvCxPFzpGHoYuFpS55y/puNyjRQqEGSXkIps17QwTekP6I2S4bGkqNyLVAd6NHAsKUBAKoK+COxOukpYWjLvtcCJpPr5z6959lfbTFYcSETEV5TqTCeSDtrTI+Lu0hkkDWTl7YZU39rknZLP77DiODofuD8ijs7F7DEV5l9WMs+VpLr52bT8nbS3maTvrrkTgQZgr4h4S9IcUikGVt2GjfLwKOBTETFV0mDSlXaTcifpltaxJl4BejRL24xU8mzSlPfSfd+S9YD9IqL05Ek+cbb68FGkS9UJwARJ95K+2+HNltUF+CXpyv85pYbccvtBwMyI2K/MuCNIwemTwHclfaDMRVa533xL29dc6feukv8/iohfNZu/N6v+dprGDSQFoP0iYomkMazY3rfyPoNVv6NyfbGNzRcSRwDXSvpJRPy63HrbokhtBABExL9IxfovlCT/nXSChvQjHV9h3udIRfk+EfFUnu4cVgSC7sC8fPXwOdKVS5NRwFl5ObV8kvqvQBdJXypJe0/+fzfwpXxVgaSdJG28FuvqDjyfhwe3ZYaIeIh0ZfRZ4Ia1WPfq+iuwoaQvNiVI2hvYDngpn6A/kj+3phswL+/HE0vS/8bKx1WT7muwjooiYnFe/0F5OzYDDqPCcVzBItJ2NLkHWN4jcC7lQroYOjGnHc6qAQhJW0nasySpP6n02Xw9TSfBBZK6snJgLp3uMaBB0n55+Z0lfUCpIXbbiLgf+AYrSmQrqfCbr7R9zfdDJXcDn8/5RtLWucTfku7AqzkI7ExqRG9N2WNIUtNxegVwFbBnmXnbrHCBILuQdEJvcgZwiqRppBP4mS3M+xDwzzw8jlSsb/rB/RIYJOkfpGqh5VcGEfEiMIvaXvU2XZl9CjhQ0tOSJgCjgWGkq/FHgUeUbj/8FWtXSvw/4EeS/sbKQbA1NwF/i4hVqhmqJe+Xo4GPKd0+OpN0xXon0ChpIumHN7sNi/su6bi4t9n0ZwJfkfQw6STQ5Lo1WEdrTga+I2kKKcidFxFPrsb8twNHlzSSnpHzOC1X5Q3N051Hajx9hFQ18myZZXUGLlC6wWAKqU6/6Tc1Crg8p/8buAKYTqrWebhkGaXTdSIFiRGSpgJTSHf2dAJ+k6snJ5PafBZW2L5yv/ly29d8P5QVEfeQ2hkezOu/mdYDyF3A+vk8cz5QqfqoVKVjaCAwRdJkUon/p21YVkXuYqJGlO4kmQ7s2VRXbomkO0g/4vvqnRezIipqiaCmJB1Muur7uYPACkq34v4TeNNBwKx+XCIwMys4lwjMzArOgcDMrOAcCMzMCs6BwApBVe5pVK303inpk5LOba/1mbUnNxbbu57S46J/B0ZH7mQuP0DULSLGtThz29cxnNQPzAVlxq1fry5FzNrCgcDe9SR9lNTZ2AHN0kV6CO5w0mP8P4yIG3NXAOdExJF5ul+QOhAclbuDGA18gvTg1HGkrkT+Qeoa4GXgdNJTrP8C9iB1bzCd1JXCVyU1kDow7JWzclZE/E3Sgax4MCiAAyJiUXvvD7PmitjXkBVPX1JHXs0dQ+r+YHfSU6cPSxrbhuUtiIg9JX2ZFDBOlXQ5JSUCSV8gPV1+cO6EbXDJ/D8lPUA3XqnL87uBXUjdlXwlB4WurNxXlVnVOBBYkQ0Absi9y74o6QFSj5mvtzJfaU+ex7QwXWnPtaUq9Xz5N+AiSdcBt0bE3DZuh9lacWOxFcFMYK8y6WW7miS9d6D0t9G8R8y29uRZthdKVvR82T//bR0RiyLix8CppF5N/5E7JjOrOgcCK4JKPY2+Chyv9Ka2BlJ3xhNIPWXuKmlDpXdMHNSGdbS110qo0POlpB0jYnpEjCB1E+5AYDXhqiF718sv0DkauCTfwrmU9Naos0jdFk8lNc5+IyLmA0i6ifTSk8dZ8fKRltwO3Kz02snTW5n2DODS3Avl+qSunYcCZ+VuqZeReoX98+psp9ma8l1DZmYF56ohM7OCcyAwMys4BwIzs4JzIDAzKzgHAjOzgnMgMDMrOAcCM7OC+//GxXGDOM9lkwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "countries = ['Norway', 'Germany', 'Canada', 'United States', 'Netherlands']\n",
+    "bronzes = np.array([10,7,10,6,6])\n",
+    "silvers = np.array([14,10,8,8,6])\n",
+    "golds = np.array([14,14,11,9,8])\n",
+    "ind = [country for country in countries]\n",
+    " \n",
+    "plt.bar(ind, golds, width=0.6, label='golds', color='gold', bottom=silvers+bronzes)\n",
+    "plt.bar(ind, silvers, width=0.6, label='silvers', color='silver', bottom=bronzes)\n",
+    "plt.bar(ind, bronzes, width=0.6, label='bronzes', color='#CD7F32')\n",
+    " \n",
+    "plt.xticks(ind, countries)\n",
+    "plt.ylabel(\"Medals\")\n",
+    "plt.xlabel(\"Countries\")\n",
+    "plt.legend(loc=\"upper right\")\n",
+    "plt.title(\"2018 Winter Olympics Top Scorers\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Testing"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 83,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "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>ParticipantLine</th>\n",
+       "      <th>Source</th>\n",
+       "      <th>EatingOccasion</th>\n",
+       "      <th>AtHome</th>\n",
+       "      <th>Calories</th>\n",
+       "      <th>FoodCode</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>73570.015.0</td>\n",
+       "      <td>Store</td>\n",
+       "      <td>Dinner</td>\n",
+       "      <td>True</td>\n",
+       "      <td>428</td>\n",
+       "      <td>lemon (not cream or meringue)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>73598.015.0</td>\n",
+       "      <td>Restaurant with Waiter-Waitress</td>\n",
+       "      <td>Dinner</td>\n",
+       "      <td>False</td>\n",
+       "      <td>726</td>\n",
+       "      <td>pumpkin</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>73633.08.0</td>\n",
+       "      <td>Store</td>\n",
+       "      <td>Lunch</td>\n",
+       "      <td>False</td>\n",
+       "      <td>309</td>\n",
+       "      <td>pumpkin</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>73653.018.0</td>\n",
+       "      <td>From Somewhere Else-Gift</td>\n",
+       "      <td>Snack</td>\n",
+       "      <td>True</td>\n",
+       "      <td>123</td>\n",
+       "      <td>lemon (not cream or meringue)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>73726.017.0</td>\n",
+       "      <td>Bake Sale</td>\n",
+       "      <td>Snack</td>\n",
+       "      <td>True</td>\n",
+       "      <td>17</td>\n",
+       "      <td>blueberry</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
       "text/plain": [
-       "<Figure size 432x216 with 2 Axes>"
+       "  ParticipantLine                           Source EatingOccasion  AtHome  \\\n",
+       "0     73570.015.0                            Store         Dinner    True   \n",
+       "1     73598.015.0  Restaurant with Waiter-Waitress         Dinner   False   \n",
+       "2      73633.08.0                            Store          Lunch   False   \n",
+       "3     73653.018.0         From Somewhere Else-Gift          Snack    True   \n",
+       "4     73726.017.0                        Bake Sale          Snack    True   \n",
+       "\n",
+       "   Calories                       FoodCode  \n",
+       "0       428  lemon (not cream or meringue)  \n",
+       "1       726                        pumpkin  \n",
+       "2       309                        pumpkin  \n",
+       "3       123  lemon (not cream or meringue)  \n",
+       "4        17                      blueberry  "
       ]
      },
+     "execution_count": 83,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "plot = df.plot.pie(subplots=True, figsize=(6,3))"
+    "df_pies = pd.read_csv('toy_data_pies.csv')\n",
+    "df_pies.head()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 84,
    "metadata": {},
    "outputs": [],
    "source": [
-    "fig = plot[0].get_figure()"
+    "df_pie_sources = df_pies.groupby('Source').agg('count')\n",
+    "df_pie_flavors = df_pies.groupby('FoodCode').agg('count')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 85,
+   "metadata": {},
+   "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>ParticipantLine</th>\n",
+       "      <th>Source</th>\n",
+       "      <th>EatingOccasion</th>\n",
+       "      <th>AtHome</th>\n",
+       "      <th>Calories</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>FoodCode</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>blueberry</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>lemon (not cream or meringue)</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>pumpkin</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                               ParticipantLine  Source  EatingOccasion  \\\n",
+       "FoodCode                                                                 \n",
+       "blueberry                                    1       1               1   \n",
+       "lemon (not cream or meringue)                2       2               2   \n",
+       "pumpkin                                      2       2               2   \n",
+       "\n",
+       "                               AtHome  Calories  \n",
+       "FoodCode                                         \n",
+       "blueberry                           1         1  \n",
+       "lemon (not cream or meringue)       2         2  \n",
+       "pumpkin                             2         2  "
+      ]
+     },
+     "execution_count": 85,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_pie_flavors.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "source_labels = df_pie_sources.FoodCode.sort_values().index\n",
+    "source_counts = df_pie_sources.FoodCode.sort_values()\n",
+    "\n",
+    "flavor_labels = df_pie_flavors.Source.sort_values().index\n",
+    "flavor_counts = df_pie_flavors.Source.sort_values()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Make square figures and axes\n",
+    "plt.figure(1, figsize=(20,10))\n",
+    "the_grid = GridSpec(2, 2)\n",
+    "\n",
+    "\n",
+    "cmap = plt.get_cmap('Spectral')\n",
+    "colors = [cmap(i) for i in np.linspace(0, 1, 8)]\n",
+    "\n",
+    "\n",
+    "plt.subplot(the_grid[0, 1], aspect=1, title='Source of Pies')\n",
+    "\n",
+    "source_pie = plt.pie(source_counts, labels=source_labels, autopct='%1.1f%%', shadow=True, colors=colors)\n",
+    "\n",
+    "\n",
+    "plt.subplot(the_grid[0, 0], aspect=1, title='Selected Flavors of Pies')\n",
+    "\n",
+    "flavor_pie = plt.pie(flavor_counts,labels=flavor_labels, autopct='%.0f%%', shadow=True, colors=colors)\n",
+    "\n",
+    "plt.suptitle('Pie Consumption Patterns in the United States', fontsize=16)\n",
+    "\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
    "metadata": {},
    "outputs": [],
    "source": [
-    "fig.savefig('test.pdf')"
+    "#importing critical items\n",
+    "from IPython.core.display import HTML, SVG\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "#import xport \n",
+    "import IPython \n",
+    "from ipywidgets import Layout\n",
+    "from ipywidgets import widgets\n",
+    "from IPython.display import display\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.plotly.v1+json": {
+       "config": {
+        "linkText": "Export to plot.ly",
+        "plotlyServerURL": "https://plot.ly",
+        "showLink": false
+       },
+       "data": [
+        {
+         "domain": {
+          "x": [
+           0,
+           0.4
+          ],
+          "y": [
+           0,
+           1
+          ]
+         },
+         "labels": [
+          "Bake Sale",
+          "From Somewhere Else-Gift",
+          "Restaurant with Waiter-Waitress",
+          "Store"
+         ],
+         "marker": {
+          "colors": [
+           [
+            0.6196078431372549,
+            0.00392156862745098,
+            0.25882352941176473,
+            1
+           ],
+           [
+            0.8853517877739331,
+            0.3190311418685121,
+            0.29042675893886966,
+            1
+           ],
+           [
+            0.9873125720876587,
+            0.6473663975394078,
+            0.3642445213379469,
+            1
+           ],
+           [
+            0.9971549404075356,
+            0.9118031526336025,
+            0.6010765090349866,
+            1
+           ],
+           [
+            0.9288735101883892,
+            0.9715494040753557,
+            0.6380622837370243,
+            1
+           ],
+           [
+            0.6334486735870821,
+            0.8521337946943485,
+            0.6436755094194541,
+            1
+           ],
+           [
+            0.2800461361014994,
+            0.6269896193771626,
+            0.7024221453287197,
+            1
+           ],
+           [
+            0.3686274509803922,
+            0.30980392156862746,
+            0.6352941176470588,
+            1
+           ]
+          ],
+          "line": {
+           "color": "#FFF",
+           "width": 2
+          }
+         },
+         "name": "Sources of Pie",
+         "showlegend": false,
+         "textinfo": "label+percent",
+         "type": "pie",
+         "uid": "3e9e11c0-ca96-4e0f-800b-6b1bb12d4d86",
+         "values": [
+          1,
+          1,
+          1,
+          2
+         ]
+        },
+        {
+         "domain": {
+          "x": [
+           0.6,
+           1
+          ],
+          "y": [
+           0,
+           1
+          ]
+         },
+         "labels": [
+          "blueberry",
+          "lemon (not cream or meringue)",
+          "pumpkin"
+         ],
+         "marker": {
+          "colors": [
+           [
+            0.6196078431372549,
+            0.00392156862745098,
+            0.25882352941176473,
+            1
+           ],
+           [
+            0.8853517877739331,
+            0.3190311418685121,
+            0.29042675893886966,
+            1
+           ],
+           [
+            0.9873125720876587,
+            0.6473663975394078,
+            0.3642445213379469,
+            1
+           ],
+           [
+            0.9971549404075356,
+            0.9118031526336025,
+            0.6010765090349866,
+            1
+           ],
+           [
+            0.9288735101883892,
+            0.9715494040753557,
+            0.6380622837370243,
+            1
+           ],
+           [
+            0.6334486735870821,
+            0.8521337946943485,
+            0.6436755094194541,
+            1
+           ],
+           [
+            0.2800461361014994,
+            0.6269896193771626,
+            0.7024221453287197,
+            1
+           ],
+           [
+            0.3686274509803922,
+            0.30980392156862746,
+            0.6352941176470588,
+            1
+           ]
+          ],
+          "line": {
+           "color": "#FFF",
+           "width": 2
+          }
+         },
+         "name": "Flavors of Pie",
+         "showlegend": false,
+         "textinfo": "label+percent",
+         "type": "pie",
+         "uid": "a31ce595-4599-4049-90d5-f835a7a91734",
+         "values": [
+          1,
+          2,
+          2
+         ]
+        }
+       ],
+       "layout": {
+        "autosize": false,
+        "height": 600,
+        "title": {
+         "text": "Pie Consumption Patterns in the United States"
+        },
+        "width": 1000
+       }
+      }
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sources_pie = go.Pie(labels=source_counts.index, values=source_counts, marker=dict(colors=colors\n",
+    "                                                            , line=dict(color='#FFF', width=2)), \n",
+    "                                                            domain={'x': [0.0, .4], 'y': [0.0, 1]}\n",
+    "                                                            , showlegend=False, name='Sources of Pie', textinfo='label+percent')\n",
+    "\n",
+    "flavor_pie = go.Pie(labels=flavor_counts.index, values=flavor_counts, marker=dict(colors=colors\n",
+    "                                                            , line=dict(color='#FFF', width=2)), \n",
+    "                                                            domain={'x': [.6, 1], 'y': [0.0, 1]}\n",
+    "                                                            , showlegend=False, name='Flavors of Pie', textinfo='label+percent')\n",
+    "\n",
+    "layout = go.Layout(height = 600,\n",
+    "                   width = 1000,\n",
+    "                   autosize = False,\n",
+    "                   title = 'Pie Consumption Patterns in the United States')\n",
+    "fig = go.Figure(data = [sources_pie,flavor_pie ], layout = layout)\n",
+    "\n",
+    "\n",
+    "py.iplot(fig, filename='basic_pie_chart')\n",
+    "\n",
+    "#https://stackoverflow.com/questions/39629735/how-to-plot-pie-charts-as-subplots-with-custom-size-with-plotly-in-python\n"
    ]
   },
   {
@@ -332,7 +1423,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/megapixels/notebooks/msc/test.pdf b/megapixels/notebooks/msc/test.pdf
deleted file mode 100644
index ddebea79..00000000
--- a/megapixels/notebooks/msc/test.pdf
+++ /dev/null
diff --git a/megapixels/notebooks/msc/test_plotly.ipynb b/megapixels/notebooks/msc/test_plotly.ipynb
new file mode 100644
index 00000000..b12cb142
--- /dev/null
+++ b/megapixels/notebooks/msc/test_plotly.ipynb
@@ -0,0 +1,1185 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Test Plotly"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Demo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from plotly.offline import iplot, init_notebook_mode\n",
+    "import plotly.graph_objs as go\n",
+    "import plotly.io as pio\n",
+    "\n",
+    "import os\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "        <script type=\"text/javascript\">\n",
+       "        window.PlotlyConfig = {MathJaxConfig: 'local'};\n",
+       "        if (window.MathJax) {MathJax.Hub.Config({SVG: {font: \"STIX-Web\"}});}\n",
+       "        if (typeof require !== 'undefined') {\n",
+       "        require.undef(\"plotly\");\n",
+       "        requirejs.config({\n",
+       "            paths: {\n",
+       "                'plotly': ['https://cdn.plot.ly/plotly-latest.min']\n",
+       "            }\n",
+       "        });\n",
+       "        require(['plotly'], function(Plotly) {\n",
+       "            window._Plotly = Plotly;\n",
+       "        });\n",
+       "        }\n",
+       "        </script>\n",
+       "        "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "init_notebook_mode(connected=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.plotly.v1+json": {
+       "config": {
+        "linkText": "Export to plot.ly",
+        "plotlyServerURL": "https://plot.ly",
+        "showLink": false
+       },
+       "data": [
+        {
+         "marker": {
+          "color": [
+           0.6293828317071586,
+           0.10871757916572877,
+           0.68311690821298,
+           0.9868548358867593,
+           0.9356744842281925,
+           0.9790537247648904,
+           0.3258180192640453,
+           0.12391204805045775,
+           0.8350240537325824,
+           0.5369662542168598,
+           0.5431266213529744,
+           0.629752855978358,
+           0.3057523930457775,
+           0.4585071756146928,
+           0.4311862805765245,
+           0.1639356212211679,
+           0.446932803456484,
+           0.8627171610367412,
+           0.31518503849660306,
+           0.5828651428770285,
+           0.16001292379812304,
+           0.6404620711754383,
+           0.04741420092894122,
+           0.7548488102472397,
+           0.7353917005000188,
+           0.4365025633180786,
+           0.7839680628427522,
+           0.6805068448092968,
+           0.8786650700491208,
+           0.06815397986979765,
+           0.13535861871332966,
+           0.9405516184122458,
+           0.5437457047334291,
+           0.5903552132029327,
+           0.08082046350853744,
+           0.7150168555710725,
+           0.986232841445708,
+           0.22817216482783065,
+           0.1076811040405542,
+           0.03804473076715431,
+           0.7114105985548173,
+           0.2836183570437315,
+           0.48931430431938294,
+           0.8365056267736387,
+           0.6336230935293655,
+           0.42541724288711247,
+           0.8350608664218104,
+           0.3437171780503755,
+           0.14541534768179498,
+           0.8787162108826218,
+           0.025388796870841612,
+           0.8111658156200445,
+           0.018717505457894856,
+           0.09869141356496391,
+           0.3921323585962584,
+           0.7132961159828939,
+           0.7318985696655684,
+           0.7869866024773561,
+           0.7814016135827416,
+           0.8919231750596648,
+           0.28134414473838654,
+           0.7237985608111946,
+           0.3618380000508312,
+           0.21075045827522243,
+           0.9628478800749577,
+           0.2900164358629147,
+           0.4719721918840184,
+           0.730285844834199,
+           0.3942587955050557,
+           0.32586005977792476,
+           0.972528200795633,
+           0.28025465435145835,
+           0.627325945653425,
+           0.015008746790136196,
+           0.14237643495137675,
+           0.050423801719477024,
+           0.7644515022481213,
+           0.6091667909932688,
+           0.3532180131753364,
+           0.8947334942638786,
+           0.17387126634230343,
+           0.5365981953906036,
+           0.6889435903426656,
+           0.6610488816804185,
+           0.9749955651002764,
+           0.9153566282398699,
+           0.5269574781630024,
+           0.8778260007512473,
+           0.38075994993668905,
+           0.5647499579658595,
+           0.418283999093396,
+           0.3579478941888037,
+           0.3683880455143794,
+           0.5201946750419136,
+           0.2613710707351792,
+           0.7122574990933892,
+           0.7298329578282315,
+           0.6379701686824202,
+           0.7955868217388932,
+           0.8163554813378757
+          ],
+          "colorscale": "Viridis",
+          "opacity": 0.6,
+          "size": [
+           24.74150982375718,
+           9.280421122552907,
+           26.816266625639166,
+           21.865635610789628,
+           9.896893758182372,
+           16.35959442725846,
+           8.829943498152526,
+           0.9561123550614292,
+           28.59004398713737,
+           27.998199247555412,
+           14.356889793713542,
+           12.510426498329961,
+           27.948307057731554,
+           11.443238859469622,
+           24.66171987028657,
+           22.666387218267374,
+           23.462946003027827,
+           25.451904787389697,
+           20.081426958372838,
+           27.524084273181675,
+           25.744255659997357,
+           21.31770690742058,
+           13.630541365724554,
+           27.44821596665852,
+           14.931786869286563,
+           2.2744366430542327,
+           18.763621500539017,
+           3.1819261762898976,
+           4.610566148833989,
+           4.149555285846313,
+           16.482766212514964,
+           22.717148416863015,
+           24.987016922679274,
+           12.528071041169763,
+           28.274788722893614,
+           11.081662434254852,
+           28.44502729834879,
+           19.51774621900454,
+           19.644621049552086,
+           18.770275237826883,
+           5.079208459129881,
+           26.875559773109472,
+           14.291584841429627,
+           13.314356351751613,
+           1.5983548469032782,
+           14.16205944182201,
+           8.747779265393547,
+           28.599356582105003,
+           20.770844383653493,
+           27.401053695841284,
+           7.4552367973015485,
+           18.184112831044487,
+           21.200618948493563,
+           19.54919647302541,
+           26.410627753123226,
+           0.6118250572534734,
+           5.081967556847226,
+           3.3611994256358946,
+           3.807649332865587,
+           19.531242703961418,
+           28.408475476902236,
+           19.03144105102476,
+           27.392315621828345,
+           20.95163521304236,
+           12.649562527197713,
+           20.94051863733014,
+           18.551288851142925,
+           24.26238241654025,
+           1.067395868930422,
+           18.027988539967136,
+           17.577785181369727,
+           12.21459774932675,
+           21.54905183176187,
+           14.025431326739437,
+           7.948668233800754,
+           14.247241180900321,
+           19.370209208556346,
+           20.08639665675465,
+           0.3473738459998921,
+           18.552605009050048,
+           5.795867754824368,
+           29.377512330217755,
+           17.0977961534976,
+           19.307556831117715,
+           24.568224556315844,
+           4.464096834419008,
+           21.71654353183601,
+           17.986786244282424,
+           9.036785758979,
+           11.467541197408401,
+           15.506290662937483,
+           5.110861130635449,
+           20.044649489346963,
+           9.172913083241099,
+           17.742661485893773,
+           16.10358725512652,
+           7.483809983245088,
+           4.193841641578638,
+           11.161330279964542,
+           10.132821938779692
+          ]
+         },
+         "mode": "markers",
+         "type": "scatter",
+         "uid": "b0b4b3e6-d74e-4596-b1f6-866494f66ac5",
+         "x": [
+          0.9107379187961171,
+          0.13830019680520433,
+          0.821736889714595,
+          0.3921878219656484,
+          0.8346405307202264,
+          0.9553493281777037,
+          0.5917624120848792,
+          0.7696872135096617,
+          0.2764705214251728,
+          0.10250747898818846,
+          0.5608219612948858,
+          0.009301052946640631,
+          0.2888044375300247,
+          0.08732715334107588,
+          0.9218542459508559,
+          0.7490711090144354,
+          0.12087960522666752,
+          0.7255816390705573,
+          0.40455316553437204,
+          0.1998318088429799,
+          0.8563460736962455,
+          0.24026621118853997,
+          0.6779207634000527,
+          0.6237494872918712,
+          0.5690422866216804,
+          0.14672189332739916,
+          0.8283514372957037,
+          0.3568733435451711,
+          0.7623487473898288,
+          0.07834607319110698,
+          0.6657053354636957,
+          0.8182792779517071,
+          0.5514257159258872,
+          0.11066849699793302,
+          0.5473351302168906,
+          0.8948668458488195,
+          0.19414716791933673,
+          0.30323631629795966,
+          0.04384302355313652,
+          0.9303407902908601,
+          0.2522389366153581,
+          0.5728123808665866,
+          0.45937696306834785,
+          0.2757418052570424,
+          0.2161959559781027,
+          0.7747543804280251,
+          0.19915143297924554,
+          0.11283247029514198,
+          0.7762917205025742,
+          0.3162146200663585,
+          0.4010503767685871,
+          0.9355531154171876,
+          0.09986423597795058,
+          0.4205367725458332,
+          0.8866456464818482,
+          0.6198436181367285,
+          0.5728557391504273,
+          0.13642060186522464,
+          0.19927373777752855,
+          0.05529450095070232,
+          0.5680820939833129,
+          0.5540148486363582,
+          0.771675176030235,
+          0.6796680014132509,
+          0.7106838708683741,
+          0.9896470266638204,
+          0.2674939931440279,
+          0.628205650589996,
+          0.3444040914427221,
+          0.39550692697500456,
+          0.7288884851078544,
+          0.7085878319736025,
+          0.6552251619832516,
+          0.7257098026671255,
+          0.7996458911486881,
+          0.8086747478773577,
+          0.6457862802781831,
+          0.4805442464646371,
+          0.06430022279946768,
+          0.7075285734743578,
+          0.41260624418349545,
+          0.7314891410155159,
+          0.23410127672814485,
+          0.40118352223110276,
+          0.5785612386470048,
+          0.4024214975652409,
+          0.5713041888957858,
+          0.17652943450758374,
+          0.9238132184426326,
+          0.3952167234942614,
+          0.053536913771633166,
+          0.16268009129180894,
+          0.7356926845628389,
+          0.2669795658555745,
+          0.9789436295229189,
+          0.19491540477894964,
+          0.6068433581142664,
+          0.028108521660386243,
+          0.5365044995026428,
+          0.5214889392986901
+         ],
+         "y": [
+          0.4873970177492336,
+          0.03520135403268476,
+          0.15372421192191132,
+          0.11747289197419675,
+          0.25929344871317506,
+          0.9343154176576614,
+          0.23290384745041115,
+          0.8076080396213733,
+          0.7146438501495851,
+          0.36975819935411935,
+          0.0870746091896345,
+          0.8008134269597948,
+          0.8475447433102793,
+          0.4923450072186961,
+          0.9242116623604295,
+          0.8436528492949156,
+          0.4541422408475154,
+          0.015582361403692735,
+          0.21977327990438322,
+          0.868154180660819,
+          0.8843432948546245,
+          0.14370992703672447,
+          0.9913364257956125,
+          0.46232751503686154,
+          0.20524933850363802,
+          0.8650688219937122,
+          0.32908578899049623,
+          0.012218730313331871,
+          0.05010744587850702,
+          0.07785971418825066,
+          0.1733171340497437,
+          0.5808155787065341,
+          0.9520204587697467,
+          0.4647336539079364,
+          0.86816473027919,
+          0.6122661358743096,
+          0.8404187829047086,
+          0.37147145579434915,
+          0.08321713328355973,
+          0.6586943244207204,
+          0.602407140437571,
+          0.2235583151695527,
+          0.763975477157094,
+          0.3142008713658715,
+          0.9892757935382203,
+          0.5557493623729575,
+          0.3164295792273947,
+          0.14059309260038433,
+          0.8344983119977883,
+          0.6887912143356906,
+          0.1611436831893751,
+          0.05897402479010627,
+          0.003373454578108892,
+          0.006539895146632224,
+          0.7903140297989631,
+          0.6311787683548261,
+          0.1172803150406797,
+          0.45702756110960463,
+          0.6876320066897875,
+          0.06217883327048679,
+          0.9150508181601353,
+          0.7869319414443614,
+          0.43316746441311127,
+          0.8274827883571912,
+          0.4858941331954577,
+          0.02735879076293446,
+          0.6909308744595408,
+          0.16557108650734542,
+          0.22845795952243486,
+          0.09676634978854826,
+          0.09194657186854938,
+          0.09298696272893658,
+          0.6005778905754431,
+          0.5929742222488289,
+          0.14320148688584555,
+          0.5390250901251392,
+          0.2944532751258836,
+          0.28996575786723555,
+          0.1392237190849983,
+          0.7640881096089533,
+          0.6181357873580661,
+          0.6044460143386351,
+          0.1416927141729023,
+          0.9391850654064762,
+          0.19425081957087342,
+          0.5560564633922214,
+          0.07036763010665592,
+          0.6031621225765096,
+          0.26627800799541,
+          0.5041808870007972,
+          0.9136777914086817,
+          0.26669225030370547,
+          0.7024233423552112,
+          0.4318747448478185,
+          0.5386857478611576,
+          0.18997125849911767,
+          0.45147057964560544,
+          0.36864502867926696,
+          0.3566839665504429,
+          0.9573684494139385
+         ]
+        }
+       ],
+       "layout": {}
+      },
+      "text/html": [
+       "<div>\n",
+       "        \n",
+       "        \n",
+       "            <div id=\"3100d9be-f563-49b0-9aac-820b17e72a92\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>\n",
+       "            <script type=\"text/javascript\">\n",
+       "                require([\"plotly\"], function(Plotly) {\n",
+       "                    window.PLOTLYENV=window.PLOTLYENV || {};\n",
+       "                    window.PLOTLYENV.BASE_URL='https://plot.ly';\n",
+       "                    \n",
+       "                if (document.getElementById(\"3100d9be-f563-49b0-9aac-820b17e72a92\")) {\n",
+       "                    Plotly.newPlot(\n",
+       "                        '3100d9be-f563-49b0-9aac-820b17e72a92',\n",
+       "                        [{\"marker\": {\"color\": [0.6293828317071586, 0.10871757916572877, 0.68311690821298, 0.9868548358867593, 0.9356744842281925, 0.9790537247648904, 0.3258180192640453, 0.12391204805045775, 0.8350240537325824, 0.5369662542168598, 0.5431266213529744, 0.629752855978358, 0.3057523930457775, 0.4585071756146928, 0.4311862805765245, 0.1639356212211679, 0.446932803456484, 0.8627171610367412, 0.31518503849660306, 0.5828651428770285, 0.16001292379812304, 0.6404620711754383, 0.04741420092894122, 0.7548488102472397, 0.7353917005000188, 0.4365025633180786, 0.7839680628427522, 0.6805068448092968, 0.8786650700491208, 0.06815397986979765, 0.13535861871332966, 0.9405516184122458, 0.5437457047334291, 0.5903552132029327, 0.08082046350853744, 0.7150168555710725, 0.986232841445708, 0.22817216482783065, 0.1076811040405542, 0.03804473076715431, 0.7114105985548173, 0.2836183570437315, 0.48931430431938294, 0.8365056267736387, 0.6336230935293655, 0.42541724288711247, 0.8350608664218104, 0.3437171780503755, 0.14541534768179498, 0.8787162108826218, 0.025388796870841612, 0.8111658156200445, 0.018717505457894856, 0.09869141356496391, 0.3921323585962584, 0.7132961159828939, 0.7318985696655684, 0.7869866024773561, 0.7814016135827416, 0.8919231750596648, 0.28134414473838654, 0.7237985608111946, 0.3618380000508312, 0.21075045827522243, 0.9628478800749577, 0.2900164358629147, 0.4719721918840184, 0.730285844834199, 0.3942587955050557, 0.32586005977792476, 0.972528200795633, 0.28025465435145835, 0.627325945653425, 0.015008746790136196, 0.14237643495137675, 0.050423801719477024, 0.7644515022481213, 0.6091667909932688, 0.3532180131753364, 0.8947334942638786, 0.17387126634230343, 0.5365981953906036, 0.6889435903426656, 0.6610488816804185, 0.9749955651002764, 0.9153566282398699, 0.5269574781630024, 0.8778260007512473, 0.38075994993668905, 0.5647499579658595, 0.418283999093396, 0.3579478941888037, 0.3683880455143794, 0.5201946750419136, 0.2613710707351792, 0.7122574990933892, 0.7298329578282315, 0.6379701686824202, 0.7955868217388932, 0.8163554813378757], \"colorscale\": \"Viridis\", \"opacity\": 0.6, \"size\": [24.74150982375718, 9.280421122552907, 26.816266625639166, 21.865635610789628, 9.896893758182372, 16.35959442725846, 8.829943498152526, 0.9561123550614292, 28.59004398713737, 27.998199247555412, 14.356889793713542, 12.510426498329961, 27.948307057731554, 11.443238859469622, 24.66171987028657, 22.666387218267374, 23.462946003027827, 25.451904787389697, 20.081426958372838, 27.524084273181675, 25.744255659997357, 21.31770690742058, 13.630541365724554, 27.44821596665852, 14.931786869286563, 2.2744366430542327, 18.763621500539017, 3.1819261762898976, 4.610566148833989, 4.149555285846313, 16.482766212514964, 22.717148416863015, 24.987016922679274, 12.528071041169763, 28.274788722893614, 11.081662434254852, 28.44502729834879, 19.51774621900454, 19.644621049552086, 18.770275237826883, 5.079208459129881, 26.875559773109472, 14.291584841429627, 13.314356351751613, 1.5983548469032782, 14.16205944182201, 8.747779265393547, 28.599356582105003, 20.770844383653493, 27.401053695841284, 7.4552367973015485, 18.184112831044487, 21.200618948493563, 19.54919647302541, 26.410627753123226, 0.6118250572534734, 5.081967556847226, 3.3611994256358946, 3.807649332865587, 19.531242703961418, 28.408475476902236, 19.03144105102476, 27.392315621828345, 20.95163521304236, 12.649562527197713, 20.94051863733014, 18.551288851142925, 24.26238241654025, 1.067395868930422, 18.027988539967136, 17.577785181369727, 12.21459774932675, 21.54905183176187, 14.025431326739437, 7.948668233800754, 14.247241180900321, 19.370209208556346, 20.08639665675465, 0.3473738459998921, 18.552605009050048, 5.795867754824368, 29.377512330217755, 17.0977961534976, 19.307556831117715, 24.568224556315844, 4.464096834419008, 21.71654353183601, 17.986786244282424, 9.036785758979, 11.467541197408401, 15.506290662937483, 5.110861130635449, 20.044649489346963, 9.172913083241099, 17.742661485893773, 16.10358725512652, 7.483809983245088, 4.193841641578638, 11.161330279964542, 10.132821938779692]}, \"mode\": \"markers\", \"type\": \"scatter\", \"uid\": \"b0b4b3e6-d74e-4596-b1f6-866494f66ac5\", \"x\": [0.9107379187961171, 0.13830019680520433, 0.821736889714595, 0.3921878219656484, 0.8346405307202264, 0.9553493281777037, 0.5917624120848792, 0.7696872135096617, 0.2764705214251728, 0.10250747898818846, 0.5608219612948858, 0.009301052946640631, 0.2888044375300247, 0.08732715334107588, 0.9218542459508559, 0.7490711090144354, 0.12087960522666752, 0.7255816390705573, 0.40455316553437204, 0.1998318088429799, 0.8563460736962455, 0.24026621118853997, 0.6779207634000527, 0.6237494872918712, 0.5690422866216804, 0.14672189332739916, 0.8283514372957037, 0.3568733435451711, 0.7623487473898288, 0.07834607319110698, 0.6657053354636957, 0.8182792779517071, 0.5514257159258872, 0.11066849699793302, 0.5473351302168906, 0.8948668458488195, 0.19414716791933673, 0.30323631629795966, 0.04384302355313652, 0.9303407902908601, 0.2522389366153581, 0.5728123808665866, 0.45937696306834785, 0.2757418052570424, 0.2161959559781027, 0.7747543804280251, 0.19915143297924554, 0.11283247029514198, 0.7762917205025742, 0.3162146200663585, 0.4010503767685871, 0.9355531154171876, 0.09986423597795058, 0.4205367725458332, 0.8866456464818482, 0.6198436181367285, 0.5728557391504273, 0.13642060186522464, 0.19927373777752855, 0.05529450095070232, 0.5680820939833129, 0.5540148486363582, 0.771675176030235, 0.6796680014132509, 0.7106838708683741, 0.9896470266638204, 0.2674939931440279, 0.628205650589996, 0.3444040914427221, 0.39550692697500456, 0.7288884851078544, 0.7085878319736025, 0.6552251619832516, 0.7257098026671255, 0.7996458911486881, 0.8086747478773577, 0.6457862802781831, 0.4805442464646371, 0.06430022279946768, 0.7075285734743578, 0.41260624418349545, 0.7314891410155159, 0.23410127672814485, 0.40118352223110276, 0.5785612386470048, 0.4024214975652409, 0.5713041888957858, 0.17652943450758374, 0.9238132184426326, 0.3952167234942614, 0.053536913771633166, 0.16268009129180894, 0.7356926845628389, 0.2669795658555745, 0.9789436295229189, 0.19491540477894964, 0.6068433581142664, 0.028108521660386243, 0.5365044995026428, 0.5214889392986901], \"y\": [0.4873970177492336, 0.03520135403268476, 0.15372421192191132, 0.11747289197419675, 0.25929344871317506, 0.9343154176576614, 0.23290384745041115, 0.8076080396213733, 0.7146438501495851, 0.36975819935411935, 0.0870746091896345, 0.8008134269597948, 0.8475447433102793, 0.4923450072186961, 0.9242116623604295, 0.8436528492949156, 0.4541422408475154, 0.015582361403692735, 0.21977327990438322, 0.868154180660819, 0.8843432948546245, 0.14370992703672447, 0.9913364257956125, 0.46232751503686154, 0.20524933850363802, 0.8650688219937122, 0.32908578899049623, 0.012218730313331871, 0.05010744587850702, 0.07785971418825066, 0.1733171340497437, 0.5808155787065341, 0.9520204587697467, 0.4647336539079364, 0.86816473027919, 0.6122661358743096, 0.8404187829047086, 0.37147145579434915, 0.08321713328355973, 0.6586943244207204, 0.602407140437571, 0.2235583151695527, 0.763975477157094, 0.3142008713658715, 0.9892757935382203, 0.5557493623729575, 0.3164295792273947, 0.14059309260038433, 0.8344983119977883, 0.6887912143356906, 0.1611436831893751, 0.05897402479010627, 0.003373454578108892, 0.006539895146632224, 0.7903140297989631, 0.6311787683548261, 0.1172803150406797, 0.45702756110960463, 0.6876320066897875, 0.06217883327048679, 0.9150508181601353, 0.7869319414443614, 0.43316746441311127, 0.8274827883571912, 0.4858941331954577, 0.02735879076293446, 0.6909308744595408, 0.16557108650734542, 0.22845795952243486, 0.09676634978854826, 0.09194657186854938, 0.09298696272893658, 0.6005778905754431, 0.5929742222488289, 0.14320148688584555, 0.5390250901251392, 0.2944532751258836, 0.28996575786723555, 0.1392237190849983, 0.7640881096089533, 0.6181357873580661, 0.6044460143386351, 0.1416927141729023, 0.9391850654064762, 0.19425081957087342, 0.5560564633922214, 0.07036763010665592, 0.6031621225765096, 0.26627800799541, 0.5041808870007972, 0.9136777914086817, 0.26669225030370547, 0.7024233423552112, 0.4318747448478185, 0.5386857478611576, 0.18997125849911767, 0.45147057964560544, 0.36864502867926696, 0.3566839665504429, 0.9573684494139385]}],\n",
+       "                        {},\n",
+       "                        {\"showLink\": false, \"linkText\": \"Export to plot.ly\", \"plotlyServerURL\": \"https://plot.ly\", \"responsive\": true}\n",
+       "                    ).then(function(){\n",
+       "                            \n",
+       "var gd = document.getElementById('3100d9be-f563-49b0-9aac-820b17e72a92');\n",
+       "var x = new MutationObserver(function (mutations, observer) {{\n",
+       "        var display = window.getComputedStyle(gd).display;\n",
+       "        if (!display || display === 'none') {{\n",
+       "            console.log([gd, 'removed!']);\n",
+       "            Plotly.purge(gd);\n",
+       "            observer.disconnect();\n",
+       "        }}\n",
+       "}});\n",
+       "\n",
+       "// Listen for the removal of the full notebook cells\n",
+       "var notebookContainer = gd.closest('#notebook-container');\n",
+       "if (notebookContainer) {{\n",
+       "    x.observe(notebookContainer, {childList: true});\n",
+       "}}\n",
+       "\n",
+       "// Listen for the clearing of the current output cell\n",
+       "var outputEl = gd.closest('.output');\n",
+       "if (outputEl) {{\n",
+       "    x.observe(outputEl, {childList: true});\n",
+       "}}\n",
+       "\n",
+       "                        })\n",
+       "                };\n",
+       "                });\n",
+       "            </script>\n",
+       "        </div>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "N = 100\n",
+    "x = np.random.rand(N)\n",
+    "y = np.random.rand(N)\n",
+    "colors = np.random.rand(N)\n",
+    "sz = np.random.rand(N)*30\n",
+    "\n",
+    "fig = go.Figure()\n",
+    "fig.add_scatter(x=x,\n",
+    "                y=y,\n",
+    "                mode='markers',\n",
+    "                marker={'size': sz,\n",
+    "                        'color': colors,\n",
+    "                        'opacity': 0.6,\n",
+    "                        'colorscale': 'Viridis'\n",
+    "                       });\n",
+    "iplot(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not os.path.exists('images'):\n",
+    "    os.mkdir('images')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import psutil"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pio.write_image(fig, 'images/fig1.png')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pie Chart"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.plotly.v1+json": {
+       "config": {
+        "linkText": "Export to plot.ly",
+        "plotlyServerURL": "https://plot.ly",
+        "showLink": false
+       },
+       "data": [
+        {
+         "mode": "markers",
+         "name": "2007",
+         "text": [
+          "Afghanistan",
+          "Albania",
+          "Algeria",
+          "Angola",
+          "Argentina",
+          "Australia",
+          "Austria",
+          "Bahrain",
+          "Bangladesh",
+          "Belgium",
+          "Benin",
+          "Bolivia",
+          "Bosnia and Herzegovina",
+          "Botswana",
+          "Brazil",
+          "Bulgaria",
+          "Burkina Faso",
+          "Burundi",
+          "Cambodia",
+          "Cameroon",
+          "Canada",
+          "Central African Republic",
+          "Chad",
+          "Chile",
+          "China",
+          "Colombia",
+          "Comoros",
+          "Congo, Dem. Rep.",
+          "Congo, Rep.",
+          "Costa Rica",
+          "Cote d'Ivoire",
+          "Croatia",
+          "Cuba",
+          "Czech Republic",
+          "Denmark",
+          "Djibouti",
+          "Dominican Republic",
+          "Ecuador",
+          "Egypt",
+          "El Salvador",
+          "Equatorial Guinea",
+          "Eritrea",
+          "Ethiopia",
+          "Finland",
+          "France",
+          "Gabon",
+          "Gambia",
+          "Germany",
+          "Ghana",
+          "Greece",
+          "Guatemala",
+          "Guinea",
+          "Guinea-Bissau",
+          "Haiti",
+          "Honduras",
+          "Hong Kong, China",
+          "Hungary",
+          "Iceland",
+          "India",
+          "Indonesia",
+          "Iran",
+          "Iraq",
+          "Ireland",
+          "Israel",
+          "Italy",
+          "Jamaica",
+          "Japan",
+          "Jordan",
+          "Kenya",
+          "Korea, Dem. Rep.",
+          "Korea, Rep.",
+          "Kuwait",
+          "Lebanon",
+          "Lesotho",
+          "Liberia",
+          "Libya",
+          "Madagascar",
+          "Malawi",
+          "Malaysia",
+          "Mali",
+          "Mauritania",
+          "Mauritius",
+          "Mexico",
+          "Mongolia",
+          "Montenegro",
+          "Morocco",
+          "Mozambique",
+          "Myanmar",
+          "Namibia",
+          "Nepal",
+          "Netherlands",
+          "New Zealand",
+          "Nicaragua",
+          "Niger",
+          "Nigeria",
+          "Norway",
+          "Oman",
+          "Pakistan",
+          "Panama",
+          "Paraguay",
+          "Peru",
+          "Philippines",
+          "Poland",
+          "Portugal",
+          "Puerto Rico",
+          "Reunion",
+          "Romania",
+          "Rwanda",
+          "Sao Tome and Principe",
+          "Saudi Arabia",
+          "Senegal",
+          "Serbia",
+          "Sierra Leone",
+          "Singapore",
+          "Slovak Republic",
+          "Slovenia",
+          "Somalia",
+          "South Africa",
+          "Spain",
+          "Sri Lanka",
+          "Sudan",
+          "Swaziland",
+          "Sweden",
+          "Switzerland",
+          "Syria",
+          "Taiwan",
+          "Tanzania",
+          "Thailand",
+          "Togo",
+          "Trinidad and Tobago",
+          "Tunisia",
+          "Turkey",
+          "Uganda",
+          "United Kingdom",
+          "United States",
+          "Uruguay",
+          "Venezuela",
+          "Vietnam",
+          "West Bank and Gaza",
+          "Yemen, Rep.",
+          "Zambia",
+          "Zimbabwe"
+         ],
+         "type": "scatter",
+         "uid": "869e7afa-226e-4a5a-9c86-17b8b0da2c40",
+         "x": [
+          974.5803384,
+          5937.029525999998,
+          6223.367465,
+          4797.231267,
+          12779.37964,
+          34435.367439999995,
+          36126.4927,
+          29796.04834,
+          1391.253792,
+          33692.60508,
+          1441.284873,
+          3822.137084,
+          7446.298803,
+          12569.85177,
+          9065.800825,
+          10680.79282,
+          1217.032994,
+          430.0706916,
+          1713.778686,
+          2042.09524,
+          36319.23501,
+          706.016537,
+          1704.063724,
+          13171.63885,
+          4959.114854,
+          7006.580419,
+          986.1478792,
+          277.5518587,
+          3632.557798,
+          9645.06142,
+          1544.750112,
+          14619.222719999998,
+          8948.102923,
+          22833.30851,
+          35278.41874,
+          2082.4815670000007,
+          6025.3747520000015,
+          6873.262326000001,
+          5581.180998,
+          5728.353514,
+          12154.08975,
+          641.3695236000002,
+          690.8055759,
+          33207.0844,
+          30470.0167,
+          13206.48452,
+          752.7497265,
+          32170.37442,
+          1327.60891,
+          27538.41188,
+          5186.050003,
+          942.6542111,
+          579.2317429999998,
+          1201.637154,
+          3548.3308460000007,
+          39724.97867,
+          18008.94444,
+          36180.78919,
+          2452.210407,
+          3540.651564,
+          11605.71449,
+          4471.061906,
+          40675.99635,
+          25523.2771,
+          28569.7197,
+          7320.8802620000015,
+          31656.06806,
+          4519.461171,
+          1463.249282,
+          1593.06548,
+          23348.139730000006,
+          47306.98978,
+          10461.05868,
+          1569.331442,
+          414.5073415,
+          12057.49928,
+          1044.770126,
+          759.3499101,
+          12451.6558,
+          1042.581557,
+          1803.151496,
+          10956.99112,
+          11977.57496,
+          3095.7722710000007,
+          9253.896111,
+          3820.17523,
+          823.6856205,
+          944,
+          4811.060429,
+          1091.359778,
+          36797.93332,
+          25185.00911,
+          2749.320965,
+          619.6768923999998,
+          2013.977305,
+          49357.19017,
+          22316.19287,
+          2605.94758,
+          9809.185636,
+          4172.838464,
+          7408.905561,
+          3190.481016,
+          15389.924680000002,
+          20509.64777,
+          19328.70901,
+          7670.122558,
+          10808.47561,
+          863.0884639000002,
+          1598.435089,
+          21654.83194,
+          1712.472136,
+          9786.534714,
+          862.5407561000002,
+          47143.17964,
+          18678.31435,
+          25768.25759,
+          926.1410683,
+          9269.657808,
+          28821.0637,
+          3970.095407,
+          2602.394995,
+          4513.480643,
+          33859.74835,
+          37506.41907,
+          4184.548089,
+          28718.27684,
+          1107.482182,
+          7458.396326999998,
+          882.9699437999999,
+          18008.50924,
+          7092.923025,
+          8458.276384,
+          1056.380121,
+          33203.26128,
+          42951.65309,
+          10611.46299,
+          11415.80569,
+          2441.576404,
+          3025.349798,
+          2280.769906,
+          1271.211593,
+          469.70929810000007
+         ],
+         "y": [
+          43.828,
+          76.423,
+          72.301,
+          42.731,
+          75.32,
+          81.235,
+          79.829,
+          75.635,
+          64.062,
+          79.441,
+          56.728,
+          65.554,
+          74.852,
+          50.728,
+          72.39,
+          73.005,
+          52.295,
+          49.58,
+          59.723,
+          50.43,
+          80.653,
+          44.74100000000001,
+          50.651,
+          78.553,
+          72.961,
+          72.889,
+          65.152,
+          46.462,
+          55.322,
+          78.782,
+          48.328,
+          75.748,
+          78.273,
+          76.486,
+          78.332,
+          54.791,
+          72.235,
+          74.994,
+          71.33800000000002,
+          71.878,
+          51.57899999999999,
+          58.04,
+          52.947,
+          79.313,
+          80.657,
+          56.735,
+          59.448,
+          79.406,
+          60.022,
+          79.483,
+          70.259,
+          56.007,
+          46.38800000000001,
+          60.916,
+          70.19800000000001,
+          82.208,
+          73.33800000000002,
+          81.757,
+          64.69800000000001,
+          70.65,
+          70.964,
+          59.545,
+          78.885,
+          80.745,
+          80.546,
+          72.567,
+          82.603,
+          72.535,
+          54.11,
+          67.297,
+          78.623,
+          77.58800000000002,
+          71.993,
+          42.592,
+          45.678,
+          73.952,
+          59.44300000000001,
+          48.303,
+          74.241,
+          54.467,
+          64.164,
+          72.801,
+          76.195,
+          66.803,
+          74.543,
+          71.164,
+          42.082,
+          62.069,
+          52.90600000000001,
+          63.785,
+          79.762,
+          80.204,
+          72.899,
+          56.867,
+          46.859,
+          80.196,
+          75.64,
+          65.483,
+          75.53699999999998,
+          71.752,
+          71.421,
+          71.688,
+          75.563,
+          78.098,
+          78.74600000000002,
+          76.442,
+          72.476,
+          46.242,
+          65.528,
+          72.777,
+          63.062,
+          74.002,
+          42.56800000000001,
+          79.972,
+          74.663,
+          77.926,
+          48.159,
+          49.339,
+          80.941,
+          72.396,
+          58.556,
+          39.613,
+          80.884,
+          81.70100000000002,
+          74.143,
+          78.4,
+          52.517,
+          70.616,
+          58.42,
+          69.819,
+          73.923,
+          71.777,
+          51.542,
+          79.425,
+          78.242,
+          76.384,
+          73.747,
+          74.249,
+          73.422,
+          62.698,
+          42.38399999999999,
+          43.487
+         ]
+        }
+       ],
+       "layout": {
+        "xaxis": {
+         "title": {
+          "text": "GDP per Capita"
+         },
+         "type": "log"
+        },
+        "yaxis": {
+         "title": {
+          "text": "Life Expectancy"
+         }
+        }
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "        \n",
+       "        \n",
+       "            <div id=\"765766e4-5bc8-490f-8488-467ecfef833c\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>\n",
+       "            <script type=\"text/javascript\">\n",
+       "                require([\"plotly\"], function(Plotly) {\n",
+       "                    window.PLOTLYENV=window.PLOTLYENV || {};\n",
+       "                    window.PLOTLYENV.BASE_URL='https://plot.ly';\n",
+       "                    \n",
+       "                if (document.getElementById(\"765766e4-5bc8-490f-8488-467ecfef833c\")) {\n",
+       "                    Plotly.newPlot(\n",
+       "                        '765766e4-5bc8-490f-8488-467ecfef833c',\n",
+       "                        [{\"mode\": \"markers\", \"name\": \"2007\", \"text\": [\"Afghanistan\", \"Albania\", \"Algeria\", \"Angola\", \"Argentina\", \"Australia\", \"Austria\", \"Bahrain\", \"Bangladesh\", \"Belgium\", \"Benin\", \"Bolivia\", \"Bosnia and Herzegovina\", \"Botswana\", \"Brazil\", \"Bulgaria\", \"Burkina Faso\", \"Burundi\", \"Cambodia\", \"Cameroon\", \"Canada\", \"Central African Republic\", \"Chad\", \"Chile\", \"China\", \"Colombia\", \"Comoros\", \"Congo, Dem. Rep.\", \"Congo, Rep.\", \"Costa Rica\", \"Cote d'Ivoire\", \"Croatia\", \"Cuba\", \"Czech Republic\", \"Denmark\", \"Djibouti\", \"Dominican Republic\", \"Ecuador\", \"Egypt\", \"El Salvador\", \"Equatorial Guinea\", \"Eritrea\", \"Ethiopia\", \"Finland\", \"France\", \"Gabon\", \"Gambia\", \"Germany\", \"Ghana\", \"Greece\", \"Guatemala\", \"Guinea\", \"Guinea-Bissau\", \"Haiti\", \"Honduras\", \"Hong Kong, China\", \"Hungary\", \"Iceland\", \"India\", \"Indonesia\", \"Iran\", \"Iraq\", \"Ireland\", \"Israel\", \"Italy\", \"Jamaica\", \"Japan\", \"Jordan\", \"Kenya\", \"Korea, Dem. Rep.\", \"Korea, Rep.\", \"Kuwait\", \"Lebanon\", \"Lesotho\", \"Liberia\", \"Libya\", \"Madagascar\", \"Malawi\", \"Malaysia\", \"Mali\", \"Mauritania\", \"Mauritius\", \"Mexico\", \"Mongolia\", \"Montenegro\", \"Morocco\", \"Mozambique\", \"Myanmar\", \"Namibia\", \"Nepal\", \"Netherlands\", \"New Zealand\", \"Nicaragua\", \"Niger\", \"Nigeria\", \"Norway\", \"Oman\", \"Pakistan\", \"Panama\", \"Paraguay\", \"Peru\", \"Philippines\", \"Poland\", \"Portugal\", \"Puerto Rico\", \"Reunion\", \"Romania\", \"Rwanda\", \"Sao Tome and Principe\", \"Saudi Arabia\", \"Senegal\", \"Serbia\", \"Sierra Leone\", \"Singapore\", \"Slovak Republic\", \"Slovenia\", \"Somalia\", \"South Africa\", \"Spain\", \"Sri Lanka\", \"Sudan\", \"Swaziland\", \"Sweden\", \"Switzerland\", \"Syria\", \"Taiwan\", \"Tanzania\", \"Thailand\", \"Togo\", \"Trinidad and Tobago\", \"Tunisia\", \"Turkey\", \"Uganda\", \"United Kingdom\", \"United States\", \"Uruguay\", \"Venezuela\", \"Vietnam\", \"West Bank and Gaza\", \"Yemen, Rep.\", \"Zambia\", \"Zimbabwe\"], \"type\": \"scatter\", \"uid\": \"869e7afa-226e-4a5a-9c86-17b8b0da2c40\", \"x\": [974.5803384, 5937.029525999998, 6223.367465, 4797.231267, 12779.37964, 34435.367439999995, 36126.4927, 29796.04834, 1391.253792, 33692.60508, 1441.284873, 3822.137084, 7446.298803, 12569.85177, 9065.800825, 10680.79282, 1217.032994, 430.0706916, 1713.778686, 2042.09524, 36319.23501, 706.016537, 1704.063724, 13171.63885, 4959.114854, 7006.580419, 986.1478792, 277.5518587, 3632.557798, 9645.06142, 1544.750112, 14619.222719999998, 8948.102923, 22833.30851, 35278.41874, 2082.4815670000007, 6025.3747520000015, 6873.262326000001, 5581.180998, 5728.353514, 12154.08975, 641.3695236000002, 690.8055759, 33207.0844, 30470.0167, 13206.48452, 752.7497265, 32170.37442, 1327.60891, 27538.41188, 5186.050003, 942.6542111, 579.2317429999998, 1201.637154, 3548.3308460000007, 39724.97867, 18008.94444, 36180.78919, 2452.210407, 3540.651564, 11605.71449, 4471.061906, 40675.99635, 25523.2771, 28569.7197, 7320.8802620000015, 31656.06806, 4519.461171, 1463.249282, 1593.06548, 23348.139730000006, 47306.98978, 10461.05868, 1569.331442, 414.5073415, 12057.49928, 1044.770126, 759.3499101, 12451.6558, 1042.581557, 1803.151496, 10956.99112, 11977.57496, 3095.7722710000007, 9253.896111, 3820.17523, 823.6856205, 944.0, 4811.060429, 1091.359778, 36797.93332, 25185.00911, 2749.320965, 619.6768923999998, 2013.977305, 49357.19017, 22316.19287, 2605.94758, 9809.185636, 4172.838464, 7408.905561, 3190.481016, 15389.924680000002, 20509.64777, 19328.70901, 7670.122558, 10808.47561, 863.0884639000002, 1598.435089, 21654.83194, 1712.472136, 9786.534714, 862.5407561000002, 47143.17964, 18678.31435, 25768.25759, 926.1410683, 9269.657808, 28821.0637, 3970.095407, 2602.394995, 4513.480643, 33859.74835, 37506.41907, 4184.548089, 28718.27684, 1107.482182, 7458.396326999998, 882.9699437999999, 18008.50924, 7092.923025, 8458.276384, 1056.380121, 33203.26128, 42951.65309, 10611.46299, 11415.80569, 2441.576404, 3025.349798, 2280.769906, 1271.211593, 469.70929810000007], \"y\": [43.828, 76.423, 72.301, 42.731, 75.32, 81.235, 79.829, 75.635, 64.062, 79.441, 56.728, 65.554, 74.852, 50.728, 72.39, 73.005, 52.295, 49.58, 59.723, 50.43, 80.653, 44.74100000000001, 50.651, 78.553, 72.961, 72.889, 65.152, 46.462, 55.322, 78.782, 48.328, 75.748, 78.273, 76.486, 78.332, 54.791, 72.235, 74.994, 71.33800000000002, 71.878, 51.57899999999999, 58.04, 52.947, 79.313, 80.657, 56.735, 59.448, 79.406, 60.022, 79.483, 70.259, 56.007, 46.38800000000001, 60.916, 70.19800000000001, 82.208, 73.33800000000002, 81.757, 64.69800000000001, 70.65, 70.964, 59.545, 78.885, 80.745, 80.546, 72.567, 82.603, 72.535, 54.11, 67.297, 78.623, 77.58800000000002, 71.993, 42.592, 45.678, 73.952, 59.44300000000001, 48.303, 74.241, 54.467, 64.164, 72.801, 76.195, 66.803, 74.543, 71.164, 42.082, 62.069, 52.90600000000001, 63.785, 79.762, 80.204, 72.899, 56.867, 46.859, 80.196, 75.64, 65.483, 75.53699999999998, 71.752, 71.421, 71.688, 75.563, 78.098, 78.74600000000002, 76.442, 72.476, 46.242, 65.528, 72.777, 63.062, 74.002, 42.56800000000001, 79.972, 74.663, 77.926, 48.159, 49.339, 80.941, 72.396, 58.556, 39.613, 80.884, 81.70100000000002, 74.143, 78.4, 52.517, 70.616, 58.42, 69.819, 73.923, 71.777, 51.542, 79.425, 78.242, 76.384, 73.747, 74.249, 73.422, 62.698, 42.38399999999999, 43.487]}],\n",
+       "                        {\"xaxis\": {\"title\": {\"text\": \"GDP per Capita\"}, \"type\": \"log\"}, \"yaxis\": {\"title\": {\"text\": \"Life Expectancy\"}}},\n",
+       "                        {\"showLink\": false, \"linkText\": \"Export to plot.ly\", \"plotlyServerURL\": \"https://plot.ly\", \"responsive\": true}\n",
+       "                    ).then(function(){\n",
+       "                            \n",
+       "var gd = document.getElementById('765766e4-5bc8-490f-8488-467ecfef833c');\n",
+       "var x = new MutationObserver(function (mutations, observer) {{\n",
+       "        var display = window.getComputedStyle(gd).display;\n",
+       "        if (!display || display === 'none') {{\n",
+       "            console.log([gd, 'removed!']);\n",
+       "            Plotly.purge(gd);\n",
+       "            observer.disconnect();\n",
+       "        }}\n",
+       "}});\n",
+       "\n",
+       "// Listen for the removal of the full notebook cells\n",
+       "var notebookContainer = gd.closest('#notebook-container');\n",
+       "if (notebookContainer) {{\n",
+       "    x.observe(notebookContainer, {childList: true});\n",
+       "}}\n",
+       "\n",
+       "// Listen for the clearing of the current output cell\n",
+       "var outputEl = gd.closest('.output');\n",
+       "if (outputEl) {{\n",
+       "    x.observe(outputEl, {childList: true});\n",
+       "}}\n",
+       "\n",
+       "                        })\n",
+       "                };\n",
+       "                });\n",
+       "            </script>\n",
+       "        </div>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import plotly.plotly as py\n",
+    "import plotly.graph_objs as go\n",
+    "import pandas as pd\n",
+    "\n",
+    "df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder2007.csv')\n",
+    "\n",
+    "fig = {\n",
+    "    'data': [\n",
+    "          {\n",
+    "          'x': df.gdpPercap, \n",
+    "            'y': df.lifeExp, \n",
+    "            'text': df.country, \n",
+    "            'mode': 'markers', \n",
+    "            'name': '2007'},\n",
+    "    ],\n",
+    "    'layout': {\n",
+    "        'xaxis': {'title': 'GDP per Capita', 'type': 'log'},\n",
+    "        'yaxis': {'title': \"Life Expectancy\"}\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "iplot(fig, filename='pandas-multiple-scatter')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pio.write_image(fig, 'images/scatter.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}