diff options
Diffstat (limited to 'datasets/Talluri2021/3.country and reason.ipynb')
| -rw-r--r-- | datasets/Talluri2021/3.country and reason.ipynb | 887 |
1 files changed, 887 insertions, 0 deletions
diff --git a/datasets/Talluri2021/3.country and reason.ipynb b/datasets/Talluri2021/3.country and reason.ipynb new file mode 100644 index 0000000..d79ad05 --- /dev/null +++ b/datasets/Talluri2021/3.country and reason.ipynb @@ -0,0 +1,887 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from plotnine import *" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "or_reports = pd.read_parquet('./outage_report_individual_reports_2019-20')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_reports = or_reports[(or_reports['reason'] != '') & (or_reports['vendor'] != 'overview')].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "instagram_or_reports = filtered_or_reports[filtered_or_reports['vendor'] == 'instagram'].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "github_or_reports = filtered_or_reports[filtered_or_reports['vendor'] == 'github'].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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>country</th>\n", + " <th>count</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>CA</td>\n", + " <td>1828</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>GB</td>\n", + " <td>1327</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>Other</td>\n", + " <td>15938</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>RU</td>\n", + " <td>3272</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>UA</td>\n", + " <td>3486</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>US</td>\n", + " <td>15723</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " country count\n", + "0 CA 1828\n", + "1 GB 1327\n", + "2 Other 15938\n", + "3 RU 3272\n", + "4 UA 3486\n", + "5 US 15723" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "top4_countries_insta = instagram_or_reports.groupby('country')['vendor'].count().reset_index().sort_values('vendor', ascending=False).reset_index(drop=True).loc[:4, 'country'].values\n", + "\n", + "truncated_insta_reports = instagram_or_reports.copy()\n", + "truncated_insta_reports.loc[~truncated_insta_reports['country'].isin(top4_countries_insta), 'country'] = 'Other'\n", + "\n", + "insta_reports_by_country = truncated_insta_reports.groupby('country')['id'].count().reset_index().rename(columns={'id': 'count'})\n", + "insta_reports_by_country" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<ggplot: (328058811)>" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(insta_reports_by_country) +\\\n", + " geom_bar(aes(x='country', y='count'), stat='identity')\n", + "\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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>country</th>\n", + " <th>count</th>\n", + " <th>country_proper</th>\n", + " <th>country_cat</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>CA</td>\n", + " <td>10265</td>\n", + " <td>Canada</td>\n", + " <td>Canada</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>GB</td>\n", + " <td>12451</td>\n", + " <td>UK</td>\n", + " <td>UK</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>IN</td>\n", + " <td>4478</td>\n", + " <td>India</td>\n", + " <td>India</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>Other</td>\n", + " <td>61927</td>\n", + " <td>Other</td>\n", + " <td>Other</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>RU</td>\n", + " <td>4200</td>\n", + " <td>Russia</td>\n", + " <td>Russia</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>US</td>\n", + " <td>80849</td>\n", + " <td>USA</td>\n", + " <td>USA</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " country count country_proper country_cat\n", + "0 CA 10265 Canada Canada\n", + "1 GB 12451 UK UK\n", + "2 IN 4478 India India\n", + "3 Other 61927 Other Other\n", + "4 RU 4200 Russia Russia\n", + "5 US 80849 USA USA" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "top4_countries_all = filtered_or_reports.groupby('country')['vendor'].count().reset_index().sort_values('vendor', ascending=False).reset_index(drop=True).loc[:4, 'country'].values\n", + "\n", + "truncated_all_reports = filtered_or_reports.copy()\n", + "truncated_all_reports.loc[~truncated_all_reports['country'].isin(top4_countries_all), 'country'] = 'Other'\n", + "\n", + "all_reports_by_country = truncated_all_reports.groupby('country')['id'].count().reset_index().rename(columns={'id': 'count'})\n", + "all_reports_by_country['country_proper'] = all_reports_by_country['country'].replace(['US', 'GB', 'CA', 'IN', 'RU'], ['USA', 'UK', 'Canada', 'India', 'Russia'])\n", + "countries_sorted = all_reports_by_country.sort_values('count')['country_proper'].values\n", + "all_reports_by_country['country_cat'] = pd.Categorical(all_reports_by_country['country_proper'], categories=countries_sorted, ordered=True)\n", + "all_reports_by_country" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 4 x 2 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: ./plots/reports_by_country.pdf\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbMAAADaCAYAAAAsYayhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAz2ElEQVR4nO3deVhV1f748fdhOqiAMogyKOKUqKiApqmFY5kDTjghaXo1tfxV2qSYmgNqg2XfHG9etSJEjTSHrmIopjmDV1JBtBwugRgIMiPD/v3hw7mdDggcUTycz+t5eOKsvfban70qPmfvvfZaKkVRFIQQQggDZlLTAQghhBAPS5KZEEIIgyfJTAghhMGTZCaEEMLgSTITQghh8CSZCSGEMHiSzIQQQhg8SWZCCCEMniQzA5Cbm0tMTAy5ubk1HYoQQjyRJJkZgPj4eHx8fIiPj6/pUIQQ4okkyUwIIYTBk2QmhBDC4EkyE0IIYfDMajoA8WiZLjpd0yEIIWq54oVP13QIcmUmhBDC8EkyE0IIYfCM9jZjaGgoYWFhhISEYGNjo7N95syZ2NjYsGzZMgD+/PNPvvvuO86fP09qaioWFhbY29vz1FNPMWbMGBo2bKjTxqlTpwgODsba2potW7Zgbm7+yM9LCCGMkdEms6pITU1l1qxZ1KtXj2HDhuHi4kJubi43b97kl19+ISUlpcxkdvDgQQCysrI4efIkzz777OMOXQghjIIks0qIiIggMzOTTz75hMaNG2vKu3XrxujRoykpKdHZJz09nejoaDp06EB8fDwHDx6UZCaEEI+IJLNKyMzMxMTEhAYNGpS53cRE99HjoUOHKC4uZujQodja2nL06FFu376No6PjI45WCCGMjwwAqYQ2bdpQUlLC8uXLKz1H4k8//YSdnR3e3t7069ePkpISIiMjH0O0QghhfOTKrBJ8fX25dOkSERERnDt3DpVKhaurK97e3gwePJhGjRpp1b948SJ//PEHI0eOxNTUlA4dOtCoUSMiIyMZO3YsKpWqhs5ECCFqJ7kyqwSVSsWrr77KP//5T6ZPn07fvn0pKirihx9+YObMmVy4cEGrfunAj/79+2v279u3L7dv3+b8+fOPPX4hhKjtjDaZmZqaAlBcXFzm9uLiYk2dUo6OjgwcOJDXX3+dDRs28O6771JYWMjmzZs1dXJzc/nll19o3bo1NjY2ZGdnk52dTbdu3VCpVJpEV5Hk5GRiYmKIiYkhLi5Oz7MUQgjjYLS3GUsHc9y5cwdbW1utbYqikJ6eTsuWLR/YRs+ePdmxYwc3btzQlP38888UFBSQkJBAQECAzj4nT54kOzsbKyurB7a9YcMGFi1aVMmzEUII42a0yaxDhw6oVCqOHj1KixYttLaVDvLo1KkTcD/h2dnZ6bSRl5dHamqq1raffvqJOnXqEBQUpDPK8erVq2zevJmoqCgGDx78wPimTZuGn58fAHFxcQQGBupzmkIIYRSMNpk5OTkxaNAgdu7cSU5ODj4+PqjVaq5cuUJ4eDgtW7bkueeeA2D79u3ExcXx7LPP4u7ujlqtJiUlhX379pGVlcWkSZMAuHHjBgkJCbz44ot07NhR55geHh7s2rWLgwcPVpjMnJyccHJyqv4TF0KIWshokxnA1KlTadKkCQcPHiQqKori4mLNc7HRo0drpp/q3bs3AEePHtUkP2tra1q0aMHChQvx8fEB/jfwY8CAAWUez8zMjD59+hAeHs5vv/2mc0UohBBCPypFUZSaDkI8WExMDD4+PkRHR+Pt7V2lfWUJGCHEoyZLwAghhBDVQJKZEEIIgyfJTAghhMGTZCaEEMLgSTITQghh8CSZCSGEMHhG/Z6ZMXgShswKIcSjJldmQgghDJ5cmdVy8tK0EI+O3Pl4csiVmRBCCIMnyUwIIYTBk2QmhBDC4NW6Z2bx8fHs2rWLuLg4srKysLKyom3btgwbNow2bdpo6sXFxXHu3Dn8/Px0FsqcMmUKTZs2ZcGCBY87fCGEEHqoVVdme/fuZc6cOaSlpfHyyy+zePFiJk2aRFpaGnPmzGHv3r2auvHx8YSFhZGTk1ODEQshhKgOtebK7NKlS2zcuBEfHx+CgoIwNTXVbHvuuedYtmwZGzdupHnz5rRt27YGI72vuLiYkpISzZppQggh9Fdrktl3330HwIwZM7QSGYCpqSnTp09n6tSphIeH85///IewsDDg/gKdpYKDg/H09NR8jo6O5ptvviExMZGGDRsyYsQI+vfvr9V2eno6oaGhnD17lrt372JnZ0ffvn0ZPXq0Jo6UlBSmTp3KxIkTKSoq4uDBg6SmpjJ//nzNwp5CCCH0VyuSWXFxMb/++istW7bEwcGhzDoNGzakZcuWxMbGMm3aNLKzs9m7dy9z587F1tYWgKZNm2rqX79+nU2bNuHv70+DBg2IiIjgiy++wMnJifbt2wP3E9lbb72FiYkJY8aMwcnJifj4eLZv387t27d54403tGLYu3cvzs7OTJ48mTp16uDs7PyIekQIIYxLrUhmmZmZFBQU0KhRowfWa9SoEQkJCVhYWNCwYUMAmjdvXuZ+mZmZfPjhh5p67dq1IzY2lp9//lmTzLZu3UpOTg6rV6/W1OvYsSMWFhZs3ryZ4cOHayVIc3NzFi1ahJlZreh2IYR4YtSqASAVURQFAJVKVWFdd3d3TYICsLCwwNnZmdu3b2vKzpw5g6enJ3Z2dhQXF2t+Sm8dXrhwQavNrl27SiITQohHoFb8ZbWxsUGtVpOSkvLAerdv30atVusMxS+LtbW1Tpm5uTn37t3TfM7IyOD06dMMHz68zDYyMzO1PpfezqyM5ORkkpOTgfuvEQghhChfrUhmpqameHp6EhMTQ2pqapnPzVJTU7l69So+Pj46A0T0ZWNjQ7NmzQgMDCxzu52dndbnylwRltqwYQOLFi16qPiEEMJY1JrbjP7+/gCsX7+e4uJirW3FxcWsW7dOq17pkPi/XmlVVZcuXbhx4wZOTk60atVK58fe3l7vtqdNm0Z0dDTR0dGEhITo3Y4QQhiDWnFlBtC2bVumTJnCxo0bmTNnDoMGDaJhw4b8+eef/PjjjyQkJDBlyhQ8PDwAcHNzA2DPnj306dMHU1NTXFxcqFu3bqWPGRAQwH/+8x/effddBg8ejIuLC4WFhdy+fZuzZ8/y6quvlju6siJOTk44OTnpta8QQhibWpPMAAYPHkzLli3ZtWsXmzZt0prOasWKFVrTWXl6euLv78+hQ4eIiIigpKRE5z2zitjZ2fHpp5+ybds2du7cSVpaGnXq1KFRo0Z4e3tX6tmcEEKIh6dSSof4iSdWTEwMPj4+REdH4+3tXaV9ZT0zIR4dWc/syaHXM7OVK1eSnp5e3bEIIYQQetErmb333nu4uroydepUzp8/X90xCSGEEFWiVzL77bffeO2119i1axfe3t707NmTsLAwioqKqjs+IYQQokJ6JTM3Nzc++ugjEhMT+fLLL8nPzycgIICmTZvywQcfaF72FUIIIR6Hh3rPTK1WM3nyZM6ePcsvv/xC69atWbJkCc2aNWPcuHFyC1IIIcRjUS0vTf/00098+OGHHDt2DDs7O8aPH8/PP/9M586d2bhxY3UcQgghhCiX3u+ZZWVlsXnzZtauXUtCQgLt27dn/fr1BAYGYmlpSWFhIdOnT+eDDz5gypQp1RmzqAIZOiyEMAZ6XZnNmDEDFxcXZs+eTZs2bYiMjCQ2NpYpU6ZgaWkJ3J8uatKkSSQlJVVrwEIIIcTf6XVlFhYWxtSpU5k5cybu7u7l1mvTpg2bN2/WOzjx8AztpWm5khRC6KPKyezevXuEhITg6emptfBkWRwcHJg4caLewQkhhBCVUeXbjGZmZgwfPpwrV648iniEEEKIKqtyMjMxMcHV1VVn4UkhhBCipug1AOQf//gHa9as0Vk3rLYKDQ3Fz8+v3AQ+c+ZMgoKCAEhJScHPz4+dO3dq1SkuLubzzz/Hz8+P7du3P/KYhRDCmOg1AMTCwoLLly/j4eGBn58fTk5OWqsoq1QqZs2aVW1BGrrCwkI++eQTTp06xfTp0xk4cGBNhySEELWKXsnsvffe0/z+6aef6myXZPY/+fn5BAcHc/HiRWbPns1zzz1X0yEJIUSto1cyu3btWnXHUStlZ2ezaNEirl27RlBQEJ07d67pkIQQolbSK5m5ublVdxy1zp07d5g7dy6pqaksXryYtm3b1nRIQghRa+k1AMTU1JTTp8t+GTc6OhpTU9OHCqo2+OGHH7hx4wbvvvuuJDIhhHjE9EpmiqKUu62kpERrMIix8vLywtzcnE2bNnH37t0q75+cnExMTAwxMTHExcU9ggiFEKL20HvW/PISVnR0NPXr19c7oCdR6ZVmea8iFBcX61yNdurUiaCgIJKSkpg3bx4ZGRlVOuaGDRvw8fHBx8eHwMBAveIWQghjUelk9vnnn9O8eXOaN2+OSqVi2LBhms+lP05OTrz22mv069fvUcb82DVo0AC4/xzs7xRFIT09XVPnr3x8fJg3bx63bt1i3rx5pKenV/qY06ZNIzo6mujoaEJCQvQNXQghjEKlB4A4OjrSrl07AK5fv07z5s11/oCr1Wo8PT154403qjXImtahQwdUKhVHjx6lRYsWWttiYmLIzc2lU6dOZe7r7e3NvHnzCA4O5v3332fp0qXY2tpWeEwnJyecnJyqI3whhKj1Kp3Mxo0bx7hx4wDo3bs369ato02bNo8ssCeJk5MTgwYNYufOneTk5ODj44NarebKlSuEh4fTsmXLB74/5uXlpUlo8+bNY+nSpdjZ2T3GMxBCiNpNr6H5hw8fru44nnhTp06lSZMmHDx4kKioKIqLi3F0dGTgwIGMHj0ac3PzB+7v5eXF/PnzWbJkiSah2dvbP6bohRCidlMpDxqa+ACKonDmzBlu3LhBXl6ezvYJEyY8dHDivpiYGHx8fIiOjsbb27tK+8p6ZkIIY6DXlVlCQgJ+fn5cuXKlzGH6KpVKkpkQQojHRq9k9tprr5Gfn8+2bdvo0KEDarW6uuMSQgghKk2vZHb69Gm+/PJL/P39qzseIYQQosr0emnaysoKGxub6o5FCCGE0IteyWzSpEmEhoZWdyxCCCGEXvS6zdi+fXu2bt2Kn58fQ4YMKXOI+YgRIx46OCGEEKIy9Bqab2Ly4As6lUpV7jyGouoeZmi+EEIYA3lpWgghhMHTK5n5+vpWdxziEXnSXpqWl6KFEI+C3kvACCGEEE8Kva7M+vTp88DtKpWKyMhIvQISQgghqkqvZFbWatKpqalcvnwZR0dHWrduXS3BCSGEEJWhVzKLiooqszwhIYGhQ4eycOFCvQO6du0au3fv5tdffyU9PR1TU1OcnZ159tlnef7557G2tta77UdpypQptG/fnjfffLOmQxFCCKOjVzIrT+vWrXnnnXd49913OXXqVJX3P3DgAOvXr8fFxYURI0bQpEkTioqKuHr1Kvv37+fy5csEBQVVZ8hCCCFqgWpNZgDNmjXjwoULVd4vPj6edevW0alTJ+bNm6e1PpiXlxfDhg0jJiamOkMVQghRS1R7MgsPD8fZ2bnK++3YsQOVSsVrr71W5kKX5ubmdO3aFYCjR49y8OBBbty4QU5ODo6OjnTt2pUxY8ZgaWmp2WfVqlUcP36cVatW8eWXX3Lx4kWsrKzo0aMHEyZM0DrO1q1biY6OJikpieLiYpycnBg4cCD9+/fXej5YVFTEN998w+HDh8nNzaVFixb84x//0In37t27hIaGcuHCBf7880/UajVNmzYlICCAdu3aVbl/hBBClE+vZDZ58mSdsoKCAmJjY7l06RIfffRRldorLi4mNjaWFi1a0LBhwwrrJyUl4ePjg5+fH5aWliQmJhIeHk5CQgLBwcFadYuKiggODqZfv34MGzaMixcvsm3bNurVq8fYsWM19W7fvs0LL7ygOf7ly5f55z//yZ07d7TqrV69msOHDzNs2DA6derEzZs3Wb58uc4CpVlZWQCMHTsWW1tb8vLyOHnyJPPmzWPJkiV4enpWqY+EEEKUT69kdujQIZ3RjJaWljRr1oy5c+cSEBBQpfYyMzMpKCigUaNGlao/ZswYze+KouDh4YGrqytBQUFcu3YNd3d3zfaioiLGjRtHz549AejYsSNXr17lyJEjWknqjTfe0PxeUlKCp6cniqKwZ88exowZg0qlIjExkUOHDjF06FAmTZoE3L8F2qBBA1auXKkVo6urKzNmzNB8Li4uxtvbm9u3b7Nnzx5JZkIIUY30SmbXr1+v5jCq5tatW4SEhBAbG8vdu3e1VrtOTEzUSmYqlYqnn9aedcLNzY3Y2FitsvPnz/Pdd99x5coVcnNztbZlZGRga2ur2efvM6D07NmTVatW6cT573//mwMHDvDf//6XwsJCTbmrq2uF55icnExycjIAcXFxFdYXQghjVu3PzPRhY2ODWq0mJSWlwrp5eXnMmTMHCwsLAgMDcXZ2Rq1Wk5qayvLly7l3755WfbVajYWFhVaZubm5Vr2EhAQWLlyIp6cnM2fOxN7eHjMzM06dOsX27ds1dUtvHdra2mq1Z2pqqvPKwK5du9i0aRMDBgxg/Pjx2NjYYGJiwrfffktiYmKF57lhwwYWLVpUYT0hhBAPkczu3LnDZ599RmRkJGlpaTg4ONCvXz/efPNNnT/2FTE1NaVjx45ER0eTmpqKg4NDuXVjY2O5c+cOy5Yto3379prynJwcfU+Fo0ePYmZmxvz587US399fLyhNWOnp6VrL3hQXF2sSXamoqCg8PT159dVXtcr//mytPNOmTcPPzw+4f2UWGBhY+RMSQggjo9fcjH/88Qfe3t4EBwdz9+5dmjZtSkZGBkuWLMHb25ukpKQqt+nv74+iKKxevVrrllypoqIiTp8+rXlWZ2amnYf379+vz6lomJqaai1tU1BQoLM6QOlzriNHjmiVHzt2TGfJG5VKpRPjtWvXuHz5cqXicXJywtvbG29vbzw8PCp9HkIIYYz0ujILCgoiLy+PU6dO0aVLF035mTNnGDJkCEFBQWzZsqVKbbZp04YZM2awfv16Zs+ezYsvvkjTpk0pKiri999/58CBA7i5uTFz5kysrKxYt24dY8eOxczMjKioqId6jte5c2d++OEHPvnkE1544QWysrLYtWuXzisCTZo0oVevXuzevVtzNXnz5k127txJ3bp1tep26dKFbdu2ERoaSrt27fjjjz/Ytm0bjo6OlJSU6B2rEEIIXXols/3797N06VKtRAb3/4AvXryY+fPn6xXMCy+8QOvWrfnhhx8IDw8nPT0dMzMznJ2d8fX1ZdCgQdjY2LBgwQI2bdrEp59+iqWlJV27duWdd95h1qxZeh23Y8eOvP7664SHh7N06VLs7e15/vnnqV+/Pl988YVW3f/3//4fDRo0IDIykr179+Lu7s6cOXP45JNPtOqNGjWKgoICDh48yPfff0+TJk2YMWMGJ0+e1OulciGEEOXTa6VpS0tL9uzZQ//+/XW2HTx4kCFDhpCfn18tAYqHW2la1jMTQhgDvZ6Zubu7s2/fvjK3/fvf/9YaGi+EEEI8anrdZpw0aRJz5syhpKSEiRMn4uTkRHJyMiEhIXzxxResWLGiuuMUQgghyqVXMnvnnXf47bffWL16NWvWrNGUK4rCK6+8wttvv11tAQohhBAV0SuZqVQqNmzYwOzZszl8+DBpaWnY29vTp08fWZhTCCHEY1fpZ2bp6emMHDmSvXv3asqeeuoppk+fzrx585g+fToJCQmMHDmStLS0RxKsEEIIUZZKX5lt3LiR8+fPM2DAgHLrDBgwgNmzZ7NmzRoWLFhQLQGKhyOjB4UQxqDSV2ZhYWFMnTpVZ1aLvzIzM2Pq1Kns3r27WoITQgghKqPSySwhIYHOnTtXWM/b25uEhISHCkoIIYSoikrfZiwqKipzBei/Mzc3L3NuRVEzHvalablNKYQwBJW+MnNycuLSpUsV1rt48SKNGzd+qKCEEEKIqqh0MvP19WXt2rUPvOoqLCxk3bp19O7du1qCE0IIISqj0sls1qxZxMfHM3z48DKXeElKSmLYsGFcvnxZ7wl/hRBCCH1UOpl16NCBNWvWcODAAdzd3enevTvjx49n/PjxdO/eHXd3dyIiIlizZo1m3a8nQWRkJH5+fly5cqVa2ktJScHPz4/IyEhNWWhoqGYhTSGEEI9flWYAmTp1Ku3bt2fZsmUcPnyYkydPAlC3bl0GDBjA3Llz6dat2yMJ9En2/PPPV3k2eyGEENWnytNZPfPMM+zZs4eSkhJSU1MBcHBw0Fql2dg4ODjg4OBQ02EIIYTR0mtuRgATExMcHR2rM5bHYtWqVRw/fpxVq1bx5ZdfcvHiRaysrOjRowcTJkzQev0gLS2NjRs3EhMTg0qlwtvbu8zbiaGhoYSFhWm9LH706FEOHjzIjRs3yMnJwdHRka5duzJmzBgsLS0fy7kKIYSx0DuZGbKioiKCg4Pp168fw4YN4+LFi2zbto169eoxduxYAAoKCliwYAF37tzhpZdewsXFhbNnz/Lxxx9X6hhJSUn4+Pjg5+eHpaUliYmJhIeHk5CQQHBw8KM8PSGEMDpGm8zGjRtHz549AejYsSNXr17lyJEjmmR26NAh/vvf/zJv3jy6du0KgJeXFwUFBURERFR4jDFjxmh+VxQFDw8PXF1dCQoK4tq1a7KAqRBCVCOjTGYqlYqnn9ae2cLNzY3Y2FjN519//ZU6depoElkpX1/fSiWzW7duERISQmxsLHfv3kVRFM22xMTECpNZcnIyycnJAMTFxVV4PCGEMGZGmczUajUWFhZaZebm5ty7d0/zOSsriwYNGujsa2trW2H7eXl5zJkzBwsLCwIDA3F2dkatVpOamsry5cu1jlOeDRs2sGjRoopPRgghhHEms8qwtrYuc8Lk9PT0CveNjY3lzp07LFu2jPbt22vKc3JyKn38adOmaQabxMXFERgYWOl9hRDC2EgyK4enpyfHjh3j1KlTWrcajxw5UuG+KpUKQGe5nP3791f6+E5OTjg5OVW6vhBCGDNJZuXo06cPu3fvZtWqVZpbhWfPnuXcuXMV7tumTRusrKxYt24dY8eOxczMjKioKK5fv/7oAxdCCCNkvG86V0CtVrN06VI6duzI119/zYoVK0hLS+Odd96pcF8bGxsWLFiAWq3m008/5f/+7/+oU6dOpfYVQghRdSrlr8PsxBMpJiYGHx8foqOjqzxtlqxnJoQwBnJlJoQQwuBJMhNCCGHwJJkJIYQweJLMhBBCGDxJZkIIIQyevGdWy8loRCGEMZArMyGEEAZPkpkQQgiDJ7cZa7mHeWlablEKIQyFXJkJIYQweJLMhBBCGDxJZkIIIQyeQT0zi4yM5PPPP9d8NjExoX79+rRv357x48fj7OxcI3GFhoYSFhbG7t27a+T4Qghh7AwqmZV64403cHFxobCwkLi4OLZv305sbCzr1q3Dysrqscfz/PPPV3k2eyGEENXHIJNZ06ZNadWqFXB/ReiSkhJCQ0M5efIk/fr1e+zxODg44ODg8NiPK4QQ4j6DTGZ/17JlSwAyMjIACAoKAmDZsmVa9VatWsWFCxfYuHGjpuzHH39k//793Lp1C5VKhZ2dHc888wwTJkwAoKCggG+//Zbjx4+Tnp6OWq2mcePGDB06FF9fX6Ds24xHjx7l4MGD3Lhxg5ycHBwdHenatStjxozB0tLykfWFEEIYo1qRzFJSUgCq/Mzs559/Zv369QwePJhJkyZhYmJCcnIy//3vfzV1/vWvf3H48GECAwNp3rw5+fn53Lx5k6ysrAe2nZSUhI+PD35+flhaWpKYmEh4eDgJCQkEBwdX/SSFEEKUyyCTWUlJCcXFxdy7d0/zzKxdu3Z07dq1Su3ExcVRr149XnnlFU1Zx44ddep4eXkxdOhQTVmXLl0qbHvMmDGa3xVFwcPDA1dXV4KCgrh27Rru7u5VilUIIUT5DDKZvfPOO1qfmzRpwrx58zA1Na1SO61bt2bfvn18/PHHPPvss7Rt2xYbGxutOq1ateLIkSN89dVXeHt707p1a9RqdYVt37p1i5CQEGJjY7l79y6Komi2JSYmVpjMkpOTSU5OBu4nVCGEEOUzyGQ2a9YsXF1dycvL49ixY+zfv59PPvmEDz74oErt9O7dm+LiYiIiIlixYgWKotCqVSvGjx+Pl5cXAK+88goODg4cPXqU8PBwLCws8PLyYtKkSeXe1szLy2POnDlYWFgQGBiIs7MzarWa1NRUli9fzr179yqMbcOGDSxatKhK5yOEEMbKIJOZq6urZjRjhw4dKCkpISIigl9++YUePXpgbm5Obm6uzn6ZmZk6Zf369aNfv37k5+dz8eJFQkNDWbJkCevXr8fR0RFLS0sCAgIICAggPT2dmJgYvvrqK5YsWcK6devKjC82NpY7d+6wbNky2rdvrynPycmp9DlOmzYNPz8/4P6VWWBgYKX3FUIIY1MrZgB5+eWXsbKyIjQ0lJKSEho1akRSUhKFhYWaOpmZmcTHx5fbhqWlJT4+PowaNYqioiJu3rypU8fW1pa+ffvy3HPP8ccff1BQUFBmWyqVCgAzM+3vCvv376/0OTk5OeHt7Y23tzceHh6V3k8IIYyRQV6Z/Z2VlRX+/v5s2bKFI0eO0KtXL/bv38/KlSt54YUXyMzM5Pvvv6du3bpa+61evRoLCws8PDywtbUlIyODHTt2UK9ePc2V39tvv03nzp1p1qwZVlZWJCYmcvjwYdq0aVPus7M2bdpgZWXFunXrGDt2LGZmZkRFRXH9+vVH3RVCCGGUakUyAxg8eDD79u1j27ZtrFmzhjfffJPw8HCCg4Np1KgR48aN4+zZs1y4cEGzT9u2bYmMjOTYsWNkZ2djY2ND27ZtmTVrFvXr1wfuv5R9+vRpdu/eTUFBAfb29vTp04dRo0aVG4uNjQ0LFixg06ZNfPrpp1haWtK1a1feeecdZs2a9cj7QgghjI1K+eswO/FEiomJwcfHh+jo6CpPmyXrmQkhjEGteGYmhBDCuEkyE0IIYfAkmQkhhDB4ksyEEEIYPElmQgghDF6tGZovyiYjEoUQxkCuzIQQQhg8SWZCCCEMntxmNAB5eXmALAUjhKh92rRpozPVoD4kmRmA0jkdZeZ8IURto8/MRmWR6awMQGpqKgcOHKBZs2bUqVOn0vuVLh0TEhIiM+//hfRL2aRfdEmflK06+0WuzIyIg4MD48eP13t/Dw+PavnmU9tIv5RN+kWX9EnZnqR+kQEgQgghDJ4ks1rMycmJhQsX4uTkVNOhPFGkX8om/aJL+qRsT2K/yDMzIYQQBk+uzIQQQhg8SWZCCCEMnoxmrIXy8vIICQnhl19+ISsrC1dXV0aOHMlzzz1X06FVyvnz54mKiiI+Pp7U1FTq1atHy5YtGTt2LC1bttSq+9tvv7FlyxYuX76Mqakpnp6eTJ48mcaNG+u0u3fvXvbt20dKSgp2dnb07duXUaNGYWam/b9BRkYGW7Zs4cyZMxQUFODu7k5gYCAdO3bUafM///kP3377LdeuXUOtVtOlSxdefvllGjRoUK19UpaIiAhWr16NpaUl27dv19pmbP1y6dIlduzYQXx8PIWFhdjb29O7d2/Gjh2rqWNsffLbb78RFhbGlStXyM7OpmHDhvj6+jJ8+HDUarVWvdrQL/LMrBZasGABV65cYeLEiTg7O/Pzzz8TERHBW2+9ha+vb02HV6EVK1aQlZVFjx49aNq0KXfv3mXXrl1cvXqVDz74QPM/RGJiIm+99Rbu7u74+/tz7949QkNDyc7O5vPPP6d+/fqaNrdv3863337LyJEj8fLy4sqVK4SEhNCnTx9mzpypqVdYWMjs2bPJyclhwoQJ1K9fnx9//JGzZ8+yZMkS2rdvr6l74cIF5s+fT+fOnRk4cCB3797lq6++wsrKik8//RRzc/NH1kdpaWnMnDkTtVpNbm6uVjIztn45cuQIn332GT169MDX1xdLS0tu3brFnTt3NMnM2Prk5s2bzJ49GxcXF0aNGoW1tTUXL15k+/btdO7cmffff7/29YsiapUzZ84oQ4YMUaKiorTK58+fr0ycOFEpKiqqocgqLz09XacsNzdXeemll5T3339fU7ZixQpl/PjxSk5OjqYsJSVFGT58uLJ582ZN2d27d5WRI0cqq1ev1mpz27Ztip+fn3Ljxg1N2b59+5QhQ4YocXFxmrKioiLl1VdfVd566y2t/WfPnq28+uqrWn166dIlZciQIcq+ffuqfN5VsXjxYmXJkiXKZ599powaNUprmzH1S2pqqjJq1Chl7dq1D6xnTH2iKIryzTffKEOGDFGSkpK0ylevXq0MGTJEycrKUhSldvWLPDOrZU6ePEmdOnXo2bOnVnnfvn25c+cOCQkJNRRZ5ZV1e6FOnTo0adKE1NRUAIqLizlz5gzdu3fXmj3A0dERT09PTp48qSmLiYnh3r179O3bV6vNfv36oSiKVt0TJ07g4uJCmzZtNGWmpqb06tWLhIQE0tLSgPtXRleuXKF3796Ymppq6np4eODi4qLVZnU7fPgwFy5cYPr06TrbjK1fIiIiyM/PZ+TIkeXWMbY+KY0DoF69elrl9erVw8TEBDMzs1rXL5LMapkbN27g6uqq9R8HgLu7u2a7IcrJyeH333+nSZMmACQnJ3Pv3j2aNWumU7dZs2aa7fC/c/57XTs7O2xsbLh586am7ObNm+W2Wbr9QW0CuLm5abVZnTIyMti4cSMTJ07EwcFBZ7ux9cvFixextrYmMTGRN954g2HDhvHSSy+xdu1acnNzAePrE4A+ffpQr1491q5dy61bt8jNzeXMmTMcOHCAgQMHYmlpWev6RQaA1DJZWVk0atRIp9zKykqz3RCtX7+e/Px8Ro8eDfzvPErP66+srKxQFIXs7Gzs7OzIysrC3NwcS0tLnbrW1tZafZKVlYW1tXWZ9QAyMzMrPL61tbWmXnVbv349Li4uvPjii2VuN7Z+SUtLo6CggA8//BB/f3+mTJnClStXCA0N5caNG5rnr+XFVBv7BKBRo0Z8/PHHLFu2jFdeeUVTPmTIEKZMmVJhXIbYL5LMaiGVSqXXtidVSEgIR44c4ZVXXtEZzVjZc62u8/57O+W1+yj6+fjx45w+fZpVq1ZV2L6x9IuiKNy7d48JEybg7+8PgKenJ2ZmZmzcuJHz589rRu4ZS58ApKSksGTJEho0aMCcOXOwsbEhISGB7du3k5eXx+uvv16p4xtSv8htxlrm79+SSmVnZwNlfwt6km3dupXt27cTGBjI4MGDNeWl3/LKO1eVSqV5XmBtbc29e/coKCjQqfv3b5Hl9V9pWWndBx2/vG+mDyMvL4/169czePBg7OzsyM7OJjs7m6KiIuD+Oefn5xtdv5S25+XlpVXu4+MD3B92bmx9AvD111+Tm5vLokWL6N69O+3bt2fEiBFMmTKFn376iQsXLtS6fpFkVsu4ubmRmJhIcXGxVnnpmmhubm41EJV+tm7dytatWxk3bpzm9mIpJycnLCwsNOf1V9evX9dsh//dk/973fT0dDIzM2natKmmzM3NrczniqVlpXVL+7G8un9tszpkZmaSkZHBrl27CAgI0Pz8/PPP5OfnExAQwMqVK42uX8p63gL3r9gATExMjK5PAH7//XeaNm2qc1uwVatWmuPWtn6RZFbLPPPMM+Tl5XH8+HGt8kOHDmFnZ0fr1q1rKLKqCQsLY+vWrYwePZpx48bpbDc1NeXpp5/mxIkTmgf9AH/++Se//vorzzzzjKbM29sbCwsLIiMjtdqIjIxEpVLRrVs3TVm3bt1ITEzk8uXLmrLi4mKioqJo3bo19vb2ANjb29O6dWuioqK0vjjEx8fzxx9/aB2/Otja2hIcHKzz4+XlhYWFBcHBwQQGBhpdv3Tv3h24v8DjX5V+fuqpp4yuT+D+wIybN29qVqn/6zFLY6pt/SIvTddCCxYs4OrVq0ycOBEnJyfNS9OzZ8+mV69eNR1ehXbu3MnmzZvx9vbWmsGhVOmQ39IXPps3b671wmdWVla5L3z6+/trvfDZu3dvnRc+Z82aRW5uLhMnTtS88HnmzBmdFz5//fVXFixYQJcuXbRe+KxXr94jf2m61KpVqzh+/HiZL00bS78sXbqUc+fOMXr0aJ566imuXr1KWFgYHTt2ZP78+UbZJ6dOnWLZsmW0bt2aoUOHYm1tzeXLlwkPD8fBwYFVq1Zhbm5eq/pFklktVDqd1bFjxzTTWfn7+xvMdFZBQUFcuHCh3O27d+/W/H716lW++uor4uPjMTU1pUOHDkyaNKnMpSn27NnDjz/+SEpKCra2tvTt25fRo0frTMWTnp7Oli1bOHv2rGYqnvHjx9OpUyedNs+dO0doaKhmKp7OnTszadKkxzKdFZSdzMC4+qWgoICwsDCOHDlCeno6dnZ2+Pr6Mm7cOK0/hsbUJwCxsbGEh4dz/fp1cnJyaNiwIV26dMHf3x8bGxtNvdrSL5LMhBBCGDx5ZiaEEMLgSTITQghh8CSZCSGEMHiSzIQQQhg8SWZCCCEMniQzIYQQBk+SmRBCCIMnyUwIIYTBk2Qmap0tW7agUqmwtLQscxLTXr16aU2p8zhFRUWhUqn47rvvauT4VXX9+nUGDRqEnZ0dKpWKN998s6ZDqjY//vgjH3zwQU2HIaqJJDNRaxUUFPD+++/XdBgGbdasWZw6dYpNmzZx4sQJZs2aVdMhVZsff/yRRYsW1XQYoppIMhO11oABAwgNDeX8+fM1Hcpjl5eXR3XMVHfhwgWefvpphg0bRrdu3aq0hJCiKDqztj8J/jpDvKg9JJmJWuvdd9/F3t6e995774H1rl+/jkqlYsuWLTrbVCqV1q2oDz74AJVKRWxsLKNGjaJ+/frY2dkxe/ZsioqKuHz5MgMGDMDa2ppmzZrx0UcflXnM/Px8Zs+eTePGjalTpw6+vr6cO3dOp97Zs2fx8/PDzs4OS0tLvLy8dCYVLr2tGhERweTJk2nYsCF169YtcyHFUjdv3iQwMBBHR0fUajUeHh6sXLmSkpIS4H+3Q69evcq///1vVCoVKpWqzLWv/tpXM2fOZP369Xh4eKBWq/nqq68AuHLlCgEBAVrHW7Nmjdb+pccMCQmpVN/s3r2bZ555hrp162JtbU3//v05ceKEVp3Sf18xMTH4+/tja2tLixYtePnllzXHLz23v57fjh076Nq1K/Xr16du3bo0b96cyZMnl3vuouZJMhO1lrW1Ne+//z4HDhzg0KFD1dr26NGj6dixI+Hh4UydOpXPPvuMWbNmMWzYMAYNGsTOnTvp06cP7733Ht9//73O/kFBQfz+++9s3LiRjRs3kpSURK9evfj99981dQ4fPkyPHj3IyMhg/fr1/PDDD3Tq1IkxY8aUmXgnT56Mubk533zzDd999125y2f8+eefdO/enYiICJYsWcLu3bvp168fb7/9tmYpD29vb06cOEHjxo3p0aMHJ06c4MSJE2XOpP5Xu3btYt26dSxYsIADBw7w7LPPcunSJbp06cKFCxdYuXIle/fuZdCgQbz++utl3uarTN+EhoYydOhQbGxs2Lp1K//6179IT0+nV69eHDt2TKfNESNG0LJlS3bs2MH69euZP38+/v7+AJpzKz2/EydOMGbMGJo3b05YWBj79u1jwYIFmlW9xRNKEaKW2bx5swIoZ86cUQoKCpTmzZsrnTt3VkpKShRFURRfX1+lXbt2mvrXrl1TAGXz5s06bQHKwoULNZ8XLlyoAMrKlSu16nXq1EkBlO+//15TVlhYqDRs2FAZMWKEpuzw4cMKoHh7e2viURRFuX79umJubq5MmTJFU9amTRvFy8tLKSws1DrW4MGDFScnJ6W4uFjrfCdMmFCp/pkzZ44CKKdOndIqnzFjhqJSqZTLly9rytzc3JRBgwZVql1AqV+/vnLnzh2t8hdeeEFxdXVV7t69q1U+c+ZMxdLSUlO/sn1TXFysODs7K56enpo+UBRFycrKUhwdHZXu3btrykr/fS1YsEAn3tdee00p60/gJ598ogBKRkZGpc5bPBnkykzUahYWFixdupSzZ8/q3J57GIMHD9b67OHhgUql4sUXX9SUmZmZ0bJlyzJHVAYEBKBSqTSf3dzc6N69O4cPHwburzEVHx/P+PHjASgqKtL8DBw4kOTkZK2VfAFGjhxZqdgPHTpE27Ztefrpp7XKX375ZRRFeair2D59+mBra6v5nJ+fT2RkJMOHD6du3bo655Gfn8/Jkye12qioby5fvkxSUhIvvfQSJib/+xNmZWXFyJEjOXnypM5zscr2DUCXLl2A+1ff27dv548//qh8B4gaI8lM1Hpjx47F29ubefPmUVhYWC1t2tnZaX22sLCgbt26WFpa6pTn5+fr7N+4ceMyy9LS0gBISUkB4O2338bc3Fzr59VXXwUgNTVVa/+KbgGWSktLK7Ous7OzZru+/t5uWloaRUVFfPHFFzrnMXDgQED3PCrqm9J/lncOJSUlpKenPzCuB3nuuefYtWsXRUVFTJgwAVdXV9q3b8/WrVsr3YZ4/MwqriKEYVOpVHz44Yf079+ff/7znzrbSxPQ3wdMPMwf9YrcunWrzDJ7e3sAHBwcAJg7dy4jRowos42nnnpK6/Nfr2YexN7enuTkZJ3ypKQkrWPr4+8x2NraYmpqyksvvcRrr71W5j7u7u5anyvqm9J/lncOJiYmWleHZcVVkaFDhzJ06FAKCgo4efIky5cvJyAggGbNmvHMM89UqS3xeMiVmTAK/fr1o3///ixevJjs7GytbY0aNcLS0pLY2Fit8h9++OGRxbN161atofM3btzg+PHj9OrVC7ifqFq1asX58+fp3LlzmT/W1tZ6Hbtv375cunSJmJgYrfKvv/4alUpF79699T6vv6tbty69e/fm3LlzdOjQoczzKE1OpSrTNy4uLoSGhmrVy8nJITw8XDPCsSJqtRrgga8PqNVqfH19+fDDDwHKHFUpngxyZSaMxocffoiPjw+3b9+mXbt2mnKVSkVgYCCbNm2iRYsWdOzYkdOnTxMaGvrIYrl9+zbDhw9n6tSp3L17l4ULF2JpacncuXM1dTZs2MCLL77ICy+8wMsvv4yLiwt37twhLi6OmJgYduzYodexZ82axddff82gQYNYvHgxbm5u7Nu3j7Vr1zJjxgxat25dXacJwOeff07Pnj159tlnmTFjBs2aNSMrK4urV6+yZ88enWd0FfWNiYkJH330EePHj2fw4MFMmzaNgoICPv74YzIyMlixYkWl4vL09ATu/3fx4osvYmpqSocOHVi6dCmJiYn07dsXV1dXMjIy+PzzzzE3N8fX17da+0ZUH0lmwmh4eXkxbty4MpPUypUrAfjoo4/Izs6mT58+7N27l2bNmj2SWJYtW8aZM2eYNGkSmZmZPP3004SFhdGiRQtNnd69e3P69GmCg4N58803SU9Px97enrZt2zJ69Gi9j92wYUOOHz/O3LlzmTt3LpmZmTRv3pyPPvqI2bNnV8fpaWnbti0xMTEsWbKE999/n9u3b9OgQQNatWqleW72V5Xpm4CAAOrVq8fy5csZM2YMpqamdOvWjcOHD9O9e/dKxRUQEMAvv/zC2rVrWbx4MYqicO3aNbp27crZs2d57733+PPPP2nQoAGdO3fm0KFDWl+CxJNFpSjVME2AEEI8pKioKHr37s2OHTs074AJUVnyzEwIIYTBk2QmhBDC4MltRiGEEAZPrsyEEEIYPElmQgghDJ4kMyGEEAZPkpkQQgiDJ8lMCCGEwZNkJoQQwuBJMhNCCGHwJJkJIYQweJLMhBBCGLz/DzCdSzIXjpa6AAAAAElFTkSuQmCC\n", + "text/plain": [ + "<Figure size 400x200 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<ggplot: (275238765)>" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(all_reports_by_country) +\\\n", + " geom_bar(aes(x='country_cat', y='count'), stat='identity', fill='#0280c9') +\\\n", + " coord_flip() +\\\n", + " xlab('Country') + ylab('Number of reports') +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " theme(figure_size=(4, 2),\n", + " axis_text_y=element_text(margin={'r': 5}),\n", + " text=element_text(size=12))\n", + "\n", + "plt.save('./plots/reports_by_country.pdf', limitsize=False)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "215\n" + ] + }, + { + "data": { + "text/plain": [ + "array(['US', 'CZ', 'CA', 'GB', 'DE', 'RU', 'UA', 'AR', 'FR', 'PK', 'KW',\n", + " 'PT', 'BH', 'MY', 'RS', 'MT', 'AU', 'NL', 'BE', 'HK', 'MX', 'RO',\n", + " 'PL', 'PH', 'SG', 'NG', 'ID', 'SK', 'JM', 'IT', 'KZ', 'SE', 'BR',\n", + " 'IE', 'FI', 'NO', 'HR', 'ES', 'CH', 'ZA', 'EG', 'MM', 'PE', 'UG',\n", + " 'CL', 'OM', 'TR', 'GR', 'IN', 'HU', 'AT', 'BY', 'SZ', 'NZ', 'IS',\n", + " 'BG', 'TW', 'HN', 'EC', 'JP', 'LB', 'BN', 'CN', 'CO', 'LT', 'GH',\n", + " 'AL', 'UZ', 'EE', 'DK', 'GY', 'AE', 'MA', 'HT', 'IM', 'BO', 'BZ',\n", + " 'PA', 'IL', 'TH', 'KR', 'Unknown', 'DO', 'SA', 'BS', 'MK', 'TT',\n", + " 'LV', 'KG', 'PS', 'VE', 'KN', 'NP', 'QA', 'IQ', 'PR', 'PY', 'SI',\n", + " 'ZW', 'TN', 'IR', 'DZ', 'KE', 'LK', 'CD', 'BM', 'MU', 'KH', 'GE',\n", + " 'CR', 'TZ', 'MZ', 'MQ', 'JE', 'CY', 'MD', 'AW', 'DJ', 'VN', 'SV',\n", + " 'SR', 'AZ', 'BB', 'WS', 'SH', 'GG', 'SN', 'BD', 'UY', 'SX', 'JO',\n", + " 'NA', 'NE', 'AD', 'TJ', 'BA', 'LU', 'VU', 'AM', 'AO', 'GT', 'GU',\n", + " 'NI', 'GM', 'KY', 'GA', 'MO', 'CW', 'SY', 'MG', 'AX', 'BJ', 'NC',\n", + " 'RW', 'CM', 'MP', 'RE', 'FO', 'CU', 'BI', 'VC', 'LA', 'ZM', 'SD',\n", + " 'BT', 'CI', 'VG', 'FJ', 'SC', 'DM', 'KM', 'CV', 'BF', 'AG', 'MV',\n", + " 'VI', 'PM', 'YT', 'GI', 'AF', 'XK', 'LY', 'MS', 'ET', 'BW', 'YE',\n", + " 'AI', 'PW', 'MN', 'GP', 'GN', 'GD', 'MC', 'PF', 'ME', 'TC', 'LC',\n", + " 'BQ', 'SO', 'ML', 'LR', 'BL', 'KI', 'TG', 'SL', 'MW', 'CG', 'CF',\n", + " 'PG', 'GL', 'MR', 'MF', 'GF', 'TM', 'WF'], dtype=object)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(len(filtered_or_reports['country'].unique())) # Including unknown\n", + "filtered_or_reports['country'].unique()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "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>reason</th>\n", + " <th>count</th>\n", + " <th>reason_cat</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>Can't login</td>\n", + " <td>3654</td>\n", + " <td>Can't login</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>Can't upload pics</td>\n", + " <td>4548</td>\n", + " <td>Can't upload pics</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>Everything is down</td>\n", + " <td>2613</td>\n", + " <td>Everything is down</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>Hashtags not working</td>\n", + " <td>408</td>\n", + " <td>Hashtags not working</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>Message read problems</td>\n", + " <td>1127</td>\n", + " <td>Message read problems</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>Message send problems</td>\n", + " <td>994</td>\n", + " <td>Message send problems</td>\n", + " </tr>\n", + " <tr>\n", + " <th>6</th>\n", + " <td>Mobile app crashes</td>\n", + " <td>3929</td>\n", + " <td>Mobile app crashes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>7</th>\n", + " <td>Mobile app not working</td>\n", + " <td>15533</td>\n", + " <td>Mobile app not working</td>\n", + " </tr>\n", + " <tr>\n", + " <th>8</th>\n", + " <td>Newsfeed</td>\n", + " <td>4161</td>\n", + " <td>Newsfeed</td>\n", + " </tr>\n", + " <tr>\n", + " <th>9</th>\n", + " <td>Unknown</td>\n", + " <td>1708</td>\n", + " <td>Unknown</td>\n", + " </tr>\n", + " <tr>\n", + " <th>10</th>\n", + " <td>Website down</td>\n", + " <td>2899</td>\n", + " <td>Website down</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " reason count reason_cat\n", + "0 Can't login 3654 Can't login\n", + "1 Can't upload pics 4548 Can't upload pics\n", + "2 Everything is down 2613 Everything is down\n", + "3 Hashtags not working 408 Hashtags not working\n", + "4 Message read problems 1127 Message read problems\n", + "5 Message send problems 994 Message send problems\n", + "6 Mobile app crashes 3929 Mobile app crashes\n", + "7 Mobile app not working 15533 Mobile app not working\n", + "8 Newsfeed 4161 Newsfeed\n", + "9 Unknown 1708 Unknown\n", + "10 Website down 2899 Website down" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "insta_reports_by_reason = instagram_or_reports.groupby('reason')['id'].count().reset_index().rename(columns={'id': 'count'})\n", + "reasons_sorted = insta_reports_by_reason.sort_values('count')['reason'].values\n", + "insta_reports_by_reason['reason_cat'] = pd.Categorical(insta_reports_by_reason['reason'], categories=reasons_sorted, ordered=True)\n", + "insta_reports_by_reason" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 4 x 3 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: ./plots/insta_reports_by_reason.pdf\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAEnCAYAAABVFmKoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAA9hAAAPYQGoP6dpAACOt0lEQVR4nOzdeXxN1/74/9fJPEuCEENiaCKjRCJUzUS1WjHP8625dTtofU1VxHS1Wr0fvbiUKkIMMRNDNIaiRWQixiKGSEISmaeT8/vDL/s6TkKixng/Hw+POmuvvfd7r9Dzttbaa6k0Go0GIYQQQogKQu9lByCEEEII8SxJciOEEEKICkWSGyGEEEJUKJLcCCGEEKJCkeRGCCGEEBWKJDdCCCGEqFAkuRFCCCFEhSLJjRBCCCEqFEluhKggsrOziYiIIDs7+2WHIoQQL5UkN0JUEOfPn8fX15fz58+/7FCEEOKlkuRGCCGEEBWKJDdCCCGEqFAMXnYAQoiXT3/Gny87BCFEBaf+pskLu5f03AghhBCiQnmlk5uwsDACAgIICAggJiZG57hGo2HkyJEEBAQwefLkp7pHQEAAS5YseWK9mJgYnTiCgoIICAh4qvu+yTZs2MCJEydedhhPVPzzTU9Pf2y9hQsXMnz48BcUlRBCiCd5pZObYqampuzfv1+nPDY2ljt37mBqavrcY6hfvz7z58+nfv36z/1eFd2mTZtei+SmrPr06cOkSZNedhhCCCH+f69FctOyZUuOHTums37H/v37cXFxoWrVqs89BjMzM1xcXDAzM3vu9xIvV15eHhqNpsz17e3tJekVQohXyGsxobhly5aEh4dz+PBh3nvvPQCysrI4duwYI0eOZPv27TrnZGRksGbNGv744w/S09OpXLkyrVq1om/fvhgaGurUDw0NZevWrSQlJWFvb0+fPn1o1aqVcjwmJoYpU6Ywe/ZsPD09HxvvkSNH2L59O9euXUOlUuHq6srgwYOf+AV4//59goKCiI2NJTk5GWNjYxwcHOjfvz/u7u5KvcTEREaMGMGQIUNQq9WEhoZy//59HB0dGTJkCF5eXkrdoKAg1q9fzw8//EBwcDBRUVGoVCr8/PwYPnw4lSpVemxMCxcu5NixYyxcuJBly5Zx9uxZLCwsaN68OYMHD9Zqy7K0efEw3sGDBzl48CAAHh4ezJkzp8T7f/HFF1hbWzNt2jSlbNy4cVy/fp0FCxbg5OQEwLFjx5g3bx7//ve/qVOnDgDnzp0jKCiIS5cuoVarqVevHr169cLPz0+5VlhYGD/++CMzZszg8OHDnDx5kvT0dDZt2lRiPDdv3mTGjBlUqlSJqVOnYm1tzcKFC4mNjWX58uVKvYCAADp16kSDBg3YuHEjSUlJ1KhRg0GDBmndH+DEiROsXbuWW7duUblyZTp37kxmZibr168v8c+2EEKIx3stkhszMzOaN2/OgQMHlOTm8OHD6Onp0aJFC50vgPz8fKZMmcKdO3fo168fderU4dy5c2zatImrV69qfVEC/Pnnn8TExNC/f39MTEzYvXs33333Hfr6+jRv3rxcsW7YsIG1a9fSvn17evfuTWFhIVu2bGHSpEl89913ODg4lHpuRkYGAH379sXGxoacnBxOnDjBlClTCAwM1Emqdu3ahZ2dHcOHD0ej0RASEsKMGTOYM2cOLi4uWnXnzp1L8+bNef/994mPj2ft2rXcuHGD7777DgODx/8xKCwsZPbs2fj7+9O1a1fOnj1LcHAw5ubm9O3bFyh7m8+fP5+pU6fSsGFDevfuDfDY3jAvLy92795NYWEhBgYGpKamcv36dYyMjDhz5oyS3ERFRWFtba0kNrGxsUybNo06deowbtw4DAwM2LNnD7NmzeLLL7+kZcuWWvf597//TePGjfn888/Jy8tDX19fJ5bY2FjmzJmDu7s7X375JcbGxo9tt1OnTnH58mX69++PqakpISEhzJkzh8WLF1O9enUATp8+zbx583B3d2fAgAGo1Wq2bNlCWlraY68thBCidK9FcgPg7+/PlClTiI+Px8HBgQMHDtC8efMSvxgPHjzItWvXmDBhAi1atACgUaNGmJiYsGrVKs6cOUOjRo2U+unp6SxYsAAbGxsAfH19GTduHL/++mu5kpvk5GTWrVvHBx98wMiRI5Vyb29vRo8ezfr165kwYUKp59eqVYsxY8Yon9VqNT4+PiQlJbFjxw6d5KaoqIiZM2diZGSkPOOIESNYu3YtgYGBWnWbNWvGsGHDlHrW1tYsWLCAo0eP0qZNm8c+V2FhIf369VPa0svLi8uXL3Po0CEluSlrm7u4uKCnp4eVlZVOAlYSb29vNm/ezIULF3B3dycqKgpTU1Patm1LVFSUkiBFRUVp9VitWrUKc3NzZs+erczJ8vPz47PPPmPlypW0aNEClUql1G/YsCEff/xxqXH89ttv/N///R/vv/8+H330EXp6Tx7Rzc/PZ+bMmcqf0Xr16jFs2DCOHj1Kz549gQc9a7a2tkyfPl3p3fLx8ZEJykII8Te8FnNu4MHQRfXq1dm/fz/Xrl3j0qVL+Pv7l1g3OjoaExMTncSkffv2yvGHeXl5KYkNgL6+Pi1atCAhIYG7d++WOcYzZ86gVqtp27YtarVa+WVkZISHh0eJb3w9as+ePXz22Wf06NGDbt260a1bN6Kiorh586ZO3WbNmimJDTzoAfHz8+Ps2bOo1Wqtuq1bt9b63KJFC/T19csUk0qlokkT7fUJHB0dSU5OVj6Xt83LytXVFSMjI6KiogCIjIzE09MTHx8fzp8/T15eHsnJydy+fVtJbnJzc7l48SLNmzfXmmyur69PmzZtuHv3Lrdu3dK6zzvvvFNqDBs2bODHH39kyJAhjBgxokyJDYCnp6dW8m1jY0OlSpVISkpS4rx8+TJvv/221vCeqampTnuXJiEhgYiICCIiIoiLiyvTOUIIUdG9Nj03KpUKf39/duzYQUFBATVr1tSah/KwjIwMrK2ttf5lDmBtbY2+vr4y/FPs4cTm0bKMjAyqVKlSphiLhxLGjx9f4vEnfSlu3bqVFStW8N577zFgwACsrKzQ09Nj7dq1JSY3pcVdWFhIbm4u5ubmpdbV19fH0tJSpy1KYmxsrJVEARgaGpKfn698Lm+bl5WRkRGurq5ERkbSv39/oqOj6d69Ox4eHhQVFXH27Fnu3bsHoCQ3mZmZaDSaEtvH1tYWQOf17uLykoSHh1O5cmWdoawnsbS01Cl7uN2K47S2ttapV1JZSZYuXcqMGTPKFZcQQlR0r01yAw96AYKCgggNDWXgwIGl1rO0tOTixYtoNBqtL9u0tDTUarXOl05qaqrONYrLSvqCKo2VlRUAEydOfKo3uMLDw/H09GTs2LFa5Tk5OSXWLy1uAwMDTExMdMorV66sfFar1WRkZJTr+R6nvG1eHg0bNiQoKIiLFy9y9+5dvL29MTMzw8nJicjISFJSUqhZs6bS5hYWFujp6ZXYPikpKcD/flZlMX36dObPn8/EiROZNWsWdnZ2T/0sD7OwsEClUpU4v6ak2EsyatQoZZJ2XFzcY/9eCCHEm+K1GZYCqFy5Mt26dcPPz4927dqVWq9hw4bKZNyH/fbbbwBaczPgwXyNh79M1Go1R48epXr16mXutYEHc0z09fVJSEjAycmpxF+Po1KpdCb3Xr16lQsXLpRY//jx41q9J9nZ2Zw8eRJ3d3edCbGHDh3S+nz06FHUajUeHh5lfr7HKU+bP9rr8yTe3t6o1WrWrl1LlSpVqFWrlnLNqKgooqOjta5vYmKCs7Mzx48fJy8vTykvKioiPDycKlWqULNmzTLf387Ojnnz5mFoaMjEiRO5fft2mc99HBMTE9566y1OnDhBQUGBUp6Tk8PJkyfLdA17e3t8fHzw8fHB1dX1mcQlhBCvu9eq5wZgyJAhT6zTrl07du/ezcKFC0lKSsLR0VF5c6dx48Z4e3tr1beysmLq1Kn06dNHeVvq5s2bfPXVV+WKrVq1avTv3581a9aQmJiIj48PFhYWpKWlcfHiRUxMTOjfv3+p5/v5+REcHExQUBDu7u7cunWL4OBg7OzsKCoq0qmvp6fHtGnT6NKlCxqNhs2bN5OdnU2/fv106h4/fhw9PT28vb2Jj48nKCiIunXrKpN//67ytLmjoyMxMTH8+eef2NjYYGpqqiQsJalfvz4WFhacOXNGmcMDD5Kb4OBg5fcPGzx4MNOmTWPKlCl069YNAwMDdu/eTXx8PF9++aXO8NmT2NraMnfuXL755hsmTZrEzJkzcXR0LNc1StK/f38CAwOZPn06nTt3pqioiJCQEExNTcnMzPzb1xdCiDfRa5fclIWRkRGzZ89m9erVbNmyhfv371O5cmW6du1a4hd/kyZNcHBwYM2aNdy9e5fq1aszfvz4cs+xAOjVqxe1a9dmx44dHD58mIKCAmxsbHjrrbd4//33n3huXl4e+/fvJyQkhNq1azNmzBhOnDhBbGysTv0PPviAgoICli1bRlpaGg4ODkybNg03NzedupMmTWLdunWEhoYCKOvclLTmz9MoT5uPGDGCJUuW8O2335KXl/fYdW7gQRLn4eHBiRMntJIkFxcXTExMyM/P13mTzMPDg1mzZhEUFMSPP/5IUVERdevWZerUqTrrzJSVlZUVs2bNYubMmUyePJnp06c/sTfuSXx9fZk4cSJr165l/vz52NjY0KlTJ1JSUpReLyGEEOWj0pRnKVbxSihexG/YsGF069btsXWLF/Fbs2ZNueaZiJensLCQTz/9lMqVKzNz5swynxcREYGvry+nT5/Gx8enXPeUXcGFEM/bi9wVvEL23AjxOvn3v/+Nt7c3tra2pKamEhoays2bNxkxYsTLDk0IIV5LktwI8ZLl5OSwcuVK7t+/j4GBAfXq1WPatGk6c8OEEEKUjQxLCVFByLCUEOJVJsNSQogX6kX+T0cIIZ6312qdGyGEEEKIJ5HkRgghhBAVigxLCSFkzs0zJEN8Qrx80nPzgl29epUff/yR4cOH06NHD3r37s1nn33G5s2bn3pzybIKCAggLCxM+RwXF0dQUNBLXQk3LCyMgIAAEhMTK8S9hw8fzsKFC5/Z9YQQQpSf9Ny8QHv37mXJkiXUrFmT7t27U7t2bQoLC7l8+TKhoaFcuHCByZMnv7B4zp8/z/r162nfvj0WFhYv7L4V2aRJkzAzM3vZYQghxBtNkpsX5Pz58yxevBhvb2+mTJmite1Bo0aN6Nq1KxERES8xQvEs1K9f/2WHIIQQbzxJbl6QjRs3olKp+Pjjj0vcz8nQ0JCmTZsqn48cOcL+/fu5fv06WVlZ2NnZ0bRpU2Vzz2ILFy7k2LFjLFy4kGXLlnH27FksLCxo3rw5gwcPLnXvqOJtGQCtlXBnz56ts09TseJepUf3gVq4cCGxsbEsX74c+N/2EEOGDEGtVhMaGsr9+/dxdHRkyJAhOptclmT//v3s2LGDW7duYWxsjIeHB4MGDaJ27dpKnUuXLrF161YuXLhAWloa1tbWNGjQgCFDhmBnZ6d1vfPnz7NixQquXLmCpaUlbdu2pXr16k+Mo/j5jh07xnfffcd///tfLly4gLGxMS1atGDYsGEYGxsrdYcPH46HhwefffaZUpaZmUlwcDAnTpzg3r17mJub89Zbb/HRRx8pG4bu3r2b0NBQ7ty5g0qlwtbWlmbNmjF48OAyxSiEEOJ/JLl5AdRqNdHR0dSvX5+qVauW6Zzbt2/j6+tLQEAAJiYm3Lx5k82bN3Px4kVmz56tVbewsJDZs2fj7+9P165dOXv2LMHBwZibm9O3b1+l3vbt25Xfv/vuu2RmZrJz504mTZqEjY0NAA4ODs/giR/YtWsXdnZ2DB8+HI1GQ0hICDNmzGDOnDm4uLiUet7GjRtZvXo1rVq1YvDgwWRkZLBu3TomTJjAggULqFGjBgBJSUnUrFmTli1bYmFhQWpqKnv27GH8+PH89NNPyl5a8fHxfP3119jZ2fHpp59ibGzM7t27OXz4cJmfpbCwkBkzZtCxY0d69OjB+fPn2bBhA8nJyXz99delnpednc3EiRNJSkqie/fuNGjQgJycHM6ePUtKSgq1atXi8OHDLFmyhA8//JBhw4ahp6dHQkICN27cKHN8Qggh/keSmxcgPT2dvLw8qlWrVuZz+vTpo/xeo9Hg6upKrVq1mDx5MlevXqVu3brK8cLCQvr160eLFi0A8PLy4vLlyxw6dEgruXlYlSpVlESrXr165YqtrIqKipg5cyZGRkbAg+G3ESNGsHbtWgIDA0s8p7iXo3Hjxnz55ZdKuYeHB6NHj2bdunWMHz8egObNm9O8eXOljlqtxs/Pj8GDB3Po0CE6d+4MQHBwMBqNhlmzZilJXOPGjRk3blyZn6WwsJCuXbsq12zUqBH6+vqsWbOGc+fOlbgTOzxIKOPj45k5c6bWdgrvvPOO8vu4uDjMzc0ZOXKkUlaW3i0hhBAlk+TmFXXnzh3WrFlDdHQ09+/f5+FdMm7evKmV3KhUKpo00X791NHRkejo6BcWb0maNWumJDYAZmZm+Pn5cfjwYdRqNfr6+jrnXLhwgfz8fNq1a6dVXrVqVRo2bEhUVJRSlpOTQ3BwMMeOHSMpKYmioiLl2MO9HtHR0Xh5eSmJDYC+vj4tWrRQhubKonXr1jqf16xZQ0xMTKnJTUREBDVr1nzsPlHOzs7s2rWLb7/9lpYtW+Lm5iY7uAshxN8gyc0LYGVlhbGxcZlfOc7JyWHixIkYGRkxcOBAatSogbGxMXfv3mXu3Lnk5+dr1Tc2NtZKIuDBHJ5H671oDycTD5cVFhaSm5uLubm5zvH09HQAbG1tdY7Z2toSGRmpfF6wYAFRUVH06dMHJycn5S2lmTNnaj17RkZGqbGUlb6+vk7CUXz+417hv3///hOHItu2bYtarWbfvn3MmzcPjUaDk5MTAwYMoFGjRo89NyEhgYSEBOBBD5AQQghJbl4IfX19vLy8OH36NHfv3qVKlSqPrR8dHU1KSgpz5szBw8NDKc/KynreoT6WoaEh2dnZOuXFCcmjUlNTSywzMDDQmhT9sOIEIiUlRedYSkqKcjwrK4uTJ0/St29fevbsqdQpKCjQSTYsLS1LjaWs1Go16enpWglO8fmWlpalnlepUiXu3bv3xOv7+/vj7+9Pbm4uZ8+eJSgoiMDAQJYsWaIzOfphS5cuZcaMGWV+DiGEeBPIIn4vSM+ePdFoNCxatIiCggKd44WFhfz554NVYlUqFQAGBtq5Z2ho6DONqfhNqrL28FSrVo3bt29rxZ+ens758+dLrH/8+HGta2dnZ3Py5Enc3d1LHJICaNCgAUZGRoSHh2uV3717l+joaBo2bAg8aCONRqPzNti+ffu0hqcAZTjr4WRGrVZz9OjRJz/0Qw4dOlTi59LeLgPw8fHh1q1bWsNpj2NiYoKvry+9evWisLCQ+Pj4x9YfNWoUp0+f5vTp06xZs6ZM9xBCiIpOem5eEBcXF8aMGcOSJUv44osveP/993FwcKCwsJC//vqLvXv34ujoSJMmTXBxccHCwoLFixfTt29fDAwMCA8P59q1a880JkdHRwB27NhBu3bt0NfXp2bNmqUuQtemTRtCQ0NZsGABHTt2JD09nZCQkFLr6+npMW3aNLp06YJGo2Hz5s1kZ2fTr1+/UmOysLCgT58+rF69mh9++IFWrVqRnp7O+vXrMTIyUs41MzPD3d2dLVu2YGVlhZ2dHbGxsRw4cEBnuKt379788ccfTJ06lb59+2JsbMyuXbvIzc0tc1sZGBiwdetWcnJycHJyUt6W8vX1LXW+DTxYFfro0aPMmTOHHj164OTkRH5+PrGxsfj5+dGwYUMWLVqEkZERrq6u2NjYkJaWxsaNGzE3N8fJyemxcdnb22Nvb1/m5xBCiDeBJDcvUMeOHXF2dmbbtm1s3rxZGaKpUaMGrVu35oMPPgAeDM1MmzaNFStW8P3332NiYkLTpk356quv+Pzzz59ZPJ6envTs2ZODBw8qPR6PW+fGzc1N2Spi9uzZVKtWjX79+nHq1CliY2N16n/wwQcUFBSwbNky0tLScHBwYNq0aY9NBgB69epFpUqV2LlzJ0eOHNFa56b4NXCAL7/8kmXLlvHLL7+gVqtxdXVl5syZzJw5U+t6jo6OBAYGsmLFChYuXIiFhQVt2rThnXfe4aeffipTWxkYGPD111+zbNkyNmzYgLGxMe+++y7Dhg177HlmZmbMmzePdevWsXfvXtavX68kLR07dlTaNSwsjKNHj5KZmYmVlRVubm58/vnnVKpUqUzxCSGE+B+V5uHXcIR4BooX8Rs2bBjdunV72eH8bcWL+G3YsOFlh/JYERER+Pr6cvr0aXx8fMp1rmyc+ezIxplCvHwy50YIIYQQFYokN0IIIYSoUGTOjXjmqlWrprXVw+vus88+09orSgghxKtNem6EEEIIUaFIz40QQibBCiEqFOm5EUIIIUSFIj03Qgh5FbycpKdLiFeb9NwIIYQQokKR5EY8d2FhYQQEBNCjRw+SkpJ0jk+ePJlPPvnkJURWuqioKL744gt69epFQEAAJ06ceKH3DwgIICgo6IXeUwghKgpJbsQLU1BQ8Fps7qjRaJg/fz76+vpMnTqV+fPna+3OLoQQ4tUmyY14YXx8fDh8+DBXr1592aE8VkpKChkZGbz99tt4eXkpG5kKIYR4PciEYvHCdO/enStXrvDLL78wY8aMUutpNBr27NnD3r17uXXrFoaGhnh5eTF06FCqV68OwK5du/jvf//LqlWrsLa2BmDLli2sXLmSTp06MXr0aACKiooYMGAA/v7+fPTRRwDs3r2b0NBQ7ty5g0qlwtbWlmbNmjF48GCCgoJYv349AKtWrWLVqlXY2dmxfPlyAG7fvk1QUBBRUVFkZWVRvXp1PvjgA2XT02LZ2dmsX7+eY8eOkZKSgpWVFc2bN2fQoEGYmJho1VuxYgXHjx+noKAAV1dXRo4c+WwaXAgh3lCS3IgXxtTUlN69e7Ns2TKioqLw8vIqsd5PP/3EwYMH+fDDDxkyZAgZGRkEBwczYcIEfvzxR2xsbPDy8kKj0RAVFUXr1q2BB/NkjIyMiIyMVK51+fJlsrKy8Pb2BuDw4cMsWbKEDz/8kGHDhqGnp0dCQgI3btwA4N1336Vu3brMnTuXDz/8kFatWmFoaAhAfHw8/+///T+qVKnCP/7xD6ytrTlz5gzLli0jPT2dfv36AZCXl8ekSZO4d+8evXr1ok6dOsTHxxMUFMT169cJDAxEpVKh0WiYPXs258+fp0+fPjg5OREXF/fYxE8IIcSTSXIjXqj33nuPHTt2sGrVKhYsWIBKpdI6fv78efbt28c//vEPunbtqpS7u7szevRotm3bxtChQ6lVqxZVqlRRkpuCggLOnTtH586d2bx5M8nJyVStWpXIyEgMDAxwd3cHIC4uDnNzc63ekYeTrCpVqqBWqwGoWrUqLi4uyrGff/4ZU1NT/vWvf2FmZgZAo0aNKCgoYPPmzXTu3BkLCwt27NjB9evX+fbbb3FyclLuUblyZebNm6fs3h0REUFMTAwjRoygc+fOyvUMDAxei7lJQgjxqpI5N+KFMjQ0ZMCAAVy+fJmjR4/qHD916hQqlYo2bdqgVquVXzY2NtStW5fY2FilbsOGDYmKigIeJEV5eXl06dIFKysrzpw5AzzozWnQoIEyFOTs7ExWVhbffvstJ06cID09vUxx5+fnEx0dzdtvv42xsbFWbI0bNyY/P58LFy4AcPLkSRwcHKhXr55WvUaNGqFSqYiJiQFQ/lvc81Ts0c+Pk5CQQEREBBEREcTFxZX5PCGEqMik50a8cK1atWLr1q2sXr2aZs2aaR1LS0tDo9EwePDgEs8tnnMDD3pDDh48yO3bt4mKiqJevXpYW1srSU/r1q05f/48vXr1Us5p27YtarWaffv2MW/ePDQaDU5OTgwYMIBGjRqVGnNGRgZqtZqdO3eyc+fOEusUJ0ppaWkkJCTQrVu3x9bLyMhAX18fKysrreM2NjalxvGopUuXyjCWEEI8QpIb8cKpVCqGDBnCtGnT2Lt3r9YxS0tLVCoVc+fOVea6POzhsuLhpMjISCIjI5V5NQ0bNmTt2rWcPXuWgoICpbyYv78//v7+5ObmcvbsWYKCgggMDGTJkiXY2dmVGLOFhQV6enq0bduWTp06lVinWrVqAFhZWWFkZMQ///nPEusVJzOWlpao1WrS09O1EpzU1NQSzyvJqFGjCAgIAB4MuQ0cOLDM5wohREUlyY14Kby9vfH29mb9+vVUrVpVKffz82Pz5s2kpKTQokWLx17D1taW2rVrc/z4cS5fvsygQYOUa//nP/9h27ZtmJmZKfNeHmViYoKvry8FBQXMmTOH+Pj4UpMbY2NjPD09+euvv6hTp06JidfDz7Bx40YsLS21epoe5enpSUhICIcOHVLm3AAcOnTosc/9MHt7e+zt7ctcXwgh3gSS3IiXZsiQIXzxxRfcv38fBwcHANzc3OjYsSM//vgjly5dwsPDA2NjY1JTUzl37hyOjo5aPSdeXl7s3LkTIyMjXF1dgQdDV9WqVePMmTM0adIEfX19pf6iRYuUujY2NqSlpbFx40bMzc1LTYKKjRgxgokTJzJp0iTef/997OzsyMnJISEhgT///JPZs2cDD1YXPnbsGJMnTyYgIIA6deqg0WhITk7mzJkzdO3alQYNGtCoUSPc3d355ZdfyM3N5a233iIuLo7w8PBn3NJCCPFmkeRGvDT169enVatWOj0VH3/8MQ0aNCA0NJQ9e/ZQVFSEra0trq6uODs7a9UtTm7c3NwwMjLSKt+3b5/OkJSbmxthYWEcPXqUzMxMrKyscHNz4/PPP6dSpUqPjdfBwYEffviB4OBg1qxZw/379zE3N8fe3p7GjRsr9UxMTJg3bx6bNm1i7969JCYmYmxsTJUqVfD29lZ6h/T09Jg6dSo///wzISEhFBYW4urqyrRp0xg7duzTNKkQQghApdFoNC87CCHE31f8ivnp06fx8fEp17myK3j5yK7gQrza5FVwIYQQQlQoktwIIYQQokKR5EYIIYQQFYokN0IIIYSoUORtKSGETJAVQlQo0nMjhBBCiApFem6EEPIq+BNIz5YQrxfpuRFCCCFEhSLJTRmEhYUREBBAQEAAMTExOsc1Gg0jR44kICCAyZMnP9U9AgICWLJkyRPrxcTE6MQRFBSkbJ4onr+FCxfSu3fvlx2GEEKIUkhyUw6mpqbs379fpzw2NpY7d+5gamr63GOoX78+8+fPp379+s/9XkIIIcTrSJKbcmjZsiXHjh0jOztbq3z//v24uLho7W79vJiZmeHi4oKZmdlzv1dFkJeX97JDEEII8YLJhOJyaNmyJeHh4Rw+fJj33nsPgKysLI4dO8bIkSPZvn27zjkZGRmsWbOGP/74g/T0dCpXrkyrVq3o27cvhoaGOvVDQ0PZunUrSUlJ2Nvb06dPH1q1aqUcj4mJYcqUKcyePRtPT8/HxnvkyBG2b9/OtWvXUKlUuLq6Mnjw4Cf2+ty/f5+goCBiY2NJTk7G2NgYBwcH+vfvj7u7u1IvMTGRESNGMGTIENRqNaGhody/fx9HR0eGDBmCl5eXUjcoKIj169crG09GRUWhUqnw8/Nj+PDhT9y0EuDChQts2LCB8+fPk5ubS+XKlfHz82PEiBE699i4cSNRUVEYGRmxatUqLl26xNatW7lw4QJpaWlYW1vToEEDhgwZomxkCQ+SobVr13Ls2DFSU1MxNjamevXqdOnShdatW2vFc/v2bZYtW8bZs2exsLCgefPmDB48WOvnWlBQQEhICOHh4SQmJmJmZoafnx9Dhw7VeuaoqCiCg4O5fv06eXl5WFlZ4eTkxBdffIGxsfET20YIIcT/SHJTDmZmZjRv3pwDBw4oyc3hw4fR09OjRYsWOslNfn4+U6ZM4c6dO/Tr1486depw7tw5Nm3axNWrV5k2bZpW/T///JOYmBj69++PiYkJu3fv5rvvvkNfX5/mzZuXK9YNGzawdu1a2rdvT+/evSksLGTLli1MmjSJ7777DgcHh1LPzcjIAKBv377Y2NiQk5PDiRMnmDJlCoGBgTpJ1a5du7Czs2P48OFoNBpCQkKYMWMGc+bMwcXFRavu3Llzad68Oe+//z7x8fGsXbuWGzdu8N1332FgUPofx4iICGbNmkWtWrX4xz/+QdWqVUlKSuLMmTM6defOnUvLli157733yM3NBSApKYmaNWvSsmVLLCwsSE1NZc+ePYwfP56ffvoJKysrAH7++Wd+++03Bg4cSL169cjNzSU+Pl5pk2KFhYXMnj0bf39/unbtytmzZwkODsbc3Jy+ffsCUFRUxOzZszl37hzdu3fHxcWFpKQk1q1bx+TJk/n+++8xNjYmMTGRwMBA3NzcGDduHBYWFty7d4+IiAgKCgokuRFCiHKS5Kac/P39mTJlCvHx8Tg4OHDgwAGaN29e4jDRwYMHuXbtGhMmTKBFixYANGrUCBMTE1atWsWZM2do1KiRUj89PZ0FCxZgY2MDgK+vL+PGjePXX38tV3KTnJzMunXr+OCDDxg5cqRS7u3tzejRo1m/fj0TJkwo9fxatWoxZswY5bNarcbHx4ekpCR27Nihk9wUFRUxc+ZMjIyMlGccMWIEa9euJTAwUKtus2bNGDZsmFLP2tqaBQsWcPToUdq0aVNqTEuWLKFKlSp89913yn3gwc/jUe3ataN///5aZc2bN9dqQ7VajZ+fH4MHD+bQoUN07twZgLi4OBo1akSXLl2Uun5+fjr3KCwspF+/fsrP1cvLi8uXL3Po0CEluTl69CgRERFMnDiRd955Rzm3bt26jB8/nrCwMDp16sSVK1fIz89n2LBh1K1bV6n3aE+REEKIspE5N+Xk4eFB9erV2b9/P9euXePSpUslfsECREdHY2JiopOYtG/fXjn+MC8vLyWxAdDX16dFixYkJCRw9+7dMsd45swZ1Go1bdu2Ra1WK7+MjIzw8PAo8Y2vR+3Zs4fPPvuMHj160K1bN7p160ZUVBQ3b97UqdusWTOthKN46OXs2bOo1Wqtuo9+Ybdo0QJ9ff3HxnTr1i3u3LlDhw4dtO5TmmbNmumU5eTk8MsvvzBy5Ei6du1Kt27d6N27N7m5udy4cUOp5+TkxOnTp1m1ahUxMTGlztlRqVQ0aaK99omjoyPJycnK55MnT2Jubk6TJk20fg716tXDxsaG2NhY4EGyY2BgwE8//URYWBh37tx54jMWS0hIICIigoiICOLi4sp8nhBCVGTSc1NOKpUKf39/duzYQUFBATVr1tSah/KwjIwMrK2tUalUWuXW1tbo6+vrDHU8nNg8WpaRkUGVKlXKFGNaWhoA48ePL/G4nt7jc9qtW7eyYsUK3nvvPQYMGICVlRV6enqsXbu2xOSmtLgLCwvJzc3F3Ny81Lr6+vpYWlrqtMXD7t+/D1Dm57e1tdUpW7BgAVFRUfTp0wcnJyelp23mzJnk5+cr9UaOHEmVKlU4cuQImzdvxsjIiEaNGjFs2DBq1Kih1DM2NtZJtAwNDbWulZaWRlZWFt27dy8xzvT0dADs7e0JDAwkJCSEpUuXkpubS/Xq1fnwww+f+Ir/0qVLmTFjxhNaRAgh3iyS3DyF9u3bExQURGhoKAMHDiy1nqWlJRcvXkSj0WglOGlpaajVaiwtLbXqp6am6lyjuOzRuo9TPH9k4sSJT/UGV3h4OJ6enowdO1arPCcnp8T6pcVtYGCAiYmJTnnlypWVz2q1moyMjMc+X/HE27L2Xj2aTGZlZXHy5En69u1Lz549lfKCggKdpMrExIT+/fvTv39/UlNTiYiIYNWqVQQGBrJ48eIy3b+YlZUVlpaWTJ8+vcTjDy8d4O7ujru7O2q1msuXL7Nz506WL1+OtbW11oTyR40aNUpJgOLi4h7751EIId4UMiz1FCpXrky3bt3w8/OjXbt2pdZr2LChMhn3Yb/99huA1ttE8OCNmYcTBbVazdGjR6levXqZey3gwVwWfX19EhIScHJyKvHX46hUKp3JvVevXuXChQsl1j9+/LhWj0V2djYnT57E3d0dfX19rbqHDh3S+nz06FHUajUeHh6lxlOzZk2qV6/OgQMHKCgoeGzsJVGpVGg0Gp230/bt20dRUVGp59nY2NC+fXtatWrFrVu3yv1auZ+fHxkZGRQVFZX4M6hVq5bOOfr6+jRo0IDRo0cDcOXKlcfew97eHh8fH3x8fHB1dS1XfEIIUVFJz81TGjJkyBPrtGvXjt27d7Nw4UKSkpJwdHRU3pZq3Lgx3t7eWvWtrKyYOnUqffr0Ud6WunnzJl999VW5YqtWrRr9+/dnzZo1JCYm4uPjg4WFBWlpaVy8eFHpnSiNn58fwcHBBAUF4e7uzq1btwgODsbOzq7EZEBPT49p06bRpUsXNBoNmzdvJjs7m379+unUPX78OHp6enh7exMfH09QUBB169ZVJuaWZvTo0cyaNYsvv/ySLl26ULVqVZKTkzlz5kypw2/FzMzMcHd3Z8uWLVhZWWFnZ0dsbCwHDhzQGjID+PLLL2ncuDF16tTBwsKCmzdv8ttvv+Hi4lLut5ZatmzJoUOHmDlzJp07d8bJyQkDAwPu3r1LTEwMTZs2pVmzZuzZs4fo6GgaN25M1apVKSgoUBaLfPTPiBBCiCeT5OY5MjIyYvbs2axevZotW7Zw//59KleuTNeuXUv84m/SpAkODg6sWbOGu3fvUr16dcaPH0/Lli3Lfe9evXpRu3ZtduzYweHDhykoKMDGxoa33nqL999//4nn5uXlsX//fkJCQqhduzZjxozhxIkTyiTYh33wwQcUFBSwbNky0tLScHBwYNq0abi5uenUnTRpEuvWrSM0NBRAWeempDV/Hubj48OcOXMIDg5m2bJl5OfnU7lyZZo2bVqm9vjyyy9ZtmwZv/zyC2q1GldXV2bOnMnMmTO16nl6evLnn3+yfft28vLyqFy5Mu3ataNXr15lus/D9PX1mTp1Ktu3byc8PJxNmzahr69P5cqV8fDwwNHREXgwofjMmTOsW7eO1NRUTExMcHR0ZOrUqVpv0wkhhCgblUaj0bzsIMTrqXgRv2HDhtGtW7fH1i1eYG/NmjXKnCDxbEVERODr68vp06fx8fEp17myK/jjya7gQrxeZM6NEEIIISoUSW6EEEIIUaHInBvx1KpVq1biflolKX69WgghhHjeJLkRQsicEiFEhSLDUkIIIYSoUKTnRgghb0s9RHqxhHj9Sc+NEEIIISqUv9Vzo9FoOHnyJNevXy9x36HBgwf/ncuL18zVq1fZvn07MTExpKamoq+vT40aNWjZsiXvvvtuufbHKq+AgAA+/fRTZcf1uLg4zpw5Q0BAABYWFk88v3gdnrJOkH4axesCPRynEEKIZ++pk5uLFy8SEBDApUuXKGkdQJVKJcnNG2Tv3r0sWbKEmjVr0r17d2rXrk1hYSGXL18mNDSUCxcuMHny5BcWz/nz51m/fj3t27cvU3LzItja2jJ//nzs7e1fdihCCFGhPXVy8/HHH5Obm0twcDANGzYs9747ouI4f/48ixcvxtvbmylTpmhtpdCoUSO6du1KRETES4zw1WBoaIiLi8vLDkMIISq8p05u/vzzT5YtW0bPnj2fZTziNbRx40ZUKhUff/xxiXtEGRoaau0BdeTIEfbv38/169fJysrCzs6Opk2bKhuGFlu4cCHHjh1j4cKFLFu2jLNnz2JhYUHz5s0ZPHhwqftRFQ8xAYwYMUIpnz17Np6enmV+rqKiIrZs2cKBAwdITEzE3NwcHx8fBg0apLVLu0ajYePGjezdu5e0tDQcHR0ZNGgQGzduBGDOnDlAycNSxbEuWrSI4OBgTp8+jaGhIY0bN2b48OE6G3sKIYR4sqdObiwsLGSPIIFarSY6Opr69etTtWrVMp1z+/ZtfH19CQgIwMTEhJs3b7J582YuXrzI7NmzteoWFhYye/Zs/P396dq1K2fPniU4OBhzc3P69u2r1Ht4rsy7775LZmYmO3fuZNKkSdjY2ADg4OBQrmdbvHgxe/fu5YMPPsDPz4+kpCTWrl1LTEwMCxcuVP78r169mk2bNtGxY0eaNWvG3bt3WbRoEWq1mho1apTpXnPnzqVly5Z06NCB69ev8+uvvwLw6aeflitmIYQQfyO5GTZsGEFBQbz33nvPMh7xmklPTycvL49q1aqV+Zw+ffoov9doNLi6ulKrVi0mT57M1atXqVu3rnK8sLCQfv360aJFCwC8vLy4fPkyhw4d0kpuHlalShUl0apXr165Yit28+ZN9u7dS6dOnRg1apRSXq9ePb788ku2bdvGoEGDyMzMZNu2bbRs2ZKPP/5Yqefg4MCECRPKnNx06NCB7t27A+Dt7U1CQgIHDhzgn//8JyqVqtzxCyHEm+ypkxsPDw/WrVtHQEAAnTt3pnLlyjp1iv9nLcTD7ty5w5o1a4iOjub+/ftaE9Jv3rypldyoVCqaNNFed8TR0ZHo6OjnGmPx9R99q8nZ2ZnatWsTFRXFoEGDuHDhAgUFBTRv3lyrnouLC3Z2dmW+36PPWKdOHfLz80lLS1N6noQQQpTNUyc3xfsEXb16lZ07d+ocV6lUqNXqp49MvBasrKwwNjYmMTGxTPVzcnKYOHEiRkZGDBw4kBo1amBsbMzdu3eZO3cu+fn5WvWNjY0xMjLSKjM0NNSp96xlZGQAlJhY2NrakpSUBDzouQKwtrbWqVdSWWkeHeItnk/0pOdMSEggISEBePD6uxBCiL+R3Pz222/PMg7xmtLX18fLy4vTp09z9+5drYm2JYmOjiYlJYU5c+bg4eGhlGdlZT3vUMuleE2e1NRUnWdKSUlRkpHi/6alpelcIy0trVy9N09j6dKlzJgx47neQwghXjdPndy0bt36WcYhXmM9e/bk1KlTLFq0SOdVcHgwbyYiIoImTZoo80cMDLT/6IWGhj7TmMra81Gahg0bAhAeHo6Tk5NSfunSJW7cuEHv3r2BB8NUhoaGHD16lHfeeUepd/78eZKSkp57cjNq1CgCAgKABz03AwcOfK73E0KI18Hf3lsqIyOD48ePc+/ePapUqcLbb7/9XFeiFa8eFxcXxowZw5IlS/jiiy94//33cXBwoLCwkL/++ou9e/fi6OhIkyZNcHFxwcLCgsWLF9O3b18MDAwIDw/n2rVrzzQmR0dHAHbs2EG7du3Q19enZs2amJmZlen8WrVq0bFjR3bu3IlKpcLX15fExETWrl1LlSpVlITC0tKSLl26sGnTJiwsLHj77be5e/cu69evx9bW9rlPBra3t5dFAYUQ4hF/K7n57rvvmDFjBtnZ2cqkUHNzc2bMmMEXX3zxTAIUr4eOHTvi7OzMtm3b2Lx5M6mpqRgYGFCjRg1at27NBx98ADwYxpk2bRorVqzg+++/x8TEhKZNm/LVV1/x+eefP7N4PD096dmzJwcPHmTfvn0UFRWVe52bMWPGUL16dQ4cOMDu3bsxMzPDx8eHwYMHa82RGTRoECYmJoSGhnLgwAFq1arFmDFjWLNmjaxTI4QQL4FKU9LeCWXw66+/MnToUN5//32GDh1KjRo1uH37NqtWrWLPnj388ssvDBo06FnHK8Rr4c6dO4wdO5a+ffsqQ1jPW0REBL6+vpw+fRofH59ynSu7gv+P7AouxOvvqXtufvjhB/r378+aNWu0ynv16sXAgQP54YcfJLkRb4SrV69y+PBhXFxcMDMz49atW4SEhGBmZkaHDh1ednhCCPHGeerk5vz588ydO7fEYwMHDqRbt25PHZQQrxNjY2MuX77M/v37ycrKwszMDE9PTwYOHChr1AghxEvw1MmNqakpKSkpJR5LSUnB1NT0qYMS4nVSo0YNAgMDX3YYQggh/n96T3tiy5YtmT59Ordv39Yqv3PnDjNnzqRVq1Z/OzghhBBCiPJ66p6bOXPm8M477/DWW2/Rvn177O3tSUhI4ODBgxgaGhISEvIs4xRCPEcyiVYIUZE8dc+Nu7s7J0+epEuXLpw8eZKVK1dy8uRJunbtyp9//ombm9uzjFMIIYQQokz+1jo3zs7OrFu37lnFIoR4SSriq+DSGyXEm+upe25KcuPGDUJDQ7l3796zvKwQQgghRJk9dXIzdepUrRVlDxw4gLOzM506dcLZ2ZmzZ88+kwBF+fz+++8EBARw5MgRnWP//Oc/CQgIICIiQufYyJEj+eyzz8p1r8mTJ/PJJ588bahaYmJiCAgIICYmRik7deoUQUFBz+T6ZREUFKRsqyCEEOL19dTJzebNm7Xm1UydOpWGDRuydetWHB0dmTVr1jMJUJSPp6cnKpVKK0mAB3uAXb9+HRMTE51jd+/e5c6dO+XamuBZq1+/PvPnz6d+/fpK2alTp1i/fv1Li0kIIcTr6ann3Ny6dYu33noLgHv37nHy5El2795Nx44dyc3NZfz48c8sSFF2VlZWODg46CQwsbGx6Ovr06FDB51jxZ+Ld8J+GczMzHBxcXlp9xdCCFFxPHVyo9FoKCoqAh4Mhejr6ytr29jb23P37t1nE6Eot4YNG7Jjxw5SUlKwtbUFHiQ3b731Fr6+vuzatYvs7Gxlh+yYmBj09PSUnjiNRsOePXvYu3cvt27dwtDQEC8vL4YOHUr16tV17nf27FlWrlzJtWvXsLCwwN/fn379+qGvr6/U2b17N6Ghody5cweVSoWtrS3NmjVj8ODBSgxTpkxRNrdcuHAhBw8eBNAaKlq2bBnVqlUrd4yPOnnyJGvWrOHGjRvY2toqG3s+Kj8/n3Xr1nHkyBFSUlKwsrLi7bffZuDAgVhYWACwcuVK9u7dy9q1a5VnXrp0Kbt27WLo0KF0794dgPT0dAYNGsSIESP48MMPlWceP3488fHxhIWFkZOTg7OzM6NGjaJWrVpPfA4hhBC6nnpYqn79+uzcuROA9evX06RJE2VV4oSEBFl2/iUqHl56uIcmOjoaDw8PXF1dUalUnDt3TjkWExND/fr1lR2sf/rpJ5YvX46XlxeTJ09m9OjRxMfHM2HCBFJTU7XulZqayrfffkubNm2YMmUKzZs3Z8OGDSxbtkypc/jwYZYsWYKHhweTJk1i8uTJdOnShby8vFKfoU+fPrzzzjsAzJ8/X/lVnKyVJ8ZHRUVFMXv2bExNTfnqq68YNmwYR48eJSwsTKueRqNh9uzZbN26lbZt2/L111/TpUsXDh48yNSpUykoKADAy8uL7OxsLl26pHUPIyMjIiMjtX4GGo0GLy8vrfusXr2apKQkPvnkEz7++GNu377NrFmzUKvVj30OIYQQJXvqnptRo0bx8ccf8+uvv5KWlsaKFSuUY7///rusc/MSeXh4oKenR2xsLK1btyY9PZ34+HiGDRuGqakp9evXJyYmhsaNG5OcnExiYiLNmzcHHuwZtm/fPv7xj3/QtWtX5Zru7u6MHj2abdu2MXToUKU8IyODKVOm0LRpUwAaNWpEXl4eoaGh9OjRg6pVqxIXF4e5uTkjR45Uznv0C/5R9vb2WFtbA+gMV5U3xketXr0aa2trZs6ciZGRkRL3iBEjtOqdOXOGM2fOaPW+NGrUiKpVqzJ//nwOHjxIx44dcXd3x8DAgMjISFxcXLh37x43b96kR48e7Nixg4KCAgwNDYmMjMTW1pbatWtr3cfBwUFrGFdPT4/58+dz6dIlGaoTQoin8NQ9N2PGjCEoKIgBAwawatUqhgwZohzLycl57JeLeL4sLCyoU6cOsbGxwIMhKT09PVxdXYEHSUBxr07xf4t7e06dOoVKpaJNmzao1Wrll42NDXXr1lWuWczU1FRJbIq1bt2aoqIipa6zszNZWVl8++23nDhxgvT09L/1fOWN8WG5ublcvnyZZs2aKYkNPJjz4+fnp1U3OjoagPbt22uVN2/eHBMTE+W4sbExLi4uREVFARAZGYm5uTndunWjsLBQ6SWLiooqMalr0kR7PZY6deoAkJyc/MS2SEhIICIigoiICOLi4p5YXwgh3gR/axG/vn370rdvX53y//73v3/nsuIZ8PT0ZNu2bdy7d08ZdioeNvTw8GDbtm1kZWURExODvr6+0tOWlpaGRqNR5sI86tH5LMW9Kw8rHpLMyMgAoG3btqjVavbt28e8efPQaDQ4OTkxYMAAGjVqVO5nK2+MD8vMzKSoqKjEYdNHyzIyMtDX16dSpUpa5SqVCmtra60kzcvLi+DgYHJzc4mMjKRhw4ZYWVnx1ltvERkZSbVq1UhMTKR///4697W0tNT6bGhoCDyY7/MkS5cuZcaMGU+sJ4QQb5K/ldyIV1fDhg3Ztm0bsbGxxMbG4uvrqxwrTmTOnj1LTEwMTk5OSuJjaWmJSqVi7ty5ypfswx4tS0tL06lTPOfl4S9tf39//P39yc3N5ezZswQFBREYGMiSJUuws7Mr17OVN8aHWVhYoFKpSpyX82iZpaUlarWa+/fvayU4Go2GtLQ0nJyclDIvLy/Wrl3L2bNniY6OVpL+hg0bKslN8ednadSoUcqE67i4OAYOHPhMry+EEK+jv7VC8eHDh+nZsyfu7u7Uq1dP55d4edzd3dHT0+P3338nPj5eaw0bc3Nz6taty8GDB0lKStI65ufnh0ajISUlBScnJ51fxUMmxXJycvjjjz+0yg4dOoSenh4eHh46cZmYmODr60uvXr0oLCwkPj6+1GcoTlIenXhc3hgfvb+TkxPHjx/X6hnJzs7m5MmTWnWLh5DCw8O1yo8dO0Zubq7WEJOTkxNmZmZs376d1NRUvL29lWv89ddf/P7779SuXZvKlSuXGtvTsLe3x8fHBx8fH2XYUQgh3nRP3XNz9OhR2rdvT5s2bYiLi+O9994jIyOD48ePU69ePWWCqng5zMzMqF+/Pn/88QcqlUrni8/Dw4Pt27cDaCU3bm5udOzYkR9//JFLly7h4eGBsbExqampnDt3DkdHRzp16qTUt7S0ZPHixSQnJ1OzZk1OnTrFvn37eP/996latSoAixYtwsjICFdXV2xsbEhLS2Pjxo2Ym5tr9X48qjhJ2bx5M76+vujp6VGnTp1yx/ioAQMGMGPGDKZNm0bXrl0pKipi8+bNGBsbK0NpAN7e3jRq1IhVq1aRnZ2Nq6sr165dY926ddSrV4+2bdsqdfX19fHw8ODPP/+kWrVq2NvbK+1pYGBAVFQUnTt3ftKPTQghxDPw1MnNN998w7Bhw1i8eDGGhobMmjULHx8foqOjee+995S3S8TL4+npyaVLl6hfv76ypk0xd3d3tm3bhoGBgU7i8/HHH9OgQQNCQ0PZs2cPRUVF2Nra4urqirOzs1ZdGxsbRo8ezYoVK7h+/TqWlpb06tVLa26Jm5sbYWFhHD16lMzMTKysrHBzc+Pzzz/Xmc/ysFatWhEXF8eePXsIDg5Go9Eo69yUJ8ZHNWrUiMmTJ7NmzRrmz5+PjY0NnTp1Ii8vT2tFZJVKxZQpU1i3bh1hYWFs3LgRKysr2rRpw6BBg3SGv7y8vPjzzz+1enQMDQ1xc3MjMjLyiW+ICSGEeDZUGo1G8zQnVqtWjV9++YWOHTtiYGDAH3/8obxtsnjxYlasWKHTzS+EeH4iIiLw9fXl9OnT+Pj4lOtc2RVcCFGRPPWcm+zsbCwsLNDT08PY2FhrRWIXFxetReKEEEIIIV6Up05uHBwcSExMBB4MO+zatUs5dujQoWc+cVIIIYQQoiyees5NmzZtCA8Pp2fPnowYMYKxY8cSFxeHsbEx+/btk40zhRBCCPFSPHVyM2PGDFJSUgAYPXo02dnZrF27FpVKxdSpU5kyZcozC1IIIYQQoqyeekKxEOLV8ncmFAshREXytxbxK3bhwgV+//13srKynsXlhBBCCCGe2t/afuHXX39l8uTJJCQkAHDy5El8fHzo3bs3HTp00NllWQjxanrdXwWX176FEA976p6bjRs3MnToUHx8fFi0aBEPj275+PiwYcOGZxKgEEIIIUR5PHVyM3fuXIYNG8b27dsZOXKk1jFXV9cKuc5NWFgYAQEBpf6KiYl52SGWKi8vj6CgoBJjDAoKIiAgQGuX69IMHz6chQsXPocIn+x53zsmJuaV/zkKIYR4sqceloqLi+Nf//pXicdsbW25d+/eUwf1qvv000+pWbOmTrmDg8NLiKZsHt5a4OG9pMpr0qRJOls5vCgv895CCCFeH0+d3JiZmXH//v0Sj926dQsbG5unDupV5+Dg8NgNH1+UvLw8jI2NX+g969ev/0Lv96rcWwghxOvjqZOb5s2bs2jRInr06KFz7JdffqFNmzZ/J67X2qeffoqpqSnz5s3TKler1Xz00Uc4OzszefJkAAoKCggJCSE8PJzExETMzMzw8/Nj6NChWptKDh8+HAcHB/z9/QkODubmzZsEBARw6dIl7t27x3/+8x9UKpVSX6PRMGrUKGrVqsWoUaOUyd3r169XenDatWvHZ599ppyTlpbG0qVLOX36NIaGhjRu3Jjhw4djbm6uFYeHh4dyXkxMDFOmTGH8+PHEx8cTFhZGTk4Ozs7Oyv0fjmnjxo3s3buXtLQ0HB0dGTRoEBs3bgRgzpw5j23XR+9dVFTExo0bCQ8PJzk5GUNDQ6pUqUKHDh0ICAh47LVu3rzJsmXLOHv2LMbGxjRv3pzGjRuXWHf//v3s2LGDW7duYWxsjIeHB4MGDaJ27drAg4n0gYGBLFiwQEl6jx07xrx582jcuDHTpk1TrjVu3Dhq1KjBpEmTAAgICKBTp040aNCAjRs3kpSURI0aNRg0aJCyV5sQQojyeerkZtq0abRo0YImTZrQv39/VCoVISEhfPPNNxw6dKhCb5pZVFSEWq3WKdfX1wfA39+fZcuWcfv2bWrUqKEcj4yMJCUlBX9/f+U6s2fP5ty5c3Tv3h0XFxeSkpJYt24dkydP5vvvv9fqmfnrr7/45Zdf6N27N9WqVcPExAQXFxdmz55NVFQU3t7eSt3Tp09z584dRo4cia2tLdOnT2f69Ol06NCBDh06AOjsyD137lxatmxJhw4duH79Or/++ivwIFl7ktWrV+Pq6sonn3xCdnY2q1atYtasWfz0009Ku6xevZpNmzbRsWNHmjVrxt27d1m0aBFqtVqrncoqJCSEdevW0bt3b9zd3VGr1dy8efOJSxKkpqYyadIkDAwMGDNmDNbW1oSHh7N06VKduhs3bmT16tW0atWKwYMHk5GRwbp165gwYQILFiygRo0aeHh4YGBgQGRkpJLcREZGYmRkRGxsLIWFhRgYGJCWlkZ8fDzvv/++1j1OnTrF5cuX6d+/P6ampoSEhDBnzhwWL15M9erVy90uQgjxpnvq5KZx48bs2bOHsWPHKlstzJkzBycnJ/bs2YO7u/szC/JV89VXX+mU6enpsXXrVgBat27NypUrCQsLY9CgQUqdsLAwrK2t8fX1BeDo0aNEREQwceJE3nnnHaVe3bp1GT9+PGFhYXTq1EkpT0tL46efftKa71NUVET16tXZtWuXVnKza9cuqlevjq+vLyqVirfeeguAypUr4+LiUuJzdejQge7duwPg7e1NQkICBw4c4J///KdWr1BJHBwctLbc0NPTY/78+Vy6dAkXFxcyMzPZtm0bLVu25OOPP9Y6b8KECU+V3MTFxeHo6Ej//v2VsrIsXrd9+3bS09NZuHAhdevWBcDX15dp06aRnJys1MvMzCQ4OJjGjRvz5ZdfKuUeHh6MHj2adevWMX78eExNTXF2diYqKopevXoBEBUVxQcffMC2bds4f/48Hh4eREVFodFotH5OAPn5+cycOVOZT1SvXj2GDRvG0aNH6dmzZ7nbRQgh3nR/a52btm3bEhcXx5UrV0hMTKRKlSo4OTkRFBSEq6sr58+ff1ZxvlI+//xzreEWQOvL38rKiiZNmnDw4EEGDBiAnp4emZmZ/PHHH3z44YdKT8bJkycxNzenSZMmWj1B9erVw8bGhtjYWK3kpk6dOjoTmfX09Pjggw9YuXIlycnJVK1alYSEBCIiIhg2bNgTk5KHNWmivVZInTp1yM/PJy0t7YlzqEo6FyA5ORkXFxcuXLhAQUEBzZs316rn4uKCnZ1dmWN8mJOTE6dOnWLx4sU0bdoUFxeXMk04jomJwcHBQUlsirVu3ZrIyEjl84ULF8jPz6ddu3Za9apWrUrDhg2JiopSyho2bMjmzZvJy8vj/v37JCQk0KpVK6Kjo4mMjMTDw4PIyEiqVq2qk8h5enpqxW1jY0OlSpVISkp64rMkJCQo60zFxcU9sb4QQrwJyp3c3L9/n61bt5KYmEiDBg3o3Lkz9evXp379+oSEhNC9e3fOnTuHo6Pj84j3lVCrVq0nTij29/fn2LFjREZG4uPjw+HDhykoKKB9+/ZKnbS0NLKyspTekkc9+mq2ra1tqfcKCgpiz549DB48mN27d2NkZKQMf5WVlZWV1mdDQ0PgQc/Ck1haWj723OJnsba21jm3pLKy6NWrFyYmJoSHhxMaGoqenh7u7u4MGTLksT+f9PR0qlWr9sQ4imMuqd1tbW21EiFvb2/Wr1/PuXPnSE5OxsrKinr16uHl5UVUVBQDBw4kOjoaLy8vnWs92nbwoP3K0u5Lly5lxowZT6wnhBBvknIlN5cvX6Zly5YkJSWh0WhQqVS0bt2arVu30q9fP0JDQ7G2tmb+/PmMGzfuecX8WmjUqBG2traEhYXh4+PDgQMHcHZ21npd3MrKCktLS6ZPn17iNUxNTct0L3Nzc9q2bcv+/fvp1q0bBw4coHXr1lhYWDyLR3kmihOntLQ0nWNpaWlP1Xujr69P165d6dq1K5mZmURFRbF69WqmT5/OihUrSn2TzMrKqtQ4Soq5eIPYh6WkpGglg87OzpiamhIVFUVSUhJeXl6oVCq8vLzYunUrly5dIjk5ucTk5u8YNWqUMnk6Li6OgQMHPtPrCyHE66hci/h9/fXXpKenM336dHbt2sW///1vzp8/zzvvvMOePXv46KOPuHLlCl9++eULf0X5VaOvr0/btm05ceIEZ8+e5fLlyzo9KX5+fmRkZFBUVISTk5POr0eHvh6nc+fOpKenM2/ePLKysvjggw+0jhsYPMhjy9Ib8Dw4OztjaGjI0aNHtcrPnz9fpuGXJ7GwsKB58+Z06tSJjIwMEhMTS63r6elJfHw8V69e1So/dOiQ1ucGDRpgZGREeHi4Vvndu3eJjo6mYcOGSpmBgQHu7u5ERkZq9dC4ubmhr6/PmjVrlGTnWbK3t8fHxwcfHx9cXV2f6bWFEOJ1Va6em0OHDjF16lTlNVaAt956i/fff5/Ro0fzn//855kH+CqKj48v8W0pe3t7rTeQ/P392bx5MwsWLMDIyIiWLVtq1W/ZsiWHDh1i5syZdO7cGScnJwwMDLh79y4xMTE0bdqUZs2alSmmmjVr4uPjw+nTp3Fzc9OZT2JmZoadnR1//PEHXl5eWFhYYGVlVeLwzPNgaWlJly5d2LRpExYWFrz99tvcvXuX9evXY2trW665QcUCAwOVNYesrKxITk5m+/bt2NnZPXaCckBAAAcOHGDmzJkMHDhQeVvq5s2bWvUsLCzo06cPq1ev5ocffqBVq1akp6ezfv16jIyM6Nevn1b9hg0bsmLFCgBl0rCxsTEuLi6cOXOGOnXqPPUQnBBCiLIrV3KTnJysMyG0RYsWAPTp0+fZRfWK+/HHH0ss/+STT3j33XeVzzVr1sTFxYXz58/TunVrrfVi4EHvztSpU9m+fTvh4eFs2rQJfX19KleujIeHR7nnLbVo0YLTp0/r9NoUGzduHCtXrmTWrFkUFBTorHPzvA0aNAgTExNCQ0M5cOAAtWrVYsyYMaxZs0anbcrC09OTY8eOsX//frKzs7GxscHb25s+ffooPVUlsbGxYc6cOSxbtozFixdjbGzM22+/zahRo5g9e7ZW3V69elGpUiV27tzJkSNHtNa5eTSBKu6VqVGjhtYwm5eXFzExMc+810YIIUTJVJqHd7x8Aj09PU6cOKH1ZoxarcbQ0JBTp06V6TVc8fzMnTuXCxcusHz58sd+ub9K7ty5w9ixY+nbty+9e/d+2eG81iIiIvD19eX06dPl/rsou4ILISqScn8DXrhwQeuLs3h4pqTXviXZef4KCgq4cuUKFy9e5MSJE/zjH/94ZRObq1evcvjwYeWV7Vu3bhESEoKZmZmysKAQQgjxd5X7W3Do0KEllj+8WF3xm1QlzUsRz1ZKSgoTJkzAzMyMjh078uGHH77skEplbGzM5cuX2b9/P1lZWZiZmeHp6cnAgQMr9F5kQgghXqxyJTcrV658XnGIp1StWjW2b9/+ssMokxo1ahAYGPiywxBCCFHBlSu5GTJkyPOKQwjxEsmcFSFERVKudW6EEEIIIV51r+bMUyHEC/Uy35aSXiMhxLMmPTdCCCGEqFAkuREvXFBQEAEBATobgxb75JNPmDx5crmvO3nyZD755JO/G54QQojXnCQ3QgghhKhQJLkRQgghRIUiE4rFKy0mJoYpU6Ywfvx44uPjCQsLIycnB2dnZ0aNGvXEndOPHz/OggULaN26NWPHjkVfX5+AgAA6depEgwYN2LhxI0lJSdSoUYNBgwbh5+endf65c+cICgri0qVLqNVq6tWrR69evZR62dnZ9O/fn8GDB9O9e3cA0tPTGTRoEKampqxduxZ9fX0A/vvf/3L48GFWr16NSqVi8uTJpKen8+mnn/Lzzz9z+fJlbGxs6NixI927d0dPT/7tIYQQT0P+7yleC6tXryYpKYlPPvmEjz/+mNu3bzNr1qzHroK9bds2/vWvf9GrVy/GjRunJBkAp06dYteuXfTv359JkyZhaWnJnDlzuHPnjlInNjaWqVOnkp2dzbhx4/jyyy8xNTVl1qxZHDlyBHiw27qTkxNRUVHKeVFRURgaGpKTk8PFixe1yhs2bKi1A3pqaioLFiygTZs2TJ06FV9fX3799VfCw8OfRbMJIcQbSXpuxGvBwcGB8ePHK5/19PSYP38+ly5dwsXFRatuUVERy5YtY+/evXz22We0adNG53r5+fnMnDkTMzMzAOrVq8ewYcM4evQoPXv2BGDVqlWYm5sze/ZsTE1NAfDz8+Ozzz5j5cqVtGjRApVKhZeXF1u3bqWgoABDQ0OioqLw8PAgJSWFqKgoXF1duXfvHjdu3CAgIEArjoyMDL755hucnZ0B8Pb2JiYmhkOHDtGuXbtn1n5CCPEmkZ4b8Vp4eCd6gDp16gCQnJysVZ6fn8+cOXM4dOgQM2fOLDGxAfD09FQSGwAbGxsqVapEUlISALm5uVy8eJHmzZsriQ2Avr4+bdq04e7du9y6dQsALy8v8vPziYuLAyAyMhJvb2+8vLyIjIwEUHp2vLy8tOKwsbFREpuHn+3R5xJCCFF20nMjXrji4aHShpTUarXWEBKApaWl1mdDQ0PgQTLzsPv37xMREYG3t7dOj87jrld8zeLrZWZmotFoStzQ09bWFkB5ld3FxQVjY2OioqKoUqUKSUlJeHt7c+/ePXbt2kVOTg5RUVFUr16d6tWrlyuOJ0lISCAhIQFASa6EEOJNJz034oWztrYGHuxo/iiNRkNqaqpSp7yqVq3K119/TUxMDHPnzi1zkvAoCwsL9PT0SE1N1TlWHLeVlRXwIBlxc3MjKiqKyMhIbGxsqFOnDu7u7sCDuTtRUVE6vTbPwtKlS/H19cXX15eBAwc+8+sLIcTrSJIb8cIVT6otnpT7sIiICLKzs/H29n7q6zdq1IgZM2Zw9uxZAgMDyc3NLfc1TExMcHZ25vjx4+Tl5SnlRUVFhIeHU6VKFWrWrKmUe3l5cfnyZY4fP64kMcXX2LlzJykpKc8luRk1ahSnT5/m9OnTrFmz5plfXwghXkeS3IgXzt7eng8++IAtW7bw008/ceLECc6cOcOGDRuYP38+b731Fq1atfpb93BzcyMwMJC//vqLadOmkZWVVe5rDB48mIyMDKZMmcLvv//OH3/8wYwZM4iPj2fYsGFabz15eXlRVFREVFSUVmLm7e3NmTNnUKlUNGzY8G89U0ns7e3x8fHBx8cHV1fXZ359IYR4HUlyI16KESNGMHr0aK5cucKCBQsIDAzk4MGDdOrUidmzZytzav4OJycn5s6dS2JiIlOnTi11u4fSeHh4MGvWLExMTPjxxx/59ttvyc7OZurUqbRs2VKrbr169ZRhqod7aIp///BxIYQQz5dKo9FoXnYQQoi/LyIiAl9fX06fPo2Pj0+5zpVdwYUQFYn03AghhBCiQpHkRgghhBAViiQ3QgghhKhQJLkRQgghRIUiKxQLIWRSrxCiQpGeGyGEEEJUKNJzI4R4Lq+CS2+QEOJlkZ4bIYQQQlQor1RyExYWRkBAAAEBAcTExOgc12g0jBw5koCAACZPnvwSIhSlSUxMJCAggLCwsJcdiqI4pi1btjyxbvGfvcTExBcQmRBCiOfplUpuipmamrJ//36d8tjYWO7cuYOpqelLiEoIIYQQr4NXMrlp2bIlx44dIzs7W6t8//79uLi4ULVq1ZcU2etDrVZTUFDwssN45h7eoVsIIYQoySs5obhly5aEh4dz+PBh3nvvPQCysrI4duwYI0eOZPv27TrnFBQUEBISQnh4OImJiZiZmeHn58fQoUOpVKmSUi8qKorg4GCuX79OXl4eVlZWODk58cUXX2BsbAzA7t27CQ0N5c6dO6hUKmxtbWnWrBmDBw8G4P79+wQFBREbG0tycjLGxsY4ODjQv39/3N3dteK6e/cuy5cv58yZM+jp6dG4cWMCAgIYP348n376Ke3bt1fqXrp0ieDgYM6dO0deXh61atWiV69etGjR4rHtlZiYyIgRIxgyZAiFhYXs37+fu3fv8vXXX+Pr61um65bnme7du8fy5cuJiIhApVLh4+NDQEBAWX60hIWF8eOPPzJjxgwOHz7MH3/8QUFBAQ0bNmTEiBFUr15dqTt58mTS09MZPXo0v/76K3/99RdNmzblq6++Ijk5mV9//ZXIyEiysrKoXr06HTp0oEuXLujpaefsRUVFbNiwgdDQUO7fv4+joyNDhgzR2uCyNJGRkWzatIlLly6hVqupV68eAwYM0Do3KCiI9evX8+OPPxIcHExkZCR6enq0b9+eoUOHkpCQwLJlyzh//jyWlpa8//779OjRQyu+jRs3Eh4eTnJyMoaGhlSpUoUOHTqUuV2FEEL8zyuZ3JiZmdG8eXMOHDigJDeHDx9GT0+PFi1a6CQ3RUVFzJ49m3PnztG9e3dcXFxISkpi3bp1TJ48me+//x5jY2MSExMJDAzEzc2NcePGYWFhwb1794iIiKCgoABjY2MOHz7MkiVL+PDDDxk2bBh6enokJCRw48YN5X4ZGRkA9O3bFxsbG3Jycjhx4gRTpkwhMDAQT09PAHJzc5kyZQqZmZkMGTIEe3t7IiIimD9/vs4zR0dHM336dJydnRk7dixmZmYcOXKE+fPnk5eXp5UElWbnzp3UqFGDf/zjH5iamlKjRo0yX7esz5SXl8e0adNISUlh0KBB1KxZk1OnTvHtt9+W62f8f//3f3h7ezN+/Hju3r3LmjVrmDx5Mv/+97+xsLBQ6qWmpvL999/TvXt3Bg0ahEql4v79+0yYMIHCwkIGDBiAnZ0dJ0+eZOXKldy5c4cxY8Zo3WvXrl3Y2dkxfPhwNBoNISEhzJgxgzlz5uDi4lJqjL/99hsLFy6kadOmfPbZZxgYGBAaGso333zDjBkzdJKj+fPn06ZNG9577z0iIyMJCQmhsLCQqKgoOnXqRLdu3Th06BCrVq3C3t6ed955B4CQkBDWrVtH7969cXd3R61Wc/PmTbKyssrVpkIIIR54JZMbAH9/f6ZMmUJ8fDwODg4cOHCA5s2bY2ZmplP36NGjREREMHHiROULA6Bu3bqMHz+esLAwOnXqxJUrV8jPz2fYsGHUrVtXqde6dWvl93FxcZibmzNy5Eil7NEvsVq1aml9garVanx8fEhKSmLHjh1KInDw4EESEhL45ptv8PX1BaBRo0bk5eURGhqqdc0lS5bg4ODA7Nmz0dfXB8DHx4f09HRWr15N27ZtdXokHmVoaMiMGTMwMPjfj3XGjBllum55nunGjRtMmTKFpk2baj3Tvn37Hhvfw9566y3++c9/Kp8dHBz4f//v/7F792569+6tlGdkZDBhwgStn8GqVau4d+8e3333Hc7OzsozFRUVERoaSkBAADVr1lTqFxUVMXPmTIyMjJR4R4wYwdq1awkMDCwxvry8PJYvX46fn5/W5HVfX18+//xzVq9erfPnomPHjnTt2hUAb29vzpw5w65du5g0aRLNmjUDwNPTk1OnTnHo0CHlz2pcXByOjo70799fuVZ5d/UWQgjxP6/knBsADw8Pqlevzv79+7l27RqXLl3C39+/xLonT57E3NycJk2aoFarlV/16tXDxsaG2NhY4EGyY2BgwE8//URYWBh37tzRuZazszNZWVl8++23nDhxgvT09BLvuWfPHj777DN69OhBt27d6NatG1FRUdy8eVOpExsbi6mpqZLYFGvVqpXW59u3b3Pz5k0lyXr4GXx9fUlJSeHWrVtPbLOmTZtqJTblvW5ZnikmJgZTU1MlsSn2cIJYFm3atNH67Orqip2dnc5bchYWFjpJRExMDLVr11YSm2Lt27dHo9EQHR2tVd6sWTMlsQGUIcuzZ8+iVqtLjC8uLo6MjAzatWun1W4ajQYfHx8uXbpEbm6u1jl+fn5an2vXro1KpdL6+evr62Nvb09ycrJS5uTkxLVr11i8eDERERE6c80eJyEhgYiICCIiIoiLiyvzeUIIUZG9sj03KpUKf39/duzYQUFBATVr1tSZ+1EsLS2NrKwsunfvXuLx4gTF3t6ewMBAQkJCWLp0Kbm5uVSvXp0PP/xQmdvQtm1b1Go1+/btY968eWg0GpycnBgwYACNGjUCYOvWraxYsYL33nuPAQMGYGVlhZ6eHmvXrtVKBDIyMrC2ttaJ59GytLQ0AFauXMnKlSsf+wyPY2Nj89TX/bvP9Oi9n6S0dnn0OUu6bnp6OtWqVdMpt7W1VWJ80jVsbGwoLCwkNzcXc3NznePFbTdv3rxSnyEjIwMTExPls6WlpdZxAwMDjI2NtRKr4vKHE5hevXphYmJCeHg4oaGh6Onp4e7uzpAhQ3Bycir1/gBLly5lxowZj60jhBBvmlc2uYEH/xIPCgoiNDSUgQMHllrPysoKS0tLpk+fXuLxh18dd3d3V+Y1XL58mZ07d7J8+XKsra2VHhV/f3/8/f3Jzc3l7NmzBAUFERgYyJIlS7CzsyM8PBxPT0/Gjh2rdZ+cnBytz5aWlly8eFEnntTUVJ34AXr27KkMXzzq4WGW0qhUqqe+7rN+picpTh4eLbO3t9cqe/SZ4MFzpaSk6JQXlxU/9+NiS01NxcDAQCs5efQeACNHjqRBgwYl1ikpQXsa+vr6dO3ala5du5KZmUlUVBSrV69m+vTprFixQpnoXpJRo0YpiXlcXNxj/54IIcSb4pVObipXrky3bt24efMm7dq1K7Wen58fR44coaioqNQvokfp6+vToEEDatWqxaFDh7hy5YrOcJGJiQm+vr4UFBQwZ84c4uPjsbOzQ6VSaQ3/AFy9epULFy5QpUoVpczDw4OjR49y+vRpraGJI0eOaJ1bq1YtatSowbVr15Q3sp6F8ly3rM/k6enJ0aNH+eOPP7SGpg4dOlSu2MLDw7XmR8XFxZGUlESHDh2eeG7Dhg3ZtGkTV65coX79+kr5wYMHUalUyvygYsePH2fYsGFKD0p2djYnT57E3d1dmYf0KFdXV8zNzblx4wYffvhhuZ7t77CwsKB58+bKG2mJiYk4ODiUWt/e3l4nIRRCiDfdK53cAAwZMuSJdVq2bMmhQ4eYOXMmnTt3xsnJCQMDA+7evUtMTAxNmzalWbNm7Nmzh+joaBo3bkzVqlUpKChQFgv09vYGYNGiRRgZGeHq6oqNjQ1paWls3LgRc3NzZYjAz8+P4OBggoKCcHd359atWwQHB2NnZ0dRUZESV7t27di2bRvff/89AwYMUN6WioiIALR7JcaOHcuMGTP45ptvaNeuHZUrVyYzM5MbN25w5coVJk6c+FTtV9brlueZtm/fzsKFCxk4cCA1atTg1KlTnDlzplxxXb58mf/7v/+jefPm3L17l9WrV1O5cmU6der0xHO7dOnCb7/9xsyZM+nfvz92dnacOnWKPXv28P777+v0cunp6TFt2jS6dOmCRqNh8+bNZGdn069fv1LvYWpqysiRI/nxxx/JzMzknXfeoVKlSqSnp3P16lXu37+v08v1tAIDA3FwcMDJyQkrKyuSk5PZvn07dnZ21KhR45ncQwgh3iSvfHJTFvr6+kydOpXt27cTHh7Opk2b0NfXp3Llynh4eODo6Ag8mFB85swZ1q1bR2pqKiYmJjg6OjJ16lRlPo2bmxthYWEcPXqUzMxMrKyscHNz4/PPP1fWy+nVqxd5eXns37+fkJAQateuzZgxYzhx4oQyeRke9PzMmjWL5cuXs2rVKuDBmzpjxoxhxowZWnM9GjZsyHfffcfGjRtZvnw5WVlZWFpaUrt27Seuc/M4Zb1uWZ/J2NiYWbNmsWzZMn799Vflmb766ismTJhQ5rjGjRtHeHg43377rbLOzfDhw3XmrZSkUqVKzJ8/n19//ZVff/2VnJwcqlWrxtChQ+nSpYtO/Q8++ICCggKWLVtGWloaDg4OTJs2DTc3t8fep23btlStWpWQkBD+85//kJOTQ6VKlahbt26ZXs0vK09PT44dO8b+/fvJzs7GxsYGb29v+vTpo9ObJoQQ4slUGo1G87KDeNNs2LCBtWvX8vPPP2sN+bwJihfxW7BgwRMny4ryiYiIwNfXl9OnT5f7VXLZFVwIUZHIPwufs507dwIP5r+o1Wqio6PZsWMHbdq0eeMSGyGEEOJFkOTmOTM2Nmb79u0kJSVRUFBAlSpV6NGjh9ZCdUIIIYR4diS5ec46dOhQpjeA3hTt27d/pvNVhBBCiEdJciOEkPkxQogK5ZXdfkEIIYQQ4mlIciOEEEKICkWGpYQQz+xVcBneEkK8CqTnRgghhBAVyiuR3ISFhREQEEBAQAAxMTE6xzUaDSNHjiQgIIDJkye/hAhFWSxcuJDhw4e/7DC0LFy4sMyv3Q8fPpyFCxc+34CEEEI8d69EclPM1NRU2evpYbGxsdy5c0drd28hhBBCiJK8UslNy5YtOXbsGNnZ2Vrl+/fvx8XFhapVq76kyMSrorCwELVa/bLDEEII8Qp7pSYUt2zZkvDwcA4fPsx7770HQFZWFseOHWPkyJFs375d55yCggJCQkIIDw8nMTERMzMz/Pz8GDp0qLLRJUBUVBTBwcFcv36dvLw8rKyscHJy4osvvsDY2BiA3bt3Exoayp07d1CpVNja2tKsWTMGDx4MwP379wkKCiI2Npbk5GSMjY1xcHCgf//+uLu7a8V19+5dli9fzpkzZ9DT06Nx48YEBAQwfvx4Pv30U62F7C5dukRwcDDnzp0jLy+PWrVq0atXrzJtmPmkmAFSU1MJCgri1KlT3L9/H1tbW9q3b0/v3r3R19cHIDExkREjRjBs2DBUKhU7d+4kPT0dR0dHPvroI1xcXLTuGxYWxqZNm0hMTKR69er07NnzibEWGz58OA4ODnTo0IGgoCBu376Nra0tAQEBdO7cWakXExPDlClT+Pzzz/nrr784cuQIqamp/PTTT9SqVYv9+/ezY8cObt26hbGxMR4eHgwaNIjatWvr3DM+Pp7//ve/XLhwAWNjY1q0aMGwYcOUn31psrOzWb9+PceOHSMlJQUrKyuaN2/OoEGDMDExUeoFBATQqVMn3nrrLTZv3kxycjIODg6MHDmSBg0asGXLFnbv3k16ejpOTk58/PHHWjt+X7lyhbVr13Lp0iWysrKwsrKiXr16jB07VrbpEEKIcnqlkhszMzOaN2/OgQMHlOTm8OHD6Onp0aJFC53kpqioiNmzZ3Pu3Dm6d++Oi4sLSUlJrFu3jsmTJ/P9999jbGxMYmIigYGBuLm5MW7cOCwsLLh37x4REREUFBRgbGzM4cOHWbJkCR9++CHDhg1DT0+PhIQEbty4odwvIyMDgL59+2JjY0NOTg4nTpxgypQpBAYG4unpCUBubi5TpkwhMzOTIUOGYG9vT0REBPPnz9d55ujoaKZPn46zszNjx47FzMyMI0eOMH/+fPLy8h67mm9ZYk5NTWX8+PHo6enRp08f7O3tOX/+PBs2bCApKYlPP/1U65q7du2iVq1aytyZtWvXMnPmTJYtW6bsYl68+WXTpk35xz/+QVZWFuvWraOgoAA9vbJ1Bl69epXly5fTr18/bGxsCA8PZ9myZRQWFtKtWzetur/++isNGjRg7NixqFQqKlWqxMaNG1m9ejWtWrVi8ODBZGRksG7dOiZMmMCCBQu0EofCwkJmzJhBx44d6dGjh/L8ycnJfP3116XGmJeXx6RJk7h37x69evWiTp06xMfHExQUxPXr1wkMDESlUin1T506xV9//cXgwYNRqVSsWrWKwMBA2rVrx507dxg1ahTZ2dn8/PPPzJs3jx9//BGVSkVubi7Tpk2jWrVqjBo1Cmtra9LS0oiOjiYnJ6dM7SmEEOJ/XqnkBsDf358pU6YQHx+Pg4MDBw4coHnz5piZmenUPXr0KBEREUycOJF33nlHKa9bty7jx48nLCyMTp06ceXKFfLz8xk2bBh169ZV6rVu3Vr5fVxcHObm5owcOVIp8/Ly0rpfrVq1GDNmjPJZrVbj4+NDUlISO3bsUJKbgwcPkpCQwDfffIOvry8AjRo1Ii8vj9DQUK1rLlmyBAcHB2bPnq30ovj4+JCens7q1atp27ZtqQlDWWJet24dWVlZLFq0SBnW8/LywsjIiJUrV9KtWzccHByU+qampnz99ddKLJUrV2b8+PGcPn2aVq1aUVRUxOrVq6lfvz6TJ09Wvtzd3NwYPXo0tra2Jcb6qJSUFBYuXKj8PHx9fbl//z7BwcF06tRJq0elevXqTJw4UfmcmZlJcHAwjRs35ssvv1TKPTw8GD16NOvWrWP8+PFKeWFhIV27dlV6hRo1aoS+vj5r1qzh3LlzuLm5lRjjjh07uH79Ot9++62yg7mXlxeVK1dm3rx5yi7cxQoKCpg5c6ZWj86cOXOIjo5m4cKFSlvdv3+f5cuXc/36derUqcPNmzfJyMhg3LhxvP3228q5Zem5E0IIoeuVmnMDD76gqlevzv79+7l27RqXLl3C39+/xLonT57E3NycJk2aoFarlV/16tXDxsaG2NhY4EGyY2BgwE8//URYWBh37tzRuZazszNZWVl8++23nDhxgvT09BLvuWfPHj777DN69OhBt27d6NatG1FRUdy8eVOpExsbi6mpqdYXH0CrVq20Pt++fZubN28qSdbDz+Dr60tKSgq3bt0qta3KEvPJkyfx9PTE1tZW5/rFsT6scePGSmIDUKdOHQCSk5MBuHXrFikpKbRq1Uqr18LOzk5n6OpxHBwctBJNeJBsZmdnc+XKFa3yhxNXgAsXLpCfn0+7du20yqtWrUrDhg2JiorSud/DiezDn0t6O6/YyZMncXBwoF69elpt16hRI1Qqlc65np6eWolN8fCYr6+vVlsVlxe3qb29PRYWFqxatYo9e/YQHx9fakyPSkhIICIigoiICOLi4sp8nhBCVGSvXM+NSqXC39+fHTt2UFBQQM2aNXXmsxRLS0sjKyuL7t27l3i8+Mve3t6ewMBAQkJCWLp0Kbm5uVSvXp0PP/yQgIAAANq2bYtarWbfvn3MmzcPjUaDk5MTAwYMoFGjRgBs3bqVFStW8N577zFgwACsrKzQ09Nj7dq1WslNRkYG1tbWOvE8WpaWlgbAypUrWbly5WOfoSRliTktLY0///xTZ6intOtbWVlpfTY0NAQeDNEUPxuAjY2NzrVsbGxISkoqNd6HPa59Ho3p0XsVHy+pl8jW1pbIyEitMn19fZ3nKr5m8fOUJC0tjYSEhDK3nYWFhdZnA4MHf70sLS1LLM/PzwfA3NycOXPmKENtmZmZ2Nra8u6779K7d2+lfkmWLl3KjBkzSj0uhBBvolcuuYEHO0cHBQURGhrKwIEDS61nZWWFpaUl06dPL/H4w6+Ou7u74+7ujlqt5vLly+zcuZPly5djbW2t9Kj4+/vj7+9Pbm4uZ8+eJSgoiMDAQJYsWYKdnR3h4eF4enoyduxYrfs8Oi/C0tKSixcv6sSTmpqqEz9Az549adasWYnPULNmzVKfvywxW1lZUadOnVLbsazDSMWKv6gffZbSykpTnNiVVPZoIvJwr8fDx1NSUnSuUTzp92FqtZr09HSt8uJYH008Hr2PkZER//znP0s9/qzUqVOHr776Co1Gw7Vr1wgLC2P9+vUYGRk9drL2qFGjlAQ9Li7usX9fhBDiTfFKJjeVK1emW7du3Lx5U2fo4WF+fn4cOXKEoqIiGjRoUKZr6+vr06BBA2rVqsWhQ4e4cuWKznCRiYkJvr6+FBQUMGfOHOLj47Gzs0OlUun8K/rq1atcuHBB640WDw8Pjh49yunTp7WGpo4cOaJ1bq1atahRowbXrl3TervpaZQWs5+fH6dOnVKGPv6umjVrYmtry5EjR+jatauSeCQlJXH+/PkyJ0vx8fFcvXpVa2jq0KFDmJqaUr9+/cee26BBA4yMjAgPD9eal3L37l2io6N1hrGKr/3wm1iHDh0CUOZJlcTPz4+NGzdiaWlJ9erVy/Rcf5dKpaJu3boMHz6csLAwnSG6R9nb22Nvb/9CYhNCiNfFK5ncAAwZMuSJdVq2bMmhQ4eYOXMmnTt3xsnJCQMDA+7evUtMTAxNmzalWbNm7Nmzh+joaBo3bkzVqlUpKChQFgv09vYGYNGiRRgZGeHq6oqNjQ1paWls3LgRc3NzZTKpn58fwcHBBAUF4e7uzq1btwgODsbOzo6ioiIlrnbt2rFt2za+//57BgwYoLwtFRERAWj3RIwdO5YZM2bwzTff0K5dOypXrkxmZiY3btzgypUrWhNpH1WWmPv3709kZCQTJkzgww8/pGbNmhQUFJCUlMSpU6fK/aqxnp4e/fv3Z9GiRcyZM4d3331XeVuqpKGm0tja2jJr1iytt6UiIyMZMmTIE1/PtrCwoE+fPqxevZoffviBVq1akZ6ervR09OvXT6u+gYEBW7duJScnBycnJ+VtKV9f31InE8OD17uPHTvG5MmTCQgIoE6dOmg0GpKTkzlz5gxdu3Ytc1L9OCdPnmT37t00bdqU6tWro9FoOH78OFlZWcqfTyGEEGX3yiY3ZaGvr8/UqVPZvn074eHhbNq0CX19fSpXroyHhweOjo7AgwnFZ86cYd26daSmpmJiYoKjoyNTp05V5qa4ubkRFhbG0aNHyczMxMrKCjc3Nz7//HNlvZxevXqRl5fH/v37CQkJoXbt2owZM4YTJ05oTcw1MTFh1qxZLF++nFWrVgEP3tAZM2YMM2bMUF6pBmjYsCHfffcdGzduZPny5WRlZWFpaUnt2rWf+LZMWWK2tbXl+++/Jzg4mC1btnDv3j1MTU2pVq0aPj4+T9Wb8+677wIQEhLC3LlzqVatGr169SI2NlZngnJp6tati7+/v9Y6Nx999BFdunQp0/m9evWiUqVK7Ny5kyNHjmitc/Pwa+DwILn5+uuvWbZsGRs2bMDY2Jh3332XYcOGPfYeJiYmzJs3j02bNrF3714SExMxNjamSpUqeHt7Y2dnV6ZYn8Te3h5zc3NCQkJISUnB0NCQmjVr6qyHJIQQomxUGo1G87KDeFNs2LCBtWvX8vPPP7/RC7MVL+I3bdq0lx1KhVL8avrp06fx8fEp17myK7gQoiJ5rXtuXmU7d+4EHsyrUavVREdHs2PHDtq0afNGJzZCCCHE8ybJzXNibGzM9u3bSUpKoqCggCpVqtCjR48y71AthBBCiKcjyc1z0qFDBzp06PCyw3glLV++/GWHIIQQogKT5EYIIXNlhBAVyiu3/YIQQgghxN8hPTdCiCe+LSU9O0KI14n03AghhBCiQqlwyU1YWBgBAQFcunSpxOMzZ85k+PDhz+3+AQEBLFmy5In14uLiCAoKIjMz87nF8ip6nZ67LD/LxMREAgICCAsLe0FRCSGEeJIKl9y8Ls6fP8/69evJysp62aG8UBXtuW1tbZk/fz6NGzd+2aEIIYT4/8mcGyEekZeX98T9rYoZGhri4uLynCMSQghRHpLcALt27eLIkSPcunWL3NxcqlevTps2bejSpYvWLuBXrlxh7dq1XLp0iaysLKysrKhXr16Jm0/+9ttvbNy4kaSkJGrUqMGgQYPw8/MDICgoiPXr1wMwYsQI5ZzZs2fj6enJkSNH2L9/P9evXycrKws7OzuaNm1Knz59MDEx0brP3r172bJlC0lJSdjb29O7d2/OnDlDbGys1noyu3fvJjQ0lDt37qBSqbC1taVZs2aP3Y08MTGRESNGMGzYMFQqFTt37iQ9PR1HR0c++ugjnS/1P/74g02bNnH16lX09fVxdnZmwIABSr0nPfejTp48SWBgIAsWLFA2Aj127Bjz5s2jcePGWts3jBs3jho1ajBp0iQA8vPzWbduHUeOHCElJQUrKyvefvttBg4cqLWfVvFWEP7+/gQHB3Pz5k0CAgJK3LhVo9GwevVqtmzZwujRo+nYsaPSRg/vA1X8nIsWLSI4OJjTp09jaGhI48aNGT58uNbeYpmZmaxYsYITJ05QWFiIh4cHI0eOZOTIkfTt25f+/fuX+vMRQghRsgqb3BQVFaFWq8tU986dO7Ru3Zpq1aphYGDA1atX2bhxIzdv3uTTTz8FIDc3l2nTplGtWjVGjRqFtbU1aWlpREdHk5OTo3W9U6dOcfnyZfr374+pqSkhISHMmTOHxYsXU716dd59910yMzPZuXMnkyZNwsbGBgAHBwcAbt++ja+vLwEBAZiYmHDz5k02b97MxYsXmT17tnKf0NBQ/vOf//DOO+/w0UcfkZ2dzfr16ykoKNCK5/DhwyxZsoQPP/yQYcOGoaenR0JCAjdu3ChT++zatYtatWopc5XWrl3LzJkzWbZsmfJFfejQIRYsWECjRo348ssvKSwsJCQkhMmTJzNr1izc3Nye+NyP8vDwwMDAgMjISCW5iYyMxMjIiNjYWAoLCzEwMCAtLY34+Hjef/994EESMnv2bKKjo+nZsydubm5cu3aNdevWcf78eb799lsMDQ2V+/z111/88ssv9O7dm2rVqukkkAAFBQUsXLiQU6dOMXXqVHx9fZ/YbnPnzqVly5Z06NCB69ev8+uvvwIof6aKioqYNWsWly9fpl+/ftSrV48LFy4wffr0svxYhBBClKLCJjdfffVVqcce3c35o48+Un5fVFSEu7s7VlZW/Pjjj3z00UdYWFhw8+ZNMjIyGDduHG+//bZSv6Sdu/Pz85k5cyZmZmYA1KtXj2HDhnH06FF69uxJlSpVqFq1qnKsWrVqWuf36dNH+b1Go8HV1ZVatWoxefJkrl69St26dSkqKmLdunU4OzszceJEpb6bmxujRo3C1tZWKYuLi8Pc3JyRI0cqZV5eXqW2z6NMTU35+uuv0dfXB6By5cqMHz+e06dP06pVK4qKili5ciWOjo5888036Ok9mMrl6+vLyJEj+eWXX5g/f/4Tn7uk+zo7OxMVFUWvXr0AiIqK4oMPPmDbtm2cP38eDw8PoqKi0Gg0eHt7A3DmzBnOnDnD0KFD6d69O/BgV/aqVasyf/58Dh48SMeOHZX7pKWl8dNPP1GzZs0S48jIyGD27NkkJiYyb9486tatW6Z269Chg3J/b29vEhISOHDgAP/85z9RqVRERERw7tw5xowZoyRmjRo1wsDAQEmEhBBClF+FTW4+//xzatWqpVP+888/c/fuXa2yK1eusG7dOuLi4sjIyNA6duvWLRo0aIC9vT0WFhasWrWK1NRU3N3dS+1x8PT0VBIbABsbGypVqkRSUlKZYr9z5w5r1qwhOjqa+/fv8/DG7Tdv3qRu3brcunWL1NRUunXrpnVu1apVcXV1JTExUSlzdnZm165dfPvtt7Rs2RI3NzesrKzKFAtA48aNlcQGoE6dOgAkJycDD9ooJSWFgIAAJbGBB8nJO++8w969e8s1j+VhDRs2ZPPmzeTl5XH//n0SEhJo1aoV0dHRREZG4uHhQWRkJFWrVqVGjRoAREdHAyjDRMWaN2+OiYkJ0dHRWslNnTp1Sk1skpKSmDBhAoaGhnz77bfl2vS0SRPttWHq1KlDfn4+aWlp2NjYEBsbC+gmyK1atSpzcpOQkEBCQgLwIIkVQghRgZObWrVqKUMZD3s46YAHX9CTJk2iZs2aDB8+nGrVqmFoaMilS5dYsmQJ+fn5AJibmzNnzhw2btzI6tWryczMxNbWlnfffZfevXtrzc2xtLTUua+hoaFyrcfJyclh4sSJGBkZMXDgQGrUqIGxsTF3795l7ty5yjWKkzBra2uda1hbW2slN23btkWtVrNv3z7mzZuHRqPBycmJAQMG0KhRoyfG9GgiVDykk5eXpxVL8TDTw2xtbSkqKiIzM/Opkhtvb2/Wr1/PuXPnSE5OVuY5eXl5ERUVxcCBA4mOjtbqicrIyEBfX59KlSppXUulUmFtbU16erpOjKW5ePEi6enpDBw4sNy7uZfWbg//DPX19XX+vJT0My3N0qVLmTFjRrniEkKIiq7CJjdldeLECXJzc5k0aZLWcNXVq1d16tapU4evvvoKjUbDtWvXCAsLY/369RgZGdGzZ89nEk90dDQpKSnMmTMHDw8PpfzRV6eLvxDT0tJ0rpGamqpT5u/vj7+/P7m5uZw9e5agoCACAwNZsmSJzjBdeRXHUtJ9U1JS0NPT05rEWx7Ozs6YmpoSFRVFUlISXl5eqFQqvLy82Lp1K5cuXSI5OVkrubG0tEStVnP//n2tBEej0ZCWllZi0luaFi1aYGNjw5o1a9BoNFpDhn9XcZwZGRlaCU5J7ViaUaNGERAQADzouRk4cOAzi08IIV5Xb/w6NyqVCkBrgqlGo2Hfvn2PPadu3brKmy9Xrlwp930f/Vf8o/E83BMEDyYPP6xmzZrY2Nhw9OhRrfLk5GTOnz9f6n1NTEzw9fWlV69eFBYWEh8fX+7YH1WzZk0qV67MoUOHtIbQcnNzOXbsGA0aNFB6bUp77tIYGBjg7u5OZGSkVg+Nm5sb+vr6rFmzRkl2ihX/Pjw8XOtax44dIzc3t1zzjeDBHKjhw4cTFBTEqlWrynXu4xQnr0eOHNEqf/Tz49jb2+Pj44OPjw+urq7PLDYhhHidvfE9N97e3hgYGPDdd9/RvXt38vPz2bNnj84KuidPnmT37t00bdqU6tWro9FoOH78OFlZWcpE1vJwdHQEYMeOHbRr1w59fX1q1qyJi4sLFhYWLF68mL59+2JgYEB4eDjXrl3TOl9PT49+/frxn//8h3nz5uHv709WVhbr16/HxsZGSZIAFi1ahJGREa6urtjY2JCWlsbGjRsxNzcvVy9GafT09Bg6dCgLFiwgMDCQjh07UlBQwJYtW8jKytJ6rbq05350uPBhDRs2ZMWKFQBKWxsbG+Pi4sKZM2eoU6eO1lCOt7c3jRo1YtWqVWRnZ+Pq6qq8LVWvXj3atm1b7mcsfnPtP//5D7m5uYwcOVKrjZ9GcUKyYsUKcnJyqF+/PufPn+e3334D0Jq/JIQQouze+OSmVq1aTJo0iTVr1jB37lwsLS1p1aoVXbp00ZrLYG9vj7m5OSEhIaSkpGBoaEjNmjW11jcpD09PT3r27MnBgwfZt28fRUVFynov06ZNY8WKFXz//feYmJjQtGlTvvrqKz7//HOta7z33nuoVCrlVfNq1arRo0cP/vjjD2WyLzzo5QgLC+Po0aNkZmZiZWWFm5sbn3/+uc68lKfVunVrjI2N2bRpE99++y16eno0aNCA2bNna/UoPO65S1Pc01KjRg2tITQvLy9iYmJ0emJUKhVTpkxh3bp1hIWFsXHjRqysrGjTpg2DBg3S6qUrj3fffRcTExN++OEHcnNzGTdu3FNdp5ienh5ff/01P//8M5s2baKwsBBXV1e++OILvvrqK631cIQQQpSdSvPwOIJ47WVmZjJmzBiaNm3KJ5988rLDEU+heM2gf/3rX+UaaoqIiMDX15fTp0/j4+NTrnvKruBCiIrkje+5eZ2lpqayYcMGPD09sbKyIikpiW3btpGTk6NMMhWvtkOHDpGSkoKjoyMqlYoLFy6wZcsW3N3dZQ6NEEI8JUluXmOGhoYkJSWxZMkS5VVrZ2dnxo4dW+oaPOLVYmZmxrZt29iwYQO5ubnY2NjQvn17eetJCCH+BkluXmMWFhZ8/fXXLzsM8Tf4+fkpe44JIYR4NuR1DCGEEEJUKNJzI4SQCcNCiApFem6EEEIIUaFIz40QFUROTg4gG2gKISoeFxeXxy72+ihJboSoIIpXsZY3rYQQFU151++SRfyEqCDu3r3L3r17qVOnDqampmU+r3jDzTVr1sjaOs+ZtPWLI2394ryItpaeGyHeUFWqVGHAgAFPfb6rq2u5VzYWT0fa+sWRtn5xXqW2lgnFQgghhKhQJLkR4g1nb2/PN998g729/csOpcKTtn5xpK1fnFexrWXOjRBCCCEqFOm5EUIIIUSFIhOKhXhD5eTksGbNGn7//XcyMjKoVasWPXr0oFWrVi87tFdKTEwMU6ZMKfHY/PnzcXFxUT5fuXKFX375hQsXLqCvr4+npyf/+Mc/qF69us65O3fuZNeuXSQmJmJra0v79u3p1asXBgba/1tOS0vjl19+4eTJk+Tl5VG3bl0GDhyIl5fXs33QFyw7O5vg4GCuXr3KX3/9RXp6On379qV///46dV92u0ZGRrJ27VquXr2KsbExfn5+DB06FGtr62fWHs9TWdt64cKFHDx4UOf8mjVrsnjxYp3yV7mtJbkR4g01d+5cLl26xJAhQ6hRowaHDx/mu+++Q6PR0Lp165cd3itn0KBBeHp6apU5Ojoqv7958yaTJ0+mbt26TJgwgfz8fIKCgpg4cSI//vgjlSpVUupu2LCBtWvX0qNHDxo1asSlS5dYs2YN9+7d45NPPlHqFRQU8PXXX5OVlcWIESOoVKkSu3fvZvr06QQGBuLh4fH8H/w5ycjIYN++fdSpU4e3336bffv2lVjvZbdrbGwsM2bMoHHjxkyZMoX79++zatUqvv76a77//nsMDQ2fXyM9I2VtawAjIyNmzZqlVWZsbKxT75Vva40Q4o1z8uRJTefOnTXh4eFa5V9//bVmyJAhmsLCwpcU2asnOjpa07lzZ83Ro0cfW2/evHmaAQMGaLKyspSyxMRETbdu3TQrV65Uyu7fv6/p0aOHZtGiRVrnBwcHawICAjTXr19Xynbt2qXp3LmzJi4uTikrLCzUjB07VjN+/Pi/+WQvV1FRkaaoqEij0Txok86dO2vWrl2rU+9lt+sXX3yhGTt2rNbfiXPnzmk6d+6s2bVr19M9/AtW1rb+4YcfNL169Xri9V6HtpY5N0K8gU6cOIGpqSktWrTQKm/fvj0pKSlcvHjxJUX2elKr1Zw8eZJ33nlHa6ExOzs7PD09OXHihFIWERFBfn4+7du317qGv78/Go1Gq+7x48epWbOm1tCXvr4+bdq04eLFi9y7d+85PtXzpVKpUKlUj63zstv13r17XLp0ibZt26Kvr6/UdXV1pWbNmlrXfJWVpa3L43Voa0luhHgDXb9+nVq1amn9TwSgbt26ynGhbcmSJXTt2pU+ffrwzTffcO7cOeVYQkIC+fn51KlTR+e8OnXqKMfhf237aF1bW1usrKyIj49XyuLj40u9ZvHxiuxlt2tp14QHQ5IVsf3z8/MZPHgwXbt2ZdiwYSxZsoSMjAytOq9DW8ucGyHeQBkZGVSrVk2n3MLCQjkuHjAzM6Nz5854enpiaWlJQkICW7ZsYfLkyUybNg0fHx+lvYrb72EWFhZoNBoyMzOxtbUlIyMDQ0NDTExMdOpaWlpqtX1GRgaWlpYl1gNIT09/Vo/5SnrZ7fq4+1taWla49q9bty5169bFwcEBgLNnz7Jt2zaio6NZsGCBsq3L69DWktwI8YZ6XDf1s+zCft3Vr1+f+vXrK5/d3d15++23+ec//8kvv/yitdx8Wdv0WbXvm/JzetntWtp1K1r7d+nSRetzo0aNqFevHvPmzWPfvn1ax1/1tpZhKSHeQI/+66pYZmYmUPK/nsT/WFhY0LhxY65du0ZeXp7yr9DS2lSlUmFubg48aPv8/Hzy8vJ06j76r9zSfk7FZSX9i7giednt+rj7l9YjUdG8/fbbmJiYcOHCBaXsdWhrSW6EeAM5Ojpy8+ZN1Gq1Vvm1a9eU46JsVCoV9vb2GBkZKe33sGvXrinH4X9zCh6tm5qaSnp6ujIkAA9+DiXNfyoue7huRfSy27X470FpdSt6+xfTaDRaPSevQ1tLciPEG6hZs2bk5ORw7NgxrfKDBw9ia2uLs7PzS4rs9ZCZmcnJkyepW7cuRkZG6Ovr06RJE44fP052drZSLzk5mZiYGJo1a6aU+fj4YGRkRFhYmNY1w8LCUKlUvP3220rZ22+/zc2bN7X+1axWqwkPD8fZ2ZnKlSs/x6d8+V52u1auXBlnZ2fCw8O1/iFw/vx5bt26pXX/iurYsWPk5eXRoEEDpex1aGuZcyPEG8jX1xdvb28WL15MdnY29vb2HD58mIiICL744gudt6jeZN999x1Vq1blrbfewsrKitu3b7N161bS0tL49NNPlXr9+/dn/PjxBAYG0rNnT2WxOSsrK7p27arUs7S0pHfv3qxduxZLS0tlAbR169bRoUMHrX+hdujQgd27d/Ovf/2LIUOGKAug3bp1i8DAwBfZDM/F6dOnyc3NJScnB4AbN27w+++/A9C4cWOMjY1fersOGTKEaf9fe/cfE3X9xwH8+QFPrjNCIAiVBYFUoCIQImLK7xSOhSI/6lAHTNdI1oS5iCIwtAySNWsZlSlaO5ygqShNt8At81AZTMdMFkNqhXmGHGoJA3l//+jLJ887ARWljudju7HP+96f9+f1fh3bvfb5ce+CAhQXFyM2Nlb+YTk3NzdERUU9+CSNkuFy3d3djc2bN2PhwoXyApjNzc2orq7Gk08+iRdeeEEe67+Qay6cSTRODS6/cPz4cXn5hcTERC6/cJuqqip8//330Ov1uHHjBmxtbeHt7Y2kpCR4eXkZ9W1tbcXOnTtx/vx5WFtbw9fXF+np6WZXS66urkZNTQ0uXboEe3t7REZGIjk52eSn67u6ulBeXo6Ghgb5p+tTU1Ph5+f3IKf9UKxatQp6vd7se1988YX8RN9Y57WpqQlarVZeEiAwMBDp6en/meUXgOFzPWnSJHz00Udoa2uDwWDAwMAAnJ2dERwcjKSkJPneplv9m3PN4oaIiIgsCu+5ISIiIovC4oaIiIgsCosbIiIisigsboiIiMiisLghIiIii8LihoiIiCwKixsiIiKyKCxuiIiIyKKwuCEiIiKLwuKGiMal8vJySJIEpVJpdiXisLAwzJw5cwwiA44dOwZJklBVVTUmx79b7e3tUKvVcHBwgCRJWLt27ViHNGpqamqwfv36sQ6D7hKLGyIa13p7e5Gfnz/WYfynZWdn4+TJk9i+fTt0Oh2ys7PHOqRRU1NTg3feeWesw6C7xOKGiMa1xYsXQ6vV4syZM2MdykN348YNjMbygs3NzQgKCsKSJUsQHBwMNze3Ee8rhJBXqv43+euvv8Y6BLoPLG6IaFx7/fXX4ejoiNzc3CH7tbe3Q5IklJeXm7wnSZLRpYv169dDkiScPXsWSUlJsLOzg4ODA3JyctDf34+WlhYsXrwYtra2cHd3R0lJidlj9vT0ICcnBy4uLnjkkUcQGhqKpqYmk34NDQ148cUX4eDgAKVSCX9/f+zZs8eoz+BluKNHjyIjIwNOTk5QqVTo7e2945x/+eUXLF++HM7OzrCxsYG3tzdKS0sxMDAA4J/LZ62trfj2228hSRIkSUJ7e/sdx5QkCVlZWSgrK4O3tzdsbGywc+dOAMBPP/0EjUZjdLxPPvnEaP/BY3799dcjys3Bgwcxb948qFQq2NraIjo6GjqdzqjP4OfV2NiIxMRE2Nvbw9PTE2lpafLxB+d26/wqKysxd+5c2NnZQaVSwcPDAxkZGXecOz08LG6IaFyztbVFfn4+jhw5gtra2lEdOzk5GbNnz8bevXuxevVqfPjhh8jOzsaSJUugVqvxzTffICIiArm5udi3b5/J/m+++Sba2tqwbds2bNu2DR0dHQgLC0NbW5vcp66uDvPnz4fBYEBZWRkOHDgAPz8/pKSkmC3EMjIyoFAo8NVXX6GqqgoKhcJs7JcvX0ZISAiOHj2KDRs24ODBg4iKisK6deuQlZUFAAgICIBOp4OLiwvmz58PnU4HnU6HKVOmDJmX/fv349NPP0VBQQGOHDmCBQsW4Ny5c5gzZw6am5tRWlqKQ4cOQa1W47XXXjN7WWgkudFqtYiPj8djjz2GiooKfPnll+jq6kJYWBiOHz9uMmZCQgKmT5+OyspKlJWV4e2330ZiYiIAyHMbnJ9Op0NKSgo8PDywe/duHD58GAUFBejv7x9y7vSQCCKicWjHjh0CgDh9+rTo7e0VHh4eIjAwUAwMDAghhAgNDRUzZsyQ+1+4cEEAEDt27DAZC4AoLCyUtwsLCwUAUVpaatTPz89PABD79u2T2/r6+oSTk5NISEiQ2+rq6gQAERAQIMcjhBDt7e1CoVCIVatWyW3PPvus8Pf3F319fUbHiouLE1OmTBE3b940mu/KlStHlJ833nhDABAnT540as/MzBSSJImWlha5zc3NTajV6hGNC0DY2dmJK1euGLUvWrRIuLq6iu7ubqP2rKwsoVQq5f4jzc3NmzfF1KlTxaxZs+QcCCHEtWvXhLOzswgJCZHbBj+vgoICk3jXrFkjzH1Vbt68WQAQBoNhRPOmh4tnboho3Js4cSI2btyIhoYGk8s59yMuLs5o29vbG5IkISYmRm6bMGECpk+fbvaJLY1GA0mS5G03NzeEhISgrq4OANDa2orz588jNTUVANDf3y+/YmNjcfHiRbS0tBiNuWzZshHFXltbCx8fHwQFBRm1p6WlQQhxX2e5IiIiYG9vL2/39PTgu+++w9KlS6FSqUzm0dPTg/r6eqMxhstNS0sLOjo6sGLFClhZ/fNV9+ijj2LZsmWor683ua9mpLkBgDlz5gD4++zcnj178Ntvv408AfTAsbghIgLw0ksvISAgAG+99Rb6+vpGZUwHBwej7YkTJ0KlUkGpVJq09/T0mOzv4uJitq2zsxMAcOnSJQDAunXroFAojF6vvvoqAOCPP/4w2n+4S0aDOjs7zfadOnWq/P69un3czs5O9Pf34+OPPzaZR2xsLADTeQyXm8G/d5rDwMAAurq6hoxrKAsXLsT+/fvR39+PlStXwtXVFTNnzkRFRcWIx6AHZ8JYB0BE9G8gSRKKi4sRHR2Nzz//3OT9wYLk9htw7+dLfji///672TZHR0cAwOOPPw4AyMvLQ0JCgtkxnnnmGaPtW892DMXR0REXL140ae/o6DA69r24PQZ7e3tYW1tjxYoVWLNmjdl9nnrqKaPt4XIz+PdOc7CysjI6e2QuruHEx8cjPj4evb29qK+vx6ZNm6DRaODu7o558+bd1Vg0unjmhojo/6KiohAdHY2ioiJcv37d6L0nnngCSqUSZ8+eNWo/cODAA4unoqLC6FHtn3/+GSdOnEBYWBiAvwsXLy8vnDlzBoGBgWZftra293TsyMhInDt3Do2NjUbtu3btgiRJCA8Pv+d53U6lUiE8PBxNTU3w9fU1O4/BYmXQSHIzbdo0aLVao35//vkn9u7dKz9BNRwbGxsAGPJxdRsbG4SGhqK4uBgAzD61RQ8Xz9wQEd2iuLgYzz33HPR6PWbMmCG3S5KE5cuXY/v27fD09MTs2bNx6tQpaLXaBxaLXq/H0qVLsXr1anR3d6OwsBBKpRJ5eXlyn88++wwxMTFYtGgR0tLSMG3aNFy5cgU//vgjGhsbUVlZeU/Hzs7Oxq5du6BWq1FUVAQ3NzccPnwYW7duRWZmJp5++unRmiYAYMuWLXj++eexYMECZGZmwt3dHdeuXUNrayuqq6tN7vEZLjdWVlYoKSlBamoq4uLi8Morr6C3txcffPABDAYD3n///RHFNWvWLAB//1/ExMTA2toavr6+2LhxI3799VdERkbC1dUVBoMBW7ZsgUKhQGho6Kjmhu4eixsiolv4+/vj5ZdfNlu0lJaWAgBKSkpw/fp1RERE4NChQ3B3d38gsbz33ns4ffo00tPTcfXqVQQFBWH37t3w9PSU+4SHh+PUqVN49913sXbtWnR1dcHR0RE+Pj5ITk6+52M7OTnhxIkTyMvLQ15eHq5evQoPDw+UlJQgJydnNKZnxMfHB42NjdiwYQPy8/Oh1+sxefJkeHl5yffd3GokudFoNJg0aRI2bdqElJQUWFtbIzg4GHV1dQgJCRlRXBqNBj/88AO2bt2KoqIiCCFw4cIFzJ07Fw0NDcjNzcXly5cxefJkBAYGora21qgoprEhCTEKP09JRET0EBw7dgzh4eGorKyUf4OG6Ha854aIiIgsCosbIiIisii8LEVEREQWhWduiIiIyKKwuCEiIiKLwuKGiIiILAqLGyIiIrIoLG6IiIjIorC4ISIiIovC4oaIiIgsCosbIiIisigsboiIiMii/A+K+LVLvww+PAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<Figure size 400x300 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<ggplot: (309548255)>" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(insta_reports_by_reason) +\\\n", + " geom_bar(aes(x='reason_cat', y='count'), stat='identity', fill='#0280c9') +\\\n", + " coord_flip() +\\\n", + " xlab('Reason') + ylab('Number of reports') +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " theme(figure_size=(4, 3),\n", + " axis_text_y=element_text(margin={'r': 5}),\n", + " text=element_text(size=12))\n", + "\n", + "plt.save('./plots/insta_reports_by_reason.pdf', limitsize=False)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "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>reason</th>\n", + " <th>mean_pdf</th>\n", + " <th>reason_cat</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>Mobile app not working</td>\n", + " <td>0.174832</td>\n", + " <td>Mobile app not working</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>Website down</td>\n", + " <td>0.173807</td>\n", + " <td>Website down</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>Unknown</td>\n", + " <td>0.130210</td>\n", + " <td>Unknown</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>Everything is down</td>\n", + " <td>0.127983</td>\n", + " <td>Everything is down</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>Can't login</td>\n", + " <td>0.082374</td>\n", + " <td>Can't login</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>Message send problems</td>\n", + " <td>0.075580</td>\n", + " <td>Message send problems</td>\n", + " </tr>\n", + " <tr>\n", + " <th>6</th>\n", + " <td>Message read problems</td>\n", + " <td>0.033245</td>\n", + " <td>Message read problems</td>\n", + " </tr>\n", + " <tr>\n", + " <th>7</th>\n", + " <td>Mobile app crashes</td>\n", + " <td>0.031515</td>\n", + " <td>Mobile app crashes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>8</th>\n", + " <td>Stream not working</td>\n", + " <td>0.029427</td>\n", + " <td>Stream not working</td>\n", + " </tr>\n", + " <tr>\n", + " <th>9</th>\n", + " <td>Videos won't play</td>\n", + " <td>0.023544</td>\n", + " <td>Videos won't play</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " reason mean_pdf reason_cat\n", + "0 Mobile app not working 0.174832 Mobile app not working\n", + "1 Website down 0.173807 Website down\n", + "2 Unknown 0.130210 Unknown\n", + "3 Everything is down 0.127983 Everything is down\n", + "4 Can't login 0.082374 Can't login\n", + "5 Message send problems 0.075580 Message send problems\n", + "6 Message read problems 0.033245 Message read problems\n", + "7 Mobile app crashes 0.031515 Mobile app crashes\n", + "8 Stream not working 0.029427 Stream not working\n", + "9 Videos won't play 0.023544 Videos won't play" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reason_fraction_df_list = []\n", + "\n", + "for vendor in filtered_or_reports['vendor'].unique():\n", + " partial_df = filtered_or_reports[filtered_or_reports['vendor'] == vendor].reset_index(drop=True)\n", + " count_df = partial_df.groupby('reason')['id'].count().reset_index().rename(columns={'id': 'count'})\n", + " count_df['pdf'] = count_df['count'] / count_df['count'].sum()\n", + " count_df['vendor'] = vendor\n", + " reason_fraction_df_list.append(count_df)\n", + "\n", + "reason_fraction_df = pd.concat(reason_fraction_df_list)\n", + "mean_fractions_reasons = reason_fraction_df.groupby('reason')['pdf'].sum().reset_index().rename(columns={'pdf': 'mean_pdf'})\n", + "mean_fractions_reasons['mean_pdf'] = mean_fractions_reasons['mean_pdf'] / 12\n", + "top10_mean_fractions_reasons = mean_fractions_reasons.sort_values('mean_pdf', ascending=False).reset_index(drop=True)[:10]\n", + "reasons_sorted = top10_mean_fractions_reasons.sort_values('mean_pdf')['reason'].values\n", + "top10_mean_fractions_reasons['reason_cat'] = pd.Categorical(top10_mean_fractions_reasons['reason'], categories=reasons_sorted, ordered=True)\n", + "top10_mean_fractions_reasons" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 400x300 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<ggplot: (309449361)>" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(top10_mean_fractions_reasons) +\\\n", + " geom_bar(aes(x='reason_cat', y='mean_pdf'), stat='identity', fill='#0280c9') +\\\n", + " coord_flip() +\\\n", + " xlab('Reason') + ylab('Mean of fraction of reports per service') +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " theme(figure_size=(4, 3),\n", + " axis_text_y=element_text(margin={'r': 5}),\n", + " text=element_text(size=12))\n", + "\n", + "plt.save('./plots/all_reports_by_reason.pdf', limitsize=False)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1062" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "github_or_reports.groupby('reason')['id'].count().reset_index().rename(columns={'id': 'count'})['count'].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "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>vendor</th>\n", + " <th>count</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>github</td>\n", + " <td>1062</td>\n", + " </tr>\n", + " <tr>\n", + " <th>7</th>\n", + " <td>skype</td>\n", + " <td>2029</td>\n", + " </tr>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>apple-servers</td>\n", + " <td>2566</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>facebook-messenger</td>\n", + " <td>6836</td>\n", + " </tr>\n", + " <tr>\n", + " <th>8</th>\n", + " <td>snapchat</td>\n", + " <td>8118</td>\n", + " </tr>\n", + " <tr>\n", + " <th>10</th>\n", + " <td>whatsapp</td>\n", + " <td>9426</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>gmail</td>\n", + " <td>9427</td>\n", + " </tr>\n", + " <tr>\n", + " <th>6</th>\n", + " <td>netflix</td>\n", + " <td>20211</td>\n", + " </tr>\n", + " <tr>\n", + " <th>9</th>\n", + " <td>twitter</td>\n", + " <td>20252</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>facebook</td>\n", + " <td>25886</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11</th>\n", + " <td>youtube</td>\n", + " <td>26783</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>instagram</td>\n", + " <td>41574</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " vendor count\n", + "3 github 1062\n", + "7 skype 2029\n", + "0 apple-servers 2566\n", + "2 facebook-messenger 6836\n", + "8 snapchat 8118\n", + "10 whatsapp 9426\n", + "4 gmail 9427\n", + "6 netflix 20211\n", + "9 twitter 20252\n", + "1 facebook 25886\n", + "11 youtube 26783\n", + "5 instagram 41574" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filtered_or_reports.groupby('vendor')['country'].count().reset_index().rename(columns={'country':'count'}).sort_values('count')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} |