diff --git a/analysis/Analysis Output - HTML Files/analysis7_OLS_NRB_ITS_2021.html b/analysis/Analysis Output - HTML Files/analysis8_OLS_NRB_ITS_2021.html similarity index 100% rename from analysis/Analysis Output - HTML Files/analysis7_OLS_NRB_ITS_2021.html rename to analysis/Analysis Output - HTML Files/analysis8_OLS_NRB_ITS_2021.html diff --git a/analysis/Analysis Output - HTML Files/analysis9-2021.pdf b/analysis/Analysis Output - HTML Files/analysis9-2021.pdf new file mode 100644 index 0000000..bf1fcf5 Binary files /dev/null and b/analysis/Analysis Output - HTML Files/analysis9-2021.pdf differ diff --git a/analysis/analysis9-2021.ipynb b/analysis/analysis9-2021.ipynb new file mode 100644 index 0000000..fbcfb89 --- /dev/null +++ b/analysis/analysis9-2021.ipynb @@ -0,0 +1,1065 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1b85622b", + "metadata": {}, + "source": [ + "# Colorado Spills \n", + "## OLS, NBR, Interrupted Time Series Analysis\n", + "## Just top 3 Counties\n", + "### Author: [David P. Adams, PhD](https://dadams.io)\n", + "#### Date: 2025-07-02" + ] + }, + { + "cell_type": "markdown", + "id": "d456a510", + "metadata": {}, + "source": [ + "---\n" + ] + }, + { + "cell_type": "markdown", + "id": "9814ecd7", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "eba79ece", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dadams/miniconda3/envs/spatial_env2/lib/python3.10/site-packages/pandas/io/sql.py:1725: SAWarning: Did not recognize type 'geometry' of column 'geometry'\n", + " self.meta.reflect(bind=self.con, only=[table_name], views=True)\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "from sqlalchemy import create_engine\n", + "import geopandas as gpd\n", + "from dotenv import load_dotenv\n", + "load_dotenv()\n", + "\n", + "import os\n", + "\n", + "# Database connection details from zshrc environment variables\n", + "# use .env file for local development\n", + "\n", + "\n", + "db_name = 'colorado_spills'\n", + "user = os.getenv('DB_USER')\n", + "password = os.getenv('DB_PASSWORD')\n", + "host = os.getenv('DB_HOST')\n", + "port = os.getenv('DB_PORT')\n", + "\n", + "\n", + "# Create an engine to connect to the PostgreSQL database\n", + "engine = create_engine(f'postgresql+psycopg2://{user}:{password}@{host}:{port}/{db_name}')\n", + "\n", + "# Read in the spills_with_demographics_geog as spills\n", + "spills = pd.read_sql_table('spills_with_demographics_geog', engine)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "da21b89e", + "metadata": {}, + "outputs": [], + "source": [ + "# use longitude and latitude to create a GeoDataFrame from spills data\n", + "spills['geometry'] = gpd.points_from_xy(spills['Longitude'], spills['Latitude'])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "789eaccb", + "metadata": {}, + "outputs": [], + "source": [ + "spills_gdf = gpd.GeoDataFrame(spills, crs='EPSG:4326') \n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d041a419", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Ensure date columns are in datetime format\n", + "spills_gdf['Date of Discovery'] = pd.to_datetime(spills_gdf['Date of Discovery'])\n", + "spills_gdf['Initial Report Date'] = pd.to_datetime(spills_gdf['Initial Report Date'])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3106f3c5", + "metadata": {}, + "outputs": [], + "source": [ + "# keep only records where year is between 2017 and 2023 (inclusive)\n", + "spills_gdf = spills_gdf[\n", + " (spills_gdf['Date of Discovery'].dt.year >= 2017) &\n", + " (spills_gdf['Date of Discovery'].dt.year < 2024) &\n", + " (spills_gdf['Initial Report Date'].dt.year >= 2017) &\n", + " (spills_gdf['Initial Report Date'].dt.year < 2024)\n", + "]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "139de8e5", + "metadata": {}, + "outputs": [], + "source": [ + "# Separate Historical vs. Recent Spills\n", + "historical_spills = spills_gdf[spills_gdf['Spill Type'] == 'Historical']\n", + "recent_spills = spills_gdf[spills_gdf['Spill Type'] == 'Recent']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "853ce353", + "metadata": {}, + "outputs": [], + "source": [ + "# only use the top 3 counties by number of spills\n", + "top_counties = spills_gdf['county'].value_counts().nlargest(3).index.tolist()\n", + "# filter spills_gdf to only include top counties\n", + "spills_gdf = spills_gdf[spills_gdf['county'].isin(top_counties)]\n", + "# filter historical spills to only include top counties\n", + "historical_spills = historical_spills[historical_spills['county'].isin(top_counties)]\n", + "# filter recent spills to only include top counties\n", + "recent_spills = recent_spills[recent_spills['county'].isin(top_counties)]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1327b4ea", + "metadata": {}, + "outputs": [], + "source": [ + "import statsmodels.formula.api as smf\n", + "\n", + "# Create 'Period' column\n", + "spills_gdf['Period'] = spills_gdf['Report Year'].apply(lambda x: 'Before 2020' if x < 2020 else '2020 and After')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2ccf5c3a", + "metadata": {}, + "outputs": [], + "source": [ + "spills_gdf = spills_gdf.rename(columns={\n", + " 'Report Delay (Days)': 'report_delay',\n", + " 'Spill Type': 'spill_type'\n", + "})\n" + ] + }, + { + "cell_type": "markdown", + "id": "1da721cd", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "1b9a3766", + "metadata": {}, + "source": [ + "# OLS Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1b722ad7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: report_delay R-squared: 0.001\n", + "Model: OLS Adj. R-squared: 0.001\n", + "Method: Least Squares F-statistic: 2.895\n", + "Date: Wed, 02 Jul 2025 Prob (F-statistic): 0.0339\n", + "Time: 12:54:40 Log-Likelihood: -40805.\n", + "No. Observations: 9087 AIC: 8.162e+04\n", + "Df Residuals: 9083 BIC: 8.165e+04\n", + "Df Model: 3 \n", + "Covariance Type: nonrobust \n", + "====================================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "--------------------------------------------------------------------------------------------------------------------\n", + "Intercept 3.6818 0.454 8.117 0.000 2.793 4.571\n", + "C(spill_type)[T.Recent] -1.1410 0.589 -1.938 0.053 -2.295 0.013\n", + "C(Period)[T.Before 2020] -0.4169 0.773 -0.539 0.590 -1.932 1.098\n", + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020] -0.2081 0.969 -0.215 0.830 -2.107 1.691\n", + "==============================================================================\n", + "Omnibus: 24587.315 Durbin-Watson: 1.954\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 1077831771.927\n", + "Skew: 33.014 Prob(JB): 0.00\n", + "Kurtosis: 1688.924 Cond. No. 7.42\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n" + ] + } + ], + "source": [ + "import statsmodels.formula.api as smf\n", + "\n", + "model = smf.ols(\"report_delay ~ C(spill_type) * C(Period)\", data=spills_gdf).fit()\n", + "print(model.summary())\n" + ] + }, + { + "cell_type": "markdown", + "id": "0cef322c", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "ee48e488", + "metadata": {}, + "source": [ + "# Negative Binomial Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "813a6d9c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Generalized Linear Model Regression Results \n", + "==============================================================================\n", + "Dep. Variable: report_delay No. Observations: 9087\n", + "Model: GLM Df Residuals: 9083\n", + "Model Family: NegativeBinomial Df Model: 3\n", + "Link Function: Log Scale: 1.0000\n", + "Method: IRLS Log-Likelihood: -19592.\n", + "Date: Wed, 02 Jul 2025 Deviance: 19541.\n", + "Time: 12:54:40 Pearson chi2: 3.97e+05\n", + "No. Iterations: 8 Pseudo R-squ. (CS): 0.04240\n", + "Covariance Type: nonrobust \n", + "====================================================================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "--------------------------------------------------------------------------------------------------------------------\n", + "Intercept 1.3034 0.024 54.986 0.000 1.257 1.350\n", + "C(spill_type)[T.Recent] -0.3709 0.031 -11.830 0.000 -0.432 -0.309\n", + "C(Period)[T.Before 2020] -0.1202 0.041 -2.949 0.003 -0.200 -0.040\n", + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020] -0.1622 0.052 -3.101 0.002 -0.265 -0.060\n", + "====================================================================================================================\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dadams/miniconda3/envs/spatial_env2/lib/python3.10/site-packages/statsmodels/genmod/families/family.py:1367: ValueWarning: Negative binomial dispersion parameter alpha not set. Using default value alpha=1.0.\n", + " warnings.warn(\"Negative binomial dispersion parameter alpha not \"\n" + ] + } + ], + "source": [ + "import statsmodels.formula.api as smf\n", + "import statsmodels.api as sm\n", + "\n", + "# Make sure spill_type and Period are clean, and report_delay is numeric\n", + "spills_gdf = spills_gdf.rename(columns={\n", + " 'Report Delay (Days)': 'report_delay',\n", + " 'Spill Type': 'spill_type'\n", + "})\n", + "\n", + "# Fit the Negative Binomial model with interaction\n", + "nb_model = smf.glm(\n", + " formula=\"report_delay ~ C(spill_type) * C(Period)\",\n", + " data=spills_gdf,\n", + " family=sm.families.NegativeBinomial()\n", + ").fit()\n", + "\n", + "# View the results\n", + "print(nb_model.summary())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4343c273", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "object", + "type": "string" + }, + { + "name": "0", + "rawType": "float64", + "type": "float" + } + ], + "ref": "78c37b6f-ac8c-4540-88a3-b6745c911c6b", + "rows": [ + [ + "Intercept", + "3.681838267786129" + ], + [ + "C(spill_type)[T.Recent]", + "0.6900928211391695" + ], + [ + "C(Period)[T.Before 2020]", + "0.8867658690823642" + ], + [ + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020]", + "0.8502810395791129" + ] + ], + "shape": { + "columns": 1, + "rows": 4 + } + }, + "text/plain": [ + "Intercept 3.681838\n", + "C(spill_type)[T.Recent] 0.690093\n", + "C(Period)[T.Before 2020] 0.886766\n", + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020] 0.850281\n", + "dtype: float64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "np.exp(nb_model.params)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f09f08d0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAJNCAYAAAAs3xZxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAClzklEQVR4nOzdeZyN9fvH8feZGTPGrLYZxoyxR7bsa4yI9E2opERIpQilvqJUlPKlEqW0WduoZCnZsm8t1pAtxm4sgxnG7Ofz+8Nvbo6ZYQ5zzOL1fDzmwbnuz7nPdZ059z33de7NZowxAgAAAAAA2c4tpxMAAAAAACC/oukGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBoAM7N+/XzabTT169HCIR0REyGaz5UxSTipTpozKlCmT02nACT169JDNZtP+/ftzOpU89Vl3VkbLxpQpU2Sz2TRlypRrjoVrZbb+zY1cvczmpfcCQOZougHkqLQNist/PD09FRYWpi5duujvv//O6RSzVW5qqi6X1nBc/uPt7a1KlSqpX79+ioqKyukUb1hmTdW1DBs2zOF9cXd3V2BgoCpVqqROnTppypQpiouLc03St6g1a9aoU6dOKlWqlDw9PVW4cGFVrlxZXbp00dSpU3M6vXQyWo9d7YcmPnulrVcv//H391e9evX0wQcfKDk5OadTBHCL88jpBABAksqXL6+uXbtKks6fP6/ff/9d3333nX766SctXbpUjRs3zuEML5o2bZouXLiQ02m4TMuWLdW0aVNJ0qlTp7R06VKNHz9es2fP1saNG1W8ePEczjDnPPjgg6pWrZokKTY2Vvv379eyZcv0448/aujQofr6668VERGRs0nmA1OmTNETTzwhDw8P3XvvvapYsaLi4+O1b98+/frrr1q5cqW6d+9+Q6+xZMmSbMr2osDAQL3xxhsOsbNnz2rcuHEKDw9Pt5cyMDAwW18fF/Xq1UuhoaGy2+06fPiwfvrpJw0cOFDLli3T3LlzXfKaI0eO1ODBg1WqVCmXzB9A/kDTDSBXqFChgoYNG+YQGzp0qN5++229+uqrWrZsWc4kdoXSpUvndAou1apVKw0ePNh6bLfb1a5dO/36668aP368hg8fnoPZ5ayHHnpIjzzyiEMsMTFRH3zwgYYOHar77rtPa9euVY0aNXIow7zvwoUL6t+/v/z8/LRmzRrrS440ycnJWr58+Q2/Tvny5W94HpcLDAxMt/7av3+/xo0bpzJlyqSbBtd48skn1bBhQ+vxiBEjVKtWLf38889asWKFmjdvnu2vWbJkSZUsWTLb5wsgf+HwcgC5Vr9+/SRJf/31lxWz2WyKiIjQkSNH1KNHD5UoUUJubm4OG+IrV65Uu3btVKxYMXl5ealixYoaOnRohnuoU1NTNWrUKFWoUEEFCxZUhQoVNHLkSNnt9gxzutp5rnPnzlWbNm1UtGhRFSxYUGXKlFG3bt20bds2SRfPDU07NLZs2bLWYZBX7h2NjIzUk08+qdKlS8vLy0slS5ZUjx49dODAgQxfd86cOapXr568vb0VHBysp556SmfOnMn4TXWSm5ubtZduw4YN6aafOHFCL7zwgipUqCAvLy8VK1ZMDz74oFXz5dLOjT1z5oyeeuopBQcHy9vbW/Xr1890L9SFCxc0bNgwVa5cWQULFlSRIkX0n//8R2vXrk03Nu0w8OXLl2vq1KmqU6eOChUqpIiICPXo0UM9e/aUJPXs2dPhMNQb4eXlpcGDB+v1119XXFycwxcWac6dO6c33nhDVatWlbe3twIDA3XPPfdo9erVWXqNpKQkffTRR2rTpo3CwsLk5eWloKAgPfDAA9q0aZPD2MmTJ8tms+ndd9/NcF6//vqrbDabBgwYkOUaExISNGjQIIWFhalgwYKqXr26Jk2a5JLX3bZtm86dO6cWLVqka7glqUCBArr77rsdYpefNjBr1izVq1dPhQoVUokSJfTss89muCzk1Hna1/M+Xc9yY4zRpEmT1KRJE/n7+6tQoUKqW7duut/b1cTExGjUqFFq3ry5QkJC5OnpqZCQED3++OPau3dvuvGXL3/ff/+9ateuLW9vb5UsWVL9+/dXfHx8uuc4u/51VkhIiB544AFJjn9Hrme9dfbsWfXv319hYWHy8PCwTlO52ilDU6dOVcOGDeXr6ytfX181bNgw09MjXP1eAMhZ7OkGkGtl1hBFR0erUaNGKlKkiDp37qykpCT5+/tLkj799FP16dNHhQsXVrt27VS8eHH99ddfevvtt7Vs2TItW7ZMnp6e1ryefvppTZo0SWXLllXfvn2VkJCgMWPGZNjUXc2gQYP07rvvqkiRIurQoYOCgoJ06NAh/fbbb6pTp46qVaum559/XlOmTNGWLVs0YMAA6xDTyzf+//jjD7Vp00ZxcXFq166dKlSooP379+ubb77R/PnztW7dOpUrV84aP23aNHXv3l3+/v7q1q2bAgMD9csvv6hVq1ZKSkpyqPV6GWMkSR4ejn8y9u7da30B0rp1a3Xo0EEnTpzQzJkztXDhQi1ZskQNGjRweE5SUpJatWql+Ph4de/eXWfPntX06dPVoUMHffXVV3rsscessYmJiWrZsqV+//131a5dW88//7xOnDihGTNmaNGiRZoxY4a1QX25d999V8uWLdP999+vu+++Wx4eHqpbt67Onj2rOXPmqH379rrjjjtu+H253MCBAzVq1CgtXLhQZ8+etX63p0+fVrNmzbR9+3bdeeedatOmjWJiYjRnzhy1aNFCP/zwgzp06HDVeZ8+fVrPP/+87rzzTt17770qXLiw9u3bp7lz52r+/PlauXKl6tWrJ0nq3LmzXnjhBX355Zf673//m25eX375paSLewSzqlOnTvr777/VqVMnJScn6/vvv1evXr10/PhxDRkyJFtft0iRIpIufvFkt9vl5pb1fQM//vijFi9erE6dOqlVq1ZasWKFPv30U61bt07r1q2Tt7d3luflKtf7Pjmz3Bhj1LVrV3377beqVKmSunTpIk9PTy1evFi9evXSP//8o/fee++aue7YsUOvv/66WrRooY4dO8rHx0c7d+7Ut99+q3nz5mnjxo0KDw9P97yPP/5Y8+fPV/v27RUREaEFCxboo48+UnR0tL755huHsdm1/nXG9ay3EhMTddddd+ncuXNq166dPD09FRwcfNXXeeGFFzR27FiVKlVKvXr1ks1m08yZM9WjRw9t2bJFY8aMcRifE+8FgJvIAEAOioyMNJJMmzZt0k179dVXjSQTERFhxSQZSaZnz54mJSXFYfz27duNh4eHqVWrlomOjnaYNnLkSCPJvPfee1Zs2bJlRpKpWbOmOX/+vBU/fPiwKVasmJFkunfv7jCf5s2bmytXnfPmzTOSTPXq1c2pU6ccpiUnJ5uoqCjrcffu3Y0kExkZma7epKQkU6ZMGePn52c2b97sMG3VqlXG3d3d3HfffVYsJibG+Pv7Gx8fH7Nr1y6H+TRr1sxIMuHh4eleJyOTJ082kszIkSMd4ikpKaZNmzZGknn33XcdpjVu3Nh4eHiYRYsWOcR37dpl/Pz8TPXq1R3i4eHhRpK56667TFJSkhXfsWOH8fb2NoGBgSY2NtaKv/nmm0aSeeyxx4zdbrfiW7ZsMV5eXqZw4cIO49944w0jyfj4+Ji///470xonT56cpffkyvl+9913Vx135513GklmyZIlVqxLly5Gkpk0aZLD2KioKBMWFmaKFy9u4uPjrXhGn4+EhARz+PDhdK+3bds24+vra1q1auUQ79u3r5FkVqxY4RA/fvy4KVCggGnQoME1azbm0mf99ttvd3ifjx07ZkqWLGk8PDzM3r17s/V17Xa7qV27tpFkmjdvbiZPnmz++eefdMv65dJ+r5LMb7/95jCtZ8+eRpJ58803HeLh4eHplo3MPh8Zjc2KtHVb8+bNHeLOvk/OLjeff/65kWR69eplkpOTrXhiYqJp166dkWTWr19/zfzPnj2bbj1qjDFLly41bm5u5sknn3SIpy0nAQEBZufOnVb8woULplKlSsZms5kjR45Y8etZ/2YmbblZt26dQ/zIkSMmKCjISDLLly83xlz/eqt169bmwoULmb725cvsypUrjSRTpUoVc/bsWSt+9uxZU7lyZSPJrFq1yiXvBYDciaYbQI5K2zAtX768eeONN8wbb7xhXnzxRdOkSRMjyRQsWNCsXbvWGi/JeHp6mpMnT6abV//+/dNtzKRJTU01xYsXN3Xq1LFiaRvkM2fOTDf+rbfeynLTfe+99xpJZunSpdes92pN908//WQkmbfeeivD5z7wwAPGzc3NxMTEGGOMmTp1qpFk+vXrl27sqlWrrqvpbtmypfV7eO6558xtt91mJJmGDRs6bAxu3LjR2rDPyMCBA40ks3XrViuWtvG6Zs2adOPTGpGvvvrKipUrV84UKFDAHDp0KN343r17pxufttH/wgsvXLVGVzXdnTt3NpLMjBkzjDHGnDx50ri7u5uWLVtmOP7DDz80kszPP/9sxa72+chIu3btjKenp0Mz9vfffxtJplu3bg5jR48ebSSZL7/8MkvzTvusf/PNN+mmvfvuu+k+q9n1unv37jWNGjWyGmlJplChQqZly5Zm8uTJ6RrwtN/r3XffnW5eR44cMQUKFDDly5d3iOdk0+3s++TsclOjRg3j4+Pj8GXOla/94osvOl3P5apXr27KlCnjEEtbTl5//fV049OmzZ0714pdz/o3M2nLTa9evcwbb7xhXn/9ddOzZ08TEBBgJJn777/fGHNj660tW7Zc9bUvX2afeOIJh3XB5b777rt0OWTnewEgd+LwcgC5wt69e62LdBUoUEDBwcHq0qWLBg8erOrVqzuMLVu2rIoVK5ZuHr///rskacGCBfrtt9/STS9QoIB27txpPd6yZYsk6c4770w3NqNYZv788095eXnd8EV60vLfuXNnhhdeioqKkt1u1+7du1W3bt2r5t+oUaN0h4NnxZIlS9Jd2blRo0ZaunSpChYsmC7XqKioDHNNe5937tzpcG5ugQIFHC50lObOO+/Uxx9/rM2bN6tr166KjY3Vvn37VKVKFYWGhqYbHxERoc8++8waf7n69etnveBsZP7/MPw0f/31l1JTU5WQkJDhe7Rnzx5JF9+j++6776rz3rx5s0aPHq3Vq1crKioq3S2QTp06ZV3MqXr16mrUqJF+/PFHffTRRwoICJAkTZo0Sb6+vurcubNTdV1t+di8ebMVy67XLVeunNauXavNmzfrt99+019//aW1a9dan81p06Zp/vz58vLyumaeISEhKl++vHbu3Klz587Jz88vq2W7zPW8T1ldbi5cuKCtW7cqJCRE//vf/9KNT/vcXL4evJrly5dr7Nix+uOPP3Tq1CmlpKRY0zI7daV27drpYmnL8NmzZ61Ydq1/Lzdx4kTr/35+ftZt5p577jlJ17/eSruWQValXWsho7sZpMUuX3Zc8V4AyF1ougHkCm3atNGCBQuyNDazc+lOnz4tSXr77bezNJ+YmBi5ubll2MBf63y9y509e1alSpVy6vzTjKTlf+V5j1dKuyd0TEyMJCkoKCjdGHd3dxUtWtTpHNJuf2O327V//34NGzZMX331lZ566il99dVX6XKdN2+e5s2bd81c0xQtWjTD9ynt/U6rKTY21iF+pRIlSjiMz2heN9uxY8ckybqtWtp7tGbNGq1ZsybT513rHt9r167VXXfdJUlq3bq1KlasKF9fX9lsNs2ePVtbtmxRYmKiw3Oefvpp9ezZU99884369Omj1atXa+fOnXrqqafk6+vrVF0Zfb6u/H254nXvuOMOh3Pvly9frq5du2rZsmX65JNP9MILL1wzz7Rcd+7cqdjY2FzRdEvOv09ZXW7OnDkjY4yOHDly1TsNZOW+8j/88IM6d+4sX19ftWnTRmXKlFGhQoWsi9ZldmHHtC8RLpf2BWBqaqoVy6717+XWrVuX4ZcTaa53vRUUFOTURRdjY2Pl5uaW4S0Wg4OD5ebm5rDsuOK9AJC7cPVyAHlOZhs/aRdTi42Nlbl4+kyGP2kCAgJkt9t16tSpdPM6fvx4lvMJDAy09kLfiLT8f/7556vmn7ZHPW3j9sSJE+nmlZqaqujo6OvOxc3NTeXKldPUqVPVrFkzff3115o9e3a6XD/66KOr5nrl/ZSjo6MzfJ/S3u+0mtLmn9nvIS2eNu5yN3pF8utx/vx5rV+/Xu7u7taevrTcXnzxxau+R1fe3/lKb7/9thITE7VkyRLNnTtX77//voYPH65hw4ZZXz5cqXPnzgoMDLQuzJX271NPPeV0bRl9vq78fbnida8UERGht956S5K0dOnSLOV5ea4ZfVZyirPvk7PLTZ06da76mcvKLRiHDRumggULasOGDfrhhx/07rvvWp+7y496uV7Ztf51xvWut5xdp/j7+8tut+vkyZPppp04cUJ2u93h85gT7wWAm4umG0C+kXbF2bRDCK+lZs2akqRVq1alm5ZRLDP169dXYmKiVqxYcc2x7u7ukhz3+KRJy3/dunVZet2r5b9u3TqHQ0Gvl81m07hx42Sz2TRkyBArb2dzTZOcnJzh7yethrQ9m/7+/ipXrpz+/fdfHTlyJN34tPfamauQX+29v1Hvv/++4uPj1bZtW6sBqlevnmw2m9Pv0ZX27t2rIkWKqEmTJg7xCxcuaOPGjRk+x9vbW127dtWmTZu0YsUK/fDDD6pRo4Z1lXNnXG35uPL9z87XzYiPj49TeR49elR79+5V+fLlc81ebsn59ymry42fn5+qVKmiHTt2OBzKfT327t2rKlWqqGLFig7xtPf0RmXX+tcZ17veclatWrUkKcN7yme07sqJ9wLAzUXTDSDf6NOnjzw8PNSvXz8dOnQo3fSzZ8863Nf48ccflyS9+eabDocTHjlyROPGjcvy6/bt21eSNGDAAOvwxTQpKSkOeyrSbol0+PDhdPNp3769SpcurTFjxmjlypXppicnJzvc27l9+/by9/fXpEmTtHv3bodxQ4cOzXL+13LHHXeoQ4cO1u2CpItfNDRo0EDfffedZsyYke45drs90y8hXnvtNYdzknfu3KlJkyYpICBA7du3t+Ldu3dXcnKyhgwZ4nCEwrZt2zR58mQFBARc83Zbl7vae3+9EhMTNXr0aL355pvy9fXVyJEjrWklSpTQww8/rLVr1+rdd99Nd863dPEWcRndP/5y4eHhOnPmjLZv327FUlNT9dJLL2W4Jy1N7969JUldunTRhQsXrntv89tvv61z585Zj48fP64xY8bIw8NDXbp0ydbXjYyM1Pjx4x1eL01cXJy1XDZt2jTd9MWLF6e7HsHQoUOVnJycbs9lbuDs+5TV5aZ///7W/DI6jDwyMjLDe0pfKTw8XP/++6/D+ishIUHPPvtstnyhl13rX2fcyHrLGWmft+HDh1unykgXj8JKO+z/8s9kTrwXAG4uzukGkG9Uq1ZNn3zyiZ599lnddtttuvfee1W+fHnrolwrVqxQjx499Omnn0q6eLhqz549NXnyZFWvXl0dO3ZUYmKiZsyYoYYNG+qXX37J0uvee++9eumll/Tee++pYsWK6tixo4KCgnTkyBEtWbJEL730kp5//nlJ0l133aX33ntPvXv3VqdOneTj46PSpUurS5cu8vLy0o8//qi2bduqefPmatmypXUxn4MHD2rVqlUqWrSodbGfgIAAffjhh+rRo4fq1aunRx55RAEBAfrll1/k7e1tXVgrOwwbNkyzZ8/Wm2++qUcffVQeHh767rvv1KJFCz3yyCMaO3as6tSpo4IFC+rgwYNat26dTp48qYSEBIf5lCxZUmfPntUdd9yh//znP4qJidF3332nhIQEffHFFw57IwcNGqR58+bpq6++0o4dO9SyZUudPHlSM2bMUHJysqZNm+bU3stGjRrJ29tbY8eOVWxsrHW+5eDBg7P0/B9//NF678+fP6/IyEitWLFC0dHRCgsL09dff+1w8SVJ+uSTT7Rr1y4NGjRIX331lRo1aqSAgAAdOnRIGzZs0J49e3Ts2DEVKlQo09ft16+fFi1apKZNm+rhhx9WwYIFtXz5ch05ckQREREZ7k2TLi4PjRs31tq1a1WwYMF0F5zLqnLlyqlatWp68MEHrft0nzhxQm+//bbDPeOz43VjYmLUr18//fe//9Wdd96pqlWrytvbW0eOHNEvv/yi06dPq06dOurXr1+65/7nP//Rvffeq06dOiksLEwrVqzQunXrVLNmTb300kvXVbsrOfM+ObPc9O7dW7///rumTp2qNWvWqFWrVgoJCdHx48e1c+dO/fHHH/r2229VpkyZq+bXr18/9evXT7Vq1dJDDz2klJQULV68WMYY1axZ07r41/XKrvWvs65nveWsZs2aqV+/fvroo4+sZccYo59++kmHDh1S//791axZM2t8Tr0XAG6i7L8gOgBk3dXu050RZXALniv9+eef5pFHHjEhISGmQIECplixYqZ27dpm8ODBZseOHQ5jU1JSzMiRI025cuWMp6enKVeunHnnnXfMv//+m+VbhqWZOXOmadGihQkICDBeXl6mTJkyplu3bmbbtm0O40aPHm0qVqxoChQokGE9hw8fNgMGDDAVK1Y0Xl5ext/f31SpUsU8+eSTDveATjNr1ixTp04d4+XlZYKCgsyTTz5pTp8+7dStjjK7T/flHnzwQSPJTJw40YqdPn3aDB061FSrVs14e3sbX19fU7FiRdOlSxfz008/OTw/LZ/o6Gjz5JNPmqCgIOPl5WXq1q1r5syZk+Frnj9/3rz22mumUqVKxtPT0wQGBpq2bdtmeFu4tNsSLVu2LNMa5s2bZ+rVq2e8vb2t21FdS9p8037c3NyMv7+/qVChgnnooYfM5MmTTVxcXKbPv3Dhghk9erSpU6eO8fHxMd7e3qZs2bKmQ4cOZtq0aQ73Us7slmE//vijqV27tilUqJApVqyYefjhh83evXuveYuxzz77zEgyXbt2vWadV0r7rF+4cMG89NJLplSpUsbT09NUrVr1mrf/ut7XTUhIMDNnzjRPP/20qVmzpilWrJhxd3c3hQsXNk2bNjVjxoxJdyusy2/19dNPP5k6deqYggULmqCgINO7d+8M7zWdk7cMu1xW3qfrWW6MMWbGjBmmVatWpnDhwqZAgQKmVKlSJiIiwrz//vsZ3nLxSna73Xz66aematWqpmDBgqZEiRKmV69e5vjx4xmuB6+2/GX23jq7/s1MZvfpzsz1rLeu9doZLYOTJk0y9erVM4UKFTKFChUy9erVM5MmTcpwPtn1XgDInWzGZHC8GwAA2Sxtz1pWDm1F9ujTp48mTJigFStWOOxZy0+vO2XKFGsvYY8ePVz6WtktK+8Tyw0A5H2c0w0AQD508uRJTZs2TVWqVLmpDXdOvW5ew/sEALcOzukGACAfmTdvnjZu3Kgff/xRcXFx17wlWV5/3byG9wkAbj003QAA5CM//PCDpk6dqpCQEL3zzjvq3Llzvn7dvIb3CQBuPZzTDQAAAACAi3BONwAAAAAALnJLHF5ut9t19OhR+fn5yWaz5XQ6AAAAAIA8zhijc+fOKSQkRG5ume/PviWa7qNHjyosLCyn0wAAAAAA5DOHDh1SaGhoptNviabbz89P0sU3w9/fP4ezAQAAAADkdbGxsQoLC7P6zczcEk132iHl/v7+NN0AAAAAgGxzrVOYuZAaAAAAAAAuQtMNAAAAAICL0HQDAAAAAOAiNN0AAAAAALgITTcAAEAOGTlypOrVqyc/Pz8FBQWpQ4cO2rVrl8OY48ePq0ePHgoJCVGhQoV0zz33aM+ePVedb0REhGw2W7qf//znP5nmYbPZ9Pzzz2dXaQCA/0fTDQAAkENWrFihvn376vfff9fixYuVkpKi1q1bKy4uTpJkjFGHDh20b98+zZkzR5s2bVJ4eLhatWpljcnITz/9pGPHjlk/27Ztk7u7uzp16pRu7F9//aXPP/9cNWrUcFmdAHAruyVuGQYAAJAbLViwwOHx5MmTFRQUpA0bNqhZs2bas2ePfv/9d23btk1Vq1aVJH3yyScKCgrSd999pyeffDLD+RYpUsTh8fTp01WoUKF0Tff58+f12GOP6YsvvtCIESOysTIAQBr2dAMAAOQSMTExki41zYmJiZKkggULWmPc3d3l6emp1atXZ3m+EydO1COPPCIfHx+HeN++ffWf//xHrVq1utHUAQCZoOkGAADIBYwxGjhwoJo2bapq1apJkipXrqzw8HANGTJEZ86cUVJSkv73v/8pKipKx44dy9J8//zzT23bti3dXvHp06dr48aNGjlyZLbXAgC4hKYbAAAgF3juuef0999/67vvvrNiBQoU0MyZM7V7924VKVJEhQoV0vLly9W2bVu5u7tnab4TJ05UtWrVVL9+fSt26NAhDRgwQF9//bXDXnQAQPaj6QYAAMhh/fr109y5c7Vs2TKFhoY6TKtTp442b96ss2fP6tixY1qwYIGio6NVtmzZa873woULmj59erq93Bs2bNCJEydUp04deXh4yMPDQytWrNCHH34oDw8PpaamZmt9AHAr40JqAAAAOcQYo379+mnWrFlavnz5VRvpgIAASdKePXu0fv16vfXWW9ec//fff6/ExER17drVId6yZUtt3brVIdazZ09VrlxZL7/8cpb3ogMAro2mGwAAIIf07dtX3377rebMmSM/Pz9FRUVJuthge3t7S5J++OEHFS9eXKVLl9bWrVs1YMAAdejQQa1bt7bm8/jjj6tUqVLpzs+eOHGiOnTooKJFizrE/fz8rPPG0/j4+Kho0aLp4gCAG5Pjh5dPmDBBNWrUkL+/v/z9/dWoUSPNnz/fmm6M0bBhwxQSEiJvb29FRERo+/btOZgxAABA9pgwYYJiYmIUERGhkiVLWj8zZsywxhw7dkzdunVT5cqV1b9/f3Xr1s3hvG9JOnjwYLoLq+3evVurV69Wr169bkotAICM2YwxJicT+Pnnn+Xu7q4KFSpIkqZOnap3331XmzZtUtWqVTVq1Ci9/fbbmjJliipVqqQRI0Zo5cqV2rVrl/z8/LL0GrGxsQoICFBMTIz8/f1dWQ4AAAAA4BaQ1T4zx5vujBQpUkTvvvuunnjiCYWEhOj555/Xyy+/LOni/SqDg4M1atQo9e7dO8PnJyYmWve1lC6+GWFhYYqOjrbeDDc3N7m5uclut8tut1tj0+Kpqam6/K3JLO7u7i6bzaaUlBSHHNLOhbryQiSZxT08PGSMcYjbbDa5u7unyzGzODVREzVREzVREzVREzVREzVREzXdnJpiY2NVtGjRazbdueqc7tTUVP3www+Ki4tTo0aNFBkZqaioKIdzlry8vNS8eXOtXbs206Z75MiRGj58eLr4pk2b5OPjI0kqXry4ypcvr8jISJ08edIaExoaqtDQUO3evVsxMTFWvFy5cgoKCtK2bdsUHx9vxStXrqzAwEBt2rTJ4Rdeo0YNeXp6av369Q451K1bV0lJSfr777+tmLu7u+rVq6eYmBjt3LnTint7e6tmzZo6deqU9u3bZ8UDAgJUpUoVHT16VIcPH7bi1ERN1ERN1ERN1ERN1ERN1ERN1HRzaoqLi1NW5Io93Vu3blWjRo2UkJAgX19fffvtt7r33nu1du1aNWnSREeOHFFISIg1/umnn9aBAwe0cOHCDOfHnm5qoiZqoiZqoiZqoiZqoiZqoiZqcmVNWd3TnSua7qSkJB08eFBnz57VzJkz9eWXX2rFihU6e/asmjRpoqNHj6pkyZLW+KeeekqHDh3SggULsjR/zukGAAAAAGSnrPaZOX71ckny9PRUhQoVVLduXY0cOVI1a9bUuHHjVKJECUmybp+R5sSJEwoODs6JVAEAAAAAyLJcdU53GmOMEhMTVbZsWZUoUUKLFy9WrVq1JF3cK75ixQqNGjUqh7MEAADOaPfR6pxOAbghP/drmtMpAMiDcrzpfuWVV9S2bVuFhYXp3Llzmj59upYvX64FCxbIZrPp+eef1zvvvKOKFSuqYsWKeuedd1SoUCF16dIlp1MHAAAAAOCqcrzpPn78uLp166Zjx44pICBANWrU0IIFC3T33XdLkgYNGqT4+Hj16dNHZ86cUYMGDbRo0aIs36MbAAAAAICckisupOZqXEgNAICcx+HlyOs4vBzA5fLUhdQAAAAAAMiPaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcJEcb7pHjhypevXqyc/PT0FBQerQoYN27drlMKZHjx6y2WwOPw0bNsyhjAEAAAAAyJocb7pXrFihvn376vfff9fixYuVkpKi1q1bKy4uzmHcPffco2PHjlk/v/76aw5lDAAAAABA1njkdAILFixweDx58mQFBQVpw4YNatasmRX38vJSiRIlsjTPxMREJSYmWo9jY2MlSSkpKUpJSZEkubm5yc3NTXa7XXa73RqbFk9NTZUx5ppxd3d32Ww2a76XxyUpNTU1S3EPDw8ZYxziNptN7u7u6XLMLE5N1ERN1ERN1JSba3KTkc12ad52IxnZ5C4jORO3XapTklL//6G7TVmM22STkdvlcSOlKutxYyS7bNR0i9WUm5an/LiOoCZqyms1XVlDZnK86b5STEyMJKlIkSIO8eXLlysoKEiBgYFq3ry53n77bQUFBWU4j5EjR2r48OHp4ps2bZKPj48kqXjx4ipfvrwiIyN18uRJa0xoaKhCQ0O1e/duKxdJKleunIKCgrRt2zbFx8db8cqVKyswMFCbNm1y+IXXqFFDnp6eWr9+vUMOdevWVVJSkv7++28r5u7urnr16ikmJkY7d+604t7e3qpZs6ZOnTqlffv2WfGAgABVqVJFR48e1eHDh604NVETNVETNVFTbq6pim+CSnknW/G9cV7ae8FLNQPiVczz0obL9nMFdSTBUw0Kx8nX49JG0IazhRSd7KHmRc7Lw+3SRtCa0z5KsLupZbFzDjUtOeWngm52NSly6ei5FLtNS6P9VKRAquoEXrDi51PctPaMr0IKJquqX4IVP5XkoY0xhVSuUJLK+1z6Qv9IfAFtP+9NTbdYTblpecqP6whqoqa8VtOVR2dnxmYub91zmDFG7du315kzZ7Rq1SorPmPGDPn6+io8PFyRkZF67bXXlJKSog0bNsjLyyvdfDLa0x0WFqbo6Gj5+/tL4psaaqImaqImaqKmm11T+49WsQeVmvJ0TbOedbymEOsIaqKmW7um2NhYFS1aVDExMVafmZFc1XT37dtX8+bN0+rVqxUaGprpuGPHjik8PFzTp0/XAw88cM35xsbGKiAg4JpvBgAAcJ12H63O6RSAG/Jzv6Y5nQKAXCSrfWauOby8X79+mjt3rlauXHnVhluSSpYsqfDwcO3Zs+cmZQcAAAAAgPNyvOk2xqhfv36aNWuWli9frrJly17zOdHR0Tp06JBKlix5EzIEAAAAAOD65Pgtw/r27auvv/5a3377rfz8/BQVFaWoqCjrZPvz58/rpZde0rp167R//34tX75c7dq1U7FixdSxY8cczh4AAAAAgMzl+J7uCRMmSJIiIiIc4pMnT1aPHj3k7u6urVu3atq0aTp79qxKliypFi1aaMaMGfLz88uBjAEAAAAAyJocb7qvdR03b29vLVy48CZlAwAAAABA9snxw8sBAAAAAMivaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF7mhpttut+vChQvZlQsAAAAAAPmKU013QkKCpkyZok6dOikkJESenp7y8/NToUKFVLduXQ0aNEhbtmxxVa4AAAAAAOQpHlkZFB8fr9GjR2vcuHGKiYlR5cqV1bJlSwUFBalgwYI6ffq09u3bpy+++ELvv/++GjdurNGjR6tRo0auzh8AAAAAgFwrS013xYoV5ePjo6FDh+qxxx5TcHBwhuOMMVq2bJkmT56sFi1aaPz48XryySezNWEAAAAAAPKKLDXdb775prp37y53d/erjrPZbLrrrrt01113afjw4Tp48GC2JAkAAAAAQF6Upab7iSeecHrG5cqVU7ly5Zx+HgAAAAAA+UW23DIsISFBO3fuVGpqanbMDgAAAACAfMHppvujjz7SW2+9ZT3esGGDwsLCVLVqVVWqVEmHDh3K1gQBAAAAAMirnG66v/zySwUGBlqPX375ZRUpUkQffPCBjDEaMWJEduYHAAAAAECelaVzui938OBBVa5cWZJ07tw5rVy5UtOnT9cDDzygwoUL6/XXX8/2JAEAAAAAyIuc3tOdmJioAgUKSJLWrVsnu92uVq1aSZLKlCmjqKio7M0QAAAAAIA8yummu3Tp0lq1apUkac6cObrjjjvk7+8vSTp58qT1fwAAAAAAbnVOH17etWtXDR8+XLNnz9aWLVv03nvvWdPWr1+vSpUqZWuCAAAAAADkVU433a+++qo8PDy0du1adezYUf3797embdu2TQ8++GC2JggAAAAAQF7ldNNts9k0ePDgDKfNnTv3hhMCAAAAACC/cPqc7n79+mnXrl2uyAUAAAAAgHzF6aZ72rRpuv3229WqVSvNmTNHxhhX5AUAAAAAQJ7ndNN99OhRffTRR4qKilLHjh1VpkwZ/e9//9OpU6dckR8AAAAAAHmW0023j4+P+vTpo23btum3335TnTp19NprryksLEw9evTQ+vXrXZEnAAAAAAB5jtNN9+Xuuusu/fTTT4qMjFTjxo311VdfqUGDBmrQoIF+/vnn7MoRAAAAAIA86Yaa7vj4eH355Zdq166dli1bpipVquiNN95QamqqOnTooLfeeiu78gQAAAAAIM+5rqZ77969GjhwoEqVKqVnnnlGoaGhWrRokbZt26bXX39d69ev18svv6yPPvoou/MFAAAAACDPcLrpbtu2rW677TZNnDhRjz/+uHbt2qWff/5ZrVq1chjXrl27LF1cbeTIkapXr578/PwUFBSkDh06pLslmTFGw4YNU0hIiLy9vRUREaHt27c7mzoAAAAAADeV00333r179cEHH+jIkSMaO3asypcvn+G4atWqadmyZdec34oVK9S3b1/9/vvvWrx4sVJSUtS6dWvFxcVZY0aPHq0xY8Zo/Pjx+uuvv1SiRAndfffdOnfunLPpAwAAAABw09hMLrvR9smTJxUUFKQVK1aoWbNmMsYoJCREzz//vF5++WVJUmJiooKDgzVq1Cj17t37mvOMjY1VQECAYmJi5O/v7+oSAABABtp9tDqnUwBuyM/9muZ0CgBykaz2mR43MacsiYmJkSQVKVJEkhQZGamoqCi1bt3aGuPl5aXmzZtr7dq1GTbdiYmJSkxMtB7HxsZKklJSUpSSkiJJcnNzk5ubm+x2u+x2uzU2LZ6amqrLv4/ILO7u7i6bzWbN9/K4JKWmpmYp7uHhIWOMQ9xms8nd3T1djpnFqYmaqImaqImacnNNbjKy2S7N224kI5vcZSRn4jbH/QWp///Q3aYsxm2yycjt8riRUpX1uDGSXTZqusVqyk3LU35cR1ATNeW1mq6sITPX1XSvXLlSH374oXbs2KH4+HiHaTabTXv37r2e2coYo4EDB6pp06aqVq2aJCkqKkqSFBwc7DA2ODhYBw4cyHA+I0eO1PDhw9PFN23aJB8fH0lS8eLFVb58eUVGRurkyZPWmNDQUIWGhmr37t3WFwCSVK5cOQUFBWnbtm0ONVeuXFmBgYHatGmTwy+8Ro0a8vT0THff8rp16yopKUl///23FXN3d1e9evUUExOjnTt3WnFvb2/VrFlTp06d0r59+6x4QECAqlSpoqNHj+rw4cNWnJqoiZqoiZqoKTfXVMU3QaW8k6343jgv7b3gpZoB8SrmeWnDZfu5gjqS4KkGhePk63FpI2jD2UKKTvZQ8yLn5eF2aSNozWkfJdjd1LKY42lnS075qaCbXU2KXDplLcVu09JoPxUpkKo6gRes+PkUN60946uQgsmq6pdgxU8leWhjTCGVK5Sk8j6XvtA/El9A2897U9MtVlNuWp7y4zqCmqgpr9V0+SnRV+P04eWrV69WixYtFBERoSVLluiee+7RuXPntG7dOpUrV05NmjTR5MmTnZmlpW/fvpo3b55Wr16t0NBQSdLatWvVpEkTHT16VCVLlrTGPvXUUzp06JAWLFiQbj4Z7ekOCwtTdHS0tdufb2qoiZqoiZqoiZpubk3tP1rFHlRqytM1zXq2oUOOrCOoiZpu7ZpiY2NVtGjRax5e7nTT3bJlS5UvX14TJkxQgQIFtH79etWuXVt///237rnnHn322Wdq166dM7OUJPXr10+zZ8/WypUrVbZsWSu+b98+lS9fXhs3blStWrWsePv27RUYGKipU6dec96c0w0AQM7jnG7kdZzTDeByWe0znb56+bZt29SxY0fZ/v/rwrRvFmrUqKHXXntNb775plPzM8boueee008//aSlS5c6NNySVLZsWZUoUUKLFy+2YklJSVqxYoUaN27sbPoAAAAAANw0Tp/TfeHCBfn6+srNzU1eXl4O9+KuXLmy/vnnH6fm17dvX3377beaM2eO/Pz8rHO4AwIC5O3tLZvNpueff17vvPOOKlasqIoVK+qdd95RoUKF1KVLF2fTBwAAAADgpnG66S5durSOHz8uSbr99ts1b948tW3bVtLFe24XLVrUqflNmDBBkhQREeEQnzx5snr06CFJGjRokOLj49WnTx+dOXNGDRo00KJFi+Tn5+ds+gAAAAAA3DRON90RERFavny5HnroIT311FPq06ePduzYIS8vLy1atEgvvviiU/PLyinlNptNw4YN07Bhw5xNFwAAAACAHON00z18+HCdPn1akvTMM8/owoUL+uabb2Sz2TR06FC9+uqr2Z4kAAAAAAB5kdNNd7FixVSsWDHr8cCBAzVw4MBsTQoAAAAAgPzA6aZbkux2u7W3u0iRInJzc/oi6AAAAAAA5HtOdcsLFy5Uq1at5Ovrq+DgYAUHB8vX11dt2rTRkiVLXJUjAAAAAAB5Upb3dL///vsaNGiQPDw8VKdOHYWHh8sYowMHDmjZsmX67bffNGbMGA0YMMCV+QIAAAAAkGdkqen+559/NHjwYLVp00YTJ05UyZIlHaYfOXJETz75pAYNGqQ2bdqocuXKLkkWAAAAAIC8JEuHl3/55ZcqU6aMZs2ala7hlqRSpUpp1qxZKl26tL744otsTxIAAAAAgLwoS0336tWr9cQTT8jLyyvTMQULFtQTTzyhVatWZVtyAAAAAADkZVlquvft26datWpdc1ytWrW0b9++G04KAAAAAID8IEtNd2xsrAIDA685LiAgQLGxsTeaEwAAAAAA+UKWmu6UlJQs3Yvbzc1NqampN5wUAAAAAAD5QZZvGfbdd99p9erVVx1z8ODBG04IAAAAAID8IstN97hx47I0zmazXXcyAAAAAADkJ1lquiMjI12dBwAAAAAA+U6Wmu7w8HBX5wEAAAAAQL6TpQupAQAAAAAA52Wp6b733nu1adOmLM80MTFRY8aM0ccff3zdiQEAAAAAkNdlqekuUaKE6tWrpyZNmuizzz7Trl270o05d+6cfvvtN/Xr10+lSpXSxx9/rFq1amV7wgAAAAAA5BVZOqd70qRJ6tevn/73v/+pf//+SklJkbe3t4oXL66CBQvq9OnTio6OljFG4eHheuWVV9S3b195eXm5On8AAAAAAHKtLN8yrFatWpoxY4ZOnDihhQsX6vfff9fRo0cVHx+vOnXqqHLlyoqIiFCTJk24bRgAAAAAAHKi6U4TFBSkbt26qVu3bq7IBwAAAACAfIOrlwMAAAAA4CI03QAAAAAAuAhNNwAAAAAALkLTDQAAAACAi9B0AwAAAADgIk433UlJSa7IAwAAAACAfMfpprtUqVIaMmSIDh486Ip8AAAAAADIN5xuutu1a6cPP/xQ5cuXV8eOHbVkyRJX5AUAAAAAQJ7ndNM9adIkHT58WG+//ba2bNmi1q1bq0qVKho/frzOnTvnihwBAAAAAMiTrutCaoULF9agQYO0d+9ezZo1S2FhYRowYIBKlSql5557Tjt37szuPAEAAAAAyHNu6OrlNptN999/v0aNGqXmzZvr/Pnz+uSTT1S1alU9+OCDOnHiRHblCQAAAABAnnPdTXdKSoq+++47NW3aVHXr1tW+ffs0atQo7d+/X2PHjtWqVav0+OOPZ2euAAAAAADkKR7OPuHIkSP67LPP9MUXX+j48eO688479f3336tjx45yc7vYw/fr10+lSpVS165dsz1hAAAAAADyCqeb7jJlysjDw0OPPPKIBgwYoDvuuCPDceXKlVNwcPCN5gcAAAAAQJ7ldNP9xhtvqHfv3ipevPhVx91xxx2KjIy87sQAAAAAAMjrnG66hw4d6oo8AAAAAADId5xuutPExMRo9+7dio+PTzetWbNmN5QUAAAAAAD5gdNNd0pKip555hlNmzZNqampGY7JLA4AAAAAwK3E6VuGffDBB/r55581adIkGWM0fvx4ffbZZ6pbt64qVqyo+fPnuyJPAAAAAADyHKeb7q+++kqvvvqqHn30UUlSgwYN9OSTT+qPP/5QeHi4li1blu1JAgAAAACQFznddO/bt081a9a07smdkJBgTXvmmWf0zTffZF92AAAAAADkYU433T4+PkpKSpLNZlORIkV04MABa5q3t7eio6OzNUEAAAAAAPIqp5vuypUrW/ffbty4scaMGaPDhw/rxIkTGj16tG677bZsTxIAAAAAgLzI6auXd+7cWbt375YkDR8+XM2aNVN4eLgkqUCBAvrpp5+yN0MAAAAAAPIop5vuPn36WP+vVauW/vnnH82ePVs2m0133303e7oBAAAAAPh/TjfdVwoLC1O/fv2yIxcAAAAAAPIVp8/pBgAAAAAAWZOlPd1ly5aVzWbL0gxtNpv27t17Q0kBAAAAAJAfZKnpbt68eZabbgAAAAAAcFGWmu4pU6a4OA0AAAAAAPIfzukGAAAAAMBFrqvpPnnypIYMGaJGjRqpYsWK2r59uyTps88+06ZNm7I1QQAAAAAA8iqnm+7IyEjVrFlTH374oWw2m/bt26fExERJ0t9//60PP/ww25MEAAAAACAvcrrpHjRokAIDA7Vnzx6tXLlSxhhrWtOmTbVmzZpsTRAAAAAAgLwqSxdSu9ySJUs0YcIEhYSEKDU11WFayZIldfTo0WxLDgAAAACAvMzpPd0JCQkqUqRIhtPi4uLk5sa12QAAAAAAkK6j6b7tttv022+/ZTht5cqVqlat2g0nBQAAAABAfuD04eVPPfWUBg4cqJCQED322GOSpKSkJP3444/65JNPNH78+GxPEgAAAACAvMjpprtPnz7avHmzXnjhBb344ouSLl5AzRijp556St27d8/2JAEAAAAAyIucbrol6fPPP9cTTzyhX375RSdOnFCxYsV03333qXHjxtmdHwAAAAAAedZ1Nd2S1LBhQzVs2DA7cwEAAAAAIF9xuuk+dOiQVq1aZd0aLCQkRM2aNVNoaGi2JwcAAAAAQF6W5ab73Llzevrpp/XDDz/IGCNjjDXNzc1NXbp00YQJE+Tj4+OSRAEAAAAAyGuy1HQbY3Tfffdp1apVuvfee3X//fcrPDxcxhgdOHBAc+bM0ddff60jR45oyZIlrs4ZAAAAAIA8IUtN908//aRVq1Zp8uTJGV6dvHfv3po8ebJ69eqlWbNmqWPHjtmeKAAAAAAAeY1bVgbNmDFD991331VvB9azZ0/dd999mj59ulMJrFy5Uu3atVNISIhsNptmz57tML1Hjx6y2WwOP1zADQAAAACQF2Sp6d60aZM6dOhwzXEdOnTQxo0bnUogLi5ONWvW1Pjx4zMdc8899+jYsWPWz6+//urUawAAAAAAkBOydHj58ePHVbZs2WuOK1eunI4fP+5UAm3btlXbtm2vOsbLy0slSpRwar4AAAAAAOS0LDXdcXFxWboqube3t+Li4m44qSstX75cQUFBCgwMVPPmzfX2228rKCgo0/GJiYlKTEy0HsfGxkqSUlJSlJKSIuniFdfd3Nxkt9tlt9utsWnx1NTUdFdozyju7u4um81mzffyuCSlpqZmKe7h4SFjjEPcZrPJ3d09XY6ZxamJmqiJmqiJmnJzTW4ystkuzdtuJCOb3GUkZ+K2S3VKUur/P3S3KYtxm2wycrs8bqRUZT1ujGSXjZpusZpy0/KUH9cR1ERNea2mK2vITJavXm6z2a490AXatm2rTp06KTw8XJGRkXrttdd01113acOGDfLy8srwOSNHjtTw4cPTxTdt2mR9eVC8eHGVL19ekZGROnnypDUmNDRUoaGh2r17t2JiYqx4uXLlFBQUpG3btik+Pt6KV65cWYGBgdq0aZPDL7xGjRry9PTU+vXrHXKoW7eukpKS9Pfff1sxd3d31atXTzExMdq5c6cV9/b2Vs2aNXXq1Cnt27fPigcEBKhKlSo6evSoDh8+bMWpiZqoiZqoiZpyc01VfBNUyjvZiu+N89LeC16qGRCvYp6XNly2nyuoIwmealA4Tr4elzaCNpwtpOhkDzUvcl4ebpc2gtac9lGC3U0ti51zqGnJKT8VdLOrSZFLOwRS7DYtjfZTkQKpqhN4wYqfT3HT2jO+CimYrKp+CVb8VJKHNsYUUrlCSSrvc+kL/SPxBbT9vDc13WI15ablKT+uI6iJmvJaTVnd4Wwzl7fumXBzc1P58uXl7e191XHx8fHat29fum8hsspms2nWrFlXPX/82LFjCg8P1/Tp0/XAAw9kOCajPd1hYWGKjo6Wv7+/JL6poSZqoiZqoiZqutk1tf9oFXtQqSlP1zTrWceL+bKOoCZqurVrio2NVdGiRRUTE2P1mRnJ0p7uZs2aZXlPd2hoaJbGXa+SJUsqPDxce/bsyXSMl5dXhnvBPTw85OHhWHLaG3eltF9uVuNXzvd64jabLcN4Zjk6G6cmasosTk3UJFFTZjk6G6emzON22aQMvupPdTZuMt4mSc1gbGZxI1u2xKnp1qopNy1P+XEdQU3U5Gw8p2vKLNcrZWnU8uXLszSzmyE6OlqHDh1SyZIlczoVAAAAAACuKmutuQudP39e//77r/U4MjJSmzdvVpEiRVSkSBENGzZMDz74oEqWLKn9+/frlVdeUbFixdSxY8cczBoAAAAAgGvL8aZ7/fr1atGihfV44MCBkqTu3btrwoQJ2rp1q6ZNm6azZ8+qZMmSatGihWbMmCE/P7+cShkAAAAAgCxJf+D6TRYRESFjTLqfKVOmyNvbWwsXLtSJEyeUlJSkAwcOaMqUKQoLC8vptHGTrVy5Uu3atVNISIhsNptmz57tMH3YsGGqXLmyfHx8VLhwYbVq1Up//PHHVec5ZcoU2Wy2dD8JCZeuhjphwgTVqFFD/v7+8vf3V6NGjTR//nxXlAgAAAAgH8rxphvIiri4ONWsWVPjx4/PcHqlSpU0fvx4bd26VatXr1aZMmXUunVrh0v/Z8Tf31/Hjh1z+ClYsKA1PTQ0VP/73/+0fv16rV+/XnfddZfat2+v7du3Z2t9AAAAAPKnHD+8HMiKtm3bqm3btplO79Kli8PjMWPGaOLEifr777/VsmXLTJ9ns9lUokSJTKe3a9fO4fHbb7+tCRMm6Pfff1fVqlWzmD0AAACAWxV7upHvJCUl6fPPP1dAQIBq1qx51bHnz59XeHi4QkNDdd9992nTpk2Zjk1NTdX06dMVFxenRo0aZXfaAAAAAPIh9nQj3/jll1/0yCOP6MKFCypZsqQWL16sYsWKZTq+cuXKmjJliqpXr67Y2FiNGzdOTZo00ZYtW1SxYkVr3NatW9WoUSMlJCTI19dXs2bN0u23334zSgIAAACQx2Wp6S5btqxsNluWZ7pv377rTgi4Xi1atNDmzZt16tQpffHFF3r44Yf1xx9/KCgoKMPxDRs2VMOGDa3HTZo0Ue3atfXRRx/pww8/tOK33XabNm/erLNnz2rmzJnq3r27VqxYQeMNAAAA4Jqy1HQ3b97coeleunSpoqKi1LhxY5UoUUJRUVFau3atSpYsqbvuustlyQJX4+PjowoVKqhChQpq2LChKlasqIkTJ2rIkCFZer6bm5vq1aunPXv2OMQ9PT1VoUIFSVLdunX1119/ady4cfrss8+yvQYAAAAA+UuWmu4pU6ZY///qq6+0Zs0a7dmzR6VLl7biBw4c0N13363mzZtne5LA9TDGKDEx0anxmzdvVvXq1bN1vgAAAABuXU6f0/2///1Pw4cPd2i4JSk8PFxvvPGGRowYoe7du2dbgoB08YJn//77r/U4MjJSmzdvVpEiRVS0aFG9/fbbuv/++1WyZElFR0frk08+0eHDh9WpUyfrOY8//rhKlSqlkSNHSpKGDx9u7RGPjY3Vhx9+qM2bN+vjjz+2nvPKK6+obdu2CgsL07lz5zR9+nQtX75cCxYsuHnFAwAAAMiznG669+7dq4CAgAynFS5cWPv377/RnIB01q9frxYtWliPBw4cKEnq3r27Pv30U+3cuVNTp07VqVOnVLRoUdWrV0+rVq1yuK3XwYMH5eZ26YL9Z8+e1dNPP62oqCgFBASoVq1aWrlyperXr2+NOX78uLp166Zjx44pICBANWrU0IIFC3T33XffhKoBAAAA5HU2Y4xx5gmVK1dW1apVNXPmzHTTOnbsqB07dmjnzp3ZlmB2iI2NVUBAgGJiYuTv75/T6QAAcEtq99HqnE4BuCE/92ua0ykAyEWy2mc6vad78ODBeuKJJ1S/fn09+uij1oXUvvvuO23YsEFffvnlDSUOAAAAAEB+4XTT3aNHD0nS0KFD9eKLL1rxkiVL6osvvlDPnj2zLTkAAAAAAPIyp5tu6WLj3b17d+3atUvR0dEqWrSobrvtNqfu5Q0AAAAAQH53XU23JNlsNlWuXDk7cwEAAAAAIF9xu/aQ9Hbu3KlHH31UJUuWlKenpzZu3Cjp4i2Yli1blq0JAgAAAACQVznddG/evFn16tXTihUrFBERodTUVGva+fPn9emnn2ZrggAAAAAA5FXXdfXyGjVqaPHixfL09NSMGTOsafXr18/wVmLIOm6ngryMW6kAAAAAjpxuutesWaOvv/5ahQoVctjLLUnBwcGKiorKtuQAAAAAAMjLnD683BgjT0/PDKedOXNGXl5eN5wUAAAAAAD5gdNNd40aNTRr1qwMpy1YsEB16tS54aQAAAAAAMgPnD68fMCAAerSpYt8fHzUrVs3SdLBgwe1dOlSTZo0ST/++GO2JwkAAAAAQF7kdNPduXNn7d27V8OGDdOHH34oSXrwwQfl4eGh4cOHq127dtmeJAAAAAAAeZHTTbckvfLKK3r88ce1cOFCHT9+XMWKFVObNm0UHh6e3fkBAAAAAJBnOd10r1y5UrVr11ZoaKh69erlMO38+fPauHGjmjVrlm0JAgAAAACQVzl9IbUWLVron3/+yXDarl271KJFixtOCgAAAACA/OC6bhmWmeTkZLm5OT1LAAAAAADypSwdXh4bG6uzZ89aj6OionTw4EGHMfHx8Zo6dapKlCiRrQkCAAAAAJBXZanp/uCDD/Tmm29Kkmw2mzp27JjhOGOMXnnllezLDgAAAACAPCxLTXfr1q3l6+srY4wGDRqkfv36qXTp0g5jvLy8VL16dTVv3twliQIAAAAAkNdkqelu1KiRGjVqJEmKi4vTU089pZCQEJcmBgAAAABAXuf0LcPeeOMNV+QBAAAAAEC+4/SlxgcOHKjHHnssw2ldu3bVf//73xtOCgAAAACA/MDppnvu3Llq3bp1htNat26tOXPm3HBSAAAAAADkB0433UeOHFGZMmUynBYeHq7Dhw/faE4AAAAAAOQLTjfdPj4+OnToUIbTDh48qIIFC95wUgAAAAAA5AdON92NGjXS+++/r+TkZId4cnKyPvjgAzVu3DjbkgMAAAAAIC9z+urlQ4cOVbNmzVStWjX16tVLpUqV0uHDhzVp0iQdOHBAn376qSvyBAAAAAAgz3G66W7QoIHmzp2rvn37avDgwVa8fPnymjt3rurXr5+tCQIAAAAAkFc53XRLUps2bfTvv/9qz549OnnypIoXL66KFStmd24AAAAAAORp19V0p6lYsSLNNgAAAAAAmchS071y5UrVrl1bvr6+Wrly5TXHN2vW7IYTAwAAAAAgr8tS0x0REaHff/9d9evXV0REhGw2W4bjjDGy2WxKTU3N1iQBAAAAAMiLstR0L1u2TLfffrv1fwAAAAAAcG1ZarqbN2+e4f8BAAAAAEDm3HI6AQAAAAAA8qss7el+4oknsjxDm82miRMnXndCAAAAAADkF1lqupcuXepw8bSzZ88qJiZGHh4eKlq0qKKjo5WSkqKAgAAVLlzYZckCAAAAAJCXZOnw8v379ysyMlKRkZH6/vvv5evrq2+++Ubx8fE6duyY4uPj9fXXX8vHx0fTp093dc4AAAAAAOQJWdrTfbkXX3xRL730kh599FEr5u7uri5duuj48eN64YUXtGbNmmxNEgAAAACAvMjpC6lt2LBB1apVy3Ba9erVtXnz5hvNCQAAAACAfMHpptvf31+//fZbhtN+++03+fv733BSAAAAAADkB04fXt6tWze9++67SklJUZcuXVSiRAlFRUXpm2++0dixYzVw4EBX5AkAAAAAQJ7jdNP9zjvv6MSJE3r//fc1ZswYK26MUdeuXfXOO+9ka4IAAAAAAORVTjfdHh4emjJlioYMGaKlS5fq9OnTKlq0qCIiIlS5cmVX5AgAAAAAQJ7kdNOd5rbbbtNtt92WnbkAAAAAAJCvOH0hNUlKTEzUZ599pkcffVStW7fWnj17JElz5szRvn37sjVBAAAAAADyKqf3dJ86dUotWrTQ9u3bVaJECR0/flznzp2TJM2ePVsLFy7UJ598ku2JAgAAAACQ1zi9p3vQoEE6e/as1q9fr4MHD8oYY01r0aKFVqxYka0JAgAAAACQVzm9p/uXX37RqFGjVLt2baWmpjpMCw0N1eHDh7MtOQAAAAAA8jKn93THxsYqPDw8w2nJyclKSUm54aQAAAAAAMgPnG66y5Ytq3Xr1mU47c8//+SK5gAAAAAA/D+nm+7HHntMo0aN0pw5c6zzuW02m/766y+NGzdO3bp1y/YkAQAAAADIi5w+p/vll1/WmjVr1LFjRxUuXFiS1KZNG0VHR+uee+7RgAEDsj1JAAAAAADyIqeb7gIFCujXX3/VjBkzNG/ePB0/flzFihXTfffdp0ceeURubtd1628AAAAAAPIdp5ru+Ph4tWrVSsOHD9cjjzyiRx55xFV5AQAAAACQ5zm1W9rb21tbt26Vh4fTO8gBAAAAALjlOH0seKNGjfTnn3+6IhcAAAAAAPIVp5vu999/X5999pmmTZum8+fP33ACK1euVLt27RQSEiKbzabZs2c7TDfGaNiwYQoJCZG3t7ciIiK0ffv2G35dAAAAAABc7br2dB8+fFg9e/ZUQECA/Pz85O/vb/0EBAQ4Nb+4uDjVrFlT48ePz3D66NGjNWbMGI0fP15//fWXSpQoobvvvlvnzp1zNnUAAAAAAG4qp0/OfvDBB2Wz2bItgbZt26pt27YZTjPGaOzYsXr11Vf1wAMPSJKmTp2q4OBgffvtt+rdu3eGz0tMTFRiYqL1ODY2VpKUkpKilJQUSZKbm5vc3Nxkt9tlt9utsWnx1NRU6z7kV4u7u7vLZrNZ8708LkmpqalZint4eMgYI3fbpXnLSKmyySYjt8vf8kzixkh22eQmo8t/RXYjGdnkLiM5E788F0mp///Q/Ypff+bxrOdOTfmjpty2PF0et9lscnd3T5djZvHcuo6gJmrKyzXlx/UeNd1aNeWm5Sk/riOoiZryWk1X1pAZp5vuKVOmOPuU6xYZGamoqCi1bt3ainl5eal58+Zau3Ztpk33yJEjNXz48HTxTZs2ycfHR5JUvHhxlS9fXpGRkTp58qQ1JjQ0VKGhodq9e7diYmKseLly5RQUFKRt27YpPj7eileuXFmBgYHatGmTwy+8Ro0a8vT01Pr16x1yqFu3rpKSkvT3339bMXd3d9WrV08xMTFqWezSHvzzKW5ae8ZXIQWTVdUvwYqfSvLQxphCKlcoSeV9Ln25cCS+gLaf91YV3wSV8k624nvjvLT3gpdqBsSrmOelD8b2cwV1JMFTDQrHydfj0odsw9lCik72UPMi5+XhdulDtua0jxLsbg45StKSU34q6GZXkyJxVizFbtPSaD8VKZCqOoEXqOkWqSm3LU87d+604t7e3qpZs6ZOnTqlffv2WfGAgABVqVJFR48e1eHDh614bl1HUBM15eWa8uN6j5purZpy0/KUH9cR1ERNea2muLhL662rsZnLW/eriI+P1+zZs3XgwAEFBQWpXbt2Kl68eJZeJKtsNptmzZqlDh06SJLWrl2rJk2a6MiRIwoJCbHGPf300zpw4IAWLlyY4Xwy2tMdFham6Oho+fv7S8q939R0/Hj1pSDfUFNTHqtpTt/GuWp54ttcaqKm3FVT+49W5bv1Xn5cl1NT5vFZzzZ0yJF1BDVR061dU2xsrIoWLaqYmBirz8xIlvZ0Hz16VM2aNVNkZKT1ogEBAZo/f74aNmx4jWffuCsPZzfGXPUQdy8vL3l5eaWLe3h4pLvdWdobd6W0X25W45ndRs2ZuM1mU6pJX5eRzfqDlJW4XTYpg3iqs/EMcrkYzzDsVI7UlD9rym3LU0bxzHJ0Nk5N1JRZnJoyj+fH9R413Vo15ablKT+uI6iJmpyN53RNWb2VdpYupDZ06FAdOXJEQ4cO1bx58zR27Fh5enrq2WefzdKLXK8SJUpIkqKiohziJ06cUHBwsEtfGwAAAACAG5Wl1nzx4sV65ZVX9Nprr0m6ePGz8uXL6/7779fx48dd1gCXLVtWJUqU0OLFi1WrVi1JUlJSklasWKFRo0a55DUBAAAAAMguWWq6o6Ki1KxZM4dYRESEjDE33HSfP39e//77r/U4MjJSmzdvVpEiRVS6dGk9//zzeuedd1SxYkVVrFhR77zzjgoVKqQuXbpc92sCAAAAAHAzZKnpTk1Nlbe3t0OsYMGCkpTly6RnZv369WrRooX1eODAgZKk7t27a8qUKRo0aJDi4+PVp08fnTlzRg0aNNCiRYvk5+d3Q68LAAAAAICrZfmWYbt27XI4UTztKnGXX6I9Te3atbOcQNoe88zYbDYNGzZMw4YNy/I8AQAAAADIDbLcdPfo0SPDeLdu3az/p11V/MrLuQMAAAAAcCvKUtM9efJkV+cBAAAAAEC+k6Wmu3v37q7OAwAAAACAfCdL9+kGAAAAAADOo+kGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAAAAAABchKYbAAAAAAAXoekGAAAAAMBFaLoBAAAAAHARmm4AAAAAAFyEphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAACQNHLkSNlsNj3//POZjunRo4dsNlu6n6pVqzqMmzlzpm6//XZ5eXnp9ttv16xZs1ycPXIrmm4AAAAAt7y//vpLn3/+uWrUqHHVcePGjdOxY8esn0OHDqlIkSLq1KmTNWbdunXq3LmzunXrpi1btqhbt256+OGH9ccff7i6DORCNN0AAAAAbmnnz5/XY489pi+++EKFCxe+6tiAgACVKFHC+lm/fr3OnDmjnj17WmPGjh2ru+++W0OGDFHlypU1ZMgQtWzZUmPHjnVxJciNaLoBAAAA3NL69u2r//znP2rVqpXTz504caJatWql8PBwK7Zu3Tq1bt3aYVybNm20du3aG84VeY9HTicAAAAAADll+vTp2rhxo/766y+nn3vs2DHNnz9f3377rUM8KipKwcHBDrHg4GBFRUXdUK7Im2i6AQAAANySDh06pAEDBmjRokUqWLCg08+fMmWKAgMD1aFDh3TTbDabw2NjTLoYbg003QAAAABuSRs2bNCJEydUp04dK5aamqqVK1dq/PjxSkxMlLu7e4bPNcZo0qRJ6tatmzw9PR2mlShRIt1e7RMnTqTb+41bA+d0AwAAALgltWzZUlu3btXmzZutn7p16+qxxx7T5s2bM224JWnFihX6999/1atXr3TTGjVqpMWLFzvEFi1apMaNG2d7Dcj9cv2e7mHDhmn48OEOMc6HAAAAAHCj/Pz8VK1aNYeYj4+PihYtasWHDBmiI0eOaNq0aQ7jJk6cqAYNGqR7viQNGDBAzZo106hRo9S+fXvNmTNHv/32m1avXu26YpBr5Yk93VWrVnW4F97WrVtzOiUAAAAAt4Bjx47p4MGDDrGYmBjNnDkzw73cktS4cWNNnz5dkydPVo0aNTRlyhTNmDFDDRo0uBkpI5fJ9Xu6JcnDw0MlSpTI8vjExEQlJiZaj2NjYyVJKSkpSklJkSS5ubnJzc1NdrtddrvdGpsWT01NlTHmmnF3d3fZbDZrvpfHpYvnhGQl7uHhIWOM3G2X5i0jpcomm4zcLr/mQiZxYyS7bHKT0eXXaLAbycgmdxnJmfjluUhK/f+H7ldc/yHzeNZzp6b8UVNuW54uj9tsNrm7u6fLMbN4bl1HUBM15eWa8uN6j5purZpy0/KUH9cRuaWm5cuXyxhjzefLL7+0LoCWlqOPj49iY2PTxS/P8aGHHtIDDzzgELfb7fye8lFNV9aQmTzRdO/Zs0chISHy8vJSgwYN9M4776hcuXKZjh85cmS6Q9IladOmTfLx8ZEkFS9eXOXLl1dkZKROnjxpjQkNDVVoaKh2796tmJgYK16uXDkFBQVp27Ztio+Pt+KVK1dWYGCgNm3a5PALr1Gjhjw9PbV+/XqHHOrWraukpCT9/fffVszd3V316tVTTEyMWhY7Z8XPp7hp7RlfhRRMVlW/BCt+KslDG2MKqVyhJJX3ufTlwpH4Atp+3ltVfBNUyjvZiu+N89LeC16qGRCvYp6XPhjbzxXUkQRPNSgcJ1+PSx+yDWcLKTrZQ82LnJeH26UP2ZrTPkqwuznkKElLTvmpoJtdTYrEWbEUu01Lo/1UpECq6gReoKZbpKbctjzt3LnTint7e6tmzZo6deqU9u3bZ8UDAgJUpUoVHT16VIcPH7biuXUdQU3UlJdryo/rPWq6tWrKTctTflxHUBM15bWa4uIurbeuxmYub91zofnz5+vChQuqVKmSjh8/rhEjRmjnzp3avn27ihYtmuFzMtrTHRYWpujoaPn7+0vKvd/UdPz4svM8+IaamvJYTXP6Ns5VyxPf5lITNeWumtp/tCrfrffy47qcmjKPz3q2oUOOrCOoiZpu7ZpiY2NVtGhRxcTEWH1mRnJ9032luLg4lS9fXoMGDdLAgQOz9JzY2FgFBARc883IDdp9xMUVkHf93K9pTqcAIBfjbxzyOv7OAbhcVvvMPHEhtcv5+PioevXq2rNnT06nAgAAAADAVeW5pjsxMVE7duxQyZIlczoVAAAAAACuKtdfSO2ll15Su3btVLp0aZ04cUIjRoxQbGysunfvntOpAQAAALkWp3QgL8tPp3Pk+qb78OHDevTRR3Xq1CkVL15cDRs21O+//67w8PCcTg0AAAAAgKvK9U339OnTczoFAAAAAACuS547pxsAAAAAgLyCphsAAAAAABeh6QYAAAAAwEVougEAAAAAcBGabgAAAAAAXISmGwAAAAAAF6HpBgAAAADARWi6AQAAAABwEZpuAMBVjRw5UvXq1ZOfn5+CgoLUoUMH7dq165rP+/jjj1WlShV5e3vrtttu07Rp0xymf/HFF7rzzjtVuHBhFS5cWK1atdKff/7pqjIAAAByBE03AOCqVqxYob59++r333/X4sWLlZKSotatWysuLi7T50yYMEFDhgzRsGHDtH37dg0fPlx9+/bVzz//bI1Zvny5Hn30US1btkzr1q1T6dKl1bp1ax05cuRmlAUAAHBTeOR0AgCA3G3BggUOjydPnqygoCBt2LBBzZo1y/A5X331lXr37q3OnTtLksqVK6fff/9do0aNUrt27SRJ33zzjcNzvvjiC/34449asmSJHn/8cRdUAgAAcPOxpxsA4JSYmBhJUpEiRTIdk5iYqIIFCzrEvL299eeffyo5OTnD51y4cEHJyclXnS8AAEBeQ9MNAMgyY4wGDhyopk2bqlq1apmOa9Omjb788ktt2LBBxhitX79ekyZNUnJysk6dOpXhcwYPHqxSpUqpVatWrkofAADgpuPwcgBAlj333HP6+++/tXr16quOe+211xQVFaWGDRvKGKPg4GD16NFDo0ePlru7e7rxo0eP1nfffafly5en20MOAACQl7GnGwCQJf369dPcuXO1bNkyhYaGXnWst7e3Jk2apAsXLmj//v06ePCgypQpIz8/PxUrVsxh7Hvvvad33nlHixYtUo0aNVxZAgAAwE3Hnm4AwFUZY9SvXz/NmjVLy5cvV9myZbP83AIFClgN+vTp03XffffJze3S973vvvuuRowYoYULF6pu3brZnjsAAEBOo+kGAFxV37599e2332rOnDny8/NTVFSUJCkgIEDe3t6SpCFDhujIkSPWvbh3796tP//8Uw0aNNCZM2c0ZswYbdu2TVOnTrXmO3r0aL322mv69ttvVaZMGWu+vr6+8vX1vclVAgAAuAaHlwMArmrChAmKiYlRRESESpYsaf3MmDHDGnPs2DEdPHjQepyamqr3339fNWvW1N13362EhAStXbtWZcqUscZ88sknSkpK0kMPPeQw3/fee+9mlgcAAOBS7OkGAFyVMeaaY6ZMmeLwuEqVKtq0adNVn7N///4byAoAACBvYE83AAAAAAAuQtMNAAAAAICL0HQDAAAAAOAiNN0AAAAAALgITTcAAAAAAC7C1csB3NLafbQ6p1MArtvP/ZrmdAoAAOAa2NMNAAAAAICL0HQDAAAAAOAiNN0AAAAAALgITTcAAAAAAC5C0w0AAAAAgIvQdAMAAAAA4CI03QAAAAAAuAhNNwAAAAAALkLTDQAAAACAi9B0AwAAAADgIjTdAAAAAAC4CE03AAAAAAAuQtMNAAAAAICL0HQDAAAAAOAiNN0AAAAAALgITTcAAAAAAC5C0w0AAAAAgIvQdAMAAAAA4CI03QAAAAAAuAhNNwAAAAAALkLTDQAAAACAi9B0AwAAAADgIjTdAAAAAAC4CE03AAAAAAAuQtMNAAAAAICL0HQDAAAAAOAiNN0AAAAAALgITTcAAAAAAC5C0w0AAAAAgIvQdAMAAAAA4CI03QAAAAAAuAhNNwAAAAAALkLTDQAAAACAi9B0AwAAAADgIjTdAAAAAAC4CE03AAAAAAAuQtMNAAAAAICL0HQDAAAAAOAiNN0AAAAAALgITTcAAAAAAC5C0w0AAAAAgIvkmab7k08+UdmyZVWwYEHVqVNHq1atyumUAAAAAAC4qjzRdM+YMUPPP/+8Xn31VW3atEl33nmn2rZtq4MHD+Z0agAAAAAAZCpPNN1jxoxRr1699OSTT6pKlSoaO3aswsLCNGHChJxODQAAAACATHnkdALXkpSUpA0bNmjw4MEO8datW2vt2rUZPicxMVGJiYnW45iYGEnS6dOnlZKSIklyc3OTm5ub7Ha77Ha7NTYtnpqaKmPMNePu7u6y2WzWfC+PS1JqamqW4h4eHjLGyJ5w/lLQSKmyySYjN5uuGTdGsssmNxnZLovbjWRkk7uM5EzcdqlOSUr9/4fuNmUxnvXcqSl/1HT27NlctTxdHrfZbHJ3d0+3zNvjz99yvydqyj81nT59OlctT5nFrRzjz9+Svydqyj81nT592iHHnFyesrINa084f0v+nqgpf9SUtrzlluUpo3hsbOz/vzeOtVwp1zfdp06dUmpqqoKDgx3iwcHBioqKyvA5I0eO1PDhw9PFy5Yt65IcAVxU+OWczgC4tRQdlNMZALeWovydA26avPQ37ty5cwoICMh0eq5vutPYbI5f1xhj0sXSDBkyRAMHDrQe2+12nT59WkWLFs30Ocj/YmNjFRYWpkOHDsnf3z+n0wHyPZY54OZheQNuLpY5SBd70nPnzikkJOSq43J9012sWDG5u7un26t94sSJdHu/03h5ecnLy8shFhgY6KoUkcf4+/uzcgRuIpY54OZheQNuLpY5XG0Pd5pcfyE1T09P1alTR4sXL3aIL168WI0bN86hrAAAAAAAuLZcv6dbkgYOHKhu3bqpbt26atSokT7//HMdPHhQzzzzTE6nBgAAAABApvJE0925c2dFR0frzTff1LFjx1StWjX9+uuvCg8Pz+nUkId4eXnpjTfeSHfqAQDXYJkDbh6WN+DmYpmDM2zmWtc3BwAAAAAA1yXXn9MNAAAAAEBeRdMNAAAAAICL0HQDAAAAAOAiNN3IN4wxstvtOZ0GkO+xrAE3n91uZ7kDgDyKphv5hs1mk5sbH2nA1S5f1iIjI3Xu3DlJF5txAK7h5ubG3zjgJuDLLbgCa2/kKVfbqN+4caOGDx+ujz766JpjAWQubU92Zhseu3bt0oABA1SsWDE1atRIK1assJ4H4PoYYzJdhg4ePKhx48apTZs2mj17tiQpNTX1JmYH3DrSvtzau3evli9fnrPJIN+g6UauZ7fbrQ0Rm82Wbnp8fLx69eqlbt26adSoUfrhhx904cKFDMcCuLa0Pdlubm5KTEy04mnL4Y4dO7Rnzx716dNHpUqV0t69eyWJvXCAky4/VcNmszn83Upb3jZs2KDu3btr8uTJ2rx5s+bPn2+NB+C8K79UvvLLrqlTpyoiIkIVK1bUs88+q2PHjt3sFJEPeeR0AsC1pG3InzhxQmvXrlVQUJAaN25sTff29lbRokU1YsQI7dixQ7/++qu2bt2qBg0ayG630wgAGbjaF1kbNmzQ1KlTtXjxYoWEhKhly5Z69tlnVbhwYUlS/fr1VbZsWVWtWlW///67duzYoYSEBBUsWPCm1gDkdWmNdnx8vBYsWKB///1XjRo1UtOmTa1ls1SpUmrSpInat2+v77//XitXrpTEl1zA9UpbdpKTkxUdHa0SJUpIkrXNuH37dtWuXVtNmzbV8uXLtWXLFpUsWZJtStwQPjnIcVe7KFNKSormzp2r5s2bq1y5cho+fLh69eql3r1769ChQ9a44cOHq2PHjrrzzjtljNFff/11s9IH8qQr96pJF5fF+fPn6/nnn1dUVJReeeUVde7cWSNGjNBbb72lCxcuSJJCQkJUs2ZNeXh4qFq1aoqMjFRkZKQ1DwCXXPn37fJl5OTJkxo0aJAqVKigQYMGac2aNercubNefPFFa0yJEiU0YsQI1atXT1WrVlVMTIy2bt2abl4ALjLGZHr6xYkTJzR27FjVqlVLoaGh6tKli959911FR0dbDfUzzzyjUaNG6aGHHpKHhwfblMgWNN3IcZdflGnfvn0Oh7MePXpU8+bN0x133KEdO3Zow4YNGjBggDZs2KBJkyZJunhem7e3tySpYsWKKlq0qDZv3iyJPQFARk6fPq2PP/5YDz74oF577TXr0Dmbzaa9e/eqU6dO+vTTT9WtWzc9/fTTevvtt/Xnn39q586dki5u0KSkpEiSGjdurOjoaO3YscOaBuCStL9De/bs0erVqx2+7Nq7d6/++ecfjR8/Xrt379bMmTP10ksv6YcfftDatWslOR4KW6FCBfn7+1vnmXLBJyA9m80md3d3SZf+JhljdOHCBX355ZeaOXOmnnjiCf32229q1qyZJkyYYF0PyG63q1y5cipQoIAqVqyo4OBgbdu2TRLblLgxfHrgcml7sjPbGD927JieeOIJ+fj46K677tITTzyhZcuWSZI8PDz08MMP69VXX1VYWJjc3NzUq1cvVa5c2WoU0las0sU9AuXKldP+/ft18uRJ1xcH5CLXupVX2rf/zz77rCZMmKDy5ctr7ty5uvfee7Vq1SpJ0lNPPaX+/furSJEiVmMdEBCgs2fPKiwsTJLjBk2DBg1ks9m0fft2SWyU4NZzrVt5/fLLL7rttttUt25dPfHEE+rUqZP27dsnSQoLC9O7776rDh06yBgjd3d3tW3bViEhIdqzZ48kx6NSypUrpzJlymj16tWuLwzIxTLbpjTGaPHixWrfvr3q16+vESNGKDIyUjabTRcuXFBgYKBeffVV9evXT9WrV9ewYcP0wAMPWF9ypf0Ns9vt8vHx0W233aajR4/q33//verrAtfC1hFcLm1Pts1mc/jGMe3/06ZN0/r167V06VJNnTpVp06dUo8ePRQTE2OdTxoUFGTNr0CBAlq6dKnq1avn8DppGz1Vq1bV+fPnrb3d7AnAreLyo0bWrFmjhQsXKj4+3mH6Z599plWrVmnSpEkaPXq0fvzxR4WGhuq1116TMUZeXl5WE+HhcfGyH5s2bVL58uVVvHhxh3lJF5uGUqVKac+ePYqJibmJ1QK5Q9pFBzP6W3PmzBm9++67uuuuuxQVFaUJEyZo9+7dev755xUdHa1SpUqpSpUqDnu/T5w4oX379ql+/fqSHJvu4OBgValSRTt37lRiYqLDl85Afnd5w5vZhQQ3bdqk/v37q2TJkurataumT5+u9u3b6/z58ypWrJj69Omje+65x2F+u3btUvny5a0vmi9Xo0YNJScna/369elyAJxB0w2XW758uZ599lndd999GjVqlPWNo81mU2xsrD788EP16NFDDRo0UPPmzfXLL78oNjZWn376qZKSkiQ5Ns7fffedChcurDvvvNPhddJWwHfccYc8PT2tFSRwq/jnn3/Uq1cvFS5cWF26dNGQIUP0wAMPWLf0ki6ewhEaGqr69evLbrerYsWKeuWVV7Ru3Tprb/fl9wP+999/9fXXX+u///1vutdLWy7r1Kmjo0ePatu2bdq3b5+2bNlyE6oFct7u3bv12muvqV69emrevLlGjx5tXc1fkpYsWaJ///1XPXv2lLe3t1q2bKlx48Zp+/bt+uWXXyRdWo7SlrmPP/5YERERqlKlSrrXc3d31+23366kpCRt2LBBkpSQkODqMoFcIW07b+PGjRo/frxmzZqVrlF+7bXXVLp0aY0ZM0b9+/fXkiVLdOzYMY0dO9Y6fTE1NVXGGNlsNp04cUKRkZFq0KCBPDw80l1ktEaNGvLz89PGjRslcTQXrh+fHLjM6dOn9eSTT+q5555TTEyMmjdvrmnTpqldu3Y6c+aMJCkpKUlnz55V3bp1JUmJiYkqUKCAOnXqpN9++00HDhxwmGdcXJy++OILPfDAA6pUqZLDhTLSVpBVq1ZVcHCwVqxYoXHjxumee+6xmncgv0pOTtbixYt17NgxzZ07V3v37tUHH3wgu92uYcOGSbq4fHl6elrLipubm4wxatSokQIDA7V69ep0GzB9+vTRgw8+qKZNm6Z7TbvdrlOnTikhIUFLly5V69atVaFCBY0fP97l9QI5bfXq1erevbs2bdqkXr166aGHHtJnn32m3r17W2O8vLx09uxZ1atXz9qYb9q0qcqVK6dVq1YpOTnZYSN++fLl+uuvvzR48GBJGR+pVaZMGfn6+urtt99Wx44d1aNHD9cWCuQCKSkpmjZtmmrVqqU2bdpo7ty5Gjx4sO677z4dPXrUGrdjxw7df//9KlSokJKSklSiRAk98cQT+uWXX7Rr1y5Jjo3zxIkTVahQIT388MOSLm1Lpv1bqVIllSlTRrt27dI///yjyZMn6+zZszepauQnNN1wmQsXLujcuXMaN26cvv32W/33v//VDz/8oNOnT2v27NmSLh5GV758+XR7pdu0aaNDhw5p//79ki4dzvP999/r4MGDeu655yQp3aF1P//8s55++mnNnDlTixYt0qeffqrixYsrLi7OtcUCN0lKSkqmh7fVrVtX77zzju688055eHioefPm6ty5s06ePKnY2Fh5eXmpUKFCMsZY56clJydLunhu9vr1663HkvTtt99q9+7dGjJkSIavd+TIEQUFBenzzz/X448/rilTpig6OlpffPFFNlcN5E6VKlXS1KlT9cwzz2jAgAH69ttvtXTpUmuj3M/PT0lJSTp27JhsNptSU1Otq/4fPHjQ+huXttyNGDFC99xzj2rXri3JsTmIiYnR0KFD9fDDD2vDhg3avXu3ChQooK5du97UmoGcEB8fr/nz56tdu3bavXu3Fi1apLFjx+rff//VxIkTJUnHjx9XWFiY1VynfWnVrl07nTp1yopLF5vqw4cP67333tPQoUOtv42XO3XqlJYsWaL169fr559/1h133KFevXpxNBeuC/fpxnWx2+3pvg28UokSJTR16lSHe/cWK1ZM5cqV05EjRyRJ/v7+uu2227R27VoNHDjQaqIjIiJ08uRJ6xxRd3d3xcbG6vXXX9f777+v4OBg2e12bdq0SaGhoQoODpYkrV27VufOndOPP/6oNm3ayMfHx2XvAXCzpB0GJ8k6zzo5OVkFChSwxhQoUEBNmjSxHqfdT3TFihW67bbbrHjlypU1Z84c/fHHH6pQoYK1UdKwYUN99dVX1p0AoqOj9d133+mZZ56Rr6+vJkyYoF9++UWenp6aNWuWJCk8PFz79u1TmTJlHPLlXqbIy9IuSHj5NRIy0rRp03RHgNjtdhUtWlSHDh1SYGCgihYtquLFi2vhwoXq2bOnUlJS5O7urmrVqmnlypVWc16gQAF9++23ioqK0syZMyVd3GO3evVqPfXUU5IkX19fxcfH65VXXlGHDh2sv3tAfnD537mMeHl56b///a91BX9Jat26tZo0aWI1wWlXHE+7pZ6Xl5ckqVGjRkpOTtaRI0ccXqdv375q1aqV7r//fkkXt2cTEhKs7daJEyfqlVdeUatWrTRp0iTdfffdKlWqVJbyBa7EVhGuS9qF0Ww2m86fP69ly5alu1q4h4eHChYs6HC/xOPHj2vPnj1q166dJKlkyZKqWbOm1q9fb124yRijokWLWufcpBk8eLAKFSqkyMhI3XfffQoICFC9evW0cuVKa8zIkSM1Z84cPfDAA/Lx8ZHdbldKSgoXU0OekZqamu7+oml/2BMTEzVt2jSFhYVp8uTJGd6HNG2ZcXNz07Fjx7Rhwwa1bt3a2kipU6eOSpUqpR9//FGSrI2L2NhY+fr6WvNZuHCh5s2bpzfeeEMhISEaO3asKlWqpNdff93htcqUKWPdQiwtHxpu5GVpV+fP6ufYGGOdwvTjjz+qdu3aqlChgiRZ10/4/vvvJV360qx69eratWuXQkJCJF28X/fgwYNVoEABPf/88ypWrJjuuOMOjR49WufOnZN08cvn999/X71791ZwcHC65Q7Ii9I+v9dqYD09PVW7dm3rb1nac9etW6eIiAhJUpEiRVS1alXt379fp06dks1mU3Jystzd3eXn56czZ85Yr7Nw4ULt379f3bp10/z58/Xwww+rSJEievPNN6359+vXT6mpqVq4cKF69OihUqVKWcsdDTecxZbRLe5qf6ztdnum0w8cOKCJEydq+fLlqlixooYPH67jx49nOPby2wu9+eabatq0qWrWrCnp4kbEPffco5iYGE2bNs0av2jRInl5eVkNwcGDB/XHH39oz549+v7773X77bdrxYoVstvt6tSpU7qaLt/49/DwoAlAnuHu7p7utImzZ8+qSpUq6t69uzZu3KgXX3xRbdu2zfDLpMvvEjBx4kT5+/vrySeftJaJMmXKqEuXLpozZ46++eYbxcXFad++ffr+++/1+OOPW/NMSEjQK6+8ol9++UUJCQnatWuXPvjgA9WqVcvhtdL+9fDw4ErKyDMy+tuW9tnftWuXhg4dqjZt2ui9996zbt11NZ6enjp48KDmzp2rRx991DpipHDhwurVq5cWLlyoNWvWWMvInDlzFBQUpKJFi0qSdu7cqfj4eCUnJ6tgwYKaPn26EhMTtWfPHvn5+WWYO8sd8pq0hvVyaZ/ff/75R4sWLXK448a1zJgxQ8nJyerYsaMVa9Kkiex2u/VFV4ECBXTmzBnrGibSxS+wJ0+erK1bt6pDhw564okn5Ovrq6+//lrvvPOONa9ChQpJkvXlVtre7bQvzwCnGNySoqOjzb59+xxiqampxm63Zzj+4MGD5uzZs9bj+fPnG5vNZu68804zb9486/lXM2/ePBMaGmo2bdpkjDEmOTnZmvbyyy+b4OBg8/LLL5vFixebVq1ama5du1rzvHDhgtmxY0eG801JSbl6sUAO2rlzpxkwYICpVKmSOXfunFm1apXZv3+/w5i0z3BMTIyZNGmSeeSRR8yIESPMli1bjDEXP//PPPOMsdlsZsyYMVl63UOHDpng4GAze/Zsh3jaMv7cc8+ZKlWqmGrVqhlfX1/TsWNHc/LkyUznl5KSYpKTk6+5nAN5zb59+8yqVauMMcZs3rzZNGzY0LRq1coMHz7cNG/e3DRs2ND8+eefxpir/517+umnzZ133pnhuPbt25uQkBDz1ltvmVdeecWULVvWzJgxw5oeGxtrEhIS0s2TZQ75QWbblsYY8/XXX5uyZcuawoULm/r165tatWqZ7du3X3N+586dM7Vr1zb/+9//jDHGJCYmWtMHDx5sQkJCzJdffmmSkpLMBx98YG6//Xbrb2pCQoKZOnWqmTNnjsO2LeBKNN23mH///dfce++9xmazmUGDBpnFixeb1q1bZ9i4Hjx40Dz++OOmcOHC5rbbbjP33XefWb16tbHb7SYmJsaEhISYtm3bmvPnz1/zdRMSEsydd95p+vXr5xBPWxHHxsaaiRMnmiZNmpgSJUqYrl27mn/++SfDeaVt/F9tJQ7cTHa7PcPPY3JysmnXrp1p2rSp+eqrr8yRI0dMkSJFzMiRI40xF5eL48ePG2OMiYqKMh07djTVq1c3zzzzjHnwwQdNWFiYWb58uTHGmEmTJhkvLy9z6NChLOXUvn1706VLF+vxgQMHzM6dOx3GbNq0yUyePNnhC63L60hNTWWDH3nChg0bzHPPPWfWrFljxVJSUjL9Unb16tVm+vTp5vvvvzc2m8307t3bHDhwwHTp0sX07NnTGnfmzBnTpk0bc++991719ZcvX26KFStm1q9f7xBPW35OnTplPv30U9O8eXPTvHlz8/XXXzs0CZePp9FGXpH2BXLa3w273W5SUlIy/HuYkJBg4uLizODBg02RIkXMli1bzL///msaNGhgxowZY33mH3nkEdO5c2er8b5yWUjbYTNq1ChTvXp1ExMTk+71YmJiTL9+/UzlypVNsWLFTLFixcyHH36YaR0sd7gZaLrzoas1o59//rkpW7asOXXqlDHm4l44m81mtmzZYn744Qfz+uuvm6SkJGPMxT1hHTt2NEuWLDGHDh0yPXr0MHfffbdZu3atMcaYO++80zz88MNX3dOclss333xj6tevb86cOWP27dtnJkyYYDp06GCOHTvmMD42NvaGagdyk9WrV5s77rjDzJkzxxhzcXlo3769CQ8PNxUrVjQBAQHm448/NsYYM2LECNOgQQOH5alXr16mfv36Jj4+3vzzzz/Gw8PDrF69+pqvO3v2bBMcHGyGDh1qXnrpJVOmTBljs9kcmomM8EUW8qKJEyea8PBw07Bhw3RNb5qoqCjr/ykpKebFF180NpvNPPjgg9bG/dGjR03RokXN2rVrzbRp08z9999vSpYsaYoVK2Z69+5tLly4kG6+aRvpnTp1Mi+99JKJiYkx33zzjWnXrp3p2rWriY6OdkHFQM5JSEgwr732milQoICpUqVKlp7z559/miJFipg+ffqY/v37m0mTJhljjBk4cKDp1q2bMebiMvrrr7+aRo0aGX9/f/P1119nOr+jR4+aChUqWEdynT592sycOdMcPXrUYdxff/1lHV2ZEZps3Ew03flYRnug3333XdOgQQOTlJRktmzZYp577jnj4eFh3N3dTVhYmHnppZdMXFycWbdunWnQoIHZunWrMcaY+Ph4M27cOOPm5mb69+9vjDHmzTffNOXLlzdxcXHXzKN48eLGZrOZsmXLGjc3N1OlShXTu3dvc/r0aWvc5Rv8fOOIvGTZsmXmlVdesTbe0w4TPXLkiKlfv7655557TJs2bUz37t2Nh4eH8fDwMOPHjzcHDhyw5lGxYkXz448/mrVr15rnnnvO1KxZ03h7e5u77rrLHD582Jw/f95Uq1bNvPrqq8aYzDcWUlNTzUsvvWRsNpsJDw83HTt2ND/88EOGDUPaeJpt5EV2u90kJSWZhx9+2HTs2DHd9AULFpgmTZoYf39/07BhQzNs2DBr2tKlS42Xl5d55513rNi5c+dMSEiIcXd3N3fccYfp37+/mT9/vsPfqStf3xhjfv75Z2Oz2UyBAgWMu7u7CQ0NNV27djVLlizJ8HlX2wMP5Hbbt283ISEh5qeffrJiaX+P9u3bZ95++23Tq1cvs3DhQmtHyrZt20yLFi1MYGCgWbZsmfW8l156yfj4+JiaNWsaX19fc/vtt5s+ffqYRYsWXfUoyrSjMAcOHGiqVatmvLy8jLu7u3VkmDHpv0RmmUNO40oA+dC2bdvUunVrVatWTT/88IMCAgKUmpqqCxcuaM2aNfrnn3/k5eWlZs2aqVKlSqpUqZIqVqxo3TtbunghmUOHDunjjz/WsmXLdOTIEYWHh6t///565JFHJEn33nuvhg0bpv379+v222/PNJ/o6Gg1aNBApUuX1r333qvWrVs73OoozeVXguQiFcgroqOj9dprr+no0aPavHmz5s2bJy8vL6WkpKhly5bas2ePAgMD9cwzz6hPnz56+eWXVadOHdWqVUulS5e2bv0VHBysTp06qXTp0qpdu7b69u2ru+66S+XLl5d08UIuERERWrBggUaMGJHplVPd3Nz01FNPadCgQSpevLjDtNTU1HQXXeIig8gr7Ha7jDHWZ9hms6lAgQIqU6aMli1bpkmTJmnt2rX68ssvFRUVpVdffVWNGzfW2LFjtXr1ar300kvy9PTUCy+8oNtvv11+fn4KDAy05p+amqrKlSurSZMm1kWY0hw8eFBxcXGqUqWKFUtbBkuVKqXOnTurc+fOat68uQoXLnzVOrjwGfKyQ4cOKSAgQFWrVlViYqKOHz+u0qVL65dfflH//v0VFhamoKAg9ezZUy1atNDXX3+tMmXKqHz58jp48KB1pfHU1FSFh4fr/9q797ic7/4P4K+rq6NSVCqlWuXQUZFK0SQmlsa9ZBJFhiG3051bG7uXGVlhyI0R3ZOte2sOm1GOzWmqOc2hlWRGCR2VDq6u6/37o/v7dV0Vc+8394r385+t6/C9vpfH9fl+P6f3+y2TybBw4UIMGDAAVlZWYrsS2nvze93Dhw+Rm5sLmUyGgoICzJo1C8HBwS3ud8L7hGNwu2N/uj950M+eg02bNtG4cePI3t6ePvzwQzFuLCUlhby9vcna2prmz5+v8vpu3bpRZWWlOFt58eJFkkgkNHLkSNq+fXuLxE9ERI8ePSIzMzP69NNP/+tz5Lhs9iIxNzennJwcsra2ph07dlBdXR0RNeVQ+Pvf/05DhgwRExdWVFSQh4eHSn6D+vp6ioqKInt7e5UEg0RN2+aEmOtdu3aRRCJ55jAMhUJBMpmMZ/hZmyXEgP5eGzduJH19fZJIJOTo6EixsbFE1BSuYW9vT3l5eeJrP/zwQ/Ly8qLjx48TEVFAQAAFBweL50FEtGXLFurcuTNt2bKFHjx4QHK5nDIzM2nmzJmUlpb2TOfE8aGsrVMoFE/9fcrl8hbtUgg9/Pjjj8nU1JT09fWpQ4cOlJSURHV1deTr60vjxo0Tj3/48GHS09MTt4lv3bqVtLW1VRIGZmdnk7q6uhiCJTh8+DBt3LhRJSxEIJPJWg3baO2cGWtLeImjjSOlOtW/RSh3cvv2bejo6CA5OVmc/QeAsLAwHDp0CAMHDkRxcbH4Pl9fXxQVFeH69eviqpeDgwM6d+6MQYMGYdKkSbC2tgbQVEs0OTkZV65cgYaGBuzs7JCamvpM56dcL1sqlUJdXZ3rHLI/3X/TxlpTXFwMIyMjdOnSBbGxsdi5cyf2798PALCzs0P//v1RXV2NkydPAgB0dXXh7++PgwcPAmhqt1paWhg/fjzy8/OxefNmlJaWAgCuX7+OhIQEHDlyBHK5HK6urvD29sadO3ee6dy4pBBr65RXoAoLC5GVlfXE1/7www+IiYnBggULcPHiRQBA79698d5778HGxgYrVqwQ68j/8ssvMDc3R8+ePcX7zrBhw6CtrY1z584BAIYOHYrjx4+rfMakSZMwdepUfPDBBwgODoa1tTWCg4NRW1sLNze3J56bcolNLlXJ2iKFQiG2BYlEIv4+hXug8r1QTU1NbJd5eXm4ceMGNDQ0cPXqVXz11VfQ1tZG7969UVlZicjISJSVlSErKwsLFy4Ujz9kyBAMGDAAR48eFdtPx44dceTIEfF8PDw8MHPmTMycORNTp05FSkoK3n77bcybNw/FxcXQ09Nr8T3U1dVhaGgIACp16pXPmbG2iO8IbdSPP/6IgQMHYt++fQDQaj3e5oQLaKdOnVBbWwsvLy+MHz8eS5YsQUVFBYCmDr+1tTVu3LiB+/fvAwB69uwJCwsLZGZmAoC43TUqKgqbN2/G1KlTcf78eezevRtz5sxBRkaGeHFet24dVq9e/UzfiTshrC2SSCSora1FfX29Sqfktwht4OLFizA1NcWjR48QEhICV1dXxMXFobKyEgDQp08f6Ojo4PLlywCaaob6+fmhsLAQ5eXlYpvw9vZGbGwsVqxYgYkTJ8Ld3R0eHh44c+YMXF1dIZVKYWtri1OnTqFnz55//D8EY/9j1dXVSElJQUBAAPT19eHj44PJkydj8uTJ4sSS0B5jY2MREhKCvLw8FBYWIiQkBPHx8fDx8UFYWBi6d++OvXv3isd2cXER62sLbdXd3R0VFRWora0FALz66qt48OAB8vLyxPr26urqWLlyJfbv34/Ro0dj8+bNuHPnDrZv3y6GerSGO/ysrVNTU4OamhoqKyvxr3/9C2PGjMGQIUOwatUq3L59GxKJRGxvFRUVmDJlCvT19REYGIgJEybg008/haOjI7KzsxEZGQmFQoHq6moATYNfTU1Nsa9ZX18PoOn+V1BQgKqqKlhZWcHe3l6clBbqdS9btgzr1q1DTU0NVq5cibq6Onz88cd4//33oaur+9TvxJPKrF358xbZWWuELW7nz5+nAQMGUExMDBH9dwkgRo0aRcuXLxff88Ybb9D8+fPFUkOfffYZ9enTR6yvTUQ0ceJE8vPzU9naWl9fT0lJSRQYGEiWlpZkbm5O06dPF+uVMvYiKCoqIn19ffriiy/Ex4Rtd08LfxCey8zMJEtLS/Hx+vp6euWVV2jOnDniY+PHj6c333yTKioqiIjo/v371LlzZ4qJiaGff/6Zvv76a3H7+ZUrV2jNmjX0z3/+UyXRmjLeQsdeBJGRkWJW/TNnzlBFRQX961//IgsLC1q5cqX4urS0NHrllVfEGrtERNu3byc9PT0qKiqi+vp6io6OJhcXF/F5IURKqL9N1FS2S1tbm77++msiasqArK2trZJM7Um4fB5r7woLC8nFxYUkEgnZ29vTrFmzaPny5WRjY0MjR45Uee17771Ho0aNoqNHj1JNTQ1t3ryZunXrRocOHSIiouTkZHJzc6P09HQiIrp16xZ5eXlRVFQUET0u67VhwwaysbEhoqakugsWLKCuXbsSUcv7a2t16hl7kfCyYxtAROL2GGG7ta2tLZydncWtds8ykycco7S0FN27d4dUKsWVK1dQV1eHNWvWICUlBQDg7OwMAwMDnD59WnzvpEmTkJOTg8jISAQEBGD8+PHQ0tJCZGQkUlJScOHCBRQVFWHTpk3w8PBocf6MtQdyuVxsJwJzc3P4+PggKSkJUVFR6Nu3L5KTkwHgqeEPwnP379+HlpYW4uPjMWTIEHTp0gV1dXVISkoSQy/69u2LsrIy/PzzzwAAY2NjLF++HOnp6XBycsKaNWtQVlYGAHB0dMTcuXMxY8YMWFlZgYharL7zzD5rq57lfiC0QU9PTwwcOBBTpkyBl5cXOnXqhLFjx6Jnz57Iy8sD0LTSfe3aNfTv3x+2trZYv349RowYgQULFqBz58749ddfoaWlBVdXV5SVlYmr271798bw4cMxY8YMbNu2DTdv3sSiRYvg5eUFd3d3AICJiQn27duHyZMnP/G7CG1PWCVkrL0yMTHB7du3sWzZMuTm5iIxMRExMTFYtGgRrl69ihs3bgBoSg763XffYfbs2Rg8eDCqqqqgq6uLoqIi8d7o4uICAwMDnDp1CgBgZmaGt956Czt37sTx48ehrq6O0tJS/Pvf/4anpyeApp2W3t7e6NevH+rq6lTur0QELS0tEJFKKCJjLxK+g/yJlGNrmnei9fX14eDggOLiYty+fRvAb3dmpFIpysrKoKamhvDwcOjr68Pb2xuampp45513sHbtWpw8eRK9e/eGjY0NLly4IL7X398f27ZtQ2NjIzw9PcW4OIVCgU6dOsHQ0PCJF0OOy2ZtmZABFWhqI83b2qFDh5CRkYETJ06gpKQE8+fPR0hIyG8eVzjmpUuXUFRUhLS0NDg7OyM1NRW3bt3C5MmTsXbtWvz000/w8/PDr7/+KnZQAODtt9/Gnj17IJPJcOLECfTr10/l2HK5XMy6yp191tb9NyFRwu/Zx8cHDx8+RH5+PoCm7aY7duxAVVUV3nvvPfG1BQUF2LdvH8zMzLBjxw64ublh9+7duHLlCvr37w8A6NGjB4yMjHDs2DHxc9avX4+AgAAkJCTAwcEB586dw7vvvivmKJFKpRgyZAjMzMxaPU9ue6wt+j0LHQqFArq6unB3d0dBQQEaGhrE5/Lz8+Hh4QFjY2MAwJkzZ6BQKLBq1Sr06NED9vb2WL16NRYsWIA5c+YAaMpXYmVlJfYj1dXVMWvWLAwcOBDh4eEIDg6Gt7c3qqursWLFCvGzgoOD8c0330BHR0fl/IR+pJCHhNsdexFxXab/EWFmX7nDL1xULly4gIyMDHTo0AFjxoxB165dATTFWmtqauLEiRMIDQ2FQqH4zRWuhoYGFBUVYfr06XjjjTfg6uoKIyMjAMCDBw8wc+ZMHDp0CFZWVjh79iyKi4thbm4OABg7dizGjh2rcjzlC59wMWSsrVJelRII/y+Xy5GRkYHExETU19cjMjISEyZMQP/+/fHFF18gNDQUiYmJT+yANycMiKuqquDh4YHvv/9e5fno6GhMmjQJERERyM7OxowZMzB06FDxeXV1dVhZWYnnptzB5/ImrL0Q2oFwb/jhhx8QFBT01IGB0MF2cXFB586dsX79eqxduxaFhYXQ0dFBp06dEB4ejtjYWAwZMgTW1tawsbHBypUrMWLECPE4DQ0NKCgoQPfu3WFhYQEbGxt89dVXmDZtGuRyOezs7JCQkIBp06bBysoK2traT/0OjLUHQh4SNTU1aGpqAvjt0o9Cexw4cCDS09Oxd+9e5OfnIy0tDbm5uQgPD0d+fj7c3d3Ro0cP3L59G4aGhli+fDl8fHxgYWGhcjwDAwM4ODhgz549+PXXX2FlZQVNTU18/fXX2L17N7KysjBmzBiMGjUKHTp0UHlva/dpxl4G/Iv/gygUCmzYsAFTp05t9XnlFTbh4peVlYVhw4Zh+PDhOHjwoJjY4vDhwwAAGxsbWFhYiJ35Z+kU6Ovro6ioCJGRkfD394eRkZH4eTExMdDS0kJubi5mz56NrKwsccAtUF5hY6y9EH6vT9oC6uDggFWrVmHnzp1wdXWFk5MTwsPDkZKSgo4dO2LYsGHo1q0bvvjiCwDPnrhQJpNBLpe3qA8KAJaWltiyZQv27t0LDQ0NREdHw9XVtdVjSaVS7oCwduOPCIkS2pi7uztKSkoQGBiIixcv4ubNm9izZw86duyIWbNmoaioCIGBgdDW1kZaWpqYBK2+vh5JSUn46KOPAABdunTBoEGD4OTkpPL5RISePXtCW1tbJcO4Mh5ws/akuLgYXbt2xZ49e8R7ntCentR3E37jQUFBOH/+PKZPn45Tp04hLCwMO3bswK1bt+Dv74+zZ8+iZ8+esLe3R7du3RASEiIOuGtraxEfH4/z588DaLrHlZWVidUAFAoFNDQ0MHbsWKxatQqhoaHo0KFDi3PiUA32suJlyz+ImpoaTExMMG7cOHHWXPhvQ0MD9u3bh127dkEikWD69Onw9fXFo0eP0K9fP+zatQt6enqoqqpCdHQ0EhISMHToUFhaWsLe3l6MvVYu7/CkTsKZM2dgaGiI8vLyFq91cnJCTk6OyuubH4tX2Fhb13xVGHjcoTh9+jQOHToEMzMzhISEwMDAAFKpFHp6eli0aBE2bNiAGTNmAAAePnyITZs2YdiwYTAxMcGAAQOwb98+zJs3T+XzFArFEzsIGhoa+PLLLxEZGYnGxsYWO0FsbW2f+ViMtXXC7/dpIVHff/89bt++jW7duj3TCrK7uzuOHj0KHx8f2NjYQCaTwcHBAUuWLMHAgQNRWFgIX19fLF26FKGhoSgoKICBgQHOnTsHfX19zJw5U8ycPH/+/BbHV/58bnusvWltl6RyHpKTJ0/i9OnTiIqKQmRk5BPbm/Db79u3LywtLREaGoqlS5eKzwcFBcHe3h7bt2+Hu7s75s+fj0WLFiEgIABRUVF48OAB9u3bh3v37okx2q+//jp8fX1hbW0NIlJpX0JYl1Qq5Uktxv6DB93/D0SkcqFpHgcqkUjELd05OTl49dVX4ezsLCZM8vLygoeHBx49eoTPP/8cu3fvxpEjRyCTyVBRUYHOnTuL5RWuXLkCJyenJ3ZihM5QeXk5Xn31VTFmrbXXKg8O+GLI2gvht9/apFB1dTWioqKQnp4ODw8P3Lt3D6mpqXj33Xfx2muvYfTo0bh27RoGDRokvic0NBTjx49HQUEBTExMMHToULHT3lpHvfmAWfj7wIEDYkmv38KdftZePO+QKKGNeXl5gYhw/vx5BAYGQkNDAwBw4sQJABCPPXz4cFy9ehVpaWm4e/cu5s6dC39//1bPW5gYYKw9UigUkEgkT7zfCXlINDU1YWBggPnz52PUqFG/eVy5XA6pVAoXFxfk5uaqhBfKZDJ07NhRLCUbHBwMfX19pKWlITo6GjKZDK+//jr+9re/iYkIDQ0NxXrZzdsb3+sYa8Vzy4v+krl+/TpVVFRQdHQ0LVy4kIiayvqsXr2aTE1N6dy5c62+r6CggF577TVyc3OjOXPm0CeffEJdunShzz//nIiIjh49Sh4eHrRx40bxmPfu3aO0tLT/zRdj7H9MoVC0KCUi/F1RUUHbt2+niRMnUmJiIlVVVRER0Ycffkh9+vShyspKImoqTTJ9+nTq27cvERGdPXuW1NTU6PTp0+IxZTIZde7cmTZv3kxERNeuXSOJREKpqalE1FRKrLq6mkpLS8nBwYE2bNhARKrlup5WUoyxtkwul1NiYiK9/fbbv/la4Xd+5swZeu2118jU1JT8/f3J3d2dfHx8xDJCubm5NGLECJo+fbr4Gc9i1KhRNH36dCovL6cLFy7QkiVLqGfPnhQXF/ebx+AyXqw9e1opusbGRvruu+9oxIgRNHjwYNqxYwcRET148IBSU1NJIpHQnTt3nvmzhHvXP//5T3JxcaFLly6Jj2/cuJFsbGzEvqfye2pqan7PV2OMNfPST0XRU2KX6SmlC2pra3HgwAEUFhaiR48e8Pb2xsOHD/HLL7/g8uXLqK+vh1QqRUpKCiZMmIA+ffq0+rkffvihuG3nk08+QWBgINTV1cU4biGu+9tvvwXQNJu4e/duhISEtBqbBjTNknK5BdaWkFIM6JMoZ/NvXkpEIpHgzJkzGDBgAFavXi0mjykvL0d1dTUuXryIqKgoNDY2YsOGDXjrrbewY8cO3L9/H7W1tejbty90dHRw7tw5cYeKuro6nJ2dkZOTg6qqKnTv3h2TJk1CbGws9PX1MXDgQFy9ehVEBAsLC9TU1ABomVyQsfaoeUgU8Pi+1NDQgK+//hphYWGYMGECTp48CQBiSFRBQQGOHDmCI0eOwMnJCQkJCQAghkQJGY2VQ6JaI7R5BwcHJCUlwdTUFF5eXjhx4gQWL16M2bNnt7piJpfLORkTa9foT8pDAgBDhw7F/fv3kZCQgKCgIBgbG+Ojjz7ClClTWuzYlEql0NXVhUKh4FJejP0/vfTby5U7zc23jypnZBW25Qj27t2LsLAwDBs2DIsXL0ZgYCCMjY3h6emJXbt24aeffoKnpyfU1NRQX1/f4hgSiQSVlZWor6+HlZWVmKgiPT0d9+/fx969e7Fp0yZ069YN7u7uuHfvnnh+BgYGGD58OKqrq9GpU6cW34k7IaytUd4mV1ZWBl1d3RaZhIXf7dmzZ1FYWAhPT09YW1tDIpGgoqICs2fPhouLC5KSkqCrq4uGhgZoaWkBALKzs3H48GHMmzcPPXv2hL+/P6Kjo9GnTx8xc6q3tzcyMzMxadIk6OrqAgD8/PyQlJSEuXPnwsDAAPHx8cjKyhIH3QBQVFSE8vJysTPCA23WXlEbColS9tZbb8HCwgIDBgxoMUHdGs47wtqTtpKHRPjMHj16wMLCAufPn8eQIUMQExMDHx+fp34HTn7G2B/gT1hdb1OysrJo8uTJrT53584d+sc//kGOjo7Ur18/Wrt2Ld2/f5+IiHJycqh37940aNAgqq6uFrcHHTx4kPr37y9uWZ03bx45OTmJxxS26dXW1pJCoaDVq1eThoYGLVq0iMLDw2nkyJG0ceNGCggIoLKyslbPa82aNZSSkqKyzZWxtqqmpoY+//xzCgoKInNzc3JycqLIyEg6efIkET1uE+np6WRnZ0edO3cmX19f6tWrlxhGcfnyZVJXV6e8vDyV9wht4LXXXqP+/fvTzz//rPLZ9fX1dPPmTSIi2rBhA3Xp0oWuX78uPn/lyhVasGABlZaWtnruwvGvXLnyh/xbMNZWtOWQKJlMxvc31u49LfzowYMHFB4eTiYmJhQYGEgeHh7k5+dHBw8eJCKiZcuWkYGBgcq95+DBg2RsbEynTp0iIqKtW7eSvr7+Ez+rtW3rwutae66xsZFDphh7jl66aavmJUMqKiqQnJyMe/fu4ZdffsGePXtQWloKAFi5ciX27t2L+fPn4y9/+QuWL1+Ov/71r2hsbESPHj1gZmYGbW1t6OnpobGxEUBThnBDQ0OxhMLUqVNx9epVrF69GmVlZZBIJCgsLERiYiJqamowb948xMXFISsrCwqFAjExMXjnnXeQnp4OQ0NDcQuS8pbxuXPnIiwsjGf7WZv3yy+/wM/PD2FhYejVqxe2bNmCZcuW4fTp05g9ezaAptn3u3fv4r333sM777yDsrIyHD9+HJMnT8bKlSuRm5uLkpISWFlZobi4GEDLrXSjRo1CeXm5mOkfAEpLS5GYmIidO3cCAAIDA6FQKMSSQwDg6OiIhIQEsZa9QGh3UqkURARHR8c//h+Hsd+BXsCQKOBxtmOgqYY9399Ye0H/2UHS/DFhR2NycjLCw8OxYcMGPHjwAACwdu1aXLp0Cfn5+di3bx+OHTuGXr16YdGiRQCAESNGoLq6GlVVVeIxBw8eDLlcjsuXLwMABg0ahOrqavz73/+GRCJBcXExampqUFZWBkdHR2zatAkAVNqdsNqtpqYGuVyucr3gTOOMPV8vzKBbuZNx+vRpuLi4oKGhQXyMlOJnlG/mN2/ehFQqRY8ePWBra4u9e/dCU1MTp0+fRmpqKubOnYspU6bg3XffRWpqKo4dO4Y9e/bAwMAAvr6+uHjxIgCIMabm5uawsbFBYWEhSktL4eDggLi4OKxevRqhoaEYMGAAPD09kZ+fL8aIzps3D0ePHsWOHTvELT5EJGawFM6bt/aw9sbCwgL29vYICQlBfHw8Xn/9dYwePRqTJ0/GhQsXcPXqVQDArl27YG1tjaioKNy/fx87d+7EoUOH8OOPP+Ls2bMwNTWFubm5yqAaeLzNNCIiAmPHjsW0adMQGRmJN998E+7u7khLS4ObmxuICNbW1igtLYWzs7PKMZQ7+4LmZfQYayuah0Q1f05dXV3sUCvbu3cvAgMDMXPmTCxevBhXrlyBhYUFPD09UVFRgZ9++gkAWoREKR/7t0KiAIghUXZ2dq2GRD0JZxxnbQm9oHlIlEmlUvF6wRh7/l6YlqZ80TA0NMSiRYtadJzlcjn279+Pv/71r0hISMCdO3dQVVUFU1NTODk5QaFQYPv27dDX10dNTQ0qKysRHh4uHmPQoEHo3r07srOzoVAo4OHhgdraWnHgIKx29+7dG1VVVeJq98KFC3HgwAEMGjQIo0ePxsmTJ7FlyxaxFIpQ01t5xrF5/A9j7ZGGhgbs7e1RXFyMu3fvAmhK0vT999/D0NAQlZWVAJpWpffv34/evXvDzs4O8fHxcHNzQ0ZGBt566y1YWlrCzc0N27ZtQ0lJiTjYPnjwII4dOwZdXV3Exsbi2LFj6NSpE6ysrLBt2zb88MMPGDFixFMHKtzZZ+1JdnY2IiMjAbTsTJeUlOCDDz6Ak5MT+vfvj3Xr1ok7t3r06AEXFxfU19cjODhYLPXj6uoKIhKTn/n6+iIzMxPA450eAFBXVwcDAwN4eXlhz549iImJQUREBDIyMrB+/Xq4urqivLwc6urqWLx4MdatWyee3507dxAWFoaOHTs+738exv4QzfOQCBNRypTzkHz11Ve4efOm+F7lPCQ//PADtm7dirfffhuvvPIKOnbsiOzsbCxYsAC2trZITk6Gk5MT9u/fj8uXL7fIQ1JbWyveo/z8/LB//37cvn0bABAfH4+EhATs379fzIXS0NDAeUgYa4v+l3vZn5dHjx7RnDlzaOnSpU98zZkzZ6hXr170yiuvUHBwMK1YsYIKCwuJiGjjxo1kamqq8vpTp06RhoaGGA/66NEjIiIKDg6msWPHUkNDA127do2cnZ1p1apVRNQUP0pElJmZST4+PvTZZ5899bw5doa9DL799lvq168fjRw5kgYMGEAdOnQgiURC48aNE19z+PBhkkgktG7dOiouLlZ5f0NDAxERlZaWkqOjI3Xv3p0mTpxI3t7eZGlpSV9++eVTywZxO2PtmVwuV4lvTk9PJ4lEQnfv3qUbN27Q7t27xVwjc+fOJTc3N9q6dSt99NFHZGpqSqGhoSSTyaiyspKGDRtGAQEBRPS4XRUVFdHrr78ulvm6evUqSSQSWrVqlZjr4Pr16/Txxx/TgwcPiIho1apVNHjwYJowYYIYXypQjhnlcl6sPeI8JIyx56HdLaXW1dWhpKQEwOOtb2pqaqiqqsKXX34JAJDJZEhOToaHh4f4nvj4eHh6euLGjRtIS0vDnDlzYGNjAwCws7NDQ0MDsrOzxc/p2rUrLC0txXIMwozno0eP8OjRI2hqasLAwAB2dnZITk4GADHT+cCBA5GZmYmJEyeqnDv9Z7sS/WflgGcf2cvA1dUVHTt2xNmzZxEWFoZvv/0WcXFxKC0txTfffAOgaXVNV1dXXE0T/Pjjj1ixYgWuXbsGIyMjHDt2DIsXL4a6ujrGjh2LU6dOISQkpMWKn3JJIW5nrC3ikCjG2h7OQ8IYe17aVcmwwsJCTJo0Cb1790ZiYqJ4c5dIJBg5ciQ+//xz1NTUQE9PD1KpFJcuXUJxcTHMzc2RnZ2NcePGITc3FzU1NbCzs4OmpiakUilsbW1hbW2Nffv2wdPTEzKZDDY2Npg4cSLWrl0LQ0NDTJo0Cbt27UJeXh6WLl0KADAyMsKMGTPExBhCx0gqlYoXvuZb3Dk5DHvZWFpaokePHtDW1saUKVOgqakJf39/6OjoICoqCtXV1QgLC8OKFSsQFxeH48ePIyAgAFlZWTh37hyGDRsGfX19AICJiQkiIiIQERHx1M/kdsbaumcNicrIyEB6ejqsrKwQFhYmhkRZWVmpdNh/KyTqzTffVAmJcnR0RGNjI9TV1dG7d2/k5OSI7W3hwoUYMWIEvvnmG2hqaiIoKAj29vYq5yZMIguD6+ZxrYy1R0IeEltbW8THx4uP5+fnY9GiRWLbaZ6H5NChQyp5SNzc3MQ8JH5+fuJxlPOQlJSUYNq0aThx4gQqKytx9uxZmJub4/3331fJQ9KcMLn1pNwj3A4Za5va1aDb0tIS1tbWKCkpQX19vVijV01NDSNGjIC2tjYyMzMxcuRIODs7w8zMDAcOHMCUKVPw/vvvIz4+Hp999hnc3d1x+/ZtGBkZ4ZNPPoGLiws8PDyQnp6OpUuXQkNDAwAQHR2N8vJyJCQkIDY2FpWVlZgxYwbGjBkjfm5AQMATz5cvfIw1cXR0xE8//YQff/wRPj4+UCgUmD17NkpKShAXFweZTIaoqCi4uLjg22+/RUpKClxcXJCYmIjBgwe3aEtC8jOOx2btkUwmQ3R0NIyMjLBkyRLY29urDGoBICsrCxEREWhoaIC7uzvMzc1RX1+P6OhodOzYER988IHK6/X09CCXy3Hr1i1YWVlBJpNBQ0MDpqamuHnzJhobG2FnZwcrKyukp6fD0dERcrkc6urq6NWrF9TV1cW8CwDg4uICFxcXlc9QnkgWkrYx9iIR8pCkp6fj7t27MDU1/c08JHfu3IGdnR2GDh2Kv//97/Dz80Ntba2YhyQyMhJmZmYAmvKQaGhowM/PD7GxsQgICMCuXbugr6+PWbNmYciQIS3OqXndbd5Bwlg79Sdta//dli1bRr6+vnTv3j0iaqrneezYMZoxYwZJJBKKjo4mIqLi4mIKDAyk4OBgImqqi11SUkKFhYWUnp5OX331FQ0dOlSMK/3mm29IIpHQJ598QlFRUbR06VJ6+PAhETXFgzePW1PGcWuMPV1mZib5+vrSunXriOhxjoSKigqaNWsWOTk5iY9xe2IvktraWrpz5w4RPY63bGxspEmTJpGzszMRNbWH7du3U79+/cT3BAcH08SJE1WOIzh48CB16tSJsrKyxMcKCwvJ1taW4uLiiOhxOwoKCqLRo0cTEdG9e/do1KhR5OLi0uJ8hPanTKFQcO1e9tLhPCSMseeh3U2Xubq6oq6uDlOmTIGvry8MDQ0RHh6O8vJyDB8+HLt27QIAdO7cGf379xfjtHV0dGBqagobGxsEBARgzJgxqKurg6GhIRoaGhAUFIRly5YhLS0NBQUF8PHxgY6ODogIXl5eYtyacky2gGcdGXs6R0dHaGpq4tixYwAg7ibp1KkT1qxZg8uXL0NDQ0Ncvaan1BtmrL0oLCxEQEAAli1bBgAtQqKEOGkNDQ2VkCgdHR1kZ2fDzMwMubm5yMnJQV1dnZjHRDkkCkCLkKgtW7ZALpcjLS0NeXl5GDduHIDHIVFLliwBoBoSJbQ/ZUJIFO8mYS8TzkPCGHseJNT8LtvG3bp1CxEREcjLy8O7774LHx8fODk5QVNTEydOnMCgQYNw+/ZtmJub47vvvsP48eORlZUFe3t7fPrpp5DL5Xj06JFYW3Tr1q1wc3MD0HILjzJqFp/NGPvvrF27FsbGxhg3blyrMdfcxtiLRiaTITIyEnV1dUhJSYGWlpb4G6+trUXXrl2xc+dOjBw5EufPn8df/vIXLFmyBFOmTMHWrVsRHx+PqqqqVkOipk2bhosXL6okAH348CFiYmKQkZGBhw8fiiFRcXFxnOeAsf/C9OnTcevWLezZs0dMOrh+/XrEx8djxYoVCAsLQ2JiIuLi4uDm5tYiD0lMTAxMTU3/5G/BGGtL2l1AlnJSpmnTpqnMztva2sLY2BgZGRmYPHkybG1tYWFhgbS0NCxevBiamppITEwU42kiIiJgb28vdvaFAXdjY2OLpGc8GGDs/2fOnDlPfZ7bGHvRCPGhGRkZqK6uhra2NhobG3Hy5El8+eWXqK6uxvHjxzFy5EiYmZnB2dlZzEMSFhaGoKAg1NbWIj8/H9XV1di8eTNWrFiBL774Am+88QaSkpKwdu1aFBQUwMTEBAsWLMC6deuQlZUFuVwu7tBq7mkTzIwxzkPCGPvjtbuVbqBpxSw1NRWrVq2Cj48P5HI5pFIpGhoaMHbsWDQ2NuK7777DvXv3EBUVBT09PWzbtg0NDQ3Q1NTkCx5jfxKhrTL2sti3bx9iY2PRtWtXVFRU4OLFi+jUqRN8fHzw4MED5Ofno6CgAPX19UhISMCnn36KX3/9tdVjDRw4EK6urli9ejW0tLSwfPlyHDhwAHp6evjb3/4Gf39/AKoTWEKGcb7vMfbsvv/+eyxZsgQhISGYPXu2mJiwsrISixcvRmZmJs6fPw8NDQ2exGKMPZN2OehufjFU7sh//PHH2LFjBy5dugQAYk1tZQqFAgqFgmPVGGOMPVccEsVY+3P//n2EhoZCX19fzBUkEAbgwON2Rs1K6DHGWHPt8srQPCmT8srZvHnzxAE3AGhqarZIxqSmpgZ1dXXukDDGGHuuhJAoV1dXTJs2DX369BE77MohUcLfQkgU0HT/SkpKQmpqKtzc3JCSkgI3NzcxpEo5JEpIsibg+xtjv1+XLl0QFBSE4ODgFm2r+YAbeFxCjwfcjLEnaXcx3cDji6GxsXGL7aqtXQz5IsgYY+zPIsSH5uTkiPGhUqkUxsbG8Pb2RlpaGiZPngwjIyM4OzujsLAQABAaGoqIiIgWA+jmf3O9bMb+eJyHhDH2R2q3o9E5c+YgLCzsifGhfDFkjDHWFri5uUFDQwNnz55VeVxLSwsDBgwQY7hNTEyQkpKCbdu2ic9LJBIoFAo0Nja2KOnFGHu+mq9yM8bY79UuY7oFnJSJMcZYW/es8aECTszEGGOMvVja9Z40HnAzxhhr6zgkijHGGHu5teuVbsYYY4wxxhhjrC3j6XTGGGPsf4DjQxljjLGXE690M8YYY4wxxhhjzwmvdDPGGGOMMcYYY88JD7oZY4wxxhhjjLHnhAfdjDHGGGOMMcbYc8KDbsYYY4wxxhhj7DnhQTdjjDHGGGOMMfac8KCbMcYYY4wxxhh7TnjQzRhjjDHGGGOMPSc86GaMMcYYY4wxxp4THnQzxhhjjDHGGGPPyf8B1ARgIs1s428AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "# Predicted delays by group\n", + "group_labels = [\n", + " \"Historical, After 2021\",\n", + " \"Recent, After 2021\",\n", + " \"Historical, Before 2021\",\n", + " \"Recent, Before 2021\"\n", + "]\n", + "\n", + "# From your exponentiated results\n", + "predicted_delays = [\n", + " 13.53, # Intercept only\n", + " 13.53 * 0.216, # Intercept * Recent\n", + " 13.53 * 2.198, # Intercept * Before 2021\n", + " 13.53 * 0.216 * 2.198 * 0.732 # Intercept * Recent * Before 2021 * Interaction\n", + "]\n", + "\n", + "# Create DataFrame for plotting\n", + "df_plot = pd.DataFrame({\n", + " \"Group\": group_labels,\n", + " \"Predicted Delay (Days)\": predicted_delays\n", + "})\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "bars = plt.bar(df_plot[\"Group\"], df_plot[\"Predicted Delay (Days)\"], alpha=0.8)\n", + "plt.title(\"Predicted Report Delay by Spill Type and Period\", fontsize=14)\n", + "plt.ylabel(\"Predicted Delay (Days)\", fontsize=12)\n", + "plt.xticks(rotation=15, ha='right')\n", + "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + "plt.tight_layout()\n", + "\n", + "# Annotate bars\n", + "for bar in bars:\n", + " height = bar.get_height()\n", + " plt.annotate(f\"{height:.2f}\",\n", + " xy=(bar.get_x() + bar.get_width() / 2, height),\n", + " xytext=(0, 3), # 3 points vertical offset\n", + " textcoords=\"offset points\",\n", + " ha='center', va='bottom')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "daa4b710", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "id": "3238be11", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "f6c679b7", + "metadata": {}, + "source": [ + "# Interrupted Time Series" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "fc8dc178", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: report_delay R-squared: 0.016\n", + "Model: OLS Adj. R-squared: -0.021\n", + "Method: Least Squares F-statistic: 0.4256\n", + "Date: Wed, 02 Jul 2025 Prob (F-statistic): 0.735\n", + "Time: 12:54:41 Log-Likelihood: -211.00\n", + "No. Observations: 84 AIC: 430.0\n", + "Df Residuals: 80 BIC: 439.7\n", + "Df Model: 3 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept 2.2068 0.867 2.546 0.013 0.482 3.932\n", + "time 0.0175 0.032 0.551 0.584 -0.046 0.081\n", + "post_2021 -0.3117 3.266 -0.095 0.924 -6.811 6.187\n", + "time_post 0.0026 0.057 0.045 0.964 -0.111 0.116\n", + "==============================================================================\n", + "Omnibus: 66.933 Durbin-Watson: 2.457\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 320.558\n", + "Skew: 2.631 Prob(JB): 2.46e-70\n", + "Kurtosis: 10.994 Cond. No. 625.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import statsmodels.formula.api as smf\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 1. Convert to monthly time series\n", + "spills_gdf['report_month'] = spills_gdf['Initial Report Date'].dt.to_period('M')\n", + "monthly = spills_gdf.groupby('report_month')['report_delay'].mean().reset_index()\n", + "monthly['report_month'] = monthly['report_month'].dt.to_timestamp()\n", + "\n", + "# 2. Create ITS variables\n", + "monthly['time'] = (monthly['report_month'] - monthly['report_month'].min()).dt.days // 30\n", + "monthly['post_2021'] = (monthly['report_month'] >= pd.Timestamp('2021-01-01')).astype(int)\n", + "monthly['time_post'] = monthly['time'] * monthly['post_2021']\n", + "\n", + "# 3. Run the ITS model\n", + "its_model = smf.ols(\"report_delay ~ time + post_2021 + time_post\", data=monthly).fit()\n", + "print(its_model.summary())\n", + "\n", + "# 4. Predict and plot\n", + "monthly['predicted'] = its_model.predict(monthly)\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(monthly['report_month'], monthly['report_delay'], marker='o', label='Observed', alpha=0.6)\n", + "plt.plot(monthly['report_month'], monthly['predicted'], linestyle='--', color='red', label='Predicted (ITS)')\n", + "plt.axvline(x=pd.Timestamp('2021-01-01'), color='black', linestyle='--', label='Policy Change (2021)')\n", + "plt.title('Interrupted Time Series: Monthly Report Delay')\n", + "plt.xlabel('Month')\n", + "plt.ylabel('Mean Report Delay (Days)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "6ae433ec", + "metadata": {}, + "source": [ + "## ITS by Spill Type" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "bfd7557f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== ITS Model Summary for Historical Spills ===\n", + "\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: report_delay R-squared: 0.018\n", + "Model: OLS Adj. R-squared: -0.019\n", + "Method: Least Squares F-statistic: 0.4853\n", + "Date: Wed, 02 Jul 2025 Prob (F-statistic): 0.693\n", + "Time: 12:54:41 Log-Likelihood: -237.68\n", + "No. Observations: 84 AIC: 483.4\n", + "Df Residuals: 80 BIC: 493.1\n", + "Df Model: 3 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept 3.6465 1.191 3.062 0.003 1.277 6.016\n", + "time -0.0298 0.044 -0.684 0.496 -0.117 0.057\n", + "post_2021 -1.7128 4.487 -0.382 0.704 -10.642 7.216\n", + "time_post 0.0578 0.078 0.740 0.462 -0.098 0.213\n", + "==============================================================================\n", + "Omnibus: 64.999 Durbin-Watson: 2.155\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 304.862\n", + "Skew: 2.539 Prob(JB): 6.31e-67\n", + "Kurtosis: 10.831 Cond. No. 625.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "=== ITS Model Summary for Recent Spills ===\n", + "\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: report_delay R-squared: 0.008\n", + "Model: OLS Adj. R-squared: -0.029\n", + "Method: Least Squares F-statistic: 0.2274\n", + "Date: Wed, 02 Jul 2025 Prob (F-statistic): 0.877\n", + "Time: 12:54:41 Log-Likelihood: -238.63\n", + "No. Observations: 84 AIC: 485.3\n", + "Df Residuals: 80 BIC: 495.0\n", + "Df Model: 3 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept 1.6599 1.204 1.378 0.172 -0.737 4.056\n", + "time 0.0285 0.044 0.645 0.521 -0.059 0.116\n", + "post_2021 0.0436 4.538 0.010 0.992 -8.987 9.074\n", + "time_post -0.0125 0.079 -0.158 0.875 -0.170 0.145\n", + "==============================================================================\n", + "Omnibus: 118.520 Durbin-Watson: 2.217\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 2530.024\n", + "Skew: 4.795 Prob(JB): 0.00\n", + "Kurtosis: 28.118 Cond. No. 625.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import statsmodels.formula.api as smf\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Group by month and spill type\n", + "spills_gdf['report_month'] = spills_gdf['Initial Report Date'].dt.to_period('M')\n", + "monthly_by_type = spills_gdf.groupby(['report_month', 'spill_type'])['report_delay'].mean().reset_index()\n", + "monthly_by_type['report_month'] = monthly_by_type['report_month'].dt.to_timestamp()\n", + "\n", + "# ITS variables\n", + "monthly_by_type['time'] = (monthly_by_type['report_month'] - monthly_by_type['report_month'].min()).dt.days // 30\n", + "monthly_by_type['post_2021'] = (monthly_by_type['report_month'] >= pd.Timestamp('2021-01-01')).astype(int)\n", + "monthly_by_type['time_post'] = monthly_by_type['time'] * monthly_by_type['post_2021']\n", + "\n", + "# Run ITS models and print summaries\n", + "its_results_by_type = {}\n", + "for stype in monthly_by_type['spill_type'].unique():\n", + " df = monthly_by_type[monthly_by_type['spill_type'] == stype].copy()\n", + " model = smf.ols(\"report_delay ~ time + post_2021 + time_post\", data=df).fit()\n", + " df['predicted'] = model.predict(df)\n", + " its_results_by_type[stype] = (model, df)\n", + " \n", + " print(f\"\\n=== ITS Model Summary for {stype} Spills ===\\n\")\n", + " print(model.summary())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d790d469", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import statsmodels.formula.api as smf\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 1. Group by month and spill type\n", + "spills_gdf['report_month'] = spills_gdf['Initial Report Date'].dt.to_period('M')\n", + "monthly_by_type = spills_gdf.groupby(['report_month', 'spill_type'])['report_delay'].mean().reset_index()\n", + "monthly_by_type['report_month'] = monthly_by_type['report_month'].dt.to_timestamp()\n", + "\n", + "# 2. Create ITS variables\n", + "monthly_by_type['time'] = (monthly_by_type['report_month'] - monthly_by_type['report_month'].min()).dt.days // 30\n", + "monthly_by_type['post_2021'] = (monthly_by_type['report_month'] >= pd.Timestamp('2021-01-01')).astype(int)\n", + "monthly_by_type['time_post'] = monthly_by_type['time'] * monthly_by_type['post_2021']\n", + "\n", + "# 3. Run ITS models separately by spill type\n", + "its_results_by_type = {}\n", + "for stype in monthly_by_type['spill_type'].unique():\n", + " df = monthly_by_type[monthly_by_type['spill_type'] == stype].copy()\n", + " model = smf.ols(\"report_delay ~ time + post_2021 + time_post\", data=df).fit()\n", + " df['predicted'] = model.predict(df)\n", + " its_results_by_type[stype] = (model, df)\n", + "\n", + "# 4. Plot side-by-side\n", + "fig, axs = plt.subplots(2, 1, figsize=(12, 10), sharex=True)\n", + "\n", + "for ax, (stype, (model, df)) in zip(axs, its_results_by_type.items()):\n", + " ax.plot(df['report_month'], df['report_delay'], marker='o', label='Observed', alpha=0.6)\n", + " ax.plot(df['report_month'], df['predicted'], linestyle='--', color='red', label='Predicted (ITS)')\n", + " ax.axvline(x=pd.Timestamp('2021-01-01'), color='black', linestyle='--', label='Policy Change (2021)')\n", + " ax.set_title(f\"ITS Model for {stype} Spills\")\n", + " ax.set_ylabel(\"Mean Report Delay (Days)\")\n", + " ax.legend()\n", + " ax.grid(True)\n", + "\n", + "axs[1].set_xlabel(\"Month\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "efc4708c", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "610abfb4", + "metadata": {}, + "source": [ + "# Conclusion: Comparative Summary\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "546334b9", + "metadata": {}, + "outputs": [], + "source": [ + "def extract_regression_results(model, model_name):\n", + " coefs = model.params\n", + " ses = model.bse\n", + " pvals = model.pvalues\n", + "\n", + " df = pd.DataFrame({\n", + " 'Coefficient': coefs,\n", + " 'Std. Error': ses,\n", + " 'P-Value': pvals\n", + " })\n", + " df['Model'] = model_name\n", + " return df.reset_index().rename(columns={'index': 'Term'})\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "a09b247e", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "Term", + "rawType": "object", + "type": "string" + }, + { + "name": "ITS (Monthly, All Spills)", + "rawType": "float64", + "type": "float" + }, + { + "name": "ITS (Monthly, Historical)", + "rawType": "float64", + "type": "float" + }, + { + "name": "ITS (Monthly, Recent)", + "rawType": "float64", + "type": "float" + }, + { + "name": "Negative Binomial", + "rawType": "float64", + "type": "float" + }, + { + "name": "OLS (Interaction)", + "rawType": "float64", + "type": "float" + } + ], + "ref": "6c82bb30-a5db-4b21-9109-e8b281128edb", + "rows": [ + [ + "C(Period)[T.Before 2020]", + null, + null, + null, + "-0.12", + null + ], + [ + "C(spill_type)[T.Recent]", + null, + null, + null, + "-0.371", + null + ], + [ + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020]", + null, + null, + null, + "-0.162", + null + ], + [ + "Intercept", + "2.207", + "3.646", + "1.66", + "1.303", + "1.66" + ], + [ + "post_2021", + "-0.312", + "-1.713", + "0.044", + null, + "0.044" + ], + [ + "time", + "0.017", + "-0.03", + "0.028", + null, + "0.028" + ], + [ + "time_post", + "0.003", + "0.058", + "-0.013", + null, + "-0.013" + ] + ], + "shape": { + "columns": 5, + "rows": 7 + } + }, + "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", + "
ModelITS (Monthly, All Spills)ITS (Monthly, Historical)ITS (Monthly, Recent)Negative BinomialOLS (Interaction)
Term
C(Period)[T.Before 2020]NaNNaNNaN-0.120NaN
C(spill_type)[T.Recent]NaNNaNNaN-0.371NaN
C(spill_type)[T.Recent]:C(Period)[T.Before 2020]NaNNaNNaN-0.162NaN
Intercept2.2073.6461.6601.3031.660
post_2021-0.312-1.7130.044NaN0.044
time0.017-0.0300.028NaN0.028
time_post0.0030.058-0.013NaN-0.013
\n", + "
" + ], + "text/plain": [ + "Model ITS (Monthly, All Spills) \\\n", + "Term \n", + "C(Period)[T.Before 2020] NaN \n", + "C(spill_type)[T.Recent] NaN \n", + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020] NaN \n", + "Intercept 2.207 \n", + "post_2021 -0.312 \n", + "time 0.017 \n", + "time_post 0.003 \n", + "\n", + "Model ITS (Monthly, Historical) \\\n", + "Term \n", + "C(Period)[T.Before 2020] NaN \n", + "C(spill_type)[T.Recent] NaN \n", + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020] NaN \n", + "Intercept 3.646 \n", + "post_2021 -1.713 \n", + "time -0.030 \n", + "time_post 0.058 \n", + "\n", + "Model ITS (Monthly, Recent) \\\n", + "Term \n", + "C(Period)[T.Before 2020] NaN \n", + "C(spill_type)[T.Recent] NaN \n", + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020] NaN \n", + "Intercept 1.660 \n", + "post_2021 0.044 \n", + "time 0.028 \n", + "time_post -0.013 \n", + "\n", + "Model Negative Binomial \\\n", + "Term \n", + "C(Period)[T.Before 2020] -0.120 \n", + "C(spill_type)[T.Recent] -0.371 \n", + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020] -0.162 \n", + "Intercept 1.303 \n", + "post_2021 NaN \n", + "time NaN \n", + "time_post NaN \n", + "\n", + "Model OLS (Interaction) \n", + "Term \n", + "C(Period)[T.Before 2020] NaN \n", + "C(spill_type)[T.Recent] NaN \n", + "C(spill_type)[T.Recent]:C(Period)[T.Before 2020] NaN \n", + "Intercept 1.660 \n", + "post_2021 0.044 \n", + "time 0.028 \n", + "time_post -0.013 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Collect regression summaries\n", + "results_frames = []\n", + "\n", + "# Add your models — use your actual variable names\n", + "results_frames.append(extract_regression_results(model, 'OLS (Interaction)'))\n", + "results_frames.append(extract_regression_results(nb_model, 'Negative Binomial'))\n", + "results_frames.append(extract_regression_results(its_model, 'ITS (Monthly, All Spills)'))\n", + "\n", + "\n", + "# ITS by spill type (e.g., 'Historical', 'Recent')\n", + "for spill_type, (model, df) in its_results_by_type.items():\n", + " label = f\"ITS (Monthly, {spill_type})\"\n", + " results_frames.append(extract_regression_results(model, label))\n", + "\n", + "# Combine all\n", + "regression_summary_table = pd.concat(results_frames, ignore_index=True)\n", + "\n", + "# Pivot just the coefficients for display\n", + "regression_coef_table = regression_summary_table.pivot_table(\n", + " index='Term',\n", + " columns='Model',\n", + " values='Coefficient',\n", + " aggfunc='first'\n", + ").round(3)\n", + "\n", + "regression_coef_table\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "spatial_env2", + "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.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}