From a5a140c6286e8b113ca8d371f88e3ed54e731cea Mon Sep 17 00:00:00 2001 From: mjkwiatkowski Date: Sun, 17 May 2026 14:21:09 +0200 Subject: feat: added lots of citations and slowly finishing the introduction --- datasets/Talluri2021/.gitignore | 140 + .../1.compare_github_and_outagereport.ipynb | 749 +++++ datasets/Talluri2021/2.basic_stats_reports.ipynb | 448 +++ datasets/Talluri2021/3.country and reason.ipynb | 887 ++++++ .../Talluri2021/4.response time experiment.ipynb | 543 ++++ .../Talluri2021/5.analyze experiment results.ipynb | 115 + datasets/Talluri2021/Dockerfile | 22 + datasets/Talluri2021/README.md | 27 + datasets/Talluri2021/artifact_documentation.txt | 23 + datasets/Talluri2021/deep chain comparison.pdf | Bin 0 -> 14748 bytes datasets/Talluri2021/deep chain comparison.png | Bin 0 -> 102439 bytes .../experiment_results/long_chain_results_sin1.csv | 13 + datasets/Talluri2021/github-global-status.html | 2881 ++++++++++++++++++++ .../github_failures_2019-20/_common_metadata | Bin 0 -> 2739 bytes .../Talluri2021/github_failures_2019-20/_metadata | Bin 0 -> 3199 bytes .../github_failures_2019-20/part.0.parquet | Bin 0 -> 6034 bytes datasets/Talluri2021/github_parser.ipynb | 726 +++++ datasets/Talluri2021/monolith comparison.png | Bin 0 -> 32580 bytes .../other notebooks/4.failures from reports.ipynb | 1920 +++++++++++++ .../5.covid period comparison.ipynb | 229 ++ .../8.analyze experiment results.ipynb | 504 ++++ .../outage_report_2019-20/_common_metadata | Bin 0 -> 2691 bytes .../Talluri2021/outage_report_2019-20/_metadata | Bin 0 -> 3198 bytes .../outage_report_2019-20/part.0.parquet | Bin 0 -> 3298243 bytes .../_common_metadata | Bin 0 -> 2939 bytes .../_metadata | Bin 0 -> 3474 bytes .../part.0.parquet | Bin 0 -> 5392774 bytes datasets/Talluri2021/outage_report_instagram.html | 970 +++++++ .../outage_report_instagram_files/1f31a.png | Bin 0 -> 860 bytes .../outage_report_instagram_files/1f33b.png | Bin 0 -> 835 bytes .../outage_report_instagram_files/1f40e.png | Bin 0 -> 1092 bytes .../outage_report_instagram_files/1f47f.png | Bin 0 -> 750 bytes .../outage_report_instagram_files/1f517.png | Bin 0 -> 635 bytes .../outage_report_instagram_files/1f614.png | Bin 0 -> 683 bytes .../outage_report_instagram_files/1f62d.png | Bin 0 -> 980 bytes .../outage_report_instagram_files/1f928.png | Bin 0 -> 727 bytes .../outage_report_instagram_files/1f931-1f3fd.png | Bin 0 -> 1007 bytes .../outage_report_instagram_files/1f98b.png | Bin 0 -> 1675 bytes ...c234488de92aa9cda3a-470x290-20200826-010136.jpg | Bin 0 -> 80599 bytes .../Z4Hc2nrF_normal.jpg | Bin 0 -> 2111 bytes .../outage_report_instagram_files/analytics.js | 86 + .../outage_report_instagram_files/bootstrap.css | 6 + .../cookie-consent-a61aae2999f43a6aa8bc.js | 2 + .../outage_report_instagram_files/css.css | 168 ++ .../outage_report_instagram_files/font-awesome.css | 4 + .../ijJfaNbC_normal.jpg | Bin 0 -> 2035 bytes .../outage_report_instagram_files/instagram-45.png | Bin 0 -> 11153 bytes .../outage_report_instagram_files/logo-small.png | Bin 0 -> 5083 bytes .../pF46Bhhz_normal.jpg | Bin 0 -> 2339 bytes .../outage_report_instagram_files/raven.js | 3 + .../outage_report_instagram_files/runtime.js | 2 + .../service-8371c8261643fae46b05.js | 90 + .../outage_report_instagram_files/service.css | 2 + .../vendors-e73437c39884b7248588.js | 18 + .../Talluri2021/plots/all_reports_by_reason.pdf | Bin 0 -> 13527 bytes datasets/Talluri2021/plots/covid_comparison.pdf | Bin 0 -> 21633 bytes .../plots/double_github_merged_failures.pdf | Bin 0 -> 134427 bytes .../double_github_merged_failures_overlay.pdf | Bin 0 -> 73654 bytes datasets/Talluri2021/plots/facebook_deseasoned.pdf | Bin 0 -> 34306 bytes .../plots/facebook_detrended_see_season.pdf | Bin 0 -> 57832 bytes .../Talluri2021/plots/facebook_fit_seasonality.pdf | Bin 0 -> 50674 bytes datasets/Talluri2021/plots/facebook_fit_trend.pdf | Bin 0 -> 77751 bytes .../Talluri2021/plots/failure_duration_ia_cdf.pdf | Bin 0 -> 32704 bytes .../plots/failure_duration_ia_cdf_with_legend.pdf | Bin 0 -> 39196 bytes .../plots/failure_duration_ia_legend.pdf | Bin 0 -> 9646 bytes .../Talluri2021/plots/failure_mean_peak_cdf.pdf | Bin 0 -> 27752 bytes datasets/Talluri2021/plots/github_failures_all.pdf | Bin 0 -> 122860 bytes .../Talluri2021/plots/github_merged_failures.pdf | Bin 0 -> 126840 bytes .../Talluri2021/plots/insta_reports_by_reason.pdf | Bin 0 -> 13311 bytes datasets/Talluri2021/plots/or_github_failures.pdf | Bin 0 -> 121794 bytes datasets/Talluri2021/plots/or_hour_of_week.pdf | Bin 0 -> 41079 bytes .../Talluri2021/plots/or_hour_of_week_count.pdf | Bin 0 -> 33151 bytes datasets/Talluri2021/plots/reports_by_country.pdf | Bin 0 -> 12929 bytes .../plots/reports_week_and_month_aggregated.pdf | Bin 0 -> 169872 bytes .../Talluri2021/plots/week_facebook_fit_trend.pdf | Bin 0 -> 10492 bytes datasets/Talluri2021/requirements.txt | 6 + datasets/Talluri2021/timeseries analysis.ipynb | 930 +++++++ 77 files changed, 11514 insertions(+) create mode 100644 datasets/Talluri2021/.gitignore create mode 100644 datasets/Talluri2021/1.compare_github_and_outagereport.ipynb create mode 100644 datasets/Talluri2021/2.basic_stats_reports.ipynb create mode 100644 datasets/Talluri2021/3.country and reason.ipynb create mode 100644 datasets/Talluri2021/4.response time experiment.ipynb create mode 100644 datasets/Talluri2021/5.analyze experiment results.ipynb create mode 100644 datasets/Talluri2021/Dockerfile create mode 100644 datasets/Talluri2021/README.md create mode 100644 datasets/Talluri2021/artifact_documentation.txt create mode 100644 datasets/Talluri2021/deep chain comparison.pdf create mode 100644 datasets/Talluri2021/deep chain comparison.png create mode 100644 datasets/Talluri2021/experiment_results/long_chain_results_sin1.csv create mode 100644 datasets/Talluri2021/github-global-status.html create mode 100644 datasets/Talluri2021/github_failures_2019-20/_common_metadata create mode 100644 datasets/Talluri2021/github_failures_2019-20/_metadata create mode 100644 datasets/Talluri2021/github_failures_2019-20/part.0.parquet create mode 100644 datasets/Talluri2021/github_parser.ipynb create mode 100644 datasets/Talluri2021/monolith comparison.png create mode 100644 datasets/Talluri2021/other notebooks/4.failures from reports.ipynb create mode 100644 datasets/Talluri2021/other notebooks/5.covid period comparison.ipynb create mode 100644 datasets/Talluri2021/other notebooks/8.analyze experiment results.ipynb create mode 100644 datasets/Talluri2021/outage_report_2019-20/_common_metadata create mode 100644 datasets/Talluri2021/outage_report_2019-20/_metadata create mode 100644 datasets/Talluri2021/outage_report_2019-20/part.0.parquet create mode 100644 datasets/Talluri2021/outage_report_individual_reports_2019-20/_common_metadata create mode 100644 datasets/Talluri2021/outage_report_individual_reports_2019-20/_metadata create mode 100644 datasets/Talluri2021/outage_report_individual_reports_2019-20/part.0.parquet create mode 100644 datasets/Talluri2021/outage_report_instagram.html create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f31a.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f33b.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f40e.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f47f.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f517.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f614.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f62d.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f928.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f931-1f3fd.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/1f98b.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/5458ac234488de92aa9cda3a-470x290-20200826-010136.jpg create mode 100644 datasets/Talluri2021/outage_report_instagram_files/Z4Hc2nrF_normal.jpg create mode 100644 datasets/Talluri2021/outage_report_instagram_files/analytics.js create mode 100644 datasets/Talluri2021/outage_report_instagram_files/bootstrap.css create mode 100644 datasets/Talluri2021/outage_report_instagram_files/cookie-consent-a61aae2999f43a6aa8bc.js create mode 100644 datasets/Talluri2021/outage_report_instagram_files/css.css create mode 100644 datasets/Talluri2021/outage_report_instagram_files/font-awesome.css create mode 100644 datasets/Talluri2021/outage_report_instagram_files/ijJfaNbC_normal.jpg create mode 100644 datasets/Talluri2021/outage_report_instagram_files/instagram-45.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/logo-small.png create mode 100644 datasets/Talluri2021/outage_report_instagram_files/pF46Bhhz_normal.jpg create mode 100644 datasets/Talluri2021/outage_report_instagram_files/raven.js create mode 100644 datasets/Talluri2021/outage_report_instagram_files/runtime.js create mode 100644 datasets/Talluri2021/outage_report_instagram_files/service-8371c8261643fae46b05.js create mode 100644 datasets/Talluri2021/outage_report_instagram_files/service.css create mode 100644 datasets/Talluri2021/outage_report_instagram_files/vendors-e73437c39884b7248588.js create mode 100644 datasets/Talluri2021/plots/all_reports_by_reason.pdf create mode 100644 datasets/Talluri2021/plots/covid_comparison.pdf create mode 100644 datasets/Talluri2021/plots/double_github_merged_failures.pdf create mode 100644 datasets/Talluri2021/plots/double_github_merged_failures_overlay.pdf create mode 100644 datasets/Talluri2021/plots/facebook_deseasoned.pdf create mode 100644 datasets/Talluri2021/plots/facebook_detrended_see_season.pdf create mode 100644 datasets/Talluri2021/plots/facebook_fit_seasonality.pdf create mode 100644 datasets/Talluri2021/plots/facebook_fit_trend.pdf create mode 100644 datasets/Talluri2021/plots/failure_duration_ia_cdf.pdf create mode 100644 datasets/Talluri2021/plots/failure_duration_ia_cdf_with_legend.pdf create mode 100644 datasets/Talluri2021/plots/failure_duration_ia_legend.pdf create mode 100644 datasets/Talluri2021/plots/failure_mean_peak_cdf.pdf create mode 100644 datasets/Talluri2021/plots/github_failures_all.pdf create mode 100644 datasets/Talluri2021/plots/github_merged_failures.pdf create mode 100644 datasets/Talluri2021/plots/insta_reports_by_reason.pdf create mode 100644 datasets/Talluri2021/plots/or_github_failures.pdf create mode 100644 datasets/Talluri2021/plots/or_hour_of_week.pdf create mode 100644 datasets/Talluri2021/plots/or_hour_of_week_count.pdf create mode 100644 datasets/Talluri2021/plots/reports_by_country.pdf create mode 100644 datasets/Talluri2021/plots/reports_week_and_month_aggregated.pdf create mode 100644 datasets/Talluri2021/plots/week_facebook_fit_trend.pdf create mode 100644 datasets/Talluri2021/requirements.txt create mode 100644 datasets/Talluri2021/timeseries analysis.ipynb (limited to 'datasets') diff --git a/datasets/Talluri2021/.gitignore b/datasets/Talluri2021/.gitignore new file mode 100644 index 0000000..b561863 --- /dev/null +++ b/datasets/Talluri2021/.gitignore @@ -0,0 +1,140 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +.DS_Store \ No newline at end of file diff --git a/datasets/Talluri2021/1.compare_github_and_outagereport.ipynb b/datasets/Talluri2021/1.compare_github_and_outagereport.ipynb new file mode 100644 index 0000000..1588f8e --- /dev/null +++ b/datasets/Talluri2021/1.compare_github_and_outagereport.ipynb @@ -0,0 +1,749 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from plotnine import *\n", + "from datetime import datetime\n", + "import numpy as np\n", + "import itertools" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "github_incidents = pd.read_parquet('./github_failures_2019-20').reset_index(drop=True)\n", + "or_events = pd.read_parquet('./outage_report_2019-20')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "github_incidents['start_time'] = pd.to_datetime(github_incidents['event_start_time'], unit='s')\n", + "github_incidents['end_time'] = pd.to_datetime(github_incidents['event_end_time'], unit='s')\n", + "\n", + "github_filter_mask = (github_incidents['event_start_time'] != -1) & (github_incidents['event_end_time'] != -1)\n", + "filtered_github_incidents = github_incidents[github_filter_mask].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
statusevent_start_timeevent_end_timevendorstart_timeend_time
0-1-11969-12-31 23:59:591969-12-31 23:59:59
1\\n\\n\\n\\nResolved -\\n \\t2019-05-07 10:35 U...-11557225300Github1969-12-31 23:59:592019-05-07 10:35:00
2\\n\\n\\n\\nResolved -\\n \\tWebhook deliveries...-11585641600Github1969-12-31 23:59:592020-03-31 08:00:00
3\\n\\n\\n\\nResolved -\\n \\tWe have identified...-11586352600Github1969-12-31 23:59:592020-04-08 13:30:00
\n", + "
" + ], + "text/plain": [ + " status event_start_time \\\n", + "0 -1 \n", + "1 \\n\\n\\n\\nResolved -\\n \\t2019-05-07 10:35 U... -1 \n", + "2 \\n\\n\\n\\nResolved -\\n \\tWebhook deliveries... -1 \n", + "3 \\n\\n\\n\\nResolved -\\n \\tWe have identified... -1 \n", + "\n", + " event_end_time vendor start_time end_time \n", + "0 -1 1969-12-31 23:59:59 1969-12-31 23:59:59 \n", + "1 1557225300 Github 1969-12-31 23:59:59 2019-05-07 10:35:00 \n", + "2 1585641600 Github 1969-12-31 23:59:59 2020-03-31 08:00:00 \n", + "3 1586352600 Github 1969-12-31 23:59:59 2020-04-08 13:30:00 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Need to incorporate these later. IMPORTANT\n", + "github_incidents.loc[~github_filter_mask].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
statusevent_start_timeevent_end_timevendorstart_timeend_time
1minor15695020201569506460Github2019-09-26 12:47:002019-09-26 14:01:00
3minor15693246001569334080Github2019-09-24 11:30:002019-09-24 14:08:00
4critical15692551201569256620Github2019-09-23 16:12:002019-09-23 16:37:00
\n", + "
" + ], + "text/plain": [ + " status event_start_time event_end_time vendor start_time \\\n", + "1 minor 1569502020 1569506460 Github 2019-09-26 12:47:00 \n", + "3 minor 1569324600 1569334080 Github 2019-09-24 11:30:00 \n", + "4 critical 1569255120 1569256620 Github 2019-09-23 16:12:00 \n", + "\n", + " end_time \n", + "1 2019-09-26 14:01:00 \n", + "3 2019-09-24 14:08:00 \n", + "4 2019-09-23 16:37:00 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Investigating the lack of critical event from September 2019\n", + "filtered_github_incidents[(filtered_github_incidents['start_time'].dt.year == 2019) & (filtered_github_incidents['start_time'].dt.month == 9)]" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [], + "source": [ + "# Check ICPE article as we missed events shorter than an hour" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(39195, 4)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# I checked outage report code and timestamps are in UTC\n", + "filtered_or_events = or_events[or_events['status_code'] >= 0].reset_index(drop=True)\n", + "filtered_or_events = filtered_or_events.drop_duplicates(subset=['vendor', 'event_time', 'status_code'])\n", + "# Combine events with the same event_time, but different status_code with max\n", + "filtered_or_events = filtered_or_events.groupby(['vendor', 'event_time'])['status_code'].max().reset_index()\n", + "filtered_or_events['evtime'] = pd.to_datetime(filtered_or_events['event_time'], unit='s')\n", + "or_github = filtered_or_events[(filtered_or_events['vendor'] == 'github')].reset_index(drop=True)\n", + "or_github.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1,\n", + " 32,\n", + " 60,\n", + " 91,\n", + " 121,\n", + " 152,\n", + " 182,\n", + " 213,\n", + " 244,\n", + " 274,\n", + " 305,\n", + " 335,\n", + " 366,\n", + " 397,\n", + " 425,\n", + " 456,\n", + " 486,\n", + " 517,\n", + " 547,\n", + " 578,\n", + " 609,\n", + " 639,\n", + " 670,\n", + " 700,\n", + " 731]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n", + "first_day_of_month = list(itertools.accumulate(days_per_month, initial=1))\n", + "first_day_of_month_for_two_years = list(itertools.accumulate(days_per_month + days_per_month, initial=1))\n", + "first_day_of_month_for_two_years" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4432.0\n", + "2974.0\n" + ] + } + ], + "source": [ + "all_or_github_count = 0\n", + "filtered_or_github_count = 0\n", + "grid_array = np.full((365*2, 24), 0)\n", + "for _, row in or_github.sort_values('evtime').iterrows():\n", + " year_of_event = row['evtime'].year\n", + " day_of_year = row['evtime'].timetuple().tm_yday\n", + " hour_of_day = row['evtime'].hour\n", + " num_reports = row['status_code']\n", + " if num_reports > 2:\n", + " if year_of_event == 2019:\n", + " grid_array[day_of_year-1, hour_of_day-1] = 1\n", + " elif year_of_event == 2020:\n", + " grid_array[365+day_of_year-1, hour_of_day-1] = 1\n", + " else:\n", + " raise Exception('Unknown year: ' + str(year_of_event))\n", + " \n", + " filtered_or_github_count += num_reports\n", + " all_or_github_count += num_reports\n", + "\n", + "or_github_grid_df = pd.DataFrame({\n", + " 'day_of_year': np.repeat(np.tile(np.arange(1, 365+1), 2), 24),\n", + " 'hour_of_day': np.tile(np.arange(1, 24+1), 365*2),\n", + " 'year': np.concatenate([np.repeat(2019, 365*24), np.repeat(2020, 365*24)]),\n", + " 'status': grid_array.flatten()\n", + "})\n", + "\n", + "unified_or_github_grid_df = or_github_grid_df[((or_github_grid_df['year'] == 2019) & (or_github_grid_df['day_of_year'] > 31+28+31+30))\n", + " | ((or_github_grid_df['year'] == 2020) & (or_github_grid_df['day_of_year'] < 365-31-30-31-30))].reset_index(drop=True)\n", + "\n", + "unified_or_github_grid_df['day_of_two_years'] = unified_or_github_grid_df['day_of_year']\n", + "unified_or_github_grid_df.loc[(unified_or_github_grid_df['year'] == 2020), 'day_of_two_years'] = unified_or_github_grid_df.loc[(unified_or_github_grid_df['year'] == 2020), 'day_of_two_years'] + 365\n", + "\n", + "# Reports used for github comparison\n", + "print(all_or_github_count)\n", + "print(filtered_or_github_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def make_grid(df):\n", + " status_to_number_map = {\n", + "# 'maintenance': 1,\n", + " 'minor': 1,\n", + " 'major': 2,\n", + " 'critical': 3,\n", + " }\n", + " \n", + " # First make and populate 2D grid array\n", + " grid_array = np.full((365*2, 24), 0)\n", + " for _, row in df.sort_values('start_time').iterrows():\n", + " year_of_event = row['start_time'].year\n", + " start_day_of_year = row['start_time'].timetuple().tm_yday\n", + " start_hour_of_day = row['start_time'].hour\n", + " end_day_of_year = row['end_time'].timetuple().tm_yday\n", + " end_hour_of_day = row['end_time'].hour\n", + " \n", + " offset = 0\n", + " if year_of_event == 2019:\n", + " offset = 0\n", + " elif year_of_event == 2020:\n", + " offset = 365\n", + " else:\n", + " raise Exception('Unknown year: ' + str(year_of_event))\n", + " \n", + " for day_of_year in range(start_day_of_year, end_day_of_year+1):\n", + " if start_day_of_year == end_day_of_year: # less than a day\n", + " for hour_of_day in range(start_hour_of_day, end_hour_of_day+1):\n", + " grid_array[offset+day_of_year-1, hour_of_day-1] = status_to_number_map[row['status']]\n", + " elif day_of_year == start_day_of_year: # first day\n", + " for hour_of_day in range(start_hour_of_day, 25):\n", + " grid_array[offset+day_of_year-1, hour_of_day-1] = status_to_number_map[row['status']]\n", + " elif day_of_year == end_day_of_year: # last day\n", + " for hour_of_day in range(0, end_hour_of_day):\n", + " grid_array[offset+day_of_year-1, hour_of_day-1] = status_to_number_map[row['status']]\n", + " else: # middle day\n", + " for hour_of_day in range(1, 25):\n", + " grid_array[offset+day_of_year-1, hour_of_day-1] = status_to_number_map[row['status']]\n", + " \n", + " return grid_array" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "github_grid_array = make_grid(filtered_github_incidents)\n", + "github_grid_df = pd.DataFrame({\n", + " 'day_of_year': np.repeat(np.tile(np.arange(1, 365+1), 2), 24),\n", + " 'hour_of_day': np.tile(np.arange(1, 24+1), 365*2),\n", + " 'year': np.concatenate([np.repeat(2019, 365*24), np.repeat(2020, 365*24)]),\n", + " 'status': pd.Categorical(github_grid_array.flatten(), [0,1,2,3], ordered=True)\n", + "})\n", + "\n", + "unified_github_grid_df = github_grid_df[((github_grid_df['year'] == 2019) & (github_grid_df['day_of_year'] > 31+28+31+30))\n", + " | ((github_grid_df['year'] == 2020) & (github_grid_df['day_of_year'] < 365-31-30-31-30))].reset_index(drop=True)\n", + "\n", + "unified_github_grid_df['day_of_two_years'] = unified_github_grid_df['day_of_year']\n", + "unified_github_grid_df.loc[(unified_github_grid_df['year'] == 2020), 'day_of_two_years'] = unified_github_grid_df.loc[(unified_github_grid_df['year'] == 2020), 'day_of_two_years'] + 365" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 25 x 2 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/github_failures_all.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(unified_github_grid_df) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " geom_tile(mapping=aes(x='day_of_two_years', y='hour_of_day', fill='status'), color='gainsboro', size=0.01) +\\\n", + " scale_fill_manual(values=['white', 'green', 'orange', 'red', 'black']) +\\\n", + " scale_x_continuous(limits=(first_day_of_month_for_two_years[4], first_day_of_month_for_two_years[-5]-1), expand=(0.005, 0.005),\n", + " breaks=first_day_of_month_for_two_years[4:-5]) +\\\n", + " scale_y_continuous(breaks=[0, 6, 12, 18, 24],\n", + " labels=['00:00', '06:00', '12:00', '18:00', '24:00']) +\\\n", + " theme(figure_size=(25, 2)) +\\\n", + " guides(fill=guide_legend(title='1 box=1 hour')) +\\\n", + " ylab('Hour of day') +\\\n", + " xlab('Day of year (First day of month is labeled)') +\\\n", + " theme(legend_box_spacing=0.01,\n", + " legend_box_margin=0,\n", + " legend_margin=0,\n", + " legend_key=element_blank(),\n", + " legend_entry_spacing=5,\n", + " legend_background=element_rect(fill=(0,0,0,0), color=(0,0,0,0)),\n", + " text=element_text(size=12))\n", + "\n", + "# scale_x_continuous(limits=(0, 365), expand=(0.005, 0.005),\n", + "# breaks=[31, 59, 90, 120, 151, 180, 211, 242, 272, 303, 333, 364],\n", + "# labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']) +\\\n", + "\n", + "plt.save('plots/github_failures_all.pdf', limitsize=False)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 25 x 2 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/or_github_failures.pdf\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/pandas/core/series.py:726: RuntimeWarning: divide by zero encountered in log\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/pandas/core/series.py:726: RuntimeWarning: divide by zero encountered in log\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(unified_or_github_grid_df) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " geom_tile(mapping=aes(x='day_of_two_years', y='hour_of_day', fill='status'), color='gainsboro', size=0.01) +\\\n", + " scale_fill_continuous('Greys', trans=\"log\") +\\\n", + " scale_x_continuous(limits=(first_day_of_month_for_two_years[4], first_day_of_month_for_two_years[-5]-1), expand=(0.005, 0.005),\n", + " breaks=first_day_of_month_for_two_years[4:-5]) +\\\n", + " scale_y_continuous(breaks=[0, 6, 12, 18, 24],\n", + " labels=['00:00', '06:00', '12:00', '18:00', '24:00']) +\\\n", + " theme(figure_size=(25, 2)) +\\\n", + " guides(fill=guide_legend(title='1 box=1 hour')) +\\\n", + " ylab('Hour of day') +\\\n", + " xlab('Day of year (First day of month is labeled)') +\\\n", + " theme(legend_box_spacing=0.01,\n", + " legend_box_margin=0,\n", + " legend_margin=0,\n", + " legend_key=element_blank(),\n", + " legend_entry_spacing=5,\n", + " legend_background=element_rect(fill=(0,0,0,0), color=(0,0,0,0)),\n", + " text=element_text(size=12))\n", + "\n", + "plt.save('plots/or_github_failures.pdf', limitsize=False)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "assert(unified_github_grid_df.shape[0] == unified_or_github_grid_df.shape[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def merge_dfs(github_df, github_or_df):\n", + " list_of_merged_rows = []\n", + " for i in range(github_df.shape[0]):\n", + " github_status = github_df.loc[i, 'status']\n", + " or_github_status = github_or_df.loc[i, 'status']\n", + "\n", + " final_status = github_status\n", + "\n", + " if or_github_status == 1:\n", + " if github_status == 0:\n", + " final_status = 4\n", + " elif github_status == 1:\n", + " final_status = 5\n", + " elif github_status == 2:\n", + " final_status = 6\n", + " else:\n", + " raise Exception('Unknown github status')\n", + "\n", + " list_of_merged_rows.append({\n", + " 'status': final_status,\n", + " 'hour_of_day': github_df.loc[i, 'hour_of_day'],\n", + " 'year': github_df.loc[i, 'year'],\n", + " 'day_of_year': github_df.loc[i, 'day_of_year'],\n", + " 'day_of_two_years': github_df.loc[i, 'day_of_two_years']\n", + " })\n", + "\n", + " merged_df = pd.DataFrame(list_of_merged_rows)\n", + " merged_df['status'] = pd.Categorical(merged_df['status'], [0,1,2,3,4,5,6], ordered=True)\n", + " return merged_df\n", + "\n", + "merged_df = merge_dfs(unified_github_grid_df, unified_or_github_grid_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 25 x 2 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/github_merged_failures.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(merged_df) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " geom_tile(mapping=aes(x='day_of_two_years', y='hour_of_day', fill='status'), color='white', size=0.02) +\\\n", + " scale_fill_manual(values=['white', 'gold', 'orange', 'black', 'teal', 'magenta', 'red'],\n", + " labels=['None', 'Official Minor', 'Official Major', 'Official Critical', 'Report without Overlap', 'Report overlaps Official Minor', 'Report overlaps Official Major']) +\\\n", + " scale_x_continuous(limits=(first_day_of_month_for_two_years[4], first_day_of_month_for_two_years[-5]-1), expand=(0.005, 0.005),\n", + " breaks=first_day_of_month_for_two_years[4:-5],\n", + " labels=['May\\n\\n2019', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'January\\n\\n2020', 'February', 'March', 'April', 'May', 'June', 'July', 'August']) +\\\n", + " scale_y_continuous(breaks=[0, 6, 12, 18, 24],\n", + " labels=['00:00', '06:00', '12:00', '18:00', '24:00']) +\\\n", + " theme(figure_size=(25, 2)) +\\\n", + " guides(fill=guide_legend(title='1 box=1 hour', nrow=1)) +\\\n", + " ylab('Hour of day') +\\\n", + " xlab('Day of year (First day of month is labeled)') +\\\n", + " theme(legend_box_spacing=0.01,\n", + " legend_box_margin=0,\n", + " legend_margin=0,\n", + " legend_key=element_blank(),\n", + " legend_entry_spacing=5,\n", + " legend_background=element_rect(fill=(0,0,0,0), color=(0,0,0,0)),\n", + " legend_position='top',\n", + " text=element_text(size=12))\n", + "\n", + "plt.save('plots/github_merged_failures.pdf', limitsize=False)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 16 x 3 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/double_github_merged_failures.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(merged_df) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " geom_tile(mapping=aes(x='day_of_year', y='hour_of_day', fill='status'), color='white', size=0.02) +\\\n", + " scale_fill_manual(values=['white', 'silver', 'orange', 'black', 'teal', 'magenta', 'red'],\n", + " labels=['None', 'Official Minor', 'Official Major', 'Official Critical', 'Report without Overlap', 'Report overlaps Official Minor', 'Report overlaps Official Major']) +\\\n", + " scale_x_continuous(limits=(first_day_of_month[0], first_day_of_month[-1]), expand=(0.005, 0.005),\n", + " breaks=first_day_of_month[:-1],\n", + " labels=['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']) +\\\n", + " scale_y_continuous(breaks=[0, 6, 12, 18, 24],\n", + " labels=['00:00', '06:00', '12:00', '18:00', '24:00']) +\\\n", + " theme(figure_size=(16, 3)) +\\\n", + " guides(fill=guide_legend(title='1 box=1 hour', nrow=1)) +\\\n", + " facet_wrap(facets='year', nrow=2) +\\\n", + " ylab('Hour of day') +\\\n", + " xlab('Day of year (First day of month is labeled)') +\\\n", + " theme(legend_box_spacing=0.01,\n", + " legend_box_margin=0,\n", + " legend_margin=0,\n", + " legend_key=element_blank(),\n", + " legend_entry_spacing=5,\n", + " legend_background=element_rect(fill=(0,0,0,0), color=(0,0,0,0)),\n", + " legend_position='top',\n", + " text=element_text(size=12))\n", + "\n", + "plt.save('plots/double_github_merged_failures.pdf', limitsize=False)\n", + "plt" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/datasets/Talluri2021/2.basic_stats_reports.ipynb b/datasets/Talluri2021/2.basic_stats_reports.ipynb new file mode 100644 index 0000000..d33a3cc --- /dev/null +++ b/datasets/Talluri2021/2.basic_stats_reports.ipynb @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from plotnine import *\n", + "from datetime import datetime\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "or_events = pd.read_parquet('./outage_report_2019-20')\n", + "or_reports = pd.read_parquet('./outage_report_individual_reports_2019-20')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_events = or_events[(or_events['vendor'] != '') & (or_events['vendor'] != 'overview')].copy()\n", + "filtered_or_events = filtered_or_events.drop_duplicates(subset=['vendor', 'event_time', 'status_code'])\n", + "# Combine events with the same event_time, but different status_code with max\n", + "filtered_or_events = filtered_or_events.groupby(['vendor', 'event_time'])['status_code'].max().reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_reports = or_reports[(or_reports['reason'] != '') & (or_reports['vendor'] != 'overview')].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "thresholded_or_events = filtered_or_events[filtered_or_events['status_code'] > 2].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def proper_vendor_names(series):\n", + " return series.str.capitalize().replace(['Apple-servers', 'Facebook-messenger', 'Youtube'], ['Apple', 'FB Msgr', 'YouTube'])\n", + "\n", + "filtered_or_reports['vendor_proper'] = proper_vendor_names(filtered_or_reports['vendor'])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def proper_vendor_names(series):\n", + " return series.str.capitalize().replace(['Apple-servers', 'Facebook-messenger', 'Youtube'], ['Apple', 'FB Msgr', 'YouTube'])\n", + "\n", + "filtered_or_events['vendor_proper'] = proper_vendor_names(filtered_or_events['vendor'])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Apple',\n", + " 'Github',\n", + " 'Skype',\n", + " 'FB Msgr',\n", + " 'Gmail',\n", + " 'Whatsapp',\n", + " 'Snapchat',\n", + " 'Netflix',\n", + " 'Facebook',\n", + " 'Twitter',\n", + " 'YouTube',\n", + " 'Instagram']" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vendor_list = list(filtered_or_events.groupby('vendor_proper')['status_code'].sum().reset_index().rename(columns={'status_code':'count'}).sort_values('count')['vendor_proper'])\n", + "vendor_list" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\begin{tabular}{lrrr}\n", + "\\toprule\n", + "vendor\\_proper & count\\_events & count\\_reports & prop \\\\\n", + "\\midrule\n", + " Apple & 3208 & 2566 & 79.99 \\\\\n", + " Github & 4432 & 1062 & 23.96 \\\\\n", + " Skype & 4799 & 2029 & 42.28 \\\\\n", + " FB Msgr & 13788 & 6836 & 49.58 \\\\\n", + " Gmail & 16471 & 9427 & 57.23 \\\\\n", + " Whatsapp & 34653 & 9426 & 27.20 \\\\\n", + " Snapchat & 68863 & 8118 & 11.79 \\\\\n", + " Netflix & 74631 & 20211 & 27.08 \\\\\n", + " Facebook & 79880 & 25886 & 32.41 \\\\\n", + " Twitter & 136672 & 20252 & 14.82 \\\\\n", + " YouTube & 152169 & 26783 & 17.60 \\\\\n", + " Instagram & 193687 & 41574 & 21.46 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n" + ] + } + ], + "source": [ + "event_count_df = filtered_or_events.groupby('vendor_proper')['status_code'].sum().reset_index().rename(columns={'status_code':'count'})\n", + "report_count_df = filtered_or_reports.groupby('vendor_proper')['country'].count().reset_index().rename(columns={'country':'count'}).set_index('vendor_proper')\n", + "\n", + "joined_count_df = event_count_df.join(report_count_df, on='vendor_proper', lsuffix='_events', rsuffix='_reports')\n", + "joined_count_df['prop'] = (joined_count_df['count_reports'] / joined_count_df['count_events']) * 100\n", + "joined_count_df['count_events'] = joined_count_df['count_events'].astype(int)\n", + "\n", + "print(joined_count_df.sort_values('count_events').to_latex(index=None, float_format=\"%.2f\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "783253\n", + "174170\n", + "0.22236748534636958\n" + ] + } + ], + "source": [ + "#\n", + "print(joined_count_df['count_events'].sum())\n", + "print(joined_count_df['count_reports'].sum())\n", + "print(joined_count_df['count_reports'].sum() / joined_count_df['count_events'].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":3: FutureWarning: Series.dt.weekofyear and Series.dt.week have been deprecated. Please use Series.dt.isocalendar().week instead.\n" + ] + } + ], + "source": [ + "filtered_or_events['evtime'] = pd.to_datetime(filtered_or_events['event_time'], unit='s')\n", + "filtered_or_events['hour_of_week'] = filtered_or_events['evtime'].dt.dayofweek * 24 + (filtered_or_events['evtime'].dt.hour + 1)\n", + "filtered_or_events['week_of_year'] = filtered_or_events['evtime'].dt.weekofyear" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2019-04-14 11:20:00\n", + "2020-10-31 23:00:00\n" + ] + } + ], + "source": [ + "# First and last dates in the dataset\n", + "print(filtered_or_events['evtime'].min())\n", + "print(filtered_or_events['evtime'].max())" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hour_of_weeksumpropvendor_proper
0119.00.142857Apple
1240.00.300752Apple
2381.00.609023Apple
34124.00.932331Apple
4522.00.165414Apple
...............
1631642431.00.413717YouTube
1641651151.00.195882YouTube
165166450.00.076583YouTube
166167398.00.067733YouTube
167168398.00.067733YouTube
\n", + "

2016 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " hour_of_week sum prop vendor_proper\n", + "0 1 19.0 0.142857 Apple\n", + "1 2 40.0 0.300752 Apple\n", + "2 3 81.0 0.609023 Apple\n", + "3 4 124.0 0.932331 Apple\n", + "4 5 22.0 0.165414 Apple\n", + ".. ... ... ... ...\n", + "163 164 2431.0 0.413717 YouTube\n", + "164 165 1151.0 0.195882 YouTube\n", + "165 166 450.0 0.076583 YouTube\n", + "166 167 398.0 0.067733 YouTube\n", + "167 168 398.0 0.067733 YouTube\n", + "\n", + "[2016 rows x 4 columns]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_df_list = []\n", + "for vendor in filtered_or_events['vendor_proper'].unique():\n", + " vendor_df = filtered_or_events[filtered_or_events['vendor_proper'] == vendor].copy()\n", + " partial_grouped_df = vendor_df.groupby('hour_of_week')['status_code'].sum().reset_index().rename(columns={'status_code': 'sum'})\n", + " partial_grouped_df['prop'] = partial_grouped_df['sum'] / partial_grouped_df['sum'].max()\n", + " partial_grouped_df['vendor_proper'] = vendor\n", + " grouped_df_list.append(partial_grouped_df)\n", + "grouped_df = pd.concat(grouped_df_list)\n", + "grouped_df" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 14 x 3 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/or_hour_of_week.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_df['vendor_cat'] = pd.Categorical(grouped_df['vendor_proper'], categories=vendor_list, ordered=True)\n", + "\n", + "vendor_maxes = grouped_df.groupby('vendor_proper')['sum'].max()\n", + "\n", + "def label_func(vendor):\n", + " if vendor == 'Apple':\n", + " return vendor + ' (max={:,})'.format(int(vendor_maxes.loc[vendor]))\n", + " else:\n", + " return vendor + ' ({:,})'.format(int(vendor_maxes.loc[vendor]))\n", + "\n", + "plt = ggplot(grouped_df) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " theme(figure_size=(14, 3),\n", + " axis_text_y=element_text(margin={'r': 5}),\n", + " panel_grid_minor_x=element_line(size=0.7, color=\"gainsboro\"),\n", + " panel_grid_major_x=element_blank(),\n", + " text=element_text(size=12)) +\\\n", + " geom_step(aes(x=\"hour_of_week\", y=\"prop\")) +\\\n", + " facet_wrap(facets='vendor_cat', nrow=2, labeller=label_func) +\\\n", + " scale_x_continuous(breaks = [12, 36, 60, 84, 108, 132, 156],\n", + " labels = [\"Mo\", \"Tu\", \"We\", \"Th\", \"Fr\", \"Sa\", \"Su\"]) +\\\n", + " xlab(\"Day of Week\") +\\\n", + " ylab(\"Max. Norm. Failures/Hour\")\n", + "\n", + "plt.save('plots/or_hour_of_week.pdf')\n", + "plt" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} 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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrycount
0CA1828
1GB1327
2Other15938
3RU3272
4UA3486
5US15723
\n", + "
" + ], + "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": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrycountcountry_propercountry_cat
0CA10265CanadaCanada
1GB12451UKUK
2IN4478IndiaIndia
3Other61927OtherOther
4RU4200RussiaRussia
5US80849USAUSA
\n", + "
" + ], + "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": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
reasoncountreason_cat
0Can't login3654Can't login
1Can't upload pics4548Can't upload pics
2Everything is down2613Everything is down
3Hashtags not working408Hashtags not working
4Message read problems1127Message read problems
5Message send problems994Message send problems
6Mobile app crashes3929Mobile app crashes
7Mobile app not working15533Mobile app not working
8Newsfeed4161Newsfeed
9Unknown1708Unknown
10Website down2899Website down
\n", + "
" + ], + "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": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
reasonmean_pdfreason_cat
0Mobile app not working0.174832Mobile app not working
1Website down0.173807Website down
2Unknown0.130210Unknown
3Everything is down0.127983Everything is down
4Can't login0.082374Can't login
5Message send problems0.075580Message send problems
6Message read problems0.033245Message read problems
7Mobile app crashes0.031515Mobile app crashes
8Stream not working0.029427Stream not working
9Videos won't play0.023544Videos won't play
\n", + "
" + ], + "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": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
vendorcount
3github1062
7skype2029
0apple-servers2566
2facebook-messenger6836
8snapchat8118
10whatsapp9426
4gmail9427
6netflix20211
9twitter20252
1facebook25886
11youtube26783
5instagram41574
\n", + "
" + ], + "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 +} diff --git a/datasets/Talluri2021/4.response time experiment.ipynb b/datasets/Talluri2021/4.response time experiment.ipynb new file mode 100644 index 0000000..3c63e3b --- /dev/null +++ b/datasets/Talluri2021/4.response time experiment.ipynb @@ -0,0 +1,543 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import random\n", + "import gc\n", + "import time\n", + "import pandas as pd\n", + "from plotnine import *\n", + "from numpy.random import weibull" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "31536000\n", + "15768000.0\n", + "{0: 14995272.0, 1: 749658.0, 2: 22542.0, 3: 508.0, 4: 9.0} 10.926686001093943\n" + ] + } + ], + "source": [ + "def runsim(num_reqs, failure_prob_thresh, num_trials=1):\n", + " max_retries = 3\n", + " successful_requests = np.full((num_reqs, num_trials), False)\n", + " current_retries = np.full((num_reqs, num_trials), 0, dtype=np.uint8)\n", + " all_retries = np.full((num_reqs, num_trials), 0, dtype=np.uint8)\n", + " \n", + " # run till all requests succeed or max retries at all levels are exhausted\n", + " while (not np.all(successful_requests)) and np.all(current_retries < max_retries+1):\n", + " random_nums = np.random.random_sample(size=(num_reqs, num_trials))\n", + " successful_this_round = random_nums >= np.repeat(np.transpose([failure_prob_thresh]), num_trials, axis=1)\n", + "# print(successful_this_round)\n", + " \n", + " valid_requests_this_round = ~successful_requests & (current_retries < max_retries+1)\n", + " \n", + " \n", + " success_intermediate = (valid_requests_this_round & successful_this_round) | successful_requests\n", + " (failure_rows, failure_columns) = np.nonzero(~success_intermediate)\n", + " \n", + " # So, if requests fail at level 2 and 3. Only the failure at 2 is counted\n", + " # We can do this because failure_columns is SORTED in column order\n", + " # take care: unique rows does not contain all rows. There are many rows without any failures\n", + " (unique_rows, unique_indices) = np.unique(failure_rows, return_index=True)\n", + " unique_rows_first_column = failure_columns[unique_indices]\n", + " \n", + " # Update retries\n", + " current_retries[unique_rows, unique_rows_first_column] += 1\n", + " all_retries[unique_rows, unique_rows_first_column] += 1\n", + " \n", + " repeated_unique_rows_first_column = np.repeat(np.transpose([unique_rows_first_column]), num_trials, axis=1)\n", + " (row_indices, column_indices) = np.indices((num_reqs, num_trials))\n", + " mask = np.full((num_reqs, num_trials), np.iinfo(np.int32).max, dtype=np.int32)\n", + " mask[unique_rows] = repeated_unique_rows_first_column\n", + "# print(mask)\n", + " \n", + " successful_requests = column_indices < mask\n", + "\n", + " # Rollback to previous level if max retries for this level has been reached\n", + " rollback_mask = current_retries == max_retries\n", + " (exhausted_retries_rows, exhausted_retries_columns) = np.nonzero(rollback_mask)\n", + " exhausted_retries_prev_columns = exhausted_retries_columns - 1\n", + "# print(exhausted_retries_prev_columns)\n", + " valid_prev_col = exhausted_retries_prev_columns >= 0\n", + "# print(valid_prev_col)\n", + " can_be_retried_again_rows = exhausted_retries_rows[valid_prev_col]\n", + " can_be_retried_again_columns = exhausted_retries_columns[valid_prev_col]\n", + " \n", + " exhausted_retries_prev_columns[~valid_prev_col] = 0\n", + " successful_requests[exhausted_retries_rows, exhausted_retries_prev_columns] = False\n", + " current_retries[can_be_retried_again_rows, can_be_retried_again_columns] = 0\n", + " \n", + " # https://lup.lub.lu.se/search/ws/files/5764781/4814056.pdf\n", + " # Magnitude of sin from above paper\n", + " sin_input = np.linspace(-np.pi, np.pi, 24*60*60)\n", + " sin_scaler = np.tile((np.sin(sin_input) + 1) / 2, 365) # Sin min magnitude 0, max 1, for 365 days\n", + " \n", + " results = {}\n", + " overall_successful_requests = np.all(successful_requests, axis=1)\n", + " retries_per_request = np.sum(all_retries, axis=1)\n", + " consolidated_retries = retries_per_request[overall_successful_requests]\n", + " filtered_sin_scaler = sin_scaler[overall_successful_requests]\n", + "# print(consolidated_retries.shape)\n", + "# print(filtered_sin_scaler.shape)\n", + "# return (True, True)\n", + " unique_retries = np.unique(consolidated_retries)\n", + " for entry in unique_retries:\n", + " results[entry] = np.round(np.sum(filtered_sin_scaler[consolidated_retries == entry]))\n", + "# print(np.transpose(successful_requests))\n", + " scaled_unsuccessful_requests = ~overall_successful_requests * sin_scaler\n", + " return (results, np.sum(scaled_unsuccessful_requests))\n", + "\n", + "sin_input = np.linspace(-np.pi, np.pi, 24*60*60)\n", + "per_day_sin_scaler = (np.sin(sin_input) + 1) / 2\n", + "num_reqs = 365*24*60*60\n", + "scaled_num_reqs = np.sum(per_day_sin_scaler) * 365\n", + "print(num_reqs)\n", + "print(np.round(scaled_num_reqs))\n", + "# 20min is outage report granularity\n", + "num_20min_chunks = num_reqs // (20*60)\n", + "failure_probabilities = np.repeat(0.01, num_20min_chunks)\n", + "failure_prob_thresh = np.repeat(failure_probabilities, 20*60)\n", + "\n", + "(results, failed_reqs) = runsim(num_reqs, np.transpose(failure_prob_thresh), num_trials=5)\n", + "# (results, failed_reqs) = runsim(10, np.repeat(0.5, 10), num_trials=5)\n", + "print(results, failed_reqs)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{0: 28523119} 3012881\n" + ] + } + ], + "source": [ + "def runsim_fanout(num_reqs, failure_prob_thresh, fanout=1):\n", + " max_retries = 3\n", + " successful_requests = np.full((num_reqs, fanout), False)\n", + " current_retries = np.full((num_reqs, fanout), 0, dtype=np.uint8)\n", + " \n", + " # run till all requests succeed or max retries at all levels are exhausted\n", + " while (not np.all(successful_requests)) and np.all(current_retries < max_retries+1):\n", + " random_nums = np.random.random_sample(size=(num_reqs, fanout))\n", + " successful_this_round = random_nums >= np.repeat(np.transpose([failure_prob_thresh]), fanout, axis=1)\n", + " \n", + " valid_requests_this_round = ~successful_requests & (current_retries < max_retries+1)\n", + " successful_valid = valid_requests_this_round & successful_this_round\n", + " \n", + " # Update retries\n", + " current_retries[~successful_valid] += 1\n", + " \n", + " successful_requests = successful_requests | successful_valid\n", + " break\n", + " \n", + " results = {}\n", + " overall_successful_requests = np.all(successful_requests, axis=1)\n", + " consolidated_retries = np.sum(current_retries, axis=1)[overall_successful_requests]\n", + " unique_retries = np.unique(consolidated_retries)\n", + " for entry in unique_retries:\n", + " results[entry] = np.sum(consolidated_retries == entry)\n", + " return (results, np.sum(~overall_successful_requests))\n", + "\n", + "\n", + "num_reqs = 365*24*60*60\n", + "# 20min is outage report granularity\n", + "num_20min_chunks = num_reqs // (20*60)\n", + "failure_probabilities = np.repeat(0.01, num_20min_chunks)\n", + "failure_prob_thresh = np.repeat(failure_probabilities, 20*60)\n", + "\n", + "(results, failed_reqs) = runsim_fanout(num_reqs, np.transpose(failure_prob_thresh), fanout=10)\n", + "# (results, failed_reqs) = runsim_fanout(10, np.repeat(0.01, 10), fanout=10)\n", + "print(results, failed_reqs)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "num_reqs = 365*24*60*60\n", + "# 20min is outage report granularity\n", + "num_20min_chunks = num_reqs // (20*60)\n", + "num_iterations = 1\n", + "results = []" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "for iteration in range(num_iterations):\n", + " num_20min_chunks = num_reqs // (20*60)\n", + " failure_probabilities = np.repeat(0.01, num_20min_chunks)\n", + " failure_prob_thresh = np.repeat(failure_probabilities, 20*60)\n", + " \n", + "# (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh)\n", + "# results.append(pd.DataFrame({\n", + "# 'vendor': 'uniform',\n", + "# 'reqs': list(final_counts.values()) + [failed_reqs],\n", + "# 'retries': list(final_counts.keys()) + [100],\n", + "# 'iteration': iteration,\n", + "# 'experiment': 'monolith'\n", + "# }))\n", + " \n", + " (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh, num_trials=5)\n", + " results.append(pd.DataFrame({\n", + " 'vendor': 'uniform',\n", + " 'reqs': list(final_counts.values()) + [failed_reqs],\n", + " 'retries': list(final_counts.keys()) + [100],\n", + " 'iteration': iteration,\n", + " 'experiment': 'deep chain'\n", + " }))\n", + " \n", + "# (final_counts, failed_reqs) = runsim_fanout(num_reqs, failure_prob_thresh, fanout=10)\n", + "# results.append(pd.DataFrame({\n", + "# 'vendor': 'uniform',\n", + "# 'reqs': list(final_counts.values()) + [failed_reqs],\n", + "# 'retries': list(final_counts.keys()) + [100],\n", + "# 'iteration': iteration,\n", + "# 'experiment': 'fanout'\n", + "# }))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ vendor reqs retries iteration experiment\n", + " 0 uniform 28382785 0 0 monolith\n", + " 1 uniform 2837362 1 0 monolith\n", + " 2 uniform 284158 2 0 monolith\n", + " 3 uniform 28516 3 0 monolith\n", + " 4 uniform 3179 100 0 monolith,\n", + " vendor reqs retries iteration experiment\n", + " 0 uniform 28387324 0 0 monolith\n", + " 1 uniform 2834446 1 0 monolith\n", + " 2 uniform 282792 2 0 monolith\n", + " 3 uniform 28385 3 0 monolith\n", + " 4 uniform 3053 100 0 monolith,\n", + " vendor reqs retries iteration experiment\n", + " 0 uniform 18618827 0 0 deep chain\n", + " 1 uniform 9311619 1 0 deep chain\n", + " 2 uniform 2795059 2 0 deep chain\n", + " 3 uniform 652424 3 0 deep chain\n", + " 4 uniform 158071 100 0 deep chain,\n", + " vendor reqs retries iteration experiment\n", + " 0 uniform 10993887 0 0 fanout\n", + " 1 uniform 20542113 100 0 fanout]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "or_events = pd.read_parquet('./outage_report_2019-20').reset_index(drop=True)\n", + "filtered_or_events = or_events[(or_events['vendor'] != '') & (or_events['vendor'] != 'overview')].copy()\n", + "filtered_or_events = filtered_or_events.drop_duplicates(subset=['vendor', 'event_time', 'status_code'])\n", + "# Combine events with the same event_time, but different status_code with max\n", + "filtered_or_events = filtered_or_events.groupby(['vendor', 'event_time'])['status_code'].max().reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "sin_input = np.linspace(-np.pi, np.pi, 24*3)\n", + "sin_scaler = np.tile((np.sin(sin_input) + 1) / 2, 365) # Sin min magnitude 0, max 1, for 265 days\n", + "for iteration in range(num_iterations):\n", + " vendor = 'instagram'\n", + " vendor_df = filtered_or_events[filtered_or_events['vendor'] == vendor].sort_values('event_time').reset_index(drop=True).loc[:num_20min_chunks-1]\n", + " scaled_reports = sin_scaler * vendor_df['status_code']\n", + " failure_fraction = scaled_reports / scaled_reports.max()\n", + " failure_prob_thresh = np.repeat(failure_fraction, 20*60)\n", + " \n", + "# (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh)\n", + "# results.append(pd.DataFrame({\n", + "# 'vendor': vendor,\n", + "# 'reqs': list(final_counts.values()) + [failed_reqs],\n", + "# 'retries': list(final_counts.keys()) + [100],\n", + "# 'iteration': iteration,\n", + "# 'experiment': 'monolith'\n", + "# }))\n", + " \n", + " (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh, num_trials=5)\n", + " results.append(pd.DataFrame({\n", + " 'vendor': vendor,\n", + " 'reqs': list(final_counts.values()) + [failed_reqs],\n", + " 'retries': list(final_counts.keys()) + [100],\n", + " 'iteration': iteration,\n", + " 'experiment': 'deep chain'\n", + " }))\n", + " \n", + "# (final_counts, failed_reqs) = runsim_fanout(num_reqs, failure_prob_thresh, fanout=10)\n", + "# results.append(pd.DataFrame({\n", + "# 'vendor': vendor,\n", + "# 'reqs': list(final_counts.values()) + [failed_reqs],\n", + "# 'retries': list(final_counts.keys()) + [100],\n", + "# 'iteration': iteration,\n", + "# 'experiment': 'fanout'\n", + "# }))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "structures_experiment_results = pd.concat(results)\n", + "structures_experiment_results.to_csv('./experiment_results/long_chain_results_sin1.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "only_const_results = []\n", + "# for iteration in range(num_iterations):\n", + "iteration = 1\n", + "for prob in [0.01, 0.1, 0.25, 0.5, 0.75]:\n", + " num_20min_chunks = num_reqs // (20*60)\n", + " failure_probabilities = np.repeat(prob, num_20min_chunks)\n", + " failure_prob_thresh = np.repeat(failure_probabilities, 20*60)\n", + "\n", + " (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh)\n", + " only_const_results.append(pd.DataFrame({\n", + " 'vendor': 'uniform',\n", + " 'prob': prob,\n", + " 'reqs': list(final_counts.values()) + [failed_reqs],\n", + " 'retries': list(final_counts.keys()) + [100],\n", + " 'iteration': iteration,\n", + " 'experiment': 'monolith'\n", + " }))\n", + "\n", + " (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh, num_trials=5)\n", + " only_const_results.append(pd.DataFrame({\n", + " 'vendor': 'uniform',\n", + " 'prob': prob,\n", + " 'reqs': list(final_counts.values()) + [failed_reqs],\n", + " 'retries': list(final_counts.keys()) + [100],\n", + " 'iteration': iteration,\n", + " 'experiment': 'deep chain'\n", + " }))\n", + "\n", + " (final_counts, failed_reqs) = runsim_fanout(num_reqs, failure_prob_thresh, fanout=10)\n", + " only_const_results.append(pd.DataFrame({\n", + " 'vendor': 'uniform',\n", + " 'prob': prob,\n", + " 'reqs': list(final_counts.values()) + [failed_reqs],\n", + " 'retries': list(final_counts.keys()) + [100],\n", + " 'iteration': iteration,\n", + " 'experiment': 'fanout'\n", + " }))\n", + " \n", + "const_results_df = pd.concat(only_const_results)\n", + "const_results_df.to_csv('./experiment_results/const_experiment_results_1.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# highest failures for instagram are on 13th june 2019. Confirmed that an instagram outage occurred on that date\n", + "vendor_results = []\n", + "vendors = filtered_or_events['vendor'].unique()\n", + "for vendor in vendors:\n", + " vendor_df = filtered_or_events[filtered_or_events['vendor'] == vendor].sort_values('event_time').reset_index(drop=True).loc[:num_20min_chunks-1]\n", + " vendor_df['failure_fraction'] = vendor_df['status_code'] / vendor_df['status_code'].max()\n", + " for iteration in range(1):\n", + " (final_counts, failed_reqs) = runsim(num_reqs, np.repeat(vendor_df['failure_fraction'].values, 20*60))\n", + " vendor_results.append(pd.DataFrame({\n", + " 'vendor': vendor,\n", + " 'reqs': list(final_counts.values()) + [failed_reqs],\n", + " 'retries': list(final_counts.keys()) + [100],\n", + " 'iteration': iteration\n", + " }))\n", + "vendors" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [], + "source": [ + "vendor_results_df = pd.concat(vendor_results).reset_index(drop=True)\n", + "vendor_results_df = vendor_results_df[(vendor_results_df['iteration'] == 0) & (vendor_results_df['retries'] != 0)]" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [], + "source": [ + "vendor_results_df['fraction'] = vendor_results_df['reqs'] / num_reqs\n", + "vendor_results_df['color'] = 'trace'\n", + "vendor_results_df.loc[vendor_results_df['vendor'] == 'uniform', 'color'] = 'uniform'" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:719: PlotnineWarning: Saving 6.4 x 4.8 in image.\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:722: PlotnineWarning: Filename: traces_vs_uniform-uniform_workload.png\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqEAAAGvCAYAAABrQAyzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAA9hAAAPYQGoP6dpAABz+ElEQVR4nO3deZgkVZkv/u+JyD0ra68uuqHpRlo2F0YYobuBsUXBBUFFhisIorjwOIwKd2wFwUv3KIuoXJFFcFxwGUUUV3QUZ1DRthXFH15xWKfpZqvurr0qs3KNOL8/IjIyIjOyKrMyI5eo7+d5qiszMisrqk5n1pvvOe97hJRSgoiIiIiohZR2nwARERERrTwMQomIiIio5RiEEhEREVHLMQglIiIiopZjEEpERERELccglIiIiIhajkEoEREREbUcg1AiIiIiarlAu0+gE0xMTDT8GEIIRKNRpNNp+Ln/fygUQi6Xa/dpeIbj6A8cR3/gOPqDl+M4PDzc1Mej1mImtEkURUEsFoOi+PtXGg6H230KnuI4+gPH0R84jv6wUsaR6sf/EURERETUcgxCiYiIiKjlGIQSERERUcsxCCUiIiKilmMQSkREREQtxyCUiIiIiFqOQSgRERERtRyDUCIiIiJqOQahRERERNRyDEKJiIiIqOUYhBIRERFRyzEIJSIiIqKWYxBKRERERC3HIJSIiIiIWo5BqMekrkPqertPg4iIiKijBNp9An6lPf8s5j97PaDriL/nYgQPP7Ldp0RERETUMZgJ9YqiAsUMqFZo77kQERERdRgGoV5RVeui1DgdT0RERGTHINQjQrWtdGAmlIiIiMih7WtC77nnHtx3333YvXs3Nm3ahK1bty7rcZ577jnccccdePTRR1EoFLB+/XpceOGFeOELX9jkM65RoJQJhaa15xyIiIiIOlTbM6GDg4M4++yzceqppzb0OKlUCsceeyxuueUWfOMb38AJJ5yA7du3I5PJNOlM62Sfji8wE0pERERk1/ZM6ObNmwEAu3btwvz8vOO2J554Al/60pewZ88eDAwM4LzzzrPuX+6www7DYYcdZl1/wxvegDvuuAPPPvssNmzY4N0PUIVzOp6ZUCIiIiK7tgeh1UxNTWHbtm14//vfj5e//OV48sknsX37dqxduxZr165d8uufeOIJSCmxevXqFpytC8d0PDOhRERERHYdG4T+8pe/xNFHH42NGzcCAA4//HBs3LgRO3bswFvf+tZFv3Zubg433HADzj33XMTj8Yrbx8bGMDY2Zl0Ph8NYs2ZNQ+ermtPvxc9SCOs2oevW8W4nhPDNz+KmfBz9iuPoDxxHf+A40krVsUHo/v378Yc//AHnnHOOdUzTNGzZsgXj4+O4+OKLreO33HILRkZGABhrQ7dt24ZjjjkGb3nLW1wf+/bbb8f27dut6x/96Edx9dVXN+W8e3t7rctTigLoOiLBEAYGBpry+J0gFAq1+xQ8Zx9Hv+I4+gPH0R84jrQSdWwQOjIygpNOOgmXXHKJ6+133XVXxbFUKoWrrroKGzZswHve856qj33RRRfhjDPOsK6Hw2FMT083dL6qqqK3txdzc3PQimtAVaNhfTo53/Djd4p4PI5UKtXu0/CM6zj6EMfRHziO/sBxXD4/JXhWorYHoZqmQdM06LoOXdeRy+WgKAq2bNmCSy+9FA888ACOPfZY6LqOXbt2IRaLua4JXVhYwLZt27B27Vq8733vW/R7rl692rFWdGJiomlPjOLPAwBQA0A+D72Q980LqJTSNz/LYhzj6EMcR3/gOPoDx5FWqrYHod/+9rdx5513Wtd37NiBk08+GZdccgmuuuoq3HHHHbjxxhsBAOvXr8e73vUu18fZuXMnHnvsMezevRs7duywjl911VV40Yte5O0PUYVQVUiA1fFEREREZdoehJ577rk499xzXW/bsGEDPvGJT9T0OK961avwqle9qpmn1riA8euVDEKJiIiIHNrerN7PRLESkM3qiYiIiBzangntBKFQCOFwuKHHEGZLpng8DiklACAZDEEHEFQUJBKJRk+zIwQCAd/8LG7cxtGPOI7+wHH0B44jrVQMQgHkcjnkcrmGHkNVVYRCIaRSKWvhta4YT7xcJlOxG1S3SiQSvvlZ3LiNox9xHP2B4+gPHMflazSBRO3F6XgPcTqeiIiIyB2DUC8Vd0/y8Tt4IiIiouVgEOol1VztwL3jiYiIiBwYhHrImo5nJpSIiIjIgYVJ8K46PhOOoABAldI3lY+s4vQHjqM/cBz9geNIKxWDUHhXHa8Z+yWhkMv5pvKRVZz+wHH0B46jP3Acl4/V8d2N0/FestaE+vfFk4iIiGg5GIR6yaqOZ2ESERERkR2DUA+JADOhRERERG4YhHrJalbPIJSIiIjIjkGol8w1oZyOJyIiInJiEOoh9gklIiIicscWTfCuT6gWjSILAJrmmx5w7GfnDxxHf+A4+gPHkVYqBqHwrk9ozvwsCwXf9IBjPzt/4Dj6A8fRHziOy8c+od2N0/EeKlXHc00oERERkR2DUC8V14RKCanr7T0XIiIiog7CINRDQrWtdmA2lIiIiMjCINRLxUwowAp5IiIiIhsGoV4KlDKhkkEoERERkYVBqIeEPRNa4HQ8ERERURFbNMG7PqELPT1YMG+PRyII+KAPHPvZ+QPH0R84jv7AcaSVikEoPOwTms9btyfnZqGGIw19j07Afnb+wHH0B46jP3Acl499Qrsbp+M9JBT7dLx/X0CJiIiI6sUg1EuBUhDKwiQiIiKiEgahHmKfUCIiIiJ3DEK9pHI6noiIiMgNg1AvOfqEMhNKREREVMQg1EOCOyYRERERuWIQ6iXHmlAGoURERERFDEK9pNqr4zkdT0RERFTEINRDIsBMKBEREZEb7pgE77bt1CAxZ94eDgTQ44Nt2bi9nD9wHP2B4+gPHEdaqRiEwrttO2U6Y92eSaUgfbAtG7eX8weOoz9wHP2B47h83Lazu3E63kuO6niuCSUiIiIqYhDqJXthEpvVExEREVkYhHpJUQBzLQwzoUREREQlDEI9JIQoZUN9vJ6JiIiIqF4MQr1mNqxnn1AiIiKiEgahHrO27tT09p4IERERUQdhEOq1gBGEMhNKREREVMIg1GvF/eNZHU9ERERkYRDqsdJ0PDOhREREREUMQr1mFSYxE0pERERUxG074d3e8QCQCgWhAwgI4Yu9gbnHsT9wHP2B4+gPHEdaqRiEwru94wFAh/HkK2QyvtgbmHsc+wPH0R84jv7AcVw+7h3f3Tgd77UA+4QSERERlWMQ6jHBHZOIiIiIKjAI9VqxMKnATCgRERFREYNQr5nN6qFzxyQiIiKiIgahHhNWs3pmQomIiIiKGIR6TS1u28k1oURERERFDEI9xh2TiIiIiCoxCPWa2aKJ1fFEREREJQxCvaaY0/FcE0pERERkYRDqMRFgn1AiIiKicgxCvVasjueaUCIiIiILg1CvFavjC8yEEhERERUxCPWYCDATSkRERFQu0O4T8Cs9vYDC449C2ztmHtAhpYQQor0nRkRERNQBGIQCCIVCCIfDDT1GMbiMx+OQUiI3M419X/+y4z6JWKyUGe1SgUAAiUSi3afhmfJx9CuOoz9wHP2B40grVXdHRE2Sy+WQy+UaegxVVREKhZBKpaBpGrRMpuI+8zMzEA0Gu+2WSCQwPz/f7tPwTPk4+hXH0R84jv7AcVy+RhNI1F5cE+qV4k5JNpLrQomIiIgAMAj1jFBdksyskCciIiICwCDUO6rLr5aZUCIiIiIADEK941KAJH28pomIiIioHgxCPSKUyjWh4P7xRERERAAYhHon4FaYxEwoEREREcAg1DN6Kll5kGtCiYiIiAAwCPWMXFioPMhMKBEREREABqGeEcFgxTHJNaFEREREABiEekaolUEodGZCiYiIiAAGod5x2yOezeqJiIiIADAI9Y5rn1BOxxMREREBDEI9I9wyoSxMIiIiIgLAINQ7rtPxzIQSERERAQxCPSOUyl8tm9UTERERGRiEeko4r3JNKBEREREABqHeKotBmQklIiIiMjAI9ZIoi0LZoomIiIgIAINQb4myXy+n44mIiIgAMAj1luLMhHI6noiIiMjAINRLFZlQBqFEREREAODSzHLlCYVCCIfDDT2GMNd/xuNxSCkBALOKAmm7T1BRkEgkGvo+7RYIBLr+Z1iM2zj6EcfRHziO/sBxpJWKQSiAXC6HXC7X0GOoqopQKIRUKgXNzHhKazpeAJDIpdOYn59v7GTbLJFIdP3PsBi3cfQjjqM/cBz9geO4fI0mkKi9OB3vIaGo5iXznR8Lk4iIiIgAMAj1VtmuSSxMIiIiIjIwCPVS+dadzIQSERERAWAQ6imhqs4DbFZPREREBIBBqLcUZxAqmQklIiIiAsAg1DP6zDT0VFm1I9eEEhEREQFgEOoZmU4DCwvOg5yOJyIiIgLAINQzsrwoCYDUGYQSERERAQxCPSOnJisPFrgmlIiIiAhgEOodt10cuCaUiIiICACDUM8o4UjFMVbHExERERkYhHqFmVAiIiKiqhiEeiUUqjgkuSaUiIiICACDUM8oLkEoM6FEREREBgahXgkEKo9xTSgRERERAAah3inbshMAJDOhRERERAAYhHpGH99feZA7JhEREREBYBDqHeFyTNcgpWz5qRARERF1GgahXgkEK49JCeh668+FiIiIqMMwCPWICLoEoQAr5ImIiIjAINQz1YJQ7ppERERExCDUM/nnnnW/gcVJRERERAxCvSKTSfcbmAklIiIiYhDqFSUScT3OXqFEREREDEI9I0Jh9xuYCSUiIiJiEOqZcJUglGtCiYiIiBiEekVUCUJZHU9ERETEINQz1afjmQklIiIiYhDqlSqFSQxCiYiIiBiEekYEAq7HOR1PRERExCDUM0II9xtYmERERETEILTV2CeUiIiICHCfM26he+65B/fddx92796NTZs2YevWrct6nHQ6je3bt+OZZ55BoVDAAQccgHPOOQcbN25s8hk3iNPxRERERO0PQgcHB3H22WfjoYcewvz8/LIfJxgM4p/+6Z9w4IEHQlVVPProo7jqqqtw6623YmhoqIln3CBmQomIiIjaH4Ru3rwZALBr166KIPSJJ57Al770JezZswcDAwM477zzrPuXCwQCOPjggwEAUkoAQKFQwP79+zsqCJUFZkKJiIiI2h6EVjM1NYVt27bh/e9/P17+8pfjySefxPbt27F27VqsXbu26tdddtllePzxx1EoFPB3f/d3OOyww1p41jVgJpSIiIioc4PQX/7ylzj66KOtNZ2HH344Nm7ciB07duCtb31r1a+77rrrkM/n8eCDD2JsbAyqqlbcZ2xsDGNjY9b1cDiMNWvWNHS+xe9T/FzYv9f1fkLXXc+pWwghuvr8l1I+jn7FcfQHjqM/cBxpperYIHT//v34wx/+gHPOOcc6pmkatmzZgvHxcVx88cXW8VtuuQUjIyPW9WAwiI0bN+LKK6/EmjVrcPzxxzse+/bbb8f27dut6x/96Edx9dVXN+W8e3t7AQDz//M4Zl1uj4ZCGBgYaMr3apdQKNTuU/BccRz9jOPoDxxHf+A40krUsUHoyMgITjrpJFxyySWut991111LPoamadi7tzIjedFFF+GMM86wrofDYUxPTy/7XAHjHV5vby/m5uagaRpyefe1nwvJeaDB79VO8XgcqVSq3afhmfJx9CuOoz9wHP2B47h83Z7UWemWFYQ+9thjuPvuu/Hss88ik8k4bhNC4Etf+lLNj6VpGjRNg67r0HUduVwOiqJgy5YtuPTSS/HAAw/g2GOPha7r2LVrF2KxmOua0CeeeALpdBpHHnkkAGM6/7HHHsO73/3uivuuXr0aq1evtq5PTEw07YlR/Hlk0P1drZ7Pd/WLqZSyq8+/VsVx9CuOoz9wHP2B40grVd1B6Ne//nW8853vRCQSwbp16yqmEKruFFTFt7/9bdx5553W9R07duDkk0/GJZdcgquuugp33HEHbrzxRgDA+vXr8a53vcv1cTRNw5e//GWMjY1BURQceOCB+MhHPoJDDz20zp+wSbh3PBEREVFVQhb7GdXosMMOwzHHHIMvf/nLiMViXp1XS01MTDT8GKqqYmBgANPT08a7vZkZzH/iyor7hV9xMqKnn9nw92uXRCLRUD/XTlc+jn7FcfQHjqM/cByXb3h4uKmPR61V97adzz//PN7znvf4JgD1iqiSCeW2nURERETLmI7/h3/4Bzz88MN41ate5cX5tEUoFEI4HG7oMYrLEOLxOKSUkPE45lzuF1QUJBKJhr5XOwUCga4+/6WUj6NfcRz9gePoDxxHWqnqDkKvueYanHfeeYhEIjjllFPQ399fcZ/BwcFmnFvL5HI55HK5hh5DVVWEQiGkUqlFpxvy6XRXT7ushGmjWsax23Ec/YHj6A8cx+VrNIFE7VV3EHrMMccAAN73vvdVLULy84tFozgdT0RERLSMIPTLX/5y3RXwZMO944mIiIjqD0Lf8Y53eHAaKwczoUREREQN7Jg0PT2NBx54AFNTUxgcHMRxxx3HnQtqoTETSkREtJJt2bIFPT09uOeee9p9Km1VdxAqpcRHPvIR3HTTTchms9bxcDiMD3zgA/jkJz/Z1BNsBS+q4wFgRgigrBJQFaKrqyBZxekPHEd/4Dj6A8eRVqplVcf/3//7f/HhD38Y/+t//S+Mjo5i3759+Pa3v43rr78e/f39uPzyy704V8+0sjq+kM12dRUkqzj9gePoDxxHf+A4Lt9Kr45Pp9OIRqPtPo1lq7tZ/Re/+EV87GMfw9VXX42XvvSlGB0dxUtf+lJcffXV+NjHPoYvfOELXpxnd3Ir4OJ0PBERUVfbuXMnTj31VPT29iKRSOD444/HL37xCwDA1NQULrzwQgwPDyMajWLz5s24//77l3zM+++/H5s3b0Y0GsXw8DAuvPBCTE1NWbfv3r0bQgjccccdeM973oOhoSEcd9xxnv2MrVB3EDo2NobNmze73rZp0yaMjY01fFK+4RaEFvz7bp6IiMjvduzYgS1btiCbzeKLX/wi7r77brzxjW/E008/DU3T8LrXvQ4//vGP8clPfhLf+c530NPTg1NOOQUPPvhg1cd88MEHccoppyCRSOA73/kOPvnJT+LHP/4xXve611Vkjy+//HJIKfGtb30Ln/rUp7z+cT1V93T8+vXr8ZOf/ASvfvWrK2776U9/ivXr1zfjvPxBUYCy/zySmVAiIqKu9eEPfxgbNmzAfffdB1VVAQCnnnoqAOBHP/oRHnjgAfzsZz/Da17zGgDAa17zGmzYsAHXXHMN7r77btfHvPrqq3HAAQfgnnvuQTAYBACsXbsWr3nNa/DTn/4Up59+unXfv/u7v8MXv/hFL3/Elqk7CL300kvxvve9D+Pj4zjrrLMwOjqK/fv34zvf+Q6+9a1v4fOf/7wX59mdhEui2cfrmoiIiPxsYWEBv//973HttddaAajdb37zG/T29loBKAAEg0GceeaZ+OY3v1n1cX/zm9/gnHPOsQJQwAhs+/v78dvf/tYRhJ522mlN+mnar+4g9KKLLkIul8PHP/5xfPOb34QQAlJKjIyM4MYbb8R73/teL86zOykuQSin44mIiLrS9PQ0dF3HmjVrqt6+atWqiuOjo6OO9Z1uXzc6OlrT17ndr1stq0/o+9//flx88cV49NFHMT09jcHBQRx++OFQ3IKulUyt/H1wOp6IiKg79ff3Q1EUPP/88663Dw4OYv/+/RXH9+3bh8HBwaqPW8/X+WnXymU3q1cUBUcddVQzz6VtvOoTOqcGoJffT9e7uh8c+9n5A8fRHziO/sBx7B7xeBybNm3C1772NfzLv/xLxZT8iSeeiE996lO49957rXWihUIB3//+93HiiSdWfdwTTzwRP/jBD/CZz3wGgYARmv3iF7/AzMzMol/X7WoKQm+44Qa87W1vw+joKG644YZF7yuEwKWXXtqUk2sVr/qESpf1Inoh39X94NjPzh84jv7AcfQHjuPytaNP6HXXXYeTTz4Zr371q/FP//RPGBgYwJ///GcMDw/jggsuwHHHHYfzzjsP1113HUZHR3HTTTdhbGwMH/3oR6s+5hVXXIHNmzfjDW94A97//vdj3759uOyyy3Dcccfh9a9/fQt/utaqKQj90Ic+hBNPPBGjo6P40Ic+tOh9uzEI9Yzq8uvlmlAiIqKudeKJJ+JXv/oVrrzySrzjHe+Aqqp40YtehE984hNQVRU//elP8aEPfQhbt25FKpXCMcccg3vvvRfHHnts1cc89thjce+99+Lyyy/HW97yFsTjcZxxxhn4zGc+41oA5Rc1BaG6rrtepiUEXX69OoNQIiKibrZ582bcd999rrcNDQ3hK1/5yqJf/6tf/ari2Cte8Qr87ne/q/o169ev7/rlDOXqriS6//77kUwmXW9LpVI17QqwUohAsPKgrkMykCciIqIVru4g9JWvfCX++7//2/W2Rx99FK985SsbPim/EKGQ+w0+XttEREREVIu6g9DFUsGpVArRaLShE/KT6kEo2zQRERHRylbTmtDf//73jnUK3/zmN/Hb3/7WcZ9MJoMf/vCHOPLII5t7ht0sEnE9LDUN/unyRURE5H9edTDwc3uupdQUhP785z/H9u3bARjV75/73Ocq7hMMBnHkkUfi1ltvbe4ZtoBXfUJzPb1wy3n2RCJQu/Q/HfvZ+QPH0R84jv7AcaSVqqYg9KqrrsJVV10FwGhSv3PnThx//PGenlgredUntFClrcL87CxUt/ZNXYD97PyB4+gPHEd/4DguXzv6hFLz1B0JsUVTHcLu0/FcE0pEREQrXd2FSd/+9rfxqU99yvW2T3/60/jOd77T8En5hVLtHRob1hMREdEKV3cQeu2111ZNf0ejUVx33XUNn5RfiCq/J+njaSUiIiKiWtQdhD7xxBN48Ytf7HrbUUcdhccff7zhk/ILEaqSCWUQSkRERItYv349fvazn7X7NDxVdxAaiUSwb98+19vGxsYQCHRnwY0nwuwTSkRERM1VKPgjjqg7CH3FK16B6667DqlUynE8lUrh+uuvx5YtW5p1bl1PhKr3CSUiIiJyc8455+Dpp5/Gm9/8ZvT09OCKK66AEAK33norjjjiCPT39wMAPvWpT2HDhg1IJBI48sgjcffddzse52tf+xpe/OIXI5FIYMOGDVZmNZfL4aMf/SgOOeQQDA8P49xzz8X09HSrf8z6q+OvueYabNq0CYceeijOOussrFmzBs8//zy++93vIpfL4c477/TiPLuSCLrsHQ8APnkHQ0REtFLse/97PHncxB2VcdO3vvUt7Ny5E7fddhte+9rXAjDir7vuugv333+/1Vf2kEMOwa9//WusXr0a3/ve93D++efj+OOPx0EHHYQf/OAH+PCHP4zvfe972LRpE5599lkkk0kAwOWXX46//e1v+MMf/oBEIoH3ve99+Od//mf8+7//uyc/YzV1B6FHHHEE/vjHP+Kqq67C3XffjcnJSQwNDeGUU07BVVddhQ0bNnhxnt2p2tIEZkKJiIioTpdddhlWrVplXT/rrLMcl6+++mr84Q9/wEEHHYTbbrsNH/rQh7B582YAwNq1awEY26/fdttt+NOf/mQ91sc//nEceuih+NrXvga1So9zLyxrAeeGDRtaHi13I1ElCJVcE0pERER1WrduneP61772Ndxwww3YvXs3ACCZTGJiYgIA8PTTT7smBsfHx7GwsIBNmzY5jiuKgr179+LAAw/05uRdsIoI3m3bWcik4bYHRiQYRLxLt2jj9nL+wHH0B46jP3AcyU3x91bt2J49e/Dud78b//mf/4kTTjgBqqriZS97mfU7Pvjgg/Hkk09WPMbw8DCi0SgeeughrF+/3rPzr8WygtAnn3wSd9xxBx5//HFkMpmK23/0ox81fGKt5NW2nbrL7wYA0skk9C7doo3by/kDx9EfOI7+wHFcvlZu2zl607+17HsBwOjoKP7nf/6n6u3FAvGRkREARlb04Ycftm5/73vfi4svvhgnnngijj/+eDz33HNIJpM44ogjcNFFF+HSSy/FrbfeitWrV2P//v3YuXMn3vjGN3r7Q5Wpuzr+j3/8I1760pfi7rvvxt13341nnnkGDz/8MO655x489NBD1qJXAteEEhER0bJcfvnluP7669Hf34+PfexjFbcfddRR2Lp1K0444QSMjo7ioYcestZ/AsCZZ56JT3ziE7jwwgvR29uLV77yldizZw8A4LrrrsPRRx+Nk046CYlEAps3b8YDDzzQsp+tSMg6c+OvfOUrsW7dOnzpS19CMBjEn/70JxxzzDH43e9+h3POOQdf+MIX8JrXvMar8/VEcf1EI1RVxcDAAKanp613ejKTxuyVWyvuG33TWQifuKXh79kOK+Ede/k4+hHH0R84jv7AcVy+4eHhpj7eYrwaIz8vxVhK3ZnQv/zlLzjnnHOgKMaXFqfjN2/ejG3btuGyyy5r7hl2s2qFSdw7noiIiFa4uoNQIQRCoRCEEFi1apWV2gWAgw46iNt22qlVpuN1BqFERES0stUdhB511FHWQtlNmzbhM5/5DB5++GE89thjuO6663DooYc2/SS7lVtlGwCAmVAiIiJa4equjn/ve99r9aO65pprcOqpp+Loo48GYLRf+O53v9vUE/Qj9gklIiKila7uIPT888+3Lh955JF45JFHsHPnTqTTaWzcuNHRyZ+q8PECeyIiIqJa1DUdn8lkcMYZZ+D++++3jvX09OCUU07BGWecwQC0RsyEEhER0UpXVyY0Eong17/+NS699FKvzsd/hADKu2BxTSgREVFXWcmtlLxSd2HSqaeeinvvvdeLc/Ent+IkZkKJiIhohat7Teg73/lOXHTRRZifn8frX/96jI6OVlSBH3PMMU07wVbwau94AJhRFEDXHfcNKKJr31Fxj2N/4Dj6A8fRHziOtFLVvWNSsUm99QC2AFRKCSFE1+1s4dWOSQAwc/mlQD7vuG/w745B/LwLG/6e7cCdPfyB4+gPHEd/4DguXyt3TKLmqykTeuaZZ+L666/Hhg0b8JWvfAXxeBwjIyNen5s/KC4rHrgmlIiIiFa4moLQH/3oR/jIRz6CDRs24MILL8TOnTtx3HHHeX1u/qCoFYdYHU9EREQrXU1B6IEHHogf//jHGB0dhZQSe/fuxdNPP131/gcffHDTTrDrqS6ZUB9PKxERERHVoqYg9JJLLsGHPvQhXHvttRBC4M1vfrPr/bp1TagXtH17kfrS54Fk0uVG/n6IiIhoZaspCL300ktx+umn49FHH8UZZ5yBT37ykzjssMO8Preup09Nuh6XDEKJiIhohau5RdOGDRuwYcMGXHDBBTjrrLNwyCGHeHle3S8YrHqTPr4f6Z//BOrgEJThESiDQxC9fRWtroiIiIj8qu4+oV/5yle8OA/fEYHqQahMJZH9xX84DwaDUAaHoQwNQR0agTI0BGVoBMrQMJTBwUUfj4iIiKjb1B2EUo2C7r9a5cC1QC5rTNXbp+Xzeej7xqDvG0NF7bwQEH39UAaHoA4XA9NikDoEEYszi0pERERdhUGoR6plLkPHbUTkhFdA6jrk7Ay0yQnoLh8yvVD6IikhZ6ahzUxD2/Vk5YNGolCHho3gdGi4lEUdHILSPwChVraJIiIiImonBqFeCVT51WazAAChKBADg1AGBoENlUVe+sIC9KkJ6BMTxmczONUmJyBnpgH7RleZNLTnnoH23DOV309RjGDUljlVhkasoFU0uF0pERER0XIwCPWIEAIIBIGCc8tOmc/V9PVKLAYldjBwUGXPVVkoQJ+ecmROtckJK2iF/XvoOvSJcegT4wAerTzPnoRj/SmLpYiIiKgVGIR6SAQDkOVBaDZf5d51PG4gAHVkFdSRVRW3SSkhk/OVAWpxmn9+znn/5Dy05Dy0Pbsrv5FLsVTgoIOhxeIsliIiIqKGMAj1UiAIIO04JPNZT7+lEAIi0Qsl0Qusf0HF7TJrFEXpkxPQyqf7ayiWsn6a8mKpwSFzPSqLpYiIiGhpDEI9JAJByPKDWW+D0KWIcBjq6jVQV69BeR7TtViqGKguq1jK1maKxVJERERkwyAUQCgUQrjBAp1i1i8ej0OaRUPJSBh62f0UrYBEItHQ9/JUXx9w8DrXm/RUCnJ6Ctl9YyiM7zc/xlGY2A9tatKlWOpZaM89W/lAiorA8DACwyNQR1YhMDyCwMgq42N4FZRIxKMfbmlu4+hHgUCgs/8fNojj6A8cR39YKeNI9WMQCiCXyyGXq61gqBpVVREKhZBKpaBpGvRUEtrCQsX98skU5ufnG/pe7ZQ4aC20vn6Iw45EELCyqW7FUvpUaT0q7L9fXUNh/z4U9u9z/R6OYqnBIaOSv0XFUuXj6FeJRKKr/x8uhePoDxxHf/ByHBtNIFF7MQj1iJyfh5ydqbyh0HhhUidqbbGUsf7UubOU0YaKxVJERETdgUGoV6rsHS8bzLh2o5qLpYqZ0yWLpfZC37d36Z2lWCxFRETUsRiEekQEQ+43+DQT2ohlF0tNTUAuLLNYanAIyvAwi6WIiIjahEGoR0S1TGihIn9Hi1hyZ6n0guu2p9V3lqpWLKVAGRiEOjyC/IEHodCTAAaGrKCVO0sRERE1F4NQr4SqZUIZhDaTEo1BOWiJnaVsbaaqF0vpVgCbf+yRisdqZ7EUERGRHzEI9UjVqV2NQWirOIqlDnfeVq1YSk5NQk5PQZuZdt6fxVJERERNxSDUS6rqLKoBAJ090jpBtWIpVVUxMDCAqX37kN+/z5E5NT4mzWIp25uJpYqlevuMANVRLGV8sFiKiIhWKgahXlKUyiDUx73u/ESEQrUXSxUr+asVS83OQJudYbEUERGRDYNQL6kBIF9WDa+X76FE3aa2YqlJ6JPjZQVTk9BnpuoulrK3mVKGRoygdXAYoo07SxERETWKQaiHhKpW7h3vcoT8xSiWigEHra24raJYaqq4HtUIWqsVSwGPVjyWiPc4MqeqfZqfxVJERNThGIR6KeDy6+Wa0BWtvmKpSWjFbOrUBORc2c5SqSS0VHLJYimjYGrYUSxFRETUbgxCPSQCgcq8p+R0PLlbcmepXM7YWWpyvK5iKZdvhGT/AGD2RWWxFBERtQODUC+5ZUKJlkmEQlAPWA31gNW1F0uZ0/zlxVLa9BQwPVV7sdSgGaSyWIqIiJqEUZKHqu2aRNRs9RVLTUKdm0F271iDxVLDVtEUi6WIiKheDEK9xCbl1CHKi6USiQTm5+cBmMVSM9NWgFqs6l+6WKoSi6WIiKhWDEI9JILuW3dKXYdQlBafDZE7EQhAHR6BOjxScZtRLJW0tZsyi6XMtakNF0sNDpvT/dxZisivJLerpioYhHqp2v7xWgFQqtxG1EGMYqkElESihmKpSVs2daLuYilrZynHVD+LpYjaSUoJ5POQ6QXITMb4nE5DZtLGZ/t165j5kTFuE/E4Bm+8vd0/CnUgBqEeElWCUFkoVM2SEnWTJYul5mahTZQyp4sVSy2+s1Sk1GaKxVJENZNSArmce9BoXV48uGx0pz+ZTjfppyG/YRDqpVDY/TinJmgFEIoC0T8ApX/A9fbyYim9OM0/MeFSLJWpq1gqMDKK7CEvgAyGABYIUheTUgLZrDNotAeLrsed1z3dqU8IoyAxEoUIhyFCYSAYhAgEAFU1np+hsPFzEJVhEOqhaplQBqFENewsVVEsNWm2oKqtWCppfraKpQaHK6b7RaKX67PJU1LXjSDSNj1dPm1d0ArIzc06p7Ft2Ul4GcAJARGJAuGwEUQGg0ZRrRlACqFAQgISEFKH1DRAK0Dm8pC5rPGRyQLpqar7AXI5DVXDINRD1drV6Pk8+GePqLqai6XMzOmyi6UCQWMXKbdiqYEhtlkjY1lJMSC0PtuDSOd12G8zg0lPg0hFgQhHgHDIWOYVCECoAUBVAGH7S6PrkLoGFDTIfA4ynweyWSBr/ExIL3i2qbTMpJkJJVcMQgGEQiGEw1WmzmtUfJcXj8etJ5vs7UPW5b6xQADhRKKh79cugUAAiS4991q4jaMfdf049vYCa9a43qTnstAmJyCmp5Aeex6F/ftRmBhHYXw/CpPjzpmIwuLFUmr/AAIjqxAYHkFgZBVU83NgZBRKvP3Zna4fxyU04/koNQ16Jg25sGAsAVkwP9ILzmNpl2MLRoDpKUWFEokAoSBEMAShBow1zooAIABIY820phlV5vk89FwWMpszCv903fMgUgRDENGoMXsRjUBEY1AiUSjRKIT5WYnGIKIR47P9WCQCNRYH4P/XVaofg1AAuVwOOfv03jKoqopQKIRUKgXNXMSdq/IHKjU9hVyX7t9t7y/pR27j6Ee+H8e+AQysfwFy66cBTbNe6NyLpcxq/io7S2nTU8g+/mjlNykWSxULpNpQLOX7cVRVBBUF8/v2oZBKuq99tBfVVBTcpI1sn7cnCQRD5jR2AEIxA0ghAAkjgNQ1oFCwgkjk7ctJNOgLKWCh6ndYPjNLKiJRIBqxLouI+dntWHF9ZyRSOlbj/2UJwO1VU9U0RITw5HW10QQStReDUA+JiPuTQ2YyLT4TIgLqKZaasALTZhVL2af7V9LOUrJQcK6HrCiscTteqtqezLUiiLQV0gjFCCABY7x1DbBlISuKfDQN0NJWxrRpeb5QqCI4FGXBIYrHwhEjoLTfLxwxHsPjbL3UdWN5zPwcZHIOcm4O+vw8ZHLOODY/DxEIYOCy/+PpeVB3YhDqpXDU9bDMMggl6kSLFktpGvTpKWeAWmexVFE3FUvJfH7RoprKIHIBMp2xjiOf9/YEVRUIBM0pbGcAKXXdDBIL1QtCNTPIbNb5KIqZZTQDQXtG0TWYjCA+OIS0Lm1BZbitbcekrkMupCDn581A0gws5+egJ83PZoApU8ml17xW6xRDKx6DUA8p1Z54Xk8PEVHTCVWtr1hqqhSsLqtYyiyQaqRYqq5G4+UBZjGI9Lqbh6oCaqAUQApASDgDyMWCnGYGkeFwRbbRyDKax8LGFDasY7YsZPG2QLDu7GM4kUDO42UVUkpjXK0AspSxlHNlwWUy2XBbJxGLQyR6ofT2Qkn0GlX1RGUYhHop5P7HQja4/pSIOkvtO0tNWJnTqjtLLVYsBQCxuJFJjUaRjsWhCQCKCkACuXzlmkiv//hbGUjFqqOBNAPIWgIZM4i0qzugVAPOwNFtXeNS09rhSEdloGth9BDNlLKUZnbSCCTnoc/N2bKX887/Z8sgolEjU9+TgNLbC9HTCyWRMILNRK/5OQHRk3BkclVV5YYS5IpBqIeq7h3PTCjRimBvNA6pQ0SjRmYzHoccWQWZyRgV2HOz0OdmIZNm8U02CxRc1h8CwEIKciEFDe5FIHVTFOOjGEHq5jrIWrkEkTUTopR9LGYXbesblWgUsYFBZKQ0pnSLwWPxfsXrPmulJXO5ymlw87pMmkHm3Dz05Fzjyx3CkVIg2ZMoBZJWYJkwPvckfPd7pvZjEOqlak/YPDOhRN3AtdF4lWnriuvmfTztEdkMur68qddAoHLq2spAOtc8VlsPiVB40eyjqqoYGBjA9PR013erkIW8+xrL+XlkMwvITU1ZAWbDS7aCwcoAsjxbWQw6WV1ObcQg1ENVM6GcjidqCanrRqbR3lB8kUbjMr0AZDKtazQOOCux26kYVMbiRvDS2w9lYADK8AjEwKDV89H6CDArJjXNDBznXddaGtPh5rrLRvdPVwOOoFLp7a2SvUwYa1a5QxF1AQahHhJV1oQiz+l4olpITTOCxGJg6AgaqxfVIJPGdCYNvdE//K1QT/AZDDoyioF4HLp5DGWFNAiFIYSEzGYhUwuQKWONoD4zBX1yEnJu1vnYhQJkch4yOQ/s3+uc6m9isVSnk7oOmUpWrrF0yWLKhVRj30xRIHoSCPT1Q8bjRkBpFvKUZy9FNMrAknyHQaiXqmZCPW5ZQtQhrCDSHjS6NBRvW6PxVjH35y4Fi27T1JXHlmoa3kiz+opiqakJox9qvcVSQkD09lW0mrJaTnXAvuHS3FWoogq8PLBMmpXhjWSlhYCI91SurbSKeRLWVLmIxSEUxfebDhBVwyDUQ9WqASXXhFKXkIW8o+djtV6QrkFkOu2P9c+hUGW7HlvbHoTLCmVs7Xqs3Wpa0DS8XiIUgnrAaqgHrEZ5HrO4s1Spmt/54cgASgk5OwNtdgbaricrv1H5zlL2jwZ2lpJSGv/f5s1p7+S8SyFPqVK8OS2HEu7rKq1K8V6IeJyV4EQ1YhDqNUWpePHjmlBqlYpG42agmJQSmenppYtqvG407iVVNXs7RsoykIu363FkIMORFRlQ2HeWChz6worbZTpt9EG1Mqe2IHV6+TtLicEhKH19UMIRQA2ikM9hRitgYd9eaHOzFdPjjbYcQiTqLOBxCS6NwLLH2FGJiJqKzyqvuQShXf2HnVrG0Wjcde2jS+Nxe1HNIo3GvdimuqkcbXts+1vbMo5WUFnersdcKzmwahVmZma6vqq6E4loFIED1wIH1rKz1AS08f3QJvZDTk85X/+W2FkKAJL1nlw4bCvWsQeYxaKe0nE/rWUl6kYMQr3m0n5EMghdEaSUQC5XJWh0affjcj/PG403m6pW39/adRca2/FwFCgGnA02DReq2nHT335TajlUtp3jnK2XpTk9Di+2KhYKRE+PsR51eBjqyCjU1QdCXb3ad8VSRH7FINRjQlErd/8oMAjtBvZG43UX1RSDyAbXobWUberaChajlcdcg8riZ/7h72quLYdsAaV9KlymG8ynq6qtSMecBo/Frdkjmc8DmTTUTAbZ/fugT086M/tSN89pDvpzz8CR8++CYikiYhDqPbf1ZF7vxUwAFmk07jJtbQ8cZ3NZaMmkuctNhzcaByqbhhf3sLYHh7ZdaEQ4gvjQENKabk1lI7x403DqXqWWQ2XbOSYri3jkQqqx//OKkZ0sTXsb0+Juu/CIaGzJQNDerL6Qzze3WMqtUKrBYikiqg+DUK+5vJjJbptibROp62awWHujcUdlthdTgM1Wx/7W7lnI5TUNDycSyLElTNeSUkIupJCfn0V+797SdPhcefbS7PvZaMuhWNzRv7JaMU+x5ZAX6iqWmioLUmemnbMSmQy055+F9vzSxVLlvVFFJOLJz0e0EjEI9ZpbReUKCUIdPSLLg8ny6ezirjYLKeN6NgN0cheBQACIRIxdZGztekQ4ArgUyrhOa4dCzD6SpdRyqKzVUNKcBrdnL5PzgKZhroHvJ2Ixswq8F6I3YXxOuGQv4z1dkRmst1hKn5wwgtbJCWc/2iWKpUS8pyJ7WpzyF4lePqeJ6sAg1GMiEKhYE9otmVC3RuMLALLTU861j+kUZCpVCiQzGchstnPXvtoyikrUmXVUojHEBgaQBSBDYfd1kOEI27VQzWQ2ayvSKWuQXsxemkU9DS/ViUQrWwy5VYr3JFbU/2GhqlCHR6AOj1TcJqWETCWdwal9mr9sZymZSkJLJaE9vbvyG5XvLGWf8h9ksRRRuZXzKtQublOljfa2q9HijcbNy8l56KmUmYE098rOZiFzWdeMbYOb1DVGDQARs3VPNGYGkKW2PSibunab0l6qabh9DRpb+1A1Mp8rbd3otq2jbVeehjP6wVBpn/BEotRiqDeB+MgoMoGgGVwmIKrs0kbVCSGMJQY9CWDdIRW323eW0qfMALU45T9VViy1zJ2ltHXrIaVksRStOAxCPSaCLr/iGiumXRuNpxeM/bAXktDnk0bBgS2AlJmM0Qw/n+ucymwhjOCvGChGYxCxKJRovErbHltxjX03mi6YEqTuJc2908v3By/feUefnwMyDa43DgRcs5NGcFmWvQyHqz5MNJFAgWt7PWXfWapcs3aWSgIslqIViUGo19wyoYUC0vf8ADKZhF4MIG3rIGU+ZzR07oTK7EAACIYgwsbUdKCnB3ooAhGLQYnF3fe3LvuMYJDv8KktpKZBr9hpxz172XDLIUVxrQIvb5CuJHqNN2N8TnS9dhdLKYNGVpXFUtStGIR6TIRcpsekRPZX/+nxNxZG8GcGkNaaxlgMIhqH6ImXMpH2vbCLu9FUaRqeSCQwz8wLtZHRcihlFumUTYMXp8iTScwk56E1ozLcVg1eNXtZbDnEohSyqbVYKpRKYuG5Z0vT/SyWohWCQajXlrNGS1WBQBAiFARC4VKAGI1Biccg4gljp5BorLJdT7GVTyDATAt1DSmlMSMw51xP6WiOXjyWSja21KTYcshtv/BigGlWiou4dy2HaGWzF0v1JBKQtjf3TS+WGhwyglMWS1GHYRDqMbdMqFj/AkQ2n2S09ymfumbTcPIJKSWQyRgthubmzVZDlcFlca1lo63LRDRmBZRKbx+iIyPIB8OQPT3OSvGeBNfXUUdbslgqn4M+WVYsVfxwK5bavxf6/vqKpbizFLUCg1CPuQWhyuAQwse8vA1nQ9Q4q+VQsYjHkb10ZjEbbtMVibi3GLJXivf2GjMDtvXX7HJAfiaCdRZLFdelcmcp6jAMQj0mwi4LxhutrCVqMpnP27KSZhDpyF560HKofN9wtyCTLYeI6lJzsZRLNT+LpajVGIR6za29Sr6DdwIi37BaDrls55hNp5GbnrICTGTSjX2zQKBKiyF7FnPplkNE5K2aiqVsmdNmFEsFhkfQ94/nePUjURdjEOoxt0yozGVd7km0NKnrRmsvM2NpBJfzrpXicqGJLYesae/KfcNFImGsa+baMSJPSSmNTKWmQWoFYx21phm78GkFoKBB6hpQ0ABdgywUAPO6cbxgu79W5XHKjocjUEcPgDI0YvztyqQhM+aGJrkcZD5vLLspKxa0F0vlAYhzzm/PL406GoNQj7lmffIdup0ltYXUdWPDAZdWQ+WV4jKVbELLoR4E+gYg43HXoJIth8jvrGCuULAFXoWyIMzt+NL3qQz8XAJCrQBouvV1CwC0XK7iuNv37EpC8LWEXDEI9ZiIRiuO6Z26pzo1jdFyKG0LIEsZy4o2RMkGWw7BmPpyBJKu0+EJ436Kwn6v1BRSyspsnOvlsmycrkGawZk9ECwPvBSpQwsEkUmljNfNqsFh2XHrsat8zw4L5tp+NkIYrQHVAISqGFskq6pReFT1uPM+zvualwMBCEU12g0SuWAQ6jERqQxCkW/N3vHUXFJKIJupvp3jnH3f8Hnjj3ADjJZDZY3Se8rXWLLlkB9IXV86e2ZNp+rWVGk6FELObG/lDM70xQPC8uOF4mXdZXrWedz+da3YGrjB1cqtJYQzOAuogKJCBAKAYlwXihGcQVGM46qKYDiMgkRZMOcW7AUAVYEwj1ULCKGWvqcwz6EYECLgEjR6nKVU+fpEVTAI9ZhrEFpgENpJZDZrZSYLqRRmtTwW9u2DNjtja0NkVIo3vJQiHHFmJ3sSxlrLiuxlwtFyiGoji+vl8nloyXljy85cbpHsmUvgVct0ah3r65YK6hoJ5lJL36U7KYoVKIlgEFIoZVm38iDM5bgZ6DmCL9eAsCx7Zz3OUsGey32WGcx1w8yE1DQgn4PM5Y2tpXPZysu5bOk+uSyQz0PmclACAQxc+N52/wjUgdoehN5zzz247777sHv3bmzatAlbt25t+DH/+te/4oorrsBb3vIWXHDBBU04y+Vzm47vtKkgP5KFvPsaS3sW0wwwHRWfAJL1frNgsLLVkGuleK/7Nq4dqBjMOYK2KlObsuBW2OAe7NW8vs4R+Jlr96quryt9nX297FQbf38dQ6mcWi0GWG7TpqVAzWVqtWrWzX0K1xnAmd9zsYCweB+lFMyx32ttpK4bAV8+B5gBoHE5B5nLuV82g0WY9y1dzjuLjswAs6GZHUUFGISSi7YHoYODgzj77LPx0EMPNeWdYD6fxxe+8AUcdthhTTi7xrkWJul8MV0OqWmlzKRrgGkW7yTnINMNTuKpAcdUuHuDdOM4wmHXynCr+KEYLOVzkOmFqlObi06nVqyjcwkIyx5nsWAvKXXo+XzV79lQ8ZMfqfbgzGXqs9qUaC3TpsVAzjFtqphTttWmU43AL97bh1Qm474eT1XZsaADSCmNN1GLBIUpRUF2bs7MIhofjstW0Oh+ueOLXaX3yzaoO7U9CN28eTMAYNeuXRVB6BNPPIEvfelL2LNnDwYGBnDeeedZ96/mu9/9Lv7+7/8e09PTnp1zPVz35dX4hCySug6ZSlbfztEWZDp2+lgOIYBwBCIchgiFjaxkKAQEghDBgBEwBAKIRKPI2qZwpaZBn50BpiZRqGV9nVbK2HVqMNe2/4GLTXPap0erTZsWjy8xbaoEg4glepHOZqGbRReLBoRLrd3r0GAumEhA7fBp3E4nNc0MCLNm5m+xyzmXqWiXoDHvDDaXeh1osJla51EUo21b1NySOhY3gnGiMm0PQquZmprCtm3b8P73vx8vf/nL8eSTT2L79u1Yu3Yt1q5d6/o1zz33HO6//3589rOfxec///kWn3EVbju+tOldoaMtSQ1Tm25r3VLBILKp1KJTrnohD2SzkJk0ZCZjvGBnbe/YC3njexanWlv3CzB73KWx2Mthh+cUbJWsVSpSqx4vXQ5GIijoevVp0/LHc1tfV2Udnf24/bFbGcypqoq+gQHonMbtalLXoWcy0OfnoKXT5hrDrBno2aaNrYDPNhXtcl+Zy5sBYtaafm7pa1CthAIIwPhHGq9drQrigkEjgIyYAWQk4gwoI1GgeKzicxQiGjHe2Nue6yqz8lRFxwahv/zlL3H00Udj48aNAIDDDz8cGzduxI4dO/DWt77V9Ws+//nP44ILLkB4iR1ZxsbGMDY2Zl0Ph8NYs2ZNQ+dbrP6rqAJ0qwrUdeQffKAs8HNZK1elAEIuMk1buT6vuT3mfPWO3S1DFghADQahC8UloCrPnrkFYWVr4sqyd24BoWM6tsptjq9tQjAXj8eRSvm2rKX689FnhBBt+xmllFbhSSkjmLWygY4pZ0cGsVS4UnEfWzGLzGWBQqHz1vban8uKaryOKEopSLQtw7GWydQb6Eodi75TdiOEMctjBYzlwWHpumIGi45gs/g1Hvx/WinPR6pfxwah+/fvxx/+8Aecc05pqy9N07BlyxaMj4/j4osvto7fcsstePjhhxEKhaygdTG33347tm/fbl3/6Ec/iquvvrop593b21txbFII57tYXUfqW19ryvfrKmZLEhEIQgSDEKEQlHAYIhyGYr4wKpEolFjMuN0M8owAzgjShBowjwesYobSfVTrtuLXIhBwPE4p4PO+LUmnC3VJkVQj3J6PfuM2jsX+nXo2A5nLGZ+zOei5rNENwgzy9Kyx843M5kr3te7jct9s1ny8bEfu/CYCQYiw8bqCYMh8HQlCqIqRwVcUCAhIAQhISF2WOipoBWOrWzNgLv68FRlIcxanqXlJVYUSjUGJRqHGYtZl43MMSqz8uu2y+TUiHOn417SV8Hyk+nRsEDoyMoKTTjoJl1xyievtd911l+P6X/7yFzzyyCN4+9vfDgBYWFiAoih48skn8fGPf9xx34suughnnHGGdT0cDje8hlRVVfT29mJubq5y+q88CK3GaktiZuZs69Kc/d2cbULK17RJCUAWs6wFs2oyb3y2/uhkIDPZhntZIhyGYlZ+W9Xg1vUERKIPSrFC3G19bB0k6k8OOL44XzB7tFb/47noOPrISsiEdvI4Sk1bJFNoywTm7VnCykyhomnQMmnHfaxilU6bZlYUcx22sR5bBEPWumwRDEGEjc/WOm0AiqoiFA4jm80aMzq6bn42Z31sFeF6LgNkMtAzaRRSKSDbohxqcfo6amYYHdPX5ddL2UfFlomM9/djoYZtdnVUWc+dyRofHURKaWXHFV3HwPpDPHk+DgwMNPXxqLXaHoRqmgZN06DrOnRdRy6Xg6Io2LJlCy699FI88MADOPbYY6HrOnbt2oVYLOa6JvQ973mPox3Tv/3bv6Gvr8+RSS1avXo1Vq9ebV2fmJho2hOj+PM4CAWOl45QCL2Xb3Ouo7O1JXFTajlUtp3jnNlqaGbGKuJBNtPYDxEwWw71JqxelsUWQ7FVq5ANBEt9LZdY+lCkA13Vmsp1HH1ESunrn69oOeNob3fjCOqqTDMjv1jlsgftbrwghBFMhcJmIGhchjljUbocNna/CYbKLhsfsrgWUJoZRl0vtdzKZSEzGWutuMykAfOzPjdjHEunIbMZRy9lz5YACWF0tnBd2xhxDSARjlQGlw1MMdvfWLfz+VjMAMPMfheTFbCSFra94he7vXg95yzIEj0JDNz8b75/XaX6tT0I/fa3v40777zTur5jxw6cfPLJuOSSS3DVVVfhjjvuwI033ggAWL9+Pd71rne5Pk48Hkc8Hreuh0IhRCKRzkj/K4pzXzYpoSR6bS2HKntXyrJKcZlu8KVYVZ0N0W0thspbECEcqbrmMJZIQGM1LrXJku1uzKBQFAqYUVUszM5Az2ZdgsMua3cTCDqzhublYDQGTVGM46FQWQAZgqh62XwMM7BEIGAEjmXBoRUwmsGhzKQh0xnIuTn3gDKbaU0Gtqz62jU4XCqgDIU7fvq6nPUGyQz8YAsAZdYeFJpZ84rbc65Bo9cJgk5cukGdQUj2TcDExETDj7FYU+WZKz8EZJzZSRHvMVoONfLrVxSInh7nfuG9vUYfy4Rze0cRjTalOrEbdvZoxEppju3VOFa2uzELUVwvu+28UjntbAWKNba7aTlVNQO6kGug6HrZEQhWXnbeN1g1WCqOoyzkjeAwYwaL6cpsY9WA0vya8k0bPLNE9bU9oFRjMfSOrEIyX4AMhapWX3ciI7tYDPRyi2YPg1Iim5w3/r9Xyy6ab6baSlGM2a9Q2Gp1h1DIuFy8XmyBZ7uuRqI44JWv8uR1dXh4uKmPR63V9kzoiqBUTtfIVJV9eYSAiPc4dt+plr0UsXjXvZOn9pG6bgV0hWwG2tTUElPOZRXMFdnDyt1WOm4dohDmGkTb9LI5lYxQsCJAtDKKNQSK1uVGpmOL6+YyaSs41GenS8Fhlenr4rG5bAZ6Ot2arYDbMH2tqipiAwPIevim0MouOoK9RbKL9iCxmGVvMLvY4AIqd8FScFgKGkNVAsVQqX9yWZBpvx1qYFnBP6viqRoGoTCm7pdq67SU4hMzHq9syjsXCDgXkweC6HnFyVB7+6D29UHp7YPa2wu1t88IODv4CRsIBJBIJNp9Gp5ZbBy9JKW0gjx71qRUiWxvf5O1Hav1eA4olKaZ51r2ky2u+EfR+gMZNDsmWMdD1h9CpRgg2m5XikUuoZBjEwI1HEG4pwc5D4NiqeuQ6TT09AJ0M4jUzesyU7qsp0u3SfO+1rFMukXT1yqUqFk8Y1ZUG5ejUCKx0uXibZGoeZ9SVbYIt376uvz5KAsFs9LfWF9qXc5mStX7xcsZ4zbnfYwuAaX7G7e1laJCiYSN6vaw8Vkpfi4eD4WNYxHjPko4Yt1fiZQ24LBf7oQEhZTSzO4aYXarX1ep8zEIBZDL5ZBrcJpDVVWEQiGkUqmKd+yy/MUgHELgdacDKFU7WnmMGiok22klTMeXj6PR7qZQ2eg6X1x3VcwY1rrbSuVl5Ns8zeYmEHBmB6tkCpecfg6GjExK2WUElz+lWizoqBa+qQAiwSAWqmTQ6pq+tl/vsOnrUKIXeUUpyzba+z+aGckaf9cSzuXrluLmEjWqml20F7Usml0sZRlFIW90AMh6v3ZxSdWyi4tkD12zi+FiNjIEqAH09vbW9bq66NsWqwtIcxlvuhYgF1KQqRTkQgp6MlmqYUjOQyaTkAsL1hsxZDLG8plgEBv+7euufx8b1WgCidqLQWgLiEDA2Vqo06Ysu5zUNDMgzFe0tal+2Vm1XAwmkc9hXtdQSKcdwWbHjVlFMYo55ewWNLpMOcf6+pApaO4BZvFyB2RSyjmmr92CQ/OYyGaR0zVk5+asP4j2gNIv09eNviksvcEy1yK6BY3lRS0Vt+cqgsy2v6lSFIhwpLResTwQLF+/GAo5p6jdgsZF1uZ2i+IGA3oyCTk7DX12ptRhJZmEXDCCyNJud+ab5eImKMuVzzMDSq4YhLaCWvZr7rSAxkOlas7KzF/VQNG+9nCJ7GF3tLtxViI7L5e1uwmFrUb+bpdRnKZucMlGO7ocSF2vL9vYYPV1Q+vslqy+LtttpgXV19aa3lwp8MsGVOSnp2tqqVMRVBY/t/v1yBYo2oPC4rRzpLfP6OwbDJatZQxVyS6Gjc0rfMB602Xr74yMuYzAbHmlp+Yh520BZLHwrLhetZAv7ZjXxkBQa7TDC/mSP56pHU4Ey4PQznhHaLW7cTTAXjxA1ADkksnubncTrJIxDIWghMII9fQY+8cHgrYAspYilVK7m06v3K1XN05fB+I90ENBY+1cMTgMR4x9r5s0fe3Gyi6mF6zp5iWzi44p6tqzi1XKG71RzC6WF7VUrY62FcFY960vu9ht3SocQaMZKFpBY3FtqsuxjK4hn0warfgytvvlC2hgi47WEsIonO3vhxgYgjI0DHXVKqijqxE4YDUCsTiQ7cBlR9RWDEJbIVC2U1CNmQepaY4pY9d2N7aMYGkqOl8WWLq0uzGP1fvO2JMqTjs14GiAveh6w2IAWUu7G+u+/vqjt5Rq09cLALLT00tWX3f09LVrQGlMX9c6jo7sYjYLfX4WmNi/ZEsde8ucrskulgeN5dnDKtlIv2UX7SqCxmwWsBUyFT9bSxUcx3KO68XxX0620ZO36kIYs3DBgLWtsbFxCgCpQ+YLxhvDQh3fPRKBOjQMZWgEyuAQlOFhKIPDUIaGofQPVJ2hYXU8VeO/V5UOVLFdpVZA6htfXjKT2PY/ZOWEKGUv7Duo2Bpk26eMS7utLBUo2qal+WJl8XL6uukbdtqnr5fMNlYJKBepvrayiy7ZQzk9DT2315FdRD6HvAAyxabq1aao2712UVWXbpmzSHYx3j+AtKaZa4L9s3axmlLQmCmNoT3L6Agaqx3LNRw0tlwwZHu+xCDicSg9Riu/Yh9oFPe9T6egz81DzkxDn5qAPjUFmU7X9n2EgOjrhzI4BHXYDDSHhq0PEYv7bpaH2otBKLxv0ZSJRlGeR8o/9OeGvp/rOZS3u6nS1mbJdjeO+4as4wgEEAwGUWhFVqxNmtWiSebzRouejNmWp9i6xzxmtetJ29r1lLX6kY1uv1ojEQzZWvdEnG15IhFbS58YFKt1j7PVjwiGrN+d1PVSZjFTyhQVW+XomYxRSTs1YbbZsbfYyVR+XS4LmckCen2Z6Wb/9qyWOOGw7XIEIuJsq+N+H3trndLnRrOLgUAA4Q5+PkopS+NY3KKz2F6p+IYpmzUuW/cx/6+Yb6LmslnjeVIMHLshaKxGUSDiPQgkeqH09ECJ90CJxxHo7QWiMSjxHqjF48XPsTigKNDnZlGYGEdhfL/xMbEfhT27kB8fhz43W/MpiGAI6sgIAsMjCIysQmB4lfF5ZASBoWEjqdBs5v9RtmiicgxC4X2LJq08KyEE1DUHLr1TSh2XvWx3A123dnzye4smRVHQH4thbmwM2kLKmW201kJ24PS1VThT2/R1YmgYyUIBIhA0CruqbOenZ7MoZLPA7Czk+PjiU9TWOrY2rwNWAxDhMNRoFDIQsLKEizfkDjnWLlbsCrOM7OKizytdB2rNTi2i2c9H5/KEUj/O0nhnIM31jKX1qlWOFXf4aUfQIYQx9SxgfP/iRzOFI1BicYh4zMgQxnuMDGUsbl53flZiceP/mMvrdCKRwNz0NArTk8hNTkIfexz65CS0yQnok+PQJyfrytqLnoQjg6kODkExM5uit6/iHArmBzLGetVaSV2HTCahz81Azs5An52FPjsNfXa2dH1uBkosjhfccAtbNFEFBqEtUPHOMhxB4tLL2nMyPlbX9HW1gDKbwVSr974un74ORyCizulrhMIQAdXYfUtRICAgIR3rGZ1FLzmjj9/MVFl1tHH/lDml2fYlH4usV6zeMsdl15fi7aEQRCDgu7W91Vj/521FL1bQaFVQl01Hlx/LdUDQqKpGoG9fuygEBABFCGiFPGTB7H9ZqGEtu5SArHHcFcWa4i4GjaVAsscRRFr3icWWlcXWFxagmUGlEVxOQJ+cxPz0JLTpqdp/94pSmioftAWbxWnzJgRmMpczWjjNzkDOzZqXzeByzrw8N1vTa4ieLzADSq4YhLZC+QuC7LC1nh3Aqr629rSuo/ra/JrWNw+vzDaiGEgFg2aVvAKoitHXsxg66sb6Rteilvk56BPjHZpdrNYSJ+SeXawoegk1nF3sdlamsbygpazopaZjuSxmWvV/vlwgYI5rBIjYssnmmyQoZqZNSkDTIfWCuWYxX3qzlDEypwCsFkLlYcqiMzRugqFSEGkFjLZsZNwlSxmONO3/odR1yJkZM9CcMNZkTpifJydqX5sJAJGoFVRWfPT1L3v9vNR1yFTSlq2cgT5nuzw7Czk3U9+52gVDUPr6jHPs6zd2BBwYaP9GA9SRGIS2gAiVBaHtzj410aLNw8uyjSi/T6unrwEj4xixZR+La2MDZtAYDCISjSKXL0C33rmbU3maZjbGL+0Eg1wW+swMZG5fqdChneMrRKmXqGt1tBEIhhMJ5Iv7qrvt+mJvqWNmF1ciI2gstUmqrKBe6lhZRXWDy36WLRCw1qjCtl7VecwMKoMhYxobMP4va5qRhczljcLJbAZIp6EXd85JJqEv7GtukCGEMTMQ70Gwtw96OGyumawSWMZ7jOykF+sZy8hsFvrUhDFVbgsw9ckJ6NNTtf8ezCIgdWgY4QNWQ+vtcwaasXj955bPOYNLczpczs6Wsprzc8seK9GTgNLXB9Hb7ww0zQ/R12e8vpZN96uqumJfQ2hx/F/RCpHyTGhnTEsUp/KcmcbFp6/T+RzyqVTpa1o1pSsEEIkafyjNNbDW9J2iGJkMM9toBY26Dui6ETgW8qXtM7NZ6Klk1exiy8KERbOLy2upU2t20a9re4tBo5YvIJdeQGF8HIX0QilAtFXK1xJIdkbQGCm9MXAcCyHS24ccYHYXMI4J277iUggjiMxkHNstyoUU9FQSMpUytl3cWzq+7AxYNWrAWjepxHucmUj79Lc9OxmNQShKW5ZVSCmNGQkzsNQmbUHm1ARkPc+bYAjK0FBpqrw4dT48DGVg0Hjzi6Wfj0b2MlW29tI+TW4EmnK5DeEDQSO47DODy97+0uW+fuN6by8DSWo6/o9qASUUcR5oQhBabfp6sWxjM6avl5WvVFUjkAoEgUDQtrZRQAjFnIKT1tQddDPzUiiUGt7rOpBeMBqAL+ccGmFlDEvdBSqyi64NuatkF4tfy3ZUZZlGlwIXe+Nu+9R0xv2YvXhjppU/SCBYWptalmWsPBayBY1V7lf2f8N4w5guBZHmZ6EVjBY8C2PGsVTKyFCa96mrB2QtIhGXwpuesgKdOESsxwosEQp1XFsfWchDn5oqBZeTE9BsU+f1LH8RiUSpb+bQsK210QhEIrHkzy7zeRTG96Hw3PPmWktb5nKuFGwuO3sZ77GylFZAWbxsBp4iGuu4MaKVgUEovG/RJPr74cgtSIloIW+0IjHb9EizPY+jXY91OW3tf11s6dP0Py7VBIqNjgMQqgKhGH8cpflzGNlGDbKglbaHK6dpQDoNaf4WPA0iA0GjPU6xJY65bk1EbG1xbO10FLO9jgiFoUTCUCJRhHp6oCmqETxGwo72Q34RCASQSCTq/jqp66VWOraWOlbLHau9Utl1qz2PrQVTJm30xG0DEQya/0ciUMwMu2L2M1XM5RqKrXG+Uvz/VLxutl2yWjSVb827CJnPQ08loaWS0JNJ6KmkMaWbMi4XisdSSejJFPTkPPSFlOub12VvhKgojjZAqr0lUPFyj3ncui1e18/ZDMttmSalhL6QQmF8P7Tx/UZGfGK/1d5Im5muPRmgqggMDZttjEotjYw2R6ugVPnbIaWEnpyHNjMFbWYa2vS08bnsQ0+lUHuDJZtAEGp/PwL9A1AHBqD2u3z09Vf2qW6DZrW+I/9hEArvWzRVPLKuY+yySxv6fjWelDFFLQQqpqlrfVddKBhZSTQ5eCzPLlrVze7ZxYqWOdW2Cqwzu1hsowMAGoxxTNin/7K5rt5qTuq6a4FLVFGwMDNdpZm3y7Fir852NXcPBt3XNIbC5t7uzmNqNIaeoSEsFArQi1nK4v2W8f+kuODE/qyRUgILKejj+51T3cVspG3q256hbHoBXSjkXnRjP1bWQgiRyKJvrKT5szpeJRaaPE1fg8VeV6WmQZ+Zhj41abUxsk+hI1P7+YpozJw2HylrbTQM0d9fscQlX8gjOzsL+eh/O4p5rGny2Vmjd6e2vLXuIt5jZCvL11729pXWXlZpHO8YN3O5VbstNo6NYoum7sYgtAVEJLaML7K9uCz3naNZcdowsxIWVu/FoLMlzqItddynsBvpa+pnxUxj+TaBy6qezmaqTis2fcekctWCxuUcW0bQqKoqegYGkK9xLaHUNMiFhcqg0Vw3WVpHaQssFxY8KMaJLb5esuxY7+goknX0dew2MptB9uk9yD61C4XxfaXWRlOT0Kcma1+PLgRE/4Cz2nxwuLTtZMx4jZZSGmNrBpP5Jx51LfKRqeTyfiA14LL2sg/x0dXIhsMQvX3G7eVbPRP5FIPQFhCRyNJ3KrecwLNadnGZLXWsKmtbAODXgpblkprmbKe05H7Tix9rWyumoC2zXNxCsyworPlYqH3brxa7NWjZDLJzM8iNjUFLzluBpF62prJ4rJ6sWU0CAVvAWOw1GXPvOVn8bBbj1EMEQ3U1F+80UkqjuMZeBGTLbMrkPKZqfbBgCMpwWQFQ8WNgEABsrYiMgFJ7ZndZkc/sspc6iVjMzFb2Q+nvNwPKfufayyrZy1giAY2vq7QCMQhtARFzyYQGgqUp52oNucunqMuzi2VFLwgwu7gUR9BoK3opBoMil8O0IrAwMwPNLN5y7D1eDBrNY20NGm3rWa0sYrFnY7hsijrsPNYzOIiFQqF0rAP7dUpdNwrR3Ka6rWMLRs9D232K7b5mmnUikWhla6AqO+MUj3ViMU67yHwe+vSkVfTjrDafrLMIqLeyMfvgEJR43FiXPleaDtfGnkP+0b9ZWc3lZy/VUkBpmw53Fvn0taQ9FJHfMAhtARGJOq+vORB9//vyNp1Nd5GaVmrknimbei4/Vh5cuhyrJcvhyVS1PWgsVkEXC5+Kx0K2oDFSdqw84GwwaAwmElBamHmR+fzS6yWtQDNZahXUzCIGRVlkvaS9ytt2PBZjF4MlFKew7ZXm9tZGcm62jiKggFlZPmStyewZHsJCLgepGcVGxR178k8+DvngA8bay2W+GRTRmK1S3J697LOymiIe78g3aUR+wCC0Bcq3UBOaf5rVl7OCxpqbeS9+rGVdAMrZ2yot1XYnZAsa3Xo6hjoz07gcUkogk1l6vWTZ9HfT+22Gwy5bKZaykWoigcSqUSxIQI9EoMTjxtgwO7ksVhFQWaBZzGzWU/wiYjGIwWFjyjoeN95YqSqElJCZrDFlPjeD/LPPIJecx7IWSiiKYzq8WpGPCDF7SdRODEJboCKT0kHbl1UGjcV9qHPmMXuQmEVe15BLJh3HOyNoDGHxtYq19G8MQ43FMDh6AGZmZ3295zhQLMaxBYzFy26Bpe1YUzcnsIpxSusmXddLlld/L1G4oaoq4gMDyPl87/hmkpmMuSazyk5AdYy76OuHkug11sMHQ8Z6dU0zXjeS89D37YX+7NPLOk8RjVbu2NNr372nz/j/5JM3fkR+xiC0DeQy23YYX2u8kCNTWsu4dLX0IoUwdW6X2bR8lmMt7GLrF2sshGnSHxxFVbvuj5e1daq1XtKWoUwtQHdcNz7PLhh9Z5sqEKwsvHFZL+kIMCPRrvt9dyup68ZOQBNmY/bJCUdro7rWTAYCRqAXjhit4KQ0diVLLxjrdGdnoM3O1HeCVvaytGNPoH8AiTUHIh0MQvYkjOwlW/IQ+QaDUHjfrB4AZoSw1kWJfA7qE4+5NvTWza0wZSYLPZs2j5UafLcr0yjM5txqJAqEQ6WG3maDb/tlZyPv4vFoqYl8B09Pt7upstR16AupUhNz87OjsXnxctI8nkrW/WZiKSIWK2tUXrqsljc1L34OdU5w0O5xbJXyTQf0XA7a5ITRlN3WnL0wMQ5tYtzYurZGVr9eoQCaBt3+prVQgJydqbl3sIjGoPb3W03U3RqsK4neitcFIYTx+pzLrahx9JuV8nyk+jEIhffN6gEY01Hmk09PJjF5+00Nfb8luWYMnYUwbsdgW99Y3IPavh95LS2aig3gXSfv8gXjo0M1s6myzOeWbA3kWEOZShnZyWa+SKuqa3/JcP8A8mbmsqLJeXTxYhzXRuYd1tTfy+bY7SSlNLoBmP0yA8l5ZJ5/zmptJOvJPgphZDEB1zcx1hKbxSiKUbFeXjXuKPLpd81eShjbAFvfOVVZEujXcSzn99Z3bFZP1TAIbRVFqb6myurvGXaZjq5lirq0H3V50EiNk1KW9u1eYr2kvdK76bsLhSMue3S7rJeM91hT4giHXYtx/P5Hr5tJTYM+PVVamzlpb200CWSbtAOOlItn0MOR0rpLl6pxpa8PwiV7SURUKwahrWJ7oQ689GWIvu70UvaRQWPLyEKhtDOOfVecYuCYXkAmn0N2ZgZ6sfo7vdD8Ypwq/SUXPRbg09UvZCbt7Jdp/5iZbu7/t3JCGNnLYlBZXuRTXJO5nE02iIjqwL9qrWILMpVoFOrIqjaeTPeTUgLZbFnjcjOwLAaVjuML0BdSNWWR6tp/Jhgsm+rucQSOFb0oY3FjuQPfdPia1HVrJyB7sKlNjEOfGG/+Dk1F4XApS+nYGtIWaPYk2PuUiDoCg9BWUUov+rLJRSTdTup61f6S9vWS5U3Om93qqrhvd7C3D3o4AlRpF+SY+uYuKSuWzOesynJ9agKF/fug790LfXrSaNDe7Ox5IlERUMZGD0A2FC5lNcs2xiAi6mQMQltEqGqpktTHQajM5WpaL1mxM04zqYHSusnyoNE61uMMLs19u1VVxcDAAKbZX3LFk1JCJpPQJsehP/cstLHnoU3shz49BTk/D+SatGd7KFS2BWSVtZcu2ct4IgGda3uJqEsxCG0VtbsyoVLXja0uy3bGmdcKSE9NuTc5X0g1fy/1SKS29ZLxOJSYEVhy326qlZ5OQ3tmD7TnnoW2b8zaZlJPJYFstuFOBca2kP1QBgah9PdXrLtU+vqBCHdyIqKViUFoi4hAoG2ZUKMYpzxodDYwN9ZWLjinu13+AC8s9yQUpWxnHPf1ks5tGGMsxqFlkbqOwuwMCs88jfy+vdDGnoM2vh9yegr6/JxRbJbPLz/IVBSj0X4iYQSYwyNQh4adRT69fVx7SUS0CP6FbxXV9qte5o5JRjFOpvoe3W5T3wspI6PTTMGQo+eka6sgt51xmO2hJpD5HPTZWcjZGeizM9BnZqCP74M2OWEcM7OYUw0EmAiFjf/LvX1QhoahrhqFcsAaqAODEH39xtaR/P9MRNQQBqFozY5JqUjYat6uSImeWAy6Wcld3AGncleceduuOMZ9m1qMIwSUWKxy95t4D9SehHM3nLixjjLU3w9d+Leye6Xs7NGJO7RIXTf+v89MV3wUpiahTU5Am51ZuoH6UgIBKNEY1EQC6uAQAqtGEVxzEILrDkFw9RoowcX3pe8knTiOzcTnoz+slHGk+jEIRWt2TNJtLXlyu57Es/90YUPfr0IgUH29ZPG42844i7QKctsZJyAUXzc55w4t3pD5PPTZGcjZWehzM6XLszPQ52at69Cb8DsXCkQshuDgEGRfH5SRUahrDoSy5kCog8MQLkGmBJADkMtkgEyTmsG3gN83HeDz0R+4YxJVwyC0RUTA1spnqXeCkegi6yXtu+X0WPdjMQ61g7WNZHF6fG7GNlVuBJxydgZyYdmrid2FI0ahz/AqKKMHIDCyCsrQMJShYYhELwLBILscEBF1OAahrRIs/apDJ/wDlP6B6plLFjNQB5CFvHPt5ewspBlklrKas8te47woISAGBo31mMOroAwNQRkyin+UwSHu5kNE5AMMQltEhEpTBuFXvArq4FAbz4ZWMikltGQS2vPPWdPh9kDTyF7OQqaS3p5IJGoElW4fff18M0ZE5HMMQltEhErT8U1vzk5kkoWCLagsTYdb2cu5Weizs5gtNLmfqxshIPr6KwPNwWEow8PGmmQuISEiWrEYhLaKLRMqM01eH0e+J6WETC84A0qXIp9lZy+FMLaWlXp9200Gg1ZQqQ6WB5uDEIHuqTQnIqLWYhDaIs5MaJP7dlJXk4UC5NycFVC6FvnMzS5/N6pg0NjjXhGQmmb0jS0PNKWsurZTJBJGoGkGl/bMpkj0MptJRETLwiC0RYStjYTMcjp+JTCyl2mXqnFnkY9MLrM1i6IYO1CFw0AgYASS+QL0TBpYSJXul89DLhbAqqqx68/QiFkAZAs2B4cd/3eJiIiahUFoiziqebuoDyG5k5pmrq+srBq3r71Efnn9Z0U0CtHbb2xdGgoBQgGkBpnNGbthzc8CmQzk/BxkDTGsiEbN4NIINGMHHoRcrAfq0AhEf/+i/WKJiIi8wCC0VcKlIFRnJrRjSSmhLSygsHcMhenJsuxlaR2mTCaXt++4okAkeqH0GXuMi56EsaWrAGS+YGzLmpw39jif2F/7DllCQPQPGOsyh402RqXM5giUWMxx9x6fN8cmIqLOxyC0RUQ4WrqS4ZrQdpCaBjk/5141bhX5zGIqt8zxiUSg9JrBZTHI7O0zMpm6DuRy0FIpyKlJ6JMTKDy1q76p+GDIDDCL6zJtgebAEESAT2ciIuoe/KuF1uwdnx4aRLEmPgjZtfsEd+oex3o67dxvfNq277j5WZ+bXXb2Uu3tg9o/UPoYKF1WehKQmgZ9bhaF8f0oTOw3Pj/yN2jj45B1TMkrvX0IjKxCYGQEgeFV5uVVCAyPQOnta1oRUKeOY7OslL2qOY7+wHGklYpBKFqzd3xBLz3xcslk106FtnzPcU2DTM5Xrxo3M5jILjN7GY5A6eszmqP39iEwMID4AWuQDYUge3qh9PUBPQkgk4Y+OQl9chyFyQnknnsW2l/+P+hTk5CzM7UHt6pqTpUPV7Y2GhyqKALSYe5pDgDJ5jWP517V/sBx9AeO4/Jx7/juxiC0RRzV8cud7vUZmcksWjWuz85Azs8tL3sphHPtpTlNrvT1W1PlSm+/VTAmNQ36zDTEzDREOoX87qegTYxDnxyHNjkJZGpfxytiMSvALG9tJPpYBERERAQwCG0ZESw17ZYNZl07ndT16msvbRXlyC6zS0A4XLH2Uum1BZd9/RA9iYptH2UmA31qAtrkBPLPPQN9cqL0MT1Ve5N2IaD0DzraGdkrz5VobOnHICIiWuEYhLaKrWhk0Z6NHU7PZKDt31cWUJZ27NHnZo3sZT277hQJAdGTKAWXFdlLM/CMRF2/3Ap+JyegPf5oKcCcmoA+MVHfbkKhsJm9dE6dK0MjUPoHWARERETUIP4lbRHH9oUdGIRKXYdMJl2qxkvT5PrcDGaW2+M0GHIGlL3Fy31mcNlv7L5Tlr2sOM98Htr+vdAnjABTMwNMfWoC+uQkUMee6KK31wgqB4egDo1AGR5GYGQVBg/dgLmCBn05gTQRERHVhEFoq9in41schMpcrqyJukuRz9xsA9nLHnM63BZQ9toum9nLWiq7pZSQCylbYGkGm+ZnWU+FuxooFQGZ7YysLScHhxxbqVpfoqoI9PZBTE/X+5sgIiKiOjAIbRFHhq+ObN1ipK5DppLOwp65yiIfmV5mc/xgsCKgjK4aRa6sonyp7GXFeZtFQPrkuFlxbgs2pybq2lFKxOJl6zJLe5uL3j4WAREREXUoBqGtJAQgJWShsORdZT5XUTVuTJXb1mHOz9W+o075qRTXXlarGu/rN7aOLMte1tpKRGbS0MyWRsXWRrrZpL2uIiBFgdI/4Aw0ba2NRNR9fSgRERF1NgahrWTu/41cDoXnnqlSNW4EmjK9sPTjuQkEF60aV3r7IXp7Gy6skbpunPPkJDQrwCxlNusqAgqHSxnMQWdWUxkYrDvTSkRERJ2PQWgrKQqgG1tHJv/vJ+v+chHvcRbzONZh9pnZy1jTdtWR+ZwRVE4V12VOIjM7jdy+vdCnJoEaMrrWuff2OabK7R8i3tO0cyYiIqLuwCC0lYIB9/WggYCxJaMje1le5NPnrLBvAimlsabU3i+zvAioVoGAmcUsFgDZWhsNDUEEK4uAiIiIaOViENpCItELmU5DPXg9Iqe8rpS9jMU9ywRKTYM+PeUMNKeKgeZkXQ3jRbwHwVWjkP39ztZGQ0MsAiIiIqK6MAhtISUUhgZA6etH8MgXNe1xZTpd1i/T9jEzXV8R0MCg1cLI2gHIzGyKSNT3exwTERFRazAIbSWzV6iss0VTqQioNFVu/5ALqdofLBxxWZc5VNoJiEVARERE1AIMQlvIqkh3KeixioCKgWYxszk5YRQBaXUUAfX1Vy8C8nDqn4iIiKhWDEJbycyE6lOTyNz7H8YU+uQE9MlxyLm52h8nEDSyl7Z+mcqQubf5wBBEsLkFTERERETNxiAUQCgUQjgcbugxitnFeDwOWWVbyWw0igIAfXICmXt/sujjKYkEAsOrEBgxP4ZHrMtKG4uAAoEAEolEW753K9Qyjn7AcfQHjqM/cBxppWIQCiCXyyGXyzX0GKqqIhQKIZVKQau2i9Ha9cCDfzQu24uArA+ztdHgMEQk4vhSHUDO/ECqjjWgTeb3wqSaxtEHOI7+wHH0B47j8jWaQKL2YhDaQqET/gGBw4+0tqJkERARERGtVAxCW0gIAXVkVbtPg4iIiKjt2F2ciIiIiFqOQSgRERERtRyDUCIiIiJqOQahRERERNRyDEKJiIiIqOUYhBIRERFRyzEIJSIiIqKWYxBKRERERC3HIJSIiIiIWo5BKBERERG1HINQIiIiImo5BqFERERE1HIMQomIiIio5RiEEhEREVHLCSmlbPdJ+MHY2Bhuv/12XHTRRVi9enW7T4eWiePoDxxHf+A4+gPHkaphJrRJxsbGsH37doyNjbX7VKgBHEd/4Dj6A8fRHziOVA2DUCIiIiJqOQahRERERNRyDEKbZPXq1bjqqqu43qXLcRz9gePoDxxHf+A4UjUsTCIiIiKilmMmlIiIiIhajkEoEREREbVcoN0n4AfJZBK33HIL/vznPyMajeLNb34z3vjGN7b7tGgR+Xwet912G/7yl79gfn4ew8PDOPvss/GKV7wCAPDud78bMzMzUBTjfdrIyAhuueWWdp4yufjsZz+L+++/H4FA6aXslltuwcjICABgfHwcN910Ex555BH09fXh7W9/O/7hH/6hXadLVZx99tmO67lcDn//93+PK6+8EgCfj53snnvuwX333Yfdu3dj06ZN2Lp1q3Xbnj17cNNNN2H37t0YHR3Fe9/7Xhx99NHW7Tt27MBXv/pVTE1N4YgjjsAHPvABrFq1qh0/BrUJg9AmuP3225HP5/GVr3wF+/fvx8c+9jEcdNBBOPbYY9t9alSFpmkYHBzEJz7xCYyOjuKRRx7Bv/7rv2J0dBRHHHEEAODyyy/nGHaBN77xjbjgggtcb/v0pz+N9evX44orrsDjjz+OT3ziE1i3bh3WrVvX4rOkxdx1113WZU3T8K53vQsnnHCC4z58PnamwcFBnH322XjooYcwPz9vHS8UCvj4xz+OU089Fddeey1+//vf49prr8Vtt92G/v5+PPPMM7jxxhtx+eWX46ijjsLXv/51XH/99fj0pz/dxp+GWo3T8Q3KZDLYsWMHzj//fMRiMaxfvx6nnnoqfvGLX7T71GgRkUgEb3vb23DAAQdACIGjjjoKRx55JB555JF2nxo1yfPPP4/HH38c559/PsLhMF7ykpfguOOOw3333dfuU6NF/PnPf0Ymk8HmzZvbfSpUg82bN2Pjxo3o7e11HP/rX/+KbDaLs846C8FgECeddBIOPvhg7NixAwDwq1/9Cscccwxe9rKXIRwO49xzz8VTTz2Fp59+uh0/BrUJM6ENeu655yCldGRWDjnkEOzcubONZ0X1ymQyePLJJ3H66adbxz772c9CSomDDz4Y5513Ho466qg2niFV8/Of/xw///nPMTw8jNNPPx2nnHIKAGMqcGRkBD09PdZ9DznkEPy///f/2nWqVIP/+q//wkknnYRwOOw4zudjd3n66aexfv16awkFALzgBS/Anj17ABjPzxe+8IXWbbFYDAcccAD27NmDgw8+uOXnS+3BILRBmUwGsVjMcSwejyOdTrfpjKheuq7js5/9LF74whfiZS97GQDgf//v/41DDz0UgPFHcfv27bjpppu4XqnDnH766bjwwgsRj8fxt7/9DZ/85CcRj8exefNmZDIZRwAK8LnZ6ebm5vDAAw/g2muvdRzn87H7pNNpxONxx7F4PI79+/cDMP52ut3O5+fKwun4BkUikYonzcLCAqLRaJvOiOohpcStt96KqakpbN26FUIIAMBRRx2FcDiMcDiM17/+9XjBC16ABx98sM1nS+UOPfRQ9Pb2QlVVvPSlL8Vpp51mTfdFIhGkUinH/fnc7Gy/+tWvsHr1ahx++OGO43w+dp9oNFrx/EulUtbzLxKJYGFhwXE7n58rD4PQBh144IEA4FjH8tRTT3E6oQtIKXHbbbfhqaeewrZt2xZ98VMUBdzXofMJIaxxWrduHcbHx5FMJq3bd+3axaKkDvZf//VfePWrX73k/fh87HwHH3ww9uzZA13XrWNPPfWU9fxbt24ddu3aZd2WTqexd+9ePj9XGAahDYpEIjjhhBPw9a9/HQsLC9izZw/uvfdea10ada7bb78djz32GLZv3+5YUjE+Po6//e1vyOfzyOfz+PnPf44nnnjCmqqnzvHb3/4WCwsL0HUd//3f/42f/OQn2LhxIwBgzZo12LBhA77xjW8gm83i4YcfxgMPPICTTz65zWdNbv7nf/4HTz/9NLZs2eI4zudjZ9M0DblcDrquQ9d15HI5FAoFvOQlL0EoFML3vvc95PN5/Pa3v8WePXusrgdbtmzBn//8Zzz00EPI5XL45je/ifXr1zOBs8Jw284mSCaTuPnmm60+oWeeeSb7hHa4/fv3493vfjeCwSBUVbWOn3XWWdi4cSM+85nPYGxsDIFAAGvXrsV5552Hl7zkJW08Y3Jz2WWXWdmWYmHSa1/7Wuv28fFxfO5zn8MjjzyC/v5+nH/++VYvWOost99+OyYmJnDFFVc4jj/99NN8Pnawb37zm7jzzjsdx04++WRccskl2L17N26++Wbs3r0bq1atwkUXXeToE/rb3/4WX/3qVzE9PY3DDz8cH/zgB7nOd4VhEEpERERELcfpeCIiIiJqOQahRERERNRyDEKJiIiIqOUYhBIRERFRyzEIJSIiIqKWYxBKRERERC3HIJSIiIiIWo5BKBERERG1HINQIiIiImo5BqFEtKI89NBD2LZtGxYWFmr+GiEEPv3pT3t4VkREKw+DUCJaUR566CFs3769riB0586deNvb3ubhWRERrTyBdp8AEVGjstksgsEgFKW576vT6TSi0Sg2btzY1MclIiJmQomozDve8Q68+MUvxq9+9Su87GUvQzwex3HHHYcHH3wQALB7924IIfDd737X8XWXXHIJ1q9fb12/4447IITAn/70J5x66qmIxWI4/PDD8Z//+Z/QdR1XXnklRkdHMTo6issvvxy6rtd8juvXr8c///M/4/rrr8e6desQjUYxNTVlfd+XvvSliEQiOPDAA3HFFVdA0zTrtne+850AgJGREQghrHMunu/OnTtxyimnIB6PY+vWrQDcp+N/8pOf4Pjjj0c0GsXIyAje9773IZVKWbfn83ls3boVBx98MMLhMFavXo3TTz8ds7OzNf+cRER+xiCUiCrs3bsXH/jAB7B161bcddddyGQyePOb34x8Pl/3Y7397W/HG97wBnz/+9/HmjVrcOaZZ+KDH/wgnnnmGXzta1/DxRdfjOuuuw533nlnXY97991345577sGNN96IH/7wh4jH47jhhhvw7ne/G695zWvw4x//GB/5yEfwuc99DldccQUA4LTTTsOVV14JAPjZz36GnTt34vvf/77jcc8991ycfPLJuOeee3D++ee7fu/vfve7OOOMM/CSl7wE3//+93H99dfje9/7Ht71rndZ97n22mtx22234bLLLsO9996Lm2++GWvWrEE2m63r5yQi8i1JRGRzwQUXSCGEfPjhh61jv/zlLyUA+Zvf/EY+9dRTEoD8zne+4/i6D37wg3LdunXW9a985SsSgLz11lutY3/9618lALlx40bH1x577LHyTW96U83nuG7dOjk0NCSTyaR1bG5uTvb09MjLL7/ccd/Pf/7zMhqNyomJCcd5jY+PO+5XPH7ddddVfD8A8lOf+pSUUkpd1+W6devkOeec47jPf/zHfzh+b6eddpo888wza/6ZiIhWGmZCiajCmjVr8KIXvci6ftRRRwEAnn322bof65RTTrEuH3bYYQCAV73qVY77HHbYYXjmmWfqetwtW7YgHo9b13/3u98hmUziH//xH1EoFKyPV7/61Uin03j44YdretzTTjtt0dsff/xx7NmzB2effbbj+7ziFa+Aoij405/+BAA45phj8NOf/hTbtm3DH//4x7qWGxARrQQsTCKiCv39/Y7roVAIAJDJZBp6rOLjuD1+vY89OjrquD4xMQHACP7c1Brklj9uueL3efOb37zo97niiiugKAq++tWvYvv27RgZGcHFF1+M//N//g+EEDWdCxGRnzEIJaK6RCIRAEAul3Mcn56ebul5lAdyg4ODAIDvfe97WLt2bcX9DznkkGU9brni97n55ptx/PHHV9y+Zs0aAEA4HMa2bduwbds2PPnkk/jyl7+Mbdu24QUveEHVtaZERCsJg1AiqsuqVasQDAbxyCOPWMdyuRx+/etft/GsgE2bNiEWi+HZZ5+tmqUEGsvqAsARRxyBgw46CLt27cLFF19c09ds2LAB11xzDW6//XbH742IaCVjEEpEdVEUBWeeeSZuvvlmbNiwAcPDw7j55pshpWzrNHN/fz/+9V//FR/+8Ifx7LPPYsuWLVBVFbt27cIPf/hD3H333YjFYjjyyCMBALfccgve9KY3IRaL4SUveUnN30cIgRtuuAHnnnsuUqkUTjvtNMTjcezZswc/+clPcM011+Cwww7Dm970Jhx77LFWm6sf//jHmJ6exsknn+zVr4CIqKswCCWiut10001473vfiw984ANIJBLYunUrDj/8cPzgBz9o63n9y7/8Cw488EDccMMNuOmmmxAMBnHooYfiDW94g5UBfdnLXoZt27bhi1/8Iq6//nqsXbsWu3fvruv7/OM//iP6+/tx9dVX4xvf+AYAo3fpa1/7WmtN6QknnIC77roLn/nMZ1AoFHD44Yfj3//93/HqV7+6qT8zEVG3ElJK2e6TICIiIqKVhS2aiIiIiKjlOB1PRB2lUChUvU0IAVVVW3g2RETkFU7HE1FHWay4ad26dXWv3yQios7ETCgRdZQ//vGPVW8Lh8MtPBMiIvISM6FERERE1HIsTCIiIiKilmMQSkREREQtxyCUiIiIiFqOQSgRERERtRyDUCIiIiJqOQahRERERNRyDEKJiIiIqOX+f1QivOdQGx3fAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = ggplot(vendor_results_df) +\\\n", + " geom_line(aes(x='retries', y='fraction', group='vendor', color='color'), size=1) +\\\n", + " scale_y_log10() +\\\n", + " xlab('num_retries')\n", + "\n", + "plt.save('traces_vs_uniform-uniform_workload.png', dpi=300)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = np.linspace(-np.pi, np.pi, 24*3)\n", + "y = np.tile(np.sin(x) + 1, 365) / 2\n", + "\n", + "ggplot()+\\\n", + " geom_line(aes(x=range(len(y))[:10000], y=y[:10000]))" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.17453292519943295" + ] + }, + "execution_count": 128, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2*np.pi / (12)" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/datasets/Talluri2021/5.analyze experiment results.ipynb b/datasets/Talluri2021/5.analyze experiment results.ipynb new file mode 100644 index 0000000..e071db7 --- /dev/null +++ b/datasets/Talluri2021/5.analyze experiment results.ipynb @@ -0,0 +1,115 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from plotnine import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# results_df = pd.read_csv('structures_experiment_results_1.csv')\n", + "results_df = pd.read_csv('./experiment_results/long_chain_results_sin1.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "results_df['cat_retries'] = pd.Categorical(results_df['retries']).rename_categories({100: 'Fail'})\n", + "# results_df['fraction'] = results_df['reqs'] / (365*24*60*60)\n", + "results_df['fraction'] = results_df['reqs'] / (365*24*60*60/2) # For sin stuff\n", + "min_max_per_exp = results_df.groupby(['vendor', 'experiment', 'cat_retries'])['fraction'].agg(['min', 'max', 'mean']).reset_index().fillna(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:719: PlotnineWarning: Saving 6.4 x 4.8 in image.\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:722: PlotnineWarning: Filename: deep chain comparison.png\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/pandas/core/series.py:726: RuntimeWarning: divide by zero encountered in log10\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:719: PlotnineWarning: Saving 6.4 x 4.8 in image.\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:722: PlotnineWarning: Filename: deep chain comparison.pdf\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/pandas/core/series.py:726: RuntimeWarning: divide by zero encountered in log10\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/pandas/core/series.py:726: RuntimeWarning: divide by zero encountered in log10\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "experiment = 'deep chain'\n", + "specific_min_max = min_max_per_exp[(min_max_per_exp['experiment'] == experiment)]\n", + "plt = ggplot(specific_min_max) +\\\n", + " theme_light(base_size=12, base_family='sans-serif') +\\\n", + " theme(text=element_text(size=12), legend_position=(0.3, 0.25)) +\\\n", + " geom_point(aes(x='cat_retries', y='mean', color='vendor', group='vendor'), size=3, shape='s') +\\\n", + " scale_y_log10(limits=[1, 1e-8], breaks = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001, 0.4e-8],\n", + " labels=['10%', '1%', '0.1%', '$10^{-2}$%', '$10^{-3}$%', '$10^{-4}$%', '$10^{-5}$%', '0']) +\\\n", + " guides(color=guide_legend(title='Workload'), fill=guide_legend(title='Workload')) +\\\n", + " scale_color_discrete(labels=['Instagram trace', 'Constant']) +\\\n", + " xlab('Number of retries')+\\\n", + " ylab('Fraction of requests')\n", + "\n", + "plt.save(f'{experiment} comparison.png', dpi=300)\n", + "plt.save(f'{experiment} comparison.pdf')\n", + "plt" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/datasets/Talluri2021/Dockerfile b/datasets/Talluri2021/Dockerfile new file mode 100644 index 0000000..f13c99a --- /dev/null +++ b/datasets/Talluri2021/Dockerfile @@ -0,0 +1,22 @@ +FROM python:3.8 + +RUN apt-get update && \ + apt-get install -y libjemalloc-dev libboost-dev \ + libboost-filesystem-dev \ + libboost-system-dev \ + libboost-regex-dev \ + python-dev \ + autoconf \ + flex \ + bison \ + cmake + +ADD ./ $HOME/jupyter/ + +WORKDIR $HOME/jupyter + +RUN pip install -r requirements.txt + +EXPOSE 8888 + +ENTRYPOINT ["jupyter","lab","--no-browser","--ip=0.0.0.0","--allow-root","--NotebookApp.token=''","--NotebookApp.password=''"] \ No newline at end of file diff --git a/datasets/Talluri2021/README.md b/datasets/Talluri2021/README.md new file mode 100644 index 0000000..7f3b862 --- /dev/null +++ b/datasets/Talluri2021/README.md @@ -0,0 +1,27 @@ +## Characterization of OutageReport for years 2019 and 2020 + +This repository contains two datasets extracted from OutageReport webpages in 2019 and 2020. One dataset of total reported failures and another of failure with detailed information. + +The datasets are in the Parquet file format. + +The Jupyter Notebook files read the datasets, clean them, and generate plots and numbers for characterization. + +All the plots used in the paper can be generated by running the jupyter notebooks in order. The plots can also ve viewed in the notebooks themselves. + +The easiest way to run the notebooks is to use the prebuilt docker container using the command `docker run --rm -p 8888:8888 sacheendra/or_char`. + +To reproduce the graphs in the paper: +1. Start the docker container. (If you are using Docker for Mac or Windows, you might need to expose port 8888 between docker vm and host) +2. Navigate to localhost:8888 in your browser. +3. On the webpage, you should see a list of files in a pane on the left. +4. The code to reproduce the graphs in in Jupyter notebooks. Jupyter notebooks have the extension `.ipynb`. +5. The noteboks to produce the plots in the paper are numbered from 1 to 5. +6. To run a notebook, first open it by double clicking it. +7. The code in the notebook can then be run by opening the `Run` dropdown at top-left, and clicking on the `Run all cells` option. + +Figure to notebook reference: +Figure 1 - Notebook 1 +Table 2 - Notebook 2 +Figure 2 - Notebook 3 +Figure 3 - Notebook 2 +Figure 4 - Experiment in Notebook 4, Plot in Notebook 5 \ No newline at end of file diff --git a/datasets/Talluri2021/artifact_documentation.txt b/datasets/Talluri2021/artifact_documentation.txt new file mode 100644 index 0000000..c95f1ff --- /dev/null +++ b/datasets/Talluri2021/artifact_documentation.txt @@ -0,0 +1,23 @@ +System Requirements: +Linux (Port forwarding confirmed to work on Linux) +Docker >= 20.0 + +The artifact is a docker container that can be pulled from Docker Hub using the command `docker pull sacheendra/or_char`. + +The container can then be started using `docker run --rm -p 8888:8888 sacheendra/or_char`. + +To reproduce the graphs in the paper: +1. Start the docker container. (If you are using Docker for Mac or Windows, you might need to expose port 8888 between docker vm and host) +2. Navigate to localhost:8888 in your browser. +3. On the webpage, you should see a list of files in a pane on the left. +4. The code to reproduce the graphs in in Jupyter notebooks. Jupyter notebooks have the extension `.ipynb`. +5. The noteboks to produce the plots in the paper are numbered from 1 to 5. +6. To run a notebook, first open it by double clicking it. +7. The code in the notebook can then be run by opening the `Run` dropdown at top-left, and clicking on the `Run all cells` option. + +Figure to notebook reference: +Figure 1 - Notebook 1 +Table 2 - Notebook 2 +Figure 2 - Notebook 3 +Figure 3 - Notebook 2 +Figure 4 - Experiment in Notebook 4, Plot in Notebook 5 \ No newline at end of file diff --git a/datasets/Talluri2021/deep chain comparison.pdf b/datasets/Talluri2021/deep chain comparison.pdf new file mode 100644 index 0000000..80c73f4 Binary files /dev/null and b/datasets/Talluri2021/deep chain comparison.pdf differ diff --git a/datasets/Talluri2021/deep chain comparison.png b/datasets/Talluri2021/deep chain comparison.png new file mode 100644 index 0000000..084a34c Binary files /dev/null and b/datasets/Talluri2021/deep chain comparison.png differ diff --git a/datasets/Talluri2021/experiment_results/long_chain_results_sin1.csv b/datasets/Talluri2021/experiment_results/long_chain_results_sin1.csv new file mode 100644 index 0000000..e3400c9 --- /dev/null +++ b/datasets/Talluri2021/experiment_results/long_chain_results_sin1.csv @@ -0,0 +1,13 @@ +,vendor,reqs,retries,iteration,experiment +0,uniform,14994946.0,0,0,deep chain +1,uniform,750141.0,1,0,deep chain +2,uniform,22399.0,2,0,deep chain +3,uniform,487.0,3,0,deep chain +4,uniform,11.0,4,0,deep chain +5,uniform,1.0,5,0,deep chain +6,uniform,16.08635843986316,100,0,deep chain +0,instagram,15658817.0,0,0,deep chain +1,instagram,105242.0,1,0,deep chain +2,instagram,1953.0,2,0,deep chain +3,instagram,332.0,3,0,deep chain +4,instagram,1656.6848523635356,100,0,deep chain diff --git a/datasets/Talluri2021/github-global-status.html b/datasets/Talluri2021/github-global-status.html new file mode 100644 index 0000000..861efdf --- /dev/null +++ b/datasets/Talluri2021/github-global-status.html @@ -0,0 +1,2881 @@ + + + + + + + + + + GitHub Status + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ + + + + +
+ + + + + + + +
+ + + + +
+ + +
+ + +
+
+ + All Systems Operational + + +
+ + + +
+ +
+ Uptime over the past 90 days. View historical uptime. +
+
+
+ +
+ + + Git Operations + + + ? + + + Operational + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ 90 days ago +
+
+
+ + 99.97 + + % uptime +
+
+
Today
+
+ +
+ +
+ +
+
+ +
+ + + API Requests + + + ? + + + Operational + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ 90 days ago +
+
+
+ + 99.97 + + % uptime +
+
+
Today
+
+ +
+ +
+ +
+
+ +
+ + + Webhooks + + + ? + + + Operational + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ 90 days ago +
+
+
+ + 99.96 + + % uptime +
+
+
Today
+
+ +
+ +
+ +
+
+ +
+ + + Visit www.githubstatus.com for more information + + + + + Operational + + + + +
+ +
+
+ +
+ + + Issues, PRs, Projects + + + ? + + + Operational + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ 90 days ago +
+
+
+ + 99.97 + + % uptime +
+
+
Today
+
+ +
+ +
+ +
+
+ +
+ + + GitHub Actions + + + ? + + + Operational + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ 90 days ago +
+
+
+ + 99.89 + + % uptime +
+
+
Today
+
+ +
+ +
+ +
+
+ +
+ + + GitHub Packages + + + ? + + + Operational + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ 90 days ago +
+
+
+ + 100.0 + + % uptime +
+
+
Today
+
+ +
+ +
+ +
+
+ +
+ + + GitHub Pages + + + ? + + + Operational + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ 90 days ago +
+
+
+ + 99.97 + + % uptime +
+
+
Today
+
+ +
+ +
+ +
+
+ +
+ + + Other + + + ? + + + Operational + + + + +
+ +
+
+
+
+ + Operational +
+
+ + Degraded Performance +
+
+ + Partial Outage +
+
+
+ + Major Outage +
+
+ + Maintenance +
+
+ +
+ + + +
+
+
+
+
+
+
+
+ +
+
+
+
+ + + Major outage + + + +
+
+ + + Partial outage + + + +
+
+ No downtime recorded on this day. +
+
+ + + had a major outage +
+
+ + + had a partial outage +
+
+
+ + +
+
+

No incidents or maintenance related to this downtime.

+
+
+
+
+ + + + + + + + + + +
+ Past Incidents + +
+
Dec 31, 2019
+

No incidents reported today.

+
+ + +
+
Dec 30, 2019
+

No incidents reported.

+
+ + +
+
Dec 29, 2019
+

No incidents reported.

+
+ + +
+
Dec 28, 2019
+

No incidents reported.

+
+ + +
+
Dec 27, 2019
+

No incidents reported.

+
+ + +
+
Dec 26, 2019
+

No incidents reported.

+
+ + +
+
Dec 25, 2019
+

No incidents reported.

+
+ + +
+
Dec 24, 2019
+

No incidents reported.

+
+ + +
+
Dec 23, 2019
+

No incidents reported.

+
+ + +
+
Dec 22, 2019
+

No incidents reported.

+
+ + +
+
Dec 21, 2019
+

No incidents reported.

+
+ + +
+
Dec 20, 2019
+

No incidents reported.

+
+ + +
+
Dec 19, 2019
+
+
+ Incident on 2019-12-19 22:49 UTC +
+ +
+ + + +
+ Resolved - + This incident has been resolved. + +
+ + + Dec 19, 23:12 UTC + +
+
+ Investigating - + Delays in Webhooks and Notifications are currently being investigated. + +
+ + + Dec 19, 22:49 UTC + +
+
+ +
+ +
+ + +
+
Dec 18, 2019
+

No incidents reported.

+
+ + +
+
Dec 17, 2019
+

No incidents reported.

+
+ +
+ + +
+ ← Incident History + + Powered by Statuspage +
+
+ +
+ + + +
+ + +
+ + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/datasets/Talluri2021/github_failures_2019-20/_common_metadata b/datasets/Talluri2021/github_failures_2019-20/_common_metadata new file mode 100644 index 0000000..75756ba Binary files /dev/null and b/datasets/Talluri2021/github_failures_2019-20/_common_metadata differ diff --git a/datasets/Talluri2021/github_failures_2019-20/_metadata b/datasets/Talluri2021/github_failures_2019-20/_metadata new file mode 100644 index 0000000..4950f58 Binary files /dev/null and b/datasets/Talluri2021/github_failures_2019-20/_metadata differ diff --git a/datasets/Talluri2021/github_failures_2019-20/part.0.parquet b/datasets/Talluri2021/github_failures_2019-20/part.0.parquet new file mode 100644 index 0000000..9b56db4 Binary files /dev/null and b/datasets/Talluri2021/github_failures_2019-20/part.0.parquet differ diff --git a/datasets/Talluri2021/github_parser.ipynb b/datasets/Talluri2021/github_parser.ipynb new file mode 100644 index 0000000..ef4ba79 --- /dev/null +++ b/datasets/Talluri2021/github_parser.ipynb @@ -0,0 +1,726 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from bs4 import BeautifulSoup\n", + "import bs4\n", + "from dateutil.parser import parse as parse_date\n", + "import numpy as np\n", + "from datetime import datetime\n", + "import re\n", + "import json" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "datetime.datetime(2018, 12, 19, 22, 49, tzinfo=tzutc())" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pdate = parse_date(\"Incident on 2019-12-19 22:49 UTC\".split(\"on\")[1])\n", + "pdate.replace(year=2018)" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'event_start_time': 1576795740,\n", + " 'event_end_time': 1576797120,\n", + " 'status': 'minor'}]" + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Parser for github status till september 2, 2020\n", + "# https://github.blog/2020-09-02-github-availability-report-august-2020/\n", + "\n", + "def get_incident_year(incident_title):\n", + " try:\n", + " current_node = incident_title.parent.previous_sibling\n", + " while type(current_node) != bs4.element.Tag or current_node.find(attrs={'data-var':'year'}) == None:\n", + " current_node = current_node.previous_sibling\n", + " return int(current_node.find(attrs={'data-var':'year'}).get_text())\n", + " except:\n", + " print(incident_title.parent.previous_sibling.previous_sibling)\n", + " raise\n", + "\n", + "def get_incident_type(incident_title):\n", + " classes = incident_title.attrs['class']\n", + " if 'impact-minor' in classes:\n", + " return 'minor'\n", + " elif 'impact-none' in classes:\n", + " return 'minor'\n", + " elif 'impact-major' in classes:\n", + " return 'major'\n", + " elif 'impact-critical' in classes:\n", + " return 'critical'\n", + " elif 'impact-maintenance' in classes:\n", + " return 'maintenance'\n", + " else:\n", + " raise Exception('Unknown impact class: ' + str(incident_title))\n", + " \n", + "def get_maintenance_incident_details(incident_update):\n", + " raise Exception('Unimplemented. Implement when we encounter one')\n", + " \n", + "def get_normal_incident_details(incident_updates, year):\n", + " try:\n", + " problem = False\n", + " investigating_divs = incident_updates.select('.investigating')\n", + " if len(investigating_divs) == 1:\n", + " incident_start_time_str = investigating_divs[0].select('small')[0].get_text().strip()\n", + " incident_start_time = parse_date(incident_start_time_str).replace(year=year).timestamp()\n", + " else:\n", + " incident_start_time = -1\n", + " problem = True\n", + "\n", + " incident_end_time_str = incident_updates.select('.resolved')[0].select('small')[0].get_text().strip()\n", + " incident_end_time = parse_date(incident_end_time_str).replace(year=year).timestamp()\n", + "\n", + " ret_data = {\n", + " 'event_start_time': np.int64(incident_start_time),\n", + " 'event_end_time': np.int64(incident_end_time)\n", + " }\n", + " \n", + " if problem:\n", + " ret_data['status'] = incident_updates.get_text()\n", + " \n", + " return ret_data\n", + " \n", + " except:\n", + " print(incident_updates)\n", + " raise\n", + "\n", + "def process_github_page(file_obj, metadata):\n", + " status_data = BeautifulSoup(file_obj.read(), 'lxml')\n", + " \n", + " incident_types = ['impact-minor', 'impact-none', 'impact-major', 'impact-critical', 'impact-maintenance']\n", + "\n", + " incidents_titles = status_data.findAll(attrs={'class': lambda x: x and 'incident-title' in x and any(incident_type in x for incident_type in incident_types)})\n", + " incidents_updates = status_data.select('.updates-container')\n", + " if len(incidents_titles) != len(incidents_updates):\n", + " raise Exception('Number of titles does not match number of updates containers: ' + metadata['date'])\n", + " \n", + " extracted_incident_info = []\n", + " for i in range(len(incidents_titles)):\n", + " incident_type = get_incident_type(incidents_titles[i])\n", + " incident_year = get_incident_year(incidents_titles[i])\n", + "\n", + " incident_details = None\n", + " if incident_type == 'maintenance':\n", + " incident_details = get_maintenance_incident_details(incidents_updates[i])\n", + " else:\n", + " incident_details = get_normal_incident_details(incidents_updates[i], incident_year)\n", + "\n", + " # Using incident field for error if required\n", + " if 'status' not in incident_details:\n", + " incident_details['status'] = incident_type\n", + "\n", + " extracted_incident_info.append(incident_details)\n", + "\n", + " return extracted_incident_info\n", + "\n", + "status_data = None\n", + "with open('github-global-status.html') as f:\n", + " status_data = process_github_page(f, {})\n", + "status_data" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'event_start_time': 1576795740,\n", + " 'event_end_time': 1576797120,\n", + " 'status': 'minor'}]" + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "status_data = None\n", + "with open('github-global-status.html') as f:\n", + " status_data = process_github_page(f, {})\n", + "status_data" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['', 'github-status', '2020', '11', '20201107', 'zip']" + ] + }, + "execution_count": 125, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import re\n", + "re.compile('[./]').split(\"/github-status/2020/11/20201107.zip\")" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def extract_individual_reports(file_obj):\n", + " html = str(file_obj.read())\n", + " if html is None:\n", + " raise ValueError(f'ERROR: HTML IS NONE \\n filename {filename} \\t file_obj {file_obj} ')\n", + " \n", + " # Get list of reasons\n", + " matches = re.search('\"outage_subjects\":(.*?)],\"', html)\n", + " list_of_reasons = json.loads(matches.group(1) + ']')\n", + " map_of_reasons = {}\n", + " for reason in list_of_reasons:\n", + " map_of_reasons[reason['_id']] = reason['name']\n", + "\n", + " matches = re.search('\"recentReports\":(.*?)],\"_', html)\n", + " reports = []\n", + " if matches is not None:\n", + " # The data is in embedded javascript. Remove constructors to make it JSON\n", + " # We used the closing brackets in the regex and don't capture them, adding them back again\n", + " sanitized_match = re.sub(r'new Date\\(\".+?\"\\)', '\"\"', matches.group(1)) + ']'\n", + " reports = json.loads(sanitized_match)\n", + "\n", + " \n", + " report_id = []\n", + " report_country = []\n", + " report_reason = []\n", + " for datapoint in reports:\n", + " try:\n", + " report_id.append(datapoint['_id'])\n", + " \n", + " if 'country_code' in datapoint:\n", + " report_country.append(datapoint['country_code'])\n", + " elif 'countryCode' in datapoint:\n", + " report_country.append(datapoint['countryCode'])\n", + " else:\n", + " raise Exception('Country code not found')\n", + " \n", + " if 'oSubjectId' in datapoint:\n", + " report_reason.append(map_of_reasons[datapoint['oSubjectId']])\n", + " else:\n", + " reason_found = False\n", + " for name, value in datapoint.items():\n", + " if 'subject' in name or 'Subject' in name:\n", + " report_reason.append(map_of_reasons[datapoint[name]])\n", + " reason_found = True\n", + " if not reason_found:\n", + " report_reason.append('Unknown')\n", + " except:\n", + " print(datapoint)\n", + " raise\n", + "\n", + " return pd.DataFrame({\n", + " 'id': report_id,\n", + " 'country':report_country,\n", + " 'reason': report_reason\n", + " })" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idcountryreason
05fc3c224dcd8580a7973cd8cRUCan't login
15fc3c11dfb995a344b9b68efTRNewsfeed
25fc3bef2fb995a344b9b68edKZMobile app crashes
35fc3bb19ae91e3734cd1777bUSCan't upload pics
45fc3b738dcd8580a7973cd80GRWebsite down
55fc3b66bd4d3565ae19b14b5RUMobile app not working
\n", + "
" + ], + "text/plain": [ + " id country reason\n", + "0 5fc3c224dcd8580a7973cd8c RU Can't login\n", + "1 5fc3c11dfb995a344b9b68ef TR Newsfeed\n", + "2 5fc3bef2fb995a344b9b68ed KZ Mobile app crashes\n", + "3 5fc3bb19ae91e3734cd1777b US Can't upload pics\n", + "4 5fc3b738dcd8580a7973cd80 GR Website down\n", + "5 5fc3b66bd4d3565ae19b14b5 RU Mobile app not working" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "status_data = None\n", + "with open('outage_report_instagram.html') as f:\n", + " status_data = extract_individual_reports(f)\n", + "status_data" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'_id': '5a8cb07dee5285d43965f834', 'name': 'Website down'},\n", + " {'_id': '5a8cb06fee5285403b65f834', 'name': 'Mobile app not working'},\n", + " {'_id': '5a8cb06fee5285403b65f835', 'name': 'Mobile app crashes'},\n", + " {'_id': '5a8d3803ee52858b2065f837', 'name': 'Message read problems'},\n", + " {'_id': '5a8d3803ee52858b2065f838', 'name': 'Message send problems'},\n", + " {'_id': '5a8f0b78ee5285e04e16fca8', 'name': \"Can't login\"},\n", + " {'_id': '5a9bdbea1b4314600050c082', 'name': 'Everything is down'},\n", + " {'_id': '5a8f18e4ee5285ad7116fca7', 'name': \"Can't upload pics\"},\n", + " {'_id': '5a912a4eee5285b07a16fcad', 'name': 'Hashtags not working'},\n", + " {'_id': '5a91ab48ee5285e14216fca8', 'name': 'Newsfeed'}]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reports_obj" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'_id': '5fc3c224dcd8580a7973cd8c',\n", + " 'serviceId': '5458ac234488de92aa9cda3a',\n", + " 'ip': '178.67.193.121',\n", + " 'oSubjectId': '5a8f0b78ee5285e04e16fca8',\n", + " 'isAmp': True,\n", + " 'uaHash': '38c958b1452dc5eda97de8e89acdfcba',\n", + " 'langCode': 'ru',\n", + " 'latitude': 68.9792,\n", + " 'longitude': 33.0925,\n", + " 'cityGeonameId': 524305,\n", + " 'cityName': 'Murmansk',\n", + " 'divisionCode': '49',\n", + " 'divisionGeonameId': 524304,\n", + " 'countryCode': 'RU',\n", + " 'countryGeonameId': 2017370,\n", + " 'continentCode': 'EU',\n", + " 'continentGeonameId': 6255148,\n", + " 'postalCode': '183006',\n", + " 'time': '',\n", + " '__v': 0,\n", + " 'countryGeoname': {'_id': '5c883341232cdab94da82765',\n", + " 'geoname_id': 2017370,\n", + " 'name': 'Russian Federation',\n", + " 'latitude': 60,\n", + " 'longitude': 100,\n", + " 'feature_code': 'PCLI',\n", + " 'country_code': 'RU',\n", + " 'admin1_code': '00',\n", + " 'center': [60, 100],\n", + " 'alt_names': {'de': {'_id': '5c848dee3e5a333eadaa4547',\n", + " 'alt_geoname_id': 2419059,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'de',\n", + " 'is_preferred_name': True,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Russland'},\n", + " 'en': {'_id': '5c848dee3e5a333eadaa450c',\n", + " 'alt_geoname_id': 1556487,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'en',\n", + " 'is_preferred_name': True,\n", + " 'is_short_name': True,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Russia'},\n", + " 'es': {'_id': '5c848dee3e5a333eadaa450e',\n", + " 'alt_geoname_id': 1556489,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'es',\n", + " 'is_preferred_name': True,\n", + " 'is_short_name': True,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Rusia'},\n", + " 'fr': {'_id': '5c848dee3e5a333eadaa4514',\n", + " 'alt_geoname_id': 1556495,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'fr',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Russie'},\n", + " 'it': {'_id': '5c848dee3e5a333eadaa454c',\n", + " 'alt_geoname_id': 2419064,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'it',\n", + " 'is_preferred_name': True,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Russia'},\n", + " 'nl': {'_id': '5c848dee3e5a333eadaa454f',\n", + " 'alt_geoname_id': 2419067,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'nl',\n", + " 'is_preferred_name': True,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Rusland'},\n", + " 'pt': {'_id': '5c848dee3e5a333eadaa452e',\n", + " 'alt_geoname_id': 1556521,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'pt',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Rússia'},\n", + " 'ru': {'_id': '5c848dee3e5a333eadaa4530',\n", + " 'alt_geoname_id': 1556523,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'ru',\n", + " 'is_preferred_name': True,\n", + " 'is_short_name': True,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Россия'},\n", + " 'uk': {'_id': '5c848dee3e5a333eadaa4556',\n", + " 'alt_geoname_id': 2419074,\n", + " 'geoname_id': 2017370,\n", + " 'lang_code': 'uk',\n", + " 'is_preferred_name': True,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Російська Федерація'}},\n", + " 'id': '5c883341232cdab94da82765'},\n", + " 'divisionGeoname': {'_id': '5c88333b232cdab94da5fb00',\n", + " 'geoname_id': 524304,\n", + " 'name': 'Murmanskaya Oblast’',\n", + " 'latitude': 68,\n", + " 'longitude': 34,\n", + " 'feature_code': 'ADM1',\n", + " 'country_code': 'RU',\n", + " 'admin1_code': '49',\n", + " 'center': [68, 34],\n", + " 'alt_names': {'de': {'_id': '5c848bae3e5a333eada3646d',\n", + " 'alt_geoname_id': 13287290,\n", + " 'geoname_id': 524304,\n", + " 'lang_code': 'de',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': True,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Murmansk'},\n", + " 'en': {'_id': '5c848bae3e5a333eada36468',\n", + " 'alt_geoname_id': 5463404,\n", + " 'geoname_id': 524304,\n", + " 'lang_code': 'en',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': True,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Murmansk'},\n", + " 'fr': {'_id': '5c848bae3e5a333eada3646b',\n", + " 'alt_geoname_id': 11761698,\n", + " 'geoname_id': 524304,\n", + " 'lang_code': 'fr',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Oblast de Mourmansk'},\n", + " 'it': {'_id': '5c848bae3e5a333eada36452',\n", + " 'alt_geoname_id': 1986257,\n", + " 'geoname_id': 524304,\n", + " 'lang_code': 'it',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': \"Oblast' di Murmansk\"},\n", + " 'nl': {'_id': '5c848bae3e5a333eada36455',\n", + " 'alt_geoname_id': 1986260,\n", + " 'geoname_id': 524304,\n", + " 'lang_code': 'nl',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Oblast Moermansk'},\n", + " 'pt': {'_id': '5c848bae3e5a333eada36459',\n", + " 'alt_geoname_id': 1986264,\n", + " 'geoname_id': 524304,\n", + " 'lang_code': 'pt',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Oblast de Murmansk'},\n", + " 'ru': {'_id': '5c848bae3e5a333eada3645c',\n", + " 'alt_geoname_id': 1986267,\n", + " 'geoname_id': 524304,\n", + " 'lang_code': 'ru',\n", + " 'is_preferred_name': True,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Мурманская область'}},\n", + " 'id': '5c88333b232cdab94da5fb00'},\n", + " 'cityGeoname': {'_id': '5c88333b232cdab94da5fb01',\n", + " 'geoname_id': 524305,\n", + " 'name': 'Murmansk',\n", + " 'latitude': 68.97917,\n", + " 'longitude': 33.09251,\n", + " 'feature_code': 'PPLA',\n", + " 'country_code': 'RU',\n", + " 'admin1_code': '49',\n", + " 'center': [68.97917, 33.09251],\n", + " 'alt_names': {'de': {'_id': '5c848bae3e5a333eada36470',\n", + " 'alt_geoname_id': 1603034,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'de',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Murmansk'},\n", + " 'en': {'_id': '5c848bae3e5a333eada364a6',\n", + " 'alt_geoname_id': 13358809,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'en',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': True,\n", + " '__v': 0,\n", + " 'name': 'Romanov'},\n", + " 'es': {'_id': '5c848bae3e5a333eada36472',\n", + " 'alt_geoname_id': 1603036,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'es',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Múrmansk'},\n", + " 'fr': {'_id': '5c848bae3e5a333eada36477',\n", + " 'alt_geoname_id': 1603041,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'fr',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Mourmansk'},\n", + " 'it': {'_id': '5c848bae3e5a333eada36479',\n", + " 'alt_geoname_id': 1603043,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'it',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Murmansk'},\n", + " 'nl': {'_id': '5c848bae3e5a333eada3647c',\n", + " 'alt_geoname_id': 1603046,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'nl',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Moermansk'},\n", + " 'pt': {'_id': '5c848bae3e5a333eada3648b',\n", + " 'alt_geoname_id': 1898338,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'pt',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Murmansk'},\n", + " 'ru': {'_id': '5c848bae3e5a333eada36491',\n", + " 'alt_geoname_id': 6004150,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'ru',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Мурманск'},\n", + " 'uk': {'_id': '5c848bae3e5a333eada3649d',\n", + " 'alt_geoname_id': 8191448,\n", + " 'geoname_id': 524305,\n", + " 'lang_code': 'uk',\n", + " 'is_preferred_name': False,\n", + " 'is_short_name': False,\n", + " 'is_colloquial': False,\n", + " 'is_historic': False,\n", + " '__v': 0,\n", + " 'name': 'Мурманськ'}},\n", + " 'id': '5c88333b232cdab94da5fb01'},\n", + " 'id': '5fc3c224dcd8580a7973cd8c'}" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reports_obj[0]" + ] + } + ], + "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 +} diff --git a/datasets/Talluri2021/monolith comparison.png b/datasets/Talluri2021/monolith comparison.png new file mode 100644 index 0000000..3b92c7e Binary files /dev/null and b/datasets/Talluri2021/monolith comparison.png differ diff --git a/datasets/Talluri2021/other notebooks/4.failures from reports.ipynb b/datasets/Talluri2021/other notebooks/4.failures from reports.ipynb new file mode 100644 index 0000000..45248a6 --- /dev/null +++ b/datasets/Talluri2021/other notebooks/4.failures from reports.ipynb @@ -0,0 +1,1920 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from plotnine import *\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "or_events = pd.read_parquet('./outage_report_2019-20')" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_events = or_events[(or_events['vendor'] != '') & (or_events['vendor'] != 'overview')].reset_index(drop=True)\n", + "filtered_or_events.loc[filtered_or_events['status_code'] <= 2, 'status_code'] = 0\n", + "filtered_or_events = filtered_or_events.drop_duplicates(subset=['vendor', 'event_time', 'status_code'])\n", + "filtered_or_events = filtered_or_events.groupby(['vendor', 'event_time'])['status_code'].max().reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_events['evtime'] = pd.to_datetime(filtered_or_events['event_time'], unit='s')" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "def proper_vendor_names(series):\n", + " return series.str.capitalize().replace(['Apple-servers', 'Facebook-messenger', 'Youtube'], ['Apple', 'FB Msgr', 'YouTube'])\n", + "\n", + "filtered_or_events['vendor_proper'] = proper_vendor_names(filtered_or_events['vendor'])\n", + "\n", + "vendor_list = list(filtered_or_events.groupby('vendor_proper')['status_code'].sum().reset_index().rename(columns={'status_code':'count'}).sort_values('count')['vendor_proper'])\n", + "\n", + "filtered_or_events['vendor_cat'] = pd.Categorical(filtered_or_events['vendor_proper'], ordered=True, categories=vendor_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "facebook_reports = filtered_or_events[filtered_or_events['vendor'] == 'facebook'].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "sorted_facebook_reports = facebook_reports.sort_values('event_time').reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
event_timestatus_codevendormonitorevtimevendor_propervendor_cat
01.555241e+09210.0facebookOutage Report2019-04-14 11:20:00FacebookFacebook
11.555242e+09299.0facebookOutage Report2019-04-14 11:40:00FacebookFacebook
21.555243e+09813.0facebookOutage Report2019-04-14 12:00:00FacebookFacebook
31.555244e+09874.0facebookOutage Report2019-04-14 12:20:00FacebookFacebook
41.555246e+09891.0facebookOutage Report2019-04-14 12:40:00FacebookFacebook
........................
436741.604180e+090.0facebookOutage Report2020-10-31 21:40:00FacebookFacebook
436751.604182e+090.0facebookOutage Report2020-10-31 22:00:00FacebookFacebook
436761.604183e+090.0facebookOutage Report2020-10-31 22:20:00FacebookFacebook
436771.604184e+090.0facebookOutage Report2020-10-31 22:40:00FacebookFacebook
436781.604185e+090.0facebookOutage Report2020-10-31 23:00:00FacebookFacebook
\n", + "

43679 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " event_time status_code vendor monitor evtime \\\n", + "0 1.555241e+09 210.0 facebook Outage Report 2019-04-14 11:20:00 \n", + "1 1.555242e+09 299.0 facebook Outage Report 2019-04-14 11:40:00 \n", + "2 1.555243e+09 813.0 facebook Outage Report 2019-04-14 12:00:00 \n", + "3 1.555244e+09 874.0 facebook Outage Report 2019-04-14 12:20:00 \n", + "4 1.555246e+09 891.0 facebook Outage Report 2019-04-14 12:40:00 \n", + "... ... ... ... ... ... \n", + "43674 1.604180e+09 0.0 facebook Outage Report 2020-10-31 21:40:00 \n", + "43675 1.604182e+09 0.0 facebook Outage Report 2020-10-31 22:00:00 \n", + "43676 1.604183e+09 0.0 facebook Outage Report 2020-10-31 22:20:00 \n", + "43677 1.604184e+09 0.0 facebook Outage Report 2020-10-31 22:40:00 \n", + "43678 1.604185e+09 0.0 facebook Outage Report 2020-10-31 23:00:00 \n", + "\n", + " vendor_proper vendor_cat \n", + "0 Facebook Facebook \n", + "1 Facebook Facebook \n", + "2 Facebook Facebook \n", + "3 Facebook Facebook \n", + "4 Facebook Facebook \n", + "... ... ... \n", + "43674 Facebook Facebook \n", + "43675 Facebook Facebook \n", + "43676 Facebook Facebook \n", + "43677 Facebook Facebook \n", + "43678 Facebook Facebook \n", + "\n", + "[43679 rows x 7 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sorted_facebook_reports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# An event has start, end, peak, median, mean" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [], + "source": [ + "def extract_failures_from_reports(partial_df):\n", + " event_start = None\n", + " prev_event_time = None\n", + " num_reports_list = []\n", + " failure_events = []\n", + " for _, report_event in partial_df.sort_values('event_time').iterrows():\n", + " num_reports = report_event['status_code']\n", + " event_time = report_event['event_time']\n", + "\n", + " if num_reports == 0:\n", + " if event_start is not None:\n", + " failure_events.append({\n", + " 'start_time': event_start,\n", + " 'end_time': prev_event_time,\n", + " 'peak': np.max(num_reports_list),\n", + " 'median': np.median(num_reports_list),\n", + " 'mean': np.mean(num_reports_list)\n", + " })\n", + " event_start = None\n", + " num_reports_list = []\n", + " else:\n", + " if event_start is None:\n", + " event_start = event_time\n", + " \n", + " num_reports_list.append(num_reports)\n", + "\n", + " prev_event_time = event_time\n", + " \n", + " return pd.DataFrame(failure_events)" + ] + }, + { + "cell_type": "code", + "execution_count": 284, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
start_timeend_timepeakmedianmean
20531.564102e+091.564102e+093.03.03.000000
46011.582679e+091.582679e+093.03.03.000000
46001.582675e+091.582675e+093.03.03.000000
24331.565659e+091.565659e+093.03.03.000000
24341.565664e+091.565664e+093.03.03.000000
..................
39651.574808e+091.574808e+09215.0215.0215.000000
39941.574950e+091.574952e+09415.0322.0274.571429
39961.574958e+091.574964e+09550.0345.0253.454545
39951.574953e+091.574957e+09553.0453.0463.363636
4021.557258e+091.557259e+09952.0908.0622.666667
\n", + "

5490 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " start_time end_time peak median mean\n", + "2053 1.564102e+09 1.564102e+09 3.0 3.0 3.000000\n", + "4601 1.582679e+09 1.582679e+09 3.0 3.0 3.000000\n", + "4600 1.582675e+09 1.582675e+09 3.0 3.0 3.000000\n", + "2433 1.565659e+09 1.565659e+09 3.0 3.0 3.000000\n", + "2434 1.565664e+09 1.565664e+09 3.0 3.0 3.000000\n", + "... ... ... ... ... ...\n", + "3965 1.574808e+09 1.574808e+09 215.0 215.0 215.000000\n", + "3994 1.574950e+09 1.574952e+09 415.0 322.0 274.571429\n", + "3996 1.574958e+09 1.574964e+09 550.0 345.0 253.454545\n", + "3995 1.574953e+09 1.574957e+09 553.0 453.0 463.363636\n", + "402 1.557258e+09 1.557259e+09 952.0 908.0 622.666667\n", + "\n", + "[5490 rows x 5 columns]" + ] + }, + "execution_count": 284, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Validate this later by plotting both the intervals and direct from reports.\n", + "# To check if the failure creation algorithm is correct\n", + "facebook_failures = extract_failures_from_reports(sorted_facebook_reports)\n", + "facebook_failures.sort_values('median')" + ] + }, + { + "cell_type": "code", + "execution_count": 285, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
start_timeend_timepeakmedianmean
2053156410160015641016003.03.03.000000
4601158267880015826788003.03.03.000000
4600158267520015826752003.03.03.000000
2433156565920015656592003.03.03.000000
2434156566400015656640003.03.03.000000
..................
396515748080001574808000215.0215.0215.000000
399415749496001574952000415.0322.0274.571429
399615749580001574964000550.0345.0253.454545
399515749532001574956800553.0453.0463.363636
40215572580001557259200952.0908.0622.666667
\n", + "

5490 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " start_time end_time peak median mean\n", + "2053 1564101600 1564101600 3.0 3.0 3.000000\n", + "4601 1582678800 1582678800 3.0 3.0 3.000000\n", + "4600 1582675200 1582675200 3.0 3.0 3.000000\n", + "2433 1565659200 1565659200 3.0 3.0 3.000000\n", + "2434 1565664000 1565664000 3.0 3.0 3.000000\n", + "... ... ... ... ... ...\n", + "3965 1574808000 1574808000 215.0 215.0 215.000000\n", + "3994 1574949600 1574952000 415.0 322.0 274.571429\n", + "3996 1574958000 1574964000 550.0 345.0 253.454545\n", + "3995 1574953200 1574956800 553.0 453.0 463.363636\n", + "402 1557258000 1557259200 952.0 908.0 622.666667\n", + "\n", + "[5490 rows x 5 columns]" + ] + }, + "execution_count": 285, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "facebook_failures['start_time'] = facebook_failures['start_time'].astype(np.int64)\n", + "facebook_failures['end_time'] = facebook_failures['end_time'].astype(np.int64)\n", + "facebook_failures.sort_values('median')" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [], + "source": [ + "failure_df_list = []\n", + "\n", + "for vendor in filtered_or_events['vendor_cat'].unique():\n", + " partial_df = filtered_or_events[filtered_or_events['vendor_cat'] == vendor].reset_index(drop=True)\n", + " \n", + " partial_failure_df = extract_failures_from_reports(partial_df)\n", + " partial_failure_df['vendor_cat'] = vendor\n", + " \n", + " failure_df_list.append(partial_failure_df)\n", + " \n", + "failure_df = pd.concat(failure_df_list)\n", + "failure_df['vendor_cat'] = pd.Categorical(failure_df['vendor_cat'], ordered=True, categories=vendor_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "metadata": {}, + "outputs": [], + "source": [ + "failure_df['duration'] = failure_df['end_time'] - failure_df['start_time']\n", + "filtered_failure_df = failure_df[failure_df['duration'] >= 0].reset_index(drop=True) # filters 5 events for now\n", + "filtered_failure_df.loc[filtered_failure_df['duration'] == 0, 'duration'] = 1200 # 0 means the event lasted less than 20 minutes. round it up to 20\n", + "filtered_failure_df = filtered_failure_df.reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 282, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\begin{tabular}{llrr}\n", + "\\toprule\n", + "{} & vendor\\_proper & count\\_events & count\\_failures \\\\\n", + "\\midrule\n", + "0 & Apple & 811 & 38 \\\\\n", + "1 & Skype & 2103 & 89 \\\\\n", + "2 & Github & 2974 & 68 \\\\\n", + "3 & Gmail & 6227 & 426 \\\\\n", + "4 & FB Msgr & 7948 & 210 \\\\\n", + "5 & Whatsapp & 21235 & 884 \\\\\n", + "6 & Snapchat & 52620 & 2549 \\\\\n", + "7 & Netflix & 59595 & 3388 \\\\\n", + "8 & Facebook & 60375 & 4069 \\\\\n", + "9 & Twitter & 123862 & 2908 \\\\\n", + "10 & YouTube & 132760 & 4219 \\\\\n", + "11 & Instagram & 175702 & 3926 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n" + ] + } + ], + "source": [ + "event_count_df = filtered_or_events.groupby('vendor_proper')['status_code'].sum().reset_index().rename(columns={'status_code':'count'})\n", + "failure_count_df = filtered_failure_df.groupby('vendor_cat')['duration'].count().reset_index().rename(columns={'duration':'count'}).set_index('vendor_cat')\n", + "\n", + "joined_count_df = event_count_df.join(failure_count_df, on='vendor_proper', lsuffix='_events', rsuffix='_failures')\n", + "joined_count_df['count_events'] = joined_count_df['count_events'].astype(int)\n", + "\n", + "print(joined_count_df.sort_values('count_events').reset_index(drop=True).to_latex(float_format=\"%.2f\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 283, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "646212\n", + "22774\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
count
vendor_cat
Apple38
Github68
Skype89
FB Msgr210
Gmail426
Whatsapp884
Snapchat2549
Twitter2908
Netflix3388
Instagram3926
Facebook4069
YouTube4219
\n", + "
" + ], + "text/plain": [ + " count\n", + "vendor_cat \n", + "Apple 38\n", + "Github 68\n", + "Skype 89\n", + "FB Msgr 210\n", + "Gmail 426\n", + "Whatsapp 884\n", + "Snapchat 2549\n", + "Twitter 2908\n", + "Netflix 3388\n", + "Instagram 3926\n", + "Facebook 4069\n", + "YouTube 4219" + ] + }, + "execution_count": 283, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(joined_count_df['count_events'].sum())\n", + "print(joined_count_df['count_failures'].sum())\n", + "failure_count_df.sort_values('count')" + ] + }, + { + "cell_type": "code", + "execution_count": 292, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute all CDFs\n", + "\n", + "def compute_cdf(partial_df, variate):\n", + " count_df = partial_df.groupby(variate)['start_time'].count().reset_index().rename(columns={'start_time':'count'}).sort_values(variate).reset_index(drop=True)\n", + " count_df['prop'] = count_df['count'] / count_df['count'].sum()\n", + " count_df['cdf'] = count_df['prop'].cumsum()\n", + " return count_df\n", + "\n", + "duration_cdf_df_list = []\n", + "peak_cdf_df_list = []\n", + "median_cdf_df_list = []\n", + "mean_cdf_df_list = []\n", + "ia_cdf_df_list = []\n", + "ia_count_df_list = []\n", + "\n", + "for vendor in filtered_failure_df['vendor_cat'].unique():\n", + " partial_df = filtered_failure_df[filtered_failure_df['vendor_cat'] == vendor].reset_index(drop=True)\n", + " \n", + " partial_duration_cdf_df = compute_cdf(partial_df, 'duration')\n", + " partial_duration_cdf_df['vendor_cat'] = vendor\n", + " duration_cdf_df_list.append(partial_duration_cdf_df)\n", + " \n", + " partial_peak_cdf_df = compute_cdf(partial_df, 'peak')\n", + " partial_peak_cdf_df['vendor_cat'] = vendor\n", + " peak_cdf_df_list.append(partial_peak_cdf_df)\n", + " \n", + " partial_median_cdf_df = compute_cdf(partial_df, 'median')\n", + " partial_median_cdf_df['vendor_cat'] = vendor\n", + " median_cdf_df_list.append(partial_median_cdf_df)\n", + " \n", + " partial_mean_cdf_df = compute_cdf(partial_df, 'mean')\n", + " partial_mean_cdf_df['vendor_cat'] = vendor\n", + " mean_cdf_df_list.append(partial_mean_cdf_df)\n", + " \n", + " # Compute interarrival time\n", + " sorted_partial_df = partial_df.sort_values('start_time').reset_index(drop=True)\n", + " ia_arr = sorted_partial_df['start_time'].values - np.roll(sorted_partial_df['start_time'].values, 1)\n", + " partial_ia_df = pd.DataFrame({'ia': ia_arr[1:], 'count':1})\n", + " partial_ia_df['vendor_cat'] = vendor\n", + " ia_count_df = partial_ia_df.groupby('ia')['count'].count().reset_index()\n", + " ia_count_df['prop'] = ia_count_df['count'] / ia_count_df['count'].sum()\n", + " ia_count_df['cdf'] = ia_count_df['prop'].cumsum()\n", + " ia_count_df['vendor_cat'] = vendor\n", + " ia_count_df_list.append(partial_ia_df)\n", + " ia_cdf_df_list.append(ia_count_df)\n", + " \n", + "duration_cdf_df = pd.concat(duration_cdf_df_list).reset_index(drop=True)\n", + "duration_cdf_df['vendor_cat'] = pd.Categorical(duration_cdf_df['vendor_cat'], ordered=True, categories=vendor_list)\n", + "\n", + "peak_cdf_df = pd.concat(peak_cdf_df_list).reset_index(drop=True)\n", + "peak_cdf_df['vendor_cat'] = pd.Categorical(peak_cdf_df['vendor_cat'], ordered=True, categories=vendor_list)\n", + "\n", + "median_cdf_df = pd.concat(median_cdf_df_list).reset_index(drop=True)\n", + "median_cdf_df['vendor_cat'] = pd.Categorical(median_cdf_df['vendor_cat'], ordered=True, categories=vendor_list)\n", + "\n", + "mean_cdf_df = pd.concat(mean_cdf_df_list).reset_index(drop=True)\n", + "mean_cdf_df['vendor_cat'] = pd.Categorical(mean_cdf_df['vendor_cat'], ordered=True, categories=vendor_list)\n", + "\n", + "ia_cdf_df = pd.concat(ia_cdf_df_list).reset_index(drop=True)\n", + "ia_cdf_df['vendor_cat'] = pd.Categorical(ia_cdf_df['vendor_cat'], ordered=True, categories=vendor_list)\n", + "\n", + "ia_count_df = pd.concat(ia_count_df_list).reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 260, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
vendor_catduration
2Github7200.0
0Apple10800.0
3Gmail21600.0
1Skype22800.0
4FB Msgr30000.0
5Whatsapp40800.0
8Facebook75600.0
6Snapchat108000.0
7Netflix117600.0
10YouTube146400.0
11Instagram171600.0
9Twitter238800.0
\n", + "
" + ], + "text/plain": [ + " vendor_cat duration\n", + "2 Github 7200.0\n", + "0 Apple 10800.0\n", + "3 Gmail 21600.0\n", + "1 Skype 22800.0\n", + "4 FB Msgr 30000.0\n", + "5 Whatsapp 40800.0\n", + "8 Facebook 75600.0\n", + "6 Snapchat 108000.0\n", + "7 Netflix 117600.0\n", + "10 YouTube 146400.0\n", + "11 Instagram 171600.0\n", + "9 Twitter 238800.0" + ] + }, + "execution_count": 260, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "duration_cdf_df.groupby('vendor_cat')['duration'].max().reset_index().sort_values('duration')" + ] + }, + { + "cell_type": "code", + "execution_count": 279, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
vendor_catlevel_1duration
3Gmail0.962400.0
5Whatsapp0.962400.0
6Snapchat0.964800.0
1Skype0.966000.0
2Github0.966000.0
4FB Msgr0.966000.0
8Facebook0.966000.0
0Apple0.967248.0
10YouTube0.968400.0
7Netflix0.9612624.0
9Twitter0.9620400.0
11Instagram0.9620400.0
\n", + "
" + ], + "text/plain": [ + " vendor_cat level_1 duration\n", + "3 Gmail 0.96 2400.0\n", + "5 Whatsapp 0.96 2400.0\n", + "6 Snapchat 0.96 4800.0\n", + "1 Skype 0.96 6000.0\n", + "2 Github 0.96 6000.0\n", + "4 FB Msgr 0.96 6000.0\n", + "8 Facebook 0.96 6000.0\n", + "0 Apple 0.96 7248.0\n", + "10 YouTube 0.96 8400.0\n", + "7 Netflix 0.96 12624.0\n", + "9 Twitter 0.96 20400.0\n", + "11 Instagram 0.96 20400.0" + ] + }, + "execution_count": 279, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "failure_df.groupby('vendor_cat')['duration'].quantile([0.96]).reset_index().sort_values('duration')" + ] + }, + { + "cell_type": "code", + "execution_count": 280, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
vendor_catia
11Instagram297600.0
9Twitter1011600.0
10YouTube1018800.0
8Facebook1386000.0
7Netflix1776000.0
4FB Msgr2221200.0
6Snapchat2451600.0
3Gmail2532000.0
2Github3805200.0
5Whatsapp5170800.0
1Skype6337200.0
0Apple11250000.0
\n", + "
" + ], + "text/plain": [ + " vendor_cat ia\n", + "11 Instagram 297600.0\n", + "9 Twitter 1011600.0\n", + "10 YouTube 1018800.0\n", + "8 Facebook 1386000.0\n", + "7 Netflix 1776000.0\n", + "4 FB Msgr 2221200.0\n", + "6 Snapchat 2451600.0\n", + "3 Gmail 2532000.0\n", + "2 Github 3805200.0\n", + "5 Whatsapp 5170800.0\n", + "1 Skype 6337200.0\n", + "0 Apple 11250000.0" + ] + }, + "execution_count": 280, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ia_cdf_df.groupby('vendor_cat')['ia'].max().reset_index().sort_values('ia')" + ] + }, + { + "cell_type": "code", + "execution_count": 295, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.5 6000.0\n", + "0.9 27600.0\n", + "Name: ia, dtype: float64" + ] + }, + "execution_count": 295, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ia_count_df['ia'].quantile([0.50, 0.90])" + ] + }, + { + "cell_type": "code", + "execution_count": 297, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
vendor_catlevel_1ia
2Facebook0.758400.0
6Netflix0.758400.0
11YouTube0.758400.0
8Snapchat0.759600.0
5Instagram0.7512000.0
9Twitter0.7512000.0
10Whatsapp0.7541400.0
4Gmail0.7598400.0
1FB Msgr0.75306000.0
7Skype0.75668400.0
3Github0.75820200.0
0Apple0.751306800.0
\n", + "
" + ], + "text/plain": [ + " vendor_cat level_1 ia\n", + "2 Facebook 0.75 8400.0\n", + "6 Netflix 0.75 8400.0\n", + "11 YouTube 0.75 8400.0\n", + "8 Snapchat 0.75 9600.0\n", + "5 Instagram 0.75 12000.0\n", + "9 Twitter 0.75 12000.0\n", + "10 Whatsapp 0.75 41400.0\n", + "4 Gmail 0.75 98400.0\n", + "1 FB Msgr 0.75 306000.0\n", + "7 Skype 0.75 668400.0\n", + "3 Github 0.75 820200.0\n", + "0 Apple 0.75 1306800.0" + ] + }, + "execution_count": 297, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ia_count_df.groupby('vendor_cat')['ia'].quantile([0.75]).reset_index().sort_values('ia')" + ] + }, + { + "cell_type": "code", + "execution_count": 242, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 14 x 3 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/failure_duration_ia_cdf.pdf\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/geoms/geom_path.py:81: PlotnineWarning: geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/geoms/geom_path.py:81: PlotnineWarning: geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 242, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dummy_df = duration_cdf_df.loc[:1, :].copy()\n", + "dummy_df.loc[0, 'dummy'] = '0'\n", + "dummy_df.loc[1, 'dummy'] = '1'\n", + "\n", + "marker_df = pd.DataFrame({\n", + " 'sec': [60*60, 60*60*4, 60*60*24, 60*60*24*4],\n", + " 'y': [1, 1, 1, 1],\n", + " 'text': ['1 hour', '4 hours', '1 day', '4 days']\n", + "})\n", + "\n", + "plt = ggplot(median_cdf_df) +\\\n", + " geom_line(aes(x='duration', y='cdf'), data=duration_cdf_df, color='black') +\\\n", + " geom_line(aes(x='ia', y='cdf'), data=ia_cdf_df, color='#0280c9') +\\\n", + " geom_line(aes(x='duration', y='cdf', color='dummy'), data=dummy_df) +\\\n", + " scale_x_log10(breaks=[1000, 10000, 100000, 1000000], labels=lambda l: list(map(lambda x: '$10^{}$'.format(int(np.log10(x))), l))) +\\\n", + " geom_vline(aes(xintercept='sec'), data=marker_df, linetype='--') +\\\n", + " facet_wrap(facets='vendor_cat', nrow=2) +\\\n", + " ylab('ECDF') +\\\n", + " xlab('Time (in seconds)') +\\\n", + " scale_color_manual(['black', '#0280c9'], labels=['Duration', 'Interarrival time']) +\\\n", + " guides(color=guide_legend(title='')) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " theme(figure_size=(14, 3),\n", + " axis_text_y=element_text(margin={'r': 5}),\n", + " panel_grid_major_x=element_line(size=0.7, color=\"gainsboro\"),\n", + " text=element_text(size=12),\n", + " legend_box_spacing=0.01,\n", + " legend_box_margin=0,\n", + " legend_margin=0,\n", + " legend_key=element_blank(),\n", + " legend_entry_spacing=5,\n", + " legend_background=element_rect(fill=(0,0,0,0), color=(0,0,0,0)),\n", + " legend_position='top')\n", + "\n", + "plt.save('plots/failure_duration_ia_cdf.pdf', limitsize=None)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 243, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 14 x 3 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/failure_mean_peak_cdf.pdf\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/geoms/geom_path.py:75: PlotnineWarning: geom_path: Removed 1 rows containing missing values.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/geoms/geom_path.py:81: PlotnineWarning: geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/geoms/geom_path.py:75: PlotnineWarning: geom_path: Removed 1 rows containing missing values.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/geoms/geom_path.py:81: PlotnineWarning: geom_path: Each group consist of only one observation. Do you need to adjust the group aesthetic?\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 243, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dummy_df = mean_cdf_df.loc[:1, :].copy()\n", + "dummy_df.loc[0, 'dummy'] = '0'\n", + "dummy_df.loc[1, 'dummy'] = '1'\n", + "\n", + "plt = ggplot(median_cdf_df) +\\\n", + " geom_line(aes(x='mean', y='cdf'), data=mean_cdf_df, color='black') +\\\n", + " geom_line(aes(x='peak', y='cdf'), data=peak_cdf_df, color='#0280c9') +\\\n", + " geom_line(aes(x='mean', y='cdf', color='dummy'), data=dummy_df) +\\\n", + " scale_x_log10() +\\\n", + " scale_y_continuous(limits=[0, 1]) +\\\n", + " facet_wrap(facets='vendor_cat', nrow=2) +\\\n", + " ylab('ECDF') +\\\n", + " xlab('Number of reports') +\\\n", + " scale_color_manual(['black', '#0280c9'], labels=['Mean number of reports of failure', 'Peak number of reports of failure']) +\\\n", + " guides(color=guide_legend(title='')) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " theme(figure_size=(14, 3),\n", + " axis_text_y=element_text(margin={'r': 5}),\n", + " panel_grid_major_x=element_line(size=0.7, color=\"gainsboro\"),\n", + " text=element_text(size=12),\n", + " legend_box_spacing=0.01,\n", + " legend_box_margin=0,\n", + " legend_margin=0,\n", + " legend_key=element_blank(),\n", + " legend_entry_spacing=5,\n", + " legend_background=element_rect(fill=(0,0,0,0), color=(0,0,0,0)),\n", + " legend_position='top')\n", + "\n", + "plt.save('plots/failure_mean_peak_cdf.pdf', limitsize=None)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 246, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_failure_df['parsed_start_time'] = pd.to_datetime(filtered_failure_df['start_time'], unit='s')\n", + "precovid_failure_df = filtered_failure_df[(filtered_failure_df['parsed_start_time'].dt.year == 2019)\n", + " & (filtered_failure_df['parsed_start_time'].dt.month >= 4)\n", + " & (filtered_failure_df['parsed_start_time'].dt.month <= 8)].reset_index(drop=True)\n", + "covid_failure_df = filtered_failure_df[(filtered_failure_df['parsed_start_time'].dt.year == 2020)\n", + " & (filtered_failure_df['parsed_start_time'].dt.month >= 4)\n", + " & (filtered_failure_df['parsed_start_time'].dt.month <= 8)].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 247, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_ia(partial_df):\n", + " sorted_partial_df = partial_df.sort_values('start_time').reset_index(drop=True)\n", + " ia_arr = sorted_partial_df['start_time'].values - np.roll(sorted_partial_df['start_time'].values, 1)\n", + " partial_ia_df = pd.DataFrame({'ia': ia_arr[1:], 'count':1, 'vendor_cat': partial_df.loc[0, 'vendor_cat']})\n", + " return partial_ia_df\n", + "\n", + "precovid_ia_partial_df_list = []\n", + "covid_ia_partial_df_list = []\n", + "\n", + "for vendor in precovid_failure_df['vendor_cat'].unique():\n", + " precovid_partial_df = precovid_failure_df[precovid_failure_df['vendor_cat'] == vendor].reset_index(drop=True)\n", + " covid_partial_df = covid_failure_df[covid_failure_df['vendor_cat'] == vendor].reset_index(drop=True)\n", + " \n", + " # Compute interarrival time\n", + " precovid_ia = compute_ia(precovid_partial_df)\n", + " covid_ia = compute_ia(covid_partial_df)\n", + " \n", + " precovid_ia_partial_df_list.append(precovid_ia)\n", + " covid_ia_partial_df_list.append(covid_ia)\n", + "\n", + "precovid_ia_df = pd.concat(precovid_ia_partial_df_list)\n", + "covid_ia_df = pd.concat(covid_ia_partial_df_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 249, + "metadata": {}, + "outputs": [], + "source": [ + "precovid_ia_quantiles = precovid_ia_df.groupby('vendor_cat')['ia'].quantile([0.50, 0.95]).reset_index().sort_values('ia').pivot(index='vendor_cat', columns='level_1')\n", + "covid_ia_quantiles = covid_ia_df.groupby('vendor_cat')['ia'].quantile([0.50, 0.95]).reset_index().sort_values('ia').pivot(index='vendor_cat', columns='level_1')\n", + "# precovid_ia_quantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 250, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
durationiaduration_covidia_covid
level_10.500.950.500.950.500.950.500.95
vendor_cat
Apple0.3333332.50000098.000000560.0333330.5000000.650000899.666667899.666667
Skype0.3333334.63333399.333333416.8000000.3333331.483333178.6666671070.333333
Github0.3333331.00000060.666667308.6000001.0000001.666667158.333333646.066667
Gmail0.3333330.6666675.00000062.3333330.3333332.00000026.666667583.733333
FB Msgr0.3333331.2000005.666667186.2000000.3333330.53333311.000000221.350000
Whatsapp0.3333330.6666674.33333326.2000000.3333330.66666711.166667376.150000
Snapchat0.3333331.3333331.3333336.6666670.3333331.3333331.666667126.500000
Netflix0.3333333.4166671.3333338.3333330.3333332.7666672.00000065.916667
Facebook0.3333332.0000001.3333335.0000000.3333331.2666671.66666769.566667
Twitter0.6666675.6666671.66666710.6666670.3333337.8666675.00000092.550000
YouTube0.3333332.3333331.3333336.3333330.3333331.6666672.00000044.700000
Instagram0.3333336.0000002.0000008.6333330.3333333.3333333.00000029.733333
\n", + "
" + ], + "text/plain": [ + " duration ia duration_covid \\\n", + "level_1 0.50 0.95 0.50 0.95 0.50 \n", + "vendor_cat \n", + "Apple 0.333333 2.500000 98.000000 560.033333 0.500000 \n", + "Skype 0.333333 4.633333 99.333333 416.800000 0.333333 \n", + "Github 0.333333 1.000000 60.666667 308.600000 1.000000 \n", + "Gmail 0.333333 0.666667 5.000000 62.333333 0.333333 \n", + "FB Msgr 0.333333 1.200000 5.666667 186.200000 0.333333 \n", + "Whatsapp 0.333333 0.666667 4.333333 26.200000 0.333333 \n", + "Snapchat 0.333333 1.333333 1.333333 6.666667 0.333333 \n", + "Netflix 0.333333 3.416667 1.333333 8.333333 0.333333 \n", + "Facebook 0.333333 2.000000 1.333333 5.000000 0.333333 \n", + "Twitter 0.666667 5.666667 1.666667 10.666667 0.333333 \n", + "YouTube 0.333333 2.333333 1.333333 6.333333 0.333333 \n", + "Instagram 0.333333 6.000000 2.000000 8.633333 0.333333 \n", + "\n", + " ia_covid \n", + "level_1 0.95 0.50 0.95 \n", + "vendor_cat \n", + "Apple 0.650000 899.666667 899.666667 \n", + "Skype 1.483333 178.666667 1070.333333 \n", + "Github 1.666667 158.333333 646.066667 \n", + "Gmail 2.000000 26.666667 583.733333 \n", + "FB Msgr 0.533333 11.000000 221.350000 \n", + "Whatsapp 0.666667 11.166667 376.150000 \n", + "Snapchat 1.333333 1.666667 126.500000 \n", + "Netflix 2.766667 2.000000 65.916667 \n", + "Facebook 1.266667 1.666667 69.566667 \n", + "Twitter 7.866667 5.000000 92.550000 \n", + "YouTube 1.666667 2.000000 44.700000 \n", + "Instagram 3.333333 3.000000 29.733333 " + ] + }, + "execution_count": 250, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "precovid_duration_quantiles = precovid_failure_df.groupby('vendor_cat')['duration'].quantile([0.50, 0.95]).reset_index().sort_values('duration').pivot(index='vendor_cat', columns='level_1')\n", + "covid_duration_quantiles = covid_failure_df.groupby('vendor_cat')['duration'].quantile([0.50, 0.95]).reset_index().sort_values('duration').pivot(index='vendor_cat', columns='level_1')\n", + "covid_table = precovid_duration_quantiles.join(precovid_ia_quantiles).join(covid_duration_quantiles, rsuffix='_covid').join(covid_ia_quantiles, rsuffix='_covid') / 3600\n", + "covid_table" + ] + }, + { + "cell_type": "code", + "execution_count": 251, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\begin{tabular}{lrrrrrrrr}\n", + "\\toprule\n", + "{} & \\multicolumn{2}{l}{duration} & \\multicolumn{2}{l}{ia} & \\multicolumn{2}{l}{duration\\_covid} & \\multicolumn{2}{l}{ia\\_covid} \\\\\n", + "level\\_1 & 0.50 & 0.95 & 0.50 & 0.95 & 0.50 & 0.95 & 0.50 & 0.95 \\\\\n", + "vendor\\_cat & & & & & & & & \\\\\n", + "\\midrule\n", + "Apple & 0.3 & 2.5 & 98.0 & 560.0 & 0.5 & 0.7 & 899.7 & 899.7 \\\\\n", + "Skype & 0.3 & 4.6 & 99.3 & 416.8 & 0.3 & 1.5 & 178.7 & 1070.3 \\\\\n", + "Github & 0.3 & 1.0 & 60.7 & 308.6 & 1.0 & 1.7 & 158.3 & 646.1 \\\\\n", + "Gmail & 0.3 & 0.7 & 5.0 & 62.3 & 0.3 & 2.0 & 26.7 & 583.7 \\\\\n", + "FB Msgr & 0.3 & 1.2 & 5.7 & 186.2 & 0.3 & 0.5 & 11.0 & 221.3 \\\\\n", + "Whatsapp & 0.3 & 0.7 & 4.3 & 26.2 & 0.3 & 0.7 & 11.2 & 376.1 \\\\\n", + "Snapchat & 0.3 & 1.3 & 1.3 & 6.7 & 0.3 & 1.3 & 1.7 & 126.5 \\\\\n", + "Netflix & 0.3 & 3.4 & 1.3 & 8.3 & 0.3 & 2.8 & 2.0 & 65.9 \\\\\n", + "Facebook & 0.3 & 2.0 & 1.3 & 5.0 & 0.3 & 1.3 & 1.7 & 69.6 \\\\\n", + "Twitter & 0.7 & 5.7 & 1.7 & 10.7 & 0.3 & 7.9 & 5.0 & 92.5 \\\\\n", + "YouTube & 0.3 & 2.3 & 1.3 & 6.3 & 0.3 & 1.7 & 2.0 & 44.7 \\\\\n", + "Instagram & 0.3 & 6.0 & 2.0 & 8.6 & 0.3 & 3.3 & 3.0 & 29.7 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n" + ] + } + ], + "source": [ + "print(covid_table.to_latex(float_format=\"%.1f\"))" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/datasets/Talluri2021/other notebooks/5.covid period comparison.ipynb b/datasets/Talluri2021/other notebooks/5.covid period comparison.ipynb new file mode 100644 index 0000000..15eaf77 --- /dev/null +++ b/datasets/Talluri2021/other notebooks/5.covid period comparison.ipynb @@ -0,0 +1,229 @@ +{ + "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_events = pd.read_parquet('./outage_report_2019-20')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_events = or_events[(or_events['vendor'] != '') & (or_events['vendor'] != 'overview')].reset_index(drop=True)\n", + "filtered_or_events = filtered_or_events.drop_duplicates(subset=['vendor', 'event_time', 'status_code'])\n", + "# Combine events with the same event_time, but different status_code with max\n", + "filtered_or_events = filtered_or_events.groupby(['vendor', 'event_time'])['status_code'].max().reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_events['evtime'] = pd.to_datetime(filtered_or_events['event_time'], unit='s')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def proper_vendor_names(series):\n", + " return series.str.capitalize().replace(['Apple-servers', 'Facebook-messenger', 'Youtube'], ['Apple', 'FB Msgr', 'YouTube'])\n", + "\n", + "filtered_or_events['vendor_proper'] = proper_vendor_names(filtered_or_events['vendor'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Apple',\n", + " 'Github',\n", + " 'Skype',\n", + " 'FB Msgr',\n", + " 'Gmail',\n", + " 'Whatsapp',\n", + " 'Snapchat',\n", + " 'Netflix',\n", + " 'Facebook',\n", + " 'Twitter',\n", + " 'YouTube',\n", + " 'Instagram']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vendor_list = list(filtered_or_events.groupby('vendor_proper')['status_code'].sum().reset_index().rename(columns={'status_code':'count'}).sort_values('count')['vendor_proper'])\n", + "vendor_list" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_events['year'] = pd.Categorical(filtered_or_events['evtime'].dt.year, ordered=True)\n", + "filtered_or_events['month'] = pd.Categorical(filtered_or_events['evtime'].dt.month, ordered=True)\n", + "filtered_or_events['vendor_cat'] = pd.Categorical(filtered_or_events['vendor_proper'], ordered=True, categories=vendor_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "367336.0" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reports_per_month = filtered_or_events.groupby(['year', 'month', 'vendor_cat'])['status_code'].sum().reset_index().rename(columns={'status_code':'count'})\n", + "subset_reports_per_month = reports_per_month[(reports_per_month['month'] > 3) & (reports_per_month['month'] < 9)]\n", + "subset_reports_per_month['count'].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "report_count_df_list = []\n", + "\n", + "for vendor in subset_reports_per_month['vendor_cat'].unique():\n", + " partial_df = subset_reports_per_month[subset_reports_per_month['vendor_cat'] == vendor].reset_index(drop=True)\n", + " max_reports = partial_df['count'].max()\n", + " partial_df['prop'] = partial_df['count'] / max_reports\n", + " report_count_df_list.append(partial_df)\n", + " \n", + "reports_per_month_with_prop = pd.concat(report_count_df_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 14 x 3 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/covid_comparison.pdf\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/layer.py:467: PlotnineWarning: geom_bar : Removed 1 rows containing missing values.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/layer.py:467: PlotnineWarning: geom_bar : Removed 1 rows containing missing values.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vendor_maxes = reports_per_month_with_prop.groupby('vendor_cat')['count'].max()\n", + "\n", + "def label_func(vendor):\n", + " if vendor == 'Apple':\n", + " return vendor + ' (max={:,})'.format(int(vendor_maxes.loc[vendor]))\n", + " else:\n", + " return vendor + ' ({:,})'.format(int(vendor_maxes.loc[vendor]))\n", + "\n", + "plt = ggplot(reports_per_month_with_prop) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " theme(figure_size=(14, 3),\n", + " axis_text_y=element_text(margin={'r': 5}),\n", + " panel_grid_minor_x=element_line(size=0.7, color=\"gainsboro\"),\n", + " panel_grid_major_x=element_blank(),\n", + " text=element_text(size=12),\n", + " legend_box_spacing=0.01,\n", + " legend_box_margin=0,\n", + " legend_margin=0,\n", + " legend_key=element_blank(),\n", + " legend_entry_spacing=5,\n", + " legend_background=element_rect(fill=(0,0,0,0), color=(0,0,0,0)),\n", + " legend_position='top',) +\\\n", + " facet_wrap(facets='vendor_cat', nrow=2, labeller=label_func) +\\\n", + " geom_bar(aes(x='month', y='prop', fill='year'), stat='identity', position='dodge') +\\\n", + " scale_fill_manual(['#0280c9', '#78d8da']) +\\\n", + " guides(fill=guide_legend(title='')) +\\\n", + " xlab('Month') +\\\n", + " ylab('Normalized reports/month')\n", + "\n", + "plt.save('plots/covid_comparison.pdf', limitsize=False)\n", + "plt" + ] + } + ], + "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 +} diff --git a/datasets/Talluri2021/other notebooks/8.analyze experiment results.ipynb b/datasets/Talluri2021/other notebooks/8.analyze experiment results.ipynb new file mode 100644 index 0000000..59abcd6 --- /dev/null +++ b/datasets/Talluri2021/other notebooks/8.analyze experiment results.ipynb @@ -0,0 +1,504 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from plotnine import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# results_df = pd.read_csv('structures_experiment_results_1.csv')\n", + "results_df = pd.read_csv('./experiment_results/long_chain_results_sin1.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "results_df['cat_retries'] = pd.Categorical(results_df['retries']).rename_categories({100: 'Fail'})\n", + "# results_df['fraction'] = results_df['reqs'] / (365*24*60*60)\n", + "results_df['fraction'] = results_df['reqs'] / (365*24*60*60/2) # For sin stuff\n", + "min_max_per_exp = results_df.groupby(['vendor', 'experiment', 'cat_retries'])['fraction'].agg(['min', 'max', 'mean']).reset_index().fillna(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0vendorreqsretriesiterationexperimentcat_retriesfraction
00uniform1.499495e+0700deep chain09.509732e-01
11uniform7.501410e+0510deep chain14.757363e-02
22uniform2.239900e+0420deep chain21.420535e-03
33uniform4.870000e+0230deep chain33.088534e-05
44uniform1.100000e+0140deep chain46.976154e-07
55uniform1.000000e+0050deep chain56.341958e-08
66uniform1.608636e+011000deep chainFail1.020190e-06
70instagram1.565882e+0700deep chain09.930757e-01
81instagram1.052420e+0510deep chain16.674404e-03
92instagram1.953000e+0320deep chain21.238584e-04
103instagram3.320000e+0230deep chain32.105530e-05
114instagram1.656685e+031000deep chainFail1.050663e-04
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 vendor reqs retries iteration experiment \\\n", + "0 0 uniform 1.499495e+07 0 0 deep chain \n", + "1 1 uniform 7.501410e+05 1 0 deep chain \n", + "2 2 uniform 2.239900e+04 2 0 deep chain \n", + "3 3 uniform 4.870000e+02 3 0 deep chain \n", + "4 4 uniform 1.100000e+01 4 0 deep chain \n", + "5 5 uniform 1.000000e+00 5 0 deep chain \n", + "6 6 uniform 1.608636e+01 100 0 deep chain \n", + "7 0 instagram 1.565882e+07 0 0 deep chain \n", + "8 1 instagram 1.052420e+05 1 0 deep chain \n", + "9 2 instagram 1.953000e+03 2 0 deep chain \n", + "10 3 instagram 3.320000e+02 3 0 deep chain \n", + "11 4 instagram 1.656685e+03 100 0 deep chain \n", + "\n", + " cat_retries fraction \n", + "0 0 9.509732e-01 \n", + "1 1 4.757363e-02 \n", + "2 2 1.420535e-03 \n", + "3 3 3.088534e-05 \n", + "4 4 6.976154e-07 \n", + "5 5 6.341958e-08 \n", + "6 Fail 1.020190e-06 \n", + "7 0 9.930757e-01 \n", + "8 1 6.674404e-03 \n", + "9 2 1.238584e-04 \n", + "10 3 2.105530e-05 \n", + "11 Fail 1.050663e-04 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_df" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:719: PlotnineWarning: Saving 6.4 x 4.8 in image.\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:722: PlotnineWarning: Filename: deep chain comparison.png\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/pandas/core/series.py:726: RuntimeWarning: divide by zero encountered in log10\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:719: PlotnineWarning: Saving 6.4 x 4.8 in image.\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:722: PlotnineWarning: Filename: deep chain comparison.pdf\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/pandas/core/series.py:726: RuntimeWarning: divide by zero encountered in log10\n", + "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/pandas/core/series.py:726: RuntimeWarning: divide by zero encountered in log10\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "experiment = 'deep chain'\n", + "specific_min_max = min_max_per_exp[(min_max_per_exp['experiment'] == experiment)]\n", + "plt = ggplot(specific_min_max) +\\\n", + " theme_light(base_size=12, base_family='sans-serif') +\\\n", + " theme(text=element_text(size=12), legend_position=(0.3, 0.25)) +\\\n", + " geom_point(aes(x='cat_retries', y='mean', color='vendor', group='vendor'), size=3, shape='s') +\\\n", + " scale_y_log10(limits=[1, 1e-8], breaks = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001, 0.4e-8],\n", + " labels=['10%', '1%', '0.1%', '$10^{-2}$%', '$10^{-3}$%', '$10^{-4}$%', '$10^{-5}$%', '0']) +\\\n", + " guides(color=guide_legend(title='Workload'), fill=guide_legend(title='Workload')) +\\\n", + " scale_color_discrete(labels=['Instagram trace', 'Constant']) +\\\n", + " xlab('Number of retries')+\\\n", + " ylab('Fraction of requests')\n", + "\n", + "plt.save(f'{experiment} comparison.png', dpi=300)\n", + "plt.save(f'{experiment} comparison.pdf')\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# experiment = 'monolith'\n", + "# specific_min_max = min_max_per_exp[(min_max_per_exp['experiment'] == experiment)]\n", + "# plt = ggplot(specific_min_max) +\\\n", + "# theme_light(base_size=12, base_family='sans-serif') +\\\n", + "# theme(text=element_text(size=12)) +\\\n", + "# geom_line(aes(x='cat_retries', y='mean', color='vendor', group='vendor')) +\\\n", + "# scale_y_log10(breaks = [0.01, 0.0001, 0.000001, 1e-8], labels=['1%', '0.01%', '$10^{-4}$%', '$10^{-6}$%']) +\\\n", + "# guides(color=guide_legend(title='Workload'), fill=guide_legend(title='Workload')) +\\\n", + "# scale_color_discrete(labels=['Instagram trace', 'Constant']) +\\\n", + "# scale_fill_discrete(labels=['Instagram trace', 'Constant']) +\\\n", + "# xlab('Number of retries')+\\\n", + "# ylab('Fraction of requests')\n", + "\n", + "# plt.save(f'{experiment} comparison.png', dpi=300)\n", + "# plt" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# experiment = 'fanout'\n", + "# specific_min_max = min_max_per_exp[(min_max_per_exp['experiment'] == experiment)]\n", + "# plt = ggplot(specific_min_max) +\\\n", + "# theme_light(base_size=12, base_family='sans-serif') +\\\n", + "# theme(text=element_text(size=12)) +\\\n", + "# geom_line(aes(x='cat_retries', y='mean', color='vendor', group='vendor')) +\\\n", + "# geom_ribbon(aes(x='cat_retries', ymin='min', ymax='max', fill='vendor', group='vendor'), alpha=0.5) +\\\n", + "# scale_y_log10(breaks = [0.01, 0.0001, 0.000001], labels=['1%', '0.01%', '0.0001%']) +\\\n", + "# guides(color=guide_legend(title='Workload'), fill=guide_legend(title='Workload')) +\\\n", + "# scale_color_discrete(labels=['Instagram trace', 'Constant']) +\\\n", + "# scale_fill_discrete(labels=['Instagram trace', 'Constant']) +\\\n", + "# xlab('Number of retries')+\\\n", + "# ylab('Fraction of requests')\n", + "\n", + "# plt.save(f'{experiment} comparison.png', dpi=300)\n", + "# plt" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# const_results_df = pd.read_csv('const_experiment_results_1.csv')\n", + "# const_results_df['cat_retries'] = pd.Categorical(const_results_df['retries']).rename_categories({100: 'Fail'})\n", + "# const_results_df['cat_prob'] = pd.Categorical(const_results_df['prob']).rename_categories({100: 'Fail'})\n", + "# const_results_df['fraction'] = const_results_df['reqs'] / (365*24*60*60)\n", + "# const_results_df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# experiment = 'deep chain'\n", + "# specific_const_results = const_results_df[(const_results_df['experiment'] == experiment)]\n", + "# plt = ggplot(specific_const_results) +\\\n", + "# theme_light(base_size=12, base_family='sans-serif') +\\\n", + "# theme(text=element_text(size=12)) +\\\n", + "# geom_line(aes(x='cat_retries', y='fraction', color='cat_prob', group='cat_prob')) +\\\n", + "# scale_y_log10(limits=[1, 1e-6], breaks = [0.01, 0.0001, 0.000001, 1e-8], labels=['1%', '0.01%', '$10^{-4}$%', '$10^{-6}$%']) +\\\n", + "# guides(color=guide_legend(title='Workload'), fill=guide_legend(title='Workload')) +\\\n", + "# xlab('Number of retries')+\\\n", + "# ylab('Fraction of requests')\n", + "\n", + "# plt.save(f'const comparison.png', dpi=300)\n", + "# plt" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# experiment = 'deep chain'\n", + "# specific_const_results = const_results_df[(const_results_df['experiment'] == experiment) & (const_results_df['cat_prob'] == 0.01)]\n", + "# plt = ggplot(specific_const_results) +\\\n", + "# theme_light(base_size=12, base_family='sans-serif') +\\\n", + "# theme(text=element_text(size=12), axis_text_y=element_text(size=35)) +\\\n", + "# geom_point(aes(x='cat_retries', y='fraction', group='cat_prob'), size=3, shape='s') +\\\n", + "# scale_y_log10(limits=[1, 1e-6], breaks = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001],\n", + "# labels=['10%', '', '0.1%', '', '$10^{-3}$%', '']) +\\\n", + "# xlab('')+\\\n", + "# ylab('')\n", + "\n", + "# plt.save(f'low const.png', dpi=300)\n", + "# plt.save(f'low const.pdf')\n", + "# plt" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# experiment = 'deep chain'\n", + "# specific_const_results = const_results_df[(const_results_df['experiment'] == experiment) & (const_results_df['cat_prob'] == 0.25)]\n", + "# plt = ggplot(specific_const_results) +\\\n", + "# theme_light(base_size=12, base_family='sans-serif') +\\\n", + "# theme(text=element_text(size=12)) +\\\n", + "# geom_point(aes(x='cat_retries', y='fraction', group='cat_prob'), size=3, shape='s') +\\\n", + "# scale_y_log10(limits=[1, 1e-6], breaks = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001],\n", + "# labels=['', '', '', '', '', '']) +\\\n", + "# xlab('')+\\\n", + "# ylab('')\n", + "\n", + "# plt.save(f'25 const.png', dpi=300)\n", + "# plt.save(f'25 const.pdf')\n", + "# plt" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# experiment = 'deep chain'\n", + "# specific_const_results = const_results_df[(const_results_df['experiment'] == experiment) & (const_results_df['cat_prob'] == 0.5)]\n", + "# plt = ggplot(specific_const_results) +\\\n", + "# theme_light(base_size=12, base_family='sans-serif') +\\\n", + "# theme(text=element_text(size=12)) +\\\n", + "# geom_point(aes(x='cat_retries', y='fraction', group='cat_prob'), size=3, shape='s') +\\\n", + "# scale_y_log10(limits=[1, 1e-6], breaks = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001],\n", + "# labels=['', '', '', '', '', '']) +\\\n", + "# xlab('')+\\\n", + "# ylab('')\n", + "\n", + "# plt.save(f'50 const.png', dpi=300)\n", + "# plt.save(f'50 const.pdf')\n", + "# plt" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# experiment = 'deep chain'\n", + "# specific_const_results = const_results_df[(const_results_df['experiment'] == experiment) & (const_results_df['cat_prob'] == 0.75)]\n", + "# plt = ggplot(specific_const_results) +\\\n", + "# theme_light(base_size=12, base_family='sans-serif') +\\\n", + "# theme(text=element_text(size=12)) +\\\n", + "# geom_point(aes(x='cat_retries', y='fraction', group='cat_prob'), size=3, shape='s') +\\\n", + "# scale_y_log10(limits=[1, 1e-6], breaks = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001],\n", + "# labels=['', '', '', '', '', '']) +\\\n", + "# xlab('')+\\\n", + "# ylab('')\n", + "\n", + "# plt.save(f'75 const.png', dpi=300)\n", + "# plt" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# print(pd.pivot_table(min_max_per_exp[['vendor', 'experiment', 'cat_retries', 'mean']], values='mean', index=['vendor', 'experiment'], columns=['cat_retries']).to_latex(float_format=\"{:0.2e}\".format))" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/datasets/Talluri2021/outage_report_2019-20/_common_metadata b/datasets/Talluri2021/outage_report_2019-20/_common_metadata new file mode 100644 index 0000000..e4deaec Binary files /dev/null and b/datasets/Talluri2021/outage_report_2019-20/_common_metadata differ diff --git a/datasets/Talluri2021/outage_report_2019-20/_metadata b/datasets/Talluri2021/outage_report_2019-20/_metadata new file mode 100644 index 0000000..2ab8ca5 Binary files /dev/null and b/datasets/Talluri2021/outage_report_2019-20/_metadata differ diff --git a/datasets/Talluri2021/outage_report_2019-20/part.0.parquet b/datasets/Talluri2021/outage_report_2019-20/part.0.parquet new file mode 100644 index 0000000..2042102 Binary files /dev/null and b/datasets/Talluri2021/outage_report_2019-20/part.0.parquet differ diff --git a/datasets/Talluri2021/outage_report_individual_reports_2019-20/_common_metadata b/datasets/Talluri2021/outage_report_individual_reports_2019-20/_common_metadata new file mode 100644 index 0000000..da2c34c Binary files /dev/null and b/datasets/Talluri2021/outage_report_individual_reports_2019-20/_common_metadata differ diff --git a/datasets/Talluri2021/outage_report_individual_reports_2019-20/_metadata b/datasets/Talluri2021/outage_report_individual_reports_2019-20/_metadata new file mode 100644 index 0000000..8ba4734 Binary files /dev/null and b/datasets/Talluri2021/outage_report_individual_reports_2019-20/_metadata differ diff --git a/datasets/Talluri2021/outage_report_individual_reports_2019-20/part.0.parquet b/datasets/Talluri2021/outage_report_individual_reports_2019-20/part.0.parquet new file mode 100644 index 0000000..4bf904a Binary files /dev/null and b/datasets/Talluri2021/outage_report_individual_reports_2019-20/part.0.parquet differ diff --git a/datasets/Talluri2021/outage_report_instagram.html b/datasets/Talluri2021/outage_report_instagram.html new file mode 100644 index 0000000..f21030d --- /dev/null +++ b/datasets/Talluri2021/outage_report_instagram.html @@ -0,0 +1,970 @@ + + +Instagram Down? Service Status, Map, Problems History - Outage.Report
+

Is Instagram Down Right Now?

See if Instagram is down or having service issues today

0
Reports in last 20 minutes
  • Mobile app not working - 18%
  • Can't upload pics - 18%
  • Mobile app crashes - 18%
  • Can't login - 18%
  • Hashtags not working - 12%
  • Website down - 12%
  • Newsfeed - 6%

Outage History

SepOctNov
+
Reports Dynamics EST (GMT -05:00)
024681013:0016:0019:0022:0001:0004:0007:0010:00
Received 28 reports, originating from
  • Ukraine
  • Russia
  • United States of America
  • Canada
  • Kingdom of Belgium
and 7 more countries
+
Instagram Outage Map
Live
    • Murmansk
    • Can't login
  • 28m
    • Istanbul
    • Newsfeed
  • 33m
    • Astana
    • Mobile app crashes
  • 42m
    • Lebanon
    • Can't upload pics
  • 59m
    • Website down
  • 1h
    • Severomorsk
    • Mobile app not working
  • 1h
+
Discussion

Please don't call "support numbers" + posted below — most probably it's a scam. Make sure to report and +"downvote" such posts. Also don't post any of your personal information.

+
Having problems? Complain here:
Twitter Reaction
View 0 new Tweets
Most Common Report Sources
  • United States of America
  • Ukraine
  • Russia
  • Republic of Uzbekistan
  • Canada
  • Republic of Kazakhstan
  • Netherlands
  • United Kingdom
  • Republic of India
  • Spain
+
+
logo©Outage.Report 2020
\ No newline at end of file diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f31a.png b/datasets/Talluri2021/outage_report_instagram_files/1f31a.png new file mode 100644 index 0000000..e585735 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f31a.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f33b.png b/datasets/Talluri2021/outage_report_instagram_files/1f33b.png new file mode 100644 index 0000000..7770c79 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f33b.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f40e.png b/datasets/Talluri2021/outage_report_instagram_files/1f40e.png new file mode 100644 index 0000000..dc91a0d Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f40e.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f47f.png b/datasets/Talluri2021/outage_report_instagram_files/1f47f.png new file mode 100644 index 0000000..5bc58b3 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f47f.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f517.png b/datasets/Talluri2021/outage_report_instagram_files/1f517.png new file mode 100644 index 0000000..76618cb Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f517.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f614.png b/datasets/Talluri2021/outage_report_instagram_files/1f614.png new file mode 100644 index 0000000..1357dd9 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f614.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f62d.png b/datasets/Talluri2021/outage_report_instagram_files/1f62d.png new file mode 100644 index 0000000..554edf0 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f62d.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f928.png b/datasets/Talluri2021/outage_report_instagram_files/1f928.png new file mode 100644 index 0000000..db22dd7 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f928.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f931-1f3fd.png b/datasets/Talluri2021/outage_report_instagram_files/1f931-1f3fd.png new file mode 100644 index 0000000..c721900 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f931-1f3fd.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/1f98b.png b/datasets/Talluri2021/outage_report_instagram_files/1f98b.png new file mode 100644 index 0000000..3d17d98 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/1f98b.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/5458ac234488de92aa9cda3a-470x290-20200826-010136.jpg b/datasets/Talluri2021/outage_report_instagram_files/5458ac234488de92aa9cda3a-470x290-20200826-010136.jpg new file mode 100644 index 0000000..ee96629 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/5458ac234488de92aa9cda3a-470x290-20200826-010136.jpg differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/Z4Hc2nrF_normal.jpg b/datasets/Talluri2021/outage_report_instagram_files/Z4Hc2nrF_normal.jpg new file mode 100644 index 0000000..1674fa6 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/Z4Hc2nrF_normal.jpg differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/analytics.js b/datasets/Talluri2021/outage_report_instagram_files/analytics.js new file mode 100644 index 0000000..a3203e2 --- /dev/null +++ b/datasets/Talluri2021/outage_report_instagram_files/analytics.js @@ -0,0 +1,86 @@ +/******************************************************************************* + + uBlock Origin - a browser extension to block requests. + Copyright (C) 2019-present Raymond Hill + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see {http://www.gnu.org/licenses/}. + + Home: https://github.com/gorhill/uBlock +*/ + +(function() { + 'use strict'; + // https://developers.google.com/analytics/devguides/collection/analyticsjs/ + const noopfn = function() { + }; + const noopnullfn = function() { + return null; + }; + // + const Tracker = function() { + }; + const p = Tracker.prototype; + p.get = noopfn; + p.set = noopfn; + p.send = noopfn; + // + const w = window; + const gaName = w.GoogleAnalyticsObject || 'ga'; + const gaQueue = w[gaName]; + // https://github.com/uBlockOrigin/uAssets/pull/4115 + const ga = function() { + const len = arguments.length; + if ( len === 0 ) { return; } + const args = Array.from(arguments); + let fn; + let a = args[len-1]; + if ( a instanceof Object && a.hitCallback instanceof Function ) { + fn = a.hitCallback; + } else if ( a instanceof Function ) { + fn = ( ) => { a(ga.create()); }; + } else { + const pos = args.indexOf('hitCallback'); + if ( pos !== -1 && args[pos+1] instanceof Function ) { + fn = args[pos+1]; + } + } + if ( fn instanceof Function === false ) { return; } + try { + fn(); + } catch (ex) { + } + }; + ga.create = function() { + return new Tracker(); + }; + ga.getByName = noopnullfn; + ga.getAll = function() { + return []; + }; + ga.remove = noopfn; + // https://github.com/uBlockOrigin/uAssets/issues/2107 + ga.loaded = true; + w[gaName] = ga; + // https://github.com/gorhill/uBlock/issues/3075 + const dl = w.dataLayer; + if ( dl instanceof Object && dl.hide instanceof Object && typeof dl.hide.end === 'function' ) { + dl.hide.end(); + } + // empty ga queue + if ( gaQueue instanceof Function && Array.isArray(gaQueue.q) ) { + for ( const entry of gaQueue.q ) { + ga(...entry); + } + } +})(); diff --git a/datasets/Talluri2021/outage_report_instagram_files/bootstrap.css b/datasets/Talluri2021/outage_report_instagram_files/bootstrap.css new file mode 100644 index 0000000..ed3905e --- /dev/null +++ b/datasets/Talluri2021/outage_report_instagram_files/bootstrap.css @@ -0,0 +1,6 @@ +/*! + * Bootstrap v3.3.7 (http://getbootstrap.com) + * Copyright 2011-2016 Twitter, Inc. + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) + *//*! normalize.css v3.0.3 | MIT License | github.com/necolas/normalize.css */html{font-family:sans-serif;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,menu,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background-color:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}dfn{font-style:italic}h1{margin:.67em 0;font-size:2em}mark{color:#000;background:#ff0}small{font-size:80%}sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{height:0;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{margin:0;font:inherit;color:inherit}button{overflow:visible}button,select{text-transform:none}button,html input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{padding:0;border:0}input{line-height:normal}input[type=checkbox],input[type=radio]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:0}input[type=number]::-webkit-inner-spin-button,input[type=number]::-webkit-outer-spin-button{height:auto}input[type=search]{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;-webkit-appearance:textfield}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}fieldset{padding:.35em .625em .75em;margin:0 2px;border:1px solid silver}legend{padding:0;border:0}textarea{overflow:auto}optgroup{font-weight:700}table{border-spacing:0;border-collapse:collapse}td,th{padding:0}/*! Source: https://github.com/h5bp/html5-boilerplate/blob/master/src/css/main.css */@media print{*,:after,:before{color:#000!important;text-shadow:none!important;background:0 0!important;-webkit-box-shadow:none!important;box-shadow:none!important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href) ")"}abbr[title]:after{content:" (" attr(title) ")"}a[href^="javascript:"]:after,a[href^="#"]:after{content:""}blockquote,pre{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}h2,h3,p{orphans:3;widows:3}h2,h3{page-break-after:avoid}.navbar{display:none}.btn>.caret,.dropup>.btn>.caret{border-top-color:#000!important}.label{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered td,.table-bordered th{border:1px solid #ddd!important}}@font-face{font-family:'Glyphicons Halflings';src:url(../fonts/glyphicons-halflings-regular.eot);src:url(../fonts/glyphicons-halflings-regular.eot?#iefix) format('embedded-opentype'),url(../fonts/glyphicons-halflings-regular.woff2) format('woff2'),url(../fonts/glyphicons-halflings-regular.woff) format('woff'),url(../fonts/glyphicons-halflings-regular.ttf) format('truetype'),url(../fonts/glyphicons-halflings-regular.svg#glyphicons_halflingsregular) format('svg')}.glyphicon{position:relative;top:1px;display:inline-block;font-family:'Glyphicons Halflings';font-style:normal;font-weight:400;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.glyphicon-asterisk:before{content:"\002a"}.glyphicon-plus:before{content:"\002b"}.glyphicon-eur:before,.glyphicon-euro:before{content:"\20ac"}.glyphicon-minus:before{content:"\2212"}.glyphicon-cloud:before{content:"\2601"}.glyphicon-envelope:before{content:"\2709"}.glyphicon-pencil:before{content:"\270f"}.glyphicon-glass:before{content:"\e001"}.glyphicon-music:before{content:"\e002"}.glyphicon-search:before{content:"\e003"}.glyphicon-heart:before{content:"\e005"}.glyphicon-star:before{content:"\e006"}.glyphicon-star-empty:before{content:"\e007"}.glyphicon-user:before{content:"\e008"}.glyphicon-film:before{content:"\e009"}.glyphicon-th-large:before{content:"\e010"}.glyphicon-th:before{content:"\e011"}.glyphicon-th-list:before{content:"\e012"}.glyphicon-ok:before{content:"\e013"}.glyphicon-remove:before{content:"\e014"}.glyphicon-zoom-in:before{content:"\e015"}.glyphicon-zoom-out:before{content:"\e016"}.glyphicon-off:before{content:"\e017"}.glyphicon-signal:before{content:"\e018"}.glyphicon-cog:before{content:"\e019"}.glyphicon-trash:before{content:"\e020"}.glyphicon-home:before{content:"\e021"}.glyphicon-file:before{content:"\e022"}.glyphicon-time:before{content:"\e023"}.glyphicon-road:before{content:"\e024"}.glyphicon-download-alt:before{content:"\e025"}.glyphicon-download:before{content:"\e026"}.glyphicon-upload:before{content:"\e027"}.glyphicon-inbox:before{content:"\e028"}.glyphicon-play-circle:before{content:"\e029"}.glyphicon-repeat:before{content:"\e030"}.glyphicon-refresh:before{content:"\e031"}.glyphicon-list-alt:before{content:"\e032"}.glyphicon-lock:before{content:"\e033"}.glyphicon-flag:before{content:"\e034"}.glyphicon-headphones:before{content:"\e035"}.glyphicon-volume-off:before{content:"\e036"}.glyphicon-volume-down:before{content:"\e037"}.glyphicon-volume-up:before{content:"\e038"}.glyphicon-qrcode:before{content:"\e039"}.glyphicon-barcode:before{content:"\e040"}.glyphicon-tag:before{content:"\e041"}.glyphicon-tags:before{content:"\e042"}.glyphicon-book:before{content:"\e043"}.glyphicon-bookmark:before{content:"\e044"}.glyphicon-print:before{content:"\e045"}.glyphicon-camera:before{content:"\e046"}.glyphicon-font:before{content:"\e047"}.glyphicon-bold:before{content:"\e048"}.glyphicon-italic:before{content:"\e049"}.glyphicon-text-height:before{content:"\e050"}.glyphicon-text-width:before{content:"\e051"}.glyphicon-align-left:before{content:"\e052"}.glyphicon-align-center:before{content:"\e053"}.glyphicon-align-right:before{content:"\e054"}.glyphicon-align-justify:before{content:"\e055"}.glyphicon-list:before{content:"\e056"}.glyphicon-indent-left:before{content:"\e057"}.glyphicon-indent-right:before{content:"\e058"}.glyphicon-facetime-video:before{content:"\e059"}.glyphicon-picture:before{content:"\e060"}.glyphicon-map-marker:before{content:"\e062"}.glyphicon-adjust:before{content:"\e063"}.glyphicon-tint:before{content:"\e064"}.glyphicon-edit:before{content:"\e065"}.glyphicon-share:before{content:"\e066"}.glyphicon-check:before{content:"\e067"}.glyphicon-move:before{content:"\e068"}.glyphicon-step-backward:before{content:"\e069"}.glyphicon-fast-backward:before{content:"\e070"}.glyphicon-backward:before{content:"\e071"}.glyphicon-play:before{content:"\e072"}.glyphicon-pause:before{content:"\e073"}.glyphicon-stop:before{content:"\e074"}.glyphicon-forward:before{content:"\e075"}.glyphicon-fast-forward:before{content:"\e076"}.glyphicon-step-forward:before{content:"\e077"}.glyphicon-eject:before{content:"\e078"}.glyphicon-chevron-left:before{content:"\e079"}.glyphicon-chevron-right:before{content:"\e080"}.glyphicon-plus-sign:before{content:"\e081"}.glyphicon-minus-sign:before{content:"\e082"}.glyphicon-remove-sign:before{content:"\e083"}.glyphicon-ok-sign:before{content:"\e084"}.glyphicon-question-sign:before{content:"\e085"}.glyphicon-info-sign:before{content:"\e086"}.glyphicon-screenshot:before{content:"\e087"}.glyphicon-remove-circle:before{content:"\e088"}.glyphicon-ok-circle:before{content:"\e089"}.glyphicon-ban-circle:before{content:"\e090"}.glyphicon-arrow-left:before{content:"\e091"}.glyphicon-arrow-right:before{content:"\e092"}.glyphicon-arrow-up:before{content:"\e093"}.glyphicon-arrow-down:before{content:"\e094"}.glyphicon-share-alt:before{content:"\e095"}.glyphicon-resize-full:before{content:"\e096"}.glyphicon-resize-small:before{content:"\e097"}.glyphicon-exclamation-sign:before{content:"\e101"}.glyphicon-gift:before{content:"\e102"}.glyphicon-leaf:before{content:"\e103"}.glyphicon-fire:before{content:"\e104"}.glyphicon-eye-open:before{content:"\e105"}.glyphicon-eye-close:before{content:"\e106"}.glyphicon-warning-sign:before{content:"\e107"}.glyphicon-plane:before{content:"\e108"}.glyphicon-calendar:before{content:"\e109"}.glyphicon-random:before{content:"\e110"}.glyphicon-comment:before{content:"\e111"}.glyphicon-magnet:before{content:"\e112"}.glyphicon-chevron-up:before{content:"\e113"}.glyphicon-chevron-down:before{content:"\e114"}.glyphicon-retweet:before{content:"\e115"}.glyphicon-shopping-cart:before{content:"\e116"}.glyphicon-folder-close:before{content:"\e117"}.glyphicon-folder-open:before{content:"\e118"}.glyphicon-resize-vertical:before{content:"\e119"}.glyphicon-resize-horizontal:before{content:"\e120"}.glyphicon-hdd:before{content:"\e121"}.glyphicon-bullhorn:before{content:"\e122"}.glyphicon-bell:before{content:"\e123"}.glyphicon-certificate:before{content:"\e124"}.glyphicon-thumbs-up:before{content:"\e125"}.glyphicon-thumbs-down:before{content:"\e126"}.glyphicon-hand-right:before{content:"\e127"}.glyphicon-hand-left:before{content:"\e128"}.glyphicon-hand-up:before{content:"\e129"}.glyphicon-hand-down:before{content:"\e130"}.glyphicon-circle-arrow-right:before{content:"\e131"}.glyphicon-circle-arrow-left:before{content:"\e132"}.glyphicon-circle-arrow-up:before{content:"\e133"}.glyphicon-circle-arrow-down:before{content:"\e134"}.glyphicon-globe:before{content:"\e135"}.glyphicon-wrench:before{content:"\e136"}.glyphicon-tasks:before{content:"\e137"}.glyphicon-filter:before{content:"\e138"}.glyphicon-briefcase:before{content:"\e139"}.glyphicon-fullscreen:before{content:"\e140"}.glyphicon-dashboard:before{content:"\e141"}.glyphicon-paperclip:before{content:"\e142"}.glyphicon-heart-empty:before{content:"\e143"}.glyphicon-link:before{content:"\e144"}.glyphicon-phone:before{content:"\e145"}.glyphicon-pushpin:before{content:"\e146"}.glyphicon-usd:before{content:"\e148"}.glyphicon-gbp:before{content:"\e149"}.glyphicon-sort:before{content:"\e150"}.glyphicon-sort-by-alphabet:before{content:"\e151"}.glyphicon-sort-by-alphabet-alt:before{content:"\e152"}.glyphicon-sort-by-order:before{content:"\e153"}.glyphicon-sort-by-order-alt:before{content:"\e154"}.glyphicon-sort-by-attributes:before{content:"\e155"}.glyphicon-sort-by-attributes-alt:before{content:"\e156"}.glyphicon-unchecked:before{content:"\e157"}.glyphicon-expand:before{content:"\e158"}.glyphicon-collapse-down:before{content:"\e159"}.glyphicon-collapse-up:before{content:"\e160"}.glyphicon-log-in:before{content:"\e161"}.glyphicon-flash:before{content:"\e162"}.glyphicon-log-out:before{content:"\e163"}.glyphicon-new-window:before{content:"\e164"}.glyphicon-record:before{content:"\e165"}.glyphicon-save:before{content:"\e166"}.glyphicon-open:before{content:"\e167"}.glyphicon-saved:before{content:"\e168"}.glyphicon-import:before{content:"\e169"}.glyphicon-export:before{content:"\e170"}.glyphicon-send:before{content:"\e171"}.glyphicon-floppy-disk:before{content:"\e172"}.glyphicon-floppy-saved:before{content:"\e173"}.glyphicon-floppy-remove:before{content:"\e174"}.glyphicon-floppy-save:before{content:"\e175"}.glyphicon-floppy-open:before{content:"\e176"}.glyphicon-credit-card:before{content:"\e177"}.glyphicon-transfer:before{content:"\e178"}.glyphicon-cutlery:before{content:"\e179"}.glyphicon-header:before{content:"\e180"}.glyphicon-compressed:before{content:"\e181"}.glyphicon-earphone:before{content:"\e182"}.glyphicon-phone-alt:before{content:"\e183"}.glyphicon-tower:before{content:"\e184"}.glyphicon-stats:before{content:"\e185"}.glyphicon-sd-video:before{content:"\e186"}.glyphicon-hd-video:before{content:"\e187"}.glyphicon-subtitles:before{content:"\e188"}.glyphicon-sound-stereo:before{content:"\e189"}.glyphicon-sound-dolby:before{content:"\e190"}.glyphicon-sound-5-1:before{content:"\e191"}.glyphicon-sound-6-1:before{content:"\e192"}.glyphicon-sound-7-1:before{content:"\e193"}.glyphicon-copyright-mark:before{content:"\e194"}.glyphicon-registration-mark:before{content:"\e195"}.glyphicon-cloud-download:before{content:"\e197"}.glyphicon-cloud-upload:before{content:"\e198"}.glyphicon-tree-conifer:before{content:"\e199"}.glyphicon-tree-deciduous:before{content:"\e200"}.glyphicon-cd:before{content:"\e201"}.glyphicon-save-file:before{content:"\e202"}.glyphicon-open-file:before{content:"\e203"}.glyphicon-level-up:before{content:"\e204"}.glyphicon-copy:before{content:"\e205"}.glyphicon-paste:before{content:"\e206"}.glyphicon-alert:before{content:"\e209"}.glyphicon-equalizer:before{content:"\e210"}.glyphicon-king:before{content:"\e211"}.glyphicon-queen:before{content:"\e212"}.glyphicon-pawn:before{content:"\e213"}.glyphicon-bishop:before{content:"\e214"}.glyphicon-knight:before{content:"\e215"}.glyphicon-baby-formula:before{content:"\e216"}.glyphicon-tent:before{content:"\26fa"}.glyphicon-blackboard:before{content:"\e218"}.glyphicon-bed:before{content:"\e219"}.glyphicon-apple:before{content:"\f8ff"}.glyphicon-erase:before{content:"\e221"}.glyphicon-hourglass:before{content:"\231b"}.glyphicon-lamp:before{content:"\e223"}.glyphicon-duplicate:before{content:"\e224"}.glyphicon-piggy-bank:before{content:"\e225"}.glyphicon-scissors:before{content:"\e226"}.glyphicon-bitcoin:before{content:"\e227"}.glyphicon-btc:before{content:"\e227"}.glyphicon-xbt:before{content:"\e227"}.glyphicon-yen:before{content:"\00a5"}.glyphicon-jpy:before{content:"\00a5"}.glyphicon-ruble:before{content:"\20bd"}.glyphicon-rub:before{content:"\20bd"}.glyphicon-scale:before{content:"\e230"}.glyphicon-ice-lolly:before{content:"\e231"}.glyphicon-ice-lolly-tasted:before{content:"\e232"}.glyphicon-education:before{content:"\e233"}.glyphicon-option-horizontal:before{content:"\e234"}.glyphicon-option-vertical:before{content:"\e235"}.glyphicon-menu-hamburger:before{content:"\e236"}.glyphicon-modal-window:before{content:"\e237"}.glyphicon-oil:before{content:"\e238"}.glyphicon-grain:before{content:"\e239"}.glyphicon-sunglasses:before{content:"\e240"}.glyphicon-text-size:before{content:"\e241"}.glyphicon-text-color:before{content:"\e242"}.glyphicon-text-background:before{content:"\e243"}.glyphicon-object-align-top:before{content:"\e244"}.glyphicon-object-align-bottom:before{content:"\e245"}.glyphicon-object-align-horizontal:before{content:"\e246"}.glyphicon-object-align-left:before{content:"\e247"}.glyphicon-object-align-vertical:before{content:"\e248"}.glyphicon-object-align-right:before{content:"\e249"}.glyphicon-triangle-right:before{content:"\e250"}.glyphicon-triangle-left:before{content:"\e251"}.glyphicon-triangle-bottom:before{content:"\e252"}.glyphicon-triangle-top:before{content:"\e253"}.glyphicon-console:before{content:"\e254"}.glyphicon-superscript:before{content:"\e255"}.glyphicon-subscript:before{content:"\e256"}.glyphicon-menu-left:before{content:"\e257"}.glyphicon-menu-right:before{content:"\e258"}.glyphicon-menu-down:before{content:"\e259"}.glyphicon-menu-up:before{content:"\e260"}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}:after,:before{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:10px;-webkit-tap-highlight-color:rgba(0,0,0,0)}body{font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:14px;line-height:1.42857143;color:#333;background-color:#fff}button,input,select,textarea{font-family:inherit;font-size:inherit;line-height:inherit}a{color:#337ab7;text-decoration:none}a:focus,a:hover{color:#23527c;text-decoration:underline}a:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}figure{margin:0}img{vertical-align:middle}.carousel-inner>.item>a>img,.carousel-inner>.item>img,.img-responsive,.thumbnail a>img,.thumbnail>img{display:block;max-width:100%;height:auto}.img-rounded{border-radius:6px}.img-thumbnail{display:inline-block;max-width:100%;height:auto;padding:4px;line-height:1.42857143;background-color:#fff;border:1px solid #ddd;border-radius:4px;-webkit-transition:all .2s ease-in-out;-o-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.img-circle{border-radius:50%}hr{margin-top:20px;margin-bottom:20px;border:0;border-top:1px solid #eee}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}[role=button]{cursor:pointer}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{font-family:inherit;font-weight:500;line-height:1.1;color:inherit}.h1 .small,.h1 small,.h2 .small,.h2 small,.h3 .small,.h3 small,.h4 .small,.h4 small,.h5 .small,.h5 small,.h6 .small,.h6 small,h1 .small,h1 small,h2 .small,h2 small,h3 .small,h3 small,h4 .small,h4 small,h5 .small,h5 small,h6 .small,h6 small{font-weight:400;line-height:1;color:#777}.h1,.h2,.h3,h1,h2,h3{margin-top:20px;margin-bottom:10px}.h1 .small,.h1 small,.h2 .small,.h2 small,.h3 .small,.h3 small,h1 .small,h1 small,h2 .small,h2 small,h3 .small,h3 small{font-size:65%}.h4,.h5,.h6,h4,h5,h6{margin-top:10px;margin-bottom:10px}.h4 .small,.h4 small,.h5 .small,.h5 small,.h6 .small,.h6 small,h4 .small,h4 small,h5 .small,h5 small,h6 .small,h6 small{font-size:75%}.h1,h1{font-size:36px}.h2,h2{font-size:30px}.h3,h3{font-size:24px}.h4,h4{font-size:18px}.h5,h5{font-size:14px}.h6,h6{font-size:12px}p{margin:0 0 10px}.lead{margin-bottom:20px;font-size:16px;font-weight:300;line-height:1.4}@media (min-width:768px){.lead{font-size:21px}}.small,small{font-size:85%}.mark,mark{padding:.2em;background-color:#fcf8e3}.text-left{text-align:left}.text-right{text-align:right}.text-center{text-align:center}.text-justify{text-align:justify}.text-nowrap{white-space:nowrap}.text-lowercase{text-transform:lowercase}.text-uppercase{text-transform:uppercase}.text-capitalize{text-transform:capitalize}.text-muted{color:#777}.text-primary{color:#337ab7}a.text-primary:focus,a.text-primary:hover{color:#286090}.text-success{color:#3c763d}a.text-success:focus,a.text-success:hover{color:#2b542c}.text-info{color:#31708f}a.text-info:focus,a.text-info:hover{color:#245269}.text-warning{color:#8a6d3b}a.text-warning:focus,a.text-warning:hover{color:#66512c}.text-danger{color:#a94442}a.text-danger:focus,a.text-danger:hover{color:#843534}.bg-primary{color:#fff;background-color:#337ab7}a.bg-primary:focus,a.bg-primary:hover{background-color:#286090}.bg-success{background-color:#dff0d8}a.bg-success:focus,a.bg-success:hover{background-color:#c1e2b3}.bg-info{background-color:#d9edf7}a.bg-info:focus,a.bg-info:hover{background-color:#afd9ee}.bg-warning{background-color:#fcf8e3}a.bg-warning:focus,a.bg-warning:hover{background-color:#f7ecb5}.bg-danger{background-color:#f2dede}a.bg-danger:focus,a.bg-danger:hover{background-color:#e4b9b9}.page-header{padding-bottom:9px;margin:40px 0 20px;border-bottom:1px solid #eee}ol,ul{margin-top:0;margin-bottom:10px}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}.list-unstyled{padding-left:0;list-style:none}.list-inline{padding-left:0;margin-left:-5px;list-style:none}.list-inline>li{display:inline-block;padding-right:5px;padding-left:5px}dl{margin-top:0;margin-bottom:20px}dd,dt{line-height:1.42857143}dt{font-weight:700}dd{margin-left:0}@media (min-width:768px){.dl-horizontal dt{float:left;width:160px;overflow:hidden;clear:left;text-align:right;text-overflow:ellipsis;white-space:nowrap}.dl-horizontal dd{margin-left:180px}}abbr[data-original-title],abbr[title]{cursor:help;border-bottom:1px dotted #777}.initialism{font-size:90%;text-transform:uppercase}blockquote{padding:10px 20px;margin:0 0 20px;font-size:17.5px;border-left:5px solid #eee}blockquote ol:last-child,blockquote p:last-child,blockquote ul:last-child{margin-bottom:0}blockquote .small,blockquote footer,blockquote small{display:block;font-size:80%;line-height:1.42857143;color:#777}blockquote .small:before,blockquote footer:before,blockquote small:before{content:'\2014 \00A0'}.blockquote-reverse,blockquote.pull-right{padding-right:15px;padding-left:0;text-align:right;border-right:5px solid #eee;border-left:0}.blockquote-reverse .small:before,.blockquote-reverse footer:before,.blockquote-reverse small:before,blockquote.pull-right .small:before,blockquote.pull-right footer:before,blockquote.pull-right small:before{content:''}.blockquote-reverse .small:after,.blockquote-reverse footer:after,.blockquote-reverse small:after,blockquote.pull-right .small:after,blockquote.pull-right footer:after,blockquote.pull-right small:after{content:'\00A0 \2014'}address{margin-bottom:20px;font-style:normal;line-height:1.42857143}code,kbd,pre,samp{font-family:Menlo,Monaco,Consolas,"Courier New",monospace}code{padding:2px 4px;font-size:90%;color:#c7254e;background-color:#f9f2f4;border-radius:4px}kbd{padding:2px 4px;font-size:90%;color:#fff;background-color:#333;border-radius:3px;-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,.25);box-shadow:inset 0 -1px 0 rgba(0,0,0,.25)}kbd kbd{padding:0;font-size:100%;font-weight:700;-webkit-box-shadow:none;box-shadow:none}pre{display:block;padding:9.5px;margin:0 0 10px;font-size:13px;line-height:1.42857143;color:#333;word-break:break-all;word-wrap:break-word;background-color:#f5f5f5;border:1px solid #ccc;border-radius:4px}pre code{padding:0;font-size:inherit;color:inherit;white-space:pre-wrap;background-color:transparent;border-radius:0}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}@media (min-width:768px){.container{width:750px}}@media (min-width:992px){.container{width:970px}}@media (min-width:1200px){.container{width:1170px}}.container-fluid{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}.row{margin-right:-15px;margin-left:-15px}.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-xs-1,.col-xs-10,.col-xs-11,.col-xs-12,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9{position:relative;min-height:1px;padding-right:15px;padding-left:15px}.col-xs-1,.col-xs-10,.col-xs-11,.col-xs-12,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9{float:left}.col-xs-12{width:100%}.col-xs-11{width:91.66666667%}.col-xs-10{width:83.33333333%}.col-xs-9{width:75%}.col-xs-8{width:66.66666667%}.col-xs-7{width:58.33333333%}.col-xs-6{width:50%}.col-xs-5{width:41.66666667%}.col-xs-4{width:33.33333333%}.col-xs-3{width:25%}.col-xs-2{width:16.66666667%}.col-xs-1{width:8.33333333%}.col-xs-pull-12{right:100%}.col-xs-pull-11{right:91.66666667%}.col-xs-pull-10{right:83.33333333%}.col-xs-pull-9{right:75%}.col-xs-pull-8{right:66.66666667%}.col-xs-pull-7{right:58.33333333%}.col-xs-pull-6{right:50%}.col-xs-pull-5{right:41.66666667%}.col-xs-pull-4{right:33.33333333%}.col-xs-pull-3{right:25%}.col-xs-pull-2{right:16.66666667%}.col-xs-pull-1{right:8.33333333%}.col-xs-pull-0{right:auto}.col-xs-push-12{left:100%}.col-xs-push-11{left:91.66666667%}.col-xs-push-10{left:83.33333333%}.col-xs-push-9{left:75%}.col-xs-push-8{left:66.66666667%}.col-xs-push-7{left:58.33333333%}.col-xs-push-6{left:50%}.col-xs-push-5{left:41.66666667%}.col-xs-push-4{left:33.33333333%}.col-xs-push-3{left:25%}.col-xs-push-2{left:16.66666667%}.col-xs-push-1{left:8.33333333%}.col-xs-push-0{left:auto}.col-xs-offset-12{margin-left:100%}.col-xs-offset-11{margin-left:91.66666667%}.col-xs-offset-10{margin-left:83.33333333%}.col-xs-offset-9{margin-left:75%}.col-xs-offset-8{margin-left:66.66666667%}.col-xs-offset-7{margin-left:58.33333333%}.col-xs-offset-6{margin-left:50%}.col-xs-offset-5{margin-left:41.66666667%}.col-xs-offset-4{margin-left:33.33333333%}.col-xs-offset-3{margin-left:25%}.col-xs-offset-2{margin-left:16.66666667%}.col-xs-offset-1{margin-left:8.33333333%}.col-xs-offset-0{margin-left:0}@media (min-width:768px){.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9{float:left}.col-sm-12{width:100%}.col-sm-11{width:91.66666667%}.col-sm-10{width:83.33333333%}.col-sm-9{width:75%}.col-sm-8{width:66.66666667%}.col-sm-7{width:58.33333333%}.col-sm-6{width:50%}.col-sm-5{width:41.66666667%}.col-sm-4{width:33.33333333%}.col-sm-3{width:25%}.col-sm-2{width:16.66666667%}.col-sm-1{width:8.33333333%}.col-sm-pull-12{right:100%}.col-sm-pull-11{right:91.66666667%}.col-sm-pull-10{right:83.33333333%}.col-sm-pull-9{right:75%}.col-sm-pull-8{right:66.66666667%}.col-sm-pull-7{right:58.33333333%}.col-sm-pull-6{right:50%}.col-sm-pull-5{right:41.66666667%}.col-sm-pull-4{right:33.33333333%}.col-sm-pull-3{right:25%}.col-sm-pull-2{right:16.66666667%}.col-sm-pull-1{right:8.33333333%}.col-sm-pull-0{right:auto}.col-sm-push-12{left:100%}.col-sm-push-11{left:91.66666667%}.col-sm-push-10{left:83.33333333%}.col-sm-push-9{left:75%}.col-sm-push-8{left:66.66666667%}.col-sm-push-7{left:58.33333333%}.col-sm-push-6{left:50%}.col-sm-push-5{left:41.66666667%}.col-sm-push-4{left:33.33333333%}.col-sm-push-3{left:25%}.col-sm-push-2{left:16.66666667%}.col-sm-push-1{left:8.33333333%}.col-sm-push-0{left:auto}.col-sm-offset-12{margin-left:100%}.col-sm-offset-11{margin-left:91.66666667%}.col-sm-offset-10{margin-left:83.33333333%}.col-sm-offset-9{margin-left:75%}.col-sm-offset-8{margin-left:66.66666667%}.col-sm-offset-7{margin-left:58.33333333%}.col-sm-offset-6{margin-left:50%}.col-sm-offset-5{margin-left:41.66666667%}.col-sm-offset-4{margin-left:33.33333333%}.col-sm-offset-3{margin-left:25%}.col-sm-offset-2{margin-left:16.66666667%}.col-sm-offset-1{margin-left:8.33333333%}.col-sm-offset-0{margin-left:0}}@media (min-width:992px){.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9{float:left}.col-md-12{width:100%}.col-md-11{width:91.66666667%}.col-md-10{width:83.33333333%}.col-md-9{width:75%}.col-md-8{width:66.66666667%}.col-md-7{width:58.33333333%}.col-md-6{width:50%}.col-md-5{width:41.66666667%}.col-md-4{width:33.33333333%}.col-md-3{width:25%}.col-md-2{width:16.66666667%}.col-md-1{width:8.33333333%}.col-md-pull-12{right:100%}.col-md-pull-11{right:91.66666667%}.col-md-pull-10{right:83.33333333%}.col-md-pull-9{right:75%}.col-md-pull-8{right:66.66666667%}.col-md-pull-7{right:58.33333333%}.col-md-pull-6{right:50%}.col-md-pull-5{right:41.66666667%}.col-md-pull-4{right:33.33333333%}.col-md-pull-3{right:25%}.col-md-pull-2{right:16.66666667%}.col-md-pull-1{right:8.33333333%}.col-md-pull-0{right:auto}.col-md-push-12{left:100%}.col-md-push-11{left:91.66666667%}.col-md-push-10{left:83.33333333%}.col-md-push-9{left:75%}.col-md-push-8{left:66.66666667%}.col-md-push-7{left:58.33333333%}.col-md-push-6{left:50%}.col-md-push-5{left:41.66666667%}.col-md-push-4{left:33.33333333%}.col-md-push-3{left:25%}.col-md-push-2{left:16.66666667%}.col-md-push-1{left:8.33333333%}.col-md-push-0{left:auto}.col-md-offset-12{margin-left:100%}.col-md-offset-11{margin-left:91.66666667%}.col-md-offset-10{margin-left:83.33333333%}.col-md-offset-9{margin-left:75%}.col-md-offset-8{margin-left:66.66666667%}.col-md-offset-7{margin-left:58.33333333%}.col-md-offset-6{margin-left:50%}.col-md-offset-5{margin-left:41.66666667%}.col-md-offset-4{margin-left:33.33333333%}.col-md-offset-3{margin-left:25%}.col-md-offset-2{margin-left:16.66666667%}.col-md-offset-1{margin-left:8.33333333%}.col-md-offset-0{margin-left:0}}@media (min-width:1200px){.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9{float:left}.col-lg-12{width:100%}.col-lg-11{width:91.66666667%}.col-lg-10{width:83.33333333%}.col-lg-9{width:75%}.col-lg-8{width:66.66666667%}.col-lg-7{width:58.33333333%}.col-lg-6{width:50%}.col-lg-5{width:41.66666667%}.col-lg-4{width:33.33333333%}.col-lg-3{width:25%}.col-lg-2{width:16.66666667%}.col-lg-1{width:8.33333333%}.col-lg-pull-12{right:100%}.col-lg-pull-11{right:91.66666667%}.col-lg-pull-10{right:83.33333333%}.col-lg-pull-9{right:75%}.col-lg-pull-8{right:66.66666667%}.col-lg-pull-7{right:58.33333333%}.col-lg-pull-6{right:50%}.col-lg-pull-5{right:41.66666667%}.col-lg-pull-4{right:33.33333333%}.col-lg-pull-3{right:25%}.col-lg-pull-2{right:16.66666667%}.col-lg-pull-1{right:8.33333333%}.col-lg-pull-0{right:auto}.col-lg-push-12{left:100%}.col-lg-push-11{left:91.66666667%}.col-lg-push-10{left:83.33333333%}.col-lg-push-9{left:75%}.col-lg-push-8{left:66.66666667%}.col-lg-push-7{left:58.33333333%}.col-lg-push-6{left:50%}.col-lg-push-5{left:41.66666667%}.col-lg-push-4{left:33.33333333%}.col-lg-push-3{left:25%}.col-lg-push-2{left:16.66666667%}.col-lg-push-1{left:8.33333333%}.col-lg-push-0{left:auto}.col-lg-offset-12{margin-left:100%}.col-lg-offset-11{margin-left:91.66666667%}.col-lg-offset-10{margin-left:83.33333333%}.col-lg-offset-9{margin-left:75%}.col-lg-offset-8{margin-left:66.66666667%}.col-lg-offset-7{margin-left:58.33333333%}.col-lg-offset-6{margin-left:50%}.col-lg-offset-5{margin-left:41.66666667%}.col-lg-offset-4{margin-left:33.33333333%}.col-lg-offset-3{margin-left:25%}.col-lg-offset-2{margin-left:16.66666667%}.col-lg-offset-1{margin-left:8.33333333%}.col-lg-offset-0{margin-left:0}}table{background-color:transparent}caption{padding-top:8px;padding-bottom:8px;color:#777;text-align:left}th{text-align:left}.table{width:100%;max-width:100%;margin-bottom:20px}.table>tbody>tr>td,.table>tbody>tr>th,.table>tfoot>tr>td,.table>tfoot>tr>th,.table>thead>tr>td,.table>thead>tr>th{padding:8px;line-height:1.42857143;vertical-align:top;border-top:1px solid #ddd}.table>thead>tr>th{vertical-align:bottom;border-bottom:2px solid #ddd}.table>caption+thead>tr:first-child>td,.table>caption+thead>tr:first-child>th,.table>colgroup+thead>tr:first-child>td,.table>colgroup+thead>tr:first-child>th,.table>thead:first-child>tr:first-child>td,.table>thead:first-child>tr:first-child>th{border-top:0}.table>tbody+tbody{border-top:2px solid #ddd}.table .table{background-color:#fff}.table-condensed>tbody>tr>td,.table-condensed>tbody>tr>th,.table-condensed>tfoot>tr>td,.table-condensed>tfoot>tr>th,.table-condensed>thead>tr>td,.table-condensed>thead>tr>th{padding:5px}.table-bordered{border:1px solid #ddd}.table-bordered>tbody>tr>td,.table-bordered>tbody>tr>th,.table-bordered>tfoot>tr>td,.table-bordered>tfoot>tr>th,.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border:1px solid #ddd}.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border-bottom-width:2px}.table-striped>tbody>tr:nth-of-type(odd){background-color:#f9f9f9}.table-hover>tbody>tr:hover{background-color:#f5f5f5}table col[class*=col-]{position:static;display:table-column;float:none}table td[class*=col-],table th[class*=col-]{position:static;display:table-cell;float:none}.table>tbody>tr.active>td,.table>tbody>tr.active>th,.table>tbody>tr>td.active,.table>tbody>tr>th.active,.table>tfoot>tr.active>td,.table>tfoot>tr.active>th,.table>tfoot>tr>td.active,.table>tfoot>tr>th.active,.table>thead>tr.active>td,.table>thead>tr.active>th,.table>thead>tr>td.active,.table>thead>tr>th.active{background-color:#f5f5f5}.table-hover>tbody>tr.active:hover>td,.table-hover>tbody>tr.active:hover>th,.table-hover>tbody>tr:hover>.active,.table-hover>tbody>tr>td.active:hover,.table-hover>tbody>tr>th.active:hover{background-color:#e8e8e8}.table>tbody>tr.success>td,.table>tbody>tr.success>th,.table>tbody>tr>td.success,.table>tbody>tr>th.success,.table>tfoot>tr.success>td,.table>tfoot>tr.success>th,.table>tfoot>tr>td.success,.table>tfoot>tr>th.success,.table>thead>tr.success>td,.table>thead>tr.success>th,.table>thead>tr>td.success,.table>thead>tr>th.success{background-color:#dff0d8}.table-hover>tbody>tr.success:hover>td,.table-hover>tbody>tr.success:hover>th,.table-hover>tbody>tr:hover>.success,.table-hover>tbody>tr>td.success:hover,.table-hover>tbody>tr>th.success:hover{background-color:#d0e9c6}.table>tbody>tr.info>td,.table>tbody>tr.info>th,.table>tbody>tr>td.info,.table>tbody>tr>th.info,.table>tfoot>tr.info>td,.table>tfoot>tr.info>th,.table>tfoot>tr>td.info,.table>tfoot>tr>th.info,.table>thead>tr.info>td,.table>thead>tr.info>th,.table>thead>tr>td.info,.table>thead>tr>th.info{background-color:#d9edf7}.table-hover>tbody>tr.info:hover>td,.table-hover>tbody>tr.info:hover>th,.table-hover>tbody>tr:hover>.info,.table-hover>tbody>tr>td.info:hover,.table-hover>tbody>tr>th.info:hover{background-color:#c4e3f3}.table>tbody>tr.warning>td,.table>tbody>tr.warning>th,.table>tbody>tr>td.warning,.table>tbody>tr>th.warning,.table>tfoot>tr.warning>td,.table>tfoot>tr.warning>th,.table>tfoot>tr>td.warning,.table>tfoot>tr>th.warning,.table>thead>tr.warning>td,.table>thead>tr.warning>th,.table>thead>tr>td.warning,.table>thead>tr>th.warning{background-color:#fcf8e3}.table-hover>tbody>tr.warning:hover>td,.table-hover>tbody>tr.warning:hover>th,.table-hover>tbody>tr:hover>.warning,.table-hover>tbody>tr>td.warning:hover,.table-hover>tbody>tr>th.warning:hover{background-color:#faf2cc}.table>tbody>tr.danger>td,.table>tbody>tr.danger>th,.table>tbody>tr>td.danger,.table>tbody>tr>th.danger,.table>tfoot>tr.danger>td,.table>tfoot>tr.danger>th,.table>tfoot>tr>td.danger,.table>tfoot>tr>th.danger,.table>thead>tr.danger>td,.table>thead>tr.danger>th,.table>thead>tr>td.danger,.table>thead>tr>th.danger{background-color:#f2dede}.table-hover>tbody>tr.danger:hover>td,.table-hover>tbody>tr.danger:hover>th,.table-hover>tbody>tr:hover>.danger,.table-hover>tbody>tr>td.danger:hover,.table-hover>tbody>tr>th.danger:hover{background-color:#ebcccc}.table-responsive{min-height:.01%;overflow-x:auto}@media screen and (max-width:767px){.table-responsive{width:100%;margin-bottom:15px;overflow-y:hidden;-ms-overflow-style:-ms-autohiding-scrollbar;border:1px solid #ddd}.table-responsive>.table{margin-bottom:0}.table-responsive>.table>tbody>tr>td,.table-responsive>.table>tbody>tr>th,.table-responsive>.table>tfoot>tr>td,.table-responsive>.table>tfoot>tr>th,.table-responsive>.table>thead>tr>td,.table-responsive>.table>thead>tr>th{white-space:nowrap}.table-responsive>.table-bordered{border:0}.table-responsive>.table-bordered>tbody>tr>td:first-child,.table-responsive>.table-bordered>tbody>tr>th:first-child,.table-responsive>.table-bordered>tfoot>tr>td:first-child,.table-responsive>.table-bordered>tfoot>tr>th:first-child,.table-responsive>.table-bordered>thead>tr>td:first-child,.table-responsive>.table-bordered>thead>tr>th:first-child{border-left:0}.table-responsive>.table-bordered>tbody>tr>td:last-child,.table-responsive>.table-bordered>tbody>tr>th:last-child,.table-responsive>.table-bordered>tfoot>tr>td:last-child,.table-responsive>.table-bordered>tfoot>tr>th:last-child,.table-responsive>.table-bordered>thead>tr>td:last-child,.table-responsive>.table-bordered>thead>tr>th:last-child{border-right:0}.table-responsive>.table-bordered>tbody>tr:last-child>td,.table-responsive>.table-bordered>tbody>tr:last-child>th,.table-responsive>.table-bordered>tfoot>tr:last-child>td,.table-responsive>.table-bordered>tfoot>tr:last-child>th{border-bottom:0}}fieldset{min-width:0;padding:0;margin:0;border:0}legend{display:block;width:100%;padding:0;margin-bottom:20px;font-size:21px;line-height:inherit;color:#333;border:0;border-bottom:1px solid #e5e5e5}label{display:inline-block;max-width:100%;margin-bottom:5px;font-weight:700}input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=checkbox],input[type=radio]{margin:4px 0 0;margin-top:1px\9;line-height:normal}input[type=file]{display:block}input[type=range]{display:block;width:100%}select[multiple],select[size]{height:auto}input[type=file]:focus,input[type=checkbox]:focus,input[type=radio]:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}output{display:block;padding-top:7px;font-size:14px;line-height:1.42857143;color:#555}.form-control{display:block;width:100%;height:34px;padding:6px 12px;font-size:14px;line-height:1.42857143;color:#555;background-color:#fff;background-image:none;border:1px solid #ccc;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075);-webkit-transition:border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;-o-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s}.form-control:focus{border-color:#66afe9;outline:0;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6);box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6)}.form-control::-moz-placeholder{color:#999;opacity:1}.form-control:-ms-input-placeholder{color:#999}.form-control::-webkit-input-placeholder{color:#999}.form-control::-ms-expand{background-color:transparent;border:0}.form-control[disabled],.form-control[readonly],fieldset[disabled] .form-control{background-color:#eee;opacity:1}.form-control[disabled],fieldset[disabled] .form-control{cursor:not-allowed}textarea.form-control{height:auto}input[type=search]{-webkit-appearance:none}@media screen and (-webkit-min-device-pixel-ratio:0){input[type=date].form-control,input[type=time].form-control,input[type=datetime-local].form-control,input[type=month].form-control{line-height:34px}.input-group-sm input[type=date],.input-group-sm input[type=time],.input-group-sm input[type=datetime-local],.input-group-sm input[type=month],input[type=date].input-sm,input[type=time].input-sm,input[type=datetime-local].input-sm,input[type=month].input-sm{line-height:30px}.input-group-lg input[type=date],.input-group-lg input[type=time],.input-group-lg input[type=datetime-local],.input-group-lg input[type=month],input[type=date].input-lg,input[type=time].input-lg,input[type=datetime-local].input-lg,input[type=month].input-lg{line-height:46px}}.form-group{margin-bottom:15px}.checkbox,.radio{position:relative;display:block;margin-top:10px;margin-bottom:10px}.checkbox label,.radio label{min-height:20px;padding-left:20px;margin-bottom:0;font-weight:400;cursor:pointer}.checkbox input[type=checkbox],.checkbox-inline input[type=checkbox],.radio input[type=radio],.radio-inline input[type=radio]{position:absolute;margin-top:4px\9;margin-left:-20px}.checkbox+.checkbox,.radio+.radio{margin-top:-5px}.checkbox-inline,.radio-inline{position:relative;display:inline-block;padding-left:20px;margin-bottom:0;font-weight:400;vertical-align:middle;cursor:pointer}.checkbox-inline+.checkbox-inline,.radio-inline+.radio-inline{margin-top:0;margin-left:10px}fieldset[disabled] input[type=checkbox],fieldset[disabled] input[type=radio],input[type=checkbox].disabled,input[type=checkbox][disabled],input[type=radio].disabled,input[type=radio][disabled]{cursor:not-allowed}.checkbox-inline.disabled,.radio-inline.disabled,fieldset[disabled] .checkbox-inline,fieldset[disabled] .radio-inline{cursor:not-allowed}.checkbox.disabled label,.radio.disabled label,fieldset[disabled] .checkbox label,fieldset[disabled] .radio label{cursor:not-allowed}.form-control-static{min-height:34px;padding-top:7px;padding-bottom:7px;margin-bottom:0}.form-control-static.input-lg,.form-control-static.input-sm{padding-right:0;padding-left:0}.input-sm{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}select.input-sm{height:30px;line-height:30px}select[multiple].input-sm,textarea.input-sm{height:auto}.form-group-sm .form-control{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.form-group-sm select.form-control{height:30px;line-height:30px}.form-group-sm select[multiple].form-control,.form-group-sm textarea.form-control{height:auto}.form-group-sm .form-control-static{height:30px;min-height:32px;padding:6px 10px;font-size:12px;line-height:1.5}.input-lg{height:46px;padding:10px 16px;font-size:18px;line-height:1.3333333;border-radius:6px}select.input-lg{height:46px;line-height:46px}select[multiple].input-lg,textarea.input-lg{height:auto}.form-group-lg .form-control{height:46px;padding:10px 16px;font-size:18px;line-height:1.3333333;border-radius:6px}.form-group-lg select.form-control{height:46px;line-height:46px}.form-group-lg select[multiple].form-control,.form-group-lg textarea.form-control{height:auto}.form-group-lg .form-control-static{height:46px;min-height:38px;padding:11px 16px;font-size:18px;line-height:1.3333333}.has-feedback{position:relative}.has-feedback .form-control{padding-right:42.5px}.form-control-feedback{position:absolute;top:0;right:0;z-index:2;display:block;width:34px;height:34px;line-height:34px;text-align:center;pointer-events:none}.form-group-lg .form-control+.form-control-feedback,.input-group-lg+.form-control-feedback,.input-lg+.form-control-feedback{width:46px;height:46px;line-height:46px}.form-group-sm .form-control+.form-control-feedback,.input-group-sm+.form-control-feedback,.input-sm+.form-control-feedback{width:30px;height:30px;line-height:30px}.has-success .checkbox,.has-success .checkbox-inline,.has-success .control-label,.has-success .help-block,.has-success .radio,.has-success .radio-inline,.has-success.checkbox label,.has-success.checkbox-inline label,.has-success.radio label,.has-success.radio-inline label{color:#3c763d}.has-success .form-control{border-color:#3c763d;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-success .form-control:focus{border-color:#2b542c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168}.has-success .input-group-addon{color:#3c763d;background-color:#dff0d8;border-color:#3c763d}.has-success .form-control-feedback{color:#3c763d}.has-warning .checkbox,.has-warning .checkbox-inline,.has-warning .control-label,.has-warning .help-block,.has-warning .radio,.has-warning .radio-inline,.has-warning.checkbox label,.has-warning.checkbox-inline label,.has-warning.radio label,.has-warning.radio-inline label{color:#8a6d3b}.has-warning .form-control{border-color:#8a6d3b;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-warning .form-control:focus{border-color:#66512c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b}.has-warning .input-group-addon{color:#8a6d3b;background-color:#fcf8e3;border-color:#8a6d3b}.has-warning .form-control-feedback{color:#8a6d3b}.has-error .checkbox,.has-error .checkbox-inline,.has-error .control-label,.has-error .help-block,.has-error .radio,.has-error .radio-inline,.has-error.checkbox label,.has-error.checkbox-inline label,.has-error.radio label,.has-error.radio-inline label{color:#a94442}.has-error .form-control{border-color:#a94442;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-error .form-control:focus{border-color:#843534;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483}.has-error .input-group-addon{color:#a94442;background-color:#f2dede;border-color:#a94442}.has-error .form-control-feedback{color:#a94442}.has-feedback label~.form-control-feedback{top:25px}.has-feedback label.sr-only~.form-control-feedback{top:0}.help-block{display:block;margin-top:5px;margin-bottom:10px;color:#737373}@media (min-width:768px){.form-inline .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.form-inline .form-control{display:inline-block;width:auto;vertical-align:middle}.form-inline .form-control-static{display:inline-block}.form-inline .input-group{display:inline-table;vertical-align:middle}.form-inline .input-group .form-control,.form-inline .input-group .input-group-addon,.form-inline .input-group .input-group-btn{width:auto}.form-inline .input-group>.form-control{width:100%}.form-inline .control-label{margin-bottom:0;vertical-align:middle}.form-inline .checkbox,.form-inline .radio{display:inline-block;margin-top:0;margin-bottom:0;vertical-align:middle}.form-inline .checkbox label,.form-inline .radio label{padding-left:0}.form-inline .checkbox input[type=checkbox],.form-inline .radio input[type=radio]{position:relative;margin-left:0}.form-inline .has-feedback .form-control-feedback{top:0}}.form-horizontal .checkbox,.form-horizontal .checkbox-inline,.form-horizontal .radio,.form-horizontal .radio-inline{padding-top:7px;margin-top:0;margin-bottom:0}.form-horizontal .checkbox,.form-horizontal .radio{min-height:27px}.form-horizontal .form-group{margin-right:-15px;margin-left:-15px}@media (min-width:768px){.form-horizontal .control-label{padding-top:7px;margin-bottom:0;text-align:right}}.form-horizontal .has-feedback .form-control-feedback{right:15px}@media (min-width:768px){.form-horizontal .form-group-lg .control-label{padding-top:11px;font-size:18px}}@media (min-width:768px){.form-horizontal .form-group-sm .control-label{padding-top:6px;font-size:12px}}.btn{display:inline-block;padding:6px 12px;margin-bottom:0;font-size:14px;font-weight:400;line-height:1.42857143;text-align:center;white-space:nowrap;vertical-align:middle;-ms-touch-action:manipulation;touch-action:manipulation;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-image:none;border:1px solid transparent;border-radius:4px}.btn.active.focus,.btn.active:focus,.btn.focus,.btn:active.focus,.btn:active:focus,.btn:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.btn.focus,.btn:focus,.btn:hover{color:#333;text-decoration:none}.btn.active,.btn:active{background-image:none;outline:0;-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn.disabled,.btn[disabled],fieldset[disabled] .btn{cursor:not-allowed;filter:alpha(opacity=65);-webkit-box-shadow:none;box-shadow:none;opacity:.65}a.btn.disabled,fieldset[disabled] a.btn{pointer-events:none}.btn-default{color:#333;background-color:#fff;border-color:#ccc}.btn-default.focus,.btn-default:focus{color:#333;background-color:#e6e6e6;border-color:#8c8c8c}.btn-default:hover{color:#333;background-color:#e6e6e6;border-color:#adadad}.btn-default.active,.btn-default:active,.open>.dropdown-toggle.btn-default{color:#333;background-color:#e6e6e6;border-color:#adadad}.btn-default.active.focus,.btn-default.active:focus,.btn-default.active:hover,.btn-default:active.focus,.btn-default:active:focus,.btn-default:active:hover,.open>.dropdown-toggle.btn-default.focus,.open>.dropdown-toggle.btn-default:focus,.open>.dropdown-toggle.btn-default:hover{color:#333;background-color:#d4d4d4;border-color:#8c8c8c}.btn-default.active,.btn-default:active,.open>.dropdown-toggle.btn-default{background-image:none}.btn-default.disabled.focus,.btn-default.disabled:focus,.btn-default.disabled:hover,.btn-default[disabled].focus,.btn-default[disabled]:focus,.btn-default[disabled]:hover,fieldset[disabled] .btn-default.focus,fieldset[disabled] .btn-default:focus,fieldset[disabled] .btn-default:hover{background-color:#fff;border-color:#ccc}.btn-default .badge{color:#fff;background-color:#333}.btn-primary{color:#fff;background-color:#337ab7;border-color:#2e6da4}.btn-primary.focus,.btn-primary:focus{color:#fff;background-color:#286090;border-color:#122b40}.btn-primary:hover{color:#fff;background-color:#286090;border-color:#204d74}.btn-primary.active,.btn-primary:active,.open>.dropdown-toggle.btn-primary{color:#fff;background-color:#286090;border-color:#204d74}.btn-primary.active.focus,.btn-primary.active:focus,.btn-primary.active:hover,.btn-primary:active.focus,.btn-primary:active:focus,.btn-primary:active:hover,.open>.dropdown-toggle.btn-primary.focus,.open>.dropdown-toggle.btn-primary:focus,.open>.dropdown-toggle.btn-primary:hover{color:#fff;background-color:#204d74;border-color:#122b40}.btn-primary.active,.btn-primary:active,.open>.dropdown-toggle.btn-primary{background-image:none}.btn-primary.disabled.focus,.btn-primary.disabled:focus,.btn-primary.disabled:hover,.btn-primary[disabled].focus,.btn-primary[disabled]:focus,.btn-primary[disabled]:hover,fieldset[disabled] .btn-primary.focus,fieldset[disabled] .btn-primary:focus,fieldset[disabled] .btn-primary:hover{background-color:#337ab7;border-color:#2e6da4}.btn-primary .badge{color:#337ab7;background-color:#fff}.btn-success{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.btn-success.focus,.btn-success:focus{color:#fff;background-color:#449d44;border-color:#255625}.btn-success:hover{color:#fff;background-color:#449d44;border-color:#398439}.btn-success.active,.btn-success:active,.open>.dropdown-toggle.btn-success{color:#fff;background-color:#449d44;border-color:#398439}.btn-success.active.focus,.btn-success.active:focus,.btn-success.active:hover,.btn-success:active.focus,.btn-success:active:focus,.btn-success:active:hover,.open>.dropdown-toggle.btn-success.focus,.open>.dropdown-toggle.btn-success:focus,.open>.dropdown-toggle.btn-success:hover{color:#fff;background-color:#398439;border-color:#255625}.btn-success.active,.btn-success:active,.open>.dropdown-toggle.btn-success{background-image:none}.btn-success.disabled.focus,.btn-success.disabled:focus,.btn-success.disabled:hover,.btn-success[disabled].focus,.btn-success[disabled]:focus,.btn-success[disabled]:hover,fieldset[disabled] .btn-success.focus,fieldset[disabled] .btn-success:focus,fieldset[disabled] .btn-success:hover{background-color:#5cb85c;border-color:#4cae4c}.btn-success .badge{color:#5cb85c;background-color:#fff}.btn-info{color:#fff;background-color:#5bc0de;border-color:#46b8da}.btn-info.focus,.btn-info:focus{color:#fff;background-color:#31b0d5;border-color:#1b6d85}.btn-info:hover{color:#fff;background-color:#31b0d5;border-color:#269abc}.btn-info.active,.btn-info:active,.open>.dropdown-toggle.btn-info{color:#fff;background-color:#31b0d5;border-color:#269abc}.btn-info.active.focus,.btn-info.active:focus,.btn-info.active:hover,.btn-info:active.focus,.btn-info:active:focus,.btn-info:active:hover,.open>.dropdown-toggle.btn-info.focus,.open>.dropdown-toggle.btn-info:focus,.open>.dropdown-toggle.btn-info:hover{color:#fff;background-color:#269abc;border-color:#1b6d85}.btn-info.active,.btn-info:active,.open>.dropdown-toggle.btn-info{background-image:none}.btn-info.disabled.focus,.btn-info.disabled:focus,.btn-info.disabled:hover,.btn-info[disabled].focus,.btn-info[disabled]:focus,.btn-info[disabled]:hover,fieldset[disabled] .btn-info.focus,fieldset[disabled] .btn-info:focus,fieldset[disabled] .btn-info:hover{background-color:#5bc0de;border-color:#46b8da}.btn-info .badge{color:#5bc0de;background-color:#fff}.btn-warning{color:#fff;background-color:#f0ad4e;border-color:#eea236}.btn-warning.focus,.btn-warning:focus{color:#fff;background-color:#ec971f;border-color:#985f0d}.btn-warning:hover{color:#fff;background-color:#ec971f;border-color:#d58512}.btn-warning.active,.btn-warning:active,.open>.dropdown-toggle.btn-warning{color:#fff;background-color:#ec971f;border-color:#d58512}.btn-warning.active.focus,.btn-warning.active:focus,.btn-warning.active:hover,.btn-warning:active.focus,.btn-warning:active:focus,.btn-warning:active:hover,.open>.dropdown-toggle.btn-warning.focus,.open>.dropdown-toggle.btn-warning:focus,.open>.dropdown-toggle.btn-warning:hover{color:#fff;background-color:#d58512;border-color:#985f0d}.btn-warning.active,.btn-warning:active,.open>.dropdown-toggle.btn-warning{background-image:none}.btn-warning.disabled.focus,.btn-warning.disabled:focus,.btn-warning.disabled:hover,.btn-warning[disabled].focus,.btn-warning[disabled]:focus,.btn-warning[disabled]:hover,fieldset[disabled] .btn-warning.focus,fieldset[disabled] .btn-warning:focus,fieldset[disabled] .btn-warning:hover{background-color:#f0ad4e;border-color:#eea236}.btn-warning .badge{color:#f0ad4e;background-color:#fff}.btn-danger{color:#fff;background-color:#d9534f;border-color:#d43f3a}.btn-danger.focus,.btn-danger:focus{color:#fff;background-color:#c9302c;border-color:#761c19}.btn-danger:hover{color:#fff;background-color:#c9302c;border-color:#ac2925}.btn-danger.active,.btn-danger:active,.open>.dropdown-toggle.btn-danger{color:#fff;background-color:#c9302c;border-color:#ac2925}.btn-danger.active.focus,.btn-danger.active:focus,.btn-danger.active:hover,.btn-danger:active.focus,.btn-danger:active:focus,.btn-danger:active:hover,.open>.dropdown-toggle.btn-danger.focus,.open>.dropdown-toggle.btn-danger:focus,.open>.dropdown-toggle.btn-danger:hover{color:#fff;background-color:#ac2925;border-color:#761c19}.btn-danger.active,.btn-danger:active,.open>.dropdown-toggle.btn-danger{background-image:none}.btn-danger.disabled.focus,.btn-danger.disabled:focus,.btn-danger.disabled:hover,.btn-danger[disabled].focus,.btn-danger[disabled]:focus,.btn-danger[disabled]:hover,fieldset[disabled] .btn-danger.focus,fieldset[disabled] .btn-danger:focus,fieldset[disabled] .btn-danger:hover{background-color:#d9534f;border-color:#d43f3a}.btn-danger .badge{color:#d9534f;background-color:#fff}.btn-link{font-weight:400;color:#337ab7;border-radius:0}.btn-link,.btn-link.active,.btn-link:active,.btn-link[disabled],fieldset[disabled] .btn-link{background-color:transparent;-webkit-box-shadow:none;box-shadow:none}.btn-link,.btn-link:active,.btn-link:focus,.btn-link:hover{border-color:transparent}.btn-link:focus,.btn-link:hover{color:#23527c;text-decoration:underline;background-color:transparent}.btn-link[disabled]:focus,.btn-link[disabled]:hover,fieldset[disabled] .btn-link:focus,fieldset[disabled] .btn-link:hover{color:#777;text-decoration:none}.btn-group-lg>.btn,.btn-lg{padding:10px 16px;font-size:18px;line-height:1.3333333;border-radius:6px}.btn-group-sm>.btn,.btn-sm{padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.btn-group-xs>.btn,.btn-xs{padding:1px 5px;font-size:12px;line-height:1.5;border-radius:3px}.btn-block{display:block;width:100%}.btn-block+.btn-block{margin-top:5px}input[type=button].btn-block,input[type=reset].btn-block,input[type=submit].btn-block{width:100%}.fade{opacity:0;-webkit-transition:opacity .15s linear;-o-transition:opacity .15s linear;transition:opacity .15s linear}.fade.in{opacity:1}.collapse{display:none}.collapse.in{display:block}tr.collapse.in{display:table-row}tbody.collapse.in{display:table-row-group}.collapsing{position:relative;height:0;overflow:hidden;-webkit-transition-timing-function:ease;-o-transition-timing-function:ease;transition-timing-function:ease;-webkit-transition-duration:.35s;-o-transition-duration:.35s;transition-duration:.35s;-webkit-transition-property:height,visibility;-o-transition-property:height,visibility;transition-property:height,visibility}.caret{display:inline-block;width:0;height:0;margin-left:2px;vertical-align:middle;border-top:4px dashed;border-top:4px solid\9;border-right:4px solid transparent;border-left:4px solid transparent}.dropdown,.dropup{position:relative}.dropdown-toggle:focus{outline:0}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:160px;padding:5px 0;margin:2px 0 0;font-size:14px;text-align:left;list-style:none;background-color:#fff;-webkit-background-clip:padding-box;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0,0,0,.15);border-radius:4px;-webkit-box-shadow:0 6px 12px rgba(0,0,0,.175);box-shadow:0 6px 12px rgba(0,0,0,.175)}.dropdown-menu.pull-right{right:0;left:auto}.dropdown-menu .divider{height:1px;margin:9px 0;overflow:hidden;background-color:#e5e5e5}.dropdown-menu>li>a{display:block;padding:3px 20px;clear:both;font-weight:400;line-height:1.42857143;color:#333;white-space:nowrap}.dropdown-menu>li>a:focus,.dropdown-menu>li>a:hover{color:#262626;text-decoration:none;background-color:#f5f5f5}.dropdown-menu>.active>a,.dropdown-menu>.active>a:focus,.dropdown-menu>.active>a:hover{color:#fff;text-decoration:none;background-color:#337ab7;outline:0}.dropdown-menu>.disabled>a,.dropdown-menu>.disabled>a:focus,.dropdown-menu>.disabled>a:hover{color:#777}.dropdown-menu>.disabled>a:focus,.dropdown-menu>.disabled>a:hover{text-decoration:none;cursor:not-allowed;background-color:transparent;background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.open>.dropdown-menu{display:block}.open>a{outline:0}.dropdown-menu-right{right:0;left:auto}.dropdown-menu-left{right:auto;left:0}.dropdown-header{display:block;padding:3px 20px;font-size:12px;line-height:1.42857143;color:#777;white-space:nowrap}.dropdown-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:990}.pull-right>.dropdown-menu{right:0;left:auto}.dropup .caret,.navbar-fixed-bottom .dropdown .caret{content:"";border-top:0;border-bottom:4px dashed;border-bottom:4px solid\9}.dropup .dropdown-menu,.navbar-fixed-bottom .dropdown .dropdown-menu{top:auto;bottom:100%;margin-bottom:2px}@media (min-width:768px){.navbar-right .dropdown-menu{right:0;left:auto}.navbar-right .dropdown-menu-left{right:auto;left:0}}.btn-group,.btn-group-vertical{position:relative;display:inline-block;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;float:left}.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:2}.btn-group .btn+.btn,.btn-group .btn+.btn-group,.btn-group .btn-group+.btn,.btn-group .btn-group+.btn-group{margin-left:-1px}.btn-toolbar{margin-left:-5px}.btn-toolbar .btn,.btn-toolbar .btn-group,.btn-toolbar .input-group{float:left}.btn-toolbar>.btn,.btn-toolbar>.btn-group,.btn-toolbar>.input-group{margin-left:5px}.btn-group>.btn:not(:first-child):not(:last-child):not(.dropdown-toggle){border-radius:0}.btn-group>.btn:first-child{margin-left:0}.btn-group>.btn:first-child:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn:last-child:not(:first-child),.btn-group>.dropdown-toggle:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.btn-group>.btn-group{float:left}.btn-group>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-left-radius:0;border-bottom-left-radius:0}.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0}.btn-group>.btn+.dropdown-toggle{padding-right:8px;padding-left:8px}.btn-group>.btn-lg+.dropdown-toggle{padding-right:12px;padding-left:12px}.btn-group.open .dropdown-toggle{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn-group.open .dropdown-toggle.btn-link{-webkit-box-shadow:none;box-shadow:none}.btn .caret{margin-left:0}.btn-lg .caret{border-width:5px 5px 0;border-bottom-width:0}.dropup .btn-lg .caret{border-width:0 5px 5px}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group,.btn-group-vertical>.btn-group>.btn{display:block;float:none;width:100%;max-width:100%}.btn-group-vertical>.btn-group>.btn{float:none}.btn-group-vertical>.btn+.btn,.btn-group-vertical>.btn+.btn-group,.btn-group-vertical>.btn-group+.btn,.btn-group-vertical>.btn-group+.btn-group{margin-top:-1px;margin-left:0}.btn-group-vertical>.btn:not(:first-child):not(:last-child){border-radius:0}.btn-group-vertical>.btn:first-child:not(:last-child){border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn:last-child:not(:first-child){border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.btn-group-vertical>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group-vertical>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group-vertical>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-left-radius:0;border-top-right-radius:0}.btn-group-justified{display:table;width:100%;table-layout:fixed;border-collapse:separate}.btn-group-justified>.btn,.btn-group-justified>.btn-group{display:table-cell;float:none;width:1%}.btn-group-justified>.btn-group .btn{width:100%}.btn-group-justified>.btn-group .dropdown-menu{left:auto}[data-toggle=buttons]>.btn input[type=checkbox],[data-toggle=buttons]>.btn input[type=radio],[data-toggle=buttons]>.btn-group>.btn input[type=checkbox],[data-toggle=buttons]>.btn-group>.btn input[type=radio]{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.input-group{position:relative;display:table;border-collapse:separate}.input-group[class*=col-]{float:none;padding-right:0;padding-left:0}.input-group .form-control{position:relative;z-index:2;float:left;width:100%;margin-bottom:0}.input-group .form-control:focus{z-index:3}.input-group-lg>.form-control,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.btn{height:46px;padding:10px 16px;font-size:18px;line-height:1.3333333;border-radius:6px}select.input-group-lg>.form-control,select.input-group-lg>.input-group-addon,select.input-group-lg>.input-group-btn>.btn{height:46px;line-height:46px}select[multiple].input-group-lg>.form-control,select[multiple].input-group-lg>.input-group-addon,select[multiple].input-group-lg>.input-group-btn>.btn,textarea.input-group-lg>.form-control,textarea.input-group-lg>.input-group-addon,textarea.input-group-lg>.input-group-btn>.btn{height:auto}.input-group-sm>.form-control,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.btn{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}select.input-group-sm>.form-control,select.input-group-sm>.input-group-addon,select.input-group-sm>.input-group-btn>.btn{height:30px;line-height:30px}select[multiple].input-group-sm>.form-control,select[multiple].input-group-sm>.input-group-addon,select[multiple].input-group-sm>.input-group-btn>.btn,textarea.input-group-sm>.form-control,textarea.input-group-sm>.input-group-addon,textarea.input-group-sm>.input-group-btn>.btn{height:auto}.input-group .form-control,.input-group-addon,.input-group-btn{display:table-cell}.input-group .form-control:not(:first-child):not(:last-child),.input-group-addon:not(:first-child):not(:last-child),.input-group-btn:not(:first-child):not(:last-child){border-radius:0}.input-group-addon,.input-group-btn{width:1%;white-space:nowrap;vertical-align:middle}.input-group-addon{padding:6px 12px;font-size:14px;font-weight:400;line-height:1;color:#555;text-align:center;background-color:#eee;border:1px solid #ccc;border-radius:4px}.input-group-addon.input-sm{padding:5px 10px;font-size:12px;border-radius:3px}.input-group-addon.input-lg{padding:10px 16px;font-size:18px;border-radius:6px}.input-group-addon input[type=checkbox],.input-group-addon input[type=radio]{margin-top:0}.input-group .form-control:first-child,.input-group-addon:first-child,.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group>.btn,.input-group-btn:first-child>.dropdown-toggle,.input-group-btn:last-child>.btn-group:not(:last-child)>.btn,.input-group-btn:last-child>.btn:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.input-group-addon:first-child{border-right:0}.input-group .form-control:last-child,.input-group-addon:last-child,.input-group-btn:first-child>.btn-group:not(:first-child)>.btn,.input-group-btn:first-child>.btn:not(:first-child),.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group>.btn,.input-group-btn:last-child>.dropdown-toggle{border-top-left-radius:0;border-bottom-left-radius:0}.input-group-addon:last-child{border-left:0}.input-group-btn{position:relative;font-size:0;white-space:nowrap}.input-group-btn>.btn{position:relative}.input-group-btn>.btn+.btn{margin-left:-1px}.input-group-btn>.btn:active,.input-group-btn>.btn:focus,.input-group-btn>.btn:hover{z-index:2}.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group{margin-right:-1px}.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group{z-index:2;margin-left:-1px}.nav{padding-left:0;margin-bottom:0;list-style:none}.nav>li{position:relative;display:block}.nav>li>a{position:relative;display:block;padding:10px 15px}.nav>li>a:focus,.nav>li>a:hover{text-decoration:none;background-color:#eee}.nav>li.disabled>a{color:#777}.nav>li.disabled>a:focus,.nav>li.disabled>a:hover{color:#777;text-decoration:none;cursor:not-allowed;background-color:transparent}.nav .open>a,.nav .open>a:focus,.nav .open>a:hover{background-color:#eee;border-color:#337ab7}.nav .nav-divider{height:1px;margin:9px 0;overflow:hidden;background-color:#e5e5e5}.nav>li>a>img{max-width:none}.nav-tabs{border-bottom:1px solid #ddd}.nav-tabs>li{float:left;margin-bottom:-1px}.nav-tabs>li>a{margin-right:2px;line-height:1.42857143;border:1px solid transparent;border-radius:4px 4px 0 0}.nav-tabs>li>a:hover{border-color:#eee #eee #ddd}.nav-tabs>li.active>a,.nav-tabs>li.active>a:focus,.nav-tabs>li.active>a:hover{color:#555;cursor:default;background-color:#fff;border:1px solid #ddd;border-bottom-color:transparent}.nav-tabs.nav-justified{width:100%;border-bottom:0}.nav-tabs.nav-justified>li{float:none}.nav-tabs.nav-justified>li>a{margin-bottom:5px;text-align:center}.nav-tabs.nav-justified>.dropdown .dropdown-menu{top:auto;left:auto}@media (min-width:768px){.nav-tabs.nav-justified>li{display:table-cell;width:1%}.nav-tabs.nav-justified>li>a{margin-bottom:0}}.nav-tabs.nav-justified>li>a{margin-right:0;border-radius:4px}.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:focus,.nav-tabs.nav-justified>.active>a:hover{border:1px solid #ddd}@media (min-width:768px){.nav-tabs.nav-justified>li>a{border-bottom:1px solid #ddd;border-radius:4px 4px 0 0}.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:focus,.nav-tabs.nav-justified>.active>a:hover{border-bottom-color:#fff}}.nav-pills>li{float:left}.nav-pills>li>a{border-radius:4px}.nav-pills>li+li{margin-left:2px}.nav-pills>li.active>a,.nav-pills>li.active>a:focus,.nav-pills>li.active>a:hover{color:#fff;background-color:#337ab7}.nav-stacked>li{float:none}.nav-stacked>li+li{margin-top:2px;margin-left:0}.nav-justified{width:100%}.nav-justified>li{float:none}.nav-justified>li>a{margin-bottom:5px;text-align:center}.nav-justified>.dropdown .dropdown-menu{top:auto;left:auto}@media (min-width:768px){.nav-justified>li{display:table-cell;width:1%}.nav-justified>li>a{margin-bottom:0}}.nav-tabs-justified{border-bottom:0}.nav-tabs-justified>li>a{margin-right:0;border-radius:4px}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:focus,.nav-tabs-justified>.active>a:hover{border:1px solid #ddd}@media (min-width:768px){.nav-tabs-justified>li>a{border-bottom:1px solid #ddd;border-radius:4px 4px 0 0}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:focus,.nav-tabs-justified>.active>a:hover{border-bottom-color:#fff}}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-left-radius:0;border-top-right-radius:0}.navbar{position:relative;min-height:50px;margin-bottom:20px;border:1px solid transparent}@media (min-width:768px){.navbar{border-radius:4px}}@media (min-width:768px){.navbar-header{float:left}}.navbar-collapse{padding-right:15px;padding-left:15px;overflow-x:visible;-webkit-overflow-scrolling:touch;border-top:1px solid transparent;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.1);box-shadow:inset 0 1px 0 rgba(255,255,255,.1)}.navbar-collapse.in{overflow-y:auto}@media (min-width:768px){.navbar-collapse{width:auto;border-top:0;-webkit-box-shadow:none;box-shadow:none}.navbar-collapse.collapse{display:block!important;height:auto!important;padding-bottom:0;overflow:visible!important}.navbar-collapse.in{overflow-y:visible}.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse,.navbar-static-top .navbar-collapse{padding-right:0;padding-left:0}}.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse{max-height:340px}@media (max-device-width:480px) and (orientation:landscape){.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse{max-height:200px}}.container-fluid>.navbar-collapse,.container-fluid>.navbar-header,.container>.navbar-collapse,.container>.navbar-header{margin-right:-15px;margin-left:-15px}@media (min-width:768px){.container-fluid>.navbar-collapse,.container-fluid>.navbar-header,.container>.navbar-collapse,.container>.navbar-header{margin-right:0;margin-left:0}}.navbar-static-top{z-index:1000;border-width:0 0 1px}@media (min-width:768px){.navbar-static-top{border-radius:0}}.navbar-fixed-bottom,.navbar-fixed-top{position:fixed;right:0;left:0;z-index:1030}@media (min-width:768px){.navbar-fixed-bottom,.navbar-fixed-top{border-radius:0}}.navbar-fixed-top{top:0;border-width:0 0 1px}.navbar-fixed-bottom{bottom:0;margin-bottom:0;border-width:1px 0 0}.navbar-brand{float:left;height:50px;padding:15px 15px;font-size:18px;line-height:20px}.navbar-brand:focus,.navbar-brand:hover{text-decoration:none}.navbar-brand>img{display:block}@media (min-width:768px){.navbar>.container .navbar-brand,.navbar>.container-fluid .navbar-brand{margin-left:-15px}}.navbar-toggle{position:relative;float:right;padding:9px 10px;margin-top:8px;margin-right:15px;margin-bottom:8px;background-color:transparent;background-image:none;border:1px solid transparent;border-radius:4px}.navbar-toggle:focus{outline:0}.navbar-toggle .icon-bar{display:block;width:22px;height:2px;border-radius:1px}.navbar-toggle .icon-bar+.icon-bar{margin-top:4px}@media (min-width:768px){.navbar-toggle{display:none}}.navbar-nav{margin:7.5px -15px}.navbar-nav>li>a{padding-top:10px;padding-bottom:10px;line-height:20px}@media (max-width:767px){.navbar-nav .open .dropdown-menu{position:static;float:none;width:auto;margin-top:0;background-color:transparent;border:0;-webkit-box-shadow:none;box-shadow:none}.navbar-nav .open .dropdown-menu .dropdown-header,.navbar-nav .open .dropdown-menu>li>a{padding:5px 15px 5px 25px}.navbar-nav .open .dropdown-menu>li>a{line-height:20px}.navbar-nav .open .dropdown-menu>li>a:focus,.navbar-nav .open .dropdown-menu>li>a:hover{background-image:none}}@media (min-width:768px){.navbar-nav{float:left;margin:0}.navbar-nav>li{float:left}.navbar-nav>li>a{padding-top:15px;padding-bottom:15px}}.navbar-form{padding:10px 15px;margin-top:8px;margin-right:-15px;margin-bottom:8px;margin-left:-15px;border-top:1px solid transparent;border-bottom:1px solid transparent;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.1),0 1px 0 rgba(255,255,255,.1);box-shadow:inset 0 1px 0 rgba(255,255,255,.1),0 1px 0 rgba(255,255,255,.1)}@media (min-width:768px){.navbar-form .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.navbar-form .form-control{display:inline-block;width:auto;vertical-align:middle}.navbar-form .form-control-static{display:inline-block}.navbar-form .input-group{display:inline-table;vertical-align:middle}.navbar-form .input-group .form-control,.navbar-form .input-group .input-group-addon,.navbar-form .input-group .input-group-btn{width:auto}.navbar-form .input-group>.form-control{width:100%}.navbar-form .control-label{margin-bottom:0;vertical-align:middle}.navbar-form .checkbox,.navbar-form .radio{display:inline-block;margin-top:0;margin-bottom:0;vertical-align:middle}.navbar-form .checkbox label,.navbar-form .radio label{padding-left:0}.navbar-form .checkbox input[type=checkbox],.navbar-form .radio input[type=radio]{position:relative;margin-left:0}.navbar-form .has-feedback .form-control-feedback{top:0}}@media (max-width:767px){.navbar-form .form-group{margin-bottom:5px}.navbar-form .form-group:last-child{margin-bottom:0}}@media (min-width:768px){.navbar-form{width:auto;padding-top:0;padding-bottom:0;margin-right:0;margin-left:0;border:0;-webkit-box-shadow:none;box-shadow:none}}.navbar-nav>li>.dropdown-menu{margin-top:0;border-top-left-radius:0;border-top-right-radius:0}.navbar-fixed-bottom .navbar-nav>li>.dropdown-menu{margin-bottom:0;border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.navbar-btn{margin-top:8px;margin-bottom:8px}.navbar-btn.btn-sm{margin-top:10px;margin-bottom:10px}.navbar-btn.btn-xs{margin-top:14px;margin-bottom:14px}.navbar-text{margin-top:15px;margin-bottom:15px}@media (min-width:768px){.navbar-text{float:left;margin-right:15px;margin-left:15px}}@media (min-width:768px){.navbar-left{float:left!important}.navbar-right{float:right!important;margin-right:-15px}.navbar-right~.navbar-right{margin-right:0}}.navbar-default{background-color:#f8f8f8;border-color:#e7e7e7}.navbar-default .navbar-brand{color:#777}.navbar-default .navbar-brand:focus,.navbar-default .navbar-brand:hover{color:#5e5e5e;background-color:transparent}.navbar-default .navbar-text{color:#777}.navbar-default .navbar-nav>li>a{color:#777}.navbar-default .navbar-nav>li>a:focus,.navbar-default .navbar-nav>li>a:hover{color:#333;background-color:transparent}.navbar-default .navbar-nav>.active>a,.navbar-default .navbar-nav>.active>a:focus,.navbar-default .navbar-nav>.active>a:hover{color:#555;background-color:#e7e7e7}.navbar-default .navbar-nav>.disabled>a,.navbar-default .navbar-nav>.disabled>a:focus,.navbar-default .navbar-nav>.disabled>a:hover{color:#ccc;background-color:transparent}.navbar-default .navbar-toggle{border-color:#ddd}.navbar-default .navbar-toggle:focus,.navbar-default .navbar-toggle:hover{background-color:#ddd}.navbar-default .navbar-toggle .icon-bar{background-color:#888}.navbar-default .navbar-collapse,.navbar-default .navbar-form{border-color:#e7e7e7}.navbar-default .navbar-nav>.open>a,.navbar-default .navbar-nav>.open>a:focus,.navbar-default .navbar-nav>.open>a:hover{color:#555;background-color:#e7e7e7}@media (max-width:767px){.navbar-default .navbar-nav .open .dropdown-menu>li>a{color:#777}.navbar-default .navbar-nav .open .dropdown-menu>li>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>li>a:hover{color:#333;background-color:transparent}.navbar-default .navbar-nav .open .dropdown-menu>.active>a,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:hover{color:#555;background-color:#e7e7e7}.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:hover{color:#ccc;background-color:transparent}}.navbar-default .navbar-link{color:#777}.navbar-default .navbar-link:hover{color:#333}.navbar-default .btn-link{color:#777}.navbar-default .btn-link:focus,.navbar-default .btn-link:hover{color:#333}.navbar-default .btn-link[disabled]:focus,.navbar-default .btn-link[disabled]:hover,fieldset[disabled] .navbar-default .btn-link:focus,fieldset[disabled] .navbar-default .btn-link:hover{color:#ccc}.navbar-inverse{background-color:#222;border-color:#080808}.navbar-inverse .navbar-brand{color:#9d9d9d}.navbar-inverse .navbar-brand:focus,.navbar-inverse .navbar-brand:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-text{color:#9d9d9d}.navbar-inverse .navbar-nav>li>a{color:#9d9d9d}.navbar-inverse .navbar-nav>li>a:focus,.navbar-inverse .navbar-nav>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav>.active>a,.navbar-inverse .navbar-nav>.active>a:focus,.navbar-inverse .navbar-nav>.active>a:hover{color:#fff;background-color:#080808}.navbar-inverse .navbar-nav>.disabled>a,.navbar-inverse .navbar-nav>.disabled>a:focus,.navbar-inverse .navbar-nav>.disabled>a:hover{color:#444;background-color:transparent}.navbar-inverse .navbar-toggle{border-color:#333}.navbar-inverse .navbar-toggle:focus,.navbar-inverse .navbar-toggle:hover{background-color:#333}.navbar-inverse .navbar-toggle .icon-bar{background-color:#fff}.navbar-inverse .navbar-collapse,.navbar-inverse .navbar-form{border-color:#101010}.navbar-inverse .navbar-nav>.open>a,.navbar-inverse .navbar-nav>.open>a:focus,.navbar-inverse .navbar-nav>.open>a:hover{color:#fff;background-color:#080808}@media (max-width:767px){.navbar-inverse .navbar-nav .open .dropdown-menu>.dropdown-header{border-color:#080808}.navbar-inverse .navbar-nav .open .dropdown-menu .divider{background-color:#080808}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a{color:#9d9d9d}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:hover{color:#fff;background-color:#080808}.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:hover{color:#444;background-color:transparent}}.navbar-inverse .navbar-link{color:#9d9d9d}.navbar-inverse .navbar-link:hover{color:#fff}.navbar-inverse .btn-link{color:#9d9d9d}.navbar-inverse .btn-link:focus,.navbar-inverse .btn-link:hover{color:#fff}.navbar-inverse .btn-link[disabled]:focus,.navbar-inverse .btn-link[disabled]:hover,fieldset[disabled] .navbar-inverse .btn-link:focus,fieldset[disabled] .navbar-inverse .btn-link:hover{color:#444}.breadcrumb{padding:8px 15px;margin-bottom:20px;list-style:none;background-color:#f5f5f5;border-radius:4px}.breadcrumb>li{display:inline-block}.breadcrumb>li+li:before{padding:0 5px;color:#ccc;content:"/\00a0"}.breadcrumb>.active{color:#777}.pagination{display:inline-block;padding-left:0;margin:20px 0;border-radius:4px}.pagination>li{display:inline}.pagination>li>a,.pagination>li>span{position:relative;float:left;padding:6px 12px;margin-left:-1px;line-height:1.42857143;color:#337ab7;text-decoration:none;background-color:#fff;border:1px solid #ddd}.pagination>li:first-child>a,.pagination>li:first-child>span{margin-left:0;border-top-left-radius:4px;border-bottom-left-radius:4px}.pagination>li:last-child>a,.pagination>li:last-child>span{border-top-right-radius:4px;border-bottom-right-radius:4px}.pagination>li>a:focus,.pagination>li>a:hover,.pagination>li>span:focus,.pagination>li>span:hover{z-index:2;color:#23527c;background-color:#eee;border-color:#ddd}.pagination>.active>a,.pagination>.active>a:focus,.pagination>.active>a:hover,.pagination>.active>span,.pagination>.active>span:focus,.pagination>.active>span:hover{z-index:3;color:#fff;cursor:default;background-color:#337ab7;border-color:#337ab7}.pagination>.disabled>a,.pagination>.disabled>a:focus,.pagination>.disabled>a:hover,.pagination>.disabled>span,.pagination>.disabled>span:focus,.pagination>.disabled>span:hover{color:#777;cursor:not-allowed;background-color:#fff;border-color:#ddd}.pagination-lg>li>a,.pagination-lg>li>span{padding:10px 16px;font-size:18px;line-height:1.3333333}.pagination-lg>li:first-child>a,.pagination-lg>li:first-child>span{border-top-left-radius:6px;border-bottom-left-radius:6px}.pagination-lg>li:last-child>a,.pagination-lg>li:last-child>span{border-top-right-radius:6px;border-bottom-right-radius:6px}.pagination-sm>li>a,.pagination-sm>li>span{padding:5px 10px;font-size:12px;line-height:1.5}.pagination-sm>li:first-child>a,.pagination-sm>li:first-child>span{border-top-left-radius:3px;border-bottom-left-radius:3px}.pagination-sm>li:last-child>a,.pagination-sm>li:last-child>span{border-top-right-radius:3px;border-bottom-right-radius:3px}.pager{padding-left:0;margin:20px 0;text-align:center;list-style:none}.pager li{display:inline}.pager li>a,.pager li>span{display:inline-block;padding:5px 14px;background-color:#fff;border:1px solid #ddd;border-radius:15px}.pager li>a:focus,.pager li>a:hover{text-decoration:none;background-color:#eee}.pager .next>a,.pager .next>span{float:right}.pager .previous>a,.pager .previous>span{float:left}.pager .disabled>a,.pager .disabled>a:focus,.pager .disabled>a:hover,.pager .disabled>span{color:#777;cursor:not-allowed;background-color:#fff}.label{display:inline;padding:.2em .6em .3em;font-size:75%;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25em}a.label:focus,a.label:hover{color:#fff;text-decoration:none;cursor:pointer}.label:empty{display:none}.btn .label{position:relative;top:-1px}.label-default{background-color:#777}.label-default[href]:focus,.label-default[href]:hover{background-color:#5e5e5e}.label-primary{background-color:#337ab7}.label-primary[href]:focus,.label-primary[href]:hover{background-color:#286090}.label-success{background-color:#5cb85c}.label-success[href]:focus,.label-success[href]:hover{background-color:#449d44}.label-info{background-color:#5bc0de}.label-info[href]:focus,.label-info[href]:hover{background-color:#31b0d5}.label-warning{background-color:#f0ad4e}.label-warning[href]:focus,.label-warning[href]:hover{background-color:#ec971f}.label-danger{background-color:#d9534f}.label-danger[href]:focus,.label-danger[href]:hover{background-color:#c9302c}.badge{display:inline-block;min-width:10px;padding:3px 7px;font-size:12px;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:middle;background-color:#777;border-radius:10px}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.btn-group-xs>.btn .badge,.btn-xs .badge{top:0;padding:1px 5px}a.badge:focus,a.badge:hover{color:#fff;text-decoration:none;cursor:pointer}.list-group-item.active>.badge,.nav-pills>.active>a>.badge{color:#337ab7;background-color:#fff}.list-group-item>.badge{float:right}.list-group-item>.badge+.badge{margin-right:5px}.nav-pills>li>a>.badge{margin-left:3px}.jumbotron{padding-top:30px;padding-bottom:30px;margin-bottom:30px;color:inherit;background-color:#eee}.jumbotron .h1,.jumbotron h1{color:inherit}.jumbotron p{margin-bottom:15px;font-size:21px;font-weight:200}.jumbotron>hr{border-top-color:#d5d5d5}.container .jumbotron,.container-fluid .jumbotron{padding-right:15px;padding-left:15px;border-radius:6px}.jumbotron .container{max-width:100%}@media screen and (min-width:768px){.jumbotron{padding-top:48px;padding-bottom:48px}.container .jumbotron,.container-fluid .jumbotron{padding-right:60px;padding-left:60px}.jumbotron .h1,.jumbotron h1{font-size:63px}}.thumbnail{display:block;padding:4px;margin-bottom:20px;line-height:1.42857143;background-color:#fff;border:1px solid #ddd;border-radius:4px;-webkit-transition:border .2s ease-in-out;-o-transition:border .2s ease-in-out;transition:border .2s ease-in-out}.thumbnail a>img,.thumbnail>img{margin-right:auto;margin-left:auto}a.thumbnail.active,a.thumbnail:focus,a.thumbnail:hover{border-color:#337ab7}.thumbnail .caption{padding:9px;color:#333}.alert{padding:15px;margin-bottom:20px;border:1px solid transparent;border-radius:4px}.alert h4{margin-top:0;color:inherit}.alert .alert-link{font-weight:700}.alert>p,.alert>ul{margin-bottom:0}.alert>p+p{margin-top:5px}.alert-dismissable,.alert-dismissible{padding-right:35px}.alert-dismissable .close,.alert-dismissible .close{position:relative;top:-2px;right:-21px;color:inherit}.alert-success{color:#3c763d;background-color:#dff0d8;border-color:#d6e9c6}.alert-success hr{border-top-color:#c9e2b3}.alert-success .alert-link{color:#2b542c}.alert-info{color:#31708f;background-color:#d9edf7;border-color:#bce8f1}.alert-info hr{border-top-color:#a6e1ec}.alert-info .alert-link{color:#245269}.alert-warning{color:#8a6d3b;background-color:#fcf8e3;border-color:#faebcc}.alert-warning hr{border-top-color:#f7e1b5}.alert-warning .alert-link{color:#66512c}.alert-danger{color:#a94442;background-color:#f2dede;border-color:#ebccd1}.alert-danger hr{border-top-color:#e4b9c0}.alert-danger .alert-link{color:#843534}@-webkit-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@-o-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}.progress{height:20px;margin-bottom:20px;overflow:hidden;background-color:#f5f5f5;border-radius:4px;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,.1);box-shadow:inset 0 1px 2px rgba(0,0,0,.1)}.progress-bar{float:left;width:0;height:100%;font-size:12px;line-height:20px;color:#fff;text-align:center;background-color:#337ab7;-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,.15);box-shadow:inset 0 -1px 0 rgba(0,0,0,.15);-webkit-transition:width .6s ease;-o-transition:width .6s ease;transition:width .6s ease}.progress-bar-striped,.progress-striped .progress-bar{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);-webkit-background-size:40px 40px;background-size:40px 40px}.progress-bar.active,.progress.active .progress-bar{-webkit-animation:progress-bar-stripes 2s linear infinite;-o-animation:progress-bar-stripes 2s linear infinite;animation:progress-bar-stripes 2s linear infinite}.progress-bar-success{background-color:#5cb85c}.progress-striped .progress-bar-success{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.progress-bar-info{background-color:#5bc0de}.progress-striped .progress-bar-info{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.progress-bar-warning{background-color:#f0ad4e}.progress-striped .progress-bar-warning{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.progress-bar-danger{background-color:#d9534f}.progress-striped .progress-bar-danger{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent)}.media{margin-top:15px}.media:first-child{margin-top:0}.media,.media-body{overflow:hidden;zoom:1}.media-body{width:10000px}.media-object{display:block}.media-object.img-thumbnail{max-width:none}.media-right,.media>.pull-right{padding-left:10px}.media-left,.media>.pull-left{padding-right:10px}.media-body,.media-left,.media-right{display:table-cell;vertical-align:top}.media-middle{vertical-align:middle}.media-bottom{vertical-align:bottom}.media-heading{margin-top:0;margin-bottom:5px}.media-list{padding-left:0;list-style:none}.list-group{padding-left:0;margin-bottom:20px}.list-group-item{position:relative;display:block;padding:10px 15px;margin-bottom:-1px;background-color:#fff;border:1px solid #ddd}.list-group-item:first-child{border-top-left-radius:4px;border-top-right-radius:4px}.list-group-item:last-child{margin-bottom:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}a.list-group-item,button.list-group-item{color:#555}a.list-group-item .list-group-item-heading,button.list-group-item .list-group-item-heading{color:#333}a.list-group-item:focus,a.list-group-item:hover,button.list-group-item:focus,button.list-group-item:hover{color:#555;text-decoration:none;background-color:#f5f5f5}button.list-group-item{width:100%;text-align:left}.list-group-item.disabled,.list-group-item.disabled:focus,.list-group-item.disabled:hover{color:#777;cursor:not-allowed;background-color:#eee}.list-group-item.disabled .list-group-item-heading,.list-group-item.disabled:focus .list-group-item-heading,.list-group-item.disabled:hover .list-group-item-heading{color:inherit}.list-group-item.disabled .list-group-item-text,.list-group-item.disabled:focus .list-group-item-text,.list-group-item.disabled:hover .list-group-item-text{color:#777}.list-group-item.active,.list-group-item.active:focus,.list-group-item.active:hover{z-index:2;color:#fff;background-color:#337ab7;border-color:#337ab7}.list-group-item.active .list-group-item-heading,.list-group-item.active .list-group-item-heading>.small,.list-group-item.active .list-group-item-heading>small,.list-group-item.active:focus .list-group-item-heading,.list-group-item.active:focus .list-group-item-heading>.small,.list-group-item.active:focus .list-group-item-heading>small,.list-group-item.active:hover .list-group-item-heading,.list-group-item.active:hover .list-group-item-heading>.small,.list-group-item.active:hover .list-group-item-heading>small{color:inherit}.list-group-item.active .list-group-item-text,.list-group-item.active:focus .list-group-item-text,.list-group-item.active:hover .list-group-item-text{color:#c7ddef}.list-group-item-success{color:#3c763d;background-color:#dff0d8}a.list-group-item-success,button.list-group-item-success{color:#3c763d}a.list-group-item-success .list-group-item-heading,button.list-group-item-success .list-group-item-heading{color:inherit}a.list-group-item-success:focus,a.list-group-item-success:hover,button.list-group-item-success:focus,button.list-group-item-success:hover{color:#3c763d;background-color:#d0e9c6}a.list-group-item-success.active,a.list-group-item-success.active:focus,a.list-group-item-success.active:hover,button.list-group-item-success.active,button.list-group-item-success.active:focus,button.list-group-item-success.active:hover{color:#fff;background-color:#3c763d;border-color:#3c763d}.list-group-item-info{color:#31708f;background-color:#d9edf7}a.list-group-item-info,button.list-group-item-info{color:#31708f}a.list-group-item-info .list-group-item-heading,button.list-group-item-info .list-group-item-heading{color:inherit}a.list-group-item-info:focus,a.list-group-item-info:hover,button.list-group-item-info:focus,button.list-group-item-info:hover{color:#31708f;background-color:#c4e3f3}a.list-group-item-info.active,a.list-group-item-info.active:focus,a.list-group-item-info.active:hover,button.list-group-item-info.active,button.list-group-item-info.active:focus,button.list-group-item-info.active:hover{color:#fff;background-color:#31708f;border-color:#31708f}.list-group-item-warning{color:#8a6d3b;background-color:#fcf8e3}a.list-group-item-warning,button.list-group-item-warning{color:#8a6d3b}a.list-group-item-warning .list-group-item-heading,button.list-group-item-warning .list-group-item-heading{color:inherit}a.list-group-item-warning:focus,a.list-group-item-warning:hover,button.list-group-item-warning:focus,button.list-group-item-warning:hover{color:#8a6d3b;background-color:#faf2cc}a.list-group-item-warning.active,a.list-group-item-warning.active:focus,a.list-group-item-warning.active:hover,button.list-group-item-warning.active,button.list-group-item-warning.active:focus,button.list-group-item-warning.active:hover{color:#fff;background-color:#8a6d3b;border-color:#8a6d3b}.list-group-item-danger{color:#a94442;background-color:#f2dede}a.list-group-item-danger,button.list-group-item-danger{color:#a94442}a.list-group-item-danger .list-group-item-heading,button.list-group-item-danger .list-group-item-heading{color:inherit}a.list-group-item-danger:focus,a.list-group-item-danger:hover,button.list-group-item-danger:focus,button.list-group-item-danger:hover{color:#a94442;background-color:#ebcccc}a.list-group-item-danger.active,a.list-group-item-danger.active:focus,a.list-group-item-danger.active:hover,button.list-group-item-danger.active,button.list-group-item-danger.active:focus,button.list-group-item-danger.active:hover{color:#fff;background-color:#a94442;border-color:#a94442}.list-group-item-heading{margin-top:0;margin-bottom:5px}.list-group-item-text{margin-bottom:0;line-height:1.3}.panel{margin-bottom:20px;background-color:#fff;border:1px solid transparent;border-radius:4px;-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}.panel-body{padding:15px}.panel-heading{padding:10px 15px;border-bottom:1px solid transparent;border-top-left-radius:3px;border-top-right-radius:3px}.panel-heading>.dropdown .dropdown-toggle{color:inherit}.panel-title{margin-top:0;margin-bottom:0;font-size:16px;color:inherit}.panel-title>.small,.panel-title>.small>a,.panel-title>a,.panel-title>small,.panel-title>small>a{color:inherit}.panel-footer{padding:10px 15px;background-color:#f5f5f5;border-top:1px solid #ddd;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.list-group,.panel>.panel-collapse>.list-group{margin-bottom:0}.panel>.list-group .list-group-item,.panel>.panel-collapse>.list-group .list-group-item{border-width:1px 0;border-radius:0}.panel>.list-group:first-child .list-group-item:first-child,.panel>.panel-collapse>.list-group:first-child .list-group-item:first-child{border-top:0;border-top-left-radius:3px;border-top-right-radius:3px}.panel>.list-group:last-child .list-group-item:last-child,.panel>.panel-collapse>.list-group:last-child .list-group-item:last-child{border-bottom:0;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.panel-heading+.panel-collapse>.list-group .list-group-item:first-child{border-top-left-radius:0;border-top-right-radius:0}.panel-heading+.list-group .list-group-item:first-child{border-top-width:0}.list-group+.panel-footer{border-top-width:0}.panel>.panel-collapse>.table,.panel>.table,.panel>.table-responsive>.table{margin-bottom:0}.panel>.panel-collapse>.table caption,.panel>.table caption,.panel>.table-responsive>.table caption{padding-right:15px;padding-left:15px}.panel>.table-responsive:first-child>.table:first-child,.panel>.table:first-child{border-top-left-radius:3px;border-top-right-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child,.panel>.table:first-child>thead:first-child>tr:first-child{border-top-left-radius:3px;border-top-right-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table:first-child>thead:first-child>tr:first-child th:first-child{border-top-left-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table:first-child>thead:first-child>tr:first-child th:last-child{border-top-right-radius:3px}.panel>.table-responsive:last-child>.table:last-child,.panel>.table:last-child{border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child{border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:first-child{border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:last-child{border-bottom-right-radius:3px}.panel>.panel-body+.table,.panel>.panel-body+.table-responsive,.panel>.table+.panel-body,.panel>.table-responsive+.panel-body{border-top:1px solid #ddd}.panel>.table>tbody:first-child>tr:first-child td,.panel>.table>tbody:first-child>tr:first-child th{border-top:0}.panel>.table-bordered,.panel>.table-responsive>.table-bordered{border:0}.panel>.table-bordered>tbody>tr>td:first-child,.panel>.table-bordered>tbody>tr>th:first-child,.panel>.table-bordered>tfoot>tr>td:first-child,.panel>.table-bordered>tfoot>tr>th:first-child,.panel>.table-bordered>thead>tr>td:first-child,.panel>.table-bordered>thead>tr>th:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:first-child,.panel>.table-responsive>.table-bordered>thead>tr>td:first-child,.panel>.table-responsive>.table-bordered>thead>tr>th:first-child{border-left:0}.panel>.table-bordered>tbody>tr>td:last-child,.panel>.table-bordered>tbody>tr>th:last-child,.panel>.table-bordered>tfoot>tr>td:last-child,.panel>.table-bordered>tfoot>tr>th:last-child,.panel>.table-bordered>thead>tr>td:last-child,.panel>.table-bordered>thead>tr>th:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:last-child,.panel>.table-responsive>.table-bordered>thead>tr>td:last-child,.panel>.table-responsive>.table-bordered>thead>tr>th:last-child{border-right:0}.panel>.table-bordered>tbody>tr:first-child>td,.panel>.table-bordered>tbody>tr:first-child>th,.panel>.table-bordered>thead>tr:first-child>td,.panel>.table-bordered>thead>tr:first-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>th,.panel>.table-responsive>.table-bordered>thead>tr:first-child>td,.panel>.table-responsive>.table-bordered>thead>tr:first-child>th{border-bottom:0}.panel>.table-bordered>tbody>tr:last-child>td,.panel>.table-bordered>tbody>tr:last-child>th,.panel>.table-bordered>tfoot>tr:last-child>td,.panel>.table-bordered>tfoot>tr:last-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>th,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>td,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>th{border-bottom:0}.panel>.table-responsive{margin-bottom:0;border:0}.panel-group{margin-bottom:20px}.panel-group .panel{margin-bottom:0;border-radius:4px}.panel-group .panel+.panel{margin-top:5px}.panel-group .panel-heading{border-bottom:0}.panel-group .panel-heading+.panel-collapse>.list-group,.panel-group .panel-heading+.panel-collapse>.panel-body{border-top:1px solid #ddd}.panel-group .panel-footer{border-top:0}.panel-group .panel-footer+.panel-collapse .panel-body{border-bottom:1px solid #ddd}.panel-default{border-color:#ddd}.panel-default>.panel-heading{color:#333;background-color:#f5f5f5;border-color:#ddd}.panel-default>.panel-heading+.panel-collapse>.panel-body{border-top-color:#ddd}.panel-default>.panel-heading .badge{color:#f5f5f5;background-color:#333}.panel-default>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#ddd}.panel-primary{border-color:#337ab7}.panel-primary>.panel-heading{color:#fff;background-color:#337ab7;border-color:#337ab7}.panel-primary>.panel-heading+.panel-collapse>.panel-body{border-top-color:#337ab7}.panel-primary>.panel-heading .badge{color:#337ab7;background-color:#fff}.panel-primary>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#337ab7}.panel-success{border-color:#d6e9c6}.panel-success>.panel-heading{color:#3c763d;background-color:#dff0d8;border-color:#d6e9c6}.panel-success>.panel-heading+.panel-collapse>.panel-body{border-top-color:#d6e9c6}.panel-success>.panel-heading .badge{color:#dff0d8;background-color:#3c763d}.panel-success>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#d6e9c6}.panel-info{border-color:#bce8f1}.panel-info>.panel-heading{color:#31708f;background-color:#d9edf7;border-color:#bce8f1}.panel-info>.panel-heading+.panel-collapse>.panel-body{border-top-color:#bce8f1}.panel-info>.panel-heading .badge{color:#d9edf7;background-color:#31708f}.panel-info>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#bce8f1}.panel-warning{border-color:#faebcc}.panel-warning>.panel-heading{color:#8a6d3b;background-color:#fcf8e3;border-color:#faebcc}.panel-warning>.panel-heading+.panel-collapse>.panel-body{border-top-color:#faebcc}.panel-warning>.panel-heading .badge{color:#fcf8e3;background-color:#8a6d3b}.panel-warning>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#faebcc}.panel-danger{border-color:#ebccd1}.panel-danger>.panel-heading{color:#a94442;background-color:#f2dede;border-color:#ebccd1}.panel-danger>.panel-heading+.panel-collapse>.panel-body{border-top-color:#ebccd1}.panel-danger>.panel-heading .badge{color:#f2dede;background-color:#a94442}.panel-danger>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#ebccd1}.embed-responsive{position:relative;display:block;height:0;padding:0;overflow:hidden}.embed-responsive .embed-responsive-item,.embed-responsive embed,.embed-responsive iframe,.embed-responsive object,.embed-responsive video{position:absolute;top:0;bottom:0;left:0;width:100%;height:100%;border:0}.embed-responsive-16by9{padding-bottom:56.25%}.embed-responsive-4by3{padding-bottom:75%}.well{min-height:20px;padding:19px;margin-bottom:20px;background-color:#f5f5f5;border:1px solid #e3e3e3;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.05);box-shadow:inset 0 1px 1px rgba(0,0,0,.05)}.well blockquote{border-color:#ddd;border-color:rgba(0,0,0,.15)}.well-lg{padding:24px;border-radius:6px}.well-sm{padding:9px;border-radius:3px}.close{float:right;font-size:21px;font-weight:700;line-height:1;color:#000;text-shadow:0 1px 0 #fff;filter:alpha(opacity=20);opacity:.2}.close:focus,.close:hover{color:#000;text-decoration:none;cursor:pointer;filter:alpha(opacity=50);opacity:.5}button.close{-webkit-appearance:none;padding:0;cursor:pointer;background:0 0;border:0}.modal-open{overflow:hidden}.modal{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1050;display:none;overflow:hidden;-webkit-overflow-scrolling:touch;outline:0}.modal.fade .modal-dialog{-webkit-transition:-webkit-transform .3s ease-out;-o-transition:-o-transform .3s ease-out;transition:transform .3s ease-out;-webkit-transform:translate(0,-25%);-ms-transform:translate(0,-25%);-o-transform:translate(0,-25%);transform:translate(0,-25%)}.modal.in .modal-dialog{-webkit-transform:translate(0,0);-ms-transform:translate(0,0);-o-transform:translate(0,0);transform:translate(0,0)}.modal-open .modal{overflow-x:hidden;overflow-y:auto}.modal-dialog{position:relative;width:auto;margin:10px}.modal-content{position:relative;background-color:#fff;-webkit-background-clip:padding-box;background-clip:padding-box;border:1px solid #999;border:1px solid rgba(0,0,0,.2);border-radius:6px;outline:0;-webkit-box-shadow:0 3px 9px rgba(0,0,0,.5);box-shadow:0 3px 9px rgba(0,0,0,.5)}.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000}.modal-backdrop.fade{filter:alpha(opacity=0);opacity:0}.modal-backdrop.in{filter:alpha(opacity=50);opacity:.5}.modal-header{padding:15px;border-bottom:1px solid #e5e5e5}.modal-header .close{margin-top:-2px}.modal-title{margin:0;line-height:1.42857143}.modal-body{position:relative;padding:15px}.modal-footer{padding:15px;text-align:right;border-top:1px solid #e5e5e5}.modal-footer .btn+.btn{margin-bottom:0;margin-left:5px}.modal-footer .btn-group .btn+.btn{margin-left:-1px}.modal-footer .btn-block+.btn-block{margin-left:0}.modal-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}@media (min-width:768px){.modal-dialog{width:600px;margin:30px auto}.modal-content{-webkit-box-shadow:0 5px 15px rgba(0,0,0,.5);box-shadow:0 5px 15px rgba(0,0,0,.5)}.modal-sm{width:300px}}@media (min-width:992px){.modal-lg{width:900px}}.tooltip{position:absolute;z-index:1070;display:block;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:12px;font-style:normal;font-weight:400;line-height:1.42857143;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;word-wrap:normal;white-space:normal;filter:alpha(opacity=0);opacity:0;line-break:auto}.tooltip.in{filter:alpha(opacity=90);opacity:.9}.tooltip.top{padding:5px 0;margin-top:-3px}.tooltip.right{padding:0 5px;margin-left:3px}.tooltip.bottom{padding:5px 0;margin-top:3px}.tooltip.left{padding:0 5px;margin-left:-3px}.tooltip-inner{max-width:200px;padding:3px 8px;color:#fff;text-align:center;background-color:#000;border-radius:4px}.tooltip-arrow{position:absolute;width:0;height:0;border-color:transparent;border-style:solid}.tooltip.top .tooltip-arrow{bottom:0;left:50%;margin-left:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.top-left .tooltip-arrow{right:5px;bottom:0;margin-bottom:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.top-right .tooltip-arrow{bottom:0;left:5px;margin-bottom:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.right .tooltip-arrow{top:50%;left:0;margin-top:-5px;border-width:5px 5px 5px 0;border-right-color:#000}.tooltip.left .tooltip-arrow{top:50%;right:0;margin-top:-5px;border-width:5px 0 5px 5px;border-left-color:#000}.tooltip.bottom .tooltip-arrow{top:0;left:50%;margin-left:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bottom-left .tooltip-arrow{top:0;right:5px;margin-top:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bottom-right .tooltip-arrow{top:0;left:5px;margin-top:-5px;border-width:0 5px 5px;border-bottom-color:#000}.popover{position:absolute;top:0;left:0;z-index:1060;display:none;max-width:276px;padding:1px;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:14px;font-style:normal;font-weight:400;line-height:1.42857143;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;word-wrap:normal;white-space:normal;background-color:#fff;-webkit-background-clip:padding-box;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0,0,0,.2);border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,.2);box-shadow:0 5px 10px rgba(0,0,0,.2);line-break:auto}.popover.top{margin-top:-10px}.popover.right{margin-left:10px}.popover.bottom{margin-top:10px}.popover.left{margin-left:-10px}.popover-title{padding:8px 14px;margin:0;font-size:14px;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-radius:5px 5px 0 0}.popover-content{padding:9px 14px}.popover>.arrow,.popover>.arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.popover>.arrow{border-width:11px}.popover>.arrow:after{content:"";border-width:10px}.popover.top>.arrow{bottom:-11px;left:50%;margin-left:-11px;border-top-color:#999;border-top-color:rgba(0,0,0,.25);border-bottom-width:0}.popover.top>.arrow:after{bottom:1px;margin-left:-10px;content:" ";border-top-color:#fff;border-bottom-width:0}.popover.right>.arrow{top:50%;left:-11px;margin-top:-11px;border-right-color:#999;border-right-color:rgba(0,0,0,.25);border-left-width:0}.popover.right>.arrow:after{bottom:-10px;left:1px;content:" ";border-right-color:#fff;border-left-width:0}.popover.bottom>.arrow{top:-11px;left:50%;margin-left:-11px;border-top-width:0;border-bottom-color:#999;border-bottom-color:rgba(0,0,0,.25)}.popover.bottom>.arrow:after{top:1px;margin-left:-10px;content:" ";border-top-width:0;border-bottom-color:#fff}.popover.left>.arrow{top:50%;right:-11px;margin-top:-11px;border-right-width:0;border-left-color:#999;border-left-color:rgba(0,0,0,.25)}.popover.left>.arrow:after{right:1px;bottom:-10px;content:" ";border-right-width:0;border-left-color:#fff}.carousel{position:relative}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel-inner>.item{position:relative;display:none;-webkit-transition:.6s ease-in-out left;-o-transition:.6s ease-in-out left;transition:.6s ease-in-out left}.carousel-inner>.item>a>img,.carousel-inner>.item>img{line-height:1}@media all and (transform-3d),(-webkit-transform-3d){.carousel-inner>.item{-webkit-transition:-webkit-transform .6s ease-in-out;-o-transition:-o-transform .6s ease-in-out;transition:transform .6s ease-in-out;-webkit-backface-visibility:hidden;backface-visibility:hidden;-webkit-perspective:1000px;perspective:1000px}.carousel-inner>.item.active.right,.carousel-inner>.item.next{left:0;-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}.carousel-inner>.item.active.left,.carousel-inner>.item.prev{left:0;-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}.carousel-inner>.item.active,.carousel-inner>.item.next.left,.carousel-inner>.item.prev.right{left:0;-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0)}}.carousel-inner>.active,.carousel-inner>.next,.carousel-inner>.prev{display:block}.carousel-inner>.active{left:0}.carousel-inner>.next,.carousel-inner>.prev{position:absolute;top:0;width:100%}.carousel-inner>.next{left:100%}.carousel-inner>.prev{left:-100%}.carousel-inner>.next.left,.carousel-inner>.prev.right{left:0}.carousel-inner>.active.left{left:-100%}.carousel-inner>.active.right{left:100%}.carousel-control{position:absolute;top:0;bottom:0;left:0;width:15%;font-size:20px;color:#fff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,.6);background-color:rgba(0,0,0,0);filter:alpha(opacity=50);opacity:.5}.carousel-control.left{background-image:-webkit-linear-gradient(left,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001) 100%);background-image:-o-linear-gradient(left,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001) 100%);background-image:-webkit-gradient(linear,left top,right top,from(rgba(0,0,0,.5)),to(rgba(0,0,0,.0001)));background-image:linear-gradient(to right,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001) 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#80000000', endColorstr='#00000000', GradientType=1);background-repeat:repeat-x}.carousel-control.right{right:0;left:auto;background-image:-webkit-linear-gradient(left,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5) 100%);background-image:-o-linear-gradient(left,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5) 100%);background-image:-webkit-gradient(linear,left top,right top,from(rgba(0,0,0,.0001)),to(rgba(0,0,0,.5)));background-image:linear-gradient(to right,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5) 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#00000000', endColorstr='#80000000', GradientType=1);background-repeat:repeat-x}.carousel-control:focus,.carousel-control:hover{color:#fff;text-decoration:none;filter:alpha(opacity=90);outline:0;opacity:.9}.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next,.carousel-control .icon-prev{position:absolute;top:50%;z-index:5;display:inline-block;margin-top:-10px}.carousel-control .glyphicon-chevron-left,.carousel-control .icon-prev{left:50%;margin-left:-10px}.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next{right:50%;margin-right:-10px}.carousel-control .icon-next,.carousel-control .icon-prev{width:20px;height:20px;font-family:serif;line-height:1}.carousel-control .icon-prev:before{content:'\2039'}.carousel-control .icon-next:before{content:'\203a'}.carousel-indicators{position:absolute;bottom:10px;left:50%;z-index:15;width:60%;padding-left:0;margin-left:-30%;text-align:center;list-style:none}.carousel-indicators li{display:inline-block;width:10px;height:10px;margin:1px;text-indent:-999px;cursor:pointer;background-color:#000\9;background-color:rgba(0,0,0,0);border:1px solid #fff;border-radius:10px}.carousel-indicators .active{width:12px;height:12px;margin:0;background-color:#fff}.carousel-caption{position:absolute;right:15%;bottom:20px;left:15%;z-index:10;padding-top:20px;padding-bottom:20px;color:#fff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,.6)}.carousel-caption .btn{text-shadow:none}@media screen and (min-width:768px){.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next,.carousel-control .icon-prev{width:30px;height:30px;margin-top:-10px;font-size:30px}.carousel-control .glyphicon-chevron-left,.carousel-control .icon-prev{margin-left:-10px}.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next{margin-right:-10px}.carousel-caption{right:20%;left:20%;padding-bottom:30px}.carousel-indicators{bottom:20px}}.btn-group-vertical>.btn-group:after,.btn-group-vertical>.btn-group:before,.btn-toolbar:after,.btn-toolbar:before,.clearfix:after,.clearfix:before,.container-fluid:after,.container-fluid:before,.container:after,.container:before,.dl-horizontal dd:after,.dl-horizontal dd:before,.form-horizontal .form-group:after,.form-horizontal .form-group:before,.modal-footer:after,.modal-footer:before,.modal-header:after,.modal-header:before,.nav:after,.nav:before,.navbar-collapse:after,.navbar-collapse:before,.navbar-header:after,.navbar-header:before,.navbar:after,.navbar:before,.pager:after,.pager:before,.panel-body:after,.panel-body:before,.row:after,.row:before{display:table;content:" "}.btn-group-vertical>.btn-group:after,.btn-toolbar:after,.clearfix:after,.container-fluid:after,.container:after,.dl-horizontal dd:after,.form-horizontal .form-group:after,.modal-footer:after,.modal-header:after,.nav:after,.navbar-collapse:after,.navbar-header:after,.navbar:after,.pager:after,.panel-body:after,.row:after{clear:both}.center-block{display:block;margin-right:auto;margin-left:auto}.pull-right{float:right!important}.pull-left{float:left!important}.hide{display:none!important}.show{display:block!important}.invisible{visibility:hidden}.text-hide{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.hidden{display:none!important}.affix{position:fixed}@-ms-viewport{width:device-width}.visible-lg,.visible-md,.visible-sm,.visible-xs{display:none!important}.visible-lg-block,.visible-lg-inline,.visible-lg-inline-block,.visible-md-block,.visible-md-inline,.visible-md-inline-block,.visible-sm-block,.visible-sm-inline,.visible-sm-inline-block,.visible-xs-block,.visible-xs-inline,.visible-xs-inline-block{display:none!important}@media (max-width:767px){.visible-xs{display:block!important}table.visible-xs{display:table!important}tr.visible-xs{display:table-row!important}td.visible-xs,th.visible-xs{display:table-cell!important}}@media (max-width:767px){.visible-xs-block{display:block!important}}@media (max-width:767px){.visible-xs-inline{display:inline!important}}@media (max-width:767px){.visible-xs-inline-block{display:inline-block!important}}@media (min-width:768px) and (max-width:991px){.visible-sm{display:block!important}table.visible-sm{display:table!important}tr.visible-sm{display:table-row!important}td.visible-sm,th.visible-sm{display:table-cell!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-block{display:block!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-inline{display:inline!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-inline-block{display:inline-block!important}}@media (min-width:992px) and (max-width:1199px){.visible-md{display:block!important}table.visible-md{display:table!important}tr.visible-md{display:table-row!important}td.visible-md,th.visible-md{display:table-cell!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-block{display:block!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-inline{display:inline!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-inline-block{display:inline-block!important}}@media (min-width:1200px){.visible-lg{display:block!important}table.visible-lg{display:table!important}tr.visible-lg{display:table-row!important}td.visible-lg,th.visible-lg{display:table-cell!important}}@media (min-width:1200px){.visible-lg-block{display:block!important}}@media (min-width:1200px){.visible-lg-inline{display:inline!important}}@media (min-width:1200px){.visible-lg-inline-block{display:inline-block!important}}@media (max-width:767px){.hidden-xs{display:none!important}}@media (min-width:768px) and (max-width:991px){.hidden-sm{display:none!important}}@media (min-width:992px) and (max-width:1199px){.hidden-md{display:none!important}}@media (min-width:1200px){.hidden-lg{display:none!important}}.visible-print{display:none!important}@media print{.visible-print{display:block!important}table.visible-print{display:table!important}tr.visible-print{display:table-row!important}td.visible-print,th.visible-print{display:table-cell!important}}.visible-print-block{display:none!important}@media print{.visible-print-block{display:block!important}}.visible-print-inline{display:none!important}@media print{.visible-print-inline{display:inline!important}}.visible-print-inline-block{display:none!important}@media print{.visible-print-inline-block{display:inline-block!important}}@media print{.hidden-print{display:none!important}} +/*# sourceMappingURL=bootstrap.min.css.map */ \ No newline at end of file diff --git a/datasets/Talluri2021/outage_report_instagram_files/cookie-consent-a61aae2999f43a6aa8bc.js b/datasets/Talluri2021/outage_report_instagram_files/cookie-consent-a61aae2999f43a6aa8bc.js new file mode 100644 index 0000000..7b07e48 --- /dev/null +++ b/datasets/Talluri2021/outage_report_instagram_files/cookie-consent-a61aae2999f43a6aa8bc.js @@ -0,0 +1,2 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[890],{1161:function(t,e,n){"use strict";t.exports=function(t,e,n,o,a,s,r,i){if(!t){var l;if(void 0===e)l=new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else{var c=[n,o,a,s,r,i],u=0;(l=new Error(e.replace(/%s/g,function(){return c[u++]}))).name="Invariant Violation"}throw l.framesToPop=1,l}}},15:function(t,e,n){"use strict";var o=n(24),a=n.n(o);e.a=a()({SERVICE_PAGE:null,MAP_PAGE:null,SERVICE_CITY_PAGE:null,SERVICE_SUBDIVISION_PAGE:null,SERVICE_DIVISION_PAGE:null,SERVICE_COUNTRY_PAGE:null,INDEX_PAGE:null,COUNTRY_PAGE:null,COMPANIES_PAGE:null,ERROR_PAGE:null,SCREENSHOT_CHART_PAGE:null,MAP_SCREENSHOT_PAGE:null,PRIVACY_POLICY_PAGE:null})},1710:function(t,e,n){t.exports=function(){"use strict";function t(e){return(t="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(e)}function e(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function n(t,e){for(var n=0;n1&&void 0!==arguments[1]?arguments[1]:"flex";t.style.opacity="",t.style.display=e},M=function(t){t.style.opacity="",t.style.display="none"},I=function(t,e,n){e?j(t,n):M(t)},V=function(t){return!(!t||!(t.offsetWidth||t.offsetHeight||t.getClientRects().length))},R=function(t){var e=window.getComputedStyle(t),n=parseFloat(e.getPropertyValue("animation-duration")||"0"),o=parseFloat(e.getPropertyValue("transition-duration")||"0");return n>0||o>0},H=function(){return document.body.querySelector("."+v.container)},q=function(t){var e=H();return e?e.querySelector(t):null},_=function(t){return q("."+t)},N=function(){return _(v.popup)},Y=function(){var t=N();return d(t.querySelectorAll("."+v.icon))},D=function(){var t=Y().filter(function(t){return V(t)});return t.length?t[0]:null},U=function(){return _(v.title)},F=function(){return _(v.content)},Z=function(){return _(v.image)},G=function(){return _(v["progress-steps"])},$=function(){return _(v["validation-message"])},W=function(){return q("."+v.actions+" ."+v.confirm)},K=function(){return q("."+v.actions+" ."+v.cancel)},X=function(){return _(v.actions)},J=function(){return _(v.header)},Q=function(){return _(v.footer)},tt=function(){return _(v.close)},et=function(){var t=d(N().querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])')).sort(function(t,e){return t=parseInt(t.getAttribute("tabindex")),e=parseInt(e.getAttribute("tabindex")),t>e?1:t\n
\n
    \n
    \n \n
    \n
    \n
    \n
    \n
    \n
    \n \n
    \n
    \n
    \n \n

    \n \n
    \n
    \n
    \n \n \n
    \n \n \n
    \n \n
    \n \n \n
    \n
    \n
    \n \n \n
    \n
    \n
    \n \n').replace(/(^|\n)\s*/g,""),rt=function(t){Ze.isVisible()&&E!==t.target.value&&Ze.resetValidationMessage(),E=t.target.value},it=function(t){if((m=H())&&(m.parentNode.removeChild(m),O([document.documentElement,document.body],[v["no-backdrop"],v["toast-shown"],v["has-column"]])),at())p("SweetAlert2 requires document to initialize");else{var e=document.createElement("div");e.className=v.container,e.innerHTML=st;var n,o,a,s,r,i,l,c,u,d="string"==typeof(n=t.target)?document.querySelector(n):n;d.appendChild(e),function(t){var e=N();e.setAttribute("role",t.toast?"alert":"dialog"),e.setAttribute("aria-live",t.toast?"polite":"assertive"),t.toast||e.setAttribute("aria-modal","true")}(t),function(t){"rtl"===window.getComputedStyle(t).direction&&T(H(),v.rtl)}(d),o=F(),a=L(o,v.input),s=L(o,v.file),r=o.querySelector(".".concat(v.range," input")),i=o.querySelector(".".concat(v.range," output")),l=L(o,v.select),c=o.querySelector(".".concat(v.checkbox," input")),u=L(o,v.textarea),a.oninput=rt,s.onchange=rt,l.onchange=rt,c.onchange=rt,u.oninput=rt,r.oninput=function(t){rt(t),i.value=r.value},r.onchange=function(t){rt(t),r.nextSibling.value=r.value}}var m},lt=function(e,n){e instanceof HTMLElement?n.appendChild(e):"object"===t(e)?ct(n,e):e&&(n.innerHTML=e)},ct=function(t,e){if(t.innerHTML="",0 in e)for(var n=0;n in e;n++)t.appendChild(e[n].cloneNode(!0));else t.appendChild(e.cloneNode(!0))},ut=function(){if(at())return!1;var t=document.createElement("div"),e={WebkitAnimation:"webkitAnimationEnd",OAnimation:"oAnimationEnd oanimationend",animation:"animationend"};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)&&void 0!==t.style[n])return e[n];return!1}(),dt=function(t,e){var n=X(),o=W(),a=K();e.showConfirmButton||e.showCancelButton||M(n),P(n,e.customClass,"actions"),mt(o,"confirm",e),mt(a,"cancel",e),e.buttonsStyling?function(t,e,n){T([t,e],v.styled),n.confirmButtonColor&&(t.style.backgroundColor=n.confirmButtonColor),n.cancelButtonColor&&(e.style.backgroundColor=n.cancelButtonColor);var o=window.getComputedStyle(t).getPropertyValue("background-color");t.style.borderLeftColor=o,t.style.borderRightColor=o}(o,a,e):(O([o,a],v.styled),o.style.backgroundColor=o.style.borderLeftColor=o.style.borderRightColor="",a.style.backgroundColor=a.style.borderLeftColor=a.style.borderRightColor=""),e.reverseButtons&&o.parentNode.insertBefore(a,o)};function mt(t,e,n){I(t,n["showC"+e.substring(1)+"Button"],"inline-block"),t.innerHTML=n[e+"ButtonText"],t.setAttribute("aria-label",n[e+"ButtonAriaLabel"]),t.className=v[e],P(t,n.customClass,e+"Button"),T(t,n[e+"ButtonClass"])}var pt=function(t,e){var n=H();n&&(function(t,e){"string"==typeof e?t.style.background=e:e||T([document.documentElement,document.body],v["no-backdrop"])}(n,e.backdrop),!e.backdrop&&e.allowOutsideClick&&m('"allowOutsideClick" parameter requires `backdrop` parameter to be set to `true`'),function(t,e){e in v?T(t,v[e]):(m('The "position" parameter is not valid, defaulting to "center"'),T(t,v.center))}(n,e.position),function(t,e){if(e&&"string"==typeof e){var n="grow-"+e;n in v&&T(t,v[n])}}(n,e.grow),P(n,e.customClass,"container"),e.customContainerClass&&T(n,e.customContainerClass))},wt={promise:new WeakMap,innerParams:new WeakMap,domCache:new WeakMap},ft=["input","file","range","select","radio","checkbox","textarea"],gt=function(t){if(!vt[t.input])return p('Unexpected type of input! Expected "text", "email", "password", "number", "tel", "select", "radio", "checkbox", "textarea", "file" or "url", got "'.concat(t.input,'"'));var e=vt[t.input](t);j(e),setTimeout(function(){S(e)})},ht=function(t,e){var n=A(F(),t);if(n)for(var o in function(t){for(var e=0;e=e.progressSteps.length&&m("Invalid currentProgressStep parameter, it should be less than progressSteps.length (currentProgressStep like JS arrays starts from 0)"),e.progressSteps.forEach(function(t,a){var s=function(t){var e=document.createElement("li");return T(e,v["progress-step"]),e.innerHTML=t,e}(t);if(n.appendChild(s),a===o&&T(s,v["active-progress-step"]),a!==e.progressSteps.length-1){var r=function(t){var e=document.createElement("li");return T(e,v["progress-step-line"]),t.progressStepsDistance&&(e.style.width=t.progressStepsDistance),e}(t);n.appendChild(r)}})},At=function(t,e){var n=J();P(n,e.customClass,"header"),Pt(t,e),function(t,e){var n=wt.innerParams.get(t);if(n&&e.type===n.type&&D())P(D(),e.customClass,"icon");else if(xt(),e.type)if(Ct(),-1!==Object.keys(k).indexOf(e.type)){var o=q(".".concat(v.icon,".").concat(k[e.type]));j(o),P(o,e.customClass,"icon"),B(o,"swal2-animate-".concat(e.type,"-icon"),e.animation)}else p('Unknown type! Expected "success", "error", "warning", "info" or "question", got "'.concat(e.type,'"'))}(t,e),function(t,e){var n=Z();if(!e.imageUrl)return M(n);j(n),n.setAttribute("src",e.imageUrl),n.setAttribute("alt",e.imageAlt),z(n,"width",e.imageWidth),z(n,"height",e.imageHeight),n.className=v.image,P(n,e.customClass,"image"),e.imageClass&&T(n,e.imageClass)}(0,e),function(t,e){var n=U();I(n,e.title||e.titleText),e.title&<(e.title,n),e.titleText&&(n.innerText=e.titleText),P(n,e.customClass,"title")}(0,e),function(t,e){var n=tt();n.innerHTML=e.closeButtonHtml,P(n,e.customClass,"closeButton"),I(n,e.showCloseButton),n.setAttribute("aria-label",e.closeButtonAriaLabel)}(0,e)},Et=function(t,e){!function(t,e){var n=N();z(n,"width",e.width),z(n,"padding",e.padding),e.background&&(n.style.background=e.background),n.className=v.popup,e.toast?(T([document.documentElement,document.body],v["toast-shown"]),T(n,v.toast)):T(n,v.modal),P(n,e.customClass,"popup"),"string"==typeof e.customClass&&T(n,e.customClass),B(n,v.noanimation,!e.animation)}(0,e),pt(0,e),At(t,e),kt(t,e),dt(0,e),function(t,e){var n=Q();I(n,e.footer),e.footer&<(e.footer,n),P(n,e.customClass,"footer")}(0,e)},St=function(){return W()&&W().click()},Bt=[],Tt=function(){var t=N();t||Ze.fire(""),t=N();var e=X(),n=W(),o=K();j(e),j(n),T([t,e],v.loading),n.disabled=!0,o.disabled=!0,t.setAttribute("data-loading",!0),t.setAttribute("aria-busy",!0),t.focus()},Ot={},Lt=function(){return new Promise(function(t){var e=window.scrollX,n=window.scrollY;Ot.restoreFocusTimeout=setTimeout(function(){Ot.previousActiveElement&&Ot.previousActiveElement.focus?(Ot.previousActiveElement.focus(),Ot.previousActiveElement=null):document.body&&document.body.focus(),t()},100),void 0!==e&&void 0!==n&&window.scrollTo(e,n)})},zt={title:"",titleText:"",text:"",html:"",footer:"",type:null,toast:!1,customClass:"",customContainerClass:"",target:"body",backdrop:!0,animation:!0,heightAuto:!0,allowOutsideClick:!0,allowEscapeKey:!0,allowEnterKey:!0,stopKeydownPropagation:!0,keydownListenerCapture:!1,showConfirmButton:!0,showCancelButton:!1,preConfirm:null,confirmButtonText:"OK",confirmButtonAriaLabel:"",confirmButtonColor:null,confirmButtonClass:"",cancelButtonText:"Cancel",cancelButtonAriaLabel:"",cancelButtonColor:null,cancelButtonClass:"",buttonsStyling:!0,reverseButtons:!1,focusConfirm:!0,focusCancel:!1,showCloseButton:!1,closeButtonHtml:"×",closeButtonAriaLabel:"Close this dialog",showLoaderOnConfirm:!1,imageUrl:null,imageWidth:null,imageHeight:null,imageAlt:"",imageClass:"",timer:null,width:null,padding:null,background:null,input:null,inputPlaceholder:"",inputValue:"",inputOptions:{},inputAutoTrim:!0,inputClass:"",inputAttributes:{},inputValidator:null,validationMessage:null,grow:!1,position:"center",progressSteps:[],currentProgressStep:null,progressStepsDistance:null,onBeforeOpen:null,onAfterClose:null,onOpen:null,onClose:null,scrollbarPadding:!0},jt=["title","titleText","text","html","type","customClass","showConfirmButton","showCancelButton","confirmButtonText","confirmButtonAriaLabel","confirmButtonColor","confirmButtonClass","cancelButtonText","cancelButtonAriaLabel","cancelButtonColor","cancelButtonClass","buttonsStyling","reverseButtons","imageUrl","imageWidth","imageHeigth","imageAlt","imageClass","progressSteps","currentProgressStep"],Mt={customContainerClass:"customClass",confirmButtonClass:"customClass",cancelButtonClass:"customClass",imageClass:"customClass",inputClass:"customClass"},It=["allowOutsideClick","allowEnterKey","backdrop","focusConfirm","focusCancel","heightAuto","keydownListenerCapture"],Vt=function(t){return Object.prototype.hasOwnProperty.call(zt,t)},Rt=function(t){return Mt[t]},Ht=function(t){Vt(t)||m('Unknown parameter "'.concat(t,'"'))},qt=function(t){-1!==It.indexOf(t)&&m('The parameter "'.concat(t,'" is incompatible with toasts'))},_t=function(t){Rt(t)&&f(t,Rt(t))},Nt=function(t){for(var e in t)Ht(e),t.toast&&qt(e),_t()},Yt=Object.freeze({isValidParameter:Vt,isUpdatableParameter:function(t){return-1!==jt.indexOf(t)},isDeprecatedParameter:Rt,argsToParams:function(e){var n={};switch(t(e[0])){case"object":a(n,e[0]);break;default:["title","html","type"].forEach(function(o,a){switch(t(e[a])){case"string":n[o]=e[a];break;case"undefined":break;default:p("Unexpected type of ".concat(o,'! Expected "string", got ').concat(t(e[a])))}})}return n},isVisible:function(){return V(N())},clickConfirm:St,clickCancel:function(){return K()&&K().click()},getContainer:H,getPopup:N,getTitle:U,getContent:F,getImage:Z,getIcon:D,getIcons:Y,getCloseButton:tt,getActions:X,getConfirmButton:W,getCancelButton:K,getHeader:J,getFooter:Q,getFocusableElements:et,getValidationMessage:$,isLoading:function(){return N().hasAttribute("data-loading")},fire:function(){for(var t=arguments.length,e=new Array(t),n=0;nwindow.innerHeight&&(x.previousBodyPadding=parseInt(window.getComputedStyle(document.body).getPropertyValue("padding-right")),document.body.style.paddingRight=x.previousBodyPadding+function(){if("ontouchstart"in window||navigator.msMaxTouchPoints)return 0;var t=document.createElement("div");t.style.width="50px",t.style.height="50px",t.style.overflow="scroll",document.body.appendChild(t);var e=t.offsetWidth-t.clientWidth;return document.body.removeChild(t),e}()+"px")},Ft=function(){null!==x.previousBodyPadding&&(document.body.style.paddingRight=x.previousBodyPadding+"px",x.previousBodyPadding=null)},Zt=function(){var t,e=H();e.ontouchstart=function(n){var o;t=n.target===e||!((o=e).scrollHeight>o.clientHeight)&&"INPUT"!==n.target.tagName},e.ontouchmove=function(e){t&&(e.preventDefault(),e.stopPropagation())}},Gt=function(){if(C(document.body,v.iosfix)){var t=parseInt(document.body.style.top,10);O(document.body,v.iosfix),document.body.style.top="",document.body.scrollTop=-1*t}},$t=function(){return!!window.MSInputMethodContext&&!!document.documentMode},Wt=function(){var t=H(),e=N();t.style.removeProperty("align-items"),e.offsetTop<0&&(t.style.alignItems="flex-start")},Kt=function(){"undefined"!=typeof window&&$t()&&window.removeEventListener("resize",Wt)},Xt=function(){var t=d(document.body.children);t.forEach(function(t){t.hasAttribute("data-previous-aria-hidden")?(t.setAttribute("aria-hidden",t.getAttribute("data-previous-aria-hidden")),t.removeAttribute("data-previous-aria-hidden")):t.removeAttribute("aria-hidden")})},Jt={swalPromiseResolve:new WeakMap};function Qt(t,e,n,o){n?ae(t,o):(Lt().then(function(){return ae(t,o)}),Ot.keydownTarget.removeEventListener("keydown",Ot.keydownHandler,{capture:Ot.keydownListenerCapture}),Ot.keydownHandlerAdded=!1),e.parentNode&&e.parentNode.removeChild(e),nt()&&(Ft(),Gt(),Kt(),Xt()),O([document.documentElement,document.body],[v.shown,v["height-auto"],v["no-backdrop"],v["toast-shown"],v["toast-column"]])}function te(t){var e=N();if(e&&!C(e,v.hide)){var n=wt.innerParams.get(this);if(n){var o=Jt.swalPromiseResolve.get(this);O(e,v.show),T(e,v.hide),ee(this,e,n),o(t||{})}}}var ee=function(t,e,n){var o=H(),a=ut&&R(e),s=n.onClose,r=n.onAfterClose;null!==s&&"function"==typeof s&&s(e),a?ne(t,e,o,r):Qt(t,o,ot(),r)},ne=function(t,e,n,o){Ot.swalCloseEventFinishedCallback=Qt.bind(null,t,n,ot(),o),e.addEventListener(ut,function(t){t.target===e&&(Ot.swalCloseEventFinishedCallback(),delete Ot.swalCloseEventFinishedCallback)})},oe=function(t){for(var e in t)t[e]=new WeakMap},ae=function(t,e){setTimeout(function(){null!==e&&"function"==typeof e&&e(),N()||function(t){delete t.params,delete Ot.keydownHandler,delete Ot.keydownTarget,oe(wt),oe(Jt)}(t)})};function se(t,e,n){var o=wt.domCache.get(t);e.forEach(function(t){o[t].disabled=n})}function re(t,e){if(!t)return!1;if("radio"===t.type)for(var n=t.parentNode.parentNode,o=n.querySelectorAll("input"),a=0;a")),it(t)}function ue(t,e){t.removeEventListener(ut,ue),e.style.overflowY="auto"}var de,me=function(t,e){ut&&R(e)?(t.style.overflowY="hidden",e.addEventListener(ut,ue.bind(null,e,t))):t.style.overflowY="auto"},pe=function(t,e){!function(){if(/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream&&!C(document.body,v.iosfix)){var t=document.body.scrollTop;document.body.style.top=-1*t+"px",T(document.body,v.iosfix),Zt()}}(),"undefined"!=typeof window&&$t()&&(Wt(),window.addEventListener("resize",Wt)),d(document.body.children).forEach(function(t){t===H()||function(t,e){if("function"==typeof t.contains)return t.contains(e)}(t,H())||(t.hasAttribute("aria-hidden")&&t.setAttribute("data-previous-aria-hidden",t.getAttribute("aria-hidden")),t.setAttribute("aria-hidden","true"))}),e&&Ut(),setTimeout(function(){t.scrollTop=0})},we=function(t,e,n){n.animation&&(T(e,v.show),T(t,v.fade)),j(e),T([document.documentElement,document.body,t],v.shown),n.heightAuto&&n.backdrop&&!n.toast&&T([document.documentElement,document.body],v["height-auto"])},fe=function(e,n){var o=F(),a=function(t){return he[n.input](o,be(t),n)};h(n.inputOptions)?(Tt(),n.inputOptions.then(function(t){e.hideLoading(),a(t)})):"object"===t(n.inputOptions)?a(n.inputOptions):p("Unexpected type of inputOptions! Expected object, Map or Promise, got ".concat(t(n.inputOptions)))},ge=function(t,e){var n=t.getInput();M(n),e.inputValue.then(function(o){n.value="number"===e.input?parseFloat(o)||0:o+"",j(n),n.focus(),t.hideLoading()}).catch(function(e){p("Error in inputValue promise: "+e),n.value="",j(n),n.focus(),t.hideLoading()})},he={select:function(t,e,n){var o=L(t,v.select);e.forEach(function(t){var e=t[0],a=t[1],s=document.createElement("option");s.value=e,s.innerHTML=a,n.inputValue.toString()===e.toString()&&(s.selected=!0),o.appendChild(s)}),o.focus()},radio:function(t,e,n){var o=L(t,v.radio);e.forEach(function(t){var e=t[0],a=t[1],s=document.createElement("input"),r=document.createElement("label");s.type="radio",s.name=v.radio,s.value=e,n.inputValue.toString()===e.toString()&&(s.checked=!0);var i=document.createElement("span");i.innerHTML=a,i.className=v.label,r.appendChild(s),r.appendChild(i),o.appendChild(r)});var a=o.querySelectorAll("input");a.length&&a[0].focus()}},be=function(t){var e=[];return"undefined"!=typeof Map&&t instanceof Map?t.forEach(function(t,n){e.push([n,t])}):Object.keys(t).forEach(function(n){e.push([n,t[n]])}),e},ye=function(t,e){var n=xe(t,e);if(e.inputValidator){t.disableInput();var o=Promise.resolve().then(function(){return e.inputValidator(n,e.validationMessage)});o.then(function(o){t.enableButtons(),t.enableInput(),o?t.showValidationMessage(o):ke(t,e,n)})}else t.getInput().checkValidity()?ke(t,e,n):(t.enableButtons(),t.showValidationMessage(e.validationMessage))},ve=function(t,e){t.closePopup({value:e})},ke=function(t,e,n){if(e.showLoaderOnConfirm&&Tt(),e.preConfirm){t.resetValidationMessage();var o=Promise.resolve().then(function(){return e.preConfirm(n,e.validationMessage)});o.then(function(e){V($())||!1===e?t.hideLoading():ve(t,void 0===e?n:e)})}else ve(t,n)},xe=function(t,e){var n=t.getInput();if(!n)return null;switch(e.input){case"checkbox":return Ce(n);case"radio":return Pe(n);case"file":return Ae(n);default:return e.inputAutoTrim?n.value.trim():n.value}},Ce=function(t){return t.checked?1:0},Pe=function(t){return t.checked?t.value:null},Ae=function(t){return t.files.length?t.files[0]:null},Ee=function(t,e,n){for(var o=et(t.focusCancel),a=0;a.swal2-modal{box-shadow:0 0 10px rgba(0,0,0,.4)}body.swal2-no-backdrop .swal2-shown.swal2-top{top:0;left:50%;transform:translateX(-50%)}body.swal2-no-backdrop .swal2-shown.swal2-top-left,body.swal2-no-backdrop .swal2-shown.swal2-top-start{top:0;left:0}body.swal2-no-backdrop .swal2-shown.swal2-top-end,body.swal2-no-backdrop .swal2-shown.swal2-top-right{top:0;right:0}body.swal2-no-backdrop .swal2-shown.swal2-center{top:50%;left:50%;transform:translate(-50%,-50%)}body.swal2-no-backdrop .swal2-shown.swal2-center-left,body.swal2-no-backdrop .swal2-shown.swal2-center-start{top:50%;left:0;transform:translateY(-50%)}body.swal2-no-backdrop .swal2-shown.swal2-center-end,body.swal2-no-backdrop .swal2-shown.swal2-center-right{top:50%;right:0;transform:translateY(-50%)}body.swal2-no-backdrop .swal2-shown.swal2-bottom{bottom:0;left:50%;transform:translateX(-50%)}body.swal2-no-backdrop .swal2-shown.swal2-bottom-left,body.swal2-no-backdrop .swal2-shown.swal2-bottom-start{bottom:0;left:0}body.swal2-no-backdrop .swal2-shown.swal2-bottom-end,body.swal2-no-backdrop .swal2-shown.swal2-bottom-right{right:0;bottom:0}.swal2-container{display:flex;position:fixed;z-index:1060;top:0;right:0;bottom:0;left:0;flex-direction:row;align-items:center;justify-content:center;padding:.625em;overflow-x:hidden;background-color:transparent;-webkit-overflow-scrolling:touch}.swal2-container.swal2-top{align-items:flex-start}.swal2-container.swal2-top-left,.swal2-container.swal2-top-start{align-items:flex-start;justify-content:flex-start}.swal2-container.swal2-top-end,.swal2-container.swal2-top-right{align-items:flex-start;justify-content:flex-end}.swal2-container.swal2-center{align-items:center}.swal2-container.swal2-center-left,.swal2-container.swal2-center-start{align-items:center;justify-content:flex-start}.swal2-container.swal2-center-end,.swal2-container.swal2-center-right{align-items:center;justify-content:flex-end}.swal2-container.swal2-bottom{align-items:flex-end}.swal2-container.swal2-bottom-left,.swal2-container.swal2-bottom-start{align-items:flex-end;justify-content:flex-start}.swal2-container.swal2-bottom-end,.swal2-container.swal2-bottom-right{align-items:flex-end;justify-content:flex-end}.swal2-container.swal2-bottom-end>:first-child,.swal2-container.swal2-bottom-left>:first-child,.swal2-container.swal2-bottom-right>:first-child,.swal2-container.swal2-bottom-start>:first-child,.swal2-container.swal2-bottom>:first-child{margin-top:auto}.swal2-container.swal2-grow-fullscreen>.swal2-modal{display:flex!important;flex:1;align-self:stretch;justify-content:center}.swal2-container.swal2-grow-row>.swal2-modal{display:flex!important;flex:1;align-content:center;justify-content:center}.swal2-container.swal2-grow-column{flex:1;flex-direction:column}.swal2-container.swal2-grow-column.swal2-bottom,.swal2-container.swal2-grow-column.swal2-center,.swal2-container.swal2-grow-column.swal2-top{align-items:center}.swal2-container.swal2-grow-column.swal2-bottom-left,.swal2-container.swal2-grow-column.swal2-bottom-start,.swal2-container.swal2-grow-column.swal2-center-left,.swal2-container.swal2-grow-column.swal2-center-start,.swal2-container.swal2-grow-column.swal2-top-left,.swal2-container.swal2-grow-column.swal2-top-start{align-items:flex-start}.swal2-container.swal2-grow-column.swal2-bottom-end,.swal2-container.swal2-grow-column.swal2-bottom-right,.swal2-container.swal2-grow-column.swal2-center-end,.swal2-container.swal2-grow-column.swal2-center-right,.swal2-container.swal2-grow-column.swal2-top-end,.swal2-container.swal2-grow-column.swal2-top-right{align-items:flex-end}.swal2-container.swal2-grow-column>.swal2-modal{display:flex!important;flex:1;align-content:center;justify-content:center}.swal2-container:not(.swal2-top):not(.swal2-top-start):not(.swal2-top-end):not(.swal2-top-left):not(.swal2-top-right):not(.swal2-center-start):not(.swal2-center-end):not(.swal2-center-left):not(.swal2-center-right):not(.swal2-bottom):not(.swal2-bottom-start):not(.swal2-bottom-end):not(.swal2-bottom-left):not(.swal2-bottom-right):not(.swal2-grow-fullscreen)>.swal2-modal{margin:auto}@media all and (-ms-high-contrast:none),(-ms-high-contrast:active){.swal2-container .swal2-modal{margin:0!important}}.swal2-container.swal2-fade{transition:background-color .1s}.swal2-container.swal2-shown{background-color:rgba(0,0,0,.4)}.swal2-popup{display:none;position:relative;box-sizing:border-box;flex-direction:column;justify-content:center;width:32em;max-width:100%;padding:1.25em;border:none;border-radius:.3125em;background:#fff;font-family:inherit;font-size:1rem}.swal2-popup:focus{outline:0}.swal2-popup.swal2-loading{overflow-y:hidden}.swal2-header{display:flex;flex-direction:column;align-items:center}.swal2-title{position:relative;max-width:100%;margin:0 0 .4em;padding:0;color:#595959;font-size:1.875em;font-weight:600;text-align:center;text-transform:none;word-wrap:break-word}.swal2-actions{display:flex;z-index:1;flex-wrap:wrap;align-items:center;justify-content:center;width:100%;margin:1.25em auto 0}.swal2-actions:not(.swal2-loading) .swal2-styled[disabled]{opacity:.4}.swal2-actions:not(.swal2-loading) .swal2-styled:hover{background-image:linear-gradient(rgba(0,0,0,.1),rgba(0,0,0,.1))}.swal2-actions:not(.swal2-loading) .swal2-styled:active{background-image:linear-gradient(rgba(0,0,0,.2),rgba(0,0,0,.2))}.swal2-actions.swal2-loading .swal2-styled.swal2-confirm{box-sizing:border-box;width:2.5em;height:2.5em;margin:.46875em;padding:0;-webkit-animation:swal2-rotate-loading 1.5s linear 0s infinite normal;animation:swal2-rotate-loading 1.5s linear 0s infinite normal;border:.25em solid transparent;border-radius:100%;border-color:transparent;background-color:transparent!important;color:transparent;cursor:default;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.swal2-actions.swal2-loading .swal2-styled.swal2-cancel{margin-right:30px;margin-left:30px}.swal2-actions.swal2-loading :not(.swal2-styled).swal2-confirm::after{content:"";display:inline-block;width:15px;height:15px;margin-left:5px;-webkit-animation:swal2-rotate-loading 1.5s linear 0s infinite normal;animation:swal2-rotate-loading 1.5s linear 0s infinite normal;border:3px solid #999;border-radius:50%;border-right-color:transparent;box-shadow:1px 1px 1px #fff}.swal2-styled{margin:.3125em;padding:.625em 2em;box-shadow:none;font-weight:500}.swal2-styled:not([disabled]){cursor:pointer}.swal2-styled.swal2-confirm{border:0;border-radius:.25em;background:initial;background-color:#3085d6;color:#fff;font-size:1.0625em}.swal2-styled.swal2-cancel{border:0;border-radius:.25em;background:initial;background-color:#aaa;color:#fff;font-size:1.0625em}.swal2-styled:focus{outline:0;box-shadow:0 0 0 2px #fff,0 0 0 4px rgba(50,100,150,.4)}.swal2-styled::-moz-focus-inner{border:0}.swal2-footer{justify-content:center;margin:1.25em 0 0;padding:1em 0 0;border-top:1px solid #eee;color:#545454;font-size:1em}.swal2-image{max-width:100%;margin:1.25em auto}.swal2-close{position:absolute;z-index:2;top:0;right:0;justify-content:center;width:1.2em;height:1.2em;padding:0;overflow:hidden;transition:color .1s ease-out;border:none;border-radius:0;outline:initial;background:0 0;color:#ccc;font-family:serif;font-size:2.5em;line-height:1.2;cursor:pointer}.swal2-close:hover{transform:none;background:0 0;color:#f27474}.swal2-content{z-index:1;justify-content:center;margin:0;padding:0;color:#545454;font-size:1.125em;font-weight:300;line-height:normal;text-align:center;word-wrap:break-word}.swal2-checkbox,.swal2-file,.swal2-input,.swal2-radio,.swal2-select,.swal2-textarea{margin:1em auto}.swal2-file,.swal2-input,.swal2-textarea{box-sizing:border-box;width:100%;transition:border-color .3s,box-shadow .3s;border:1px solid #d9d9d9;border-radius:.1875em;background:inherit;box-shadow:inset 0 1px 1px rgba(0,0,0,.06);color:inherit;font-size:1.125em}.swal2-file.swal2-inputerror,.swal2-input.swal2-inputerror,.swal2-textarea.swal2-inputerror{border-color:#f27474!important;box-shadow:0 0 2px #f27474!important}.swal2-file:focus,.swal2-input:focus,.swal2-textarea:focus{border:1px solid #b4dbed;outline:0;box-shadow:0 0 3px #c4e6f5}.swal2-file::-webkit-input-placeholder,.swal2-input::-webkit-input-placeholder,.swal2-textarea::-webkit-input-placeholder{color:#ccc}.swal2-file::-moz-placeholder,.swal2-input::-moz-placeholder,.swal2-textarea::-moz-placeholder{color:#ccc}.swal2-file:-ms-input-placeholder,.swal2-input:-ms-input-placeholder,.swal2-textarea:-ms-input-placeholder{color:#ccc}.swal2-file::-ms-input-placeholder,.swal2-input::-ms-input-placeholder,.swal2-textarea::-ms-input-placeholder{color:#ccc}.swal2-file::placeholder,.swal2-input::placeholder,.swal2-textarea::placeholder{color:#ccc}.swal2-range{margin:1em auto;background:inherit}.swal2-range input{width:80%}.swal2-range output{width:20%;color:inherit;font-weight:600;text-align:center}.swal2-range input,.swal2-range output{height:2.625em;padding:0;font-size:1.125em;line-height:2.625em}.swal2-input{height:2.625em;padding:0 .75em}.swal2-input[type=number]{max-width:10em}.swal2-file{background:inherit;font-size:1.125em}.swal2-textarea{height:6.75em;padding:.75em}.swal2-select{min-width:50%;max-width:100%;padding:.375em .625em;background:inherit;color:inherit;font-size:1.125em}.swal2-checkbox,.swal2-radio{align-items:center;justify-content:center;background:inherit;color:inherit}.swal2-checkbox label,.swal2-radio label{margin:0 .6em;font-size:1.125em}.swal2-checkbox input,.swal2-radio input{margin:0 .4em}.swal2-validation-message{display:none;align-items:center;justify-content:center;padding:.625em;overflow:hidden;background:#f0f0f0;color:#666;font-size:1em;font-weight:300}.swal2-validation-message::before{content:"!";display:inline-block;width:1.5em;min-width:1.5em;height:1.5em;margin:0 .625em;zoom:normal;border-radius:50%;background-color:#f27474;color:#fff;font-weight:600;line-height:1.5em;text-align:center}@supports (-ms-accelerator:true){.swal2-range input{width:100%!important}.swal2-range output{display:none}}@media all and (-ms-high-contrast:none),(-ms-high-contrast:active){.swal2-range input{width:100%!important}.swal2-range output{display:none}}@-moz-document url-prefix(){.swal2-close:focus{outline:2px solid rgba(50,100,150,.4)}}.swal2-icon{position:relative;box-sizing:content-box;justify-content:center;width:5em;height:5em;margin:1.25em auto 1.875em;zoom:normal;border:.25em solid transparent;border-radius:50%;font-family:inherit;line-height:5em;cursor:default;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.swal2-icon::before{display:flex;align-items:center;height:92%;font-size:3.75em}.swal2-icon.swal2-error{border-color:#f27474}.swal2-icon.swal2-error .swal2-x-mark{position:relative;flex-grow:1}.swal2-icon.swal2-error [class^=swal2-x-mark-line]{display:block;position:absolute;top:2.3125em;width:2.9375em;height:.3125em;border-radius:.125em;background-color:#f27474}.swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=left]{left:1.0625em;transform:rotate(45deg)}.swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=right]{right:1em;transform:rotate(-45deg)}.swal2-icon.swal2-warning{border-color:#facea8;color:#f8bb86}.swal2-icon.swal2-warning::before{content:"!"}.swal2-icon.swal2-info{border-color:#9de0f6;color:#3fc3ee}.swal2-icon.swal2-info::before{content:"i"}.swal2-icon.swal2-question{border-color:#c9dae1;color:#87adbd}.swal2-icon.swal2-question::before{content:"?"}.swal2-icon.swal2-question.swal2-arabic-question-mark::before{content:"؟"}.swal2-icon.swal2-success{border-color:#a5dc86}.swal2-icon.swal2-success [class^=swal2-success-circular-line]{position:absolute;width:3.75em;height:7.5em;transform:rotate(45deg);border-radius:50%}.swal2-icon.swal2-success [class^=swal2-success-circular-line][class$=left]{top:-.4375em;left:-2.0635em;transform:rotate(-45deg);transform-origin:3.75em 3.75em;border-radius:7.5em 0 0 7.5em}.swal2-icon.swal2-success [class^=swal2-success-circular-line][class$=right]{top:-.6875em;left:1.875em;transform:rotate(-45deg);transform-origin:0 3.75em;border-radius:0 7.5em 7.5em 0}.swal2-icon.swal2-success .swal2-success-ring{position:absolute;z-index:2;top:-.25em;left:-.25em;box-sizing:content-box;width:100%;height:100%;border:.25em solid rgba(165,220,134,.3);border-radius:50%}.swal2-icon.swal2-success .swal2-success-fix{position:absolute;z-index:1;top:.5em;left:1.625em;width:.4375em;height:5.625em;transform:rotate(-45deg)}.swal2-icon.swal2-success [class^=swal2-success-line]{display:block;position:absolute;z-index:2;height:.3125em;border-radius:.125em;background-color:#a5dc86}.swal2-icon.swal2-success [class^=swal2-success-line][class$=tip]{top:2.875em;left:.875em;width:1.5625em;transform:rotate(45deg)}.swal2-icon.swal2-success [class^=swal2-success-line][class$=long]{top:2.375em;right:.5em;width:2.9375em;transform:rotate(-45deg)}.swal2-progress-steps{align-items:center;margin:0 0 1.25em;padding:0;background:inherit;font-weight:600}.swal2-progress-steps li{display:inline-block;position:relative}.swal2-progress-steps .swal2-progress-step{z-index:20;width:2em;height:2em;border-radius:2em;background:#3085d6;color:#fff;line-height:2em;text-align:center}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step{background:#3085d6}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step~.swal2-progress-step{background:#add8e6;color:#fff}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step~.swal2-progress-step-line{background:#add8e6}.swal2-progress-steps .swal2-progress-step-line{z-index:10;width:2.5em;height:.4em;margin:0 -1px;background:#3085d6}[class^=swal2]{-webkit-tap-highlight-color:transparent}.swal2-show{-webkit-animation:swal2-show .3s;animation:swal2-show .3s}.swal2-show.swal2-noanimation{-webkit-animation:none;animation:none}.swal2-hide{-webkit-animation:swal2-hide .15s forwards;animation:swal2-hide .15s forwards}.swal2-hide.swal2-noanimation{-webkit-animation:none;animation:none}.swal2-rtl .swal2-close{right:auto;left:0}.swal2-animate-success-icon .swal2-success-line-tip{-webkit-animation:swal2-animate-success-line-tip .75s;animation:swal2-animate-success-line-tip .75s}.swal2-animate-success-icon .swal2-success-line-long{-webkit-animation:swal2-animate-success-line-long .75s;animation:swal2-animate-success-line-long .75s}.swal2-animate-success-icon .swal2-success-circular-line-right{-webkit-animation:swal2-rotate-success-circular-line 4.25s ease-in;animation:swal2-rotate-success-circular-line 4.25s ease-in}.swal2-animate-error-icon{-webkit-animation:swal2-animate-error-icon .5s;animation:swal2-animate-error-icon .5s}.swal2-animate-error-icon .swal2-x-mark{-webkit-animation:swal2-animate-error-x-mark .5s;animation:swal2-animate-error-x-mark .5s}@-webkit-keyframes swal2-rotate-loading{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}@keyframes swal2-rotate-loading{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}@media print{body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown){overflow-y:scroll!important}body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown)>[aria-hidden=true]{display:none}body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown) .swal2-container{position:static!important}}')},1722:function(t,e,n){"use strict";n.r(e);var o=n(1710),a=n.n(o),s=n(24),r=n.n(s)()({ACCEPT:null,REJECT:null}),i=n(15),l=window.localStorage,c=window.adsbygoogle||[],u=function(){return c.pauseAdRequests=0},d=function(){c.requestNonPersonalizedAds=0,u()},m=function(){c.requestNonPersonalizedAds=1,u()};c.pauseAdRequests=1;for(var p=0;pThis site and our partners collect data and use cookies to understand how you use our site and to\n improve your experience. Learn More

    ',allowOutsideClick:!1,allowEscapeKey:!1,showCancelButton:!0,focusConfirm:!1,confirmButtonText:"Accept",confirmButtonAriaLabel:"Thumbs up, great!",cancelButtonText:"Reject",cancelButtonAriaLabel:"Thumbs down"}).then(function(t){t.value?(l.setItem("orepCookieConsent",r.ACCEPT),d()):"cancel"===t.dismiss&&(l.setItem("orepCookieConsent",r.REJECT),m())})}})},1731:function(t,e,n){t.exports=n(1722)},24:function(t,e,n){"use strict";var o=n(1161);t.exports=function(t){var e,n={};for(e in t instanceof Object&&!Array.isArray(t)||o(!1),t)t.hasOwnProperty(e)&&(n[e]=e);return n}}},[[1731,888]]]); +//# sourceMappingURL=cookie-consent-a61aae2999f43a6aa8bc.js.map \ No newline at end of file diff --git a/datasets/Talluri2021/outage_report_instagram_files/css.css b/datasets/Talluri2021/outage_report_instagram_files/css.css new file mode 100644 index 0000000..8f7430a --- /dev/null +++ b/datasets/Talluri2021/outage_report_instagram_files/css.css @@ -0,0 +1,168 @@ +/* cyrillic-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 400; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu72xKKTU1Kvnz.woff2) format('woff2'); + unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F; +} +/* cyrillic */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 400; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu5mxKKTU1Kvnz.woff2) format('woff2'); + unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116; +} +/* greek-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 400; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu7mxKKTU1Kvnz.woff2) format('woff2'); + unicode-range: U+1F00-1FFF; +} +/* greek */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 400; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu4WxKKTU1Kvnz.woff2) format('woff2'); + unicode-range: U+0370-03FF; +} +/* vietnamese */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 400; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu7WxKKTU1Kvnz.woff2) format('woff2'); + unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+1EA0-1EF9, U+20AB; +} +/* latin-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 400; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu7GxKKTU1Kvnz.woff2) format('woff2'); + unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF; +} +/* latin */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 400; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu4mxKKTU1Kg.woff2) format('woff2'); + unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD; +} +/* cyrillic-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 500; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fCRc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F; +} +/* cyrillic */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 500; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fABc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116; +} +/* greek-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 500; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fCBc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+1F00-1FFF; +} +/* greek */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 500; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fBxc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0370-03FF; +} +/* vietnamese */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 500; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fCxc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+1EA0-1EF9, U+20AB; +} +/* latin-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 500; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fChc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF; +} +/* latin */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 500; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fBBc4AMP6lQ.woff2) format('woff2'); + unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD; +} +/* cyrillic-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 700; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfCRc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F; +} +/* cyrillic */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 700; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfABc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116; +} +/* greek-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 700; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfCBc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+1F00-1FFF; +} +/* greek */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 700; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfBxc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0370-03FF; +} +/* vietnamese */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 700; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfCxc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+1EA0-1EF9, U+20AB; +} +/* latin-ext */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 700; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfChc4AMP6lbBP.woff2) format('woff2'); + unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF; +} +/* latin */ +@font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 700; + src: url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfBBc4AMP6lQ.woff2) format('woff2'); + unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD; +} diff --git a/datasets/Talluri2021/outage_report_instagram_files/font-awesome.css b/datasets/Talluri2021/outage_report_instagram_files/font-awesome.css new file mode 100644 index 0000000..540440c --- /dev/null +++ b/datasets/Talluri2021/outage_report_instagram_files/font-awesome.css @@ -0,0 +1,4 @@ +/*! + * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */@font-face{font-family:'FontAwesome';src:url('../fonts/fontawesome-webfont.eot?v=4.7.0');src:url('../fonts/fontawesome-webfont.eot?#iefix&v=4.7.0') format('embedded-opentype'),url('../fonts/fontawesome-webfont.woff2?v=4.7.0') format('woff2'),url('../fonts/fontawesome-webfont.woff?v=4.7.0') format('woff'),url('../fonts/fontawesome-webfont.ttf?v=4.7.0') format('truetype'),url('../fonts/fontawesome-webfont.svg?v=4.7.0#fontawesomeregular') format('svg');font-weight:normal;font-style:normal}.fa{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571429em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14285714em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14285714em;width:2.14285714em;top:.14285714em;text-align:center}.fa-li.fa-lg{left:-1.85714286em}.fa-border{padding:.2em .25em .15em;border:solid .08em #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left{margin-right:.3em}.fa.fa-pull-right{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left{margin-right:.3em}.fa.pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s infinite linear;animation:fa-spin 2s infinite linear}.fa-pulse{-webkit-animation:fa-spin 1s infinite steps(8);animation:fa-spin 1s infinite steps(8)}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scale(-1, 1);-ms-transform:scale(-1, 1);transform:scale(-1, 1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scale(1, -1);-ms-transform:scale(1, -1);transform:scale(1, -1)}:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270,:root .fa-flip-horizontal,:root .fa-flip-vertical{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:"\f000"}.fa-music:before{content:"\f001"}.fa-search:before{content:"\f002"}.fa-envelope-o:before{content:"\f003"}.fa-heart:before{content:"\f004"}.fa-star:before{content:"\f005"}.fa-star-o:before{content:"\f006"}.fa-user:before{content:"\f007"}.fa-film:before{content:"\f008"}.fa-th-large:before{content:"\f009"}.fa-th:before{content:"\f00a"}.fa-th-list:before{content:"\f00b"}.fa-check:before{content:"\f00c"}.fa-remove:before,.fa-close:before,.fa-times:before{content:"\f00d"}.fa-search-plus:before{content:"\f00e"}.fa-search-minus:before{content:"\f010"}.fa-power-off:before{content:"\f011"}.fa-signal:before{content:"\f012"}.fa-gear:before,.fa-cog:before{content:"\f013"}.fa-trash-o:before{content:"\f014"}.fa-home:before{content:"\f015"}.fa-file-o:before{content:"\f016"}.fa-clock-o:before{content:"\f017"}.fa-road:before{content:"\f018"}.fa-download:before{content:"\f019"}.fa-arrow-circle-o-down:before{content:"\f01a"}.fa-arrow-circle-o-up:before{content:"\f01b"}.fa-inbox:before{content:"\f01c"}.fa-play-circle-o:before{content:"\f01d"}.fa-rotate-right:before,.fa-repeat:before{content:"\f01e"}.fa-refresh:before{content:"\f021"}.fa-list-alt:before{content:"\f022"}.fa-lock:before{content:"\f023"}.fa-flag:before{content:"\f024"}.fa-headphones:before{content:"\f025"}.fa-volume-off:before{content:"\f026"}.fa-volume-down:before{content:"\f027"}.fa-volume-up:before{content:"\f028"}.fa-qrcode:before{content:"\f029"}.fa-barcode:before{content:"\f02a"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-book:before{content:"\f02d"}.fa-bookmark:before{content:"\f02e"}.fa-print:before{content:"\f02f"}.fa-camera:before{content:"\f030"}.fa-font:before{content:"\f031"}.fa-bold:before{content:"\f032"}.fa-italic:before{content:"\f033"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-align-left:before{content:"\f036"}.fa-align-center:before{content:"\f037"}.fa-align-right:before{content:"\f038"}.fa-align-justify:before{content:"\f039"}.fa-list:before{content:"\f03a"}.fa-dedent:before,.fa-outdent:before{content:"\f03b"}.fa-indent:before{content:"\f03c"}.fa-video-camera:before{content:"\f03d"}.fa-photo:before,.fa-image:before,.fa-picture-o:before{content:"\f03e"}.fa-pencil:before{content:"\f040"}.fa-map-marker:before{content:"\f041"}.fa-adjust:before{content:"\f042"}.fa-tint:before{content:"\f043"}.fa-edit:before,.fa-pencil-square-o:before{content:"\f044"}.fa-share-square-o:before{content:"\f045"}.fa-check-square-o:before{content:"\f046"}.fa-arrows:before{content:"\f047"}.fa-step-backward:before{content:"\f048"}.fa-fast-backward:before{content:"\f049"}.fa-backward:before{content:"\f04a"}.fa-play:before{content:"\f04b"}.fa-pause:before{content:"\f04c"}.fa-stop:before{content:"\f04d"}.fa-forward:before{content:"\f04e"}.fa-fast-forward:before{content:"\f050"}.fa-step-forward:before{content:"\f051"}.fa-eject:before{content:"\f052"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-plus-circle:before{content:"\f055"}.fa-minus-circle:before{content:"\f056"}.fa-times-circle:before{content:"\f057"}.fa-check-circle:before{content:"\f058"}.fa-question-circle:before{content:"\f059"}.fa-info-circle:before{content:"\f05a"}.fa-crosshairs:before{content:"\f05b"}.fa-times-circle-o:before{content:"\f05c"}.fa-check-circle-o:before{content:"\f05d"}.fa-ban:before{content:"\f05e"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrow-down:before{content:"\f063"}.fa-mail-forward:before,.fa-share:before{content:"\f064"}.fa-expand:before{content:"\f065"}.fa-compress:before{content:"\f066"}.fa-plus:before{content:"\f067"}.fa-minus:before{content:"\f068"}.fa-asterisk:before{content:"\f069"}.fa-exclamation-circle:before{content:"\f06a"}.fa-gift:before{content:"\f06b"}.fa-leaf:before{content:"\f06c"}.fa-fire:before{content:"\f06d"}.fa-eye:before{content:"\f06e"}.fa-eye-slash:before{content:"\f070"}.fa-warning:before,.fa-exclamation-triangle:before{content:"\f071"}.fa-plane:before{content:"\f072"}.fa-calendar:before{content:"\f073"}.fa-random:before{content:"\f074"}.fa-comment:before{content:"\f075"}.fa-magnet:before{content:"\f076"}.fa-chevron-up:before{content:"\f077"}.fa-chevron-down:before{content:"\f078"}.fa-retweet:before{content:"\f079"}.fa-shopping-cart:before{content:"\f07a"}.fa-folder:before{content:"\f07b"}.fa-folder-open:before{content:"\f07c"}.fa-arrows-v:before{content:"\f07d"}.fa-arrows-h:before{content:"\f07e"}.fa-bar-chart-o:before,.fa-bar-chart:before{content:"\f080"}.fa-twitter-square:before{content:"\f081"}.fa-facebook-square:before{content:"\f082"}.fa-camera-retro:before{content:"\f083"}.fa-key:before{content:"\f084"}.fa-gears:before,.fa-cogs:before{content:"\f085"}.fa-comments:before{content:"\f086"}.fa-thumbs-o-up:before{content:"\f087"}.fa-thumbs-o-down:before{content:"\f088"}.fa-star-half:before{content:"\f089"}.fa-heart-o:before{content:"\f08a"}.fa-sign-out:before{content:"\f08b"}.fa-linkedin-square:before{content:"\f08c"}.fa-thumb-tack:before{content:"\f08d"}.fa-external-link:before{content:"\f08e"}.fa-sign-in:before{content:"\f090"}.fa-trophy:before{content:"\f091"}.fa-github-square:before{content:"\f092"}.fa-upload:before{content:"\f093"}.fa-lemon-o:before{content:"\f094"}.fa-phone:before{content:"\f095"}.fa-square-o:before{content:"\f096"}.fa-bookmark-o:before{content:"\f097"}.fa-phone-square:before{content:"\f098"}.fa-twitter:before{content:"\f099"}.fa-facebook-f:before,.fa-facebook:before{content:"\f09a"}.fa-github:before{content:"\f09b"}.fa-unlock:before{content:"\f09c"}.fa-credit-card:before{content:"\f09d"}.fa-feed:before,.fa-rss:before{content:"\f09e"}.fa-hdd-o:before{content:"\f0a0"}.fa-bullhorn:before{content:"\f0a1"}.fa-bell:before{content:"\f0f3"}.fa-certificate:before{content:"\f0a3"}.fa-hand-o-right:before{content:"\f0a4"}.fa-hand-o-left:before{content:"\f0a5"}.fa-hand-o-up:before{content:"\f0a6"}.fa-hand-o-down:before{content:"\f0a7"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-globe:before{content:"\f0ac"}.fa-wrench:before{content:"\f0ad"}.fa-tasks:before{content:"\f0ae"}.fa-filter:before{content:"\f0b0"}.fa-briefcase:before{content:"\f0b1"}.fa-arrows-alt:before{content:"\f0b2"}.fa-group:before,.fa-users:before{content:"\f0c0"}.fa-chain:before,.fa-link:before{content:"\f0c1"}.fa-cloud:before{content:"\f0c2"}.fa-flask:before{content:"\f0c3"}.fa-cut:before,.fa-scissors:before{content:"\f0c4"}.fa-copy:before,.fa-files-o:before{content:"\f0c5"}.fa-paperclip:before{content:"\f0c6"}.fa-save:before,.fa-floppy-o:before{content:"\f0c7"}.fa-square:before{content:"\f0c8"}.fa-navicon:before,.fa-reorder:before,.fa-bars:before{content:"\f0c9"}.fa-list-ul:before{content:"\f0ca"}.fa-list-ol:before{content:"\f0cb"}.fa-strikethrough:before{content:"\f0cc"}.fa-underline:before{content:"\f0cd"}.fa-table:before{content:"\f0ce"}.fa-magic:before{content:"\f0d0"}.fa-truck:before{content:"\f0d1"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-square:before{content:"\f0d3"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-plus:before{content:"\f0d5"}.fa-money:before{content:"\f0d6"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-up:before{content:"\f0d8"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-columns:before{content:"\f0db"}.fa-unsorted:before,.fa-sort:before{content:"\f0dc"}.fa-sort-down:before,.fa-sort-desc:before{content:"\f0dd"}.fa-sort-up:before,.fa-sort-asc:before{content:"\f0de"}.fa-envelope:before{content:"\f0e0"}.fa-linkedin:before{content:"\f0e1"}.fa-rotate-left:before,.fa-undo:before{content:"\f0e2"}.fa-legal:before,.fa-gavel:before{content:"\f0e3"}.fa-dashboard:before,.fa-tachometer:before{content:"\f0e4"}.fa-comment-o:before{content:"\f0e5"}.fa-comments-o:before{content:"\f0e6"}.fa-flash:before,.fa-bolt:before{content:"\f0e7"}.fa-sitemap:before{content:"\f0e8"}.fa-umbrella:before{content:"\f0e9"}.fa-paste:before,.fa-clipboard:before{content:"\f0ea"}.fa-lightbulb-o:before{content:"\f0eb"}.fa-exchange:before{content:"\f0ec"}.fa-cloud-download:before{content:"\f0ed"}.fa-cloud-upload:before{content:"\f0ee"}.fa-user-md:before{content:"\f0f0"}.fa-stethoscope:before{content:"\f0f1"}.fa-suitcase:before{content:"\f0f2"}.fa-bell-o:before{content:"\f0a2"}.fa-coffee:before{content:"\f0f4"}.fa-cutlery:before{content:"\f0f5"}.fa-file-text-o:before{content:"\f0f6"}.fa-building-o:before{content:"\f0f7"}.fa-hospital-o:before{content:"\f0f8"}.fa-ambulance:before{content:"\f0f9"}.fa-medkit:before{content:"\f0fa"}.fa-fighter-jet:before{content:"\f0fb"}.fa-beer:before{content:"\f0fc"}.fa-h-square:before{content:"\f0fd"}.fa-plus-square:before{content:"\f0fe"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angle-down:before{content:"\f107"}.fa-desktop:before{content:"\f108"}.fa-laptop:before{content:"\f109"}.fa-tablet:before{content:"\f10a"}.fa-mobile-phone:before,.fa-mobile:before{content:"\f10b"}.fa-circle-o:before{content:"\f10c"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-spinner:before{content:"\f110"}.fa-circle:before{content:"\f111"}.fa-mail-reply:before,.fa-reply:before{content:"\f112"}.fa-github-alt:before{content:"\f113"}.fa-folder-o:before{content:"\f114"}.fa-folder-open-o:before{content:"\f115"}.fa-smile-o:before{content:"\f118"}.fa-frown-o:before{content:"\f119"}.fa-meh-o:before{content:"\f11a"}.fa-gamepad:before{content:"\f11b"}.fa-keyboard-o:before{content:"\f11c"}.fa-flag-o:before{content:"\f11d"}.fa-flag-checkered:before{content:"\f11e"}.fa-terminal:before{content:"\f120"}.fa-code:before{content:"\f121"}.fa-mail-reply-all:before,.fa-reply-all:before{content:"\f122"}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:"\f123"}.fa-location-arrow:before{content:"\f124"}.fa-crop:before{content:"\f125"}.fa-code-fork:before{content:"\f126"}.fa-unlink:before,.fa-chain-broken:before{content:"\f127"}.fa-question:before{content:"\f128"}.fa-info:before{content:"\f129"}.fa-exclamation:before{content:"\f12a"}.fa-superscript:before{content:"\f12b"}.fa-subscript:before{content:"\f12c"}.fa-eraser:before{content:"\f12d"}.fa-puzzle-piece:before{content:"\f12e"}.fa-microphone:before{content:"\f130"}.fa-microphone-slash:before{content:"\f131"}.fa-shield:before{content:"\f132"}.fa-calendar-o:before{content:"\f133"}.fa-fire-extinguisher:before{content:"\f134"}.fa-rocket:before{content:"\f135"}.fa-maxcdn:before{content:"\f136"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-html5:before{content:"\f13b"}.fa-css3:before{content:"\f13c"}.fa-anchor:before{content:"\f13d"}.fa-unlock-alt:before{content:"\f13e"}.fa-bullseye:before{content:"\f140"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-rss-square:before{content:"\f143"}.fa-play-circle:before{content:"\f144"}.fa-ticket:before{content:"\f145"}.fa-minus-square:before{content:"\f146"}.fa-minus-square-o:before{content:"\f147"}.fa-level-up:before{content:"\f148"}.fa-level-down:before{content:"\f149"}.fa-check-square:before{content:"\f14a"}.fa-pencil-square:before{content:"\f14b"}.fa-external-link-square:before{content:"\f14c"}.fa-share-square:before{content:"\f14d"}.fa-compass:before{content:"\f14e"}.fa-toggle-down:before,.fa-caret-square-o-down:before{content:"\f150"}.fa-toggle-up:before,.fa-caret-square-o-up:before{content:"\f151"}.fa-toggle-right:before,.fa-caret-square-o-right:before{content:"\f152"}.fa-euro:before,.fa-eur:before{content:"\f153"}.fa-gbp:before{content:"\f154"}.fa-dollar:before,.fa-usd:before{content:"\f155"}.fa-rupee:before,.fa-inr:before{content:"\f156"}.fa-cny:before,.fa-rmb:before,.fa-yen:before,.fa-jpy:before{content:"\f157"}.fa-ruble:before,.fa-rouble:before,.fa-rub:before{content:"\f158"}.fa-won:before,.fa-krw:before{content:"\f159"}.fa-bitcoin:before,.fa-btc:before{content:"\f15a"}.fa-file:before{content:"\f15b"}.fa-file-text:before{content:"\f15c"}.fa-sort-alpha-asc:before{content:"\f15d"}.fa-sort-alpha-desc:before{content:"\f15e"}.fa-sort-amount-asc:before{content:"\f160"}.fa-sort-amount-desc:before{content:"\f161"}.fa-sort-numeric-asc:before{content:"\f162"}.fa-sort-numeric-desc:before{content:"\f163"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbs-down:before{content:"\f165"}.fa-youtube-square:before{content:"\f166"}.fa-youtube:before{content:"\f167"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-youtube-play:before{content:"\f16a"}.fa-dropbox:before{content:"\f16b"}.fa-stack-overflow:before{content:"\f16c"}.fa-instagram:before{content:"\f16d"}.fa-flickr:before{content:"\f16e"}.fa-adn:before{content:"\f170"}.fa-bitbucket:before{content:"\f171"}.fa-bitbucket-square:before{content:"\f172"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-long-arrow-down:before{content:"\f175"}.fa-long-arrow-up:before{content:"\f176"}.fa-long-arrow-left:before{content:"\f177"}.fa-long-arrow-right:before{content:"\f178"}.fa-apple:before{content:"\f179"}.fa-windows:before{content:"\f17a"}.fa-android:before{content:"\f17b"}.fa-linux:before{content:"\f17c"}.fa-dribbble:before{content:"\f17d"}.fa-skype:before{content:"\f17e"}.fa-foursquare:before{content:"\f180"}.fa-trello:before{content:"\f181"}.fa-female:before{content:"\f182"}.fa-male:before{content:"\f183"}.fa-gittip:before,.fa-gratipay:before{content:"\f184"}.fa-sun-o:before{content:"\f185"}.fa-moon-o:before{content:"\f186"}.fa-archive:before{content:"\f187"}.fa-bug:before{content:"\f188"}.fa-vk:before{content:"\f189"}.fa-weibo:before{content:"\f18a"}.fa-renren:before{content:"\f18b"}.fa-pagelines:before{content:"\f18c"}.fa-stack-exchange:before{content:"\f18d"}.fa-arrow-circle-o-right:before{content:"\f18e"}.fa-arrow-circle-o-left:before{content:"\f190"}.fa-toggle-left:before,.fa-caret-square-o-left:before{content:"\f191"}.fa-dot-circle-o:before{content:"\f192"}.fa-wheelchair:before{content:"\f193"}.fa-vimeo-square:before{content:"\f194"}.fa-turkish-lira:before,.fa-try:before{content:"\f195"}.fa-plus-square-o:before{content:"\f196"}.fa-space-shuttle:before{content:"\f197"}.fa-slack:before{content:"\f198"}.fa-envelope-square:before{content:"\f199"}.fa-wordpress:before{content:"\f19a"}.fa-openid:before{content:"\f19b"}.fa-institution:before,.fa-bank:before,.fa-university:before{content:"\f19c"}.fa-mortar-board:before,.fa-graduation-cap:before{content:"\f19d"}.fa-yahoo:before{content:"\f19e"}.fa-google:before{content:"\f1a0"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-square:before{content:"\f1a2"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-stumbleupon:before{content:"\f1a4"}.fa-delicious:before{content:"\f1a5"}.fa-digg:before{content:"\f1a6"}.fa-pied-piper-pp:before{content:"\f1a7"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-drupal:before{content:"\f1a9"}.fa-joomla:before{content:"\f1aa"}.fa-language:before{content:"\f1ab"}.fa-fax:before{content:"\f1ac"}.fa-building:before{content:"\f1ad"}.fa-child:before{content:"\f1ae"}.fa-paw:before{content:"\f1b0"}.fa-spoon:before{content:"\f1b1"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-recycle:before{content:"\f1b8"}.fa-automobile:before,.fa-car:before{content:"\f1b9"}.fa-cab:before,.fa-taxi:before{content:"\f1ba"}.fa-tree:before{content:"\f1bb"}.fa-spotify:before{content:"\f1bc"}.fa-deviantart:before{content:"\f1bd"}.fa-soundcloud:before{content:"\f1be"}.fa-database:before{content:"\f1c0"}.fa-file-pdf-o:before{content:"\f1c1"}.fa-file-word-o:before{content:"\f1c2"}.fa-file-excel-o:before{content:"\f1c3"}.fa-file-powerpoint-o:before{content:"\f1c4"}.fa-file-photo-o:before,.fa-file-picture-o:before,.fa-file-image-o:before{content:"\f1c5"}.fa-file-zip-o:before,.fa-file-archive-o:before{content:"\f1c6"}.fa-file-sound-o:before,.fa-file-audio-o:before{content:"\f1c7"}.fa-file-movie-o:before,.fa-file-video-o:before{content:"\f1c8"}.fa-file-code-o:before{content:"\f1c9"}.fa-vine:before{content:"\f1ca"}.fa-codepen:before{content:"\f1cb"}.fa-jsfiddle:before{content:"\f1cc"}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-saver:before,.fa-support:before,.fa-life-ring:before{content:"\f1cd"}.fa-circle-o-notch:before{content:"\f1ce"}.fa-ra:before,.fa-resistance:before,.fa-rebel:before{content:"\f1d0"}.fa-ge:before,.fa-empire:before{content:"\f1d1"}.fa-git-square:before{content:"\f1d2"}.fa-git:before{content:"\f1d3"}.fa-y-combinator-square:before,.fa-yc-square:before,.fa-hacker-news:before{content:"\f1d4"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-qq:before{content:"\f1d6"}.fa-wechat:before,.fa-weixin:before{content:"\f1d7"}.fa-send:before,.fa-paper-plane:before{content:"\f1d8"}.fa-send-o:before,.fa-paper-plane-o:before{content:"\f1d9"}.fa-history:before{content:"\f1da"}.fa-circle-thin:before{content:"\f1db"}.fa-header:before{content:"\f1dc"}.fa-paragraph:before{content:"\f1dd"}.fa-sliders:before{content:"\f1de"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-bomb:before{content:"\f1e2"}.fa-soccer-ball-o:before,.fa-futbol-o:before{content:"\f1e3"}.fa-tty:before{content:"\f1e4"}.fa-binoculars:before{content:"\f1e5"}.fa-plug:before{content:"\f1e6"}.fa-slideshare:before{content:"\f1e7"}.fa-twitch:before{content:"\f1e8"}.fa-yelp:before{content:"\f1e9"}.fa-newspaper-o:before{content:"\f1ea"}.fa-wifi:before{content:"\f1eb"}.fa-calculator:before{content:"\f1ec"}.fa-paypal:before{content:"\f1ed"}.fa-google-wallet:before{content:"\f1ee"}.fa-cc-visa:before{content:"\f1f0"}.fa-cc-mastercard:before{content:"\f1f1"}.fa-cc-discover:before{content:"\f1f2"}.fa-cc-amex:before{content:"\f1f3"}.fa-cc-paypal:before{content:"\f1f4"}.fa-cc-stripe:before{content:"\f1f5"}.fa-bell-slash:before{content:"\f1f6"}.fa-bell-slash-o:before{content:"\f1f7"}.fa-trash:before{content:"\f1f8"}.fa-copyright:before{content:"\f1f9"}.fa-at:before{content:"\f1fa"}.fa-eyedropper:before{content:"\f1fb"}.fa-paint-brush:before{content:"\f1fc"}.fa-birthday-cake:before{content:"\f1fd"}.fa-area-chart:before{content:"\f1fe"}.fa-pie-chart:before{content:"\f200"}.fa-line-chart:before{content:"\f201"}.fa-lastfm:before{content:"\f202"}.fa-lastfm-square:before{content:"\f203"}.fa-toggle-off:before{content:"\f204"}.fa-toggle-on:before{content:"\f205"}.fa-bicycle:before{content:"\f206"}.fa-bus:before{content:"\f207"}.fa-ioxhost:before{content:"\f208"}.fa-angellist:before{content:"\f209"}.fa-cc:before{content:"\f20a"}.fa-shekel:before,.fa-sheqel:before,.fa-ils:before{content:"\f20b"}.fa-meanpath:before{content:"\f20c"}.fa-buysellads:before{content:"\f20d"}.fa-connectdevelop:before{content:"\f20e"}.fa-dashcube:before{content:"\f210"}.fa-forumbee:before{content:"\f211"}.fa-leanpub:before{content:"\f212"}.fa-sellsy:before{content:"\f213"}.fa-shirtsinbulk:before{content:"\f214"}.fa-simplybuilt:before{content:"\f215"}.fa-skyatlas:before{content:"\f216"}.fa-cart-plus:before{content:"\f217"}.fa-cart-arrow-down:before{content:"\f218"}.fa-diamond:before{content:"\f219"}.fa-ship:before{content:"\f21a"}.fa-user-secret:before{content:"\f21b"}.fa-motorcycle:before{content:"\f21c"}.fa-street-view:before{content:"\f21d"}.fa-heartbeat:before{content:"\f21e"}.fa-venus:before{content:"\f221"}.fa-mars:before{content:"\f222"}.fa-mercury:before{content:"\f223"}.fa-intersex:before,.fa-transgender:before{content:"\f224"}.fa-transgender-alt:before{content:"\f225"}.fa-venus-double:before{content:"\f226"}.fa-mars-double:before{content:"\f227"}.fa-venus-mars:before{content:"\f228"}.fa-mars-stroke:before{content:"\f229"}.fa-mars-stroke-v:before{content:"\f22a"}.fa-mars-stroke-h:before{content:"\f22b"}.fa-neuter:before{content:"\f22c"}.fa-genderless:before{content:"\f22d"}.fa-facebook-official:before{content:"\f230"}.fa-pinterest-p:before{content:"\f231"}.fa-whatsapp:before{content:"\f232"}.fa-server:before{content:"\f233"}.fa-user-plus:before{content:"\f234"}.fa-user-times:before{content:"\f235"}.fa-hotel:before,.fa-bed:before{content:"\f236"}.fa-viacoin:before{content:"\f237"}.fa-train:before{content:"\f238"}.fa-subway:before{content:"\f239"}.fa-medium:before{content:"\f23a"}.fa-yc:before,.fa-y-combinator:before{content:"\f23b"}.fa-optin-monster:before{content:"\f23c"}.fa-opencart:before{content:"\f23d"}.fa-expeditedssl:before{content:"\f23e"}.fa-battery-4:before,.fa-battery:before,.fa-battery-full:before{content:"\f240"}.fa-battery-3:before,.fa-battery-three-quarters:before{content:"\f241"}.fa-battery-2:before,.fa-battery-half:before{content:"\f242"}.fa-battery-1:before,.fa-battery-quarter:before{content:"\f243"}.fa-battery-0:before,.fa-battery-empty:before{content:"\f244"}.fa-mouse-pointer:before{content:"\f245"}.fa-i-cursor:before{content:"\f246"}.fa-object-group:before{content:"\f247"}.fa-object-ungroup:before{content:"\f248"}.fa-sticky-note:before{content:"\f249"}.fa-sticky-note-o:before{content:"\f24a"}.fa-cc-jcb:before{content:"\f24b"}.fa-cc-diners-club:before{content:"\f24c"}.fa-clone:before{content:"\f24d"}.fa-balance-scale:before{content:"\f24e"}.fa-hourglass-o:before{content:"\f250"}.fa-hourglass-1:before,.fa-hourglass-start:before{content:"\f251"}.fa-hourglass-2:before,.fa-hourglass-half:before{content:"\f252"}.fa-hourglass-3:before,.fa-hourglass-end:before{content:"\f253"}.fa-hourglass:before{content:"\f254"}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:"\f255"}.fa-hand-stop-o:before,.fa-hand-paper-o:before{content:"\f256"}.fa-hand-scissors-o:before{content:"\f257"}.fa-hand-lizard-o:before{content:"\f258"}.fa-hand-spock-o:before{content:"\f259"}.fa-hand-pointer-o:before{content:"\f25a"}.fa-hand-peace-o:before{content:"\f25b"}.fa-trademark:before{content:"\f25c"}.fa-registered:before{content:"\f25d"}.fa-creative-commons:before{content:"\f25e"}.fa-gg:before{content:"\f260"}.fa-gg-circle:before{content:"\f261"}.fa-tripadvisor:before{content:"\f262"}.fa-odnoklassniki:before{content:"\f263"}.fa-odnoklassniki-square:before{content:"\f264"}.fa-get-pocket:before{content:"\f265"}.fa-wikipedia-w:before{content:"\f266"}.fa-safari:before{content:"\f267"}.fa-chrome:before{content:"\f268"}.fa-firefox:before{content:"\f269"}.fa-opera:before{content:"\f26a"}.fa-internet-explorer:before{content:"\f26b"}.fa-tv:before,.fa-television:before{content:"\f26c"}.fa-contao:before{content:"\f26d"}.fa-500px:before{content:"\f26e"}.fa-amazon:before{content:"\f270"}.fa-calendar-plus-o:before{content:"\f271"}.fa-calendar-minus-o:before{content:"\f272"}.fa-calendar-times-o:before{content:"\f273"}.fa-calendar-check-o:before{content:"\f274"}.fa-industry:before{content:"\f275"}.fa-map-pin:before{content:"\f276"}.fa-map-signs:before{content:"\f277"}.fa-map-o:before{content:"\f278"}.fa-map:before{content:"\f279"}.fa-commenting:before{content:"\f27a"}.fa-commenting-o:before{content:"\f27b"}.fa-houzz:before{content:"\f27c"}.fa-vimeo:before{content:"\f27d"}.fa-black-tie:before{content:"\f27e"}.fa-fonticons:before{content:"\f280"}.fa-reddit-alien:before{content:"\f281"}.fa-edge:before{content:"\f282"}.fa-credit-card-alt:before{content:"\f283"}.fa-codiepie:before{content:"\f284"}.fa-modx:before{content:"\f285"}.fa-fort-awesome:before{content:"\f286"}.fa-usb:before{content:"\f287"}.fa-product-hunt:before{content:"\f288"}.fa-mixcloud:before{content:"\f289"}.fa-scribd:before{content:"\f28a"}.fa-pause-circle:before{content:"\f28b"}.fa-pause-circle-o:before{content:"\f28c"}.fa-stop-circle:before{content:"\f28d"}.fa-stop-circle-o:before{content:"\f28e"}.fa-shopping-bag:before{content:"\f290"}.fa-shopping-basket:before{content:"\f291"}.fa-hashtag:before{content:"\f292"}.fa-bluetooth:before{content:"\f293"}.fa-bluetooth-b:before{content:"\f294"}.fa-percent:before{content:"\f295"}.fa-gitlab:before{content:"\f296"}.fa-wpbeginner:before{content:"\f297"}.fa-wpforms:before{content:"\f298"}.fa-envira:before{content:"\f299"}.fa-universal-access:before{content:"\f29a"}.fa-wheelchair-alt:before{content:"\f29b"}.fa-question-circle-o:before{content:"\f29c"}.fa-blind:before{content:"\f29d"}.fa-audio-description:before{content:"\f29e"}.fa-volume-control-phone:before{content:"\f2a0"}.fa-braille:before{content:"\f2a1"}.fa-assistive-listening-systems:before{content:"\f2a2"}.fa-asl-interpreting:before,.fa-american-sign-language-interpreting:before{content:"\f2a3"}.fa-deafness:before,.fa-hard-of-hearing:before,.fa-deaf:before{content:"\f2a4"}.fa-glide:before{content:"\f2a5"}.fa-glide-g:before{content:"\f2a6"}.fa-signing:before,.fa-sign-language:before{content:"\f2a7"}.fa-low-vision:before{content:"\f2a8"}.fa-viadeo:before{content:"\f2a9"}.fa-viadeo-square:before{content:"\f2aa"}.fa-snapchat:before{content:"\f2ab"}.fa-snapchat-ghost:before{content:"\f2ac"}.fa-snapchat-square:before{content:"\f2ad"}.fa-pied-piper:before{content:"\f2ae"}.fa-first-order:before{content:"\f2b0"}.fa-yoast:before{content:"\f2b1"}.fa-themeisle:before{content:"\f2b2"}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:"\f2b3"}.fa-fa:before,.fa-font-awesome:before{content:"\f2b4"}.fa-handshake-o:before{content:"\f2b5"}.fa-envelope-open:before{content:"\f2b6"}.fa-envelope-open-o:before{content:"\f2b7"}.fa-linode:before{content:"\f2b8"}.fa-address-book:before{content:"\f2b9"}.fa-address-book-o:before{content:"\f2ba"}.fa-vcard:before,.fa-address-card:before{content:"\f2bb"}.fa-vcard-o:before,.fa-address-card-o:before{content:"\f2bc"}.fa-user-circle:before{content:"\f2bd"}.fa-user-circle-o:before{content:"\f2be"}.fa-user-o:before{content:"\f2c0"}.fa-id-badge:before{content:"\f2c1"}.fa-drivers-license:before,.fa-id-card:before{content:"\f2c2"}.fa-drivers-license-o:before,.fa-id-card-o:before{content:"\f2c3"}.fa-quora:before{content:"\f2c4"}.fa-free-code-camp:before{content:"\f2c5"}.fa-telegram:before{content:"\f2c6"}.fa-thermometer-4:before,.fa-thermometer:before,.fa-thermometer-full:before{content:"\f2c7"}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:"\f2c8"}.fa-thermometer-2:before,.fa-thermometer-half:before{content:"\f2c9"}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:"\f2ca"}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:"\f2cb"}.fa-shower:before{content:"\f2cc"}.fa-bathtub:before,.fa-s15:before,.fa-bath:before{content:"\f2cd"}.fa-podcast:before{content:"\f2ce"}.fa-window-maximize:before{content:"\f2d0"}.fa-window-minimize:before{content:"\f2d1"}.fa-window-restore:before{content:"\f2d2"}.fa-times-rectangle:before,.fa-window-close:before{content:"\f2d3"}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:"\f2d4"}.fa-bandcamp:before{content:"\f2d5"}.fa-grav:before{content:"\f2d6"}.fa-etsy:before{content:"\f2d7"}.fa-imdb:before{content:"\f2d8"}.fa-ravelry:before{content:"\f2d9"}.fa-eercast:before{content:"\f2da"}.fa-microchip:before{content:"\f2db"}.fa-snowflake-o:before{content:"\f2dc"}.fa-superpowers:before{content:"\f2dd"}.fa-wpexplorer:before{content:"\f2de"}.fa-meetup:before{content:"\f2e0"}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0, 0, 0, 0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto} diff --git a/datasets/Talluri2021/outage_report_instagram_files/ijJfaNbC_normal.jpg b/datasets/Talluri2021/outage_report_instagram_files/ijJfaNbC_normal.jpg new file mode 100644 index 0000000..30dc53a Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/ijJfaNbC_normal.jpg differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/instagram-45.png b/datasets/Talluri2021/outage_report_instagram_files/instagram-45.png new file mode 100644 index 0000000..4d99caf Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/instagram-45.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/logo-small.png b/datasets/Talluri2021/outage_report_instagram_files/logo-small.png new file mode 100644 index 0000000..d034ba4 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/logo-small.png differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/pF46Bhhz_normal.jpg b/datasets/Talluri2021/outage_report_instagram_files/pF46Bhhz_normal.jpg new file mode 100644 index 0000000..de48354 Binary files /dev/null and b/datasets/Talluri2021/outage_report_instagram_files/pF46Bhhz_normal.jpg differ diff --git a/datasets/Talluri2021/outage_report_instagram_files/raven.js b/datasets/Talluri2021/outage_report_instagram_files/raven.js new file mode 100644 index 0000000..5c54289 --- /dev/null +++ b/datasets/Talluri2021/outage_report_instagram_files/raven.js @@ -0,0 +1,3 @@ +/*! Raven.js 3.22.2 (2e9f9b6) | github.com/getsentry/raven-js */ +!function(a){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=a();else if("function"==typeof define&&define.amd)define([],a);else{var b;b="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,b.Raven=a()}}(function(){return function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);var j=new Error("Cannot find module '"+g+"'");throw j.code="MODULE_NOT_FOUND",j}var k=c[g]={exports:{}};b[g][0].call(k.exports,function(a){var c=b[g][1][a];return e(c?c:a)},k,k.exports,a,b,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;gthis.k.maxBreadcrumbs&&this.u.shift(),this},addPlugin:function(a){var b=[].slice.call(arguments,1);return this.r.push([a,b]),this.n&&this.E(),this},setUserContext:function(a){return this.j.user=a,this},setExtraContext:function(a){return this.U("extra",a),this},setTagsContext:function(a){return this.U("tags",a),this},clearContext:function(){return this.j={},this},getContext:function(){return JSON.parse(h(this.j))},setEnvironment:function(a){return this.k.environment=a,this},setRelease:function(a){return this.k.release=a,this},setDataCallback:function(a){var b=this.k.dataCallback;return this.k.dataCallback=e(b,a),this},setBreadcrumbCallback:function(a){var b=this.k.breadcrumbCallback;return this.k.breadcrumbCallback=e(b,a),this},setShouldSendCallback:function(a){var b=this.k.shouldSendCallback;return this.k.shouldSendCallback=e(b,a),this},setTransport:function(a){return this.k.transport=a,this},lastException:function(){return this.d},lastEventId:function(){return this.f},isSetup:function(){return!!this.a&&(!!this.g||(this.ravenNotConfiguredError||(this.ravenNotConfiguredError=!0,this.z("error","Error: Raven has not been configured.")),!1))},afterLoad:function(){var a=J.RavenConfig;a&&this.config(a.dsn,a.config).install()},showReportDialog:function(a){if(K){a=a||{};var b=a.eventId||this.lastEventId();if(!b)throw new i("Missing eventId");var c=a.dsn||this.G;if(!c)throw new i("Missing DSN");var d=encodeURIComponent,e="";e+="?eventId="+d(b),e+="&dsn="+d(c);var f=a.user||this.j.user;f&&(f.name&&(e+="&name="+d(f.name)),f.email&&(e+="&email="+d(f.email)));var g=this.I(this.F(c)),h=K.createElement("script");h.async=!0,h.src=g+"/api/embed/error-page/"+e,(K.head||K.body).appendChild(h)}},K:function(){var a=this;this.m+=1,setTimeout(function(){a.m-=1})},V:function(a,b){var c,d;if(this.b){b=b||{},a="raven"+a.substr(0,1).toUpperCase()+a.substr(1),K.createEvent?(c=K.createEvent("HTMLEvents"),c.initEvent(a,!0,!0)):(c=K.createEventObject(),c.eventType=a);for(d in b)w(b,d)&&(c[d]=b[d]);if(K.createEvent)K.dispatchEvent(c);else try{K.fireEvent("on"+c.eventType.toLowerCase(),c)}catch(e){}}},W:function(a){var b=this;return function(c){if(b.X=null,b.v!==c){b.v=c;var d;try{d=A(c.target)}catch(e){d=""}b.captureBreadcrumb({category:"ui."+a,message:d})}}},Y:function(){var a=this,b=1e3;return function(c){var d;try{d=c.target}catch(e){return}var f=d&&d.tagName;if(f&&("INPUT"===f||"TEXTAREA"===f||d.isContentEditable)){var g=a.X;g||a.W("input")(c),clearTimeout(g),a.X=setTimeout(function(){a.X=null},b)}}},Z:function(a,b){var c=D(this.w.href),d=D(b),e=D(a);this.x=b,c.protocol===d.protocol&&c.host===d.host&&(b=d.relative),c.protocol===e.protocol&&c.host===e.host&&(a=e.relative),this.captureBreadcrumb({category:"navigation",data:{to:b,from:a}})},B:function(){var a=this;a.$=Function.prototype.toString,Function.prototype.toString=function(){return"function"==typeof this&&this.L?a.$.apply(this.N,arguments):a.$.apply(this,arguments)}},O:function(){this.$&&(Function.prototype.toString=this.$)},C:function(){function a(a){return function(b,d){for(var e=new Array(arguments.length),f=0;f2?arguments[2]:void 0;return c&&b.Z(b.x,c+""),a.apply(this,arguments)}};E(history,"pushState",j,d),E(history,"replaceState",j,d)}if(c.console&&"console"in J&&console.log){var k=function(a,c){b.captureBreadcrumb({message:a,level:c.level,category:"console"})};s(["debug","info","warn","error","log"],function(a,b){G(console,b,k)})}},P:function(){for(var a;this.t.length;){a=this.t.shift();var b=a[0],c=a[1],d=a[2];b[c]=d}},Q:function(){for(var a in this.q)this.p[a]=this.q[a]},E:function(){var a=this;s(this.r,function(b,c){var d=c[0],e=c[1];d.apply(a,[a].concat(e))})},F:function(a){var b=I.exec(a),c={},d=7;try{for(;d--;)c[H[d]]=b[d]||""}catch(e){throw new i("Invalid DSN: "+a)}if(c.pass&&!this.k.allowSecretKey)throw new i("Do not specify your secret key in the DSN. See: http://bit.ly/raven-secret-key");return c},I:function(a){var b="//"+a.host+(a.port?":"+a.port:"");return a.protocol&&(b=a.protocol+":"+b),b},A:function(){this.m||this.R.apply(this,arguments)},R:function(a,b){var c=this.S(a,b);this.V("handle",{stackInfo:a,options:b}),this.aa(a.name,a.message,a.url,a.lineno,c,b)},S:function(a,b){var c=this,d=[];if(a.stack&&a.stack.length&&(s(a.stack,function(b,e){var f=c.ba(e,a.url);f&&d.push(f)}),b&&b.trimHeadFrames))for(var e=0;e0&&(a.breadcrumbs={values:[].slice.call(this.u,0)}),this.j.user&&(a.user=this.j.user),b.environment&&(a.environment=b.environment),b.release&&(a.release=b.release),b.serverName&&(a.server_name=b.serverName),Object.keys(a).forEach(function(b){(null==a[b]||""===a[b]||r(a[b]))&&delete a[b]}),o(b.dataCallback)&&(a=b.dataCallback(a)||a),a&&!r(a)&&(!o(b.shouldSendCallback)||b.shouldSendCallback(a)))return this.ha()?void this.z("warn","Raven dropped error due to backoff: ",a):void("number"==typeof b.sampleRate?Math.random() ",i=h.length;a&&f++1&&g+e.length*i+b.length>=d));)e.push(b),g+=b.length,a=a.parentNode;return e.reverse().join(h)}function y(a){var b,c,d,e,f,g=[];if(!a||!a.tagName)return"";if(g.push(a.tagName.toLowerCase()),a.id&&g.push("#"+a.id),b=a.className,b&&i(b))for(c=b.split(/\s+/),f=0;f=0;--b)s[b]===a&&s.splice(b,1)}function c(){n(),s=[]}function k(a,b){var c=null;if(!b||f.collectWindowErrors){for(var d in s)if(s.hasOwnProperty(d))try{s[d].apply(null,[a].concat(h.call(arguments,2)))}catch(e){c=e}if(c)throw c}}function l(a,b,c,g,h){var l=null,m=e.isErrorEvent(h)?h.error:h,n=e.isErrorEvent(a)?a.message:a;if(v)f.computeStackTrace.augmentStackTraceWithInitialElement(v,b,c,n),o();else if(m&&e.isError(m))l=f.computeStackTrace(m),k(l,!0);else{var p,r={url:b,line:c,column:g},s=void 0;if("[object String]"==={}.toString.call(n)){var p=n.match(j);p&&(s=p[1],n=p[2])}r.func=i,l={name:s,message:n,url:d(),stack:[r]},k(l,!0)}return!!q&&q.apply(this,arguments)}function m(){r||(q=g.onerror,g.onerror=l,r=!0)}function n(){r&&(g.onerror=q,r=!1,q=void 0)}function o(){var a=v,b=t;t=null,v=null,u=null,k.apply(null,[a,!1].concat(b))}function p(a,b){var c=h.call(arguments,1);if(v){if(u===a)return;o()}var d=f.computeStackTrace(a);if(v=d,u=a,t=c,setTimeout(function(){u===a&&o()},d.incomplete?2e3:0),b!==!1)throw a}var q,r,s=[],t=null,u=null,v=null;return p.subscribe=a,p.unsubscribe=b,p.uninstall=c,p}(),f.computeStackTrace=function(){function a(a){if("undefined"!=typeof a.stack&&a.stack){for(var b,c,e,f=/^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack||[a-z]:|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,g=/^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i,h=/^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx(?:-web)|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i,j=/(\S+) line (\d+)(?: > eval line \d+)* > eval/i,k=/\((\S*)(?::(\d+))(?::(\d+))\)/,l=a.stack.split("\n"),m=[],n=(/^(.*) is undefined$/.exec(a.message),0),o=l.length;n eval")>-1;q&&(b=j.exec(c[3]))?(c[3]=b[1],c[4]=b[2],c[5]=null):0!==n||c[5]||"undefined"==typeof a.columnNumber||(m[0].column=a.columnNumber+1),e={url:c[3],func:c[1]||i,args:c[2]?c[2].split(","):[],line:c[4]?+c[4]:null,column:c[5]?+c[5]:null}}!e.func&&e.line&&(e.func=i),m.push(e)}return m.length?{name:a.name,message:a.message,url:d(),stack:m}:null}}function b(a,b,c,d){var e={url:b,line:c};if(e.url&&e.line){if(a.incomplete=!1,e.func||(e.func=i),a.stack.length>0&&a.stack[0].url===e.url){if(a.stack[0].line===e.line)return!1;if(!a.stack[0].line&&a.stack[0].func===e.func)return a.stack[0].line=e.line,!1}return a.stack.unshift(e),a.partial=!0,!0}return a.incomplete=!0,!1}function c(a,g){for(var h,j,k=/function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i,l=[],m={},n=!1,o=c.caller;o&&!n;o=o.caller)if(o!==e&&o!==f.report){if(j={url:null,func:i,line:null,column:null},o.name?j.func=o.name:(h=k.exec(o.toString()))&&(j.func=h[1]),"undefined"==typeof j.func)try{j.func=h.input.substring(0,h.input.indexOf("{"))}catch(p){}m[""+o]?n=!0:m[""+o]=!0,l.push(j)}g&&l.splice(0,g);var q={name:a.name,message:a.message,url:d(),stack:l};return b(q,a.sourceURL||a.fileName,a.line||a.lineNumber,a.message||a.description),q}function e(b,e){var g=null;e=null==e?0:+e;try{if(g=a(b))return g}catch(h){if(f.debug)throw h}try{if(g=c(b,e+1))return g}catch(h){if(f.debug)throw h}return{name:b.name,message:b.message,url:d()}}return e.augmentStackTraceWithInitialElement=b,e.computeStackTraceFromStackProp=a,e}(),b.exports=f}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{5:5}],7:[function(a,b,c){function d(a,b){for(var c=0;c0){var i=d(c,this);~i?c.splice(i+1):c.push(this),~i?e.splice(i,1/0,g):e.push(g),~d(c,h)&&(h=b.call(this,g,h))}else c.push(h);return null==a?h instanceof Error?f(h):h:a.call(this,g,h)}}c=b.exports=e,c.getSerialize=g},{}]},{},[4])(4)}); +//# sourceMappingURL=raven.min.js.map \ No newline at end of file diff --git a/datasets/Talluri2021/outage_report_instagram_files/runtime.js b/datasets/Talluri2021/outage_report_instagram_files/runtime.js new file mode 100644 index 0000000..cbc9462 --- /dev/null +++ b/datasets/Talluri2021/outage_report_instagram_files/runtime.js @@ -0,0 +1,2 @@ +!function(l){function e(e){for(var c,i,n=e[0],b=e[1],d=e[2],s=0,y=[];s>>0,o=0;o0)for(n=0;n=0;return(r?n?"+":"":"-")+Math.pow(10,Math.max(0,p)).toString().substr(1)+o}var k=/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,F=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,H={},I={};function D(t,e,n,o){var p=o;"string"==typeof o&&(p=function(){return this[o]()}),t&&(I[t]=p),e&&(I[e[0]]=function(){return j(p.apply(this,arguments),e[1],e[2])}),n&&(I[n]=function(){return this.localeData().ordinal(p.apply(this,arguments),t)})}function P(t,e){return t.isValid()?(e=U(e,t.localeData()),H[e]=H[e]||function(t){var e,n,o,p=t.match(k);for(e=0,n=p.length;e=0&&F.test(t);)t=t.replace(F,o),F.lastIndex=0,n-=1;return t}var V=/\d/,G=/\d\d/,Y=/\d{3}/,K=/\d{4}/,$=/[+-]?\d{6}/,Q=/\d\d?/,J=/\d\d\d\d?/,Z=/\d\d\d\d\d\d?/,tt=/\d{1,3}/,et=/\d{1,4}/,nt=/[+-]?\d{1,6}/,ot=/\d+/,pt=/[+-]?\d+/,rt=/Z|[+-]\d\d:?\d\d/gi,bt=/Z|[+-]\d\d(?::?\d\d)?/gi,Mt=/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,ct={};function zt(t,e,n){ct[t]=X(e)?e:function(t,o){return t&&n?n:e}}function it(t,e){return i(ct,t)?ct[t](e._strict,e._locale):new RegExp(at(t.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,function(t,e,n,o,p){return e||n||o||p})))}function at(t){return t.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}var Ot={};function ut(t,e){var n,o=e;for("string"==typeof t&&(t=[t]),M(e)&&(o=function(t,n){n[e]=m(t)}),n=0;n68?1900:2e3)};var Bt,Lt=Xt("FullYear",!0);function Xt(t,e){return function(n){return null!=n?(_t(this,t,n),o.updateOffset(this,e),this):Nt(this,t)}}function Nt(t,e){return t.isValid()?t._d["get"+(t._isUTC?"UTC":"")+e]():NaN}function _t(t,e,n){t.isValid()&&!isNaN(n)&&("FullYear"===e&>(t.year())&&1===t.month()&&29===t.date()?t._d["set"+(t._isUTC?"UTC":"")+e](n,t.month(),St(n,t.month())):t._d["set"+(t._isUTC?"UTC":"")+e](n))}function St(t,e){if(isNaN(t)||isNaN(e))return NaN;var n,o=(e%(n=12)+n)%n;return t+=(e-o)/12,1===o?gt(t)?29:28:31-o%7%2}Bt=Array.prototype.indexOf?Array.prototype.indexOf:function(t){var e;for(e=0;e=0&&isFinite(e.getUTCFullYear())&&e.setUTCFullYear(t),e}function It(t,e,n){var o=7+e-n,p=(7+Ht(t,0,o).getUTCDay()-e)%7;return-p+o-1}function Dt(t,e,n,o,p){var r,b,M=(7+n-o)%7,c=It(t,o,p),z=1+7*(e-1)+M+c;return z<=0?b=yt(r=t-1)+z:z>yt(t)?(r=t+1,b=z-yt(t)):(r=t,b=z),{year:r,dayOfYear:b}}function Pt(t,e,n){var o,p,r=It(t.year(),e,n),b=Math.floor((t.dayOfYear()-r-1)/7)+1;return b<1?(p=t.year()-1,o=b+Ut(p,e,n)):b>Ut(t.year(),e,n)?(o=b-Ut(t.year(),e,n),p=t.year()+1):(p=t.year(),o=b),{week:o,year:p}}function Ut(t,e,n){var o=It(t,e,n),p=It(t+1,e,n);return(yt(t)-o+p)/7}D("w",["ww",2],"wo","week"),D("W",["WW",2],"Wo","isoWeek"),T("week","w"),T("isoWeek","W"),x("week",5),x("isoWeek",5),zt("w",Q),zt("ww",Q,G),zt("W",Q),zt("WW",Q,G),st(["w","ww","W","WW"],function(t,e,n,o){e[o.substr(0,1)]=m(t)}),D("d",0,"do","day"),D("dd",0,0,function(t){return this.localeData().weekdaysMin(this,t)}),D("ddd",0,0,function(t){return this.localeData().weekdaysShort(this,t)}),D("dddd",0,0,function(t){return this.localeData().weekdays(this,t)}),D("e",0,0,"weekday"),D("E",0,0,"isoWeekday"),T("day","d"),T("weekday","e"),T("isoWeekday","E"),x("day",11),x("weekday",11),x("isoWeekday",11),zt("d",Q),zt("e",Q),zt("E",Q),zt("dd",function(t,e){return e.weekdaysMinRegex(t)}),zt("ddd",function(t,e){return e.weekdaysShortRegex(t)}),zt("dddd",function(t,e){return e.weekdaysRegex(t)}),st(["dd","ddd","dddd"],function(t,e,n,o){var p=n._locale.weekdaysParse(t,o,n._strict);null!=p?e.d=p:u(n).invalidWeekday=t}),st(["d","e","E"],function(t,e,n,o){e[o]=m(t)});var Vt="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),Gt="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),Yt="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),Kt=Mt,$t=Mt,Qt=Mt;function Jt(){function t(t,e){return e.length-t.length}var e,n,o,p,r,b=[],M=[],c=[],z=[];for(e=0;e<7;e++)n=O([2e3,1]).day(e),o=this.weekdaysMin(n,""),p=this.weekdaysShort(n,""),r=this.weekdays(n,""),b.push(o),M.push(p),c.push(r),z.push(o),z.push(p),z.push(r);for(b.sort(t),M.sort(t),c.sort(t),z.sort(t),e=0;e<7;e++)M[e]=at(M[e]),c[e]=at(c[e]),z[e]=at(z[e]);this._weekdaysRegex=new RegExp("^("+z.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+c.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+M.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+b.join("|")+")","i")}function Zt(){return this.hours()%12||12}function te(t,e){D(t,0,0,function(){return this.localeData().meridiem(this.hours(),this.minutes(),e)})}function ee(t,e){return e._meridiemParse}D("H",["HH",2],0,"hour"),D("h",["hh",2],0,Zt),D("k",["kk",2],0,function(){return this.hours()||24}),D("hmm",0,0,function(){return""+Zt.apply(this)+j(this.minutes(),2)}),D("hmmss",0,0,function(){return""+Zt.apply(this)+j(this.minutes(),2)+j(this.seconds(),2)}),D("Hmm",0,0,function(){return""+this.hours()+j(this.minutes(),2)}),D("Hmmss",0,0,function(){return""+this.hours()+j(this.minutes(),2)+j(this.seconds(),2)}),te("a",!0),te("A",!1),T("hour","h"),x("hour",13),zt("a",ee),zt("A",ee),zt("H",Q),zt("h",Q),zt("k",Q),zt("HH",Q,G),zt("hh",Q,G),zt("kk",Q,G),zt("hmm",J),zt("hmmss",Z),zt("Hmm",J),zt("Hmmss",Z),ut(["H","HH"],qt),ut(["k","kk"],function(t,e,n){var o=m(t);e[qt]=24===o?0:o}),ut(["a","A"],function(t,e,n){n._isPm=n._locale.isPM(t),n._meridiem=t}),ut(["h","hh"],function(t,e,n){e[qt]=m(t),u(n).bigHour=!0}),ut("hmm",function(t,e,n){var o=t.length-2;e[qt]=m(t.substr(0,o)),e[ht]=m(t.substr(o)),u(n).bigHour=!0}),ut("hmmss",function(t,e,n){var o=t.length-4,p=t.length-2;e[qt]=m(t.substr(0,o)),e[ht]=m(t.substr(o,2)),e[Wt]=m(t.substr(p)),u(n).bigHour=!0}),ut("Hmm",function(t,e,n){var o=t.length-2;e[qt]=m(t.substr(0,o)),e[ht]=m(t.substr(o))}),ut("Hmmss",function(t,e,n){var o=t.length-4,p=t.length-2;e[qt]=m(t.substr(0,o)),e[ht]=m(t.substr(o,2)),e[Wt]=m(t.substr(p))});var ne,oe=Xt("Hours",!0),pe={calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},longDateFormat:{LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},invalidDate:"Invalid date",ordinal:"%d",dayOfMonthOrdinalParse:/\d{1,2}/,relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},months:wt,monthsShort:Et,week:{dow:0,doy:6},weekdays:Vt,weekdaysMin:Yt,weekdaysShort:Gt,meridiemParse:/[ap]\.?m?\.?/i},re={},be={};function Me(t){return t?t.toLowerCase().replace("_","-"):t}function ce(e){var n=null;if(!re[e]&&void 0!==t&&t&&t.exports)try{n=ne._abbr,!function(){var t=new Error("Cannot find module 'undefined'");throw t.code="MODULE_NOT_FOUND",t}(),ze(n)}catch(t){}return re[e]}function ze(t,e){var n;return t&&(n=b(e)?ae(t):ie(t,e))&&(ne=n),ne._abbr}function ie(t,e){if(null!==e){var n=pe;if(e.abbr=t,null!=re[t])L("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),n=re[t]._config;else if(null!=e.parentLocale){if(null==re[e.parentLocale])return be[e.parentLocale]||(be[e.parentLocale]=[]),be[e.parentLocale].push({name:t,config:e}),null;n=re[e.parentLocale]._config}return re[t]=new _(N(n,e)),be[t]&&be[t].forEach(function(t){ie(t.name,t.config)}),ze(t),re[t]}return delete re[t],null}function ae(t){var e;if(t&&t._locale&&t._locale._abbr&&(t=t._locale._abbr),!t)return ne;if(!p(t)){if(e=ce(t))return e;t=[t]}return function(t){for(var e,n,o,p,r=0;r0;){if(o=ce(p.slice(0,e).join("-")))return o;if(n&&n.length>=e&&R(p,n,!0)>=e-1)break;e--}r++}return null}(t)}function Oe(t){var e,n=t._a;return n&&-2===u(t).overflow&&(e=n[dt]<0||n[dt]>11?dt:n[ft]<1||n[ft]>St(n[lt],n[dt])?ft:n[qt]<0||n[qt]>24||24===n[qt]&&(0!==n[ht]||0!==n[Wt]||0!==n[mt])?qt:n[ht]<0||n[ht]>59?ht:n[Wt]<0||n[Wt]>59?Wt:n[mt]<0||n[mt]>999?mt:-1,u(t)._overflowDayOfYear&&(eft)&&(e=ft),u(t)._overflowWeeks&&-1===e&&(e=Rt),u(t)._overflowWeekday&&-1===e&&(e=vt),u(t).overflow=e),t}function ue(t,e,n){return null!=t?t:null!=e?e:n}function se(t){var e,n,p,r,b,M=[];if(!t._d){for(p=function(t){var e=new Date(o.now());return t._useUTC?[e.getUTCFullYear(),e.getUTCMonth(),e.getUTCDate()]:[e.getFullYear(),e.getMonth(),e.getDate()]}(t),t._w&&null==t._a[ft]&&null==t._a[dt]&&function(t){var e,n,o,p,r,b,M,c;if(null!=(e=t._w).GG||null!=e.W||null!=e.E)r=1,b=4,n=ue(e.GG,t._a[lt],Pt(Xe(),1,4).year),o=ue(e.W,1),((p=ue(e.E,1))<1||p>7)&&(c=!0);else{r=t._locale._week.dow,b=t._locale._week.doy;var z=Pt(Xe(),r,b);n=ue(e.gg,t._a[lt],z.year),o=ue(e.w,z.week),null!=e.d?((p=e.d)<0||p>6)&&(c=!0):null!=e.e?(p=e.e+r,(e.e<0||e.e>6)&&(c=!0)):p=r}o<1||o>Ut(n,r,b)?u(t)._overflowWeeks=!0:null!=c?u(t)._overflowWeekday=!0:(M=Dt(n,o,p,r,b),t._a[lt]=M.year,t._dayOfYear=M.dayOfYear)}(t),null!=t._dayOfYear&&(b=ue(t._a[lt],p[lt]),(t._dayOfYear>yt(b)||0===t._dayOfYear)&&(u(t)._overflowDayOfYear=!0),n=Ht(b,0,t._dayOfYear),t._a[dt]=n.getUTCMonth(),t._a[ft]=n.getUTCDate()),e=0;e<3&&null==t._a[e];++e)t._a[e]=M[e]=p[e];for(;e<7;e++)t._a[e]=M[e]=null==t._a[e]?2===e?1:0:t._a[e];24===t._a[qt]&&0===t._a[ht]&&0===t._a[Wt]&&0===t._a[mt]&&(t._nextDay=!0,t._a[qt]=0),t._d=(t._useUTC?Ht:function(t,e,n,o,p,r,b){var M=new Date(t,e,n,o,p,r,b);return t<100&&t>=0&&isFinite(M.getFullYear())&&M.setFullYear(t),M}).apply(null,M),r=t._useUTC?t._d.getUTCDay():t._d.getDay(),null!=t._tzm&&t._d.setUTCMinutes(t._d.getUTCMinutes()-t._tzm),t._nextDay&&(t._a[qt]=24),t._w&&void 0!==t._w.d&&t._w.d!==r&&(u(t).weekdayMismatch=!0)}}var Ae=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,le=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,de=/Z|[+-]\d\d(?::?\d\d)?/,fe=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/]],qe=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],he=/^\/?Date\((\-?\d+)/i;function We(t){var e,n,o,p,r,b,M=t._i,c=Ae.exec(M)||le.exec(M);if(c){for(u(t).iso=!0,e=0,n=fe.length;e0&&u(t).unusedInput.push(b),M=M.slice(M.indexOf(n)+n.length),z+=n.length),I[r]?(n?u(t).empty=!1:u(t).unusedTokens.push(r),At(r,n,t)):t._strict&&!n&&u(t).unusedTokens.push(r);u(t).charsLeftOver=c-z,M.length>0&&u(t).unusedInput.push(M),t._a[qt]<=12&&!0===u(t).bigHour&&t._a[qt]>0&&(u(t).bigHour=void 0),u(t).parsedDateParts=t._a.slice(0),u(t).meridiem=t._meridiem,t._a[qt]=(i=t._locale,a=t._a[qt],null==(O=t._meridiem)?a:null!=i.meridiemHour?i.meridiemHour(a,O):null!=i.isPM?((s=i.isPM(O))&&a<12&&(a+=12),s||12!==a||(a=0),a):a),se(t),Oe(t)}else ye(t);else We(t);var i,a,O,s}function Be(t){var e=t._i,n=t._f;return t._locale=t._locale||ae(t._l),null===e||void 0===n&&""===e?A({nullInput:!0}):("string"==typeof e&&(t._i=e=t._locale.preparse(e)),h(e)?new q(Oe(e)):(c(e)?t._d=e:p(n)?function(t){var e,n,o,p,r;if(0===t._f.length)return u(t).invalidFormat=!0,void(t._d=new Date(NaN));for(p=0;pthis?this:t:A()});function Se(t,e){var n,o;if(1===e.length&&p(e[0])&&(e=e[0]),!e.length)return Xe();for(n=e[0],o=1;or&&(e=r),function(t,e,n,o,p){var r=Dt(t,e,n,o,p),b=Ht(r.year,0,r.dayOfYear);return this.year(b.getUTCFullYear()),this.month(b.getUTCMonth()),this.date(b.getUTCDate()),this}.call(this,t,e,n,o,p))}D(0,["gg",2],0,function(){return this.weekYear()%100}),D(0,["GG",2],0,function(){return this.isoWeekYear()%100}),nn("gggg","weekYear"),nn("ggggg","weekYear"),nn("GGGG","isoWeekYear"),nn("GGGGG","isoWeekYear"),T("weekYear","gg"),T("isoWeekYear","GG"),x("weekYear",1),x("isoWeekYear",1),zt("G",pt),zt("g",pt),zt("GG",Q,G),zt("gg",Q,G),zt("GGGG",et,K),zt("gggg",et,K),zt("GGGGG",nt,$),zt("ggggg",nt,$),st(["gggg","ggggg","GGGG","GGGGG"],function(t,e,n,o){e[o.substr(0,2)]=m(t)}),st(["gg","GG"],function(t,e,n,p){e[p]=o.parseTwoDigitYear(t)}),D("Q",0,"Qo","quarter"),T("quarter","Q"),x("quarter",7),zt("Q",V),ut("Q",function(t,e){e[dt]=3*(m(t)-1)}),D("D",["DD",2],"Do","date"),T("date","D"),x("date",9),zt("D",Q),zt("DD",Q,G),zt("Do",function(t,e){return t?e._dayOfMonthOrdinalParse||e._ordinalParse:e._dayOfMonthOrdinalParseLenient}),ut(["D","DD"],ft),ut("Do",function(t,e){e[ft]=m(t.match(Q)[0])});var pn=Xt("Date",!0);D("DDD",["DDDD",3],"DDDo","dayOfYear"),T("dayOfYear","DDD"),x("dayOfYear",4),zt("DDD",tt),zt("DDDD",Y),ut(["DDD","DDDD"],function(t,e,n){n._dayOfYear=m(t)}),D("m",["mm",2],0,"minute"),T("minute","m"),x("minute",14),zt("m",Q),zt("mm",Q,G),ut(["m","mm"],ht);var rn=Xt("Minutes",!1);D("s",["ss",2],0,"second"),T("second","s"),x("second",15),zt("s",Q),zt("ss",Q,G),ut(["s","ss"],Wt);var bn,Mn=Xt("Seconds",!1);for(D("S",0,0,function(){return~~(this.millisecond()/100)}),D(0,["SS",2],0,function(){return~~(this.millisecond()/10)}),D(0,["SSS",3],0,"millisecond"),D(0,["SSSS",4],0,function(){return 10*this.millisecond()}),D(0,["SSSSS",5],0,function(){return 100*this.millisecond()}),D(0,["SSSSSS",6],0,function(){return 1e3*this.millisecond()}),D(0,["SSSSSSS",7],0,function(){return 1e4*this.millisecond()}),D(0,["SSSSSSSS",8],0,function(){return 1e5*this.millisecond()}),D(0,["SSSSSSSSS",9],0,function(){return 1e6*this.millisecond()}),T("millisecond","ms"),x("millisecond",16),zt("S",tt,V),zt("SS",tt,G),zt("SSS",tt,Y),bn="SSSS";bn.length<=9;bn+="S")zt(bn,ot);function cn(t,e){e[mt]=m(1e3*("0."+t))}for(bn="S";bn.length<=9;bn+="S")ut(bn,cn);var zn=Xt("Milliseconds",!1);D("z",0,0,"zoneAbbr"),D("zz",0,0,"zoneName");var an=q.prototype;function On(t){return t}an.add=$e,an.calendar=function(t,e){var n=t||Xe(),p=Fe(n,this).startOf("day"),r=o.calendarFormat(this,p)||"sameElse",b=e&&(X(e[r])?e[r].call(this,n):e[r]);return this.format(b||this.localeData().calendar(r,this,Xe(n)))},an.clone=function(){return new q(this)},an.diff=function(t,e,n){var o,p,r;if(!this.isValid())return NaN;if(!(o=Fe(t,this)).isValid())return NaN;switch(p=6e4*(o.utcOffset()-this.utcOffset()),e=w(e)){case"year":r=Je(this,o)/12;break;case"month":r=Je(this,o);break;case"quarter":r=Je(this,o)/3;break;case"second":r=(this-o)/1e3;break;case"minute":r=(this-o)/6e4;break;case"hour":r=(this-o)/36e5;break;case"day":r=(this-o-p)/864e5;break;case"week":r=(this-o-p)/6048e5;break;default:r=this-o}return n?r:W(r)},an.endOf=function(t){return void 0===(t=w(t))||"millisecond"===t?this:("date"===t&&(t="day"),this.startOf(t).add(1,"isoWeek"===t?"week":t).subtract(1,"ms"))},an.format=function(t){t||(t=this.isUtc()?o.defaultFormatUtc:o.defaultFormat);var e=P(this,t);return this.localeData().postformat(e)},an.from=function(t,e){return this.isValid()&&(h(t)&&t.isValid()||Xe(t).isValid())?Ue({to:this,from:t}).locale(this.locale()).humanize(!e):this.localeData().invalidDate()},an.fromNow=function(t){return this.from(Xe(),t)},an.to=function(t,e){return this.isValid()&&(h(t)&&t.isValid()||Xe(t).isValid())?Ue({from:this,to:t}).locale(this.locale()).humanize(!e):this.localeData().invalidDate()},an.toNow=function(t){return this.to(Xe(),t)},an.get=function(t){return X(this[t=w(t)])?this[t]():this},an.invalidAt=function(){return u(this).overflow},an.isAfter=function(t,e){var n=h(t)?t:Xe(t);return!(!this.isValid()||!n.isValid())&&("millisecond"===(e=w(b(e)?"millisecond":e))?this.valueOf()>n.valueOf():n.valueOf()9999?P(n,e?"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"):X(Date.prototype.toISOString)?e?this.toDate().toISOString():new Date(this._d.valueOf()).toISOString().replace("Z",P(n,"Z")):P(n,e?"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYY-MM-DD[T]HH:mm:ss.SSSZ")},an.inspect=function(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var t="moment",e="";this.isLocal()||(t=0===this.utcOffset()?"moment.utc":"moment.parseZone",e="Z");var n="["+t+'("]',o=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",p=e+'[")]';return this.format(n+o+"-MM-DD[T]HH:mm:ss.SSS"+p)},an.toJSON=function(){return this.isValid()?this.toISOString():null},an.toString=function(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")},an.unix=function(){return Math.floor(this.valueOf()/1e3)},an.valueOf=function(){return this._d.valueOf()-6e4*(this._offset||0)},an.creationData=function(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}},an.year=Lt,an.isLeapYear=function(){return gt(this.year())},an.weekYear=function(t){return on.call(this,t,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)},an.isoWeekYear=function(t){return on.call(this,t,this.isoWeek(),this.isoWeekday(),1,4)},an.quarter=an.quarters=function(t){return null==t?Math.ceil((this.month()+1)/3):this.month(3*(t-1)+this.month()%3)},an.month=xt,an.daysInMonth=function(){return St(this.year(),this.month())},an.week=an.weeks=function(t){var e=this.localeData().week(this);return null==t?e:this.add(7*(t-e),"d")},an.isoWeek=an.isoWeeks=function(t){var e=Pt(this,1,4).week;return null==t?e:this.add(7*(t-e),"d")},an.weeksInYear=function(){var t=this.localeData()._week;return Ut(this.year(),t.dow,t.doy)},an.isoWeeksInYear=function(){return Ut(this.year(),1,4)},an.date=pn,an.day=an.days=function(t){if(!this.isValid())return null!=t?this:NaN;var e=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=t?(t=function(t,e){return"string"!=typeof t?t:isNaN(t)?"number"==typeof(t=e.weekdaysParse(t))?t:null:parseInt(t,10)}(t,this.localeData()),this.add(t-e,"d")):e},an.weekday=function(t){if(!this.isValid())return null!=t?this:NaN;var e=(this.day()+7-this.localeData()._week.dow)%7;return null==t?e:this.add(t-e,"d")},an.isoWeekday=function(t){if(!this.isValid())return null!=t?this:NaN;if(null!=t){var e=function(t,e){return"string"==typeof t?e.weekdaysParse(t)%7||7:isNaN(t)?null:t}(t,this.localeData());return this.day(this.day()%7?e:e-7)}return this.day()||7},an.dayOfYear=function(t){var e=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==t?e:this.add(t-e,"d")},an.hour=an.hours=oe,an.minute=an.minutes=rn,an.second=an.seconds=Mn,an.millisecond=an.milliseconds=zn,an.utcOffset=function(t,e,n){var p,r=this._offset||0;if(!this.isValid())return null!=t?this:NaN;if(null!=t){if("string"==typeof t){if(null===(t=ke(bt,t)))return this}else Math.abs(t)<16&&!n&&(t*=60);return!this._isUTC&&e&&(p=He(this)),this._offset=t,this._isUTC=!0,null!=p&&this.add(p,"m"),r!==t&&(!e||this._changeInProgress?Ke(this,Ue(t-r,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,o.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?r:He(this)},an.utc=function(t){return this.utcOffset(0,t)},an.local=function(t){return this._isUTC&&(this.utcOffset(0,t),this._isUTC=!1,t&&this.subtract(He(this),"m")),this},an.parseZone=function(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var t=ke(rt,this._i);null!=t?this.utcOffset(t):this.utcOffset(0,!0)}return this},an.hasAlignedHourOffset=function(t){return!!this.isValid()&&(t=t?Xe(t).utcOffset():0,(this.utcOffset()-t)%60==0)},an.isDST=function(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()},an.isLocal=function(){return!!this.isValid()&&!this._isUTC},an.isUtcOffset=function(){return!!this.isValid()&&this._isUTC},an.isUtc=Ie,an.isUTC=Ie,an.zoneAbbr=function(){return this._isUTC?"UTC":""},an.zoneName=function(){return this._isUTC?"Coordinated Universal Time":""},an.dates=y("dates accessor is deprecated. Use date instead.",pn),an.months=y("months accessor is deprecated. Use month instead",xt),an.years=y("years accessor is deprecated. Use year instead",Lt),an.zone=y("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",function(t,e){return null!=t?("string"!=typeof t&&(t=-t),this.utcOffset(t,e),this):-this.utcOffset()}),an.isDSTShifted=y("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",function(){if(!b(this._isDSTShifted))return this._isDSTShifted;var t={};if(d(t,this),(t=Be(t))._a){var e=t._isUTC?O(t._a):Xe(t._a);this._isDSTShifted=this.isValid()&&R(t._a,e.toArray())>0}else this._isDSTShifted=!1;return this._isDSTShifted});var un=_.prototype;function sn(t,e,n,o){var p=ae(),r=O().set(o,e);return p[n](r,t)}function An(t,e,n){if(M(t)&&(e=t,t=void 0),t=t||"",null!=e)return sn(t,e,n,"month");var o,p=[];for(o=0;o<12;o++)p[o]=sn(t,o,n,"month");return p}function ln(t,e,n,o){"boolean"==typeof t?(M(e)&&(n=e,e=void 0),e=e||""):(n=e=t,t=!1,M(e)&&(n=e,e=void 0),e=e||"");var p,r=ae(),b=t?r._week.dow:0;if(null!=n)return sn(e,(n+b)%7,o,"day");var c=[];for(p=0;p<7;p++)c[p]=sn(e,(p+b)%7,o,"day");return c}un.calendar=function(t,e,n){var o=this._calendar[t]||this._calendar.sameElse;return X(o)?o.call(e,n):o},un.longDateFormat=function(t){var e=this._longDateFormat[t],n=this._longDateFormat[t.toUpperCase()];return e||!n?e:(this._longDateFormat[t]=n.replace(/MMMM|MM|DD|dddd/g,function(t){return t.slice(1)}),this._longDateFormat[t])},un.invalidDate=function(){return this._invalidDate},un.ordinal=function(t){return this._ordinal.replace("%d",t)},un.preparse=On,un.postformat=On,un.relativeTime=function(t,e,n,o){var p=this._relativeTime[n];return X(p)?p(t,e,n,o):p.replace(/%d/i,t)},un.pastFuture=function(t,e){var n=this._relativeTime[t>0?"future":"past"];return X(n)?n(e):n.replace(/%s/i,e)},un.set=function(t){var e,n;for(n in t)X(e=t[n])?this[n]=e:this["_"+n]=e;this._config=t,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)},un.months=function(t,e){return t?p(this._months)?this._months[t.month()]:this._months[(this._months.isFormat||Tt).test(e)?"format":"standalone"][t.month()]:p(this._months)?this._months:this._months.standalone},un.monthsShort=function(t,e){return t?p(this._monthsShort)?this._monthsShort[t.month()]:this._monthsShort[Tt.test(e)?"format":"standalone"][t.month()]:p(this._monthsShort)?this._monthsShort:this._monthsShort.standalone},un.monthsParse=function(t,e,n){var o,p,r;if(this._monthsParseExact)return function(t,e,n){var o,p,r,b=t.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],o=0;o<12;++o)r=O([2e3,o]),this._shortMonthsParse[o]=this.monthsShort(r,"").toLocaleLowerCase(),this._longMonthsParse[o]=this.months(r,"").toLocaleLowerCase();return n?"MMM"===e?-1!==(p=Bt.call(this._shortMonthsParse,b))?p:null:-1!==(p=Bt.call(this._longMonthsParse,b))?p:null:"MMM"===e?-1!==(p=Bt.call(this._shortMonthsParse,b))?p:-1!==(p=Bt.call(this._longMonthsParse,b))?p:null:-1!==(p=Bt.call(this._longMonthsParse,b))?p:-1!==(p=Bt.call(this._shortMonthsParse,b))?p:null}.call(this,t,e,n);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),o=0;o<12;o++){if(p=O([2e3,o]),n&&!this._longMonthsParse[o]&&(this._longMonthsParse[o]=new RegExp("^"+this.months(p,"").replace(".","")+"$","i"),this._shortMonthsParse[o]=new RegExp("^"+this.monthsShort(p,"").replace(".","")+"$","i")),n||this._monthsParse[o]||(r="^"+this.months(p,"")+"|^"+this.monthsShort(p,""),this._monthsParse[o]=new RegExp(r.replace(".",""),"i")),n&&"MMMM"===e&&this._longMonthsParse[o].test(t))return o;if(n&&"MMM"===e&&this._shortMonthsParse[o].test(t))return o;if(!n&&this._monthsParse[o].test(t))return o}},un.monthsRegex=function(t){return this._monthsParseExact?(i(this,"_monthsRegex")||Ft.call(this),t?this._monthsStrictRegex:this._monthsRegex):(i(this,"_monthsRegex")||(this._monthsRegex=kt),this._monthsStrictRegex&&t?this._monthsStrictRegex:this._monthsRegex)},un.monthsShortRegex=function(t){return this._monthsParseExact?(i(this,"_monthsRegex")||Ft.call(this),t?this._monthsShortStrictRegex:this._monthsShortRegex):(i(this,"_monthsShortRegex")||(this._monthsShortRegex=jt),this._monthsShortStrictRegex&&t?this._monthsShortStrictRegex:this._monthsShortRegex)},un.week=function(t){return Pt(t,this._week.dow,this._week.doy).week},un.firstDayOfYear=function(){return this._week.doy},un.firstDayOfWeek=function(){return this._week.dow},un.weekdays=function(t,e){return t?p(this._weekdays)?this._weekdays[t.day()]:this._weekdays[this._weekdays.isFormat.test(e)?"format":"standalone"][t.day()]:p(this._weekdays)?this._weekdays:this._weekdays.standalone},un.weekdaysMin=function(t){return t?this._weekdaysMin[t.day()]:this._weekdaysMin},un.weekdaysShort=function(t){return t?this._weekdaysShort[t.day()]:this._weekdaysShort},un.weekdaysParse=function(t,e,n){var o,p,r;if(this._weekdaysParseExact)return function(t,e,n){var o,p,r,b=t.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],o=0;o<7;++o)r=O([2e3,1]).day(o),this._minWeekdaysParse[o]=this.weekdaysMin(r,"").toLocaleLowerCase(),this._shortWeekdaysParse[o]=this.weekdaysShort(r,"").toLocaleLowerCase(),this._weekdaysParse[o]=this.weekdays(r,"").toLocaleLowerCase();return n?"dddd"===e?-1!==(p=Bt.call(this._weekdaysParse,b))?p:null:"ddd"===e?-1!==(p=Bt.call(this._shortWeekdaysParse,b))?p:null:-1!==(p=Bt.call(this._minWeekdaysParse,b))?p:null:"dddd"===e?-1!==(p=Bt.call(this._weekdaysParse,b))?p:-1!==(p=Bt.call(this._shortWeekdaysParse,b))?p:-1!==(p=Bt.call(this._minWeekdaysParse,b))?p:null:"ddd"===e?-1!==(p=Bt.call(this._shortWeekdaysParse,b))?p:-1!==(p=Bt.call(this._weekdaysParse,b))?p:-1!==(p=Bt.call(this._minWeekdaysParse,b))?p:null:-1!==(p=Bt.call(this._minWeekdaysParse,b))?p:-1!==(p=Bt.call(this._weekdaysParse,b))?p:-1!==(p=Bt.call(this._shortWeekdaysParse,b))?p:null}.call(this,t,e,n);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),o=0;o<7;o++){if(p=O([2e3,1]).day(o),n&&!this._fullWeekdaysParse[o]&&(this._fullWeekdaysParse[o]=new RegExp("^"+this.weekdays(p,"").replace(".",".?")+"$","i"),this._shortWeekdaysParse[o]=new RegExp("^"+this.weekdaysShort(p,"").replace(".",".?")+"$","i"),this._minWeekdaysParse[o]=new RegExp("^"+this.weekdaysMin(p,"").replace(".",".?")+"$","i")),this._weekdaysParse[o]||(r="^"+this.weekdays(p,"")+"|^"+this.weekdaysShort(p,"")+"|^"+this.weekdaysMin(p,""),this._weekdaysParse[o]=new RegExp(r.replace(".",""),"i")),n&&"dddd"===e&&this._fullWeekdaysParse[o].test(t))return o;if(n&&"ddd"===e&&this._shortWeekdaysParse[o].test(t))return o;if(n&&"dd"===e&&this._minWeekdaysParse[o].test(t))return o;if(!n&&this._weekdaysParse[o].test(t))return o}},un.weekdaysRegex=function(t){return this._weekdaysParseExact?(i(this,"_weekdaysRegex")||Jt.call(this),t?this._weekdaysStrictRegex:this._weekdaysRegex):(i(this,"_weekdaysRegex")||(this._weekdaysRegex=Kt),this._weekdaysStrictRegex&&t?this._weekdaysStrictRegex:this._weekdaysRegex)},un.weekdaysShortRegex=function(t){return this._weekdaysParseExact?(i(this,"_weekdaysRegex")||Jt.call(this),t?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(i(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=$t),this._weekdaysShortStrictRegex&&t?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)},un.weekdaysMinRegex=function(t){return this._weekdaysParseExact?(i(this,"_weekdaysRegex")||Jt.call(this),t?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(i(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=Qt),this._weekdaysMinStrictRegex&&t?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)},un.isPM=function(t){return"p"===(t+"").toLowerCase().charAt(0)},un.meridiem=function(t,e,n){return t>11?n?"pm":"PM":n?"am":"AM"},ze("en",{dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(t){var e=t%10,n=1===m(t%100/10)?"th":1===e?"st":2===e?"nd":3===e?"rd":"th";return t+n}}),o.lang=y("moment.lang is deprecated. Use moment.locale instead.",ze),o.langData=y("moment.langData is deprecated. Use moment.localeData instead.",ae);var dn=Math.abs;function fn(t,e,n,o){var p=Ue(e,n);return t._milliseconds+=o*p._milliseconds,t._days+=o*p._days,t._months+=o*p._months,t._bubble()}function qn(t){return t<0?Math.floor(t):Math.ceil(t)}function hn(t){return 4800*t/146097}function Wn(t){return 146097*t/4800}function mn(t){return function(){return this.as(t)}}var Rn=mn("ms"),vn=mn("s"),yn=mn("m"),gn=mn("h"),Bn=mn("d"),Ln=mn("w"),Xn=mn("M"),Nn=mn("y");function _n(t){return function(){return this.isValid()?this._data[t]:NaN}}var Sn=_n("milliseconds"),Tn=_n("seconds"),wn=_n("minutes"),En=_n("hours"),Cn=_n("days"),xn=_n("months"),jn=_n("years"),kn=Math.round,Fn={ss:44,s:45,m:45,h:22,d:26,M:11},Hn=Math.abs;function In(t){return(t>0)-(t<0)||+t}function Dn(){if(!this.isValid())return this.localeData().invalidDate();var t,e,n=Hn(this._milliseconds)/1e3,o=Hn(this._days),p=Hn(this._months);t=W(n/60),e=W(t/60),n%=60,t%=60;var r=W(p/12),b=p%=12,M=o,c=e,z=t,i=n?n.toFixed(3).replace(/\.?0+$/,""):"",a=this.asSeconds();if(!a)return"P0D";var O=a<0?"-":"",u=In(this._months)!==In(a)?"-":"",s=In(this._days)!==In(a)?"-":"",A=In(this._milliseconds)!==In(a)?"-":"";return O+"P"+(r?u+r+"Y":"")+(b?u+b+"M":"")+(M?s+M+"D":"")+(c||z||i?"T":"")+(c?A+c+"H":"")+(z?A+z+"M":"")+(i?A+i+"S":"")}var Pn=we.prototype;return Pn.isValid=function(){return this._isValid},Pn.abs=function(){var t=this._data;return this._milliseconds=dn(this._milliseconds),this._days=dn(this._days),this._months=dn(this._months),t.milliseconds=dn(t.milliseconds),t.seconds=dn(t.seconds),t.minutes=dn(t.minutes),t.hours=dn(t.hours),t.months=dn(t.months),t.years=dn(t.years),this},Pn.add=function(t,e){return fn(this,t,e,1)},Pn.subtract=function(t,e){return fn(this,t,e,-1)},Pn.as=function(t){if(!this.isValid())return NaN;var e,n,o=this._milliseconds;if("month"===(t=w(t))||"year"===t)return e=this._days+o/864e5,n=this._months+hn(e),"month"===t?n:n/12;switch(e=this._days+Math.round(Wn(this._months)),t){case"week":return e/7+o/6048e5;case"day":return e+o/864e5;case"hour":return 24*e+o/36e5;case"minute":return 1440*e+o/6e4;case"second":return 86400*e+o/1e3;case"millisecond":return Math.floor(864e5*e)+o;default:throw new Error("Unknown unit "+t)}},Pn.asMilliseconds=Rn,Pn.asSeconds=vn,Pn.asMinutes=yn,Pn.asHours=gn,Pn.asDays=Bn,Pn.asWeeks=Ln,Pn.asMonths=Xn,Pn.asYears=Nn,Pn.valueOf=function(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*m(this._months/12):NaN},Pn._bubble=function(){var t,e,n,o,p,r=this._milliseconds,b=this._days,M=this._months,c=this._data;return r>=0&&b>=0&&M>=0||r<=0&&b<=0&&M<=0||(r+=864e5*qn(Wn(M)+b),b=0,M=0),c.milliseconds=r%1e3,t=W(r/1e3),c.seconds=t%60,e=W(t/60),c.minutes=e%60,n=W(e/60),c.hours=n%24,b+=W(n/24),p=W(hn(b)),M+=p,b-=qn(Wn(p)),o=W(M/12),M%=12,c.days=b,c.months=M,c.years=o,this},Pn.clone=function(){return Ue(this)},Pn.get=function(t){return t=w(t),this.isValid()?this[t+"s"]():NaN},Pn.milliseconds=Sn,Pn.seconds=Tn,Pn.minutes=wn,Pn.hours=En,Pn.days=Cn,Pn.weeks=function(){return W(this.days()/7)},Pn.months=xn,Pn.years=jn,Pn.humanize=function(t){if(!this.isValid())return this.localeData().invalidDate();var e=this.localeData(),n=function(t,e,n){var o=Ue(t).abs(),p=kn(o.as("s")),r=kn(o.as("m")),b=kn(o.as("h")),M=kn(o.as("d")),c=kn(o.as("M")),z=kn(o.as("y")),i=p<=Fn.ss&&["s",p]||p0,i[4]=n,function(t,e,n,o,p){return p.relativeTime(e||1,!!n,t,o)}.apply(null,i)}(this,!t,e);return t&&(n=e.pastFuture(+this,n)),e.postformat(n)},Pn.toISOString=Dn,Pn.toString=Dn,Pn.toJSON=Dn,Pn.locale=Ze,Pn.localeData=en,Pn.toIsoString=y("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",Dn),Pn.lang=tn,D("X",0,0,"unix"),D("x",0,0,"valueOf"),zt("x",pt),zt("X",/[+-]?\d+(\.\d{1,3})?/),ut("X",function(t,e,n){n._d=new Date(1e3*parseFloat(t,10))}),ut("x",function(t,e,n){n._d=new Date(m(t))}),o.version="2.20.1",e=Xe,o.fn=an,o.min=function(){return Se("isBefore",[].slice.call(arguments,0))},o.max=function(){return Se("isAfter",[].slice.call(arguments,0))},o.now=function(){return Date.now?Date.now():+new Date},o.utc=O,o.unix=function(t){return Xe(1e3*t)},o.months=function(t,e){return An(t,e,"months")},o.isDate=c,o.locale=ze,o.invalid=A,o.duration=Ue,o.isMoment=h,o.weekdays=function(t,e,n){return ln(t,e,n,"weekdays")},o.parseZone=function(){return Xe.apply(null,arguments).parseZone()},o.localeData=ae,o.isDuration=Ee,o.monthsShort=function(t,e){return An(t,e,"monthsShort")},o.weekdaysMin=function(t,e,n){return ln(t,e,n,"weekdaysMin")},o.defineLocale=ie,o.updateLocale=function(t,e){if(null!=e){var n,o,p=pe;null!=(o=ce(t))&&(p=o._config),e=N(p,e),(n=new _(e)).parentLocale=re[t],re[t]=n,ze(t)}else null!=re[t]&&(null!=re[t].parentLocale?re[t]=re[t].parentLocale:null!=re[t]&&delete re[t]);return re[t]},o.locales=function(){return g(re)},o.weekdaysShort=function(t,e,n){return ln(t,e,n,"weekdaysShort")},o.normalizeUnits=w,o.relativeTimeRounding=function(t){return void 0===t?kn:"function"==typeof t&&(kn=t,!0)},o.relativeTimeThreshold=function(t,e){return void 0!==Fn[t]&&(void 0===e?Fn[t]:(Fn[t]=e,"s"===t&&(Fn.ss=e-1),!0))},o.calendarFormat=function(t,e){var n=t.diff(e,"days",!0);return n<-6?"sameElse":n<-1?"lastWeek":n<0?"lastDay":n<1?"sameDay":n<2?"nextDay":n<7?"nextWeek":"sameElse"},o.prototype=an,o.HTML5_FMT={DATETIME_LOCAL:"YYYY-MM-DDTHH:mm",DATETIME_LOCAL_SECONDS:"YYYY-MM-DDTHH:mm:ss",DATETIME_LOCAL_MS:"YYYY-MM-DDTHH:mm:ss.SSS",DATE:"YYYY-MM-DD",TIME:"HH:mm",TIME_SECONDS:"HH:mm:ss",TIME_MS:"HH:mm:ss.SSS",WEEK:"YYYY-[W]WW",MONTH:"YYYY-MM"},o}()}).call(this,n(62)(t))},function(t,e,n){"use strict";n.d(e,"a",function(){return p});var o=n(17);function p(t){return function e(n){return 0===arguments.length||Object(o.a)(n)?e:t.apply(this,arguments)}}},function(t,e,n){"use strict";var o=n(24),p=n.n(o);e.a=p()({SET_CURRENT_PAGE:null,LOAD_INDEX_PAGE_DATA:null,LOAD_SERVICE_PAGE_DATA:null,FETCH_INDEX_PAGE_SERVICE_SUCCESS:null,FETCH_SERVICE_PAGE_SERVICE_SUCCESS:null,FETCH_MAP_PAGE_SERVICE_SUCCESS:null,FETCH_COUNTRY_PAGE_SERVICE_SUCCESS:null,FETCH_COMPANIES_PAGE_SERVICE_SUCCESS:null,FETCH_SERVICE_CITY_PAGE_SERVICE_SUCCESS:null,FETCH_SERVICE_SUBDIVISION_PAGE_SERVICE_SUCCESS:null,FETCH_SERVICE_DIVISION_PAGE_SERVICE_SUCCESS:null,FETCH_SERVICE_COUNTRY_PAGE_SERVICE_SUCCESS:null,FETCH_MOST_COMMON_REPORT_CITIES_SERVICE_SUCCESS:null,FETCH_MOST_COMMON_REPORT_DIVISIONS_SERVICE_SUCCESS:null,FETCH_MOST_COMMON_REPORT_COUNTRIES_SERVICE_SUCCESS:null,LOAD_SERVICE_GEONAME:null,LOAD_PRIVACY_POLICY_PAGE_DATA:null,LOAD_MAP_PAGE_DATA:null,LOAD_SERVICE_CITY_PAGE_DATA:null,LOAD_SERVICE_DIVISION_PAGE_DATA:null,LOAD_COMPANIES_PAGE_DATA:null,FETCH_CALENDAR_SERVICE_SUCCESS:null,FETCH_METRICS_SERVICE:null,LOAD_SERVICE_DIVISION:null,FETCH_REPORTS_BY_DIVISION_SERVICE_SUCCESS:null,NAVIGATE_START:null,NAVIGATE_SUCCESS:null,NAVIGATE_FAILURE:null,LOAD_ONGOING_INCIDENTS:null,LOAD_INCIDENTS_BY_DATE:null,FETCH_INCIDENTS_BY_DATE_START:null,FETCH_INCIDENTS_BY_DATE_SUCCESS:null,FETCH_INCIDENTS_BY_DATE_FAILURE:null,FETCH_DOMINANT_DATA_SUCCESS:null,FETCH_LOCAL_DOMINANT_DATA_SUCCESS:null,LOAD_SERVICE:null,LOAD_STATS:null,LOAD_CITY_SUCCESS:null,LOAD_SCREENSHOT_URLS:null,LOAD_MAP_PAGE_DATA_SUCCESS:null,LOAD_COUNTRY:null,LOAD_CITY_STATS:null,LOAD_COUNTRY_STATS:null,LOAD_PAGE_META:null,LOAD_OUTAGE_SUBJECT_STATS:null,LOAD_LOCAL_OUTAGE_SUBJECT_STATS:null,LOAD_SCREENSHOT_MAP_DATA_SUCCESS:null,LOAD_CALENDAR_DATA:null,LOAD_CALENDAR_DATA_NEW:null,LOAD_NOTABLE_OUTAGES:null,LOAD_RECENT_REPORTS:null,LOAD_TWEETS:null,LOAD_TWEETS_START:null,LOAD_TWEETS_SUCCESS:null,LOAD_TWEETS_FAILURE:null,ADD_NEW_TWEET:null,SHOW_NEW_TWEETS:null,FETCH_CHART_DATA_START:null,FETCH_CHART_DATA_SUCCESS:null,FETCH_CHART_DATA_FAILURE:null,FETCH_CITY_CHART_DATA_SUCCESS:null,FETCH_LOCAL_CHART_DATA_SUCCESS:null,FETCH_MAP_DATA_START:null,FETCH_MAP_DATA_SUCCESS:null,FETCH_MAP_DATA_FAILURE:null,UPDATE_STATUS:null,SEND_REPORT_START:null,SEND_REPORT_SUCCESS:null,SEND_REPORT_FAILURE:null,RECEIVE_REPORT:null,SOCKET_CLIENT_INIT:null,INDEX_LOAD_SERVICES_SUCCESS:null,INDEX_SERVICE_CHECK_START:null,INDEX_SERVICE_CHECK_SUCCESS:null,INDEX_SERVICE_CHECK_FAILURE:null,INDEX_SOCKET_RECEIVE_REPORT:null,INDEX_RECEIVE_SERVICES:null,LOAD_INDEX_PAGE_DATA_SUCCESS:null,SWITCH_MAP:null,LOAD_SERVICE_LIST_SUCCESS:null,LOAD_OUTAGES_SUCCESS:null,CHANGE_DATE_START:null,CHANGE_DATE_FAILURE:null,CHANGE_DATE_SUCCESS:null,CHART_INIT_COMPLETE:null,BROWSER_LOADED:null,DFP_LOADED:null,LOAD_WEBSITE_SUCCESS:null,GOOGLE_MAPS_ASSETS_LOADED:null,LOAD_COUNTRY_PAGE_DATA:null,LOAD_LANG_SUCCESS:null,CHANGE_LANG_SUCCESS:null,LOAD_COUNTRY_SUCCESS:null,SET_AMP_TRUE:null,SET_SCREENSHOT_PARAMS:null,SET_IS_FROM_EEA:null})},function(t,e,n){"use strict";n.r(e),function(t,o){n.d(e,"css",function(){return ft}),n.d(e,"keyframes",function(){return re}),n.d(e,"createGlobalStyle",function(){return oe}),n.d(e,"isStyledComponent",function(){return B}),n.d(e,"ThemeConsumer",function(){return Vt}),n.d(e,"ThemeContext",function(){return Ut}),n.d(e,"ThemeProvider",function(){return Gt}),n.d(e,"withTheme",function(){return be}),n.d(e,"ServerStyleSheet",function(){return Yt}),n.d(e,"StyleSheetManager",function(){return Qt}),n.d(e,"__DO_NOT_USE_OR_YOU_WILL_BE_HAUNTED_BY_SPOOKY_GHOSTS",function(){return Me});var p=n(147),r=n.n(p),b=n(383),M=n.n(b),c=n(0),z=n.n(c),i=n(382),a=n(98),O=n(146),u=(n(6),n(56),n(377)),s=function(t,e){for(var n=[t[0]],o=0,p=e.length;o=0||Object.prototype.hasOwnProperty.call(t,o)&&(n[o]=t[o]);return n},W=function(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?t:e},m=function(t){return"object"===(void 0===t?"undefined":A(t))&&t.constructor===Object},R=Object.freeze([]),v=Object.freeze({});function y(t){return"function"==typeof t}function g(t){return t.displayName||t.name||"Component"}function B(t){return t&&"string"==typeof t.styledComponentId}var L=void 0!==t&&Object({NODE_ENV:"production"}).SC_ATTR||"data-styled",X="undefined"!=typeof window&&"HTMLElement"in window,N="boolean"==typeof SC_DISABLE_SPEEDY&&SC_DISABLE_SPEEDY||!1,_={};var S=function(t){function e(n){l(this,e);for(var o=arguments.length,p=Array(o>1?o-1:0),r=1;r0&&-1!==n.slice(0,e).indexOf(I)&&n.slice(e-I.length,e)!==I?"."+H:t};x.use([function(t,e,n){2===t&&n.length&&n[0].lastIndexOf(I)>0&&(n[0]=n[0].replace(D,P))},F,k]),C.use([F,k]);function U(t,e,n){var o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:"&",p=t.join("").replace(E,""),r=e&&n?n+" "+e+" { "+p+" }":p;return H=o,I=e,D=new RegExp("\\"+I+"\\b","g"),x(n||!e?"":e,r)}var V=function(){return n.nc},G=function(t,e,n){n&&((t[e]||(t[e]=Object.create(null)))[n]=!0)},Y=function(t,e){t[e]=Object.create(null)},K=function(t){return function(e,n){return void 0!==t[e]&&t[e][n]}},$=function(t){var e="";for(var n in t)e+=Object.keys(t[n]).join(" ")+" ";return e.trim()},Q=function(t){if(t.sheet)return t.sheet;for(var e=document.styleSheets.length,n=0;n"+t()+""}},nt=function(t,e){return function(){var n,o=((n={})[L]=$(e),n["data-styled-version"]="4.1.3",n),p=V();return p&&(o.nonce=p),z.a.createElement("style",f({},o,{dangerouslySetInnerHTML:{__html:t()}}))}},ot=function(t){return function(){return Object.keys(t)}},pt=function(t){return document.createTextNode(Z(t))},rt=function t(e,n){var o=void 0===e?Object.create(null):e,p=void 0===n?Object.create(null):n,r=function(t){var e=p[t];return void 0!==e?e:p[t]=[""]},b=function(){var t="";for(var e in p){var n=p[e][0];n&&(t+=Z(e)+n)}return t};return{clone:function(){var e=function(t){var e=Object.create(null);for(var n in t)e[n]=f({},t[n]);return e}(o),n=Object.create(null);for(var r in p)n[r]=[p[r][0]];return t(e,n)},css:b,getIds:ot(p),hasNameForId:K(o),insertMarker:r,insertRules:function(t,e,n){r(t)[0]+=e.join(" "),G(o,t,n)},removeRules:function(t){var e=p[t];void 0!==e&&(e[0]="",Y(o,t))},sealed:!1,styleTag:null,toElement:nt(b,o),toHTML:et(b,o)}},bt=function(t,e,n,o,p){if(X&&!n){var r=function(t,e,n){var o=document.createElement("style");o.setAttribute(L,""),o.setAttribute("data-styled-version","4.1.3");var p=V();if(p&&o.setAttribute("nonce",p),o.appendChild(document.createTextNode("")),t&&!e)t.appendChild(o);else{if(!e||!t||!e.parentNode)throw new S(6);e.parentNode.insertBefore(o,n?e:e.nextSibling)}return o}(t,e,o);return N?function(t,e){var n=Object.create(null),o=Object.create(null),p=void 0!==e,r=!1,b=function(e){var p=o[e];return void 0!==p?p:(o[e]=pt(e),t.appendChild(o[e]),n[e]=Object.create(null),o[e])},M=function(){var t="";for(var e in o)t+=o[e].data;return t};return{clone:function(){throw new S(5)},css:M,getIds:ot(o),hasNameForId:K(n),insertMarker:b,insertRules:function(t,o,M){for(var c=b(t),z=[],i=o.length,a=0;a0&&(r=!0,e().insertRules(t+"-import",z))},removeRules:function(b){var M=o[b];if(void 0!==M){var c=pt(b);t.replaceChild(c,M),o[b]=c,Y(n,b),p&&r&&e().removeRules(b+"-import")}},sealed:!1,styleTag:t,toElement:nt(M,n),toHTML:et(M,n)}}(r,p):function(t,e){var n=Object.create(null),o=Object.create(null),p=[],r=void 0!==e,b=!1,M=function(t){var e=o[t];return void 0!==e?e:(o[t]=p.length,p.push(0),Y(n,t),o[t])},c=function(){var e=Q(t).cssRules,n="";for(var r in o){n+=Z(r);for(var b=o[r],M=tt(p,b),c=M-p[b];c0&&(b=!0,e().insertRules(o+"-import",s)),p[i]+=u,G(n,o,z)},removeRules:function(M){var c=o[M];if(void 0!==c){var z=p[c];!function(t,e,n){for(var o=e-n,p=e;p>o;p-=1)t.deleteRule(p)}(Q(t),tt(p,c)-1,z),p[c]=0,Y(n,M),r&&b&&e().removeRules(M+"-import")}},sealed:!1,styleTag:t,toElement:nt(c,n),toHTML:et(c,n)}}(r,p)}return rt()},Mt=/\s+/,ct=void 0;ct=X?N?40:1e3:-1;var zt=0,it=void 0,at=function(){function t(){var e=this,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:X?document.head:null,o=arguments.length>1&&void 0!==arguments[1]&&arguments[1];l(this,t),this.getImportRuleTag=function(){var t=e.importRuleTag;if(void 0!==t)return t;var n=e.tags[0];return e.importRuleTag=bt(e.target,n?n.styleTag:null,e.forceServer,!0)},zt+=1,this.id=zt,this.forceServer=o,this.target=o?null:n,this.tagMap={},this.deferred={},this.rehydratedNames={},this.ignoreRehydratedNames={},this.tags=[],this.capacity=1,this.clones=[]}return t.prototype.rehydrate=function(){if(!X||this.forceServer)return this;var t=[],e=[],n=!1,o=document.querySelectorAll("style["+L+'][data-styled-version="4.1.3"]'),p=o.length;if(!p)return this;for(var r=0;r0&&void 0!==arguments[0]&&arguments[0];it=new t(void 0,e).rehydrate()},t.prototype.clone=function(){var e=new t(this.target,this.forceServer);return this.clones.push(e),e.tags=this.tags.map(function(t){for(var n=t.getIds(),o=t.clone(),p=0;p1?e-1:0),o=1;o=4;)e=1540483477*(65535&(e=255&t.charCodeAt(p)|(255&t.charCodeAt(++p))<<8|(255&t.charCodeAt(++p))<<16|(255&t.charCodeAt(++p))<<24))+((1540483477*(e>>>16)&65535)<<16),o=1540483477*(65535&o)+((1540483477*(o>>>16)&65535)<<16)^(e=1540483477*(65535&(e^=e>>>24))+((1540483477*(e>>>16)&65535)<<16)),n-=4,++p;switch(n){case 3:o^=(255&t.charCodeAt(p+2))<<16;case 2:o^=(255&t.charCodeAt(p+1))<<8;case 1:o=1540483477*(65535&(o^=255&t.charCodeAt(p)))+((1540483477*(o>>>16)&65535)<<16)}return((o=1540483477*(65535&(o^=o>>>13))+((1540483477*(o>>>16)&65535)<<16))^o>>>15)>>>0}var ht=52,Wt=function(t){return String.fromCharCode(t+(t>25?39:97))};function mt(t){var e="",n=void 0;for(n=t;n>ht;n=Math.floor(n/ht))e=Wt(n%ht)+e;return Wt(n%ht)+e}function Rt(t,e){for(var n=0;n2&&void 0!==arguments[2]?arguments[2]:v,o=!!n&&t.theme===n.theme;return t.theme&&!o?t.theme:e||n.theme},Xt=/[[\].#*$><+~=|^:(),"'`-]+/g,Nt=/(^-|-$)/g;function _t(t){return t.replace(Xt,"-").replace(Nt,"")}function St(t){return"string"==typeof t&&!0}var Tt={childContextTypes:!0,contextTypes:!0,defaultProps:!0,displayName:!0,getDerivedStateFromProps:!0,propTypes:!0,type:!0},wt={name:!0,length:!0,prototype:!0,caller:!0,callee:!0,arguments:!0,arity:!0},Et=((vt={})[a.ForwardRef]={$$typeof:!0,render:!0},vt),Ct=Object.defineProperty,xt=Object.getOwnPropertyNames,jt=Object.getOwnPropertySymbols,kt=void 0===jt?function(){return[]}:jt,Ft=Object.getOwnPropertyDescriptor,Ht=Object.getPrototypeOf,It=Object.prototype,Dt=Array.prototype;function Pt(t,e,n){if("string"!=typeof e){var o=Ht(e);o&&o!==It&&Pt(t,o,n);for(var p=Dt.concat(xt(e),kt(e)),r=Et[t.$$typeof]||Tt,b=Et[e.$$typeof]||Tt,M=p.length,c=void 0,z=void 0;M--;)if(z=p[M],!(wt[z]||n&&n[z]||b&&b[z]||r&&r[z])&&(c=Ft(e,z)))try{Ct(t,z,c)}catch(t){}return t}return t}var Ut=Object(c.createContext)(),Vt=Ut.Consumer,Gt=function(t){function e(n){l(this,e);var o=W(this,t.call(this,n));return o.getContext=Object(O.a)(o.getContext.bind(o)),o.renderInner=o.renderInner.bind(o),o}return q(e,t),e.prototype.render=function(){return this.props.children?z.a.createElement(Ut.Consumer,null,this.renderInner):null},e.prototype.renderInner=function(t){var e=this.getContext(this.props.theme,t);return z.a.createElement(Ut.Provider,{value:e},z.a.Children.only(this.props.children))},e.prototype.getTheme=function(t,e){if(y(t))return t(e);if(null===t||Array.isArray(t)||"object"!==(void 0===t?"undefined":A(t)))throw new S(8);return f({},e,t)},e.prototype.getContext=function(t,e){return this.getTheme(t,e)},e}(c.Component),Yt=function(){function t(){l(this,t),this.masterSheet=at.master,this.instance=this.masterSheet.clone(),this.sealed=!1}return t.prototype.seal=function(){if(!this.sealed){var t=this.masterSheet.clones.indexOf(this.instance);this.masterSheet.clones.splice(t,1),this.sealed=!0}},t.prototype.collectStyles=function(t){if(this.sealed)throw new S(2);return z.a.createElement(Qt,{sheet:this.instance},t)},t.prototype.getStyleTags=function(){return this.seal(),this.instance.toHTML()},t.prototype.getStyleElement=function(){return this.seal(),this.instance.toReactElements()},t.prototype.interleaveWithNodeStream=function(t){throw new S(3)},t}(),Kt=Object(c.createContext)(),$t=Kt.Consumer,Qt=function(t){function e(n){l(this,e);var o=W(this,t.call(this,n));return o.getContext=Object(O.a)(o.getContext),o}return q(e,t),e.prototype.getContext=function(t,e){if(t)return t;if(e)return new at(e);throw new S(4)},e.prototype.render=function(){var t=this.props,e=t.children,n=t.sheet,o=t.target;return z.a.createElement(Kt.Provider,{value:this.getContext(n,o)},e)},e}(c.Component),Jt=(new Set,{});var Zt=function(t){function e(){l(this,e);var n=W(this,t.call(this));return n.attrs={},n.renderOuter=n.renderOuter.bind(n),n.renderInner=n.renderInner.bind(n),n}return q(e,t),e.prototype.render=function(){return z.a.createElement($t,null,this.renderOuter)},e.prototype.renderOuter=function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:at.master;return this.styleSheet=t,this.props.forwardedComponent.componentStyle.isStatic?this.renderInner():z.a.createElement(Vt,null,this.renderInner)},e.prototype.renderInner=function(t){var e=this.props.forwardedComponent,n=e.componentStyle,o=e.defaultProps,p=(e.displayName,e.foldedComponentIds),r=e.styledComponentId,b=e.target,M=void 0;M=n.isStatic?this.generateAndInjectStyles(v,this.props):void 0!==t?this.generateAndInjectStyles(Lt(this.props,t,o),this.props):this.generateAndInjectStyles(this.props.theme||v,this.props);var z=this.props.as||this.attrs.as||b,i=St(z),a={},O=f({},this.attrs,this.props),s=void 0;for(s in O)"forwardedComponent"!==s&&"as"!==s&&("forwardedRef"===s?a.ref=O[s]:i&&!Object(u.a)(s)||(a[s]=O[s]));return this.props.style&&this.attrs.style&&(a.style=f({},this.attrs.style,this.props.style)),a.className=Array.prototype.concat(p,this.props.className,r,this.attrs.className,M).filter(Boolean).join(" "),Object(c.createElement)(z,a)},e.prototype.buildExecutionContext=function(t,e,n){var o=this,p=f({},e,{theme:t});return n.length?(this.attrs={},n.forEach(function(t){var e,n=t,r=!1,b=void 0,M=void 0;for(M in y(n)&&(n=n(p),r=!0),n)b=n[M],r||!y(b)||(e=b)&&e.prototype&&e.prototype.isReactComponent||B(b)||(b=b(p)),o.attrs[M]=b,p[M]=b}),p):p},e.prototype.generateAndInjectStyles=function(t,e){var n=e.forwardedComponent,o=n.attrs,p=n.componentStyle;n.warnTooManyClasses;return p.isStatic&&!o.length?p.generateAndInjectStyles(v,this.styleSheet):p.generateAndInjectStyles(this.buildExecutionContext(t,e,o),this.styleSheet)},e}(c.Component);function te(t,e,n){var o=B(t),p=!St(t),r=e.displayName,b=void 0===r?function(t){return St(t)?"styled."+t:"Styled("+g(t)+")"}(t):r,M=e.componentId,c=void 0===M?function(t,e,n){var o="string"!=typeof e?"sc":_t(e),p=(Jt[o]||0)+1;Jt[o]=p;var r=o+"-"+t.generateName(o+p);return n?n+"-"+r:r}(Bt,e.displayName,e.parentComponentId):M,i=e.ParentComponent,a=void 0===i?Zt:i,O=e.attrs,u=void 0===O?R:O,s=e.displayName&&e.componentId?_t(e.displayName)+"-"+e.componentId:e.componentId||c,A=o&&t.attrs?Array.prototype.concat(t.attrs,u).filter(Boolean):u,l=new Bt(o?t.componentStyle.rules.concat(n):n,A,s),d=z.a.forwardRef(function(t,e){return z.a.createElement(a,f({},t,{forwardedComponent:d,forwardedRef:e}))});return d.attrs=A,d.componentStyle=l,d.displayName=b,d.foldedComponentIds=o?Array.prototype.concat(t.foldedComponentIds,t.styledComponentId):R,d.styledComponentId=s,d.target=o?t.target:t,d.withComponent=function(t){var o=e.componentId,p=h(e,["componentId"]),r=o&&o+"-"+(St(t)?t:_t(g(t)));return te(t,f({},p,{attrs:A,componentId:r,ParentComponent:a}),n)},d.toString=function(){return"."+d.styledComponentId},p&&Pt(d,t,{attrs:!0,componentStyle:!0,displayName:!0,foldedComponentIds:!0,styledComponentId:!0,target:!0,withComponent:!0}),d}var ee=function(t){return function t(e,n){var o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:v;if(!Object(a.isValidElementType)(n))throw new S(1,String(n));var p=function(){return e(n,o,ft.apply(void 0,arguments))};return p.withConfig=function(p){return t(e,n,f({},o,p))},p.attrs=function(p){return t(e,n,f({},o,{attrs:Array.prototype.concat(o.attrs,p).filter(Boolean)}))},p}(te,t)};["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","big","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","keygen","label","legend","li","link","main","map","mark","marquee","menu","menuitem","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","param","picture","pre","progress","q","rp","rt","ruby","s","samp","script","section","select","small","source","span","strong","style","sub","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr","circle","clipPath","defs","ellipse","foreignObject","g","image","line","linearGradient","mask","path","pattern","polygon","polyline","radialGradient","rect","stop","svg","text","tspan"].forEach(function(t){ee[t]=ee(t)});var ne=function(){function t(e,n){l(this,t),this.rules=e,this.componentId=n,this.isStatic=Rt(e,R),at.master.hasId(n)||at.master.deferredInject(n,[])}return t.prototype.createStyles=function(t,e){var n=U(dt(this.rules,t,e),"");e.inject(this.componentId,n)},t.prototype.removeStyles=function(t){var e=this.componentId;t.hasId(e)&&t.remove(e)},t.prototype.renderStyles=function(t,e){this.removeStyles(e),this.createStyles(t,e)},t}();function oe(t){for(var e=arguments.length,n=Array(e>1?e-1:0),o=1;o1?e-1:0),o=1;o0))return b;do{b.push(r=new Date(+n)),e(n,p),t(n)}while(r=e)for(;t(e),!n(e);)e.setTime(e-1)},function(t,o){if(t>=t)if(o<0)for(;++o<=0;)for(;e(t,-1),!n(t););else for(;--o>=0;)for(;e(t,1),!n(t););})},n&&(M.count=function(e,r){return o.setTime(+e),p.setTime(+r),t(o),t(p),Math.floor(n(o,p))},M.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?M.filter(b?function(e){return b(e)%t==0}:function(e){return M.count(0,e)%t==0}):M:null}),M}var b=r(function(){},function(t,e){t.setTime(+t+e)},function(t,e){return e-t});b.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?r(function(e){e.setTime(Math.floor(e/t)*t)},function(e,n){e.setTime(+e+n*t)},function(e,n){return(n-e)/t}):b:null};var M=b,c=b.range,z=6e4,i=6048e5,a=r(function(t){t.setTime(1e3*Math.floor(t/1e3))},function(t,e){t.setTime(+t+1e3*e)},function(t,e){return(e-t)/1e3},function(t){return t.getUTCSeconds()}),O=a,u=a.range,s=r(function(t){t.setTime(Math.floor(t/z)*z)},function(t,e){t.setTime(+t+e*z)},function(t,e){return(e-t)/z},function(t){return t.getMinutes()}),A=s,l=s.range,d=r(function(t){var e=t.getTimezoneOffset()*z%36e5;e<0&&(e+=36e5),t.setTime(36e5*Math.floor((+t-e)/36e5)+e)},function(t,e){t.setTime(+t+36e5*e)},function(t,e){return(e-t)/36e5},function(t){return t.getHours()}),f=d,q=d.range,h=r(function(t){t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+e)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*z)/864e5},function(t){return t.getDate()-1}),W=h,m=h.range;function R(t){return r(function(e){e.setDate(e.getDate()-(e.getDay()+7-t)%7),e.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+7*e)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*z)/i})}var v=R(0),y=R(1),g=R(2),B=R(3),L=R(4),X=R(5),N=R(6),_=v.range,S=y.range,T=g.range,w=B.range,E=L.range,C=X.range,x=N.range,j=r(function(t){t.setDate(1),t.setHours(0,0,0,0)},function(t,e){t.setMonth(t.getMonth()+e)},function(t,e){return e.getMonth()-t.getMonth()+12*(e.getFullYear()-t.getFullYear())},function(t){return t.getMonth()}),k=j,F=j.range,H=r(function(t){t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e)},function(t,e){return e.getFullYear()-t.getFullYear()},function(t){return t.getFullYear()});H.every=function(t){return isFinite(t=Math.floor(t))&&t>0?r(function(e){e.setFullYear(Math.floor(e.getFullYear()/t)*t),e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,n){e.setFullYear(e.getFullYear()+n*t)}):null};var I=H,D=H.range,P=r(function(t){t.setUTCSeconds(0,0)},function(t,e){t.setTime(+t+e*z)},function(t,e){return(e-t)/z},function(t){return t.getUTCMinutes()}),U=P,V=P.range,G=r(function(t){t.setUTCMinutes(0,0,0)},function(t,e){t.setTime(+t+36e5*e)},function(t,e){return(e-t)/36e5},function(t){return t.getUTCHours()}),Y=G,K=G.range,$=r(function(t){t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+e)},function(t,e){return(e-t)/864e5},function(t){return t.getUTCDate()-1}),Q=$,J=$.range;function Z(t){return r(function(e){e.setUTCDate(e.getUTCDate()-(e.getUTCDay()+7-t)%7),e.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+7*e)},function(t,e){return(e-t)/i})}var tt=Z(0),et=Z(1),nt=Z(2),ot=Z(3),pt=Z(4),rt=Z(5),bt=Z(6),Mt=tt.range,ct=et.range,zt=nt.range,it=ot.range,at=pt.range,Ot=rt.range,ut=bt.range,st=r(function(t){t.setUTCDate(1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCMonth(t.getUTCMonth()+e)},function(t,e){return e.getUTCMonth()-t.getUTCMonth()+12*(e.getUTCFullYear()-t.getUTCFullYear())},function(t){return t.getUTCMonth()}),At=st,lt=st.range,dt=r(function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e)},function(t,e){return e.getUTCFullYear()-t.getUTCFullYear()},function(t){return t.getUTCFullYear()});dt.every=function(t){return isFinite(t=Math.floor(t))&&t>0?r(function(e){e.setUTCFullYear(Math.floor(e.getUTCFullYear()/t)*t),e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,n){e.setUTCFullYear(e.getUTCFullYear()+n*t)}):null};var ft=dt,qt=dt.range;n.d(e,!1,function(){return r}),n.d(e,"c",function(){return M}),n.d(e,!1,function(){return c}),n.d(e,"n",function(){return M}),n.d(e,!1,function(){return c}),n.d(e,"g",function(){return O}),n.d(e,!1,function(){return u}),n.d(e,"r",function(){return O}),n.d(e,!1,function(){return u}),n.d(e,"d",function(){return A}),n.d(e,!1,function(){return l}),n.d(e,"b",function(){return f}),n.d(e,!1,function(){return q}),n.d(e,"a",function(){return W}),n.d(e,!1,function(){return m}),n.d(e,"j",function(){return v}),n.d(e,!1,function(){return _}),n.d(e,"h",function(){return v}),n.d(e,!1,function(){return _}),n.d(e,"e",function(){return y}),n.d(e,!1,function(){return S}),n.d(e,!1,function(){return g}),n.d(e,!1,function(){return T}),n.d(e,!1,function(){return B}),n.d(e,!1,function(){return w}),n.d(e,"i",function(){return L}),n.d(e,!1,function(){return E}),n.d(e,!1,function(){return X}),n.d(e,!1,function(){return C}),n.d(e,!1,function(){return N}),n.d(e,!1,function(){return x}),n.d(e,"f",function(){return k}),n.d(e,!1,function(){return F}),n.d(e,"k",function(){return I}),n.d(e,!1,function(){return D}),n.d(e,"o",function(){return U}),n.d(e,!1,function(){return V}),n.d(e,"m",function(){return Y}),n.d(e,!1,function(){return K}),n.d(e,"l",function(){return Q}),n.d(e,!1,function(){return J}),n.d(e,"u",function(){return tt}),n.d(e,!1,function(){return Mt}),n.d(e,"s",function(){return tt}),n.d(e,!1,function(){return Mt}),n.d(e,"p",function(){return et}),n.d(e,!1,function(){return ct}),n.d(e,!1,function(){return nt}),n.d(e,!1,function(){return zt}),n.d(e,!1,function(){return ot}),n.d(e,!1,function(){return it}),n.d(e,"t",function(){return pt}),n.d(e,!1,function(){return at}),n.d(e,!1,function(){return rt}),n.d(e,!1,function(){return Ot}),n.d(e,!1,function(){return bt}),n.d(e,!1,function(){return ut}),n.d(e,"q",function(){return At}),n.d(e,!1,function(){return lt}),n.d(e,"v",function(){return ft}),n.d(e,!1,function(){return qt})},function(t,e,n){var o,p,r;r=function(){return function(){return function(t){var e=[];if(t[0].match(/^[^/:]+:\/*$/)&&t.length>1){var n=t.shift();t[0]=n+t[0]}t[0].match(/^file:\/\/\//)?t[0]=t[0].replace(/^([^/:]+):\/*/,"$1:///"):t[0]=t[0].replace(/^([^/:]+):\/*/,"$1://");for(var o=0;o0&&(p=p.replace(/^[\/]+/,"")),p=o0?"?":"")+b.join("&")}("object"==typeof arguments[0]?arguments[0]:[].slice.call(arguments))}},void 0!==t&&t.exports?t.exports=r():void 0===(p="function"==typeof(o=r)?o.call(e,n,e,t):o)||(t.exports=p)},function(t,e,n){(t.exports=n(1363)).tz.load(n(1362))},function(t,e){var n;n=function(){return this}();try{n=n||Function("return this")()||(0,eval)("this")}catch(t){"object"==typeof window&&(n=window)}t.exports=n},function(t,e,n){"use strict";var o=function(t,e){return te?1:t>=e?0:NaN},p=function(t){var e;return 1===t.length&&(e=t,t=function(t,n){return o(e(t),n)}),{left:function(e,n,o,p){for(null==o&&(o=0),null==p&&(p=e.length);o>>1;t(e[r],n)<0?o=r+1:p=r}return o},right:function(e,n,o,p){for(null==o&&(o=0),null==p&&(p=e.length);o>>1;t(e[r],n)>0?p=r:o=r+1}return o}}};var r=p(o),b=r.right,M=r.left,c=b,z=function(t,e){null==e&&(e=i);for(var n=0,o=t.length-1,p=t[0],r=new Array(o<0?0:o);nt?1:e>=t?0:NaN},u=function(t){return null===t?NaN:+t},s=function(t,e){var n,o,p=t.length,r=0,b=-1,M=0,c=0;if(null==e)for(;++b1)return c/(r-1)},A=function(t,e){var n=s(t,e);return n?Math.sqrt(n):n},l=function(t,e){var n,o,p,r=t.length,b=-1;if(null==e){for(;++b=n)for(o=p=n;++bn&&(o=n),p=n)for(o=p=n;++bn&&(o=n),p0)return[t];if((o=e0)for(t=Math.ceil(t/b),e=Math.floor(e/b),r=new Array(p=Math.ceil(e-t+1));++M=0?(r>=R?10:r>=v?5:r>=y?2:1)*Math.pow(10,p):-Math.pow(10,-p)/(r>=R?10:r>=v?5:r>=y?2:1)}function L(t,e,n){var o=Math.abs(e-t)/Math.max(0,n),p=Math.pow(10,Math.floor(Math.log(o)/Math.LN10)),r=o/p;return r>=R?p*=10:r>=v?p*=5:r>=y&&(p*=2),ea;)O.pop(),--u;var s,A=new Array(u+1);for(p=0;p<=u;++p)(s=A[p]=[]).x0=p>0?O[p-1]:i,s.x1=p=1)return+n(t[o-1],o-1,t);var o,p=(o-1)*e,r=Math.floor(p),b=+n(t[r],r,t);return b+(+n(t[r+1],r+1,t)-b)*(p-r)}},S=function(t,e,n){return t=q.call(t,u).sort(o),Math.ceil((n-e)/(2*(_(t,.75)-_(t,.25))*Math.pow(t.length,-1/3)))},T=function(t,e,n){return Math.ceil((n-e)/(3.5*A(t)*Math.pow(t.length,-1/3)))},w=function(t,e){var n,o,p=t.length,r=-1;if(null==e){for(;++r=n)for(o=n;++ro&&(o=n)}else for(;++r=n)for(o=n;++ro&&(o=n);return o},E=function(t,e){var n,o=t.length,p=o,r=-1,b=0;if(null==e)for(;++r=0;)for(e=(o=t[p]).length;--e>=0;)n[--b]=o[e];return n},j=function(t,e){var n,o,p=t.length,r=-1;if(null==e){for(;++r=n)for(o=n;++rn&&(o=n)}else for(;++r=n)for(o=n;++rn&&(o=n);return o},k=function(t,e){for(var n=e.length,o=new Array(n);n--;)o[n]=t[e[n]];return o},F=function(t,e){if(n=t.length){var n,p,r=0,b=0,M=t[b];for(null==e&&(e=o);++r=arguments.length)?c=e[b]:(c=arguments[p],p+=1),o[b]=c,Object(M.a)(c)||(r-=1),b+=1}return r<=0?n.apply(this,o):a(r,O(t,o,n))}}var u=c(function(t,e){return 1===t?Object(b.a)(e):a(t,O(t,[],e))}),s=Object(b.a)(function(t){return u(t.length,function(){var e=0,n=arguments[0],o=arguments[arguments.length-1],p=Array.prototype.slice.call(arguments,0);return p[0]=function(){var t=n.apply(this,i(arguments,[e,o]));return e+=1,t},t.apply(this,p)})});function A(t){return function e(n,o,p){switch(arguments.length){case 0:return e;case 1:return Object(M.a)(n)?e:c(function(e,o){return t(n,e,o)});case 2:return Object(M.a)(n)&&Object(M.a)(o)?e:Object(M.a)(n)?c(function(e,n){return t(e,o,n)}):Object(M.a)(o)?c(function(e,o){return t(n,e,o)}):Object(b.a)(function(e){return t(n,o,e)});default:return Object(M.a)(n)&&Object(M.a)(o)&&Object(M.a)(p)?e:Object(M.a)(n)&&Object(M.a)(o)?c(function(e,n){return t(e,n,p)}):Object(M.a)(n)&&Object(M.a)(p)?c(function(e,n){return t(e,o,n)}):Object(M.a)(o)&&Object(M.a)(p)?c(function(e,o){return t(n,e,o)}):Object(M.a)(n)?Object(b.a)(function(e){return t(e,o,p)}):Object(M.a)(o)?Object(b.a)(function(e){return t(n,e,p)}):Object(M.a)(p)?Object(b.a)(function(e){return t(n,o,e)}):t(n,o,p)}}}var l=A(function(t,e,n){if(t>=n.length||t<-n.length)return n;var o=(t<0?n.length:0)+t,p=i(n);return p[o]=e(n[o]),p}),d=Array.isArray||function(t){return null!=t&&t.length>=0&&"[object Array]"===Object.prototype.toString.call(t)};function f(t){return null!=t&&"function"==typeof t["@@transducer/step"]}function q(t,e,n){return function(){if(0===arguments.length)return n();var o=Array.prototype.slice.call(arguments,0),p=o.pop();if(!d(p)){for(var r=0;rt?e:t});function y(t,e){for(var n=0,o=e.length,p=Array(o);n0&&(t.hasOwnProperty(0)&&t.hasOwnProperty(t.length-1)))))}),L=function(){function t(t){this.f=t}return t.prototype["@@transducer/init"]=function(){throw new Error("init not implemented on XWrap")},t.prototype["@@transducer/result"]=function(t){return t},t.prototype["@@transducer/step"]=function(t,e){return this.f(t,e)},t}();function X(t){return new L(t)}var N=c(function(t,e){return a(t.length,function(){return t.apply(e,arguments)})});function _(t,e,n){for(var o=n.next();!o.done;){if((e=t["@@transducer/step"](e,o.value))&&e["@@transducer/reduced"]){e=e["@@transducer/value"];break}o=n.next()}return t["@@transducer/result"](e)}function S(t,e,n,o){return t["@@transducer/result"](n[o](N(t["@@transducer/step"],t),e))}var T="undefined"!=typeof Symbol?Symbol.iterator:"@@iterator";function w(t,e,n){if("function"==typeof t&&(t=X(t)),B(n))return function(t,e,n){for(var o=0,p=n.length;o=0;)x(e=H[n],t)&&!D(o,e)&&(o[o.length]=e),n-=1;return o}):Object(b.a)(function(t){return Object(t)!==t?[]:Object.keys(t)}),U=c(q(["fantasy-land/map","map"],C,function(t,e){switch(Object.prototype.toString.call(e)){case"[object Function]":return u(e.length,function(){return t.call(this,e.apply(this,arguments))});case"[object Object]":return w(function(n,o){return n[o]=t(e[o]),n},{},P(e));default:return y(t,e)}})),V=c(function(t,e){for(var n=e,o=0;o=0?o:0);np?1:0}),Ot=A(function(t,e,n){var o={};for(var p in n)o[p]=n[p];return o[t]=e,o}),ut=Number.isInteger||function(t){return t<<0===t},st=Object(b.a)(function(t){return null==t}),At=A(function t(e,n,o){if(0===e.length)return n;var p=e[0];if(e.length>1){var r=!st(o)&&x(p,o)?o[p]:ut(e[1])?[]:{};n=t(Array.prototype.slice.call(e,1),n,r)}if(ut(p)&&d(o)){var b=[].concat(o);return b[p]=n,b}return Ot(p,n,o)}),lt=c(function(t,e){switch(t){case 0:return function(){return e.call(this)};case 1:return function(t){return e.call(this,t)};case 2:return function(t,n){return e.call(this,t,n)};case 3:return function(t,n,o){return e.call(this,t,n,o)};case 4:return function(t,n,o,p){return e.call(this,t,n,o,p)};case 5:return function(t,n,o,p,r){return e.call(this,t,n,o,p,r)};case 6:return function(t,n,o,p,r,b){return e.call(this,t,n,o,p,r,b)};case 7:return function(t,n,o,p,r,b,M){return e.call(this,t,n,o,p,r,b,M)};case 8:return function(t,n,o,p,r,b,M,c){return e.call(this,t,n,o,p,r,b,M,c)};case 9:return function(t,n,o,p,r,b,M,c,z){return e.call(this,t,n,o,p,r,b,M,c,z)};case 10:return function(t,n,o,p,r,b,M,c,z,i){return e.call(this,t,n,o,p,r,b,M,c,z,i)};default:throw new Error("First argument to nAry must be a non-negative integer no greater than ten")}}),dt=Object(b.a)(function(t){return lt(2,t)});function ft(t){return"[object Function]"===Object.prototype.toString.call(t)}var qt=c(function(t,e){var n=u(t,e);return u(t,function(){return w(nt,U(n,arguments[0]),Array.prototype.slice.call(arguments,1))})}),ht=Object(b.a)(function(t){return qt(t.length,t)}),Wt=c(function(t,e){return ft(t)?function(){return t.apply(this,arguments)&&e.apply(this,arguments)}:ht(J)(t,e)}),mt=Object(b.a)(function(t){return u(t.length,t)}),Rt=mt(function(t){return t.apply(this,Array.prototype.slice.call(arguments,1))});function vt(t){return function e(n){for(var o,p,r,b=[],M=0,c=n.length;Me)throw new Error("min must not be greater than max in clamp(min, max, value)");return ne?e:n});function Lt(t){return new RegExp(t.source,(t.global?"g":"")+(t.ignoreCase?"i":"")+(t.multiline?"m":"")+(t.sticky?"y":"")+(t.unicode?"u":""))}var Xt=Object(b.a)(function(t){return null===t?"Null":void 0===t?"Undefined":Object.prototype.toString.call(t).slice(8,-1)});function Nt(t,e,n,o){var p=function(p){for(var r=e.length,b=0;b=0;){if(n[M]===t)return o[M]===e;M-=1}switch(b){case"Map":return t.size===e.size&&ee(t.entries(),e.entries(),n.concat([t]),o.concat([e]));case"Set":return t.size===e.size&&ee(t.values(),e.values(),n.concat([t]),o.concat([e]));case"Arguments":case"Array":case"Object":case"Boolean":case"Number":case"String":case"Date":case"Error":case"RegExp":case"Int8Array":case"Uint8Array":case"Uint8ClampedArray":case"Int16Array":case"Uint16Array":case"Int32Array":case"Uint32Array":case"Float32Array":case"Float64Array":case"ArrayBuffer":break;default:return!1}var c=P(t);if(c.length!==P(e).length)return!1;var z=n.concat([t]),i=o.concat([e]);for(M=c.length-1;M>=0;){var a=c[M];if(!x(a,e)||!ne(e[a],t[a],z,i))return!1;M-=1}return!0}var oe=c(function(t,e){return ne(t,e,[],[])});function pe(t,e,n){var o,p;if("function"==typeof t.indexOf)switch(typeof e){case"number":if(0===e){for(o=1/e;n=0}function be(t){return'"'+t.replace(/\\/g,"\\\\").replace(/[\b]/g,"\\b").replace(/\f/g,"\\f").replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/\t/g,"\\t").replace(/\v/g,"\\v").replace(/\0/g,"\\0").replace(/"/g,'\\"')+'"'}var Me=function(t){return(t<10?"0":"")+t},ce="function"==typeof Date.prototype.toISOString?function(t){return t.toISOString()}:function(t){return t.getUTCFullYear()+"-"+Me(t.getUTCMonth()+1)+"-"+Me(t.getUTCDate())+"T"+Me(t.getUTCHours())+":"+Me(t.getUTCMinutes())+":"+Me(t.getUTCSeconds())+"."+(t.getUTCMilliseconds()/1e3).toFixed(3).slice(2,5)+"Z"};function ze(t){return function(){return!t.apply(this,arguments)}}function ie(t,e){for(var n=0,o=e.length,p=[];n":Ae(n,o)},o=function(t,e){return y(function(e){return be(e)+": "+n(t[e])},e.slice().sort())};switch(Object.prototype.toString.call(t)){case"[object Arguments]":return"(function() { return arguments; }("+y(n,t).join(", ")+"))";case"[object Array]":return"["+y(n,t).concat(o(t,se(function(t){return/^\d+$/.test(t)},P(t)))).join(", ")+"]";case"[object Boolean]":return"object"==typeof t?"new Boolean("+n(t.valueOf())+")":t.toString();case"[object Date]":return"new Date("+(isNaN(t.valueOf())?n(NaN):be(ce(t)))+")";case"[object Null]":return"null";case"[object Number]":return"object"==typeof t?"new Number("+n(t.valueOf())+")":1/t==-1/0?"-0":t.toString(10);case"[object String]":return"object"==typeof t?"new String("+n(t.valueOf())+")":be(t);case"[object Undefined]":return"undefined";default:if("function"==typeof t.toString){var p=t.toString();if("[object Object]"!==p)return p}return"{"+o(t,P(t)).join(", ")+"}"}}var le=Object(b.a)(function(t){return Ae(t,[])}),de=c(function(t,e){if(d(t)){if(d(e))return t.concat(e);throw new TypeError(le(e)+" is not an array")}if(Object(g.a)(t)){if(Object(g.a)(e))return t+e;throw new TypeError(le(e)+" is not a string")}if(null!=t&&ft(t["fantasy-land/concat"]))return t["fantasy-land/concat"](e);if(null!=t&&ft(t.concat))return t.concat(e);throw new TypeError(le(t)+' does not have a method named "concat" or "fantasy-land/concat"')}),fe=Object(b.a)(function(t){return a(K(v,0,U(function(t){return t[0].length},t)),function(){for(var e=0;e10)throw new Error("Constructor with greater than ten arguments");return 0===t?function(){return new e}:mt(lt(t,function(t,n,o,p,r,b,M,c,z,i){switch(arguments.length){case 1:return new e(t);case 2:return new e(t,n);case 3:return new e(t,n,o);case 4:return new e(t,n,o,p);case 5:return new e(t,n,o,p,r);case 6:return new e(t,n,o,p,r,b);case 7:return new e(t,n,o,p,r,b,M);case 8:return new e(t,n,o,p,r,b,M,c);case 9:return new e(t,n,o,p,r,b,M,c,z);case 10:return new e(t,n,o,p,r,b,M,c,z,i)}}))}),he=Object(b.a)(function(t){return qe(t.length,t)}),We=c(re),me=c(function(t,e){return u(K(v,0,Y("length",e)),function(){var n=arguments,o=this;return t.apply(o,y(function(t){return t.apply(o,n)},e))})}),Re=function(){function t(t,e,n,o){this.valueFn=t,this.valueAcc=e,this.keyFn=n,this.xf=o,this.inputs={}}return t.prototype["@@transducer/init"]=W.init,t.prototype["@@transducer/result"]=function(t){var e;for(e in this.inputs)if(x(e,this.inputs)&&(t=this.xf["@@transducer/step"](t,this.inputs[e]))["@@transducer/reduced"]){t=t["@@transducer/value"];break}return this.inputs=null,this.xf["@@transducer/result"](t)},t.prototype["@@transducer/step"]=function(t,e){var n=this.keyFn(e);return this.inputs[n]=this.inputs[n]||[n,this.valueAcc],this.inputs[n][1]=this.valueFn(this.inputs[n][1],e),t},t}(),ve=O(4,[],q([],O(4,[],function(t,e,n,o){return new Re(t,e,n,o)}),function(t,e,n,o){return w(function(o,p){var r=n(p);return o[r]=t(x(r,o)?o[r]:e,p),o},{},o)})),ye=ve(function(t,e){return t+1},0),ge=z(-1),Be=c(function(t,e){return null==e||e!=e?t:e}),Le=A(function(t,e,n){var o=t(e),p=t(n);return o>p?-1:o0?(this.n-=1,t):this.xf["@@transducer/step"](t,e)},t}(),ke=c(q(["drop"],c(function(t,e){return new je(t,e)}),function(t,e){return xt(Math.max(0,t),1/0,e)})),Fe=function(){function t(t,e){this.xf=e,this.n=t,this.i=0}return t.prototype["@@transducer/init"]=W.init,t.prototype["@@transducer/result"]=W.result,t.prototype["@@transducer/step"]=function(t,e){this.i+=1;var n=0===this.n?t:this.xf["@@transducer/step"](t,e);return this.n>=0&&this.i>=this.n?h(n):n},t}(),He=c(q(["take"],c(function(t,e){return new Fe(t,e)}),function(t,e){return xt(0,t<0?1/0:t,e)}));var Ie=function(){function t(t,e){this.xf=e,this.pos=0,this.full=!1,this.acc=new Array(t)}return t.prototype["@@transducer/init"]=W.init,t.prototype["@@transducer/result"]=function(t){return this.acc=null,this.xf["@@transducer/result"](t)},t.prototype["@@transducer/step"]=function(t,e){return this.full&&(t=this.xf["@@transducer/step"](t,this.acc[this.pos])),this.store(e),t},t.prototype.store=function(t){this.acc[this.pos]=t,this.pos+=1,this.pos===this.acc.length&&(this.pos=0,this.full=!0)},t}(),De=c(q([],c(function(t,e){return new Ie(t,e)}),function(t,e){return He(t=0&&t(e[n]);)n-=1;return xt(0,n+1,e)})),Ve=function(){function t(t,e){this.xf=e,this.pred=t,this.lastValue=void 0,this.seenFirstValue=!1}return t.prototype["@@transducer/init"]=W.init,t.prototype["@@transducer/result"]=W.result,t.prototype["@@transducer/step"]=function(t,e){var n=!1;return this.seenFirstValue?this.pred(this.lastValue,e)&&(n=!0):this.seenFirstValue=!0,this.lastValue=e,n?t:this.xf["@@transducer/step"](t,e)},t}(),Ge=c(function(t,e){return new Ve(t,e)}),Ye=Vt(-1),Ke=c(q([],Ge,function(t,e){var n=[],o=1,p=e.length;if(0!==p)for(n[0]=e[0];o=0?e.length-t:0,e)}),on=c(function(t,e){return oe(nn(t.length,e),t)}),pn=A(function(t,e,n){return oe(t(e),t(n))}),rn=A(function(t,e,n){return oe(e[t],n[t])}),bn=c(function t(e,n){var o,p,r,b=n instanceof Array?[]:{};for(p in n)r=typeof(o=e[p]),b[p]="function"===r?o(n[p]):o&&"object"===r?t(o,n[p]):n[p];return b}),Mn=function(){function t(t,e){this.xf=e,this.f=t,this.found=!1}return t.prototype["@@transducer/init"]=W.init,t.prototype["@@transducer/result"]=function(t){return this.found||(t=this.xf["@@transducer/step"](t,void 0)),this.xf["@@transducer/result"](t)},t.prototype["@@transducer/step"]=function(t,e){return this.f(e)&&(this.found=!0,t=h(this.xf["@@transducer/step"](t,e))),t},t}(),cn=c(q(["find"],c(function(t,e){return new Mn(t,e)}),function(t,e){for(var n=0,o=e.length;n=0;){if(t(e[n]))return e[n];n-=1}})),sn=function(){function t(t,e){this.xf=e,this.f=t,this.idx=-1,this.lastIdx=-1}return t.prototype["@@transducer/init"]=W.init,t.prototype["@@transducer/result"]=function(t){return this.xf["@@transducer/result"](this.xf["@@transducer/step"](t,this.lastIdx))},t.prototype["@@transducer/step"]=function(t,e){return this.idx+=1,this.f(e)&&(this.lastIdx=this.idx),t},t}(),An=c(q([],c(function(t,e){return new sn(t,e)}),function(t,e){for(var n=e.length-1;n>=0;){if(t(e[n]))return n;n-=1}return-1})),ln=Object(b.a)(vt(!0)),dn=Object(b.a)(function(t){return u(t.length,function(e,n){var o=Array.prototype.slice.call(arguments,0);return o[0]=n,o[1]=e,t.apply(this,o)})}),fn=c(Ct("forEach",function(t,e){for(var n=e.length,o=0;oe}),vn=c(function(t,e){return t>=e}),yn=c(function(t,e){if(0===t.length)return!1;for(var n=e,o=0;o=0?t:n.length;var o=Array.prototype.slice.call(n,0);return o.splice(t,0,e),o}),xn=A(function(t,e,n){return t=t=0?t:n.length,[].concat(Array.prototype.slice.call(n,0,t),e,Array.prototype.slice.call(n,t))}),jn=c(function(t,e){for(var n,o,p=new Ne,r=[],b=0;be.length?(n=t,o=e):(n=e,o=t),kn(ie(dn(re)(n),o))}),Hn=c(Ct("intersperse",function(t,e){for(var n=[],o=0,p=e.length;o=0;){if(oe(e[n],t))return n;n-=1}return-1}return e.lastIndexOf(t)});function oo(t){return"[object Number]"===Object.prototype.toString.call(t)}var po=Object(b.a)(function(t){return null!=t&&oo(t.length)?t.length:NaN}),ro=c(function(t,e){return function(n){return function(o){return U(function(t){return e(t,o)},n(t(o)))}}}),bo=Object(b.a)(function(t){return ro(Vt(t),Ee(t))}),Mo=Object(b.a)(function(t){return ro(V(t),At(t))}),co=Object(b.a)(function(t){return ro(G(t),Ot(t))}),zo=c(function(t,e){return t=0;)r=t(r[0],n[o]),p[o]=r[1],o-=1;return[r[0],p]}),uo=c(function(t,e){return w(function(n,o){return n[o]=t(e[o],o,e),n},{},P(e))}),so=c(function(t,e){return e.match(t)||[]}),Ao=c(function(t,e){return ut(t)?!ut(e)||e<1?NaN:(t%e+e)%e:NaN}),lo=A(function(t,e,n){return t(n)>t(e)?n:e}),fo=K(z,0),qo=Object(b.a)(function(t){return fo(t)/t.length}),ho=Object(b.a)(function(t){var e=t.length;if(0===e)return NaN;var n=2-e%2,o=(e-n)/2;return qo(Array.prototype.slice.call(t,0).sort(function(t,e){return te?1:0}).slice(o,o+n))}),Wo=c(function(t,e){var n={};return a(e.length,function(){var o=t.apply(this,arguments);return x(o,n)||(n[o]=e.apply(this,arguments)),n[o]})}),mo=c(function(t,e){return In({},t,e)}),Ro=Object(b.a)(function(t){return In.apply(null,[{}].concat(t))}),vo=A(function(t,e,n){var o,p={};for(o in e)x(o,e)&&(p[o]=x(o,n)?t(o,e[o],n[o]):e[o]);for(o in n)x(o,n)&&!x(o,p)&&(p[o]=n[o]);return p}),yo=A(function t(e,n,o){return vo(function(n,o,p){return ae(o)&&ae(p)?t(e,o,p):e(n,o,p)},n,o)}),go=c(function(t,e){return yo(function(t,e,n){return e},t,e)}),Bo=c(function(t,e){return yo(function(t,e,n){return n},t,e)}),Lo=A(function(t,e,n){return yo(function(e,n,o){return t(n,o)},e,n)}),Xo=c(function(t,e){return In({},e,t)}),No=c(function(t,e){return In({},t,e)}),_o=A(function(t,e,n){return vo(function(e,n,o){return t(n,o)},e,n)}),So=c(function(t,e){return e=n.length||b<0||b>=n.length?n:[].concat(p.slice(0,b)).concat(M).concat(p.slice(b,n.length))}),Co=c(function(t,e){return t*e}),xo=Object(b.a)(function(t){return-t}),jo=c(function(t,e){return R(ze(t),e)}),ko=Object(b.a)(function(t){return u(t<0?1:t+1,function(){return Vt(t,arguments)})}),Fo=A(function(t,e,n){return t(e(n))});var Ho=Object(b.a)(function(t){return[t]}),Io=c(function(t,e){for(var n={},o={},p=0,r=t.length;p0&&t(V(e,n))}),np=c(function(t,e){for(var n={},o=0;o=0;)e=t(n[o],e),o-=1;return e}),dp=O(4,[],function(t,e,n,o){return w(function(n,o){return t(n,o)?e(n,o):h(n)},n,o)}),fp=Object(b.a)(h),qp=c(function(t,e){var n,o=Number(e),p=0;if(o<0||isNaN(o))throw new RangeError("n must be a non-negative number");for(n=new Array(o);pp?1:0})}),Bp=c(function(t,e){return Array.prototype.slice.call(e,0).sort(function(e,n){for(var o=0,p=0;0===o&&p=0&&t(e[n]);)n-=1;return xt(n+1,1/0,e)}),xp=function(){function t(t,e){this.xf=e,this.f=t}return t.prototype["@@transducer/init"]=W.init,t.prototype["@@transducer/result"]=W.result,t.prototype["@@transducer/step"]=function(t,e){return this.f(e)?this.xf["@@transducer/step"](t,e):h(t)},t}(),jp=c(q(["takeWhile"],c(function(t,e){return new xp(t,e)}),function(t,e){for(var n=0,o=e.length;n1)for(var n=1;n1&&void 0!==arguments[1]?arguments[1]:null,n=e.minimal,o=void 0!==n&&n,p=e.noSeconds,r=void 0!==p&&p;if(b.a.isMoment(t)||(t=b()(t)),o){var M=b()().diff(t,"seconds"),c=b()().diff(t,"minutes"),z=b()().diff(t,"hours"),i=b()().diff(t,"days");return c<1?r?"1m":"".concat(M,"s"):z<1?"".concat(c,"m"):i<1?"".concat(z,"h"):t.year()===b()().year()?t.format("MMM D"):t.format("ll")}return b()().diff(t,"hours")<24?t.fromNow():t.format("LLL")}function s(t){var e,n,o;return(o=null===(e=t.original)||void 0===e?void 0:null===(n=e.user)||void 0===n?void 0:n.profile_image_url_https)||(o="/dummyAvatar.jpg"),o}function A(t){var e=M.default.span.withConfig({displayName:"utils__Span",componentId:"nq5gy5-0"})(["color:#0084B4;"]);return z()(t,/(([@#])([a-z\d_]+))/gi,function(t,n,o,r,b,M){var c="@"===o?"https://twitter.com/".concat(r):"https://twitter.com/hashtag/".concat(r);return p.a.createElement(e,{key:d()},p.a.createElement("a",{key:d(),href:c,target:"_blank"},n))})}var l=function(t,e,n){var o,p,r=null===(o=t.original)||void 0===o?void 0:null===(p=o.entities)||void 0===p?void 0:p.media;return r&&r.forEach(function(o,p){var r=o.sizes.small.w,b=o.sizes.small.h,M=o.media_url_https,c=e({src:M,w:r,h:b},t,p);n=z()(n,o.url,c)}),n};function d(){return Math.floor(1e3*Math.random())+1}},function(t,e,n){var o=n(113);t.exports=function(t){return Object(o(t))}},function(t,e,n){"use strict";var o=n(0),p=n.n(o),r=n(5),b=n(131),M=r.default.section.withConfig({displayName:"SbBox__SbBoxWrap",componentId:"s13wx3g3-0"})(["margin-top:20px;"]);e.a=function(t){return p.a.createElement(M,null,p.a.createElement(b.a,null,t.children))}},function(t,e,n){"use strict";e.__esModule=!0,e.default=function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}},function(t,e,n){"use strict";e.__esModule=!0,e.default=function(t,e){var n={};for(var o in t)e.indexOf(o)>=0||Object.prototype.hasOwnProperty.call(t,o)&&(n[o]=t[o]);return n}},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o=n(1426);Object.keys(o).forEach(function(t){"default"!==t&&"__esModule"!==t&&Object.defineProperty(e,t,{enumerable:!0,get:function(){return o[t]}})});var p=n(1423);Object.keys(p).forEach(function(t){"default"!==t&&"__esModule"!==t&&Object.defineProperty(e,t,{enumerable:!0,get:function(){return p[t]}})})},function(t,e){e.f={}.propertyIsEnumerable},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.screenSize=void 0;var o=n(1404);e.screenSize=o.screenSize},function(t,e,n){"use strict";n.d(e,"b",function(){return b}),n.d(e,"c",function(){return M}),n.d(e,"a",function(){return c}),n.d(e,"d",function(){return z});var o=n(0),p=n.n(o),r=n(12),b=(n(38),function(){return p.a.createElement(r.Trans,{id:"SearchNotFound"})}),M=function(){return p.a.createElement(r.Trans,{id:"supportTargets.header"})},c=function(){return p.a.createElement(r.Trans,{id:"reportBtn.itemOther"})},z=function(){return p.a.createElement(r.Trans,{id:"thanksForReport"})}},function(t,e,n){var o=n(1187),p=function(){return!this}();function r(t,e){this.name="AuthTokenExpiredError",this.message=t,this.expiry=e,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function b(t){this.name="AuthTokenInvalidError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function M(t,e){this.name="AuthTokenNotBeforeError",this.message=t,this.date=e,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function c(t){this.name="AuthTokenError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function z(t,e){this.name="SilentMiddlewareBlockedError",this.message=t,this.type=e,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function i(t){this.name="InvalidActionError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function a(t){this.name="InvalidArgumentsError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function O(t){this.name="InvalidOptionsError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function u(t){this.name="InvalidMessageError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function s(t,e){this.name="SocketProtocolError",this.message=t,this.code=e,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function A(t){this.name="ServerProtocolError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function l(t){this.name="HTTPServerError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function d(t){this.name="ResourceLimitError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function f(t){this.name="TimeoutError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function q(t,e){this.name="BadConnectionError",this.message=t,this.type=e,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function h(t){this.name="BrokerError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function W(t,e){this.name="ProcessExitError",this.message=t,this.code=e,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}function m(t){this.name="UnknownError",this.message=t,Error.captureStackTrace&&!p?Error.captureStackTrace(this,arguments.callee):this.stack=(new Error).stack}r.prototype=Object.create(Error.prototype),b.prototype=Object.create(Error.prototype),M.prototype=Object.create(Error.prototype),c.prototype=Object.create(Error.prototype),z.prototype=Object.create(Error.prototype),i.prototype=Object.create(Error.prototype),a.prototype=Object.create(Error.prototype),O.prototype=Object.create(Error.prototype),u.prototype=Object.create(Error.prototype),s.prototype=Object.create(Error.prototype),A.prototype=Object.create(Error.prototype),l.prototype=Object.create(Error.prototype),d.prototype=Object.create(Error.prototype),f.prototype=Object.create(Error.prototype),q.prototype=Object.create(Error.prototype),h.prototype=Object.create(Error.prototype),W.prototype=Object.create(Error.prototype),m.prototype=Object.create(Error.prototype),t.exports={AuthTokenExpiredError:r,AuthTokenInvalidError:b,AuthTokenNotBeforeError:M,AuthTokenError:c,SilentMiddlewareBlockedError:z,InvalidActionError:i,InvalidArgumentsError:a,InvalidOptionsError:O,InvalidMessageError:u,SocketProtocolError:s,ServerProtocolError:A,HTTPServerError:l,ResourceLimitError:d,TimeoutError:f,BadConnectionError:q,BrokerError:h,ProcessExitError:W,UnknownError:m},t.exports.socketProtocolErrorStatuses={1001:"Socket was disconnected",1002:"A WebSocket protocol error was encountered",1003:"Server terminated socket because it received invalid data",1005:"Socket closed without status code",1006:"Socket hung up",1007:"Message format was incorrect",1008:"Encountered a policy violation",1009:"Message was too big to process",1010:"Client ended the connection because the server did not comply with extension requirements",1011:"Server encountered an unexpected fatal condition",4000:"Server ping timed out",4001:"Client pong timed out",4002:"Server failed to sign auth token",4003:"Failed to complete handshake",4004:"Client failed to save auth token",4005:"Did not receive #handshake from client before timeout",4006:"Failed to bind socket to message broker",4007:"Client connection establishment timed out",4008:"Server rejected handshake from client"},t.exports.socketProtocolIgnoreStatuses={1000:"Socket closed normally",1001:"Socket hung up"};var R={domain:1,domainEmitter:1,domainThrown:1};t.exports.dehydrateError=function(t,e){var n;if(t&&"object"==typeof t)for(var p in n={message:t.message},e&&(n.stack=t.stack),t)R[p]||(n[p]=t[p]);else n="function"==typeof t?"[function "+(t.name||"anonymous")+"]":t;return o(n)},t.exports.hydrateError=function(t){var e=null;if(null!=t)if("object"==typeof t)for(var n in e=new Error(t.message),t)t.hasOwnProperty(n)&&(e[n]=t[n]);else e=t;return e},t.exports.decycle=o},function(t,e){var n=0,o=Math.random();t.exports=function(t){return"Symbol(".concat(void 0===t?"":t,")_",(++n+o).toString(36))}},function(t,e,n){var o=n(50),p=n(43),r="[object Symbol]";t.exports=function(t){return"symbol"==typeof t||p(t)&&o(t)==r}},function(t,e,n){var o=n(27),p=n(118),r=n(1286),b=n(1283);t.exports=function(t,e){return o(t)?t:p(t,e)?[t]:r(b(t))}},function(t,e,n){var o=n(1309);t.exports=function(t,e){var n=t.__data__;return o(e)?n["string"==typeof e?"string":"hash"]:n.map}},function(t,e,n){var o=n(49)(Object,"create");t.exports=o},function(t,e,n){var o=n(65);t.exports=function(t,e){for(var n=t.length;n--;)if(o(t[n][0],e))return n;return-1}},function(t,e,n){var o=n(1331),p=n(1330),r=n(1329),b=n(1328),M=n(1327);function c(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e-1&&t%1==0&&t=0&&(t._idleTimeoutId=setTimeout(function(){t._onTimeout&&t._onTimeout()},e))},n(92),e.setImmediate="undefined"!=typeof self&&self.setImmediate||void 0!==t&&t.setImmediate||this&&this.setImmediate,e.clearImmediate="undefined"!=typeof self&&self.clearImmediate||void 0!==t&&t.clearImmediate||this&&this.clearImmediate}).call(this,n(21))},function(t,e,n){"use strict";var o=n(1212)(!0);n(296)(String,"String",function(t){this._t=String(t),this._i=0},function(){var t,e=this._t,n=this._i;return n>=e.length?{value:void 0,done:!0}:(t=o(e,n),this._i+=t.length,{value:t,done:!1})})},function(t,e,n){"use strict";e.__esModule=!0;var o=b(n(1453)),p=b(n(1449)),r=b(n(137));function b(t){return t&&t.__esModule?t:{default:t}}e.default=function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+(void 0===e?"undefined":(0,r.default)(e)));t.prototype=(0,p.default)(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(o.default?(0,o.default)(t,e):t.__proto__=e)}},function(t,e,n){"use strict";e.__esModule=!0;var o,p=n(137),r=(o=p)&&o.__esModule?o:{default:o};e.default=function(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!==(void 0===e?"undefined":(0,r.default)(e))&&"function"!=typeof e?t:e}},function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var o={};Object.defineProperty(e,"default",{enumerable:!0,get:function(){return r.default}});var p,r=(p=n(1422))&&p.__esModule?p:{default:p},b=n(144);Object.keys(b).forEach(function(t){"default"!==t&&"__esModule"!==t&&(Object.prototype.hasOwnProperty.call(o,t)||Object.defineProperty(e,t,{enumerable:!0,get:function(){return b[t]}}))})},function(t,e,n){"use strict";t.exports=n(1424)},function(t,e,n){"use strict";var o={},p={},r={},b={},M={};function c(t){return String(t).padStart(3,"0")}function z(t){return r[t]}function i(t){return p[t]}function a(t){var e=c(t);return i(b[e])}function O(t){var e=c(t);return b[e]}function u(t){if("string"==typeof t){if(/^[0-9]*$/.test(t))return O(t);if(2===t.length)return t.toUpperCase();if(3===t.length)return z(t.toUpperCase())}if("number"==typeof t)return O(t)}n(1361).forEach(function(t){var e=t;p[e[0]]=e[1],r[e[1]]=e[0],b[e[2]]=e[0],M[e[0]]=e[2]}),e.registerLocale=function(t){if(!t.locale)throw new TypeError("Missing localeData.locale");if(!t.countries)throw new TypeError("Missing localeData.countries");o[t.locale]=t.countries},e.alpha3ToAlpha2=z,e.alpha2ToAlpha3=i,e.alpha3ToNumeric=function(t){return M[z(t)]},e.alpha2ToNumeric=function(t){return M[t]},e.numericToAlpha3=a,e.numericToAlpha2=O,e.toAlpha3=function(t){if("string"==typeof t){if(/^[0-9]*$/.test(t))return a(t);if(2===t.length)return i(t.toUpperCase());if(3===t.length)return t.toUpperCase()}if("number"==typeof t)return a(t)},e.toAlpha2=u,e.getName=function(t,e){try{return o[e.toLowerCase()][u(t)]}catch(t){return}},e.getNames=function(t){var e=o[t.toLowerCase()];return void 0===e?{}:e},e.getAlpha2Code=function(t,e){try{var n,p=o[e.toLowerCase()];for(n in p)if(p.hasOwnProperty(n)&&p[n].toLowerCase()===t.toLowerCase())return n;return}catch(t){return}},e.getAlpha2Codes=function(){return p},e.getAlpha3Code=function(t,e){var n=this.getAlpha2Code(t,e);return n?this.toAlpha3(n):void 0},e.getAlpha3Codes=function(){return r},e.getNumericCodes=function(){return b},e.langs=function(){return Object.keys(o)}},function(t,e,n){var o=n(1);t.exports=function(t){for(var e=1;e2!=!0&&t.setState({firstQueryComplete:!1}),(null===(n=t.state)||void 0===n?void 0:n.query.length)>2&&!t.startsWithNotFound(t.state.query)?t.getInfo():t.setState({data:null})})}},{key:"handleInputBlur",value:function(){this.setState({showSearch:!1})}},{key:"handleButtonClick",value:function(){this.setState(function(t){return{showSearch:!t.showSearch}}),this.input.focus()}},{key:"render",value:function(){var t,e,n,o=this;return A.a.createElement(U,null,A.a.createElement(V,{type:"text",placeholder:"Service name...",spellCheck:!1,ref:function(t){return o.input=t},expanded:this.state.showSearch,onChange:function(){return o.handleInputChange()},onBlur:function(){return o.handleInputBlur()}}),this.state.showSearch&&(null===(t=this.state.query)||void 0===t?void 0:t.length)>2&&this.state.firstQueryComplete&&A.a.createElement(G,{onMouseDown:function(t){return t.preventDefault()}},(null===(e=this.state)||void 0===e?void 0:null===(n=e.data)||void 0===n?void 0:n.results.length)?this.state.data.results.map(function(t){return A.a.createElement("div",{key:t.name},A.a.createElement(Y,{href:Object(P.b)(o.props.langCode,t.url)},t.prettyName))}):A.a.createElement("p",null,A.a.createElement(I.b,null),' "',this.state.query,'"')),A.a.createElement(H,{onMouseDown:function(t){t.preventDefault(),o.handleButtonClick()}},A.a.createElement("i",{className:"fa ".concat(this.state.showSearch?"fa-close":"fa-search"),"aria-hidden":"true"})))}}]),e}(A.a.Component),$=K=Object(B.connectToStores)(K,["CommonStore"],function(t,e){return{website:t.getStore("CommonStore").getWebsite(),langCode:t.getStore("CommonStore").getLangCode()}}),Q=Object(L.default)(H).withConfig({displayName:"Lang__Link",componentId:"s15qdq31-0"})(["display:flex;align-items:center;"]),J=L.default.i.attrs({className:"fa fa-caret-down","aria-hidden":"true"}).withConfig({displayName:"Lang__CaretDown",componentId:"s15qdq31-1"})(["font-size:15px;margin-left:3px;"]),Z=Object(L.default)(D).withConfig({displayName:"Lang__DropDownWrap",componentId:"s15qdq31-2"})(["min-width:200px;"]),tt=function(t){function e(){var t,n;p()(this,e);for(var o=arguments.length,r=new Array(o),b=0;b *{margin-left:30px;}"]),bt=Object(L.default)(H).withConfig({displayName:"Nav__LogoNavLink",componentId:"s1la68cx-4"})(["font-size:25px;"]),Mt=(L.default.div.withConfig({displayName:"Nav__EndElWrap",componentId:"s1la68cx-5"})([""]),function(t){var e=t.website,n=t.urlCreator,o=t.langCode,p=Object(P.b)(o),r=p(n.getIndexUrl()),b=p(n.getCompaniesUrl());return A.a.createElement(nt,null,A.a.createElement(w,null,A.a.createElement(ot,null,A.a.createElement(pt,null,A.a.createElement(bt,{href:r},A.a.createElement(_,null),e.title)),A.a.createElement(rt,null,A.a.createElement(H,{href:b},A.a.createElement(X.Trans,{id:"navbar.companies"})),A.a.createElement($,null),A.a.createElement(et,null)))))}),ct=Mt=Object(B.connectToStores)(Mt,["CommonStore"],function(t,e){return{website:t.getStore("CommonStore").getWebsite(),urlCreator:t.getStore("CommonStore").getUrlCreator(),langCode:t.getStore("CommonStore").getLangCode()}});n.d(e,"a",function(){return it}),n.d(e,"b",function(){return at}),n(2038);var zt=function(t){function e(){return p()(this,e),c()(this,i()(e).apply(this,arguments))}return O()(e,t),b()(e,[{key:"render",value:function(){return A.a.createElement("div",{id:"wrap"},A.a.createElement(ct,null),A.a.createElement(u.Container,null,this.props.children),A.a.createElement(g,{website:this.props.website}))}}]),e}(A.a.Component);zt=Object(B.connectToStores)(zt,["CommonStore"],function(t,e){return{website:t.getStore("CommonStore").getWebsite(),urlCreator:t.getStore("CommonStore").getUrlCreator(),currentPage:t.getStore("CommonStore").getCurrentPage()}});e.c=zt;var it=q,at=W},function(t,e,n){"use strict";n(0);var o=n(5).default.header.withConfig({displayName:"SbBoxHeader",componentId:"s1wr1o9x-0"})(["font-size:18px;font-weight:500;line-height:1.1;margin-bottom:10px;"]);e.a=o},function(t,e,n){function o(t){if(t)return function(t){for(var e in o.prototype)t[e]=o.prototype[e];return t}(t)}t.exports=o,o.prototype.on=o.prototype.addEventListener=function(t,e){return this._callbacks=this._callbacks||{},(this._callbacks["$"+t]=this._callbacks["$"+t]||[]).push(e),this},o.prototype.once=function(t,e){function n(){this.off(t,n),e.apply(this,arguments)}return n.fn=e,this.on(t,n),this},o.prototype.off=o.prototype.removeListener=o.prototype.removeAllListeners=o.prototype.removeEventListener=function(t,e){if(this._callbacks=this._callbacks||{},0==arguments.length)return this._callbacks={},this;var n,o=this._callbacks["$"+t];if(!o)return this;if(1==arguments.length)return delete this._callbacks["$"+t],this;for(var p=0;p0?o:n)(t)}},function(t,e){t.exports=function(t){if(void 0==t)throw TypeError("Can't call method on "+t);return t}},function(t,e,n){var o=n(57);t.exports=function(t,e){if(!o(t))return t;var n,p;if(e&&"function"==typeof(n=t.toString)&&!o(p=n.call(t)))return p;if("function"==typeof(n=t.valueOf)&&!o(p=n.call(t)))return p;if(!e&&"function"==typeof(n=t.toString)&&!o(p=n.call(t)))return p;throw TypeError("Can't convert object to primitive value")}},function(t,e,n){var o=n(330),p=n(1248),r=n(66);t.exports=function(t){return r(t)?o(t,!0):p(t)}},function(t,e,n){var o=n(328)(Object.getPrototypeOf,Object);t.exports=o},function(t,e,n){var o=n(310);t.exports=function(t,e,n){"__proto__"==e&&o?o(t,e,{configurable:!0,enumerable:!0,value:n,writable:!0}):t[e]=n}},function(t,e,n){var o=n(27),p=n(82),r=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,b=/^\w*$/;t.exports=function(t,e){if(o(t))return!1;var n=typeof t;return!("number"!=n&&"symbol"!=n&&"boolean"!=n&&null!=t&&!p(t))||b.test(t)||!r.test(t)||null!=e&&t in Object(e)}},function(t,e,n){var o=n(83),p=n(64);t.exports=function(t,e){for(var n=0,r=(e=o(e,t)).length;null!=t&&n-1&&t%1==0&&t<=n}},function(t,e,n){var o=n(1341),p=n(1340),r=n(1339),b=r&&r.isTypedArray,M=b?p(b):o;t.exports=M},function(t,e,n){(function(t){var o=n(36),p=n(1342),r="object"==typeof e&&e&&!e.nodeType&&e,b=r&&"object"==typeof t&&t&&!t.nodeType&&t,M=b&&b.exports===r?o.Buffer:void 0,c=(M?M.isBuffer:void 0)||p;t.exports=c}).call(this,n(62)(t))},function(t,e,n){var o=n(330),p=n(1338),r=n(66);t.exports=function(t){return r(t)?o(t):p(t)}},function(t,e,n){var o=n(1349),p=n(332),r=n(1335),b=n(27);t.exports=function(t,e){return(b(t)?o:p)(t,r(e))}},function(t,e){t.exports=function(t){return!!t&&("object"==typeof t||"function"==typeof t)&&"function"==typeof t.then}},function(t,e,n){"use strict";var o=n(8),p=n.n(o),r=n(7),b=n.n(r),M=n(11),c=n.n(M),z=n(10),i=n.n(z),a=n(9),O=n.n(a),u=n(0),s=n.n(u),A=(n(6),n(14),function(t){function e(t){var n;return p()(this,e),(n=c()(this,i()(e).call(this,t))).state={error:null},n}return O()(e,t),b()(e,[{key:"componentDidCatch",value:function(t,e){this.setState({error:t}),Raven.captureException(t,{extra:e})}},{key:"render",value:function(){return this.state.error?s.a.createElement("h4",null,"Something went wrong."):this.props.children}}]),e}(s.a.Component));e.a=A},function(t,e,n){"use strict";var o=n(28),p=n.n(o),r=n(45),b=n.n(r),M=n(4),c=n(38),z=function(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:null,p=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,r="serviceId="+String(t)+"&langCode="+e;return n&&(r+="&oSubjectId="+String(n)),o&&(r+="&text="+o),p&&(r+="&socketId="+String(p)),new Promise(function(t,e){var n=new XMLHttpRequest;n.open("POST",c.default.reportPostUrl),n.setRequestHeader("Content-Type","application/x-www-form-urlencoded"),n.onload=function(){if(200===n.status)t();else{var o=new Error("XHR request returned bad status code: ".concat(n.status));o.name="BadStatus",o.statusCode=n.status,o.xhr=n,e(o)}},n.send(encodeURI(r))})};e.a={sendReportWithSubject:function(){var t=b()(p.a.mark(function t(e,n){var o,r,b,c,i;return p.a.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return o=n.serviceId,r=n.oSubjectId,b=n.text,c=n.socketId,i=n.langCode,t.prev=1,t.next=4,z(o,i,r,b,c);case 4:e.dispatch(M.a.SEND_REPORT_SUCCESS),t.next=10;break;case 7:t.prev=7,t.t0=t.catch(1),console.error(t.t0.message);case 10:case"end":return t.stop()}},t,this,[[1,7]])}));return function(e,n){return t.apply(this,arguments)}}(),changeDate:function(){var t=b()(p.a.mark(function t(e,n){var o,r,b,c,z;return p.a.wrap(function(t){for(;;)switch(t.prev=t.next){case 0:return o=n.service,r=n.dateMTz,b=void 0===r?null:r,c=o._id,e.dispatch(M.a.CHANGE_DATE_START,b),e.dispatch(M.a.FETCH_CHART_DATA_START),e.dispatch(M.a.FETCH_MAP_DATA_START),z=b?b.format():void 0,t.next=8,Promise.all([e.service.read("chart",{serviceId:c,dateStr:z}).then(function(t){return e.dispatch(M.a.FETCH_CHART_DATA_SUCCESS,t.data)}),e.service.read("map",{serviceId:c,dateStr:z},{xhrTimeout:1e4}).then(function(t){e.dispatch(M.a.FETCH_MAP_DATA_SUCCESS,t.data)}),e.service.read("DominantMessageData",{service:{_id:o._id,country:o.country},dateStr:z},{timeout:2e4}).then(function(t){var n=t.data.dominantData;return e.dispatch(M.a.FETCH_DOMINANT_DATA_SUCCESS,n)})]);case 8:return t.abrupt("return",e.dispatch(M.a.CHANGE_DATE_SUCCESS));case 9:case"end":return t.stop()}},t,this)}));return function(e,n){return t.apply(this,arguments)}}(),loadTweets:function(t,e,n){t.dispatch(M.a.LOAD_TWEETS_START),t.service.read("tweets",e,{timeout:2e4},function(e,o){if(e||!o)return t.dispatch(M.a.LOAD_TWEETS_FAILURE,e),n(e);t.dispatch(M.a.LOAD_TWEETS_SUCCESS,o),n(null,o)})},showNewTweets:function(t,e,n){t.dispatch(M.a.SHOW_NEW_TWEETS),n()},showMoreIncidentsByDate:function(t,e,n){t.dispatch(M.a.FETCH_INCIDENTS_BY_DATE_START),t.service.read("IncidentsByDate",e,{timeout:2e4},function(e,n){e?t.dispatch(M.a.FETCH_INCIDENTS_BY_DATE_FAILURE,e):t.dispatch(M.a.FETCH_INCIDENTS_BY_DATE_SUCCESS,n.incidentServices)}),n()}}},function(t,e,n){var o=n(52),p=n(1210),r=n(109),b=n(111)("IE_PROTO"),M=function(){},c=function(){var t,e=n(299)("iframe"),o=r.length;for(e.style.display="none",n(1209).appendChild(e),e.src="javascript:",(t=e.contentWindow.document).open(),t.write("