From 66bf4ddbd6f2e4506838022171a0a298265f528d Mon Sep 17 00:00:00 2001 From: Apoorva Lal Date: Wed, 21 Aug 2024 16:11:58 -0700 Subject: [PATCH] add mundlak event study --- duckreg/estimators.py | 261 +++++++- notebooks/event_study.ipynb | 1131 +++++++++-------------------------- 2 files changed, 528 insertions(+), 864 deletions(-) diff --git a/duckreg/estimators.py b/duckreg/estimators.py index b55112d..70167ac 100644 --- a/duckreg/estimators.py +++ b/duckreg/estimators.py @@ -37,7 +37,6 @@ def __init__( self._parse_formula() def _parse_formula(self): - lhs, rhs = self.formula.split("~") rhs_deparsed = rhs.split("|") covars, fevars = rhs.split("|") if len(rhs_deparsed) > 1 else (rhs, None) @@ -79,7 +78,6 @@ def compress_data(self): self.df_compressed.eval(create_means, inplace=True) def collect_data(self, data: pd.DataFrame) -> pd.DataFrame: - y = data.filter( regex=f"mean_{'(' + '|'.join(self.outcome_vars) + ')'}", axis=1 ).values @@ -127,7 +125,6 @@ def fit_vcov(self): self.vcov = n_nk * (bread @ meat @ bread) def estimate_feols(self): - if self.fevars: fml = f"{'+'.join([f'mean_{x}' for x in self.outcome_vars])} ~ {' + '.join(self.covars)} | {' + '.join(self.fevars)}" else: @@ -310,7 +307,6 @@ def compress_data(self): ) def collect_data(self, data: pd.DataFrame): - rhs = ( self.covariates + [f"avg_{cov}_unit" for cov in self.covariates] @@ -332,7 +328,6 @@ def collect_data(self, data: pd.DataFrame): return y, X, n def estimate(self): - y, X, n = self.collect_data(data=self.df_compressed) return wls(X, y, n) @@ -408,8 +403,259 @@ def bootstrap(self): ################################################################################ +class DuckMundlakEventStudy(DuckReg): + def __init__( + self, + db_name: str, + table_name: str, + outcome_var: str, + treatment_col: str, + unit_col: str, + time_col: str, + cluster_col: str, + n_bootstraps: int = 100, + **kwargs, + ): + super().__init__( + db_name=db_name, + table_name=table_name, + n_bootstraps=n_bootstraps, + **kwargs, + ) + self.table_name = table_name + self.outcome_var = outcome_var + self.treatment_col = treatment_col + self.unit_col = unit_col + self.time_col = time_col + self.num_periods = None + self.cohorts = None + self.time_dummies = None + self.post_treatment_dummies = None + self.transformed_query = None + self.compression_query = None + self.cluster_col = cluster_col + def prepare_data(self): + # create_cohort_and_ever_treated_columns + self.cohort_query = f""" + ALTER TABLE {self.table_name} ADD COLUMN cohort INTEGER; + UPDATE {self.table_name} SET cohort = ( + SELECT MIN({self.time_col}) + FROM {self.table_name} AS p2 + WHERE p2.{self.unit_col} = {self.table_name}.{self.unit_col} AND p2.{self.treatment_col} = 1 + ); + """ + self.conn.execute(self.cohort_query) + self.ever_treated_query = f""" + UPDATE {self.table_name} SET cohort = NULL WHERE cohort = 2147483647; -- Set to NULL if never treated + ALTER TABLE {self.table_name} ADD COLUMN ever_treated INTEGER; + UPDATE {self.table_name} SET ever_treated = CASE WHEN cohort IS NOT NULL THEN 1 ELSE 0 END; + """ + self.conn.execute(self.ever_treated_query) + # retrieve_num_periods_and_cohorts + self.num_periods = self.conn.execute( + f"SELECT MAX({self.time_col}) FROM {self.table_name}" + ).fetchone()[0] + cohorts = self.conn.execute( + f"SELECT DISTINCT cohort FROM {self.table_name} WHERE cohort IS NOT NULL" + ).fetchall() + self.cohorts = [row[0] for row in cohorts] + # generate_time_dummies + self.time_dummies = ",\n".join( + [ + f"CASE WHEN {self.time_col} = {i} THEN 1 ELSE 0 END AS time_{i}" + for i in range(self.num_periods + 1) + ] + ) + # generate cohort dummies + cohort_intercepts = [] + for cohort in self.cohorts: + cohort_intercepts.append( + f"CASE WHEN cohort = {cohort} THEN 1 ELSE 0 END AS cohort_{cohort}" + ) + self.cohort_intercepts = ",\n".join(cohort_intercepts) + + # generate_treatment_dummies + treatment_dummies = [] + for cohort in self.cohorts: + for i in range(self.num_periods + 1): + treatment_dummies.append( + f"CASE WHEN cohort = {cohort} AND {self.time_col} = {i} THEN 1 ELSE 0 END AS treatment_time_{cohort}_{i}" + ) + self.treatment_dummies = ",\n".join(treatment_dummies) + # create_transformed_query + self.design_matrix_query = f""" + CREATE TEMP TABLE transformed_panel_data AS + SELECT + p.{self.unit_col}, + p.{self.time_col}, + p.{self.treatment_col}, + p.{self.outcome_var}, + -- Intercept (constant term) + 1 AS intercept, + -- cohort intercepts + {self.cohort_intercepts}, + -- Time dummies for each period + {self.time_dummies}, + -- Treated group interacted with treatment time dummies + {self.treatment_dummies} + FROM + {self.table_name} p; + """ + self.conn.execute(self.design_matrix_query) + + def compress_data(self): + self.rhs = f""" + intercept, + {", ".join([f"cohort_{cohort}" for cohort in self.cohorts])}, + {", ".join([f"time_{i}" for i in range(self.num_periods + 1)])}, + {", ".join([f"treatment_time_{cohort}_{i}" for cohort in self.cohorts for i in range(self.num_periods + 1)])}; + """ + self.compression_query = f""" + CREATE TEMP TABLE compressed_panel_data AS + SELECT + {self.rhs.replace(";", "")}, + COUNT(*) AS count, + SUM({self.outcome_var}) AS sum_{self.outcome_var} + FROM + transformed_panel_data + GROUP BY + {self.rhs} + """ + self.conn.execute(self.compression_query) + self.df_compressed = self.conn.execute( + "SELECT * FROM compressed_panel_data" + ).fetchdf() + self.df_compressed[f"mean_{self.outcome_var}"] = ( + self.df_compressed[f"sum_{self.outcome_var}"] / self.df_compressed["count"] + ) + + def collect_data(self, data): + self._rhs_list = [x.strip().replace(";", "") for x in self.rhs.split(",")] + X = data[self._rhs_list].values + y = data[f"mean_{self.outcome_var}"].values + n = data["count"].values + + y = y.reshape(-1, 1) if y.ndim == 1 else y + X = X.reshape(-1, 1) if X.ndim == 1 else X + return y, X, n + + def estimate(self): + y, X, n = self.collect_data(data=self.df_compressed) + coef = wls(X, y, n) + res = pd.DataFrame( + { + "est": coef.squeeze(), + }, + index=self._rhs_list, + ) + cohort_names = [x.split("_")[1] for x in self._rhs_list if "cohort_" in x] + event_study_coefs = {} + for c in cohort_names: + offset = res.filter(regex=f"^cohort_{c}", axis=0).values + event_study_coefs[c] = ( + res.filter(regex=f"treatment_time_{c}_", axis=0) + offset + ) + + return event_study_coefs + + def bootstrap(self): + # list all clusters + total_clusters = self.conn.execute( + f"SELECT COUNT(DISTINCT {self.cluster_col}) FROM transformed_panel_data" + ).fetchone()[0] + boot_coefs = {str(cohort): [] for cohort in self.cohorts} + # bootstrap loop + for _ in tqdm(range(self.n_bootstraps)): + resampled_clusters = ( + self.conn.execute( + f"SELECT UNNEST(ARRAY(SELECT {self.cluster_col} FROM transformed_panel_data ORDER BY RANDOM() LIMIT {total_clusters}))" + ) + .fetchdf() + .values.flatten() + .tolist() + ) + + self.conn.execute( + f""" + CREATE TEMP TABLE resampled_transformed_panel_data AS + SELECT * FROM transformed_panel_data + WHERE {self.cluster_col} IN ({', '.join(map(str, resampled_clusters))}) + """ + ) + + self.conn.execute( + f""" + CREATE TEMP TABLE resampled_compressed_panel_data AS + SELECT + {self.rhs.replace(";", "")}, + COUNT(*) AS count, + SUM({self.outcome_var}) AS sum_{self.outcome_var} + FROM + resampled_transformed_panel_data + GROUP BY + {self.rhs.replace(";", "")} + """ + ) + + df_boot = self.conn.execute( + "SELECT * FROM resampled_compressed_panel_data" + ).fetchdf() + df_boot[f"mean_{self.outcome_var}"] = ( + df_boot[f"sum_{self.outcome_var}"] / df_boot["count"] + ) + + y, X, n = self.collect_data(data=df_boot) + coef = wls(X, y, n) + res = pd.DataFrame( + { + "est": coef.squeeze(), + }, + index=self._rhs_list, + ) + cohort_names = [x.split("_")[1] for x in self._rhs_list if "cohort_" in x] + for c in cohort_names: + offset = res.filter(regex=f"^cohort_{c}", axis=0).values + event_study_coefs = ( + res.filter(regex=f"treatment_time_{c}_", axis=0) + offset + ) + boot_coefs[c].append(event_study_coefs.values.flatten()) + + self.conn.execute("DROP TABLE resampled_transformed_panel_data") + self.conn.execute("DROP TABLE resampled_compressed_panel_data") + # Calculate the covariance matrix for each cohort + bootstrap_cov_matrix = { + cohort: np.cov(np.array(coefs).T) for cohort, coefs in boot_coefs.items() + } + return bootstrap_cov_matrix + + def estimate_feols(self): + raise NotImplementedError( + "feols solver not implemented for Mundlak event study estimator" + ) + + def summary(self) -> dict: + """Summary of event study regression (overrides the parent class method) + + Returns: + dict of event study coefficients and their standard errors + """ + if self.n_bootstraps > 0: + summary_tables = {} + for c in self.point_estimate.keys(): + point_estimate = self.point_estimate[c] + se = np.sqrt(np.diag(self.vcov[c])) + summary_tables[c] = pd.DataFrame( + np.c_[point_estimate, se], + columns=["point_estimate", "se"], + index=point_estimate.index, + ) + return summary_tables + return {"point_estimate": self.point_estimate} + + +################################################################################ class DuckDoubleDemeaning(DuckReg): def __init__( self, @@ -429,7 +675,7 @@ def __init__( table_name=table_name, seed=seed, n_bootstraps=n_bootstraps, - **kwargs + **kwargs, ) self.outcome_var = outcome_var self.treatment_var = treatment_var @@ -494,7 +740,6 @@ def compress_data(self): ) def collect_data(self, data: pd.DataFrame): - X = data[f"ddot_{self.treatment_var}"].values X = np.c_[np.ones(X.shape[0]), X] y = data[f"mean_{self.outcome_var}"].values @@ -566,4 +811,4 @@ def bootstrap(self): return np.cov(boot_coefs.T) -###################################################################### +################################################################################ diff --git a/notebooks/event_study.ipynb b/notebooks/event_study.ipynb index fcf1af5..6166df5 100644 --- a/notebooks/event_study.ipynb +++ b/notebooks/event_study.ipynb @@ -1,5 +1,12 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# `duckreg` for panel data: Applying Mundlak Regression to estimate Event Studies at scale" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -9,7 +16,7 @@ "data": { "text/html": [ "\n", - "
\n", + "
\n", " \n", @@ -49,7 +56,7 @@ "data": { "text/html": [ "\n", - "
\n", + "
\n", " \n", @@ -90,7 +97,7 @@ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "from duckreg.estimators import DuckMundlak, DuckDoubleDemeaning\n", + "from duckreg.estimators import DuckMundlak, DuckMundlakEventStudy\n", "import duckdb\n", "import pyfixest as pf\n", "\n", @@ -113,12 +120,14 @@ " ar_coef=0.2, # Autoregressive coefficient for epsilon_it\n", " sigma_unit=1,\n", " sigma_time=0.5,\n", - " sigma_epsilon = 0.5, # Standard deviation of epsilon_it\n", + " sigma_epsilon=0.5, # Standard deviation of epsilon_it\n", "):\n", " unit_intercepts = np.random.normal(0, sigma_unit, num_units)\n", "\n", " # Generate day-of-the-week pattern\n", - " day_effects = np.array([-0.1, 0.1, 0, 0, 0.1, 0.5, 0.5]) # Stronger effects on weekends\n", + " day_effects = np.array(\n", + " [-0.1, 0.1, 0, 0, 0.1, 0.5, 0.5]\n", + " ) # Stronger effects on weekends\n", " day_pattern = np.tile(day_effects, num_periods // 7 + 1)[:num_periods]\n", "\n", " # Generate autoregressive structure\n", @@ -167,26 +176,17 @@ " time_ids = np.tile(np.arange(num_periods), num_units)\n", " W_it = treatment_status.flatten()\n", " Y_it = np.where(W_it, Y1.flatten(), Y0.flatten())\n", - " unit_intercepts_flat = np.repeat(unit_intercepts, num_periods)\n", - " time_intercepts_flat = np.tile(time_intercepts, num_units)\n", " df = pd.DataFrame(\n", " {\n", " \"unit_id\": unit_ids,\n", " \"time_id\": time_ids,\n", " \"W_it\": W_it.astype(int),\n", " \"Y_it\": Y_it,\n", - " \"unit_intercept\": unit_intercepts_flat,\n", - " \"time_intercept\": time_intercepts_flat,\n", " }\n", " )\n", - " # assign units to ever treated if the max of W_it is 1\n", - " df[\"ever_treated\"] = df.groupby(\"unit_id\")[\"W_it\"].transform(\"max\")\n", - " # label cohorts\n", - " df['cohort'] = df.query(\"W_it == 1\").groupby('unit_id')['time_id'].transform('min')\n", - " df['cohort'] = df['cohort'].fillna(0)\n", - " df['cohort'] = df.groupby('unit_id')['cohort'].transform('max')\n", " return df\n", "\n", + "\n", "# Function to create and populate DuckDB database\n", "def create_duckdb_database(df, db_name=\"large_dataset.db\", table=\"panel_data\"):\n", " conn = duckdb.connect(db_name)\n", @@ -200,25 +200,14 @@ "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.21533040462966416)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "num_periods = 30\n", "treat_start_period = 15\n", "treat_effect_vector= 0.2 * np.log(2 * np.arange(1, num_periods - treat_start_period + 1))\n", "treat_effect_vector[8:] = 0 # switch off effects after a week\n", "sigma_i, sigma_t = 2, 1\n", - "treat_effect_vector.mean()" + "event_study_true = np.r_[np.repeat(0, num_periods-treat_start_period), treat_effect_vector]\n" ] }, { @@ -236,7 +225,7 @@ ], "source": [ "df = panel_dgp(\n", - " num_units=100_000, num_treated= 50_000,\n", + " num_units=10_000, num_treated= 5_000,\n", " num_periods=30,\n", " treatment_start = treat_start_period,\n", " hetfx=False,\n", @@ -245,26 +234,7 @@ ")\n", "\n", "db_name = 'event_study_data.db'\n", - "create_duckdb_database(df, db_name)\n", - "df = df.merge(\n", - " pd.get_dummies(df[\"time_id\"], prefix=\"time\"), left_index=True, right_index=True\n", - ")\n", - "time_dummies = df.filter(regex = r\"time_\\d\").columns" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### in-memory estimation\n", - "\n", - "Eq 5.13 in Wooldridge\n", - "\n", - "$$\n", - "Y_{it} = \\alpha + \\xi d_i + \\beta_q(d_i fq_t) + \\dots + \\beta_T(d_i fT_t) + \\theta_0 fq_t + \\dots + \\theta_T fT_t + \\epsilon_{it}\n", - "$$\n", - "\n", - "where $\\beta$ coefficients are the event study coefficients." + "create_duckdb_database(df, db_name)" ] }, { @@ -272,61 +242,80 @@ "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Y_it ~ -1 + ever_treated*(time_0 + time_1 + time_2 + time_3 + time_4 + time_5 + time_6 + time_7 + time_8 + time_9 + time_10 + time_11 + time_12 + time_13 + time_14 + time_15 + time_16 + time_17 + time_18 + time_19 + time_20 + time_21 + time_22 + time_23 + time_24 + time_25 + time_26 + time_27 + time_28 + time_29)\n", - " \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/alal/Desktop/duckreg/.venv/lib/python3.11/site-packages/pyfixest/estimation/feols_.py:1987: UserWarning: \n", - " The following variables are collinear: ['time_29'].\n", - " The variables are dropped from the model.\n", - " \n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 5.4 s, sys: 1.56 s, total: 6.96 s\n", - "Wall time: 4.14 s\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/alal/Desktop/duckreg/.venv/lib/python3.11/site-packages/pyfixest/estimation/feols_.py:646: RuntimeWarning: invalid value encountered in sqrt\n", - " self._se = np.sqrt(np.diagonal(_vcov))\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", + "
unit_idtime_idW_itY_it
00000.436139
10101.016883
20200.480516
30300.578209
40401.066747
\n", + "
" + ], "text/plain": [ - "Index(['Intercept', 'ever_treated', 'time_0', 'time_1', 'time_2', 'time_3',\n", - " 'time_4', 'time_5', 'time_6', 'time_7', 'time_8', 'time_9', 'time_10',\n", - " 'time_11', 'time_12', 'time_13', 'time_14', 'time_15', 'time_16',\n", - " 'time_17', 'time_18', 'time_19', 'time_20', 'time_21', 'time_22',\n", - " 'time_23', 'time_24', 'time_25', 'time_26', 'time_27', 'time_28',\n", - " 'ever_treated:time_0', 'ever_treated:time_1', 'ever_treated:time_2',\n", - " 'ever_treated:time_3', 'ever_treated:time_4', 'ever_treated:time_5',\n", - " 'ever_treated:time_6', 'ever_treated:time_7', 'ever_treated:time_8',\n", - " 'ever_treated:time_9', 'ever_treated:time_10', 'ever_treated:time_11',\n", - " 'ever_treated:time_12', 'ever_treated:time_13', 'ever_treated:time_14',\n", - " 'ever_treated:time_15', 'ever_treated:time_16', 'ever_treated:time_17',\n", - " 'ever_treated:time_18', 'ever_treated:time_19', 'ever_treated:time_20',\n", - " 'ever_treated:time_21', 'ever_treated:time_22', 'ever_treated:time_23',\n", - " 'ever_treated:time_24', 'ever_treated:time_25', 'ever_treated:time_26',\n", - " 'ever_treated:time_27', 'ever_treated:time_28', 'ever_treated:time_29'],\n", - " dtype='object', name='Coefficient')" + " unit_id time_id W_it Y_it\n", + "0 0 0 0 0.436139\n", + "1 0 1 0 1.016883\n", + "2 0 2 0 0.480516\n", + "3 0 3 0 0.578209\n", + "4 0 4 0 1.066747" ] }, "execution_count": 5, @@ -335,19 +324,16 @@ } ], "source": [ - "%%time\n", - "print(ff := f\"\"\"\n", - " Y_it ~ -1 + ever_treated*({' + '.join(time_dummies)})\n", - " \"\"\")\n", - "m = pf.feols(ff, data = df)\n", - "m.coef().index" + "df.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Event study regression" + "## Static Specification\n", + "\n", + "### Two-way Mundlak" ] }, { @@ -356,25 +342,46 @@ "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "CPU times: user 17.9 s, sys: 2.14 s, total: 20 s\n", - "Wall time: 9.96 s\n" + "100%|██████████| 100/100 [00:01<00:00, 65.08it/s]\n" ] + }, + { + "data": { + "text/plain": [ + "point_estimate 0.203918\n", + "standard_error 0.003637\n", + "Name: 1, dtype: float64" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "%%time\n", - "m2 = pf.feols(\"\"\"\n", - " Y_it ~ i(time_id, ever_treated, ref = 14) |\n", - " unit_id + time_id\n", - " \"\"\",\n", - " df\n", - " )\n", - "evstudy_coefs = m2.coef().values\n", - "# insert zero in reference period\n", - "evstudy_coefs = np.insert(evstudy_coefs, 14, 0)" + "mundlak = DuckMundlak(\n", + " db_name=\"event_study_data.db\",\n", + " table_name=\"panel_data\",\n", + " outcome_var=\"Y_it\",\n", + " covariates=[\"W_it\"],\n", + " unit_col=\"unit_id\",\n", + " time_col=\"time_id\",\n", + " cluster_col=\"unit_id\",\n", + " n_bootstraps=100,\n", + " seed = 42\n", + ")\n", + "mundlak.fit()\n", + "\n", + "mundlak_results = mundlak.summary()\n", + "\n", + "restab = pd.DataFrame(\n", + " np.c_[mundlak_results[\"point_estimate\"], mundlak_results[\"standard_error\"]],\n", + " columns=[\"point_estimate\", \"standard_error\"],\n", + ").iloc[1, :]\n", + "restab" ] }, { @@ -385,111 +392,57 @@ { "data": { "text/plain": [ - "" + "0.21533040462966416" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "p0 = np.r_[np.zeros(15), treat_effect_vector]\n", - "p1 = m.coef().filter(regex=r\"ever_treated:time_\\d\").values\n", - "\n", - "\n", - "p2 = (\n", - " df.groupby([\"ever_treated\", \"time_id\"])[\"Y_it\"]\n", - " .mean()\n", - " .unstack()\n", - " .diff(axis=0)\n", - " .iloc[1, :]\n", - " .values\n", - ")\n", - "f, ax = plt.subplots(figsize = (10, 6))\n", - "ax.plot(p0, marker=\".\", label=\"True\", linewidth=2)\n", - "ax.plot(p2, marker=\".\", alpha=0.3, label=\"Difference in means\")\n", - "ax.plot(p1, marker=\".\", alpha=0.3, label=\"Two-way-Mundlak Regression (no offset)\")\n", - "ax.plot(\n", - " p1 + m.coef().filter(regex=\"ever_treated$\").values,\n", - " marker=\".\",\n", - " alpha=0.3,\n", - " label=\"Two-way-Mundlak Regression (with offset)\",\n", - ")\n", - "ax.plot(evstudy_coefs, marker=\".\", alpha=0.3, label=\"Event Study\")\n", - "ax.legend()" + "treat_effect_vector.mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We get the same coefficient once we offset the $\\beta$ vector with $\\xi$. The wooldridge paper claims that the $\\beta$ coefficients should be identical to the event study coefficients without the $\\xi$ offset. This is not true. \n", - "\n", - "So, the gameplan is to groupby (`on_hot_encoded_cohort_id, one_hot_encoded_time_id, on_hot_encoded_cohort_id X one_hot_encoded_time_id`) and run the compressed regression by weighted least squares." + "The Two-way Mundlak specification consistently recovers the average treatment effect in the post-treatment period. Under staggered adoption, however, this guarantee is lost. More on this later. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### compress (in pandas for now)" + "## Dynamic Specification\n", + "\n", + "### Single Treatment Cohort" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 2.54 s, sys: 992 ms, total: 3.53 s\n", - "Wall time: 3.54 s\n" - ] - }, - { - "data": { - "text/plain": [ - "(60, 65)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "%%time\n", - "cohort_dummies = pd.get_dummies(df['cohort'], drop_first=True).astype(int).values\n", - "time_dummies = pd.get_dummies(df['time_id']).astype(int).values\n", - "\n", - "# cohort dummies, time dummies, and interaction\n", - "Xmat = np.c_[\n", - " np.ones(df.shape[0]),\n", - " cohort_dummies,\n", - " cohort_dummies[:, [0]] * time_dummies,\n", - " time_dummies,\n", - "]\n", - "y = df[\"Y_it\"].values\n", - "dfnew = pd.DataFrame(\n", - " np.c_[y, Xmat], columns=[\"Y_it\"] + [f\"X{i}\" for i in range(Xmat.shape[1])]\n", - ")\n", - "# collapse to strata level\n", - "agg_df = dfnew.groupby(list(dfnew.columns[1:]))['Y_it'].agg(['sum', 'count']).reset_index()\n", - "agg_df['y_mean'] = agg_df['sum'] / agg_df['count']\n", - "agg_df.shape" + "df[\"ever_treated\"] = df.groupby(\"unit_id\")[\"W_it\"].transform(\"max\")\n", + "m2 = pf.feols(\"\"\"\n", + " Y_it ~ i(time_id, ever_treated, ref = 14) |\n", + " unit_id + time_id\n", + " \"\"\",\n", + " df\n", + " )\n", + "evstudy_coefs = m2.coef().values\n", + "# insert zero in reference period\n", + "evstudy_coefs = np.insert(evstudy_coefs, 14, 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### compressed estimation" ] }, { @@ -501,49 +454,51 @@ "name": "stdout", "output_type": "stream", "text": [ - "y_mean~0+X0+X1+X2+X3+X4+X5+X6+X7+X8+X9+X10+X11+X12+X13+X14+X15+X16+X17+X18+X19+X20+X21+X22+X23+X24+X25+X26+X27+X28+X29+X30+X31+X32+X33+X34+X35+X36+X37+X38+X39+X40+X41+X42+X43+X44+X45+X46+X47+X48+X49+X50+X51+X52+X53+X54+X55+X56+X57+X58+X59+X60+X61\n", - "CPU times: user 205 ms, sys: 219 ms, total: 423 ms\n", - "Wall time: 423 ms\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/alal/Desktop/duckreg/.venv/lib/python3.11/site-packages/pyfixest/estimation/feols_.py:1987: UserWarning: \n", - " The following variables are collinear: ['X0', 'X31', 'X61'].\n", - " The variables are dropped from the model.\n", - " \n", - " warnings.warn(\n" + " unit_id time_id W_it Y_it\n", + "0 0 0 0 0.436139\n", + "1 0 1 0 1.016883\n", + "2 0 2 0 0.480516\n", + "3 0 3 0 0.578209\n", + "4 0 4 0 1.066747\n" ] } ], "source": [ - "%%time\n", - "print(ff := f\"y_mean~0+{'+'.join(dfnew.filter(like = 'X').columns)}\")\n", - "m_agg = pf.feols(ff, data = agg_df, weights = 'count', weights_type='fweights')\n", - "coefs = m_agg.coef()\n", - "compressed_coefs = coefs.iloc[2:31] + coefs['X1']" + "conn = duckdb.connect(\"event_study_data.db\")\n", + "print(conn.execute(\"SELECT * FROM panel_data LIMIT 5\").fetchdf())\n", + "conn.close()" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, + "outputs": [], + "source": [ + "mundlak = DuckMundlakEventStudy(\n", + " db_name=\"event_study_data.db\",\n", + " table_name=\"panel_data\",\n", + " outcome_var=\"Y_it\",\n", + " treatment_col=\"W_it\",\n", + " unit_col=\"unit_id\",\n", + " time_col=\"time_id\",\n", + " cluster_col=\"unit_id\",\n", + " n_bootstraps=0, # set to nonzero to get block-bootstrapped standard errors\n", + " seed=42,\n", + ")\n", + "\n", + "mundlak.fit()\n", + "evsum = mundlak.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -553,50 +508,41 @@ } ], "source": [ - "p0 = np.r_[np.zeros(15), treat_effect_vector]\n", - "p1 = m.coef().filter(regex=r\"ever_treated:time_\\d\").values\n", - "p2 = (\n", - " df.groupby([\"ever_treated\", \"time_id\"])[\"Y_it\"]\n", - " .mean()\n", - " .unstack()\n", - " .diff(axis=0)\n", - " .iloc[1, :]\n", - " .values\n", - ")\n", - "\n", - "f, ax = plt.subplots(figsize=(10, 6))\n", - "ax.plot(p0, marker=\".\", label=\"True\", linewidth=2)\n", - "ax.plot(p2, marker=\".\", alpha=0.9, label=\"Difference in means\")\n", - "ax.plot(\n", - " p1 + m.coef().filter(regex=\"ever_treated$\").values,\n", - " marker=\".\",\n", - " alpha=0.5,\n", - " label=\"Two-way-Mundlak Regression (with offset)\",\n", - ")\n", - "ax.plot(evstudy_coefs, marker=\".\", alpha=0.5, label=\"Event Study\")\n", - "ax.plot(compressed_coefs, marker=\".\", alpha=0.8, label=\"Compressed TWM\")\n", - "ax.legend()" + "mundlak_estimates = evsum[\"point_estimate\"][\"15\"]\n", + "time_labels = [\n", + " int(x.replace(\"treatment_time_15_\", \"\")) for x in mundlak_estimates.index\n", + "]\n", + "f, ax = plt.subplots(1, 1, figsize=(10, 6))\n", + "ax.plot(event_study_true, marker=\".\", label=\"True Treatment Effect\")\n", + "ax.plot(time_labels, mundlak_estimates, marker=\".\", label=\"Mundlak Estimate\")\n", + "ax.plot(time_labels, evstudy_coefs, marker=\".\", label=\"2WFE estimate\")\n", + "ax.axvline(14.5, color=\"red\", linestyle=\"--\")\n", + "ax.axhline(0, color=\"red\", linestyle=\"--\")\n", + "ax.set_ylabel(\"Dynamic Treatment Effect\")\n", + "ax.set_xlabel(\"Time\")\n", + "ax.legend()\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We recover the event study coefficients with compressed data. Now, we need implement the one-hot-encoding steps above in duckdb." + "The two-way Mundlak specification correctly recovers the treatment effect/impulse response function." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Multiple cohorts\n", + "### Multiple cohorts\n", "\n", "Event study, followed by fully interacted (Sunab / Wooldridge) regression." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -607,7 +553,7 @@ " treatment_start_cohorts=[15],\n", " sigma_unit=1,\n", " sigma_time=0.5,\n", - " sigma_epsilon=.2,\n", + " sigma_epsilon=0.2,\n", " hetfx=False,\n", " base_treatment_effects=[0.1 * np.log(np.arange(1, 30 - 15 + 1))],\n", " return_dataframe=True,\n", @@ -617,7 +563,9 @@ " unit_intercepts = np.random.normal(0, sigma_unit, num_units)\n", " ####################################################################\n", " # time FEs: Generate day-of-the-week pattern\n", - " day_effects = np.array([-0.1, 0.1, 0, 0, 0.1, 0.5, 0.5]) # Stronger effects on weekends\n", + " day_effects = np.array(\n", + " [-0.1, 0.1, 0, 0, 0.1, 0.5, 0.5]\n", + " ) # Stronger effects on weekends\n", " day_pattern = np.tile(day_effects, num_periods // 7 + 1)[:num_periods]\n", " # autoregressive structure in time FEs\n", " ar_coef_time = 0.2\n", @@ -650,12 +598,16 @@ " # Create a 2D array to store the heterogeneous treatment effects\n", " treatment_effect = np.zeros((num_units, num_periods))\n", " # iterate over treatment cohorts\n", - " for cohort_idx, (treatment_start, num_treated_cohort) in enumerate(zip(treatment_start_cohorts, num_treated)):\n", + " for cohort_idx, (treatment_start, num_treated_cohort) in enumerate(\n", + " zip(treatment_start_cohorts, num_treated)\n", + " ):\n", " base_treatment_effect = base_treatment_effects[cohort_idx]\n", " cohort_treatment_effect = np.zeros((num_units, num_periods - treatment_start))\n", "\n", " for i in range(num_units):\n", - " cohort_treatment_effect[i, :] = heterogeneous_multipliers[i] * base_treatment_effect\n", + " cohort_treatment_effect[i, :] = (\n", + " heterogeneous_multipliers[i] * base_treatment_effect\n", + " )\n", " cohort_treated_units = np.random.choice(\n", " np.setdiff1d(np.arange(num_units), treated_units),\n", " num_treated_cohort,\n", @@ -663,7 +615,9 @@ " )\n", " treated_units = np.concatenate((treated_units, cohort_treated_units))\n", " treatment_status[cohort_treated_units, treatment_start:] = True\n", - " treatment_effect[cohort_treated_units, treatment_start:] += cohort_treatment_effect[cohort_treated_units, :]\n", + " treatment_effect[\n", + " cohort_treated_units, treatment_start:\n", + " ] += cohort_treatment_effect[cohort_treated_units, :]\n", "\n", " # Apply the heterogeneous treatment effect to the treated units\n", " Y1 = Y0.copy()\n", @@ -681,7 +635,7 @@ " # Create a DataFrame\n", " unit_ids = np.repeat(np.arange(num_units), num_periods)\n", " time_ids = np.tile(np.arange(num_periods), num_units)\n", - " W_it = treatment_status.flatten()\n", + " W_it = treatment_status.flatten().astype(int)\n", " Y_it = np.where(W_it, Y1.flatten(), Y0.flatten())\n", " unit_intercepts_flat = np.repeat(unit_intercepts, num_periods)\n", " time_intercepts_flat = np.tile(time_intercepts, num_units)\n", @@ -711,13 +665,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "num_periods = 30\n", "treatment_start_cohorts = [10, 15, 20]\n", - "num_treated_units = [25, 50, 25]\n", + "num_treated_units = [25_000, 50_000, 25_000]\n", "\n", "# effect functions\n", "treat_effect_vector_1 = np.log(2 * np.arange(1, num_periods - treatment_start_cohorts[1]+ 1))\n", @@ -731,7 +685,7 @@ "sigma_i, sigma_t = 2, 1\n", "sigma_epsilon=1\n", "dgp = panel_dgp_stagg(\n", - " num_units=200, num_treated=num_treated_units,\n", + " num_units=100_000, num_treated=num_treated_units,\n", " num_periods=num_periods,\n", " treatment_start_cohorts = treatment_start_cohorts, hetfx=False,\n", " base_treatment_effects= base_treatment_effects,\n", @@ -743,577 +697,69 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Create a figure and axis\n", - "fig, ax = plt.subplots(figsize=(12, 6))\n", - "\n", - "# Plot the raw time series data for each unit\n", - "for unit_id in range(Y0.shape[0]):\n", - " Y = (1 - W[unit_id]) * Y0[unit_id] + W[unit_id] * Y1[unit_id]\n", - " ax.plot(Y, alpha=0.3, color = 'grey')\n", - "# Add vertical lines to indicate treatment start for each cohort\n", - "for cohort_start in treatment_start_cohorts:\n", - " ax.axvline(x=cohort_start - 0.5, color='red', linestyle='--')\n", - "# Plot the true treatment effect functions for each cohort\n", - "for cohort_idx, cohort_start in enumerate(treatment_start_cohorts):\n", - " effect_vector = base_treatment_effects[cohort_idx]\n", - " effect_vector_padded = np.zeros(num_periods)\n", - " effect_vector_padded[cohort_start:cohort_start+len(effect_vector)] = effect_vector\n", - " ax.plot(effect_vector_padded, marker=\"o\", label=f\"True Effect (Cohort {cohort_idx + 1})\")\n", - "\n", - "ax.plot(Y0.mean(0), color='b', marker='o', label=r\"$\\alpha_i + \\gamma_t$\")\n", - "\n", - "# Overlay week dotted lines\n", - "for week in range(1, num_periods // 7 + 1):\n", - " ax.axvline(x=week * 7 - 0.5, color='k', linestyle=':', alpha=0.5)\n", - "\n", - "# Add labels and title\n", - "ax.set_xlabel(\"Time\")\n", - "ax.set_ylabel(\"Outcome (Y)\")\n", - "ax.set_title(\"Outcome Time Series\")\n", - "\n", - "# Add legend\n", - "ax.legend()\n", - "\n", - "# Show the plot\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f, ax = plt.subplots(2, 2, figsize=(10, 10), sharex=True, sharey=True)\n", - "ax[0][0].matshow(np.ma.array(Y0), aspect='auto')\n", - "ax[0][0].set_title(\"Y0\")\n", - "ax[0][1].matshow(np.ma.array(Y1, mask = 1-W), aspect='auto')\n", - "ax[0][1].set_title(\"Y1\")\n", - "ax[1][0].matshow(W == 1, aspect='auto')\n", - "ax[1][0].set_title(\"W\")\n", - "cax = ax[1][1].matshow(Y1 - Y0, aspect='auto')\n", - "ax[1][1].set_title(r\"$Y^1 - Y^0$\")\n", - "# f.colorbar(cax, pad=0.2)\n", - "f.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "df = dgp['dataframe']\n", - "# create ever_treated column which takes value 1 if unit has ever been treated\n", - "df['ever_treated'] = df.groupby('unit_id')['W_it'].transform('max')\n", - "# generate first time period under treatment for each unit\n", - "df = df.merge(\n", - " df.assign(first_treated_period = df['time_id'] * df['W_it']).groupby('unit_id')['first_treated_period'].apply(lambda x: x[x > 0].min()),\n", - " on='unit_id')\n", - "df['rel_year'] = df['time_id'] - df['first_treated_period']\n", - "# replace NaN values with Inf\n", - "df['first_treated_period'] = df['first_treated_period'].replace(np.nan, 0).astype(\"int\")\n", - "df['rel_year'] = df['rel_year'].replace(np.nan, np.inf)\n", - "\n", - "cohort_dummies = pd.get_dummies(df.first_treated_period, drop_first = True, prefix = \"cohort_dummy\")\n", - "df_int = pd.concat([df, cohort_dummies], axis = 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/alal/Desktop/duckreg/.venv/lib/python3.11/site-packages/pyfixest/estimation/feols_.py:1987: UserWarning: \n", - " The following variables are collinear: ['C(rel_year, contr.treatment(base=-1.0))[T.inf]'].\n", - " The variables are dropped from the model.\n", - " \n", - " warnings.warn(\n" + "Data loaded into DuckDB database: stagg_event_study_data.db\n" ] } ], "source": [ - "m2 = pf.feols(\"Y_it ~ i(rel_year, ref = -1.0) | unit_id + time_id\", df,\n", - " vcov = {\"CRV1\": \"unit_id\"})\n", - "m_did2s = pf.did.estimation.did2s(\n", - " df,\n", - " yname=\"Y_it\",\n", - " first_stage=\"~ 0 | unit_id + time_id\",\n", - " second_stage=\"~i(rel_year,ref=-1.0)\",\n", - " treatment=\"W_it\",\n", - " cluster=\"unit_id\",\n", - ")\n" + "db_name = 'stagg_event_study_data.db'\n", + "create_duckdb_database(df, db_name)" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - " " - ], + "application/vnd.jupyter.widget-view+json": { + "model_id": "410c12b21e7243ecafa900b94470cd10", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "" + "FloatProgress(value=0.0, layout=Layout(width='auto'), style=ProgressStyle(bar_color='black'))" ] }, - "execution_count": 49, "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pf.iplot([m2,\n", - " m_did2s,\n", - " ],\n", - " xintercept=18.5,\n", - " yintercept=0,\n", - " figsize=[1200, 400],\n", - " plot_backend=\"lets_plot\", coord_flip=False, )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Eq 6.15 in Wooldridge\n", - "\n", - "$$\n", - "Y_{it} = \\alpha + \n", - "\\overbrace{\n", - "\\lambda_q d_q + \\dots \\lambda_T d_T\n", - "}^{\\text{cohort dummies}} + \n", - "\\overbrace{\n", - "\\sum_{s=2}^T \\theta_s fs_t\n", - "}^{\\text{time dummies}} + \n", - "\\overbrace{\n", - " \\sum_{r=q}^T \\sum_{s=r}^T \\tau_{rs} (d_r fs_t)\n", - "}^{\\text{cohort - time dummies}} + \n", - "\\epsilon_{it}\n", - "$$\n", - "\n", - "Under CCT, we exclude cohort-specific-time-specific effects prior to the treatment ($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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
EstimateStd. Errort valuePr(>|t|)2.5%97.5%
Coefficient
C(rel_year, contr.treatment(base=-1.0))[T.14.0]:cohort_dummy_150.7035500.4334881.6229981.061730e-01-0.1512701.558370
C(rel_year, contr.treatment(base=-1.0))[T.-16.0]:cohort_dummy_20-0.2707280.482886-0.5606465.756696e-01-1.2229590.681502
C(rel_year, contr.treatment(base=-1.0))[T.16.0]:cohort_dummy_100.7106070.4049131.7549638.080460e-02-0.0878641.509077
C(rel_year, contr.treatment(base=-1.0))[T.-8.0]:cohort_dummy_20-0.6995410.502003-1.3935001.650231e-01-1.6894690.290387
C(rel_year, contr.treatment(base=-1.0))[T.5.0]:cohort_dummy_10-0.1266740.442231-0.2864427.748374e-01-0.9987330.745386
C(rel_year, contr.treatment(base=-1.0))[T.-10.0]:cohort_dummy_20-0.0253610.485448-0.0522439.583872e-01-0.9826430.931920
C(rel_year, contr.treatment(base=-1.0))[T.-9.0]:cohort_dummy_20-0.0409650.482986-0.0848169.324928e-01-0.9933920.911462
C(rel_year, contr.treatment(base=-1.0))[T.2.0]:cohort_dummy_151.9473340.2829896.8813067.540613e-111.3892922.505376
C(rel_year, contr.treatment(base=-1.0))[T.3.0]:cohort_dummy_152.2278070.3225896.9060236.553535e-111.5916762.863939
C(rel_year, contr.treatment(base=-1.0))[T.-7.0]:cohort_dummy_20-0.8652330.495434-1.7464128.228230e-02-1.8422080.111742
\n", - "" - ], - "text/plain": [ - " Estimate Std. Error \\\n", - "Coefficient \n", - "C(rel_year, contr.treatment(base=-1.0))[T.14.0]... 0.703550 0.433488 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-16.0... -0.270728 0.482886 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.16.0]... 0.710607 0.404913 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-8.0]... -0.699541 0.502003 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.5.0]:... -0.126674 0.442231 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-10.0... -0.025361 0.485448 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-9.0]... -0.040965 0.482986 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.2.0]:... 1.947334 0.282989 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.3.0]:... 2.227807 0.322589 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-7.0]... -0.865233 0.495434 \n", - "\n", - " t value Pr(>|t|) \\\n", - "Coefficient \n", - "C(rel_year, contr.treatment(base=-1.0))[T.14.0]... 1.622998 1.061730e-01 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-16.0... -0.560646 5.756696e-01 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.16.0]... 1.754963 8.080460e-02 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-8.0]... -1.393500 1.650231e-01 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.5.0]:... -0.286442 7.748374e-01 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-10.0... -0.052243 9.583872e-01 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-9.0]... -0.084816 9.324928e-01 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.2.0]:... 6.881306 7.540613e-11 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.3.0]:... 6.906023 6.553535e-11 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-7.0]... -1.746412 8.228230e-02 \n", - "\n", - " 2.5% 97.5% \n", - "Coefficient \n", - "C(rel_year, contr.treatment(base=-1.0))[T.14.0]... -0.151270 1.558370 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-16.0... -1.222959 0.681502 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.16.0]... -0.087864 1.509077 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-8.0]... -1.689469 0.290387 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.5.0]:... -0.998733 0.745386 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-10.0... -0.982643 0.931920 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-9.0]... -0.993392 0.911462 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.2.0]:... 1.389292 2.505376 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.3.0]:... 1.591676 2.863939 \n", - "C(rel_year, contr.treatment(base=-1.0))[T.-7.0]... -1.842208 0.111742 " - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "print(\n", - " ff := f\"\"\"\n", - " Y_it ~\n", - " {'+'.join([f\"i(rel_year, {x}, ref = -1.0)\" for x in df_int.filter(like = \"cohort_dummy\", axis = 1).columns])}\n", - " | first_treated_period + time_id\n", - " \"\"\" # programmatically create all event X treatment interactions interacted with cohort\n", + "mundlak = DuckMundlakEventStudy(\n", + " db_name=\"stagg_event_study_data.db\",\n", + " table_name=\"panel_data\",\n", + " outcome_var=\"Y_it\",\n", + " treatment_col=\"W_it\",\n", + " unit_col=\"unit_id\",\n", + " time_col=\"time_id\",\n", + " cluster_col=\"unit_id\",\n", + " n_bootstraps=0,\n", + " seed=42,\n", ")\n", - "# cohort intercepts and time intercepts partialled out\n", - "\n", - "m3 = pf.feols(ff, df_int,\n", - " vcov = {\"CRV1\": \"unit_id\"})\n", - "res = m3.tidy()\n", - "# create a dict with cohort specific effect curves\n", - "res_dict = {}\n", - "for c in cohort_dummies.columns:\n", - " res_cohort = res.filter(like = c, axis = 0)\n", - " event_time = res_cohort.index.str.extract(r'\\[T\\.(-?\\d+\\.\\d+)\\]').astype(float).values.flatten()\n", - " res_dict[c] = {\n", - " 'est': res_cohort, 'time': event_time\n", - " }\n", "\n", - "res.sample(10)" + "mundlak.fit()\n", + "evsum = mundlak.summary()" ] }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 17, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_795918/1522635039.py:34: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " df_tmp['rel_time'] = df_tmp['time_id'] - j\n", - "/tmp/ipykernel_795918/1522635039.py:34: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " df_tmp['rel_time'] = df_tmp['time_id'] - j\n", - "/tmp/ipykernel_795918/1522635039.py:34: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " df_tmp['rel_time'] = df_tmp['time_id'] - j\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXhM59vA8e9km+yJRCIJIfaIJfYt1aAqsRUtxauItYpaSlFdEopUUbRq6SJa5UeriqqlqC2oltZO7EttiS0R2WfO+0eaUyOLhCQzSe7Pdc1l5plnzrnnnPPMyD3PolEURUEIIYQQQgghhBBCiEJkZuwAhBBCCCGEEEIIIUTJI0kpIYQQQgghhBBCCFHoJCklhBBCCCGEEEIIIQqdJKWEEEIIIYQQQgghRKGTpJQQQgghhBBCCCGEKHSSlBJCCCGEEEIIIYQQhU6SUkIIIYQQQgghhBCi0ElSSgghhBBCCCGEEEIUOklKCSGEEEIIIYQQQohCJ0kpIYQQoojbuXMnGo2GnTt3GjuUPNFoNISFhRk7jGJr6dKlaDQaLl26ZOxQRA4uXbqERqNh6dKlBbofY39OhIWFodFojLJvIYQQpkuSUkIIIQpNxh/J2d1+//13Y4fIvn37CAsL4/79+7l+zc8//0xgYCDu7u7Y2tpSqVIlXn31VTZv3qzWuX79OmFhYRw+fDj/gzZhGzduNLnEU0JCAmFhYUUuiVfUrVixgrlz5xo7DFGApG0JIYTIKwtjByCEEKLkmTJlChUrVsxUXqVKFSNEY2jfvn1MnjyZkJAQnJ2dn1h/1qxZvP322wQGBvLOO+9ga2vLuXPn2LZtGytXriQ4OBhIT0pNnjwZHx8f6tatW7BvwoRs3LiRzz//PMvEVGJiIhYWhf9fkYSEBCZPngxAy5YtC33/JdWKFSs4fvw4o0ePNnYoooDk1Lbee+89Jk6caISohBBCmDJJSgkhhCh07dq1o2HDhsYO45mlpaXx4Ycf8uKLL/Lrr79mej46OtoIURUd1tbWxg5B5MHDhw+xs7MzdhgmQ1EUkpKSsLGxMXYoRYKFhYVRktBCCCFMmwzfE0IIYVJSU1NxcXGhf//+mZ6Li4vD2tqacePGqWXJycmEhoZSpUoVtFot3t7ejB8/nuTkZIPXajQaRowYwdq1a6lVqxZarZaaNWsaDLELCwvj7bffBqBixYrqsMLs5uS5ffs2cXFxBAQEZPm8u7s7kD6XS6NGjQDo37+/ut2MOWR8fHwICQnJ9PqWLVtm6m3wzz//0KVLF+zs7HB3d2fMmDGZ3mtoaCiWlpbExMRk2uaQIUNwdnYmKSkpy5gznD59mm7duuHi4oK1tTUNGzZk/fr1BnVSU1OZPHkyVatWxdraGldXV5577jm2bt0KQEhICJ9//jmAwTDNDI/PKZUx58yZM2d47bXXcHJyws3Njffffx9FUbh69SqdO3fG0dERDw8PZs+ebRBPSkoKH3zwAQ0aNMDJyQk7OztatGjBjh071DqXLl3Czc0NgMmTJ6sxPRpHfrz37GQ3r05W8z/5+PjQsWNHIiMjady4MdbW1lSqVIlvv/020+tPnDhB69atsbGxoVy5ckydOhW9Xp9lDJs2baJFixbY2dnh4OBAhw4dOHHihEGdkJAQ7O3tOX/+PO3bt8fBwYHevXtn+74ePHjA6NGj8fHxQavV4u7uzosvvshff/0FpF/Lv/zyC5cvX1aPuY+PD5C785bhzp079OnTB0dHR5ydnenXrx9HjhzJck6mH374AT8/P6ytralVqxY//fQTISEh6n4z6PV65s6dS82aNbG2tqZMmTK8/vrr3Lt3z6BexvnYsmULDRs2xMbGhsWLFwNw//59Ro8ejbe3N1qtlipVqjBjxoxM5+D+/fuEhITg5OSkxp/bocJ3795l3Lhx1K5dG3t7exwdHWnXrh1HjhzJVDc3nxOPHqcGDRpgY2ND6dKlee2117h27ZpBnYzr4cKFCwQFBWFnZ4eXlxdTpkxBURTgyW0rq2s/I7FfuXJltFotPj4+TJo0KVOseWkLQgghihb5uUIIIUShi42N5fbt2wZlGo0GV1dXLC0t6dq1K2vWrGHx4sVYWVmpddauXUtycjI9e/YE0v+YfOmll4iMjGTIkCHUqFGDY8eOMWfOHM6cOcPatWsN9hEZGcmaNWsYNmwYDg4OfPrpp7zyyitcuXIFV1dXXn75Zc6cOcP//vc/5syZQ+nSpQHUP7Qe5+7ujo2NDT///DNvvvkmLi4uWdarUaMGU6ZM4YMPPmDIkCG0aNECgObNm+fpuCUmJvLCCy9w5coVRo4ciZeXF8uWLeO3334zqNenTx+mTJnCqlWrGDFihFqekpLC6tWreeWVV3LspXTixAkCAgIoW7YsEydOxM7Oju+//54uXbrw448/0rVrVyD9j8zw8HAGDRpE48aNiYuL4+DBg/z111+8+OKLvP7661y/fp2tW7eybNmyXL/PHj16UKNGDT766CN++eUXpk6diouLC4sXL6Z169bMmDGD5cuXM27cOBo1asTzzz8PpCctv/rqK3r16sXgwYN58OABX3/9NUFBQfzxxx/UrVsXNzc3Fi5cyBtvvEHXrl15+eWXAahTp06+vvf8cu7cObp168bAgQPp168fS5YsISQkhAYNGlCzZk0Abt68SatWrUhLS1Nj/uKLL7LswbNs2TL69etHUFAQM2bMICEhgYULF/Lcc8/x999/GyRs0tLSCAoK4rnnnmPWrFnY2tpmG+fQoUNZvXo1I0aMwM/Pjzt37hAZGcmpU6eoX78+7777LrGxsfzzzz/MmTMHAHt7eyB35w3S23unTp34448/eOONN/D19WXdunX069cvUzy//PILPXr0oHbt2oSHh3Pv3j0GDhxI2bJlM9V9/fXXWbp0Kf3792fkyJFcvHiR+fPn8/fff7N3714sLS3VulFRUfTq1YvXX3+dwYMHU716dRISEggMDOTatWu8/vrrlC9fnn379vHOO+9w48YNdR4tRVHo3LkzkZGRDB06lBo1avDTTz9lGX9WLly4wNq1a+nevTsVK1bk1q1bLF68mMDAQE6ePImXlxeQ+88JQH3fjRo1Ijw8nFu3bjFv3jz27t3L33//bTCEWafTERwcTNOmTfn444/ZvHkzoaGhpKWlMWXKlCe2rawMGjSIb775hm7dujF27FgOHDhAeHg4p06d4qeffjKom5u2IIQQoghShBBCiEISERGhAFnetFqtWm/Lli0KoPz8888Gr2/fvr1SqVIl9fGyZcsUMzMzZc+ePQb1Fi1apADK3r171TJAsbKyUs6dO6eWHTlyRAGUzz77TC2bOXOmAigXL17M1Xv64IMPFECxs7NT2rVrp0ybNk05dOhQpnp//vmnAigRERGZnqtQoYLSr1+/TOWBgYFKYGCg+nju3LkKoHz//fdq2cOHD5UqVaoogLJjxw61vFmzZkqTJk0MtrdmzZpM9bLywgsvKLVr11aSkpLUMr1erzRv3lypWrWqWubv76906NAhx20NHz5cye6/G4ASGhqqPg4NDVUAZciQIWpZWlqaUq5cOUWj0SgfffSRWn7v3j3FxsbG4LilpaUpycnJBvu4d++eUqZMGWXAgAFqWUxMTKZ9F8R7z0rGe3xcRtt49LqrUKGCAii7d+9Wy6KjoxWtVquMHTtWLRs9erQCKAcOHDCo5+TkZLDNBw8eKM7OzsrgwYMN9n3z5k3FycnJoLxfv34KoEycODFX78vJyUkZPnx4jnU6dOigVKhQIVN5bs/bjz/+qADK3Llz1TKdTqe0bt06U9uqXbu2Uq5cOeXBgwdq2c6dOxXAIIY9e/YogLJ8+XKD/W/evDlTecb52Lx5s0HdDz/8ULGzs1POnDljUD5x4kTF3NxcuXLliqIoirJ27VoFUD7++GOD996iRYtsPxselZSUpOh0OoOyixcvKlqtVpkyZYpaltvPiZSUFMXd3V2pVauWkpiYqNbdsGGDAigffPCBWpZxPbz55ptqmV6vVzp06KBYWVkpMTExiqLk3LYev/YPHz6sAMqgQYMM6o0bN04BlN9++00ty21bEEIIUfTI8D0hhBCF7vPPP2fr1q0Gt02bNqnPt27dmtKlS7Nq1Sq17N69e2zdupUePXqoZT/88AM1atTA19eX27dvq7fWrVsDZBr+06ZNGypXrqw+rlOnDo6Ojly4cOGp38vkyZNZsWIF9erVY8uWLbz77rs0aNCA+vXrc+rUqafeblY2btyIp6cn3bp1U8tsbW0ZMmRIprp9+/blwIEDnD9/Xi1bvnw53t7eBAYGZruPu3fv8ttvv/Hqq6/y4MED9ZjeuXOHoKAgzp49qw7tcXZ25sSJE5w9ezYf32V674kM5ubmNGzYEEVRGDhwoFru7OxM9erVDc6dubm52rNOr9dz9+5d0tLSaNiwoTqMLCem8N4f5+fnp/asg/Ree4+/740bN9K0aVMaN25sUO/x4XZbt27l/v379OrVy6C9mJub06RJkyyHy73xxhu5itPZ2ZkDBw5w/fr1vL7FXJ+3zZs3Y2lpyeDBg9UyMzMzhg8fbrC969evc+zYMfr27av2xgIIDAykdu3aBnV/+OEHnJycePHFFw2OSYMGDbC3t890TCpWrEhQUFCmbbRo0YJSpUoZbKNNmzbodDp2794NpJ8nCwsLg2Nqbm7Om2++mavjpNVqMTNL/6+7Tqfjzp072NvbU716dYPjlNvPiYMHDxIdHc2wYcMMek526NABX19ffvnll0wxPNrzMmNIdEpKCtu2bcvVe3jUxo0bAXjrrbcMyseOHQuQaf+5aQtCCCGKHhm+J4QQotA1btw4x4nOLSwseOWVV1ixYgXJyclotVrWrFlDamqqQVLq7NmznDp1KtvhdY9PNF6+fPlMdUqVKpVp7pi86tWrF7169SIuLo4DBw6wdOlSVqxYQadOnTh+/Hi+Teh9+fJlqlSpkmlelurVq2eq26NHD0aPHs3y5cv54IMPiI2NZcOGDYwZMybLOY0ynDt3DkVReP/993n//fezrBMdHU3ZsmWZMmUKnTt3plq1atSqVYvg4GD69OmT43Cd3Hj8PDk5OWFtba0Op3y0/M6dOwZl33zzDbNnz+b06dOkpqaq5Vmt9vg4U3jvj8vNNXv58mWaNGmSqd7j10VGAi0jafs4R0dHg8cWFhaUK1cuV3F+/PHH9OvXD29vbxo0aED79u3p27cvlSpVytXrc3PeLl++jKenZ6ZhhI+v2nn58uUsyzPKHk3gnD17ltjYWHX+t8c9/hmS1XV09uxZjh49+sTPoYz4H02UQdbtNyt6vZ558+axYMECLl68iE6nU59zdXVV7+f2cyLjOGW1f19fXyIjIw3KzMzMMp3PatWqAWQ7715OLl++jJmZWabz5OHhgbOzsxpfhoL6/BZCCGFckpQSQghhknr27MnixYvZtGkTXbp04fvvv8fX1xd/f3+1jl6vp3bt2nzyySdZbsPb29vgsbm5eZb1lH8n6n1Wjo6OvPjii7z44otYWlryzTffcODAgRx7JgHZJol0Ol22MT9JqVKl6Nixo5qUWr16NcnJybz22ms5vi5jYuZx48Zl6hGSIeOPyOeff57z58+zbt06fv31V7766ivmzJnDokWLDHo75VVW7zk35+67774jJCSELl268Pbbb+Pu7o65uTnh4eEGPcayUxjvPadznZX8vGYz3t+yZcvw8PDI9PzjK6M92jPnSV599VVatGjBTz/9xK+//srMmTOZMWMGa9asoV27djm+9lnP27PQ6/W4u7uzfPnyLJ9/PNGU1Txder2eF198kfHjx2e5jYzEzbOaPn0677//PgMGDODDDz/ExcUFMzMzRo8ene2k9kVBTknyRxX057cQQgjjkKSUEEIIk/T888/j6enJqlWreO655/jtt9949913DepUrlyZI0eO8MILL+T6D5snya/tNGzYkG+++YYbN248cbulSpXKcgWuy5cvG/RMqFChAsePH0dRFIPtRUVFZbndvn370rlzZ/7880+WL19OvXr1njghcMb+LC0tadOmTY51AXWlxP79+xMfH8/zzz9PWFiYmpjJr+OZG6tXr6ZSpUqsWbPGYL+hoaEG9bKLKb/fe1ZKlSoFpK/C9ugk0o/3CsmLChUqZDmM8PHrImPoqru7e67eX155enoybNgwhg0bRnR0NPXr12fatGlqUiq7457b81ahQgV27NhBQkKCQW+pc+fOZaqXVXlWZZUrV2bbtm0EBARkmXDKjcqVKxMfH//EY1qhQgW2b99OfHy8QW+p7Nrv41avXk2rVq34+uuvDcrv379v0Iswt58TGccpKioqU++5qKgo9fkMer2eCxcuGCTZzpw5A6BOkJ+X9l6hQgX0ej1nz56lRo0aavmtW7e4f/9+pv0LIYQonmROKSGEECbJzMyMbt268fPPP7Ns2TLS0tIMhu5Beu+Ma9eu8eWXX2Z6fWJiIg8fPszzfu3s7ABytUx7QkIC+/fvz/K5jDmyMobG5LTdypUr8/vvv5OSkqKWbdiwgatXrxrUa9++PdevX2f16tUGMXzxxRdZxtCuXTtKly7NjBkz2LVr1xN7SUF6wqJly5YsXrxYTag9KiYmRr3/+NA5e3t7qlSpYrCce16O57PK6EnxaM+JAwcOZDpHGQmNx2PK7/eelYzEUMY8QwAPHz7km2++yfF1OWnfvj2///47f/zxh0Gsj/f+CQoKwtHRkenTpxsMkXv0NU9Dp9MRGxtrUObu7o6Xl1ema+HxepD78xYUFERqaqpBe9fr9Xz++ecG9by8vKhVqxbffvst8fHxavmuXbs4duyYQd1XX30VnU7Hhx9+mCmutLS0XF23r776Kvv372fLli2Znrt//z5paWlA+nlKS0tj4cKF6vM6nY7PPvvsifuA9OP0eK+gH374QZ3nLENuPycaNmyIu7s7ixYtMjhPmzZt4tSpU3To0CFTDPPnz1fvK4rC/PnzsbS05IUXXgCyb1tZad++PYC6OmGGjJ6vWe1fCCFE8SM9pYQQQhS6TZs2cfr06UzlzZs3N+gZ1KNHDz777DNCQ0OpXbu2wa/pAH369OH7779n6NCh7Nixg4CAAHQ6HadPn+b7779ny5YtOc5dlZUGDRoA8O6779KzZ08sLS3p1KmTmlx5VEJCAs2bN6dp06YEBwfj7e3N/fv3Wbt2LXv27KFLly7Uq1cPSE9GODs7s2jRIhwcHLCzs6NJkyZUrFiRQYMGsXr1aoKDg3n11Vc5f/483333ncGk7ACDBw9m/vz59O3bl0OHDuHp6cmyZcsyzbGTwdLSkp49ezJ//nzMzc3p1atXro7B559/znPPPUft2rUZPHgwlSpV4tatW+zfv59//vmHI0eOAOkTD7ds2ZIGDRrg4uLCwYMHWb16tcFkyBnHc+TIkQQFBWFubk7Pnj1zFUdedezYkTVr1tC1a1c6dOjAxYsXWbRoEX5+fgbJCRsbG/z8/Fi1ahXVqlXDxcWFWrVqUatWrXx971lp27Yt5cuXZ+DAgbz99tuYm5uzZMkS3NzcuHLlylO97/Hjx7Ns2TKCg4MZNWoUdnZ2fPHFF1SoUIGjR4+q9RwdHVm4cCF9+vShfv369OzZU93vL7/8QkBAgEHSIbcePHhAuXLl6NatG/7+/tjb27Nt2zb+/PNPZs+erdZr0KABq1at4q233qJRo0bY29vTqVOnXJ+3Ll260LhxY8aOHcu5c+fw9fVl/fr13L17FzDspTN9+nQ6d+5MQEAA/fv35969e8yfP59atWoZbDMwMJDXX3+d8PBwDh8+TNu2bbG0tOTs2bP88MMPzJs3z2DC8Ky8/fbbrF+/no4dOxISEkKDBg14+PAhx44dY/Xq1Vy6dInSpUvTqVMnAgICmDhxIpcuXcLPz481a9ZkmajLSseOHZkyZQr9+/enefPmHDt2jOXLl2ea5ym3nxOWlpbMmDGD/v37ExgYSK9evbh16xbz5s3Dx8eHMWPGGNS3trZm8+bN9OvXjyZNmrBp0yZ++eUXJk2apA5zzKltPc7f359+/frxxRdfcP/+fQIDA/njjz/45ptv6NKlC61atcrVcRFCCFHEGWXNPyGEECVSxrL32d0eXxJdr9cr3t7eCqBMnTo1y22mpKQoM2bMUGrWrKlotVqlVKlSSoMGDZTJkycrsbGxaj0gyyXrK1SooPTr18+g7MMPP1TKli2rmJmZKYBy8eLFLPedmpqqfPnll0qXLl2UChUqKFqtVrG1tVXq1aunzJw5M9My9+vWrVP8/PwUCwuLTO939uzZStmyZRWtVqsEBAQoBw8eVAIDA5XAwECDbVy+fFl56aWXFFtbW6V06dLKqFGj1OXrM5Z6f9Qff/yhAErbtm2zfA/ZOX/+vNK3b1/Fw8NDsbS0VMqWLat07NhRWb16tVpn6tSpSuPGjRVnZ2fFxsZG8fX1VaZNm6akpKSoddLS0pQ333xTcXNzUzQajcGS8Dy2dHzGkvEZy8tn6Nevn2JnZ5cpxsDAQKVmzZrqY71er0yfPl09F/Xq1VM2bNig9OvXT6lQoYLBa/ft26c0aNBAsbKyyhRHfr337Bw6dEhp0qSJYmVlpZQvX1755JNP1Lbx6LVWoUIFpUOHDlm+78evi6NHjyqBgYGKtbW1UrZsWeXDDz9Uvv766yyv3x07dihBQUGKk5OTYm1trVSuXFkJCQlRDh48qNbJ7phnJTk5WXn77bcVf39/xcHBQbGzs1P8/f2VBQsWGNSLj49X/u///k9xdnZWAPWc5OW8xcTEKP/3f/+nODg4KE5OTkpISIiyd+9eBVBWrlxpUHflypWKr6+votVqlVq1ainr169XXnnlFcXX1zfTe/jiiy+UBg0aKDY2NoqDg4NSu3ZtZfz48cr169fVOtmdD0VRlAcPHijvvPOOUqVKFcXKykopXbq00rx5c2XWrFkG18SdO3eUPn36KI6OjoqTk5PSp08f5e+//87y8+9xSUlJytixYxVPT0/FxsZGCQgIUPbv3//MnxOrVq1S6tWrp2i1WsXFxUXp3bu38s8//xjUybgezp8/r7Rt21axtbVVypQpo4SGhio6nc6gbnZtK6N9Pyo1NVWZPHmyUrFiRcXS0lLx9vZW3nnnHSUpKcmgXl7aghBCiKJFoygyO6AQQghRXB05coS6devy7bff0qdPH2OHI0S+W7t2LV27diUyMpKAgIAc69atWxc3Nze2bt1aSNEVDyEhIaxevdqgl5kQQgiRH2ROKSGEEKIY+/LLL7G3t+fll182dihCPLPExESDxxlzMjk6OlK/fn21PDU1VZ3LKcPOnTs5cuQILVu2LIxQhRBCCJELMqeUEEIIUQz9/PPPnDx5ki+++IIRI0ZkOSeWEEXNm2++SWJiIs2aNSM5OZk1a9awb98+pk+fbrB63rVr12jTpg2vvfYaXl5enD59mkWLFuHh4cHQoUON+A6EEEII8ShJSgkhhBDF0JtvvsmtW7do3749kydPNnY4QuSL1q1bM3v2bDZs2EBSUhJVqlThs88+yzTBfKlSpWjQoAFfffUVMTEx2NnZ0aFDBz766CNcXV2NFL0QQgghHidzSgkhhBBCCCGEEEKIQidzSgkhhBBCCCGEEEKIQidJKSGEEEIIIYQQQghR6IrdnFJ6vZ7r16/j4OCARqMxdjhCCCGEEEIIIYQQJYqiKDx48AAvLy/MzLLvD1XsklLXr1/H29vb2GEIIYQQQgghhBBClGhXr16lXLly2T5f7JJSDg4OQPobd3R0NHI0QojiJCUlhdmzZwMwduxYrKysjByRyNLDh+DllX7/+nWwszNuPMLkmVzblmtYFGUmdv2aXPsWQuQLadumLy4uDm9vbzVHk51il5TKGLLn6OgoSSkhRL5KS0ujWbNmADg7O2NhUew+QosHc/P/7js6Gv0PImH6TK5tyzUsijITu35Nrn0LIfKFtO2i40nTKmkURVEKKZZCERcXh5OTE7GxsZKUEkKIkujhQ7C3T78fH2/0P4iEyDO5hkVRJtevEEIIcp+bkdX3hBBCCCGEEEIIIUShk6SUEEIIIYQQQgghhCh0JXbgpU6nIzU11dhhCCFyydLSEvNH56kwgpSUFGbOnAnA22+/LRMqClFMSNsWoviS9i1E8SRtu/gocUkpRVG4efMm9+/fN3YoQog8cnZ2xsPD44mT5RUkSWYLUTxJ2xai+JL2LUTxJG27eChxE53fuHGD+/fv4+7ujq2trVH/uBVC5I6iKCQkJBAdHY2zszOenp5GiyM2NhYAJycn+fwwVXo9XLmSfr98eTCTkeoiZybXtuUaFkWZiV2/Jte+hRD5Qtq26cvtROclqqeUTqdTE1Kurq7GDkcIkQc2NjYAREdH4+7ubpShfBqNBmdn50Lfr8gjMzPw8TF2FKIIMbm2LdewKMpM7Po1ufYthMgX0raLjxL101tG9z5bW1sjRyKEeBoZbVe66gohhBBCCCFE0VeiklIZpGufEEWTsduuTqfj999/5/fff0en0xk1FpGDlBR4++30W0qKsaMRRYDJtW25hkVRZmLXr8m1byFEvpC2XXyUqOF7QgjxLHQ6HZs3bwagfv36Rl8NUGQjNRVmzUq/HxYGshqLeAKTa9tyDYuizMSuX5Nr30KIfCFtu/gokT2lRME6ffo0TZs2xdramrp162ZbVpi+/vpr2rZtm+/bXbp0aZEYyzxx4kTefPNNY4dR5JmZmVG7dm1q166NmUw8LESxIW1biOJL2rcQxZO07eJDzl4RoNFocryFhYUVWiwtW7bMMoahQ4eqdUJDQ7GzsyMqKort27dnW/asNBoNa9eufWK9pKQk3n//fUJDQw3K4+LiePfdd/H19cXa2hoPDw/atGnDmjVrMIVFKXOb8Lpx4wb/93//R7Vq1TAzM2P06NGZ6owbN45vvvmGCxcu5H+gJYiFhQWvvPIKr7zyChYW0tFUiOJC2rYQxZe0byGKJ2nbxYecvSLgxo0b6v1Vq1bxwQcfEBUVpZbZ29ur9xVFQafTFWjDHDx4MFOmTDEoe3Ty+PPnz9OhQwcqVKiQY1lhWb16NY6OjgQEBKhl9+/f57nnniM2NpapU6fSqFEjLCws2LVrF+PHj6d169ZG7QGVl4m8k5OTcXNz47333mPOnDlZ1ildujRBQUEsXLiQmTNn5leYQgghhBBCCCHEU5OeUs/gRmwi+87f5kZsYoHux8PDQ705OTmh0WjUx6dPn8bBwYFNmzbRoEEDtFotkZGRhISE0KVLF4PtjB49mpYtW6qP9Xo94eHhVKxYERsbG/z9/Vm9evUT47G1tTWIycPDA0dHRyC999KhQ4eYMmWK2osrqzKAq1ev8uqrr+Ls7IyLiwudO3fm0qVLBvtasmQJNWvWRKvV4unpyYgRIwDw+Xep4a5du6LRaNTHWVm5ciWdOnUyKJs0aRKXLl3iwIED9OvXDz8/P6pVq8bgwYM5fPiwmui7d+8effv2pVSpUtja2tKuXTvOnj2baR9btmyhRo0a2NvbExwcbJBI1Ov1TJkyhXLlyqHVaqlbt646/hng0qVLaDQaVq1aRWBgINbW1ixfvpz+/fsTGxv7xB5xPj4+zJs3j759++Lk5JTtcejUqRMrV67M9nkhhBBCCCGEEKIwlfiklKIoJKSk5fm2bP8lAj76jf/78gABH/3Gsv2X8ryN/BwiNnHiRD766CNOnTpFnTp1cvWa8PBwvv32WxYtWsSJEycYM2YMr732Grt27XrqOG7cuEHNmjUZO3YsN27cYNy4cVmWpaamEhQUhIODA3v27GHv3r1qQifl35VaFi5cyPDhwxkyZAjHjh1j/fr1VKlSBYA///wTgIiICG7cuKE+zkpkZCQNGzZUH+v1elauXEnv3r3x8vLKVN/e3l7taRYSEsLBgwdZv349+/fvR1EU2rdvb9CTKSEhgVmzZrFs2TJ2797NlStXGDdunPr8vHnzmD17NrNmzeLo0aMEBQXx0ksvZUpuTZw4kVGjRnHq1ClatWrF3LlzcXR05MaNG+pxexaNGzfmn3/+yZT4E7mXkpLCxx9/zMcff6xep0KIok/athDFl7RvIYonadvFR4kfvpeYqsPvgy3PtA29Au+vO8H7607k6XUnpwRha5U/p2DKlCm8+OKLua6fnJzM9OnT2bZtG82aNQOgUqVKREZGsnjxYgIDA7N97YIFC/jqq68MyhYvXkzv3r3x8PDAwsICe3t7PDw8gP+SPI+Wfffdd+j1er766is0Gg2QnmBydnZm586dtG3blqlTpzJ27FhGjRql7qdRo0YAuLm5AeDs7KxuMyv3798nNjbWIPl0+/Zt7t27h6+vb47H6OzZs6xfv569e/fSvHlzAJYvX463tzdr166le/fuQPpQu0WLFlG5cmUARowYYTC8cdasWUyYMIGePXsCMGPGDHbs2MHcuXP5/PPP1XqjR4/m5ZdfVh8/2isuP2Qcg8uXL+fYs0zkLCEhwdghCCEKgLRtIYovad9CFE/StouHEp+UKi4e7QmUG+fOnSMhISFTIislJYV69erl+NrevXvz7rvvGpSVKVMmT/s/cuQI586dw8HBwaA8KSmJ8+fPEx0dzfXr13nhhRfytN3HJSamD620trZWy3LbQ+3UqVNYWFjQpEkTtczV1ZXq1atz6tQptczW1lZNSAF4enoSHR0NpE+mfv36dYP5rAACAgI4cuSIQVlez2Fe2djYAPLh/SwsLS0ZNmyYel+YKBsbOH78v/tCPIHJtW25hkVRZmLXr8m1byFEvpC2XXyU+KSUjaU5J6cE5ek1N2OTaPPJLvSP5DbMNLDtrUA8nKyzf2EW+84vdnZ2Bo/NzMwyJV8eHXIWHx8PwC+//ELZsmUN6mm12hz35eTkpA6je1rx8fE0aNCA5cuXZ3rOzc0t35b1dHV1RaPRcO/ePYPtOzs7c/r06XzZx+MfghqN5qmGZj5+DvPb3bt3gf96mYm802g0uLu7GzsM8SRmZlCzprGjEEWIybVtuYZFUWZi16/Jte98cvPhTa7EXaG8Y3k87PKnV70QRUlxbdslUYmfU0qj0WBrZZGnWyU3e8Jfro35v8POzDUawl+uTSU3+zxtJ2PYWkFwc3MzmGwb4PDhw+p9Pz8/tFotV65coUqVKgY3b2/vAosrQ/369Tl79izu7u6Z9u/k5ISDgwM+Pj5s3749221YWlqi0+ly3I+VlRV+fn6cPHlSLTMzM6Nnz54sX76c69evZ3pNfHw8aWlp1KhRg7S0NA4cOKA+d+fOHaKiovDz88vV+3R0dMTLy4u9e/calO/du/eJ27Cysnri+8uL48ePY2lpSU0T+o+iEEIIIYTImzVn1xD0YxADfx1I0I9BrDm7xtghCSHEUyvxSamn1aNReSIntuJ/g5sSObEVPRqVN3ZIBlq3bs3Bgwf59ttvOXv2LKGhoRzP6EoNODg4MG7cOMaMGcM333zD+fPn+euvv/jss8/45ptvctx2QkICN2/eNLg92hMpN3r37k3p0qXp3Lkze/bs4eLFi+zcuZORI0fyzz//ABAWFsbs2bP59NNPOXv2rBpfhoyk1ZP2HxQURGRkpEHZtGnT8Pb2pkmTJnz77becPHmSs2fPsmTJEurVq0d8fDxVq1alc+fODB48mMjISI4cOcJrr71G2bJl6dy5c67f69tvv82MGTNYtWoVUVFRTJw4kcOHDxvMlZUVHx8f4uPj2b59O7dv385x2N3hw4c5fPgw8fHxxMTEcPjwYYNEHMCePXto0aKFOoxP5J1Op+PQoUMcOnQoXxOGIp+lpEBYWPpNJr4UuWBybVuuYVGUmdj1a3Lt+xldibtC2L4w9IoeAL2iZ/L+ydx8eNPIkQlRuIpb2y7JSvzwvWfh6WSDp5Np/oEfFBTE+++/z/jx40lKSmLAgAH07duXY8eOqXU+/PBD3NzcCA8P58KFCzg7O1O/fn0mTZqU47a//PJLvvzyy0z727x5c67js7W1Zffu3UyYMIGXX36ZBw8eULZsWV544QUcHR0B6NevH0lJScyZM4dx48ZRunRpunXrpm5j9uzZvPXWW3z55ZeULVs221XlBg4cSMOGDYmNjcXJyQkAFxcXfv/9dz766COmTp3K5cuXKVWqFLVr12bmzJlqvYiICEaNGkXHjh1JSUnh+eefZ+PGjXkatzxy5EhiY2MZO3Ys0dHR+Pn5sX79eqpWrZrj65o3b87QoUPp0aMHd+7cITQ0lLCwsCzrPjoP2KFDh1ixYgUVKlQwOCYrV67M9vUid3Q6HT///DMAtWvXxtw8/4bginyUmgqTJ6fff/ttsLIybjzC5Jlc25ZrWBRlJnb9mlz7fkpxKXF8H/U9EcciUDCcJkKv6Ln64KoM4xMlSnFp2wI0ytNMfmPC4uLicHJyIjY2Vk1uZEhKSuLixYtUrFjRYOJrUfx1796d+vXr88477xg7FKPYtGkTY8eO5ejRo1hYFN1ctLHbcFpaGqtXrwagW7duRfpYFmsPH4K9ffr9+Hgo4PnaRNFncm1brmFRlJnY9Wty7TuPohOi+e7kd3x/5nsepj7Mso6Zxowtr2yRpJQoUYp62y4JcsrNPErOnCgRZs6cqWbSS6KHDx8SEREhH9bPyMLCgp49exo7DCFEPpO2LUTxVVTb94XYCyw9vpSfL/xMmj4NgCrOVRhQawCn7pxi2allQHpCKrRZqCSkRIlTVNu2yEz+QhUlgo+PD2+++aaxwzCaR4c9CiGEEEII03Qk5ghLji1hx9Ud6jC9+u71GVh7IC3KtkCj0VCrdC2WnVqGtbk1P3f9WRJSQogiTZJSQgghhBBCCGEkiqKw59oelhxfwqFbh9TyVt6tGFBrAHXd6xrUd7d1ByBJl4SDlUNhhiqEEPlOklJCCJFLqampfP755wAMHz48TxPeCyFMl7RtIYovU27fqfpUNl/cTMSJCM7eOwuAhZkFHSt1pH/N/lRyrpTl6+ws7bCztONh6kOiE6Kp6FSxMMMWwiSYctsWeSNJKSGEyCVFUbh//756XwhRPEjbFqL4MsX2nZCawE/nfuKbE99w4+ENAGwtbOlerTuv+b2Wq+F4bjZuPEx9SExCjCSlRIlkim1bPB1JSgkhRC5ZWFgwePBg9b4wUdbW8Mcf/90X4glMrm3LNSyKMhO7fk2pfd9Lusf/Tv+P/53+H/eT7wPgYu3CazVe49Xqr+Kkdcr1tsrYluFS3CVuJdwqoGiFMG2m1LbFs5GzJ4QQuWRmZkbZsmWNHYZ4EnNzaNTI2FGIIsTk2rZcw6IoM7Hr1xTa97X4a3x74lvWnF1Dki4JAG8Hb0JqhvBS5Zewtsh78s7N1g2AmMSYfI1ViKLCFNq2yB+SlBJCCCGEEEKIfBZ1N4olx5ew5dIWdIoOAD9XPwbUGkCb8m0wNzN/6m1nTHYenRCdL7EKIYSxSFJKCCFySa/Xc/z4cQBq1aqFmZmZkSMSWUpJgXnz0u+PGgVWVsaNR5g8k2vbcg2LoszErt/Cbt+KonDw1kG+Pv41e6/tVcubeTZjQO0BNPFogkajeeb9SFJKlHQm990tnpqcuRJs6dKlODs7GzuMPMmvmNeuXUuVKlUwNzdn9OjR2ZYVpj59+jB9+vR8325ISAhdunTJ9+3mt6ZNm/Ljjz8aO4wcpaWlsWbNGtasWUNaWpqxwxHZSU2F8ePTb6mpxo5GFAEm17blGhZFmYldv4XVvvWKnm2Xt9F7Y28GbBnA3mt7MdOYEewTzKqOq/ii7Rc09WyaLwkpkKSUECb33S2emiSlnpZeBxf3wLHV6f/qdQW6u5CQEDQaTaZbcHBwrl7v4+PD3LlzDcp69OjBmTNnCiBaQ4Wd/MrqOGk0GlauXKnWef311+nWrRtXr17lww8/zLbsWezcuRONRqOuCpGTI0eOsHHjRkaOHGlQfu7cOfr370+5cuXQarVUrFiRXr16cfDgwWeOLz/kNuG1e/duOnXqhJeXFxqNhrVr12aq89577zFx4kT0en3+B5pPNBoNlSpVolKlSvn2n0ohhPFJ2xai+Cro9p2iS+HHMz/SeW1nxuwcw7Hbx9Caa+lRvQcbumxgZuBM/Fz98n2/GUmpmASZU0qUTPLdXXzI8L2ncXI9bJ4Acdf/K3P0guAZ4PdSge02ODiYiIgIgzKtVvvU27OxscHGxuZZwzJJERERmRJ2GYmx+Ph4oqOjCQoKwsvLK9uywvTZZ5/RvXt37O3t1bKDBw/ywgsvUKtWLRYvXoyvry8PHjxg3bp1jB07ll27dhV6nBl0Ol2ePvwfPnyIv78/AwYM4OWXX86yTrt27Rg0aBCbNm2iQ4cO+RVqvrK0tKRv377GDkMIkc+kbQtRfBVU+36Q8oAfzvzAdye/Uycbd7ByoGf1nvSu0RtXG9d83+ej3G3+7SmVGI1e0WOmkb4GomSR7+7iQz698urkevi+r2FCCiDuRnr5yfUFtmutVouHh4fBrVSpUkD6+PWwsDDKly+PVqvFy8tL7XXTsmVLLl++zJgxY9ReQ5C5B1NYWBh169ZlyZIllC9fHnt7e4YNG4ZOp+Pjjz/Gw8MDd3d3pk2bZhDXJ598Qu3atbGzs8Pb25thw4YRHx8PpPcW6t+/P7Gxseq+w8LCAEhOTmbcuHGULVsWOzs7mjRpws6dOw22vXTpUsqXL4+trS1du3blzp07uTpWzs7OmY6VtbU1O3fuxMHBAYDWrVuj0WiyLQOIjIykRYsW2NjY4O3tzciRI3n48KG6n+TkZCZMmIC3tzdarZYqVarw9ddfc+nSJVq1agVAqVKl0Gg0hISEZBmrTqdj9erVdOrUSS1TFIWQkBCqVq3Knj176NChA5UrV6Zu3bqEhoaybt06te6xY8do3bo1NjY2uLq6MmTIEPX4P2rWrFl4enri6urK8OHDSX2kS/29e/fo27cvpUqVwtbWlnbt2nH27FmD8+Ds7Mz69evx8/NDq9UyYMAAvvnmG9atW6ee28fPX4Z27doxdepUunbtmu05Mzc3p3379gY92oQQQgghTMHNhzf548YfnLx9kjmH5tB2dVvmHJpDTGIM7rbujGs4jq3dtjKy/sgCT0gBlLYtDUCaPo37yfcLfH9CCFFQpKeUokBqQu7q6nWwaTygZLUhQJPeg6pSS8jNahqWtpBPXQ1//PFH5syZw8qVK6lZsyY3b97kyJEjAKxZswZ/f3+GDBnC4MGDc9zO+fPn2bRpE5s3b+b8+fN069aNCxcuUK1aNXbt2sW+ffsYMGAAbdq0oUmTJkD6cpyffvopFStW5MKFCwwbNozx48ezYMECmjdvzty5c/nggw+IiooCUHsDjRgxgpMnT7Jy5Uq8vLz46aefCA4O5tixY1StWpUDBw4wcOBAwsPD6dKlC5s3byY0NPSZjlPz5s2JioqievXq/PjjjzRv3hwXF5csy86fP09wcDBTp05lyZIlxMTEMGLECEaMGKH2WOvbty/79+/n008/xd/fn4sXL3L79m28vb358ccfeeWVV4iKisLR0THbXmlHjx4lNjaWhg0bqmWHDx/mxIkTrFixIstJ+zKSiQ8fPiQoKIhmzZrx559/Eh0dzaBBgxgxYgRLly5V6+/YsQNPT0927NjBuXPn6NGjB3Xr1lWvh5CQEM6ePcv69etxdHRkwoQJtG/fnpMnT2JpaQlAQkICM2bM4KuvvsLV1RVPT08SExOJi4tTj4eLi8sznZ/GjRvz0UcfPdM2hBBCCCHy05qzawjbF4by2N8AlZwq0b9WfzpU7ICluWWhxmRpZomLtQt3k+4SnRCNi/Wz/R9MCCGMRZJSqQkwPb+GaynpPag+8s5d9UnXwcou11vfsGGDwfAugEmTJjFp0iSuXLmCh4cHbdq0wdLSkvLly9O4cWMgPVFgbm6Og4MDHh4eOe5Dr9ezZMkSHBwc8PPzo1WrVkRFRbFx40bMzMyoXr06M2bMYMeOHWpS6tFJwX18fJg6dSpDhw5lwYIFWFlZ4eTkhEajMdj3lStXiIiI4MqVK+pwuXHjxrF582YiIiKYPn068+bNIzg4mPHjxwNQrVo19u3bx+bNm594rHr16oW5uWFi8OTJk5QvXx53d3f1uGTElFVZeHg4vXv3Vt9f1apV+fTTTwkMDGThwoVcuXKF77//nq1bt9KmTRsAKlWqpO4vI0Hj7u6e45xaly9fxtzcXI0BUHsp+fr65vg+V6xYQVJSEt9++y12dunX0vz58+nUqRMzZsygTJkyQHpvrfnz52Nubo6vry8dOnRg+/btDB48WE1G7d27l+bNmwOwfPlyvL29Wbt2Ld27dwcgNTWVBQsW4O/vr+7fxsaG5OTkJ15XueXl5cXVq1fR6/UmuYJGamoqX3zxBQBDhgxRE3ZCiKJN2rYQxdeztu9Td04Rui/zj6KTm02mS9UuRh02V8a2jJqU8nXJ+f+MQhQ38t1dfEhSqghp1aoVCxcuNCjLSHx0796duXPnUqlSJYKDg2nfvj2dOnXCwiJvp9jHx0cdygZQpkwZzM3NDRIEZcqUITr6v5U+tm3bRnh4OKdPnyYuLo60tDSSkpJISEjA1tY2y/0cO3YMnU5HtWrVDMqTk5NxdU3v8nzq1KlMw72aNWuWq6TUnDlz1ERRhrzOFXXkyBGOHj3K8uXL1TJFUdDr9Vy8eJFjx45hbm5OYGBgnrb7uMTERLRarcEcTYqSVW+8zE6dOoW/v7+akAIICAhAr9cTFRWlJqVq1qxpkKTz9PTk2LFj6jYsLCzUJCOAq6sr1atX59SpU2qZlZUVderUebo3mUs2Njbo9XqSk5NNcr4zRVGIiYlR7wshigdp20IUX0/bvuNT4ll6YikRxyOyfN7b0dvo8zi52bpx6u4pWYFPlEjy3V18SFLK0ja9x1JuXN4Hy7s9uV7v1VChee72nQd2dnZUqVIly+e8vb2Jiopi27ZtbN26lWHDhjFz5kx27dqVp6zx43U1Gk2WZRkrpF26dImOHTvyxhtvMG3aNFxcXIiMjGTgwIGkpKRkm5SKj4/H3NycQ4cOZerR9HhvsKfh4eGR7bHKrfj4eF5//fVMK+IBlC9fnnPnzj3T9jOULl2ahIQEUlJSsLKyAlCTdadPn6ZevXrPvI+czmFu2djYFPjKFnfv3sXOzs4kE1IAFhYW6txgeU34ikJkbQ07dvx3X4gnMLm2LdewKMpM7PrNa/tO0aWwKmoVXx79knvJ97KsY6Yxw9shlyMjClDGCnySlBIlkcl9d4unJmdPo8n9ELrKrdNX2Yu7QdbzSmnSn6/cOndzSuUzGxsbOnXqRKdOnRg+fDi+vr4cO3aM+vXrY2VlhU6ny/d9Hjp0CL1ez+zZs9XeVN9//71Bnaz2Xa9ePXQ6HdHR0bRo0SLLbdeoUYMDBw4YlP3+++/5GH3O6tevz8mTJ7NNbtWuXRu9Xs+uXbsy9coC1ATTk4573bp1gfThhRn369ati5+fH7Nnz6ZHjx6ZhrLdv38fZ2dnatSowdKlS3n48KHaW2rv3r3qUMvcqFGjBmlpaRw4cEAdvnfnzh2ioqLw88t5CeP8vq6OHz+eL0m4gmJmZoaPj4+xwxBPYm4OLVsaOwpRhJhc25ZrWBRlJnb95rZ96/Q6Nl7cyPy/53P9YfoP1j6OPoyqP4rY5Fim/D5FXeUutFkoHnb5M3XBs1BX4JOklCiBTO67Wzw1SUrlhZk5BM9IX2UPDYaJqX97kAR/VGAJqeTkZG7evGlQZmFhQenSpVm6dCk6nY4mTZpga2vLd999h42NDRUqVADSh+Xt3r2bnj17otVqKV26dL7EVKVKFVJTU/nss8/o1KkTe/fuZdGiRQZ1fHx8iI+PZ/v27fj7+2Nra0u1atXo3bs3ffv2Zfbs2dSrV4+YmBi2b99OnTp16NChAyNHjiQgIIBZs2bRuXNntmzZkquhe5CetHn8WDk4OBgMc3uSCRMm0LRpU0aMGMGgQYOws7Pj5MmTbN26lfnz5+Pj40O/fv0YMGCAOtH55cuXiY6O5tVXX6VChQpoNBo2bNhA+/btsbGxybIXmJubG/Xr1ycyMlJNSmk0GiIiImjTpg0tWrTg3XffxdfXl/j4eH7++Wd+/fVXdu3aRe/evQkNDaVfv36EhYURExPDm2++SZ8+fdShe09StWpVOnfuzODBg1m8eDEODg5MnDiRsmXL0rlz5xxf6+Pjw5YtW4iKisLV1RUnJ6cse+bFx8cb9Cy7ePEihw8fxsXFhfLly6vle/bsoW3btrmKWwghhBDiWSmKwp5re5j711zO3kuf09Pdxp036r5BlypdsDBL/3MpoGwAVx9cxdvB2yQSUiA9pYQQxYPpzSRs6vxegle/BUdPw3JHr/Ryv5cKbNebN2/G09PT4Pbcc88B6auxffnllwQEBFCnTh22bdvGzz//rM7PNGXKFC5dukTlypVxc3PLt5j8/f355JNPmDFjBrVq1WL58uWEh4cb1GnevDlDhw6lR48euLm58fHHHwMQERFB3759GTt2LNWrV6dLly78+eefapKiadOmfPnll8ybNw9/f39+/fVX3nvvvVzF1b9//0zH6rPPPsvTe6tTpw67du3izJkztGjRgnr16vHBBx8YzE21cOFCunXrxrBhw/D19WXw4ME8fPgQgLJlyzJ58mQmTpxImTJlGDFiRLb7GjRokMHcVZC+Et3BgwepUqUKgwcPpkaNGrz00kucOHGCuXPnAmBra8uWLVu4e/cujRo1olu3brzwwgvMnz8/T+81IiKCBg0a0LFjR5o1a4aiKGzcuPGJQz8HDx5M9erVadiwIW5ubuzduzfLegcPHqRevXpqL6i33npLPZ4Zrl27xr59++jfv3+eYi9Mer2e06dPc/r06TwPfxSFKDUVPv88/ZaaauxoRBFgcm1brmFRlJnY9ZtT+z4Sc4T+W/ozfPtwzt47i4OVA6Prj2bDyxvoVq2bmpAC8LDzoJFHI5NJSEH6nFIAMYkxRo5EiMJnct/d4qlplGI2K1hcXBxOTk7Exsbi6Oho8FxSUhIXL16kYsWKWD/rGHe9Ln2OqfhbYF8mfQ4pIwzZE8VDYmIi1atXZ9WqVTRr1szY4RjFhAkTuHfvnrqKRlbytQ0/hZSUFKZPnw6kr3yZMURTmJiHDyGjV2J8POShh6QomUyubcs1LIoyE7t+s2rfF+5fYN5f8/jt6m8AWJlZ0btGbwbWHoiT1smY4eZJ1N0ouv3cDRdrF3b12GXscIQoVCb33S0yySk38ygZvve0zMyhYtZzIQmRVzY2Nnz77bfcvn3b2KEYjbu7O2+99Zaxw8iRRqPB29tbvS+EKB6kbQtRfD3avm8l3OKrg1+x9txadX6oLlW68Ib/GybVAyq3Mobv3U26S6ouFUvz3C9uJERRJ9/dxYf0lBJCFBnShkWumNiv9ELkmVzDoigzwes3NjmWr499zYrTK0jWJQPQ2rs1o+qPopJzJSNH9/QURaHBdw1I1aey5ZUteNl7PflFQghRSKSnlBBCCCGEEKLESkpLYvmp5Xx9/GsepDwAoL57fcY0GENd97rGDS4faDQa3G3duRZ/jeiEaElKCSGKJElKCSGEEEIIIYqNNH0aa8+tZeHhhUQnpq9MV7VUVUbXH02Lsi2K1VAfNxs3NSklhBBFkSSlhBAil1JTU4mIiADSV3h80uqEQoiiQdq2EMWDoihsv7KdeX/N41LcJQA8tB5UO1+N2om1adauWbFKSMF/80rJCnyipJHv7uJDklJCCJFLiqJw/fp19b4QoniQti1E0ffnzT+Ze2guR28fBcBZ68yQOkPoWrErs2bM4ubNm8WyfWckpW4l3DJyJEIULvnuLj4KNCkVHh7OmjVrOH36NDY2NjRv3pwZM2ZQvXr1bF+zdOlS+vfvb1Cm1WpJSkoqyFCFEOKJLCws+L//+z/1vjBRWi1s2PDffSGewOTatlzDoigr5Os36m4Uc/+aS+S1SABsLGzo49eHkJohOFg5oNfrTat957OMpJQM3xMljcl9d4unVqBnb9euXQwfPpxGjRqRlpbGpEmTaNu2LSdPnsQuh5U4HB0diYqKUh8Xt262QoiiyczMjGrVqhk7DPEkFhbQoYOxoxBFiMm1bbmGRVFWSNfvPw/+4fPDn/PLhV9QULDQWPBKtVcY6j+U0jal1Xom177zmZutGwAxCTJ8T5Qsxb1tlyQFmpTavHmzweOlS5fi7u7OoUOHeP7557N9nUajwcPDoyBDE0IIIYQQQhQxd5Pu8sXRL1gVtYo0fRoAwT7BvFnvTco7ljdydIWvjG0ZQHpKCSGKLrPC3FlsbCwALi4uOdaLj4+nQoUKeHt707lzZ06cOFEY4Yl8cvr0aZo2bYq1tTV169bNtqwwff3117Rt2zbft7t06VKcnZ3zfbv5rWfPnsyePdvYYRR5er2e8+fPc/78efR6vbHDEdlJTYWlS9NvqanGjkYUASbXtuUaFkVZAV2/CakJLDyykPZr2rP81HLS9Gk09WzKyo4rmRk4M9uElMm173zmZpPeU0qSUqKkKe5tuyQptKSUXq9n9OjRBAQEUKtWrWzrVa9enSVLlrBu3Tq+++479Ho9zZs3559//smyfnJyMnFxcQa34kaj0eR4CwsLK7RYWrZsmWUMQ4cOVeuEhoZiZ2dHVFQU27dvz7bsWWk0GtauXfvEeklJSbz//vuEhoYalMfFxfHuu+/i6+uLtbU1Hh4etGnThjVr1pjEZHm5TXitWbOGF198ETc3NxwdHWnWrBlbtmwxqPPee+8xbdo0NTEsnk5aWhrLli1j2bJlpKWlGTsckZ2UFOjfP/2WkmLsaEQRYHJtW65hUZTl4/V78+FN9l3bx6Iji2i3ph0LDi/gYepD/Fz9+OLFL/iy7ZfUdK2Z4zZMrn3ns4w5pRLSEohPiTdyNEIUnuLetkuSQpsRbPjw4Rw/fpzIyMgc6zVr1oxmzZqpj5s3b06NGjVYvHgxH374Yab64eHhTJ48Od/jNSU3btxQ769atYoPPvjAYM4te3t79b6iKOh0ugKd7G3w4MFMmTLFoMzW1la9f/78eTp06ECFChVyLCssq1evxtHRkYCAALXs/v37PPfcc8TGxjJ16lQaNWqEhYUFu3btYvz48bRu3dqoPaBS8/DL4u7du3nxxReZPn06zs7ORERE0KlTJw4cOEC9evUAqFWrFpUrV+a7775j+PDhBRV2sffo0GKZ606I4kPathCm58czPzJ5/2QU/vuhsLxDed6s/yZtK7TFTJO739aLe/u2tbTF3tKe+NR4ohOjsbeyf/KLhCgGinvbLlGUQjB8+HClXLlyyoULF57q9d26dVN69uyZ5XNJSUlKbGysert69aoCKLGxsZnqJiYmKidPnlQSExOfKo7H3Yi/oRy4fkC5EX8jX7aXGxEREYqTk5P6eMeOHQqgbNy4Ualfv75iaWmp7NixQ+nXr5/SuXNng9eOGjVKCQwMVB/rdDpl+vTpio+Pj2Jtba3UqVNH+eGHH3Lcf2BgoDJq1KhsnwcMbqGhoVmWKYqiXLlyRenevbvi5OSklCpVSnnppZeUixcvGmzv66+/Vvz8/BQrKyvFw8NDGT58uKIoilKhQgWDbVaoUCHbmDp06KCMGzfOoOyNN95Q7OzslGvXrmWq/+DBAyU1NVVRFEW5e/eu0qdPH8XZ2VmxsbFRgoODlTNnzqh1M87H5s2bFV9fX8XOzk4JCgpSrl+/rtbR6XTK5MmTlbJlyypWVlaKv7+/smnTJvX5ixcvKoCycuVK5fnnn1e0Wq0SERGR7XHLDT8/P2Xy5MkGZZMnT1aee+65XG/DFOV3GxbFVHy8okD6LT7e2NEIkXdyDYuiLB+u379u/qXUWlrL4FZ7aW3latzVfA62eHjpp5eUWktrKfuv7zd2KEIIoYqNjc02N/OoAh2+pygKI0aM4KeffuK3336jYsWKed6GTqfj2LFjeHp6Zvm8VqvF0dHR4JbXGBNSE/J8W3l6JUGrgxj460CCVgex8vTKPG9DycchYhMnTuSjjz7i1KlT1KlTJ1evCQ8P59tvv2XRokWcOHGCMWPG8Nprr7Fr166njuPGjRvUrFmTsWPHcuPGDcaNG5dlWWpqKkFBQTg4OLBnzx727t2Lvb09wcHBpPzb1XvhwoUMHz6cIUOGcOzYMdavX0+VKlUA+PPPPwGIiIjgxo0b6uOsREZG0rBhQ/WxXq9n5cqV9O7dGy8vr0z17e3t1Z5mISEhHDx4kPXr17N//34URaF9+/YGPZkSEhKYNWsWy5YtY/fu3Vy5coVx48apz8+bN4/Zs2cza9Ysjh49SlBQEC+99BJnz5412O/EiRMZNWoUp06dolWrVsydOxdHR0du3LihHrfc0Ov1PHjwINPcbY0bN+aPP/4gOTk5V9sRQgghhChMafo0lh5fysBfB2Z6TkHhxsMbWbxKZAzhkxX4hBBFUYEO3xs+fDgrVqxg3bp1ODg4cPPmTQCcnJywsbEBoG/fvpQtW5bw8HAApkyZQtOmTalSpQr3799n5syZXL58mUGDBhVIjIlpiTRZ0eSZtqFHz7QD05h2YFqeXnfg/w5ga2n75Iq5MGXKFF588cVc109OTmb69Ols27ZNHS5ZqVIlIiMjWbx4MYGBgdm+dsGCBXz11VcGZYsXL6Z37954eHhgYWGBvb292p0yI8nzaFnGfGFfffWV2t0yIiICZ2dndu7cSdu2bZk6dSpjx45l1KhR6n4aNWoEgJtb+qSOzs7OOa7UeP/+fWJjYw2ST7dv3+bevXv4+vrmeIzOnj3L+vXr2bt3L82bNwdg+fLleHt7s3btWrp37w6kD7VbtGgRlStXBmDEiBEGwxtnzZrFhAkT6NmzJwAzZsxgx44dzJ07l88//1ytN3r0aF5++WX1sZOT01OtRDlr1izi4+N59dVXDcq9vLxISUnh5s2bRhlGKYQQQgiRnRN3TjB532RO3T2V5fNmGjO8HbwLOaqiISMpdSvhlpEjEUKIvCvQpNTChQuB9MmxHxUREUFISAgAV65cwczsvw5b9+7dY/Dgwdy8eZNSpUrRoEED9u3bh5+fX0GGWuQ92hMoN86dO0dCQkKmRFZKSoo6D1F2evfuzbvvvmtQVqZMmTzt/8iRI5w7dw4HBweD8qSkJM6fP090dDTXr1/nhRdeyNN2H5eYmAiAtbW1WpbbHmqnTp3CwsKCJk3+S1q6urpSvXp1Tp367z9Mtra2akIKwNPTk+jo9BVQ4uLiuH79usF8VgABAQEcOXLEoCyv5zArK1asYPLkyaxbtw53d3eD5zISwQkJCc+8n5IqNTWV5cuXA+ntwNLS0sgRCSHyg7RtIYwnITWBzw9/znenvkOv6HG0cmRcw3HoFT1Tfp+CXtFjpjEjtFkoHnZ5+6EOSkb7lp5SoiQqCW27pCjQpFRu/vjfuXOnweM5c+YwZ86cAoooMxsLGw7834E8veZWwi26rO2Cnv+WnjTTmLG281rK2OY+OWNjYZOn/ebEzs7O4LGZmVmm4//okLP4+PTVOX755RfKli1rUE+r1ea4LycnJ3UY3dOKj4+nQYMG6gfJo9zc3AwSlc/C1dUVjUbDvXv3DLbv7OzM6dOn82Ufj38AajSapxqa+fg5zKuVK1cyaNAgfvjhB9q0aZPp+bt37wL/9TITeacoCpcuXVLvCyGKB2nbQhjHnn/2MPX3qVx/eB2AdhXbMb7ReErblAYgoGwAVx9cxdvB+6kSUlAy2rebTfr/7aIToo0ciRCFpyS07ZKi0FbfM1UajSbPQ+gqOlUktHkok/dPNvj1pqJT3ufMKihubm4cP37coOzw4cNqAsXPzw+tVsuVK1dyHKpXUOrXr8+qVatwd3fPdh4wHx8ftm/fTqtWrbJ83tLSEp1Ol+N+rKys8PPz4+TJk7Rt2xZIT9j17NmTZcuWERoammleqfj4eKytralRowZpaWkcOHBAHb53584doqKict1zz9HRES8vL/bu3WtwnPfu3Uvjxo2fGPuT3l+G//3vfwwYMICVK1fSoUOHLOscP36ccuXKUbp06VxtU2RmYWGhDtssyBUuxTPSauH77/+7L8QTmFzblmtYFGW5uH7vJN5hxp8z2HRxEwBedl681/Q9WpRrYVDPw87jqZNRGUyufReAjB/FoxMlKSVKjpLQtksKOXtP6eWqL9Pcq/kz/3pTUFq3bs3MmTP59ttvadasGd999x3Hjx9Xh+Y5ODgwbtw4xowZg16v57nnniM2Npa9e/fi6OhIv379st12QkKCOj9YBq1WS6lSpXIdX+/evZk5cyadO3dmypQplCtXjsuXL7NmzRrGjx9PuXLlCAsLY+jQobi7u9OuXTsePHjA3r17efPNN4H/klYBAQE57j8oKIjIyEhGjx6tlk2bNo2dO3fSpEkTpk2bRsOGDbG0tGTPnj2Eh4fz559/UrVqVTp37szgwYNZvHgxDg4OTJw4kbJly9K5c+dcv9e3336b0NBQKleuTN26dYmIiODw4cNZ9hJ7lI+PD/Hx8Wzfvh1/f39sbW2xtc2cQF2xYgX9+vVj3rx5NGnSRD03NjY2ODk5qfX27NmjJubE0zEzM6NmzZrGDkM8iYUF/PufFCFyw+TatlzDoijL4fpVFIW159Yy6+As4lLiMNOY8VqN1xhed3i+zbP6OJNr3wXAzVZ6SomSpyS07ZKiQFffK+487Dxo5NHI5BJSkJ6Ief/99xk/fjyNGjXiwYMH9O3b16DOhx9+yPvvv094eDg1atQgODiYX3755YmrJH755Zd4enoa3Hr16pWn+Gxtbdm9ezfly5fn5ZdfpkaNGgwcOJCkpCS151S/fv2YO3cuCxYsoGbNmnTs2NFgxbrZs2ezdetWvL29c5wHa+DAgWzcuJHY2Fi1zMXFhd9//53XXnuNqVOnUq9ePVq0aMH//vc/Zs6cqSZzIiIiaNCgAR07dqRZs2YoisLGjRvzNGZ55MiRvPXWW4wdO5batWuzefNm1q9fT9WqVXN8XfPmzRk6dCg9evTAzc2Njz/+OMt6X3zxBWlpaQwfPtzgnDw6QXxSUhJr165l8ODBuY5bCCGEECK/XI67zKBfB/HBvg+IS4nD18WXFe1X8HajtwssIVVSZMwpdTvhNnpF/4TaQghhWjRKMRuAGRcXh5OTE7GxsZmGhSUlJXHx4kUqVqxoMPG1KP66d+9O/fr1eeedd4wdilEsXLiQn376iV9//dXYoTwTY7dhvV7PP//8A0C5cuXybe4zkc/S0uCnn9Lvd+2a/qu9EDkwubYt17Aoyh67flM1CktPLGXRkUWk6FOwNrdmeN3hvOb3GhZmBX9tm1z7LgCp+lQaLGuAgsKOV3eoc3IJUZyVhLZd1OWUm3mU/C9HlAgzZ87k559/NnYYRmNpaclnn31m7DCKvLS0NJYsWQLApEmTsLKyMnJEIkvJyfDqq+n34+PlD3rxRCbXtuUaFkXZI9fvkcu/E/b3R5y7fw6AZp7NeL/Z+3g7eBdaOCbXvguApZklrjau3E68TXRCtCSlRIlQEtp2SSH/yxElgo+PjzoXVUk0aNAgY4dQLGg0GlxcXNT7QojiQdq2EPnrobUZ87qVYeWOwSgolNKWYnzj8XSo2KHQ21hJad9uNm7cTrxNTEIMuBo7GiEKXklp2yWBJKWEECKXLC0tGTlypLHDEELkM2nbQuSfHdd3M21aVW65WgIKL1V+iXENx1HKOvcL4uSnktK+y9iW4dTdU9xKuGXsUIQoFCWlbZcEkpQSQgghhBBCPJOYhBjC/whn6+Wt4GpJuegUPnhlEc0qtTJ2aCVCxgp8MYkxRo5ECCHyRpJSQgghhBBCiKeiV/SsPrOauYfm8iD1AeYac/ptuMnQddHYDGts7PBKjIwV+KIToo0ciRBC5I0kpYQQIpfS0tJYtWoVAD169MBCJh8WoliQti3E07lw/wKT90/mr+i/AKjlWouwehOo3q+ekSP7T0lp32VsywCSlBIlR0lp2yWBnDkhhMglvV7P2bNn1ftCiOJB2rYQeZOiS+HrY1/z5bEvSdWnYmNhw8h6I+nl2wvzxCRjh2egpLTvjOF7kpQSJUVJadslgSSlhBAil8zNzenSpYt6X5goKyuIiPjvvhBPYHJtW65hYcIO3TrE5P2TuRh7EYDnyz3Pe03ew9PeM72CiV2/Jte+C0jG8L2YBJlTSpQMJaVtlwQaRVEUYweRn+Li4nByciI2NhZHR0eD55KSkrh48SIVK1bE2traSBEKIZ6WtGEhhBDCOOJS4phzaA6rz6wGwNXalYlNJhJUIUiWYzcB95Pu02JVCwAOvXYIK3PjJwSFECVbTrmZR5kVYkzCxCxduhRnZ2djh5En+RXz2rVrqVKlCubm5owePTrbssLUp08fpk+fnu/bDQkJUX9FMFUpKSn4+Phw8OBBY4cihBBCiEcoisKvl36l89rOakLqlaqvsK7LOoJ9giUhZSKctE5YmaUnomQFPiFEUSJJqaek6HQ8PPAHsRt+4eGBP1B0ugLdX0hICBqNJtMtODg4V6/38fFh7ty5BmU9evTgzJkzBRCtocJOfmV1nDQaDStXrlTrvP7663Tr1o2rV6/y4YcfZlv2LHbu3IlGo+H+/ftPrHvkyBE2btzIyJEjDcrPnTtH//79KVeuHFqtlooVK9KrVy+TSd7kNuEVHh5Oo0aNcHBwwN3dnS5duhAVFaU+b2Vlxbhx45gwYUIBRvvs9Ho9N2/e5ObNmzJ23ZSlpcEvv6Tf0tKMHY0oAkyubcs1LEzEzYc3GbljJGN3jeV24m18HH1YErSEsOZhOGmdsn6RiV2/Jte+C4hGo5F5pUSJUlLadkkgc0o9hbhff+XW9HDSbt5Uyyw8PCgz6R0c27YtsP0GBwcTkTFG/19arfapt2djY4ONjc2zhmWSIiIiMiXsMhJj8fHxREdHExQUhJeXV7Zlhemzzz6je/fu2Nvbq2UHDx7khRdeoFatWixevBhfX18ePHjAunXrGDt2LLt27Sr0ODPodLo8/TK6a9cuhg8fTqNGjUhLS2PSpEm0bduWkydPYmdnB0Dv3r0ZO3YsJ06coGbNmgUV+jNJS0tj0aJFAEyaNAkrE5grQ2QhORk6dky/Hx8PshqLeAKTa9tyDQsjuvnwJpdiL3E45jARxyNISEvAwsyCgbUGMrjOYLTmT/i/p4ldvybXvgtQGdsyXIu/JkkpUSKUpLZd3ElPqTyK+/VXro0abZCQAki7dYtro0YT9+uvBbZvrVaLh4eHwa1UqVJAetfqsLAwypcvj1arxcvLS+1107JlSy5fvsyYMWPUXkOQuQdTWFgYdevWZcmSJZQvXx57e3uGDRuGTqfj448/xsPDA3d3d6ZNm2YQ1yeffELt2rWxs7PD29ubYcOGER8fD6T3Furfvz+xsbHqvsPCwgBITk5m3LhxlC1bFjs7O5o0acLOnTsNtr106VLKly+Pra0tXbt25c6dO7k6Vs7OzpmOlbW1NTt37sTBwQGA1q1bo9Fosi0DiIyMpEWLFtjY2ODt7c3IkSN5+PChup/k5GQmTJiAt7c3Wq2WKlWq8PXXX3Pp0iVatWoFQKlSpdBoNISEhGQZq06nY/Xq1XTq1EktUxSFkJAQqlatyp49e+jQoQOVK1embt26hIaGsm7dOrXusWPHaN26NTY2Nri6ujJkyBD1+D9q1qxZeHp64urqyvDhw0lNTVWfu3fvHn379qVUqVLY2trSrl07dTWLjPPg7OzM+vXr8fPzQ6vVMmDAAL755hvWrVunntvHz1+GzZs3ExISQs2aNfH392fp0qVcuXKFQ4cOqXVKlSpFQECAQY82U6PRaHBwcMDBwUGGKwhRjEjbFiLdmrNraLu6LYO3Dubzw5+TkJZAXbe6/NDxB0bUG/HkhJQJKkntW3pKiZKkJLXt4q7E//SmKApKYmLu6up03Jo6DbKaG15RQAO3pk3HrlkzNLlYAUBjY5NvDejHH39kzpw5rFy5kpo1a3Lz5k2OHDkCwJo1a/D392fIkCEMHjw4x+2cP3+eTZs2sXnzZs6fP0+3bt24cOEC1apVY9euXezbt48BAwbQpk0bmjRpAoCZmRmffvopFStW5MKFCwwbNozx48ezYMECmjdvzty5c/nggw/U4VoZvYFGjBjByZMnWblyJV5eXvz0008EBwdz7NgxqlatyoEDBxg4cCDh4eF06dKFzZs3Exoa+kzHqXnz5kRFRVG9enV+/PFHmjdvjouLS5Zl58+fJzg4mKlTp7JkyRJiYmIYMWIEI0aMUHus9e3bl/379/Ppp5/i7+/PxYsXuX37Nt7e3vz444+88sorREVF4ejomG2vtKNHjxIbG0vDhg3VssOHD3PixAlWrFiBmVnm3HFGMvHhw4cEBQXRrFkz/vzzT6Kjoxk0aBAjRoxg6dKlav0dO3bg6enJjh07OHfuHD169KBu3brq9RASEsLZs2dZv349jo6OTJgwgfbt23Py5EksLS0BSEhIYMaMGXz11Ve4urri6elJYmIicXFx6vFwcXHJ1XmIjY3Nsn7jxo3Zs2dPrrZhDJaWlowdO9bYYQgh8pm0bSHgRvwNwvaFofDf/3M1aPj4+Y//W1mvCCpJ7TtjBT5JSomSoCS17eJOklKJiUTVb5BPG0vvMXWmUeNcVa/+1yE0tra53vyGDRsMhndBelfFSZMmceXKFTw8PGjTpg2WlpaUL1+exo3T43BxccHc3BwHBwc8PDxy3Ider2fJkiU4ODjg5+dHq1atiIqKYuPGjZiZmVG9enVmzJjBjh071KTUo5OC+/j4MHXqVIYOHcqCBQuwsrLCyckJjUZjsO8rV64QERHBlStX1OFy48aNY/PmzURERDB9+nTmzZtHcHAw48ePB6BatWrs27ePzZs3P/FY9erVK9PSoCdPnqR8+fK4u7urxyUjpqzKwsPD6d27t/r+qlatyqeffkpgYCALFy7kypUrfP/992zdupU2bdoAUKlSJXV/GQkXd3f3HOfUunz5Mubm5moMgNpLydfXN8f3uWLFCpKSkvj222/VYXDz58+nU6dOzJgxgzJlygDpvZDmz5+Pubk5vr6+dOjQge3btzN48GA1GbV3716aN28OwPLly/H29mbt2rV0794dgNTUVBYsWIC/v7+6fxsbG5KTk594XT1Kr9czevRoAgICqFWrlsFzXl5eXL58OdfbEkIIIcSzi0+J553IdwwSUgAKCv/E/1Okk1IlibuNJKWEEEVPiU9KFSWtWrVi4cKFBmUZiY/u3bszd+5cKlWqRHBwMO3bt6dTp05Y5HEcv4+PjzqUDaBMmTKYm5sb9NYpU6YM0dH/fdlt27aN8PBwTp8+TVxcHGlpaSQlJZGQkIBtNkm3Y8eOodPpqFatmkF5cnIyrq6uAJw6dYquXbsaPN+sWbNcJaXmzJmjJooy5HWuqCNHjnD06FGWL1+ulimKgl6v5+LFixw7dgxzc3MCAwPztN3HJSYmotVqDXrNKVn1xsvCqVOn8Pf3VxNSAAEBAej1eqKiotSkVM2aNQ2SdJ6enhw7dkzdhoWFhZpkBHB1daV69eqcOnVKLbOysqJOnTpP9yYfMXz4cI4fP05kZGSm52xsbEhISHjmfQghhBAid87dO8eYnWO4FHcp03NmGjO8HbwLPyjxVKSnlBCiKCrxSSmNjQ3V/zr05IpAwsGDXB3y+hPreX+xGNtHhmLltO+8sLOzo0qVKlnv09ubqKgotm3bxtatWxk2bBgzZ85k165d6vCr3Hi8rkajybIsY4WDS5cu0bFjR9544w2mTZuGi4sLkZGRDBw4kJSUlGyTUvHx8Zibm3Po0KFMPZoe7w32NDw8PLI9VrkVHx/P66+/nmlFPIDy5ctz7ty5Z9p+htKlS5OQkEBKSoo6QV9Gsu706dPUq1fvmfeR0znMLZt8GG46YsQINmzYwO7duylXrlym5+/evYubm9sz7aMgpaWlsWbNGgBefvnlPCd9hRCmSdq2KKk2XdxE6L5QEtMSKWNbhk6VO7Hk+BL0ih4zjRmhzULxsMt9b2hTVJLad8acUjGJMUaORIiCV5LadnFX4s+cRqPJ9RA6u4AALDw8SLt1K+t5pTQaLMqUwS4gIFdzSuU3GxsbOnXqRKdOnRg+fDi+vr4cO3aM+vXrY2VlhU6ny/d9Hjp0CL1ez+zZs9XeVN9//71Bnaz2Xa9ePXQ6HdHR0bRo0SLLbdeoUYMDBw4YlP3+++/5GH3O6tevz8mTJ7NNbtWuXRu9Xs+uXbsy9coC1ATTk4573bp1gfThhRn369ati5+fH7Nnz6ZHjx6Z5pW6f/8+zs7O1KhRg6VLl/Lw4UO1t9TevXvVoZa5UaNGDdLS0jhw4IA6fO/OnTtERUXh5+eX42tze10pisKbb77JTz/9xM6dO6lYsWKW9Y4fP54vSbiCotfrOXnyJABdunQxbjBCiHwjbVuUNKm6VGYfms3yU+m9wZt6NmXG8zNwsXahR/UeXH1wFW8H7yKfkIKS1b7L2Kb3kI9OiEZRFJn8WRRrJaltF3clPimVFxpzc8pMeodro0aDRmOYmPr3Q7/MpHcKLCGVnJzMzcdW/bOwsKB06dIsXboUnU5HkyZNsLW15bvvvsPGxoYKFSoA6cPydu/eTc+ePdFqtZQuXTpfYqpSpQqpqal89tlndOrUib1796pLc2bw8fEhPj6e7du34+/vj62tLdWqVaN379707duX2bNnU69ePWJiYti+fTt16tShQ4cOjBw5koCAAGbNmkXnzp3ZsmVLrobuQXrS5vFj5eDgYDDM7UkmTJhA06ZNGTFiBIMGDcLOzo6TJ0+ydetW5s+fj4+PD/369WPAgAHqROeXL18mOjqaV199lQoVKqDRaNiwYQPt27fHxsYmy15gbm5u1K9fn8jISDUppdFoiIiIoE2bNrRo0YJ3330XX19f4uPj+fnnn/n111/ZtWsXvXv3JjQ0lH79+hEWFkZMTAxvvvkmffr0UYfuPUnVqlXp3LkzgwcPZvHixTg4ODBx4kTKli1L586dc3ytj48PW7ZsISoqCldXV5ycnLLsmTd8+HBWrFjBunXrcHBwUM+Nk5OTwQTwe/bs4cMPP8xV3MZgbm5O+/bt1fvCRFlZwfz5/90X4glMrm3LNSwK0K2Htxi3axyHYw4DMLj2YIbXHY65Wfq172Hn8WzJKBO7fk2ufRegjJ5SiWmJxKfG42Dl8IRXCFF0laS2XewpxUxsbKwCKLGxsZmeS0xMVE6ePKkkJiY+2z62bFHOBLZUTlb3VW9nAlsqsVu2PNN2c9KvXz8FyHSrXr26oiiK8tNPPylNmjRRHB0dFTs7O6Vp06bKtm3b1Nfv379fqVOnjqLVapWM0x4REaE4OTmpdUJDQxV/f/9M++3cubNBWWBgoDJq1Cj18SeffKJ4enoqNjY2SlBQkPLtt98qgHLv3j21ztChQxVXV1cFUEJDQxVFUZSUlBTlgw8+UHx8fBRLS0vF09NT6dq1q3L06FH1dV9//bVSrlw5xcbGRunUqZMya9Ysg5izktVxApTw8HBFURTl3r17CqDs2LFDfU1WZYqiKH/88Yfy4osvKvb29oqdnZ1Sp04dZdq0aerziYmJypgxYxRPT0/FyspKqVKlirJkyRL1+SlTpigeHh6KRqNR+vXrl23MCxYsUJo2bZqpPCoqSunbt6/i5eWlWFlZKRUqVFB69eql/PXXX2qdo0ePKq1atVKsra0VFxcXZfDgwcqDBw/U57M6h6NGjVICAwPVx3fv3lX69OmjODk5qefxzJkz6vOPXysZoqOj1eOT1fHLkN05iYiIUOvs27dPcXZ2VhISErI9TvnVhoUQQoiS6MD1A8rzK59Xai2tpTRb3kz57fJvxg5J5LNmK5optZbWUs7dO2fsUIQQJVxOuZlHaRQllzMqFxFxcXE4OTkRGxuLo6OjwXNJSUlcvHiRihUrYm1t/Uz7UXQ6Eg4eIi0mBgs3N2wbNjDKkD1RPCQmJlK9enVWrVpFs2bNjB2OUfTo0QN/f38mTZqUbZ38bMNCCCFESaEoChEnIpj31zz0ip7qpaozp+UcvB1lEvPipuu6rpy7f44vXvyCZl4l8/+UQgjTkFNu5lEyfO8paczNsWvS2NhhiGLCxsaGb7/9ltu3bxs7FKNISUmhdu3ajBkzxtih5EhRFO7evQukr3wpczWYKJ0O9uxJv9+iBcgPBuIJTK5tyzUs8tGDlAe8F/kev139DYCXKr/Ee03fw8Yibwvu5JqJXb8m174LmJuNG+fun5MV+ESxV9LadnEmSSkhTETLli2NHYLRWFlZ8d577xk7jCfKmD8NYNKkSepk9sLEJCVBq1bp9+PjIQ9zyYmSyeTatlzDIp+cuXeGt3a+xeW4y1iaWTKx8US6V+tesH+8mdj1a3Ltu4C527oDsgKfKP5KWtsuziQpJYQQeSDDBoUonqRti+Jmw4UNTN43mSRdEp52nnzS8hNqla5l7LCMoiS174yk1K2Ht4wciRAFryS17eJMklJCCJFLVlZWTJw40dhhCCHymbRtUZyk6lL5+M+PWRm1EoDmXs35qMVHlLIuZeTIjKOktW/pKSVKipLWtoszSUoJIYQQQghRDNx8eJOxO8dy9PZRAF6v8zpv+L+BuZnMS1ZSuNm6AcicUkKIIkOSUkIIIYQQQhRxv9/4nfG7xnMv+R4OVg581OIjni/3vLHDEoWsjG0ZAG4lyPA9IUTRIEkpIYTIpbS0NDZs2ABAx44dsbCQj1AhigNp26Io0yt6vj72NfMPz0ev6KnhUoNPWn5COYdyxg7NJBTH9q3odCQcPERaTAwWbm7YNmyA5t9VDt1s0ntK3Um8g06vk15yotgqjm27pJIzJ4QQuaTX6zl8+DAA7du3N24wQoh8I21bFFVxKXG8G/kuO6/uBKBrla5MajIJawuZ/DdDcWvfcb/+yq3p4aTdvKmWWXh4UGbSOzi2bYurjStmGjN0io67SXfV4XxCFDfFrW2XZJKUEkKIXDI3N+fFF19U7wsTZWkJH3/8330hnsDk2rZcwyIXou5GMWbnGK4+uIqVmRWTmkzilWqvGDssk7t+Ta59P4O4X3/l2qjRoCgG5Wm3bqWXz5ubnpiydiUmMYboxGhJSoliqzi17ZJOoyiPfaoVcXFxcTg5OREbG4ujo6PBc0lJSVy8eJGKFSvK8pEF6PTp04SEhHD48GF8fX05fPhwlmWF6euvv2bVqlX8+uuv+brdpUuXMnr0aO7fv5+v281vPXv2pFGjRowdO9bYoTwTacNCCCEErDu3jg9//5BkXTJl7csyu+VsarrWNHZYogApOh3nXmhj0EPKgEaDRZkyVNm+jV6benPizgk+bfUprcq3KtxAhRDiXznlZh5lVogxiaek0WhyvIWFhRVaLC1btswyhqFDh6p1QkNDsbOzIyoqiu3bt2db9qw0Gg1r1659Yr2kpCTef/99QkNDDcrj4uJ499138fX1xdraGg8PD9q0acOaNWswhVzt0qVLcXZ2fmK9yMhIAgICcHV1xcbGBl9fX+bMmWNQ57333mPatGnExsYWULRCCCGEKGgpuhSm7J/Ce3vfI1mXzHNln2NVx1WSkCoBHu7bl31CCkBRSLt5k4SDh3C3dQcgJjGmkKITQoinJ8P3ioAbN26o91etWsUHH3xAVFSUWmZvb6/eVxQFnU5XoBO9DR48mClTphiU2draqvfPnz9Phw4dqFChQo5lhWX16tU4OjoSEBCglt2/f5/nnnuO2NhYpk6dSqNGjbCwsGDXrl2MHz+e1q1b5yohVFBSU1NzXdfOzo4RI0ZQp04d7OzsiIyM5PXXX8fOzo4hQ4YAUKtWLSpXrsx3333H8OHDCyrsYk9RFB48eACAg4MDGo3GyBGJLOl08Ndf6ffr1wfp0i2ewOTatlzDIgs34m/w1s63OH7nOBo0vFH3DV6v8zpmGhP7jdnErl+Ta985UBSFtOgYUi5eIOXiRZIvXCTl4kVSLlwg9fr1XG0jLSYG99LpSSlZgU8UZ0WpbYucmdi3WNESfy+Jf6LuEX8vqUD34+Hhod6cnJzQaDTq49OnT+Pg4MCmTZto0KABWq2WyMhIQkJC6NKli8F2Ro8eTcuWLdXHer2e8PBwKlasiI2NDf7+/qxevfqJ8dja2hrE5OHhoXbH02g0HDp0iClTpqi9uLIqA7h69Sqvvvoqzs7OuLi40LlzZy5dumSwryVLllCzZk20Wi2enp6MGDECAB8fHwC6du2KRqNRH2dl5cqVdOrUyaBs0qRJXLp0iQMHDtCvXz/8/PyoVq0agwcP5vDhw2qi7969e/Tt25dSpUpha2tLu3btOHv2bKZ9bNmyhRo1amBvb09wcLBBIlGv1zNlyhTKlSuHVqulbt26bN68WX3+0qVLaDQaVq1aRWBgINbW1ixfvpz+/fsTGxv7xB5x9erVo1evXtSsWRMfHx9ee+01goKC2LNnj0G9Tp06sXLlymyPk3iy1NRUPvnkEz755JM8JQ5FIUtKgsaN029JBfv5LIoHk2vbcg2Lx+y7to9XN7zK8TvHcdI6saDNAt7wf8P0ElJgctdvfrRvRafj4YE/iN3wCw8P/IGi0z1TTPrkZJKizhC3eQu3Fy7k2vjxXOzWnTMNG3EuMJArIf25OXkK95Yt42FkZK4TUgAWbm7/9ZRKkJ5Sovgyue9u8dRKfE8pRVFIS9Hn+XWn999gz6ozKApoNNCiRzV8m3nmaRsWVmb5ltGdOHEis2bNolKlSpQqVSpXrwkPD+e7775j0aJFVK1ald27d/Paa6/h5uZGYGDgU8Vx48YN2rRpQ3BwMOPGjcPe3p6hQ4dmKktNTSUoKIhmzZqxZ88eLCwsmDp1KsHBwRw9ehQrKysWLlzIW2+9xUcffUS7du2IjY1l7969APz555+4u7sTERFBcHBwjpPbRUZG0qdPH/WxXq9n5cqV9O7dGy8vr0z1H+15FhISwtmzZ1m/fj2Ojo5MmDCB9u3bc/LkSSz/nbwzISGBWbNmsWzZMszMzHjttdcYN24cy5cvB2DevHnMnj2bxYsXU69ePZYsWcJLL73EiRMnqFq1qrqviRMnMnv2bOrVq4eZmRlz58416BX3aFw5+fvvv9m3bx9Tp041KG/cuDHTpk0jOTkZrVabq22JzMzMTPAPACHEM5O2LUyRXtHzxdEvWHB4AQoKfq5+fNLyE8ralzV2aEXKs7TvJ612lx1FUdDdvk3yxYukXLhIysUL6v3Ua9cyTVauMjfHqlw5rCpWxKpSJbSVKmJVsSKWFSpwqVt30m7dyvq1/84pZduwAW4XrgEQnRD91O9biKJAvruLhxKflEpL0fPFqF3PtA1Fgd0rz7B75Zk8vW7IvEAstfnTpXnKlCnq6gO5kZyczPTp09m2bRvNmjUDoFKlSkRGRrJ48eIck1ILFizgq6++MihbvHgxvXv3xsPDAwsLC+zt7fHw8ADSkymPl3333Xfo9Xq++uorNTEXERGBs7MzO3fupG3btkydOpWxY8cyatQodT+NGjUCwM0tfSURZ2dndZtZuX//PrGxsQbJp9u3b3Pv3j18fX1zPEYZyai9e/fSvHlzAJYvX463tzdr166le/fuQHqWftGiRVSuXBmAESNGGAxvnDVrFhMmTKBnz54AzJgxgx07djB37lw+//xztd7o0aN5+eWX1ceP9orLjXLlyhETE0NaWhphYWEMGjTI4HkvLy9SUlK4efOmUYZRFgdWVlZ88MEHxg5DCJHPpG0LUxSbHMukyEns/mc3AN2qdWNi44lozeWHpbx4lvadm9Xu7Fu2JPXy5UeSTxfT71+8iP7foUVZMXN0RFuxopp8sqrog7ZSJay8vdFYWWX5mjKT3knf7+P+/b90mUnvoDE3p4xtGQCiEyUpJYov+e4uPkp8Uqq4aNiwYZ7qnzt3joSEhEyJrJSUFOrVq5fja3v37s27775rUFamTJk87f/IkSOcO3cOBwcHg/KkpCTOnz9PdHQ0169f54UXXsjTdh+XmJgIYLBSW24nMT916hQWFhY0adJELXN1daV69eqcOnVKLbO1tVUTUgCenp5ER6f/JyAuLo7r168bzGcFEBAQwJEjRwzK8noOH7dnzx7i4+P5/fffmThxIlWqVKFXr17q8zY2NkB6zy4hhBBCmK5Td04xZucYrsVfQ2uu5b2m79GlShdjh1WiKDodt6aHZ90r6d+ya2PeAr0++15PZmZYliuXnnCqWAmrihXVnk/mrq55HjHh2LYtzJubuedWmTIGPbfcbNN/vJWeUkKIoqDEJ6UsrMwYMi9vQ9Xi7yfzv7DfDb5/NBroFdYUe+fc/3plYZV/3Q3t7OwMHpuZmWVKvjw61jY+Ph6AX375hbJlDbuAP2lol5OTE1WqVHmWcImPj6dBgwbqELdHubm55VtXTNd/v/Dv3btnsH1nZ2dOnz6dL/vIGMaXQaPRPNXqfY+fw7yqWLEiALVr1+bWrVuEhYUZJKXu3r0L/NfLTAghhBCm56ezPzH196mk6FMoa1+Wua3m4uuSc+9ukf8SDh7KebU7SJ/UHTCztzdIOFlVTO/5ZFWhAmb5PGWCY9u2OLzwAhde6kzK+fOUHj6c0sPeQPPIVBYZc0rFJseSrEuW3nVCCJNW4pNSGo0mz0PoSpWxpeVrvuxcfhpFDxozaNnbl1JlbJ/84kLi5ubG8ePHDcoOHz6sJlD8/PzQarVcuXLlqeePehb169dn1apVuLu7q5OkP87Hx4ft27fTqlWrLJ+3tLRE94SJJq2srPDz8+PkyZO0/ffXIzMzM3r27MmyZcsIDQ3NNK9UfHw81tbW1KhRg7S0NA4cOKAO37tz5w5RUVH4+fnl6n06Ojri5eXF3r17DY7z3r17ady48RNjf9L7y45eryc5Odmg7Pjx45QrV47SpUs/1TYFpKWlsWXLFgCCgoIKdJVLIUThkbYtjOnmw5tcibuCh50HS44v4cezPwLwfLnnmf7cdJy0TkaOsGh72vadFpO7ScLLfPA+pXr1KtSVvzTm5tjUqknK+fNoLC0NElIAjlaOaM21JOuSiU6IxtvBu9BiE6KwyHd38SFn7in5BXhR3s+F2OhEnNxtsC9l/eQXFaLWrVszc+ZMvv32W5o1a8Z3333H8ePH1aF5Dg4OjBs3jjFjxqDX63nuuefUicQdHR3p169ftttOSEjg5mO/HGm12lxPsA7pQwBnzpxJ586d1ZXpLl++zJo1axg/fjzlypUjLCyMoUOH4u7uTrt27Xjw4AF79+7lzTffBP5LWgUEBOS4/6CgICIjIxk9erRaNm3aNHbu3EmTJk2YNm0aDRs2xNLSkj179hAeHs6ff/5J1apV6dy5M4MHD2bx4sU4ODgwceJEypYtS+fOnXP9Xt9++21CQ0OpXLkydevWJSIigsOHD2fZS+xRPj4+xMfHs337dvz9/bG1tcXWNnPi8/PPP6d8+fLqHFm7d+9m1qxZjBw50qDenj171MSceDp6vZ4///wTIE9zuAkhTJu0bWEsa86uYfL+yeiV/xbd0aBhRL0RDKo9yDRX1ytinrZ9W+SyZ7m2chWjLEVvWb48AClXrmR6TqPR4G7rztUHV4lJiJGklCiW5Lu7+JCk1DOwL2VtcsmoDEFBQbz//vuMHz+epKQkBgwYQN++fTl27Jha58MPP8TNzY3w8HAuXLiAs7Mz9evXZ9KkSTlu+8svv+TLL7/MtL/NmzfnOj5bW1t2797NhAkTePnll3nw4AFly5blhRdeUHtO9evXj6SkJObMmcO4ceMoXbo03bp1U7cxe/Zs3nrrLb788kvKli3LpUuXstzXwIEDadiwIbGxsTg5pf/a6OLiwu+//85HH33E1KlTuXz5MqVKlaJ27drMnDlTrRcREcGoUaPo2LEjKSkpPP/882zcuDHTkL2cjBw5ktjYWMaOHUt0dDR+fn6sX7/eYOW9rDRv3pyhQ4fSo0cP7ty5Q2hoKGFhYZnq6fV63nnnHS5evIiFhQWVK1dmxowZvP7662qdpKQk1q5dm6dzJDIzNzenZcuW6n1hoiwtITT0v/tCPIHJtW25hkuEmw9vZkpIAYS3CKdDpQ5GiiofmNj1+7Tt27ZhAyw8PLIfwvfIanfGYFU+fdGalCuXs3zezcaNqw+uyrxSotgyue9u8dQ0ytNMfmPC4uLicHJyIjY2NtOwsKSkJC5evEjFihUNJr4WxV/37t2pX78+77zzjrFDMYqFCxfy008/8euvvxo7lGcibVgIIURx8ceNPxj468BM5UuCltDIo5ERIhKPu/3118TMnJX5iX97RpWdN1edXLywJR47xqXur2Lh5kbVPbszPT9+13g2XdrEuIbj6Fcz+xEQQghRUHLKzTxK+gSLEmHmzJnY29sbOwyjsbS05LPPPjN2GEIIIYT4162EW5nKzDRmMtTKRCh6PQ/+/TFP89gPYRZlyhg1IQVg9e/wvbSYGPRZrKycsQJfTELu5sYSQghjkeF7okTw8fFR56IqiQYNGmTsEIoFRVHUCeS1Wq1R5pAQuaDXw6lT6fdr1IB8Ws1TFF8m17blGi72Iq9FErYvzKDMTGNGaLNQPOw8jBNUfjGx6/dp2/f91atJOnIUMzs7Kv78M6lXr5IWE4OFmxu2DRtkmly8sJk7OWHu5IQuNpaUK1ew9jVcoTFjBT4ZvieKK5P77hZPTZJSQgiRS6mpqXz00UcATJo0CSsrKyNHJLKUmAi1aqXfj48HOzvjxiNMnsm1bbmGi7XIa5GM+m0UKfoUXij/AuMajuPGwxt4O3gX/YQUmNz1+zTtO+3ePWJmfwJA6TdHYOXliZWXZ4HG+TQsK1RAd/QoKZczJ6XK2JYBIDpRklKieDK5727x1CQpJYQQQgghRCF4PCE1M3AmlmaWlHMoZ+zQxCNiPvkEXWws2mrVcHntNWOHky2r8uVJOno0y8nOM4bvSU8pIYSpk6SUEELkkqWlJe+//z4AZjKcRohiQ9q2KAzZJaREwcpr+048fJj7P6wGwCP0AzQWpvvnklWF9BX4Uq9cyfRcxvC9mIQYFEWRoU2i2JHv7uKjQM9eeHg4jRo1wsHBAXd3d7p06UJUVNQTX/fDDz/g6+uLtbU1tWvXZuPGjQUZphBC5IpGo8Hc3Bxzc3P5z50QxYi0bVHQMiWknpeEVGHJS/tWdDpuTJkCgFOXLtg2aFAYIT41qwrpk52nXM6clHKzSe8plaRLIi4lrlDjEqIwyHd38VGgSaldu3YxfPhwfv/9d7Zu3Upqaipt27bl4cOH2b5m37599OrVi4EDB/L333/TpUsXunTpwvHjxwsyVCGEECKTG7GJ7Dt/mxuxicYORQhRRGWZkDKXhJQpuve/lSSfPIWZoyPub48zdjhPlLECX0oWPaWsLaxx0joBsgKfEMK0FWh/1M2bNxs8Xrp0Ke7u7hw6dIjnn38+y9fMmzeP4OBg3n77bQA+/PBDtm7dyvz581m0aFFBhiuEEDnS6XRs374dgBdeeAFzI6+8IwrWqj+v8M6aY+gVMNNA+Mu16dGovLHDEgVA2rYoKHuv7ZWElJHltn2n3b5NzLx5ALiNHoWFq2uhxfi0LP8dvpd28yb6xETMbGwMnnezcSM2OZbohGiqlKpijBCFKDDy3V18FOrgy9jYWABcXFyyrbN//37atGljUBYUFMT+/fuzrJ+cnExcXJzBTQghCoJOp2Pfvn3s27cPnU5n7HBEAboRm6gmpAD0Ckxac1x6TBVT0rZFQdh7bS8jfxtJij6F1t6tJSFlJLlt39EzZ6F/8ADrmjUp1aNHIUb49MydnTFzcAAg5erVTM/LCnyiOJPv7uKj0JJSer2e0aNHExAQQK2MZWKzcPPmTcqUKWNQVqZMGW7evJll/fDwcJycnNSbt7d3vsZdnC1duhRnZ2djh5En+RXz2rVrqVKlCubm5owePTrbssLUp08fpk+fnu/bDQkJoUuXLvm+3fyUkpKCj48PBw8eNHYoOTI3N6d58+Y0b95cfo0xZZaWMG5c+s3y6f4AvHj7oZqQyqBTFC7dTsiHAIWpMbm2nQ/XsDCuxxNSswJnlZyElIldv7lp3wkHDxK7bh1oNOmTm5vC50AuaDQadQhfVpOdywp8ojgzue9u8dQKLSk1fPhwjh8/zsqVK/N1u++88w6xsbHq7WoWvxIUBL1ex9UTRzm1dxdXTxxFry/Y7GxISAgajSbTLTg4OFev9/HxYe7cuQZlPXr04MyZMwUQraHCTn5ldZw0Go3Btff666/TrVs3rl69yocffpht2bPYuXMnGo2G+/fvP7HukSNH2LhxIyNHjjQoP3fuHP3796dcuXJotVoqVqxIr169TCZ5k9uE18KFC6lTpw6Ojo44OjrSrFkzNm3apD5vZWXFuHHjmDBhQgFG++zMzc1p27Ytbdu2lS8/U2ZlBTNnpt+srJ5qExVL25HVlJmxiSnPFpswSSbXtvPhGhbGU6ITUmBy1++T2reSmsrNyemTmzt3745NnTqFHeIzyViBL6vJzjNW4JOklCiOTO67Wzy1QlnjdMSIEWzYsIHdu3dTrly5HOt6eHhw69Ytg7Jbt27h4eGRZX2tVotWq823WHPj7IF9/Lb0C+Lv3lbL7F1K0zpkCFWbNC+w/QYHBxMREWFQ9izv3cbGBpvHxp4XFxEREZkSdhmJsfj4eKKjowkKCsLLyyvbssL02Wef0b17d+zt7dWygwcP8sILL1CrVi0WL16Mr68vDx48YN26dYwdO5Zdu3YVepwZdDpdnla5KFeuHB999BFVq1ZFURS++eYbOnfuzN9//03NmjUB6N27N2PHjuXEiRNqmRDG4ulkg7+3E4evxhqUD1/xN++0S2TgcxVlpRchRCaPJqRaebcqeQmpIujud8tJPnsWc2dn3MaMNnY4eWZZIfvJzt1tJCklhDB9BdpTSlEURowYwU8//cRvv/1GxYoVn/iaZs2aqROWZdi6dSvNmjUrqDDz5OyBfaz/ZLpBQgog/u5t1n8ynbMH9hXYvrVaLR4eHga3UqVKAenHOiwsjPLly6PVavHy8lJ73bRs2ZLLly8zZswYtdcQZO7BFBYWRt26dVmyZAnly5fH3t6eYcOGodPp+Pjjj/Hw8MDd3Z1p06YZxPXJJ59Qu3Zt7Ozs8Pb2ZtiwYcTHxwPpvYX69+9PbGysuu+wsDAgfT6wcePGUbZsWezs7GjSpAk7d+402PbSpUspX748tra2dO3alTt37uTqWDk7O2c6VtbW1uzcuROHf8fet27dGo1Gk20ZQGRkJC1atMDGxgZvb29GjhxpsHpkcnIyEyZMwNvbG61WS5UqVfj666+5dOkSrVq1AqBUqVJoNBpCQkKyjFWn07F69Wo6deqklimKQkhICFWrVmXPnj106NCBypUrU7duXUJDQ1m3bp1a99ixY7Ru3RobGxtcXV0ZMmSIevwfNWvWLDw9PXF1dWX48OGkpqaqz927d4++fftSqlQpbG1tadeuHWfPnjU4D87Ozqxfvx4/Pz+0Wi0DBgzgm2++Yd26deq5ffz8ZejUqRPt27enatWqVKtWjWnTpmFvb8/vv/+u1ilVqhQBAQH53psyPymKgk6nQ6fToSjKk18gjEOvh0uX0m96/VNvJuMUj2lTle1vBfKSvxc6vcLUX04xfMVfxCen5Uu4wvhMrm3n0zUsCte+a/sMElKzA2eXzISUiV2/ObXv1Fu3uP3ZZwC4jX0Li3//X12UWJXP6Cl1OdNz0lNKFGcm990tnlqB9pQaPnw4K1asYN26dTg4OKjzQjk5Oak9dPr27UvZsmUJDw8HYNSoUQQGBjJ79mw6dOjAypUrOXjwIF988UWBxKgoCmnJybmqq9fr+C1icY51flu6mPK1/TEze3IXQgutNt9+af/xxx+ZM2cOK1eupGbNmty8eZMjR44AsGbNGvz9/RkyZAiDBw/OcTvnz59n06ZNbN68mfPnz9OtWzcuXLhAtWrV2LVrF/v27WPAgAG0adOGJk2aAGBmZsann35KxYoVuXDhAsOGDWP8+PEsWLCA5s2bM3fuXD744AOioqIA1N5AI0aM4OTJk6xcuRIvLy9++ukngoODOXbsGFWrVuXAgQMMHDiQ8PBwunTpwubNmwkNDX2m49S8eXOioqKoXr06P/74I82bN8fFxSXLsvPnzxMcHMzUqVNZsmQJMTExjBgxghEjRqg91vr27cv+/fv59NNP8ff35+LFi9y+fRtvb29+/PFHXnnlFaKionB0dMy2V9rRo0eJjY2lYcOGatnhw4c5ceIEK1aswMwsc+44I5n48OFDgoKCaNasGX/++SfR0dEMGjSIESNGsHTpUrX+jh078PT0ZMeOHZw7d44ePXpQt25d9XoICQnh7NmzrF+/HkdHRyZMmED79u05efIklv/OB5GQkMCMGTP46quvcHV1xdPTk8TEROLi4tTjkdMiBhl0Oh0//PADDx8+zJRsbty4MXv27HniNowlNTVVnfdr0qRJWJnAsASRhcREyPgRJD4e7OzyvAlFUbh4Oz0BHVTLg8ru9szrWZeGPqX4cMNJNh67yembD1j0WgOqlXHIz+iFEZhc286Ha1gUrn3X9vHmb2/mOSGl6HQkHDxEWkwMFm5u2DZsUGTmM8qWiV2/ObXv6Bkz0CckYOPvj/MrrxgrxGdipfaUyj4pFZMQU6gxCVEYTO67Wzy1Ak1KLVy4EEjvqfOoiIgItdfIlStXDP7obt68OStWrOC9995j0qRJVK1albVr1+Y4OfqzSEtO5tN+3fJte/F37zC/f+5W7Bj5zWosra1zve0NGzYYDO+C9AY4adIkrly5goeHB23atMHS0pLy5cvTuHFjID1RYG5ujoODQ7bDIDPo9XqWLFmCg4MDfn5+tGrViqioKDZu3IiZmRnVq1dnxowZ7NixQ01KPTopuI+PD1OnTmXo0KEsWLAAKysrnJyc0Gg0Bvu+cuUKERERXLlyRR0uN27cODZv3kxERATTp09n3rx5BAcHM378eACqVavGvn372Lx58xOPVa9evTKNLT558iTly5fH3d1dPS4ZMWVVFh4eTu/evdX3V7VqVT799FMCAwNZuHAhV65c4fvvv2fr1q3qipGVKlVS95eRoHF3d89xTq3Lly9jbm6uxgCovZR8fX1zfJ8rVqwgKSmJb7/9Frt//9M3f/58OnXqxIwZM9RFA0qVKsX8+fMxNzfH19eXDh06sH37dgYPHqwmo/bu3Uvz5unDT5cvX463tzdr166le/fuQPoH/4IFC/D391f3b2NjQ3Jy8hOvK0jv0dWsWTOSkpKwt7fnp59+ws/Pz6COl5cXl7P4pU+IwnY/IZW4pPSeUBVc0tuWRqOhbzMfapV1Yvjyv7gQ85DO8/fy0Su16Vy3rDHDFUIY0dMmpOJ+/ZVb08NJe2QxHwsPD8pMegfHtm0LMmQBPNy/n7iNm8DMLH1y8yx+BCwKMiY6T7txE31yMmaPTO2RkZS6nXSbNH0aFmaFMnOLEELkSYF+MuWmG11Ww326d++u/iEs/tOqVSs10ZchI/HRvXt35s6dS6VKlQgODqZ9+/Z06tQJC4u8nWIfHx91KBukr3xobm5ukDgsU6YM0dH/dQPetm0b4eHhnD59mri4ONLS0khKSiIhIQFbW9ss93Ps2DF0Oh3VqlUzKE9OTsbV1RWAU6dO0bVrV4PnmzVrlquk1Jw5c9REUYa8zhV15MgRjh49yvLly9UyRVHQ6/VcvHiRY8eOYW5uTmBgYJ62+7jExES0j/Way20X1FOnTuHv768mpAACAgLQ6/VERUWpSamaNWsaJOk8PT05duyYug0LCws1yQjg6upK9erVOXXqlFpmZWVFnWeY/LN69eocPnyY2NhYVq9eTb9+/di1a5dBYsrGxoaEBNNd3czS0pKJEyeq90XxdfFOei8pD0drbKwME9z1y5diw5vPMWrlYSLP3WbUysP8dfke73bww8qiaP5RU9JJ2xZP61kSUtdGjf5vnPC/0m7dSi+fN1cSU/kkq/atT0nh5pT0RW1K9eqF9WM/khUl5q6umNnZoX/4kNR//kFbubL6nIu1C+Yac3SKjrtJd9UklRDFgXx3Fx8lPl1uodUy8pvVuar7z6njrPko7In1Xp4YRrkaT+7ZZZHHScrt7OyoUqVKls95e3sTFRXFtm3b2Lp1K8OGDWPmzJns2rUrT4308boajSbLMv2/cwRcunSJjh078sYbbzBt2jRcXFyIjIxk4MCBpKSkZJuUio+Px9zcnEOHDmXq0fR4b7Cn4eHhke2xyq34+Hhef/31TCviAZQvX55z58490/YzlC5dmoSEBFJSUtRupxnJutOnT1OvXr1n3kdO5zC3bGxsnmm4qZWVlXpOGjRowJ9//sm8efNYvPi/IbF3797Fzc3tqfdR0DQaDdZ56N0oiq5L/w7d8ymd9WeYq72WbwY0Zu62M3z22zm+2X+Zo9di+fz/6uPlXDwXkCjOpG2Lp/FoQqqld8s8Ddm7NT08U0Iq/UkFNBpuTQ/H4YUXiv5QPhOQVfu+G7GUlIsXMS9dGrdRmf+fV5RoNBosK5Qn+eQpUi5fMUhKmZuZ42rjSnRCNNEJ0ZKUEsWKfHcXHyX+J12NRoOltXWubhX862HvUjrH7Tm4lqaCf71cbS+/V26ysbGhU6dOfPrpp+zcuZP9+/ervWGsrKzQ6XT5uj+AQ4cOodfrmT17Nk2bNqVatWpcv37doE5W+65Xrx46nY7o6GiqVKlicMsYClajRg0OHDhg8LpHJ8YuaPXr1+fkyZOZ4qtSpQpWVlbUrl0bvV6f7Sp4GQmmJx33unXrAunDCx8t8/PzY/bs2Vkmj+7fvw+kH6MjR44YTL6+d+9edahlbtSoUYO0tDSDY33nzh2ioqIyDa973LNcV3q9nuTH5nM7fvx4viThhHhW/8/efYdHUW4PHP/OtvTeSQPpIB2UasNesKFg7xX773qv5V6vtyh67Yq9YQdUVARFbEiVKl16CoT0nmySbfP7Y5LQEtiQ7M7u5nyeZ59Mdmd3DjAvs3v2vOdtSkp1i2+9F4rRoPB/Z/bmveuHExls4o/cCs5/ZQlLdpS0+hwhRGBYlreMe369pzkh9fzJz7vd1Ny6es1BU/YOo6o4Cgqwrl7TQdGKA9nz8ihpnHmQ9OBfMEZG6hxR+zU3O2+hr1RSqFY1L83OhRC+qtMnpdrCYDBy2vW3HnGfU6+71a0m58eioaGBgoKCg24lJdqHn+nTp/Puu++yadMmdu/ezccff0xISAiZmdpFqmvXrixatIi8vLzm53SEHj16YLfbeeWVV9i9ezcfffQRb7zxxkH7dO3alZqaGn7++WdKSkqwWq306tWLq666imuvvZbZs2eTlZXFypUrmTp1KvPmzQPgnnvuYf78+Tz77LPs2LGDadOmuTV1D7SkzaF/Vwcmbtzxt7/9jWXLlnHXXXexbt06duzYwTfffMNdd93V/Oe67rrruPHGG/n666/Jyspi4cKFzJo1C4DMzEwURWHu3LkUFxe3uCIeQEJCAkOHDmXJkiXN9ymKwvvvv8/27dsZN24c3333Hbt372bDhg088cQTXHjhhQBcddVVBAcHc91117Fp0yZ+/fVX7r77bq655prmqXtH07NnTy688EJuueUWlixZwvr167n66qtJTU1tPk5runbtyoYNG9i2bRslJSUHreh3oIcffphFixaRnZ3Nxo0befjhh1m4cCFXXXXVQfstXryYM314uoLT6WThwoUsXLjQI0le4TuySrVppF3jjt6g97Q+Scy7ZxzHp0ZSVmvjmvdWMO2XHbhcshKMv5CxLdqiKSHV4Gxoc0IKwFHsXtPpvHvvJe+BByj74APq1q3DZbMda8id2qHju2DqVNT6ekKHDydywgS9w+sQTX2lWlqBLyFEq0CXpJQINHLtDhySlGqjnieOZsIDjxxWMRURF8+EBx6h54mjPXbs+fPnk5KSctBt7NixgLYa29tvv82YMWMYOHAgP/30E99++21zf6Z///vfZGdn07179w6dHjVo0CCef/55nn76aY4//ng++eST5pUUm4wePZrbb7+dSZMmkZCQwP/+9z9Aa3h/7bXX8n//93/07t2biy66iFWrVpHReGEdOXIkb7/9Ni+99BKDBg1iwYIF/P3vf3crrhtuuOGwv6tXGpf8ddfAgQP57bffmhNDQ4YM4bHHHjuoN9Xrr7/OxIkTufPOO+nTpw+33HJLc/IrNTWVf/3rXzz00EMkJSU1J7NacvPNNx/Uuwq0lehWr15Njx49uOWWW+jbty8TJkxg8+bNvPjiiwCEhobyww8/UFZWxogRI5g4cSLjx49n2rRpbfqzvv/++wwbNozzzz+fUaNGoaoq33333VGnft5yyy307t2b4cOHk5CQwNKlS1vcr6ioiGuvvZbevXszfvx4Vq1axQ8//MAZZ5zRvM/y5cuprKxk4sSOW3igo8nFr/PIKW2avufeqlHpsaF8cftorjghHVWFZxds5+YPV1NpbTlRK3yLjG3hrvYmpABMbr4Pc1ZUUPXd9xROfYrsyVewbdhwsi6fRMETT1I5dx62vXtlGXQ3HDi+K3/9lZqffgajkaTH/tHhsxb00rQCnz0n97DHmqbsSVJKBBq5dgcORQ2wq1lVVRVRUVFUVlYSeUg5bn19PVlZWXTr1q3d809dLid5f26mpqKc8OgYUvv291iFlAh8dXV19O7dm5kzZzJq1Ci9w9HFpEmTGDRoEI888kir+3TkGD4WDoeDH374AYCzzjqrzQsJCC9paIAHHtC2n38e2ti/T1VVBv5rAdX1Dn647yR6J0cc/UkHmLV6D//4ehMNDhdpMSG8cfUwjk+NatNrCO/yubHdznNYeMayfcu455fGhFTaKTx/StsTUqD1lNo5/vTWp/ApCqbERFKmPkn9ho3UbdhA3bp1OMvKDtvVGBdHyKBBzbfg44/HGO5eMt1jfOz8bRrfLpuNntNeRc3LI/aGG0j62191jasjWVevJufqazCnpdHjpx8PeuztDW/z8h8vc2H3C/nv2P/qFKEQHc/nrt3iMEfKzRxI/uWOkcFgJL3/sa9EJsSBQkJC+PDDDzt0aqU/sdlsDBgwgPvvv1/vUI7IZDJx3nnn6R2GOJqgIHj11WN+elmtjep6BwCZcS03Oj+Sy4en079LJHd8vJbcMiuXvL6M/1zYn0kjMo45JuFZPje223kOi47XUQkpAMVoJOmRh8m7594WHtQqd5IefYTw0aMJH61V4Kuqij0vj7p166lbr93q//wTZ2kpNb/8Qs0vv2jPNxgI6tlzf6Jq8CAs3bqhGNybHKE6nVrPq+JiTAkJhA4f1vZm6z52/jaN7+Jpr1KSl4cpMZH4KVP0DqtDmRtnGdj37UO12VAa+5rC/kqp4jr3po0K4S987totjpkkpYTwEaeccoreIejGYrG4PTVTCE/Lbpy61yUqmGDzsVXA9u8Sxbd3j+X/Zq3jpz+L+NuXG1mdXc5/Ljr+mF9TCKGPjkxINTFGR7d4vykpiaRHHibykP6KiqJgSUvDkpZG1PnahzBXQwP1W7Y0J6nq1q/HsS+fhm3baNi2jYrGHpeGiAhCBg5sTlIFDxiAKSbmsGNXLVhA4ZNTD6rgMiUntxiPv7Hl5lL61lsAJD38kP7VZB3MlJCAEhKCWleHLS+PoG7dmh9LCJWeUkII3yZJKSGEEIFFVaGp6jA+vrnywF1ZJY1Nzt3sJ9WaqBAzb10znDcW7eLZH7bx+Zq9bN5XxetXDyXTjQbqohNr5zksOo4nElKqqlL8/AsARE26nKhzzzumyiRDUBChQ4YQesCqtfbCIuo2rKd+/XqtqmrTJlzV1dQuXUrtAX0fLV27NiepQgYNwpaTS94DD2jn3gEchYXk3XsfvPSi+4kpHzt/VVWl4IknUG02wkaPIuLss3WNxxMURcGSkUHDtm3YcnIOSkrJ6ntCCF8nSSkhhHCTzWbjqaeeAuChhx7CckB5vPAhViskatMVqKmBsLYlgNra5PxIDAaFO0/pweC0aO7+7A+25Fdx/itLeOHywZzez70VMoXn+dzYbuc5LDrGoQmp5055rt0JKYCaXxdSt24dSnAwCVOmYG76t+4A5qREzGecQWTjQiKq3U7Djh1aJVXj1D9bdnbzrfKbb478gqoKikLhk1OJGD/evYSZj52/ZfPn88yXs8Fo4Mm//i1gmpsfqikpZc89uNl5U6VUla2Kekc9wSbv9+QUwhN87totjlmnTEoFWG93IToNXxi7LpdL7xCEh2WVNCaljqGfVGtG94hn3j3juPOTNazNreDmD1dz5yndeeCMXpiMshCuL5CxLQ60fN/ywxJSFmP7P/CoLhfFjSvoxl5zdYcmpFqimM0E9+tHcL9+xFxxBQCO8nLqN25sTlJZ165Fras7QtAqjoICrKvXEHbiCR6Nt6O5rFYKnn4aFyqhgwcTdFy3oz/JTzWtwGc7ZAW+CHMEIaYQ6hx1FFuLSY9M1yM8ITxCrt2BoVMlpZqWt7darYSEhOgcjRCiraxWbVpV01j2NrPZzAONKwrpFYPwvKaeUl07eIpdclQwM24dxdTv/+T9pdm8tnAX6/ZU8PIVQ4gPl9XV9CRjWxxo+b7l3P3L3R2ekAKomjePhu3bMUREEHfzzR3ymm1liokh/KSTCD/pJAAqv/2WfQ8efSU6R7H/NcoueeNNlPwCbu7Xj24ffBDQ49ucmQlo/bMOpCgKCSEJ5FbnUmgtlKSUCBhy7Q4cnSopZTQaiY6OpqhIm1MdGhoasCW8QgQSVVWxWq0UFRURHR2Nsa0rAXUQRVGOuJyp8H+qqpLd2FOqWwdM3zuUxWTgnxf0Z2hGDH/7cgPLdpVy3suLee2qoQzLjO3w4wn3yNgWTQ5MSJ2cdnKHJqRUm43il14GIO7mmzFGRXXI67aXKdG9qcSmhAQPR9KxGnbvpvT991EUhR6PPUZEcrLeIXmUJaMpKZVz2GOJoYnkVudKXykRUOTaHTg6VVIKILnxgtSUmBJC+I/o6OjmMSyEJ5TW2qhpcKAokB7bcdP3DnXBoC70TYngto/WsKu4lklv/s6j5/Xl+tFd5csSIXRyaELq+VOe77CEFED5F19g37sXY3w8sddc3WGv216hw4dhSk7GUVh4WKPzJkpICMEDjvdyZMdOVVUK/vMfsNsJO/kkwseP1zskj2uavmfP24dqt6McUDmSGKpNEy2u879qNyFE4Ot0SSlFUUhJSSExMRG73a53OEIIN5nNZt0qpJo4nU5+//13AEaOHKl7PKLjZTf2k+oSFUKw2bP/vj0SI/jmrrE89OUG5m7I51/fbmFNTjlPXzqQsKBOd3nWlYxt4emElMtqpeT11wGIv+N2DKGeS3q3lWI0kvTIw9oqe4rSYmJKrasj97rrSXvlZcx+8OVQ9fffY13+O4rFQsJDD7Fs2TIgsMe3KTERJSgItaEB+759WBqn88H+pFShtVCv8ITocHLtDhyd9l2v0WiUE1cI0SZOp5Mff/wRgBEjRsj/IQGoucl5vHc+MIYHmXjliiEMy4zhiXl/MndDPlsLqnnj6qH0SIzwSgxCxnZn93v+7x5NSAGUffwJzuISzGlpxFx2WYe+dkeIPPNMeOlFCp+ciqOgoPl+U3Iy0ZdeQvnHn1C/cSNZEy8j7eWXCB06VMdoj8xZU0vhU08DEHfrrRhTU/nxgw+AwB7fisGAJSOdhh07seXmtpiUKrZKpZQIHHLtDhydNiklhBBtZTAYGDx4cPO28FEmE1x33f7tNvBUk/MjURSFG8Z0Y2BaFHd+spadRTVMmLaUpy8dyAWDungtjs7M58Z2O85h0Ta/5//OXT/fRYOzgZPSTvJIQspZWUnpO+8AkHDP3Sg+umx55JlnEjF+PNbVa3AUF2NKSCB0+DAUo5Goiy9m75S7aNi2jZzrrif50UeJmTyp5RfS+fwtmTYNR1ER5owM4m65GZevjW8PMmdmakmpnFwYt//+hFCtH5j0lBKBxOeu3eKYyTsdIYRwk8lk4qKLLtI7DHE0QUEwffoxPdWTTc6PZlhmLPPuGcc9n/3Bsl2l3P3ZH6zNLefhc/piMcmbLU/yubHdjnNYuKegtoD52fN5Ze0r2Fw2Tko7iRdOeaHDE1IApe+8i6uqiqCePYk877wOf/2OpBiNhJ14wmH3W9LS6PrZp+x79FGqv59PweOPU79lC8l/f/TwJJuO52/9tu2UffQRAMl/fxRDUBAG8K3x7UGtNTtPCtWa2UtSSgQSn7t2i2Mm73KFEEKIRnpUSh0oPjyIj246kSmndgfg/aXZXPH27xRU1usSjxCBaPaO2Zz5xZk8t/o5bC4bPWN6eiwhZS8qak6SJNx/H4ofTy8xhIaS+vzzJDzwACgKFbNmkXPd9dh9ZPEgrbn5v8HpJOKM0wk/6SS9Q/I6S0Zjs/Oc3IPuTwjZXymlttLMXggh9CJJKSGEEIFFVaG2Vru14c23qqrNjc676lAp1cRoUHjwrD68c+1wIoJNrMkp57yXF/Pt+jyW7Sohv7JOt9iElxzjOSyOrqC2gMeXPY7K/r/XXRW7KKsv88jxSl5/HbW+npDBgwk/9VSPHMObFEUh/tZbSH/zDQwREdT98QfZEy+jbsOG/TvpdP5WzZlD3eo1KCEhJD38sNeO60uaVuCz5RxcKdXUU8rmslFlq/J6XEIIcSSSlBJCCDfZbDaeeuopnnrqKWw2m97hiNZYrRAert2sVrefVlzTQK3NiUGB9NgQDwbontP7JTH37rH0S4mktNbG3Z+t48q3VzDmqV+YuSr36C8g3OZzY/sYz2FxdLsrdh+UkAJwqS72VO/p8GPZcnOp+PwLABIeuB9FUTr8GHoJP+kkun0+C0v37jiKisi5+hoqZn+lPajD+eusqqLwf88AEH/HHZi77O/H53Pj24OaKqVseXmoDsf++40WooOiAVmBTwSOzjS2A50kpYQQog3q6+upr5epVIGoqZ9Ul+gQgky+McUmMy6M1646eJUrlwoPz94oFVMdTMZ257Bw78LD7jMoBtIj0jv8WMWvTAOHg7CxYwk74fA+Tf7O0rUrXWfOIHz8eFSbjfxHHqHgiSdR7Y6jP7mDFb/0Ms7SUizduhF3/XWHPd5ZxrcpORnFbAa7HfsBqyiCrMAnAlNnGduBThqdCyGEm8xmM3fffXfztggsTVP39GhyfiT7Wkg+uVRYuK2IK07IbOEZoq1kbHcOqwpWMWPrDAAUFFRUDIqBf476J8lhyR16rPpt26iaOxfQekkFKmN4OGmvvEzJa69TMm0a5R99RMOWLaQajZicTq/EULd5M+WffQZA8mP/OKzxemca34rRiDkjA9uuXdhycrCkpTU/lhCawPby7dLsXASMzjS2A50kpYQQwk2KohAXF6d3GMJD9G5y3ppu8WEYFC0RdaB/frMZo8HA5cM7vsKjs5GxHfiqbFU8suQRVFQu7nExdw6+kz3Ve0iPSO/whBRA8QsvgqoScc7ZhPTv3+Gv70sUg4GEu6YQ3LcP+x78K9Y1a8jK7Ep63l6CPXxs1eWi4N//BpeLyHPPIWzUqMPj62Tj29KYlLLn5sKYMc33ywp8ItB0trEdyGT6nhBCCMH+pFRmXKjOkRwsJSqEqZcMwNjYj8agQJ/kCGxOlb9+sYGHvtxAvd07FQlC+CNVVfnv8v9SUFtAekQ6D53wEMlhyYxIHuGRhJR17VpqFi4Eo5GEe+7p8Nf3VRHjx9N11kzM6ek4zGayMzKp/H6+R49Z8eWX1K/fgCE0lMS//c2jx/IXzX2lsg9udn7gCnxCCOFLpFJKCCHc5HQ6WbNmDQDDhg3D6MdLe4vDZTX2lPK16XsAk0ZkcFKvBLJLrHSNDyUpIpjXFu7kuR+3M2PVHjbtq+T1q4aRHutbCTV/IWM7sM3dPZfvs7/HqBh5atxThJo9N05UVaXo+ecBiL7kYoK6dfPYsXxRUI8edPvoQ/KGj6A2PJx9f/879bt3k/h/D6B08LhylJdT/Jz2dx1/992Yk5Ja3K+zjW9z0wp8uQcviNHUU0qSUiJQdLaxHcikUkoIIdzkdDr57rvv+O6773B6qVeG8A5VVclpmr7ng0kp0CqmRnWPIyUqBINB4a7TevLhjScQG2ZhU14V5728mF+2yqpKx0LGduDaW72XJ1Y8AcDtg25nYMJAjx6vdvFi6lavQbFYiJ8yxaPH8lXGiAjS8/YSV1oCQNl777Hn1ttwVlR06HGKn38BZ0UFQT17Env1Va3u19nGtyVD6zV4aFKqefpenSSlRGDobGM7kEmllBBCuMlgMNCvX7/mbeGjjEaYOHH/thuKqhuw2pwYFEiP8Z9qo3E9E5h791ju/GQt6/ZUcOP01dx9Wg/uO70XRkPgLD/vaT43to/hHBaHc7gcPLLkEWrttQxJHMLNA2726PFUl4uiF14EIOaqqzAnd/zUQL9gNKJMnEgiEHz1Nex7/HFqly4l67LLSZs2jeDevdp9iLr166n44gsAkv/5mLbiXCt8bnx7mKWrlpSy5+aiOp3NFWoJoTJ9TwSWzja2A5miqqp69N38R1VVFVFRUVRWVhIZGal3OEIIIfzAit2lTHrrdzJiQ1n011P1DqfNbA4XT8zbwgfLtR4iY3vE89LkwcSFB+kcmRD6eXP9m0xbN40wcxhfXPAFaRFpR39SO1R99x15D/wfhrAwuv/0I6aYGI8ez1/Ub9vG3il3Yd+7FyU0lC5TpxJ51pnH/Hqq00n2ZZdTv2ULURdeSJenn+rAaP2f6nCwdchQsNvp8cvPmLt0AaCkroRTZ52KgsLaa9ZiMkhtghDCs9zNzUhKUQghRKfnq03O3WUxGfjXhcfz0uTBhJiNLNlZwvmvLGFtbrneoQmhiw3FG3h9/esAPHriox5PSKl2O8UvvQxA7I03SELqAMG9e9P181mEjhqJarWSd++9FL34IqrLdUyvVz5jBvVbtmCIiCDxwb90cLT+TzGZsKSmAgdP4YsNjsWkmFBRKakr0Ss8IYQ4jCSlhBBCdHq+3OS8LS4cnMo3d43huIQw8ivrmfTmcj5Ylk2AFUULcURWu5WHFj+EU3VyTtdzOP+48z1+zIrZX2HLycEYG0vsddd7/Hj+xhQTQ8bbbxN7/fUAlL7xJnvvuBNndXWbXsdRUkLxiy8BkHDfvZji4zs61IDQ3Oz8gBX4DIqB+FDt76vYWqxLXEII0RJJSgkhhJvsdjvPPfcczz33HHa7Xe9wRGtqa0FRtFttrVtPyS5pbHIe599JKYBeSRHMuWss5w5Ixu5U+eeczdw7Yx21DQ69Q/NZPje2j+EcFvs9tfIp9lTvITksmb+P+juK4tn+aq76ekpefRWA+Ntvwxju//+PtEsr569iMpH00N/o8r+nUYKCqPntN7Ivu5yG3bvdfumiZ57FVV1NcL9+xEye7NZzfG58e0Frzc4TQ2QFPhE4OuPYDlSSlBJCCDepqkp1dTXV1dVSeRJgmqbv+XulVJPwIBOvXjmUf5zfD5NBYc76fVz06lJ2FtXoHZpPkrEdOH7M+ZGvdn6FgsKTY58k0uL5/qLln3yKo6gIU5cUot1MlHRmURMmkPnJJ5hSUrBlZ5N92eVU//LrUZ9nXb2aym++AUXRmpu7uQhAZxzflsympFTOQfcnhjYmpWQFPhEAOuPYDlTS4U4IIdxkMpm4/fbbm7dFYFBVlZxSbfpe1wBJSgEoisJNY7sxMC2KKZ+sZUdRDRdOW8L/Jg7ivIEpeofnU2RsB4bC2kIeX/Y4ADcefyMjkkd4/JjO6mpK33oLgIQpd2GwWDx+zEAQcnx/un3xOXn33od19Wr23nkn8ffcTfztt6O0sIqWardT8K9/AxA9cSIhgwa5fazOOL4tjdP37DkHV0rJCnwikHTGsR2opFJKCCHcZDAYSE5OJjk5WZaeDSCFVQ3U2Z0YDQppMSF6h9PhRnSNZe49Yxl5XCy1NidTPl3Lf+Zuwe48tibDgUjGtv9zqS4eXfooVbYq+sX1Y8rgKV45bul77+GsrMTSvTtRF07wyjEDhSkujoz33yPmyisBKHn5FfLuvQ9njVa5qjqd1K5YSeXceRQ8OZWGHTswRkWR8MD9bTpOZxzflozGnlJ79hzUUL65UkqSUiIAdMaxHagkpSiEEKJTy2rsJ5UWE4LZGJhvahIjgvn4phN5dsF23vhtF+8uyWL9ngpevWooSZHBeocnRLt9tOUjVuSvIMQUwlPjnsJsNHv8mI6SEso++BCAhHvvQZFv6ttMMZtJfuwfBPXtQ+G//0P1jz9iy84ievJkSt9+B0dBwUH7R5xztqxs6AZzly5gNKLW1+MoKsKcnAxIUkoI4ZsC8923EEJ4gNPpZN26daxbtw6n06l3OKKDNPWTCoQm50diMhp46Jw+vHnNMCKCTKzOKee8lxezfFep3qHpTsa2f9tatpWX1morsj044kG6RXXzynFL3nwL1WoleMAAIs44wyvHDFQxl11GxocfYEpIoGHHTgr/89/DElIAFTNnUbVgQZteuzOOb8VsxpyaCoDtgCl8TUkpWX1PBILOOLYDlSSlhBDCTU6nk6+//pqvv/5aLn4BJNCanB/NWf2TmXP3WPokR1BSY+Oqd37njd92deomoTK2/Ve9o56/LfobdpedU9NPZWLPiV45rm1vHuUzZgCQ+MD9Hl/hrzMIHTKEzJkzwXzkKrfCJ6eitmGcdtbx3TyF74Bm57L6nggknXVsByKpMxZCCDcZDAZ69uzZvC18lNEI5567f/soskuaKqVCPRmVT+kWH8ZXd47h0a83MnttHk99v5W1OeU8e/kgIoM9P+3J1/jc2G7jOdyZPb/meXZX7iY+JJ7HRz/uteRQybRpYLcTOmokYaNGeeWYfqMd5699zx440tLuqoqjoADr6jWEnXiCW6/pc+PbSyyZmdQuWYI99/BKqWp7NVa7lVBz57nuicDTWcd2IJKklBBCuMlkMnHVVVfpHYY4muBgmDfP7d2zS7SV9zI7SaVUkxCLkecuG8TwzFgen7OZBVsKmfDKEl67ahj9ukTqHZ5X+dzYbuM53Fkt2ruIz7Z+BsB/x/yX2OBYrxy3YedOKufMASDx/rY13e4U2nH+Oordm1bm7n7gg+PbS5pW4Dtw+l64JZxQUyhWh5XiumIyzZl6hSdEu3XWsR2IJKUohBCi03K51P3T9wK8p1RLFEXhyhMz+OKOUaRGh5BdauXi15byxZq9eocmxBGV1pXyj6X/AODqvlczJnWM145d/NJL4HIRccbphAwc6LXjdgamhIQO3a8zMzdP38s96H5pdi6E8DWSlBJCCNFpFVTV0+BwYTIopMWE6B2ObgamRTP37rGc3CuBBoeLv3y+nodnb6TeLj0ahO9RVZXHlj1GWX0ZPaJ7cN+w+7x27Lr166n+8ScwGEi4916vHbezCB0+DFNyMrQ2DVNRMCUnEzp8mHcD80OWDK0Kypabe1DPQElKCSF8jSSlhBDCTXa7nZdffpmXX34Z+5F6Xgh91dZCWJh2q6094q5NVVLpsaGYjJ37khgTZuH960dw/+m9UBT4bGUul72xnD1lVr1D8zifG9ttOIc7o1nbZrFo7yIsBgtPn/Q0QcYgrx276IUXAYi68EKCevTw2nH9SjvOX8VoJOmRhxt/OSQx1fh70iMPo7ShV5XPjW8vsaSlgsGAarUeNN0xIVSrMpOklPB3nXVsB6LO/Q5cCCHaQFVVysrKKCsr69QrlfkFq1W7HUVTP6nO1OT8SAwGhXtP78n0G04gOtTMxrxKzn9lCb9uC+wPLz45tt08hzub3RW7eWb1MwDcN+w+esX08tqxa5ctw/r77yhmMwl3TfHacf1SO87fyDPPJPWlFzElJR10vykpidSXXiTyzDPb9Ho+Ob69QLFYMHfpAtBis3NJSgl/11nHdiCSRudCCOEmk8nEjTfe2Lwt/F9TpVRmJ+wndSQn90pg7t1jmfLJWtbvreTG6au4+7Se3Du+J0aDd1Y38yYZ2/7B5rTxt8V/o8HZwOguo7mqr/ca3KqqStHzLwAQfcVkzKmpXjt2ZxR55plEjB+PdfUaHMXFmBISCB0+rE0VUk068/i2ZGRg37sXW04uocOHA5AYIkkpERg689gONPKvJ4QQbjIYDGQ0Ng4VgSGrpLHJeSdbec8daTGhzLp9FP+Zu4WPf8/l5Z938EduOS9NHkJsmEXv8DqUjG3/MO2PaWwt20p0UDT/HfNfDIr3Cv6rF/xI/aZNKKGhxN92m9eO25kpRiNhJ57Q7tfpzOPbnJkBy5Yd1Oy8qVKquM79FQyF8EWdeWwHGpm+J4QQotPKbkxKdZWkVIuCTEb+e9EAnr98EMFmA4t3lHD+y4v56c9Clu0qIb+yTu8QRSexIn8F0zdPB+Dx0Y8398XxBtXh0FbcA+Kuvw5TXJzXji1EezQ3O8/Jab5Ppu8JIXyNVEoJIYSbXC4Xf/75JwB9+/bFYJC8vj9zuVRyGpt4d5Ppe0d0ydA0+nWJ5I6P15JVUsvNH6wGwKDA1EsGMGmEf39TKWPbt1U2VPLIkkdQUbm056WMzxjv3eN/Mwfb7t0Yo6KIveEGrx5btF9nHt+WTO3/Zltuy0kpVVVRWlvpUAgf15nHdqCRfzkhhHCTw+Hg888/5/PPP8fhcOgdjmin/Kp6bA4XJoNCl+hgvcPxeX2SI3nrmoOXYXep8PDsjX5fMSVj23epqsq/lv+LImsRmZGZ/HXEX716fFdDA8XTpgEQd9ttGCMivHp80X6deXxbGqc22XNymxtBJ4RoVYZ2l52Khgq9QhOi3Trz2A40UiklhBBuUhSFrl27Nm8LH2UwwMkn799uRdPUvYzYUExG+Y7GHcU1DYfd51Jh+a5SLhmapkNEHcPnxrab53Bn8M2ub/gx50dMiomnxj1FqNm7K2VWzJiBIz8fU1ISMVde4dVj+y0fO399bnx7kTk9HRQFV20tzrIyTHFxmI1mYoNjKasvo8haRExwjN5hCnFMOvPYDjSSlBJCCDeZzWauv/56vcMQRxMSAgsXHnW3LOkn1Wbd4sMwKFoi6kB//3oTIWYj5wxI0SewdvK5se3mORzo9lTtYeqKqQDcOfhOjo8/3qvHd9bUUvLGmwDET7kTQ7BUVLrFx85fnxvfXmQICsKUkoxjXz62nNzmfmgJIQnNSanesb11jlKIY9OZx3ag8ejXF4sWLeKCCy6gS5cuKIrC119/fcT9Fy5ciKIoh90KCgo8GaYQQohOqLnJufSTcltKVAhTLxmAsfEbSYOi9eOy2pzc8clanpi3BbvTpXOUIhA4XA4eWvIQVoeVoYlDufH4G70eQ9kH03GWl2PJzCT6kku8fnwhOkJzs/MW+krJCnxCCF/g0Uqp2tpaBg0axI033sglbbiYb9u2jcjIyObfExMTPRGeEEKITiy7tLHJebx3pwP5u0kjMjipVwLZJVa6xocSHx7EMz9s461Fu3l7cRbr91Qy7cohJEZKVYk4dm9teIsNxRuIMEcwddxUjAajV4/vKC+n7L33AUi4714Uk0wuEP7JkpGB9fffW1yBr9BaqFdYQgjRzKNX2HPOOYdzzjmnzc9LTEwkOjq64wMSQoh2sNvtvPvuuwDcdNNNmM1mnSMSLaqthcYeA2RnQ1jLlVDZpVqlVKZUSrVZSlQIKVEhzb8/cm5fhmZE85fPN7Ayu4xzX17Cq1cO4cTj4nSM0n0+N7bdPIcD1bqidby5QZs29/eRf6dLeBevx1D65lu4amsJ6teXiLPO8vrx/ZqPnb8+N769rGkFPntObvN9B67AJ4S/6uxjO5Do332wBYMHDyYlJYUzzjiDpUuX6h2OEEIA2ipQBQUFFBQUNK9iI3xUSYl2a4XTpZLbXCnVuT7we8rZx6cw564x9E6KoKSmgSvfWcFbi3b5xVjxybF9lHM4UNXYanho8UO4VBfnHXce5x53rtdjsOfnU/7ppwAk3n8/ig806/Y7PnT++uT49iJLZtP0vcOTUsVWmb4n/FdnH9uBxKdqkVNSUnjjjTcYPnw4DQ0NvPPOO5xyyimsWLGCoUOHtvichoYGGhr2rwZUVVXlrXCFEJ2MyWTimmuuad4W/mtfRR02pwuL0UCX6JCjP0G45biEcL6aMppHv9rEV3/k8eR3W1mbU8H/LhtIZLDvfoMpY9t3TF05lbyaPLqEdeHREx/VJYbiV19FtdkIHTGCsLFjdYlBdJzOPr7NGVqllC0nB1VVURRFKqVEQOjsYzuQ+NS/Xu/evende/8KEKNHj2bXrl288MILfPTRRy0+Z+rUqfzrX//yVohCiE7MYDDQvXt3vcMQHSCnsUoqPTYEo0GWEe5IoRYTz18+iKGZMfzn2y3M31zAtsJqXr96KH2SI4/+AjqQse0b5mfPZ86uORgUA1PHTSXCEuH1GBp2Z1E5+ysAEh64X5YZDwCdfXxb0tMBcFVX46yowBQTI0kpERA6+9gOJD5fj3zCCSewc+fOVh9/+OGHqaysbL7t2bPHi9EJIYTwR1mN/aRk6p5nKIrCNSMzmXX7KFKjQ8gqqeWiV5cye+1evUMTPqqgtoB/L/83ADcPuJmhSS1XyHta8csvg8tF+KmnEjpkiC4xCNGRDCEhmJKSALA3NjtPCEkAoKy+DLvLrltsQggBfpCUWrduHSkpKa0+HhQURGRk5EE3IYTwBJfLxfbt29m+fTsulyx778+yS6TJuTcMTo/m27vHMq5nPPV2Fw/MWs+jX22kweHUO7SDyNjWl9Pl5JElj1Btq2ZA/ABuH3S7LnHUbdpM9fz5oCgk3HefLjGIjifjW1uBD/b3lYoJjsFkMKGiUlpXqmdoQhwzGduBw6NJqZqaGtatW8e6desAyMrKYt26deQ2/of48MMPc+211zbv/+KLL/LNN9+wc+dONm3axH333ccvv/zClClTPBmmEEK4xeFw8Omnn/Lpp5/icDj0Dke0Q1NSqqtUSnlcbJiF6TecwL3je6Io8MmKXC5/Yzl7y616h9ZMxra+PtjyAasKVhFiCmHquKmYDfr0Hyt+4QUAIi84n+DevXSJQXQ8Gd9g6drY7LxxBT6DYmiuliq0FuoWlxDtIWM7cHi0p9Tq1as59dRTm39/4IEHALjuuuuYPn06+fn5zQkqAJvNxv/93/+Rl5dHaGgoAwcO5KeffjroNYQQQi+KotClS5fmbeGjDAYYPnz/dguap+9JpZRXGA0K95/Ri8EZ0dw/cx3r91Zy/itLeGnyEE7ulaB3eL43tt04hwPFltItvPLHKwA8dMJDZEZm6hJH7YqV1C5dCiYTCXffrUsMAcPHzl+fG986MB9SKQXaCnz5tfmyAp/wWzK2A4eiBtj6iVVVVURFRVFZWSlT+YQQQhzG6VLp84/vsTtVlvztVNJiQvUOqVPZU2blzk/WsjGvEkWBe8f35J7TemKQhvOdTp2jjsu/vZzsqmzGZ4znhVNe0OWDhaqq5Ey+grr164m58gqSH3vM6zEI4UlVPywg7957CR40kG4zZwLwwMIH+DHnRx464SGu6nuVzhEKIQKRu7kZ/b++EEIIIbxoX0UddqeKxWSgS1SI3uF0OumxoXx++yiuPDEDVYUXf9rBDdNXUV5r0zs04WXPrnqW7KpsEkMSeXzU47p9013zyy/UrV+PEhxM3O369LMSwpMsmVqllD3n4EopQCqlhBC6k6SUEEKITiWrsZ9URmyoVOfoJNhs5MmLB/DsZYMIMhn4bXsx57+yhPV7KvQOTXjJwj0LmbV9FgD/GfsfooOjdYlDdTopfvFFAGKvvRZzYqIucQjhSZb0dACcFRU4KyuB/SvwFVmLdItLCCFAklJCCOE2u93Ou+++y7vvvovdLkso+yyrFbp21W7Ww5tpZzf2k+oq/aR0N3FYGl9PGUPXuFDyKuq47I3lfLIiB293FvC5sX2Uc9jfldSV8NhSbYrctf2uZXSX0brFUjV3Lg07dmKIjCTupht1iyOg+Nj563PjWweGsDCMCfHA/r5STZVSRXWSlBL+ScZ24PBoo3MhhAgkqqqyZ8+e5m3ho1QVcnL2bx+iqVKqW/xRekm5nJCzDGoKITwJMkeDwdjR0XZ6fVMimXP3WP4yaz0LthTy6FebWJNTzhMXDSDE4p2/b58b20c5h/2Zqqr8fenfKW8op1dML+4deq/3Y3A6sa5egyM/n8JnnwUg7uabMUZFeT2WgORj56/PjW+dWDIzqSsuwZaTS8iAAfuTUlIpJfyUjO3AIUkpIYRwk8lkYvLkyc3bwj/llGrf3HeNP0Kl1JY5MP9vULVv/32RXeDsp6HfBA9H2PlEBpt585phvLVoN0/P38rstXls2VfF61cPo9uR/p06iIxt7/l066cszVtKkDGIp8c9jcVo8erxqxYsoPDJqTgKCvbfaTBg7pLi1TiE98j41lgyMqlbvQZbrpYwlJ5Swt/J2A4c8q8nhBBuMhgM9OnTR+8wRDtlN1VKtTZ9b8scmHUtcMi3blX52v2XfyiJKQ9QFIXbTu7OwLRo7v7sD7YWVDPhlSU8e/kgzuqf7NFjy9j2jt/3/c6zq7TKpPuH3U+PmB5ePX7VggXk3Xvf4dU7Lhf7HvwrisVC5JlnejUm4XkyvjWWjIObnTclpWrsNVjtVkLNshKt8C8ytgOH9JQSQgjRaTicLnLLtEqpzJYqcFxOrULq0IQU7L9v/kPafsIjRnWPY949YxnRNYbqBge3fbSGqd//icPp0js00Q6zts3ilh9vwaE6AAg2Bnv1+KrTSeGTU484nazwyamoThnbIjA1rcBna5xaGWYOI8ysXQcLrYW6xSWEEJKUEkIIN7lcLrKzs8nOzsblkg/I/iivog6HSyXIZCAlsoUPxTnLDp6ydxgVqvK0/YTHJEUG8+ktI7l5bDcA3vxtN1e9s4Ki6nqPHE/GtmcV1Bbw39//e9B9//793xTUFrTyjI5nXb3m4Cl7h1JVHAUFWFev8VpMwjtkfGvMjZVSTY3OQabwCf8mYztwSFJKCCHc5HA4mD59OtOnT8fhcOgdjjgGTU3OM+NCMRiUw3eocfPbYnf3E8fMbDTw9/P78dpVQwmzGFmRVcb5Ly9hVXZZhx9LxrZn5VTloB5SfehSXeyp3uO1GBzF7n3odnc/4T9kfGssmZkAOMvKcFZXA5AYoiWlpFJK+CMZ24FDekoJIYSbFEUhISGheVv4KEWBfv32bx+gucl5a/2kwpPcO4a7+4l2O3dACr2TI7j9ozXsKKph8lu/8/A5fbhpbLcOG4c+N7aPcA77o9K60sPuMygG0iPSvRaDqfHft6P2E0fgY+evz41vnRjDwzHGxeEsLcWWm0tI//77K6XqJBkr/I+M7cAhSSkhhHCT2WxmypQpeochjiY0FDZvbvGhpkqpVlfeyxytrbJXlU/LfaWAyFRtP+E13RPC+XrKGB6evZE56/fx33l/sja3nKcvHUhEsLndr+9zY/sI57A/WpCzAAAFBRUVg2Lgn6P+SXKYZxvYHyh0+DBMycmtT+FTFExJSYQOH+a1mAKWj52/Pje+dWTJyKCutBR7Y1IqIVT7QF9kLdI5MiHaTsZ24JDpe0IIITqN7NLGpFRrlVIGI5z9NK0mpAD6TtD2E14VFmTipcmD+feF/TEbFb7bWMCFry5le2E1+ZV1LNtVQn5lnd5hikMU1Bbw655fAXjrjLd476z3+OHSH7ik5yVejUMxGkl44IFWHtS+YU965GEUo4xtEbiaVuBranbeVCklSSkhhJ6kUkoIIUSnkd1cKXWEpa/7TYBBV8D6zw6+3xIOthpY9Q70ORe6neTBSEVLFEXh2lFdGZAaxZ2frGV3cS3nvbwYh1PrWGRQYOolA5g0IkPvUEWjL7Z/gUt1MTxpOCO7jNQ1luYqKaMRDlhlz5SURNIjDxN55pk6RSaEd5ibV+DTmp1LUkoI4QskKSWEEG6y2+189pmWqLjiiiswm9s/bUh4gNUKI0Zo26tWaVNJALvTxZ5yrZKmW2vT95rUV2o/h90IXcdoPaTSR8Lsm2HL1zDjKrjxB0jq56E/hDiSIRkxzL17LHd8vIaV2eXN97tUeGT2Jk7qlUBKVIjbr+dzY7uVc9jf2J12vtzxJQCT+kzSNRZXbS1l778PQMp//4O5SyqO4mJMCQmEDh8mFVIdycfOX58b3zqyZGjNzptW4JPV94Q/k7EdOCQpJYQQblJVld27dzdvCx+lqrBly/7tRnnldThdKsFmA0kRwa0/3+WC3OXa9pCrIe2AHjMXv6mtvJe7HD6ZCDf/pPWgEl4XFx7EPeN7cfW7Kw6636mqZJdY25SU8rmx3co57G9+3vMzJXUlxIfEMz59vK6xlM+YibO8HHNGBlEXXIBikrfAHuNj56/PjW8dNa3AZ8ttnL7XuPpeUV0RLtWFQZHOLsJ/yNgOHHJFFkIIN5lMJi655JLmbeFfshr7SWXGhmEwHGGVluKtUFcO5jBIGXjwY+ZgmPwpvHcWlGyHTy6DG76D4CgPRi5a0z0xDIOiVUgdqKi6vk2vI2PbM2ZunQnApT0vxWzU7xtsV10dpe+9B0D8bbdJQqqTkfG9nyVDW/HSWVyCq7aW+NB4ABwuBxUNFcQGx+oZnhBtImM7cEg6XAgh3GQwGBg4cCADBw7EYJD/Pv2NW/2kAHKWaj/TR0BLH6RDY+GqL7QpfYWbYOY14LB1cLTCHSlRIUy9ZADGQ5aCvm/mOl75eQeuQ7NVrZCx3fF2lO9gdeFqjIqRib0m6hpLxaxZOEtLMaelETXhAl1jEd4n43s/Y1QUxuhoAGx79mA2mJsTUdJXSvgbGduBQ/71hBBCdAr7k1JH6SeVs0z7mTmm9X1iMuGqz7Xm51m/wZy7fGKaSmc0aUQGSx46lc9uGcnCv5zCFSeko6rw3I/buemDVVRYJWGoh5nbtCqpU9JPITksWbc4XPX1lLzzDgBxt92KIj1HRCfX3Ow8W5vClxSaBEhSSgihH0lKCSGEm1wuF3l5eeTl5eFyufQOR7RRdqkVgG5xR0hKqer+flKZo4/8gimD4PIPQDHChpnwy386KFLRVilRIYzqHkfX+DCmXjKQ/00cSJDJwK/bijn/lSVs3Ft5xOfL2O5YtfZavt31LQCT+0zWNZaKz7/AWVyCqUsK0RdeqGssQh8yvg/WWrNzSUoJfyNjO3BIUkoIIdzkcDh4++23efvtt3E4HHqHI9oou9SNSqnyLKjOB4MZUoe1vl+THqfDBS9p24ufg9XvdUCkor0uH57O7DtHkxEbyt7yOi59YxkzVua22ghVxnbHmrtrLlaHla6RXTkx+UTd4nA1NFD69tsAxN96K4rFolssQj8yvg92aLPzhNAEQJJSwv/I2A4ckpQSQgg3KYpCdHQ00dHRKMoRGmULfSkKZGZqt8Z/J7vTxd7yOgC6HqlSqmnqXuowMLu5etvQa+CUh7Xtef8H2+Yfa+SiA/XvEsW3d4/l9L5J2BwuHpq9kb9+sYF6u/OwfX1ubLdwDvsLVVWZsW0GAJN6T9L177Ny9mwcRUWYkpKIamyGK7zAx85fnxvfOrM0Tt+z50illPBvMrYDh7SpF0IIN5nNZu677z69wxBHExoK2dkH3bWnzIrTpRJiNpIUGdT6c3PcnLp3qJP/BpV74I+P4Ysb4Lq5kOZGpZXwqKgQM29dM4w3F+3mmR+28vmavWzaV8UbVw8l84DkpM+N7RbOYX+xtmgtOyt2EmwMZkKPCbrFodpslLylVUnF3XILBqmS8h4fO399bnzrzJLR2FOqafpeiCSlhH+SsR04pFJKCCFEwGuaupcZF3rkb9OaVt5ra1JKUeD8F7XpfHYrfHo5lO0+tmBFhzIYFO44pTsf33wi8eEW/syv4vxXlrBgc4HeoQWkmVu1BufnHXcekZZI3eKo+OprHPn5mBISiL5M39X/hPAl5saklKOwEFddXXOlVHFdsZ5hCSE6MUlKCSGECHjZJY1Nzo/UT6oqX+sppRgg/YS2H8Rohss+0BqgW0vg40uhtuQYIxYdbXT3eObePY5hmTFU1zu49aM1PD1/Kw6nNEftKCV1JfyY+yMAl/e+XLc4VLud0jffBCDulpsxBB2hOlKITsYYHY0hUksY23L3yPQ9IYTuJCklhBBucjgczJgxgxkzZkhDRV9WVwcjRmi3Oq2PlFtNznMb+0klD4DgqGM7dlA4XPk5RGdolVKfTQab9dheS3S45KhgZtw6khvHdAPg9YW7uObdleSX1/rW2G7hHPYHX27/EofLwcCEgfSL66dbHJVz5mDftw9jfDzRl12mWxydlo+dv3LtPpiiKAc1O29KSpXVl2F32vUMTYg2kbEdOKSnlBBCuMnlcrF169bmbeGjXC5YvXr/NpBV0piUigtt/XlNTc4z2jh171ARSXDVl/DuGbB3Fcy+BS7/EAzG9r2u6BBmo4HHLujH0Mxo/vrFBpbvLmXCK4sYUvYHXaJDfGNst3AO+zqHy8Hn2z8HYHLvybrFoToclLzRWCV1440YQtxcsEB0HB87f+XafThLRgb1Gzdiz80lNuh0zAYzdped4rpiuoR30Ts8IdwiYztwSFJKCCHcZDQaueCCC5q3hf9orpRyZ+W9tvaTaklCL7hiBnx4IWydC9//Dc59xidWohKa8wd2oU9yBLd/vJYdBZV8X9mFGwZ0w2CQIvJj8dve3yi0FhITFMOZXc/ULY7KuXOx79mDMTaWmMmTdItD+A65dh+uaQU+W04uiqKQGJpIXk0eRdYiSUoJvyFjO3DIOy8hhHCT0Whk2LBhDBs2TC5+fsTmcJFXrk0habWnlLUMirZo2x2RlALIHAWXvAUosOptWPZyx7yu6DA9EiP4ZsoYLhichjGpBx/uMHLvrA3UNMg0gLZqanB+cc+LCTLq08NJdTgoff0NAOJuvAFD6BEqI0WnIdfuw5kPWYEvISQBkL5Swr/I2A4ckpQSQggR0PaUW3GpEGYxkhDRyofl3N+1n/G9ISy+4w7e/yI460lt+8fHYOMXHffaokOEBZl45YohPH5BP0wGhXkb8rlw2hJ2FFbrHZrfyK7MZnn+chQULuulXw+nqu+/x5aTgzE6mpgrrtAtDiF8nSWjsadUTg6ArMAnhNCVJKWEEMJNqqpSVFREUVERqqrqHY5wU3ZjP6nMuDCU1qbP5SzVfmaO6vgARt0JI6do21/dDlmLOv4Yot3O7RnG65d2JykiiF3FtVz46lLmrN+nd1h+Ydb2WQCMSxtHWkSaLjGoTicljVVSsddfjyHsCFN1Raci1+7DNU3fc+Tn46qvb05KFVoL9QxLiDaRsR04JCklhBBustvtvPbaa7z22mvY7bJCjb9obnIef4SpPLnLtZ+ZYzwTxJn/hX4XgcsOM66Gwi2eOY44Jk1je+m3n/HVHScyunscVpuTez77g8fnbMbmkAaqralz1PH1zq8BmNRbvx5O1T/8gG33bgxRUcRcfZVucQjfI9fuwxljYzGEhwNg37t3f6WUVSqlhP+QsR04JCklhBBtEBoaSqj0KfF98fHaDTeanDfUwL512nZH9ZM6lMEAF78JGaOgoRI+uQyqpArHlzSN7fjwID666USmnNodgOnLspn81nLyK728tP0B57Av+z7re6pt1aSGpzI2dawuMaguFyWvvw5A7HXXYmz8sC105GPnr1y7D6YoCpYD+ko1JaWkp5TwNzK2A4OsvieEEG6yWCz89a9/1TsMcTRhYVC8/9ve7BIrAF1ba3K+dyWoTojKgCgPTj0yB8PkT+G9s6Bku5aYuuF7CI703DGFW1oa2w+e1Ych6THcP2sda3MrOP/lJbx8xRDG9PDCB+1DzmFfpaoqM7bOALQqKYOiz3ed1Qt+pGHHTgwREcRefbUuMYgD+Nj5K9fulpkzM6jfsgVbTi6J/foDkpQS/kXGduCQSikhhBABralSqtWV93KWaT89VSV1oNBYuOoLCE+Cwk0w6xpw2Dx/XHFMTu+XxLy7x9EvJZLSWhvXvLuCV3/dicslvSsANpZs5M+yP7EYLFzU4yJdYjioSuqaazBGSpJXCHfsb3aeLZVSQghdSVJKCCFEwGpwONlXoU27yoxrpbw7p6mflBeSUgAxmXDlLDCHwe6FMOdukAadPisjLpTZd47m8uFpuFR45odt3PLhaiqt0r9i5raZAJzd7WxigmN0iaHml19o2LYNQ1gYsddeo0sMQvijpul79txcEkISALA6rNTYavQMSwjRCUlSSggh3ORwOPjyyy/58ssvcTgceocjWlNXB6ecAqecwp595bhUCLMYSQgPOnxfRwPsXaVteyspBdBlMFz+IShG2DADfvmv944tDnO0sR1sNvK/iYN4+tIBWEwGft5axPnTFrMpr9IzAR1wDlPn5V5WbiqvL2d+1nxAvwbnqqpS/NprAMRcfTXG6Ghd4hCH8LHzV67dLbN0baqUyiXUHEqEOQKAojqplhL+QcZ24JCklBBCuMnlcrFx40Y2btyIyyWrcfkslwt++w1+++2AlffCUBTl8H3z1oKzAcISIK6Hd+PseTpc8JK2vfhZWP2+d48vmrk7tieNyGD2HaNJjw1hT1kdl7y+jFmr9ngioOZzGB/9v+brnV9jc9noG9uXAfEDdImh5teFNGz5EyU0lNjrr9MlBtECHzt/5drdsuZKqfx8XDYbCaFatZRM4RP+QsZ24JBG50II4Saj0cjZZ5/dvC18X3aZ9i19q03Ocw/oJ9VS0srThl4DlXvht6dg3gMQkQK9z/Z+HJ1cW8b28alRzL1rHPfPWscvW4v465cbWJNTzr8u7E+wuXP8v+B0OZun7k3uM7nlhK+HqapKSWOVVOxVV2KK0Wf6oPB9cu1umTE+HiU0FNVqxb43j8TQRHZX7qbY6jtN6oU4EhnbgUOSUkII4Saj0cjIkSP1DkO0QXa5lpTqFneUJucZXpy6d6hTHtISU+s+hi9ugOvnQuow/eLphNo6tqNCzbxz7XBe/20Xzy3YxszVe9i0r5LXrxqG2aSQVVJLt/gwUqJCPBi1fpbuW0peTR4RlgjO6XaOLjHULl5M/aZNKCEhxF5/vS4xCP8g1+6WKYqCJSODhq1bseXmNDc7L7QW6hyZEO6RsR04JCklhBAiYGWXWYFWmpy7nJC7Qtv2Zj+pQykKXPAiVOfDrp/hk8vh5h8h9jj9YhJHZTAoTDm1B4PSorlnxh9s3lfFmS/8RoPThaqCQYGplwxg0ogMvUPtcE1VUhf1uIgQk/cTb6qqUvzqqwDETJ6MKS7O6zEIEQiaklL2nBwSB2hJKamUEkJ4m/SUEkIIN6mqSkVFBRUVFaiyWppfaJq+162l6XsFG8FWDUFRkNTfy5EdwmiGyz+A5IFgLYGPJ0Jtqb4xdSLtGdtje8Yz756x9O8SSb3D1byQokuFR2ZvIr9S/0bPHWlv9V4W710MwOW9Ltclhtply6hfvwElKIi4G2/QJQbhP+Ta3TpLppY0t+XsX4FPekoJfyFjO3BIUkoIIdxkt9t58cUXefHFF7HbZTl4X1dvNLOvsgFopadU89S9E8HgA70IgiLgqs8hKgPKdsFnk8EeWAkNX9XesZ0SFcLfzu5z2P1OVSW7xNoRIfqMz7d/jorKqJRRdI3q6vXjq6pKyauNK+5NnoQpIcHrMQj/Itfu1lkyG1fgy80lKTQJkNX3hP+QsR04JCklhBBtYDabMZvNeochjiY0lD3JXVGBiCATcWGWw/fJWar91HPq3qEikuHqLyA4GvauhC9v1qYZCo9r79jumRSOoYV+39X1x/hGOTRUu/mQBmcDX+34CoBJfSbpEoN1xQrq1q5FsViIvfEmXWIQbvCx81eu3S0zN67AZ8vNldX3hF+SsR0YFDXAat2qqqqIioqisrKSyMhIvcMRQgihkwWbC7j1ozUMSI3i27vHHvygqsIz3cFaCjf9COkn6BNka3KWw4cXgrMBTrgVzpoKucuhphDCk7REmi9Ud4mDzFyVyyOzN+E84K2VyaDw9/P6ct3orrqsUteRvt31LY8seYTksGS+v+R7TAbvtybNueZarKtWEXPVVST/4+9eP74QgcReWMjOk08Bo5HopfM585tzMCkm1lyzBoMitQtCiPZxNzcjjc6FEEIEpOzSWqCVJucl27WElCkEUgZ7NzB3ZI6CS96Ez2+AlW/B+hnQULX/8cgucPbT0G+CfjGKw0wakcFJvRLILrGSEBHECz9uZ97GfB7/dgtrcit46pIBhAX571uvGdtmAHBZr8t0SUjVrlyJddUqFLOZuFtu9vrxhQg0poQElOBg1Pp6osoaUFBwqA7K6suID4nXOzwhRCchKXAhhBABKauxl0+LTc6bpu6lDQdTC1P7fEH/i2HwFdr2gQkpgKp8mHUtbJnj/bjEEaVEhTCqexw9EsOZduUQ/nF+P0wGhW/X7+PCV5eys6hG7xCPyZbSLWwo3oDJYOKSnpfoEkPJ668DEDXxUszJybrEIEQgUQwGLOnpALj25hEXoq1kKSvwCSG8SZJSQgjhJofDwZw5c5gzZw4Oh0PvcERr6uvhvPPI/kVrZN41rqWk1HLtZ+YYLwbWRi4n7F7YyoON08PmPyQ9pzqAp8a2oijcNLYbn906ksSIIHYW1XDhtCXM3bDvyE9sPIc57zxt2wfM2jYLgDMyztClgsK6di3W5b+D2Uz8Lbd4/fiiDXzs/JVr95FZujY2O8/JJTE0EZC+UsI/yNgOHJKUEkIIN7lcLtauXcvatWtxuVx6hyNa43TCd9+R49IqoA5beU9VD2hyPsrLwbVBzjKoOlLyQoWqvP2rCIpj5umxPaJrLPPuGcfI42KptTm569M/+Pe3W7A7WzlW4znMd99p2zqrslUxb/c8QL8G500r7kVfdBHmLl10iUG4ycfOX7l2H9mBzc4TQ7SkVKG1UM+QhHCLjO3A4b+NDYQQwsuMRiOnnXZa87bwXfUmC/sitTfXh03fq8jVkjkGE6SN0CE6N9W4+aHA3f1Eq7wxthMigvj4phN5dsF23vhtF+8tzWLD3gqmXTmU5Khgjxyzo8zZOYd6Zz09onswNHGo149ft24dtUuXgtFI3G23ev34wr/JtfvILBmNlVK5OSSelgZAcZ1M3xO+T8Z24JCklBBCuMloNHLSSSfpHYZwQ050CgARQUZiQg9ZKripsqjLELC0MLXPV4Qndex+olXeGtsmo4GHzunDkIxo/jJrPatzyjn/lcW8fMUQRnf3zabCqqoyc9tMACb3nqzLCoLFTb2kLrwQS1qa148v/Jtcu4/MkqlVStmzc0gIHQLI9D3hH2RsBw6ZvieEECLgZMVo03u6xYYe/iE6tzEplTnay1G1UeZobZU9jpAEiEz1/T+HOMxZ/ZP59u6x9EmOoKTGxtXvrOD1hbtQVVXv0A6zomAF2VXZhJnDOL/7+V4/ft3GjdT+tgiMRuJvv83rxxci0Fmapu/l5ZEUpCXHJSklhPAmjyalFi1axAUXXECXLl1QFIWvv/76qM9ZuHAhQ4cOJSgoiB49ejB9+nRPhiiEEG5TVZXa2lpqa2t98sOj2C+7MSnVNTbk8AebKqUyfDyZYzDC2U83/tJKYuq0f2j7iXbRY2x3jQ/jqzvHcMnQVFwqPD1/K7d+tIbKOrtXju+uGVtnAHDBcRcQZvZ+ZWHJa41VUuef3/zhWYi2kGv3kZmSk1EsFnA4SKrWrieSlBL+QMZ24PBoUqq2tpZBgwbx6quvurV/VlYW5513Hqeeeirr1q3jvvvu4+abb+aHH37wZJhCCOEWu93OM888wzPPPIPd7lsfHMXBcmK06XuHJaWqC6F0J6BAxoneD6yt+k2Ayz+EyJSD71caE1Hb52uN20W7dNjYdjkhazFs/EL7eZSVEUMsRp67bBBPXjwAi9HAj1sKmTBtCVsKao49hg5UUFvAr3t+BWBSb+83OK/fsoWaX38Fg4G426RKShwbuXYfmWIwYM5IByCu1AZAsVV6SgnfJ2M7cHi0p9Q555zDOeec4/b+b7zxBt26deO5554DoG/fvixZsoQXXniBs846y1NhCiGECDD7p+8dkpTKXa79TDoeQmK8HNUx6jcB+pynVXjVFGo9pExB8P45sOVr+ONjGHqN3lGKLXNg/t8OXjExsotW7dZvQqtPUxSFK0/M4PjUSO74eC05pVYufn8tTxx/GhM3/eKFwFv3xfYvcKkuhicNp0dMD68fv6Sxl1TkuecSdFw3rx9fiM7CkpGJbecuwgu1hHh5Qzk2pw2L0aJzZCJQ1ZTXU1FUR3RiCOExvr3Yh/A8n2p0vnz5ck4//fSD7jvrrLO47777Wn1OQ0MDDQ0Nzb9XVVV5KjwhRCdnsVh4/PHH9Q5DHE1YGNkDToCqejJTYw9+rGnqXuYo78fVHgYjdBt38H2n/R1+ehy+/ytkjIT4nrqEFgjaPba3zIFZ1wKHVK1V5Wv3X/7hERNTAAPTopl3z1jum7mOhduK+ct5D7DmXy/yT0swerxdtzvtfLnjSwAm9dGhSmrbNqp//AkUhfg7bvf68UU7hIX5VAWnXLuPrmlqrHFfMZY0CzaXjeK6YlLDU3WOTASiLUv3sfDjragqKAqccnUf+o3p0ubXkbEdOHyq0XlBQQFJSQevIpSUlERVVRV1dXUtPmfq1KlERUU139LT070RqhBCCB9VZ3NSUFUPQLe4Q3rg5PhJk3N3jL4Xup0Edit8eRM4Go7+HNHxXE6tQurQhBTsv2/+Q0edygcQHWrhvetG8MAZvVAU+GxlLpe9sZw9ZdYODdkdP+/5mZK6EuJD4hmfPt7rx2/qJRV5ztkEde/u9eML0Zk0r8CXk0NCaAIgfaWEZ9SU1zcnpEDLXy/8ZCs15fX6BiZ05VNJqWPx8MMPU1lZ2Xzbs2eP3iEJIYTQUXZpLQBRIWZiwg6YelBXAYWbtG1fb3LuDoMBLn4TQmIhfz388h+9I+qccpYdPGXvMCpU5e1PiB6FwaBwz/iefHDDCcSEmtmYV8n5ryzh123e/YA4c+tMAC7teSlmo9mrx67fvp3qxn6icbdLlZQQnmZuWoEvN5ekUK1AQJJSwhMqiuoOK6RUXVBZ1HIBiugcfCoplZycTGFh4UH3FRYWEhkZSUhICysoAUFBQURGRh50E0IIT3A4HMyfP5/58+fjcDj0Dke0Iie/AoCu5fug/oBv3vasAFSI7Q4RSS0+1+9EdoELp2nby16BnT/rG4+fOqaxraqQ+zv88oR7+9cUHn2fJvX1nPToncz981MGpUZSWWfnxumreH7BNpwuz0+L2lG+g9WFqzEqRib2mujx4x2q9I03AYg480yCe/Xy+vFFO9XXw2WXabd6/asf5Np9dJbMrgDY9+whKVgqpYTnNNQdPgYVA0QltvxZ/0hkbAcOn0pKjRo1ip9/PvgN9Y8//sioUX7W+0MIEZBcLhe///47v//+Oy6XS+9wRCuySrRKqa67NoPzgClTOUu1n4Ewde9Afc6DETdr21/dDjWyalJbtWlsW8vg99fhtZHw3lmwZ7l7BwlvQyLU6YQvviB1xgfMunYw14zMRFXh5V92cv37Kymrtbn/Wsdg5jatSurU9FNJDkv26LEO1bB7N1Xffw9A/J13ePXYooM0nr988cXB/wfrRK7dR2dOSQazGdVuJ70+FJAV+ETHqyy2svDjrYfd32dkyjE1O5exHTg82ui8pqaGnTt3Nv+elZXFunXriI2NJSMjg4cffpi8vDw+/PBDAG6//XamTZvGX//6V2688UZ++eUXZs2axbx58zwZphBCuMVoNDJu3LjmbeGbshv773QtP2RKVU5j8iBzjJcj8oIz/wvZS6H4T/hmClw5U+seKtxy1LHdVBW1Zrq24qGjsfrDHAr9L4YdC6C2hJb7SgGRqcecDA0yGfjPRcczNDOah2dvZPGOEs5/eTGvXjWUIRkdv4Jkrb2Wb3d9C+jT4LzkjTdAVQk/fTzBffp4/fgi8Mi1++gUoxFLWhq2rCzSKrS/o0JrG6o7hTiK+ho7c6dtoL7GTmJmBKff2J91P+ayZck+9u2owOV0YTC2rV5Gxnbg8GhSavXq1Zx66qnNvz/wwAMAXHfddUyfPp38/Hxyc3ObH+/WrRvz5s3j/vvv56WXXiItLY133nmHs846y5NhCiGEW4xGI+PHe7/hr2ibrDKtL0G3A5NSNivsW6tt+9vKe+4wh8DEd+GtU2HHD7DyLTjxNr2j8hutjm1rGayfoSWjSrbtvz9pAAy/HgZcBsFRB6y+p9BiYiq+lzY/oR0uHpJG35RI7vh4LVkltVz+5nIeO78fV4/MROnABOTcXXOxOqx0jezKickndtjruqMhK4uqudoXkfF3SJWU6Bhy7XaPJSMDW1YW8SV2iJTpe6LjOO0uvntjAxWFVsJjgzj3zoGERQUxZmIPdq8rprK4jh2rCuk9MqVNrytjO3B4NCl1yimnoB5hSdjp06e3+Jw//vjDg1EJIYQIZNmNSamDKqX2rgKXQ6tYic7UKTIPS+qvVUx9/yAs+IdWEZZ8vN5R+R9VhdzlWiJq89fgbFzV0BwKx18Kw26A1KEHV6L1mwCXf6itwndg0/PQOLCWwu5ftSl/o+5sV2h9kiOZc9cYHvx8A/M3F/CPbzazJqecJy8ZQKil/W/pVFVlxrYZAEzqPalDk13uKH3zLXC5CD/lFEL69/fqsYXo7MyNK/BFFVshEorrZPqeaD/VpfLzh3+Sv7MSS7CR8+8aRFhUEACWYBNDzshg+Ve7WPVdNj1HJLW5WkoEBo8mpYQQIpCoqordbgfAbDZ7/QObODqrzUFRjdZvp1tZ3v4Hcpum7o0O7GltJ9wCu36G7fPhy5vgll/BEqp3VD5PVVXslYWwYRbm9R+hlG7f/2DyAC0RNeAyCD7CYir9Jmj9vXKWaU3Nw5O08+3312HBo/DDIxB7HPQ+u12xRgSbef3qobyzOIun5m/l63X72JJfxRtXD+O4hPB2vfbaorXsrNhJsDGYCT0mtOu12sqWm0vlt9q0QeklJTqSXLvdY8nUvrAJLqiA7lqllKqq8vcl2mXFt7vZsaoQg0Hh7NsHENfl4OvU8Sen8seCXCqL6tixuojeJ7rfx1DGduCQVKQQQrjJbrfz5JNP8uSTTzZfBIVvyS7R+klF11UR1VC7/4GmJucZATh170CKAhe+CuHJULxVS4aI1qkqZC/FPvMmnry4O08+9iD2om1gDoOh18Itv8Bti2HETUdOSDUxGKHbOBgwUftpMMKoKTD0OkDVEoUFm9odtqIo3HLScXx684kkRASxvbCGCdOW8v3G/Ha97sytWoPz8447j0iLd1czLnnrLXA6CRs3jpCBA716bBHYOuraXVNez95t5dSU67+ioCdYMrSklGGfNm2vzlFHjb1Gz5CEn9uydB9rvs8B4JSre5PeJ/awfSzBJgafkQ7A6u+ycbVhhVl5Xx44JCklhBAiYGSXNq68d+DUPYcN9qzStgOxyfmhwuLh4je07dXvwZ9z9Y3HF1nLYNk0mDYCpp8Lm78A1aFVN537LPzfVpjwCqQOa39lnaLAec9Bt5PAVgOfTYbqjmkgfOJxccy7eywndI2lpsHBHZ+s5Yl5W7A7274KUUldCT/m/gjA5D6TOyQ+d9n25lH59TeAVEkJ37Rl6T4+fGQZ37zwBx8+sowtS/cd/Ul+xtI4fc+xZy+RZq2aRfpKiWO1588yfvtE68U4/Nyu9B3dpdV9B5ySRlCYiYpCKztWSYP9zkim7wkhhJvMZjOPPPJI87bwPVklWlKq21knw+s1EBqq9ZNy1Gn9fRJ66xyhl3Q/FUbfA8tehjl3aT2QIlt/Q9gpqKpWMbdmOmz5BpzaNE/MYZiHXMIjN14DXQZjtlg6foqn0az1nHrndCjdCTOuhOvnag3qWxIaCjU1+7ePIDEymE9uOZFnftjGW4t28/biLNbvqWTalUNIjHR/ie0vt3+Jw+VgUMIg+sR6d9W70rfeAoeDsNGjCR0yxKvHFh7QhvPXG9pz7XY5XeRuKePXj/YvY6+qsPCTrWT0iz2mZex9lblLFzCZUBsa6GFPYy01FFmL6B7dXe/QhJ8pzath/psbcblUeo5I4oQLuh1xf0uwicGnZ7Dim92sbuotZTj6dVjelwcOSUoJIYSbFEXBYrHoHYY4gpymSqmkKAgLa7xzmfYzY1Rg95M61Gn/gKxFkL8OZt8K136jTScLNC7n4X2cDvxz1pbC+s+0ZFTpjv33Jw+E4TfA8RNRgiPx+MgOiYErZ8Hbp0Heavj6Tpj4XsvnpKLsP3/dYDYaeOTcvgzNiOYvn29gZXYZ5768hH9P6Ed0mIVu8WGkRLWSAAMcLgefb/8c0Bqce5N93z4qvvoKgPgp7WsEL3xEG89fT2vLtdve4KQwq5L8XZXs21FBQVYVjgbnYfupLqgsqguopJRiMmFO7YI9J5fu1aGsjZBKKdF2tZUNzH11PbZ6Jyk9ohh/bV+3ej0NPCWNdT/lUlFoZefqQnqdcPTeUvK+PHBIUkoIIUTAaOop1TX+gG/nm5JSmaN1iEhHJgtc+i68eRJkL4alL8G4B/SOqmNtmXP4ineRXeDspyAkVktE/TnnoKooBkyEYddr1WPeFtcdJn0MH10Em2dDfC849eEOe/mzj0+hV1IEd3y8lm2F1dz5qbaasUGBqZcMYNKIjBaf99ve3yi0FhITFMOZXc/ssHjcUfrOO2C3E3riiYQOG+bVYwtRV23TElA7K8jfWUlJbvVhPW0swUZs9QcnphQDRCW2nuj1V5aMTOw5uaRXmSFCVuATbWNvcDLv1Q3UlDUQnRTKubcPxGh2r1uQJcTE4PEZrJijVUv1GO5etZQIDJKUEkIINzmdThYuXAjAKaecgtEYgFUnfi6rqVJq2rPgKIfXX4Pc37UHO1tSCiC+B5z7P/hmCvz6BHQ7GdIC5IP/ljkw61rgkKaoVfsa7z9AyqDGFfQmQlDEYS/l1bHdbRyc/wLMuRt+ewrie2pxHaihAW67Tdt+800ICnL75Y9LCOf1q4dy2nO/Nd/nUuHh2Rs5qVdCixVTTQ3OL+55MUFG94/VXvbCQio+/wKA+DulSipgtOP89YSm8a2qKkOPH0lRdjX5OyrI31VJeYH1sP3DY4JI6RFNSvcouvSMJjYljD+X57Pw462ojf/dDD0rM6CqpJpYMjOpXbyYpHIXpEJhrfT3Ee5xuVQWvLuZ4txqgsPNnH/XQILD2zalbuCpWrVUeYGVnWsK6TXiyNVS8r48cEhSSggh3OR0Olm8eDEA48aNk4ufj6lpcFBc3QBA14/fhoZa+Oed0FAJlnBIGqBzhDoZfBXs/FmrzPnyRrh9SYuJGb/icmoVUocmpA6iwNBrYPiN0OXIfYq8PraHXgsl22HZK9o0vuhMSB+x/3GHAz74QNt+9dU2f6gvqDp8dTCXCou2Fx9WLZVdmc3y/OUoKFzW67I2/1Hao/Ttd1DtdkKHDyfsxBO8emzhQe08fzuKy6VSmldD7p9FvP/Kl9SU1XNqPycm48EflGO7hJHSPUpLRPWIIjLu8MRtvzFdyOgXy0/T/yRvWzk2q8NbfwyvsmRo/z/EFGvXUqmUEu5a+vkOsjeUYDQZOO/OgUQltL2fnCXExODT01kxJ4vV87LpMezI1VLyvjxwSFJKCCHcZDAYGDlyZPO28C3ZjU3OY0PNRDVo2+xtrJJKPxGMnfSSpyhaZc7e1VCeDfP+Ape8qXdU7ZOz7OApey1SYcDlR01IgU5j+/R/Qeku2PYdzLgCbvkFolueXtdW3eLDMChaIupAj32zCbPRwCVD05rvm7V9FgAnpZ1EWkQa3mIvKqJilnZs6SUlOoLD5qQwu4r8nZXk76wgf3cl9nonTpeTKGcGUVFgNBlJ7hbZmIDSqqGCw9yr5giPCWbYWZnkbStn+6pCxkzs6fbUJH/RtAJfWFEVID2lhHvW/7yHDb/uBeD0G/qRfFzUMb/WgFPTWffTHsoLrOxaU0TPEUmt7ivvywNHJ32HLoQQbWcymTj77LP1DkO0Iqe0sZ9U7AHfcu9Zof3sjFP3DhQSDZe+De+fAxtmQI/xMPByvaM6djVuTilxcz9dxrbBCJe8De+dDYUb4dNJcOMPEBzZ7pdOiQph6iUDeGT2JpyqikGB7gnh7Ciq4YFZ61mTU85jF/TDhY2vd34NeL/Bedm776HabIQMGUJo44cKIdqivtZO/q7Kxql4FRTlVONyHpyJNQcbyTgultEXTSalRxRJXSMxWY69miK1Twxh0UHUVjSQtaGEHsMS2/vH8Cnmxkop074SUFVJSomj2r2umCVfaIuIjLq4e7vHRFCIiUHj01n5bRarvsum+7DEVqul5H154JCklBBCiICQ3dRP6sCk1F5JSjXLGAkn/w0WToW5D0DaCIg98jLNPklVIW+te/uGt/4Nq08ICocrZ2gr8hVtgS9vgitmdMhLTxqRwUm9EsgusdI1PpTEiGBe/nkHL/+yg09W5LIpr5IJY/dSbasmNTyVMaljOuS47nCUlFA+U+tjFX/nnW6tzCQ6p5ryeiqK6ohODMHlUvdXQe2qpGxf7WH7h0ZZ6NI4DS+lRzRxqeEd2izZYFDoPTKZtfNz2Pp7fsAlpSypqWAwoNQ3EFNjpMRQgtPlxBiIK7eKdivMruLHdzeDCv3HdWHImR1T7TvwtHTW/7yH8vxadq0toudwH7+Wi3aTpJQQQoiAkNU4fa9rTGNSKtYA1mIwBkEXHVZa80Xj/gK7F0LucvjyZrhxPhjb1ohUV/WV8O29sPmro+yoaKvw+UMyMioNrvgM3j8XdiyABX+HcX/vkJdOiQo5qLH5/Wf0YnBGNPfPXMf6vRXsXjkdgrQqKYPivakPpe+/j1pfT/DAgYSN9V4yTPiXLUv38evHW4/YOi4mOVTrB9UzmpTu0UTGB3s8ydmnMSmVu7mM2soGwqL0beTekRSLBXNqKvY9e0ipUCiPcFLeUE58SLzeoQkfU1VSx7zXNuCwu8joH8tJk3t12Ng7qFpqXjY9hiaiyEp8AU0mXwohhJtsNhuPP/44jz/+ODabTe9wxCGaeko1V0plNn6zmzYczIG3StIxMZrgkrcgKAryVsNvT+sdkfvy1sCbJ2kJKYMJBk4GlMbbgRp/P/spbYqcG3Qf26nD4OI3tO3fX4N1H3rsUKf2TuTbu8bSK6McgvJQXSYK8wbgOrQBlYc4ysoo//QzABKmSJWUaFlNeX2LCam4tHAGn57OObcP4MZnxnLl4yM59Zq+9BmZQlRCSIvnU0eP75jkMJKPi0R1qWxfGXir0zU1O+9REw5AoTXw/oyifRqsdua+uoG6KhtxqeGcdfPxGIwdm1YYeGoaQaEmyvNr2bm25Wmkul+7RYeRpJQQQoiA0DR9r1tc44ovGY0JCX+olvGm6Ay44EVte9GzkL1E13COSlVh2TR49yytUXt0htZ76ZI34fIPITLl4P0ju2j395ugS7jHrP/FcFpjhdRPj0I3z02XSY8NZejxWwBwVA3kjV8LuWH6KsprPfemXnU6qV2xkvxH/45aV0dQv36EnXSSx44n/FtFUV2LFVLjLuvJmIk9OW5wAiERFu8H1qjPKO3/na3L81FV7yR0vaWp2Xlmlfb3W1QrfaXEfk6Hi+/f3ER5fi1hURbOv2sglpCOn3wVFGpm4GnpAKz+LhvVS1+cCH3I9D0hhHCT2WzmwQcfbN4WvqO63k5JjfaBumtqLBQVwYenQPVeyBilb3C+6PhLYNfP8MfHMPtWuH0JhMbqHdXhakvh6ztgxw/a730nwIRXtMbtoCWe+pynrcZXU6j1kMoc7XaFVBOfGdvj/gIlO2DDTLg5GSZ+AaFtX1b7aMrry/kxZwEAdwy9htcX2PltezHnv7KE164ayqD06A49XtWCBRQ+ORVHQUHzfY59+6j+8UcizzyzQ48lfEBoqPZ/cNP2MYhKOLy6VTFAVGJIC3sfmSfGd49hiSyeuYOyfbUU51aTmNn+BQp8RVOz85QKreqsuK5Yz3CED1FVlYWfbCVvWznmICPn3TWI8BjPVaIPOi2N9T/voWxfLbv+KD6sh5vPXLtFu0mllBBCuElRFMLCwggLC5MpJz6maeW9+HALESEWsDRoCSnFCOkn6Bydjzr7aYjrAVV58O09WkWSL8lZBm+M1RJSxiA47zmtAqopIdXEYIRu42DARO3nMTTk9ZmxrSha0i19JNiq4fvbwVrW4Yf5eufX2Fw2+sX1456x4/nqzjF0jQslr6KOy95Yzicrcjqs+qNqwQLy7r3voIQUgLOykrx776NqwYIOOY7wIYoCCQna7RjHU4PVcfBLGuCUq/oc0wdgT4zvoFAzxw3W+ixtXV5wlL39iyUjE4D4Eu2LHpm+J5qs+T6brcsLUBQ48+b+JKRHePR4QaFmBp2WBsCqeVmHVUv5zLVbtJskpYQQQvi9pibnmXFh2h05y7WfKYMgyLNvmvxWUDhc+g4YzPDnt7D2A70j0ric8Nv/YPp5UL1PS5zd8jOMuPmYP+D6FVMQTP4EojOhPAtmXg2Ohg57eafLycxt2sp3k3tPRlEU+qZEMufusZzZLwmb08WjX23i/z5fT53N2a5jqU4nhU9ObTnh2Xhf4ZNTUZ3tO44IPDtWaZVWGf1juej+IVz7xGj6jemic1QHa5rCt31VAU67S+doOo6lq5aUCi+qAVWl2CqVUgK2rShgxZwsAE66ojddB3in+f3A09KxBBubq6VEYJKklBBCuMnpdLJo0SIWLVqEUz5E+ZTmJudxYdDQAJ80NvBOkyqpI+oyBMY/pm1//xAUb9M3nuoC+Ogi+PUJUF0w6Aq49TdIHuDRw/rc2DZFwO4B4DJD7jL49r4Oq2Rbum8peTV5RFgiOLvb2c33RwabefOaYTx8Th8MCsxem8fFry1tTvgeC+vqNYdVSB1EVXEUFGBdveaYjyF8UEMDTJmi3RranlBVVZWda7TqnD6jUkjtHdOuKUKeGt9pfWMJi7LQUOsge1NJh72u3sxpaaAomOrtRFmhyCo9pTq7fTvK+eWjPwEYfEYGx5+U6rVjB4eZGTi+qbfUwdVSPnftFsdMklJCCOEmp9PJL7/8wi+//CIXPx+T1dTkPD4UHA6o2ao90EWSUkc16i447lRw1MEXN3VoVU6b7PwJXh8DWYvAHAYXvaGtSBcU7vFD+9zYdjjglU/h0wpt3tL6T2Hpix3y0k1VUhf1uIgQ08H9eRRF4baTu/PJzSOJDw9ia0E1E15Zwg+bj216kqPYvW+13d1P+AmHA157Tbs5HEff/xBF2dVUldRjCjJ2SDWGp8a3waDQe2QyEFhT+AwWC+YUrQosuRyK6iQp1ZmVF9Ty3esbcTlUug9JYPTF3b0ew6DGaqnSvFp2r99/vfC5a7c4ZpKUEkIINxkMBoYOHcrQoUMxGOS/T1/S1FOqa3wYWEshobGvkFRKHZ3BoCV/QuOgcCP89Lh3j++0a8f8+FKwlkDS8XDrQhh8hddC8NmxvcsJp/1H2/7pcdgyp10vt7d6L4v3Lgbg8l6Xt7rfqO5xzLtnLCO6xlDd4OC2j9Yw9fs/cTjbNkXJlJDQofuJzmFHY5VUtwFxmIPavwqlJ8d375Fa8iZnUynWqsBZkt7cuAJfcpkqlVKdWF21jbnT1tNgdZDULZLTb+iHYvD+NPrgsP0r8a2au38lPp+9dos2k389IYRwk8lkYsKECUyYMAGTSRYv9SUHTd/bu1K7s8gJIT64opwvikiGi17Xtn9/DXb86J3jVuTC++fCkhe034ffBDf/BAm9vHP8Rj49tofeACfcqm3PvhX2/XHML/X59s9RURmVMoquUV2PuG9SZDCf3jKSm8d2A+DN33Zz1TsrKKqud/t4jtKjTGlSFEzJyYQOH+b2a4rAprpUdq7WkiA9hid1yGt6cnzHpoSR1C0S1aWyfWXgVEs1NTtPLlepbKikwalTBa3QjcPmZN5rG6gqqScyPphz7xiIydL+JPGxGjQ+HXOwkdK8GrLWa9cWn752izaRpJQQQgi/VlVvp7RW+4a6a3wY7P1deyBHSrnbpNdZcMJt2vbXd0CNh78d/3Outrre3pUQFAWXfQDnPw/mti/5HvDOmgrdx2tTLD+7Aqr2tfklGpwNfLXjKwAm9Znk1nPMRgN/P78fr101lPAgEyuyyjjv5SWszDr6ioDWtWvJf+jh/Xcc2qS+8fekRx5GMer3QUf4lvzdldRWNGAJNpLR3z++VGhqeL51eX6HrVqpN0uGVimVWqGNTamW6lxUl8pP72+hMKuKoFAT5981iNBIi64xBYeZGdRYLbWyhZX4hH+TpJQQQgi/1lQlFR8eRHiQ6YCkVNt7mXR6Z/wbEvtDbbGWmHJ5YEUpez189yDMvArqKyF1GNy+CPpf1PHHChRGE1z2PiT0gep8+Gwy2NrWgHxB9gLKG8pJDkvm5LST2/Tccwek8M1dY+iVFE5xdQNXvP077yze3eoHcFt2NnvvnIJqsxE+fjypL76AKengqhdTUhKpL71I5JlntikWEdiaqqS6DU7AZPaPZGWPYYkYTQZK82op2VOjdzgdomkFvtRK7aOirMDXuSz/ahe7/ijGYFQ45/YBxCSH6R0ScEC11N4asjYEzuICQpJSQgjhNpvNxhNPPMETTzyBzRY4vSP8XdPqYN3iQ6G+Coo2aw/kSqVUm5mDYeK7YArWGo+veKNjX790F7x7Bqx8S/t99N1ww3yI6dqxx2kjvxjbwVFw5Uyt91f+evjqtjYlDWdsmwHAZb0uw2Ro+zSH7gnhfD1lDBcO7oLTpfLfeX9y5ydrqa63H7Sfo6yM3Ftvw1lRQfCAAaQ++wyRZ59Nj59/IuODD+jy7LNkfPABPX7+SRJS4iAul8rOtVpSqmcHTd0Dz4/v4DAz3QZpDdm3Ls/v8NfXQ1OlVEKpE1TpK9WZbFqUxx8/5gJw2rV9Se0Vo3NE+wWHmRl4ahoAq+Zl0dDQ4PvXbuEWSUoJIUQb2O127Hb70XcUXtPc5DwuDPasBNUFZS6oltLuY5LYF856Qtv+6Z9aAqQjbPgc3jwJCjZovb6u/BzO/C+Y9J0S0MQvxnZMV5j8KRgt8Oe38Mt/3HraltItbCjegMlg4pKelxzz4UMtJl6cNJj/XNgfs1Hh+00FXDhtKdsKqgFw1dez9447sefmYk5LI/311zCEaNMxFaORsBNPIOr88wg78QSZsicOs297OXVVNoLCTKT17dgPwp4e301T+LavLMTp8ECFqZeZ07VpUsH1TiLqZPpeZ5GzqZRFn20D4IQLutH7xGSdIzrc4PEZmIOMlOzRqqX84totjko6ggkhhJvMZjP33Xdf87bwDc1NzuPDIOdr7c4TLoKs/0CI9Cc6JsNvgp2/wLZ58OXN2mp4lmMs37fVwvd/hT8+1n7PHAuXvg2RXTos3PbyubEdEgJZWfu3D5QxEiZMg69uhSXPQ3xPGHzlEV9u1rZZAJyRcQbxIfHtCk1RFK4Z1ZXjU6O485O17C6p5aJXlzL1on4Mn/4sdevXY4iKIv2tNzHFt+9Ywk8d6fw9gh2NU/e6D0nEaOy47829Mb7T+8YQGmXBWmkjZ1Mpxw327xUlDcHBmJKTcRQUkFwuSanOoGRvNT+8vQlVhT6jkhl+ble9Q2pRcLhWLbVmfg7rftjLvffei6IovnHtFsdMKqWEEMJNiqIQHR1NdHQ0yqFNe4VuskoPWHkvd7l2Z78zoWtXkCWCj42iwIRXICIFSrbD/IeP/pyWFG6Bt05tTEgpcPJDcN0cn0pIgQ+ObYNBO39bO4cHTYKTHtS259wDOctafakqWxXzds8D3G9w7o4hGTHMvXss43rGU2d3svmxJ6j+8Ucwm0mf9gpBxx3XYccSfuZo528LnE4Xu/5oWnUvsUPD8cb4NhgNzVUlgTaFL7lMpu8FupryeuZO24C9wUlq7xhOuaqPb1wLWzH4dK1aqnRvLRW5Dt+5dotjJu/WhRBC+LWmSqlu0QbIW6PdmTlax4gCRFgcXPwmoMDaD2DLN+4/V1VhzXR4+1Qo2QbhyVoy6tSHwSDTtjrEKY9Av4vAZYcZV0HZ7hZ3m7NzDvXOenpE92Bo4tAODSEuPIjpN5zAc6ZtXLJrEQCfnXY95T2P79DjiMC3989yGmodhERafKqHTVv0GalN4cvZWIq1yv/721gytWbnyeUqRXWSlApUtnoHc1/dQG1FAzEpYZxz2/EYTb6dIggONzOgsbfUyrlZAbPqZWfm22ecEEL4EKfTye+//87vv/+O0ylNtH1BpdVOuVXrJdCtYSs4bRCeBE+9Dg8+CNL4sn2OOxnG3qdtz7kHKvce/Tn1VfDFjfDtveCohx6nw+1LoNtJHg21PXxubNts2vl7pHPYYICLXocuQ6GuDD6dBHUVB+2SX5PP9M3TAbiizxUe+SbZ+usv9PvyHQA+HXQ+H4b05vyXF7Nou6zW1Wm5c/4eYufqQgB6DEnAYOjY89Rb4zu2SxiJmRG4XCo7VhV67DjeYslsrJSS6XsBy+V08cPbmyjdW0NIpIXzpwwkKNQ/psENPj0dgxlWrV7JV5/84BvXbnHMJCklhBBucjqdzJ8/n/nz58vFz0dkN07dS4wIImTfSu3O1BPg2efg2WdBml+236mPaomP+gqYfSu4jnDu562FN8fB5tlgMMEZ/9Yamof7dn8Vnxvbdrt2/h7tHLaEwhWfQWSqNs3y8+vBqe0/e8dszvryLAqt2odjp9rxf666DRvI+7+/gKoSffnl3PLa4wxIjaLcaue691fy8s87cLnkG+xOx93zt5HD7mT3Oi2J2aMDV91r4s3x3dTw/M8AmMJnbpq+V65SbC2WapQAo6oqi2ZsJ3dzGSazgfPuHEhkvP/04QwJt9B/XApb9qzis/e/xOFw6B2SaAdJSgkhhJsMBgMDBgxgwIABGKRXkU/IPrCfVM5S7c60kTpGFICMZpj4LljCtb/jxc9C1mLY+IX206UtGc7yV+HdM6E8G6Iy4Ib5MOZev+jr5ddjOyIZrpgB5jDY/St8/1cKavL51/J/obL/Q+RTK5+ioLagww5r27uXPXfciVpfT9hJ40h+7B9kxIXx+e2juOKEDFQVnv9xOzd+sIoKq1Qsitblbi7DVu8kLDqIlO5RHf763hzfPUckYTAplO6toXhPtUeP5Wn7p+9BvbOeKluVzhGJjvTHj7lsXrwPFDjjpv4kdY3UO6Q2G3JmJulJ3YkyprJnc7ne4Yh2kNX3hBDCTSaTiUsvvVTvMMQBshr7SR0XZ4HtjZVS6ZKU6nCxx8F5z8FXt8GvTx78WEQyhKdA/h/a730v0Jqkh/hPXxi/H9spA+HSd2DGlbD6PXJDw3CpBy9L71Jd7KneQ3JY+5f4dlZUsOeWW3GWlhLUry+pz7+AYtLeUgabjUy9ZABDM6L5+9ebWLitmPNeXsIbVw8jPsJCVkkt3eLDSInyn2/khWftXNPY4HxYIkoHT90D747v4DAz3QYmsGttEduWF5CQHuGV43qCJT0dgIh6CKvTqqWigjo+aSi8b+eaIpbP3gXA2Ik9/Xa1yIjoUK676Ur+WJDLHz/sofuQJGl47qf87OtAIYQQYr+mJufDg/aCvRaCoyG+t75BBSpzK0mE6gItIWUwwbnPwuUf+VVCKmD0ORfO/A8AGcve4NC35QbFQHpEersP47LZ2HvX3diysjClpJD++hsYw8MO2++y4enMvnM0mXGh5FXUcdGrSxk99ReufHsFY576hZmrctsdi/B/dpuTrA0lAPT0wNQ9PfQZpSV+t60swOlwHWVv32UIDcWUoCUrpK9UYKgpr2fDr3v58b3NAAw4NY2Bp6XpHFX7DDkjA5PFQFFONTmbSvUORxwjSUoJIYTwW9mlVgD62zdpd2SMAkUubR3O5YT5Dx15n5BYGH4jyLeU+hl1Fwy9ljiHnTDn/g/DBlXln9V2knNWtuvlVZeL/Icfwbp6NYbwcNLffANzUmKr+/fvEsWcu8Yytkc8TnX/ZEKXCo/M3kR+ZV274hH+L2djKY4GJ5HxwSR29d+qogNl9IslJNJCfY3d7z8kywp8gWPL0n188MgyFs/cjsupEpcWztjLevp9ZVFIhIUBJ2uJtVWyEp/fknfuQgjhJpvNxv/+9z/+97//YZNV3XxCU0+ptKrGqWOZo3WMJoDlLIOqfUfep7ZI288PBczYVhQ47lR+DgulxmggxuHkrfxCftizj0uK98Gsa2HLnGN++eIXX6Jq3jwwmUh75WWCe/U66nOiQszccXL3w+53qirZJdZjjkUEhh1Nq+4N89y0G2+Pb4PRQO8TtWqprX7e8NwsK/AFhJryehZ+vJUD2gxSlleDtbJBv6A6QNPY/mXzLDA6pVrKj0lSSggh2sBqtWK1ygcpX1BhtVFhtaPgIrxwlXanJKU8o8bN5c3d3c8HBcTYdjlhwaPMjAgHYFJ1DaPqG0h2Omn+NDL/oSOvoNiK8pmzKH3rLQBS/vMfwkaNcvu5xyWG0VKroNzGpLLonGx1juYPkD2Gt15x1xG8Pb77jNSSUjkbS6mr9t9EtyXjgEopSUr5rYqiOg4tIFJVqCzy/2pVq9WKw2Wj/7hUAFbNy5ZqKT8kjc6FEMJNZrOZO++8s3lb6KupyfnI8GKU+gowh0LKIFCMsKlxOl+INFPuEOFu9npxdz8f43NjOyTk2M7hnGXsqCtmdVwKRlXl0uqaQ3ZQoSpPq2jrNs7tl61ZtIiCf/8bgPgpU4i++CL3YwJSokKYeskAHpm9CecBHxb+NnsjWaVW/nJmL0xG+Z40YLh5/mZtKMFpdxGdFEp8WrjHwtFjfMelhpOYGUFRTjXbVxUy6LT293PTg6WxUiqlTGWLJKX8VnTi4eNQMUBUC/f7kwPHdlhQFNuWFlGUXUXu5jIyj4/TOTrRFpKUEkIINymKQmKiZ7/NFe5rmrp3euhOqALSTwBj4weO/v31CywQZY6GyC5Qlc9B9f/NFO1xP61U87mxbTAc2zlcU8jMSO3D/anWusYKqZb3c1f9li3sve9+cDqJuugi4u+a0va4gEkjMjipVwLZJVZSY4KZvjSH95Zm8cZvu1i3p5xXrhhKQkTQMb228DFunr87m6buDU/0aF8bvcZ375EpFOVUs3V5vv8mpTL2T98rthbrHI04ViERFoxmA0671mtQMcApV/UhPCZY58ja59CxffzJqaz7aQ+r5mWR0T/W7/tldSbytZQQQgi/1NSPZrjyp3ZH5hgdowlwBiOc/XTjL4e+yWv8/eyntP2EbmqDo/i2cSW8SVXVre/oZkWbfd8+9tx2O6rVSuiokaT8+1/tepOfEhXCqO5xZMSG8dgF/Zh25RDCLEZ+313GeS8vZnV22TG/tvAv9bV2crdo/949h/lnheXR9BqRhMGoULKnhpK9RxiPPszcOH0vsg6qSwt0juboVKeT2hUrqZw7j9oVK1FbS8x3Mvt2VOC0uwgOMzHhvsFc+8Ro+o3pondYHW7ImZmYzAYKs6qa/38R/kGSUkII4San08maNWtYs2YNTnmjozutUkqlR91G7Y6Mxh43Nhs8/rh28+em1b6m3wS4/EOITDn4/sgu2v39+JxZoAABAABJREFUJugTVwfwubF9jOfwXEcJVoOBrjY7J9a31MBWgchUtyranNXV7LntdhzFxQT17Enayy+jWCxux+KO8wd24Zu7xtAjMZyi6gYmv/U77y6R1ZP8nhvn7+51xdoKYKlhxHYJ82g4eo3v4HAz3QbGA7B1ue8ndFpiDA9DiYsFwFRQgvMY+tF5S9WCBewcfzq5113Hvr/8hdzrrmPn+NOpWrBA79B0l7WhBIBugxJI7xPr9xVSTQ4d26GRFvqf3NhbSlbi8ysyfU8IIdzkdDr59ttvARgwYABGo1SF6Cm7pJYMpYgwWzEYzJA2XHvAbod//UvbfvBB6OAP0p1avwnQ5zytJ1FNoVZxkzna7yukfG5sH8M5rKoqM7bPArQG5woKh0+1VN2qaFNtNvbecw8NO3ZgSkgg/a03MUZEHMMf5Oh6JEbwzZQxPDR7I9+u38d/5m5hbU45T08cSHiQvE31S26cvzvXaP2JenihSkrP8d1nVAq7/ihm+8oCRl3SHaMf9k4LysykvrSMxDIXpfWlJIb60FTnRlULFpB3730c2s3bUVio3f/Si0SeeaYuselNVVWy1mtTL7sNitc5Go3L5STvz83UVJQTHh1Dat/+GI7hfURLY3vIGRls/i2Pwqwq9vxZRkY/6S3lD+RqL4QQbjIYDPTp06d5W+hHVVWySmo5y9A4dS91GJj9u2Gn3zAY29Qk2x8EwtheW7SWnRU7CTGFMOH0v8NPj0PVvoN3Co2H3ucc8XVUVSX/sX9iXf47htBQ0t98A3NKyhGf015hQSZenjyYYRnR/Hfen8zbmM+fBVW8efUweiZ5Jhkm9FNXbWPv1nLA86vugb7jO71/LCGRFuqqbORuLmuunPInQRmZ1K/9g+RyKLIW+VxSSnU6KXxy6mEJKe1B7b7CJ6cSMX48it5fOOigZG8NNWUNmMwG0vrG6h0OO1Ys45fpb1FTVtJ8X3hsPKddfys9T2xbX8qWxnZYVBD9T0pl/c97WDU3i/S+0lvKH0hSSggh3GQymZg8ebLeYQig3Gqnqt7BCNM27Y5M95enF+JQgTC2Z26dCcC53c4lcuAkOH7i/oq2kGiYfRtYS2DDLBhyVauvU/Lqa1R+/TUYjaS++ALB/fp5JX5FUbh+TDcGpEUz5ZO17C6u5cJXlzL1kgFcODjVKzEI79j1RzGqSyUhI4LoxFCPH0/P8W00Guh1QhLrf9rD1uX5fpmUal6Br1ylyAdX4LOuXoOj4MjTIx0FBVhXryHsxBO8FJXvyG6cupfWNxazRd+k3I4Vy5jz/JOH3V9TVsKc559kwgOPtCkx1drYHnJmBpsW5VGwu4q9f5aT3k//ZJw4Mv/8OlAIIUSn1rTy3ujmpJQ0ORedV0ldCT/m/gjA5D6Nb9CbKtoGTIQep8OYe7T7Fz8HrfSFqfjqa0qmTQMg+bHHCD/pJI/HfqhhmTHMvWcso7vHYbU5uXfGOh6fsxmbw+X1WIRn7FilrbrXc3hgNjg/VJ+RWqVh9oYS6mvsOkfTdpZMrdl5so8mpRxF7q0m6u5+gSZrfVM/KX0Toi6Xk1+mv3XEfX794C1cHdC3LCwqiOPHaV9mrJTeUn5BklJCCCH8TnZJLYmUk0aBtrZxeuf79lOIJl9u/xKHy8GghEH0ie3T8k7Db4KQGCjbBZu/Ouzh2uXLyf/HPwCIu+UWYiZd7smQjyg+PIiPbjqRKad2B2D6smwmvbWc/Mo63WISHaO2ooF9OysA70zd8wXxaeEkZETgcqpsX+V/iZGmFfiapu/5GpPLvb9Td/cLJDXl9RTnVoMCXQfom5TK+3PzQVP2WlJdWkLen5s75HhDzsrAaDZQsLuyebqw8F2SlBJCCDfZ7XZefPFFXnzxRex2//u2M5Bkl9RygmGr9kvS8RAcpW9Awq/589h2uBx8vv1zACb1ntT6jkHhMHKKtr34OXDtrzyq37advXffAw4HkeeeS8L993kwYvcYDQoPntWHd64dTmSwiT9yKzjv5SUs3XnkDzXCt+1cUwQqJB8XRUSsd1YA84Xx3WdUMgBbl+frcvz2sGSkAxBdC2VleTpHc7jQzEhMIU4OX9ihiYop1EFoZqQ3w/IJTVVSyd2iCI3Ud9GXmgr3EkPu7gdHHtthUUH0H9cFkJX4/IEkpYQQwk2qqlJRUUFFRYVc3HSWVWrdn5SSqXuinfx5bP+29zcKrYXEBMVwZtejrC51wi0QFAlFW2DbPADshUXsuf12XDU1hAwfRspTU1F8qNn76f2SmHv3OPp3iaSs1sY1767g1V934nL517+T0Oxco1WreLNKyhfGd88RSRiMCsW51ZTm1egSw7EyRkbiiAwDwLFnr87RHE6JSiG+f9UR90kaUoUS5dkFG3xRUz8pvafuAYRHx3TofnD0sT30zEyMJgP5uyrZu02qpXyZNDoXQgg3mUwmbrnlluZtoZ+c0lqmNCelDmmKGRwMK1fu3xbiKHxubLfhHG5qcH5Jz0sIMgYd+XVDouGEW2Hxs7DoGZzpp7Ln9ttx5Odj6daN9GnTMFj0/Ta9JRlxoXx5x2j++c1mZq7ewzM/bGNtTjnPXz6YqFCz3uGJQ7Vy/laV1lGwuwoU6DHUe0kpXxjfIeEWug6IZ/e6YrYuz2fMxJ66xHHM0pJhyy6UvUduKK6LzNHUljYmMgwquA5eac0U7CKib+zh7xUCnK3O0ZyI0Tsp5XI5yd6w9qj7RcTFk9q3v9uve7SxHRatVUtt+HUvq+ZmkdY7Rlbi81G+81WYEEL4OIPBQGpqKqmpqX67bHwgUFWV0pJC+hj2aHdkHLLyntEII0Zot064/LNoO58b226ew9mV2SzPX46CwmW9L3PvtUfeCeYw1Lz15N16LQ1//okxLo70t97EGB3dMfF7QLDZyNMTB/L0pQOwmAz8vLWI86ctZlNepd6hiUO1cv7uXKP1I0rtGU1Y9FESqB3IV8Z30xS+bSsLcTn9q3G/JUNbgS8o3/eqTWqWLqM6C1BUup5RTMapJXQZVU7auFIMFieOeiPl6gRt8YdOJGdzKS6nSlRiCNFJnl/lsjXWygq+fOIxVn79xVH3PeXamzG04d/JnbE99KzGaqmdleRJtZTP8oF3XkIIIYT7ympt9LVpjTBdcT0hPEHniITQx6ztswA4Ke0kUsNT3XtSWBzq8BsoWBNF7do/UYKDSX/jdSzp6R6MtONMGpHB7DtGkx4bwp6yOi55fRkzV+XqHZZww87VWlKqRydZde9QGcfHERJhpq7KRu6WMr3DaZPw47TKrpiSeuod9TpHs5+roYGCf/8bgNhetYQkhRCWZCMqs46I1AYSB1YDUDzrF5wVFTpG6n37p+4l6FYdtG/7n3z00L3kblqPKSiIc+95kAkPPEJ4bMuVW7Vt6CflrrDoIPo19paSlfh8l1eSUq+++ipdu3YlODiYE088kZVNJb0tmD59OoqiHHQLlukXQggf4HK52LBhAxs2bMDl8q9vOQNJdun+JueGri30k7LZ4JlntJvN5uXohD/yubHtxjlc56jj651fA0dpcN6C0u1xVOwKA1RSH7yekAED2hmwdx2fGsXcu8Yxvk8iNoeLv325kb9+sZ56e/uXEhcdoIXzt6LISnFuNYpBofsQ736R4Cvj22g00OsE/2x4HtatBwDJ5SrF1mKdo9mv9J13sO/ZiynESfzYGPi/rXDdXLj0XbhuLtFnjCIoyo6ruoaS11/XO1yvcTpd5GwqBfSZuqeqKmu/n8PMxx+ipqyU2C5pXP3kC/QdczI9TxzNLa++y+WPPcm59zzI5Y89yanXaVPwFn38PqV797h9HHfH9tAzMzGYFK1aantFe/94wgM8npSaOXMmDzzwAP/85z9Zu3YtgwYN4qyzzqKoqPUlRSMjI8nPz2++5eTkeDpMIYQ4KofDwezZs5k9ezYOh0PvcDqtrBIrJxj+1H7JaKFHhN0Of/2rdvOzldSEPnxubLtxDn+f9T3VtmpSw1MZk+p+s//KufMofvVtAJKGVhFh/7FDQva2qFAzb187nAfP6o1BgVmr93LJa8vILbXqHZpo4fxtqpJK6xNDSIR3+5b50vhumsKXtaGE+hr/uT4FZWYCkFwOhdZCnaPR2HJzKX3zTQCShlRivPBZbZXRbuNgwEToNg7l3KkkDtEay5d9/DENWVl6huw1+TsrabA6CA43k3ycd1cnttXXMe+l//Hr9LdwOZ30GjWOq558nri0jOZ9DAYj6f0H0nfMyaT3H8iQsy8gc+AQHHYb3017FqfDvbHh7tgOjwmi/1itmnjV3M5xDvgbjyelnn/+eW655RZuuOEG+vXrxxtvvEFoaCjvvfdeq89RFIXk5OTmW1JS5yzzFUL4FkVROO644zjuuOOkUaKO9hUVc7ySrf3SyRqXCs/wt7Gtqiozts4AtCopg+Le2znrqlXkP/wwALFXXEpsHxtkL4bc3z0WqycZDApTTu3BhzeeSGyYhS35VZz/ymJ+2uIbH5rFfjtWa/8mPb246l4TXxrf8WkRxKeH43KozX8n/qCpp1RsDZSU678Cn6qqFPz3CVSbnbCkBiLOGA+9Wlh9NKE34RdcTVhKPThdFP3vGe8Hq4Os9Vo1W9cBcRgM3jvnS/fu4ZNHHmDb8sUYjEZOve4Wzr/3r1hCjtzTSjEYOPuO+wgOj6AoaxfLv/jMreO1ZWwPPSsDg0lh344K6S3lgzyalLLZbKxZs4bTTz99/wENBk4//XSWL1/e6vNqamrIzMwkPT2dCy+8kM2bN3syTCGEcIvZbObaa6/l2muvxWyWFZ/0Yti7CpPiojo4BaL9ow+O8G3+NrY3lmzkz7I/sRgsXNTjohb3UZ1OalespHLuPGpXrKR+xw723HU3qt1OxBlnkPiPf8PgK7WdFz3rveA9YGzPeObdM5YhGdFU1Tu4+cPVPPPDVpwu6R3iC0r31VC2rxaDUaHbIO/3APS18d1nZArgX1P4jNHRNDSudFm1e4fO0UD1Tz9Ru2gRikEl6cR6lHOean3nUx4m6UQXKCo1v/5K7e/+mYR3l6qq+/tJDfTeeNu6bBGfPHI/ZXl7CI+J5fLHpjL03AvdTgSHx8Zxxi1TAFj59Rfkbd1y1Oe0ZWyHxwTTf4zWW2rVPKmW8jUeTUqVlJTgdDoPq3RKSkqioKDlJUV79+7Ne++9xzfffMPHH3+My+Vi9OjR7N3bcla+oaGBqqqqg25CCCECV3zZagCqE0foHIkQ+pi5bSYAZ3c7m5jgmMMer1qwgJ3jTyf3uuvY95e/kHvddWRddDGuykpCBg2iyzP/QzEYYOz9oBhh54+Qd/Tlun1ZSlQIM28dxfWjuwLw6q+7uPa9FZTUNOgbmGieupfRP47gMP2TQnrrdUISBoNCUU41pftq9A7HbXUp0QDU5+j7gd5ltVL4xBMAxPapIeiC/4PojNafEBZH0IV/JaaHNrW38MknUJ2B23+ubF8tVSX1GE0G0vvFevx4ToedX6e/xbyX/oe9oZ70/gO55umXSe3Tr82v1WvkWPqddBqq6uL7V5/DVtex07GHnq31lsrbXkHedqmW8iU+t/reqFGjuPbaaxk8eDAnn3wys2fPJiEhgTcb5wwfaurUqURFRTXf0v1k9RghhBBtp6oq3a0bATB2c7+PjhCBory+nPlZ8wGY3HvyYY9XLVhA3r334Tj0y7/GD2HRky7H0LSATGw3GHCZtr34OY/F7C0Wk4HHJ/TnpcmDCTEbWbqzlPNfXsKaHPnwoRdVVdm5pnHVvWHen7rni0IiLGQOiANg2/KWv6T3Rc4ujf9+e/Wt8Cp5/XUcBYWYwxzEj02CUXcf/UkjbiF+bBwGs4uG7TupmD3b84HqpGnqXlrfGMxBRo8eq7q0hJn/epi1388B4ISLLmPio/8hNCr6mF/ztBtuIzIhkcqiQn794O0OilQTHhNMP6mW8kkeTUrFx8djNBopLDx4znRhYSHJycluvYbZbGbIkCHs3LmzxccffvhhKisrm2979rjfsV8IIdrCbrfz6quv8uqrr2KXBtq6KKmoZiDa1IHovqfoG4wIGP40tr/a+RU2l41+cf04Pv74gx5TnU4Kn5wKR1jyuvjlVw6uEhj3f4ACW+dCYWC0S7hwcCrf3DWG4xLCKKiqZ9Kby5m+VJYC10NJnpWKQitGs0GXVcDAN8d3n1HaFL5tKwpwOX1gxU83GDO0RtHmfaW6xdCwcyel770PQNLQSgwXPQcmNxrnmyyYLvwv8f2rASh+4QWcNbWeDFU3Weubpu55drzlbFzHRw/dS/72/2fvvMOjKLs+fM9sSe+9J0BC770KFkRQRBR77+21V97X/gn2igqoCCqKgA0REUREeodQQxLSQ3ovm+zuzPfHJKEkgZRtCXNf11472X32mbObOVPOnPM7R3FydePKp19g7A23IWraFwhzcnXjsgefAEHg4Pq1JO5sXvKnLb496NIoRI1AVkIJ2YnqDQtHwapBKb1ez+DBg1m3bl3Da5IksW7dOkaOHNmiOcxmMwcOHCAkJKTJ952cnPD09DztoaKiomINZFkmPz+f/Px89eLGThQe24qTYKQIL5yCutvbHJVOQkfxbbNkZmnCUkDJkjpTq6Nq1+7GGVJnYMrJoWrX7pMvBMRB72nKcifIlqonLsiDFQ+PYUrfEEySzMu/HeaRJfuorHGA7ornEUn7lABGdB8/9M5au9jgiP4d1ccPZ3cdVWW1pB8usrc5LcI1uisAbnnldlm/LMvkvPoqmM24h1Xjcenl0GV8yyfoPhnfSwaiczdhLiqmcP58q9lqLypLashLU/4/0VYKSsmSxPafl/Lj6y9SXVZKQHQXbp79Ad2GDLfYOsJ79WHoFdMBWDvvYypLmg4etcW3PXxPZkvtWJlqEXtV2o/Vjw5PPPEEt912G0OGDGHYsGF88MEHVFZWcscddwBw6623EhYWxuzZswF49dVXGTFiBN26daOkpIS3336btLQ07r77bmubqqKionJWtFott99+e8Oyiu0xpmwGIMmlL8OaE890dob1608uq6icA4fz7Wa24c3Zm8mqyMJD78GkmEmNPmbKz2/R9I3GjX0KDv0MB3+C8c+Df2ybTXck3J20zLlxIIM2+zB71RF+25/NkRNlzL15MG5OGlIKKonxdyPEy8XepnYu6rZfWZZJ/Eu5mOw2xH6dtB3OvwGNViRuWBDxf2eSsC2H6L72ySJrDd5delAF+ObXIMuyzTsZlq38naodOxE0EkHDzTDx9dZNIAgIk2cTtPUSMjf5UvTVV/hcdy26sDDrGGwHUuoEzoNiPHHzcrL4/IaKCv745F2O79kJQO/xF3PRXQ+g01t+XaOuvZnU/XvIT0vhz88+4KrnXm60zbXVtwdNiuLw5myyEorJTiwhNNbbgpartAWr75mvu+468vPzefHFF8nJyWHAgAGsXr26Qfw8PT0dUTyZsFVcXMw999xDTk4OPj4+DB48mC1bttCrV+vF0lRUVFQsiSiKREdH29uM8xq3nB0A5PkMbn6QRgPjx9vGIJVOgcP5djPbcL3A+bRu03DRNg6kaANa1mmp0bjgPtB9MiSsgo3vwVWftdpkR0UQBO4aE0O/cC8eWryHpLwKJn/4L0azjAyIAsye3pfrhp5FKFmlddRtv7kppZQX7kbrpGnQULIHDuffdfQYGUL835kc35+PodLo8CLwgXH9SAX8ymVKy/Lw9rJdoNFcXk7uG0oCg3+vCvRXzATPpqtozkpIP9wvvwbXY39QlQd5775L2HvvWdha+9FQumeFUtnclGR+e28WpXm5aHQ6LrrzAfpeONHi66lHq9Mx+T9P8e3zj5Gybzfxf/1B/0smnzamrb7t4etMz9GhHPo3i52/p3DlYwMtZLVKW7GJ0PnDDz9MWloaNTU1bN++neHDT6b3/fPPPyxcuLDh7/fff79hbE5ODr///jsDB6obioqKisp5j2QmpGw/AMbwEXY2RkXFtmSWZ7IxcyMA13W/rskxrkMGoz2bZqcgoA0OxnVIE0HdcU8pz/E/QHFqO611PIZG+/L7I2MZFOlNbV1ACkCSYeZPBzlRWm1X+zoj9V33Yvr5o9NbV3C5IxIQ4YFfmDuSSSZpV+65P2BnnP2DqHJSMlVykw7YdN35H36EubAIvYcJ37GRMOy+Ns8lXPQiQcOMgEzZqj+o2rvXcobakVqDicwEpRTU0qV7B9av4fsXnqI0LxevwCBuePVtqwak6vGPiGLsDbcD8M83X1KUnWWxuQdPUrSlMo8Wk51UYrF5VdqGw3XfU1FRUXFUJEni6NGjHD16FEnqGMKknYqcA7hIVZTJLnhEDmh+nNEIn3yiPBxE1FbFsXE4325iG152bBkyMqNCRxHlGdXkxwSNhqCZzzc9Z13ZQ9DM5xGaEqINGwxdLwLZDJs+sMS3cDgCPJx4/JK4Rq+bZZnUAsu2Hj+vMRqR53xC0objAMQOsW/XPYfz71PoMVIJIh/pAF34BEGg2F8p0ypNPmqz9RoOH6b4u8UABA8uQbzyPdC0o9jHIwjnqY/iFaP4fO6sWcgOtl20hYzDRUgmGc8AF3xD3Cwyp7G2hj/nfsiauR9hNhrpMmgoN8/+kKAu3Swyf0sYdNkVRPbpj6mmhj/mvIPZdFIXsD2+7eHrTI9RSrbdzpVqJz57owalVFRUVFqIyWRiyZIlLFmyBJNJFcu1NXKaoie1S+pOdOBZmlrU1sLDDyuP2lobWafSkXE43z5jG64x1/Bz4s9A81lS9bgOHYqgb9yNShsURNiHH+A58Sx3t8c9rTzvWwyllrsj7Uh0C3RHbEIKp6DCYHtjOiu1tZx4fR6VJh16Zw2RvexXugcO6N+nEDcsGFEUyEsto+iE43eDqwzyAKA69bhN1idLEidefgUkGc/IatwuvQaiWtYs66yMfIiA0Z4IWgnDgYOU/b6q/XPamVO77llC76skN4fvX3iag+vXIggiY66/lWlPv4Czu3u7524Ngigy6cHHcXJzIyc5kW0//dDwXnt9e/CkKERRyZaK/zuDimL1OGAv1KCUioqKSgsRBIGIiAgiIiJsLvCpAjXJmwDYKfcgwlcVJlaxHI7u22tS11BcU0ywWzDjwseddWzR118j19ai796diEULCX3nHSIXLaLbur/OHpAC5WIvagyYa2HLRxb8Bo5DiJcLs6f3RXPG//nRJfv49J8kJMkxurN1dBK7TQCgSx8fNDr7Xm5Ywr8lyUzGoXiObN5AxqF4JMlsEdtcPfVE9lGCdgnbTlhkTmtiDFXKwkwZmTZZX8mPP2KIj0fUSgSOkOGSVy0zsc4F3bRX8O9ZAUDeO28jVXfcEl7JLJF60HJ6Usm7t/Pt84+Sn3ocFw9Prp75KsOvuhZBtI8ve/j5c/FdDwKw/ecfyD6mZOq117c9/VwI6qLc5Ny4NJGvZ27h8OZsyxmu0mIcowWFioqKSgdAp9Nx11132duM8xNZRpOxDYAU1/44aVV9EhXL4ei+vSRhCQAz4magFZs/dTOXlVH8zbcABDz0IO7D29Cie9xT8M0m2L0Qxj4J7vYtvbIG1w2NZFxcAKkFVQR7OjNnfRI/7snkrdUJ7Ekr4d1r++Pl4tii046MZJZJjlGCp90G2jdLCtrv34nbt/D3wvlUFBU0vObu68+Ft99L7PBR7bav58gQUuMLSNiWw/AruyI2lcrnIAjhocARNFl5Vl+XqbiY/HfeAcC/bzm6K14F95Y1c2gRvafje9FnFCenYcrNo2jhQvwfeMBy89uQE8ml1FSacHLTEtLVq83zSJKZLUsXs/3npQCExPXgiseew8PP/t0he4y+gOTdOzi6eQN/zHmXW976CL2zS7t8u6LYwInk0oa/ZRn+WXyUyF6+uPuo3ZttiZoppaKioqLi+BQcQ1dThEHWYQjsZ29rVFRsxuHio8Tnx6MVtUyPnX7WsUXffINUUYFTbCweF1/cthV2GQ/hQ8FkgK1z2jZHByDEy4WRXf2ICXDjnRn9mD29L3qNyF9Hcpk6ZxOHskvPPYlKk2Qll1Ht6oNzdSnhsWcpte4AJG7fwor3Zp0WkAKoKCpgxXuzSNy+pd3riOrrh7ObjsrSWjKOFLV7PmviVNfpzCXH+v6R/957mEvLcPI24ntBLAy+w7IrEATEy98ksF85AAXz5mHMtX6wzRqkxCvbZ3Qff0RN2y7vq0pL+PH1FxoCUgMvu4LrXprtEAGpei666wE8/AIoyT3Bhq+/bPd8JXnVcEZyrCxBaV7HzZrrqKhBKRUVFRUVx6dOT2qPFEuEv7d9bVFRsSFLj/8EwCVRl+Dv0vzFgbmigqJFXwPg/+ADbS+zEIST2lI7v4Qqx75ItgSCIHDDsEiWPzCSMG8X0gqrmP7pFpbtyrC3aR2SpH2FAHRJ2YimjRfIjoAkmfl74fyzjlm/aH67S/k0WpHYYUEAHN3q2CV8nl26A+BRbECyomZj1d69lCxbDkDw4FKEK94D0QoZ0uGD8bz8cpz9apENNeR/+IHl12FlZFk+qSfVxtK9rIQjfPPco6QfjEfn5MyUR57mwtvvQ6N1rIxRZzd3Jj34OADx61aTvHt7u+bzDnThzKo/QQSvQFUiwtZ03COFioqKio0xGo3Mnz+f+fPnY1S7utmWNOVu9E65B9H+lukqo6JSj6P6dpmryO/pfwJwfffrzzq2+NvFSGVl6Lt2xeNc2lHnInYiBPeF2grY9ln75upA9Av35vdHxjC+ewA1Jomnl8fz/E/xGIyW0Q86HzCbJJIPFAMQm7zeztYotNW/s44capQhdSblhQVkHTnUXhPpOVLpApayrwBDpePsg87EP7QL1XoQZDBmWkdXSjaZyHlF0Y7yiqnCddJNSndQKyFc8jJBQxSB69Kff8Fw+LDV1mUNik9UUZZfjagViOjl2+y4pnTRZFlmzx8rWPrKc1QUFeIbGs5Ns96jx+gLbPgNWkdkn34MnjINgD8++5A5H37Q5mO3u48z42/ugXBKRGTgxCi1dM8OqJpSKioqKi1ElmWys7MbllVshCw3BKW2Sz24y8/VzgapdDYc1bdXjPbBYK4h1ieWgYEDmx1nrqik6KuvAPC//34ETTszCuqzpZbeCtvnwaiHwbntOiUdCW9XPQtuG8qc9Um8/9cxvt+RwYGsUj67aTARvuq+51xkHCmipsqES1URoSfi7W0O0Hb/rigptui4s+Ef4Y5fmBuFWZUk7c6jz7iwds9pDQLdgtjhAzG5UJ2aglOXLhZfR/F331Nz9CiiXiJwhAYuetHi6zgNr3Bcr3wQzyPzKUt3JXf2bCK//tohm140RUp8PgDh3X3ROzd9ad+kLpqPH54BgWQfOwJA95FjmXjff9C7OP5+bsz1t5J2YB85KcfZs/JXeowa1+Zjd6/RoUT28mXtgsNkJ5Y0ypxSsQ1qppSKiopKC9Fqtdx4443ceOONaLVqTN9mlKRDWRZGWcNeqdu5M6WcnGDlSuXh5GQbG1U6NA7n205OyL/9xg+39gWULKmzXSCVLPkec2kp+uhoPCdfZhkbelwBAT2gphR2fG6ZOTsIoijwyEWxfH3nMHxcdRzMKuPyjzex/mjH1JuxJUm7ld+oWy9PxN9WOMQ+uK3+7e7tY9FxZ0MQBLqPULKlHLmEz9fZlzwf5fKxJMnyGUXGvLyGErrAfmVor3gFXJvP/rEYox8lcKQzgkamaucuKtats/46LcS5Svea1UUrLiT72BEEUWTC7fcy5dFnOkRACkCr1zP54SfR6XXE6GQGd4lo17Hb3ceZXqMV/0uNL7SUmSqtQA1KqaioqLQQURSJi4sjLi4O0U5tcc9L6rKkDsox1AjORPic46RJq4UpU5SHIwQYVBweh/NtrZZtg/xINRfgpnNjSpcpzQ6VqqooXKBkSfndf1/7s6TqEUUY+5SyvPUTqK20zLwdiLGxAax8ZCz9I7wprTZyx8KdvLcmAbPkONl0joTJaOb4PiVrI/aaYQ6zD26rf4f17I2rl/dZx3j4+RPWs3c7LVSIGxaEIArkppRRnOOY/iYKImWByo2hypQki8+f99bbSJVVOPvW4j2uNwy4yeLraBInd3TTXsS3ewUAuW++gWxFzSxLUVlaQ25KGQAx/RoHpVqii+bi7smAS6d0mMywegKiYhh7w20EeLiTum41pXk57Zovqo8/ggCFWRWUFapC57bGAc68VFRUVFRUzkL6ydK9cB9X9Fr10KXS+fkh4QcAruhyBW665rMDi39YirmoCF1EBF6XX25ZI3pfBb5doLoIdi2w7NwdhDBvF5beN4JbR0YB8NHfSdz+1Q6KKh3/gtXWpB8qwmgw4+7jRHCXjl/uaTYazyn0POG2exEtJMDt5uVEVG8lK+jo1vZdYFsTQ7CSGVabnm7ReSu3bads5UpAJnhoGcLU95XguK3ofwN+E6LROJsxZmRRtPg72627jaTWdd0LjPLAzbtxVmJLdNGqykosootmD4ZMmUZEr74Yawz8MeddJHPb9f+c3XUEd1X2W2kH1GwpW6Oe2auoqKi0EEmSSE5OJjk5GUmS7G3O+UNdptQOqYUi50YjLFyoPBxItFrFcXE0384pzWR92t8AXNf16mbHSQYDhV8qbbH9778PwdJZKRotjHlCWd7yMRjPz7vHTloNr17Zhw+uG4CLTsPGxAIu/2gje9PbryXUmUjclQtA1wH+CF8vcph9cFv9+++v5lNemI/e1RU3n9NLyARB4PLHniN2+CiL2tqjTvA8YXsOkoNm5MnhwQAImbmWm7O2lpxXXgHAJ7YKl0l3Kc0WbIkoopn6FoF9ywEo+ORjTMWO7eP1QanmSvdsqYtmD2Qg7rKrKDVKZB07yvZflrZrvui+yu9Y/7uq2A41KKWioqLSQkwmE9988w3ffPMNJpPJ3uacH5TnQmESMgK7pDiiWyJyXlsLd9yhPDpA+r2K/XE0316esAxJkBl6pIJurhHNjitZugxzQQG60FC8pk61jjH9rgOvCKjIhb3fWmcdHYRpA8P45aHRdPF3I7vUwLXztvLN1lSHEse3F8Yac8OFXGw/b4faB7fFvw//+zcH168BQWDqEzO599OvuPbFWUx66Al0Lq7IsoyLh4fFbY3u64+Tm5bKkhoyjxZZfH5LoI+MVJ7zSixW4la4aBG1KSlonMwEjHCGCc9bZN5WEzUKr8kX4eRtRKqoouDjOfaxowUYa8xkHFWCSTH9A5ocY0tdNHtgMpn4ZdUqCr0CkCSZrcu/JyfpWJvni64rgcw8Vkytwf7nAucTalBKRUVFpYUIgkBwcDDBwcEdrva+w5K+FYAsfQxluBPt14JMKRWVVuJIvm00G/kx5VcArvu7+YtSqaaGwi++AMDvvvsQdGcvM2ozWj2MeUxZ3vQBmOwfZLAn3YM9+PXh0VzWJxijWeaFXw/x+A/7qKo9vy9gUg8UYKqV8PR3JjDCsfbTrfXvwswM1n7xCQAjr76BqL4DEEUNEb370XvchfQYNRaAhK0bLW6rRicSNyQIcNwSPo/QSGq0IMgytVlZ7Z7PmJVFwSfK7x00oAzNFa/btduncOlrBA2uAqB4yRJqkiyvnWUJMo4UYTZKePg54xvatM+F9eyNu2/TWVT1WFIXzdbU+3afYSOIGzkGWZJYNeddjAZDm+bzCXbFM8AFySSTccQxg8KdFTUopaKiotJCdDod999/P/fffz86a10AqpxOXenebnoBENOS8j0VlVbiSL69LmMdBYZC/EuMXLinrNlxJT/+iCkvD21ICF5XTbOuUQNuBvdgKMuE/d9bd10dAA9nHZ/eNIj/TemJRhT4ZV820z7ZTHJ+hb1NsxtJu+q67g0Jsntg90xa49/GGgO/vT8bU00NkX36MeLq6xqN6T5CCUolbt/SLg2b5ugxSinhO74vn5oq+5c/nkmQWzA5dYk1RgvoSuXMno1sqME1oAbP8YOh7zXtnrNd+MbgduVduIdVgySR++ab9rWnGVL2K00FYvr7N+tzoqhh9HU3n3UeS+qi2Zp6337ggQeYdN9/cPf1o/hEFhsWf9Wm+QRBIKa+hE/VlbIpalBKRUVFRcVxqQtKrTd0BWiZppSKSgdmydElAFzzTzG6Zq53pdpaCud/DoDfPXcj6vXWNUrnDKMfUZY3vQfm8zsrCJSLl7vHduH7e0YQ6OHEsdwKpn68iVUHTtjbNJtTW20i7aByARc7JNDO1rSPv7+aR2FmOq5e3kz+z9NNXqxH9O6Li4cn1eVlZBw6YHEbAiI98A11w2yUSNqdZ/H520uAawA5vkoQpDatfUGp8n/+oeKvdSDIBA2tQJjyLjhCUHPcUwSO0IAgU7lxExUbN9nbotOQJLkhaNJc6V49+WkpAIhndGb18PNn6hMzLa6LZi9c3D249IHHANi/5ndS9u5q0zzR/fwASDtQgOygum6dETUopdLhkCQzGYfiObJ5AxmH4pEky9+lUlFRcQCqSyD3IACba+PQiALhPi72tUlFxYokFieyO3c3GkHD1RuaLx0o/fkXTDk5aAMD8b66eSF0izL4dnD1g+JUOPijbdbZARgW48vKR8YwPMaXylozDy7ew/+tPIzRbH/BfFuRsj8fs0nCJ9gVvzB3e5vTZg5tWMfB9WsRBJEpjzyDWzM6O6JGQ+ww5UI+YZvlS/gEQaDHCCVbyhFL+AJdAxsypdrTgU8yGMh97f8A8O1eifNl90NgD0uY2H6cvXCaNhPf2EoA8t6YhewAeoP15BwvxVBhxMlVS0i35ksdS3Jz2Pfn7wBMe+ZFrn1xFpMfeZprX5zF3XO+7DQBqXqi+w1k4GVXAPDn3A+pKitt9Rwhsd7oXbRUlxvJTW0+W1nFsqhBKZUOReL2LXz+0F0sfXUmqz56m6WvzuTzh+4icfsWe5umch5gNBpZuHAhCxcuxOgAHYU6PRnbAZlqj2jy8SHcxwWdRj1sqVgeR/HtHxJ+AGBC6FiCi5u+AJKNRgrnzQPA7+67EZ0atwG3Cno3GPmwsrzxHXCALoWOQqCHM4vvHs59F3QB4ItNKdz4+TZyy9qma9LRSKzL5uk2ONDhSvegZf5dmJnOX19+CsDIa24gsk+/s84ZN3IMAIk7tlqlhC9ueBCCKJBzvJSS3CqLz98eAl0CyfFR/s/VqSltnqdw/ucYs7LQupgJGOkO456xlImWYdBt+F8QikYvUZOcQsny5fa2qIGU/UpTgag+fmjOcl606ftFSGYT0f0HETNgMBG9+9Fz9AVE9O7XYUv2TqUp3x574+34hUdSWVLM2vlzWt2IQqMRieytdNtUu/DZDvXsXqXDkLh9Cyvem0VF0ek7iIqiAla8N0sNTKlYHVmWSU1NJTVV7bZkE9I2A5DtNRBAFTlXsRqO4NuVxkp+S/4NgOu7Nq+pUrpiBcbsbDT+/nhfO8NW5ikMvVsRIC44Bkd+te26HRytRuT5y3oy9+bBeDhp2ZlazJSPNrHteOfWJTFUGsk4pGT1dasT6HY0zuXfRoOB395/Q9GR6juA4dOvPeecEb364uLphaG8jPRD8Ra32c3LicheyoXx0a2OVRLqrnen2N8ZgJq01DbNUZuaSuHn8wEIGlSKeMWb4ORgWXYaLZpps/HvUw5A/gcfYC4vt7NRCvXBkvpucU1xIilBEeMXBMbddIetTLMpTfm2Tu/EZQ8/iajRkrRzK4f++avV80Y36EqpQSlboQalVDoEkmTm74Xzzzpm/aL5aimfilXRarXMmDGDGTNmoNVq7W1O5ydN6bx3RNcHaIXIuZMTLF2qPGyVRaLSoXEE316ZvJIqUxXRntEMCx/V5DYsm0wUzK3LkrrrLkRnZ9sa6ewJwx9Qlv99B9TgfCMm9QlmxX/G0CPYg4KKGm76YjvzNiR32hsZx/flI0kyfmHu+IbU7aMdbB98Lv9et2AuhZnpuHn7MPnhJ1uUQSJqNMTVlT4ds0IXPoAeI5USvoTtOUgOpm1jDlV0jKTsnFaXtcmyTM7/vY5sNOEWbMBj/GjoeYU1zGw/XS/EZ9Jo9J5GzCWlFMyda2+LKM6ppCS3ClEjENXbr8kxsizz77eK2HfvcRcREBVjSxNtRnO+HRTTlVHX3gTA3wvnU5rXujLYqD5+CKJAYVYlZYXVFrVZpWnUoJRKhyDryKFGGVJnUl5YQNaRQzaySOV8RBRFevfuTe/evRFFdfdpVWqrIHsPAFvM3QGI9nNt2We1WpgxQ3mowUOVFmBv35ZlmSUJisD59T2uR9DpmtyGS1euxJiRgcbXF5/rzp3NYRWG3wd6d0Xv7dhq+9jg4MT4u/Hzg6OZPigMsyQz+4+j3PfNbsoMna/sO3FnLgDdThU4d7B98Nn8++A/f3Fow191OlJPN6sj1RRx9V34dmzFbAW9oeh+fji5aqkoriHraLHF528PTsGh1GpBMJsxZme36rPlf66hctMmBFEmeGg1wuS3HUPcvBmEy14ncKCiLVW86GtqMzLsak996V5Ydx/0Lk37V/LuHWQeOYhWpz9n972OzNl8e+jU6YT16IXRUM2qOe+1KnHB2U1HSFdFqys1vnNnuzoK6lWVikNTL2q+7acfWjS+osSxDtoqKiptJHMnSCbwCGV3iSegdt5T6bzsydtDUkkSLloXrujadMaAbDZT+Jlyl97vzjsQXVsYpLU0rr4w7B5l+d+31WypZnDRa3h3Rn9mXdUXvUZkzeFcpn68iSMnOo9wblVZLVkJynlXR+y6V5CRxrovPwNg1Iwbieh9dh2pMwnv1RtXL28MFeVkHNxvcfu0Og2xQ5WSyKPbHKuEL8A9kBxvZbk1HfjMFZXkzpoFgF/PCvSTHwG/rlaw0IIExOE+9WbcggzIJhN5b79tV3Pqg1IxzZTuSWYzGxcrWVKDplyJh1/zJX6dGVHUcNlDT6B3cSE74TA7f21dg46ovkoWmlrCZxvUoJSKwyFLEllHD/P3V/OY/+AdLH11JuktPNi7t+IOl4pKa5EkifT0dNLT05E6icivw3azTFM04uSoUaQWKSKvLdaUMplg2TLl4UDdclQcF3v79pKjSpbU5JjJeOo9m9yGy1b9QW1aGhovL7yvv8HmNp7GiIdA6wJZuyH5b/va4sAIgsCNwyNZ/sBIwrxdSC2s4qpPN/Pj7kx7m2YRju/NQ5YhMMoDr4BTgqQOtg9uyr8bdKRqa4jqN5BhV7Ven00UNcQOHw1AwrZNFrW5nvoufMf35lNTbf/fsp5A10By68TOa9PTWvy5gk8/xZSXh87NhN9IHxjzuLVMtCjChOcJHCGDIFO+Zi1VO3faxY6qslpyUpSOcjH9mw42Hfj7T4qyM3Hx8GTYlc3rE3YGznXs9goMZsLt9wGwZdlico8ntXju+qBf1rFiag2O43udFTUopeIQyLJMTtIx/vnmSz5/+C6WvPQMe1f/RmVxEU5ubvQefzHOTs5nvSOr0+kI7dHLhlarnG+YTCYWLFjAggULMDnAiXZ7UbpZ3nlGN8s7HaNpQLpiQ2ngUGpMElpRINzHpWWframBa69VHjU1VjRSpbNgT98uqC7grzRFiPX6HtcrL56xDctmc4OWie8dt6Nxt3PWoHsADKkTzv33Hfva0gHoF+7Nyv+M4YK4AAxGiSeX7WfmzwcwGB3kJkAbSdxV13XvTIFzB9sHN+Xf6xZ8RlFWBm4+vi3WkWqK7nVd+JJ2bMVssnx5ZmC0Bz7BrpiMEsl1XQ4dAaUDn7JsTG9ZppTh2DGKFi0CIHhwKeLUd0DXwuO6vXH1xXnaM3h3UW6S5c6ehWyHGxipBwpAhoBID9x9GmsK1lZXsWXZd4DSRdLJtXNnmLfk2N37gouIHTYKyWxm1Zx3Mda2bJ/kHeSKV4ALkkkm43CRJc1WaQI1KKViN2RZJi/1OBu/W8iXj97D4v8+we6VP1NemI/exYWeYycw7ZkXeWD+t1x673/ok5VX/8EzJwKUtqDrPv/UcTI9VDodgiDg6+uLr6+vQ7a9bg0N3SwLz+hmWegA3SxNtZCh3IVMcVXKKSJ8XdGepe2xikp7sKdv/3jsR0yyif4B/enh26PJMeVr1lCbnIzo6YnPTTfZ1L5mGfUf0OiVAHLqZntb4/D4uOn56vahPH5xHIIA321P59p5W8moywTtaFQU15CdVAJAt8GOXbp3pn8fXL+WQxvWNehIuXp5t3nusB69lBK+ygrSD1i+hE8QhAbBc0fqwhfoGkhOfaZU6rkzpWRZJvfV18BsxiO8GvcJF0PcpdY207IMvZuAsX6IWgnD4aOUrlhhcxMaSveayZLa+dvPVJWW4B0cQr+LJ9nSNLvQkmO3IAhcfM9DuHn7UJSVwcbvFrZ47vruhvXdDlWsh/3VB1XOOwoz0zm65V8Stmyk+ERWw+taJye6DhpG91FjiRkwBK1e3/Be5batBGblM6iiisOh/hj0JzddZ6OJgLIqMvw8ObB+DTVVlVz2n6fQ6nQ2/V4qnR+dTscjjzxibzPajSSZ+Wvuh0pA98yDuCCALLNu3kd0HTq8zXeP28WJfWCqBhdfjphCgeKWi5yrqLQBe/m2STKx7Ngy4JQsqTOQJYmCTxXdG99bb0Xj4WEz+86KZygMvAV2faloS0WPtrdFDo8oCjx6cSwDIr15dMle4jNLuWLOJl68vBfBXs7E+LsR4tUxMkeS9+SBDCFdvfDwtXEXyFZyqn8XpKeyboGSdTjq2puI6NW3XXOLooa4EaPZ9+fvJGzdRMzAIe2290y6Dw9m2y/JnEgupSSvCu9A+x8PlaCUslzbgkypshUrqNq1C0EjETS0Bi57w8oWWgGtHu201/Hbew/5+z3Jf+cdPCdOtJm+n7HWTOYRJWMnugk9qYqiQnat/AmAsTfejkbb+a+DWnrsdvX04tIHHuOn2S+x94/f6DJoGNH9Bp7zc9H9/Nm/LoPUg4VIkowoduwb0o6MGpRSsQnFJ7JI2LKRhK0bKcg4eUdFo9MRM2AIPUaPo8vAoeiaaG9dm55OyVfKCXlwaSVBpZUUuTlTo9PiZDThW2lAAPwrqtkfE8Kx7Zupqa5i6pMz0Tt3jJM7lfMLSTIrHSVLinH39iGsZ2+LB38ks5nywnxK83Ipyc2hLL/uOS+XwuxMaqsqm+92IwhUVlbw3X+fJDSuJz4hofiEhOETEoaHv7/VAlWysZaqVV9j2rUCbYEe1zEjSC1SWvGqIucqnZENmRvIrcrFx8mHiVETmxxT/s8/1CQmIrq743uLg3VRGv0o7FkEx9dD5i4It/wFeWfkgrgAVv5nDA8t3sP+zFKeWKpk2IgCzJ7el+uGRtrZwnOTuKuJrnsOTq2h+jQdqeHTWq8j1RTdR4xl35+/k7RrK2bTQxYPBrh5OxHRy4/0Q4UkbMth+NQuFp2/LQS6BnLCty5TKjMD2WxG0DR9bmAuKyP3zTcB8O9TgW7yU+Dt+Nt4k3S/DN+JAyhJOoaxoJDCLxcQ8J+HbbLqzCNFmIwS7r5O+Ie7N3p/y/LvMNXUEBLXg9hho2xiU0ciZsBg+k+cwv41v/Pnp+9z6zuf4OJ+9ps8Id280LtoMVQYyU0pa+jIp2J51KCUitUozcslYetGErZsJC81ueF1UaMluv9Auo8aR9fBw3Fq4g5DTXIy5WvWULZmLTVHjpz2ngD4VRoafSaktJKwUX35c9cx0uL3suy1/zL9uZdx8fC0+HdTUWkridu38PfC+VQUnUwFdvf158Lb7yV2eMtPImRZprqsVAk65SnBptK8nLpHLmUF+e3WO8g9ntRIFFKj0eDp44dPSCi+UTH4hkU0BK1cvbzbXPpUtmAWOZ98Qx71AedwArfvoduEz0B3actFzlVUOhA/HFU6y06PnY5eo2/0vgwUfP4FAD633IzGy8FOiH2ioN/1sO9bJVvqxpZ1ylWBcB9XPrphIBe8/U/Da5IMz/90gHFxAQ6dMVVWUE1uShmCAF0HdYyglCzLrPviU4qyM3Gv05ESRMuUhIf26Imbjy+VxUWkHdhHl4FDLTLvqfQYGUz6oUKObj3BsMtjEOycsRHgEkChBxg1oDOaMJ7IQR8e1uTY/A8+xFxUjN7TiN/IYBj5Hxtba0EEAXHKmwRuuZiszT4UfvE53jOuQRccbPVVp8TXd90LaHSuVZCRxsG/1wJwwc13dXiJCWtxwc13kH5wP8XZmfz1+Sdc/tizZ/2tNBqRqN6+JO7KIzW+QA1KWRE1KKXSIlqa2VFeWMCxbZtI2LKRE0kJDa8LokhU3wF0HzmWbkNH4ux+eoRflmVqEhKUQNSfinbGyQ/LuATUUlOsQzIKKGGpM5HR6CViJ1+K5+Tb+Gn2y+QkHeOHl5/j6v++iofv+dkOVcWymEwmfvhBuei67rrr0Gpbtwut13E6k4oiRcdp6hMzTwtMGQ0GJciUn0tpbs4ZAahcjDWNg7OnIsrgYjThaqjBpdaEa60R11oTtRqRgxHnvpCIyStGACqddFQ66anS6zBjprggj+KCPI4f2HfaeJ0o4unqgZePLz5BIfhGReMXG4dfbHecz3I3qmzBLHbP+5HDkZEY9CfvMDvXGum1aTMP9qgk2n/YOe1VUWkr7fXttpBamsrWE1sREJjRvemMjQo3d2qOHUN0dcX31lutblObGPM47P8Ojq2GE/shpL+9LeowZJVUN3pNkuGvI3ncMiLKDha1jKQ6we3QOG/cvJzsbM25MZlMvPPS/ziw7k8GRIYx5ZFn2qUjdSaiqCFu+Gj2rv6NY1s3WSUoFdPfH72LloriGjKPFRPRw9fi62gNOo0OH1c/cr3zCC8EY3pak0Gp6oOHKP7+e0ARNxemfgHaxgH4DkVwHzymzsAl4XeqCyD/vfcJfetNq65SkuQGXaOm9KQ2frcQWZaIHTaKsO49rWqLI9HaY7fOyZnJDz/J9y88xbFtmziycRi9xl141s9E9/NXglIHChh5VVeL2a5yOmpQSuWcnCuzo7KkWAlEbd1I1tHDJz8oCET06kv3kWOJHT4KV8/To8uyLGM4eJDyP/+kbM3a07t3iDJuQTV4RlTjHlaDNrIXZfuzyPrHGeXe8amBKeVvc61I6d48QmZcwPWvvMny11+gMDOdJS8+w9UzX8M3tOk7OCoqLUWSJBITExuWW/dZM38vnH/WMas/e5+EbZuUoFN+LlWlJeec10UQcakx4lJRiWtd4Mml1oRrjREnk7nBU3ReGvSeZvS+VUiyRFKtLwadpukSPlnG2WhibGAKemcJo0GDqUqktlhDudGVEsmZMnRU6pRgVaWTjmq9FqMkUVhRSmFFKWSkwK6TYulOZgkPUYOHswte3r74BIXiGxGJd2Q0+7/6iT1Rje8yGnRa9kQFM/T4PqI9O782gor9aI9vt5UfEpQT6XHh4whzb3x8koECfz8AfG66Ca2Pj03sajX+3aD3dDi4HDa+C9d+bW+LOgwx/m6IghKIOpVXVhwE4ObhkQ6Z8dBQujc46BwjHYPc1OP889uvSGYzI6+5kfBefSy+jriRY9i7+jeSdm7DZDRaXNdUq9MQOzSIQ/9mcXTrCbsHpUAp4cv1ySe8UKY2PR23Uadne8tmMzmvvAyyjGdUFW4XXg5dxtvFVksjXPQCQRt+JXWVE6UrVuBzy8249G2fPtnZyE0po7rciN5FS2ic92nvpR+M5/ienYgaDWNvvM1qNjgibTl2B3eNZeTVN7B56besWzCX8J598Axo/kZtZG8/BFGgKLuSsoJqPP0dN4u1I6MGpVTOyrkyO/wioijKzECWT+4Iwnr0ovvIscSNGIOb9+kn0bIkUb1vnxKIWrsWU/bJTiKCRsYt2IBnhAH3UAOa8F7Q+yrl4d8Nz8MrwHgvuXs8MVWfzNLSupjRe5qoynXmxAsvYi4vx+/OO7nh1bdZ/vr/KD6RzZKXnuHqma8SFKNGuFXajkajYdq0aQ3LrSHryKHTArtNUVtdTcKWf097Ta/R4iYIuBhqcC6twKW6Rgk81ZhwMRrRnHIxI+olnDxM6ANM6D1N6D1OPk5NbJQl6LM+j10hIY3Fzuu6WfYpyMP/CnelRKCmHIxldQOKG4aZa0RM1SLGag2GKi0l1S4UG10oNTtTKjtTrtFTqdNTo9NSoxGpQaagpgpyqyA3E+J3KBOF1F3YNCO6ftjfn0Gbl8LV97bsx9br4auvTi6rqJyD9vh2W6gyVvFr0q8AXNf9usYD9Hoq//c/DMuWI7g443vH7Va3qV2Me0oJSh1eAXlHIbDpLoIqpxPi5cLs6X2Z+dNBzLKMKEDPEE8OZZfxwi8H2ZNWzOtX9cFV7zin6yW5VRRkVCCIAl0HBTQ9yIH2wbWGav74+B16BfsTGteTEVdZRkfqTMLieuLu40tFcRFp8XvpOtjy2b09RgZz6N8sju/Jp/Z6E3oX+24XAS4BJ8XOm+jAV7JsOYYDBxF1EoFDzXDp6za20Iq4B+Jy1WN4Hf6Q0lRXcme9TtR331stiJwanw9AVG9fNKd0IpYliX8XLwCg38WX4RNyft2Ab+uxe9i0GRzft4sTx46yas67jJxxA1WlpU1WAzm76Qjp6kV2Ygkp8QX0vzDC0l9DBTUo5dDYQgz5XOs/V2ZHYZ1oeXC3uIZAlKf/6ScpsslE1a5dlK9ZQ/navzDl5ze8J2hl3EMMSkZUSA1iSBz0ma4EogK6n76yXlPxfBI8Vj1LVXIBJoMGrbMZ167+EDGSvO/XU3TUnby33sZcUkLA449z/Stv8eOsl8hLTWbpK89z1TMvWuUOmaNg723GUW2xFBqNhgEDBrTpsxUF+eceBISWVxBUWNFQaqczn3HnR5DRu9cFnjzMShCqLgClcZIR3APAIwI8QsA9SHn2CAL34IZlIT+RgVnXIx0U6rpZnlIyZzTRK7uAgX2yEWYsh5ixyhtmE9RWKAGqmnKEmnK0NeVoa8pwrinHo6acgLr3qClrGCdXlVFZUExhfg2FZTLFVRpKTM6Uyc6UiU6YzrVNCAIGvY7shCO0uJJfp4Pbb2/paBWVdvl2W1iduppyYznh7uGMDmvctU7Wask/dgwAnxtuROtr/6yIsxLYE3peAUd+U7Klrv7c3hZ1GK4bGsm4uABSC6qI9ncl2NOZzzce583VCfy8N4vD2WV8dvMgugQ0Fja2B0m7lSypiB4+uLg3E3BykH2wLMv89cWnlOZk071rF26Z9bbVOjMLokjciDHs+WMFx7ZutEpQKijaE59gV4pzqkjak0ev0aEWX0drCHQN5ISPAMiNOvCZiorIe+9dAAL6lqObPFPp2NmZGPEgAWMWUJZhpHrvfsr//BPPSZOssqqU/fWle6dfYx3d8i+5x5PQu7gw8pobrLJuR6atx25Ro2HyQ0+y8MkHyTp6iOWv/a/hvaZ0XqP7+ZOdWEKqGpSyGmpQykGxlBhyc5hNRqrLyqgqK1Wey0upLiuluryM6rJSqspKKT6Rfc7MDoDJjzxFz9HjT3tNrq2lcvt2JRD11zrMxcUN74k6CfdQJSPKLdiAGFSX+t/7KgjqdfaV9ZqK0GMKbmlboCJXueiOGgWihsCYz9G88zL58Z4Uzv8cc2kJwS+9zLUvzeKXt14j88hBfpz1Ipc//ixdBw9vy8/m0Fh7m+motjgMh7e1aFhEbil+lQY0zmacfOsynTzN6APdcQr1QxcWhuAVAh7BysM9+OSyWyBoWrBb9wjBs7cvg8kibE85eaJbQzfLQLmC4IHlePb2U3yrHo0WXLyVRysQAPe6RxQomVG1lUrAylDGzrkfsPFQxjnnqXFTxSVVOgeyLLPk6BJAyZIShcZiy5Wbt2DYH4/g5ITfnXfY2sS2MfYpJSh1cDmMfw781MzklhLi5XKasPm947rSL9ybh7/bS0JuOVPnbOadGf2Y1CfEjlYqJO5S9KS6DXH80r0Df6/hyMb1CKLIlEefaSQjYWniRo5lzx8rSNq1HVNtLVoLZ4kJgkD3EcFs++U4R7eecIigVGJ9plT66ZlSee+8i1RWjpO3EZ9RkTD8PjtYaGV0zuimvYrf3kcoOORB3ltv4T5hAqKTZXXWSnKrKM6pQhQFInufvEFhqq1l0xKlXHrYlTOsvn13NvLTUjCbjI1eb0rnNaafP1t+TCI7sYTaavtnKXZG1F/UAWmtGDIogshKgEkJLNUvV50SZKquC0BVl5dRU1VpQYuVVFWppobKzZsp/3MN5evXI5WVNYzQOEm4h1YrgaigGgT/mJMZUUF9mm9N3xSi5mT2xqlWDLsH/5eD0Mx+iJydbpT8sAyptITQt99l+sxXWPnBmxzfvYNf33mdSQ88dk5hu45EW7aZ88EWSyNJEnl5ygl5YGAgYgs795TknGDrjr3KH2eWy9VTp+MUO9QX/xtnoAmKVjKcPELALQAsmWUmamDSm3iW3YpHmIGwfN3JzMMAI4IITHrDsuusRxDAyR2c3BE8Qwi+8h449OI5P+Y7fmrL12EywZ9/KsuXXgo2EK1W6di01bfbwoGCAxwpOoJe1DOt27RG78uyTMGcOQD4DB+G1tvbarZYlNABEDsREtfApvfhyjn2tqhDM6KLH6seGcPD3+1lR2oR93+7h3vHdeGZS7uj1Vhv+zwbhVkVFGVXImoFugw4SwMZB9gH56elsP6reQCMnHETWm8/cnJyrOrfobHdcff1o6KokNT4vXQbYvkboN2Hh7D91+OcSCqlJK8K78DGHaxtRaBrIDk+yvmMMT0DWZIQRJGqPXso/eknAIKHlCBc8Q1oOqkuZO+r8Lv4M0qOp2HMPkHxN9/gd/fdFl1FfZZUaJw3Tq4nf8d9f66kLD8Pd18/Bk1uxTlSJ6Ktx+6WVAOtXzSfrkOHI4oavINc8Q5ypSS3ivTDRXQb3DG6jnYk1DN1B6MlTrLqk3cJW7caQ/nJTCdTbU2r1yUIIi6enrh4eOLq6YVL/cPDE1dPT6rKStn245Jzz3MsiawfV1Dxzz9IVVUNr2ucJTzCq/EMr8Y1sBbBNxJ636EEokL6ty4Q1VJ6TcXnNT/EWTeTvdGJstVrMZfdTfgnc5n6xEzWzP2QwxvX88cn72GoKGfQ5Cstb4ONack2s2beRxhrDGj1ejQ6HRqtDo1We9qyqNWh1ekQG17XotHqEDWaFtfIt3Yn39EwmUzMnTsXgJkzZ6JvwV3Q5N3b+WPOe9RUGdCazJg0YrM6Tr2yC3G//X404yx7QtMkvabCtV8jrH4WNzH75OueYUpAqpdtTnDC+/bHzUlPpaGm2WCdXq8jvG8rOnrV1MDllyvLFRVqUErlnLTFt9tKvcD5pJhJeDt7N3q/avt2qvftQ5AkfBd8Be+/33G24XFPK0Gp/d/DBc+Ct1rm0B4CPZ1ZfM9w3v4zgfn/Hmf+v8fZl1HCnBsGEujpbHN76rvuRfbyO+3iuBF23gfXVlfx2/tvYDLWEjNgMIMmX8nsN94ArOvfDSV8q37l2NaNVglKufs4EdHTl/TDRSRsy2H41C4WX0dLCXQNpMALzCJoamsx5eaiDQgg5+WXAfDuUonrRTMgaqTdbLQ6goA49Q0Ctk3hxHYfCj79BK+rrkLr52exVaTU6Umd2nWvuqKcbT8rx5LR196Mzsn2+wNHoK3H7pbovJYXFpB15BARvfsBEN3Xj325VaTGF6hBKSvQQc5yzh9a4iSmmhrS9u9p9LpGp8PF0wtXDy9cPOsCTR6eymueymsNyx6eOLu5I5wloixJZg6sXkllRXnzmR0mM9Kb71CfE6V1lfAIr8Iz3ICLfy2Cdzj0vkXJigodZJ1A1JlEj8brtZVoZl1D5l8ylVt2kH7bzUR8uZBJDz6Os4cne1b9yvpFn1NdUc6oGTc5ZHebltKSbcZQWcEfn7zX5nWcGqSqD2aJWh3aumBW/fu1BkOrd/IdCUEQ8PDwaFg+G5JkZsvSxWz/eSkAPrUGBiTlUOrqxOHQAAynCNfW6ziFm6pwnWzDtu+9pkKPKdBEOaytEEUNFz30lJJd11SwThCIvOa+DhnEVOk4tMa320OxoZjVKasBuL779U2OKfjkUwC8S0vRmU1Ws8UqRAyDmAsgZQNs/gCmvGtvizo8Oo3IzMk9GRjhzdPL49mRUsSUjzcx54aBDO9iuQvfcyHLckPXvdghjntBJssyaz//hOITWbj7+jHpoScQNRqb+DdA95FKUCp5t3VK+AB6jAwh/XARR7acICzWG+9gV9x9bB+UCHQNRBIFCrxFgookin/4AXNpGTXHEtHoJQKGAZe8anO7bE7YYLyuuILiY39jKIb8jz4i5JVXLDJ1dUUtOcmlgKJrVM/2n36gprIS/8hoel3QeSo/Wktbj90VJcXnHnTGuOh+/uz7K4O0g4VIkowodtxrR0dEDUo5GC11kn4XT6Lr4OF1mU5euHp6onN2sdjBVjYaMRUU0DMlk10BXs1ndmQVoHOX8AyvwjOiGmdfI4JnKPS+WdGJChsMViyDaJag3ri/soZItyvJ+K2S6vjDpF1/DZFff8f4W+/Gxd2DzUu/ZduPS6guL+eiO+47a4DOUTEZjRza8HeLxvqFR+Ls7o7ZZMJsNCrPJmPD31Lds8lkbPj/1mM2GjEbjUC1Rexu6XbuaOh0Op588slzjqsqK+X3j94m/cA+AGKKS+ieUYhWI+NSaiKotJIiN5cGHSffymoEIOiZWxF0Nu5U1Ew5rC2JHT6KqU/M5O+F86goKjz5hiCQRxjXjrvAfsapnBe01Lfby89JP1Mr1dLLrxd9/Bs33ajauZOqnTsRdDr8TvWFjsS4p5Wg1J5vFJ0pT/vrIHUGLusbQvdgDx74dg8JueXc+MV2npvUg7vHxtjkxlpBRgWledVodeJpF8eOxoG//+To5g0Iosjljz7boLNjC/8GCOnWHQ+/AMoL80ndv4duQ0dYfB0x/f3R6EQqS2r49cN9CAKMv7mHzTWmAlwCGJYg4VOqNGQpnDuv4T2PiGq0k18A92Y6NHYyhEteJujfP0hbo6dk2TJ8brwJ5+5x7Z43Nb4QWQb/CHc8/RTdudK8HPb9uRKAC26647y+adfWY7f7Gd3hWzIupKsXTq5aDJVGco+XEtLNu9XrVWkeNSjlYLTUSXqMGtfiTBNZlpGrqjAVF2MuKsJcXIypqG65pBhTURHmomLl9eIizMUlDXpQgcCgKkNdh64zMzsKCS6tJGRCEe5dfaDXDUpGVPgw+wSizsQ7Atf//UWU+1Wk/3CCmuR00mZcReQ33zPi6utx9vBk3YLP2L/mdwwV5Vz20ONotB2j5t1sMnFow19s++kHylvY1e2iKycS0auPUtev0dc9dKB1AlF32v9MMpuVgJWxPnBlPD2YVRfEMplOBrPMJiN5aSns/HX5OW1p6XbeETmRmMBv779BeWE+WhH6pOYQWlyJ3l9HxBdfY9iyitxPvsGv0tDwGa2bQNBDt+B550w7Wm5fYoePouvQ4Q0dG3cu/JL8siKiK7MJ9XY59wQqKg6OWTKzNEHJnLy++/VNBhIKPvsMAK+pU9EdPGBT+yxG9BiIGAEZ22DrnM7VBt7OdAlw5+eHRjHzpwP8si+b11cdYXdaMW/P6IeHs3XPX+qzpKL6+qF3dszLh7zU4/xdpyM15vpbCetxjuY5VkAp4RvN7t9/IWHrRqsEpQyVRszGk515ZRn+WXyUyF6+Ns2Y0v67iyd/kpp4R6Yk2Q234gg8bWaNnfEKw/Wqh/A4PI/yTBfy3phNxIIF7Q4Yp8Yr1QenBoI3LfkGs8lEZN8BRPUf1K75z1fCevbG3df/rNUdHn7+hPXs3fC3qBGJ7O1H4s5cUg8UqEEpC+OYR5XzmNC4HjibJQyi0HzJnCQT6B9ETXIy5qIiJcBUXIy5+JTloiJMJcVKsKmoCLm2ts02BZdW1mV2OJ+S2WGg3jpz3E3w6Ls2LflpMa6+OD/1B1EeN5H+1UFqs/NJnXEVkd8uYcDEyTi7ufHHJ++RsOVfaqoqmfr48+icHbcuWzKbObxxPdt+/J7SPOUE0dXdDVNFKbWyptltxk2sJWzdbXC2pCpR2xCoEjVOiBo9ulMDWNpTAlkNQS39aQGuWDeRA0YjBq22+VJNWSY36RhhPXt3qrs7siyzf80q1i/6HMlswkMwM+BINh6GWtx7BxO64Gc0Xt7oewzA45anqFr1NabsdLShkbhOtkOGlAMiipqGYPvxlHzyf1uI0cmEMfcEmpBO1kpa5bxjc/Zmsiqy8NR7Mimmcdvwqj17qdyyFbRa/O+4HWZ10GCOIMAFT8O3V8OuBTDmcXBz3MyajoarXsv71w1gcLQvr/52iNWHckjILWfuzYPpHuxhlXXKskxSfde9wY7Zda+2uoqVH7yB2WgkZuAQhl4x3W62dB85lt2//0Ly7h0Ya2vQ6S3cjS2vcda6LEFpXrXNglKy2UzebEWnq/HZnvJK7uw38bj4EgRN5znXOyujHyFw9CIqlslUbt1GxYYNeIwf3+bpTLVm0g8rGbNd+isZZznJiRzdvAEEgQtuvrNDy4/YE1HUcOHt9zbZmKmeCbfd2+g6JaafP4k7c0mJL2TkVd2sbeZ5hRqUcjAMe/bRKyOPPVFBzZfMZeRx/ILxrZ5b0GnQuDuhddWgcZLR6I1oNNVoNZVo9GY0ThJaJwmNs4TGScJQrCXjH+VEUoDTMjtORRsS5pgBqXr0rjg9uIxoz/tJ/+QfaovKSbt2OhELv6XH6AtwcnNnxXuzSN23m+Wvv8BVz76Es7u7va0+DUkyk7D5X7b++D3FJxRRalcvb4ZdOYO+3nlsfe4zdoWENLvN9EgrJN/kpxy8zBKyZD5ZoieDXPcMQt3LNSDXNHoP+bRplfdloWHZZBDpZfQ96/aLILDhu4Uc3baJS+55mKAuHWenbjKZ+Kmuo8z06dPR1om3GmsMrP38E45sXA9AWG0lvRJy0UkyftPHEfB/n51WHiro9LhdaQMx8w5MYZdBaMxfYdRqOPrNIgY887y9TVLpxDTn25akXuB8WrdpuGgbZ//VZ0l5XzUNXUgHL3nrehGEDoTsvbD1E7j4JXtb1KkQBIFbRkTRJ9SThxbvIaWgkmmfbGb29L5MGxhm8fXlppRRXmRA56Qhqq/tdKxaykkdqWzc/fy57KEnTjvm2sK/TyW4Wxwe/gGUF+STum83scMs23HYO9AFQThdaUEQwSvQdlnFVbt2Y8rJaSIgdRJTTg5Vu3bjNnyYzeyyK3o39Fe9hM/+Zyg66k7e7Nm4jx6NoGtbFmNmQjGmWgl3Hyf8I9yRZZkN334JQK+xEwiMtp/IvaPQHt8+KR0xv1HG1GUPPdFkp/DI3r4IokDxiUpK86vxClAz+S2FGpRyMEx5uQSXVjIoLfesJXMAorsrWg8XNG46NM6CElTS16ARq9EIZWjFCjROSoBJ6ywhaOTmdcYFUWk77x6kPDyCcKutQbv9X0zVIk3dBwEZrasZ1yEd4GCj0aK79XOifF4gY/b3GIoh/abrCZ/3OTEjRnLNf/+Pn998mexjR/jh5We5+r+v4e7ja2+rkSWJY9u3sHX5dxRmpgPg7OHJsKlXM+CiiegOfk/l4v8jMN+NQbXNbzNBpdUUFVv2Tl1zBNP89tszuxCjRuRYTAi5x5NYPPMJBk2+glHX3oze2fF37JIkcfjwYQCmTZsGQPGJLFa8N5uC9FQEQaBXQR6RmWWIWgj57yN43fSAHS3uuKQVGTCJ/nhSSMLOrQywt0EqnZqmfNuSZJZnsjFzIwDXdr+20fvV8fFUbtwIGg1+995r8fXbHEFQtKWW3Ag7PofRj4BL5y3bthcDI31Y+chYHl2yl42JBTz2wz52pRXxwuW9cNJa7mZhfZZUdD9/dHrHuwkZ/9fq03SkXDxOLxqztn+fiSAIdB85ll2//UTC1k0WD0q5+zgz/uYerP/maMNr42/qYdPSPVNdtr6lxnUa+l2H/0WfUZqSQ21aOkXffY9zjx6Y8vPRBgTgOmRwizPHUvafLN0TBIHk3TvIPHwQjU7H6Otutua36DC017fPlI74d/FXVBQWIDYT3HJy1RHazYusYyWkxhfQ/yK1w6ylUINSDoZWUnbe5yqZixhfgHtwC0ryNE7gEQLuweAeCB7ByrJH0OmvufqD5vTNQZDMBP3bh6y1MkqKzKmBKeX2TNBoLUKXMe3+3jZBENBO/T8ivYLJ/N97VOU7kXHXXYR98B5hl0ziupff5MdZL1KQkcaSF5/mmv/+H97B9rlbraTKb2Pr0sXkp6cC4OzmzpArpjNw0uXos7bAVxch5yVQlqycfJ1rm3EbMxqnrt2UiwVRBEHRPkAQ614TEE5ZRhBOe1+oLykVxLqxwumfFUVq9m+h+Je/zmnLoGsHsl3oSsKWf9n9+68c27aFC++83yrtky2JRqNh8uTJDcuJO7ey+pP3qa2uwkUnMiAxHZ/SGrQeWsI/m4vLkNF2trjjklpQSUrAMKYU/EE2JsqPHMGjZ8+WfVivhzlzTi6rqJyDM33b0iw7tgwZmVGho4jyjGr0fsGnJ7Wk9BERYDR2/G047jII7A15h2D7fBj/rL0t6pT4uulZeMcwPlyXyEfrEvl2WzoHMkv59ObBhFlAj0+WZJJ213XdG9rC0j0b7oPzUo+zftF8AMbecBth3RsfJ6zt303RfcQYdv32E8d378BYY0DnZNmAUa/RoQgi/L3oKC4eOnqOtO35av31iqXGdRpEEc3UNwjYfjU5u7zJe+ON01LatEFBBP13Jp4TJ551GlmSG/SkYvr7I5nN/Lv4KwAGTb4ST3/H7YBpSyzh26dKR+TXaeMm7dxGj1Hjmhwf3c9fCUodUINSlkQNSjkYrlGeaF3MmKpFBIQmSuaU7CS3UA34xp2S2RR8ynPgycCTs3fz2j7nQtTg+cCbUHUvuXs8MVWfdHatq0TQwDI8H5jv2KV7TaC54GEiPgoh6+lnqMjUk/nI44S+VkzANTdw/Stv8ePrL1CSe4IlLz3D1TNfJSAqxma2ybJMyt5dbF76LXkpyQDoXVwZPGUag6dciVNlFvx0G/KxNZRnOpN/KJjaklPKwmi+zNLvnnutnkItX3M15Wv7Y6qUm9l+FWpX/8GkK3rS+4H7WffjSkrzcvn17deIHTaKCXfci4evY+qPaDQahg0bhmQ2s2nJ1+xc8SMAgVoTffZn4GyUcInxI/yr5WiDg+1sbccmpbCS4+5RuBZoqBLh0OJFjPi/N1r2YZ0OHnrIugaqdCrqfdsa1Jhr+ClRKS+4rvt1jd6vPnSIin/+AVHE/766LKnOsA2LIox7CpbfAds+hZEPgpN1NI/OdzSiwBOXxDEwwpvHftjH/sxSLv9oIx9cP5AL4trX/exEcgmVpbXoXbRE9mxhBrmNtt+aqip+e382ZqORLoOGMuTyq5ocZ03/bo6grrF4BgRRlp9Lyr7dxA23/E2q2CFBbPwhkepyI7lpZQTHeFl8Hc1Rf71irLteaUxdNUXUeSN1fpKoUWi6DIZdSQ2yF/WYcnPJeuRR+OjDswamctPKqCqrReesISzWh4Pr11CUlYGzhyfDp82w8hfoOFjat7sNGc7OX5eTsncXZpOxyQZY0X392bw8iexjJdRUm3ByUcMplsABWqSpnIrgFULQoNK6v87Yk9VnJw0sQ7hlGTy8E25fCdd8qXS3Gf0I9LsWuoyHwB5Kqnx7BfB6TcXzyfl0u0lD5IQCQkcWEzmhgG43avB8cj70mtq++e2EOPBqwuctwKuLEWTI/t+rFH3xCd5BwVz/6lsEREZTWVLMDy8/R9bRw1a3R5ZlUvfv4fv/PcXPb75CXkoyOmcXhl91HXfP+ZJRUybhtOE15E9HUvHvBlLXBpC12ZfaEhHB0xPxHBpY2uBgXIcMtvr3EHR6gh66pf5bnfGu3PBaWaobx+el4vPVw9x6aRDDLr8SUaMhcccWFj7xAHv++A1JMlvd3rZQWVLM8tdfaAhIdTeVMGh3Gs5GCa8Jg4j89W81INVOTGaJjKIqEASieip3r44djkeWz9ymVFQcnzWpayipKSHYLZhx4Y3vvNZrSXlePgV9dLSNrbMyva4Ev1gwlMCO+ZCyEQ4sV54ddB/fkZnQI5CV/xlD3zAviquM3P7VDj78KxFJavu+M3GnUrrXZWAAGp3jXDbIssza+R9TknMCD78AJj34+Gk6UvZGEATiRiiBqIStm6yyDq1OQ3QfRePr+N6WdWK2FKderzTuv3fK9YpXB9fHawOy2UzuX2fLEJPJfeVFZHPz+8DUutK9qN5+mM01bFm2GICR06/DydXNkuaqnEJIt+64enlTW11FxqGmO+B6B7niHeSKJMmkHyq0sYWdF8fZe6soRI3Cs7cvYaNL0LqcvpvXupoJG12CZ28/iLJsffpZ6TUV4YmDuD3zE15PzMHtmZ8QnjjYYQNS9QhdLyDky5/x6a0cPHPfmUP+26/i6uXNtS+9QWj3XtRUVbL89Rc4vnen1exIPxjPDy8/y4+zXuREUgJavRNDp17N3R9/wZgZN+ByeAl8PIiq374k7S8vMjb4YSjSIbi64vfA/cT+tZaQWa/XldadEYSsey1o5vM2637ieedMwp65Fa3b6bZo3QTCnrmVqO++w6lbDOZakRPbPcl+4weGHn2fm++9ipDY7tRWV7N+4Ty+/99T5KUet4nNLSXz6GHmPnY/R/fsQqsRGVaUTddDhYgCBD18OyGffovYUUttHIgTpQaMZhm9VmT4rbcDkK8VKNzcwhN7sxn++Ud5nOWkT0WlHlmWKSwspLCw0OLBzyUJSwC4Nu5atOLpd1QNR49S8dc6EAT877//5BudZRsWNTD2SWX57/+DRZfDj3cpzx/0gcMr7GufIyCZLRqsi/B1Zdn9I7lhWCSyDO//dYw7F+2kuLL1XZgls0TyXiUoFTu4FeVCNth+4//6g4StGxE1Gi5/7JlGOlKnYk3/PhvdR44F4PgepYTPGnQZqPxfju/Nt+2Nm7rrFcOECorOSIC02/WKg1C1cwemogqa1uMFEDAVllK1c0ezc6TEn9ST2vXbz1SWFOMdFEL/iZMtb3AHxtK+LYgiXeukRJJ2bW92XHQ/paIj9UBBs2NUWoeab+ZoiBqY9CaeZbfiEWagKl+HyaBB62zGNcCIIAKT3rB9yZyogZixtl2nDRBC+hL0xZ9oHp1KwY5aCr78HnNRAUGvf8A1/32V396bTcq+3fz69v8x6cHH6TlmvMXWnXn0EFuWLibjUDwAGp2O/pdMZtiV1+Dm7QNJf8Gf/6U6IZn8Ax5UnqjrhKjX43PDDfjdew9aP+UOmefEifDhB+TOmo0pJ6dhHdqgIIJmPn/O2nVL43nnTDxueYqqVV9jyk5HGxqJ6+RbEXRKwCbmlxUUffMtBR9+QHUBpPwk4XvwBa6dOoRDQ65j468ryUlO5NvnH2PQ5CsZNeNGuwqhy7LM3tW/sW7h56w9mICzTuS/OhHPchnRWSTsvXdxv7Bxi3eVtpFSoDRziPJ1xa9LV/z0LhTWVnNg2RImjGnBfshggAkTlOWKCnBT7yqqnB2j0cjHH38MwMyZM9FbKLh8uPAw8fnxaEUtV8U2Li0q+GwuAJ6XXYZTl1M6KXWmbVhbp6Ujn5FPUXYClt4K137d4W9ytZnDK2D1s1CWffI1z1CY9Ga7fhNnnYbZ0/syKNKb//1ykH8S8rn84018dvMg+oV7t3ierIQSqsuNOLvrCOvRCqF6K2+/uSnJrF/0OaDoSIXGnV1v0Fr+fS6CunTDKzCI0rxcUvbuIm6E5TVYI3v7otGKlOZXU5RdiV+YjbpH112v+FTfwe3DvBmULvFhapH9r1ccANORLS0fN2Jko9dL86soyq5EEAX8I0T+/EQp/x5zw21NlpOdz1jDt7sNHcGBdX+SvGsbF915v6KhewYx/fzYtzadtIOFSGYJUaPm+bQXNSjliPSaCtd+jbD6WdzEU09UwpQd/Pl68mYlBJ8oAuauR/PkZHLXl1L881qkktsI+fgrrnz6BVZ/+j5HN29g1Zx3MVRWMPDSy9u1vhOJCWxe+i1p8XsB0Gi19L3oUoZPuxZ3Xz8oSITF91Gzax35Bzwoz6zTg9Bq8Z4+Hf8HH0DXRHmY58SJeFx0kdKmtw1dPiyNoNPjduXdTb+n1eJ3x+14XjaJ3Nf/j/K16yhKcKdsziFihuykyzX38U+ChmPbt7B75c8c27aJi+58gK6Dbd/psdZQzdr5czi6eQOSWSLQGfyzinD28kUf4kXEgu/Rd1Hb8lqS1MK6oJSfciHTc8RoNv37F8npyYw3mRCs3M5b5fzE2dnynauWJiwF4JKoS/B3OV0rz3DsGOV//gmA/wP3N/psp0Ayw5qZzbxZ10Bl9XPQY8r5d/F6eIUSlDuz1N2CwboZQyLoHerFA4t3k1ZYxTWfbeXlqb25YVhEkxdaZ5JYJ3DedWAAGge56KqpqmLl+28oOlKDhzG4GR2pM7GGf58LQRCIGzmWnb8uJ2HrJqsEpfTOWiJ6+ZIaX0Dy3nzbBaUAuk4gUNYiiwK7ozXoMOAqy+f99cqZlS6tHVffdS801os9K5dirDEQ0q17QzmoyulY2rcje/dH5+RMRVEhuceTCO4a22hMcBcvnFy11FSayDleRmist0VtOB9Rz+wdlV5TlZO0tC1QkauImEeNOv9O2myFqy++H/6N+MI0TqxIp3T9Lsy3TSdswTImP/wkzu7u7Pvzd/5eMBdDeTkjrr6+RSd0p5J7PIktyxZzfI9SCihqNPQZfwnDp1+rdNGoLobVz1P79xcUxLtSmhYAslJ+53nF5QQ8/DD6yMizrkPQaKwuZm5JdMHBhH88h4qNG8l56UWM2TlkbfTALWkBl17oRe/b/sO6VZspy8/jl7deJW74aCbcfq8SvLMBhVkZ/PbebAoz0xFFkREUcEWlBsHbD/fBPQid9w2ac+h5qbSe+kypGH9XAPrecAubN6ylVK8l8/ffiLiyZRchKiotRa/X89xzz1l0zrLaMn4//jsA13e/vtH7hXPnAeBx6aU4xTY+6e0UpG05PQuoETKUZSnjOmE2drNIZiVDqpH2Ilg6WNcr1JMVD4/hyaX7+etILjN/PsDutGL+b1ofXPTNz202SQ06Rd2GtLDrnpWRZZk18z6iJPcEHv51OlItOBezhn+3lO4jxrDz1+Uc37MTo8GAzgrBsa4DA0iNL+D43nyGXW675jwc/Ak3kwE3GSoFyJv8JtH+vc776xXXIcPQunyOqVqk6RK+OhH4IU2fr9cHpQIjTGxbvgaAcbfc2errjvMBa/i2Vq8nZsBgjm3fTNLObU0GpUSNSFQfP47tyCU1vkANSlkAx7jtodI09SVzfa9Rns/jHbxN0LviPWsV4bf2QxBlKnYnknHtJKSqKi68435GXnMDAFuWLWb9ovnIUsvuhOSnpfDrO//Ht88/xvE9OxFEkd7jL+bOD+Zxyb0P4+njCzs+x/jGQE7MWUzySj9KU11BFvC45GJifv2FsLfeOmdAqiPjPnYsXVb9gf+DDyBoNVSecOb49wY8FrzIrcNMDLn0UgRR5Nj2zXz1xP3s/XOl1YXQj23bxOKZT1CYmY6bmzMXFB0ncH+p0uHwpumEf71cDUhZidS6oFS0v5Ip5errR6iHUjpycOWvdrNLRaU1rEhagcFsINYnloGBA097r+b4ccr++APoxFlSoNxUawnLbodvpsOqZ2D7PKV8vTi184ihyzJUFkLWbjj4E6x8ouXBOgvg5aJj/i2DeXZSD0QBftyTyVWfbm7Y1zZFxpEiaqpMuHrqHeaCa/+aVRzbtknRkXr0WVzcHb+bY2BMV7yDQjDV1lhNnzS6nz+CKFCYVUFJXpVV1tEke78BIFCvdP3LCx+oXq8AQpcxBI2p/w2a1jkKGq1F6NI4c85QYeREsiIgn3X0d2RZotvQEYT36G0tc1WaoOvQEQAk79rW7BhVV8qyqJlSKiqnotHi8dwPRHj/h8xP1lKVkEP6VRcT8cPvjJpxE87uHqxfOJ+9f/yGoaKCS+9/FEEUyDpyiIqSYty9fQjr2RtR1FCYmc6WZd9xbFudOLMg0HPMeEZefT0+IWHKa0nrMP3yHIWbcihOdEM2K3dB3EaPJuCxR3Hp29dOP4TtEZ2dCXjkETyvuILcl1+icvtOCg56Upa2lcHDN9DzxgdZuzWHnORE/l4wlyP/rufiex4iMNqypXNmk4mN3y9i98qfAQjzdaLvvgOIxSKCViDk1Zfwmt64rbuK5UgrVE6qY/xO6pD0umgiWb8uJaUwB3NlJZqOrLGj0umRZIkfEn4AlCypM+9wF8ydC7KM+8UX4dyjhz1MtA3uLcywqSqA5HXK41Q0evCJAb9u4Nel7rkb+HYFj+C2dxiWzJbPRK+pgJI0KE5r4jkdastbP2dLg3otQBQFHhjflf4RXjzy/V6O5pRzxcebePfa/kzs3VgSIGmXInDedXAgomifDA1JMjecX9VWV7F+0XwAxt54O6FxHcNvlBK+Mez4ZRkJWzc2iJ9bEmc3HWFx3mQeLeb4vnwGTYyy+DoakXcEMneCoCHQuwsp+XvJrbLc9tqhETV4PvAmVN1L7h5PTNWN9y26Cx9scp+TdrAAWZJx9y4g/cBuBFFk7I2328BolVPpMnAogihSkJFGSc4JvIMbd5GM7O2HKAoU51RRkleFd6CrHSztPNgkKPXJJ5/w9ttvk5OTQ//+/fn4448ZNqz5EqNly5bxwgsvkJqaSmxsLG+++SaTJ6vdBlRshCDg9sAcIn1eI2PWtxgySkm78mIiv/+FQZdNxcXdgz8+fZ8jG9dTlJlOZWkJFUUnW4K6evngExJCVsIR5e4oSgeWkdfciF94hDKoIBHzb89TtHIbRQluSCYl48Zl4EACHn8Mt7P4R2fHKSaGiIWLKP/jD3Jff43awhIy/tLieewzrrk4lMNX3cSm1f9wIimBb59/jMFTpjHqmhstkhJfUVzEyg/eJOvoIQD6+9QStikRjCJab1eCP/2cdenp8MsvXH755WhVbSOLYzJLpBcpQan6TCmAHtNn8PcvP1Ct05L0w/d0v7NpvTIVlbZgMplYuXIlgEV8e/uJ7aSWpeKmc+PyLqfrENamplK2Uinr83/ggXatx+GJGqUId5edoOmMAUEJLl01H0pSoTAJCpOVR9FxMNdAQYLyOBOdG/h1rXvUBar8uil/u/o2b1NbxcVNtVCaoWRwNRV8qmpBa3D3YPCJAq0LpPzTgvGWL5sb1dWflf8Zy0Pf7WF3WjH3frOb+y/oylMT49DW6UaZjGaO71dK92LtVLqXuH0Lfy+cT0XR6VkIQV1jGTxlWqvmsrR/t5buI8ey45dlpOzZRa2h2iqNW7oODFCCUnttFJTao2RJ0f0yAj3CIX8v+dX51l9vR6HXVDyfBI9Vz1KVXNDQtKo42ZXydFeyPvuNLpfeheh6eiAjJb4AWZYxlP4DQL+LJuEbGm6HL9AxsJZvO7u7E9GrD+kH40natY0hTWjXObloCYn1JiuhmNT4AgZc3HkrWmyB1ffKP/zwA0888QRz585l+PDhfPDBB1x66aUkJCQQGNi4veyWLVu44YYbmD17Npdffjnfffcd06ZNY8+ePfTp08fa5qqoNOBy/QtE+QaT/uzb1OYbSJs+hchvvqfn2Ak4ubnz6zuvk5uS3OhzVaXFVJUWAxA7bBQjZ9xIQGS08mZ1MdLaWRR/t4TCw66Ya5XUc6cecQQ+/gRu48apNeModxY9J0/Gbdw48j/8kOJvF1OW7kLF14VE9X2dbldcwT9ZoRzbtZNdv/3EsW2bufiuB4gZOKTN68w8cpCVH7xJZUkxeic9o+V0XDZUgCzi0j2KsM+/Rvb2Zt8KpYW5Gii3Dlkl1ZgkGSetSLDnyUCj3tmFqMBQjuef4Mj6tWpQSsWiSJLEvn37AMv4dn2W1NSuU3HVnX7RUTBvPkgS7uPH49K7k5dk1HXoUgS9BU4PTNUd6y57C7qMA8ad/lnJDKWZUFQXpGoIWCUpQSBjJeTEK48zcfE5PauqPnCVfxR+updmxcUvfx/845oOOpVlN/7cmTh7K0En76hTnqOVZ+8I0Lmc/G4f9Dl7sM4zVAnqWYFgL2eW3DuC2auOsmBzCnM3JLMvo5iPbxhEgIcT6QeLMBrMuPs4ERzjaRUbzkbi9i2seG9Wk+/lJieStGMrscNb/ttY2r9bS0BUDN7BIZTknOD47h30GH2BxdcRMyCADUuOkZtSRkVxDe4+ThZfRwOmGohfoiwPvIWAiiMA5FXlWW+dHZFeUxF6TMGtPitT74rz8ieoXm7GmJ5B7ttvE/LSSw3DzUaJ9ENFSMYEKirT0Tm7NEiHqDSNNX2765CRSlBqZ9NBKYCYfv5KUOqAGpRqL1YPSr333nvcc8893HHHHQDMnTuX33//nQULFjQpTPbhhx8yadIknn76aQBee+011q5dy5w5c5g7d661zXU4diYksf9YCv3jYhjavZtqi41tcZp4D9FegaQ9/AzGMki94Toi580levBonNzcqC4rbfazrl7eXP74s4iiBswm5O1fUDz/HQr3iZgMSmaUPiqcgMefxGPiRATRMhJvnen/pHF3J/i//8X7qqs48eILGA4eJnevF06pf3HxaJleV9/Hug1HKcvP5ac3XiZu5Fgm3HYP7j6N75I3Z4ssy+z+/Rf+XfwVsiTh5+fJiLTdyMmKQKXXZRcS/MZ7iE5OmM1mLrnkEsW2dnY17Ez/J0vy1/6jRGtycPLwbVQy0ueKqzi+4FPSq8qoyc/HKSCg6Ul0OnjrrZPL7eB4VgbH0zLoEhVBl7CIds3VXlRbrGePRqOxmG/vStrH0QPpuDl7cV3300t9azMyKK0LbPs/eJYsKQttwxXFBkryqvEOdMHdx/bdx4CGjsKsfpaK4hpKTCF4a08o9pytQ5eoUQI7PlHQ9cLT3zPVKoGiwqTTg1WFyVCerTQOydypPJqhwux30hZNXZbTysfO/l10rnUBpsgmgk9R4OzVst/kjGBdhdn3DFtk5bexojaPTiPy4hW9GBTlzbPL49l2vIgpH23kk5sGkb4hAwD/OC+EtpTutWP7lSQzfy+cf9Yx6xfNp+vQ4cr5VQuwlH+fKK0mpaCSGH83Qrxanu0kCALdR45l+89LSdi6yWJBqTPtCY7xIud4KSn78+k73orZNQmrlMxAjxDodjGBxxT/2ZF1gPicVPoFR1tv3S0gPieV3VmJDA6LtbstiBriXSLYXWRgcEAs/a7/lNCM60j/x5+S75fgceFFuI9VtKUyE4qpNdRgrtkMwLCpV+Pm7WNRcxzpt7GELZby7aZs6TZkOOsXziM74QhVZaW4ejbev0f382PTskROJJZSU2XEybV955xns6ezI8iyfI7bPm2ntrYWV1dXli9fzrRp0xpev+222ygpKeHXXxsL1kZGRvLEE0/w2GOPNbz20ksv8csvv7B///5zrrOsrAwvLy9KS0vx9LT93R1L8tIni/E/EISIiIREXs8T3HjVBLvY8t3P6wk8EnL+2pKyF+mFVzAVCwg6KLvrOrb/+885Pzb8/scJ0BUjfvcBht2VSFVKHFjw9US89TbECRcgaC130tmZ/0+yJCH9uRbzgoVQZQBknGMMaMdEsl8zlNRde5ElCa2zM90vu4rIEWMbAn3N2WIyGIhf9jU58XsACA92pef+Y8iFOhBAc9tNiNdcbfHstc78f7KkLYV9crj3+okN70uSxC8P30ONIDN8wEi63HOPVe1Z9ecmqjd6NtjjMraMyZdavqW3akvnsedMW7zGG5gx5eQ2nPvGG5Su+A3XESMIf+9dq9pybEcOm5cnIcuK9NLoa7oRN6yxdpCtOLYtm80/HT9pz/QuxI0ItfyKaqvqMpxSoCi17jlFCVrV6Todqx7H5vI7kBERkBjt8RVxLv8qn3cLBP9Y8AxXspu8wsErQnm4+rZdx6opElZz7JfVbC6Yfrotrlvg7r+U9duAlIIKnloWT0pBJX2MWi6o1iIgICGjH+7PNTNsp9904uhB/nz7pXOOu/TpVwjpYbsKil/2ZvH6qiNIMogC/HdyT6YNDGvx54syUlnx8pOIWh03fPAVOpf2lfA1ZU+PUti3MpXAbl5ceL/1fhuP5dehT11P1fDHqB47k0fWvkB8mdK4QZYFLvC7kydGNe44agve27KEDYULEATZ7rY0Z8//jInULPyN6mNu4OeD7tuFCJ6eHPr1BCn//oWpegPOXl5c/PIstE6Wy3hzpN+mo9iyfvarlGakM/CW24ka2fR5xcYPkqjMr6X/dWGE9GvhjYlW2HN56H94Y6J1z3etSUtjM1YNSmVnZxMWFsaWLVsYOXJkw+vPPPMMGzZsYPv27Y0+o9frWbRoETfccDJd8dNPP+WVV14hN7exgF5NTQ01NTUNf5eVlREREdHhg1I7E5LY/n4aQpOtRFXsjbn2KMbKVeccp3ObjEbfMcQ4OzqSKQ9j1Vpks7KfEDQh6NwuRtQEIMsSkikL5EoQ3BC1YchSMcaK35ClIkBE6zIejVN/tXzSwTFWbcBcsxtRF4fe/fJzf0BFRUVFpc1IyMzzNFBho37dsRWJTMr/65zjVgdcTKJ741btDossc3PW9/gYS61mu5dZ4N5yZyRkPvU0UG2F/1koBWxyehRRkBlX8z4ZGmfcur2BIFjtcrJTojPKvPmVmfBC2NxT4MMrtdyy83k0hctBrmFz30ISIyrsbeZ5T/9ELwYmepMeWMXfQ5rWTBuedgUDsy8m0X8X62K/sbgNsizw3aQVHTZjqqVBKRsdYqzH7Nmz8fLyanhERNi/jMAS7D+WogakHBmhhZ2/WjpOpd2I2kD0HjegdZkA6JDNJ6gtW0xt+a/UlH6BsWIZxspVGCuWUVM6l9qyb5WAlOCO3uNatM4DzhmQkmWZ6tpKqmsrsWI8X+Us1Ad5JWMyslxzjtEqKi1D9W0VlaYREfAx2+5yoUrTsg5WLR0Hin9LNVVINVX2829BINFNKY+PrWysR2oJSjUyuRoJEYGuRuuUfs7QbEAUZLaYe5EuByHqC9SAVBsw6gTmXKHBJMLoIzIXHwhFX34U5BqK3Y0khasBqZYgyzLmajPmarNVfDs9SGm8E1rgjMbc9DVCmo/SHCmiuCeCbPl9pSDI7MlKsvi8joZVNaX8/f3RaDSNMpxyc3MJDm46hTw4OLhV459//nmeeOKJhr/rM6U6Ov3jYtj2eyriKXFDCYmhj0YyNK6rTW3ZeSyZnR+mq7bUIVeVknXbTFbK3hh0mqZT+WUZZ6OJCTvfwu+GGfg88BgaDw+r2uUIv42tbZGNRoq+/obCT+Yg19SCIOPbvQL9RYP4t7wvyfsPIJmaOPmTDQD4+XkwPmc7VZuU0mC3EYMJ+WBOs/+r2tpaZs+eDcBDzz+PXq9vtc3n4/+pPbYMeyySoXGna4B9edMSymUzg4M2Mvzl/2s8WWUl1N+NKSsDt9YHh1OyMlj1emIjeyb/N5YYG2soqbZY355TffvhNvp2s7b8L44IUUvSpZPAaCTq60W4Dh169skqK6F+P1Re3uptuKLYwDf/3cqp5+iCCLf830i7aEs5hD2SGT7oS0VxLd8UzEM+5f8kYOYW//sVcejH4q2q5XQqzf4u4//C/dAnENQX7vvHZvYcTy9h1ew9iKfcFJWQWfjICLpEerd8onZsv5JkZt79G86q2enh58+/793ZYk2p2tpaZs1ShNNnzpzZav8+UVrNmDfXI53yf9IIsPHZCa3SlspP78U3z+wmzpjJey+Mx8m1bS3kz2ZP1uZcdvyWwv3dQpjyYL82zd8skhk+egZKYeQ1j5HSbzLxOanc9OcXpwWmZFng24m/0i/YBl0ATyE+J42b11zpELa0yJ71r1O4ay4FBz25ILkvyU77ALjjwdd4tR2Ne9pkiw2xpC2nHrufb8Ox+1y2yLLMgoR7KMvPY2nvuXQbOqLRHJIks+jZzVDpxqqR6wmN9W6VDS2xZ1CYffVebYFVb33o9XoGDx7MunXrGl6TJIl169adVs53KiNHjjxtPMDatWubHe/k5ISnp+dpj87A0O7dKBlUgIQEKCe2JYMKGNEzDo1GY9PHiJ5xqi2nPLQevkR8s5ZeOXVpnGcG5uv+7pVbQOxffxP0/Mvovb3Pi9/G1rZonZ0JvPceuv3xBx4XTkCQBYqPelD41REmpHyNs9PZ4u4yVXmFVB12QgD8b7+FyC8XnfN/pdVq0Wq1Dv/bdBZbhveIQxTFhodGoyGud38AEg/FIwjCae83PFAOcE2+14JH14gofCYaTrPHZ6KBrhFRbZ5TtcWx7anfFi1uS3gkRV8uQDAacRs6FLdhwxAE4dwPlP50LRp7xsPD14XxN/dAqDvLE0QYf1MPPHxd2jRfex8OYY9Gi3DZm3hoCxnv+RkCZsUWzIz3nIuHthDhsjeUcfb+XaY8ieDihZB3AGHvNzazp2uUD55jgpDqTmQkZDzHBNE1yqf187Vx+zUbjQjC2bOWJ9x2L5pW/p/q/bstv0uotyuzp/dFU2eXRhCYNb0vod6urZonIDIa39BwzEYjKXt2tPn/dDZ7ugxQGoBkHCnCWGO27DaSsgGhNBOcvRB6TUUQBPqHxHB56H+QZcWWeg2cAaExNj8eDAh1HFtaZM/45/C/sAvOvrVkOlcCZvwietBl0NBO/dtY2pb2HLvPZYtGo6HbECUQdXz3jibn0Go1RPXxByDtYJFVfpuOWrrXGqyqKQXwww8/cNtttzFv3jyGDRvGBx98wNKlSzl69ChBQUHceuuthIWFNUQ5t2zZwgUXXMAbb7zBlClTWLJkCbNmzWLPnj306XNu0b7OJHQOirZU/LFU+sVF270rlmrLSSp//YL0Z98lx8uNw6H+GPQngx/OtUZ6ZRcSXFpJ5JtP4nalbVvX2/u3sact5evXk/vqKxhP5FLo5sz2bucWIR2RkkOf/76A15VXWt2+Uzmf/0/ttaXoeDJfPf8oyDK3P/k//IafcdOishLclQ6XVFS0KVOqnuNZGaSkZxITGW73LnOqLR3DnjNtMebmkXzJJci1tUQu/Aq3EY3vtDbCQttwRbGB0rxqvOzZfc/R7Dm8oqETYKkpGC9tzrk7AVqZJn+XbZ/B6ufA1Q/+swdcvG1mT3JaCcnHS+naxYuuUW1Ybzu237Xz5xC/bjXOHp5otVoqiosa3vPw82fCbfcSO3xU622yACdKq0ktqCLa37VVGVKnsnnpYrb9+D1dhwxn2tMvWNweWZZZ/NI2SvOqmXh3b2KHBLVrHaex7HY49DMMvQemvHPaW/E5qezJSmJQWDe7X0A7ki3ntCfvKAmv3cTKvBAAJo2aRO9HH7aPLTamo9iScSiepa/OxNnDkwfmfYOoaZyhmbQ7jz8/P4h3kCs3vdKCY3w77OloOITQeT1z5szh7bffJicnhwEDBvDRRx8xfPhwAMaPH090dDQLFy5sGL9s2TL+97//kZqaSmxsLG+99RaTJ09u0bo6W1BKxTEp/exFsj9cBiiJUUVuztTotDgZTfhWGhoS30MfnYHXA6/azc7zEam6moK5czmwbAn7IgLOOf6SqTPod9NtNrBMxZIsuvkaCowGBoV3YcK7H53+pgWDUioq7SV39myKFn2Ny6BBRC3+9pxZIIC6DVsbyQxpW6AiF9yDIGqUzUrkWozZCJ+NgoJjMPJhuPR1e1vUctq4/R7fu5Of33gFgBkvzCK8V2+yjhyioqQYd28fwnr2pqUle45KQUYai556CI1WywOfL8bJ1fK+vfXnJPb8mU63IYFcereFuvBVFsK73UEywn0bIcTCpYHnKbIs89UDd1NcnIszYVx0dDsxP/+MU5cYe5umUodkNvPZvTdjqCjnupfeILxXY5+qqTax4MmNSJLMTa+MwDuobaW5nRGHEjp/+OGHSUtLo6amhu3btzcEpAD++eef0wJSADNmzCAhIYGamhoOHjzY4oCUioqt0IZGNiwLgF+lgdCSCvxOCUidOU7FNoguLgQ+/jjRD95w7sGAd0CH7/dwXtJ9mJIdlZSSiGw229kaFZWmMeXnU7zkBwD8H3ywZQEpFesjaiBmLPS9Rnl2xECHRgeXKlUEbJ8LBYn2tcfKVJWVsmaucoNh0OQriezTD1HUENG7Hz1HX0BE734dPiAF4B8RhV94JGaTieRdjbuQW4IuAwIBSDtQiMlooeNj/A9KQCqkvxqQsiApe3dRXJwLaOhaa0KuqSH72WeRTSZ7m6ZSh6jR0GWQogOZtGtrk2OcXLSExnkDkHqgwFamdSrUqzEVlTbgOvlWtG7QWFCqHhmtmzJOxT4EampxrjVBc8mgsoxzrRGfwhMtntNkMvH777/z+++/Y1JPGOxK35tuR5BlynQaMv9YZW9zVDo4lvJtSTKTcSieI5s3kHEonvwFXyHX1ODcvx9uo+1TcqTSgYm9GGIngmSCP/9rb2ushizLrPviUypLivENi2DMDZY9d3K0Y3fciNEAJGzdaJX5A6M8cPdxwlhjJvNIcfsnlGXYW9fqfpB6XmspJLOZf75ZAIDGaSBDe+xD1EkYDhygYP58O1vXMbCVb9frSiXt2t5sl7/ovoquVGq8GpRqC2pQSkWlDQg6PUEP3VL3V9NK50EP3YKga30HJxXLIBk09MquOzCceQCp+7tXdiGSoeV3XiVJYufOnezcuRNJkixlqkobcPPzI9TdG4CDK3+2rzEqHR5L+Hbi9i18/tBdLH11Jqs+epulr87kp+3ryfFyI0DNklJpK5fOAlELiX9C4l/2tsYqHN30D8e2b0bUaJj88JPo9E4Wnd/Rjt1xI8YAkLp/L4bKCovPL4gCMXWC58n78ts/YdZuyDsMWmfoc03751MB4OA/f1GcnQGCMwExE/C77kmCBytdJws++ZTqg4fsbKHjYyvfju4/CK1OT2luDgUZaU2P6acEpbKTSjFUGq1mS2dFDUqpqLQRzztnEvbMrWjdTr/Q0LoJhD1zK553zrSTZSoA2p6jCC6tZFBaLs5npK87G00MSssluLQSbc+WZy9oNBrGjx/P+PHj0TQhdKhiW3pNuASAlLwTmKurT76h08FLLykPnc5O1ql0JNrr24nbt7DivVlUFJ1+h9SgFdkTFUy289k6gTaBug2r1OMfC8PuU5b/fF7RmnJ0WrH9lhcWsG7BXABGXH09QV0s32zD0Y7d9SV8ktl6JXxd64JSKfvzkcztvFjf87Xy3OtKmwrud2aMBgNbli0GQOs8nC4Dw6H/DXheeiEeEdVgNpP99NNIBoOdLXVsbOXbOmdnIvsqnZ+Td25rcoxXgAs+IW7Ikkz64UKr2dJZsYnQuS1Rhc5VbI1srKVq1deYstPRhkbiOvlWNUPKAZDNZpLGjcZUWIKM0IQYvYzWz5tu/25GcICTVJXWU2uo5rNbrsEkClw+5Wq633qHvU1SOQ+RJDOfP3RXo4DUqXj4+XP3nC87hSaOih2oLoGPB0FVIUx6E0bcb2+LLIIsSSyf9SLpB/YR3C2OG159u8nOVp2Rrcu/Z8uyxXQZNJSrnn3J4vNLZomvnt2MocLIlY8NILyHb9smqqlQBM5rK+D23yF6jGUNPU/Z+uP3bFm6GEHjhd7jNq55bjjBMV5QWYDpvRGk/ChiMmjwufUWgmeqN7kdgQN/r2HNvI8I6tKNm2d/0OSY+iYDsUODmHhXb9sa6KA4lNC5ikpnRtDpcbvybrweeBW3K+9WA1IOgqDREPTSq4DQjBi9QNBLr6oBqQ6M3tmFqACljfLhdWvsbI3K+UrWkUNnDUiBkg2SdUQtxVBpIy7ecOH/lOV/Zimd0DoB+9b8TvqBfWj1Tlz20BPnTUAKzijhq7B8CZ+oEYnpr5QTHd/bjhK+w78oASnfLhA12jLGnedUlhSzc8VPAGidx+Dm5UpQVN3Fups/2ms/JmRYCQDFX39D5bamM3NUbEuXQUNBEMg9nkRZQdM+Va8rlX6oEHN7MxTPM9SglIqKSqfFc+JEwj76EG1Q0Gmva4ODCfvoQzwnTmzVfLIsYzAYMBgMzQodqtiWPpdfCUBGZQk1hXUXapIEhw4pDwfQD1FxfNrj2xUlLRMSbuk4QN2GVRoz6DYI6gOGUiUw5ci0YPstys7k38ULARh30+34hoZbzRxHPHb7hUfgHxmNZDaRtMs6QYcudSV8x/flI0tt/N576gTOB94Cqi6eRdi6/DuMhmpcvSMQdXFE9/NHEE/5bbtfhvuUa/HuVglA9nPPYS4rs5O1jo0tfdvN24fQuJ4AJO9uuuw2qIsXzu46aqpM5CSVWtWezoYalFJRUenUeE6cSLe/1xG5aBGh77xD5KJFdFv3V6sDUgBGo5E33niDN954A6OxA+h6nAfEXHoZzhIYNRqOfLtQebG6Gvr0UR6nak2pqDRDe3zbzdOrReMOb1jHiaSElp04q9vwecOZHRslydz0QFEDk2Yry7sWQK4DZ96dY/uVzGb++OQ9TLU1RPYdwICJU6xqjqMeu7vXZUsds1IXvogevuicNVSW1pKb2oagRn4CZGwDQQMDbrS8gechhVkZxK/7EwCdyzgEQWjIaDuNS2cRdIEnOncTppxccl9/3caWdgxs7dvdhtZ14WtGV0oUBaL6+AGQckDtwtca1KCUiopKp0fQaHAbPgyvy6fgNnyYWrLXidBotHSN6grA0W2b7WyNyvmIT4UBvdHUuMtnPXWvp+7fw3f/fZJvn3+M+HWrqTWowabznaY6Nn7+0F0kbt/S9AdixkHPK0CWYPXzzW9zDs72X5aSk3QMJ1c3Jj3wGIJ4fl6OxI1UglJpB/ZRXVFu8fk1OrGhnKhNJXx767Kk4i4Fj2ALWnb+svG7RciSRHivwdQYgtDqRcK7+zQe6OyJOGMeYSNKQJAp/XUFZX+qMgX2ptuQ4QBkHj7QbOfMep9LjVeDUq3h/DwKqKioqLQBnU7HCy+8wAsvvIBO7YjlMPS99gYATpgMVKSm2NkalY5Ie3y7OCUZsygopS1nBgnq/o7LLqBblzg0Oh15KcmsnT+HefffxroFn1GQnmqhb6HSkWiuY2NFUQEr3pvVfGDqktdA4wQpGyBhlQ0stSy5x5PY9uMSAC668348/JrIErEwjnrs9g0NJyAqBslsJmnnVquso76EL3lffuvKm0y1sO97ZXngLVaw7Pwj88hBkndtQxBFgrpeCkBkLz+0+mZulEaPxmXqffj1VIIfOS++iDEvz1bmdghs7ds+IWF1nTPNpOzd1eSYyF6+iBqB0rxqinMqrW5TZ0ENSqmoqKi0EEEQ0Gg0aDQaBFVbwWEIHTocT0QkUeTg11/Z2xyVDkhbfbu6opw1G/7ErNHgaqjFyXh66ZWz0cSgtFy65Zdy8bTrue+zRVxw8514B4dQW13Fvj9/Z9HTD/P9i89wZON6TLW1lv5qKg6IJJn5e+H8s45Zv2h+06V8vjEw8iFl+c//gqnGChZaB2NtDavmvItkNhM3Ygw9xoy3yXod+dgd11DCt8kq80f29kWjEynLr6YwqxUXyMdWQ1UBuAdBbOvlDlROR5ZlNny7AIC+F04kN00LQHS/cwRlJ/yPgAnhOPnUYi4tJeeFFx1GF80RsIdvd63Llkra1bSulN5FS1icNwCp8Z2jKYUtUINSKioqKiodGkEQiO3VD4CEA3vtbI3K+YLZZOS392ZTWlKEi9HEyORsLjySxvCkLAak5TI8KYsJR9IJLqtCGxyM65DBuHh4MuSK6dz5/jyu+e//ETt8FIIokp1wmFVz3mXeg7ez4dsFFOfm2PvrqViRdndsHPuEEiwoToFtn1nBQuuw6fuvKcrKwM3bh4vvftDhAkT2oD4olXZgH9Xllhez1jtriezlC8Dxva3IstnztfI84EbQaC1u1/lCvWbc+oXzyUk6hlbvRL+Lr6YgowJBgOi+fmefQOeMcM18wkZWIIgyFRs2ULJsmW2MV2mSel2plL27MDWjY1UfbExVdaVajBqUUlFRUWkhZrOZNWvWsGbNGszmZsRoVexCv5tuA6BAkCjcpwamVFpHa31blmX++uIzMg7Fo9VoGXz8BE4mMwLgV2kgtKQCv0pDw0V30MznT9OyE0SRqH4DmPrETO795CtGXXsT7n7+GMrL2PXbTyx4/lGWjxtGYlgQkrqv6XS0u2Ojkwdc/LKy/O87UJ5rGcOsSPrBePas+hWAifc/gouHp83W7cjHbt/QMAKiuyBLEok7rFvCd3xfC3WlSrMgeZ2yrJbutZlTNeP2rv4NAFGjIf5vpewruKsXLh76c08U0g+nq54hoJ8StMydPZva9HSr2d2RsIdvB3eJxc3HF6OhmoxD8U2OqdeVOpFciqHScZorODJqUEpFRUWlhZjNZrZs2cKWLVsc7sT2fMe3WywBWicQBOJ/Wmpvc1Q6GK317d0rf+bg+jUIgsCApAw8DbV4Tb8KbfDpYsDaoCDCPvzgrN0+3X39GHn1Ddzz8Zdc+fQLxAwYDIJAWnAAK0YP4fOnH2Lz0sWUF6p3XDsL7t5NCBu3dly/6yF0ENSWw9+vWsgy61BTVcnqz94HoN9Fk+gycKhN1+/ox+6GLnzbrFPCF93PH0EUKMyqpCS36twf2PedIqYfNQb8ulrFps5Oc5pxtdVVxK+Zh7k2kZh+AS2fcPRj+F7cG9eAGuRqA9nPPYfsgNuyrbGHbwui2CB43pwWnKe/C76hbsiSTNpBtYSvJaj5mCoqKiotRKPRMGrUqIZlFcei+5AR5G/bQFJqEuOffFLJUnEgUVsVx6U1vp20azsbFivaZT3zSggsq8L7uusIfvklkCSqdu3GlJ+PNiAA1yGDW9ztU9Ro6DZkON2GDKc0M4P4V/7HgYoSKkqK2fbj92z/6Qe6DB5G/0suI7rfwPO2Y1lnwM3HD0EUkSWp2TFOrq6E9ezd/CSiCJe9CV9eAnsXw9C7IXSgFaxtAzodPPVUw/L6Lz6hvCAfr6BgLrj1Lpub4+jH7riRY9i05GvSD+6nqqwUV08vi87v7KYjLM6bzKPFHN+Xz6BLo5ofLEmwt650b5CaJdUWWqIZZ6z6h6i+N7V8UlGDcNVcQpPHcfw3HdV79lK4YAH+99zTTms7Nvby7a5DRrB/7R8k797BxXdJTR6Po/v5U5RdSeqBAroPV7tXngs1KKWioqLSQjQaDRPPkvGgYl/63nI7W7b8Q5lWJPOSi4i49DJ7m6TSQWipb+elHmfVR2+DLBNVZSQquwDXkSMI/t9/lSCoRoPb8GHttscrPIKxny9ilMlI4o6t7F+7iszDSuem5F3b8AoMot/Fl9Fn/MW4enm3e30qtiM3JZmfZr901oAUQE1VFZuXfMOYG25rXnspYhj0nQEHlsEfz8Gdq5UukPZGr4e33wYgcccWDm1YB4LAZQ8+gd7ZxebmOPqx2yc4lMCYruSlJJO0cyv9Lppk8XV0HRjQsqBU6r9Qkg5OntBzqsXtOB9oiWYccjmVRcfxDenX8on9uqK7+jWCsmZyYocP+R9+hPvYsTj36NE+gzsw9vLtiN790Lu4UFlcRE5yIiGx3RuNiennz57VaaQfKsJsltBo1BtJZ0P9dVRUVFRUOgWu/gGEuis6JQdX/GRna1Q6GxXFRfz81qsYawwEyiI9E9Nxiokh/IMPEKyUkafR6ugxahzXvfQGt7/7GYMum4qTqxulebls/G4h8x64nd8/epvMwwcbdWSqF9g9snkDGYfim+7kpmJT0g/uZ+krz1FVWkJAVAwT73sEd9/Tu295+PnTc+wEAHb8upx1X3569gDWxS+D1gUytsEhx9rvVZYUs3b+HACGTr2asB697GyR49J95FgAEqzUhS9mQAAIkJtSRkXxWTo21guc950Beler2NLZyU1JbtG4lmrLncbgO/C6ZDTuYdVgMpH99DNIatdWm6PV6YgeMARovoQvMNoTFw8dtdUmTiSW2NC6jomaKaWioqLSQmRZRqq7OBBFUe0c5ID0HHcRmat/4XhOJtKxY4jduillLioqZ+Fcvm2sMfDr269RUViAh0ZH/33H0Hl5ETH3MzReli21AZQSmnoh28hIEEX8wiOYcPu9jLnhVhK2bGT/X3+Qk3SMo5s3cHTzBvzCI+l38WX0GjeBjIPx/L1w/ml36919/bnw9nuJHT7K8vaqnJOErRtZ9fG7SGYTEb36cuXT/8PJ1Y3e4y9SMitKinH39iGsZ29EUUN4j96s/eIT9q/9g5qqKiY9+DgabROn7V7hMOZx+GcWrHkR4i6zfzBBkpDT0lizaB7V5WUEREYzakYrSpUsTEc4dseNGMPG7xaScTDeKiV8bl5OBMd4kXO8lJT9+fQdH954UFURHFmpLKule62mpqqSrT8uaRD0Pxct1ZY7DUFAmPYJIcdHcPwnMzWJieR/+CFBTz/d+rk6Afb07W5DR3Bs60aSdm1n7I23N3pfFAWi+vhxdGsOqfGFhPfwtZltHRH1TF1FRUWlhRiNRl577TVee+01jM20gVWxLz2vuxGtJGHQaki8eAJUV9vbJJUOwNl8W5YkVn/yPjnJiThpdQw6mIROoyHs44/QR52lDKY9VFdDTIzyOGMb1jk502fCJdz0+nvcPPsD+l50KVonJwoz01m/cB6f3XtzkwK7FUUFrHhvFonbt1jHZpVm2fPHb6z88C0ks4m44aOZPvNVnFzdABBFDRG9+9Fz9AVE9O6HKCq6KP0unsSUR55G1Gg4unkDK959HWNtMxkuo/4DnuFQlglbPrbV12qe6moOXjSO40cOotFquezhJ9HaUd+vIxy7vYOCCeoSiyxLVvPRLgMVYe3kvc104TuwDMw1ENwXQgZYxYbOiCSZiV/3J18+ei+7V/6MLElozrG9u/v5n10z7mx4BKO95n1ChpUAULTgK6p27mzbXB0ce/p2zIDBiBoNRVkZFGVnNTmmvgtfyoGCRtnMKqejBqVUVFRUVDoNOldXonwCATgcHWFna1Q6A5uXLubY9s2IosjAo6m41ZoIefll3Ia1XzuqvQR16cbEe//D/XO/5sI778c3LALJZDrrZ9Yvmq+W8tkIWZbZtORr1i+cB7LMgEunMOWxZ1ocoOkxahzTnn4Brd6J43t28tOsl6ipaqJ7mt4VJtZ14Nv0PpRmWvBbtJ7S/DzWD1AuuEdddS0BUTF2taejEDdiNADHtm20yvxdBihBqezEEqorzij5kuWTpXsDb3UMbbIOQObRQyye+QRr539MdVkpPqHhTH/uZab85+yZSxfedm9DALpN9L4Kj0lT8YqpBFkm+9nnMFdUtn0+lVbj7OZORG9FEyx517Ymx0T08kXUCpTlV7es8+V5jBqUUlFRUWkhOp2O5557jueeew6d2tXNYekzURE4Tw/woba01M7WqHQEmvPtw//+zfaffwCgT0Y+vpUG/O65G++rp9vL1CZxcnVj4KWXc9GdD5xzbHlhAVlHDtnAqvMbyWxmzbyP2P7zUgBGX3szF95xf6svRGMGDuHqma+gd3El88hBlr76PFVlTezXek+HyJFgqoa/XrbAN2gbkmRm9ZefYtRpCcsvYsilV9jNlno6yrG7+8gxAGQcOkhlW/SGzoFXgAv+Ee7Ikkxq/BlC3Nl7IfcgaJyg3wyLr7uzUVaQz8oP3+KHl54lLyUZJ1c3xt96N7e9PYeYgUOIHT6KqU/MbKQZh+DB8OkPWaaMevLbBI1zQ+dmwpidTe4bs9s/ZwfD3r7ddchwAJJ2Nh2U0jtrCYtTyjRTzvQ5ldNQg1IqKioqLUQQBJydnXF2dnZITQoVhS4TL8O51ohJq+Hw0u/sbY5KB6Ap3848eog18z4CoFtpNeEFJbhffBEBjz9uT1PPSmVpyy5k2ySwq9JijDUGfn33dQ6uX4sgiFxy738YcfX1bT5uhPfsw7UvzsLF04u8lGR+eOlZygvPuMARBJg0GxCUMqz07e3/Im1gz++/knnsCDqjiUk79iE6gKZfRzl2ewUGE9y1roRvR9Piye2lPlvq+JklfPVZUr2mgksbtI7OE4w1BrYu/56vHr+fhC3/giDQ76JJ3PnBPAZPmXaa7lvs8FHc88mXXPviLMbe9DA69xm4+d/D8Kss1C3OxQfNtZ8QOrwEkCld/iPlf/9tmbk7CPb27a6DlaBUduLRZgPJ9SV8jQLBKqdh/yOFioqKioqKBRE1GrpmKyfcR610Yq/SuSnJzWHFO69jNpkIMUFsajZOvXoS9tZbCA5wkd0cLRXObZPArkqLqK74//buOzyqKn3g+PfOTHrvjQQSQguEDqFLExEXRERFUbCsrIr+FrGzlsVC0dW19wKsogIqxYIiAtJ7C4SSEAikF9LblPv7YyAIBDIJyZTwfp5nHiYzZ+59Q865k3lzzntKWPLycxzbuQ2dkzNjHptB52HXXfFxQ2JimTBzLl4BQRRknOKbF57kdOYFdUzCu0G3MwXFVz5lLphvRXlpx9nwjTm5MXjvQXzLpKZffbU9swvfkS1Nswvf2bpSaUkFVFeeWepbXQaJ35nvd5MC57VRVZXDm9fzxfQH2bT4KwzVVUS078ids9/k2ikP4+7jW+vrztaMU7Tt0DpFEhkXiJPzFSzbu1Drobj/7W7825uX7mU++yyGgoLGO764LO/AIEJi2oCqkrJzW61tWnUOACArpYjKUvusaWcP7Pc3KyGEsDNGo5G1a9eydu1ajEapyWLP4lOOA5Cpr6T0ZJptgxF2769ju7ykmB/mzqSipBhfjY74pGM4BQcT+cEHaNzte4v0iA4dL14ucgFP/4CGF9gVl1Wcl8u3LzxFxpEkXDw8uPnZl4jt1afRju8f3oIJL87FLyyC4twcvnnhKXKOHzu/0dDnwdnLvBxr3zeNdu66GA16fn7vDYwGAzGduxN/7KTVzl0XR3rvbtfHvITv1MGmWcLnH+aBb4g7JoPKicR884MHl0FVMfi1glYDG/2cji7n+DEWzXyGH9+cS0leLl4BQfxt2lPc9u85hES3tugYqXvNs2Siu1z++twgw2cSdE0QLj56jAWnyXrhhaumqLY9jO3YM0v4LlVXyjvAjYAID1QVThzIr/N4qr6asmWfUvTB85Qt+xRVX13na5oDSUoJIYSF7OHNT1gmIv803mWVmDQK+xd8YetwhJ07O7bX/PEHy96YQ0H6Sdx0TnTfn4yTswst3n8fp5AQW4dZJ41Gy9C7p1y2jadfAAr2u4TJUeWfSuPr558g/1Qanv4BTPj3XFq0b/zkn3dgMBNmziWoVQzlRYUsevEZ0g8nnWvgFQKDHjff/30mVJU0egy12bzkG3KPH8PVy5sR9/zDrnqYI713ewcFExbbrsl24VMU5eIlfLv+Z/63251gxzNBra28uIhVH7/L/57+J6eSEtE5u9Dvlonc898PaNd3oMXLxUpPV5KbVgLKuaVcjcrZHc0tnxDetxg0KiWrfqdo6bLGP48dsoexffYPDyf276G6svbZoZYu4Sv+fBbJfbqQ9tTrZLy1mLSnXie5TxeKP5/VuEHbIbnyCCGEhTQaDb169aJXr152USdDXIJOBw89RFsnNwCO7Ntp44CEvTs7tp2L8jiZuAedVkv3g8dwNRgJf3Uubp2sPLPoTB/moYfM9+vhUgV23X180Wg0ZKUcYduyJY0Z7VUv40gS3zz/JKX5efiHt+D2l14jMKpVk53P3ceXW5+fRXi7OKrKyljyyrMc3/OX61yfB8EvGkqzYP0bTRbHWRlHkti2dDEA1/79ITwCAhvcf5uCo713tz1T8PxwU+3Cd2YJ3/HEfAyZRyFtEyga6DqxSc7naIwGAzt/Wsbn/5zCvtUrQVVp128Q9/z3A/qOvx0nF9d6He9sIiI02gd3b+emCBla9MD1xmkEdTInobNffgl9enodL3J89jC2AyJb4hMSilGv58Te3bW2adXZ/H6cdiAfo6H2ZdXFn88i/dUFGMrOn+VmKFNJf3VBs09MKWozm99XXFyMj48PRUVFeHt72zocIYQQNnL6yCE+f/YxUBTunvEyAV262jokYcd2r1zBH198BED3EzmEFpYQNH06gVPut3FkDWMyGUlPOkBp4Wk8ff2I6NCRxD9WseqTd0FRuPmZmbTq0t3WYTq8lJ3b+PHNuRiqqwhr046bnnoBNy/r/P6pr6pk+RuzOb5nJxqtjhv+73Hanln+xaGf4Js7zLupTd0K/tFNE0NlJQueeoTCrEw6DBzCqIcfa5LzXE2K83L4ZOq9oCj844P5ePr5N+rxVVVlwYxNlJ6uYlTf/USnPg9troOJixr1PI4odc9O1s7/hIKMUwAEt2rNkLvvp0WHTg0+5g+v7yLjaCHdR7ak71jLlvs1iFGP+vEwTnx1ioo8F9x79yZq3hd2XQfRHqj6asp/XoAhIw1deBTuoyahONUvebh2wafs/GkpcQOHcH0t10DVpPLFUxuoKNEzZlpXItufP6ZVfTXJfbqcSUjVNgNPReehELtlb71jszVLczPSS4UQQjRLfm3bE6Q1v3nv+/p/No5G2LPUPTtZM+8TANrnlxBaWILP2LEE3P93G0fWcGcL7Hbofw2RHTuj0WiJH3YdnYaMAFXlp7dfoygny9ZhOrTENatY9p+XMVRXEdO9F7c8+4rVElIATi6ujH3iWdr2GYDJaODHN19l/x+/mZ9sNwqirwFjFax6rsliWPfl5xRmZeIZEMjQe/7RZOe5mngHBhPWtj2oKke3bmz045+3hC/xzPLO7pMa/TyOpCAjnR/mzuT72S9QkHEKN28frp3yCBNnv3FFCal9a06ScbQQgF2/nuDgxoxGirgWWieU8Z8Q3q8cRWeifNs2ChYsaLrzNQONtVwutqd5Cd+xXdsxXbiMUFVRqotp2cb8++ixlZupXPEeZQv+TfFbj1D44l1k3T0YQxnUnpAyP24og/Kfm+/P0/ZzaoUQQojGpKqQZ54u365HArnbN3A0+RDXmEwOsXRDWFde2nF+fHMOqmoiqtJI9Kkc3Hr2IPTFmbbbPv4vfZjAQGikOBRFYdi9D5B7IpXsY0dZ9vosbn/x1XovR7naqarKtmVL2PD1fAA6XjOMa6c8ct528Nai1Tlxwz+fwMXdnf1//MZvH71NVVkpPUePg5Fz4MP+kLQCUtdDdOMWsT6+Zyd7V/0MwMgHpuHq4Wl+oon679WkXZ8BZB45xOHNG+g2cnSjHz+maxD71pwitTQeY1Ao2rZXvkOkI6oqL2PL99+y6+flmIwGNFot3a4fQ9+bJ+Di7nFFxy49Xcn6RUfPPaDC2q8OERXnj6dfE11zg9rhfNPzhGS8RNYOX3LfeAPP/v1xadOmac7nwM4ulzM7d406u1wOwPveGTWPq+UlGPPSMeWmY8zPwliQg6kwH2NhAS6Fp3FRoLKslD23DSaovARjhR5ThQFjtYqpWsHJtxt0mkLy7lKCPny3QXX3DBnNd+MeSUoJIYSFqqurmTNnDgBPP/00zs6ONYX2qlFeDsHBAHQ6doxNW9dTolVI/2M1kcOvtXFwwp6UFxXyw6svUV5axtZDx0jNzqdj5y60eOcdNLYc33/pw5SWgseVfTj6K52zM2Mee4Yvn55G7vFj/P7Je4ycOt12CTgHo5pMrFnwCbt/WQFA7xvHM+D2yTb9/9NotFw75RFcPDzZseJ71n35OZVlZfS/7U6UnvfC9k9h5dPwjz9B0zjb0VeUlrDyw7cA6DZyNC07dz33ZBP234ZwxPfuNgn9WbvgU9IPH6SkIA+vOnbVrK+wWB9cnSqo1HuREf4PIrVOjXp8e6eaTCSu/Z0N3yygvKgQgOhuPRk86e/4h7dolHMU5lTABUVyVBMU5VQ0XVIKIOEBfA/9RGnGQUozIP3Jp4j+9hsUB+j39dXQsa3qq8l+7+wM+guv3Qqgkv6fBeR8/CVqtQljFajGy1/jAyODSPf3JrVAxS2j6syj5/4Q6nf6EIpJT6VbEFWBEXgr+WjdndG4u6FWV1OeUvdum7rwKIu+P0ckSSkhhKgHk6n2AoXCPnkEBxPu7sWpylISly2RpJSoYaiuZtl/XqE4NxtPnTPB2fng5Ezku++g8/OzdXhNyjswmL9Ne4olLz/HwfVrCG3Tjm7X/c3WYdk9g17Pyvf/y+FNfwIweNL99LjhRhtHZaYoCoMm3oOrhycbvlnA1h++paq8lKG3PI2yfzFkJ8Ku+dDz3kY53+rPPqDsdAF+4S0YeMfkRjlmU3K0927vwCDC23Yg40gSR7duovv1Yxr1+JqyLKJ1G0nSD+eYfgCRjXp0+5Z+6CBr5n9M9rFkAPzCIhg8+e/EdOvVqOepLf+raMAn2K1Rz3PxiTUoN31IWGp/ji01UpWURO777xM8bVrTntdGGjK2y39eUOdyOUygL7y4xpPGSUXjoqB11aFxc0Lr7orG043WLh6kl5nIDQ8kdOxQtP6BaP2D0fiHog0KQ+MfzPEFx0lLOo363Ge0vq5lzTEtrSnlPqr5LrOVpJQQQljIycmJ6dOn19wXjiFu0FBO/bacY5knMeqr0TpYkUjR+FRV5beP3ibjSBLOOid67U+md0AgEW+/hWf79rYOzyqiOnVh4MS7+fPLz1k7/xOCW8YQ0T7O1mHZreqKcpa9Pou0/XvQaHWMnPooHfpfY+uwzqMoCgk33YqLhyerP/+APb/+RFV5OdcNfBrtqmfgj5eh4zhw872i8xzauI7Dm/5E0Wi4fuqjdr/801Hfu9v1HUDGkSSObNnQ6Ekp9iwkxnUzSRXDOXaomkEmFUXj+LMla9vgQXMmO1SSn8efX33BoY3rAHB2c6fv+NvpNvJvaHWN3y+O7ck772tFA4Mntm/aWVJn+UaiGzeX0PRppG/0J//jj/EYOBAMRgy5ueiCgnDv2QNF2zgzJ22loWNbn3q07kZAwHVxeI+7E01gGNrAcDT+YSiXOE9wVSWb/j6Rsuoq9GPuxq9VzEVtWnUpIy3pNMf35dH9L0kpxcmZkKl3nVk2eGFiyjzdLmTqXQ5X5Lw+JCklhBAWUhRFdvV0QO0nTGTNL0up1GpI+X4JbW+7w9YhCRvb+v23JG1Yi6IodD18Aq9qA6H/fgG/ESNsHZpV9fzbTWQlH+HIlg2s+O9s7pzzVqPv9NUclBWe5vs5/yYnNQUnF1fGPP4vWnXuZuuwLqnriFG4eHiw8r03SFq/hqqyXoz2b4eu4DCsexVGNnxr8ZKCPFZ/9gEACTfdRlhsu8YKu8k46nt3mz79WTP/E9IPNfISPpMJdn9JpPNJnJxMlBdVk328mNAYn8Y5vo0c3bqJP+Z9TGnBuWSQp38gg+68h8KsDLYtW4KhqgoUhfihIxhw2124+/g2SSz6KiOHNmUCMHRye7z93fAJdrNOQuqsLhPwHvETJafWU3zCnbRJk+EvRbh1ISGE/GsG3g78vlffsa3qqyl691my5y3n0rOkzvEYej2u19xk0bGdXFxp2bkbKTu2kLx9C8G1JaU6B/LnN0fIOlZERWk1bp7nkkxn61dlv/e/M7O4zHQeCiFT7zqvvlVzJBVfhRBCNGtOHh60DDDXNzmw6hcbRyNs7fDm9Wxc9CUAnTILCCytwG/SXfhNmGDjyKxPURSue/CfBLSIoqzwNCv+OwejQW/rsOxKYVYm3zz/JDmpKbh5+3DrC7PtOiF1Vof+13Dj48+ic3Lm2K7tfJ/RnWqjFrZ9BHmWzRK4kKqq/Pbh21SWlRISE0ufcbc1ctTir7z8A2tmLx7d0oi78J3YAKdT0bq40arzmV34duc23vFt4OjWTSx/Y9Z5CSmA0oI8fn77NTYt+gpDVRUR7Tty5+w3GTHlkSZLSAEc2ZZFVbkB70BX2ieEEdHOz7oJKTBvMPC3N/Fo6QKo5yWkAAzZ2aT/3z8p/u0368ZlC6pK6bfvkDq4O5kfrcBUpYCiclHRr3MvQOdBvZfLxfZMACB5x5Zan/fydyWghSeqCicS8y963vveGcRu2UvU3McI/+ctRM19jNgte5t9QgokKSWEEBYzGo1s3LiRjRs3Yrxwy1dh1zqONNfLSSvMp7q42MbRCFvJPHqYle/9F4CY0ioiswvwuGYQgY8/ftWObWdXN8Y89i+c3dzJOHyQtQs+s3VIdiM7NYWvn3+CwuxMfIJDuP3FVwlt7Ti7WMV078W4GTNxdnPjZOopFuUMoLwa+PVfDTre3lW/cHzvLnROzlw/9TGb7DbYEI783t22j3nHxMObNzTeQXedKfAcP56Y7mEApOzJRVUv9QHdvplMRv6Y9/Fl2ygaDaMeeZzb/j2HkOjWTRqPqqrsX3sKgPjBLWy6LFJ19SN3n+flWpA983lUBxsXZ1kytiv/XEra9T05+cL7VOUb0TirBN/Sh/B/nk2qX9jvG75cLqZHbxRFQ+7xYxTn5tTaJrqzecbj8X15tT6vODnjcePf8XnwRTxu/HuzXrL3V5KUEkIICxmNRlatWsWqVasc7hfbq13M6LG4GU0YtBoOLlxQ9wtEs1Ocl8PS117CoK8mxKTQLuUULm3aEPH665jgqh7b/uERjHrkMQD2/PojB9attnFEtpeWuJdFM5+mvKiQoJbR3P7Sf/ALi7B1WPUWGRfPrc/PxtXLm+xCE4vSulBycA0c/b1exzmdmc66L80Jy4F3TCagheOUxnbk9+62Cf1AUcg4kkRxXiPMZqo4DQeXme93v4uojv5onTQU51aQn152+dfaqfSkAxfNkLqQajLh6edvlV0yM5MLyU8vQ+ekoX3fsCY/3+WUb9+GobCCyxX0NuQXUb59mzXDajSXG9v6Q9vJuH0QqVOepux4OYpGxX9wLLG/riTgpS/weWAmEU9OQudx/v+NzkMh4slJDZqd5O7tQ3i7DsClZ0u1ijcnpdIOFmA0ONYGDE1JklJCCGEhjUZD165d6dq1KxqNXD7tlk4Hkyebb2f+kq/R6Yhp0QqApDNFTsXVo7qinKVzX6S8qBAfrRNdDqSgCwigxQcfoPX0tL+xXUsfbmqteyTQ5+bbAfj9k/fITk2xynnt0eHN6/lu1gtUV1QQGRfPbf+eg4ev4+7IGBITy4R/z8XTP4D8Kne+OdGFwqXPgtGypZomo5Ff3nsDQ1UVUZ06023k6Mu/wAb993LsbnzXg6d/AC3adwTg6NZGWMK3fwkYqyC4I4R3x9lVR1ScuY7csd21z+ywd6WFpxu13ZXatyYdgLYJobh62LawviFpk0XtKjc4ZmmD2sa2MTuNnIdvJOXmuyjanQsoeHcOJGbxPEI+XIE2rFXN65tiuVxsrz4ApFwiKRXc0gs3b2f0lUYyjhQ2+DzNjWNdmYUQwoZ0Oh1jx45l7Nix6OzgF21xCS4uMG+e+ebiUvNw/M3mmkGZVeWUZaTbJjZhdSaTkZ/efo3ctOO46pzovj8ZJ50TLd59B+cW5pkvdje2L9GHm1q/8bcT3a0nBn01y1+fRUXJ1bfUddcvK/jxrVcxGQ20TejPuBkv4uLuYeuwrlhAi0gmzHwV35AQivWufLPbm9xf3rDotduXf0fm0cM4u7lz3YPTUOpK7Nio/16K3Y3vemrbpz9gTpZesV1nZgp3n2SuOQTEdDtTV2qPY9aV8rQwYWxpuytRerqq5v8xfnCLJj9fXXRuls3Eyfl0MSfuvofilStRq6ubOKrG89exra0up+DF+0gZMYL834+gGhXcI11p9d6LRCxaj3PHPrUeo7GXy8X2NJ/n5MFEKkpLLj6fRqFVpwAAUvdffobf1USSUkIIIa4KEQMH4WMCVVHYt+ALW4cjrOTPL7/g2K7taDUauiel4qY3EDZrFu7d7L9YtbUpGg2jHn4cn5BQinOz+ent1zCZHGu5U0OpqsqGbxawZt5HoKp0ve4Gbpj2JLp6bDNu73yCQ5jw4n8ICvKhzOjMooVryNi39bKvyU5NYdPirwAYes8/8A4Mtkao4i/aJPQHRSHz6OFL1qmxSMYeyNoHWmfofGvNw63iA9FoFPLTyyjMLr/ygK0stE07dM6XTyR4BQQS0aFjk8dyYH06qkklvI0vgS0uV8vJOtx79kbnZuRyBb0Vjbngd/mWLaRPe5SjQ4aS88Z/qT51yoqRNpxqNFD80XMcG5JA9sJNGKsUnP00tHh2ClG/7sRt2C1Wjcc3NIzAyJaoJhOpu3fU2qbVX+pKOWott8YmSSkhhBDNi6pCWZn5dsGbfWw78y+lR/bU/ouCaF72/b6SnT8tBSD+RDa+5VUETp2Kz99usG1gdblMH25qrp6e3PjYv9A5u3Bi3242LfrKque3BpPJyMkD+0jauI6TB/Zh0Ffz20dvs/WHRQD0v/VOht7zABqN1saRNj4PXz9unfU+Yd4GKo06lsx9mRP79tTa1lBdzS/vvo7JaKRN737EDRpq2Uls2H+bI08/f1qcSagc2XIFBc93nylw3mE0uPvXPOzq4UREO1/A8WZLGfR6fnrrNQx1zO4ZMnlKk49no97EgfXmWdj2MEsKQIkZQMiAs9937QW9w/sWEjs6h8COJehcjRjz88n/+GNSrh1B2v1TKFm9GtVgsGrcFlFVyld8zInhXUn/7xKqi0DrBqH3Xk/M2p143flo3bM6m8jZJXzJ2zfX+nxkB3+0Og0l+ZUUZDpmLbfGJkkpIYSwUHV1NXPmzGHOnDlUO9D05qtOeTl4eppv5ef/1bfLHZNAVclTDeQn7rdRgMIaTuzfw+rPPwCg7ekywguK8R41isCHp17U1u7G9mX6sDUEtYxmxD8eAWDrD4s4us2yuiSO4OjWTXwy9T4WvTiDn99+jUUvzuDdeyaQuGYViqLh2imP0OfmCVYpiGwrrt4+3PL4E7T0OI3eoPLDnBdqfsZ/Tdj98v5/yT+VhruPL8Pvn2r5/4mN+++F7G58N0C7s7vwNTQppa+AfYvN97vdddHTMd3MM+AcKSmlr65i2X9eJmXHFrROTvS+6VY8/QPPa+MVEMiY6TNok9CvyeNJ3pVDRYkeD18XorsG1v0Ca9Bo8X5wLhH9Cy9ayqdzNxHRvxDvae/idPfnBI0fROzYAiIGFOARWgmqStn69Zya+jDJQ4eS+8676LOybPSNnK96+y+cuqkXRx9/g7cTc/j0dB5e13eh9Zr1+D35BoqLq03ja31mCd/xPbtqTZg6uWiJaGdeTnqpXfiuNo63sFoIIWyosrLS1iGIK+AX15EgjRO5qoF9Xy9gyCuv2Tok0QQKMk6x4r+zMRmNtKg20TotC9cunQmb9colP1jL2D5fhwGDyUo5yq6fl7Hy/f/iHxFJQITj7LhWm6NbN7H8jVkXPW7Umz809Bw9js7DrrN2WDbh1G4YY4d/wc9/JHO0JJAVb8yhy4hRJG/fctFOZp2GDMfd28dGkTYORx/fbRL68ccXH5GVfISinGx8gkPqd4CDy6GqCHyjIPqai56O7hLIuq8Pk51aTOnpSjz9bPuhvi7VlRUsffUlTh7Yh87FhbFPPEfL+K70v3WieTe+wtN4+voR0aGj1WY87l9rXu7WaVA4Wq0dzfuIG4P3Y+D181OUp+RhqNSiczXi3joQZdTHEDfG3K7jWJTyArwPLsV732KqD2yl8Jg7hcfcMeTkkvfee+R98D6e11yD3+2349G/P4rWurNJDal7yXvxUU5vzQCTAqgo4d64DxlJ8Nw30NaxjNNaQmJi8fQPoLQgn7TEvcR073VRm+jOAaQdyOf4vnx6jGxl/SDtjCSlhBDCQk5OTjzyyCM194VjatetN7m7NnH0SBKDVbVZz4i4GlWUFPPD3JlUlZXhr+joeOgITuFhRL77LhrX2j9oydiu3aCJ95CTmsKppESW/+cVJs56A2c3d1uH1SAmk5E/5n182TaHNq5lwO13Nctle7XRXf8yf0vuzapTBhKLQtnz64+1ttu2dAmhMW2tMtukKTSH8e3h60eLuE6cPLCPI1s30mv0uPod4OzSvW53QS1Lmjx8XAiL8SEzpYhje/LoPMQ+lp/Vpqq8jO/nzCTj8EGc3dy46akXaNGhEwAajZbIjp2tHlP28WKyU4vRaBXiBkRY/fx1ihuD0v4GPE5sgtJs8AyBlv3gwmuduz/0vBd63ovz6RMEJy4hcPe3lOw+QWGKB+U5LpSuWUvpmrU4hQTgO+FOfMffjC4oqEnDNxVkUjDrYfJ/TcSk1wAKHm38aPXcK8xobf5529PYVhSF1j37sPe3n0jevrnWpFTL+ED4+ghZqUVUlFTj5mUfCTVbsaM0rhBC2DdFUQgICCAgIEASGQ4sftLdaEwmSjRwat0aW4cjrtBflxsd37ebZa+/QmFWJh46Z7olJuPk5kbkBx9c9pdmGdu10+p0/G3aU3j6+VOQcYqV77/psEVZ05MOXDQD6EIl+XmkJx2wUkR2wK8Vmv4PMzz0KE6ay+/StWb+xw5b9L65jO92fQcAcKS+u/Dlp8Dx9YACXe+4ZLNzu/BdQTH1JlZRWsKSl58l4/BBXDw8GP+vl2sSUraUeGaWVGyPYNy97TS5oNFC9ECIH2/+t67ku19LGPgYmke24jNrFS3/dTsxt6j4ty1F42xCn51P7ltvcfSaazj1wL2Ubd6MarJstz9LqVVlFL32ICnXDib3x4OY9BpcQlyIem0GUSs24dZ7iN2O7bN1pVJ2bqv12unl70pgpCeocCIx39rh2R1JSgkhhLiquIeFE+5q3hUn8YfFNo5GXIkL6wN998pzpCcdMO+0dyAFF5NK+Buv49quna1DdVgevn6Mnj4DjVbH0W2b2L78O1uH1CClhacbtV2zMWA6GUSjN13+I8FVl7CzQ21690NRNGSlHKUopx61fXZ/af43djj4XHoGVExXc1Iq40ghFaX2V3urvLiIxS/OICvlKK5e3tzy3CzC2tj+2l5RUs3RHeZEXrwdzzBrMEWBsM5w3Su4zDxAyJv/o81zQwjrX4FbYDWYVErWbibtnntJGdyP/PffxHD6Cq+jJiNl/3uZ48N6kvHZWgxlGnSeGsIevZPoP3biMfriumj2JjKuE85u7pQXFZJ59EitbVrFn9uF72onSSkhhLCQ0Whk27ZtbNu2DaPRMf9iLMziBg4BICX9BEaD3sbRiIY4Wx+ottkvRqORMhcnQp56Eq/Bg+s8loztywtv256h9/wDgA1fL+D4vt02jqh+9FWVpO7ablFbT1+/Jo7Gzrh4UtruNouaOmrCrrmMb3cfXyI7xgNweLOFBc+NBtiz0Hy/++U/yHsHuhEY6YmqQupe+/qQXHq6gEUznyH3RCruPr7c9vwsQqJb2zosAA5uzMBoMBHc0ouQVt62DqdpabQQMxjNLR/i+2ESrT76D9EPtMOvTQUanQl9ThE5b39E8oB+pN87nvJN62qdXavqqylb9ilFHzxP2bJPUc/U9UNVqVw1j7Tru5L2yldU5oHGCYJuH0brP7fj+49/nVfHyp7HtlbnVLNsL2XHllrbtOpsTkqlHSzAqG/cWWaORpJSQghhIaPRyM8//8zPP/9sd29+on7a33EnTkYTVVoNKUu/t3U4op4sqg8UG4nPnRMtOp6M7bp1Hj6STkOuRVVN/PT2axTlZNs6JIsk79jKvMceImnD2jrbegUEEtGhY9MHZWc8u4yyrJ2DJuya0/hu2+fMEj5Ld+FLXgWlWeAeCG2vr7P52dlS9rQLX3FeLotmPk3+qTQ8/QO47d9zCYxqZeuwADAZTSSuSwcgfnALu1tC1qSc3KDjTbhOW0rot7to8+GjhF7nj6tfNaoRijcd4MS9D3BsUHcK/vM0xnxzorP481kk9+lC2lOvk/HWYtKeep3kPl04PfsfZE5IIPX/5lB2wgCKit+weFr/vprAF95F435xPUN7H9uteyYAkLy99qRUcJQX7t7O6KuMpB91zKR/Y5FC50IIYSGNRkNcXFzNfWGntFoYP/7c/Vo4eXrR0jeQ5JICDvz2M23HWzZTQNiHOusDKQrlBj0Zhw5aVPTW7sa2BX3Y2hRFYdi9D5J74jjZx46y/I1ZTHjxVZycXWwdWq2KcrL444uPOHZmhpRXYBDt+13D9uVLLvmaIZOnXDVFzv8qIq4Tnp4ulJZWArV9qFbx8va0PGFnZ/3X7sb3FWiT0I/Vn31A9rFkktavBY1y+V3mdi0w/9tlAujqrnUU0y2IbStSOZlUQHWFAWc3235ULMrJYtGL/6I4NxvvoBBuee4VfENCbRrTXx3fl0/p6SpcPZ2I7Rls63Bsx90fzYAH8BvwAH6nT1Cx4n0Kl/5C0eEqqnMryf50GTlfLMWthTvlJ8rPvOjctcZQppI1f92ZxxS8ukQQPPN1nNt3uexp7X1sR3ftiUar43RmOvnpJy/awVbRKLSKD+DgxkyO78snKi7ARpHaniSlhBDCQjqdjltvvdXWYYi6uLrC4rprRXUceQPJi/9H2ulcqktLcPb0skJwojE0dn0guxvbFvZha9M5OzPmsWf48ulp5KSmsPrT97nuwWl2NTvAoNezY/l3bP1hEQZ9NRqtjp6jb6LPTbfh5OpKWGxb/pj38XlJTa+AQIZMnuKwu8tdKQ0wNOwEy4+GACrnJ6bMS2+GhKRYvrzCzvqv3Y3vK+Du7UNAZBR5acf5+d3/1Dzu6R/I0Lsv6MMlWXDkV/P97pMsOr5/mAe+Ie4UZpdzIjGfNr1CGjP8einISGfxy/+iND8P39AwbnluFt6BTbvLW33tO1PgPG5AODon2ydg7YJfS9wmzcXtrjkEJ2+haP5bFK7eQ9VphfITFdSe+D7zmEYl6t1X8Rg6xqJT2fvYdnF3J6pTZ47v3UXy9i0XJaXAvITPnJTKY+Btbezq/dSa7C+lKIQQQlhBzNibcTOYMGg0HPz6K1uHI+rBw9unUdsJy3kHBnPDP59EUTQcWLeavat+sXVINY7v3cWCJ6aycdGXGPTVRHXqzKTX3mHg7ZNxcnUFzDNN7n/vM259fhaj/u8Jbn1+Fn9/97OrNiEFwIlNtNEdZUxEEp668wtce+mqGBORRBvdUTixyUYBirOObt1EXtrxix4vLchj+RuzOLr1Lz+jvV+DaoTIBAiyrCC4oih2sYQv/1Qai2Y+TWl+Hv4Rkdz277l2l5DKzygl/fBpFAU6DYqwdTj2R1HQtumL/8vfEL0hkZCJA+t+jUmBEvvd/bEhanbhu0RdqRYd/NE6aSgpqKQgo8yaodkVmSklhBDiqqTR6WgdEUVi9imSNqyh6/0P2DokYSG/0kpc9AaqdFrzzkAXUlVc9Qb8SiutH9xVoGV8VwbeMZk/v/qCNfM+JqhlNBHtOtgsnpL8PNYu+LSmzo6Hnz+D77qPdv0G1fpXZ41Ga9GyzqtGqbk+WBvvfFp75ZNe7kOpwRlPXTUR7kVolPPbCduwpJbemvkf07pXAhpFA7v+Z36wW/12KovpFsSuX09wPDEfg95o9RlAOcePseTlZ6koKSYoqhXjn30Zdx9fq8ZgicS15lpS0V2C8PJ3tXE09k3R6tAGWrbs0pCR1sTRWFfrHgn8/un7ZB49TOnpAjz9/M973slZS4v2fpzYn0/qvjwCIjxtFKltyUwpIYSwkF6v5/XXX+f1119Hr5cd2+xWWZk5UaEo5vuX0ekm87TvzIpSSjMzrRGdaASm/Hxcq/Xmn/GFO/uc+TouIx9Tfr5Fx7O7sV2PPmwrPUePo21Cf0xGAyv+O5syG+zMZjQY2LHie7549AGObNmAotHQfdSN3PPGh7Tvf81Vuwyi3jzPLdHSKBDpUUQHn1wiPf6SkLqg3WXZWf+1u/HdQHXW0sOcoE1POmCe1VaQAs6e0PGmep0nuKUXnn4uGKqMnEyy7rjOSj7CohefoaKkmJCYNtzywmy7TEhVVRg4tDULgPghLWwcjWPQhUc1ajtwjLHt6R9AaGxbAI7t3FZrm1bx5l34ju+zr10vralJk1IFBQVMnDgRb29vfH19ue+++ygtLb3sawYPHoyiKOfdHnhA/nothLA9VVUpKSmhpKSk1i1uheMJHzwEH6OKqijs//ILW4cjLHSyqIAiDzdQVZwN5++446o30P1ENqFFZeiCLFvuIWO7/hRF4boH/0lAiyjKThew4r+zMRoMVjv/qaREvnz6n6z78nP0VZWEt+3AnbPfZMjk+3GpZZcmcRkt+4F3OLXXesH8uHeEuZ0Dai7ju1619M4WOO80DlzqN/PivCV8u623lCr90EEWv/wvqsrKCG/bgVueexk3O631eGhTJoYqI35hHkS09bV1OA7BfdQkdB5wtk7dxVR0HuZ2lnKUsR3b07yEL3n75lqfP5uUyj5eTHlxda1tmrsmXb43ceJEMjMzWbVqFXq9nnvuuYcpU6awcOHCy77u/vvv58UXX6z52l1+uRBC2AGdTleTJNfpZPVzc6AoCm3adGDHsUMc3rWdvrYOSNSpqrycjRt+ByAmp5B2WQUUeLhS5aTDRW/Av6wSRVHQhYbi3rOHRceUsd0wzm7ujHlsBl/NmE76oYOs+/Izht79jyY9Z1nhaf786gsO/vkHAG5e3gyceDedrhmOYoe7LzkEjRZGzoVFkzAnpi78cKfCyDnmdg6ouYxvT18/i9ppTdVwcJn5i+6TG3SumG5B7FtzitR9eRiNJrTaph1baYn7WPrqi+irKomMi2fsU8/j7OrWpOdsKNWksn+ducB558ERMiPTQoqTMyFT7yL91QVcakOFkKl3oTjVvUvkWY4ytmN79WHDNwtIS9xLdUU5zm7n5zY8/VwIivIiN62EE4l5dOgXbqNIbafJrjBJSUmsXLmSTz/9lISEBAYMGMA777zDN998Q0ZGxmVf6+7uTmhoaM3N29u7qcIUQgiLaTSamuuSPW49Kxom/va7QFXJN+nJTzpg63BEHTZ++z9KC/Jxr9bTJvs0ChBQVkl4YSkBZxJSACEznkGxcDt6GdsN5x/eguunTgdg9y8rOLh+TZOcx2QysufXn/ji0QfMCSlFofPwkdzz5kfEDxkhCakrFTcGbl0A3mEXP+fbCtqOtHpIjaW5jO+IDh3x9A+ss93PH7zDnxkhVPjGQYRlifkLhcX64ublRFWZgYyjhQ06hqVS9+zkhzn/Rl9VScvO3bjp6RfsNiEFcDKpgKKcCpxdtbRNsKxOkjDzvncGEU9OQudxfiJP56EQ8eQkvO+dUa/jOcrY9o+IxC8sHKPBQOqeXbW2aRUfAMDxfZaVHWhumuynt3nzZnx9fenZs2fNY8OHD0ej0bB169bLvvarr74iMDCQTp068cwzz1BeXn7JtlVVVRQXF593E0IIISzl37kLwYo5ebF34f9sHI24nMyjh9n9648AdDqZi1ubNuhCz69zowsJIeKtN/EeMcIWIV6VYnv1oc+42wBY9fG75Bw/1qjHz0w+zMJ/Pcbqzz+gqryM4OjW3PHyf7j2/oftdnmPQ4obA9MSYfKPcPNncMt8cPGBwuOwbq6to7vqaTRaht495bJtfMPCMRpNbM+P5NOdIWxaspCq8vrX9dJoFKI7mxNgx3Y33S58ydu3sOy1lzDoq4np0ZuxTz6Pk4t9Fw3fv9Y8S6p9vzCcXe13do698r53BrFb9hI19zHC/3kLUXMfI3bL3nonpByJoii0rmsJ35nxlpZUgEFvrLVNc9ZkIykrK4vg4ODzT6bT4e/vT1ZW1iVfd8cdd9CyZUvCw8PZt28fTz31FIcPH+b777+vtf3s2bOZOXNmo8YuhBC1MRqN7N+/H4D4+Hi0Fs7CEPavbZde5OzdSvLhAwxRVZmOb4eMBgO/ffwOqCoRBSUEmxSiPngfXWgo5Tt2YsjNRRcUhHvPHhbPkKo5toztK9b3ljvIOpbM8T07Wf76K0yc/eYVJ4wqSkvY8PV89q3+FVQVF3cPBkyYROdrR6Jx0KVkdk+jhegLtm5fPBk2vAFtroWoPraJ6wo0p/HdJqEfY6bP4I95H59X9NwrIJAhk6cQG+lB6us3siEvmtxKDzYv+ZrdK3+k15ib6Xbd33BytTzhE9MtmIMbMzm2J5dBt7VF0TTu++LhzRv4+Z3XMBmNtE3oz6j/exytzqlRz9HYinIrOJ5onskSf40UOG8oxckZjxv/fsXHcaSxHduzDztWfE/q7h0YDQa0Fyw3DIr0wt3HmfKiatKPFNKyY4CNIrWNeielnn76aebOvfxfS5KSkhoc0JQp5/4CEB8fT1hYGMOGDSMlJYXWrVtf1P6ZZ55h+vTpNV8XFxcTGRnZ4PMLIcSlGI1Gli5dCkBcXJxdv/mJ+uk06R42PbqZEo2G9I3raTFgkK1DEhfY+dNS8tKO42Qw0j4jj+DnnscpIgIAj4TeV3RsGdtXTqPRMuqRx/nqmWkU5WTz89uvcdPTLzQoeaSaTBxYt5o/v/qCihLzDPi4QUMZNPEePCysqyMaScexcOR22Ps1fD8FHtgAro5VVqO5je82Cf1o3SvBvBtf4Wk8ff2I6NDRPNZ+foIYr9NE9x7E0ZZT2LjoKwrST7J+4Tx2/rSUhJtupfOwkeic667b06KdH86uWsqLqsk+XkxojE+jfQ8H//yDle+/iaqa6DBwCCMfnIbGAX4uietOgQpRcf74hkjNY1tzpLEd1rYdbt4+VBQXcepgIi07dz3veUWj0Co+kIMbMji+L0+SUnV57LHHuPvuuy/bJiYmhtDQUHJyzt+xwWAwUFBQQGio5etvExISAEhOTq41KeXi4oKLi4vFxxNCiIbSaDS0adOm5r6wU1otjBp17r4FPFq0IMLZnZOGSvZ9960kpexMYVYmmxabN0npkJGHf0ICvrfd2mjHt7ux3YA+bA/cPL0Y89i/+Pq5Jzi+dxebFy+k/2131esYOcePsfqzD8g4Yv4DZ0CLKIbf9xAt4jo1RcjCEte/Cic2QuEJWPkMjH3v8u3trP82yvg2GeHEJijNBs8Q806ENpytp9FoiezY+fwH9ZWwbxEASo/JtI0dQGzvvhzasI5NSxZSlJ3Fmnkfs33F9/QdN4GOg4dfNFvjr7ROGlrGB3J0ezYpu3MbLSm1b/VKVn3yHqgq8UNHMPz+qQ4x81FfbSRpUyYA8UNklpQ9sLv37svQaLS07pFA4prfSN6x5aKkFJiX8J1NSg2a0PaqmrWvqE20f2JSUhJxcXHs2LGDHj3MRfZ+++03Ro4cyalTpwgPt6yq/MaNGxkwYAB79+6lc+fOdbYvLi7Gx8eHoqIiKZAuhBDCYvvff4ff1v2Ki0nlwa+XXfaXdWE9qqqy5JXnSNu/h4CScvpkF9N6+bKaWVLC/hxcv4Zf3n0dgBsff5bYXnUv+aoqL2fT4q/YvXIFqsmEk6sb/cbfTrfrx8hYtAcnNsEXowAVbv2fuf7U1eLgclj5FBT/ZaMm73DzjoX29P+wfwl8dx/4RMI/98FfPqQbDQYOrP2dzd9/Q2m+edmfT0go/cbfQfsB11wyKZSyK4eVHyfiHejKnS/1veIPybt+WcGaeR8B0PW6Gxh69z8cZpOCA+vTWfvVYbwDXZn4Yl80jbycUTR/KTu3svTVl/AKCOL+9z6/aDzpq4189th6jHoTg+9sR8uOAXj62XeNtbpYmptpsqtAhw4dGDlyJPfffz/btm1j48aNPPzww0yYMKEmIZWenk779u3Ztm0bACkpKbz00kvs3LmT48ePs3z5ciZNmsSgQYMsSkgJIYQQDdV+4iScjEaqNArJPy6zdTjijKT1a0jbvweNSaXTqVxCnnxSElJ2Lm7gELpdPxqAX957nYKMU5hMRk4e2EfSxnWcPLAPk8lcyFVVVQ5tXMcX0x9g18/LUE0m2vYZwD1vfEDP0eMkIWUvWvaDAdPM91f8HxRn2jQcqzm4HBZNOj8hBebvf9Ek8/P2Ytd887/d7jwvIQWg1enoPHwk9735MUMm34+7jy9F2Vn88t4bLHjiEY5s3YhqMl10yKiOAWidNBTnVZKfXnpF4W1btqQmIdVz9DiG3vOAwySkVFVl/9p0ADpd00ISUqJBouK7onNxoSQ/l5zUlIued3LW4hts3nly7ZeHWTBjEwc3ZlzUrjlq0nf6r776iocffphhw4ah0Wi4+eabefvtt2ue1+v1HD58uGZ3PWdnZ37//XfefPNNysrKiIyM5Oabb+bZZ59tyjCFEEIInHx8aOkdQHJZIQdW/ki7sTfbOqSrXnlxEWvmfwJAbHYBwT1743vrLTaOSljimjvvIyf1GOmHDrD45WfBpFJ6+txW157+gfQaM46UHVtIS9wHgF9YOEPveYBWXbrbKmxxOYNnQPJqyNoHy6bCnd9Bc15eYjKaZ0hR26ISFVBg5dPQ/gabLuUDoCAVUv80x9R14iWb6Zyd6T7qRuKHXseulSvYsfw78k+lseKN2QS3ak3/2+4kulvPmhkcTi5aouL8Sd2bR8ruXAJb1H/zAlVV2fLdN2xa/BUAfW6eQL9bJjrU0qTM5CLy00vROWno0C/M1uEIB+Xk7EKrzt1J3r6Z5B1bCImJPe/50tOV5Kef2y1TVWHtV4eIivN3+BlTdWnS9LS/vz8LFy6kpKSEoqIiPv/8czw9PWueb9WqFaqqMnjwYAAiIyNZt24d+fn5VFZWcvToUV599VVZhieEsAt6vZ63336bt99+G71eb+twxKWUlYGHh/lWVr+tsDuOMNdBScvPobr0yv4qLK7cn19+TmVpCZ4VVcSW6Ql7+aUm+SBjd2P7CvqwvdDqdIx+9GlcPDwpzc87LyEFUFqQx5p5H5OWuA+dkzP9b72TSa+9Jwkpe6Zzhps/BZ0rpKyGbZ/U3s7O+m+Dx/eJTRfPkDqPCsXp5na2tvtL87+th4Jv3Rs+Obm6kjD2Fv7+7mf0HX87zm5u5BxP4Ye5M/n6+SdIS9xb0zamWxAAx3bn1jssVVXZ8PX8moTUgAmT6H/rnQ6VkALYv/YUAG0TQnH1sO8dAq8mdvfebYGzy9lTtm+56LnCnIqLHlNNUFTL482NY8yZFEIIO6CqKgUFBRQUFNBE5fhEYykvN9/qKWbceNz1RowahYOLFjZBYMJSJ/bv4cC61eZiuKdyCX3qSZwsrEdZX3Y5thvYh+2Jm7d3nTtqaZ2cmfSfd+lz8wR0TvJhz+4FtYNrXzLfX/Uc5ByqvZ0d9d8Gj+/SbMvandgIRkPDgmsMRgPsOfN+1b1+Gwu4uHvQ75aJ3Pf2p/QcPQ6dswuZRw6x+KV/sfilGWQcSaJVfCAajUJBRhmF2Zb/TFVVZe38T9i2bAkAgyf9nYSbGm+DCmspPV1FypmEXPxgWTpuT+zyvbsOMd17oWg05KYdpygn67znfIPdLpp8qmjA58ySvuZMFuoLIYSFdDod9957b8190fxonJ2JCYskMS+DpD/X0PXeKbYO6aqkr65i1SfvAtAyv5gW3Xrie0vTLduTsd000pMOUFFcdNk2Rn01pfl5+IU2TcJRNIHe98ORlebZUt/fD39fbZ5FZacaPL49Qyxrt3Y2bH4fogdCzGCIGQIBra23tDFlNZRkgJs/tBvVoEO4e/twzZ330uOGsWz9YRH7fl9JWuI+0hKfIKZ7LwIiepJ70o1je3Lpfl3LOo+nmkz8/tn77Pt9JQDD7nuIriMaFputHVifjmpSCYv1adDyRdF0HPG9283LmxbtO3Ly4H6St2+lxw031jzn6efK4Dvbs/arQ6gmc0Jq8MT2zX7pHkhSSgghLKbRaIiKirJ1GKKJdRo7nsRP3yajvJgjG9ZiVBQ8ff2I6NDRIbatbg62fPcNRdlZuFYbaF9USdhLLzbpcg8Z202jtPB0o7YTdkJR4Mb34IO+5vpSa2fD8BdsHdUlNXh8t+wHHkFQdpllazo30DpDVREc+tF8A/BuAa0HmxNU0deAZ1CDYrfIrgXmf7vcDjqXKzqUp58/w+59gF6jx7Hl+29IXPs7x3ZtB7ajcWrDoU3XXpSUMpmMpCcdoLTwNJ6+foS1a8/vH7/PgXW/g6Jw3T/+j05Drr2iuGzFqDdxYL25wHnnIXUvixTW5ajv3bG9+piTUjs2n5eUAojrH05UnD9FORX4BLtdFQkpkKSUEEIIcZ7w4dfi/uGblOs0rHjnPzWPe/oHMPTuf9AmoZ8No2v+ctOOs2P5dwB0TM8l4qmnm2zZnmhanr5+jdpO2BHvMBj9Niy6Czb8F9pca07iNCd5R0B/qVouZ5Lk4z42FzrP3APH1kLKGji5FYpPmes8na31FBJ/LkkV1Rec3RsnxtIc86w1qPfSvcvxDgpmxD/+j15jbmbzkq9J2rgOk/4omYeSWf5GIoPuuAvf0DCObt3EH/M+prQgr+a1OmdnDNXVKBoN1z/8GB36X9NocVlb8q4cKkr0ePg4E9010NbhiGaidc8+rJn/CelJBykvLsLd2+e85z39XK+aZNRZkpQSQggLmUwmkpKSAOjQoQMaB9nKWNRP8rbNlOsu/tmW5uex/I1ZjJk+QxJTTcRkMvLbR29jMpkIKSwlpnN3fMePt8J5ZWw3hYgOHfH0DzzvA+uFvAICiejQ0YpRiUYTN8a809uer+D7f8CDG8DVp+7XWVmDxnfBMVgwFqpLwT/GnJwqyTz3vHc4jJxj/j8AiOhhvg18DKrLIW3TmSTVWsjef+626R3zzKqoPueW+oV1afjufXu/BpMBWvSC4A4NO8Zl+IVFMOqRx+l943gWv/Ie5YVJHN36Jyk7NhIZF8+J/Xsueo2huhqAHjeMdeiEFJwrcN5xUARarbwv2BtHfe/2CQ4hqGU0uSdSSd29g47XDLN1SDbnGD85IYSwAwaDgcWLF7N48WIMBhsWNRVNxmQysvqjt8378F5IUUBVWf3R25hMRusHdxXYu+oXspKPoDOa6FRY0eTL9s6Ssd00NBotQ+++fF22IZOnyLJYRzZyDvi2hKI0+OUpW0dTq3qP76J0mH8jlGZBcEdzzaxHD8DkH+Hmz8z/Ttt/LiF1IWd3iB0OI142J+oeTza/ruud4B0BxmpI/RNWvwifDIHXWsOiSbDjCyhIteybMhnNx9j8vvnrrhMte10DBUa1ou8tj+DsNRF33zaYjMZaE1J/dXjTnw79Xplzopjs1GI0WoWOA6XAuT1y5Pfu1j3Nu/Alb99s40jsg8yUEkIICymKQqtWrWruCzul0cA115y7Xw+nDuynrKz00gVqFYWyslJOHdhPVHzXK4tTnKckP4/1X30BQLvMfFo98QROYWFWObfdje0r6MP2pk1CP8ZMn3HREh+vgECGTJ4isw4dnau3eQnbF9ebZ+20vQ5iRtpV/63X+C7NhQU3mpNs/q1h0lJw9zc/Fz2wYQF4BkH8ePNNVSE/+dxSv+ProeI0HFxmvgH4tTo3iyp60Lnzn3VwOax8Coozzj22bi64B1w6UdYIYroGsXFJCKoymgG3F7Hh688u274kP4/0pANEduzcZDE1pbOzpGJ7BOPubb+F/K9mdvfeXQ+xvfqw5buvOb53N/qqSpxcrq7lehdSVEfZP9FCxcXF+Pj4UFRUhLe3t63DEUII4UD2zP+c1T9/X2e7YaPG0XXyvVaI6Oqx9LWXSNmxFd+ySoaHRhP1yccO90umuLQLiyHLxgHNzOoXYf3r4OoLD202L29zNBWnYd5o8zI7n0i45xfwbeLi1kYDZOwyJ6iOrYVT28zL8WooEN7VnKCKGQzlebDkPuDCj29nrpW3LmjSxNS3r2wj72Qp7XoXs/fXT+tsP+r/nnDIJXwVJdXMf2YTRoOJm5/sQWiM/S1LFY5NVVU+efheSvJyufGJ54jtmWDrkJqEpbkZmSklhBBCnOGit2z69/bVv1Dl4UZs3wEERMiOPFfq6LZNpOzYiqKqdC4oJfzTlyQh1cxoNFqHnTEhLHDN05C82lzwe+lDcOf3djFLymJVJfDleHNCyjMEJi1r+oQUgFYHkb3Nt8FPmeM4selMkmoN5B6CjN3m24Y3LnMgFVBg5dPmwutNlPBt3S2IvJOlFGRaNqfBUTcxOLgxA6PBRFCUFyHRMslBND5FUYjt2YfdK1eQsmNLs01KWcqB3i2EEEKIptWiY2dcqw2115QC8+OqSnFVBRsWf8W86Q/y2YN3s37hfLKSj9DMJh9bRVV5Oas/eQ+AmJxC2jz2BE6hoTaOSghRLzpnGPcJ6NzMyZRtH9s6IsvpK+Dr2yF9B7j5wV1LIaC1bWJx8TIvgbx+DkzdCtMPwdgPofMEcK0rwaNCcbo5qdVEYroGA5CX4Y2nX8Bl2zrqJgYmo4nEP9MB6DykhfyBRDSZ1mcSUSk7tzl0/bXGIEkpIYSwkF6v58MPP+TDDz9Er9fbOhxxKWVlEBRkvpWV1eulnr170an8zGypCxNMZ76Ozy4i/nQ5gcXlKCaVwoI8ti1bzFf/ms7H/7iL1Z9/SFriXkzGq/sXDEutXziPsuIi3Kuq6dImDp9x46weg92N7Svow0LYTFBbGPGS+f6PT0G7ALvov5cd34ZqWDTZXNvJ2cs8wyskzjaB1sY7DLreDuM+glGvWfaa0uwmC8cvzB3fEHdUo0L7gbddtq2jbmJwfF8+pQVVuHo4Edsz2NbhiMuwu/fuemrRoRMuHh5UFBeRceSQrcOxKVm+J4QQFlJVlaysrJr7wo7lXXoL+stRtFq6PfYkpudmcDA8kErnc2+TrnojcRl59HhpFl7DhlG+dSu5S5dybOtGMl2dyPVyp7SokD2//sieX3/E1d2D1r36ENurLy27dMPJ2aWxvrtmI+NIEntX/QxA5/wyWnxom2V7djm2G9iHhbCpXn+HpJ8h9Q8YXAWGKsDDpiFdcnybjPDDFDj6q3mG18RFENHdRlFawMvCGaSeIU0WgqIoxHQLYtfKE1SURTXLTQz2nSlwHjcgHJ2T4yXVriZ2+d5dD1qdjphuvUjasJbk7Vto0d7xZhY2Fil0LoQQFjKZTKSmmrdrjo6ORuNI9TKuJmVl4Olpvl9aCh71/0BU/NtvZM2aTU5JIVVOOlz0BoK9fAmd8QzeI0ac19ZUUUHpmjXkL1vGib27yfZyJdvbA73u3C+zOmcXorv2ILZ3X2K698LVw/OKvsXmwGjQs2D6QxRkZxJRUMzIB6bhe7P1Z0mBHY7tRujDQthM9jF4vQu4a6D3QzBqtk3DqXV8m0yw/BHY8yVonOCObyB2uE3jrJPJCG92guJMLi50DqCYC8xP299kNaUAck4Us3j2DnQuWu57bQAaHc1mE4OCjDK+fnErigJ3vdIPL/+re0c0e2d3790NcGTLBlb8dw6+IWHc+1bz2+BFCp0LIUQj02g0tG5tozoTwqq8R4zAa9gwInbsxJCbiy4oCPeePVC0F/+irXFzw3vUKLxHjSLy9GmKf/mFwmXLyUg+TLaPB1k+HlRiLuZ9dNsmNFpzwefYXn2J7ZmAp//l63I0V9uXLaEgOxNng5EerdriM+4mm8UiY1uIRuQZAisq4TZ32PYBxN0ArQbYLJyLxreqwq/PmBNSihbGf27/CSkwJ5pGzoVFkzDvtvfXxNSZD7Ij5zRpQgogKMoLTz8XSk9XcTKpgOguQc1mE4P968yzpKK7BElCygE0h/fuVl26o9XpKMzOJP9UGoGRLW0dkk04XjpRCCGEsAJFq8UjoTc+f7sBj4TetSakLqTz88P/jjuI+fYbev+wjEHj7+C6Cg39j5wkNrsAz4pqTEYjJ/btZvVn7/PRg5NZ+OxjbFu2hNOZ6Zc8rslk5OSBfSRtXMfJA/scviDm6cx0Ni/5GoC4glJavfxKs/vroBBXtUMG2F0NqPDDA1BZZOuIzvnjZdj6ofn+2Pchboxt46mPuDFw6wJzram/8g43P26F70VRFGK6BgFwbHduk5/PWqoqDBzaYl4KFj84wsbRiKuFs5s7UfFdAUjZsdW2wdiQzJQSQggLmUwmkpOTAYiNjXXIacLCepyjogh66CECH3yQiMREilasoPinnykuySLLx4NsHw8KPVzJPHqYzKOHWb9wHgEtomjTuy+xvfoSHN0aRVE4unUTf8z7iNKC/Jpje/oHMPTufzhkzQ5VVfnt7f9gMpkILCmn+8OP4hTSdDVQLCFjW4gmsLISBreBohPw8xMwzjY78p03vrNWoFn/H/MTN7wOXSbYJKYrEjcG2t9g3mWvNNs8M61lvyafIfVXMd2C2LfmFKn78jAaTWi1jn/NPLQ5E0OVEb8wDyLa1bXTobAHzeW9O7ZnH1J37yB5+2YSbrrV1uHYhCSlhBDCQgaDgYULFwIwY8YMnJ2dbRyRcASKouAWH49bfDwhTz5J2ebNhK1YQcmq36nQV5N9JkGV7+lO/qk08k+lseX7b/EKDCIwsiWpu3eYl5v8ZSZRaX4ey9+YxZjpMxwuMXVgzSpOHTuKxmSid3gMvjZctneWjG0hmkA1cMM78PVY2PcttL0OOt1s9TBqxnf6TmaErsNZq8Dwmeai7I5Ko4XogTY7fVisL25eTlSU6Mk4UkhkB3+bxdIYVJNK4jrzbOXOgyNk5q6DaC7v3a17JrDq0/fISjlKSUEeXv6Btg7J6iQpJYQQFlIUhfDw8Jr7wk5pNNCz57n7dkTR6fAcOBDPgQMxlZVR8scfBKxYQcuNm9CjkuPlTpavJ3k+npTk5VKSd2ZpxIX9TVFAVVn90du07pXgMEVly4uLWPvZBwC0PV1O7Lv2sWzP7sa2HfdhIer01/4b2RsGPgZ/vgY/PgqRfcDHukujFEUh3HgKsn5HCXWCQU/AgGlWjaG50WgUojsHcnBjJsd25zp8UurkoQIKs8txdtXSNsHCXQ6Fzdnde3cDefj6EdamHZlHDpGyYxtdR4yydUhWJ7vvCSGEEDZmyMuj+OdfKPrxRyr37cOoKKQG+XAkrO4i6Lc8+3JNPQJ7t2LWCxzZuxOviirGT34QfxvttieEsCKjHj67FjJ2Q/Q1cNdS6yZbDy6DxXeDaoKEB2Hk7IsT/aLeTiTm8+O7e3H3dubuOf1RNI77f/rTe3s5vj+fzkNaMPC2trYOR1yFti1bwvqF82jZuRvj//WSrcNpNJbmZuTPb0IIIYSN6QID8Z90F9GLviXml58JefBBPF3dLXptwa5dTRxd4zi+ewdH9u4EVSUhKBI/O1i2J4SwAq0TjPsEdG6Qug62fmC9cx9dBUvuMyekut0lCalG1KKdH86uWsqLq8lKLbZ1OA1WlFvB8URzzcb4wS1sHI24WsX26gPAyQP7qSovs3E01idJKSGEEMKOuERHE/R/jxB6q2XFLvWnTzdxRFdOX1XJr2++CkCr4griZs1x6Kn2Qoh6CmwD171ivv/7TMg+0PTnPL4Bvr0TTHroOA5GvyUJqUakddLQMt5c++bYHsfdhS/xz3RQISrOH98Qy/4YJERj8w9vgV94C0xGAztWfN9sdlu2lCSlhBDCQnq9ns8++4zPPvsMvV5v63DEpZSXQ6tW5lt5ua2jabAWHbvgWm0wFzmvzZnH129Zy8ZFX2Gw4z654ZP3Ka0sx7XawMD7HsApJNjWIZ3H7sZ2M+nD4ip1qf7b815ocx0Yq+C7+8FQ1XQxpO+EhRPAUIk+ZgSfFfblsy/m2cf4bkZadwsC4NjuHByxIoy+2kjSxgxAZkk5Irt7775C/hGRAGz5/lt+fvs1Fr04g0+m3sfRrZtsHFnTk6SUEEJYSFVVTp48ycmTJx3yl6+rhqrCiRPmmwP/nDx796JTucH8xYXfx5mvvcsqUVWVLd99zYInH+HUwUQrR1m3nJSj7P7zDwB6+oUSNP4WG0d0Mbsb282kD4ur1KX6r6LAmHfAPQByDsAfTVQ3JfsA/G8cVJdA9CDUmz/jZHqG/YzvZiSqYwBaJw3FeZUc3JhB6elKW4dUL0e3ZVNVbsA70JWoTnXXcBT2xe7eu6/A0a2bSNm++aLHSwvMuy0398SU7L4nhBAW0ul0TJgwoea+EE1J0Wrp9tiTmJ6bwcHwQCqdz/U5V72BuIx8QkoqyPJy40BEEKczTvHtzKeJHzqCQRPvxdXT04bRm5lMRn6ePRNVgbCyKrq//apdLtuTsS2ElXiFmBNT39wBm96FNiMgelDjHT8vGRaMhcpCaNELJnyNzsldxncTcXLR4hfiTt6pUtZ+eRhFgcF3tieuf7itQ6uTqqrsW3sKgE7XtEDjwIXar1bN5b3bZDLyx7yPL9tmzfyPHWq35fpy3J+eEEJYmUajoX379rYOQ1xFvEeMoAcQMWs2OSXZVDnpcNEbCPbyJfSlWbi0aYPXq68R+Oc6DoX5czLAh/1//EbKzm0MuXsK7foOtGkSaMeX88gvKURnNDLkznvtbtneWTK2hbCi9jdA90mwawH88CA8uBHcfK/8uIUnYcGNUJYDofEwcTG4eKIBGd9NpPR0JXnppTVfqyqs/eoQUXH+ePq52jCyumWmFJF/qhSdk4YO/cJsHY5ogOby3p2edIDSgrzLtinJzyM96QCRHTtbKSrrkqSUEEIIYce8R4zAa9gwInbsxJCbiy4oCPeePVC05r+WRX7wPn4bN+I5Zw4RyadIbBFEKYX89NarHPzzD4bf9xDeQdZPBhVnZbL5xx9Agc5egYTeNsHqMQgh7NR1syF1PZxOhZ8fh5s/vbLjlWTDgjFQfAoC28KdP4CbX+PEKi6pMKcCLlxdboLT2eV2n5Tav8Y8S6pt7xBcPZxsHI24mpUWWrZhjaXtHJHUlBJCCAuZTCaOHz/O8ePHMZlMtg5HXEUUrRaPhN74/O0GPBJ61ySkzvLs35/oH34g7vEnGZRdQpusAjQmldTdO/ji0QfY+dNSTEbr7eCiqiq/vPgsBgX8KvX0n/WaXS7bO0vGthBW5uIJ4z4BRQv7F8P+JQ0/VnkB/G8sFBwD3yi4ayl4BtU8LeO76fgGu9W6oeGWpSkU51VYPyALlZ6u4thu846B8UOkwLmjai5j29PXsgS6pe0ckSSlhBDCQgaDgXnz5jFv3jwMBoOtwxHiPIpOh9/tt9P2t19JuP5GBqRk4FdagUFfzdoFn/LVM9PITk2xSiwHf1jCqfxsFJPK0HETcA4Ltcp5G0rGthA2ENkLBj1uvv/jdPPyu/qqLIYvb4acg+AZCpOWgU/EeU1kfDcdTz9XBt/ZHuXsJ0oFtDqFnOMlfPPyNg5vybTLAtQHNqRjMqmExfoQ2MLL1uGIBmouYzuiQ0c8/QMv28YrIJCIDh2tFJH1yfI9IYSwkKIoBAUF1dwXdkpRIC7u3P2rjNbbm5Cnn8L3tlsJmfsqh/btJCksgJwTqXz1zDS6j7qR/rfeiZNr0yytqCwqZO0380GBDu4+tJx0d5OcpzHZ3di+yvuwcHD16b+DnoDk3yF9Jyx9ECYtB42FfzOvLoevJ0DGLvOOfpOWgX9MLeHY2fhuZuL6hxMV509RTgU+wW6YjCq/f3GQzJQifp+XxPH9+VxzRzu7WSJnNJg4sD4DgPjBMkvKkTWXsa3RaBl69xSWvzHrkm2GTJ7SbIucAyiqPaavr0BxcTE+Pj4UFRXh7e1t63CEEEIImyrduJG0ObPZU1VCpp/5L8Je3j5cO3U60V17NPr5fnz0IQ5npOGhNzD5nc9wi4io+0VCiKtXfgp8OAD05TDiZej3SN2vMVSZd/BL/h1cvGHyCgjv2uShCsuYjCZ2/ZrG9h9TMZlUPHxdGHZ3ByLb+9s6NI5sy2LV5wfx8HHmrln90Gpl4ZCwD0e3buKPeR+fV/TcKyCQIZOn0Cahnw0jazhLczOSlBJCCCGaOdVgoHDxYhI//oB9vm5UOpv/Yt22S0+GTZ2Gu49vo5wn9beVfP/ZuwDcMPxvtL//gUY5rhCimdvxBfw4DbTOcP8aCO106bZGAyy5G5JWgJM73PUDRPWxVqSiHrKPF/P7FwcpzC4HoMvwSPrcGIPOyXYzPr57dQdZx4rpPTqaXjdE2ywOIWpjMhnNu/EVnsbT14+IDh0deoaUJKUkKSWEEEKcx1hcTOY777L1j5UcD/ACRcFZq+OaO+8l/vrRVzT93VBRzueTb6NEUYl28eCm+d849HR6IYQVqap5Kd6RlRAcZ05MOdWyxNhkgmUPwd6vzQmsOxZB6yHWj1dYTF9lZON3yRz4Mx2AgAgPrr23IwERnlaPJedEMYtn70CjVZg0qx8ePi5Wj0GIq4mluRmZryiEEBbS6/UsWLCABQsWoNfrbR2OuJTycujY0XwrL7d1NHZF6+1Ni3/N4G+fzme4TyjeFVVUGw2smv8xC6feR8HJEw0+9rp/P0uJouJsNHHtzNkOlZCyu7EtfVg4sob0X0WBMe+CR5C5aPkfL13cRlXhlyfMCSlFC7fMsyghZXfj+yrj5KJl8B3tuOGhzrh5OZGfXsai2dvZ83saqsm6cyP2rz0FQOvuwZKQagZkbDcfUuhcCCEspKoqx44dq7kv7JSqwsGD5+6Li7hER9Plk8+IXr+ezW/M5aDORFZ+DvMfm0qPvoPo/8ijaHWWF6XN2riBfccOg0ah/6Br8Yq+uNiwPbO7sS19WDiyhvZfzyBzYurr22Dzu9B6qHk2VGk2eAbD0VWw/VNAgZs+gvY3WBiOnY3vq1SrzoFMeC6BNf8zFz/fuCSZE4n5DJvcAU+/ptl4468qSqs5uj0HgM5DpMB5cyBju/mQ5XtCCGEhk8lEYmIiAJ06dUJj6Q5BwrrKysDzzLKA0lLw8LBtPHZONRg4Oe8L1i5fTK6bMwDeGh3XTnmEVkOG1fl6U3U1/5t4M3kalVAnN25f8K3DjQ27G9vSh4Uju9L+u+KfsHMeKBpQTRc//7c3oec9Fh/O7sb3VU5VVQ6sz2Dj4qMY9CZc3HUMntie2B7BTXreXb+eYPMPKQRFeXHLMz0dajavqJ2MbfsnNaUkKSWEEFcn+UDfIIaiIna88iLbUw5SrdOCqtI2MIxhz72Ee1jYJV+3+bln2HRkP1qTyl0vvkZAhzgrRt1MSR8WjuxK++++xfD93y/9/K3/g7gxDY9P2IXTWWX8/sVBck6UANCuTyiDbmuLs1vjL+QxGU3877nNlBZUMXRSBzr0u/R7mhCi8UhNKSGEEEJYTOfjQ59XX+euma/RytkDFIUj+Vl8/vC97HptDqYz9RqM+mqOLFnErnfeZPd/X2fbwT0A9OjZVxJSQogrYzLC789fpoECK582txMOzS/Ug3FP9qDnqFYoChzeksU3L28jI7mw0c91fH8+pQVVuHo40aZn087IEkLUn9SUEkIIC5lMJjIzMwEICwuTacKiWfLt1Imb//cth79ZyJrvFlKm07JmxwaSJmygZds49h5NpFL7l76v0+KuQr/HnrZd0FdIxrYQduLEJijOuEwDFYrTze2iB1p0SBnf9kur1ZAwJoaoOH9+n3eQ4rxKlr6+i+7XtaTX36LR6hrnZ3W2wHncgHB0ztpGOaawPRnbzYf85IQQwkIGg4FPPvmETz75BIPBYOtwhGhS7SbcwX3zF9GlbScUVSVLB1tTDlCpuaAOh6pSjkri5x/bJtBGIGNbCDtRmt247ZDx7QjCYn257V+9ad83FFWFnStP8N2rOzmdVXbFxy7ILOPUodMoCnQcFN4I0Qp7IWO7+ZCklBBCWEhRFHx9ffH19ZUCmfZMUaBlS/NNfk5XxMndneEvzWHCs6+gmFTz/+eF/6dnvt7w248Y9dU2iPLK2d3Ylj4sHNmV9F/PkMZthx2Ob1ErZzcdwybHcd39nXBx15GbVsKiV7aTuO7UFe2sdnaWVKvOgXgHuDVWuMIOyNhuPqTQuRBCCCEu68iSRaxYvKDOdqNvmUTb8bdaISIhRLNkMsKbnaA4E6jtI4oC3uEwbT9oZBlWc1V6uorV8w9y6tBpAFrGBzD0rg64ezvX6zhVFQbmPb0RQ5WRG6d1pUV7/6YIVwhxCVLoXAghhBCNojTzcjVe6t9OCCFqpdHCyLlnvrhw5sOZr0fOkYRUM+fp58KY/+vKgFvaoNVpOLE/n29e2krq3tx6HefwlkwMVUb8Qt2JaOfXRNEKIa6UJKWEEEIIcVmeYZbV4bC0nRBCXFLcGLh1AXiHnf+4d7j58bgxtolLWJWiUegyLJJbnulJQIQnFSV6fv5gP2u+OoS+qu7dF1WTyv616QDED24hy7uEsGOy+54QQljIYDCwZMkSAMaPH49OJ5dQu1RRAYMGme//+Se4SQ2JK9X6xrG4fjPPXOS8tl/sVRVXk0rrG8daPbbGYHdjW/qwcGSN0X/jxkD7G8y77JVmm2tItezXoBlSdje+Rb0ERHhyy9M92bL8GHtWpXFwfQbph09z7T0dCYm+9HKgk4cKKMwux8lVS7s+oVaMWFiLjO3mQ35yQghhIZPJxKFDh2ruCztlMsGOHefuiyumdXJmwIi/8fvvP4Gqnp+YOlOacsCIv6F1ql+9D3thd2Nb+rBwZI3VfzVaiB7YCOHY2fgW9aZ10tD/5lhadvTn93lJFOVU8N1rO+l1Qyt6jGyJRnvx4p+zs6Q69A3D2VU+8jZHMrabDxmhQghhIa1Wy+jRo2vuC3E16TLlIcC8y16l9lxSytWkMmDE32qed0QytoVovmR8Nx8t2vsz4bnerFt4mOSdOWxbkUragXyG3xOHT5B7TbvivAqO788DoNM1EbYKVzQxGdvNh+y+J4QQonkpKwNPT/P90lLw8LBtPM2MUV9NyrKllGZm4BkWTusbxzrsDCm7JX1YODLpv6KJqarKkW3Z/Pn1YaorjTi5aBl4Wxva9w1DURQ2fpfMnlVpRMb5M+b/uto6XCGuWpbmZmSmlBBCCCEspnVypu34W20dhhBCiKuUoii0SwglrLUPv887SGZyEX8sOMTx/fl0GxHFgT9PAdB5cAsbRyqEsIQkpYQQwkKqqpKba96OOCgoSHZyEaKZkLEtRPMl47v58g50Y+z07uz+7QTblqdybHcux3bn1jxfVlRlw+hEU5Ox3XxcXBVOCCFErfR6Pe+//z7vv/8+er3e1uEIIRqJjG0hmi8Z382bRqPQY2QrRj3U+aLn1n19mNLTlTaISliDjO3mo8mSUq+88gr9+vXD3d0dX19fi16jqirPP/88YWFhuLm5MXz4cI4ePdpUIQohRL25u7vj7u5ed0NhW4GB5psQFrK7sS19WDgyO+u/dje+RaPTOl38sVY1QVFOhQ2iEdYiY7t5aLJC5y+88AK+vr6cOnWKzz77jMLCwjpfM3fuXGbPns38+fOJjo7mueeeY//+/Rw8eBBXV1eLziuFzoUQQgghhBDi6lF6upIFMzbx10+2igYmvdIPTz/LPkcKIRqXpbmZJpspNXPmTB599FHi4+Mtaq+qKm+++SbPPvssN954I507d2bBggVkZGSwdOnSpgpTCCGEEEIIIYQD8/RzZfCd7VHOfLpVNDB4YntJSAnhAOym0HlqaipZWVkMHz685jEfHx8SEhLYvHkzEyZMsGF0QgghhBBCCCHsVVz/cKLi/CnKqcAn2E0SUkI4CLtJSmVlZQEQEhJy3uMhISE1z9WmqqqKqqpzOysUFxc3TYBCiKuewWBg2bJlANx4443odHZzCRV/VVEB119vvv/LL+DmZtt4hN2zu7EtfVg4Mjvrv3Y3vkWT8vRzlWTUVULGdvNRr+V7Tz/9NIqiXPZ26NChpoq1VrNnz8bHx6fmFhkZadXzCyGuHiaTif3797N//35MJpOtwxGXYjLBunXmm/ychAXsbmxLHxaOzM76r92NbyFEo5Cx3XzUK5342GOPcffdd1+2TUxMTIMCCQ0NBSA7O5uwsLCax7Ozs+nateslX/fMM88wffr0mq+Li4slMSWEaBJarZaRI0fW3BdCNA8ytoVovmR8C9E8ydhuPuqVlAoKCiIoKKhJAomOjiY0NJTVq1fXJKGKi4vZunUrDz744CVf5+LigouLS5PEJIQQf6XVaunTp4+twxBCNDIZ20I0XzK+hWieZGw3H022+15aWhp79uwhLS0No9HInj172LNnD6WlpTVt2rdvzw8//ACAoihMmzaNl19+meXLl7N//34mTZpEeHg4Y8eObaowhRBCCCGEEEIIIYQNNFk1sOeff5758+fXfN2tWzcA1qxZw+DBgwE4fPgwRUVFNW2efPJJysrKmDJlCoWFhQwYMICVK1fi6irF6oQQtqeqas01y8fHB0VRbByREKIxyNgWovmS8S1E8yRju/lQVFVVbR1EYyouLsbHx4eioiK8vb1tHY4Qohmprq5m1qxZAMyYMQNnZ2cbRyRqVVYGnp7m+6Wl4OFh23iE3bO7sS19WDgyO+u/dje+hRCNQsa2/bM0NyP7JgohRD04OTnZOgRhCXd3W0cgHIzdjW3pw8KR2Vn/tbvxLYRoFDK2mweZKSWEEEIIIYQQQgghGo2luZkmK3QuhBBCCCGEEEIIIcSlSFJKCCGEEEIIIYQQQlidJKWEEMJCBoOB5cuXs3z5cgwGg63DEZdSWQk33GC+VVbaOhrhAOxubEsfFo7Mzvqv3Y1vIUSjkLHdfEihcyGEsJDJZGLXrl0AjBw50sbRiEsyGuHnn8/dF6IOdje2pQ8LR2Zn/dfuxrcQolHI2G4+JCklhBAW0mq1DB06tOa+EKJ5kLEtRPMl41uI5knGdvMhu+8JIYRoXsrKwNPTfL+0FDw8bBuPEPUlfVg4Mum/QgghkN33hBBCCCGEEEIIIYQdk+V7QghhIVVVKS8vB8Dd3R1FUWwckRCiMcjYFqL5kvEtRPMkY7v5kJlSQghhIb1ez2uvvcZrr72GXq+3dThCiEYiY1uI5kvGtxDNk4zt5qPZzZQ6WyKruLjYxpEIIZqb6upqqqqqAPM1xtnZ2cYRiVqVlZ27X1xsF7s/Cftmd2Nb+rBwZHbWf+1ufAshGoWMbft3NidTVxnzZlfo/NSpU0RGRto6DCGEEEIIIYQQQoir2smTJ2nRosUln292SSmTyURGRgZeXl7NYl1pcXExkZGRnDx5UnYTFA5H+q9wdNKHhSOT/iscnfRh4eikDwtHdqX9V1VVSkpKCA8PR6O5dOWoZrd8T6PRXDYL56i8vb3lQiYclvRf4eikDwtHJv1XODrpw8LRSR8WjuxK+q+Pj0+dbaTQuRBCCCGEEEIIIYSwOklKCSGEEEIIIYQQQgirk6SUnXNxceGFF17AxcXF1qEIUW/Sf4Wjkz4sHJn0X+HopA8LRyd9WDgya/XfZlfoXAghhBBCCCGEEELYP5kpJYQQQgghhBBCCCGsTpJSQgghhBBCCCGEEMLqJCklhBBCCCGEEEIIIaxOklJ27L333qNVq1a4urqSkJDAtm3bbB2SEBb597//jaIo593at29v67CEqNWff/7J6NGjCQ8PR1EUli5det7zqqry/PPPExYWhpubG8OHD+fo0aO2CVaIWtTVh+++++6LrskjR460TbBCXGD27Nn06tULLy8vgoODGTt2LIcPHz6vTWVlJVOnTiUgIABPT09uvvlmsrOzbRSxEOezpA8PHjz4ouvwAw88YKOIhTjngw8+oHPnznh7e+Pt7U3fvn355Zdfap63xvVXklJ26ttvv2X69Om88MIL7Nq1iy5dunDdddeRk5Nj69CEsEjHjh3JzMysuW3YsMHWIQlRq7KyMrp06cJ7771X6/Ovvvoqb7/9Nh9++CFbt27Fw8OD6667jsrKSitHKkTt6urDACNHjjzvmvz1119bMUIhLm3dunVMnTqVLVu2sGrVKvR6PSNGjKCsrKymzaOPPsqKFStYvHgx69atIyMjg3HjxtkwaiHOsaQPA9x///3nXYdfffVVG0UsxDktWrRgzpw57Ny5kx07djB06FBuvPFGDhw4AFjn+iu779mphIQEevXqxbvvvguAyWQiMjKSRx55hKefftrG0Qlxef/+979ZunQpe/bssXUoQtSLoij88MMPjB07FjDPkgoPD+exxx7j8ccfB6CoqIiQkBDmzZvHhAkTbBitEBe7sA+DeaZUYWHhRTOohLBHubm5BAcHs27dOgYNGkRRURFBQUEsXLiQ8ePHA3Do0CE6dOjA5s2b6dOnj40jFuJ8F/ZhMM+U6tq1K2+++aZtgxPCAv7+/rz22muMHz/eKtdfmSllh6qrq9m5cyfDhw+veUyj0TB8+HA2b95sw8iEsNzRo0cJDw8nJiaGiRMnkpaWZuuQhKi31NRUsrKyzrse+/j4kJCQINdj4VDWrl1LcHAw7dq148EHHyQ/P9/WIQlRq6KiIsD8oQhg586d6PX6867D7du3JyoqSq7Dwi5d2IfP+uqrrwgMDKRTp04888wzlJeX2yI8IS7JaDTyzTffUFZWRt++fa12/dU12pFEo8nLy8NoNBISEnLe4yEhIRw6dMhGUQlhuYSEBObNm0e7du3IzMxk5syZDBw4kMTERLy8vGwdnhAWy8rKAqj1enz2OSHs3ciRIxk3bhzR0dGkpKQwY8YMrr/+ejZv3oxWq7V1eELUMJlMTJs2jf79+9OpUyfAfB12dnbG19f3vLZyHRb2qLY+DHDHHXfQsmVLwsPD2bdvH0899RSHDx/m+++/t2G0Qpjt37+fvn37UllZiaenJz/88ANxcXHs2bPHKtdfSUoJIRrd9ddfX3O/c+fOJCQk0LJlSxYtWsR9991nw8iEEOLq89dlpvHx8XTu3JnWrVuzdu1ahg0bZsPIhDjf1KlTSUxMlDqUwmFdqg9PmTKl5n58fDxhYWEMGzaMlJQUWrdube0whThPu3bt2LNnD0VFRSxZsoTJkyezbt06q51flu/ZocDAQLRa7UVV7bOzswkNDbVRVEI0nK+vL23btiU5OdnWoQhRL2evuXI9Fs1JTEwMgYGBck0WduXhhx/mxx9/ZM2aNbRo0aLm8dDQUKqrqyksLDyvvVyHhb25VB+uTUJCAoBch4VdcHZ2JjY2lh49ejB79my6dOnCW2+9ZbXrrySl7JCzszM9evRg9erVNY+ZTCZWr15N3759bRiZEA1TWlpKSkoKYWFhtg5FiHqJjo4mNDT0vOtxcXExW7duleuxcFinTp0iPz9frsnCLqiqysMPP8wPP/zAH3/8QXR09HnP9+jRAycnp/Ouw4cPHyYtLU2uw8Iu1NWHa3N2MyC5Dgt7ZDKZqKqqstr1V5bv2anp06czefJkevbsSe/evXnzzTcpKyvjnnvusXVoQtTp8ccfZ/To0bRs2ZKMjAxeeOEFtFott99+u61DE+IipaWl5/2lMjU1lT179uDv709UVBTTpk3j5Zdfpk2bNkRHR/Pcc88RHh5+3u5mQtjS5fqwv78/M2fO5OabbyY0NJSUlBSefPJJYmNjue6662wYtRBmU6dOZeHChSxbtgwvL6+aOiU+Pj64ubnh4+PDfffdx/Tp0/H398fb25tHHnmEvn37ys57wi7U1YdTUlJYuHAho0aNIiAggH379vHoo48yaNAgOnfubOPoxdXumWee4frrrycqKoqSkhIWLlzI2rVr+fXXX613/VWF3XrnnXfUqKgo1dnZWe3du7e6ZcsWW4ckhEVuu+02NSwsTHV2dlYjIiLU2267TU1OTrZ1WELUas2aNSpw0W3y5MmqqqqqyWRSn3vuOTUkJER1cXFRhw0bph4+fNi2QQvxF5frw+Xl5eqIESPUoKAg1cnJSW3ZsqV6//33q1lZWbYOWwhVVdVa+y6gfvHFFzVtKioq1Iceekj18/NT3d3d1ZtuuknNzMy0XdBC/EVdfTgtLU0dNGiQ6u/vr7q4uKixsbHqE088oRYVFdk2cCFUVbweOt8AAAPRSURBVL333nvVli1bqs7OzmpQUJA6bNgw9bfffqt53hrXX0VVVbXxUlxCCCGEEEIIIYQQQtRNakoJIYQQQgghhBBCCKuTpJQQQgghhBBCCCGEsDpJSgkhhBBCCCGEEEIIq5OklBBCCCGEEEIIIYSwOklKCSGEEEIIIYQQQgirk6SUEEIIIYQQQgghhLA6SUoJIYQQQgghhBBCCKuTpJQQQgghhBBCCCGEsDpJSgkhhBBC2MDdd9/N2LFjbR2GEEIIIYTN6GwdgBBCCCFEc6MoymWff+GFF3jrrbdQVdVKEQkhhBBC2B9JSgkhhBBCNLLMzMya+99++y3PP/88hw8frnnM09MTT09PW4QmhBBCCGE3ZPmeEEIIIUQjCw0Nrbn5+PigKMp5j3l6el60fG/w4ME88sgjTJs2DT8/P0JCQvjkk08oKyvjnnvuwcvLi9jYWH755ZfzzpWYmMj111+Pp6cnISEh3HXXXeTl5Vn5OxZCCCGEqD9JSgkhhBBC2In58+cTGBjItm3beOSRR3jwwQe55ZZb6NevH7t27WLEiBHcddddlJeXA1BYWMjQoUPp1q0bO3bsYOXKlWRnZ3Prrbfa+DsRQgghhKibJKWEEEIIIexEly5dePbZZ2nTpg3PPPMMrq6uBAYGcv/999OmTRuef/558vPz2bdvHwDvvvsu3bp1Y9asWbRv355u3brx+eefs2bNGo4cOWLj70YIIYQQ4vKkppQQQgghhJ3o3LlzzX2tVktAQADx8fE1j4WEhACQk5MDwN69e1mzZk2t9alSUlJo27ZtE0cshBBCCNFwkpQSQgghhLATTk5O532tKMp5j53d1c9kMgFQWlrK6NGjmTt37kXHCgsLa8JIhRBCCCGunCSlhBBCCCEcVPfu3fnuu+9o1aoVOp38WieEEEIIxyI1pYQQQgghHNTUqVMpKCjg9ttvZ/v27aSkpPDrr79yzz33YDQabR2eEEIIIcRlSVJKCCGEEMJBhYeHs3HjRoxGIyNGjCA+Pp5p06bh6+uLRiO/5gkhhBDCvimqqqq2DkIIIYQQQgghhBBCXF3kT2hCCCGEEEIIIYQQwuokKSWEEEIIIYQQQgghrE6SUkIIIYQQQgghhBDC6iQpJYQQQgghhBBCCCGsTpJSQgghhBBCCCGEEMLqJCklhBBCCCGEEEIIIaxOklJCCCGEEEIIIYQQwuokKSWEEEIIIYQQQgghrE6SUkIIIYQQQgghhBDC6iQpJYQQQgghhBBCCCGsTpJSQgghhBBCCCGEEMLqJCklhBBCCCGEEEIIIazu/wGioFKDFpFyQAAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1321,67 +767,40 @@ } ], "source": [ - "f, ax = plt.subplots(1, 3, figsize=(12, 5), sharey=True, dpi=200)\n", - "\n", - "cmp = plt.get_cmap(\"Set1\")\n", - "\n", - "max_effect_length = max(len(effect) for effect in base_treatment_effects)\n", - "event_time = np.arange(-max(treatment_start_cohorts), max_effect_length)\n", + "# Create a figure and axis\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", "\n", - "i = 0\n", + "for cohort_start in treatment_start_cohorts:\n", + " ax.axvline(x=cohort_start - 0.5, color='red', linestyle='--')\n", + "# Plot the true treatment effect functions for each cohort\n", "for cohort_idx, cohort_start in enumerate(treatment_start_cohorts):\n", " effect_vector = base_treatment_effects[cohort_idx]\n", - " effect_vector_padded = np.zeros(len(event_time))\n", - " start_idx = np.where(event_time == 0)[0][0]\n", - " effect_vector_padded[start_idx:start_idx+len(effect_vector)] = effect_vector\n", - " ax[0].plot(event_time, effect_vector_padded, marker=\".\", label=f\"True Effect (Cohort {cohort_idx + 1})\", color=cmp(i))\n", - " i += 1\n", - "\n", - "ax[0].set_title(\"True Effects (Event Time)\")\n", - "ax[0].set_xlabel(\"Relative Time\")\n", - "\n", - "\n", - "i = 0\n", - "for k, v in res_dict.items():\n", - " ax[1].plot(v['time'], v['est']['Estimate'], marker='.', label=k, color=cmp(i))\n", - " ax[1].fill_between(v['time'], v['est']['2.5%'], v['est']['97.5%'], alpha=0.2, color=cmp(i))\n", - " i += 1\n", - "\n", - "ax[1].set_title(\"Event Study Coefficients (Event Time)\")\n", - "ax[1].set_xlabel(\"Relative Time\")\n", - "\n", - "\n", - "i = 0\n", - "for j in sorted(df.first_treated_period.unique())[1:]:\n", - " df_tmp = df.query(f\"first_treated_period.isin([0.0, {j}])\")\n", - " df_tmp['rel_time'] = df_tmp['time_id'] - j\n", - " group_means = df_tmp.groupby([\"ever_treated\", \"rel_time\"])[\"Y_it\"].mean().unstack()\n", - " diff_in_means = group_means.loc[True] - group_means.loc[False]\n", - " diff_in_means.plot(color = cmp(i), ax = ax[2])\n", - " i += 1\n", - "ax[2].set_title(\"Difference in Means\")\n", + " effect_vector_padded = np.zeros(num_periods)\n", + " effect_vector_padded[cohort_start:cohort_start+len(effect_vector)] = effect_vector\n", + " ax.plot(effect_vector_padded, marker=\".\", label=f\"True Effect (Cohort {cohort_idx + 1})\")\n", + " # estimated cohort effect\n", + " cohort_estimates = evsum[\"point_estimate\"][f\"{cohort_start}\"].values\n", + " ax.plot(cohort_estimates, marker=\"o\", label=f\"Estimated Effect (Cohort {cohort_idx + 1})\")\n", "\n", - "ax[0].axvline(-.5, linestyle = \"--\", color = 'k'); ax[0].axhline(0, linestyle = \"--\", color = 'k')\n", - "ax[1].axvline(-.5, linestyle = \"--\", color = 'k'); ax[1].axhline(0, linestyle = \"--\", color = 'k')\n", - "ax[2].axvline(-.5, linestyle = \"--\", color = 'k'); ax[2].axhline(0, linestyle = \"--\", color = 'k')\n", + "# Overlay week dotted lines\n", + "for week in range(1, num_periods // 7 + 1):\n", + " ax.axvline(x=week * 7 - 0.5, color='k', linestyle=':', alpha=0.5)\n", "\n", - "f.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Event study coefficients are a vertical offset of the difference in means." + "# Add labels and title\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_title(\"Event Study estimates under staggered adoption\")\n", + "# Add legend\n", + "ax.legend()\n", + "# Show the plot\n", + "plt.tight_layout()\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Compressing out-of-memory\n", - "\n", - "In progress in scratch notebook; will add after some testing" + "Again, we get the correct treatment effect/impulse response function for each cohort. Estimates are considerably noisier, however." ] } ],