From 692febd8327726105ef2a496ae774d573aac927b Mon Sep 17 00:00:00 2001 From: terence-lim <41972012+terence-lim@users.noreply.github.com> Date: Tue, 3 Jan 2023 21:58:10 -0500 Subject: [PATCH] Update --- README.md | 274 +++--- business_description.ipynb | 1513 ++++++++++++++++------------------ conditional_volatility.ipynb | 1198 ++++++--------------------- covariance_matrix.ipynb | 725 ++++++++++++++++ elman_kalman.ipynb | 1433 ++++++++++++++++++++++++++++++++ jegadeesh-titman.ipynb | 528 ++++++++++++ link_prediction.ipynb | 628 ++++++++++++++ stock_prices.ipynb | 1294 +++++++++++++++++++++++++++++ tcn_var.ipynb | 1459 ++++++++++++++++++++++++++++++++ weekly_reversal.ipynb | 666 ++++++++++----- 10 files changed, 7562 insertions(+), 2156 deletions(-) create mode 100644 covariance_matrix.ipynb create mode 100644 elman_kalman.ipynb create mode 100644 jegadeesh-titman.ipynb create mode 100644 link_prediction.ipynb create mode 100644 stock_prices.ipynb create mode 100644 tcn_var.ipynb diff --git a/README.md b/README.md index ec366ad..e770eaf 100644 --- a/README.md +++ b/README.md @@ -1,227 +1,149 @@ -# Data Science Notebooks +# 30+ Financial Data Science Projects -These Jupyter notebooks contain code examples and results output from -exploring data science and machine learning methods on large and -textual financial data sets. They accompany the -[https://github.com/terence-lim/financial-data-science](https://github.com/terence-lim/financial-data-science) -repo. +These Jupyter notebooks contain code examples and output from 30+ +financial data science projects, which apply quantitative and +machine learning methods to large structured and unstructured +financial data sets. They accompany the [FinDS Python +repo](https://github.com/terence-lim/financial-data-science.git), +but reflect an older version hence do not (yet) sync with the code and examples +presently in that repo. -[https://github.com/terence-lim/data-science-notebooks](https://github.com/terence-lim/data-science-notebooks) +1. [Track stock identifier changes and price adjustments](stock_prices.ipynb) + - stock splits, dividends, identifiers, and total holding returns -## NOTE: These examples reflect an older version, hence do not match the code in the new modules -- updated versions of the notebooks will be reloaded very soon. +2. [Construct Jegadeesh-Titman rolling portfolios](jegadeesh_titman.ipynb) + - Newey-West correction; momentum effect -by: [Terence Lim](https://www.linkedin.com/in/terencelim) +3. [Construct Fama-French sorted portfolio](fama_french.ipynb) + - linear regression; value and size anomaly -  + ## Expected Returns -## Applications in Unsupervised Learning +4. [Estimate Fama-Macbeth cross-sectional regressions](fama_macbeth.ipynb) + - CAPM tests; polynomial regression; feature transformations -### Topic models and FOMC meeting minutes +5. [Backtesting a stock price reversal trading strategy](weekly_reversal.ipynb) + - Contrarian strategy; statistical arbitrage + - implementation shortfall; structural change with unknown breakpoint -[fomc_topics.ipynb](fomc_topics.ipynb) +2. [Event studies of key developments](event_study.ipynb) + - Abnormal returns; post-announcement drift; multiple testing -- NMF, LSA, LDA, PLSI matrix decomposition models +2. [Performance evaluation of factor investing](quant_factors.ipynb) + - Return predicting signals; performance evaluation -### Text Analysis with 10-K Business Descriptions from Edgar + ## Risk -[business_description.ipynb](business_description.ipynb) +2. [Conditional volatility of cryptocurrencies](conditional_volatility.ipynb) + - Value at Risk, Expected Shortfall, GARCH, EWMA; bitcoin, etherium -- part-of-speech tagging, lemmatizing, multilevel community detection -- spacy, nltk, sklearn, igraph -- Hoberg and Phillips (2016), SEC Edgar, Wharton Research Data Services +2. [Covariance matrix estimates of industry returns](covariance_matrix.ipynb) + - Covariance Matrix: PCA, SVD, Shrinkage + - Risk Decomposition, Black-Litterman, Risk Parity -### LSTM networks, state space models and mixtures from FRED-MD +2. [Visualizing the term structure of interest rates](term_structure.ipynb) + - yield curve, duration, bootstrap + +2. [Examine principal components of bond returns](bond_returns.ipynb) + - Principal components analysis, bond returns + +2. Market microstructure: [Intra-day liquidity from tick data](market_microstructure.ipynb) + - TAQ tick data; spreads, Lee-Ready tick test, intra-day volatility -[economic_states.ipynb](economic_states.ipynb) +2. Event risk: Count dependent and aggregate loss models + - frequency and severity of actuarial risks -- Long Short-Term Memory networks, hidden states, state space models, Gaussian mixtures -- pytorch, hmmlearn, statsmodels, sklearn -- Chen, Pelger and Zhu (2020) and others -### Unsupervised learning models for clustering economic series + ## Econometric Methods -[unsupervised_economics.ipynb](unsupervised_economics.ipynb) +2. [Revisions of macroeconomic time series from ALFRED](revisions_vintage.ipynb) + - Archival-FRED, vintages -- KMeans, agglomerative, spectral clustering, nearest neighbors, PCA -- isolated forest, minimum covariance determinant, local outlier factor -- sklearn, FRED-MD +2. [Analyze linear regression gaussian assumptions](linear_diagnostics.ipynb) + - Residual analysis, outliers, leverage, influential points + - Multicollinearity; robust standard errors -## Applications in Supervised Learning +2. [Forecast inflation time series](econometric_forecast.ipynb) + - trends, stationarity, seasonality, ARMA, smoothing, cointegration + - granger causality, impulse response function -### DAN for text classification +2. [Approximate factor model of FRED-MD macroeconomic series](approximate_factors.ipynb) + - PCA-EM, unit root -[dan_classifier.ipynb](dan_classifier.ipynb) -- deep averaging networks, word embeddings -- pytorch, spacy, GloVe, S&P Key Developments -### Classification models and events text + ## Network Science -[classification_models.ipynb](classification_models.ipynb) +2. [Ego network of principal customers supply chain](customer_ego.ipynb) + - Induced subgraph, ego network -- naivebayes, logistic, linearsvc, mlp, decisiontree, wordcloud -- sklearn, nltk, S&P Key Developments +2. [Centrality measures of BEA input-output tables](bea_centrality.ipynb) + - Graph centrality algorithms -### Binary classification of events text +2. [Community detection for industry sectoring](industry_community.ipynb) + - Community detection graph algorithms -[keydev_classifier.ipynb](keydev_classifier.ipynb) +2. [Link prediction on company relationships](link_prediction.ipynb) + - Accuracy metrics; imbalanced sample + - Random graphs, link prediction graph algorithms -- text classification, logistic regression, stochastic gradient descent -- precision, recall, ROC curve, sensitivity, specificity -- S&P Key Developments -### Sentiment analysis of 10-K MD&A Edgar company filings + ## Text Mining -[mda_sentiment.ipynb](mda_sentiment.ipynb) +2. [Logistic regression for text classification of key developments +financial news](keydev_classifier.ipynb) + - Logistic regression, stochastic gradient descent -- Cohen, Malloy and Nguyen (2020), Loughran and McDonald (2011), and others -- sklearn, nltk, SEC Edgar, Wharton Research Data Services +2. [Sentiment analysis of 10-K management discussion text](mda_sentiment.ipynb) + - SEC Edgar, Loughran-MacDonald dictionary -### Approximate factor models, VAR and TCN from FRED-MD +2. [Syntactic analysis of 10-K business descriptions for industry +classifications](business_description.ipynb) + - Softmax regression; POS tagging, named entity recognition -[approximate_factors.ipynb](approximate_factors.ipynb) +2. [Topic modeling of FOMC meeting minutes](fomc_topics.ipynb) + - Matrix decomposition algorithms -- PCA, EM, vector autoregression, temporal convolutional networks -- Bai and Ng (2002), McCracken and Ng (2016), and others -### Supervised learning models for regression + ## Machine Learning -[regression_models.ipynb](regression_models.ipynb) +2. [Compare classification models for key developments financial news +classification](classification_models.ipynb) + - Generalized linear models, SVM, KNN, Naive-Bayes, decision tree + - Cross-validation, feature importances -- subset selection, partial least squares, ridge, lasso regression -- cross validation, feature importances, dimension reduction -- gradient boosting, random boosting, ensembles -- sklearn, statsmodels, St Louis Fed FRED, GDP +2. [Compare regression models for inflation prediction](regression_models.ipynb) + - Subset selection, dimensional reduction, penalized least squares, ensembles + - Regularization -## Applications in Linear Regression +2. Unsupervised learning: Cluster analysis of factor risk premiums + - K-Means, hierarchical clustering -### Forecasting and Econometrics +2. [Estimate state space economic models](economic_states.ipynb) + - Mixture models, hidden markov models -[econometric_forecast.ipynb](econometric_forecast.ipynb) +2. Bayesian belief networks for fraud detection -- seasonality, spectral density, unit root, stationarity -- autocorrelation functions, AR, MA, SARIMAX -- scipy, statsmodels, seaborn, St Louis Fed FRED -### Linear regression diagonostics and residual plots + ## Deep Learning -[linear_diagnostics.ipynb](linear_diagnostics.ipynb) +2. [Tune word embeddings for text classification](dan_classifier.ipynb) + - Deep averaging networks, Feed forward neural net -- linear regression assumptions, residual plots, robust standard errors -- outliers, leverage, multicollinearity -- statsmodels, St Louis Fed FRED +2. [Recurrent neural network and dynamic factor models](elman_kalman.ipynb) + - Long short term memory (LSTM), kalman filter -### Economic time series and releases +2. Train language model of fedspeak -[revisions_vintage.ipynb](revisions_vintage.ipynb) +2. [Temporal convolutional networks and VAR](tcn_var.ipynb) + - Convolutional neural network, vector autoregression -- revisions and vintages, St Louis Fed FRED/ALFRED +2. Deep reinforcement learning and derivatives pricing -## Applications in Risk Modelling -### Market microstructure + ## Big Data and the Cloud -[market_microstructure.ipynb](market_microstructure.ipynb) +2. Big data + - Hadoop, Spark, Hive -- intraday liquidity, variance ratio, effective spreads, tick sign test -- tick data, NYSE Daily TAQ - -### Factor and empirical covariance matrix from NYSE TAQ - -[taq_covariance.ipynb](taq_covariance.ipynb) - -- covariance matrix shrinkage, PCA, minimum variance portfolios -- high frequency tick data, NYSE Daily TAQ - -### Conditional volatility models - -[conditional_volatility.ipynb](conditional_volatility.ipynb) - -- Value at Risk, GARCH, EWMA, Scholes-Williams Beta -- VIX, Bitcoin, St Louis Fed FRED - -### Bond market index components and interest rate indicators - -[bond_returns.ipynb](bond_returns.ipynb) - -- PCA, St Louis Fed FRED - -### Term structure of interest rates - -[term_structure.ipynb](term_structure.ipynb) - -- bootstrap, splines, yield curve, duration -- Liu and Wu (2020), St Louis Fed FRED - -## Applications in Network Science - -### Social network analysis of BEA industries - -[social_iouse.ipynb](social_iouse.ipynb) - -- Input-Output Use Tables, Social Relations Regression Model -- igraph, rpy2, Bureau of Economic Analysis - -### Graph centrality and BEA input-output use tables - -[bea_centrality.ipynb](bea_centrality.ipynb) - -- igraph, network, centrality, BEA Input-Output Use Table -- Choi and Foerster (2017), Bureau of Economic Analysis, and others - -### Industry sectoring - -[industry_community.ipynb](industry_community.ipynb) - -- igraph, community detection, modularity -- Text-based Network Industry Classification (Hoberg and Phillips, 2016) - -### Principal customers network - -[customer_ego.ipynb](customer_ego.ipynb) - -- igraph, ego graph, betweenness centrality -- S&P Compustat, Wharton Research Data Services - -## Applications in Quantitative Finance - -### Event Study Abnormal Returns - -[event_study.ipynb](event_study.ipynb) - -- CAR, BHAR, post-event drift, order statistics, Bonferroni adjustment -- S&P Key Developments, Wharton Research Data Services - -### Weekly reversals strategy - -[weekly_reversal.ipynb](weekly_reversal.ipynb) - -- information coefficient, slippage, cross-sectional dispersion -- structural breaks, unknown changepoint -- rpy2, CRSP, Wharton Research Data Services - -### Factor investing - -[quant_factors.ipynb](quant_factors.ipynb) - -- return predicting signals, portfolios sorts, backtests -- CRSP, Compustat, IBES, Wharton Research Data Services -- Green, Hand and Zhang (2013) and others - -### Risk premiums from Fama-Macbeth cross-sectional regressions - -[fama_macbeth.ipynb](fama_macbeth.ipynb) - -- pandas datareader, Fama French data library - -### Fama-French and momentum research factors - -[fama_french.ipynb](fama_french.ipynb) - -- CRSP, Compustat, Wharton Research Data Services - -### Current Market Estimates - -[realtime_monitor.py](realtime_monitor.py) - -- UNDER CONSTRUCTION +2. Cloud computing diff --git a/business_description.ipynb b/business_description.ipynb index a9f9f6d..b5bfe1b 100644 --- a/business_description.ipynb +++ b/business_description.ipynb @@ -4,544 +4,195 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Text Analysis with 10-K Business Descriptions from Edgar\n", - "- part-of-speech tag, lemmatize, named entity recognition\n", - "- jaccard similarity, cosine similarity, multilevel community detection\n", - "- spacy, nltk, sklearn, igraph\n", - "- Hoberg and Phillips (2016), SEC Edgar, Wharton Research Data Services\n", + "# Syntactic analysis of 10-K business descriptions for industry classifications\n", "\n", - "Terence Lim\n", - "License: MIT" + "- POS tags, named entity recognition\n", + "- Softmax regression\n", + "\n", + "Copyright 2022, Terence Lim\n", + "\n", + "MIT License" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last FamaFrench Date 2022-11-30 00:00:00\n" + ] + } + ], "source": [ "import re\n", - "import os\n", + "import json\n", + "import gzip\n", + "import requests\n", "import time\n", - "import gzip, json\n", "import numpy as np\n", "import pandas as pd\n", "from pandas import DataFrame, Series\n", "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n", + "from sklearn.linear_model import LogisticRegression, LogisticRegressionCV\n", + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", "from wordcloud import WordCloud\n", "import spacy\n", - "import seaborn as sns\n", - "import igraph # pip3 install cairocffi\n", - "from igraph import Graph\n", - "from sklearn.feature_extraction import text\n", - "from sklearn.metrics.pairwise import cosine_similarity, pairwise_distances\n", - "from tqdm import tqdm\n", - "from collections import Counter\n", "from finds.database import SQL, MongoDB, Redis\n", - "from finds.structured import CRSP, PSTAT\n", - "from finds.busday import BusDay, int2date\n", - "from finds.unstructured import Unstructured\n", - "from finds.edgar import EdgarClone, Edgar\n", - "from finds.graph import igraph_info, igraph_community\n", + "from finds.structured import CRSP, Signals, Benchmarks, PSTAT\n", + "from finds.backtesting import BackTest\n", + "from finds.busday import BusDay\n", + "from finds.unstructured import Unstructured, Store\n", "from finds.sectors import Sectoring\n", - "from settings import settings\n", - "ECHO = False\n", - "sql = SQL(**settings['sql'])\n", - "user = SQL(**settings['user'])\n", + "from finds.edgar import Edgar\n", + "from finds.display import plot_date, show\n", + "from tqdm import tqdm\n", + "from conf import VERBOSE, credentials, paths\n", + "\n", + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(ndigits=4, latex=None)\n", + "\n", + "sql = SQL(**credentials['sql'], verbose=VERBOSE)\n", + "user = SQL(**credentials['user'], verbose=VERBOSE)\n", "bd = BusDay(sql)\n", - "rdb = Redis(**settings['redis'])\n", - "crsp = CRSP(sql, bd, rdb)\n", - "mongodb = MongoDB(**settings['mongodb'])\n", - "wordlists = Unstructured(mongodb, 'WordLists')\n", - "ed = EdgarClone(settings['10X'], zipped=True, echo=ECHO)\n", - "imgdir = os.path.join(settings['images'], 'edgar')\n", - "item, form = 'bus10K', '10-K'" + "rdb = Redis(**credentials['redis'])\n", + "crsp = CRSP(sql, bd, rdb, verbose=VERBOSE)\n", + "pstat = PSTAT(sql, bd)\n", + "bench = Benchmarks(sql, bd)\n", + "ed = Edgar(paths['10X'], zipped=True, verbose=VERBOSE)\n", + "item, form = 'bus10K', '10-K'\n", + "store = Store(paths['scratch'], filetype='pickle')\n", + "imgdir = paths['images'] / 'edgar'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Retrieve business description (10-K item 1) from Edgar\n" + "## Retrieve and process 10-K business descriptions text" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AAPL 2003 business description:\n", - "ITEM 1. BUSINESS\n", - "\n", - "COMPANY BACKGROUND\n", - "\n", - "APPLE COMPUTER, INC. (\"APPLE\" OR THE \"COMPANY\") WAS INCORPORATED UNDER THE LAWS OF THE STATE OF CALIFORNIA ON JANUARY 3, 1977. THE COMPANY DESIGNS, MANUFACTURES\n", - "\n", - "AND MARKETS PERSONAL COMPUTERS AND RELATED SOFTWARE, PERIPHERALS AND PERSONAL COMPUTING AND COMMUNICATING SOLUTIONS. THE COMPANY'S PRODUCTS INCLUDE THE MACINTOSH® LINE OF DESKTOP AND\n", - "\n", - "NOTEBOOK COMPUTERS, THE MAC OS® X OPERATING SYSTEM, THE IPOD™ DIGITAL MUSIC PLAYER, AND A PORTFOLIO OF SOFTWARE AND \n", - "AAPL 2020 business description:\n", - "ITEM 1. BUSINESS\n", - "\n", - "COMPANY BACKGROUND\n", - "\n", - "THE COMPANY DESIGNS, MANUFACTURES AND MARKETS SMARTPHONES, PERSONAL COMPUTERS, TABLETS, WEARABLES AND ACCESSORIES, AND SELLS A VARIETY OF RELATED SERVICES. THE COMPANY’S FISCAL YEAR IS THE 52- OR 53-WEEK PERIOD THAT ENDS ON THE LAST SATURDAY OF SEPTEMBER. THE COMPANY IS A CALIFORNIA CORPORATION ESTABLISHED IN 1977.\n", - "\n", - "PRODUCTS\n", - "\n", - "IPHONE\n", - "\n", - "IPHONE\n", - "\n", - "®\n", - "\n", - "IS THE COMPANY’S LINE OF SMARTPHONES BASED ON ITS IOS OPERATING SYSTEM. DURING 2020, THE COMPANY RELEASED A NEW \n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
20032020
itunes_store160
final_cut110
macintosh_systems100
personal_computers105
operating_system95
high_quality90
personal_computer90
airport_extreme80
education_customers80
united_states80
cut_pro80
inch_powerbook60
macintosh_windows60
video_editing60
real_time60
net_sales57
user_interface50
computer_industry50
personal_computing50
active_matrix50
intellectual_property010
products_services07
apple_watch05
system_released04
property_rights04
apple_form04
digital_content04
research_development03
distribution_channels03
computers_tablets03
reports_form03
competition_markets03
product_service03
relating_aspects03
indirect_distribution03
smartphones_personal03
components_components02
\n", - "
" - ], - "text/plain": [ - " 2003 2020\n", - "itunes_store 16 0\n", - "final_cut 11 0\n", - "macintosh_systems 10 0\n", - "personal_computers 10 5\n", - "operating_system 9 5\n", - "high_quality 9 0\n", - "personal_computer 9 0\n", - "airport_extreme 8 0\n", - "education_customers 8 0\n", - "united_states 8 0\n", - "cut_pro 8 0\n", - "inch_powerbook 6 0\n", - "macintosh_windows 6 0\n", - "video_editing 6 0\n", - "real_time 6 0\n", - "net_sales 5 7\n", - "user_interface 5 0\n", - "computer_industry 5 0\n", - "personal_computing 5 0\n", - "active_matrix 5 0\n", - "intellectual_property 0 10\n", - "products_services 0 7\n", - "apple_watch 0 5\n", - "system_released 0 4\n", - "property_rights 0 4\n", - "apple_form 0 4\n", - "digital_content 0 4\n", - "research_development 0 3\n", - "distribution_channels 0 3\n", - "computers_tablets 0 3\n", - "reports_form 0 3\n", - "competition_markets 0 3\n", - "product_service 0 3\n", - "relating_aspects 0 3\n", - "indirect_distribution 0 3\n", - "smartphones_personal 0 3\n", - "components_components 0 2" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "from nltk.tokenize import RegexpTokenizer\n", - "ticker = 'AAPL'\n", - "cik = Edgar.fetch_tickers()[ticker.lower()] # lookup aapl's cik\n", - "stop_words = [w for c in ['genericlong', 'DatesandNumbers'] # LM stop word lists\n", - " for w in wordlists['lm', c.lower()]] # if \"'\" not in w]\n", - "top_words = {}\n", - "for year in [2003, 2020]:\n", - " files = Edgar.fetch_index(year=year, quarter=4) # \n", - " r = files[files['cik'].eq(cik) & files['form'].isin(Edgar.forms_['10-K'])]\n", - " htmls = Edgar.extract_filenames(Edgar.fetch_detail(r.iloc[0]['pathname']))\n", - " filing = Edgar.fetch_filing(Edgar.from_path(r.iloc[0]['pathname'],htmls[0]))\n", - " doc = Edgar.extract_item(filing, 'bus10K')\n", - " print(ticker, year, 'business description:')\n", - " print(doc[:500])\n", - " words = doc.lower()\n", - " tokenizer = RegexpTokenizer(r\"\\b[^\\d\\W][^\\d\\W][^\\d\\W]+\\b\")\n", - " unigrams = [t for t in tokenizer.tokenize(words) if t not in stop_words]\n", - " counts = Series(unigrams).value_counts()\n", - " unigrams = [t for t in unigrams if t not in counts[counts > 40].index]\n", - " unigram_counts = Series(unigrams).value_counts()\n", - " bigrams = [a + '_' + b for a,b in zip(unigrams[:-1], unigrams[1:])]\n", - " bigram_counts = Series(bigrams).value_counts()\n", - " top_n = 20\n", - " top_words[year] = bigram_counts.iloc[:top_n].to_dict()\n", - "DataFrame(top_words).fillna(0).astype(int)" + "# Retrieve universe of stocks\n", + "univ = crsp.get_universe(20181231)\n", + "\n", + "lookup = crsp.build_lookup('permno', 'comnam', fillna=\"\") # company name\n", + "comnam = lookup(univ.index)\n", + "univ['comnam'] = comnam\n", + "\n", + "lookup_sic = pstat.build_lookup('lpermno', 'sic', fillna=0) # sic from PSTAT\n", + "sic_ = Series(lookup_sic(univ.index, date=20181231), univ.index)\n", + "univ['siccd'] = univ['siccd'].where(sic_.isin([0, 9999]), sic_)\n", + "\n", + "lookup_naics = pstat.build_lookup('lpermno', 'naics', fillna=0) # naics from PSTAT\n", + "naics_ = Series(lookup_naics(univ.index, date=20181231), univ.index)\n", + "univ['naics'] = univ['naics'].where(sic_.isin([0, 9999]), naics_)\n", + "\n", + "# Retrieve business descriptions text; extract nouns from POS tags\n", + "nlp = spacy.load(\"en_core_web_lg\") # Load a spaCy language pipeline\n", + "if 'bus' not in store: # store processed text if necessary\n", + " rows = DataFrame(ed.open(form=form, item=item)) # open bus10K archive\n", + " bus = {}\n", + " restart = 0\n", + " for i, permno in tqdm(enumerate(univ.index)):\n", + " found = rows[rows['permno'].eq(permno) &\n", + " rows['date'].between(20190101, 20190331)]\n", + " if len(found) and i >= restart:\n", + " doc = nlp(ed[found.iloc[0]['pathname']][:nlp.max_length].lower())\n", + " bus[permno] = \" \".join([re.sub(\"[^a-zA-Z]+\", \"\", token.lemma_)\n", + " for token in doc if token.pos_ in ['NOUN']\n", + " and len(token.lemma_) > 2])\n", + " store.dump(bus, 'bus') # serialize\n", + "bus = store.load('bus')\n", + "keys = list(bus.keys())\n", + "corpus = list(bus.values())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Display top words" + "## Generate bag-of-words Tf-idf document features" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "for num, (year, words) in enumerate(top_words.items()):\n", - " wc = WordCloud(height=400, width=500, colormap='cool')\n", - " fig, ax = plt.subplots(1, 1, num=num+1, clear=True, figsize=(5,4))\n", - " ax.imshow(wc.generate_from_frequencies(words))\n", - " ax.axis(\"off\")\n", - " plt.tight_layout(pad=2)\n", - " ax.set_title(f\"Top Bigrams: {ticker} {year} 10-K Business Description\")\n", - " #plt.savefig(os.path.join(imgdir, f\"{ticker}{year}.jpg\"))\n", - "plt.show()" + "vectorizer = TfidfVectorizer(max_df=0.5, min_df=10)\n", + "tfidf = vectorizer.fit_transform(corpus)\n", + "X = tfidf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Community Detection with Business Descriptions" + "## Retrieve Fama-French sector scheme" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Language: en_core_web_lg vocab: 684830 dim: 300\n" + "legacy\n", + "BusEq 395\n", + "Chems 60\n", + "Durbl 110\n", + "Enrgy 117\n", + "Hlth 547\n", + "Manuf 187\n", + "Money 573\n", + "NoDur 69\n", + "Other 209\n", + "Shops 194\n", + "Telcm 46\n", + "Utils 88\n" ] } ], "source": [ - "# Load spacy vocab\n", - "lang = 'en_core_web_lg'\n", - "nlp = spacy.load(lang, disable=['ner'])\n", - "n_vocab, vocab_dim = nlp.vocab.vectors.shape\n", - "print('Language:', lang, ' vocab:', n_vocab, ' dim:', vocab_dim)\n", - "stopwords = {'company', 'companys', 'companies', 'product', 'products',\n", - " 'service', 'services', 'business', 'description', 'year', 'years'}\n", - "\n", - "# Load stock universes\n", - "univs = {y: crsp.get_universe(bd.endmo(int(f\"{y-1}1231\"))).assign(year=y)\n", - " for y in range(1993, 2021)}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Extract lemmatized nouns from bus10K documents\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "A = ed.open(form=form, item=item) # open bus10K archive\n", - "A['year'] = [d.year-(d.month<4) for d in int2date(A['date'])] # set fiscal year\n", + "# populate codes49 industry, company name, and legacy sector\n", + "codes = Sectoring(sql, scheme='codes49', fillna=\"\") # codes49 industry\n", + "sic = Sectoring(sql, scheme='sic', fillna=0) \n", + "codes49 = Series(codes[univ['siccd']])\n", + "replace = univ['siccd'].isin([0, 9999]).values\n", + "codes49[replace] = codes[sic[univ.loc[replace, 'naics']]]\n", + "univ['industry'] = codes49.values\n", "\n", - "tic = time.time()\n", - "for year in [2018, 2017]: #[2020, 2019, 2018, 2017]:\n", - " docs = dict()\n", - " for i, permno in tqdm(enumerate(sorted(univs[year].index))):\n", - " doc = A[A['permno'].eq(permno) & A['year'].eq(year)].sort_values('date')\n", - " if len(doc):\n", - " text = ed[doc.iloc[0]['pathname']].encode('ascii', 'ignore').lower()\n", - " tokens = nlp(text.decode()[:900000])\n", - " nouns = [t.lemma_ for t in tokens if t.pos_ in ['NOUN','PROPN'] and\n", - " len(t.text)>1 and not (t.is_oov or t.is_stop) and\n", - " t.text not in stopwords]\n", - " counts = Series(nouns, dtype='object').value_counts()\n", - " if len(counts):\n", - " docs[permno] = counts.to_dict()\n", - " print(year, len(docs), f\"{time.time()-tic:.1f}\")\n", - " with gzip.open(os.path.join(imgdir, f\"docs{year}.json.gz\"), 'wt') as f:\n", - " json.dump(docs, f) # save this year's docs\n" + "codes12 = Sectoring(sql, scheme='codes12', fillna=\"\") # [5,10,12,17,30,38,48,49]\n", + "sic = Sectoring(sql, scheme='sic', fillna=0) # cross-walk naics to sic\n", + "legacy = Series(codes12[univ['siccd']]) # convert sic to legacy sector\n", + "replace = (legacy.eq(\"\").values | univ['siccd'].isin([0, 9999]).values)\n", + "legacy[replace] = codes12[sic[univ.loc[replace, 'naics']]] # convert naics\n", + "univ['legacy'] = legacy.tolist()\n", + "y = univ['legacy'].reindex(keys)\n", + "print(y.groupby(y).count().to_string())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Text Vectorizer" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "max_df, min_df, max_features = 0.5, 25, 10000\n", - "#max_df, min_df, max_features = 1.0, 1, None\n", - "tv = text.TfidfVectorizer(max_df=max_df,min_df=min_df,max_features=max_features)\n", - "cv = text.CountVectorizer(max_df=max_df,min_df=min_df,max_features=max_features)\n", - "\n", - "# Helper to return an iterable of str from dict of docs dicts\n", - "def iterable(docs, unique=True, key=False, lemma=False):\n", - " for k, doc in docs.items():\n", - " value = \" \".join([k if unique else \" \".join([k] * v)\n", - " for k,v in doc.items()])\n", - " if lemma:\n", - " value = \" \".join(t.lemma_ for t in nlp(value))\n", - " yield (k, value) if key else value" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Document term frequencies and average word vectors, and cosine and jaccard similiary\n" + "## Softmax Regression with Grid CV" ] }, { @@ -553,126 +204,135 @@ "name": "stderr", "output_type": "stream", "text": [ - "3219it [26:22, 2.03it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1592.6109266281128\n" + "/home/terence/env3.10/lib/python3.10/site-packages/sklearn/linear_model/_logistic.py:444: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n" ] } ], "source": [ - "similar = dict()\n", - "for year in [2020]:#, 2019, 2018]:\n", - " similar[year] = dict()\n", - " with gzip.open(os.path.join(imgdir, f\"docs{year}.json.gz\"), 'rt') as f:\n", - " docs = json.load(f)\n", + "Cs = 10**(np.linspace(-4, 5, 10))\n", + "tic = time.time()\n", + "clf = LogisticRegressionCV(Cs=Cs,\n", + " cv=5,\n", + " random_state=0,\n", + " verbose=VERBOSE,\n", + " n_jobs=-1,\n", + " max_iter=2000).fit(X, y)\n", + "Cs = clf.Cs_ # inverse of regularization: smaller is stronger regularize\n", "\n", - " # document term frequencies and average word vectors\n", - " tic = time.time()\n", - " x = cv.fit_transform(iterable(docs, unique=True)) # term dummy\n", - " feature_names = cv.get_feature_names()\n", - " df = Series({k: v for k,v in zip(feature_names,\n", - " np.asarray(np.sum(x, axis=0)).flatten())})\n", - " tfidf = tv.fit_transform(iterable(docs, unique=False)) # tfidf\n", - " vector = np.zeros((len(docs), vocab_dim))\n", - " permnos = []\n", - " for i, (key, doc) in tqdm(enumerate(iterable(docs, unique=False, key=True))):\n", - " permnos.append(int(key))\n", - " vector[i] = nlp(doc).vector\n", - " print(time.time() - tic)\n", + "valid_accuracy = np.array(list(clf.scores_.values())[0]).mean(axis=0)\n", + "train_accuracy = [] # Train set accuracy\n", + "for C in Cs:\n", + " clf_ = LogisticRegression(C=C,\n", + " class_weight='balanced',\n", + " verbose=VERBOSE,\n", + " penalty='l2',\n", + " multi_class='multinomial',\n", + " max_iter=1000)\n", + " clf_.fit(X, y)\n", + " train_accuracy.append(clf_.score(X, y))\n", "\n", - " # compute cosine similarity matrixes between documents\n", - " similar[year]['cosine'] = cosine_similarity(tfidf, tfidf)\n", - " #cos_vector[year] = cosine_similarity(vector, vector) \n", - " #corr_tfidf[year] = np.corrcoef(tfidf.toarray(), rowvar=True)\n", - " terms = (tfidf > 0).todense()\n", - " similar[year]['jaccard'] = 1- pairwise_distances(terms,metric=\"jaccard\")" + "# store intermediate results \n", + "store['logistic'] = dict(Cs=Cs, clf=clf,\n", + " valid_accuracy=valid_accuracy,\n", + " train_accuracy=train_accuracy)\n", + "res = store['logistic']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Populate new DataFrame, indexed by permnos, with sic and naics codes\n" + "## Confusion Matrix" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[389 0 1 1 2 0 2 0 0 0 0 0]\n", + " [ 0 58 0 0 0 0 1 0 1 0 0 0]\n", + " [ 0 0 110 0 0 0 0 0 0 0 0 0]\n", + " [ 0 0 0 117 0 0 0 0 0 0 0 0]\n", + " [ 0 0 0 0 544 0 3 0 0 0 0 0]\n", + " [ 0 0 0 0 0 187 0 0 0 0 0 0]\n", + " [ 2 1 0 0 1 0 568 0 0 1 0 0]\n", + " [ 0 0 0 0 0 0 0 69 0 0 0 0]\n", + " [ 4 0 1 2 3 0 2 0 196 0 1 0]\n", + " [ 2 0 0 0 1 1 1 0 0 189 0 0]\n", + " [ 0 0 0 0 0 0 0 0 0 0 46 0]\n", + " [ 0 0 0 1 0 0 0 0 0 0 0 87]]\n" + ] + }, { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
sicnaics
Non-missing32193219
\n", - "
" - ], + "image/png": "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\n", "text/plain": [ - " sic naics\n", - "Non-missing 3219 3219" + "
" ] }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "pstat = PSTAT(sql, bd)\n", - "vs = DataFrame(index=permnos)\n", - "for code in ['sic', 'naics']:\n", - " lookup = pstat.build_lookup('lpermno', code, fillna=0)\n", - " vs[code] = lookup(vs.index)\n", - "naics = Sectoring(sql, 'naics', fillna=0) # supplement from crosswalk\n", - "sic = Sectoring(sql, 'sic', fillna=0)\n", - "vs['naics'] = vs['naics'].where(vs['naics'] > 0, naics[vs['sic']])\n", - "vs['sic'] = vs['sic'].where(vs['sic'] > 0, naics[vs['naics']])\n", - "Series(np.sum(vs > 0, axis=0)).rename('Non-missing').to_frame().T\n" + "print(confusion_matrix(y, res.clf.predict(X)))\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ConfusionMatrixDisplay.from_predictions(y, res.clf.predict(X), ax=ax)\n", + "fig.tight_layout()\n", + "plt.savefig(imgdir / 'logistic_cf.jpg')\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 3)) # accuracy vs alpha\n", + "ax.semilogx(res.Cs, res.valid_accuracy) #, drawstyle=\"steps-post\")\n", + "ax.semilogx(res.Cs, res.train_accuracy) #, drawstyle=\"steps-post\")\n", + "argmax = np.argmax(res.valid_accuracy)\n", + "ax.annotate(f\"{res.valid_accuracy[argmax]:.4f}\",\n", + " xy=(res.Cs[argmax], res.valid_accuracy[argmax]))\n", + "ax.plot(res.Cs[argmax], res.valid_accuracy[argmax], \"o\")\n", + "ax.set_xlabel(\"Regularization parameter (C)\")\n", + "ax.set_ylabel(\"accuracy\")\n", + "ax.set_title(f\"Softmax Regression: Accuracy vs Complexity\")\n", + "ax.legend(['Cross-Validation Accuracy', 'Training Accuracy'])\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / 'logistic.jpg')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Use sectoring scheme" + "## Feature importances" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -696,220 +356,462 @@ " \n", " \n", " \n", - " sic\n", - " naics\n", - " codes49\n", + " BusEq\n", + " Chems\n", + " Durbl\n", + " Enrgy\n", + " Hlth\n", + " Manuf\n", + " Money\n", + " NoDur\n", + " Other\n", + " Shops\n", + " Telcm\n", + " Utils\n", " \n", " \n", " \n", " \n", - " 10026\n", - " 2050\n", - " 311812\n", - " Food\n", - " \n", - " \n", - " 10028\n", - " 5990\n", - " 453998\n", - " Rtail\n", - " \n", - " \n", - " 10032\n", - " 3672\n", - " 334412\n", - " Chips\n", - " \n", - " \n", - " 10044\n", - " 2060\n", - " 311352\n", - " Food\n", - " \n", - " \n", - " 10051\n", - " 8093\n", - " 621498\n", - " Hlth\n", - " \n", - " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " \n", - " \n", - " 93422\n", - " 1311\n", - " 2111\n", - " Oil\n", - " \n", - " \n", - " 93423\n", - " 7996\n", - " 713110\n", - " Fun\n", - " \n", - " \n", - " 93426\n", - " 3674\n", - " 334413\n", - " Chips\n", - " \n", - " \n", - " 93434\n", - " 100\n", - " 111998\n", - " Agric\n", - " \n", - " \n", - " 93436\n", - " 3711\n", - " 336111\n", - " Autos\n", + " 0\n", + " functionality\n", + " coating\n", + " vessel\n", + " coal\n", + " patient\n", + " steel\n", + " loan\n", + " toy\n", + " warrant\n", + " inventory\n", + " satellite\n", + " waste\n", + " \n", + " \n", + " 1\n", + " software\n", + " chemical\n", + " vehicle\n", + " oil\n", + " device\n", + " aluminum\n", + " bank\n", + " carpet\n", + " construction\n", + " merchandise\n", + " station\n", + " utility\n", + " \n", + " \n", + " 2\n", + " cell\n", + " fragrance\n", + " truck\n", + " refinery\n", + " candidate\n", + " backlog\n", + " insurer\n", + " apparel\n", + " rent\n", + " store\n", + " programming\n", + " glossary\n", + " \n", + " \n", + " 3\n", + " game\n", + " additive\n", + " oem\n", + " well\n", + " therapy\n", + " tire\n", + " licensee\n", + " beverage\n", + " motor\n", + " restaurant\n", + " radio\n", + " recycling\n", + " \n", + " \n", + " 4\n", + " semiconductor\n", + " resin\n", + " helicopter\n", + " roofing\n", + " treatment\n", + " quad\n", + " reinsurance\n", + " food\n", + " mining\n", + " dealership\n", + " carrier\n", + " gas\n", + " \n", + " \n", + " 5\n", + " integration\n", + " lithium\n", + " appliance\n", + " rig\n", + " study\n", + " packaging\n", + " hotel\n", + " newspaper\n", + " mineral\n", + " metal\n", + " communication\n", + " water\n", + " \n", + " \n", + " 6\n", + " founder\n", + " beauty\n", + " freight\n", + " reserve\n", + " hospital\n", + " pulp\n", + " estate\n", + " school\n", + " trial\n", + " software\n", + " subscriber\n", + " energy\n", + " \n", + " \n", + " 7\n", + " sensor\n", + " adhesive\n", + " flight\n", + " fracturing\n", + " reimbursement\n", + " lift\n", + " premium\n", + " check\n", + " staffing\n", + " selection\n", + " spectrum\n", + " scrap\n", + " \n", + " \n", + " 8\n", + " cloud\n", + " ams\n", + " heater\n", + " gas\n", + " drug\n", + " distributor\n", + " adviser\n", + " tobacco\n", + " client\n", + " fulfillment\n", + " cable\n", + " electricity\n", + " \n", + " \n", + " 9\n", + " measurement\n", + " chemistry\n", + " motorcycle\n", + " liquidity\n", + " insulin\n", + " precision\n", + " agent\n", + " snack\n", + " student\n", + " gaming\n", + " television\n", + " frontier\n", + " \n", + " \n", + " 10\n", + " domain\n", + " plant\n", + " wheel\n", + " diesel\n", + " associate\n", + " dealer\n", + " broker\n", + " chicken\n", + " lease\n", + " theatre\n", + " connectivity\n", + " transmission\n", + " \n", + " \n", + " 11\n", + " page\n", + " ethanol\n", + " cargo\n", + " barrel\n", + " surgery\n", + " crane\n", + " fund\n", + " fabric\n", + " pest\n", + " vendor\n", + " fiber\n", + " landfill\n", + " \n", + " \n", + " 12\n", + " threat\n", + " specialty\n", + " traveler\n", + " mine\n", + " hospice\n", + " watch\n", + " card\n", + " bottle\n", + " compressor\n", + " casino\n", + " broadcast\n", + " plant\n", + " \n", + " \n", + " 13\n", + " ehr\n", + " ammonia\n", + " mattress\n", + " exploration\n", + " distributor\n", + " pump\n", + " acre\n", + " golf\n", + " rating\n", + " coffee\n", + " broadband\n", + " lead\n", + " \n", + " \n", + " 14\n", + " architecture\n", + " phosphate\n", + " furniture\n", + " train\n", + " medicare\n", + " printing\n", + " timber\n", + " lemon\n", + " cpg\n", + " catalog\n", + " messaging\n", + " pipeline\n", + " \n", + " \n", + " 15\n", + " installation\n", + " crop\n", + " airline\n", + " subsurface\n", + " gene\n", + " burner\n", + " banking\n", + " beer\n", + " energy\n", + " refrigerant\n", + " telecommunication\n", + " generation\n", + " \n", + " \n", + " 16\n", + " duplex\n", + " reactor\n", + " transportation\n", + " subsea\n", + " salmon\n", + " accessory\n", + " franchisee\n", + " wine\n", + " stockholder\n", + " park\n", + " band\n", + " wastewater\n", + " \n", + " \n", + " 17\n", + " feature\n", + " cellulose\n", + " sleep\n", + " mining\n", + " test\n", + " projector\n", + " franchise\n", + " pop\n", + " subcontractor\n", + " shoe\n", + " voice\n", + " gathering\n", + " \n", + " \n", + " 18\n", + " module\n", + " fuel\n", + " axle\n", + " wax\n", + " tissue\n", + " trinity\n", + " ethanol\n", + " flavor\n", + " knife\n", + " branch\n", + " roaming\n", + " disposal\n", + " \n", + " \n", + " 19\n", + " lottery\n", + " pest\n", + " robot\n", + " petroleum\n", + " antibody\n", + " pipe\n", + " trading\n", + " fitness\n", + " pump\n", + " racing\n", + " entertainment\n", + " appliance\n", " \n", " \n", "\n", - "

3219 rows × 3 columns

\n", "" ], "text/plain": [ - " sic naics codes49\n", - "10026 2050 311812 Food\n", - "10028 5990 453998 Rtail\n", - "10032 3672 334412 Chips\n", - "10044 2060 311352 Food\n", - "10051 8093 621498 Hlth\n", - "... ... ... ...\n", - "93422 1311 2111 Oil\n", - "93423 7996 713110 Fun\n", - "93426 3674 334413 Chips\n", - "93434 100 111998 Agric\n", - "93436 3711 336111 Autos\n", + " BusEq Chems Durbl Enrgy Hlth \\\n", + "0 functionality coating vessel coal patient \n", + "1 software chemical vehicle oil device \n", + "2 cell fragrance truck refinery candidate \n", + "3 game additive oem well therapy \n", + "4 semiconductor resin helicopter roofing treatment \n", + "5 integration lithium appliance rig study \n", + "6 founder beauty freight reserve hospital \n", + "7 sensor adhesive flight fracturing reimbursement \n", + "8 cloud ams heater gas drug \n", + "9 measurement chemistry motorcycle liquidity insulin \n", + "10 domain plant wheel diesel associate \n", + "11 page ethanol cargo barrel surgery \n", + "12 threat specialty traveler mine hospice \n", + "13 ehr ammonia mattress exploration distributor \n", + "14 architecture phosphate furniture train medicare \n", + "15 installation crop airline subsurface gene \n", + "16 duplex reactor transportation subsea salmon \n", + "17 feature cellulose sleep mining test \n", + "18 module fuel axle wax tissue \n", + "19 lottery pest robot petroleum antibody \n", "\n", - "[3219 rows x 3 columns]" + " Manuf Money NoDur Other Shops \\\n", + "0 steel loan toy warrant inventory \n", + "1 aluminum bank carpet construction merchandise \n", + "2 backlog insurer apparel rent store \n", + "3 tire licensee beverage motor restaurant \n", + "4 quad reinsurance food mining dealership \n", + "5 packaging hotel newspaper mineral metal \n", + "6 pulp estate school trial software \n", + "7 lift premium check staffing selection \n", + "8 distributor adviser tobacco client fulfillment \n", + "9 precision agent snack student gaming \n", + "10 dealer broker chicken lease theatre \n", + "11 crane fund fabric pest vendor \n", + "12 watch card bottle compressor casino \n", + "13 pump acre golf rating coffee \n", + "14 printing timber lemon cpg catalog \n", + "15 burner banking beer energy refrigerant \n", + "16 accessory franchisee wine stockholder park \n", + "17 projector franchise pop subcontractor shoe \n", + "18 trinity ethanol flavor knife branch \n", + "19 pipe trading fitness pump racing \n", + "\n", + " Telcm Utils \n", + "0 satellite waste \n", + "1 station utility \n", + "2 programming glossary \n", + "3 radio recycling \n", + "4 carrier gas \n", + "5 communication water \n", + "6 subscriber energy \n", + "7 spectrum scrap \n", + "8 cable electricity \n", + "9 television frontier \n", + "10 connectivity transmission \n", + "11 fiber landfill \n", + "12 broadcast plant \n", + "13 broadband lead \n", + "14 messaging pipeline \n", + "15 telecommunication generation \n", + "16 band wastewater \n", + "17 voice gathering \n", + "18 roaming disposal \n", + "19 entertainment appliance " ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" - } - ], - "source": [ - "scheme = 'codes49'\n", - "codes = {scheme: Sectoring(sql, scheme, fillna=0)}\n", - "vs[scheme] = codes[scheme][vs['sic']]\n", - "vs = vs[vs[scheme].ne(codes[scheme].fillna)]\n", - "vs\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run community detection on edges " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Min jaccard similarity threshold for edges: 40th %-tile\n", - "Deleting 6 vertex IDs with degree 0.\n", - "\n", - " vertices edges density simple directed weak-components largest-weak\n", - "2020 3213 3106737 0.602072 True False 2 3198\n", - " modularity components\n", - "jaccard threshold % \n", - "40 0.075417 5\n", - " Community 1: Banks(359), Oil(89), Insur(86)\n", - " Community 2: Softw(125), Chips(111), Mach(69)\n", - " Community 3: Drugs(459), Softw(107), MedEq(102)\n", - " Community 4: Banks(22), Steel(3), Softw(2)\n", - " Community 5: Other(3), Rtail(2), Drugs(2)\n", - "\n", - "Min jaccard similarity threshold for edges: 60th %-tile\n", - "Deleting 12 vertex IDs with degree 0.\n", - "\n", - " vertices edges density simple directed weak-components largest-weak\n", - "2020 3207 2070202 0.402699 True False 3 3140\n", - " modularity components\n", - "jaccard threshold % \n", - "60 0.130905 5\n", - " Community 1: Softw(214), Chips(121), Rtail(81)\n", - " Community 2: Banks(359), Oil(91), Insur(87)\n", - " Community 3: Drugs(454), MedEq(101), Softw(32)\n", - " Community 4: Banks(22), Steel(3), Softw(2)\n", - " Community 5: Other(3), Rtail(2), Drugs(2)\n", - "\n", - "Min jaccard similarity threshold for edges: 80th %-tile\n", - "Deleting 49 vertex IDs with degree 0.\n", - "\n", - " vertices edges density simple directed weak-components largest-weak\n", - "2020 3170 1034528 0.205964 True False 3 3103\n", - " modularity components\n", - "jaccard threshold % \n", - "80 0.233319 6\n", - " Community 1: Oil(87), Mach(79), Chips(63)\n", - " Community 2: Softw(245), Rtail(82), BusSv(71)\n", - " Community 3: Banks(357), Insur(81), Fin(55)\n", - " Community 4: Drugs(449), MedEq(87), Other(22)\n", - " Community 5: Banks(22), Steel(3), Softw(2)\n", - " Community 6: Other(3), Rtail(2), Drugs(2)\n", - "\n", - "Min cosine similarity threshold for edges: 40th %-tile\n", - "Deleting 15 vertex IDs with degree 0.\n", - "\n", - " vertices edges density simple directed weak-components largest-weak\n", - "2020 3204 3106986 0.605508 True False 1 3204\n", - " modularity components\n", - "cosine threshold % \n", - "40 0.093159 4\n", - " Community 1: Drugs(465), Softw(156), MedEq(126)\n", - " Community 2: Oil(97), Util(75), Mach(71)\n", - " Community 3: Banks(378), Insur(83), Fin(63)\n", - " Community 4: Rtail(95), Softw(71), Meals(37)\n", - "\n", - "Min cosine similarity threshold for edges: 60th %-tile\n", - "Deleting 15 vertex IDs with degree 0.\n", - "\n", - " vertices edges density simple directed weak-components largest-weak\n", - "2020 3204 2070790 0.403568 True False 1 3204\n", - " modularity components\n", - "cosine threshold % \n", - "60 0.174424 4\n", - " Community 1: Oil(97), Mach(78), Util(74)\n", - " Community 2: Drugs(464), MedEq(124), Hlth(39)\n", - " Community 3: Banks(381), Insur(82), Fin(59)\n", - " Community 4: Softw(200), Rtail(96), BusSv(52)\n", - "\n", - "Min cosine similarity threshold for edges: 80th %-tile\n", - "Deleting 15 vertex IDs with degree 0.\n", - "\n", - " vertices edges density simple directed weak-components largest-weak\n", - "2020 3204 1034594 0.201628 True False 1 3204\n", - " modularity components\n", - "cosine threshold % \n", - "80 0.344024 6\n", - " Community 1: Oil(97), Mach(78), Util(73)\n", - " Community 2: Drugs(456), MedEq(100), Hlth(36)\n", - " Community 3: Banks(359), Insur(75), Fin(51)\n", - " Community 4: Softw(246), BusSv(70), Chips(51)\n", - " Community 5: Rtail(101), Meals(40), Clths(24)\n", - " Community 6: Banks(21), Steel(3), Softw(2)\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMAAAADQCAYAAABRCm6cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB5XklEQVR4nO2dd3wcxdnHv7N7vejUe7Pcey/YdELvNUCAEAglgRBICCEFUkgILyR0EggJPfTeq2kG3LstW3KRrN5P0vXb3Xn/OFmWrJOs5pLgH59Dvi0zz+7NM/PMU4WUkoM4iG8rlP1NwEEcxP7EQQY4iG81DjLAQXyrcZABDuJbjYMMcBDfahxkgIP4VuMgAxzEtxoHGWCIEEKUCSGCQghfl8+D+5uug+gfTPubgP8RnCql/HiwNwshBCCklMYw0nQQ/cDBFWAvQQhxqRBikRDir0KIFiHEdiHEiV3OfyaE+LMQ4isgABQJIY4TQmwWQrQKIf4uhPhcCPFDIYRFCNEshJjc5f50IURACJG2P57vfwUHGWDvYi6wGUgF7gT+3THb78TFwJWAG2gFXgZ+BaR03DcfQEoZAZ4HLupy7wXAJ1LKhr38DP/TOMgAw4PXhRDeLp8rOo6XSykflVLqwJNAFpDR5b4npJQbpJQacCKwQUr5asf3+4HaLtc+CVzQhYEuBp7eq0/1LcBBBhgenCGlTOzyebTjeOcAllIGOv7p6nJfRZd/Z3f9LmNeipVdvi8hJiodKYQYB4wC3hzex/j24eAmeP+iqytuDZC780vHTJ+72/VPEhODaoGXpZShvU7h/zgOrgAHDt4BJgshzhBCmIBrgMzdrnkGOJMYEzy1j+n7n8RBBhgevLWbHeC1gTYgpWwEziW2WW4CJgDLgXCXayqAlcRWji+HhfJvOcTBgJgDE0IIhdge4HtSyk+7HH8MqJZS/na/Efc/hIN7gAMIQojjgSVAEPgFIIDFXc4XAmcB0/cHff+LOCgCHVg4BNgKNAKnEtMuBQGEELcB64G7pJTb9x+J/1s4KAIdxLcaB1eAg/hWo889gBBi0MvDGeZzaZZNfKEtHGwTB3EQwwYppYh3fK9tgiepU6kyKviC/14GEEIlNW86uWOPwe5Kw99WQ0XxBzTXbIB9JDp60scw+fAfgxjcYt1YsZJNS57cZ/T+t6HfDJAkkjnOdDKZSjZVxg7ej76Fjs4ZlvN4PfISQQKMUEYyTpnI+9pbSCBRJHOx5XJMmHg3+gZ1MuYZMFGZzGHmo1FQWaktZYn+FRKJHQfHmI9nhDKStfoqvtI+R0MjR+RxlPlYUkQqxfoGPtM+IkJkb72TDgjGzbuUQ868E6sjqfNo8Ds38tlzV1O29o293H8MrsRcJh9xLUJRB3X/lhUvsHnJ00j0YabsfwP9mlYEgptstzJWHU+psYk0kY5DOLELJxdbLschHACMVMZwqvksRMd/x5tPISSDpItM7rDfjx07mSKbv9jvo8Vopt6ooVAp6iBE4We2XzFbPYQdRhmXW37M2eYLABijjsOCle3GVq60/oTjzCfvpdexC46ETGae8GusjiSEEJ0fuzuDWSf8FrPVvddpOIi9j34xgEQSkRFs2Nmil/Bo5CHqZV2f9wjgk+j7vBR9lofCd5MiUilQijAwOtv8TPuYF6JPI5GkinSON5/CNqMUFZVyYzsnm8/AhJlvtC9ZoS8lIsNUG5WMUyYO+cH3hMT0MTiT8ujuvQxCCDzpo3En5+91Gv7roZpwH3kaOX/8N3n3vELmL+/FlJrV7RIlIYmsXz+AbcKM/UJivwXLv4X/TKmxid/b7+Av9ntJFEk9rlG6NCeRtMhmACKECeAnQXiol7XcFPwJk9SpPOx4mu+aL0IgcAgHNmy4hJtkkUq5sZ3nIk9iwsQf7HdyoeX7OIUbHR1lkPLwQGCxJ6Ao8SVE1WTFZHHudRoAwsEWard/Q1PVWtqathP0NRIN+9GiQXQtgmFoHKiqbMfUQ8j5w6NILYp/6adoDTXISHf/PdXpxjXvWMyZ+2dC6fceICgDPBH5J69Enud+x6PMUw9lsb4IBQWncNEimxmtjkUVMVlVIChSR6Gi4hFJeEQidbIWBYUtxmZ+H/olk9Rp3GG/l/e0t2iVXppkI59GP6TY2IBAQUHgEUnMVg/he/4zqJe1zFTn7LWX0RXRsA9p6Ai15yvStTDRiH+f0NFYsYo37j8G1WRDNVlRTVbMVidWRxJWRzI2RzJ2dzqTj7iWhNQR+4Sm/sI+cSa6t4m6e3+F3tYS95pobQXbf3AEWmvzPqYuhn4xgAkTv7H9CYuwIBA4hZvNRjFtso0l2tf8xX4v2/Qt5Cn5BDrc3nV0Rigj+YP9TnJFHt9oi6gydjBKGcP1tptpMOrIULJYra3AL31oaPw7/Hf+aL+LrUYpDpx8qL3Dh9F32WJs5mbb7/BKLwXqCBq1vR8E1VpfSqCtBmdibjcxSEqJt7YYX3P5XqdhJwwtgqFFiPZyXjXZGDH19D4ZwJyZj/OQ79D2/gvYxkzFPmUuMhLCt2QhkbLNu67LLcI56wjUhCTC24vxL/8CGezC7EJgyRuFc9bhKC4P4S3r8a/8EhkKdpxXcM49CuuI8bgPOwnF7SHlouuR0TDh8lLaPn4FDAPF4SbxjEtRnW6kYdD2yWvd6BBmC55TLiKw/AsUtwfHtPkgJYFViwhtXgtdwqcteSNxzjkKNSkV0SEdSF3D+8aTaE19i+r9YgANjUfC95Gr5COBMmMrjR2ReH8J/Y6x6ngkUGGUkSxSMDB4KvwvAgTIEtkoQqFEL0ZDY5uxhftCd5IokvDJdrYYJWhoALwSfZ7F2ldkK7kE8LNVLyFMiBsD1zBaHYdf+qiXddix9YfsIcHXWs2ahfcy55Q/YrI4Oo/7vZUseftWomHfXqdhOGHOKSTt8psxZ+TiPvwktMY6TMlpyGikc+C5Dj2BrJvuJVpfhdZUR9KZPyC8dSPVt/0YvbUJgISjzyDjhv8jWl2G5m0i6ewfEtywjJrbr8PwtYIQ2EZNwpxbhGJ3IkxmTKkZyGgEraWR2O6Q2AA2DExp2SSd/n0iZSU9GCDlwp+QcORpmNKyiFRsxZyRQ9oVv6bq1svwLXofAPuk2eT++UmCG1cQrask4ajTUT3JND51D1LX9vxipJS9foi53X5rP4pqlnnjj5MLzr5Hfuf7z8jZJ/9eJmVOkCD2O21dP6rJJs+44XP544dkj89xlz0vhVClY+bhcvySdpn7l6elmpwuMZmlsDmksFhjbSSmyFGvrJGZP79LCptDoqjSkjdKjnptvUy78jcSkKa0LDn6rU0y/Zo/SGG1SxRVWosmyNFvl8iUi67vQVfq5TfLkS+tlIrD3SvtprRsOe7TGplwzFnd373DJUe9ulaOfmuTtBSMkSiqVNyJsvDRj2TeX1+QKIoEZPYt/5AF/3iv8zlcC46XYz+tkZYR47q119sYP+gN2gcMPUpF8YdUFH+4v0kZHmgaLa8/jt5cD4DUdglVtjFTMKXn4H33OWQoJsZGKrbQ/uW7uI84hcan78E+YSaqJ5nW955HhmMiT3h7Mb7FH+M+6jSaX3y4xyZ3qPB99QGRHaUgJUa7l9DmNTimHhIzDAqJmpSG1lSHjMbsQlpjHUIIVEf/1NQHfYG+RZC6htZYG/ecKSUTGY2ge5u6HdfqKjElpaFYbJhSs5DhUPcNrZRo9VWYUjIQZvOw0xxtqKarFVvqOuw0CkqJf9lnOKYegnPm4VjyR5N4yveI1lcRqdzWr/YPrgDfKkh6c4nQfa0I1YRid3Q7rrgTMYJ+pKaht3vBZEbYul4jUFwejEB7bHAON4y+c4V533wK1/zjyP7dP9GaaonWVVL1+ys69yx7wkEG2FdQFEhIgNbWXgfh/kSoZC1GyI9z9pGEt28CKVGcblxzjiKwbilGwEeoeBUYOs4Zh+LtmGGVhEScsw4nsPqbTrFoX8KSPxJLTiE7fn4OkfJSpKZBfza/HTjIAPsIomAElvsfJvyDC6HxwMtlpdVX0fjEX0n9/s8xpWUTrS7HteB41KRUmm6/FqRBpGobTc/cT9pVt2DOGYFWX437iJMRZivNz/99QIxtzsrHnF2IOTMXYbFimzADvb0FvbWFUMna/hNuGKgJyWTdfD96azPoGuHyUryvP06kYusebz/IAPsIsq6W6D13Qqt3v/RvtHsJrPoKI9iLAU9Kml98hGj1DjwnnId94kxCpeuoe+C3u9SThkHT0/cSqdhCwrHn4Jg8h+Cm1dTe9fO4gy1aU05w/XKk0XNGdh1yLAnHno1QTQQ3rcYxZR72iTOJ1uyg5i/XIQ2d4LplRGt2dLsvUrEVxeECKRF2J4mnXkxo82qCG1YgtSjCasM192gc0+az4yenYQT6Vlf3GRE2lHiA3VpCUU1YbB4sdg+q2YaimJCGhhYNEQ60EAm1xX1R/w1Qps9EpKQixo7DWLkckZSMyCtA+8+T4GtHPf4klHnzoa2N6CMPQiCmZVFmzkEkJYHNjjJ5CsaWUvS334BgRw6tpGRMJ52GyMvHWLca/eMPIBzu0b9qsnHqTz4ge9ThPc5tWfECHz3+PWLJ6QTQ35+0P9cKUkQqZszUyup+trt7H7uj/0PONf84sm99mO2XHUW0epdh0nnIseT+6XG2XTS/k4H2eTwAgNWRTMaIueSOOYb0wjk4E7Ox2hNRTTYU1YSha+gdDNDeXEbNtq+oKP6QxsrVaJHAnjsYJBJSihgx7UxE3B9gz2iu2cCOje+z88dSJk/FdP5F6As/wvrgv9BefQFlxmxkYwP6Ky9grF8HCR7MP/sl0ace28UAU6Zh/unP0V57Gbm1FPNV1yBSUtEefgCcLqz3PISsqcZYswrTxT9AGTchtorsYWPYOwYyn+35WgXBzfY/kKvkc4nvLKIDdlEf4vyqqAizBTUxlWhtBUhQPcm4F5yA1lSH3t66xyb2CgM4PTmMnXsxY+ZcjCdtJIpq6eFVCXT6tdhcKXjSR5Ez9himHXMjDRUrWP/FPyhf99Ze8blJyhzH/DPv7DSbDxSbFj9JRfEH3ZzQjA3riD72T9RTzkB7+nHUtjaU/EJ0QFZVYKxcBtGezgyyspLo/90GoRAIgXrMcWiPPIgyaw4iJ5fIH34LAT+yuQnLH+8g+s+/Q3vbYB99WGFgsDD6AR7hQWffr96B1V/hX/opeX95hmh9ZYwBklJA16m95+aYZXoPGFYGUFQLRdPOYtaJt5CUMQ6hDGyACSEwW51kjTyMjMK5VG76hCVv30JjxSqGPFvsZUi/P6Z9CPhjg1nTwGrd433GjjKIxGZO2d4OZgsgEDm5iMIiLH+9H5CgqBgVO8A0uMCYgcDa4WoSJoQVGxYsRIkQItTlGitWYeMr7TOiMtrp5r477Dgwi132AYkkIP3owxCgY/jaqPr9FVhHTsScmQsStOZ6wts3YfTifLc7ho0BLLYEZp10K5MO+zGq2RZ3xu8vhBCoJiv5E08kJWcKX7/6c7aufgVpHMBRTTtXg4HyaS/ijKypRm4pIXzVpeDv2MgJ0Sk+7U1cbbueBJHAcm0JV9iuJVvJpUIv58f+79PQEQdyrvUivm+9kiSRzDfal9zgv7LTpwtiDpTfs17GOZYLcQgnySIViPmR/SrwUzbpG/pFi92RSkr6OCrLFvU4Z7a4yMiejgwY1C/6hGhk4P5Zw8IAFruHw869n9Gzv4fSS+hep7ggjQ4/DB0h1BijdIgi8YJPnIk5HHnho1jsHoq/fqxjMzc0RMI+WutLMVmcmCx2TGYHiskc2xPEirV0o2FIUFXEmHEoEyYh3G7UmXMwyrchS0v6vM1YuhhZV4vlltswFn8FiUkQDKA9+Rjs5UIyCSKBUy3nUKgU8a/QQ7RKL5lKNj65S/R6Jfwcn0Te5xbHX0gWKey+oZ1vOoKf2X7DTYFrWa+v5hzLhVxl+ym/C/yCUn1T/2lJyueQY35LyfpXsVjdbN/8AY1161EUM0ef8jdGjDkeQ+rU7FjK+69cMWAmGDIDqCYb8067vdfBL6UkGmqjrmwJ1aWf01S9nkB7HYYeRTVZcSXmkJI7lZzRR5GaNx2T2d5t0AkhMNvczD/zr0TDPkqXP89QxaHarYt4+a55mC2ODiZwYLEnYHOmdHxSsbvTGT3zfJyJ2Xtsz9i4HlFXC+Ew2usvIQMBjDWrwGIBqw3TKWeAJwH9vXdQDjsCZfwEouUPYmxYh2z1dq4ecksp+ntvxZ7P7yN8/Y8wnXgqYuw4aG1D/+qLvT74d8IhHPwp+Bu2G/F16UEChGQQn2zHIzw9zs8yzaXCKOfz6MeECPJ65EWusv0Ul0gYoPgjyBtxOA5XOqFACxOnX8TrT5+NpkfIH3k0bz53IYH2Ok654BlyRxzG9s3vDeg5h8gAgvHzL2f8/MvjDn5di1C27k1WfXQXTVVr0LWeKrw6YOuqlzFZHGSOOIQZx91M9pgju0VjdWWC1sat1JctHRLVUhpEgl4iQW+v16gmK+kFs/vHAMt30aM9+o/Ysa935a6N3vXn+Pct/QaWfrPr+/o1GOvX7LrA60V7bv/UwKg2KqkwBh/z0CbbcAs3dmEnJIMkiWQAfLJ9wG011Rfz8uMnEwp6OfS4P5I/8mh2bF2IEAotjaUE/Q2UlX5MZs6MATPAkJzhkrMmMuP4X6Gaem72omE/S9++lU+e/D715UvjDv6u0CIBKjd/wvv/Opd1nz6ArnVXqQkhcHiyOOT0O7DYE4dC9kH0A1EZRQ5hpX0v+gZBgtzv/De/sv+RPznu4f3IW2zWNw6oHWlo+NpqCAWa0bUQ7d4dOFzpKKolJq52rJ7BQCMWa8KA6Rz0CiAUE9OP/QVOT88Z0tCjrProTlZ/8rcBG7ciQS+L3/oNqtnGxEOv6qZJEkKQNeowxs65mHWfPzBY0g98KCq2vNGEq7Z2c1n+b0KDUc8mfQOGNKgyKrgz+AeWal8TZmDu0r72WhyudCbPvow27w7GTT0fgSA9eypmsx1XQjahkBdPUiH+9viern1h0CtAWu40Cief1mOTKKWksuRT1iy8Z9CWXT0aZNk7v6exclWPgG8hVCYd/iPs7oxe7t63UF2J2IsmDWub5sRURv7m31gyDszMEwoK6SKDfKWQBOHBIVzkK4VkiCzMxFSeaUo6R5mOY6n2Fcu0b6iXtaQoqagMTI0b8NWz9PO7mDb3Ko459T6qd3zDp+/8HG/TNpZ+fhffOeNBTjr3cUaOP4XyLZ8M+FkGuQIIRs++EIu95+ZHiwZY/dGdRMMDl/W6IuirZ/Unf+Poi59ANVl29dyRlqRg0sls+uaxIfUxHHBPPRTXhDlUbtvAcNkqot5Gtt52KeHafRd33BVe6aVe1vYqAiWLVB5wPk6KkoZbJKCg8C/Xc7TLNm4N3MgafSU2bNTJWn7ruJ2ojCIQGOg8G36Ce0N/6aYy7RuSzeteYnvJ+6iqhVDQi5Q61TuWoCgm2tuqycqdxcev/4S6qpUDftZBMYDNmULBxJPjzv71Zcuo3fb1YJrtgfIN7+Gt20RKzpRuxxXFxOiZ51Oy7D8Ye9hb7C0oNgfpZ11NytHnodgd2HJHofu8lD94E0bQR8ox30XqUcwpWbgnH0KwooTqp/4PaWikHHkOCbOPQbU7CWzbQN2r/0BvjxluEhecTOqxF4BQKL/vBqLNMb27a9IhuCcfghGN4Jo4l2hzHbUv3EekvqIvMgeFR0L3oqBiYOAQTsaZJuNWdsnXURnlSv+FaLLnIA4R2/A+4Hyc1yMv8EbkJaIygipMfMd8Ir+w3cqz4ceplpU97u0LkR4TqsQwomxa8zyb1jw/mMcEBskAydmTcKcUxD23fe0baNHh8QuPBL2Ub3iP5OzJPZgtLX8G7qQ8Whu2DEtfA4URDdO88BUsaTkoFhs1z92N1DWMcMxQZc0dSfIRZ1L/5r+oe/0RFIstJs93mBmaPnoeGQ2Tc9mtGOEAtc/fC0Db8oVE6qsYecvjKNZdgSfm5HSyLvgZ1U/fSd3LD5Jx5tVkX3IzZXf/ZNifbWfaSStW/ux5kHGmSTQbTexc4VqMZn7ZehV+4uvck0UqBWoRy4OLqTJiDGqSJgIygIY2YLcJi8VNTuF8EpIKY9pGSafZYfvmD/A279ntuTcMigGyRh4a24XvBi0SoGbr8Jauqir9lKlHX99D02Sxe0gvnLvfGABdJ1yzHa21GcVqJ1RR2v28EAS3b6T+zX9BVwu2hOYv3sCSnovJ6SG4fSO27JGdp41wkGhjTSywYzeEqrdR/9a/MEIBVEcC2Zf8Mpa3aC95iaSrWeSrRVzWfCYNxq4NpoQ+B3GNUcVS7Sv+4rifJdoiojJKjpLHNNNMHgv/nQZZ328aVNXKMaffT9HYE/C11fQwhDY3bN63DCAUUw+RZCeCvnramsoGTUw8tNRuIhJqw+5K606HUEnLnU7psmc5UP2Eoi113Qc/YE7JovD6e9DDASK1FTFtT01Zv9rTvE2dWiEjGkaIvesXpEmNZqMRr2wegMwOAfxc57+cQ01HMUYdj4pKqbaJv4X+TIm+sVe/oXjwJBeSV3Q4b/znu9RWLOvBAMYQXegHzACqaiYxfXRcFwFfcwXR0NA2v7sj7G8m0FobhwEEydmTEEIZFveIwULqGorF1k0nvetkT8b0zDoaxZnA1j9dhhENk//jv6DYHD2u66W3oRM8ADQZDdQbtfzE9Su+DH9MWMb2W1EibIyu6dOi2y7beC/6Bu9Fh5ZFW1WthINeaiuXo2nDH3I5YAYwWRzYnClxz/m8FcPusKZrYQJtNaTkTO5xzuHJQjVZhm3PMRj4ipdR8JO/knflbWhtLdS+8lCfqUFCFVuwpGSSddEvUMxW7IUTCFdvj51UVBIPOQF7/ljMSemkHHc+obLNtCx+dx89TXckK6kUqkW4zTOYazkc2TFztxhNXO+9FL/c+8nB2tuqCIdaSc+aQvWOJQz3JDBgBrDYE1HN9h7HpZSE/E3IYfZVMQyNcKAFKWWPVcdic2O2uvcrA7St+JRtf7kCW+4ooi31ndnIWr58E8XUM02Ir3gpW/90GfaCcUQaKql75SHMOzMmC4FQTERbGqh4pKMKqqogEPg3rURr93a2HyrfRNVTt8f2CnH2Y8OBOqOaH7acjUCgoAISAwOJJCj3vlcqxIyqdVUrOfm7T7O95H3aWyu7jbEtG9+kuWFzHy30jYGLQB3hjPEQSxc4zMu0NHoNilFNVhTT3vnx+w1Dx1+8DH/xsm6Hg1vXxb9eSgKlqwmUru48FGmoiv1D12j5Mr7IEKmv6KbyjLbU07r0oyGRvidIJCoqp9svYLZlPhoaX4Y/5v3g63u1365wuTPJzJ1FwFdHRvZ00rO7V4itrVy+bxlAUUy9Visx9L1jtje0+KF2imLqlRkPYuhQMfEL922kqZl8E/4Uk7Bwrv0SctR8/uG7a0i+Qv1Fc2MJz//z6F7PD1XiGPjokUav6S8GG2K4R/TSrpRyn/wI31ZkKFmMNI3hmpYLaZVeAD4KvcX/ef7Bk+If+Afh2TkY9DbIPUmFRCJ+gv7Bp5kZ8IjV9ShGHAsgENcrdDjQW7uGEUXupVXnIEAVKhpat3psIRkEBMogEwoMJ6bOvZLcEYcNqY0BrwBa2BdXJBFCYLF54qsDhwChqFhsCXHVrno0hKYNbzLWg9iFer2WkAzyY9cv+SL8ISZMnGr/Lpu0dfjl3isQIoSColrQtRAg4k6AArA704ZcLWjADBAOtvaaG9/uTkcIFdnLCjEYKKq5V7VrpA9aDmLoCBPiT2038WPXTdya8Fd0dL4Mf8y/fPdh7MWqk4Wjj2PWodfzxrPn4XJnc+K5j8UVrxNTiigr+WBIfQ2YAXQ9jK+lAk/aqB7n3Mn5KKoJfRgTXJlMtl6jstpbKvpXBOEgBo1KvZzftF6LBSsSSZTIXt93tTRtoWT9K+jRMGaLE6vNw9qlj2LsZmOaMO3CIfc1YAYwtCjNNRvIHn1kD7HE4cnG7kzD5x0+D0WHJxubK7XHcSklzdXrht3ucBA9IZHdAlkuc17H84F/E9hLYpC3aQvepg4fLylprF3Pyq8f7OH2kJQ6esh9DUKAktSVLYkbnG1zpZCYOXbIRHVFau7UuDV5paHRUDFw/++D2DMUVNSOudGECRPmzo9N2JlrOQwz+8b+0tJUytef/DGuz099zRoCvv471sXDoJTodduXEA609JiZFcVM3rjjqNz0CcNiEBMKeeOPixtwH/I30bDjIAPsDVzguIxsNZ9n/I/wO8/d3aK4VKFSqPYUf/cWIuF2Guvi5xBav/yJIYtjg2KA9uZy6sqXkj/hxB5iUOHkU1j10Z2E/I1DIgzAlZhD7thjehyXUlK3fQn+1sEkZD2IPWFlZAlblM04hBO3SOA/gX92DjQTJi5x/ng/UxjDcDhBDooBDD1C6bJnyRt3LELd5e8ihMCTNpqiaWey8atHh0iaYMzs78UNupeGRumK5/9rs0kf6CjWYvn5s9V8Pgt/wLuhVzvPKSgcZzudfeWZarY4KRp7EmWlHxEOeYe9/UErUcs3vEtTdU9/F0U1MfWYn+NOGVrR5uSsiUw6/JoebhdSSpqq1//vFK47gFGjV/CYv3v2DQODe3234dsHnqAACYn5HH7Cn7HtpVQ4g2aAcKCFNQvvjZvvJzF9DIeefTdWZ/Kg2nYkZHHoeffjTMzpcc4woqz7/EHCgf1TWfzbBImMG/m1Vdu8z7JBC6Gia2FCfSQxGwqGZEbbtuplyta9HSd1iaBw8qkc/b1/k5BaRPxCCPEgSMqcwDHff4qc0UfEDbqvKP6IrStfHArZB9FP2ISd0abx3Y6ZMDNSHYuyjwqMtnl30NZaSVpWz3iQ4cCQXCm1aJDFb/6KpMzxJGWO757TU1EpnHI6ydmTWPf5Q2xf8xo+b1VHwExXhhEoiglXcj4jZ5zLpMN+hCspL+7gb28qY/EbN+8l66/o4NNY2QyhmHpNjCsUFaGYwNA6nkR2PNK+cszrTquimnp1RBRCQagq6HLAtGYreVzjupmfey/rjP5yChe/TriDn3q/3y1Z7t6CoUcoXv0cR5z4f2wtfos2745uE25l2SLavTv6aKFvDEuJpOzRR3Lspc/g8GTHHbhIg0B7PU3Va2muXk+gtQZdC6OabTg9OaTkTCY5exJ2Z1rcmgKxYJtGFj79A8rXvzPAR+x4FkUlKXM8NmcKZqu7M5jGYnNjsSVgtnuw2hIw2xOw2DxY7R6SMsdjtrp6tBXyN9FaX0ok1Nb9E2wjGmonEm4nGmonGm4nEmonEmyluWZ9v93FhaKSlDEem6sLrTY3Fqsbi90To9eWgNXu6fzbK62BFlrrS4gEu9Ma7fy7k14f0XA74WArLTUbEJrOSNM4rnXdzE2tV6J3uLdkqbn8NfHfXNZ8Bu1yzwUohoqU9PGcduHzmMz2mCZqt/H6yZs/ZXs/3CF6K5E0TDXCBHnjj+XICx+NO3vHIaZrH3u8NthexxcvXMu2Na8O2tHO6kjmjBs+JzFtdEfkldIxa4qhp0DfjV6QSGnErNRSEg56efn/ZuNr6Z+FfP/QGpuowgEvb91zNOf4T+RY26mMNI2hVCvuUIMKEoSHpZFF3NZ244AC5QcLIRRUk61XIVrTwv1Sh+7lGmEx2fyDf53DYec9SHr+rD6rw/T3R5TSoLl6PV++9FOqSz9nKCLGzqIbqnnvuGx37Sc2UHc9v8nUETQ/gDb2F62q2YYuDJ4OPEyxtpbLnNfxqO8eDHQkEJR+SrSN+2TwQ2wMaNG9F345jOFUkvryZbz7yGlMO+ZGxs+7FKszZVAzlpSScLCF0qX/YdXHd/V75jyI4UNA+lkVWcK7yit8E/ms36lMBArHFl1FnmeQ+VKlZEnVK6xv+BQAmz2ZEWNP6HUcVW7/krYh7AGGPZ4w2FbH4tdvpmTpM0xYcAUFk07GlZgb2zj28hA7RSJpaPhaKijf8B7F3zxGU9WaYcsyIYnNJrt7FO4LxEShAVzPfqa1g9h22caLwScGdL8iFGZknczMrJMH2b+k1r+lkwGcCZnMO+rmbqGvJpMdpzuTlsZSvE3bDiwGgJiJuqlqDV++dB0r3v8TafmzyCpaQGLmWFyJuZitbhSTGT0aJhL04vNW0lJbTO32xTRWrCLoaxj2SiiRYCsfPnZ+TBzZh1BMZrKnn4wxgJLLe4tWxWQmf953sbiSaKsqpnb9Jz32VIah0d68KylvnlrIYdZjcQpn57GA9PNS4Cki7P28rM31m3jmoUO6HBGYLQ4KRx/H6Iln0FRfPKT2925EuTQItNVSvv5tyte/jVBMKKo5ppoTIrb5MoxYaONenu2kodFUuXqv9hEPJpuLCRf+GduKlwk090+U21u0CkVFMwsKF3wPW3YRdW/f3udE4xQu7kz8J+1GG/mmEZRENzDCNJpF4YWdOYL2NmScrCDRiI9Na55n4vSLyMiZwY6tCwfd/r6xZnRAGhp6NIgW8RMN+9AiAXQtNODBb8XGb8y/Z4TYlVNTQeWHpquZqcwebrJ7IJFE/my+i4ctj3Oh6ZJ+3iVQLQ5Ui53uhkGBarZhsrpQdgv9U8xWhKKiqBZMVme3fKyKyYJQTQjFFDu3+70mKyarM5Y7tAPS0Gko/oLmbct7GC/jIUVJx5AGN3gvZVH4Ex7w/YXrWi4mRUlD9DJ0JJLq9k2Ut66j3l9Ge7iJkOYjogfRjAiG1PvV954gFBMmsx1LHNXvQPBfmVPEhInvqMfzgf4u22UsMapAkCGycDK0F9IftNPOo9o/uNZ8PdOVmTzLU31eL4Qgf965uDN/jcnmYvvnT1D29XMgJQXzL6Bg/gWoZiuGFmXjm3fQsDmWYHjKeX+irXIj6eOPwJFaQP3Gz1j/2m0gDUYdczVCUXClj8STO4H22i2sePI6DC1C1tTjGXX0lahWB8GWata/ehv+hu0Dfk6JQZQIutRpMZrJV4tYGllEhpqFTdiIyJ4ikCF1nl3/a17a+EfMqhWTYsVucuOyJOE0J+GyJOGyJJPtHsvRIy7HrPSt6bI7Uxk98cxumiohFDJzZpKQmDeknEDwX8QAsQGeiRMX7bKt257SiYtckcer2otUxck7b8NGlsgBJFWyqpvsmkQSqSIdHZ16WYeP9i732ckWORjoVMuqzuwIOjplchu1soYMkblH2hWzFaRk2b+vxp05mpmXPkDTtmW015TQvH05TVuXEg20MuKwixl/6k00lHwF0sCemE1i3mRWP3sT4fammBKhQ2SxOBPJmXU6K5+8Hl/9VhSTFUML48oYxaSzbmXVf26kvXYLI4+8nCnn3cbihy8dcPhoo1GP12jGoySxIvI1v3T/mTI9FqkVjjP4YyubRDMiaEaEoNb9eFfkJUzi8PyL98gADmca0+Ze1S0mREqJv72GT966nubG0j7u3jP+KxhAIDhb/S7Xmm+gTtbix0dCl9KcOSKXq8zXcrT6Hf4UuZWX9Rc6z2WLHP5suYsEPJiFmWqjil9HbqSZJuYpC7jF8kcCMoBN2NhmbOHGyHVEiZIn8vmz5S6cuLAIC+VGGb+J/IJWvAOm39AiVK16h1BrHeG2RkLeWhLzJtNeU0LIW0vSiJk4x8zHlpiJxZXUkfDXQAhB1cq38O5YG/etNJZ8TcPmRXQdXKmj56Ga7SSPmElSwTTMjgRSRs7BZHUSDQzMchuUAW5pvQ6fbKcpUs+//PcxyjSOh0L/F7fW16TDrqai+CO0aJBAey3SMCicfApFU8+iYcdyNn79ry7Ok/0Tg5rqN/Gfv8/vcTymJRu6LeK/ggGSSeEG8038IfobPtcXMleZz5O2XVVBSuQmbo7cwJPW5ztyWMagoHCt+Qa2GKXcE/0/TJj4u/XfnG+6iH9o93Oyehqr9BX8Ofp7BODASZQoCgrXm29irbGGh6L3YMHKo9YnOdt0Ho9p/xz4A0jZGbuwU70pFBNmZxLzrnocf2M5jSVfE25r6DYuJBAN9O5vEw22s/tAUsy2XXESQiHQXMWG129Hjw5OY+OXfiQSDY13Qi/3eW1m0QLGzv0+ejTI1lWvULL8P0w+/BrWffF3iqacTt64Yylb//bACBCx4uXxvI4V1dLhXjL4PcV/BQPkKQUoKCzXlxImzGpjJbWypts1O5O2doUNG4cqh9MoG7nTcl+sLVHABMULwPv6O9xmuYPbxV28or3IMmMxAE6cHKIsoEpWUmiJxTVki1wmKIMz7igmCykj59K8bTn2pGzsiVm015XiTMnDnTmKZY/9iIiviZFHX9lr2sn46PnDt5StwtCjVK95n0BjOUJRUS12jGjXGTvmUhHTxPXeepJI4cfum7i3/bZ+ZYLWoyEWvfxT2hq3c8jpd1C2/m20aIiK4g+JBL3kjjl6wAyQnDqGmQt+widvXo9h7PKlEkLlsOP/xIaVT9FYu35AbXbFfwUDqCjIjszEENucxatPtTt2ZjX+TP+EtcZqAF7meeo6CsB9ZXzBReFzOUk9jd9a/sAGYx2/ivy84z6FhfpHFBsbOu+rkYMIwZQQ8beQkD2WeT96EntiFjVr3qN1xzpUq4O26s3M+eEjhNub0EI+Iv5dcQ5S13rNeiENPa72zFu+mrJFzzDnh/9EC7ahmK3UrvuYTe/+jYTscYw88ockFU7H5kln+kV3U7/xMyqXvxa3jwQlkYmmaf2u7B7yN8Uc9axOnInZZI08FLPFiVBUDF3rFj3YX5gtTlLSJ8RxstRJTR9PYnLR/z4DVMsqTMLESGUUK4zl5Ii8OJvPnlbmECHWGavxiES+Mr5AQ8OMucOJOCby1Moa/q09zDf6Iv5tfYZUkUa9rGODXI9buFlkfI6O3pEFId502berhxYJsPTRKwm3NWBPzgFp4G/aEasnFmhl8cPfx5Gcix4NE/RWY/Nkdoowa1/8TYeY0xNbFv4zrmVdGjqlH/+DiqWvYnWnoEeCBFqqQEqCzVVs++IJ+OKJzusjvt4Di7xGMz7Zhlt4OlIi9o0tK19g3ml/QTVZKN/wLml5M/A2lDL35D+QkFrEpqV9a8u6QSiYVCsmkxUhFExme7fV0e5IxenOGnJC5mHyBt27UFD4qflGTlXPZI2xErdIYLIylWvCP2S5sZTj1BOZrEzlAtMlFBsbWKJ/zQf6u5TKzYwR4/ib9QF8sp1W2UqySOa+6N/42viS35n/RIEygibZRKEYQZWs4BeR64kQZqKYxJ3W+/BKLz7ZRpJI5q7o7SwzljBFmcaR6jEcq56ACxdv6K+yXF/KIuPz/f2qhhV24eAa181MNE/jy/BHhGVMjArKAG8HX+qWM3QnzFYXimomHPQCApPZTsHEE9GjIXYUf4ihx+7JS5jIn4/6Bru5e8obKSVPrv0ZX7e8w1En/43ElCISEvNpaSzdZT8QYLMlEgw08+qTp/WrQPZe9gbduzAweCB6D5/pn5AsUthorCdTZLHNiNkAmmQjxcZGbo3c3HGHJEjMg7BEbuLi0HlMUibjEE5qZDWbjJh779+1+xknJuAQDhplA+uNdZ0q0g1yPReFzmWSMhm7cFBlVFIiNwHgkz62GKVsMXap4Ly07LsXso/gFC4SlSSajQYmmqezcwVsM1p5L/QayO4MoKgW0vNn404p6NTbG3qUratfReulxkNv8DZtY+FbNzBqwqlMnXsla5f9u5vWJxJqo6r860FVh++K/woGANCIsspY0fm9qzy+wlgW75ZOeGlhkfFFj+P1so56WdfrfS0082WcWX2b3MI2fT9Vp9yHaDTq+W1r/8uwjp17MWPnXEJ9+bJOm4OmhVDUgQ8zKXW8zVspWf8qWXlzWbv0X+h6/DoRQ8F+YwCBsssfvePYzpC9WN7//Z3yUHRkHu5K34FC2+4Qsf+E0su7lAxWVSgQ5KoFjDaNR0Njc3Q9dUZN3GvT82fxzeu/pK5s8aD6igdfWzVfffx79L2UBn+fMYDN5CbDOYJ8z2Ry3ONJdeSRaMvEqjoxqzaQBhEjRCDaSmuonqZgJXX+rVS1FdMQ2EF7pBFjL1eDtJlcZDpHMTJ5FrkJE0h3FOKypGBR7RhSJ6S10xSsoqa9hC0ty9jRupa2cMM+L9KhCBMeaxqZrtHkeyaR5RpNij0XtzUNq2pHESqaESGk+WmPNNIUqKTWv4Vy71pqfKX4Ik39pvlU23lc7bqRNulFxYRdOLi97Wa+jnza49rmmg140kbRsGN5F1fuob0bw9CG7O7QF/YqA5gUK4WeqRySdx6T048hyzUKs2JDEb3HBuzEzplWMyK0huqoaNvI+vqFrG9YSFX7JiL68BTGEwjSHIUsyL+AOdlnkJswHotq77JCxadNMyI0B6tYXfcBn5U9wXbvys642b0Bk2IhwzmSqRnHMTXjOAo8U0iwpqEq5o7Zv/f3uXMV0IwwTcFKNjR8xpflz1DSvBjN6F2sSFJSucB5Ob9ovYKS6EYEgkOsR3C58zpWRL7pYQ2WhsHcU/7I2DkXEwm1gZRo0SBfvfozQv6mQT23opjJH3kkVeXfEI3sskWYLS7yi46kfMsnQyqfulcYQBEmxiTP5dQxNzIp/WjsJveAI8OEEAhULKqdNGchac5CpmeeQFDz8cbm/+PVTbcPmU6XJZlji67muKKrSLHn9rvEkxACs2olw1XEcc6rOTTvAhZXvcxrm/5CnX/bkOnancYp6cdyeMFFjE2Zj8OcOOCiELF3KbCodrJco8l0juLQvAtYXvM2L238A9Xtm+LelyA8+A0fpdFioh0an9WRZVzp/BlWYe3UCu1EVelnNNd2z+MpDX1IWTzcnhyOOe1+Xn/6bJrqN3YeV1ULC479PQF/AzUVSwbd/rAzgNuSwuljb+I7I67EYfYMaxC3EApmxco279CT4hZ4pnLZtPsZl7oAZQgV14UQOC2JHF14ORNSj+CptTeysvadYRHXJqd/h0um3EVewkRUZeBGpN4ghMBmcrEg97uMTJzJwyt+yMbGnkqCVqMFl+Jminkm66IrUYTCfOuR+GQ7IdnTF6ildiMtuyllTBbnkHT1VlsiENsLdEUk3EY04sOVkDXotmGY4wEynEVcP/d5Th3zc5yWxGEd/BBbyivbNlLS9M0QWhFMSj+am+a/xvjUw4Y0+Lu1KgSZrlFcO/tJji26CkUMfW4Jaz7SnUXDOvi7YifNP571OPkJPd08vLKZJ/1/54+e+3gl9TNeSfmMHzqv5x++O/sdDTb1qJ9iT9izx2xv0I1IbOKzOLodV1QLqsk6ZM3QsK0AWa7R/HTusxQlztyjPAoQ0YMEtTbCehDdiAACs2LFanJiN7sxiVjwx+5tfVP1EoHo4PPRjE89jGtmPdEh8sSxpEqJLqM0B6up9W2hOVhFWA9gUsy4LalkukaS6sjHbkroQZ8QAofFw0WT/w8pDT7a9s8haYy2eVeyvn4hs7NPj59vidh7bI800hSspDlYjT/Sgi6jmBUbibaM2AbZkYdZscV9XiEE6c4RXDj5L9y9+LtE9O4ZGN4Lvc6KyGLyTSPQpcZ2rRSv7G7zSM6aSHtzOY6ETKyO7ukwU3KmxE1v31/4WquIhNuYPOsyVnx1H5FwO6rJxuiJZ2B3ptJcH1986y+GhQE81gyumvnPPge/lJLWcB0bGj5nTd2H7GhdizdURyDaii6jgMCi2HBakkiyZ1GQMIUxKYcwKnkOqY58zIoVX6SJpVXx/Vb6g0znSH44/aG4g19KSUQPsLL2XT4te5ytLctjtBkadOTEUYSCWbGR6RrJ7JwzOKrgUlIdBd2ZAIFVdXLhpNtpClayomaA3o9doBkRPtr2CNMyT8CixuKDDanjDdVS0ryE9fWfsLV5GfWBMoLRNnSpx8JMkTF/JqFiMzkp8EzlmBGXMyfnLKyqo8ezCyGYkn4sk9OPjkOvpN6ooT6yS/U53jSF0p2pUYTC6JnnU7L8WaZ/5yYc7oyO4nYxJKYPrWBKONTKNwv/zNGn3suYSWfha6/BZk/Ck1TI0i/uorWlbEjtD5kBVGHm7PG/ZULq4b3OqP5oCwvLHuPjbY9S59/Wa5nViB7AF22mzr+VTY2L+HDbwzgtiYxInM6srNMAqPUNzgBlVmxcMOl28hImxh389f7tHfL7u2hGvOVdoksDXfdR1rqGsta1fFn+Hy6Y9Gfm5pyF2iVrgRAChzmR70/5G5VtG4e0MS5u/JKSpm8oSprJ5qav+LriBdbXL6QlVNOn1kl20OuPetnY+Dklzd+wqvZ9fjDtXtyW1B7vwKRYODz/IlbXvt9nuwoKP3LdyC2t18VqB0uDpe/+AWnohHyNLHn7FoLtu6q2LDjzr4N+9p0o3fAGLU1bGTHmONyeXEKBZsq3LqRmx5L9UCh7N0zJ+A5HFV4aV4MipaS6fTP/Xn0t6+s/HbA4IDHwRZpZV/8J6+oXYlLMg1Y1zsk5g9nZp/U6+O9dcj5bWvq2KO9OXa1/Cw+vuIJgtJWjRlzWbT8Rk69Hc9a43/DPlVd3rHIDR1j388y6XyIQlLWu6YU59wzNiPBVxXNYVBs/nP53zGr3SCwhBGNS5uO2ppKrZZGt5sVtxyTMZKl5dHUC3Om8t/Kj/yMcaOmWqW3r6lc6/IKGAklj7Toaa3um4x8qhsQAVtXJqWNuxKo6e5yTUlLjK+XeJRdQ1rp6KN3sbLFPnXVfcJg8nDz6Bky7hd9JKQnpPp5Ye8MAB/8uBLU2nll/M5nu0UxI7ZnR+pDcc/i0/HE2NS4aVPsAWwdJ2+6QSBZVPMchuecxNeO4HrQmWNPIdI3i0uilFJlG0x4n+a2CSqqSHrf9kL8xlsrQbOu0n9eVL0WPDr2Ws8WaEDcAPhRoHlKt6CExwPjUwxibMj+u6BPU2nh89U+HafAPDVMyjmVE4rS4dC6ufJlVNe8NqX1fpJkXNtzKzQvexmFO6DweUze6OWHkNZQ0Le5V9NuXiOhBvtjxDFMyvoOg++bUrFjJcBYRbAnwy9ar2aaV9LjfhJn7k+K7NSemj2HOyX/E7k5npwVYiwRY+MxlsVxPg4Jg0szvM+uwG7DaEjolDSEUQkEvn7x5HTu29rRK9xeDZgCBwmH534sb1Cyl5IvyZ1hb/9GgCRsuqMLMofkXoIqeqsSg1sb7Wx8atHjSFSVNi1lT9wHzcs7poRmanH4Mma6RVLfvPZP+QLCleSnBaDtOS2KPc0m2bP7lv49avTJuIIyOzqLwwriu0BPmX0FD5Uq2r3mjUwyS0iAUGLynrNOdydwjb2LDiqdACNIyp7B+xROMmXwOSEn1jsEbwWAIdoBEWwYT0uJvfNsjjXy47R973XenP0i258RdpaSUlDQtZkfr4KOJukKXUb7c8WxcZnJZUpiWccKw9DMcaA830haOX17Ubk6gXN9KuA89/9OBhwnGqREsFJWqzQvx1m+mtWELrQ1baGvcNqRabg5XOroeYeU3D1FXvYpgoIntJR+w8K0bSEjMJzl1zKDbhiEwQGHiNBJt8Q0cGxu+OGBmu6KkGSRY0+Kckayu+2DQm8p4KG1eTEuop3+6EIKpGccOm9FtqIgYQUJ6fP98s9K9/q9AIUfNZ5Z5PjPM80hTMrr4x3ZH9ZYvmHLkdeSMOZr0/Fmk588iNXd6t4ReA0Vn2KcQhIJe3J4cFMVMNOInHG4jIalg0G3DEESgUUlz4ooVUhqsrH1nrzqGDQSjk+fFzWKmGZEhWpR7oj3cSEXretIc+d2OCwR5CZNwW1JpDfcef7CvYEi919W56+AWKFzsuJKLnVejSQ2BQCK5x/dHPgy92eNed3IBdlc6M75zU0fwikSLBPn8xR8T8g2ubK6vvRpD10hOHYu3aStuTx7TD/kRfl8d6VlTWfn1A3tupA8MigEUoZLvmdzL5tfHtpYDo4C1KszkJoyPe64t0khjYPBZheNBlxo7WtcxPbNn/WSPLZ0Ue84BwQD9RbqSyVmOi7jRewXF0bUoxHyBrnT9jEXhTwjsJgat+/wB1n3xUI92hiIChQItfPnBb2jz7iDob2T5ontZ8J3fYTLbKN3wOrWVywfdNgySAVRhIsNVFPecL9JE0zAPrMHCrFpJcxTG36eEm/BFhr/SZI2vp+YEYsyY6Ro1LI588WBSrJgVKybFglm1YVUdWFTbruNq7K9ZsWA1uXBZ9lzB0yzM1Ok1FEfXdvr+rIwsISRD3fIv7UQsDXx3W09m0QKaqtYMwSNUdiuBtHHVfygr+RDVZMHfXtctVcpgMCgGsJncOMyeuOeag1VE9KHrfYcDFsXW6w/dGq7bK2JaS6gGidFDxagIhSR7z6Lfg4EqzHhs6eS6x1OYOI3chAmkOgrwWNNwWZI7Yy4UoXREiSk9/t2fyp0Neh31eg0n2M5gbXQFJmHiSOvxlGmlpCipJJFMREaol3UxrY9QeuwPRk0/F1/LjmEsbCgJ+ONv4AeDQTKAK67xC2Jy8HCoFYcDdnNCr7knY7P/8EdyBaPtaEYEi2rf7YwgwRJvM95fCJJsWUzLPJ452WdQlDQrFhDT4XU63J63AElKChPN0zjKdgI+2Y6Cgku4aZdtzLEcBsB2YwtPzS5m86rnyRt/POn5s+iWqjFnGqsX/m3QNFhsCUyeeSkbVz9H0D9YW0LvGBQDmBQzpl5cdEO6H2OYi1sMFibF2mvwSEQPDkua7t2hGeG4zy+E6GCKnoli9wSPNYPvjLiCowovJc1Z2Ge02nCiwajlypZz46wVu55BQ8eyaSTB9npSc6ZSUfxBl+gvgcUWX1LoLxI8ecyY/xNK1g/eCbIvDHITbOpVpacZ0QMmaFwVvdfP1feSjWKnR2Y8mBTLgIa/6IhduHjKXRR4pvRLjdobU0skhtQ6NUCWjtjhvuAUblKVdDZp6zupNmFmvvUoloa/ILQzJLI8puGp3PwxZRveJRra5UKRXjB7SMVPpJRoWrBbOORwYlAMsDM7QjwoHXLgvg4UjwddRnsdjOowBKzEQ1/xzpqMDmjwL8g7nx9Muy+u9+ZO7Ixf8Ee8NATKaQpW0Byswhuqwx9pIai1EdL8RPQAUSNMVA+hKmaumfVEr4qMnXAIJ3/y3M9Lgad4LfgsLsXNta6byVULWBZZ1IOTS1e8AMiOvUAMaz+/n2ho8IO3taWM5oYSsgsOYdum9xhusXVQo0A3or1uIGOBF0q/arfubUQ7KpLEg0W17TE57GBgVqxxZ1YpJVE9SH9/wEnpx/CDaff1YsSL6fLr/WWsrHmH1XUfsKN1Hb5Ic0y028MK7DAlEDX2rKioNar4des13Oj+A/Osh5OmZLIhuopfeq8mKHuWLk3NmcK4Q36A1Z7Izk22Fg2y+M1fEw4MTuOmKCo7ti7kiBPuoGjsSR0F8Xa9wy0b3qC5Mb7mrT8YFANE9RDRXiyoLksyijAdEG4QwWhbn3T2RxMyUNjNbkxKfMtne6R/mRHcllQumnwHbktqj3M74yveKb2XT7b/i5ZQ/Bw9w4XtWimfht/netcttEkvf22/Fa+MP5jHzfsBLbWbqN3+9a7Kn9IgGo6f37Q/cLmzGDflu0TC7WRkTycje3q387WVy/c9AwS0NkLRdthd0QEk2bIwKZZhdTEYLCJ6kPZwI8n2nB7nPNZ0VGEadg/NRGtGXMuzIXVagv0brPPzzqOwF+/V9kgTD6+4guXVbw5+r9WRkGxPcAgnv3T/iXzTSC5vOZNCdRS/T7iH54OP8VLgyR7OcmUb3mbs7Iux2NydsbqGFsHXXD7owPjmxhKe/+dRvZ4fakDMoHyBonoQbzh+TkaPLYOEODPX/oBmhKn3l8Xdr7gtqbgsScPeZ6ZrdNzjMZFlz3W6zIqNBXnnx2Ui3dB4fdMdQxv8xPYpXSPYekOSkkKb0coNLZeyPrqKt0Mv8YvWK5lpnodD9FSD5445Bj0aJBRoJhJsi31CbQPWtu1uS5DS6PUzVAyKAQypU9G6Ie6DOc0e8jwTh0zYcECXGjva4nt7uq2ppDjiRz0NFjtdROLBF2miMbhnC3mKI5dcd898+AB1/q18vuPpIWvZLKoDm7rnYoLVegX3+G7DK5s7B2WptpFbWn+KT/YUa7z1JbQ1bae1YSve+hK89SW0Nmwd8OyfkTOTmYdejxAKVpuHnIL5MMBcSP3FoLVA272r4lo8VcXMlPTvsKLmHfaGoWmgKGn6GkPqPbQ+ZsXC6OS5bGleOmx9uSzJcWOOAWp8W2gL79mQk2rPj2tll1KyqXER7eHBOZV1hceaHjcWoEefSJKVZM5zXMpY00T+7ruLFqORbDWPNdE4PjjSwJM2CndyYadLhKaF8NZvJhzofzRfauYksoXCCmmQmDKSQ4+7jZcfO/HASo5b0vRNr0EV0zJPxLPpdlp78Tnfl9juXU1LqIbUHrO9YGrG8Xy07ZFBh1rujqLEmXH3G1JKNjR81q9+PLb0Xm0XVe2bh8XGMjp5Tq8b9a6wYOXWhL9hoJOvFpGqpKPJCD93/4Erm88hRPeUhJuWPMmmJU8OmT5p6JgdblSTDSFUhKLE/saNO99PQfH1ge3saF3HuNRDe8x4Gc4i5uWeywdbe3oG7mu0huvYUP8phxdc3CNSa2zKfHLc4yhvjVeFcWBQhMqCvO/GHVhh3c/q2v6FXe4et9wVIW3oxiCTYmVW1qm9FrruinQ1iyQlmR+1nM9vE+4EwCtbsAs7FmHtV9WYwaCuaiWphx7NWd9/HcPQSEkbxwnnPBrXoLbi6weprRx8zPSgBauIHuSryhfizkiqYuKU0deT4RwZ5859C0PqfFnxn7h6b6c5ke+MuHJYAlXyPVOYmXVKXPFnW8sKylrX9Kud3RNTdcXu1VQGgzHJ8xiXeli/XCl2/rZdN6UekYQmNTT2nr9XU30x777wfeqr16BrEaQ00KJBolrPz1DtTUMyhy6rfp1TRl9PpmtUj3MZzpFcOvVuHlr+g73idjwQFDd+SXHjl0xJP7bHKnBY/vdYWv0a6+o/GXT7VtXJOeNvwWVJ6XFOMyJ8vO2f/c5m3RKs6fSs3B057vEIlEGLQS5LCudO+B020543wAB1eg2Vejl/9NxHvlrEd2ynMNI0loXhd+MawoYLEoPKskVUli0iNXMSR538Vz56/Zq9sgcY0ta6OVjFh9sejmv0EkIwI+tkrpzxcFy5eLCIbWYHZsCK6EHeKvlbXBHCYfbwg6n3kuOOHzizJ5gVK2eMvYlZcWb/nXHHyweQHa45WIUv0jOIXAjB+NTDSLRlDIpOm8nNhZP+3GscdzxoRLmj7desi66k0agnQ8nizeDzPOX/xz5zdQn6G6nesWSvOC7CMCTH/XT742xq/CougYpQmZdzDjcveIs52Wf26kLdN2I5Q7PdYzm26Cqunf0kKYNgqHX1C/m8/MkenppCCHITJnLD3OcZn3pYv2TjnXBZkjl/0p84fewveyTDlVIS0Fp5cePvCWq9F7veHS2hairbi+O+z3TnCE4Y9ZO4oah9IcWex5Uz/sHRhZcPWNxrk6087n+Qq1vO4xrvhbwSfKbPgPnhhr+9lq8++v2QA196w5A9wnzRZp5e9wt+ccirJNmy4+adLPRM46dzn2VryzKWVL1GccPnNAUrCWrtRPVwx5IuUIUJi2rDZnKRYE0nN2E8RYkzY5vVhHE4zIn4Is2oG347YDoNqfFK8Z8pTJzG2JQFPUShfM9kbpr/Ol+UP82n5U9S3UsRDoGCx5rG5IzvcOKonzAyaVZc92RDarxV8jeK46Qd7wtRI8ziypcZn3po3KCak0f9FMPQeHfL/bRHeleJCgQeWwazs0/n5FHXk+0es6twnTQI6wFsqnOfuFXvTpkiVMyKrdcrTMKCSVhizoxDKO/UL2qGp0yqYE72GVw981FcluTePRc7vEijeojWcD3t4QZCmg/NiKAIE2bVht3sxm1JwWlOwqRYenhXtoUb+dXCOf2yqsZDvmcyN8x9PiZP95LLNKi1UdW2iR1t62kIlBPS2mNRWNY0st3jyPdMIsWeiyJMcdswpM5n5U/y2KrrCPeSfaEvJFozufWIT8hLmBD3vCF1KtuKWVnzDltaltESqiGqhzApZlyWZNKdIxiTPI+xqQtIted3e4dSSlbXvc/q2ve5ZMrfulmEpZS8U3oPT679+YBp9ljTyXSNxmZyYTO5sJtc2M0JOEwJOMwe7GYPDrMHhzkBm8mF05xEbsL4HiuSlJKmYCVNwQrCWoCg1kYw2kYg2kZAa+38d0hrJ6T5CWk+AtFWdrSt61PN3FuZ1GGrEyxQmJ19OpdPfyDuSjBcGCoDABQlzeTaWU+Q24vRaijQjVh+oMfXXE8g6h10O4fknsuPZj2GvY8Nq5QxH/+dMRixjNCmWNxBL8xd3PgFDyy7BLNi4/ajF3dzBxkKA5ww8loumvx/HaGYaufA3hvjYGf5LEMaGFKnLdzALZ8e2qelvTcGGDb7ssRgafXr3PXNWWxu+gpD6ntt4zJUbGtZwV3fnM2aug870p8PHVJKAtE2Xtt0B/9efe2QBj/AkqrXeKX4T4S1QK/vUQiBqpixmhyxMFWTE7Nq7XVVWlX7Hg8svZjGwA6ag5XU+krjtDo47KTDrFpRldjKuLcmQSFiYpRJMWNRbVhV+6D7GmYHC8mW5qX839en8591v6IhUI4hjWFhhNhsZ9AWbhgWy22Nr4R7lnyX5zfcQnOwuks50YHTpRtRSpsXc/fi83ip+I/DYrAypMbbJXfz+Jrr8YZqB/0OY4zZylsld3P/0otoDFYAENYDbGledsBOUvsKeyUsyhdp5s2Sv/JVxfPMyTmDQ3LPIz9hUjcfl/5UiYTYzNUeaaTMu4blNW+ysuYdmoPVfd7bXwSirbyx+f9YUvVqrIBE9pmkOws7NTp9RWFBLLfo1pblfFb2BMtr3hpS5Zp40GWUhdv/RWnTYk4efT0zs04hwZoKfVSF7DqgfZFmNjR8xrtb7mdz09c9XL83NS2KlXPaudke0oTdESXYvVBxd3SNB413XW/xovGOd7l/KCw8bHuAvmBR7WQ4ixiROIOipJlkOItItGXiNCfGlkxhQpc6UT0UC+HTAwT0dna0rqW47jMq2zfhDdUMm89OPAgU3NYURibNYlzqYeQnTCTFnofD7MGsWtGNKCE9QGuolnp/GaXNSyhtXkx1e0m/oquGCkWYSHeOYELq4YxLPZRM1yg81jSsqhNFKGhGhIDWTmuojjr/Vkqbl7K56WsCpjCzjv8tSz+8jVFTzya76FCiYT8rP7sbf902ihKnY7V5GDPjfPLHHkdzuJrlq//FxmVPEu5MaivILJzLuFkX4UkeQTQSoL5iOesX/5uQP6aJSnePYsHcGxg55Sysdg8NlavZsPjftLWUx1oQgvkn305FySeoJitjZpyPxeqmrPhdNiz+N2k505hx9C/44rUb8LftipsYPf1c8kYdzRev/wwtGsRqS2DszAvJG3MMQihUlH7KhqWPsb7qwz5/h72+Ce4KVbF01P3q5bwwY1IsnUHrO2OIpTTQpUZO6lTmjf8BFpODpxdeir6XdMB9QRWmWH4dRe2wDUgMqaMZEaJGhP3p6SoQmFUbqjDHNDwIJAZ6B31aF/oS08Zw1jWfUL9jOe3eCppq1pOQXMDmlc/TVLMORbVw+Bl3k5I1iU3Ln0FKgwlzvk+7t5KPn78cPRrCkzqS0698h23r36KuYhkOVzqp2VP45r3fEWirAQTTjriO8bO/T/HSJwj6mxg15Uzs7nTeeewcgr56EApnXPUuIIiE2qja+gWqyUI46GXD4sewu1I559rPWbHwTjYufQIA1WTjtCvepL5yJV+99StUk5Ujz34AT8oINq14FiEUJs69jOa6Yha+9COMPizFvTFATPbt5dPxFgf08Tiy5JGTrxvwfbt/MpPGyytOeEWqinnIbX2bP4lpY+TVd3jlnON+K4VQepxPz5slL/vdDpmRP1uqJptUTTaZO+pIeeWfGmR63qzOay7/Q5UsGHe8VNSdv4fobMPhzpSX/HqzHD39u51teFJHyst+Vy7Hzvxe7DqhyDOufl9+94Yl0uZIiUOrkIeedqc8/ap3papaJSDTcqfLy39fIdPzZkpAZhcdKn9wa5lMzZ7S2U/B+BPkFX+qkylZk/p8D72N8T73AKpiYVrRWfiCDeSnz6Ssbilbar5ASoNEZy5TRpyGqphZV/Y2jW1byUmZwvzxPyQvbQZWi5ua5g2s3f4GqmJmUuHJNLeVMyb3KLy+SlZufRlVqIzLO5bslMnUNG+guOJDNL13K2OSK4/JhaehKibWlb1FY9s2RmTMQwJldYuxmd1MLTqTZaXPMj7v+Fj+ItVGINxMojOXZaXPoh0gWev2JQwtSuWWz+K6DqdkTcThTue4C5/oSGgbK0FqsthxerKhAppq1lO89EmOPPtBmmrXU7rqRcqK3yccbAEgIbkAV2IO80+6jTnH/hoAIVSsjmTcSd3d0Ot2LCUUiBcbLSld/RJjZlxAUsZYGqvXMnLymTTXbaKpJhbUlJo1BUdCJidc8mynZ6hqsmEy23EkZHVeNxD0yQAmxcJ3pv+C5SXPUtGwiu9Mv5GoFqS+tYRzD7uPNdteRzeinHPoPTy98DLagw3Ut5bgsqeysfw9/OFY9jWTauHwSddQ3oWBAA4ZfxnZKZNZueVFpow4nWR3IZ+vi5/t12FN5pxD72PNttcwDI1zDr2Xpxf+gIKMOUgpKatbjNWSwKzRF7Jy60vMHHkelU2rGZ93HFtrFpGZNIGa5vWU1Q9fAMx/C6TU0XuJyhJCJehr4PPXru9Wy0tKSWvjVgB0LcQ3795C8fKnGTn5dGYcfSOT5l/JB89cgs9bgRAKejTE4vd/j7ehu2rV563q9l3ro1xSY/U6vPWbGTn5DNpbdjBi4ims/fIhdC02KQpFIdBaw2evXNct0F5K2aPf/mKPWqBwpI0VW17A668kM2k8o7IPQ1UteJw5CKFgUq24bGlkJU1gS80XNLZuJc0ziorG3ZLASslXGx+lqX17rGPVyoT8E3lj8a+obdlIi6+Ccw+9n6+L/0VU6+mCkJ08CY8zK1aDSrXgssf67A2aEaa44iOSXQVsrlyIEAo2i2eAr+d/H821G1BUC4auUbdjl1+9EGqnq3EszY1BS10xy+uKKVn5Amf++ENyRx3JpuVP09ZcTiTUhsXqpm7Hcti5PxIKA8k7o2shNq98nsnzr6Shei1mi4PyTe93nm+qWY/JYkePhnqldaDYsxpU7PJzEUIgiWmgdD0cyzRm6Cxcew/1rbHUFLHH7bnf0I0IUa2LC60EKY0uvuZ71sHpemRXn2vuob61lJzUaZ3mfItq76yqLqWBYWhIqXf8lfvB7+XAR0PlarasfYUjz76fjUufxNdahcuTjTMhm2/evQUtGiC76DBGTj6d2vIlRMM+0vNmoigmWptiK4S/rYbVXz7IzGNuwunJobmuGJsjmZTMCSz96M/4W/uvti7f9D4zjvoZ04+4nsotn+Hrcm9N+RK2b3yXo879O8XLnsTfVos7MRebM5XF793auVIMBHtkALvFw5yxl7Cjfjnj847jnWV/oKG1lNZADRaTE6+/Erc9nXA0ZvzxBRvISBzDmJyjaQvUUtuyMW67mhFmXflbHD75GlZtfZkphafF9gBaiCRXPhlJ47BbEslOmUxj61aqm9d19OnA66/q7LOxdSuHTbqa6qZ1jMw6DKt5MB6n/7vQokHqdizrNTeProdZ9MZNjJ5+HiMmnIzNmUJIa6eqdWOnB6avtRJFtTBx3g9RVDPtLeUsfPFqassWd7QiWfPlA7Q2bmX0tHPJGXk44aCXqq1fEAl2eMJKSXPtRtqay3oSoZqwFIxCcSYQqq2kdPVL5BQdRvGyp+hcTQA9GuSLV3/KmBkXUDjhRKz2JPyt1Wzf8BaGPjiLfp9qUJvZLa888VW+3PAIqQkjKKtbytaaRUgMEhyZTCw4Cac1hZrm9RRXfoRhaCjCxMSCE8lKmkBZ/VJKqj5FVSzMGHkOa7e/QVjb5RymKmbG5BxNbupUapo3sqnyI3QjytQRZ5DmGY2qmInqQTbueJ+a5g0dfZ6M05oc67PiI4RQmFRwMmmeUZTVLSbBmcXqba8yIe8EttctJj9tBtVN60nzjMLrr6KxbeugXtR/NYTC7nn7e7kQhMA+YQbpP7uD8iuOh84wRNGRT4gOsaa3cbPzOhlH/IlvJUs890oSTjiXyNZN+Jd8QvvCN2LX9klzRz990rILg1KDWk0uee2pH0q3PX2/q/MOfvbdxzZhpix4bKFEUfd+f0LI3Htelq4jT5EIRSLEXulnUGpQXUYpqVxI9H9UdehIyCJ71GGk58/CnVyAyexA18MEfQ201m+hsWo1NVsX9Vu2FIqJ9PxZuBJzaKhcRVvjtr38BP2DpWA0iWf/EFNaFrq3iZbn/06kvJSkC64hsq0Y/5KFsRKk1/6R1refAUCYzSRf8GNsE2YQKl5Ny8uPIkMBhMNF0tmXYxs3DalptH/2Fr5P38Q2YQauBSfQ+OjtALiPPh3FmUDrW09jGz8d++S5yGgYx6zDCW8rpumJu7GNn07imT/APmUOiiuBhGPPoenJuwmXrMU+eQ4JJ12AmphCtKac5mcfQm+MJWOzjplC4mmXoKZmoDfW0vjYXejN9Zgyckg65wrMOYWEt23C+9I/0Vv7DsftkwE0PcyHq+4Yjt/ggIIQKqNmfpfZJ96KJ3UkitrzNUgpaWvazqt3LyDQFj8L3u7In3ACx17yFBZbAk0163nroRP6fe9egxCkXP5LIts30frGk5gy8zACsf2addREDP+uaDX75Nn4Pn8bqWmYs/LR21pofuZ+Uq/6DUYogPflR3HNPxbHrCNoeOj3KA4XUovtE9SkNGwTduXtNOcUoiamdJxLJfni62h64m6an30IoZpA1wlv3Ujjv+7AkleE99XHCKz6Cr0lZiOQWhTf52+jNdWTfOE1JJ1zBY0P34YpK5+sW/+B9/UnCL37HGpSKkbQj7DayPj5nfiXfU7bx6/iOfViUq/6DXV3/YK+RKm9kyP8AEf+hOM54rt/x2KLVXWXhk40EkCL+GOqXasTVbXSXL1+QBXOc0YdgcWeiBCC5MwJeFJH7X8GkJJQ8Spchx5PtK4K/+KP0Zt7e6ZdYnK0roq2j15BhoK0vv0snpPOx/vyo0QqtqEmJOI69ATaP32DSHn/9O/R2gpa33wKGd3lriCDfrRQECMURGtuQKvbZTOINtRgHTUJ+9R5qImpoMQclx3T5hOtKcf76mNd9idgKRyDffp89JZGLAWjMadlYSkcgzCbkZHeV/BvHQOYzHamH3Nj5+D3t1az4oPbqSr9lGjYjxACs9VFQupIQr7GARV36GpI0rUwkSFkRR5OtLz4CMH1y0g4/lySzvkhdX/7JaENOzO7dQx6RUWou6KzpK6B3lHtPRJCmGP5jsKb11D960txH3MGmb9+gPbP3qLl2Qe7twUIS/f8Rnp7K1Lv37tUHC6y//AogeWf4/v8HWQ4hGXE2Ng5uwPD395jVhdmCzLgp/3L95DhmB3JCAY6V6je8K1jgITUIlJzY5mXDUNj6Tu3UvzN48T2SrvQXLNhwG2XrnierJGH4kktomT5c7TUFg8T1UODKSWd8JYNNG7dSNpP/4xz9hGENixHb23GWjQOYXPEZs3sgs57zOnZWEdNJFxWgmPW4YQ2x5KHqYkp6P52Wl76J5EdW0n+/vW0PP8PDF8banIaakoGaFEc0+Z33hODpL9QHC7MWXm0ffQKWnMDiWdf3pkmJrR5LUnnXoVlxDiiNTtQbHYMXxtafTVaa8zzILh+OcJsQZhMYPSt/frWMYA7ubBz9g/7W6gsWchAfpy+0Na4lff+eQaKakaLBIYle/GQoSikfP9nWPJHxTQf0UjnjN327nNk/OKv5Nz1LFp9NaHSdUhdQ+oaoY0rSTz3Csxp2RjhEHV/vREAx+wjSDzjB0gtijCZ8b74T9A1QiVrCW/ZQM5fnkRvaSRaX92515BaFMPfe5CQEWjvNlNr3iZ8X7xL5q8f6GirChGOKWJCm1bjfe0xMn91LzIaQYaC1P31JqLVZTTc9xuSv/8zki/8CUhJ2wcv0vrm032+nn0SD3AgYezsizjmkqcQQtDWVMbzf5lCNHRgiCp7C8JiRXG6AREbbOFdWj1hd6LYHBiBdoTJjBEOgZQoVhtS11AcLoyAb9c9ioriSkCYzMhwqNsmGpMZ1e2JDcxIGFQTMuiPzcZWO4YvfsCQ4vZgBAPQVVxRTajuRKQexQj4YzO9f+fvJFBcboTF2kGDj52TmLDZOzbnGoavrXOf0Jsd4Fu3Agh1V04daWjIPSyR/wuQkTB6LxtBGfSjB2PGya6MsXP21sO7qcANHaOtJX5HWhS9pWuqllifMhrptvndHUZ7HMbQNXTvrrZ2DX4AGRvccSBDQfRQ/3OWDpgBbM5UbM5kpDTwtVR00ZEL7O50UnOn4UkbhdniIBrx095UTkvtRnzeyn7niVdUMwkpI0jJnoIzMacjcKIVb91mmms2dEYh7RkCRTVhsjgxWxyYrW48qbsKwymqmcT00WiRnmn+dC2Cr2VH70X2TFZcSXm9ZnI29CjtzTv67aQlhII7pRBFMREN+3b5zwgFpyeb1NxpJKSMwGS2Ew37aGvaRlPV2lj01IDjegV2VyrJWZNITB+Nxe6JPa+3kqaqNbQ3lQ8oEZXTk43Z6sLQNdqby7s50bmS8kjNnYY7uQDVZCUcbKWtcSstdZsItNb2eD872wKIhNo7Am76B0W14E7O73Dek/hbq9EifaelGbAINOeUPzL96BsxjChvPng8dWWLMdsSmHzYj5gw/wpcSXkdevWYOdwwdCLBVjZ+/SiL3/wNfcnbQihkFi1g2jE/J3vkYVhsCQilQzMhJYYepa25jM1LnmT9V48Q9vdu5LC7Mzj07HtwJxdgdSRitSdisSWgmqyIjqwFUhoxBo5DUkvdJl6//ygiwfjLdmrOVE77yceYLb0UDG8p57V7Du+3GtXqSOa8Xy7H4c6kZttXvP2Pk7E6Epl29M8ZM+tC7AkZKIpK53vVNQJttZQs/w+rF95NyNe/ScHhzmDS4T9m9KwLcSfloSjmTtcFaeiEg61UlXzKqk/uor68i2dnLxBC4fjLX6RgwkkE/Y28fNdcAm01OBKymHHsTYyacR52V1rH7xhzXTAMjaCvgSVv38KmxY93bY05J/+eacfciEDQULGCt/5+Yr+rzBdOOpVjL30GRTETDrbwxv3H0FK3CRhGEUhRzKhmGypWnJ4srI5kjjjvQUZOPzeOQUmgqgo2ZwrB9gb6epmKamby4dcw64RbsDqSOgaojIkpUqKoJhSThaSMscw55TZyxhzNZ89dSVvT9rjtWaxuCiaehNXu6bVPIRRM5jiFzgDVbKUvD1VJjDYAoZo6B+dOj1PVZOvz/p60iFhwh8VOYvpokjLHMf/Mv5I35phOnxdDj8ZCSBUTqik22834zk0kZ03ik6cv3WMlxpScqRx1wSOk589GKEqHO4CB1LXOdu2uVEZOP4fsUYfz9eu/oGTZf/a4md8ZQGOTSdicKZjMdo655Amyihb0XCGFQFUs2F1pcbxEJdvWvMaUI67D6kgkLX8mGYVzqdy858TFQiiMmnEuZmssg3bD5pWd8Qx9YQh7AEFC6kjyxh3LqBnnEQ37qN2+mNqyxQRaa1BNFjxpo8konIMrKZ+qLZ/1RT0T5v+Qeaf+GZPF0eGbvpxta1/HW7cZQ4/gSMgif/zxFEw8EZPFSe7YYzjygn/ywWPfjfvDB/2NLHnrt6im7vro9ILZjJpxHkIIgr5G1iy8G13rKZ+GAk3o0d5lSW/dZt544FisjiSs9kSsjkSyRx3O+HmXIZShZZuxu9M58vxHyCicQzTko3zju+wo/pBAWw2qyUZqzlTGzL4QT9pohKJSMPEkJh16FSs+/EuvbSakjuQ7lzxJSvYUAPytNWxb+zq1W78iFGjGbHGSljeDkTPOxZM6EkdCBoedcx+hQAvl6/uX3FdRTCRljmfC/B+SVbSAoK+Rmi1fUl+xgpC/CbPVRXLmeDIK56IoZhorV/Voo7lmA9VbvqBw8qmoJhtjZn+PqpJP98iEzsRccsYcHVNv61FKVzzXL5F7SJvgCfN/iDspj/qKlXz16s+pK1vco1OTxUFCShHe+t5LWabmTGP2ib9DNdvR9QhrPrmbFR/eQSTUXfzYvPQpRk0/j8O/+xBWu4ecMUcx6bCrWfHBX9h9dYkEvaz74kF2x7h5P2DUjPM6r1n72QODqkKua2GadwvB0yIBxs29dEAJduNBNdnIKJxLoK2Wz567ivKN73WuNgDb175OyfL/cPxlL5CaOx1FURkz5yLWL3q4SyaHXVBUC3NPua1z8DdWrmLhfy6nsWpNt/3D1tUvs/Gbf3H09x4je9ThWOyJzDv1T9SXLY0Ftu8Bimph9km3kpQ+lrL177D4zV/TUlvcQ8632Dy4knI7pILuMPQom5c+Rf6EE1BNFvLHH48ruYD2Xlb6ncgbdyyOhEwA2lt2UNGPVQOGmBgrMX0MvpZKPn7yYmq2fhmX47RIgOaa9b1G7AtFZepRP8XuTgdgx8YPWPb+bT0GP9DB2c+zafETHQEuCuPn/aDz3sHgQKhovzuEEEhDY+k7v6Ns/dvdBv9OtDZsYeWH/9d5LiF5BJ7UnnUaALKK5jNi8mkIIYgEW/nipZ/QWLk67ua5rXEbX79+E5FQa8ylI2sShZNP7S/hJGdOpHrrlyz8z2U016yPqwSIhFo7DI3x331lyad46zcD4HBnMmIP/SuqhVHTz+nc/Javf4dge//Kcw2aAYSI+Wuv+fTeTmIHA1dSPvnjj+9YuiJsWPRwXK3MTkips2XVS2jRIEII3MmFpOfPGnT/Bypa6jazdfXL9LVvqi37hlCH+KeoZtwphXGuEoyedQEmiwOAys2fUFfWd1x0U9Ua6nesiN0tFAonn4LoR1lVIQRaNMjy9//U7015PIQDzWxZ+WJHoi3B6JkXdGqG4iExfQwZhXNj/UcCbFn1Ev01bg5pBQj5mykvfn/PF/aB9PyZ2F1pAATb6ztffF9obdhCJBTTAwtFJS1vxpBoONAgpaRm6yLCAW+f10XDvk6RRwiBxdazhJLFltCxGY1pvSpLPom7onSFroVprl7fGUaalDEeSx8DsCu89SXUlw++ZtdObFn1MiFfI0IIUnOnkl4wp9drR0w+FYs9ESkljZWraajoubfoDUPaA/i8Ff1eanpDas7UTj+PaMRPWt50tEjfhgyz1dXNGcqVlDskGg5E9CUi7IQ09G6hgCJO8Qu7Ox1nYk7n9Warm+xRR+yx/67aM7szBZPF0c3Zrzd46zYRDQ88JfzuaG3YQsXmjxk98/zYZnjWhVSXft5DpDJbXYyYckbHN8mWVS/uUfffFUNigHCgZY+zSZ8QAmfirsGbmD6WU370Tn9v7mhCxFSZneFx/wuQBNvrhqWlmFoyJv4IxcQhp99B/8SDLp6dSkwF3R8EfY39bL9vSENj89KnGDntLFTVQsGEE3Al5dG+W0xxau50UrInIYQg0FZH2fr+jp8YhiQCGcbQUqALoWC27F6lRPTzQ5cMdruO/a8gnmp2MDBbXXGyYfTv/QKdv6/o5/sd0oS4G2q2fUVT1Vok4PBkUTj5lN2uEDEGMduRUlJZspD25vIB9bHffYG66ne99ZtjhpcB+uc01azvM+rnvxPDs5p1fb+GHmXDV/8k0Np/9wKI5esJxVGv7m1EQ+2ULH+WtLyZCEVh9MwL2PTN40Q7RBybK4X8CScihEDXIpQuf27ADLhfGSBmem/p3GwFWmtY9fFf0bX/zRjk/YGYmKqDao5p0Fa+QM3WRfubrH5j25rXmX7ML3Amxvyh0gvmUFX6KQBZRYeSkDICiG2+a7Z9NeD2h7lAxsDhrd8VUudKyutU1x3E8CDka+iiKrWQkFK0hzsOLPhadlC24Z1YBgezndGzzgchEEJh5PRzUFQzUhpsW/PaHrVm8bDfGaCubEnnjO/0ZJOSPXk/U/S/hUB7PS11mzsNh7ljj+7Vg/VAhJQGm5c+jRYNxKp5jj8ehzsThyeLnFFHxIx7oTa2rn6FwYiN+/1NNFWv7dQ5q2Y7Ew+9st8ah4PYMww9wrbVr8bSUApBwYQT/+smmYYdy6kvX46UEqcnm+yRh5FVtABHQgZSSuq2Lx50+Ol+Z4BoqJ11XzzU4ekoKJp6JlOOuK7Dm7IviFj67eSCPVx3EFtXvdw5QGyuNA49575O2bkvKCYrnrTRKOr+nZC0aJCSZc8gpY5QTORPOD7mPaCYkIZO6Yrn+yyO0Rf2uxYIYMvKl8gddyxjZl6AyWxn7im3kVk4j01LnqCpZgORQAsIBbPFgd2djidtFNkjDydnzJGUrX+Hb9745T6mWMTcnxU15kYsFBRFjcUa70yyoKhYnclo0SBS6jG3Y8Po+Dt8qsL+INBey5K3fssxFz+OxR7zWj3lR++wftEjVJV+hr+1GkOPopqsWB1JuBJzSM+fTc6Yo3An5fHavUf2yxlub6Jsw7vMbN5BQmoRWaMOjylrhaDdW0nFpo8G3e4BwQBaNMBXr9yAyWxjxJTTUU1WiqadxYgppxEOetGjYRAxfxezxdmxUY753g/l4QeLkdPOYszs72G2ujHb3FisLsxWF2aru9Ma6/BkccZ1C9GiQaJhH9Fwe+xvyMeKD2+noWLlHnoZXpStf4uvXruR+WfcidWRTGLGOA49+55OuqQRm11Vsw2z1RkLlIGYQe4AMLEEWmvYtvYNph51fWdUn5SSHRvf61ZTbKA4IBgAIOhrYOEzlzH58GuYdNiPcCbmdARopPW4dmcgh6+liqbqgVcFGSqSsydTNPXMPq9RFBNOT1aP41JKNi15cp8zgJQGxYufoK1xO7NP+h2ZI+ahqBYstoTOLBldaQRJNOyntmwJeh9FLfYdJKXLn2PCIZdh6XDT0CIBSle+OCQPgAEzQO32r1n3+QOAoKVu06ALE8RDJNTGio/uoGT5cxRMOIHs0UfgSRuF1Z5E7AeJxcq21G2mZusi6sqWDJj7W2o3dtIf9DX0O065K+rKlrD2s/iVbHaHYrIwavq5WJ3JsQMCCiafgjulAC0aYsuKF4iG29GiIYq/+TcWmweJpDWO/7s7pZCCiSd1anFUsx2bMwUJeBtK95zLSBpUlX5K/cPLyCpaQP6EE0nJmYIzIQvVZEGLhggFmmhr3E79juXUbF1ES21xn3YZKSVl69+mvakMgOotX/brvQwGTdVrqStbQu64Yzu+r6Nhx/I93NU3Dui0KEJRUVRLR7ghSMPAMKIdDmD/HX4/FpuHs278muSsntVsgu31vHTnHHz9NN8XTDqFE654BTWOlqxk+XN8/PiFA6ROoJosXWKkZYeDXeTAyGm0G0xmB6de8x5ZIw8D4OvXb2L1J3/t173/lWlRpKGjG0GGb43Z99C0IGs/u4/E9DHYXGnYnalkFh2C1ZE04LZaaotZ8f6fsbvTsbtScSXlxfzglZ5eoP2D7MjqMfDKKvsDqXnTSMub0RHO2kDZujeH3OYBzQD/CzC0CBsX/bPzu6KaOe0nH5E9es8uybujrXEry9/7Y+f31NzpnHXjV5iU+IH9/1MQCmNmXYjJ4ow5vm1eOCzp5/e7HeDbBinlsIVhHohiyt5CcuZ4iqad3eH4FmbT4sc7y7oOBQcZ4CAOeNicKcw77XYc7pjlt6pkIVVbvhiWtg+KQAdxQCE5ayLu5EKiER9CqCSmjWLs3EvILJwXk/3bG1j2/m19pqwZCIbEACbFQq5zHInW9M6ACV1qlHiXEdJ9mBUbmY4RJFkziRoRavyleCPdLYoWxUaOcywJllQiRpC6wHaaw7XsMSOZopI54hBMZjvtLRV4OzKA7YSimskYMQ+TyYZh6NSVLekRKudMzCUpczyGHqF2+zcYPYJQBI6EDDKLFpCWPxO7Ox1Di9DauIWaLYtoqlozqNKcB9E7CiedwtxTbsMwdAQCxWTpDOiJhn0seedW6sqWDFt/g2YAs2Ljh+P/SpFnOrWBbYxKmEmyLZtPKp9kR/tGInqQi8fexvTUYwlo7VhVB6owcf/ayyltjelu7SY3P5r4EIXuyQS0NmwmJ0HNx19WnE1btKnP/hXFzCFn3EnGiHlsWfECHz9xUTebhDulkBOveh2rPQlDj/LWg8dTXfpZtzYmLLiCWSfeQkttMa/+bQGRLgygmqyMnXsJ0465kYS0kT08KLWwj/KN77Hkzd/SOsgq5QfRE7FMEAqqadfQNPQorQ1bWfHh7ZQsf25YQ18HzQCF7knMzTiNW5eeSIVvI0UJ0/ntrNf5qOIxvJFYPOu75f/gtW130xZpwKa6+Pn0Zzgq52K2tK5AIilwTWRSyuH8YdmpVLRvxKo68FjTaI/uOfpI1yM0Va8jY8Q8EjPGoJpt3Wb4lJwpWKwxC6eimkkvmN2dAYRCas5UhBC01pd2ZpmIXW9h5om3MP2YG1FMFqJhH976EgKtNZitThLTx+LwZDJy+rkkpo/lw39/d0ipYQ5iF7asepFAWy1OTxYmi4No2E9L7Ubq+pmca6AYNAOYFCsSSVBri/3VYzna1S75Y5pCVeQ4xzIuaR4OUwImYe4UlySSxlAV/mgr5468mQ8qHqXUu5zaQD9VW9LoSK0ncSbmYnMm4+vCABkFMf14a0MpnrTRpOfPRChqZ8kjs9WFJy1WNKKhYmW3kMpRM7/LtKN/hmKyULv9G7557SYaK1ah6xGEUHB4YolfJyy4gpScKcw/6y4+fOz8PvMZHUT/0N5UxuYOq/K+wKC1QGXta9nauoprJj/C+aNu4Yfj/8aG5kVU+mKyuNOUyE8mP8q1kx9hSspRpNpysajdE8Y2hiq4Y+V5eMN1XD3xAf4w513mZ57V79SCjZVrMPQoFltCt6RQimomvXA2uhamdNmzGHqUlJwpmLpkcna403EkZiMNLZYlrQM2ZyrTj70Jk8VOe3MZnz79A2q3fYUWDSANDUOP4Gsu55vXf0lVyWcIIcgbd+yg9PoHsf8xaAYIaj42tnyFL9pCfbCcN7bfy4PrriKkx2bhKSlHMiX1KO5dexmPbLiOF7bcTpWvp5hQ5d/Mv4t/zm+XHMuSure4csK95LnG94sGX3M5wfYGVJOVxPSxncftrjQS08cQDbVRUfwRIX8TDk827uT8zmsS0kZhsbqIhn2dKbQBcsYcSVLGWKSUlC57tlvIZldEw77OzMmKycqIyad15jc6EGFxpZA+8SjSJx6N1RM/laQ9ORdHSt6w9mtNSMOVGT9l406YnUkkjZjR7f0pJiuJBVP7lZFuKBj0L2ZWLMzNOJVqfwkVvo34oi0kWtNRRIxgVTGDBENqqMJEUcJUJqcc2a2NJGsmWY6RmBQrbZEm1jYtBGKb4/4g6GukvbkMIQQpObuinBIzxmFzptDWVEZL/Wbam8ux2NwkZ03svCYlexJCUfG1VHYpZSrIGXMUQjFh6BGqSj+nL22Ut24TWiSWojEldxpql+ozfWI/uDGZHQmkjTuMmZf/nfTxR8a9ZuQxVzDy2B8Na785s89gwpm/pS+f6qSCaUy7+G/dIgGd6YXMuuIRLO6UHte7Mkfjzh43LPQNmr0cpgSaQzUcnft9Ds8+HxCowsTHlY/z0tY7WN/0BZX+Tfxqxsu0dKg1Vzd+jNOc2NlGUcJ0Lh//V0K6H11GcZgS+Kbudba3rekXDYYepbFyDZlFC0jKGI+imjH0KOkFs1FUC976zUQCLTRVriGjcC7pBXPYsuIFhFA6wgIFLbXFaB0FGIRQSMqc0KF2ExRMPLHPtIuOhMxOPxy7K7VjtuqHWnQ/+Nf767dT/MYdJI2Y2Uv/gtL3H2S4ubPim5eoXvF23+2Kzv91wl+3jW/uv4Bw2+4ZpAUFCy7AV7eN9urNQ6Z3UAygoHDpuDtoDlfzs6/mENaDKEJlVtqJXDL2z7xX/gjeSB1/WXEuua6xgKAmsAVDGiRZMzGIbThXN37EbctPJ9GagYKCN1JPbWAbuuyvi7KMbYSlQULqCMxWN5FgKxkj5gHQsGMlUhodm1xJWt70zlDLpA7vzIbKlZ0uBarZ2ulrrposTD36hn6/E6GoKHt5uR4qdvr57w6rJ4PJ592GPTmbquVvsu2TXb5LQjGRP/98smeeSshbQ0PxlyTkTmDTW3cx6ZzfUb3yHRo3x9KsjDrux0QDbZQvegaTzcXk8/6EM6OI5i1L2Pja7bv6FgrZ008if8GFaKF22mtKutE18pgryZhyHIYWYcVj1xD1x7SCjtQCxpz0U3Jnn0m4rYGc2WcQaCxn3Yu3UnTU5UR8zZQvegYA1WJn2sV3s+Wjf9C6o2u51u4YHAMIlQL3JD6qeIy2SBMgUYSKIlSiRghdxnw0/JqXzd7uRgu/5kW1ONAjATCbqYtWUhPYgsniQIuGYtnibAkgQYv4O7Q2ApPNhR72x4K7FRXVYkcL+WiqWouuR7C70nB0pElPzpqIroU7CzA0VKxE18Mkpo/F6khCUU04PTlIQ6exSyLVWJWU2Ixu6BottcX9jjX1t1YPa2zEvkS4rYF1L/yWCWf9BlfGyG7nMiYdw9iTb2Dt879B6lEmnn0r4fZGhKLiyZ9CU+mu39eVOYpIe8x+o4X8bHj1NoqO/iGJBVO6tZlYMJXJ59/Ohlf+SKi1jvGn/bKb+FP+1bO0VRUz47KHuh0Pt9Wz9aOHScgaR92GT6ha9gaGFkaPBGmv3sS4035J1bLX0MJ+PPlTSBoxg2BTRZ/PPigG0KTGl9UvcmrhdeS7JxLU2km15TE6cRZvbL+PgBa/rhaAMyWfCSfeyPLnfsaMc/9C2N/M+rfvYPb37mPN639g7DE/IiFrLKrJSlPZCta9GZs5pp35Bxq3L6VsyQsUzb+YhKyxrH7lFtqbdxBsr8eRkIU7tQjFZMHpySLkb8RbF9t0+5rLCbTW4PBk4UkfjaGFsTmTCQdbaG3Y0kmbrkU6TexaNMhHT3xvj4UZdkJKOaCkrAcUpEG4rZ6ovxXF3L2iTvbMU6hZ/R61a2JZwBMLp5M65pD+NErE10TE17N6T+aUY2nZvpLKpa+CNChLymbMCdd1ntdCPoLemk6V9U7okSC+um1oYR8hbx2+ul2/XWPJ1whFJWnkbBo2fk7u7DOoW/cxEb+3TyoHuWZL3iy7n03ebxiZMAOzaqXSt5kXt9xOlb+kT2/HsL8ZR1I2VlcKVncaNncatoQMTFYnYX8Tmxf+g2iwHYs9gUOv/g/bvn6G9rotbP7k78y95EH0SJDCueex+MkfIQ2NcKCZtsbtuJLyO6LHPKhmOy3bF3emDg8FmvHWl+BOGUFK9iQiwVYU1bzbBrijsmNTeayEj2rG5kiiuXrd4F7R/wQE1oR02qp2pRwJt9X36oXa33xDtoR0Qt6aTttLpL1xyJ6dWshH5bLXyJ//XVor1pM24UhWPnYNe9ojDFpo1WWU4pavKW75ekD3RUM+wv5mkvOnEfY1oZosJOVNJthWBxKyJh5L6ohZCEXF7snozBTXXr+FrYueZO4lf2fp09fib4xFURl6lMaq1WSPPoLE9NFEE3MQQqFhx/JOPx1p6NSXLyNv/PGk5k3H760GBM3V63eLd5XUbP2SkdPPQTVZyBlzFNXD5HXYDf8dwWyAJOStxZ68K4O3NSEtNtA7osd2rhhCqNiTsuNsWnsi6K2NiUVCAWlgcacOYP8US4gcrw5b1bLXyZ//PLmzziDqb6G1cg8houwPd2hp4KvfRuaEY2ipWEOgpZqsCcfQWrWBjHFHUDD7bNa9fQcrXvgl/ubKztuEouLJnoC/uYKErHHdZpvGithG2JM2OhZ6KA1qty/u1m39juUYhkZS5niSMmN2hsbKVT1ms/IN7xFor0UIhbFzL8GTPnr438F+0AJZXMm4MkZisruxJ+XgSC1ANccUAiabC2d6EdaEVKzuFJzpRZjsMTeSquVvkDXtRPLmnUv2zFPJmXU60OGfU7GOwkO/R/rEoxhx9OUkFkzr7E+12HGkFWJPzMLs8ODKHInFGYuCq137AYkF0yg8/BIypx5PwYIL6az0rqjYk3JwpRehWuy4MkZiS8rqtBFIaeCv3072jFNIG384yaPmdO7bAk0VtGxfydhTfkblstcxonvWyO0Xy423upj0MQtordpIS8UasiYei7dqA6rFjtQ1kAaZ447AmbzLKJM9+QQSssby5d/PJ7VoNhlddNnNNRvQosHO4trhoJeWmo3d+myu3kA01I4ndSTJWRORhha3kkhb0zY2fPkwhq7hThnB0Rc/TsaIQ3ok6lIUMxabh/SC2Uw58qdYHcn9evadKtaOb/1OO957Wztb2vX/eCg87BImnPErIr5mkkfOZtK5vyexYCoQ2+hOPPtWLK4UTDY3E8++lezpJwHQUPw5G175I5lTTyBl1DyqV74Ty94tJSXv3EPztuUUHnEpZpub9S//vkOjA0lFM5l09q0k5I5HDweZcNZvyV9wAQiF1or1rHrqBlLHzCdzynGUfvgQtWs/BEPH7Exi/Bm/ouCwi2mr3MCoY69m3Kk3YXZ0ZK6QkpL37qO9tpSioy4nbexhuwqDSIPqFW+hmKyde5Y9vsP9ERTvShvB9LP/xJKnf4LFkci0s29j+XM/R48EmXTSL3CmFtBcvhrVbGX7khcItdYx7aw/snXRk7RUrCFlxGwKZp/Dmtd+hx4NYXOlcs5NS3El5SMQNFat5rW7D+vmm2OyODnzhs9JzZuOlAYhXyMv3zkXX8uOHvRZbAkcfv7fGTXzfIRQiITaaKxYibduM9FIALPFgcOTRWL6GFxJeUSCrbx81zz83spu7ZgsDkZMOQObKzWWfsTuwWpPpHDyKTgSMtGiIbavfYNAWw2RYBuRUBuRYCu1277qkeovKXM8mUULsNo9WOweLLYEXMkFFE4+BUUx0da4jYpNH3W000ok2EbI30jZurf6XWi6Pyg49HvkzDqDb+6/YJ8n+OoPxpx0A57ciSx79Mpu/l0HVFC8r2E7Xz58ESCJ+JtZ1PFvgFWv7LQadue95c/9vPNY0/ZlNG3fVcU8EmyltX4LCSkjYs5tO1ai7ZbLRov4aapeR1r+TIRQOrRH8auwREJtfPHCNbQ3lTPh0CuxOVPIHn0k2aOP7LymaxYFf2txnFiCWBrCw7/7IBZ7YrfjO2duk9nWWbK1E1LyzRs392CA/IknMv/Mu9h9lt/ZVkJqERMWXNntXDjQQl3ZkmFlgAMTgtSx80ksnEbBggtY8dg1/a4XsR8tN7KXf8f73vc1hh5l49eP0ly9DgmUrXsr7gvYvORpwv6YWq6hcjV6Hzr+SLCVpW/fSumK5xgx9UwyRxwSS99usqFFAwTaammp3UT1ls+p2fpVXFfdaKiN9V/8A5N5T3lOuz9VvFw3DTtWsmbhvQMSmLRokEiwd5X0YNBWVRzLyXmAxSPbPBnYPJmsfuZGmrf1P1fQAZ0X6ECCoppRVDMQq0VmGFpHUq2Dr+i/Ab2JQAcZ4CC+FeiNAQ5c/92DOIh9gIMMcBDfahxkgIP4VuMgAxzEtxp9boIP4iD+13FwBTiIbzUOMsBBfKtxkAEO4luNgwxwEN9qHGSAg/hW4yADHMS3Gv8PSKKpzhvONg4AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -919,9 +821,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -931,9 +833,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -943,9 +845,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -955,9 +857,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUMAAAMyCAYAAAD30qNKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAB5m0lEQVR4nO3dd5xcdfX/8dc7G1IgQKSI9NADBBJIgtITei+CFFEJFsQfRVFEUL8KoiICIkXE0EKTIjUUKUICIURIAqlUgdBCbykkgWzO74/PZ8LNMLO7szs7996Z88xjHjtzy2fOnZ2c/XxuOVdmhnPONbouaQfgnHNZ4MnQOefwZOicc4AnQ+ecAzwZOucc4MnQOeeAFJOhpEsk/V9a759FktaSNEdSUzvXP0LS/dWOKy8k/VDSXzux/TmS1u2s9oveyyStX4P3mSFpl3auWzZGScMkPdqx6DpO0rmSftSWZVtNhvHDmhe/CB9KulvSmh0N0syOMbMzOtpONUgaIelTSbPjY5qkMyUtX8s4zOxVM+tlZs2tLSupT/wydk2sf52Z7da5US4RQ3dJl0t6JX5ukyTtWbTMzpKelfSJpFGS1k7MO0fSC3HdZyV9p2jdAZImxnUnShrQQizdgF8DZ1d5MxeLv5uXqt2upNGSvl/tdrNMUpOk30uaGX//T0nqnZh/oqS3JM2SdIWk7nF6V0k3SPpI0r2Slkus80tJPy16q3OAX8bvR4va2jPc18x6AasCbwMXtnG9PPmzmS0LrAwcBXwNGCtpmVq8eTKp5UhX4DVgR2B5QjK6SVIfAEkrAbcC/wesAEwAbkysPxfYN657JHC+pG3iut2AO4BrgS8BVwF3tPCl3h941szeqOL25UJOvzunA9sAWwPLAd8G5gNI2h04BdgZWBtYNy4P8HXAgJWAj4Gj4zrrAPsBFyTfxMzeBJ6N81pmZi0+gBnALonXewHPJ16PBr6feD0MeDQ+F3Ae8A4wC5gK9IvzRgC/j8+HAK8DP4vLvgkclWizOyHDv0pIxpcAPeO8lYC7gI+AD4AxQJc47xfAG8Bs4Dlg5zLbuDiWxLRlYxzHJaZ9F3gG+BC4D1i7DdvZEzgXeIXwy3s0TutD+KV+L27XI4lpXROf7ZnAE7HdO4AV4rxX47Jz4mPr5Gcfl9kGGB/fdzywTdHv7QxgbPx87gdWivN6EJLQ+/FzHQ+s0tp3Ja47BTgoPj8aeCwxbxlgHtC3zLojgZ/F57vF350S818F9iiz7hXAr4umbQc8FrfhNWBYnL48cDXwbvy9/DrxnVkfeDh+Zu8BNybaM2D9xHfmb8Dd8fN7HFgvsWxf4AHCd/I54JAycf8BaCYkgjnARYn3OgZ4Icb/t8JnEX/PYwnfufeB39P+/yMzgJPi7+1jwh+rHon4fgD8L643ElitzOexYpw/i/B9PYPEd7Fom78Ut3W9MvP/Cfwx8Xpn4K3E/+kfxufHABfH53cC25Zp71fAla19dyvaZyhpaeBQ4L9tXGU3YAdgQ8IX8BDCL6+Ur8RlVickiL9J+lKc96fYxgDCl3V14Ddx3s8IiXRlYBXgl4BJ2gg4Dhgce3y7E37xbWJmswlf5u0BJO0f2/56fK8xwPVt2M5zgIGExLQCcDKwKPFWOwIbx/hK+Q4hCa8KLOTzv3w7xJ+94/BtXHIlSSsQ/qNeQPii/gW4W9KKicW+SegFfxnoRvhPAaGXtjywZlz3GEISa5GkVeJnMD1O2hSYXJhvZnOBF+P04nV7AoOL1p1itsT1olNKrRttRkg6hfbWBv5NGMWsTPjuTIqzL4zbty7h8/8O4XOA8J/4fsJ/2DVoeRR0GKHH8iVCwvhDfO9lCN+dfxI+28OAiyVtUtyAmf2K8F06Lv4ej0vM3ofwmWxO+E4lvyNfBV4ifOf/QDv+jyTaOgTYA1gnvtewuB07Ef4YH0L4/r0C3FDms/gbIaGvSvi+frfMchB+VwuBg+NQ+HlJxybmL/G9ic9Xid/dacBOcdg8FJgu6UDgPTMbW+b9ngH6txAP0PZh8u2SPiL85diVtu+X+YzQw+pL+Kv2jIVua7llf2dmn5nZPYS/HBtJEqGHcaKZfRCT1B8JX7DCeqsSemmfmdmY+B+omfDXchNJS5nZDDN7sY1xF8wkJDAICeHMuA0LYwwD4n+6ktspqQvhS/FjM3vDzJrN7DEzW5B4j9PMbK6ZlUs215jZtJhI/g84pI0HWPYGXjCza8xsoZldTxgu7JtY5kozez6+902E/0jE7VmR8Fe/2cwmmtmslt5M0lLAdcBVZvZsnNyL8J1J+pjwWRW7hPClv68d6wL0JvTQCr4J/MfMro/fi/fNbFL87A4DTjWz2WY2g9Bz/3Zc7zPC0Gw1M5tvZi0dBLjNzJ6I34fr+Pzz2weYYWZXxs/+KeAW4BsttFXKn8zsIzN7FRiVaB9gppldGN97Pu37P1JwgZnNNLMPCD2swvscAVxhZk/G7+ypwNaF3SAF8TM9CPhN/C5PI+zWKGcNwh+jDQkJ+GDgNEm7xvnFv/vC82WBe4CX+XzEcwPwW+BkSX+Q9Iiki4t2p8wmfD9a1NZkeICZ9SYMn44DHpb0ldZWMrOHgIsIfzXekTQ8ucOzyPvxF1vwCeFDWRlYGpgYd5p+BNwbp0NIzP8D7pf0kqRT4nv/D/gJcFp87xskrdbG7S1YnTA8gPAf5PxEDB8Qhsert7CdKxE+s5aS8GutxJCc/wqwVGy3NavF5ZNeIWxTwVuJ54XPG+AaQlK6Ie7g/nNMdiXFpH8N8Cnh+1Ewh7A/KGk5lkxaSDob6EcYSlol6yZ8yJKJck1Kf+4rET7D5GeT/FxOJvxen5A0XVJLPZxyn9/awFcL35X4fTmCMPqpRLn2YcnvRbv+j7ThfZb4DpnZHMKIJ/kdKrx/Yf9xQfF3L6nwh/93ZjbPzKYQktpecXrx777wfLYFp5jZ5mZ2NGHf4iWEHvQgQk+/G0v2TJcl7CJoUUXD5NhLuJXQ69ouTp5L+EUUfKVonQvMbCCwCeEvwc8reU/Cfpt5wKZm1js+lrdwQIf41/1nZrYuYSfpTyXtHOf908y2I3w5DTirrW8qqRewC2EIA+EX/cNEDL3NrKeZPdbCdr5H+Ku9Xgtv1VrZoOSR+7UIf+Xfa8N6MwnbnbQWYT9ci2Lv4XQz24QwvN+HMJT8gthzv5ww/DrIzD5LzJ5OYngSh4/r8flQGEmnA3sCuxX1PqcDm8f2CzZPrltkCuFzL3iN0p/7e3ze+ytY/LmY2Vtm9gMzWw34IWF4W+kpLq8BDxd9V3qZWblTPNpTOiq5Trv/j7Riie9Q/P2tyBe/Q+8Shr3F39VyppTYhuTzJb438fnbZrbELjZJmxG+n8MJQ++J8Y/peMJ3pWBjlhx2l1TpPkPFfWdfIozDIeyH+bqkpeOX5nuJ5QdL+mrsVcwlJIZFVMDMFgGXAudJ+nJsd/V4xAlJ+0haP/6n+ZiQqBdJ2khSYd/CfMKXpdX3VjhdZCBwO6G3cWWcdQlwqqRN43LLS/pGS9sZY78C+Iuk1RROJ9i6cJpAG31L0iZxf+3vgJstnHrzbtyecue93QNsKOmbCqcjHEpI1He14TMYKmmzOPyZRUge5T67vxO+bPuWGOrfBvSTdJCkHoR9WFMKw2hJpxKGs7sUf9EJB3iagRPi76TQ43yohe3dMfH6OmAXSYfE7V9R0oD42d0E/EHSsnE3x08JB4yQ9A1Ja8Q2PiT8J63oO0v4jDeU9G1JS8XHYEkbl1n+bcr/HlvV3v8jbWj6euAohVOcuhOG3o/HXQvJ928mnDVwWswDmxD2O5eL90VCJ+NX8Xe7MWFIX/huXg18L37vexMOcI1IthG35SLghLj9LwPbxeHxjoT9qQU7EvYft8zadjR5HqHrOpuwA/OIxPyVCDucZxOOcJ3G50eTdyb8FZhD+Ot1HdDLyhxNLvG+u9jnRzf/GDdwFiERnxDnnRiXnUvYSfx/cfrmhKNaswlD2rtIHAkreq8RhCHe7BjrdEIvsnfRct8mHCmeRfjrf0UbtrMn8FfCX9OPCUeNk0eTuybaX2IaXzyafCfxiG+c/ztCUvyIcCrQMJY8mrwdMDG+70Rgu8S80ZQ/C+BwwsGIuYT/qBck40ysU+hxF46EFh7J78cuhH2V8+J79knMM2BB0bq/TMzfIsY9D3gS2KKF7+lShCOpyaOd2xOO8hZ+X0fa50czr42f3WuEJF04uvrn+LuaQxhmH10Ub/Jo8u8T84aQ+A4DGxEOYL1LGFo+BAwoE/vWwPOE5HtB8XuV+P+yxO+5vf9Hiv+fxdenAdcmXh8TP4fC/6E1ynweK8f5rR5NjsuvThjKz4kx/7Bo/k8J371ZhA5J96L53wX+lnjdlTDU/piwi2e5OH3VuM3dWst1hUP1LoMkjSZ8MS9LO5Y8kHQ0sImZ/STtWFw2SDoXeNHMLm5t2TyerOlcSWY2PO0YXLaY2c/auqwXanDOOfBhsnPOgfcMnXMO8GTonHOAH0BpC9+P4OqJWl+kMXkybMU/X7w37RAq8s319uDNT+5MO4yKrLr0vrw2N18xr7nMvrwzf2TaYVTkyz1ar2LVyHyY7JxzeDJ0zjkgw8lQ0hqS7lAoC/+ipPMldYvXSe6VWO40SSe11JZzzrUmk8kwXoR9K3C7mW1AqEbSi1DEcgCfl/qpxnu16+ZLzrn6kslkCOwEzDezK2FxVYwTge8TLqQ/VOHmQ4fG5TdRuKnOS5JOKDQi6VuSnojL/qOQ+BRubnWupMmEi+Sdcw0uq8lwU0K1ksUs1LqbQbjfw41mNsDMCjcX6ksoib4V8NtYMmljwi0KtjWzAYSyRUfE5ZchlCLqby1XMnbONYisJsNK3W1mC8zsPcJNmVYhlNUaCIyXNCm+LtSMayaUYS9J0tGSJkia8NAN93Ru5M65TMjqeYZPE+6LsJhCGf21CBV1iyXvKdJM2C4R7sdxaonl51sL9yaO1U+GA/zzxXv9pGvnGkBWe4YPAksr3lQ87us7l1Dg8m3K3xSouI2DE5V/V1DiBubOOZeUyWRooZTOgcA3JL1AqAI8n3CLw1GEAybJAyil2niaUC78fklTCLduXLXTg3fO5VJWh8mY2WsseVvLggWEO2GVW69f4vmNhJtiFy/Tq3iac66xZbJn6JxztebJ0Dnn8ErXbeEfkKsnXsKrjMzuM8yKTxdNbH2hDOnWZSC2+JbW+SA29phrQJS7bbMDHyY75xzgydA554CcJENJB0gySX3bse7vJO3SGXE55+pHLpIhcDjwaPzZZpKazOw3ZvafzgnLOVcvMp8MJfUCtgO+BxwWp3WRdLGkZyU9IOkeSQfHeTMknSXpScIVLCMS8wZLekzS5Fjaqy2X9TnnGkAejibvD9xrZs9Lel/SQGAdoA+wCfBl4BngisQ675vZlgCS9og/uxGuRjnUzMbHwg/zarcZzrksy3zPkDA0viE+vyG+3g74l5ktMrO3CNcrJ33hEjxgI+BNMxsPoT6imZWqgLNECa/Lht9alY1wzmVbpnuGklYgVL3eTJIBTYSToG9rZdW5HXnfZAmvTxdN9JOunWsAWe8ZHgxcY2Zrm1kfM1sTeBn4ADgo7jtcBRjShraeA1aVNBhA0rKSMv3HwDlXO1lPBocDZxVNuwXYGHidUAT2NeBJ4OOWGjKzT2PJrwsl9STsL9wFmFPtoJ1z+ZPba5Ml9TKzOZJWBJ4g3OvkrWq/T96GyX45Xm3kNWb82uSyst4zbMldknoD3YAzOiMROucaR26ToZkNSTsG51z9yO0wuYb8A3L1xIfJZeS2Z1grFz59f9ohVOT4TXbL5b6s2Z89mHYYFVl2qZ1zWd7NlZf1U2ucc64mPBk65xyeDJ1zDshoMpTUHO+LPFnSk5K2idP7SJpWZp3RkgbF5zMkjSmaP6mwrqQBkvbq7O1wzuVHJpMhMM/MBphZf+BU4Mx2tLGspDUBJBXf/GEA4MnQObdYVpNh0nLAh8UTJfWUdIOkZyTdBvQsWuQm4ND4/HDg+rheN+B3wKGxt3gozrmGl9Vk2DMmqmeBy4AzSizzI+ATM9sY+C1QfN7ALcDX4/N9gTshXKMM/Aa4MfY+v1DuK1nCa+xN91Rni5xzmZbVZFgYJvcF9gCullR8sugOwLUAZjYFmFI0/33gQ0mHEYq/ftLWNzez4WY2yMwGbXuIj6adawRZTYaLmdk4YCVg5XasfiPwN+IQ2Tnnysn8FSjxjnhNhJ7e0olZjwDfBB6S1A/YvMTqtwGrAvcBqyWmzwb8/ifOtaDnWodn4lLUea9eX5NLCLPaMyzsM5xE6N0daWbNRcv8Hegl6RnCAZEvXBtlZrPN7Ky4nzBpFLCJH0BxzhVksmdoZk1lps8A+sXn84h3yyuxXJ9W1v0AGFyVYJ1zdSGTydA5lz4pqwPHzuElvFrnH5CrJ23e/7b02kdk4rv/ySvX1WSfofcMnXMlKbOHFDqHJ8NW5LE2oMfc+cTGvDjrzrTDqMh6y+2bdgiZ1lip3znnyvCeoXOupEY7gJKrZBhvC1qoD/8VoBl4N77eqsT5hM451ya5SoZm9j6h/BaSTgPmmNk5acbknKsPue8HS9pZ0lOSpkq6QlJ3STtJuj2xzK6SbpPUJGmEpGlx+RNTDN25TJO6ZOJRK3lPhj2AEcChZrYZoaf7I8Lldn0lFYo7HAVcQehVrm5m/eLyV9Y8YudcJuU9GTYBL5vZ8/H1VcAOFs4kvwb4lqTewNbAv4GXgHUlXShpD2BWqUaT9QyHD7+p0zfCuSySlIlHreRqn2GFriQUdJ0P/MvMFhLqG/YHdgeOAQ4Bvlu8opkNB4YDGM9k4ix851znynsybAb6SFrfzP4HfBt4GMDMZkqaCfwa2AVA0krAp2Z2i6TniMVhnXMu78lwPmF/4L8kdQXGA5ck5l8HrGxmhcsbVgeu1Od7ZU+tWaTO5U7e96JVJrfJ0MxOS7zcosxi2wGXJtaZDGzZiWE553Iqt8mwNZImAnOBn6Udi3Mu++o2GZpZ8d3ynHMV8Mvx3BJE8f3ns89jrg2vAlNfPBm24p35I9MOoSJf7rFfLsth5TFmeL7V5bJlw4qWbrSeYWNtrXPOleHJ0Dnn8GGyc66MRiv7n7mtlWSSrk287irpXUl3xdf7STolvQidc/Uoiz3DuUA/ST3jvZF3Bd4ozDSzkUC+jmo4l0N+ACUb7gH2js8PB64vzJA0TNJF8fkISRdIekzSS5IOTiz3c0njJU2RdHqctoykuyVNjjUND63hNjnnMiyryfAG4DBJPYDNgcdbWHZVwmV3+wB/ApC0G7ABsBWhhuFASTsAewAzzay/mfUD7i3VYLKE19WX31elTXLOZVkWh8mY2RRJfQi9wntaWfx2M1sEPC1plThtt/h4Kr7uRUiOY4BzJZ0F3GVmY8q8/+ISXu/MH+klvFxDarRhciaTYTQSOAcYAqzYwnILEs+V+Hmmmf2jeGFJWwJ7Ab+X9KCZ/a464Trn8izLyfAK4CMzmyppSIXr3gecIek6M5sjaXXgM8L2fmBm10r6CPh+NQN2zuVXZpOhmb0OXNDOde+XtDEwLpYNnwN8C1gfOFvSIkJy/FGVwnWu7vgwOWVm1qvEtNHA6Ph8BOEmUJjZsHLrmtn5wPlFTb1I6DU659wSMpcMnXPZIGp3M6Ys8GTYii/32C/tECqWx3JYeYy50iowLtsaa6eAc86V4T3DVnyycGzaIVRk6a7bks86ex5z5/N6hi1prK11zrkyPBk65xw5S4aSVpH0z1iUYaKkcZIObGH5IYXSXyXmzYg3lXfOlSB1ycSjVnKTDBXOnr4deMTM1o13vzsMWCPVwJxzdSFPB1B2Aj41s0sKE8zsFeDCWN3m78AgYCHwUzMblVxZ0oqEUmCrA+OgwU6icq5CfgAluzYFniwz71jAzGwzQqWbq2KCTPot8KiZbQrcBqzVaZE653InT8lwCZL+Fou0jifUM7wWwMyeBV7hi+cR7JBY5m7gwxbaXlzP8IpL7+iU+J1z2ZKnYfJ04KDCCzM7Nh4AmQC8Xs03StYz/GThWK9n6BpUbvtK7ZKnrX0I6CEpWWlm6fhzDHAEgKQNCUPg54rWfwT4ZlxmT+BLnRqtcy5XcpMMzcyAA4AdJb0s6QngKuAXwMVAF0lTgRuBYWa2oKiJ04EdJE0Hvg68WrPgnXOZl6dhMmb2JuF0mlKOKrH8aD4v/fU+4VYAzrk28KPJzjnXgHLVM3TO1U6j9Qw9GbYiVIHJmzzW2fOYXbo8GbZiQfP4tEOoSPemweSxtJTxTNpBVCQUo83f5+zK82TonCtJDXZIobG21jnnyvBk6Jxz5HCYLOkrwF+BwcBHwNvAT8ysoh04kuaUui2pcy7wo8kZFmsa3gZcZWaHxWn9gVXI395s51yG5C31DwU+K6ppOBl4VNLZkqZJmirpUABJvSQ9KOnJOH3/tAJ3Lm8kZeJRK3lLhv2AiSWmfx0YAPQHdgHOlrQqMB840My2JCTSc9WGTzdZwuuyS2+rWvDOuezK1TC5BdsB15tZM/C2pIcJ+xT/DfxR0g7AIkKV61WAt1pqLFnCa0HzeC/h5VwDyFsynA4cXMHyRwArAwPN7DNJM4DiCtjOuRIa7QBK3rb2IaC7pKMLEyRtTjiqfKikJkkrE6paPwEsD7wTE+FQYO0UYnbO5UCueoZmZvHWoH+V9AvCPsEZwE+AXsBkwICTzewtSdcBd8Y6hxOAZ1MJ3LkcarQrUHKVDAHMbCZwSIlZP4+P5LLvAVuXacfPMXTOLdZYqd8558rIXc+w1kIVmLzJX3WSUAUmb/L3OVfCD6A451wD8p5hK5Zb9/tph1CRWS9dlsvagAsXTU47jIp07dKf/F0BWt892Y7yZOicK8mHyc4514DqMhlKWkPSHZJekPSipPMldZM0SNIFcZlhki5KO1bnskp0ycSjVuouGcZCDLcCt5vZBoQdJb2AP5jZBDM7IdUAnXOZVHfJENgJmG9mVwLE4g0nAt+VtJeku1KNzjmXSfV4AGVTisp8mdksSa8C66cTknM55AdQXLKe4aez/HJm5xpBPSbDp4GByQmSlgPWAv7XlgbMbLiZDTKzQd2W69sJITrnsqYek+GDwNKSvgMgqQk4FxgBfJJiXM7litQlE49aqbtkaGYGHAh8Q9ILhMsE5gO/TDUw51ym1eMBFMzsNWDfErNGxwdmNoLQW3TOlVDLmzFlQd31DJ1zrj08GTrnHHU6TK6mWS9dlnYIFctjbcBQBSZv6rsKjJf9d0t44eN8XbCywfL7kMfSUpM/yNfn3H+FfXJZKs2V11ip3znnyvCeoXOuJK9n6JxzDSjzyVDSVyTdEOsSTpR0j6SK9lxLOkDSJp0Vo3N1ScrGo0YynQxjbcLbgNFmtp6ZDQROBVapsKkDgJLJUJLvKnDOZTsZAkOBz8zsksIEM5sMNEkaLelmSc9Kui4mTiT9SdLTkqZIOkfSNsB+wNmSJklaL677V0kTgB+nsmXOuUzJeq+oH0W1CRO2INQunAmMBbaV9AzhuuS+ZmaSepvZR5JGAneZ2c2w+DKjbmY2qFTDko4Gjgb43V+P5bBhe1Rzm5zLh6x3laos68mwJU+Y2esAkiYBfYD/EooyXB4rWrd08tqN5WaY2XBgOMALH99lVYrXOZdhWc/90ymqTZiwIPG8GehqZguBrYCbgX2Ae1toe25VInSuXqV94MQPoCzhIaB7HLYCIGlzYPtSC0vqBSxvZvcQ7ntSuMZrNrBsJ8fqnMuxTCfDRG3CXeKpNdOBM4G3yqyyLHCXpCnAo8BP4/QbgJ9LekrSep0dt3MufzK/z9DMZgKHlJh1aWKZ4xLTtyrRxliWPLVmSLXic65ueT1D55xrPJnvGaYtVIHJm/yVluq/Qv4+Z68CU188GTrnSmuwcaMnw1Y8+d7daYdQkS1X2ptmm5Z2GBVpUj8WLpqcdhgV6dqlPx8uyFcNxi91z1/vu5Y8GTrnSjI/gOKcc40nN8lQUnMstFB49Olge30k5Ws86ZzrNHkaJs8zswFpB+Fcw2isUXJ+eoalSBog6b+xXNdtkr7UyvSBkiZLmgwcm2rwzrlMyVMy7JkYIt8Wp10N/MLMNgemAr9tZfqVwPFmlsf7UjrnOlGekuE8MxsQHwdKWh7obWYPx/lXATu0ML13nP5InH5NuTeSdLSkCZIm3Hp1S4VvnKtjXZSNR43kaZ9hzSTrGT753t1ez9C5BpCnnuESzOxj4ENJhXJe3wYebmH6R8BHkraL04+oacDO5U3adQxrXM8w7z3DI4FLJC0NvAQc1cr0o4ArJBlwf62Ddc5lV26SoZn1KjFtEvC1CqZP5POCrwAnVy9C51ye5SYZOudqzM8zdM65xuM9w1ZsudLeaYdQsSb1SzuEinXtkr9TP70KTH3xZNiK2Z89mHYIFVl2qZ0xnkk7jIqIjfl0UbnbY2dTty4DGf9uvsq7DV65wj/sNTzHLwt8mOycc3jP0DlXjtczTJ+kOUWvh0m6qIXly86XNEPSSiWmnybppI5H65yrB5lMhs45V2u5S4aSviFpWizF9Uhi1mqS7pX0gqQ/l1n3V5Kel/QosFFtInYup5SRR41kdZ9hT0mTEq9XAEbG578BdjezN2IlmoIBwBbAAuA5SRea2WuFmZIGAofF5boCTwL5OoTpnOs0We0ZJst1DSAkwIKxwAhJPwCaEtMfNLOPzWw+8DSwdlGb2wO3mdknZjaLz5PrFyRLeF15Wb7ugOZc1aRdustLeLXMzI6R9FVgb2Bi7PFB6BEWNNOBbUuW8Jr92YNewsu5BpDVnmFZktYzs8fN7DfAu8CabVz1EeAAST0lLQvs22lBOudyJ3c9Q+BsSRsQdq0+CEwm7AdskZk9KenGuPw7wPjODNK53Gus0wyzmQyLy3WZ2QhgRHz+9RKrLJ4fl9kn8bxP4vkfgD9UMVTnXJ3I3TDZOec6QyZ7hs659FmDXY7nybAVyy61c9ohVExsnHYIFevWZWDrC2VMxVVgXKZ5MmxFs01LO4SKNKkfCxdNTjuMioRahs+nHUaFNszld6MiOSnhJelE4PuAEe6TfhSwKnADsCLh4opvm9mnLbXj+wydc7klaXXgBGCQmfUjXIhxGHAWcJ6ZrQ98CHyvtbY8GTrn8q4r4RLersDSwJvATsDNcf5VwAGtNeLJ0DlXWtoFGtpQqMHM3gDOAV4lJMGPCcPij8xsYVzsdWD11jY3F8kwVpuZLmmKpEnxcry2rDdEkl9c7FyOJWsFxMfRiXlfAvYH1gFWA5YB9mjP+2T+AIqkrYF9gC3NbEEs1Not5bCcczWSrBVQwi7Ay2b2LoCkW4Ftgd6Susbe4RrAG629Tx56hqsC75nZAgAze8/MZkraWdJTkqZKukJSdwBJe0h6VtKTwOKrVSRtJWlcXOcxSV7P0LmWSNl4tOxV4GuSlpYkYGdC1apRwMFxmSOBO1prKA/J8H5gzViU9WJJO0rqQbj87lAz24zQw/1RnH4poQjDQOAriXaeBbY3sy0IJcH+WO4Nk93yS4f/q3O2yjnXYWb2OOFAyZOE02q6EHqRvwB+Kul/hNNrLm+trcwPk81sTizTtT0wFLgROJPQNS6cnHYVcCwwOk5/AUDStUBh/8LywFWxyIMBS7Xwnou75c02zUt4ucaUk/MMzey3wG+LJr8EbFVJO5lPhgBm1kxIdKMlTSUkvkqdAYwyswMl9YntOecckINhsqSNYm+uYADwItBH0vpx2reBhwlD4T6S1ovTD0+stzyf70Qd1mkBO+dyKfPJEOhFGN4+LWkKsAlwCuGSm3/FnuIi4JJY8v9o4O54AOWdRDt/Bs6U9BQ56RE7l6q0zy9sw3mG1ZT5pGBmE4FtSsx6kHADqOLl7wX6lpg+DtgwMenX1YrROZd/eegZOudcp8t8zzBtFVf6yIBQBSZvNmx9kYzJ43ejIg1Wz9B7hs45h/cMW+W1AWshn7UBP100Me0wKlJxAV3vGTrnXOPxZOicc+RomCypmXDtoYBm4DgzeyzdqJyrYw3WVcpNMgTmmdkAAEm7E65P3rGjjUpqipf7OecaWF5z/3KE+xoAIOnnksbH4q+nJ6Z/S9ITsSDsPyQ1xelzJJ0raTKwde3Ddy4H0i7d1bYSXlWTp55hT0mTgB6EGoc7AUjaDdiAUKFCwEhJOwDvAocC25rZZ5IuBo4AriZUw33czH5W861wzmVSnnqG88xsgJn1JZT1vjoWc9wtPp4i1DTrS0iOOxNqGo6PSXRnYN3YVjNwS7k3WrKe4c3lFnPO1ZE89QwXM7Nxsfz/yoTe4Jlm9o/kMpKOB64ys1NLNDG/pf2EyXqGCxdN9nqGrjE11mmGueoZLiapL+H+qO8D9wHfldQrzltd0pcJhRwOjs+RtIKktdOK2TmXbXnqGRb2GUL4m3Vk7N3dL2ljYFwYNTMH+JaZPS3p13F+F+AzQlHYV2ofunMu63KTDM2sqYV55wPnl5h+I+E2AcXTe1U3Oufqj+Wk7H+15HKY7Jxz1ZabnqFzrsYarFCDJ8NWeG3A2shjbcCKq8C4TPNk2Covh9XZmtQP45m0w6iI2Jg8fjdceZ4MnXOlNdYo2Q+gOOcceDJ0zjkgI8lQ0q8kTY9VZyZJ+moH2xsi6a5qxedcQ+qibDxqJPV9hpK2BvYBtjSzBfGa424ph+WcazBZ6BmuCrxnZgsAzOw9M5spaYakM2NPcYKkLSXdJ+lFSccAKDhb0jRJUyUdWty4pMGSnpK0nqSBkh6WNDG2tWqNt9W5/Ei7jmGN6xlmIRneD6wp6XlJF0tKVq9+NVa3HgOMAA4GvgYUCrh+HRgA9Ad2Ac5OJjhJ2wCXAPsDrwIXAgeb2UDgCuAPpQJKlvAaPvwLV/M55+pQ6sNkM5sjaSCwPTAUuFHSKXH2yPhzKtDLzGYDsyUtkNQb2A64PhZseFvSw8BgYBawMaEM126xp9kP6Ac8EAs6NAFvlolpcQkveN5LeDnXAFJPhgAxmY0GRkuaChwZZy2IPxclnhdetxb7m4Sq2FsAMwlnTU03My/z71xb+HmGtSVpI0kbJCYNoO1ltsYAh0pqkrQysAPwRJz3EbA3cKakIcBzwMrxgA2SlpK0aYc3wDlXF1JPhkAv4CpJT0uaAmwCnNbGdW8DpgCTgYeAk83srcJMM3ubcKT6b4Qe4sHAWfFGUJOAbaq0Dc65nJOZ7xJrWd72Gfq1ybWQ42uT2zz4Xe+omzLx3X/xykNqMmDPQs/QOedSl4kDKNmWv0ofeSyHFXpaeZO/70ZFvNK1c841Hu8ZtmLhoslph1CRUIw2f/uy8vg553M/pyvHk6FzriRrrFGyD5Odcw5ykgwlrRgLNkyS9JakNxKvv1DhRlIfSd9MvPaSXs65FuVimGxm7xOuTEHSacAcMzunhVX6AN8E/tnZsTlXt/xocn7E8lxTJPWQtEwsENsP+BOwfew5nli0zo6JXuVTkpZNJ3rnXJbkomdYjpmNlzQS+D3QE7jWzKbFqjcnmdk+EIbJidVOAo41s7GSegHzaxy2c/nQYPdNznXPMPodsCswCPhzG5YfC/xF0glAbzNbWLxAsp7hpcNvrm60zrlMynXPMFqRUOxhKULJrrktLWxmf5J0N7AXMFbS7mb2bNEyi+sZLlw0ORPXZzrnOlc9JMN/AP8HrAOcBRwHzAZK7guUtJ6ZTQWmShoM9AWeLbWscw2twQ6g5DoZSvoO8JmZ/VNSE/CYpJ0IdQ6bY6muEcBTidV+ImkooUDsdODfNQ7bOZdBuUuGZnZa4vnVwNXxeTOQvMXoTkWrjo7LHd+5ETpXJ+rhiEIFGmxznXOuNE+GzjlHDofJtRaqwORN/urs5fFzrvsqMA12nqEnw1ac9PhDaYdQkXO+ulMuy/4vaB6fdhgV6d402Et41RkfJjvnHN4zdM6V02DnGXrP0DnnyHAylHSAJJPUtw3L/kTS0rWIy7lGYVImHrWS2WQIHA48Gn+25ieAJ0PnXLtlMhnG0lrbAd8DDovTlqhWLekiScNi9ZnVgFGSRsV5h0uaKmmapLPitCZJI+K0qcV1Dp1zjS2TyRDYH7jXzJ4H3pc0sNyCZnYBMBMYamZDJa1GKNiwE6E69mBJB8Tnq5tZPzPbDLiyXJvJEl5Tbve7BbgG1SUjjxrJajI8HLghPr+Btg2VCwYDo83s3Vir8DpgB+AlYF1JF0raA5hVrgEzG25mg8xs0OYH7NO+LXDO5UrmTq2RtAKhV7eZJAOaAAPuYMnk3aOSds3sQ0n9gd2BY4BDgO9WJWjnXO5lsWd4MHCNma1tZn3MbE3gZUKsm0jqLqk3sHNinWT9wieAHSWtFMt6HQ48LGkloIuZ3QL8GtiyRtvjXD51UTYeNZK5niEheZ1VNO0WwoGUm4BphOSYrFE4HLhX0sy43/AUYBQg4G4zuyP2Cq+UVPgDcGpnboRzLl8ylwzNbGiJaRckXp5cYv6FwIWJ19cD1xctMxnvDTrXdg1WqCGLw2TnnKu5zPUMs+acrxYXzM6+JvVLO4SKdW8anHYIFfMqMPXFk6FzrrQGK9TgybAVny6amHYIFenWZSDwfNphVGjDXNYGvOOVfN1LbP+190w7hEzzfYbOOYf3DJ1z5TTWKDkfPUNJX5F0g6QXJU2UdI+kDSVNi/MHSNorsfxpkk5KL2LnXN5kvmcoScBtwFVmVqhg0x9YJbHYAGAQcE/NA3SuTlmDHUDJQ89wKPCZmV1SmBBPoH4NQFI34HfAoZImSTo0LraJpNGSXoplvpC0jKS7JU2OpbwOxTnnyEHPEOgHlD2ka2afSvoNMMjMjoMwTAb6EhLpssBzkv4O7AHMNLO943LLd3LszrmcyEPPsL3uNrMFZvYe8A5hWD0V2FXSWZK2N7OPS62YrGd42fBbaxmzc9mRdoEGL9TwBdMJlWwqtSDxvBnoambPS9oS2Av4vaQHzex3xSua2XBC8Qc+XTTR2vHezrmcyUPP8CGgu6SjCxMkbQ6smVgmWcKrrFgF+xMzuxY4Gy/c4Fx5UjYeNZL5ZGhmBhwI7BJPrZkOnAm8lVhsFOGAyaRWDopsBjwhaRLwW+D3nRS2cy5n8jBMxsxmEipTF+sX539AKPdfbv1C5YIZwH3Vjs85l3+5SIbOuRRkftxYXQ22uc45V5r3DFsRqsDkzYZpB1CxPNYG9Cow9cWTYSvmLnw47RAqskzXHcljCS+PuRYq/CPpZf+dc67xeM/QOVeaF2pwzrnGk7lkKKk5njw9WdKTkrZJOybnXP3L4jB5npkNAJC0O+Fqkx1Tjci5RuTD5ExZDvgQQpFXSWfHOoRTC5fdSTo/lvBC0u6SHpHURdJASQ/Hytj3SVo1LnOCpKclTZF0Q2pb5pzLlCz2DHvGa4d7AKsChRsXf51Q0bo/sBIwXtIjwKnx+RjgAkJFmibgQmB/M3s3Js4/AN8FTgHWMbMFknqXCiAWhTga4IKLf8Z3f7BvJ2ymcy5LspgMk8PkrYGrJfUDtgOuN7Nm4G1JDwODzWykpB8AjwAnmtmLcfl+wAPhrgE0AW/G9qcA10m6Hbi9VADJEl5zFz7sJbxcQ7IGO88wi8lwMTMbJ2klYOVWFt0MeB9YLb4WMN3Mti6x7N7ADsC+wK8kbWZmC6sVs3MunzK9z1BSX0Kv7n1gDOE+J02SViYktCckrQ38DNgC2FPSV4HngJVjzxJJS0naVFIXYE0zGwX8Alge6FXzDXMuD7pk5FEjWewZFvYZQujhHWlmzZJuA7YGJgMGnAy8DTwAnGRmMyV9DxhBKOd1MHBBvM9JV+CvhOunro3TBFxgZh/VaLuccxmWuWRoZk1lphvw8/hI2iWxzETCkBlgEqH3WGy7jkfpnKs3mUuGzrmM8AMoLilUgcmb/JXw8phd2jJ9AMU552rFe4ateG3unWmHUJE1l9mXPNbZM55JO4iKiI1Z0Dw+7TAq0r2p7G2CSvPL8ZxzrvF4z9A5V1qD9QwzmQwlNQNTCfE9QzjX8JN0o3LO1bOsDpPnmdmAeL/jT4FjOuNNYiWcrH4GzrkaykMiGAOsL2lfSY9LekrSfyStAiDpNEnXSBon6YVYtIE47+eSxsdyXafHaX0kPSfpamAasGYqW+Vc1ikjjxrJ5DC5QFJXYE/gXuBR4GtmZpK+T7gc72dx0c2BrwHLAE9JuptQtWYDYCvCRzpS0g7Aq3H6kWb231puj3Muu7KaDJPXJ48BLgc2Am6MRVq7AS8nlr/DzOYB8ySNIiTA7YDdgKfiMr0ISfBV4JWWEmGynuGZF/w/jvjuHtXaLudyw/wASiYsrmlYIOlC4C+xfuEQ4LTE7OKag0boDZ5pZv8oaqcPMLelN0/WM3xt7p1ez9C5BpCHfYYFywNvxOdHFs3bX1IPSSsCQ4DxwH3AdyX1ApC0uqQv1ypY51y+ZLVnWMppwL8kfQg8BKyTmDcFGEW4HcAZZjYTmClpY2BcrHY9B/gW0FzLoJ3LLS/UkD4z+0LBVTO7A7ijzCpTzOw7JdY5Hzi/xPL9Ohahc67e5GmY7JxznSaTPcNKmNlpacfgXF3yo8kuKVSByZv81dkTG6cdQsUqrgLjMq3DyVDSGsBhwPaEu9PNI1zZcTfwbzNb1NH3SFf+ymHlMeY8lvB6f/7ItMOoyIo99qtshcbqGHYsGUq6ElgduAs4C3iHcPP3DYE9CLfiPMXMHulooM4515k62jM818ymlZg+DbhVUjdgrQ6+h3POdboOJcMyiTA5/1Pgf5W0mSjfJcI5gceZ2WOVxhavUjnJzPapdF3nHHRpsHNNOrS5knpJ+p2k6ZI+lvSupP9KGtaBZgvlu/oDpwJndiRG55xri47m/uuAl4DdgdOBC4BvA0Ml/bGDbQMsB3wIi2sPni1pmqSpkg5taXqSpMGx9Nd6knaUNCk+npK0bBXidM7lXEf3GfYxsxHx+V8kjTezMyQdBTwN/LIdbRYq1vQAVgV2itO/DgwA+hMuuxsv6RFgmzLTAZC0DXAhsL+ZvSrpr8CxZjY2Xrc8vx0xOlf3GuxqvA73DOdK2g5A0n7ABwDxdJr2fpSFYXJfwhHpqxUuLt4OuN7Mms3sbeBhYHAL0wE2JlSf2dfMXo3TxhIS9wlAbzNbWByApKMlTZA0YfjwG9u5Gc65POloz/AY4DJJGwDTge8CSFoZ+FsH28bMxklaCVi5nU28SehhbgHMjG3+KRZ/3QsYK2l3M3u26H0Xl/CC572El2tI3jOsgJlNMbOtzOxLZradmT0fp79rZhd0NDhJfYEm4H1CkddDJTXFZLsD8EQL0wE+AvYGzoxHl5G0nplNNbOzCKW++nY0Tudc/lX9cjxJD5nZTq0vWVayyrUI5fmbJd0GbA1MJhRvPdnM3mphel8AM3tb0j7AvyV9F/iWpKHAIkJv9t8diNU5Vyc6egXKlOJJwIaF6Wa2eaVtmllTmekG/Dw+2jJ9NDA6Pn8V2DTOerzSmJxrRGqwcXJHe4YzgFnA7wnXJIswbM1jdQPnXA5J6g1cRqhTaoRjF88BNwJ9CHnqEDP7sKV2OrrPcD/gFsLBhv5mNgP4zMxeMbNXOtK2c8610fnAvfEMlP7AM8ApwINmtgHwYHzdIoVRZsdIWgY4A1gPGGhma3S40ezwo8munrR57Lv+JY9k4rv/v2N2KBuzpOWBScC6lkhmkp4DhpjZm/GOmqPNbKOW3qcqB1DMbC7wU0n9CQcznHOuFtYB3gWujPlnIvBjYBUzezMu8xawSmsNVSUZStoWmGRmkyVtLukvwPn1MFT+zxv3pB1CRXZZfS8mf3BX2mFUpP8K+3Dh0/enHUZFjt9kN7a749G0w6jIo/tvV9HyWTl+kryPeTQ8ngsMIYdtCRxvZo9LOp+iIbGZmaRWe7nVqkvxd+CTmJlPBF4Erq5S2865BmZmw81sUOIxPDH7deB1MyucJXIzITm+HYfHxJ/vtPY+1UqGC+N4fX/gb2b2N8ALIDjnOpWZvQW8JqmwP3BnQl2EkXx+f/UjKX9nzcWqddL1bEmnEirWbC+pC7BUpY1UsZbhRsA/gN5Ad2CMmR3d4krOuSUoP/UMjweui8WkXwKOInT0bpL0PeAV4JDWGqlWMjwU+Cbw3Xj1x1rA2e1oZ56ZDQCQtDuhluGO7WjnAuC8eK9lJG3WjjacczlgZpOAQSVm7VxJO1XJ/bGreguhFwbwHnBbB5tN1jIcImnxUQFJFxUKyEr6k6SnJU2RdE5cZFXCvoRCfFPjsv+VtGmindGSSn2IzjU8KRuPWqnW0eQfEI72rEA413B14BIqzMyUr2VY7n1XBA4E+sYjRr3jrPOAhyQ9BtwPXGlmHxHOSD8E+G3cqbqqmU2oMEbnXB2q1l6BY4FtCZfmYWYvAF9uRzvlahmW8zGhOOvlkr4OfBLf/0pCLcN/AUOA/0rqDtwEHBzXPYRw5OkLkvUM777W6zg41wiqlQwXxJs/ASCpKx28csPMxhEqV68MLGTJWHvEZRYCWxGS2j7AvYn1Z5rZFWa2f1y/n5m9AbwvaXPCfs6SlVuTh/L3/taeHdkM53Kri7LxqNn2VqmdhyX9kjDM3ZXQI7uzIw0W1TJ8BdhEUvc4FN45LtMLWN7M7iGc39g/Tt9D0lLx+VeAFYE3YtM3AifH9Yqr7jjnGlS1jiafAnyPcFrMD4F7CFUkKlWyliHhPKKbCPdjfhl4Ki6zLHCHpB5x+Z/G6bsB50sq3N/k5/EgD4Re5PmEa6mdcw6o3rXJi4BL46Mj7ZSsZRjnnUzo0RXbqsSyP+XzxFg87206oaitc/UmK5fj1UpHi7tOpYV9g+0p7uqcc2noUAkvSWvHp8fGn9fEn98iXB/dag2xHMhEGSPnqqTN/b1Nr8xGCa/pR5Uv4VVNHeoZFqrSSNrVzLZIzPqFpCdpQ0FF55zLgmrtO5Okbc1sbHyxDdU7Up2qPJZpWrhoctphVKRrl/58umhi2mFUpFuXgbn8nF151UqG3wOuiFVnRbiM7rtVats5lwK/IVQ7mNlEoH9MhpjZx9Vo1znnaqUqQ1lJy8fq1g8CD0o6t5AY27DuVyTdIOlFSRMl3RMvh8tXuWbnXK5Va7/eFcBswvW+hxCuUb6ytZXidce3EW7Wsp6ZDQROpQ33K3DOdS51ycajVqr1VuuZ2W/N7KX4OB1Ytw3rDSXcWvSSwgQzm0y493IvSTdLelbSdYWCDZIGSno49iLvS5T2Hi3pvFhg4RlJgyXdKukFSb+Pyywj6W5JkyVNk3RolbbfOZdz1TqAMk/Sdmb2KCy+QdS8NqzXj3A3q1K2ADYFZgJjgW0lPQ5cCOxvZu/GZPYHPj9Y86mZDZL0Y0KZ74HAB8CLks4jVLCZaWZ7xzjbNJR3rhE12PGTqiXDHwFXJZLLh8CwDrb5hJm9DhCvV+4DfERIoA/EjmIT8GZinZHx51RgeuFWgZJeAtaM08+VdBZwl5mNKfXGybtxrfejn/OV3ffr4KY457KuWkeTJxGOJi8XX89q46rT+by+YLEFiefNhFhFSHLl7s1cWGdR0fqLgK5m9rykLYG9gN9LetDMfldie4YDwwG2u+PRTJyF75zrXNU6mvxHSb3NbJaZzZL0pcJ+ulY8BHSPPbFCW5sD25dZ/jlgZUlbx2WXSpbxb0OcqwGfmNm1hHu0bNnWdZ1rNGmX+6912f9qHUDZM5bVB8DMPiT0vloUby96ILBLPLVmOuEmUG+VWf5TQk/yLEmTgUnANhXEuRnwRBx2/xZoS8J2zjWAau0zbJLU3cwWAEjqyec3h2qRmc2k9G38Lk0sc1zi+SRghxLtDEk8Hw2MLjUPuK8tcTnnGku1kuF1hJOtC+cWHgVcVaW2nXMp8KPJ7WBmhWHrLnHSGWbmPTDnXG50tJ6hrJUG2rJMxuU5dueKtbm/t+U/x2Tiu//kN7fPfj1DYJSkW4A7zOzVwkRJ3YDtgCOBUcCIDr5PauY3j0s7hIr0aNqanmsdnnYYFZn36vXA82mHUaENvYRXneloMtyDcPXH9ZLWIZwU3ZNwlPp+4K9m9lT51Z1zLhs6Wul6PnAxcHG8NedKhBvBf1SF2JxzKfIDKO1kZp+x5KVxzjmXG5m7ZaakZsI1xEsBC4GrgfPi7Uidc65TZC4ZEobZAwAkfRn4J7Ac4YqRxSR1NbOFtQ/PucbQaMPkTN+0yczeIVSPOU7BMEkjJT1EOMl7SLIitqSLJA2Lz/eKtRAnSrqgsJykHSVNio+nJC2bxrY557KlWoUavh6LqH4saZak2ZLaWrmmRWb2EqFU15fjpC2Bg81sxxbi6QH8g3DN9EBg5cTsk4BjY+9ze0rUXYy3HZggacLll95ejc1wLnfURZl41Eq1hsl/BvY1s2eq1F5LHjCzD1pZpi/wkpm9HF9fT6xPSCgU+xdJ1wG3FmomJiVLeM1vHpeJE0+dc52rWsPktzsrEUpal1DP8J04aW5i9kKW3IYerbVnZn8Cvk84H3KspL5VCtU5l2PV6hlOkHQjcDuJoqpmdmtHGpW0MnAJcJGZWYn7uL4CbCKpOyG57Qw8Sqh7uK6kPmY2Azg00eZ6ZjYVmCppMKEX+WxH4nSuHjXaAZRqJcPlgE+A3RLTDGhPMuwZ6w0WTq25BvhLqQXN7DVJNwHTgJeBp+L0eZL+H3CvpLnA+MRqP5E0lFD9ejrw73bE6JyrM9WqWnNUNdqJbTW1MG8ERdc5m9nJwMklFh9lZn3jXfX+BkyIyx9frVidq2eN1jOs1tHkNSTdJumd+LhF0hrVaLsDfhB7mNOB5QlHl51zrqQOlfBa3Ij0AOHk6GvipG8BR5jZrh1uPH1+NNnVkzb39756czZuhvb4wdvVpI9araPJK5vZlWa2MD5GsOS5fc65nEn7RlC1viFUtQ6gvC/pW4Tz+QAOB96vUtup+ujTfB1f6d1tT5ptWtphVKRJ/XIZs1GL02qrR2ycdgiZVq2e4XcJN3V6i1C55mDCfVCccy4XqnU0+RVgv2q05ZzLhhpeCZcJHUqGkk42sz9LupASBxrM7IR2tFko4dWVcO7gt1sqFhsLMwxK3k40Tu8D3GVm/SqNwTnXeDraMyzsNJnQ0UASkiW8rgKOBf5QxfaXIKnJzJo7q33n8srPM6yAmd0Zn35iZlclH4QrUjpqHLA6gKTRkgbF5ytJmpFYbs04/wVJybqHXSVdJ+kZSTdLWjquP0PSWZKeBL5RhTidczlXrQMop7ZxWptJaiJcazyyDYtvBRwEbA58o5A0gY2Ai81sY2AW8P8S67xvZlua2Q0didM5Vx86lAwl7Rn3F64eC6gWHiMI1xW3R+Ha5LeAVYAH2rDOA2b2vpnNI1wPvV2c/pqZjY3Pr01MB7ixXGPJeoYjLsvXqTXOVYu6ZONRKx3dZziTsL9wP2BiYvps4MR2tjnPzAbEIe19hH2GF7Bkua7iUl3FB2+slemwZCmwJRdK1DP86NN/Z+IsfOdc5+rorUInA5Ml/TPeHa9qzOwTSScAt0u6GJgBDASeIJzHmLSrpBUIVasPIJz3CLCWpK3NbBzwTUJ5L+ec+4JqdUL7xAMUT0t6qfDoaKPxBvRTCFe0nAP8SNJThPszJz0B3BKXvcXMCke3nwOOlfQM8CXg7x2NyblGkfZleHm9HO9Kwt3rzgOGEq4+aVeiNbNeRa/3TbzcPPH813H+CIrKesXpMwiFW0u9R5/2xOacq1/V6hn2NLMHCVVwXjGz04C9q9S2cy4FkjLxqJVq9QwXSOoCvCDpOOANoFcr6zjnXGZUKxn+GFgaOAE4gzBU/k6V2k5V7257ph1CxZqUvysQ8xizV4GpL9VKhn3MbDwwh1itRtI3gMer1H5qJn9wV+sLZUj/FfYBnk87jAptyMJFk9MOoiJdu/Qnj59zJfxyvPap+hUozjlXSx2tWrMnsBfxCpTErOVo/xUozjlXc1m8AsU5lwGNNkzO7BUoSZJ+RbiCpJlwv+MfAlsDw82sXdVx4vXTd5nZzdWK0zmXX9U6gLKVpNOAtWObAszM1u1ow5K2BvYBtjSzBZJWAroRCi1cS3VKhTnnijRaz7BaB1AuB/5CqAozGBgUf1bDqsB7ZrYAwMzeI1ybvBowStIoAEm7SRon6UlJ/5LUK04fKOlhSRMl3Sdp1SrF5ZyrI9VKhh+b2b/N7J1YSut9M6vW3fHuJxRvfV7SxZJ2NLMLCPsrh5rZ0Nhb/DWwi5ltSdiP+VNJSwEXAgeb2UDgCtpQNTtZwuvmq+6t0mY457KsWsPkUZLOJtQSXFCYaGZPdrRhM5sjaSCwPeFk7hslnVK02NeATYCx8fKdboQq2RsB/YAH4vQmwt37WnvPxSW8Jn9wl5fwcg3JbwjVPl+NPwclphmwUzUaj/coGQ2MljQVOLJoEREKvB6+xERpM2C6mW1djTicc/WrWrcKHVqNdkqRtBGwyMxeiJMGAK8AfYBlgfeA/wJ/k7S+mf1P0jKEe6c8B6xcqGkYh80bmtn0zorXuXrRaD3DquwzlLSKpMsl/Tu+3kTS96rRNqHgw1WxVuIUwnD4NMIw9l5Jo8zsXWAYcH1cZhzQ18w+JRxsOUvSZGASsE2V4nLO1ZFqDZNHEGoa/iq+fp5w6svlHW3YzCZSOoFdGB+F5R6ixBFsM5sE7FBi+rCOxuacqx/VSoYrmdlNkk4FMLOFCjeDd87lVBc11rHDaiXDuZJWJN5wSdLXgI+r1HaqQhWYvKmsOkkWhCoweZO/z9mVV61k+FPC/Y3XkzQWWJkv3rTJOecyq1pHk5+UtCPhvD4Bz3Xmtcq1tKB5fNohVKR702DyWWfPY+58lfVk/WhyO8RCrj3jKSsHEE6M3rIabTvnXC1U63K8/zOz2ZK2A3YmHEX223I6l2NdMvKolWq9V+HI8d7ApWZ2N+GSuHaT1CxpUuLRp8xyfSRNKzNvtKTnJE2WNDaewO2cc19QrQMob0j6B7Ar4QTn7nQ80c4zswEdjgyOMLMJko4GziYUol1MUlO83M8518Cq1TM8BLgP2N3MPgJWAH5epbYBkNRL0oOxRNdUSfsnZneVdJ2kZyTdLGnpEk08Aqwf25oj6dx4VYpft+xcCV1kmXjUbHur0UisNv0OoZ4hhPufvFB+jTbpmRgi3wbMBw6MJbqGAufq8ztMbwRcbGYbA7OA/1eivX2BqfH5MsDjZtbfzB7tYJzOuTpQraPJvwV+wed3xFuKUIW6I+aZ2YD4OJBwys4f47XH/yEUYlglLvuamY2Nz6/l86QMcJ2kScC2wElxWjNwSwvbs7ie4WWX3tbBzXDO5UG19hkeCGwBPAlgZjMlLVultguOIJzMPdDMPpM0A+gR5xX3pZOvjzCzCUXz57e0nzBZz3BB8/jGuibJucjPM2yfT83M+PxyvGWq1G7S8sA7MREOJdxvpWCteK8UCDeO8qGvc64i1UqGN8Wjyb0l/YAwjL20Sm0XXAcMisVdvwM8m5j3HHCspGeAL+HnODrXYWmfX1jr8ww7PEyOBzFuBPoSDl5sBPzGzB7oSLtm1qvo9XuUP/Lbt0wbQ9rStnPOdTgZmplJusfMNgM6lACdcy4t1TqA8qSkwWaWr6oGzrmyGu0ASjVvCPWteIR3Lp/fRH7zKrWfmlAFJm/yWGfPY3bpqlYy3L1K7WTOwkWT0w6hIqFIav5KSxnPpB1ERcTGOf1uuHKqVc/wlViyazvC6TVjq3HPZOdcetRgZf+rdQXKb4CrgBWBlYArJf26Gm0751wtVGuYfATQ38zmA0j6E+G2nL+vUvvOuRprtAMo1TqncSafXxoH0B14oxoNx3sy/1PSS5ImShon6cBqtO2ccwXV6hl+DEyX9ABhn+GuwBOSLgAwsxPa02g8oft24Coz+2actjZFNQmdc66jqpUMb4uPgtFVancnwnXPlxQmmNkrwIWShgGDzOw4AEl3AeeY2WhJc4DzgX2AecD+ZvZ2vFfLbwlVaz42sy/cXN45F9TyUrgsqNbR5Ksk9QTWMrPnqtFmtCmxEk6FlgH+a2a/kvRn4AeE/Ze/IRSgfUNS73Irx6rYRwNc/Pdf84Oj/a6nztW7qiRDSfsC5xDue7KOpAHA78ysqsNZSX8jnL7zKfC3Fhb9FLgrPp9IGLYDjAVGSLoJuLXcyskSXgsXTW6s8wuci2pZZToLqtUTPg3YCvgIwMwmAetWod3pwOJbjprZsYS7761MqKadjD95AOezWFIMwpC4a1z/GODXwJrAREkrViFG51wdqFYy/MzMPi6atqgK7T4E9JD0o8S0wv1NZgADJHWRtCYhGbdI0npm9riZ/QZ4l5AUnXOuagdQpkv6JtAkaQPgBOCxjjYaK+IcAJwn6WRCAptLuMXAWOBl4GngGdq2b/HsGJ+AB4F8XU/lXA012nmG1UqGxwO/AhYA1wP3AmdUo2EzexM4rMzsI8qs0yvx/Gbg5vj869WIyTlXf6p2dzwz+5WZDTazQcA1wEXVaNs552qhQz1DSZsTjiKvRjg5+m+EJPhV4NyOBpcF+az0kb/SUmLjtEOoWD6/G23XaOcZdnR7LwX+CRwEvEe4HvlFYH0zO6+DbTvnXM10dJ9hdzMbEZ8/J+kEMzu5g21myvoHdfT2z7X1v1u+lcvagAua81UkvXvT4LqvZ+gHUCrTQ9IWhKOzAAuSr72moXMuLzqaDN8E/pJ4/VbitRGuLXbOuczrUDI0s6HVCqQUhVK715nZt+LrroQE/LiZ7dOO9mYQiju8V9VAnatDfjletswF+sUiEBCuMa5KnUTnnEvKejIEuAfYOz4/nHBSNwCStorFXp+S9JikjeL0JknnSJomaYqk4xPtHS/pSUlTJZW8+bxzrvHkIRneABwmqQewOfB4Yt6zwPZmtgWhPNcf4/SjgT7AgHi70usS67xnZlsCfwdO6uTYncutLsrGo2bbW41GJN0qaW9JVU+uZjaFkNgOJ/QSk5YH/iVpGnAeof4hwC7AP8xsYWzjg8Q6hdJdE2O7XyDpaEkTJE2Y9fJD1dgM51zGVSt5XQx8E3hB0p8Kw9UqGkm40uX6oulnAKPMrB+wL0uW8SpnQfy5uLRXMTMbbmaDzGzQcuv4AXHXmLpk5FEr1bo2+T9mdgSh9uAM4D9xH95RkpaqwltcAZxuZlOLpi/P5wdUhiWmPwD8MB59RtIKVYjBOVfHqpZ4Y6HUYcD3gacI9yDZkpCYOsTMXjezC0rM+jNwpqSnWLKXdxnwKjBF0mRCr9U558qqVtn/24CNCNVq9o1ltwBulDShve0mS3Elpo0m3nDKzMaxZFWCX8fpC4Gfxkdy3T6J5xOAIe2Nzbl612jnGXY4GcaDJhPNrOS9jGNJL+ecy7QOD5PNbBGhao1zzuVWtSpdPyjpIODWxI2Y6sL/bvlW2iFULI+1Abs3DU47hIrVfT1Dr1rTLj8k7J9bKGk+oWqNmdlyVWo/NbM/ezDtECqy7FI757IcFjyfdhgV2pDJH9zV+mIZ0n+Fii/nbyjVuon8stVoxzmXHY3WM6zWFShf6D6Vmuacc1nVoWQoqUc8oXklSV+StEJ89AFWr6CdOUWvh0nq0A2lJM2QtFJH2nDONY6ODpN/CPyEcEOoiXxe8XoWNbw7nqSuheuQnXPVkYcqLtXUoe01s/PNbB3gJDNb18zWiY/+ZlaVZChpX0mPxzJd/5G0Spx+mqRrJI0FrpG0oqT7JU2XdBkxMUv6uaQT4vPzJD0Un+8k6bpy7+ucayzVSv5vSVoWQNKvYxWbLStYv6ekSYUH8LvEvEeBr8UyXTcAyRtObQLsYmaHA78FHjWzTYHbgLXiMmOA7ePzQUCveL309sAjFW2lcw2kiywTj5ptb5Xa+T8zmy1pO0L5rMsJ9QLbap6ZDSg8CLUJC9YA7pM0Ffg5n5fpAhhpZvPi8x2AawHM7G7gwzh9IjBQ0nKEijXjCElxe0Ki/IJkCa8rL8vX6RPOufapVjJsjj/3BobHZNStSm1fCFxkZpsR9lEmy3TNbW1lM/sMeJlQROIxQgIcCqwPpe+pmSzhddT3/dws57IuVrd/StJd8fU6cffa/yTdKKnVfFStZPiGpH8AhwL3SOpexbaTZbqObGG5R4jVaSTtCXwpMW8Moar1I/H5McBT9Xa1jHPVlHaF6worXf+YJTs3ZwHnmdn6hFHi91rd3ko/oDIOAe4Ddjezj4AVCEPaajiNUM16ItDSXe1OB3aQNB34OqGEV8EYYFVgnJm9DcynzBDZOZcvktYgjEovi69FuE3xzXGRq4ADWmunWpfjrQRMiIEUDlw829aVi0t1mdkIYER8fgdwR4l1Tit6/T6wW5n2HwSWSrzesNRyzrlc+ivhwGrhSrgVgY8Sp9u9ThvOe65WMrybcNN4EfbprQM8x5IHO5xzOZKV8wwlHU24yVvBcDMbHuftA7xjZhMlDenI+1Tr2uTNkq/jaTX/rxptO+caW0x8w8vM3hbYT9JehI7YcoQq+70TF2OsQRvut67OOoYgaWpxkswpP8ji6kmbD0mc/MRDmfju/3mrndoUc+wZnmRm+0j6F3CLmd0g6RJgipld3NL61Sr7nyyv34Vw75OZ1WjbOefa4RfADZJ+T7gn0+WtrVCtfYbJEl4LCfsQb6lS26ka89bdaYdQke2/sjfzm8elHUZFejRtzaeLJqYdRkW6dRlIs01LO4yKNKlf2iF0qqL7I70EbFXJ+tXaZ3h6NdpxzmWH/IZQbSfpTlrYp2Zm+3Wkfeecq5WOHj0/BziXcLnbPODS+JgDvNiRhiU1J4s3SDolTh8tqewd92ItxHeL1t2kI7E45+pfh3qGZvYwgKRzi24JemdH7pcczYtFG9rjRjM7roPv71xD87L/7bOMpHULLyStAyxTpbbLkrSHpCclTW7tNgMKLpL0XKyLeI+kgzs7RudcPlTraPKJwGhJLxHOY1qbUGGmI3rG2oYFZ5rZjYUXklYmDMl3MLOX4+0HCg6N5cQKtgb2BDYi1EBcBXgauKKDMTpXt7JyBUqtVOto8r2SNgD6xknPmtmCDjbb2jD5a8AjZvZyjOGDxLwvDJMl7QBcb2bNwMxCxetSkpf/nPTn49jv23u0cxOcc3lRrZ4hwECgT2yzvyTM7Ooqtl8zyct/xrx1d2OdX+Bcg6rWrUKvIRxZ3g4YHB9lj/hWyX8JJbvWiTGs0MryjxCGz02SViUUeHXOlZF2uf9al/2vVs9wELBJlYulFu8zvNfMTim8MLN343D2VkldgHeAXePs4n2G/49wX5SdCPsKXyWU/3fOOaB6yXAa8BXgzSq1h5k1lZk+JPH838C/i+aPINZCLGHxfkRJ5ZZxzjWgahZ3fVrSE4SbLgF+BYpzedZo5xlWKxmeVqV2asbMhqUdg3MuO6p1as3D1Wgni7b/yt5ph1CxHk1bpx1Cxbp1GZh2CBWr9yow3jOsgKTZlC7UIMDMbLmOtJ8Fu9/3aNohVOS+3bfjvGkPpB1GRU7styuvzb0z7TAqsuYy+3LS42VPVc2kc766U9ohZFpHr01etvWlnHMu+6p50rVzro6UPJ2jjmX28kNJX5F0g6QXJU2MhRWOlnRXmeUv81Jdzrn2ymTPMN4E+jbgKjM7LE7rD5Q9VcfMvl+j8JxrCLW8+iMLstozHAp8ZmaXFCaY2WRgDNBL0s2SnpV0XUycSxR9lTRH0nmSpkt6MFa4QdIJkp6WNEXSDSlsl3Muo7KaDPsB5e4QtAXwE0IprnUJ900ttgwwwcw2BR4GfhunnwJsYWabA8dUM2DnXL5lNRm25Akze93MFgGTCJVyii0CCrUPryUUkACYAlwn6VuEu/iVFPdNTpA04fV7RlYtcOfypIuy8ajZ9tburSoynVASrJRkncRm2rbfs7DzY2/gb4T7Oo+XVHJdMxtuZoPMbNAae/kVhc41gqwmw4eA7rEqDQCSNge2b+P6XYBCSf9vAo/GyjZrmtkowg2mlwd6VS9k51yeZfJospmZpAOBv0r6BTAfmAHc3sYm5gJbSfo1obTXoYTTpq6VtDzhCpkLzOyjKofuXN3wy/EywsxmAoeUmHVpYpnjEs+HFK3/0xLrbldimnPOZTcZOufS1dRgPcOs7jPsEDPzfYHOuYqoupX665J/QK6etLm/d+7UBzLx3f/ZZrvWpI/qw+RWfLJwbNohVGTprtvSc63D0w6jIvNevR54Pu0wKrQhzTYt7SAqUmn9xUY7gFKXw2TnnKuUJ0PnnMOHyc65MrxqTY1JMknXJl53lfRuubqFLbSTrFozQ9JUSZPi44Jqx+2cqy9Z6BnOBfpJ6mlm8wg3gn+jCu0ONbP3qtCOcw3JD6Ck4x5CEQWAw4HrCzMkLSPpCklPSHpK0v5xes9YCfsZSbcBPVt7E0kDJU2Oj7Ml5etwoHOu02QlGd4AHCapB7A58Hhi3q+Ah8xsK0LR17MlLQP8CPjEzDYm1CssrnIzKjFMPjFOuxI43sz6txRMsoTXFZfe0fGtc85lXhaGyZjZFEl9CL3Ce4pm7wbsJ+mk+LoHsBawA3BBYv0pRestMUyW1BvobWaPxEnXAHuWiWc4MBzgk4VjG2svsnNRo90QKhPJMBoJnAMMAVZMTBdwkJk9l1w4Vvt3zrmqyMowGeAK4HQzm1o0/T7g+MS9TraI0x8h1CpEUj/C8LqsWK7rI0mFyjVHVClu51wdyEzP0MxeJw57i5wB/BWYEgu0vgzsA/wduFLSM8AzfPGeKaMkNcfnU8zsO8BRwBWSDLi/+lvhXP1otKPJqSfDUhVmzGw0MDo+nwf8sMQy84DDyrTZp8z0iUB/gLiPcq92Be2cqzupJ0PnXDY12hUoDZsMzWwG4ZakLVq6a6k7kWZbqAKTNxumHUDFKq0C47ItSwdQnHMuNQ3bM2yrd+bn677JX+6xH8YzaYdREbFxLmsD5vFzroSX/XfOuQbkydA558hhMpR0QCz71TftWJyrZ12UjUfNtrd2b1U1hwOPxp9tIsn3jTrnWpSrZCipF+FG8N8jnnAtqSmW4xovaYqkH8bpQySNkTQSeFpSD0lXxqKvT0kamt6WOJd9afcIa90zzFuPaX/gXjN7XtL7kgYSSnd9bGaDJXUHxkoqXGq3JdDPzF6W9DPAzGyzOMS+X9KGZjY/nU1xzmVJrnqGhKHxDfH5DfH1bsB3JE0i1EFcEdggLvOEmb0cn28HXAtgZs8Cr1DmTN9kPcOrL7+vM7bDOZcxuekZSloB2AnYLBZaaCLc4H08oWDrfUXLDyHcUqBiyXqG78wf2VjXJDkXNVqhhjz1DA8GrjGztc2sj5mtSahgMxn4kaSlACRtGCthFxtDLNslaUNCgdjnSiznnGtAuekZEobEZxVNuwXYGHgaeDLWPHwXOKDE+hcDf5c0FVgIDDOzBZ0XrnP51uSFGrLJzL5w9NfMkvUPf1k0e3R8FJadT6hn6JxzX5CnYbJzznWa3PQMnXO11Wg9JU+Grfhyj/3SDqFilVYnyYI81gbM4+fsyvNk2Ir5zePSDqEiPZq2Bp5PO4wKbZjLclh5LDvmyvNk6Jwryc8zdM65BuQ9Q+dcSd4zzBBJv5I0PVajmSTpq5JmSFqpxLL7SToljTidc/mX2Z6hpK0JN4vf0swWxATYrdzyZjYSyNcNS5xzmZHZZAisCrxXuGTOzN4DCFfccbykfYGlgG+Y2bOShgGDzOw4SSOA+cAgYDngp2Z2l6RNgSsJSbULcJCZvVDbzXIuHxrtcrwsD5PvB9aU9LykiyXtmJj3npltCfwdOKnM+n2ArYC9gUsk9QCOAc43swGERPl6qRWTJbwuv/T2qmyMcy7bMtszNLM5sXjr9sBQ4MbEPsFb48+JwNfLNHGTmS0CXpD0EtAXGAf8StIawK3leoXJEl7zm8c11p9H5xpUZpMhgJk1EwsuxGozR8ZZhWozzZTfhuIkZmb2T0mPE3qL90j6oZk9VOWwnasLfjQ5IyRtJGmDxKQBhOrUbfUNSV0krQesCzwnaV3gpVjt5g5g86oF7JzLtSz3DHsBF0rqTag/+D/gaMIR5rZ4FXiCcADlGDObL+kQ4NuSPgPeAv5Y9aidqxON1jPMbDI0s4nANiVm9UksMwEYEp+PAEYklvuPmR1T1OafgD9VN1LnXD3I7DDZOedqKbM9w44ws2HVaitUgcmbkjf9y7Q8lsOq9yowjTZM9p6hc85Rpz3DarrjlX+nHUJF9l97Tz76NF8x9+62JwsXTU47jIp07dKfuQsfTjuMiizTdcfWF2pgngydcyU1+TDZOecaT6Z6hpLmmFmvNi57GjDHzM4pmt4HeIYlbxD/FzO7ulpxOtcIujRYoYZMJcMqejEWY3DOuTbJ/DBZ0r6SHpf0lKT/SFolMbu/pHGSXpD0gza0dVSsgvOEpEslXdSJoTvnciQPPcNHga+ZmUn6PnAy8LM4b3Pga8AywFOS7o7T15M0KdHG8YTL+U4HBgIfA6OApzo/fOfyKfM9pSrLw/auAdwXq9b8HNg0Me8OM5sXC7+OItQvhDhMTjzGAF8FRpvZu2b2KXBjuTdM1jO875/5Ok3FOdc+eegZXkg4ADJS0hDgtMS8L5TpqsYbJusZ3vHKvxtrL7JzkV+Bkj3LA2/E50cWzdtfUg9JKxIKNoxvoZ3HgR0lrShpKeAbVY/UOZdbWesZLi0pWYr/L4Se4L8kfQg8BKyTmD+FMDxeCTjDzGbGU2uK9xleYWYXxNNxxgEfAcn5zrkGl6lkaGbleqp3lFj2tDJtzAB6lpl3JeGGUBRuINWOMJ1rCH4FinPONaBM9QxrqUQxWOdcA5OZHyxthX9Arp60efA75q27M/Hd3/4re9dkwN6wPcO22vv+R9MOoSJ377YdzTYt7TAq0qR+uYx5QXNLJy9kT/emwWmHkGmeDJ1zJfl5hs4514A8GTrnHBkeJserSh6ML78CNAPvxtdbxeuLnXOdpNGGyZlNhmb2PjAAShdyldTVzBamE51zrt5kNhmWImkEMB/YAhgr6QbgfKAHMA84ysyei1eX7AcsDawH3GZmJ0tqAi4nXHlihMv0zqv5hjjnMidXyTBaA9jGzJolLQdsb2YLJe0C/BE4KC43gJA0FwDPSboQ+DKwupn1A5DUu9QbSDoaOBqg349/zlp77deJm+NcNjXaAYU8JsN/mVlzfL48cJWkDQg9vaUSyz1oZh8DSHoaWBuYDqwbE+PdwP2l3iBZwmvv+x/NxImnzrnOlcfkPzfx/AxgVOzp7UsYLhcsSDxvBrqa2YdAf2A0cAxwWeeG6lx+Sdl41Eoee4ZJyVqHw1pbWNJKwKdmdouk54BrOzE251yO5LFnmPRn4ExJT9G2xL46MDrWOrwWOLUTY3PO5UgueoYt1C4cB2yYmPTrOH0EiYo0ZrZPYpktqx6gc3WowU4zzH3P0DnnqsJLeLXOPyBXT9rc4Rv/bjZKeA1e2Ut4OedSVMsjuVngybAV85vHpR1CRXo0bc3CRZPTDqMiXbv059NFE9MOoyLdugzkF+MfbH3BDDlr8M5ph5BpngydcyU12gGFRtte55wrKXM9w0pKd8XCDXeZ2c01DdI5V3cylwxbK93lnKsNKRMHk2smc8mwFEkDgb8AvYD3gGFm9mbRMoMJ5byWIVyXvDOhgs0BcdoGwDlAN+DbcZm9zOyD2myFcy7L8rDPUMCFwMFmNhC4AvjDEgtI3YAbgR+bWX9gF0J9Q4B+wNeBwXG9T8xsC2Ac8J2abIFzOaSMPGolD8mwOyGhPRCvKf41oaZh0kbAm2Y2HsDMZiWqYI8ys9lm9i7wMXBnnD4V6FPqDSUdLWmCpAmXX3p7NbfFOZdReRgmC5huZlu3c/1kKa9FideLKLP9yXqG85vHNdaOE+caVB56hguAlSVtDSBpKUmbFi3zHLBq3G+IpGUl5SHRO5dZadcx9HqGX7QIOBi4QNLyhJj/SqhaDYCZfSrpUOBCST0J+wt3SSFW51xOZToZFpXu2qHE/GGJ5+OBrxUtMoIlS3n1STxfYp5zrrFlOhk659LTYHUacrHP0DnnOp3XM2ydf0CunrS5wzftw7sy8d3v96V9vJ5hFqx31E1ph1CRF688BHg+7TAqtCHNNi3tICrSpH7k8XN25fkw2Tnn8J6hc64MP4DinHMNKPfJUFIfSdOKpp0m6SRJwyStlph+maRN4vMZ8abyzjmX/2TYimHA4mRoZt83s6fTC8e5/Ej7Mry2XI4naU1JoyQ9LWm6pB/H6StIekDSC/Hnl1rb3npPhoOA6yRNktRT0mhJg9IOyjlXNQuBn5nZJoQr0I6No79TgAfNbANC5fxTWmuo3pPhBOAIMxtgZvNaXTpKlvCa9dx/OjE857Ir7TqGbalnaGZvmtmT8fls4BlgdWB/4Kq42FWEIs8tqodkWO7E0HafMGpmw81skJkNWm4jr/fgXB5I6gNsATwOrJKohv8WsEpr69dDMnwfKN4fsALh9gDOuZxLjtTi4+gSy/QCbgF+YmazkvMsXGbXauco98nQzOYAb0raCcKOU2AP4FFgNrBsiuE5l1tpD48Lj+RILT6GLxGntBQhEV5nZrfGyW9LWjXOXxV4p7XtzX0yjL4D/F+8LcBDwOlm9iKhRNclhQMoKcbnnOsEkgRcDjxjZn9JzBoJHBmfHwnc0VpbdXEFSjxdZmiJ6bcQ/mIUDEnM69PpgTnnOtu2hLtdTo2dIYBfAn8CbpL0PeAV4JDWGqqLZOicq74uObgez8wepfxB550ractLeLXOPyBXT9qc4p7/OBslvDZc3kt4OedSlIOOYVV5MmzF6U/l66Tr326xCwuax6cdRkW6Nw3mo0//nXYYFendbU/ufT1fMe+xxp5ph5Bp9XI02TnnOsR7hs65kqRM7DKsmcz2DCWdJ+knidf3Sbos8fpcST+VdFeZ9VssyiBphKSDqxq0cy63MpsMgbHANgCSugArAZsm5m8DdEshLucaQtpXnrSlUEM1ZTkZPgZsHZ9vCkwDZkv6kqTuwMbAk0AvSTdLelbSdfGM9MUkNcVe4DRJUyWdWNOtcM7lQmb3GZrZTEkLJa1F6AWOI5Tm2Rr4GJgKfEqoUrEpMJPQm9yWcF1ywQBgdTPrByCpd402wTmXI1nuGULoHW7D58lwXOL12LjME2b2upktAiYBfYraeAlYV9KFkvYAZtGKZJWMCbfcXZUNcS5v0q5w3ZZK19WU9WRY2G+4GWGY/F9Cz3AbQqIEWJBYvpmi3q6ZfQj0B0YDxwCX0YpklYxBB+3dwU1wzuVB1pPhY8A+wAdm1mxmHwC9CQnxsZZWLIg3feoSizb8Gtiyk2J1zuVYZvcZRlMJR5H/WTStl5m9p7b1oVcHroxHpAFOrW6IztWnrPeUqi3TydDMmoHliqYNSzwfTRj+Fl4fl3g+JLHaF3qDyXaccy7TydA5l55aHrzIgkbrCTvnXElez7B1/gG5etLm/t4rc+7MxHd/7V77ej3DLJj12QNph1CR5ZbalYWLJqcdRkW6dunPO/NHph1GRb7cYz++tP7/SzuMinz4v4srWr7BRsk+THbOOfBk6JxzQM6SoaTmeNvPaZLuLFxnLKmPpG+2Yf3VJN0cnw8pV/7LOZf+ZXh+OV7L5pnZgFh04QPg2Di9D9BqMjSzmWbmNQydc1+Qt2SYVKhiA+EeqdvHXuOJsac4RtKT8VGoi9hH0rTUInYuR9KuY1jreoa5PJosqYlwT9TL46RTgJPMbJ84f2lgVzObL2kD4HqgbNVr55zLW8+wp6RJwFvAKkC5816WAi6VNBX4F7BJJW+SLOF15WVewsu5RpC3nuE8MxsQe373EfYZXlBiuROBtwmlu7oA8yt5EzMbDgwHmPXZA5k48dS5WuvSYCca5q1nCICZfQKcAPxMUldgNrBsYpHlgTdjwddvA021j9I5lye5TIYAZvYUMAU4PP5sljQ53uPkYuBISZOBvsDc9CJ1zuVBrobJZtar6PW+iZc7FS2+eeL5L+LyM4B+8floEuW/nHNLarBRcn57hs45V0256hk652pHaqxjh17Cq3X+Abl60ubR71vzRmbiu/+VnvvVZMTuw2TnnMOHya3KY21A45m0w6iI2JjZnz2YdhgVWXapnTlvWr5qXZ7Yb9eKlvcDKM4514A8GTrnHBlNhpJM0rWJ110lvdve+oNerca5yqVdx9DrGQZzgX6SesbXuwJvpBiPc67OZTUZAtwD7B2fH04owwWApGUkXSHpCUlPSdo/Ti9ZxzBJ0qZxvUmSpsQSX865ImnXMax1PcMsJ8MbgMMk9SBcWvd4Yt6vgIfMbCtgKHC2pGWAdwh1DLcEDqV0RZtjgPPNbAChxuHrxQskS3hdOvzmam6Tcy6jMntqjZlNkdSH0Cu8p2j2bsB+kk6Kr3sAawEzgYskDQCagQ1LND0O+JWkNYBbzeyFEu+9uITXwkWTM3HiqXOuc2U2GUYjgXOAIcCKiekCDjKz55ILSzqNVuoYmtk/JT1OGILfI+mHZvZQp0TvXI5ledjYGbK+vVcAp5vZ1KLp9wHHS+FYk6Qt4vRW6xhKWhd4ycwuAO5gyeo2zrkGlelkaGavx6RV7AxCaf8pkqbH19C2OoaHANPi7QP6AVdXPXDn6kDap9TU+tSaTA6Ti+sWxmmjifUHzWwe8MMSy7xA63UM/0S4m55zzi2W6Z6hc87Vipfwap1/QK6etHng+cGCOzPx3V+h+75ewss552olk/sMs+X5tAOo0IbkMeaeax2edhAVmffq9SxoHp92GBXp3jQ47RAyzZOhc64kNVhFQx8mO+ccGesZSmoGphJ28jYDx5nZY+1sazRwkplNqF6EzjUOqbH6SplKhsC8WEABSbsDZwI7phqRc64hZDn1Lwd8CCCpl6QHY1muqUUlu56RdKmk6ZLuT9RAJC7TRdIISb+X1BSfT4vtnJjCdjnnMihrPcOe8TK5HsCqwE5x+nzgQDObJWkl4L+SRsZ5GwCHm9kPJN0EHAQUqmR3Ba4DppnZHyQNBFY3s34AknrXYqOcyyc/gJKmeWY2wMz6AnsAV8diDAL+KGkK8B9gdWCVuM7LZjYpPp8I9Em09w9iIoyvXwLWlXShpD2AWaWCSNYzHD78xipunnMuq7LWM1zMzMbFXuDKwF7x50Az+0zSDELvEWBBYrVmIDlMfgwYKulcM5tvZh9K6g/sTijyegjw3RLvvbieITyfibPwnXOdK7PJUFJfQgmu9wmlud6JiXAosHYbm7kc2AG4SdLXgd7Ap2Z2i6Tn+Hw47Zwr0mjnGWYtGRb2GUIYGh9pZs2SrgPulDQVmAA829YGzewvkpYHriFUq7lSn58zcGr1QnfO5VmmkqGZfaEYa5z+HrB1mdX6JZY7J/F8SOL5bxPLb9mxKJ1rFI3VM8zaARTnnEuFJ0PnnMPrGbaFf0CunrR57Dvrswcy8d1fbqldazJez9Q+wyxauGhy2iFUpGuX/rw/f2TrC2bIij32Y6PLHkk7jIo89/0deOHju9IOoyIbLL9P2iFkmg+TnXMO7xk658ryo8nOOddw6qpnmKiHWHAA8E8z2yadiJzLL78CJd8W10NM8ETonGtV3Q+TJc2JP4dIGi3pZknPSrouVsRxzrm6S4Y9JU2Kj9tKzN8C+AmwCbAusG2pRpIlvC4dfnPnRetchikj/2qlEYbJSU+Y2esAsSBEH+DR4oWSJbwWLpqciRNPnXOdq96SYWuKax822vY7V4F6Gzi2rLG21jnnyvBk6Jxz1Nkw0cx6lZtmZqOB0Ynpx9UsMOdyqNFOtvCeoXPO4SW82sI/IFdP2tzdm7vw4Ux895fpuqOX8HLOpamxhsmeDFuxoHl82iFUpHvTYJptWtphVKRJ/dhgt8vTDqMiL9z/vVzWunTleTJ0zpXUaIUa/ACKc86Rk2RYKLbgnHOdpeGHyZK6mtnCtONwLnty0VeqmlxtbUtluCT9SdLTkqZIOidOGyHp4MT6yXJeYySNBJ5OZWOcc5mSx57hFsCmwExgLLCtpGeAA4G+ZmaSerehnS2Bfmb2cqdF6pzLjVz1DKMnzOx1M1sETCKU4foYmA9cLunrwCdtbKdkIkzWM7zs0lJlEZ2rf2nXMfR6hq37QhkuM1soaStgZ+Bg4DhgJ2AhMeFL6gJ0S6w7t9wbJOsZLmgen4mz8J1znSuPyfALJPUCljazeySNBV6Ks2YAA4GbgP2ApdKJ0Ln8abRCDXWRDIFlgTsk9SBcQ/TTOP3SOH0ycC8t9Aadc40tF8mwjWW4tiqx3tvA1xKTflGqHeecy0UydM6lobGGyXk8muycc1Xn9Qxb5x+Qqydt7u7Nb/5vJr77PZq+5vUMs8B4Ju0QKiI2zmVpqSffuzvtMCqy5Up7A8+nHUaFNqxoaTXYwLGxttY558rwnqFzrgw/gOKccw0n88lQUrOkSZKmSbqzUIRBUh9J0+LzIZI+jssVHru00OZPJC1do01wzuVA5pMhMM/MBphZP+AD4Ngyy42JyxUe/2mhzZ8Angyda4GkTDxqJW/7DMcBm7d1YUnLEK5LXgNoAs4AVgFWA0ZJes/MhnZGoM65fMlDzxAASU2EqjQjyyyyfdEweT1gD2CmmfWPPct7zewCQi3EoeUSYbKE1/DhN3XG5jiXA8rIozby0DPsKWkSsDrwDPBAmeXGmNk+yQkxgZ4r6SzgLjMb05Y3TJbwMp7JxImnzrnOlYee4TwzGwCsTfgzUW6f4ReY2fOEitZTgd9L+k2nROicy7089AwBMLNPJJ0A3C7p4rasI2k14AMzu1bSR8D346zZhLJf73VKsM7VgUa7AiU3yRDAzJ6SNAU4HCge8m4fh9MFvyckvbMlLQI+A34U5w0H7pU00w+gOOcgB8mwUMsw8XrfxMt+cdpoYPkyTdxXos0LgQurFKJzrg5kPhk659LSWJfjeQmv1vkH5OpJmzPcZ4smZeK7v1SXAV7CyzmXnlrepjMLPBm2YkHz+LRDqEj3psF8umhi2mFUpFuXgXyycGzaYVRk6a7b8uYnd6YdRkVWXXrf1hdqYI117Nw558rwnqFzrqRGu29yZnuGRaW7/lVJyS1JXSRdENedKmm8pHU6M17nXL5lNhmyZOmuT4Fj2rKSpK7AoYTKNJub2WbAgcBHnRWocy7/spwMk8YA60taRtIVkp6Q9JSk/QEkDZM0UtJDwIPAqsCbZrYIwMxeN7MPJR0j6exCo3G9i9LYIOeyr0tGHrWR+WQYe3p7Eoot/Ap4yMy2AoYSLrVbJi66JXCwme1IqGG4bxxmnytpi7jMLYReYsGhwA212A7nXLZlORkWSndNAF4FLgd2A06J00cDPYC14vIPmNkHEHqCwEbAqcAi4EFJO5vZu8BLkr4maUWgL/CFczqS9Qwvu/S2TtxE57JLGflXK1k+mlwo3bWYwuGtg8zsuaLpXwXmJqeZ2QLg38C/Jb0NHEAYQt8AHAI8C9xmJS7BSdYzXNA8PhNn4TvnOleWe4al3AccH5MiieHvEiRtGct3IakL4VYBr8TZtwH7Eyrf+BDZOQfkLxmeASwFTJE0Pb4u5cvAnfHueVOAhcBFAGb2IaFi9tpm9kTnh+xcXqVd7t/L/gNfLN0Vp80Dflhi+ghgROL1vcC9LbS9T7l5zrnGlLeeoXPOdYrM9gydc+lqtMvxvJ5h6/wDcvWkzRkuK3eGFBt7PcMsmP3Zg2mHUJFll9qZ/5v4n7TDqMgZA3fhxVn5Koe13nL70nOtw9MOoyLzXr2+wjUaay9aY22tc67uSNpD0nOS/ifplPa248nQOZdbkpqAvxEu2d0EOFzSJu1py4fJzrmSclL2fyvgf2b2EoCkGwgXVTxdaUOZ7RlK+pWk6ZKmxIILX21h2e3jspMkbS1pr1rG6pxLzerAa4nXr8dpFctkz1DS1sA+wJZmtkDSSkC3FlY5AjjTzK6VNAwYBNzT+ZE6V882zETXUNLRwNGJScNj/YCqymrPcFXgvVhsATN7z8xmSto51jGcGusadpf0fULhhTMkXQ/8Djg09hIPjcv2VvC+pO8ASLpa0q6pbaFzrk3MbLiZDUo8konwDWDNxOs14rSKZTUZ3g+sKel5SRdL2lFSD8Ild4fG6tVdgR+Z2WXASODnZnY48Bvgxlgl+0ZCia5tgU2Bl4Dt43tsDTxW6s2TJbyuvOyuTtxM51wHjQc2kLSOpG7AYYR8ULFMDpPNbI6kgYTENRS4ETgTeNnMno+LXQUcC/y1lebGADsQqtb8HTha0urAh2Y2t9QKyRJesz97MBMnnjrnvsjMFko6jlDRqgm4wsymt6etTCZDADNrJhRwHS1pKiHxtccjcd21CJWyDwQOJiRJ51zOmdk9VOEYQSaHyZI2krRBYtIA4EWgj6T147RvAw+XWH02sGzhhZm9BqwEbBAPvz8KnERIks45B2Q0GQK9gKskPS1pCuFkylOAo4B/xZ7iIuCSEuuOAjYpHECJ0x4HCsPrMYRD74925gY45/Ilk8NkM5sIbFNi1oPAF6pbm9mwxPMPgMFF87+deP4Y2f0j4JxLiScF55zDS3i1hX9Arp5k4kTqLPKeoXPOkdF9htnyfOuLZMqGNNu0tIOoSJP65bJu5Ph37047jIoMXnnvtEPINO8ZOuccngydcw6og2GypGZgamLSAWY2I6VwnHM5lftkCMwzswFpB+Gcy7e6HCZLmhFrICJpkKTR8flpsfTXaEkvSToh1UCdc5lRDz3DnpImxecvm9mBrSzfl1AJZ1ngOUl/N7PPOjNA51z21UPPcF6sXTigDYkQ4G4zW2Bm7wHvAKsUL5CsZzh8+I1VD9g5lz310DMsZSGfJ/oeRfMWJJ43U+IzSNYzhOf9ChTnGkA99AxLmQEMjM8PSjEO51xO1GsyPB04X9IEQu/POedalPthspn1KjFtDLBhiemnFb3u13mROefypF57hs45VxFPhs45h9czbAv/gFw98XqGZeR+n2Hny18Jr1+Mz1c5rLMG78z85nFph1GRHk1bs3DR5LTDqEjXLv3TDiHTfJjsnHN4MnTOOSCnyVDSnKLXwyRdFJ+fJumkxPTVEsstLuDgnHNJuUyGFRgGrNbaQs45V7fJUNLBwCDgunhD+Z5x1vGSnpQ0VVLfFEN0zmVIXpNhz5jgJsXyXb8rXsDMbgYmAEfEijbz4qz3zGxL4O/ASTWL2DmXaXlNhsmyXQOA31Sw7q3x50SgT6kFvISXc42nEc8zLJTwKlm+C7yEl3ONKK89w7aaTaho7ZxzLar3ZDgCuKToAIpzzn1BLofJxWW7zGwEIfEtUabLzG4Bbkks2icxbwIwpNOCdM7lSr33DJ1zrk08GTrnHF7Cqy38A3L1xEt4leE9w9apMx6SfthZbXvMHnMLD1eGJ8P0HJ12AO3gMddGHmPOPU+GzjmHJ0PnnAM8GaZpeNoBtIPHXBt5jDn3/Giyc87hPUPnnAM8GdacpCskvSNpWtqxtJWkNSWNkvS0pOmSfpx2TK2R1EPSE5Imx5hPTzumtpDUJOkpSXelHUuj8WRYeyOAPdIOokILgZ+Z2SbA14BjJW2SckytWQDsZGb9gQHAHpK+lm5IbfJj4Jm0g2hEngxrzMweAT5IO45KmNmbZvZkfD6b8J919XSjapkFhRuHLRUfmd5BLmkNYG/gsrRjaUSeDF1FJPUBtgAeTzmUVsUh5yTgHeABM8t6zH8FTgYWpRxHQ/Jk6NpMUi9CSbSfmNmstONpjZk1x9tCrAFsJalfyiGVJWkf4B0zm5h2LI3Kk6FrE0lLERLhdWZ2a2vLZ4mZfQSMItv7arcF9pM0A7gB2EnStemG1Fg8GbpWSRJwOfCMmf0l7XjaQtLKknrH5z2BXYFnUw2qBWZ2qpmtYWZ9gMOAh8zsWymH1VA8GdaYpOuBccBGkl6X9L20Y2qDbYFvE3orhVu07pV2UK1YFRglaQownrDP0E9XcWX5FSjOOYf3DJ1zDvBk6JxzgCdD55wDPBk65xzgydA55wBPhs45B3gy7BBJX5F0g6QXJU2UdI+kDdOOqxxJq0m6OT4fkDxXUNJ+kk6pwnv0lPSwpKYqtNWnUOqspXglnSbppI6+X9F7V73N2O5PJC2deD2npeXb0N6c+HNlSfd2NL5G5smwneJVGbcBo81sPTMbCJwKrJJuZOWZ2UwzOzi+HADslZg30sz+VIW3+S5wq5k1V6GtpAF0Try19hNg6dYWqpSZvQu8KWnbarfdKDwZtt9Q4DMzu6Qwwcwmm9kYBWdLmiZpqqRDASQNib2mOyS9JOlPko6IRUinSlovLjdC0t8l/TcuNyQWhX1G0ojC+yV7FZIOLsyL618g6bG4/sFxep8YUzfgd8Ch8WqSQyUNk3RRXG5lSbdIGh8f28bpOyauQHlK0rIlPpcjgDvasb2FJP2F3lJr8RYtu56ke2NPfYykvpKWl/SKpC5xmWUkvSZpqVLLt/RLr+B3s5ukcZKelPQvSb0knQCsRrgyZlRi2T8oFKH9r6RVEr+rhyRNkfSgpLXi9HViu1Ml/b4ovNvj5+/aw8z80Y4HcAJwXpl5BwEPAE2EnuKrhMvDhgAfxefdgTeA0+M6Pwb+Gp+PIFysL2B/YBawGeGP10RgQFxuTuI9DwZGJNb/V1x+E+B/cXofYFp8Pgy4KLH+4tfAP4Ht4vO1CNckA9wJbBuf9wK6Fm13N+CtxOtKtvfgxHpzKoz3NOCk+PxBYIP4/KuEa3whJOih8fmhwGWtLL+4zaJtbPV3A6wEPAIsE9f5BfCb+HwGsFKiPQP2jc//DPw68VkfGZ9/F7g9Ph8JfCc+P5YlvwOrA1PT/r+R10dXXGfYDrjewlDxbUkPA4MJ/3HGm9mbAJJeBO6P60wl9DYL7jQzkzQVeNvMpsZ1phOSxKRWYrjdzBYBTxd6GxXYBdgk7AkAYDmF8l1jgb9Iuo4wFH69aL2VCMkvqa3b22Exxm2AfyVi7x5/3khIgqMIhRAubmX5lrT2u1mD8EdobGy3G+F69FI+BQrXTE8kFJQA2Br4enx+DSFRQrhO/KDE9LMSbb1D6Hm6dvBk2H7TCb2xSi1IPF+UeL2IJX8fC0osU7xc8sLyHi28j6hMF+BrZja/aPqfJN1N2Hc3VtLuZpasBDOvlTjKbe/C+J7EoWy3CuNNxv2RhRqGxUYCf5S0AjAQeAhYpoXlW9La76aZUBji8Da09ZnFbl1cry3/J8sVFOhB+B24dvB9hu33ENBd0tGFCZI2l7Q9MIawf6tJ0srADsATnRDD25I2jgnkwArXnQ2U2ucHofd2fOGFpAHx53pmNtXMziJUglli/5qZfQg0SSpOiK2ZQUhQAPsRSvRXEm/h/WcBL0v6RoxXkvrHeXNizOcDd1ko/Fp2+Q76L7CtpPVju8vo87MMWt2O6DFCDxbCfsAx8fnYoulJGwK5udFY1ngybKf41/xAYBeFU2umA2cCbxGOMk8BJhOS5slm9lYnhHEKYYj1GPBmheuOIgyFJyke4Ek4ARgUd94/DRwTp/9E4QDMFOAz4N8l2r2fsJugEpcCO0qaTBgezq0w3qQjgO/FtqYT9usV3Ah8K/5sy/LtYuHI7jDg+vhZjePzPxzDgXuTB1DKOB44Kq7/bcI+VuLPY+MQvfg+NEOBuzsaf6PyEl6uqiRtCZxoZt9OO5ZGI+kRYP/YQ3cV8p6hqyoLd9EbpSqcdO3aLu6O+YsnwvbznqFzzuE9Q+ecAzwZOucc4MnQOecAT4bOOQd4MnTOOQD+P2k8zNc8NVJcAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -967,9 +869,21 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] }, "metadata": { @@ -979,66 +893,24 @@ } ], "source": [ - "for num, metric in enumerate(['jaccard', 'cosine']):\n", - " \n", - " # Create edges, and edge value thresholds\n", - " perms = [str(p) for p in permnos]\n", - " E = DataFrame(data=similar[year][metric], index=perms, columns=perms)\n", - " E = E.stack()\n", - " thresh = [10, 20, 25, 30, 40, 50, 60, 70, 80, 90, 95]\n", - " thresh = {t: v for t,v in zip(thresh, np.percentile(E, thresh))}\n", - " E = E.reset_index()\n", - "\n", - " thresholds = [40, 60, 80]\n", - " for i, pct in enumerate(thresholds): # percentile thresholds to cull edges\n", - " print(f'\\nMin {metric} similarity threshold for edges: {pct}th %-tile')\n", - " edges = E[(E.iloc[:,0] != E.iloc[:,1]) & (E.iloc[:,-1] > thresh[pct])]\n", - " attributes = edges.iloc[:, -1].values\n", - " edges = edges.iloc[:, :-1].values\n", - " \n", - " # Populate igraph including attributes (note: vertex names must be str)\n", - " g = Graph(directed=False)\n", - " g.add_vertices(vs.index.astype(str).to_list(), vs.to_dict(orient='list'))\n", - " g.add_edges(edges, {'score': attributes})\n", - " degree = Series(g.vs.degree()) # to remove zero degree vertexes\n", - " print('Deleting', len(degree[degree==0]), 'vertex IDs with degree 0.\\n')\n", - " g.delete_vertices(degree[degree==0].index.to_list())\n", - " g = g.simplify() # remove self-loops and multi-edges\n", - " s = Series(igraph_info(g, fast=True)).rename(year)\n", - " print(s.to_frame().T)\n", - " #t = g.components(mode=1)\n", - " #print('Deleting', t._len-1, 'components with sizes', t.sizes()[1:], '\\n')\n", - " #g = t.subgraph(0)\n", - " \n", - " # detect communities and report modularity\n", - " c = g.community_multilevel()\n", - " print(DataFrame({'modularity':c.modularity, 'components':len(c.sizes())},\n", - " index=[pct]).rename_axis(f'{metric} threshold %'))\n", - " \n", - " # plot and display industry representation of communities detected\n", - " detect = 'multilevel'\n", - " indus = pd.concat([Series(c.subgraph(j).vs[scheme])\\\n", - " .value_counts().rename(i+1)\n", - " for i, j in enumerate(np.argsort(c.sizes())[::-1])],\n", - " axis=1).dropna(axis=0, how='all').fillna(0).astype(int)\\\n", - " .reindex(codes[scheme].sectors['name']\\\n", - " .drop_duplicates(keep='first'))\n", - " for j in indus.columns:\n", - " tops = \", \".join(f\"{k}({v})\" for k,v in\n", - " indus.sort_values(j)[-1:-4:-1][j].items())\n", - " print(f\" Community {j}:\", tops) \n", - " fig, ax = plt.subplots(num=(len(thresholds)*num) + 1 + i, clear=True,\n", - " figsize=(5, 12))\n", - " sns.heatmap(indus, square=False, linewidth=.5, ax=ax, yticklabels=1,\n", - " cmap=\"YlGnBu\", robust=True)\n", - " ax.set_yticklabels(indus.index, size=10)\n", - " ax.set_xlabel(f'Communities ({detect} method)')\n", - " ax.set_ylabel(f'Industry Representation ({scheme})')\n", - " ax.set_title(f\"Business Descriptions {year} ({metric} threshold {pct}%)\")\n", - " fig.subplots_adjust(left=0.4)\n", - " plt.tight_layout(pad=3)\n", - " plt.savefig(os.path.join(imgdir, f'{metric}{year}_{pct}.jpg'))\n", - "plt.show()" + "top_n = 20 \n", + "words = {}\n", + "feature_names = vectorizer.get_feature_names_out()\n", + "for topic, lab in enumerate(res.clf.classes_):\n", + " importance = res.clf.coef_[topic, :]\n", + " words[lab] = [feature_names[i]\n", + " for i in importance.argsort()[:-top_n-1:-1]]\n", + " freqs = {feature_names[i]: importance[i]\n", + " for i in importance.argsort()[:-top_n-1:-1]}\n", + " fig, ax = plt.subplots(figsize=(3.5, 3), clear=True)\n", + " wc = WordCloud(height=500, width=500, colormap='cool')\n", + " ax.imshow(wc.generate_from_frequencies(freqs))\n", + " ax.axis(\"off\")\n", + " ax.set_title(lab)\n", + " plt.tight_layout()\n", + " plt.savefig(imgdir / f\"logistic_wc{topic}.jpg\")\n", + "out = DataFrame.from_dict(words, orient='columns')\n", + "show(out, index=False, **SHOW)" ] }, { @@ -1050,8 +922,9 @@ } ], "metadata": { + "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1065,9 +938,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.10.9" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/conditional_volatility.ipynb b/conditional_volatility.ipynb index c6d27a4..b319c4c 100644 --- a/conditional_volatility.ipynb +++ b/conditional_volatility.ipynb @@ -4,12 +4,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Conditional Volatility\n", + "# Conditional Volatility of Cryptocurrencies\n", "\n", - "- Value at Risk, GARCH, EWMA, Scholes-Williams Beta\n", - "- VIX, Bitcoin, St Louis Fed FRED\n", + "- Value at Risk, Expected Shortfall, GARCH, EWMA\n", + "- Cryptocurrencies: bitcoin, etherium\n", "\n", - "Terence Lim" + "Copyright 2023, Terence Lim\n", + "\n", + "MIT License" ] }, { @@ -18,119 +20,35 @@ "metadata": {}, "outputs": [], "source": [ - "import os\n", "import numpy as np\n", - "import scipy\n", + "from scipy.stats import chi2, norm, t, jarque_bera, kurtosis, skew\n", "import pandas as pd\n", "from pandas import DataFrame, Series\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns \n", "from finds.alfred import Alfred\n", + "from finds.recipes import kupiecLR, pof, halflife, RiskMeasure\n", + "from finds.display import show\n", + "from conf import VERBOSE, credentials, paths\n", "\n", - "from settings import settings\n", - "imgdir = os.path.join(settings['images'], 'ts')\n", - "alf = Alfred(api_key=settings['fred']['api_key'])\n" + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(ndigits=4, latex=None)\n", + "imgdir = paths['images'] / 'ts'\n", + "alf = Alfred(api_key=credentials['fred']['api_key'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Helpers for VaR tests" + "## Histogram, VaR and ES of Cryptocurrencies" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], - "source": [ - "# proportion of failures likelihood test\n", - "def kupiecLR(s, n, var):\n", - " \"\"\"Kupiec LR test (S violations in N trials) of VaR\"\"\"\n", - " p = 1 - var # e.g. var95 is 0.95\n", - " t = n - s # number of non-violations\n", - " num = np.log(1 - p)*(n - s) + np.log(p)*s\n", - " den = np.log(1 - (s/n))*(n - s) + np.log(s/n)*s\n", - " lr = -2 * (num - den)\n", - " return {'lr': lr, 'pvalue': 1 - scipy.stats.chi2.cdf(lr, df=1)}\n", - "\n", - "def pof(X, pred, var=0.95):\n", - " \"\"\"Kupiec proportion of failures VaR test\"\"\"\n", - " Z = X / pred\n", - " z = scipy.stats.norm.ppf(1 - var)\n", - " r = {'n': len(Z), 's': np.sum(Z < z)}\n", - " r.update(kupiecLR(r['s'], r['n'], var))\n", - " return r\n", - "\n", - "# convert alpha to halflife\n", - "from pandas.api import types\n", - "def halflife(alpha):\n", - " \"\"\"Returns halflife from alpha = -ln(2)/ln(lambda), where lambda=1-alpha\"\"\"\n", - " if types.is_list_like(alpha):\n", - " return [halflife(a) for a in alpha]\n", - " return -np.log(2)/np.log(1-alpha) if 00)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Retrieve Bitcoin from FRED and plot EWMA and Daily Returns" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "z = scipy.stats.norm.ppf(0.05)\n", - "alpha = [0.03, 0.06]\n", - "series_id = 'CBBTCUSD'\n", - "X = alf(series_id, log=1, diff=1)[126:]\n", - "X.index = pd.DatetimeIndex(X.index.astype(str), freq='infer')\n", - "Y = np.square(X)\n", - "ewma = [np.sqrt((Y.ewm(alpha=a).mean()).rename(series_id)) for a in alpha]\n", - "fig, ax = plt.subplots(num=1, clear=True, figsize=(10,6))\n", - "ax.plot(X.shift(-1), ls='-', lw=.5, c='grey')\n", - "ax.plot(z * ewma[0], lw=1, ls='-.', c='b')\n", - "ax.plot(z * ewma[1], lw=1, ls='--', c='r')\n", - "ax.set_title(alf.header(series_id))\n", - "ax.set_ylabel('Daily Returns and EWMA Volatility')\n", - "ax.legend([series_id] + [f\"$\\lambda$ = {1-a:.2f}\" for a in alpha])\n", - "ax.plot(-z * ewma[0], lw=1, ls='-.', c='b')\n", - "ax.plot(-z * ewma[1], lw=1, ls='--', c='r')\n", - "plt.savefig(os.path.join(imgdir, 'ewma.jpg'))\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "## Retrieve SP500 and VIX data, compute EWMA" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, "outputs": [ { "data": { @@ -153,134 +71,159 @@ " \n", " \n", " \n", - " SP500\n", - " EWMA(0.94)\n", - " VIXCLS\n", - " \n", - " \n", - " date\n", - " \n", - " \n", - " \n", + " std dev\n", + " skewness\n", + " excess kurtosis\n", + " jarque-bera pvalue\n", " \n", " \n", " \n", " \n", - " 2011-03-15\n", - " -0.011264\n", - " 0.011264\n", - " 0.015320\n", - " \n", - " \n", - " 2011-03-16\n", - " -0.019687\n", - " 0.016142\n", - " 0.018520\n", - " \n", - " \n", - " 2011-03-17\n", - " 0.013309\n", - " 0.015209\n", - " 0.016612\n", - " \n", - " \n", - " 2011-03-18\n", - " 0.004293\n", - " 0.013189\n", - " 0.015396\n", - " \n", - " \n", - " 2011-03-21\n", - " 0.014882\n", - " 0.013581\n", - " 0.012983\n", - " \n", - " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " \n", - " \n", - " 2021-03-04\n", - " -0.013508\n", - " 0.010921\n", - " 0.017997\n", - " \n", - " \n", - " 2021-03-05\n", - " 0.019308\n", - " 0.011487\n", - " 0.015534\n", + " CBBTCUSD\n", + " 0.0426\n", + " -1.8736\n", + " 48.9911\n", + " 0.0\n", " \n", " \n", - " 2021-03-08\n", - " -0.005374\n", - " 0.011260\n", - " 0.016045\n", + " CBETHUSD\n", + " 0.0556\n", + " -0.4426\n", + " 4.7691\n", + " 0.0\n", " \n", " \n", - " 2021-03-09\n", - " 0.014055\n", - " 0.011416\n", - " 0.015137\n", + " CBBCHUSD\n", + " 0.0625\n", + " -0.5600\n", + " 11.5654\n", + " 0.0\n", " \n", " \n", - " 2021-03-10\n", - " 0.006012\n", - " 0.011208\n", - " 0.014211\n", + " CBLTCUSD\n", + " 0.0588\n", + " 0.7586\n", + " 9.4610\n", + " 0.0\n", " \n", " \n", "\n", - "

2514 rows × 3 columns

\n", "" ], "text/plain": [ - " SP500 EWMA(0.94) VIXCLS\n", - "date \n", - "2011-03-15 -0.011264 0.011264 0.015320\n", - "2011-03-16 -0.019687 0.016142 0.018520\n", - "2011-03-17 0.013309 0.015209 0.016612\n", - "2011-03-18 0.004293 0.013189 0.015396\n", - "2011-03-21 0.014882 0.013581 0.012983\n", - "... ... ... ...\n", - "2021-03-04 -0.013508 0.010921 0.017997\n", - "2021-03-05 0.019308 0.011487 0.015534\n", - "2021-03-08 -0.005374 0.011260 0.016045\n", - "2021-03-09 0.014055 0.011416 0.015137\n", - "2021-03-10 0.006012 0.011208 0.014211\n", - "\n", - "[2514 rows x 3 columns]" + " std dev skewness excess kurtosis jarque-bera pvalue\n", + "CBBTCUSD 0.0426 -1.8736 48.9911 0.0\n", + "CBETHUSD 0.0556 -0.4426 4.7691 0.0\n", + "CBBCHUSD 0.0625 -0.5600 11.5654 0.0\n", + "CBLTCUSD 0.0588 0.7586 9.4610 0.0" ] }, - "execution_count": 5, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "sp500 = alf('SP500', log=1, diff=1).dropna()\n", - "vix = alf('VIXCLS')\n", - "ewma = np.sqrt((np.square(sp500).ewm(alpha=0.05).mean()).rename('EWMA(0.94)'))\n", - "mkt = pd.concat([sp500, ewma, (vix/100)/np.sqrt(252)], axis=1, join='inner')\n", - "mkt.index = pd.DatetimeIndex(mkt.index.astype(str), freq='infer')\n", - "mkt" + "labels = ['CBBTCUSD', 'CBETHUSD', 'CBBCHUSD', 'CBLTCUSD']\n", + "alpha = 0.95 # VaR parameter\n", + "out = {}\n", + "fig, axes = plt.subplots(2, 2, num=1, clear=True, figsize=(10, 5))\n", + "for label, ax in zip(labels, list(axes.ravel())):\n", + " rets = alf(label, log=1, diff=1).dropna()\n", + " sigma = rets.std()\n", + " risk_measure = RiskMeasure(rets, alpha=0.95)\n", + " var = risk_measure.value_at_risk()\n", + " es = risk_measure.expected_shortfall()\n", + " var_normal = risk_measure.value_at_risk(normal=True)\n", + " es_normal = risk_measure.expected_shortfall(normal=True)\n", + " \n", + " n, bins, _ = ax.hist(rets[rets < var], color='red', bins=30)\n", + " stepsize = (bins[-1] - bins[0]) / (len(bins) - 1)\n", + " bins = np.arange(var, max(rets) + stepsize, stepsize)\n", + " ax.hist(rets[rets >= var], color='green', bins=bins)\n", + "\n", + " ax.axvline(var, color='blue', ls='--')\n", + " ax.axvline(es, color='blue', ls=':')\n", + " ax.axvline(var_normal, color='cyan', ls='--')\n", + " ax.axvline(es_normal, color='cyan', ls=':')\n", + " ax.legend([f'VaR(empirical) {var:.4f}',\n", + " f'ES(empirical) = {es:.4f}',\n", + " f'VaR(normal) {var_normal:.4f})',\n", + " f'ES(normal) {es_normal:.4f})',\n", + " 'tail < VaR(empirical)',\n", + " f'daily returns (std={sigma:.4f})'], fontsize='x-small')\n", + " ax.set_title(f\"{label} {alf.header(label)[:60]}\",\n", + " {'fontsize' : 'small'})\n", + " ax.set_ylabel(f'{min(rets.index)}-{max(rets.index)}',\n", + " fontsize='small')\n", + " ax.set_xlabel(f'VaR and ES (alpha={alpha*100:.0f})',\n", + " fontsize='small')\n", + " out[label] = {'std dev': np.std(rets, ddof=1),\n", + " 'skewness': skew(rets),\n", + " 'excess kurtosis': kurtosis(rets)-3,\n", + " 'jarque-bera pvalue': jarque_bera(rets)[1]}\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / 'es.jpg')\n", + "\n", + "# Non-normal: Jacque-Bera, excess kurtosis, mixtures\n", + "show(DataFrame(out).T, **SHOW)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## GARCH(1,1) wrapper around rugarch" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import rpy2.robjects as ro\n", + "from rpy2.robjects.packages import importr\n", + "from finds.pyR import PyR\n", + "def rugarch(rets: Series, savefig: str = '') -> np.array:\n", + " rugarch_ro = importr('rugarch') # to use library rugarch\n", + " c_ = ro.r['c']\n", + " list_ = ro.r['list']\n", + " spec = ro.r['ugarchspec'](mean_model=list_(armaOrder=c_(0, 0),\n", + " include_mean=False))\n", + " model = ro.r['ugarchfit'](spec, data=PyR(rets.values).ro) \n", + " ro.r['show'](model)\n", + "\n", + " if savefig:\n", + " for which in [4, 5, 10, 11]:\n", + " ro.r['plot'](model, which=which)\n", + " PyR.savefig(imgdir / f'{savefig}{which}.png')\n", + " return PyR(ro.r['sigma'](model)).values # fitted volatility values" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## GARCH(1,1) using rugarch" + "## Retrive Bitcoin from FRED and plot GARCH, EWMA and Daily Returns" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "scrolled": false - }, + "execution_count": 4, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -294,226 +237,93 @@ "Conditional Variance Dynamics \t\n", "-----------------------------------\n", "GARCH Model\t: sGARCH(1,1)\n", - "Mean Model\t: ARFIMA(2,0,0)\n", + "Mean Model\t: ARFIMA(0,0,0)\n", "Distribution\t: norm \n", "\n", "Optimal Parameters\n", "------------------------------------\n", " Estimate Std. Error t value Pr(>|t|)\n", - "mu 0.000816 0.000112 7.3115 0.000000\n", - "ar1 -0.066110 0.022580 -2.9278 0.003413\n", - "ar2 0.022196 0.021454 1.0346 0.300866\n", - "omega 0.000004 0.000002 2.1419 0.032204\n", - "alpha1 0.218600 0.011632 18.7924 0.000000\n", - "beta1 0.748534 0.002150 348.1085 0.000000\n", + "mu 0.002181 0.000589 3.7042 0.000212\n", + "omega 0.000091 0.000013 6.9373 0.000000\n", + "alpha1 0.197710 0.018396 10.7477 0.000000\n", + "beta1 0.780395 0.016824 46.3859 0.000000\n", "\n", "Robust Standard Errors:\n", " Estimate Std. Error t value Pr(>|t|)\n", - "mu 0.000816 0.000419 1.94560 0.051703\n", - "ar1 -0.066110 0.021508 -3.07370 0.002114\n", - "ar2 0.022196 0.028794 0.77083 0.440807\n", - "omega 0.000004 0.000013 0.32900 0.742154\n", - "alpha1 0.218600 0.099536 2.19620 0.028078\n", - "beta1 0.748534 0.110271 6.78815 0.000000\n", + "mu 0.002181 0.000660 3.3041 0.000953\n", + "omega 0.000091 0.000037 2.4581 0.013967\n", + "alpha1 0.197710 0.063783 3.0998 0.001937\n", + "beta1 0.780395 0.047028 16.5942 0.000000\n", "\n", - "LogLikelihood : 8483.952 \n", + "LogLikelihood : 5486.844 \n", "\n", "Information Criteria\n", "------------------------------------\n", " \n", - "Akaike -6.7446\n", - "Bayes -6.7307\n", - "Shibata -6.7446\n", - "Hannan-Quinn -6.7395\n", + "Akaike -3.7567\n", + "Bayes -3.7485\n", + "Shibata -3.7567\n", + "Hannan-Quinn -3.7537\n", "\n", "Weighted Ljung-Box Test on Standardized Residuals\n", "------------------------------------\n", " statistic p-value\n", - "Lag[1] 1.547 0.2136\n", - "Lag[2*(p+q)+(p+q)-1][5] 3.498 0.2068\n", - "Lag[4*(p+q)+(p+q)-1][9] 7.013 0.1268\n", - "d.o.f=2\n", + "Lag[1] 2.037 0.15347\n", + "Lag[2*(p+q)+(p+q)-1][2] 3.928 0.07882\n", + "Lag[4*(p+q)+(p+q)-1][5] 8.572 0.02121\n", + "d.o.f=0\n", "H0 : No serial correlation\n", "\n", "Weighted Ljung-Box Test on Standardized Squared Residuals\n", "------------------------------------\n", " statistic p-value\n", - "Lag[1] 0.04389 0.8341\n", - "Lag[2*(p+q)+(p+q)-1][5] 1.57993 0.7202\n", - "Lag[4*(p+q)+(p+q)-1][9] 3.84728 0.6148\n", + "Lag[1] 0.06894 0.7929\n", + "Lag[2*(p+q)+(p+q)-1][5] 2.07961 0.5997\n", + "Lag[4*(p+q)+(p+q)-1][9] 2.87423 0.7795\n", "d.o.f=2\n", "\n", "Weighted ARCH LM Tests\n", "------------------------------------\n", " Statistic Shape Scale P-Value\n", - "ARCH Lag[3] 0.1376 0.500 2.000 0.7107\n", - "ARCH Lag[5] 2.5065 1.440 1.667 0.3698\n", - "ARCH Lag[7] 4.2297 2.315 1.543 0.3146\n", + "ARCH Lag[3] 1.267 0.500 2.000 0.2603\n", + "ARCH Lag[5] 1.544 1.440 1.667 0.5809\n", + "ARCH Lag[7] 1.866 2.315 1.543 0.7457\n", "\n", "Nyblom stability test\n", "------------------------------------\n", - "Joint Statistic: 3.2664\n", - "Individual Statistics: \n", - "mu 0.1125\n", - "ar1 0.2584\n", - "ar2 0.1496\n", - "omega 0.5571\n", - "alpha1 0.2554\n", - "beta1 0.2102\n", + "Joint Statistic: 1.3755\n", + "Individual Statistics: \n", + "mu 0.24191\n", + "omega 0.46907\n", + "alpha1 0.04071\n", + "beta1 0.27349\n", "\n", "Asymptotic Critical Values (10% 5% 1%)\n", - "Joint Statistic: \t 1.49 1.68 2.12\n", + "Joint Statistic: \t 1.07 1.24 1.6\n", "Individual Statistic:\t 0.35 0.47 0.75\n", "\n", "Sign Bias Test\n", "------------------------------------\n", - " t-value prob sig\n", - "Sign Bias 3.6264 0.0002931 ***\n", - "Negative Sign Bias 0.8899 0.3735995 \n", - "Positive Sign Bias 0.7971 0.4254712 \n", - "Joint Effect 24.0749 0.0000241 ***\n", + " t-value prob sig\n", + "Sign Bias 1.089 0.2761 \n", + "Negative Sign Bias 1.203 0.2292 \n", + "Positive Sign Bias 1.722 0.0851 *\n", + "Joint Effect 4.481 0.2140 \n", "\n", "\n", "Adjusted Pearson Goodness-of-Fit Test:\n", "------------------------------------\n", " group statistic p-value(g-1)\n", - "1 20 122.1 4.576e-17\n", - "2 30 135.7 9.908e-16\n", - "3 40 152.8 2.155e-15\n", - "4 50 160.3 9.681e-14\n", + "1 20 481.9 3.534e-90\n", + "2 30 487.1 1.260e-84\n", + "3 40 513.4 4.743e-84\n", + "4 50 535.0 6.399e-83\n", "\n", "\n", - "Elapsed time : 0.629132 \n", + "Elapsed time : 0.2113795 \n", "\n" ] }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import rpy2.robjects as ro\n", - "from rpy2.robjects.packages import importr\n", - "from finds.pyR import PyR\n", - "rugarch_ro = importr('rugarch') # to use library rugarch\n", - "c_ = ro.r['c']\n", - "list_ = ro.r['list']\n", - "spec = ro.r['ugarchspec'](mean_model=list_(armaOrder=c_(2,0),include_mean=False))\n", - "model = ro.r['ugarchfit'](spec, data=PyR(mkt['SP500'].values).ro) \n", - "ro.r['show'](model)\n", - "for which in [4, 5, 10, 11]:\n", - " ro.r['plot'](model, which=which)\n", - " PyR.savefig(os.path.join(imgdir, f'ugarch{which}.png'))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Plot all, but for illustration only: \n", - "## The 3 \"forecasts\" are not comparable: VIX is implied from options with 3-month expiry, GARCH fitted fully in-sample, EWMA is rolling average" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mkt['GARCH(1,1)'] = PyR(ro.r['sigma'](model)).values # fitted volatility values\n", - "var = 0.95 # VaR95\n", - "z = scipy.stats.norm.ppf(1 - var)\n", - "fig, ax = plt.subplots(num=1, clear=True, figsize=(10,7))\n", - "ax.plot(mkt['SP500'], ls='-', lw=.5, c='grey')\n", - "ax.plot(z * mkt.iloc[:,1], lw=1, ls='-.', c='blue')\n", - "ax.plot(z * mkt.iloc[:,2], lw=1, ls='--', c='green')\n", - "ax.plot(z * mkt.iloc[:,3], lw=1, ls=':', c='red')\n", - "ax.set_title('SP500')\n", - "ax.set_ylabel('Daily Returns and VaR')\n", - "ax.legend(mkt.columns)\n", - "plt.savefig(os.path.join(imgdir, 'var.jpg'))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Get all daily series of financial price categories from FRED\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "32255 32255 Stock Market Indexes\n", - "33913 33913 Cryptocurrencies\n", - "94 94 Daily Rates\n" - ] - }, { "data": { "text/html": [ @@ -535,578 +345,76 @@ " \n", " \n", " \n", - " 0\n", - " \n", - " \n", - " \n", - " \n", - " DJCA\n", - " Dow Jones Composite Average\n", - " \n", - " \n", - " DJIA\n", - " Dow Jones Industrial Average\n", - " \n", - " \n", - " DJTA\n", - " Dow Jones Transportation Average\n", - " \n", - " \n", - " DJUA\n", - " Dow Jones Utility Average\n", - " \n", - " \n", - " NASDAQ100\n", - " NASDAQ 100 Index\n", - " \n", - " \n", - " NASDAQCOM\n", - " NASDAQ Composite Index\n", - " \n", - " \n", - " SP500\n", - " S&P 500\n", - " \n", - " \n", - " WILL2500IND\n", - " Wilshire 2500 Total Market Index\n", - " \n", - " \n", - " WILL2500INDGR\n", - " Wilshire 2500 Growth Total Market Index\n", - " \n", - " \n", - " WILL2500INDVAL\n", - " Wilshire 2500 Value Total Market Index\n", - " \n", - " \n", - " WILL2500PR\n", - " Wilshire 2500 Price Index\n", - " \n", - " \n", - " WILL2500PRGR\n", - " Wilshire 2500 Growth Price Index\n", - " \n", - " \n", - " WILL2500PRVAL\n", - " Wilshire 2500 Value Price Index\n", - " \n", - " \n", - " WILL4500IND\n", - " Wilshire 4500 Total Market Index\n", - " \n", - " \n", - " WILL4500PR\n", - " Wilshire 4500 Price Index\n", - " \n", - " \n", - " WILL5000IND\n", - " Wilshire 5000 Total Market Index\n", - " \n", - " \n", - " WILL5000INDFC\n", - " Wilshire 5000 Total Market Full Cap Index\n", - " \n", - " \n", - " WILL5000PR\n", - " Wilshire 5000 Price Index\n", - " \n", - " \n", - " WILL5000PRFC\n", - " Wilshire 5000 Full Cap Price Index\n", - " \n", - " \n", - " WILLLRGCAP\n", - " Wilshire US Large-Cap Total Market Index\n", - " \n", - " \n", - " WILLLRGCAPGR\n", - " Wilshire US Large-Cap Growth Total Market Index\n", - " \n", - " \n", - " WILLLRGCAPGRPR\n", - " Wilshire US Large-Cap Growth Price Index\n", - " \n", - " \n", - " WILLLRGCAPPR\n", - " Wilshire US Large-Cap Price Index\n", - " \n", - " \n", - " WILLLRGCAPVAL\n", - " Wilshire US Large-Cap Value Total Market Index\n", - " \n", - " \n", - " WILLLRGCAPVALPR\n", - " Wilshire US Large-Cap Value Price Index\n", - " \n", - " \n", - " WILLMICROCAP\n", - " Wilshire US Micro-Cap Total Market Index\n", - " \n", - " \n", - " WILLMICROCAPPR\n", - " Wilshire US Micro-Cap Price Index\n", - " \n", - " \n", - " WILLMIDCAP\n", - " Wilshire US Mid-Cap Total Market Index\n", - " \n", - " \n", - " WILLMIDCAPGR\n", - " Wilshire US Mid-Cap Growth Total Market Index\n", - " \n", - " \n", - " WILLMIDCAPGRPR\n", - " Wilshire US Mid-Cap Growth Price Index\n", - " \n", - " \n", - " WILLMIDCAPPR\n", - " Wilshire US Mid-Cap Price Index\n", - " \n", - " \n", - " WILLMIDCAPVAL\n", - " Wilshire US Mid-Cap Value Total Market Index\n", - " \n", - " \n", - " WILLMIDCAPVALPR\n", - " Wilshire US Mid-Cap Value Price Index\n", - " \n", - " \n", - " WILLREITIND\n", - " Wilshire US Real Estate Investment Trust Total...\n", - " \n", - " \n", - " WILLREITPR\n", - " Wilshire US Real Estate Investment Trust Price...\n", - " \n", - " \n", - " WILLRESIND\n", - " Wilshire US Real Estate Securities Total Marke...\n", - " \n", - " \n", - " WILLRESIPR\n", - " Wilshire US Real Estate Securities Price Index...\n", - " \n", - " \n", - " WILLSMLCAP\n", - " Wilshire US Small-Cap Total Market Index\n", - " \n", - " \n", - " WILLSMLCAPGR\n", - " Wilshire US Small-Cap Growth Total Market Index\n", - " \n", - " \n", - " WILLSMLCAPGRPR\n", - " Wilshire US Small-Cap Growth Price Index\n", - " \n", - " \n", - " WILLSMLCAPPR\n", - " Wilshire US Small-Cap Price Index\n", - " \n", - " \n", - " WILLSMLCAPVAL\n", - " Wilshire US Small-Cap Value Total Market Index\n", - " \n", - " \n", - " WILLSMLCAPVALPR\n", - " Wilshire US Small-Cap Value Price Index\n", - " \n", - " \n", - " CBBCHUSD\n", - " Coinbase Bitcoin Cash\n", + " std dev\n", + " skewness\n", + " excess kurtosis\n", + " pof(95)\n", + " pof p-value\n", " \n", " \n", " CBBTCUSD\n", - " Coinbase Bitcoin\n", - " \n", - " \n", - " CBETHUSD\n", - " Coinbase Ethereum\n", - " \n", - " \n", - " CBLTCUSD\n", - " Coinbase Litecoin\n", - " \n", - " \n", - " DEXBZUS\n", - " Brazil / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXCAUS\n", - " Canada / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXCHUS\n", - " China / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXDNUS\n", - " Denmark / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXHKUS\n", - " Hong Kong / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXINUS\n", - " India / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXJPUS\n", - " Japan / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXKOUS\n", - " South Korea / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXMAUS\n", - " Malaysia / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXMXUS\n", - " Mexico / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXNOUS\n", - " Norway / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXSDUS\n", - " Sweden / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXSFUS\n", - " South Africa / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXSIUS\n", - " Singapore / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXSLUS\n", - " Sri Lanka / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXSZUS\n", - " Switzerland / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXTAUS\n", - " Taiwan / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXTHUS\n", - " Thailand / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXUSAL\n", - " U.S. / Australia Foreign Exchange Rate\n", - " \n", - " \n", - " DEXUSEU\n", - " U.S. / Euro Foreign Exchange Rate\n", - " \n", - " \n", - " DEXUSNZ\n", - " U.S. / New Zealand Foreign Exchange Rate\n", - " \n", - " \n", - " DEXUSUK\n", - " U.S. / U.K. Foreign Exchange Rate\n", - " \n", - " \n", - " DEXVZUS\n", - " Venezuela / U.S. Foreign Exchange Rate\n", - " \n", - " \n", - " DTWEXAFEGS\n", - " Trade Weighted U.S. Dollar Index: Advanced For...\n", - " \n", - " \n", - " DTWEXBGS\n", - " Trade Weighted U.S. Dollar Index: Broad, Goods...\n", - " \n", - " \n", - " DTWEXEMEGS\n", - " Trade Weighted U.S. Dollar Index: Emerging Mar...\n", - " \n", - " \n", - "\n", - "" - ], - "text/plain": [ - " 0\n", - "DJCA Dow Jones Composite Average\n", - "DJIA Dow Jones Industrial Average\n", - "DJTA Dow Jones Transportation Average\n", - "DJUA Dow Jones Utility Average\n", - "NASDAQ100 NASDAQ 100 Index\n", - "NASDAQCOM NASDAQ Composite Index\n", - "SP500 S&P 500\n", - "WILL2500IND Wilshire 2500 Total Market Index\n", - "WILL2500INDGR Wilshire 2500 Growth Total Market Index\n", - "WILL2500INDVAL Wilshire 2500 Value Total Market Index\n", - "WILL2500PR Wilshire 2500 Price Index\n", - "WILL2500PRGR Wilshire 2500 Growth Price Index\n", - "WILL2500PRVAL Wilshire 2500 Value Price Index\n", - "WILL4500IND Wilshire 4500 Total Market Index\n", - "WILL4500PR Wilshire 4500 Price Index\n", - "WILL5000IND Wilshire 5000 Total Market Index\n", - "WILL5000INDFC Wilshire 5000 Total Market Full Cap Index\n", - "WILL5000PR Wilshire 5000 Price Index\n", - "WILL5000PRFC Wilshire 5000 Full Cap Price Index\n", - "WILLLRGCAP Wilshire US Large-Cap Total Market Index\n", - "WILLLRGCAPGR Wilshire US Large-Cap Growth Total Market Index\n", - "WILLLRGCAPGRPR Wilshire US Large-Cap Growth Price Index\n", - "WILLLRGCAPPR Wilshire US Large-Cap Price Index\n", - "WILLLRGCAPVAL Wilshire US Large-Cap Value Total Market Index\n", - "WILLLRGCAPVALPR Wilshire US Large-Cap Value Price Index\n", - "WILLMICROCAP Wilshire US Micro-Cap Total Market Index\n", - "WILLMICROCAPPR Wilshire US Micro-Cap Price Index\n", - "WILLMIDCAP Wilshire US Mid-Cap Total Market Index\n", - "WILLMIDCAPGR Wilshire US Mid-Cap Growth Total Market Index\n", - "WILLMIDCAPGRPR Wilshire US Mid-Cap Growth Price Index\n", - "WILLMIDCAPPR Wilshire US Mid-Cap Price Index\n", - "WILLMIDCAPVAL Wilshire US Mid-Cap Value Total Market Index\n", - "WILLMIDCAPVALPR Wilshire US Mid-Cap Value Price Index\n", - "WILLREITIND Wilshire US Real Estate Investment Trust Total...\n", - "WILLREITPR Wilshire US Real Estate Investment Trust Price...\n", - "WILLRESIND Wilshire US Real Estate Securities Total Marke...\n", - "WILLRESIPR Wilshire US Real Estate Securities Price Index...\n", - "WILLSMLCAP Wilshire US Small-Cap Total Market Index\n", - "WILLSMLCAPGR Wilshire US Small-Cap Growth Total Market Index\n", - "WILLSMLCAPGRPR Wilshire US Small-Cap Growth Price Index\n", - "WILLSMLCAPPR Wilshire US Small-Cap Price Index\n", - "WILLSMLCAPVAL Wilshire US Small-Cap Value Total Market Index\n", - "WILLSMLCAPVALPR Wilshire US Small-Cap Value Price Index\n", - "CBBCHUSD Coinbase Bitcoin Cash\n", - "CBBTCUSD Coinbase Bitcoin\n", - "CBETHUSD Coinbase Ethereum\n", - "CBLTCUSD Coinbase Litecoin\n", - "DEXBZUS Brazil / U.S. Foreign Exchange Rate\n", - "DEXCAUS Canada / U.S. Foreign Exchange Rate\n", - "DEXCHUS China / U.S. Foreign Exchange Rate\n", - "DEXDNUS Denmark / U.S. Foreign Exchange Rate\n", - "DEXHKUS Hong Kong / U.S. Foreign Exchange Rate\n", - "DEXINUS India / U.S. Foreign Exchange Rate\n", - "DEXJPUS Japan / U.S. Foreign Exchange Rate\n", - "DEXKOUS South Korea / U.S. Foreign Exchange Rate\n", - "DEXMAUS Malaysia / U.S. Foreign Exchange Rate\n", - "DEXMXUS Mexico / U.S. Foreign Exchange Rate\n", - "DEXNOUS Norway / U.S. Foreign Exchange Rate\n", - "DEXSDUS Sweden / U.S. Foreign Exchange Rate\n", - "DEXSFUS South Africa / U.S. Foreign Exchange Rate\n", - "DEXSIUS Singapore / U.S. Foreign Exchange Rate\n", - "DEXSLUS Sri Lanka / U.S. Foreign Exchange Rate\n", - "DEXSZUS Switzerland / U.S. Foreign Exchange Rate\n", - "DEXTAUS Taiwan / U.S. Foreign Exchange Rate\n", - "DEXTHUS Thailand / U.S. Foreign Exchange Rate\n", - "DEXUSAL U.S. / Australia Foreign Exchange Rate\n", - "DEXUSEU U.S. / Euro Foreign Exchange Rate\n", - "DEXUSNZ U.S. / New Zealand Foreign Exchange Rate\n", - "DEXUSUK U.S. / U.K. Foreign Exchange Rate\n", - "DEXVZUS Venezuela / U.S. Foreign Exchange Rate\n", - "DTWEXAFEGS Trade Weighted U.S. Dollar Index: Advanced For...\n", - "DTWEXBGS Trade Weighted U.S. Dollar Index: Broad, Goods...\n", - "DTWEXEMEGS Trade Weighted U.S. Dollar Index: Emerging Mar..." - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "categories = {}\n", - "for category in [32255, 33913, 94]:\n", - " c = alf.get_category(category)\n", - " print(category, c['id'], c['name'])\n", - " series = Series({s['id']: s['title'] for s in c['series']\n", - " if s['frequency'].startswith('Daily') and 'DISCONT' not in s['title']})\n", - " categories.update({c['name']: series})\n", - "pd.set_option('max_rows', 999)\n", - "pd.concat(list(categories.values()), axis=0).to_frame()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Fit EWAM models, and backtest VaR" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Stock Market Indexes 43\n", - "Cryptocurrencies 4\n", - "Daily Rates 26\n", - "Name: series, dtype: int64\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
lambdahalflifepof
0.001.00inf0.032441
0.010.9969.00.046650
0.020.9834.30.047519
0.030.9722.80.048021
0.040.9617.00.048053
0.050.9513.50.048594
0.060.9411.20.048053CBBTCUSD0.0426-1.873048.97940.03580.0003
0.070.939.60.047878EWMA(0.94)1.1405-1.143416.31340.04650.3969
0.080.928.30.047719EWMA(0.97)1.0822-1.562718.88690.04370.1177
0.090.917.30.047118GARCH(1,1)1.0237-0.82668.84390.04150.0346
\n", "
" ], "text/plain": [ - " lambda halflife pof\n", - "0.00 1.00 inf 0.032441\n", - "0.01 0.99 69.0 0.046650\n", - "0.02 0.98 34.3 0.047519\n", - "0.03 0.97 22.8 0.048021\n", - "0.04 0.96 17.0 0.048053\n", - "0.05 0.95 13.5 0.048594\n", - "0.06 0.94 11.2 0.048053\n", - "0.07 0.93 9.6 0.047878\n", - "0.08 0.92 8.3 0.047719\n", - "0.09 0.91 7.3 0.047118" + " std dev skewness excess kurtosis pof(95) pof p-value\n", + "CBBTCUSD \n", + "CBBTCUSD 0.0426 -1.8730 48.9794 0.0358 0.0003\n", + "EWMA(0.94) 1.1405 -1.1434 16.3134 0.0465 0.3969\n", + "EWMA(0.97) 1.0822 -1.5627 18.8869 0.0437 0.1177\n", + "GARCH(1,1) 1.0237 -0.8266 8.8439 0.0415 0.0346" ] }, - "execution_count": 9, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" - } - ], - "source": [ - "alphas = 1 - np.linspace(1, 0.91, 10)\n", - "results = {'pof': DataFrame(), 'n': DataFrame(), 'end': DataFrame(),\n", - " 's': DataFrame(), 'pvalue': DataFrame()} # to collect results\n", - "for category, series in categories.items():\n", - " for series_id in series.index:\n", - " X = alf(series_id, log=1, diff=1, freq='D').dropna()\n", - " if X is None:\n", - " print(f'*** oops {series_id} ***')\n", - " assert(X)\n", - " Y = np.square(X)\n", - " results[series_id] = {}\n", - " for i, alpha in enumerate(alphas):\n", - " ewma = np.sqrt((Y.ewm(alpha=alpha) if alpha>0 else Y.expanding())\\\n", - " .mean()).rename(i)\n", - " r = pof(X[126:], ewma[126:], var=0.95)\n", - " results['pof'].loc[series_id, alpha] = r['s']/r['n']\n", - " results['pvalue'].loc[series_id, alpha] = r['pvalue']\n", - " results['n'].loc[series_id, alpha] = r['n']\n", - " results['s'].loc[series_id, alpha] = r['s']\n", - " results['end'].loc[series_id, alpha] = alf.header(\n", - " series_id, 'observation_end')\n", - " #print(results['pof'].loc[series_id, [alpha]])\n", - "print(Series({k: len(v) for k, v in categories.items()}, name='series'))\n", - "pd.concat([Series(index=alphas, data=1-alphas, name='lambda').round(2),\n", - " Series(index=alphas, data=halflife(alphas),name='halflife').round(1),\n", - " results['pof'].median(axis=0).rename('pof').round(6)], axis=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plot distributions of Proportion of Failures by Model" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -1116,36 +424,60 @@ } ], "source": [ - "fig, ax = plt.subplots(num=1, clear=True, figsize=(10,6))\n", - "results['pof'].boxplot(ax=ax, grid=False)\n", - "ax.set_xticklabels([f\"{1-c:.3}\" for c in results['pof'].columns])\n", - "ax.set_xlabel('$\\lambda$ smoothing parameter')\n", - "ax.set_title('VaR Proportion of Failures Box-Plot')\n", - "ax.set_ylabel('Proportion of Failures')\n", - "ax.axhline(1 - var, linestyle=':', color='g')\n", - "for x, c in enumerate(results['pof'].columns):\n", - " for arg in [results['pof'][c].argmin(), results['pof'][c].argmax()]:\n", - " \n", - " y = results['pof'][c].iloc[[arg]]\n", - " ax.annotate(y.index[0], xy=(x + 1, y[0]-.003), fontsize=8, c='m',\n", - " rotation=45)\n", - "plt.savefig(os.path.join(imgdir, 'pof.jpg'))\n", - "plt.show()" + "series_id = 'CBBTCUSD'\n", + "X = alf(series_id, log=1, diff=1).dropna()\n", + "X.index = pd.DatetimeIndex(X.index.astype(str), freq='infer')\n", + "Y = np.square(X)\n", + "\n", + "lam = 0.97\n", + "asset = np.sqrt((Y.ewm(alpha=1 - lam).mean()).rename('EWMA')).to_frame()\n", + "asset['EWMA(0.94)'] = np.sqrt((Y.ewm(alpha=1 - 0.94).mean()))\n", + "asset['GARCH'] = rugarch(X)\n", + "\n", + "# Conditional Volatility Models EWMA(94), EWMA(97), GARCH(1, 1): Bitcoin\n", + "fig, ax = plt.subplots(num=1, clear=True, figsize=(10, 5))\n", + "ax.plot(X.shift(-1), ls='', marker='.', markersize=2)\n", + "ax.plot(norm.ppf(1 - alpha) * asset['EWMA'], lw=1, ls='-', c='r')\n", + "ax.plot(norm.ppf(1 - alpha) * asset['GARCH'], lw=1, ls='--', c='m')\n", + "ax.set_title(alf.header(series_id)\n", + " + f\" ({max(Y.index).strftime('%Y-%m-%d')}:\"\n", + " + f\"{min(Y.index).strftime('%Y-%m-%d')})\")\n", + "ax.set_ylabel('Daily Returns and Conditional Volatility')\n", + "ax.legend([series_id] + [f\"EWMA($\\lambda$={lam:.2f})\"] + ['GARCH(1,1)'])\n", + "ax.plot(-norm.ppf(1 - alpha) * asset['EWMA'], lw=1, ls='-', c='r')\n", + "ax.plot(-norm.ppf(1 - alpha) * asset['GARCH'], lw=1, ls='--', c='m')\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / 'ewma.jpg')\n", + "\n", + "# Statistical summary of conditional volatility models\n", + "y = X.shift(-1)\n", + "results = {}\n", + "for label, x in zip([series_id, 'EWMA(0.94)', f'EWMA({lam:.2f})','GARCH(1,1)'],\n", + " [1.0, asset['EWMA(0.94)'], asset['EWMA'], asset['GARCH']]):\n", + " if isinstance(x, (int, float)):\n", + " pof_ = pof((y / np.std(y))[126:], x) # skip first six months\n", + " else: \n", + " pof_ = pof(y[126:], x[126:]) # skip first six months\n", + " results[label] = {'std dev': np.std(y.div(x).dropna()),\n", + " 'skewness': skew(y.div(x).dropna()),\n", + " 'excess kurtosis': kurtosis(y.div(x).dropna()) - 3,\n", + " f'pof({int(100*alpha)})': pof_['s']/pof_['n'],\n", + " 'pof p-value': pof_['pvalue']}\n", + "show(DataFrame.from_dict(results, orient='index'), caption=series_id, **SHOW)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "scrolled": true - }, + "metadata": {}, "outputs": [], "source": [] } ], "metadata": { + "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1159,9 +491,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.10.9" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/covariance_matrix.ipynb b/covariance_matrix.ipynb new file mode 100644 index 0000000..0e8d4a9 --- /dev/null +++ b/covariance_matrix.ipynb @@ -0,0 +1,725 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Covariance Matrix Estimates of Industry Returns\n", + "\n", + "- Covariance Matrix: PCA, SVD, Shrinkage\n", + "- TODO: Risk Decomposition, Black-Litterman, Risk Parity\n", + "\n", + "Copyright 2023, Terence Lim\n", + "\n", + "MIT License" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy.linalg import inv, svd\n", + "from sklearn.decomposition import PCA\n", + "from scipy.stats import multivariate_normal\n", + "import pandas as pd\n", + "from pandas import DataFrame, Series\n", + "from tqdm import tqdm\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.covariance import LedoitWolf, OAS, EmpiricalCovariance\n", + "from finds.database import SQL, Redis\n", + "from finds.structured import CRSP, FFReader\n", + "from finds.busday import BusDay\n", + "from finds.recipes import halflife\n", + "from finds.display import plot_bar, show\n", + "from conf import credentials, VERBOSE, paths\n", + "from typing import Tuple\n", + "\n", + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(ndigits=4, latex=None)\n", + "imgdir = paths['images']\n", + "sql = SQL(**credentials['sql'], verbose=VERBOSE)\n", + "user = SQL(**credentials['user'], verbose=VERBOSE)\n", + "\n", + "rdb = Redis(**credentials['redis'])\n", + "bd = BusDay(sql, verbose=VERBOSE)\n", + "crsp = CRSP(sql, bd, rdb=rdb, verbose=VERBOSE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Retrieve industry returns from Ken French Data Library website" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
firstlastmissing
Missing Values in FF-49 Industry Monthly Returns
Soda49vw1926073119630628444
Hlth49vw1926073119690630516
Rubbr49vw192607311944063060
FabPr49vw1926073119630628444
Guns49vw1926073119630628444
Gold49vw1926073119630628444
PerSv49vw192607311927063012
Softw49vw1926073119650630468
Paper49vw192607311929062936
\n", + "
" + ], + "text/plain": [ + " first last missing\n", + "Missing Values in FF-49 Industry Monthly Returns \n", + "Soda49vw 19260731 19630628 444\n", + "Hlth49vw 19260731 19690630 516\n", + "Rubbr49vw 19260731 19440630 60\n", + "FabPr49vw 19260731 19630628 444\n", + "Guns49vw 19260731 19630628 444\n", + "Gold49vw 19260731 19630628 444\n", + "PerSv49vw 19260731 19270630 12\n", + "Softw49vw 19260731 19650630 468\n", + "Paper49vw 19260731 19290629 36" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "name, item, suffix = ('49_Industry_Portfolios', 0, '49vw')\n", + "df = FFReader.fetch(name=name,\n", + " item=item,\n", + " suffix=suffix,\n", + " date_formatter=bd.endmo)\n", + "\n", + "# show missing dates\n", + "nans = df.isnull()\n", + "missing = {col: {'first': min(nans[nans[col]].index),\n", + " 'last': max(nans[nans[col]].index),\n", + " 'missing': np.sum(nans[col])}\n", + " for col in df if nans[col].sum()}\n", + "df = df[df.index > 19690630]\n", + "Y = df.to_numpy()\n", + "show(DataFrame.from_dict(missing, orient='index'),\n", + " caption=\"Missing Values in FF-49 Industry Monthly Returns\", **SHOW)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PCA and scree plot" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.56140494 0.62540872 0.6651483 0.70222492 0.73038079 0.75292049\n", + " 0.77105102 0.78525435 0.79902919 0.81088906]\n", + "u: (641, 49) s: (49,) vT: (49, 49) v (49, 49)\n", + "[0.56140494 0.06400378 0.03973958 0.03707662 0.02815587 0.02253971\n", + " 0.01813052 0.01420333 0.01377484 0.01185987]\n", + "y: (641, 49) x: (641, 49) components_: (49, 49)\n", + "singular values: True\n", + "singular values: True\n", + "projections: [True, True, True, True, True, True, True, True, True, True]\n", + "projections: [True, True, True, True, True, True, True, True, True, True]\n", + "components: [True, True, True, True, True, True, True, True, True, True]\n", + "covariance matrix: True\n" + ] + } + ], + "source": [ + "# PCA of returns covariances by SVD\n", + "# SVD: u S vT = x (T samples x N stocks)\n", + "means = Y.mean(axis=0, keepdims=True)\n", + "X = Y.copy()\n", + "\n", + "x = np.array(X - means) # pre-process: demean by column\n", + "u, s, vT = np.linalg.svd(x, full_matrices=False)\n", + "v = vT.T\n", + "k = 10\n", + "print(np.cumsum(s[:k]**2/np.sum(np.diag(s**2))))\n", + "print('u:', u.shape, 's:', s.shape, 'vT:', vT.shape, 'v', v.shape)\n", + "\n", + "# sklearn PCA: X (T samples x N features/stocks), sanity check same results\n", + "pca = PCA() # note: PCA first demeans input X by column mean_\n", + "y = pca.fit_transform(X) # project X (stock returns) onto the components\n", + "print(pca.explained_variance_ratio_[:k])\n", + "print('y:', y.shape, 'x:', x.shape, 'components_:', pca.components_.shape)\n", + "\n", + "# assert: s == singular_values_ (aka 2-norm of the projection on components)\n", + "print('singular values:', np.allclose(pca.singular_values_, s))\n", + "\n", + "# assert: s**2 / len(y) == explained_variance_\n", + "print('singular values:', np.allclose(pca.singular_values_, s))\n", + "\n", + "# assert: x @ v == transform(x) (aka projection on components) (aka returns)\n", + "print('projections:', [np.allclose((x @ v)[:,i], -y[:,i]) or\n", + " np.allclose((x @ v)[:,i], y[:,i]) for i in range(k)])\n", + "\n", + "# assert: u @ s == transform(x) (aka factor returns)\n", + "print('projections:', [np.allclose(u[:,i]*s[i], -y[:,i]) or\n", + " np.allclose(u[:,i]*s[i], y[:,i]) for i in range(k)])\n", + "\n", + "# assert: cols of v == rows of components_ (right SVD eigenvectors) (weights)\n", + "print('components:', [np.allclose(pca.components_[i,:], -v[:,i]) or\n", + " np.allclose(pca.components_[i,:], v[:,i])\n", + " for i in range(k)])\n", + "\n", + "\n", + "# assert: covariance matrix == loadings.T @ loadings\n", + "loadings = np.diag(pca.singular_values_) @ pca.components_\n", + "print('covariance matrix:', np.allclose(x.T @ x, loadings.T @ loadings))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Projection on first component, and average \"market\" factor" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
frac weights +vesum weightssum abs weightscorr with eql-wtd market returns
PC10.000000-6.8380026.838002-0.998898
PC20.2448980.0983634.1204750.004852
PC30.4285710.1472793.6134180.005724
PC40.326531-0.9331995.192985-0.035033
\n", + "
" + ], + "text/plain": [ + " frac weights +ve sum weights sum abs weights \\\n", + "PC1 0.000000 -6.838002 6.838002 \n", + "PC2 0.244898 0.098363 4.120475 \n", + "PC3 0.428571 0.147279 3.613418 \n", + "PC4 0.326531 -0.933199 5.192985 \n", + "\n", + " corr with eql-wtd market returns \n", + "PC1 -0.998898 \n", + "PC2 0.004852 \n", + "PC3 0.005724 \n", + "PC4 -0.035033 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = pca.components_\n", + "top_k = 4\n", + "DataFrame({'frac weights +ve': np.mean(t[:top_k, :] >= 0, axis=1),\n", + " 'sum weights': np.sum(t[:top_k, :], axis=1),\n", + " 'sum abs weights': np.sum(np.abs(t[:top_k, :]), axis=1),\n", + " 'corr with eql-wtd market returns':\n", + " [np.corrcoef(x.mean(axis=1), y[:,i])[0,1]\n", + " for i in range(top_k)]},\n", + " index=[f\"PC{i+1}\" for i in range(top_k)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot components/portfolio weights distribution " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows=1, ncols=3, num=1, clear=True, figsize=(10, 4))\n", + "for i, ax in enumerate(np.ravel(axes)):\n", + " ax.bar(np.arange(t.shape[1]),\n", + " np.sort(t[i, :]),\n", + " color=f\"C{i}\")\n", + " ax.legend([f\"Weights (Loadings) on PC{i+1}\"], fontsize=6)\n", + "plt.tight_layout(pad=0)\n", + "plt.savefig(imgdir / 'weights.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Scree Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, num=1, clear=True, figsize=(5,3))\n", + "k=10\n", + "plot_bar(Series(pca.explained_variance_ratio_[:k],\n", + " index=np.arange(1, k+1)),\n", + " ylabel='Explained Variance Ratio',\n", + " xlabel=\"Component\",\n", + " legend=None,\n", + " title='Scree Plot',\n", + " ax=ax,\n", + " fontsize=8,\n", + " labels=[f\"{i:.3f}\" for i in pca.explained_variance_ratio_[:k]])\n", + "plt.tight_layout(pad=1)\n", + "plt.savefig(imgdir / 'explained.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate rolling GMV portfolio volatility: shrinkage, PCA, EWMA" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Helper to compute EWMA covariance matrix estimate\n", + "def ewma(X, alpha=0.03, demean=False):\n", + " weights = (1 - alpha)**np.arange(len(X))[::-1]\n", + " if demean:\n", + " X = X - X.mean(axis=0, keepdims=True)\n", + " return (weights.reshape((1, -1)) * X.T) @ X / weights.sum()\n", + "\n", + "\n", + "# Helper method to compute Minimum Variance Portfolio and realized volatility\n", + "def gmv(cov, ret):\n", + " \"\"\"Compute minimum variance portfolio and realized volatility\"\"\"\n", + " w = np.linalg.inv(cov) @ np.ones((cov.shape[1], 1))\n", + " return ret @ w/sum(w)\n", + "\n", + "\n", + "# Rolling monthly evaluation\n", + "r = {} # collect results of covariance matrix models\n", + "start_eval = 20000101\n", + "for retdate in tqdm(df.index[(df.index >= start_eval)]):\n", + " x_train = Y[df.index < retdate, :]\n", + " x_test = Y[df.index == retdate, :]\n", + " keep = 5 * 12 # keep five years\n", + " N = x_train.shape[1]\n", + " r[retdate] = {}\n", + "\n", + " cov = EmpiricalCovariance().fit(x_train[-keep:, :]).covariance_\n", + " \n", + " r[retdate]['Full Covariance'] = float(gmv(cov, x_test))\n", + "\n", + " for alpha in [0.1, 0.06, 0.03, 0.01, 0.003]:\n", + " r[retdate][f'EWMA({halflife(alpha=alpha):.0f}mo)'] = \\\n", + " float(gmv(ewma(x_train, alpha=alpha), x_test))\n", + "\n", + " r[retdate]['Eye'] = float(gmv(np.identity(x_train.shape[1]), x_test))\n", + "\n", + " r[retdate]['Diagonal'] = float(gmv(np.diagflat(np.diag(cov)), x_test))\n", + "\n", + " for k in [2, 5, 10, 15, 20]:\n", + " r[retdate][f\"PC 1-{k}\"] = float(gmv(PCA(k).fit(x_train[-keep:, :])\\\n", + " .get_covariance(), x_test))\n", + "\n", + " r[retdate]['LW'] = float(gmv(LedoitWolf().fit(x_train[-keep:, :])\\\n", + " .covariance_, x_test))\n", + " \n", + " r[retdate]['OAS'] = float(gmv(OAS().fit(x_train[-keep:, :])\\\n", + " .covariance_, x_test))\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0
Realized volatility of minimum variance portfolios
Full Covariance0.0644
EWMA(7mo)0.0645
EWMA(11mo)0.0503
EWMA(23mo)0.0401
EWMA(69mo)0.0350
EWMA(231mo)0.0355
Eye0.0485
Diagonal0.0434
PC 1-20.0365
PC 1-50.0356
PC 1-100.0368
PC 1-150.0366
PC 1-200.0380
LW0.0342
OAS0.0352
\n", + "
" + ], + "text/plain": [ + " 0\n", + "Realized volatility of minimum variance portfolios \n", + "Full Covariance 0.0644\n", + "EWMA(7mo) 0.0645\n", + "EWMA(11mo) 0.0503\n", + "EWMA(23mo) 0.0401\n", + "EWMA(69mo) 0.0350\n", + "EWMA(231mo) 0.0355\n", + "Eye 0.0485\n", + "Diagonal 0.0434\n", + "PC 1-2 0.0365\n", + "PC 1-5 0.0356\n", + "PC 1-10 0.0368\n", + "PC 1-15 0.0366\n", + "PC 1-20 0.0380\n", + "LW 0.0342\n", + "OAS 0.0352" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts = DataFrame.from_dict(r, orient='index')\n", + "vol = np.std(ts, axis=0)\n", + "show(vol, caption='Realized volatility of minimum variance portfolios', **SHOW)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot evaluation period realized volatility of minimum variance portfolios" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, num=1, clear=True, figsize=(10, 5))\n", + "plot_bar(vol,\n", + " ylabel='Volatility',\n", + " xlabel='Risk Model',\n", + " title='Test Period Volatility of Minimum Variance Portfolios',\n", + " labels=[f\"{v:.4f}\" for v in vol],\n", + " legend='',\n", + " fontsize=6,\n", + " ax=ax)\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / 'gmv.jpg')\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# 4. Newey-west, Scholes Williams Beta\n", + "# 1/T \\sum_t e_t^2 + 2/T \\sum_L \\sum_T w_l e_t e_t-l: w_l = 1-(l/(L+1))\n", + "#\n", + "# 5. Risk Decomposition: MCR, BL equilibrium, Risk Parity\n", + "# u.T @ x = beta, since u is standardized (orthogonal) factor returns\n", + "# u @ beta = stock's return due to orthogonal component\n", + "# (u @ beta)*2 = variation of stock returns due to orthogonal component" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/elman_kalman.ipynb b/elman_kalman.ipynb new file mode 100644 index 0000000..5259757 --- /dev/null +++ b/elman_kalman.ipynb @@ -0,0 +1,1433 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Recurrent Neural Networks and Linear Dynamic Factor Models\n", + "\n", + "- Long Short Term Memory (LSTM) RNN, Kalman Filter, Mixed Frequency\n", + "\n", + "Copyright 2023, Terence Lim\n", + "\n", + "MIT License" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import DataFrame, Series\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import time\n", + "from datetime import datetime\n", + "import statsmodels.api as sm\n", + "import random\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "from sklearn.preprocessing import StandardScaler\n", + "from tqdm import tqdm\n", + "from finds.alfred import fred_md, fred_qd, Alfred\n", + "from finds.display import show\n", + "from conf import VERBOSE, paths, credentials\n", + "\n", + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(ndigits=4, latex=None)\n", + "\n", + "imgdir = paths['images'] / 'states'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load and pre-process time series from FRED" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "alf = Alfred(api_key=credentials['fred']['api_key'])\n", + "vspans = alf.date_spans('USREC') # to indicate recession periods in the plots\n", + "beg = 19600301\n", + "end = 20200131\n", + "# TODO: end = train up to MINUS two quarters, forecast through current" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieve FRED-MD series and apply tcode transformations" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
RPIW875RX1DPCERA3M086SBEACMRMTSPLRETAILINDPROIPFPNSSIPFINALIPCONGDIPDCONGD...DDURRG3M086SBEADNDGRG3M086SBEADSERRG3M086SBEACES0600000008CES2000000008CES3000000008MZMSLDTCOLNVHFNMDTCTHFNMINVEST
1960-03-31-0.134881-0.2757712.216461-2.860458-0.488916-1.494126-0.747423-0.399146-0.045307-1.035927...-1.4698200.295721-0.643390-0.0037713.306562-1.0103610.3169370.1425840.0474430.324377
1960-04-300.1406050.2032782.4710890.7187741.808191-1.3517440.044685-0.1096360.617368-0.158355...1.3299450.7351100.960469-2.253155-7.4671900.001676-0.1939350.3560250.2697942.267079
1960-05-31-0.045275-0.004559-4.482796-3.197753-1.675079-0.4326460.5164090.6127680.4805660.339132...-0.418471-1.1135420.3160952.2557464.5669010.0016760.188096-0.197676-0.1016550.353369
1960-06-30-0.338482-0.482476-0.5595400.602494-0.511228-1.983791-1.854133-1.702628-0.970468-0.600344...-0.8495200.036686-0.482642-1.125930-1.2528250.0016760.1865210.2104010.367009-0.943151
1960-07-31-0.148985-0.100803-0.122954-0.860250-1.254201-0.747608-1.070579-0.984785-1.243071-1.916083...0.9183600.3027680.4213781.1235000.8289460.0016760.247264-0.447705-0.1621113.023607
..................................................................
2019-09-30-0.079715-0.081618-0.174630-0.239203-0.752893-0.747932-1.076215-1.247348-0.984334-1.453438...-0.071819-0.163996-0.071125-0.204290-0.3074190.0983700.138877-0.163879-0.2818420.375870
2019-10-31-0.598714-0.639323-0.385917-0.656535-0.108856-0.828301-0.648297-0.596663-0.251664-1.417370...0.0740421.2673150.290075-0.2025660.0006370.0009780.5223650.0804820.200078-1.320725
2019-11-300.2023760.355149-0.0575310.283946-0.2179450.9832661.6868872.0541742.1283292.857134...-0.704147-0.295116-0.421273-0.201345-0.0375540.484033-0.370009-0.095845-0.0561030.600435
2019-12-31-0.644414-0.535997-0.324231-0.230203-0.374542-0.815438-1.127034-1.336095-1.517772-1.297690...-0.2393850.5225181.1934640.6046090.457551-0.386623-0.7676870.2460580.036262-0.996952
2020-01-310.203651-0.0633440.0488760.2506120.246743-0.934552-1.599474-2.152708-1.3603950.204324...1.763764-0.802817-0.654722-0.703859-0.456666-0.6729610.661603-0.219878-0.0783930.361933
\n", + "

719 rows × 123 columns

\n", + "
" + ], + "text/plain": [ + " RPI W875RX1 DPCERA3M086SBEA CMRMTSPL RETAIL INDPRO \\\n", + "1960-03-31 -0.134881 -0.275771 2.216461 -2.860458 -0.488916 -1.494126 \n", + "1960-04-30 0.140605 0.203278 2.471089 0.718774 1.808191 -1.351744 \n", + "1960-05-31 -0.045275 -0.004559 -4.482796 -3.197753 -1.675079 -0.432646 \n", + "1960-06-30 -0.338482 -0.482476 -0.559540 0.602494 -0.511228 -1.983791 \n", + "1960-07-31 -0.148985 -0.100803 -0.122954 -0.860250 -1.254201 -0.747608 \n", + "... ... ... ... ... ... ... \n", + "2019-09-30 -0.079715 -0.081618 -0.174630 -0.239203 -0.752893 -0.747932 \n", + "2019-10-31 -0.598714 -0.639323 -0.385917 -0.656535 -0.108856 -0.828301 \n", + "2019-11-30 0.202376 0.355149 -0.057531 0.283946 -0.217945 0.983266 \n", + "2019-12-31 -0.644414 -0.535997 -0.324231 -0.230203 -0.374542 -0.815438 \n", + "2020-01-31 0.203651 -0.063344 0.048876 0.250612 0.246743 -0.934552 \n", + "\n", + " IPFPNSS IPFINAL IPCONGD IPDCONGD ... DDURRG3M086SBEA \\\n", + "1960-03-31 -0.747423 -0.399146 -0.045307 -1.035927 ... -1.469820 \n", + "1960-04-30 0.044685 -0.109636 0.617368 -0.158355 ... 1.329945 \n", + "1960-05-31 0.516409 0.612768 0.480566 0.339132 ... -0.418471 \n", + "1960-06-30 -1.854133 -1.702628 -0.970468 -0.600344 ... -0.849520 \n", + "1960-07-31 -1.070579 -0.984785 -1.243071 -1.916083 ... 0.918360 \n", + "... ... ... ... ... ... ... \n", + "2019-09-30 -1.076215 -1.247348 -0.984334 -1.453438 ... -0.071819 \n", + "2019-10-31 -0.648297 -0.596663 -0.251664 -1.417370 ... 0.074042 \n", + "2019-11-30 1.686887 2.054174 2.128329 2.857134 ... -0.704147 \n", + "2019-12-31 -1.127034 -1.336095 -1.517772 -1.297690 ... -0.239385 \n", + "2020-01-31 -1.599474 -2.152708 -1.360395 0.204324 ... 1.763764 \n", + "\n", + " DNDGRG3M086SBEA DSERRG3M086SBEA CES0600000008 CES2000000008 \\\n", + "1960-03-31 0.295721 -0.643390 -0.003771 3.306562 \n", + "1960-04-30 0.735110 0.960469 -2.253155 -7.467190 \n", + "1960-05-31 -1.113542 0.316095 2.255746 4.566901 \n", + "1960-06-30 0.036686 -0.482642 -1.125930 -1.252825 \n", + "1960-07-31 0.302768 0.421378 1.123500 0.828946 \n", + "... ... ... ... ... \n", + "2019-09-30 -0.163996 -0.071125 -0.204290 -0.307419 \n", + "2019-10-31 1.267315 0.290075 -0.202566 0.000637 \n", + "2019-11-30 -0.295116 -0.421273 -0.201345 -0.037554 \n", + "2019-12-31 0.522518 1.193464 0.604609 0.457551 \n", + "2020-01-31 -0.802817 -0.654722 -0.703859 -0.456666 \n", + "\n", + " CES3000000008 MZMSL DTCOLNVHFNM DTCTHFNM INVEST \n", + "1960-03-31 -1.010361 0.316937 0.142584 0.047443 0.324377 \n", + "1960-04-30 0.001676 -0.193935 0.356025 0.269794 2.267079 \n", + "1960-05-31 0.001676 0.188096 -0.197676 -0.101655 0.353369 \n", + "1960-06-30 0.001676 0.186521 0.210401 0.367009 -0.943151 \n", + "1960-07-31 0.001676 0.247264 -0.447705 -0.162111 3.023607 \n", + "... ... ... ... ... ... \n", + "2019-09-30 0.098370 0.138877 -0.163879 -0.281842 0.375870 \n", + "2019-10-31 0.000978 0.522365 0.080482 0.200078 -1.320725 \n", + "2019-11-30 0.484033 -0.370009 -0.095845 -0.056103 0.600435 \n", + "2019-12-31 -0.386623 -0.767687 0.246058 0.036262 -0.996952 \n", + "2020-01-31 -0.672961 0.661603 -0.219878 -0.078393 0.361933 \n", + "\n", + "[719 rows x 123 columns]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df, t = fred_md(202004) # from vintage April 2020?\n", + "data = []\n", + "for col in df.columns:\n", + " data.append(alf.transform(df[col], tcode=t['transform'][col], freq='m'))\n", + "mdf = pd.concat(data, axis=1).iloc[2:]\n", + "mdata = mdf[(mdf.index >= beg) & (mdf.index <= end)].dropna(axis=1)\n", + "mdata = (mdata - mdata.mean(axis=0)) / mdata.std(axis=0, ddof=0)\n", + "mdata.index = pd.DatetimeIndex(mdata.index.astype(str), freq='m')\n", + "mdata" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieve FRED-QD series and apply tcode transformations" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GDPC1PCECC96PCDGPCESVPCNDGPDIC1FPIY033RC1Q027SBEAPNFIPRFI...TLBSNNBTLBSNNBBDITABSNNBTNWBSNNBTNWBSNNBBDICNCFS&P 500S&P: industS&P div yieldS&P PE ratio
1960-03-310.0222240.0095210.0316660.0090430.0025060.0957880.0328560.0342000.0341660.030306...0.037652279155.400.0091830.00430886.68-0.051251-0.026073-0.0298960.2278-0.057371
1960-06-30-0.0054080.0125350.0225010.0110030.010896-0.097837-0.0183420.0167110.014503-0.085422...0.018321280144.950.0030570.000375-22.940.014782-0.003680-0.0067780.0876-0.024349
1960-09-300.004881-0.004005-0.008030-0.001174-0.005880-0.002544-0.021666-0.044133-0.017656-0.030290...0.018804275164.710.0079520.006017-47.830.036742-0.006262-0.0122850.02760.001369
1960-12-31-0.0129170.001294-0.0254500.0096250.000690-0.117411-0.001999-0.035770-0.002352-0.001084...-0.005096273738.350.0038430.0054408.200.000101-0.006964-0.0065690.02570.000796
1961-03-310.006728-0.000372-0.0565410.0097980.0059510.025621-0.008523-0.033095-0.0143720.003940...0.038024291545.950.0092000.00399445.35-0.0250010.1138130.111342-0.38890.128986
..................................................................
2018-12-310.0027100.0035650.0031550.0034440.0042080.0073900.0065610.0177700.011718-0.011973...0.021630398935.930.0137400.00857612.73-0.012680-0.057381-0.0583070.1617-0.098323
2019-03-310.0076230.0028290.0006390.0024160.0053310.0149370.007913-0.0002450.010812-0.002634...0.014793399732.210.0161810.0170952.610.0127990.0111110.0116860.0233-0.033627
2019-06-300.0049850.0111350.0305720.0068460.015664-0.016345-0.0036000.002076-0.002531-0.007507...0.004232392693.840.0115500.016331-3.440.0219960.0573990.059265-0.07310.013658
2019-09-300.0052040.0077500.0194670.0054290.009520-0.002477-0.002080-0.009578-0.0057770.011351...0.012694388971.840.0138070.014530-4.630.0222180.0259180.025926-0.01060.004248
2019-12-310.0052610.0045350.0068050.005952-0.001400-0.015571-0.001371-0.010886-0.0061890.015724...0.012437389233.630.0056090.001158-6.330.0117640.0423070.041578-0.04450.035413
\n", + "

240 rows × 211 columns

\n", + "
" + ], + "text/plain": [ + " GDPC1 PCECC96 PCDG PCESV PCND GPDIC1 \\\n", + "1960-03-31 0.022224 0.009521 0.031666 0.009043 0.002506 0.095788 \n", + "1960-06-30 -0.005408 0.012535 0.022501 0.011003 0.010896 -0.097837 \n", + "1960-09-30 0.004881 -0.004005 -0.008030 -0.001174 -0.005880 -0.002544 \n", + "1960-12-31 -0.012917 0.001294 -0.025450 0.009625 0.000690 -0.117411 \n", + "1961-03-31 0.006728 -0.000372 -0.056541 0.009798 0.005951 0.025621 \n", + "... ... ... ... ... ... ... \n", + "2018-12-31 0.002710 0.003565 0.003155 0.003444 0.004208 0.007390 \n", + "2019-03-31 0.007623 0.002829 0.000639 0.002416 0.005331 0.014937 \n", + "2019-06-30 0.004985 0.011135 0.030572 0.006846 0.015664 -0.016345 \n", + "2019-09-30 0.005204 0.007750 0.019467 0.005429 0.009520 -0.002477 \n", + "2019-12-31 0.005261 0.004535 0.006805 0.005952 -0.001400 -0.015571 \n", + "\n", + " FPI Y033RC1Q027SBEA PNFI PRFI ... TLBSNNB \\\n", + "1960-03-31 0.032856 0.034200 0.034166 0.030306 ... 0.037652 \n", + "1960-06-30 -0.018342 0.016711 0.014503 -0.085422 ... 0.018321 \n", + "1960-09-30 -0.021666 -0.044133 -0.017656 -0.030290 ... 0.018804 \n", + "1960-12-31 -0.001999 -0.035770 -0.002352 -0.001084 ... -0.005096 \n", + "1961-03-31 -0.008523 -0.033095 -0.014372 0.003940 ... 0.038024 \n", + "... ... ... ... ... ... ... \n", + "2018-12-31 0.006561 0.017770 0.011718 -0.011973 ... 0.021630 \n", + "2019-03-31 0.007913 -0.000245 0.010812 -0.002634 ... 0.014793 \n", + "2019-06-30 -0.003600 0.002076 -0.002531 -0.007507 ... 0.004232 \n", + "2019-09-30 -0.002080 -0.009578 -0.005777 0.011351 ... 0.012694 \n", + "2019-12-31 -0.001371 -0.010886 -0.006189 0.015724 ... 0.012437 \n", + "\n", + " TLBSNNBBDI TABSNNB TNWBSNNB TNWBSNNBBDI CNCF S&P 500 \\\n", + "1960-03-31 279155.40 0.009183 0.004308 86.68 -0.051251 -0.026073 \n", + "1960-06-30 280144.95 0.003057 0.000375 -22.94 0.014782 -0.003680 \n", + "1960-09-30 275164.71 0.007952 0.006017 -47.83 0.036742 -0.006262 \n", + "1960-12-31 273738.35 0.003843 0.005440 8.20 0.000101 -0.006964 \n", + "1961-03-31 291545.95 0.009200 0.003994 45.35 -0.025001 0.113813 \n", + "... ... ... ... ... ... ... \n", + "2018-12-31 398935.93 0.013740 0.008576 12.73 -0.012680 -0.057381 \n", + "2019-03-31 399732.21 0.016181 0.017095 2.61 0.012799 0.011111 \n", + "2019-06-30 392693.84 0.011550 0.016331 -3.44 0.021996 0.057399 \n", + "2019-09-30 388971.84 0.013807 0.014530 -4.63 0.022218 0.025918 \n", + "2019-12-31 389233.63 0.005609 0.001158 -6.33 0.011764 0.042307 \n", + "\n", + " S&P: indust S&P div yield S&P PE ratio \n", + "1960-03-31 -0.029896 0.2278 -0.057371 \n", + "1960-06-30 -0.006778 0.0876 -0.024349 \n", + "1960-09-30 -0.012285 0.0276 0.001369 \n", + "1960-12-31 -0.006569 0.0257 0.000796 \n", + "1961-03-31 0.111342 -0.3889 0.128986 \n", + "... ... ... ... \n", + "2018-12-31 -0.058307 0.1617 -0.098323 \n", + "2019-03-31 0.011686 0.0233 -0.033627 \n", + "2019-06-30 0.059265 -0.0731 0.013658 \n", + "2019-09-30 0.025926 -0.0106 0.004248 \n", + "2019-12-31 0.041578 -0.0445 0.035413 \n", + "\n", + "[240 rows x 211 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df, t = fred_qd(202004) # from vintage April 2020\n", + "data = []\n", + "for col in df.columns:\n", + " data.append(alf.transform(df[col], tcode=t['transform'][col], freq='q'))\n", + "df = pd.concat(data, axis=1).iloc[2:]\n", + "qdata = df[(df.index >= beg) & (df.index <= end)].dropna(axis=1)\n", + "qdata.index = pd.DatetimeIndex(qdata.index.astype(str), freq='q')\n", + "qdata" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## LSTM in pytorch for time series" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "class LSTM(nn.Module):\n", + " def __init__(self, n_features, hidden_size, num_layers=1):\n", + " super().__init__()\n", + " self.lstm = nn.LSTM(input_size=n_features,\n", + " hidden_size=hidden_size,\n", + " num_layers=num_layers)\n", + " self.linear = nn.Linear(in_features=hidden_size,\n", + " out_features=n_features)\n", + "\n", + " def forward(self, x, hidden_state=None):\n", + " \"\"\"\n", + " x: shape (seq_len, batch, input_siz)\n", + " h: of shape (num_layers * num_directions, batch, hidden_size)\n", + " c: of shape (num_layers * num_directions, batch, hidden_size)\n", + " output: shape (seq_len, batch, num_directions * hidden_size)\n", + " \"\"\"\n", + " output, (h, c) = self.lstm(x, hidden_state)\n", + " return self.linear(output), (h.detach(), c.detach())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create input data for LSTM, with sequence length 16 (months)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "seq_len = 16\n", + "train_exs = [mdata.iloc[i-(seq_len+1):i].values\n", + " for i in range(seq_len+1, len(mdata))]\n", + "n_features = mdata.shape[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train LSTM" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LSTM(\n", + " (lstm): LSTM(123, 1)\n", + " (linear): Linear(in_features=1, out_features=123, bias=True)\n", + ")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 1200/1200 [00:39<00:00, 30.30it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Hidden Size 1': 0.8990438811459772}\n", + "LSTM(\n", + " (lstm): LSTM(123, 2)\n", + " (linear): Linear(in_features=2, out_features=123, bias=True)\n", + ")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 1200/1200 [00:39<00:00, 30.45it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Hidden Size 1': 0.8990438811459772, 'Hidden Size 2': 0.8105732301658715}\n", + "LSTM(\n", + " (lstm): LSTM(123, 3)\n", + " (linear): Linear(in_features=3, out_features=123, bias=True)\n", + ")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 1200/1200 [00:40<00:00, 29.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Hidden Size 1': 0.8990438811459772, 'Hidden Size 2': 0.8105732301658715, 'Hidden Size 3': 0.7568852641219087}\n", + "LSTM(\n", + " (lstm): LSTM(123, 4)\n", + " (linear): Linear(in_features=4, out_features=123, bias=True)\n", + ")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 1200/1200 [00:39<00:00, 30.17it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Hidden Size 1': 0.8990438811459772, 'Hidden Size 2': 0.8105732301658715, 'Hidden Size 3': 0.7568852641219087, 'Hidden Size 4': 0.7138534036074948}\n" + ] + } + ], + "source": [ + "hidden_factors = dict()\n", + "prediction_errors = dict()\n", + "for hidden_size in [1, 2, 3, 4]:\n", + " model = LSTM(n_features=n_features,\n", + " hidden_size=hidden_size).to(device)\n", + " print(model)\n", + "\n", + " # Set optimizer and learning rate scheduler, with step_size=30\n", + " lr, num_lr, step_size = 0.001, 3, 400\n", + " optimizer = torch.optim.Adam(model.parameters(),\n", + " lr=lr)\n", + " scheduler = torch.optim.lr_scheduler.StepLR(optimizer,\n", + " step_size=step_size,\n", + " gamma=0.1)\n", + " loss_function = nn.MSELoss()\n", + "\n", + " batch_size, num_epochs = 32, step_size*num_lr\n", + " for i in tqdm(range(num_epochs)): # Run training loop per epoch\n", + " idx = np.arange(len(train_exs)) # shuffle indxs into batches\n", + " random.shuffle(idx)\n", + " batches = [idx[i:(i+batch_size)] for i in range(0,len(idx),batch_size)]\n", + " total_loss = 0.0 \n", + " model.train() \n", + " for batch in batches: # train each batch\n", + " # train_ex input has shape (seq_len, batch_size=16, n_features)\n", + " nparray = np.array([[train_exs[idx][seq] for idx in batch]\n", + " for seq in range(seq_len+1)])\n", + " train_ex = torch.tensor(nparray).float()\n", + " model.zero_grad()\n", + " y_pred, hidden_state = model.forward(train_ex[:-1].to(device))\n", + " loss = loss_function(y_pred[-1],\n", + " train_ex[-1].to(device))\n", + " total_loss += float(loss)\n", + " loss.backward()\n", + " optimizer.step()\n", + " scheduler.step()\n", + "\n", + " # collect predictions and hidden states, and compute mse\n", + " with torch.no_grad(): # reduce memory consumption for eval\n", + " hidden_state = []\n", + " prediction_error = []\n", + " mse = nn.MSELoss()\n", + " for i in range(seq_len+1, len(mdata)):\n", + " # single test example shaped (seq_len=12, batch_size=1, n_features)\n", + " test_ex = torch.tensor(mdata[i-(seq_len+1):i].values)\\\n", + " .float()\\\n", + " .unsqueeze(dim=1)\\\n", + " .to(device)\n", + " y_pred, (h, c) = model.forward(test_ex[:-1], None)\n", + " prediction_error.append(float(mse(y_pred[-1], test_ex[-1])))\n", + " hidden_state.append(h[0][0].cpu().numpy())\n", + " hidden_factors[hidden_size] = DataFrame(hidden_state,\n", + " index=mdata.index\\\n", + " [(1+seq_len):len(mdata)])\n", + " prediction_errors[f\"Hidden Size {hidden_size}\"] = np.mean(prediction_error)\n", + " print(prediction_errors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot LSTM hidden states sequence" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAn8AAAKvCAYAAAAbcKnUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOyddXhcZdqH73c87l5N3ZW60ZbS4rC4Oyy22McCi7PoLrAs7rpIcWkptFSoUfc0aZsmaePuyej5/jiSmWTiqZ/7uno1M3PmzJkz57zv8z7ye4QkSejo6Ojo6Ojo6JwYGI70Aejo6Ojo6Ojo6Bw+dONPR0dHR0dHR+cEQjf+dHR0dHR0dHROIHTjT0dHR0dHR0fnBEI3/nR0dHR0dHR0TiB0409HR0dHR0dH5wRCN/50dHQOKUKIqUKItBZe/1AI8c8WXpeEEH0PzdHp6OjonHjoxp+OzjGGECJTCDG7mdceFEJkCCGqhRDZQogvled3Kc9VCyHcQoh6r8cPCiGuVoyslxrt72zl+Q+b+bwZQohsP88vF0JcDyBJ0kpJkgZ0+ot3MUKIIUKI34QQpUKIciHEJiHEacprfr9XK/s7JEaqYhw7lN+qVAixWAgxsKs/R0dH58RBN/50dI4ThBBXAVcAsyVJCgbGAr8DSJI0RJKkYOX5lcBt6mNJkp5WdpEOXCiEMHnt9ipgz+H7FoeVn4DFQDwQC9wBVB7RI2qe55XfrhtQCHzYeAMho4/pOjo6raIPFDo6xw8nAb9KkpQOIElSviRJb7fj/fnADuBUACFEJDAJ+LEzB9XYiyaEGCWE2CyEqFI8k7ZG2/+fECJPCJErhLi20WtWIcS/hRAHhBAFQog3hRAB3p8jhLhHCFGo7OOaZo4pGugNvCNJkkP5t1qSpFVCiCDgFyDRyzuaKIQYJ4RYq3gJ84QQrwohLMr+/lB2vU3Z/iLl+TOEEFuV96wRQgz3Ooa/CyFylPOQJoSY1dq5lCSpFvgMGKrsY7kQ4ikhxGqgFkgWQkwSQmwQQlQo/0/y+sxIIcQHyrktE0J87/Vau49VOScbhRCVyu/xYmvfQUdH58ijG386OscPfwJXKsbTWCGEsQP7+Bi4Uvn7YuAHwN5VB6gYS98DnwCRwFfAX7xenwvcC5wC9AMah7efBfoDI4G+QBLwiNfr8UCY8vx1wGtCiAg/h1IC7AM+FUKcI4SIU1+QJKkGmAfkenlHcwE3cBcQDUwEZgG3KO+Zprx9hLL9l0KIUcD7wE1AFPAW8KNiwA4AbgNOkiQpBNngzmzD+QsGLgO2eD19BXAjEAJUAQuA/yqf+SKwQAgRpWz7CRAIDEH2dr6k7Lejx/oy8LIkSaFAH2B+a99BR0fnyKMbfzo6xwmSJH0K3I48Oa8ACoUQf2/nbr4DZgghwpCNwI/b8J5ExVuk/QOmNLPtBMAM/EeSJKckSV8DG7xevxD4QJKknYoR9pj6ghBCIBs5d0mSVCpJUhXwNLKRquIEnlD2vRCoBprkG0pyU/OTkY2YF4A8IcQfQoh+zX1JSZI2SZL0pyRJLkmSMpENpOnNnxZuBN6SJGmdJEluSZI+QjakJyAbklZgsBDCLElSpuqxbYZ7lfO6DwgGrvZ67UNJknZJkuQC5gB7JUn6RDnOz4FU4EwhRAKyUXuzJEllyjla0cljdQJ9hRDRkiRVS5L0ZwvfQUdH5yhBN/50dI4jJEn6nyRJs4Fw4GbgSSHEqe14fx2y5+ghIEqSpNVteFuuJEnh3v+AVc1smwjkKMaXSlaj1w8281oMstdqk5eRuUh5XqVEMYJUapGNpSZIkpQtSdJtkiT1AXoCNbRg7Aoh+gshfhZC5AshKpENz+jmtlf2eU8jo7g7kChJ0j7gTmTjtlAI8YUQIrGFff1bObfxkiSd1chQ9D5fifieM5THScpnl0qSVNaFx3odsic2VQkxn9HCd9DR0TlK0I0/HZ3jEMWr8xWwHSU/rB18DNwDfNrlBwZ5QJLixVPp0ej17s28VgzUAUO8DM0wpRCiU0iSdBB4jYZzJfnZ7A1kL1o/Jcz5ICD8bKdyEHiqkWEcqHjjkCTpM0mSpiAbXhLwXEcP3+vvXGV/3vQAcpTjiRRChHfVsUqStFeSpEuQQ8jPAV8rOZM6OjpHMbrxp6NzbGIWQti8/pmELNdyuhAiRAhhEELMQ87tWtfOfa9Azrl7pcuPGtYCLuAOIYRZCHEeMM7r9fnA1UKIwUKIQOBR9QVJkjzAO8BLQohYACFEUns8mypCiAghxONCiL7KuYoGrkXOmwQoAKKU8LdKCHI1cLWQpVb+2mi3BUCy1+N3gJuFEOOFTJDX7zNACDFTCGEF6pGNWk97v4cfFgL9hRCXKtfERcBg4GdJkvKQC1leV76/WQih5ip26FiFEJcLIWKU36Zc2VdXfA8dHZ1DiG786egcmyxEnoTVf48hGyYPAgeQJ+Lngb9KktRcCNYvkszvkiSVduUBK/t2AOch56yVAhcB33q9/gvwH2Apcn7b0ka7+Lvy/J9K6HUJfnL62oAD6KW8vxLYiZzjdrVyHKnA58B+JQyaiFyIcilyUcU7wJeN9vkY8JGy/YWSJG0EbgBeBcqU475a2daKXLxSjFxlHQs80IHv4YMkSSXAGcie2xLgPuAMSZKKlU2uQM7TS0WWjLlTeV9Hj3UusEsIUY1c/HGxkjqgo6NzFCN8U290dHR0dHR0dHSOZ3TPn46Ojo6Ojo7OCYRu/Ono6Ojo6OjonEDoxp+Ojo6Ojo6OzgmEbvzp6Ojo6Ojo6JxA6Mafjo6Ojo6Ojs4JhG786ejo6Ojo6OicQOjGn46Ojo6Ojo7OCYRu/Ono6Ojo6OjonEDoxp+Ojo6Ojo6OzgmEbvzp6Ojo6Ojo6JxA6Mafjo6Ojo6Ojs4JhG786ejo6Ojo6OicQOjGn46Ojo6Ojo7OCYRu/Ono6Ojo6OjonEDoxp+Ojo6Ojo6OzgmEbvzp6Ojo6Ojo6JxA6Mafjo6Ojo6Ojs4JhG786ejo6Ojo6OicQOjGn46Ojo6Ojo7OCYRu/Ono6Ojo6OjonEDoxp+Ojo6Ojo6OzgmE6UgfQHPMnTtXWrRo0ZE+jOOKHdkVrW4zrFvYYTiSprTl2PxxpI63K/H33dv6vTpy3o6Hc3YkaOlc6+f06EP/vXzp6BgLJ+b5OsYRrW1w1Hr+iouLj/Qh6Ojo6Ojo6Ogcd3SJ8SeEeF8IUSiE2NnM60II8V8hxD4hxHYhxOiu+FwdHR0dHR0dHZ320VWevw+BuS28Pg/op/y7EXijiz5XR0dHR0dHR0enHXSJ8SdJ0h9AaQubnA18LMn8CYQLIRK64rN1jg1Kaxy43J4jfRiHHbvLjSRJR/owdHR0dHR0NA5Xzl8ScNDrcbbynA9CiBuFEBuFEBuLiooO06HpHAokSSK/ol57/O3mbP76v82aIeRweXhqQQq3/G8TewuqjtRhdprCqnoufHMtKbmVTV5bsaeIAQ8tYt7LK4/Akeno6Ojo6PjnqCr4kCTpbUmSxkqSNDYmJuZIH45OG/h1Vz7ltY4mzy/YkceEZ35nfYbsEDYaBItTCrjh443cM38b+4urmb8xm4U78vlqU/bhPuwuoaLWyeM/pbA+s5Qluwu05+udbtweiaySGgBS849d41ZHR0dH5/jjcBl/OUB3r8fdlOd0jmGySmq46ZNNPPDtDu25f/2ayrebs9mUVQbAgu253PDxRgItRkwGwZLdhXyzORuDECy7dwZDk0LZndfUa3ak8Xgk/v1rGjd8vBFnM+HqK95fx4LteQDEhFi15wc+vIi/fbEFu1N+36uXjjr0B6yjo6Ojo9NGDpfx9yNwpVL1OwGokCQp7zB9ts4hIr2oGoDIIIv23GvL0rl7/jbunTOA6GALi1MKWJxSQH6Fne6Rgdp2dQ43kUEWBsWHsjvv6POMrc8s5dVl+wi2mnB7/OfsXTa+B8+eN4zdT8zlknE9AKixuwD4eXseQVYTPaMCOWVw3GE7bh0dnWOTGruLZ37ZTb3TfaQPRecEoEtEnoUQnwMzgGghRDbwKGAGkCTpTWAhcBqwD6gFrumKz9U5sqjhzPvmDuTZX1J5c0U6ANP6xxBkNXHTtD48tXA3AJFBZnpHB5FRLIdCz35tNZdP6MHEPlFU1btwuDxYTEdPFoIayr5+am9sZiMv/pbG0KQwpg+IwWQwsCu3gtmD4ogKtvq8z+6SvX1Wk4FLx8vfb3laEacMisNgaFV3U0dH5wTl1WX7eGvFfrqFB3DFxF5H+nB0jnO6qtr3EkmSEiRJMkuS1E2SpPckSXpTMfxQqnxvlSSpjyRJwyRJ2tgVn6tzZNmTX0VCmI2wADPLUgu15wfGh/D8olS6Rwby97kDAQgPtHDqEF8PmN3p4bzR3XjzijFHleEHUG2XV9+peVVU1Tt5Z2UGH6/NYsBDi/htVz7nvb6Gd1dlAPDAt9t5d+V+QPaCTusfw8CEUAB+2ZnHTZ9swuk58SqdDzUz/72c6z/acKQPQ0enS/AoEYb4sIAjfCQ6JwJH14x7DJH8wALm/uePI30YR5Qbp/Whxu7i+o82ctmEHtrzP23L5fXl6dQ73YzuEQ5ARKCFicnRPu8PtBgP5+G2i+p6JwD3fLWNHTkV1DndRCjh7cIqOy6PRHyoDYB1GaVsPVgOyOHsZ84bxntXjeWD1Rk8vygNAJdbl3vpDHaXu0k4bH9xDUt2FzbzDh2dY4f8inotajA+OfIIH43OiYBu/HUQj6RXcQ5ODGVCchT7ldw/lTxF4sVqMrAsTZbsiQmx0iMqkK2PnMJT5w4FIMBioqCynjFPLuZ3r2rZo4ExPSOZPSgWgKIqOwCRgWYAcsrrAIhTjL9gq4lqJdfvuUWpnPnKKqKDrewrbDgvrmbyBnXaxtXvb2Dgw4u04psTUTNS5/hEkiQmPPM7H67JxGQQhFi7JBtLR6dFdOOvA+gTjzxgLU0toLjazv7iGh75YRcAYQFmbRur2cA7K/dz28l9GRAfAsjh34vGyoXfgRYjVpOBkhoHNQ7X4f8SLTCsWxh3ndIfgIJK2ZiNDJLz+3LKZOMvPkw2/oIsJtakl3DP/G0cKK2ltMbBf5bsoc7LU9Vc0YhO21i7vwSAj9dmAbJouI7O8YDq8QNwSxKLU46uhbDO8Ym+xOgANfYTuxrrsR938cPWHBwuDzWOhnPx1xl9eGN5uvbYZjYSF2Ilt6JOe87jkdiQWcaE5EgGJ4QSaJEvwTrnkTeoa+wu6p1uooKtFFTWawZGUZUdIeSiFYBsxfOnhn2DbSYcLg/fbM4m1CZ/n/8s2cu0/g1alfqCoXMMjA8hNb9KqzAvqrYf4SPS0ekavI0/ScJn0aijc6jQjb8OUKnkg52ofLgmEwCLyYAQ8oAVYjUxrlckb9Bg/FlNBnIr6vl2cw4vXjgSkFe2l7zzJ/ec0p/ZigSK2Siodxz5AW/uy39wsLSOzGdP57lFqfy4NReA5Jhg0p86jap6F3kV9QxODMXp9hAdLOcAdo9okLCprHdpYeDCynrCA828fcVYwgLNfj9Tp208c94w9hZWMzE5CpC9rTo6xwN2l+/Y59Tzg3UOA/oI2gHU/K64UGsrWx7fuD0Sw5PC2JZdQXJsMIt25muv7XhsDgHmpgUdZqMBs1FQ67W6DbSYjgptq36xIRwslb16NXaXUq08gCGJYRgMgrBAM/cp1cvePHLmYPYWVlFUZSc1v4qB8SFszCojyGpiWr8YxvXWE7g7y6geEYzqEaE97hUdxGfXj2fPMdwaUEcH0MTgVfQogc7hQDf+OkCPyEC+vHECfWODj/ShHHa8u124PRKT+kazK7eS8b0jefsPWe7ksxvGE2KTPV3L751BcaMQndMt8cbydMb2jGDWoDjOHZVEeMCR94zFh9k0b16N3U1EoJm5QxNYs6+Y15enc/+8gbg9ErnldVTVu5jYJ0p77+CEUJyxEqcNSyDQYmRjVhm3zexL35hgvt2czYTkKCKDLNj8GMQnEtV2Fxajgf3F1QyMD23z+xbtzGdXbgXjekcytV8M9U43E5KjmNQ3uvU36+gcJmodLvYWVDOie3ib3+Md9gVw6vnBOoeBY6rgo97pJq+i7oivjIKsJsYnRzUR+AU5JDzt+WWs2lvcqc+QJAmn28PqfcUs3HH0NEMprPI15AwCnjxnKGcOT/R6TvDUghTKahz0ig5ibC//ni+zUb78HjtrCLMGNe2CUVhZz46cisNWLPHbrgKKq+U8v2q7i2CbmZV7i/huSw6frz8gS9c8uZgzXlnFTZ80SFX+uC2XjVllLE0twOHyMHOgXCVcUetkW3Y5d8/fxqRnl3LmK6sOy/foKMtSC7l7/lYcrkNzf5VU2xn66K+c9t+VzP3PynalT9z/7XZeWbqPj9bIBR8v/JZG8oMLSS+qRpL0yVLn0LA7r5Je9y9gV25Fm7ZPy6/ipk82UW13MeuF5by0eE+r7+kdHcTGh2Zrj5Ojgzp8vDo6beWYMv5+2pbLxGeWalIiXUWN3UVKbtP+svsKq/hpW26T5zOLa5jz0gp63b+gycQjgAOltWzILO3UMX22/gD9/vELl727jlv+t7lT++pK1MrX3tFBfH7DBC4Z14NLxvVgWLcwbZunF+7mnZUZrSYuB3jp/C3ZXcCdX27xeX3FniIe/G4HV7y/jps/3dSF38I/3h7KaruLYKuRv366ma82ZWMQEGpr8E6qhitAabWdTVllZJbUsimrjB6RsqTNkt0FPL1gt7bd3kJfSZyjjfdWZfDt5hz+/Vua9lxGcU2XheTrFaNSNeYtxrYPP6pBqnqe1UKjWS+s0CupvXj2l1QGP7LoSB/GcYOaytLWCtzdeVXkV9ZTY3eRU17XpuINo0FgFHL3n2sn92ZyI292cbWdLQfKmuQG6uh0hmPK+Kuql3PtalsoDthXWE2v+xdw7YdtV/6/5X+bOe2/K5tMcg98u4PbP9/CzhzfVd/a/SXsKZAn8sYue7V61SA618rrh61Njc6jAbdHon9cMG9ePoaJfaLo5lXs0C1CVqbfni2fr+a6dlw2XhaEVnMCr/5gPS//vpf0oho8Xsa0OsFX1bs0bb1DiXf3tbtm9+fScT21MG2IzYzJ2LCB0Wtj78rTtftLcLolwgMt7C2o9vGUTu13dIcoY0NkT/Y7K/ezPbscgA9WZ3Df19vZX1TdaY+7+n61/7G5E8ZfndcYoCfIN/DmivQWx0ed9jFSCd/OGBDb6ra7cit4+XfZ01frcFPv9PD2H/v5eG1mi970zOIanlbaYPaOaer1W5JSwLmvr6GkWpc30uk6jinjb4ES/mwpXKRODvva4WXpEyPn7jX2RKgivq8u3efzfHV9gyadajDuyK5g6vNLufPLrVhMBmo7qVs3RVn9JUcH0TMqsJWtDx0HS2vZcqBMe3xSr0gW3jGV2BAr327O9hF4Tgz3bUvUnPF3khIGVjt8mAwN23nnFC5Pa+jecCi74kqSxN6CKoYmhTFjgCzPcvrwBKb0i9aOMTTApK3OwddwaWwTBVjkXsBpBVU+3k31OjtaefGikWx7ZA5RQRa+3pQNwM6cCn7clsvMF1ZwsKz9BvjGzFJu/HgjHo+k/baqQaz2eW4Nj0fSRLLVSdT7/nLoCfI6hwj12jK1oS/3noIqCirla9t7jnjkh128p7SC9EdmSQ1fbcrmsxvG88RPu3h5yV6f1w+W1QKQ3YH7T0enOY4p40+dfFsK86httNqz+rWZDZgMAkOjG1yd+Hs0Mr6q7N7GnwdJkrj/2+0cLK0jxGYi0GLs9Op7oCKKnBwTTP+4EL/bfLXxIGmHuMvImyvSueFj31bMn/yZxagnF3P3/G2s3teQ2/iP0wYxd0i89ri5sF6V3cXA+BAilXZpQdYGA8npavhthfJ7x4RYmz0HXcFHazI55aU/2J5dQVp+FR6PxKasMoqq7Jp3MibYisEgNO+gtxfwrzP6cO3k3vzyt6l8ct04AD5dd0D+boonOMRqOur6F/sjLNDMxodO4Ymzh+L2SKTkVTJCCelnlrTNWPMmJa+S31IKKK6x43D53reuNvY79jbuVAPS+/460jnARxN3zOwLoOdBdhGqoHtKXtO0oMZ4e/cq6nwdFC3d+2r0KCzAjNtrkaT+hqpBmdnGxZKOTls4pqp9VQdRS8af06OGhVwcLK0lt7yO8clRfrd98bc0hiaFseVAOS6PpOR5NZySJ88ZyiNnDvF5Dpp6/jZmlbErt5Knzx3GpeN7kJJbSVAnW/REBFk4b3QSZoOBfnFNPUZ2l5v/+3o7wVYTn1w3jteWpfPaZaOwmrq2mvR/ihGj8tqyffzr14acMJOXgTeiezijeoSzaJecJ9Oc8bc8tRCjQRAeKBt/gV6abU4vg0A1tALNRpL9hEO6il5eCdZ5FfVc//FGlqYW8ve5A7FZjEzrH8PH18pG3f+dOpAAs4GBCQ2VqmEBZh45c7DPPoOtJkprHIzrHclN05O596vtTdIHjjb+76ttTO4bzTmjkgDYX1RNvdPDGcMT2ZZdQWZxDVU9nWzILGXmwKYFOv6IDZG954WVdmxm3+vB6Wr+Pq53urn+o408cuZg+sQE88Otk3F5JE1e6bRhCRRXO9idV3lCh33zKuowCkGsEqW4bkoyF43r0cq7dNqKmqphNrbu+VONv97RQU2u9ZgQKyf/ezkZxTVkPnu6z2uq8Wc1GTEbDTg9Hm79bDNZJTX8fPtUbV+6+LNOV3JMGX9J4YFAaYthUKcaFnK6mfr8MoAmN5vKZ+sPcMrgeLYeLAegqt7pY+hZTUbUh7UOFw99v5MHTxtElRJ2vmx8DwItRn7fXYjZKDhnlFzx+v2tkzvzNQH4M72Ebzfn0Dc2mLJaB9dPTfZ5XQ2ZxYfZuObDDZTXOtmZU8GYnodGU87tkTAaBHsb6aoZG3lL1XDo5odPaeJJVTEZhZb3BQ0e1nNHJRGhGIQgT/Afrskkq7SWQV7GVlej5vUN7xbG9uwKlqYWasf1xFlDfEK8f53Rp037VK+jkd3DGZwQSmFlvU9Iu638sDWH91ZlEBtipc7p5sHTBjEkMaz1N7YTj0fim83ZxIXaeOG3NGxmo1Z1qEravLJ0H0VVdl5fns6Pt01meLfwVverFj4VVtUzc2AcI7qHs02531oK1+4tqGbVvmJe+C2Nc0clMXdogs/rl4zrwUm9IlifUUaIreGe3XKgjMIqO6d6eaCPZy57dx0BZiML7pgKwBsr0jEbBffMGXCEj+z4QF1Mt+XWVY2472+dTFiAmfNGJ/Ht5hxAXsw0l+ZgV4w6q8mA2WjgrRWyZFavqECWpRVqRuXRoIWqc/xwTBl/UcEWbGaDT5FBY9ROClP7xfDHnqJmt3O5PRRXO0jLr+SGacn89/e9TTwRX208yEuL91DjcHPf3AF8uzkHi9HAPXMGcP3UZK1fbUKYjTNHJPp4sDqLmte4r7Dab/6i+tzz5w/nvNfXALAhU87NOxQGYI3DRajNTFmtbzij8Yr4L2O6ccrgOJ8ev435dZdv5dxgxbCL9DL8wDdH7lDldWWV1HDH53KVsXc1b6+oQM4ZlYTd6eaer7Zx+8x+jOsdSU55HbtyKgixmX10/hoTbDMxvnckZ41M5P3VmZTUOCjpQD/arzdlsz27gvBAM+W1ThanFBwS46+y3olHgsggCz9vzyXIamJ6/xiuntSL+DAbMSFWJAluntGHd1dm8OPW3DYZf1klcr5SoRK6CvYK8bcUrlWLh37dVcCvuwr4v1MHEGqTQ+cXndSDshoH3SIC6RvbkA4gSRLnKvdCcwu+4424EJtPJOTtP9LxSHDryX1PeE3JrmCrUvjUOIzrD9UDrUY8BieE8i2y8devBU1YzfNnNvikkxworeWaDzZo3u76o6AFps7xw1GbhFRUZWfYY7/6TBDzhsZz07Q+VNQ2fyMOjA8l89nT+fjacSSFB3CuEsICSMmt5JK3/6Te6dZu5s0HyumjhBSdHg/Vdhf//DmFDZml/JZSQG5FPRV1TkYoE93a/SV8ti6LAfEhuD0Sbo/EVZN6ae3LQJZbeOzHXZ36/jtzWs4xySuvxyAaBqXXLxvNs7+k8pc31h4S6YtapZ9xeaNB0GjwvYTCAsxsyCzluUWpze4rqVFhyIjusjHz3uoM8rz6ADtcbsYr3TFUb1xXU1zt0AoQVin5i4+cMZhXLx1NWICZbzbnsHJvsbb6PvOVVdz4ySaebeH7gZzjV+/ykFtex5M/p3T4+Kb1i+H+eQNZe/8sMp45jTtn9+/wvlpC7WMcGWTBZDTgcHkYmhTGY2cNITrYytJ7pvPHfTMItZmZ0i+aX3bmtymvTF0EFFTa2XygjNX7SgB50dC4QMgb1XBRK5D/9Wsaj/+Uwn9/l4uv5r28kru+3MqO7Aqt8nd9huxlvH5K746cgmMSm9ngEw5Ub3294rdr2KPkVNfamy/gU/U/rSYDax+YyRmvrOS1Zft4afEe+sYGIwTa/AFN8zEvHdeD1CfnEh1k5RKvkL36W4YFmLGZDdR0sohQR8ebo9b4c0sSdQ63T05ZXKiNl3/fy6JdrYseu9we8ivrfQyNR3/cydr9JWw7WO6TJ7TlQLnyHomqeifvrspgZyNxYTXvIqukliW7C9l8oIw+Dy5keVphE2MrLb+SjVmd0/lrTSnmhmnJXD81mUd+2Mk9p/T3yTFUJ8GuwGIyYDEZtEm8vNbBgLgQbpqezCfXjWNaI/mSfYVV3D1/Gx8p/X/98dPtU1h051TtsZrQDL4r7FX7ittVZPD5+gPc+9W2Nm8PDaGUeUMbwoRnDE9gaJJskKpGrCrBoIa5za1U/7122WjKahzM33iwXcfTmBumJXPz9D4EWIxaAcyhoKxWNv4igixYjAZcHgmHy0O9040kSYTYzJpn++QBMeSU17VJb1Od6OYOjfdZtJ07Konukc178Hco+ZHeUjlBVpPmJal1uNieXcGZr64iXak4X7WvGIPghAp5Lksr0s6VNx1JMdBpnpa8qDV2F6U1Dp74OQWryUh6UQ3ZZXXUONzU2F1IEj5e/8byYAaDwGY2YjAI/j53ILMG+srK9I8L4ZVLRnO/n9aSOjod5ag1/sprnLg8EoVVDROMqvXWkvt7aWoBve5fQN9//EJkkIVXl+3TjLOLT5JXVeGBFp/KrC82yEUNDpeHic8sBeTB03sA/XN/g0EVGWTBqlRv/bargCGPLvJJ5g+0mtq18na6PWQr5fwqjed5f14Wu9NNZZ2L22f1Y3r/GLY9KvfT/S0lv8m2HeWqiT15+PRBmmTJkMRQzhudxAPzBjG1X4xWtKGSqqyUGw9w3kQGWXxae23KapCS8TbK650eH8OwNYqr7Hy9KVsTogb5evhha06z71GNPzWXLyk8gF15ldo+VM9TgpJQr0o+mFpJAHd5JA6U1vpcqzdNT27hHU2pqHVq+aUAj/+0i++2ZLdrH23F7vIQG2IlKsiCyShwuj38b10WAx9e1CTk1TNKNoTbor1od3tIjgliQHyIz/1UbXf5aPU1xp/xEmw1Nej8Od2EKgsS9bniajseCb7b0vzvfaKgG39dgzruXTmpZ7Pb1NgbrmO1GK6iTjb21AXSp39madt4Go3lS1IKeOzHXVpXJ1XP9prJvRACft6ex51fbGk2h1pHpyMctcafKgNxx+dbuO9r2Zvz3kpZK0lVOne6PTy/KNVncvK+ES8Y003bDtC8Yy6PR8she/nikUzpG0NimM1H0sXplnw8et5hR+8erWv2F+N0Sz7VqIFmY4sTW2Oe/DmFKc8to8xrdai6/9X+wQWVdsY8uVgzlO6Zv43V6SVU1Dm1UGlYgJmeUYHU2t38vD23SyaA22f1o1tEoNb94vXLxnD15F7syq3g/VUZ5DYyANrTtUHllhl9uGmabBg5vYzGxvtujbmK9+7XXQ3G77UfbuRvX2xt9j1qyCxTyU07ZXAc13ywgV8UTclv/jqJT64bpw28muevle+5YLss0h3kpfPXO6p9FcvvrdrPiMd/0xYqP23L1fI6u5pJfaJZ/4/ZDE0KIyrISliAWbt+Gn/X8cmR7Hz8VE2vsSWMQlBS7WCdIn6tsnBHPsvSmg/l+xPFVY0/+Z9EqFLooe53St8YzEbBg9/tOOGlTo7VCmi3orpwtKDdA4bm73fv4/1Zue8bL5jsLg8r/m8Gq++f2SQ3fGNWGZ+tP4AQgrn/+YP1maXcdnJfzhieiEDOP65xuPlgdfNagTo67aVLjD8hxFwhRJoQYp8Q4n4/r18thCgSQmxV/l3f2j7VoSuzuJb9RXLoT514n/kllQe+3cHCHXm8vjydZ39pyL/yNnh2KS3bVENvkxKKrXe6te1UD154oMWnAtXh8uDySHSPDOC8UUmaURNoMfoYfwdL6xicEOpzQwdajD77ag31GMxeWlCqsnxCmI3JfaNYn1lKSY2D/yzZQ53DzTebs7U8rXkvr9Tet+jOaVw6vgd3fL6FjV1gKGQV13LNhxvYqoTGAdakl3D6f1fxxM8pTYpRzB3QsjMZDVo1r7fUi+r9NBtFiwUkKhsVw9hbe7A1zEYD0cFWrejjz/1KTpryPbpHBjK1X4zP9tC0yrkx25QuJ96GU3uEx0FO+E4IC9A0wkwGw2HRtHvhwhF8ct14zYBobPxZTcYm8kfN8d9LRjFrUCx3z9/WRNevpcWJ6jnuHtmQthFklfUz1X6pqudPPSenD0/QciKb8zz/uiv/qJfcaQ8Wo8GnAv3VS0cBx67n7/5vtjP00V+PGuNddQAs3Nl8qpG34LjNbCTAbPRj/LnpGRXUJN9ZfU2bA4wG5gyO4545/ckorsEjyTIxIHsAdXS6ik4bf0III/AaMA8YDFwihBjsZ9MvJUkaqfx7t7X9hiiTS35lvTapS4pJKEmw7WC5dsMkhtm097m8VrwrlGpf1YugenmSo4NJDAvg3jn9+XhtFkt2F5CSV6lJUIB808+/aSIr7j2ZFy8aqcnL1DrcxIRYsXkZOWN6Rvgce/fIQJJjgnF7pDaV56seyUCvvJKiKjuXje9BQWU9F47tzgBF5NjtkTRP36AE+bnG3ja1crO10GRbOPPVVYBc7ZtVUsOU55ayck+DcdX4M6zKsbQ3QmEzGYkJsfp00VBb5DndUptao/2otMTzF3Jvrgjm1CHxrH9wlvZYDVs359m7Y1ZfHjxtIA+eNqjFY1F/k+gQK8vvncGZIxL50U+f6JY4UFpLD6+8OJNR+FzfXckvO/K4+oP1vp0zXKrnr+mP+eaKdD5em9mmfQdajNQ53T4yPtCyd0pdsB0srWNgfAhL7p7GG5eP4d45/Xl9eToWo4FJSrW1um1hZb12zfgz/g6W1nLTJ5u46v31bTruox2PR8Lh9mjjIMie622PzDnqu8k0x1dKZxl/1f31Tvdh7+N8z5wBCEGLYvohXioBFqOBmQNjGdsz0mfBand5uPmTTfS6f4HWOtH7NVVSxmw04HR7WLQzX8tfVvvOV7XQ2UpHp710hedvHLBPkqT9kiQ5gC+Aszu706hgS5Pn1Mmie2QAdldDzs9Yr/CTOmgMiAvh2sm9lffJz4XazJgMgoggC2GBZuYMiWdNeon2XtVT+Ml147j3VDlpXA33qV09EsJs3HpyX4KsJi0kO663b/jr+qnJfH/rZO77ejsDH17U6ipWk8PwSm5/f3Umq/YVs6egmoziGgbEhzCtf4wS5pXzSMb3lie/WEUKAODdlft58LsdAOxugyp9S3gfd43dTUmNg+yyOh9jwNQoHKJ6zD6+dny7PispIoD3rzrJ57f01jbsF9t6hw/1d/YXMmzJE2IwCCxGg88iornw9bmjunHjtD6tdhyJUrqXRAVZiAmxsr+omtIaB063h6WpbWsSf6C0zkfT0mI04DxEk19GSQ3L04owCMH7qzK4e/5WnG4PZqPwW2iyNLWQn7e17on416+pfPrnAeocbqb1j+Gli0Zor7XkxUz2Et5OzZfbZsWF2uihhM7PGpnI2SOTePnikZrXeMa/l2u9Ve1+Fl3q4q/qKAordgaPJIe+/7NkLw6XhzqHmyveXc+qfcWteqaPVkb3CAeajisA576+hkvf+fMwH5Ec8m1poTIgPoTn/jIMkKM4r102msfOGsLLF4/UtrE7PZr4vXdqkvqaasCbjIJlaUU+agnePc51dLqKrjD+kgDvksZs5bnG/EUIsV0I8bUQoru/HQkhbhRCbBRCbKyqrGhS9eRyexjeLYyDpXWkF9Voq3uLqWGg6xkVyFkjEvn6rxM5fXgCV03siU1ZVZXWOOQiksp6ymsdWihzpvI5kUEWbj25D72UCeblJXv55M8shj32K58pnS7UUKvNbOR/14/njpl9OWWw/24H32yWV7HFrTTk3qMIJ+8vbggL2p1uzSj8z5K97C2o4uwRiZw7KknLhTtrRCIhVhNjvXT9th4s52Bpnfa+zuA94GWV1GihDLUtGzT1/I3oFs6mh2YzPrnzWoPe2lhqAnVLOJTr460rxjR5rbkw4Nebsrn83XVYTAafkHVznr/M4hreWpGuiRc3e+xKV5Y+scH839fb2JVbicsj8fKSvVz74UZW7i3Sclf9UetwUVxt96mIDQ0wt6nTQEdQNS7NRgN7C6tYubeYiX2iuPXkvn637x4RqPUcbYnlabL3vU6pGg7y7ubSgvE3NCmMCV7X0P3fbmdZWqEWOq+xuwi0GDl7ZBJxoTZqHS5qHW4trObv91bzcP0tDo5FTEYDd8zqB0C9y02tw8X6zFLu/WobB0trqbG7uPOLLRRWtl6VfbQQYjMzoluYX+N1d14l67pQyaAtfLMpG0ej4j9/XHRSD84emahFcTweiYSwAK/XG6a8Oqevd73a7tQKS9Rxx3v86RsbzOCEUN340+lSDpfI80/A55Ik2YUQNwEfATMbbyRJ0tvA2wDhPQY2WWrdPqsfO7Ir2K7kUw1T5DjWppdowsZT+8VoOVpjekb4hGTV3MHNB8qxmQ3c9812oEF3LjHcxrVTevP0wt30iw1mwY5ckqODsZoMzBndjYLKelbtK2ZnTgVDk8KIC7Vxtx9ZiSUpBbz8+16umdyLD1ZnklFco+Vt+OPS8T34x3c7NS09gPpGE9Q1H24gMSyA+TdP5PP1B4gKshARaKHK7vLZt3cuVmmNA0mSOiwR4m2cvPXHftIUIzXYq6NC44bnFpOBt//YT3SwlRumtb26tdbh4tlfUpk7NJ5JfeQQ787cCrpHBnKwtJb3V2dy7qhuLe7D4fLQPTLQpwL5tUtHszS1sNnG7PuLqlmXUYJHavDA3jQ9uUkoX+VvX25l28FyzhuV1GLBQ6jNTKjNRGWdk4U7GgpQVPHiK96TQ4/NiRFLEjx59hBG9Wg4jq7oHOPNVxsPYjIKzh3VDYfbjdEgMBoEZqOcW+h9LzUmKtiiycO0hLcR9umfWTz8g6x/eeqQOEY3c45BNtScbonk6CD2F9dwsLSOFWlFfKhICP2yM59zRxURYjPTJzaIeof8OZeO78nMgbHEK17czQfK2HKgnNmDYo+7DgkeT0NRmpzHLP9d53STXVbH8rRCvt+aS2iAmSfOHnokD7XNTO8fw9r9JdTYXZ1ukdkVqLJZLXmpP1mbyWM/pfDrndPoGxvMdR9u4HevAsGrJvb0iQ55p6Vc99EGVu4t1saBc0clsT6jlAivBXa/2GD6xQbzzsqMTo3nOjredIXnLwfw9uR1U57TkCSpRJIkNab5LtDUNdMIjyRhNRsItpq08O3oHhG8t6qh4klt69TczSBJslaZp1GozKFUC6qoUiClNU7Kahz8tC2X9RmluDwSJqMgNsRGWa1Dk/2obCX3otruYkdOBScPkD2K+4taTvRXw7ctiXhml9URH2ajoLKeM0cksunhU7CYDEQHWxgY3xCCbFxJ1prXsSUaek7Kl4naASM5Opi/zerHh9ec1CT8WVrj4K0/9vPpuizag0EIthwsJ99LO+5/6w5QWt0QCm8tfC6HVAt53+saOX14Ai9cOKLZiaTO6cZmMnKbl4fr5AENxkNj2ir1MqlvNNsfO9UnjA1NUwSaI8hq4oqJvTS9wUPB/329nbu+lPOKnG5J8yqalDBXRZ3TpwLdmxCriXqnp1UvmsPlYVSPcD66dhyViufit7um8dYVY1vsVPLJn5lsyirzmSiDrL5aa1X1Li55509W7immuEa+TpKjg+gdHaR5TpakFPDkzync+tnm4643ak55Hc8oxW71Do+PwoDT7dHOt7envquorHdysLR1z297iQq2sDilwEeu6Uiievy8F7yNqax34fZIWki6sYcut6Ke1PyGFBzva3pyX3mhq8omXTKuBxaTwafb0Zr0Eib0iWL3k3N1w0+ny+gK428D0E8I0VsIYQEuBn703kAI4d2Y8yxgd2s7tbs8LNyRT7XdpVU7bsgs5YAy4MwaGEt6oezJK/LKlXtt2T4GPbwIl9vDsrRC+j/0iyaC+tz5wwF5QvJ246uD5Lur9jPqycUIZAPR5ZYwGQTdIgJYmlrIiO7hPHzGYCYmN9/WCxq0oVbvK+beOf1b9HBAg6SJ96Dgb6XpcHkY//TvLEkp0D5n40OnMGtQQ9g52GpECLR8k/I2eGeaw2w0cOXEnkxRBqhlaYWcMjiOvrHB3HVKf2YMiG0iflqtnEvVi9aezwLfRG+X26Plu0CD4n1zLL5rOvOGxmveoVqHixd+S2NNenGzieL1Tg82i1EL3Z86JI6csrpmjR6jZvy17dbx9ji+ftnoNus/Vttd7M6r9CnAeHHxHq3StasJDzRrhrzZJOv8/fPnFE7/78pmtw+xmVqtare73PSPDWF6/xjNeO8ZFci+wmpKvAx7t0fySYRXjcp8LyOgsQHvrfNXrIwBdpeHt1akN7mn9hZUExdqY3zvSD66dlzLJ+MYwdszX+9y+3g2XR4Pdqcbg6DZ0H1HeODb7XywOoPhj/3G1OeXdbksS7oS1vf2GO8rrPZZ+B3OSmCHolP5f6f6Ciyv2VdMr/sXUFhVr52Dwio7byxP18Z/lcUpBTz03U7tcW+vfNZpimf9ug83AHJRh8PlITE8gFtP7oPZKKioc/LcorRD8v10ji9yyuu0AqHW6LTxJ0mSC7gN+BXZqJsvSdIuIcQTQoizlM3uEELsEkJsA+4Arm7r/mNDrHytVIB5t8k6dUg825TJwjv8ZHe6qXO6tfAVNKze1C4d3gLOS++ZTnJMEKcNi2f2oDgCzEYCFT0xt0fCZDRoeVfrM0u5bkrvVldfAYpB9NYf+7lhWnKrxQHvrJQbeXtPpPcpau7eCf99YuVB484vt/LminS/+4oKtpIYFqAdY2f6QYYp4aItShX09P4xvHPlWMICzPy2K58Xfktr0mrPbOrYytRoEBiEbz5WY4OtsThqYwwGQaDFqO2jtMbBK0v3cek765r1vtY73QSYjZr8R6+oIO75apuWh9mYBu9Y276nd+5SYniA9lsDPt7GxmzOKmPeyyt9buT1GSWs3V/S7Hvay7yh8fRXchNvmdGXH2+bAkBMsJWeUYFywUcz0j1XTOzFjsdO9QlP+SMi0KJUL+ZRWiNfKyaDgdkvruATL+Hbl3/fy1mvrtZ+B/U39D7NjeVlApVJ1umR6BsbzP3zBiKELAWVUSwvDNWJ2a6kBHx500Sm9/cfyj7W8L63zUa5L6x6vTlcEsO7hXPDtORWNSnbisPl4fP1B3n8pxQeOl2udq9sQ8/btuL2SPx3qdy+TzX+1uwrZvaLK3hvVYb2+x9OD67T7fFb/PW+orm39UC5z7j95/4Sbfz32Y9HYu0DM9n26BzG9oxg/oaD1DncrEmXlRNUlYG758ue+Il9oqioczK8WziJYTZ25lRw5xdbfBwdOjqNeX9VBme/tqpN23bJqCBJ0kJJkvpLktRHkqSnlOcekSTpR+XvByRJGiJJ0ghJkk6WJKnlxqheWEwGzXvlHardfKDMbw6P0yNpFYrqoHfbZ1uYv+Eg326Ww7sOl0cbXOT8JgmryUhlnZMQmwmz0YDDJWE1GQgwG5mmTBbWNg6iQxJDmT0olsV3TaOk2sFWLwkZf5iNBsIDzVw6vqGv48ju4YQFmIkItDBOCR1GB1u1gSWvGQHkqyb14rRh8XyyNpOvbp7oIz7dXjweWXFeLXJRz1lOeR03frKJV5buo7xRIUZnJhqLyeDjkXU1Mv5akzn5588pLE4p0LyH3lV1zRV8xIZaGRgfwv3fyhXSaq5Oc0aP2svYXzWiP7yNxO82Z1NUZWdEtzAynz1dqyj3h6qJ5+1hVGUguoqyWgd55U3Da9dPTea3u6YroeD2/Z6bD5T5GHWL7pzGqUPjufnTzewvrsak5BUaDcLnu6gyS+rk5lB+a4/UkN4R1CilQQ3NO10ekmOCuXl6H+KVTiyqV8zbc1pUZWdvQRUfr808LvL/1Gv6o2vH0Ts6iB6Rgcy/aSIgXz+zB8dR53D7pEF0BovJQHJMEKcOidPyjFVDbM2+4lbTYVrD25Csd7rp94+F3PDxRgDOHpnER9eexE3Tkxn1xGIWHCbNO4vJSGp+Fa8u9S2eU4sCk2OCfMYZi8ng4/lL++dcThkch8PlISEsgBCriR+35XLfN9t5ffk+vlHmpDcvlzOhAsxGekcHccrgONakl+B0e0iKCMDtkfh+a642Fuvo+GNYUhg3TevT+oYcvoKPdqNqJGWXyUaOaoiofLHhIHfOlivd1LAkyKHCxhVT+ZX13PfNdm3Ff+qQeDySxLtXjuWZX3ZzoLSWA6W1hAWYiQmxEmozYTEJlt47Q9tvkMXYpJVZc0QFW3n3qpMA+Md3shj1lkfmNLu90+2hd3SQT77e6n3FzBoYy7K0Ql68aCQn58naUUFWWTMtwY9YqEpGcQ21DnebOjC0xI6cCs5+bTVPnzuMt/5IZ3FKAWOeXMz8mydq2zQOf6oh+iBL09Vva/SOCtJCeeDr+bt0XI9W8+y+3HCQKrtL8xBU2xsmE39GkyRJPDBP9mD0un8B0CDE3JzUy41Tk5nSN4qzR/oraG+KEIIN/5jNF+sP8MLiPSTHBNEtIpD1GaW8snQvz/5luN/3qQsdb+NRXah0FXsKqjlJyUF8cfEeskpqePniUdrrDq97qTEZxTX8+7c0/jq9j09e4stL9rItu5zLxvXQZJLUBUtCmI1Zg2KV7yJ8FnPqX6pT3dsDfNO0ZM4b3Y2oYAu/peSzI7uCFfedrG3j8ng4WFqLEGBVvPu786r4eG2Wj+f0hd/SNKHcUwbH+VRjHis43R5q7C5CbWZNzsZqMlBR52TMk4u5Z84A9j41D5NBUFhVz+p9xRRW2rl2Su8u+fyIQAu/7ipgzT7ZA13ncHOwtJZL313HuaOSeOmikR3ed7mX8VdW48DplnC63YQFmIlWpL/OHZXEWyv28/APOzl9eEJzu+oyXrlkFKl5lZoMmIrq8e4WEchJvSI0ZQeTQTC6Rzg7ciqY1i8Gi9GA1WSgrMbBy0v28tKShrQNjyTrwJ45IlHrTmQyCu26VgsUvWkpL1zn2GXbwXKsZoNP29OOcM6ots1LcBQbfwlhAXjr8Ms5eB7iQq0MSwpnye4CLbHWeyJ2Knl6gI/4Kcg32+ge4ZrHIDE8QKv4BbklT5+YIL68aaLv+zwSNQ53q2FHf8SF2iirlfM4LM14k+xOD1sOlPPbrnzmDJEHgSd/TqHa7qKs1onT5dFU/FWDKKGZgoStB8tZsrsQq8nAN5uyGdc70kcupD2onoUekYHEh9rIKqmlpMbhE9YwN672Vb2tM/u1+/OeP3+Ez+NHzhjMbUrnjZMHxLbqhVI9furg6Z147a8wYdSTi5mYHMUbl49h9qBY/thb7CVs7P+zpvSLZkobBKe9cXskreNHUaWd/UU1/KEIkJdU2xE0NWpdfrprmBp5yzpLgNmoFQPsLajSDN8F2/P4cE0GQggszRjc9U43C7bncebwBB/jL6+ijjE9IiiqthMTbOXajzZoXpLThiVo1cONvZhPnj2EdRmljOsdybO/pHKgtGHie2vFfirqnPzj9MEkhAVQbXdhNhowCMG7V46lX1wwzy5KZXduJe9fLS+61B6rt53cl9mD49h2sJx0r9B/ea3zmDT+duVWcs5rq3n/6rH0iQnm9OEJXPz2n9x9Sn9cHonnFqVyxvAE4sNsTHj6dzwSxIb4Hyvay+p9xVp7ySq7C5vZgMPt0Qo/OlukoUZ47pzdj8GJDZNgZb2Tmz/dxK+7ChivLFYOpwfMn8c9IcxGfKiNWoebi8f1oF9cCH95Yw1mo4ErJvbiiom9tG2tJiPF1XbN8LOaDNhdHmKCrdQ6XD7i/nnl9eSU1zXpRx5iNVHVSj9snWOXs19bDTSv/tAWHC4PZbUOwgPNmmh4Sxy1vX0lJE3wE2RDxOmWqLW7WbJbLnhQFc+920aN6RnBhWPl4uPYECs3T5eNpuhgKw6Xh80HyknJrWR/UTVLUgowGQQn9ZILMoYmhXLVpF7avu6Zv43vt+RQray2OqKxplYIF1U3n6thVwaWRTsbJEEcbo/m9bzxk018ueEA9U43pw2TV7uJzXj+1IILu8vDPV9t0/IiO4JqCFnNBi6f0JPEMBtWk8HHIGmsx2U1GUh9cq7Wq7cz9PTqhZtbUddqazOn28ON05LZ9qjsZfVORvcn0lpe6+SXnfk8+XMKVrPRx9PY3G+dXlTN3fO3+nSDaY0L31rbcM02SpCvrPO/km8I+zYcR0yI1a/4eUfJKa/T8mm9FyeFVfVsyCzj7JGJPveDN2ootvHx51XU83tqIdP/tQyH28PytCKtL7T3xGU2Gvhs3QGtS0jPqCAuHNudQIuJN1eks2R3IVdN7AnI5+ydlRlkldRgNgqeOkcW1DUaBLMHx9EzKoiSajtRwRbN86f2xjYYBCO7h3PVpF4+HRcat986XJTVODrVok897u+35PL1pmzuOUVuZ/eiVyHQIz/s5IetuVqBVHu/6zO/7OYeJffMG1ViSwjZ+El9ch6je0QwqW80YQFmn240HaFcyR+e1j+GnlFB3DtH/m6SBL/uku+fdRmlJITZfNr+HUr+9WsqKXmVTcaP0T0iyK+sZ3laIS63hzE9IxiaFKrdn3UOt5ZycOXEnjx61hDtvZP7RvPihSOY1j+GWofbJ0zsllSPv4E3Lx+tpe08frb8/va0DdU5sdhXWM34p39nWWpRm7Y/ao2/tPwqxvVuqKoVQu4T6u1luH5qMrEhVu78Yqv23JkjEnnoDLm7XGyojfvnDeTPB2ax6M6pmmfo5+25/LIzn+s/3ojZaCBOyRM6ZVA8Z49M4o3l6Ty3KJWft+eyO6+SUJuZjQ/N5u9zfSu+2oLafaOlVbGaPO3t0m8c3vv7NztYu7+EU4fEMyQx1G+PSGgqh9GZgg81b8pqMnDmiETmDIlXjD+vDh+NPGRCCGxmoxbyaw8v/JbGh2sa8pMWp+QTqhgZj/64i7La5icxl9uDR5KLAtTBdN7QBH69cxp3zOzrd7K4YIysG5hTJldIqcbfuaOSmvUK/WtRGt9uztE8d23hgJckxoOn+V5DzbVsGtU9gn9fMEJbPAA8de4w/nf9hDZ/bltxuj0+IV71/1MGx3HeaP/aimp43jvPq9ruoqpe1p2sd3oorJSNPtXoeviHnVr18MNnDMLu8vCIovu3OKWAc15b7VNoExvq67EqrLLzzsoMbVEEsDS1gD0FVRRXO4gOthIbYmPdg7N49MzBhAea+e/ve1maWkBafpVPb+UjkTjvcnsY9eRiHlDySzuCasj9uC2XV5buI8uP3MqytCJNESA+1NZu4++tFfv5ZnM2n6074PN75FfUEWIzMWtgnE8KjCRJRAdbOiVCvDS1gLhQG0+cPYT1GaXsK6zi3NHdmH/TRP59gW9E4G+z+vHjrVM6/FntYeVeuSCjcV9qtdio1uFm7ssrueaD9bx88SgemDeIZWmFDHpkEYMf+RWAEd3Dmay0IgyxmliaWsj0/jEkxwRjd3m0fQFaapLVZGDu0ARGdAunR2Qgo3pEEBFoprnYkyRJvLcq46iRyNFpH31igggPbL1/fUuo+beNq82b46g1/qAh3+m/l4wi1GZmTM8In2pHASSEB/gk87s9kiYF4PFIHCyt5YetOVTWObXgmsPVoE8WZDVqeUB7CqsoqbazKauUFWlFSrWv/K7oYGub5T28UUMu6kToj5N6RTK6R7iPDIi/8J7NJBefLLhjarOeP1UOo6HTQcfDBA06f3LYYm9hFVazkUCLiYdOH8Qn143TejB3BQfKan0Mpbf+2K/J8EDDqtgfLo9EoMXI9uwKHvtxF3UOueJ7QHwId88Z4ONFBMivqNdkaoSAyX0bFhon9Yps9QbqyLUAMGdwPAvumMJ5o+VUheYmzB5RgZw/pptP39BDRb3T7eP5U437zOLaZrtDBFtMCCHLJK1NL6Gq3klRlR0hYFT3cPn9JXLotnd0EF/dPJGhiWGad+fcUd0YnCAXRoFcpbb1YDlbDpRpn6GGblVUo/RfvzU8f8v/NvPNpmzN82c0yEH0bzfnaAb8kt2FnPv6an7Zma+lLLSlO0lXo3qP1P61HaFxde01H2zQ/r5rdn/N662e+/HJke32Fp83OolAi5EHv9vB6n3FuNwelqcV8tHaLNweiaWpBdidbu78YgtfrD/ArBdXcN2UZP4+dyC78yr55M+sdvXgrbG7uPbDjTz43Q5OHRLPs7+kcteX2zj3tdX0iQmiV5SvR/Gh73dqnueu4O0/0vnUq0jJG3WeaLwYfOwnedFS53BTUFnPpqwyZr2wgtzyuiZjYmZxDYsVY1xtWXnBm2vJLK4h7cm53OPVKEDVAVXHJrNRcKC0lpJqO1semcOpSlpQY/Ir63ny5xTGP/07f3ahIoDO4eGkXpEMaEUVpDXUyIq/anN/HNXG36vL5LJ/NY9s4Y6GCq9v/jqJnbkVbDtY7mPg3PnlVma+sAKA4mo7U59fxjO/pHLdRxv57IYJhAeaNakXi9FA94iGgWXB9jxe/n0vFpOcy+LySFp1Z0fpHR3EG5eN9glhN+aPPUUcKK3zcen7C1OqUjUtoRp/10zuBXTO89c7Ooibp/chOtjCs7+ksnpfCWcMT8BiMnD91GSm9ovpkIevOSxG3x6aTaReWphQbGYjKU/MZVr/aD5ck0mNw8Wy1EKeWpBCfkV9k3DJG8v3aVWpJdUO7ca7+5T+1DndzRrNEmouXvu/99J7ppNdVkdSeACPnTWEvrHBWpiyMQWV9WzMLPVZBHy0JpPblRzIrkDtiVvndJMcE6zJvqhG1rUfbtD6RDfGYBD0jgoip6yOS975kyd/TqF3dBB7/jmPaxRRdtUrFRpg5qRekQTbTNp5S8uvIiWvUivOUfNp6xxuMp89XTMKQa5m/fG2ydp793p5o8wGA7UON2W1TqKDrUiSxI2fbOLB73bwz3OGEGA2EmSRcxutJgN/ndGHJXdP14Tj28KC7Xn87YvOn/euaCunevH+ec5QHj1zsM9rQ5NCtbEyo7gGIeBf54/QJHzaSpDFpC1EH/8phaWphZr3ttbhxiPJC6bvt+Zy/7c7yCuvZ86QOHpEBfLoD7t4+Pud7dL/U6+3yjqnVqCTVVJDYZWd0ABzEy1Rl0filaX72JTVNa3eftmZz6+78v2+5nR7OH14QhPvo3p+imvsVNW7tMXllxsPEh3s283puy05mhj3oIQQ/nf9ePYX1/DZ+gMIIXxSZ1QngTouqOfmyw0HaQmDl/zYxW//6aOZqXP00y8uhPvntT+y6I3m+TsejD+QPVj3zN/K3oIq7pm/jdOHJ/DpdeMZ0zNCqzjzHlRdbo/mMfTOTcsorqG42i7LuLhlz5/ZKHj7yrGAPOlbjAYCLbLUi2pFNy5oaC9BVhPzhiU0CWF5c89X2yiutvt4/t67aizRwVafwo7Gg6A/gq0m+sYGa2GZzkhaDEoI5f55A4kKtmJVuok8euYQJEninT/2c/8327tUcNWiJFaX1jhwKsa3N40fN7cPkK+JNenFvLMygwnP/M4vO30H98ySWm2Q7h4ZyF4lJOhye3jy55RmpWFU2qrz501RlZ3L31vHlgPlhNrMLLl7erNVwwu253H+m2t9jNZ9hdWs3lfc7s9tjmuVBYLd6eGZ84bxTyWXLirYyohuYXiklqVelt47g9E9wwGY4lXIoWpT5lfUkRwTRFiAmW83Z7M9u8JLfmkzIBsQIOd1AdQ5PRRX29mUVcbI7uEsvmsa0/vHMLxbuPbbeh+TWZEHevnikZw6JB4hhCatFB5ooc7pJtBiIirYyrjekdwxqx99Y4PbdC+pfLM5mx+U4+wMQVYjl47vwUsXjWh942YY1zuSu0/pz+UTejZZHE1IjtIiFRP7RPGP0wY1W2TWEp808oKV1zoZ1SOCxXdN42ElpeZJr3ZxY3tFkFVSyzebslmv9Lxuj/FnMRnoHhnA/uIabvpkEyB7lCMCzZiNBm2B4O0B/O/SvVpItrNsOVDe7L6cbslv5b9dWVRnKnqSar5jWn4V0Y1aeaq/wfp/zGLGgFgm940mPNBMXkU99329zceIVR0cqmTR3xRFC5NRcNMnG/l+i28hiEpcqI2fb28w8ltKkdE5ulDnnM5ez8dV2Bfk3Icah5t6p+yt6xkZyMCEEOZvPKh5FuwuD7nldazcWyRX+6qTRKOB764vt1JUZcfhkjQBW9Wzonb1CLQYMRsN2F1u4kKtXRJe2JBZqlXJ+cPh8nD+mG4+vVtHdA+nX2ywzw/ZlgkrLEA2Kv4yOokFd0zhYq+G4v4orKpn4Y48v31a6xxuKmqdSJKsg2j38iI+tXA3X2w42KXthkxGA3anh6s+WN8k5AdNPYHelFTbuePzLVqBi9wwvcHwvferbXy3pSHcVl7rYEhiKFP7RTOyR7h246nGSHNSL6qR0pGw78M/yCr/bbmmmtX56wLvEcg5QmoXlsaiudP7x/DDbVOIC7W1aPy53B6+35JDQpiNM4cnsHBHHo/+sJPoYCv3zR3A6cMSWXrPDOYMjuPu+dvIKK5puDe99utye7Tvm19Rx9h/LqGs1onJIOjnFQrx1/ReNcLPHpmkeTJVPlI6vQRbTSSG2UjNr6LO4eaPPUW8pkQV2kJUkIXEZqrr24PJaODpc4e12qO6JU7qJRuwNXYX/1wgN0ra8vApfH3zRIKsJkwGgdVkYGzPCK6fmsya9GIuemut1j6sI1TZXXy3JRujQTBYOcf1Xp7xsAAzP23L1UKh0L7ChPJaBwdL5ePz7lOuLs56RQeR+ezpLL57OiD/5t0jAn1yODtKa+HpqGAL323J4a4vt/o8rxZzTFC6PamLdI8kNZG5UlUnrCajZgjaTEbyK+qYvzHbJ4d1UIJ8vat56LEhNsIVI3hZahG7vdrENWZoUhhL7p4GHLmCJp32U6uMvy92snvT4IQQHjxtoM891BJHrfEXp+TK7VdWVq8s3av02jVwoLSW+77ezg6l+uzicT34eG0W1364gXqnWwsPNZ7AN2TK3oS7TunHtVN68+6VY3lukeyOf0E58YEWI1FBFhLCAlj34Gyubkd4qDme+CmFVxqJhHpjd7mJDLL4GHffbMomLMBMZnENn143nsfPGqJpXbUFIQRDEsOICm75QthfVMMbK9Ip8dMD+NM/sxjxxG/UONxYzQaq7C4uemvtIesv2SsqUCsk2J5T7vPaHTP7EtVCN4mqehc/bsv1Egn2UG13aQUjIHvOftiag93lprTWQUSgmU+uG88VE3ryv+vH8+Q5Q7Wcw+aMnttm9uXJs4dw9sjENn+v1Cfn8u6VY9lTIE9Wap/Qv366iWd/SaW0xtFkEvKv8ydwerrG+HN5JF5dto+/zepH/7gQrv1wg3YvqMje8eaHiP/+vpcNmWUMjA8hJa+SJbsLWLQrH4vJwC0z+mpyHUIIAsxy28GTB6gewobvVeNwU6csLHK9ejs39r6qkkWXeYmhm40GCqvsrM8obWJwqPmFgVYjyTFBFFXZufTdP1m7v4T/LNnT5ry0PQVV5FbUd7qbRUWtk3//msbKvW0vFmpMXkUdxdV2nyKB8ECz1kNaCEHaP+cxa1AcxdV2auxu1mWUau3v2kKQxejTLzy3vI67vtzG77sLsSgdfH72ElkODTATFmD2yV9tT/FHWn5DGD8q2KJdG97h01qHi7zyevrFBjO9fwx9YoJI96OD115qW9HN++6WyZw2LF5rEapS43Bz2rB4pveP4abpyfSNlVMm5JC4IDHMxlRFEsqqjOuP/7hLk8Wxmg2aXI2/MJ26GNqUVUZ5rROTwUCg1ehTMZ9dVstHazLxeCQWbM9j1BO/aR6/ruy8onNoqff6Tf/yxpp2KUl40zc2hBun9fFRNWiJo9b4U6tkVX5TEmYtRqEZdXVON0OTQrliQk/6xwXjdEvsLazy8hA0NVJGdAujW0QgPaOCGNsrskkfvCCriQdOG8RPt3ddNVlsiLXFgg+Hy8O+wmoe+n6HNiDc+/U2th4sxyNBr+hArprUq93J//M3Hmw1TKhOkMV+pGjUvDeL0YBN0Q06lF01r5ncm8uVif1vM/vxlqJ6D3DK4HgfAejGqB7cIKtciFBQWU9VvdPH+M2rqOdvX2xlWWoh5TVOn4rFxPAALh3XYFQ0lrBRGd4tnCsmtu+32F9Uw+r0ht9BDWPtL6rhx605XPXBejY2yl/yq/PXSBi5M6jnS/Usp+VXaZWCmw+UcdrLK8kpr9Mme3+cNTKRt64Yg4Qsi7S3oFprZej2SLy+fB9DH/2VnTkVBFiMXD6+p9a20Pt7VdtdvHPlGL756ySu9xIjbmxgO90ehncLIymiIfn+PxePZGJyFBe+tVZr6aYyQDFgzhiWqIXXA8xGekcF4XRLzbZIbMxOZYzI72QlZUFVPa8u28cV763v8D7u/WobN32yyWcB5m8xdsGba3l9Wbo2EbS1+4YkyZqmDpdHCyOqFb+J4QGaZuPUftFaUdnYnhFNKhX/8sYarv9oA23BW+UgPNDCL3+bxlUTe2qC4C63h5FPLGbav5axt7Ca6GAr8WE2dudV8sHqjHYVlzT5bK/oQHmtQ0n58PWEmwxNdf5mD4ojxGqm1uHmgXmDGNVDlgtTPaNrHpjFJ9eNB9B0/L7dkqNJftlMxobFiZe4/3dKWFftTb1KiUgYDfJ+vFODftiay6M/7uLVZXKnpbJap+Y00T1/xw7ev+mmrDL+8X3H1ABKqu1kFNe0ORXrqDX+gCZVXiCHTrwLH5wuiYLKev6uiDX3jQ3WJg0hBLfP7Ms/Thukbb98TxFLUwtYt79EkxcICzBrK2m1K0ZFrZNrPljPsrTCTn+P2FArhVX+Jw5VoqSizsmnfx5gf1G1UrHcMNlMeW5Zh/LrXvxtTxOx0Maok4L36lulyu7CYpSlXWYOlAfixsLZXU2JYvzGhNhIDA/gub8M57rJvUnNr2xxla56ieYNTWDlfSdzxXvrWZ5WRITXpKQOzOlFNTx+9hDOamRcNGfwebMpq4wL31zLvkL/vX/9cdp/V/LB6kztcYhVPqaIILPm6dqQ6ZsW4HR7MAjfY4oNsdEnJqhL8ixVI/LZX1JJza/06WFa73CTklfJhWO7tdjJpG9sCKcOiSchLIDCKrkaXDX+nG4Pzy9Ko9ruok7pn+wdXvbWvayxu+gWEciYnhE+howaUlOxmY38eNsUTccT5PtV7bYQqhjkUUEWhiWFEaEY97VOF/3jQhgYH0Kw1cRZIxOZ0jeaFxfv0YqIquqdfL7+AHsLqrC73Dz+0y5258lGnzp5d0bKBLqu4EM16EZ0C9NaT3rzwLfbqba7CA80a9u21RhQ76P9xTUEWoycOypJi0gkRQQQFWwl89nTOXdUN1bfP5PMZ0/nvNHdfLwNw7vJclxLdrdt7PROzwgPMNM3NpjHzx6qVcYaDQ1dL26alsyVk3oyvFs4IBekdKbrhZqb+PLFI1mxp4j3VmWwJr2hWvb6jzby47bcJtJb988byO78Sh74dgdV9U4igyz0jg7yEadWmdIvmqsVvUz1Hnv0rMHac96pPX+fO5AQq4mkcHnuU3ulXzGhFwEWo88YeMuMPsweFMd7qzK0azMq2MKZIxJJju54W0+dw0ttI+HujsqAfrw2i5P/vZy2Tg9HtfF3lyJgqnLvnP6cNyoJi1G+WZ4/fzijeoQz9z9/aKunMT0judJLXf2eOQO4fmpvtj0yB6NBkFVSy/urMvlgdSbP/ZKGzWwg0GIkPszG6cMT6BsbzDebsrnknT9ZllZEfkXndZNiQ2yUNCPuahCCL2+coLWqyyyp9Svz8kUr1V7+sJkNrVb7qqtmyY9Pr6zGQUSQGSEEw7qFMTA+pM2VRB1he3Y5Ty2U85j+ty6LbzZny56amCD+7+vtLYZ51HNmNclhQIAnzxnKlzdN5MKxco5VXKisyp9eVM15o7sxWlmtN8a7XWBj3liezvrMUtLyO5ZvdMWEnlrY1zustSHD1/N39shEXr9sjM9zV03qxW93Te+SsLv3tZhZXIvD7SX1ovx/5ojEJgaYP2KCLZTWOKh3erSKYZvZqGkUSpIc5vp6UzbXfyT3alXv0QCzkQCzkXdX7ufuL7fyxfoD2n7bktO1KauM+cq9ERogn9eVfz+Zb2+ZpPWd3p5dgSRJpOZXsb+4BpvZyIwBMbg9kibgfsGba3ng2x38sbeYLQfK+WB1phaie+2y0UDbvWfN0dnuLOszStmZU6mlMrgliS1+cok/Xy+fj4hOGH8Aryzdx9PnDtPCl4nhvnmPktQgq6V6/j6/YQKf3TCByCBLm8eKWq9w/VWTevLF+gOaNAr4ejYvPKk7QxLDuGhsd+5W5ofOGOVCyPnVsSE2eisGk7eht1xZ/Df+7SRJIsBsZEdOBWe9upqYECvL7p3BWSOapoPEhdo0CRe1IGdSn2iGJIUSbDX5aLPOGRLPjsdP1QxC1VgMDzLTOzqIsICGaIUQgkl9oqioc5JVUoPRIAi0GHnlklHMG3boW9/pdAxJknjo+x2sUyR5+sUFc9/cBrmfAcoY2l7qnG5sZkObFTiOauNPLTB49dJRTO8fw2lK1axaBu90ewi2mrB76fZtOVDmkxfx07Zcnl64m0CrkXBlIHS4PErBh6DG4Savop79RTVsyiyjxu7iQGktKcqqvy3eoNaIDbUiSVDsJ6/OYBCMT45ifO8oxTitaXaSaO+kbzMbW632VVeS/ozE0hqn5j0pq3GQml+lSQq8fPFIvrixawWHvXMe0/Kr+HBNJnsLq7S8t5akXkA2pkpqHNz+mSzLMSAuBLPRwFWTepEYZiMyyEJyTBA7sivYmFnqdzIPbJTv1BT5GDp6XcwYEKO919v4axxq6hcXovX7PBR4V05rOn+NCiq2HChvVufPG7W60SDwKdB484ox9IuVJWTeuXIssSFWLZdpmCLW/s6VY0kKD+Cphbv5dksO32/N0dI1vm/Faw3wxfoDWoWpGk5XK/bPHpnEqB7hPh5FVVJmeLdwTe6lpNpOquL5PlBSo4Xa1NZ36rE2J8jdVjrr+bvivXVAQyXnsKQwwoOaTz8IC7QQHmhmYHwIQZa2Fa6FBZj53/VyuPK7LTm4PB7yKuoxGQTRQb6pOJe+s47eDyzk1135jOsdxdJ7pjOsWxifrztAeKBZO3+t4V0ZnBQeyEPf7+SGjzf6FGipqJEHg0FoeXbVnTD++sQEc9fsfny54YC20FeL3yRJwuWRsJoMDPHy6DndHpIfXMg6ZcHmL0LlTZ3DrUVg1Htre3Y5AWYTOx8/tcV+rup4u+VAOe9edRLPnCdX5FfVOznjlZVkKXqOWw6UE2w1add5V6ow6HQtVXYXn/55gIve/hOPR1ZUGJIYRp+YIP51/nDuPmVA6zvxQ53D3S7nzFFt/Kl9d0/qFcnsQbHc/Okm0ouqiQqysOjOqWQU1fD91hxqHW7qnG7mDI5jY2YZd3hpct3++RbeWZnBR2syufOU/kztFy1LvSgdDbz7KuZX1pNWUOUjj9ARPbfGnDIojm9vmUSEn4G61iFX0uVX1JMULssd/OO7nZ3+TJATjetbmXAuOknOc/NXnXfe6CStIfzSVHkF3F8xjM4emdQmr1B7iPOSw1HboJkMAqMyoLWU2zOqRwQbH5rNwPgQrbLx4rfX8vP2XAItJr6/dTKT+0bTOzqIvYXVnP/mWrYfrGiyn7tP6d8k39QfHbH9vrtlkk/PRbWyD+RVm/f3S8uvYk26b77mgu15nPv66k4bISBXHKvts+qdbsb3jiQ5Rp5MVWP7xcV7mhW/9UY1Yn++faom8AxyC6zFd08nPNBCn5hgooKtmBTdzM2KmHOQ1Ui9y62FKiYkR7H3qdPkCttmhMy9UT1OwVZTkwrspPAAvrtlsnZ8y+6dwTc3TwJkyZRHzhxMqM1MZkmD4HNWaS3rMuQVuVq9qqZ+VHbCyJCrz1vuNd0STrdH88qpHrhnzhvOyvtmNvuecEUjb9Gd09rV8N07DPl/X23njz1FfH/r5CYeBVVwP9BiJNhqomdUEM8vSuWphbvZX1Sj5Vy2xhnDE7lICeWn5FVoCxN/ieve949q7Hf2fsgsruH7rbn8VynKK1NST9TUiDtm9eODa8Zp29c63D6htT4xLXtqqu0urT2dWbn+X1m6jyd+Tmn12NTFyoo03yKhPQXV7MyppF9cCJP6RDGqR7gmHH/Fe+u48v2O55XqHFq8uwut3V/C3oIqth0s5545AzhYVtem+ccfanpNWzmqjb8R3cPpGxvMlOeW8vAPu9hTUM2mrDJMRgMD40NZmlbo402b0i+apIgAvwbb4pQCftqWi9Vk0Dx/FqNBE6RV3fVBFpNPhWVnRZ5BblM1ukeE32bLJdUO7vpyG+szS+kdHcTuvEp+3CbLjZw5IrFTLV+sJkOrnr9gq4k+MUF+dblOG5ag5Vep3tYzhsvhhMd+3MUdXSg4DPhU5qoYDQ1u7Dbp/HkZ7h4JduZUcu7rqzXB8Ksm9eKGqfJv7u/cpuRV8vHa1g2ejvD+6kxN7gVkw3v+TRNJCg/AI+Ejt/Phmkzu+Hyrz/tLauxsOVDeqgZhWwi0mLhsvNw7t87p5oNrxnGpUmwTFmBmnJL72lK1r8qYnhG8efkYkiICmvVObz1Yzu68Sq2A5FlF9Pbc19f4nG/VCC6pcbRYJKWiFu38+4LhrW7bOzpIyw+UJIk6pbChSMnHTY4OIqukVpMdKauRjYpXl+5jdI9wzm+m1V1bOPnfy7nuo428efkYHmskztwW1OrNayf35pEzhrS4rSol1Fj6pi3sLajiBiU0D7Lx4fZIPm01GxNqMyNJEq8s3evzW147uTcpuZWteuzjw2yMUkTwF+5o0OP09ownhNkQwlcmSf27cb/s9rAkpYDHfpKNMNXzV1qrGn/yfdZ4Pmmce5zcivGnGrF/m9VPazNpMxvZnVfJbZ9tbrELU0Mvdxs/bM3hjFdW4nJ7NI/fxD5RfHbDBJ45bziPnilfF0aD0As+jmIiAi3cMbMvIOe4p+RV8uLiPfy6K5///r7Xp5lFe6hzurG1UeMPjnLjz2IUGIRvtwuzUSBJEh+uzmC/Vw7YGcMTEEKwr7Dar8FmMgrWZ5Ty5/5SHG6PLN5pMmhhKHUlrur8gZw47s8gaS8Ol4evNh5kZ05TT5N3/9wPrzmJZ86V3foxIVbiQqyd0nV75ZJR/OeikS1qbv2+u4DJfaK5fWa/Jq+lF1VroVG12lcNqX+4JlMzUrsKuS+w729nMgjNGG+pvdumrDKu/2hjE4MhxGaivNbJx2uzqKhz0j8uRFupR/gJS327OcdHd6sx6iG0JwSvDvg/bcttUpE6rnckt87oA/hKE7ncniaTjuo1e+i7nZ0S7wZ5AtulVLE29qh2jwzko2tlT0djrUx/xIXamDs0vkWJgbXpvoLs3hO790p4y4Fyrv5A9los2V1Aa6ifOaqZ/M3mSMmrZNAji1iWVqjliI7tFcGB0oacW9UYt7s8JMe0Txi6Mao3eu7QeK6e3Lvd4svqZD68W1irIq4D40O4cGw3Te/r9s+38LiXBl9LFFXbtaIrkGWJUvOrtFC4P8IC5Lzg/yzxlbOqqHNy2n9X8uiPDZ/9weqMJlIWaicbi8nAVV752t7XyNoHZpHxzOk+v8GghFBW/N8MJnYiAlHgVYhXXO0gKTyAy8bJiyKPJNEvNpgF2/OY9/JKbTu1OE4tIEuOabm4wmIyEGQxUm13aeOGGr5euCNPu6/9oc5FVpMBIQQ7cyq58ZNN7MyR71214to71SnUZtalXrqAB7/b0eb7pi24FPmxyCALd88ZQOazp3PWiESt4EMVkm+LR9gfl47roeXBtoWj2vjbkFmmaaOpmAzyTaAKnA5OCOWh0wfxwoUjtCR2f8aO6nW7bkpvPrzmJP59wQieOHsoX22U80oWKe19Ai1GooIt9IsNZsnd05kxILbJvtqLQciesg8V0VlvVC+ORbm5cyvkSaJvTDDhgWYm9Y3mq5sn8tYVY5q8tzXiQm3847sdDHn012ZX3z/vyGNXXqWWn/P8olS+35LDgu15zHphBe/+sR9o8PypBRmHii9umMhtJ/fVwqomoyA21MZ9pw6gX2zzK+zc8jqW7C5oYiB6C66qxpT6W0d0wKv68BmDefXSUS0WhTRm5X0zWX1/0/Dc3oIqet2/gMIqOy9dOFJrzQeyl7Ox1837+Ftr99QaGcU1XP7eOt68fAyXjOvB5GeX8uWGhmILh+b16JohQjWAe0TKE+XJA2I03crqehdWk0EziNZllHLBmG58ct04/zvzQvXeNg6LtYZaGVxR5yQ2xMqMATH836kD2fTQbDY9fAr3zulPrcNNvVP+t2hnPvd+tY1duU0XcG3hXCXs+vyiVJanFbarAwZAuTKZh7Xhmv33BSO4cGx37Z7PKavV5FpAFp1vTgJKNSKSY4LoHhmghVZ/3t78Qk81wBsbtLcqXVw++TOLGruLfYVVPP5Tio/sEcD/1h3gnZUZ7PnnPIZ1a/Awevckzq+o16qvVWxmIz2jgjpllDeeK/4yOokeSg5fiM3M4runM31ALLvzKpEkuTmAmpZz0/RkHjtzMINayNnTPsfh5r1VGdqiTV3kRgVbW8wfVg3NslonJ/WSFzhLUwvZW1hFlKIN+96qDAY9sohrlEVTWIBZu150Os5n6w74qDR0lju+2MIpL64gr6KOPQVV2v3ZuNq3os7ptzi0NSb3jeaM4W3Xn+267tiHCe+qTpfDzdheEVw7uTdCNOSMea9cVdRBLCkigPJaJ5klNcwdEu/jdQA5HHb2yKQWJS7ai8lo4MwRibIu05mDCbGZ5TZ0RoPmCbGYDGw7WM7Ha7O4fkpv3l2VwaXje3DbzH6K9Ev7E3h/313ARkVCZGlqoU9OnUqt3UVJtZ2ftuVyyuA4Xl/uq32mhtVaWp12JUaD4NQh8cwaGEtlvYsgqxGrycjUfk0lLbxRr4vgRk3VA70eq/kQqhezI5XLvaKD6NUBGQV/bQJVD85/ft/Lv/4ynLdX7ufy8T0Iscn9p02NPH/ehlhnwzoNOoICu8tDTnmdNvEXV9uZ8a/lgOx97wq6KT20J/aRvTSyR1FgNgoigiz8dtc0BILXlu3jt5R8/tWol2pzTO0bg8kg+Gl7Lhe20s3GG1UzsrLOyYVjuzN3qG91ZKRS3FBe68Su5OulFVSxaFc+QxKbD4E2h2qgvL48ndeXpzP/polaBWhb6BMdzPtXj2V4C+FXlS83HOTtP/az96l5gGwMFFXbKayqZ0lKIe+u2k9VvYsFt09p0nZSnYhm9I9lxoAYzVDz1zVgUEIou/MqtfBriNVEict37I0JsVJUZWdxSgHbsssxG4WPVA/IOXHeotX/uWgka9NLfNJkJjzzOwCZz56uPedye3h3VQaje0T4PZfpRdXYXR7NQ9eYwqp6ftvl613OKa9naWoBMwfGac+ZvdJOzEYDK+87mdyKOu2abg9qDp/63WJaEeFXjfaSajsJYQ05sCv3FnOOIlXVO1o+DlWPMi7USnmtk3qnm+yyOhanFHDB2I6nLJyISJJEr6hAMktqqbG7fBbm7eXlJXvZmFVKz6hA8irq+fTPLN5csZ9bZvShuNre5DqSJJjx7+W8fPFIxvRs+xixO6+SQItR6zPdGl0yowsh5goh0oQQ+4QQ9/t53SqE+FJ5fZ0Qoldb9uuvWkxdqamrTLfS5Lv3Awu1xN+RXqvH588fzgsXjNDkNVakFXHGK6u47bMtbMwqY2p/2YOjrsTU/3fnVXLhW2u7rEH2X8Z0o87p1sInE575nSd+aughq+bnbTlQruW2qQNFnwcXcvHbf7b7MxftzMdqNpIUHsDzv6b6DRXWONyU1Tr55M8s0ry8Ayrqb6B6boa1YfLpCkxGA5FBFrmtnMvN1oPlbMwq5cxXV5Fe1FQCRDWiE8JsvtpnXjazGnJ59dJR7HhsTockU37fXcC055dpOTft+T6N8Q5rZZfXsXBHHjXK5OtyS1pyuPf2o3rIPW4bdxxoL2q6wzO/pPLB6gygIcQrkCfkMT0jmNwOD2dLdFeEmVX5lJV7iyiutuN0S1TbnfSMCqJHVKDSYrHtA21YoJn4MFurk2hjQhQxcO/wmMcjceGba+n74EIGxIfw+mWjCbGZqHe6uWVGH3pGBnY43P65l4QNQLW9fcZ7WKCZmQPjWu3YA7KB6fJI2vUdFmCmos7JjuwKHvxuB9dN6U11vYsr3lvfpKhIXQC8vzqDDZml9FQ8tf7G4l/+NpXMZ0/Xrm3VoI71MhQfOn0QA+NDqKhz8tO2PCb2iSazuMYnElHrcPks2s4ZlcRz57eew2k0CJ5blNqkY8rS1AJeX76PN1ek+422qFzx7no2KlI5u5+Yy9tXjCGtoJInf5ajGx+tyeT8N9ZoQ4i6YDIYRLsNvzOVnHJ1AXfFBDm03Forrl6KYTdzkGyMrrzvZM4f0w2L0cALF44EYFxveUGlLmZP6hXJtZN7Y3d5+H13Ac8tSuXrTU0rp3WaRwjBg4o+8B4/82Jb2HKgjPJaByv3FlFV79KM97zyeiKDLGSX1fHHnmK/+rXZZXU88fNuzn9jDX/uL2nyuj/u+nIrTy1oe2Su08afEMIIvAbMAwYDlwghGmc0XweUSZLUF3gJeK4t+z5rRCIhXoPCb3dN41wl6dpqMnLBmG5M7x/DS0vk1mxqLpf3yvzCsd35y5huWveGBUoy5enDE+geGah5gfrEyJIUQgjWppcw7+WVrM8obXd4pjlU0c38ynqcbg/F1Q7eX53BsKQwfr59CsO7hWudC9QBy7sf58YWegM3R1mtg+JqO/fPG8ieguomiaSSJGnGdJ3TzY6cCoRA0/UC32pKgG4RrVdgdpY9BVVc9PZanvh5F4WV9VTUOnn4h528slQu2tiQWdrkPU6vMGV5rYPBCaEsvGMq545OaiJMbTIamu3QERZg9pF1aMynf2ZxoLS23X1FVS/epV6tyWxmI0EWI5dP6NmQ16hMMH+b3Y+nFVkHlSn9ojlvdDccbg/bDpZ3Ss5BzaPdV1itaUhqUi/K+Zo3NL7VZPa2ohoPqn7bVzdNYv5NE5naL1q7b3/dlc93W3I0rcC2UOeQvRsHy2pb39gLg0EQYjVRWe/inNdWc9/X2zAYBOszS3F5JPrGBnPasASCrCZW3HcyN0xNVqSTOpaD2zgvrKJO7pnd1u4U+wqrWJJS0KFwUGiAmfyKeq2X86lD4nnj8tGU1zm45oMNWlchSZIIspo0qaPP1x9gRHd5LE1oQ29jtWjux9um8JkiF7Mzp4Jf/jaV4d3CKK62U+90c/6ba7X0FpBFngM74FkRQhBsNTXR+bvry208vyiNjOIa9hVWaWODw0sSzO5y+yx2AyxG5gyJp29MMBnFNVz/0UbmbzxIbnmd5pV0uD38sDWH6z7c4JNj1xZUDUH1Pu8VHcTkvlHa880RYJbPi3pvdo8MZFSPcBxuj9aRJ9hq4t0rx/Kxkqc7PjmKR84cTFiAWevc5NGlX9rFwdJaPJLE5L4dyyctrXFw6TvrmPPSH2zMKmNc70htHsouqyNG6VJTUFnPHbP6sfGh2QBaaB9g28FyNmaV8VMbc+vrne5W84G96QrP3zhgnyRJ+yVJcgBfAGc32uZs4CPl76+BWaINbpeqehd2l4ebpifzyBmD6R8Xohkh/eLkm9Tby6PqPvmbCExGQffIAM2Y+efZQ0kKD9C8SLtyK7X8Qm/9t64Kd0YEWrAYDVTUOX1CzUFWE0OTwgi2mohvFIIZoajYd5RNisE4JDGU+FCblgdSUefkQKks7OvySNrEXFRpZ0LvKFZ6JXerq0k1zKi2JJp/00S+vWVSp46vOTweiVqHmw2ZZZTWOLScGHUACzAbya+o9/mdAy0mekYFYjUb2J5dwZ6CKgYnhmI2Grh8Qk9OHRLn97Ma0y0ioMnv0BWYDXLSd2NZiF1PzOWisd217+jyeFifUYrZKBjTs2kRg7oKVKU79hRU8caKdH7cltuqfMi+wmp+3p5LVb1TmxCHJIZq16Mm8qxc8x+uydQMg84ihGD1/TN596qxgFzhOa53JB9fO06ruE8Is3HdlN7895JRbd6v6sFUK3Tbw19n9GVa/2gOltY2KRKzmgys2ltMTnkdSeEBRARZsJkN2J1uNmeVtbulmKlR2L+sxslzi9IY/tivfj3Zjfl5ex7Xf7yx1e1ALiLyNiq6RQQwZ3A8B0prCVJ6l88YEMun143H4fawYk8hlfVOhj32Gz2jAll05zRALoBQ1RTa4nG8YVoyKU+cqv22AKv3lci5zOX1RAdbuUHp2nHx23/y/irZu1hjdxFsbXnS+u2uabxz5dgmz4faGnoKq4sh1VC1u+TCvq83ZbMuo4R//5bGbZ/LeYjfbZZ19+6bO4AtD5/CqCd+4/lFqZqQ/JLdBezKrWRgQijdIwOZ2i8aIWDbwQrW7i9pUpjWGqqIuzrt7S+q5i+ju2nepeYoV4qO9np1FFK1V1/2KrCZPTjOJx2l3ummqt6pnRvBoenHfrzy9aZs/vq/zbx31UmtFpM1bgRxsLSWteklPH/+cE7qHcl5o5O4dFwPzfjLKa8jOsRKYpgNl0finT/2Ex1sZWT3cM4d1Y31/5ilzcmDEkK1wtayGgcb/Tg+QNaNrKhztiuVqSty/pIA7+zzbGB8c9tIkuQSQlQAUYBPzEEIcSNwI0CPHj3YU1CFw+3hgXlNb5D/XDQSo0FgMxt5+4oxfL81h7AAMzdP7+M3P2xgfCgr75tJRZ2T/Ip6rdLzgrHdWZ1eQlSQRTux3lWXXSHyDLKnYdcTp2I2GtjqVe22Jr2Y7NI6LjypOyajgQFxIZw6NJ6/Tu+jWfGnD09gYFzbNLO8uWx8T15dto+eUUGsfWCmViF29QfrcXkkfrx1Ml/eOIG16SX85/e9nD0ykXnDEhj1xG9cOakX2WV1jFB026KDrSTHBGnGdnvyldpLkFeFdYDFqEm9jO8dxa+78okNsXLDJ/JEqOYA/WVMN/4yxn9ey8NntF1a460rxvj8/o05Z1QSy9KK2qxhphJgMbLribnNvq55/jwSTy5I4cXFRt696iQtRw5kbbwF2/OwmQ08MG8gQgiKquz8saeIaruLlNwK7vdzr4A8Md41fysgDyiT+0bzxmWjySypZVduJYMTQrXKQavJQHSwleyyOjKKq4kM6prfOsmPbp/3GnB4t3CtbVdbCbGZefC0gcwa1Dbj3pu/zuhDelE1JTUOLa3h0TMHsyOngmq7i8vfW8ff5w7E5fZw8sBYrpuSzMasUh79aRdXTezF+X6ut125Fbg9EsO7hXOgpJbHftrFrSf3aVK4VlbrYE16MTUON//+NY03vPpYe/P2H+k8vTBVe+wvfaAx82+a6PP4qkm9KK52cPHba6lxuLVz3i8uhJX3nUy3iEAq651U210s2pmvybpM7RfNgLgQThsW32zenDfeoVuT0cDXN0/UFuRJEQFcP7U345MjCQswU1BZzxM/p3D2yETevmJMq4vs/nEhWuvAxp9ZXutg5r+Xk11ex7/OH05ZrYPThydw7sgkbv50E19vzuaSk3qw9WA5cYqGWmp+FTdNS+bGqclU1bsoq3Xy+vJ0Pr9hAm+uSMdsFCxNLWTmwFhOHRLPqUPi8XgkUvMr6REZ2O6UkVE9wjVdRJBz9h79cRfT+8e0aFiroukDvL77SGVMVnsfN8bjkRj++G9cO7m3tmiv66Q6wInGjpwKenkVE7k9EgbRVOVh0c587vhiCy9fNJKp/WNIL6xmaWohL/++l/UPztLC/SDn0z50+iDeXJFOZKCZIUlhmI2CN1fs57aZ/fj+1snatt/dMomM4hq+35Kjtf78yxtr2F9cQ8Yzp/kcR1ZJDWe9uhqQPcNt5agq+JAk6W3gbYCxY8dKX/91YrPeDO8bZs6QeOYMkbsh3D9vYIufERZg9pGk6B0dxA9eJx3ocpHnhn3J+y3w6prwzaYcVu0r0pLVf71rWpP3vXbp6A593r2nDuCuU/r7GLAOl0fLKRRCEGgxaSvGvIp6LCaDXyMlyGpi6T0zOnQc7aVbeADXTOpFr6ggekYFabmciWE2Prj6JEJtZoYnhTWrd/fyxSPbbURon91KLk9XFwOpmIwGTAaBR5KFj2vsbl7+fQ8T+zRM5Gq+mdlo0G7+yX2jmdw3mg/XZPDN5hzKah2aZ8AbtXq3W0QAJ/WOJCbEyrxhCdpC5PIJPRmraPsZDIL1D86i3uVuV/7dkeLGaX069L6yGge3fbaFQItRK0JQvZAej4TFaCA1v5IftuYSHWJlaGKYlv/TXBeelxbvJbuslkV3TuNfv6WxNLVQq/QF2YOVml/FgLgQLX2hJcOqtKbzVZtWk5HEMBsHS+uayKKo13uozczoHuG8umwf+wqrfQorGrcZbCvq9QSywaIaLZsfPgWDkMebuFBbpxbYwTYT6zNLqaqX8wbH9IzgvxePIsRmxu2R+PCacThcHsICzKzcW6Tl2T52VoNWoneobGKfKCb2iVJa16EtPN0eiXNfX8327Apmd2Chcd/cgdw3t2FuUvu2r04v8dsSTqVvbLDPbwGQGB7Q5DlvDAZBYpiN7LJaLezbllzVfYXVPP7TLu49dUCno07HKsvTCimvdbJqbzGXju/BhW+tJSFMbv335op0djx2qjaPL04pYG9BFcOTwrj98y1cN7U3b63Yj8VkoF9scJNiqsGJoQxODKVXVBARQWZG94gg5Ym5fqMIPZW5b3NWGd9vzeWGjzeyX5EJq3W4CbKa2FdYTUywFYvJwBuXjWZAfEiraQTedMXIngN4l291U57zt022EMIEhAGtZjFaTUa/wsiHGu+E5a6c/L7ccIDU/Cr+4iUWm1ZQ6dcj0lWoA+v8jQdZvKvAJ4F/TXoxewqquWRcd16+aCQv/76XgQkhXSJv0xmEEJzndY7U77BwZx77i2u4d47c/sa7GvadP/azMauUt64Ye0iMs0PNSb0i+e4WeRFSY28w8rxRPZIhfvKj1G4YzRklahXnmcMTSQoPoKCyntR8eeDqFRXYJJfTYBDHhOHXGV5cvIfdeZU8efYQn+IbkL9/QrhN02W0mQ3sKajSOpOMb8bzrWoT1jvdWl/YOqdbK7oIMBu1yT7UZubcUUncPqupxqZKRZ2T6GAr84bGd6o9nBCCXY+f2qSC3JshiWFsPlDu420+FKj3c1s6uLTGe1eN5X/rDvCvX9NYfPc0EsICNIN2R3YFYQFm6hxu8ivrqba7/H6m1WTAZjZwh9fvIITA28ljNAjOHplEsNXEZRN6NNlHeylRjLLOtKZriaSIAHLK6/jyxolc8s6fJIUHsD6jhKJqB6c30/d3Z04F5XVONmSUnjDGn93l9rEx3v5jP2sUTdJZg2LZll1OaY1D613+6658TU7l+6057M6t5IfbJnPGK6t4a4Usi+ZweRif3HR8qHW4yKuoZ0q/aM2jaDYaaClSq3rhvXtduzwShVX1zHv5D0IVOaKO9HLuioS2DUA/IURvIYQFuBj4sdE2PwJXKX+fDyyVjuLmg0kRAQxJDOWNy0ZrYYuuYFduJd9uzmFoUhj/uWgk8aE29hVWd8kg2BrphdUs31NIUngA988dyDc3T2JjVhm/7y7AapLbwO0vruFo/FGsJiOPnjmYQIuJFXuKSC+qZntOhSZSDLAzt4LdeR2ryjpaaWz8qSE/fxWCCaE2JveNblaXT01Q351XyYGSWv7cX8JV76+ntNbBr3dN862QPkF44uwh7H1qHld4CQt7kxBmI0PJt7GajKzYU6RNDK0ZxkVVdi3fqt7p5p/nDAXg2UWp7M6rZGNmKW9fOZaXLhrp877SGoePnl1FnYPwQDNPnjO0TRWwLRFkNbW4mL59Vl8ePG0gl43vvHFzuAgPtJCSKy+gE8IC+HB1Bvd9vc0nV3Vrdjm3fraZwiq7X3FtIQSpT87jlhl9W/ys66b05rMbJnByFyyOL1YKEE8eeGjuu+hgKyXVDiwmA9/8dRJXTerFkwt28+aK9ObfpBi7R+MccCgor3Uw9bllfLI2kwe/28Gt/9vMmvQSekUFMr53JON6R2oFRWqkxTu/L7e8joRwGyE2cxNVBH/9mtdnlDLrhRW8tyqD7DYWqM0ZEu+Tr/7JdeMICzCTW16P0y3x5DlD29xDuzGdNv4kSXIBtwG/AruB+ZIk7RJCPCGEOEvZ7D0gSgixD7gbaCIHczQRaDGx4I6pHbKmWyIu1EZFnZNHf9jJ3KHxrLl/Jh6P/1yoriYmxIrTLRFiMzG5bzQWk4GDpbWax+ezdXJbpu4d0K461BgNgrE9I7WVuL9K29IaR4dvgqOBnLI6Xlq8x0dCpnGRgPr4lpObTlLDuoVz/9yBfkO+IBdYfHj1SSzfU8QvO/O0al+zwXBEvOtHA0KIFkWsE8MDtNZhsneo4Txta0UCKtPrd6xzuLX3Ltiexwu/pfHwD3LngOcXpTL+6SXatnkVddwzf5uWq1VR52yxc0pXEhti48ZpfdqUV3g0ERpg0vqMP/ZTCvM3ZnOgtGFytSrfZ3i3MJ/e00eS0T0iyHz2dB/tvq4kMsjCwbJaHv1hJ1sOtF8p4njgnvnbuPDNtT5FEvVON/uLqtlXWM393+yguNpOoMXE9uxyraf3E2cP5cubJmI1GQmymKixu3ArhWX/XLCb/yjqInnl9SQqv5+qEGE0CG47ua/ffGB1nP3Xr2l8v6VxcLR5ekcHE2A28tcZDfUMavchf9q9baVL4jqSJC0EFjZ67hGvv+uBC7risw4XS1IKeGnJHt676iTi2yBz0BbUjgbfbM6hW0Qg54xKwuH2HBbPnxrW2pQlV9BuzS4nNb+KuUqu5LZsWTfucEi5dIS1+0u0qieXR2JAXIiPVIPcmqnrq3QPF5X1TpamFWq6k9DU8xcWYGZK3+hmDbyWMAihGRFOt0eTDDGb9CrA5rh5eh8GJ4TyzwW7sZqM2Ly8Rv7yTb2DGd4egkCriRu8KnUjAi3syq3kivfWsaegiuJqB2n5VWzMKqVPTDApeZX8uDWHKyb2Ynr/GAwd0KM8kfjH6YOb5GbHhVoprpInSLU70QVjumt5h8c7pwyKo87h5qO1WXy0Novzx3RjzuC4FiXD1DN4FAflWqWizkllnROXR+KbzbK24QVvrWVAXAjf3TKZNenFXOfVu/qWGX2YNSiWiX2iSAwPwOn2+Iy7wTbZ+CuraXjuP0v2csuMvhRU1ZOgzN2XjuvBZ+sOEB1s5d5TB/g9NqtXhXh7utLcP28g988byJYDZUx65nfOGpmkOUA60qVK5fhO6ukE938rrwpa6ifbXmYPiuPO2fVcN0Wuwrrv6228efkYJvjJD+hq1FDhB2sytSRgaDBIHz59EOszyzrVKulQ8uwvDeKVbo+H5Jgg8ry0wkpr7AxLan8j+6MFTc7GA6cPS2DBjjzumePbp7F7ZCCfXt+4kF5mc1YZz/+aylPnDmsiJwNyOzc1B83hlrTcwMPVueVYpH9cCMnRQZw/ppuWcqDiT29PkuD/Th3Av35No7LexcD4EB48bRDT+sfw2I+7cHsk4kKtRARZKKqyk1dRT7DVhNsjsWhnPi8t2cO2R+YwJDGULzYc5IqJvTpczHIi4V1lfOO0ZN5WpDNU40/Nla22u5AkqUPi7scak/pGg0DT8Mwuq2Vkt/Bmc4IBLbJyLJwfj0diV24lQ5NCfY73lx153P/tDt68fAxGg+DXO6eyaGc+caE2AixGZg2K460rxlDvlIvZTh4Qg8loIFwJeDVecE9IjiLUZiY21EqKVzrGhsxSJAnN4SCE4NEzh9BS7ZK33mxH5lmDEORW1Guhe5NBaB24OoJu/DWDWh1l7MIbISrYyp2z5Qm9rMbJsrQiThuW0KkfsK3EhVqJCbFSUetbPah+9rjeUZpS/NGIQQhN58/lltiQWUqlV7J0cnSwXymIYwWTl86fOkC3p3JLQu7W4mymKCCrpIZvlVCD0+1pCPt2YTX78UZ5rYPFKQWM6x1JeKDFR9vN6adCz2AQnD4sgTdXpJMUbtP08rzFnC0mAxGBFq3iPj5MzvvdkVNBRKCZsEAzF5/UnYd/2MXytEImJEcdtQuyo5H75w7k7lP6+0ziVuX8PbcolcvG9+Dik46dnMaOYne5Wa9oCyaFB7C3oJpah5vLxvds9j0zB8QxKD5U6218NPPGinT+9Wsaz543TMufBDTHxowBMTx1zlD6xoZw20zfeeFUJdrVFs4f0w2UYvcQm4nNWeV8szmb/Ip6Up/0VcVoTf7MO72mI61FG7eYU9s3dhR92d8MV06Ub5KO/EhtITRA/iHf+mP/Idl/Y/rGhvD+VScxID5E8/b9bVY/5gxuv2zBkcCoTKwgyy6o4rMqn984gesVAdljEdXzV17r5DelsmtTO7q6qFWcqlFRVe/0kRDwbh7ucns4dWg8H107rlM9K08E/u/r7Uz/13JKqmUB9F7KxOjP81dSbWdXbiXL752h9Qq+7bPNvOQlxnuwtM4nVKMKEu/MqdB6cp6tSMPc+eVWBj68iP/+3vB+nZYxKNqv3kQFWbhOkfBp3O3neGXbwQr+o1x3PSIDKalxsD27osUOMcE2E/3iQo6JHGDV2/va8n0+VfDF1Q5CbCZsZqOPUdgZXG4PZTUOLjmpB/86fzg9IgOJCbFiMxvbtTCLDbVylWpXtKMTh0rjvvWS1Dkv7YlxJ3SAe+fIyu9hnYipt4T6Q7a3TVhnqXW4tPy/WofrmHDxq+RV1PPFDRM4Z1QSCWE2ph9HFapmo4EQm8mnDdMPW9vW1ge8PYcS9U43l767jndXNiwsVJHXh08fzKXje5IUHsD0/jEtFjyc6Hh75GvsbkIDzNq9468LzO68Km79bDPpRTWsSS/mnNdW8/P2PFJyG/ow//OcoUzpF80jivD4iG7hXDKuB/mV9ZqnN9Rm5sfbJmvbhNh0A70zBFlNTB8gjxWWY8Cw6Qq8i99iQxvUAf7x/c5m35NRXM2Zr65i1b7iZrc50lTWOymvdXDVpF58cM1JHCyt46Hvd2jRkqJqe7v7fLfE5+sP0PcfvzDqycV8vTkbg0Hw+NlDOhRlCrWZuffUAbx/9VjG+une1BpBjbrg/OP7He3ehzf6yN8MBoPQuoAcCkxGA6cPT2hXK6vO8qzSvkgVyH5nZYbW2/doJyk8gMKqevIq6jEbDbg9kuYt23awnFNeXOHTOeVYIzE8gM+un8A4L2FctXVZW1Bz91xuj1aM4J2jVutwYxBy78je0UGk5VexcEfeMZ3cfTgY3k3W2bKaDZTWONiYVUZCmM1vRxG1Au+phbt5ecleth4sx2oyYHd5OH247An0SBLdIgKZ2CeKQQmhzBgQw6NnDkYI6OkVbhveLVwTgW5vKzkdXzySRIoiC2U9QRY7Ucrc9dDpg5oUuTTX51eVztqRU+H39aOBH7bkMPKJxeRV1HHygFjOG5XEV5uytdeLKu1NNDs7g7enWD2nJw+I7VARqNsjkVlcy5DEsCYC0G0hyGLSOtQAfL+l7c4Bf5wYd8JRymuXjm5R3b2r2V9UTXyojUtO6q5pefnTvToaeeGCEbx04UjWpBezPqOUwio7S1MLcbk95FfWs7ewuok0yrGIy2uizy5re7/a8EAzpwyKIyrYolXteVeX2ZWm35uyyth8oIyft+dy62ebjynP75Hg42vH8e8LRhAXatPyibx7c3uj9s7enVvJOiXfKjLIgiTBc3+RNfpeXyYna2eV1PLE2UMY2ysSi9HApodO4epJvXz2p+rJdWSi0GnA7ZF4dpHcIu9YGe86S1iAGaNBUF7r5JrJvblkXEMfhmN5MbH5QDkxIVbN8/7vC0bw021TMBsNXPHeOrZll3PjtK5L//EOtXZWlcPl8XDmq6u46ZNNVNa3v3OPwSB45rxh2uOxvdrvPfTZX6ferXNMEWozEx9mo2dUEGW1TkKspmMm7GcyyjprP23PZUdOufa80y1pxTkdyaM4Wqixu3h64W5NawrA7my75y8u1MYds/rROzqY0AAzQxJDtZZlANdPTebTa8fz1h/7+XhNJo5GkgY6/gkPtGiaXaoXwOWReH91RpNt1TaESV5ySRGBFmocLs0gV9t6PflzCv/7M4vsslqSH1zIkt0FTQq/5gyJZ9GdUzlzeNfqjZ5oeC8Kex4DxQxdgcEgcHskvt8qF3mFemlFNlfxq3oEj9ZogNsjsXJvMeN6R2qLVoNBaF0wgq0m4sNszO7CPHZv48+fikJ7UKvOtx4sJ7e87Qt7b8ICLMwbGo/ZKDrt4dRH/xOIIKuRrQfLyS6rZeGOPE3A9ljCaBC4PJJWseX0NFSuWo5hY8YjSazdX0K13a21DrO7Ot6M/dnzhjNvqK/RYDIaMBkFTo+Eyy1hPg48pYcT7+RuVYTZm3qlqMa7PeSI7uGYjQaGPPqrz7Y55XV8vzVXu3Zf/G2P388cGB+qe2c7iRCCALORs0ckakU1JwL/uWgkL188ig9XZzB/w0GuUTzLzXn+XO6j0+gDePSHncx6YTnF1fZmq3X7x4WQVVLLwdK2dc9oC8Fe+bad9Rp738cdLST954IULCYDTrfErtzOheeP3dlSp92oOXKbD5Qf2QPpBCaDnO/XM1KtupS0CraW+pYe7ai/TZDFyJVKu7FzR7W9R3FBZT1nv7aKJbsLKKqy8+iPO9nh1YXi283ZfL8lB5NB4HTJIs/HWieHI4238edvorx0fE++vWWSlmw/ukc4T587lGe9QjWzG+UKRirePtUjqHNoEEKWATmWQ57t5ZxRSYzpGYHLI1FW6yQ21MaMFkTDVU3bIxURqHW4+GB1Bi8v2csTP6Xw07aGnLY/9haTWSIbdScP8F/oF60sul7uwur4+FAbSeEB3Dy9a/U2OxqlcrklKuqc9IwK5LopvTt1DHoZ2QlEVJB8cwRajHx8zTiORYeC6vn7LSUfkAsc4kJtTO0XfchkeQ4HqvFX53Rr4cP2yAgYDQKPJK/qax0uNh8oJ7+inreuGAvAmvQSAi1GTAYDTrcHh1vSNf7aibfOn79inPgwG/FhNnpEBTKuVyTzb54IoHn3ACxKR5WXLhrB68vStUreqf2im+xPp+uodbhZnV7CX4qq6XcM64F2hNxyeWHhdHu4Z47/7hMA84YkMCk5msQOdEpyKyoDnZGOcrokHv8pBQCDgN9SAjhzRCIVtU4yims4Z2Qipw9PJMTmX4Fj7pB43lqRzrWTO2cUeRMbamP1/TO7bH8qHZ2r1GKczGdP7/Qx6MbfCcRpw+JZtCufALPxkFYyH0pMBoHbLWmrQI8EJw+M5eSBnW+2fiRRq3VT86vk7g4TejKlHQaBt9SLWjRS5iXoXed0Exlkoc7pxumWuH1mXy4Y27T/pE7zWE1GPr1uvI+0hDer9xVTWefkgXmDtOfeWpGu6a0BZBbL1+25o7px7ij5/G96aLZPeEmn6zl5QAzL0opOmIIPb9T0kdYK4oJtpg5fhxe8uYbNB8r57yWjOlTEuCmrlLhQG1sePoUQm4mnFu7mq41yFe87imTVBWO7M7lv82NiTIiVVX/vekOtKxmWFMaOnIqjQrhdH3FOIFSh38BjuDDi7SvGYjQIlqUVcuHY7l3Wd/lIYxByrpjqjTtzRCLdItqenO4t9aKGJCUaPE5OtwerycBtJ/dlUGIoieEBh6Wn9PFGWICZMT0jCfJzD/1vXRZ7CqqZNyyBpxaksKegmoHxIZrG4t/nDuScUU0nxqgulKbQ8c+IbuEsSys6JgSMu5p75gzQZErOf3MNL100ku5+xpadORU88N0ObpqWzBnD22fA7c6T+6xnKP3X28ul76zj6km9eOA0eeE0rV8MwVYT2WW1vLpsH2eOSGRi8tHbgaqtvH3lGLJKajscWv/ulkmapFRnOfGWQScwB0vlCqOu7Fd8uJHDm7JZo4ZKP1ydwaRnfvdRej/WEELw3lUncZrSxaS9+YvquXB7JL8hSbVhec+oIPrEBPPTtlz+3F/SZDud1rl6Ui8u8KqkVqlzuAkwG1mTXsw7KzPYnNXQK/vm6X04dUgcCWG6wX0k2J0vGycnoucvMsjC3XMGYBACu8vTbGHHxixZnihVOVdtRZIk6l1uwgPNnDyw/cL7bo+E3eXxyYM7eWAs98wZQHighXevHMsD8wZiOA4K1EqqHU06dbSHUT0imDmwa6qZdc/fCcQpg+MICzAxpkfn9IGOJF9uPKhJbny2/gB/ndGH8jonuRX1x4XOn9YDtp0rQ7NRcObwBPrEBGurSu/VpdloIMAiV3vnlNfy3KJUxvWKZMJxsJo+WqhzysZfneJhr7K7tAntjll9CbTow+2R4tddco7wiWj8qahRheZavKljj6udRTFOt8Spg+M5Y0QCw7uFt/u4ah2y6kSQ1/3h9kiU1zoItpm6VLrlSHPGK6uArsnZ6yz6aHQCYTQIJvY5thPL/0wv8Vkhltc6cbklDIJjfmX49MLdVCvyO+31/JmMBm6c1lCRdvaIRJ+J7m2l8OOphSmU1zopq3Ecs3mfR5rnf02ltMbBs+cN93m+zukhLMDsc17VxO7c8jp6RQXpFdZHiIhAM2W1TmwnsPGnpoY0V/GsPu9uR2chkA3qN68YQ3pRNRnFNVqbwraipiN5j+ur9xVz5fvreea8YcQrBX36vdO16GdT55jCaBAYDYJbZ/QFVJ2/40OweGduBSaD4MapycSFtD+X0eHyaIUI109N1iRjvDEZDFTbXdQ43D79P3XajtPt8dsWsd7hJtBsJMJLrLl7pBzmnf3iH1r7LJ3Dz9CkMJLCA05oA8KoLCidzen8qZ6/Dur93fq/zTy9cHe736caf969a9V76MPVmVz/8UZd6/IQoHv+dI4pTEZZuT5BKfRwumSR5+PB+DMZBLEhVs4ckdghr9wl7/7J6cMSGNszgk/XHeCu2f1ICAvA7ZH4129pTO8XjckoKFTak0UE6sZfR5DlcppOkO9eNRaDQWjFIBGBZmYOjOPNy8dw86ebjotr9FilzuEmp4NdFY4XYoKtzB0ST0Sgf6kUj2L8tbfid0d2BVe+v46yWqffBeWBklr+7+ttRIdYeeXiUU0iNDEhVt66YozWqQPkdpUAewuriA62ajnNxzpvXzFGawN5pNGNP51jCqNBUFXv4uvNsgyAyyMxMCGEOUOO/bwQo8FAWa2TzOIaBiaEtNtYMCstncprnezOq+SBb3fw4TXjcLo9rN5XTN+YYMwGg1YY09wkoNMyJqPwW1TTXREe93gkhiaFap5X1RuravzpHH462k7reCIxPIBbT+7b7OvXTO7NZeN7tnvhWVnvpKzWSYDZSI2jaVeiD9dkar2unz53GGEBvuNOsNXUpGuHavx5JNk4PF6Y00x3kiNBp4w/IUQk8CXQC8gELpQkqczPdm5gh/LwgCRJZ3Xmc3VOXALMRkqqHWw9WA7IhQwXju3u08f2WMVkEKzPLGV9Zikb+sxu96BnNAicbo8WvlFXmGoYx2yUQ+ahNhM/3DaF6GDd89cRzEaD39DY+6syGNYtjJN6RfLz7VMB2etx++dbgIacK53DzwsXjqTyKPG4HEnU/r3+unwEWU0EdcDOUvOU40KtTdIh3B6Jz9cfACA5JsivIkNRlZ2duRWM7RmhCTgHW02YFEH/48n4O5ro7Gh0P/C7JEn9gN+Vx/6okyRppPJPN/x0OsxDpw/mibOGAPC3mf0Yp/TBPR7oHhmgVfl2pPuGyWhQRJ7lAVZt0O7QPE8GLj6pOz/cNoXe0UHNKuXrtMzQxFC/HTmeXrib5WmFPs/ZLF4V1ydwscGRJthqOuF1LbNKajj7tdWsSfcv8bRybxGXvvsnb/+R3q79VtfLBl9sqK2J8Wc0CEb1COe7Wyax9J4Zfg25TVmlXPPBBk2KDGTpq7/PHQjI4WqdrqezYd+zgRnK3x8By4G/d3KfOjotouoUqrkj93+znZ25FZq35VjlkTOG8O3mbD5Yk9mh/DC1+0ljr5QadjQbDUQFWymtcbAkpYArJ/U8IUVvO4s/nS3V49q4bZMa4gowG5uEu3R0DifeQvAqm7PKSC+u5oIx3Vm9r5iqehe78tpXmKR6/m6cmqx5Fr357IYJLb6/ueYDN0xLZlLfqGO6befRTGeNvzhJkvKUv/OB5hKvbEKIjYALeFaSpO87+bk6Jyg/b89lU5acWfDSkj2M7RVBld2laasd66hyC+2VegE4c3iiz8parZDzSBJRQRYCLUZ251Xy5IIUqupdXDO5V5cc84mIJEna+XW6PRwsldu2NW7bZDUZCbQYuXRcj06Ju+rodBa12tdbx+/Rn3YBcMGY7tqiur3Vvr2igzh3VBJT+0f7LCaXpRby/uoM/n3BCIqr7Tz+YwqPnDnYp7AD0PIE/XWeGpIY1uQ5na6h1dFICLEE8Jel+A/vB5IkSUKI5q6anpIk5QghkoGlQogdkiQ18S0LIW4EbgTo0aNHqwevc+KRll/FxqyGtNLCqnqcruND6uW/S/eyOKUAAHMH8sPOGZWk/f23mf3YlSc3AU8IC+DDa8YBcguyqnoXoTbTCS170Rn+ty6L+RsP8sOtUwDYnVfJP77fCeBXyNkgBDtyKvB4pGNei1Ln2MXs1QVI5ZyRifyyUxbAVo2+5nQAm2N6/xim948hv6KefYVlTEiOxGQ0sCOngpV7iwm1mckpr2N9ZilF1fYm769TRJ4D9cXRYaXV0V+SpNmSJA318+8HoEAIkQCg/F/YzD5ylP/3I4eGRzWz3duSJI2VJGlsTEz728ToHP8YDYLIIAsvXzQSAKdLwuWROuQpO9rILq0l1Gbib7P6dchIqKp3UlUvJ7XPHhzH32b1b7KN2gUlVA9BdhiDEHikhkmywquQIMDSdEittrtYl1Gq5V7q6BwJVLkUNewrSRJWkxGHy4MkSVrI1l8le0uoucW/7srn8vfWaffD/qJqEsNsBFiMmlfPX4Smxq6IPOvh3cNKZ5f+PwJXKX9fBfzQeAMhRIQQwqr8HQ1MBlI6+bk6Jygmg0CSJC1/ShV5Ph4qKY0GQffIQGYP6phszaM/7uLfv+1hwY48bv98szaYZxTX8NhPu8gsrtG8fXoIsuOoXmZ1kvQ2/hpLVgDcNbu/z/t0dI4ENrORc0Ym0UvpwLE7v4ovNx5EQg4Fq4uZuND2CczfPX8bs19cQZAyphRXO/h4bSar9hWTHBMMNLRu8yeOfv6Ybnx63fjjRsvvWKGzM8CzwHwhxHVAFnAhgBBiLHCzJEnXA4OAt4QQHmRj81lJknTjT6dDGI2yFt6n67IAOVQxrV/MceFVMRkNZJbUsKegimHd2p/rYjIacHs8lNY4yCyp5eK3/+R/14+nrNbBpqwyLhzbvcHzp1f6dhiT1iNVwmpqMP7MRoHNTwGNy+NBCPTJTeeIYjMbuW5Kb+1xitJxJthqwuWWeOSMIXgkqUneamtU212YjQZN3LzW4eKtFfuJDbFx5+x+QEPrtjpnU89f98hATSNT5/DRKeNPkqQSYJaf5zcC1yt/rwGGdeZzdHRUQpTV5ZLdcoZBeKCZs0cmtfSWYwajQVBe6+SxH3fxlzHd2v1+VRdLDevUOd043Q0t3yxGg+b5e/o8/ZbsKGru1IbMUvrHhWjGn9MtsTW7nNE9Iny2f2XpvsN+jDo6jZEkiVqHG5NRkFtez/yNBxnZPZwnzhrSofZpO3MqeG3ZPoqr7YTaTJrnz+2RWPi3qT7V7UEWE0OTQv1WvG/ILKXa7uLkAbEd/3I67UaP/egcU1w+oScjuoXx4Pc7efqcoceN4QfQKyqQTVllWlVeezEZBLUOj081n8staa3IzEbByQNiuHpSL104tRP0jgnmrBGJvLB4DwB/m9UPIWDhjny/k9vdp/Tng9UZh/swdXSacPE7f3LasASWpRYSYDZy28l9NcPv+y05LEsrJDTAzJNnD211Xx+szuSXnfI1P3NgrOYxzCmvY2wvX/3VAIvRrxRXYVU9d8/fis1k1I2/w4xu/Okcc6hKBGpRxJmvrCIx3MZbV4w9gkfVea6e1JvyWifbsis69H6jQW475m38Od0eTVXfbDRgNAjeWbmf04YlMKZnRHO70mmBwQmhxIVY+XFbLiAb3f/P3lmHR3F2ffh+VuKeEE9wd4cCLUUKpS60hbq7G3Vvv/pbdzdoqdDilKLF3S2EuLutz/fHM2sRkkAKAea+rly7GX1mZ3fmzJHf+fDKgQ0uf8/YztwztvOxGp6GRr0IITDoBGlFVTgUhYfO6kJeuYlX5+/hobO6smRfPgcLq5osMB/sZyDAR0+V2UZ8mB8DksOYdnY3zuzWNCNu0a48bvluA4oCwzqcPGL9Jwqa8adxQrF8XwFvLtoLwLTftmN1KFhsDgQnRz6V3aG48vKay7juMZisdqos7qTqV+fv4Zw+8SSE+eNn1LM9q4wvVqYSFeSrGX9HwS4PIdyl+wq4cljbepvaa2i0JvQ6QefoYF66UKZ9bEwrYX9+JZVmG/ZmSr3klZuottgZ2y2a0zpGYdDruO2Mjg0uf/UXaxnYNpz71AKo79ek4WfQ8+GVA+iZEHKUR6bRXLTyM40TipyyGjyvTTmlNVgdjpNC6uXb1YdYuq/giI9lRKcoxnaP4fy+Cbx+SR9AVvSFBRj5+KqBRAT6uJK87c2Uc9Dw5rUF8gGkQ5tANqaV8PAvW4/ziDQ0Gsegl9EBvU72+fZVWw5abA6XyLNDod5OHbUpqrQA0Ck6iBGd6rY7rM2hoirSiqpd//dPDuPhCV05s1s00cHNqzDWOHo040/jhEKvSrpMv3kYPmovW6v95BB5LqmWF9NbRnU4ovVLqy3klpkA6BYXQrtIWUHn6Ul0ammd6n1Oj5ZXLurN+X3jeWJSdwBGd9V0STVaP0adjtnbcliwUwo7+3gafx5P1U3x/hVVScHmXU1sBxfoY6DaYnPpAt43rgs3eFQfaxxbTvw7psYphachY9AL2VPVfuSh0taEQacjyNdA36SwI1r/29VpPPb7dj5ceoCnZ+3grjNlntlfW7OZ9ts27A6FC/sn8NolfbjwJCqUOR70Sgjl5lEdiA724487RnD18HbHe0gaGo0yvofUEC1XxeCdxp/ZZsfp7OsSE9Qkz9/ce2UBx4r9hS5x+cPh76On2mJn3o5chr+ymEOFVUdyCBothJbzp3FC4dRKe3/JAaotdmx2hckDE+kUE3ycR3b09IwPYf7OXH5Ym35EBqCz4KO4ysLmjFI2Z5RyeucodEKwO6ccnZCe08sGJ7X84E9hNP0+jROFrrHyOtkjTubYBfka6B4XQmGlhTcm9yXEz+Cq/q0wWfEx6Lz69Xria9DTLTaYPbkVBDdBNzRANf725FaQV24iNlQL9R5PNM+fxgmFsy3ZygOFtIsMIDkigAfO6sr5feOP88iOnlGdZejwj81ZR7S+n1FPpcnGNo9q4ehgPyICfTDodUek5aWhoXHysDqlCJB5eiC7ebx2SR8+XXGQ+2Zs8bpGPPTLViZ/vJpqS92uHEWVZp79cyfPnt+TZQ+PbtK++yaG0SMuhL255bSLDGy2mLRGy6J5/jROKM7o0garzcE7/+znqXN6MLZHDNUWm5eA8YmKXif49OqGJUMa4/y+8axKKSS/wt08fcnefLrEBONzgn82GhoaR8/iPVIc39Ob5xSFL6w08+r8PWSWVPP8+b3IVvOHN6aVMGN9Bn4+el6+SFYJZ5XW8PWqQ4zoFMWwDoFN2vcjE7thdyic/toS+hxBByONlkW7I2iccDir0nQ6wZ0/bKLH0wt4feHe4zyqliEu1J+40CMrxmgT7OvqLuEs7CiqsrD6YFGTtbs0NDROXp47r6dLCQBkrt+1X61z/b8ju4xDRdVUmG0YdIJLBiRidyj8tjmL/HKTa7nCSvmAGRXUPHmj1SlFZJXWMLFX3R7YGscWzfOncUKRXVrD+0tkuyy9TrD6oAxjGHXacwzATaPaE+xnQK8TjO8ew30ztlBhtrnCPBoaGqcuA2ppexp0OspNNvolhbElo5TwAB9Kq60UVZqxORQCffSUqu0L35jclwqTlWqLncIKqUwQFdS8TkFpxVXcN67zSdWZ6URFM/40Tih0Hsn1eiEI8zdSXGU5KXT+WgJfg55rPCpPA3z1DGwXzoPjux6/QWloaLRK9DrZ9aNjmyB2ZJURpuZUl1RbGdYhgm/XpAGgExDiZ+TqL9dSY7EztrusGm5um8grh7Zt2QPQOGI0d4nGCUWIn3xeuf60doT4GwlW/z8ZdP5agvwKE+8u3s+B/EoAAnwM1Fjsx3lUGhoarRWbQ+HXTZnYHIrrempzOHhiUg/6q6oDYQE+6HSC6GA/CirNVJlthPgZtKKNExjtjqlxQuFv1GPQCSpMsgItyGX8aZ4/AEWBRbvzeODnLYCUV1ibWszvmzOP78A0NDRaPQa9jj4JoS7plmA/Iwad4ItrZd/0NsG+FFSYeXhCVzY/fdbxHKrGUaIZfxonFEIIbA6FmZsysTsUOkdL3SpnocOpTqTaX9Yp0XpO7zj5f9PadWpoaJzCnNcnnpcu6k2Aj56rvlhLXrkJP6Oe/ur1tU2QLyargwqzTdO3PMHRjD+NExYh4Nnze3Lo/85hULuI4z2cVoFT7qZDGym/EBsihVTjNEFVDQ2Nejjbo/K2TC3uqDTZKKuxEhHoQ6XZxlq1sM6Z43fnD5v4aV36sR+sRouhGX8aJxyXD0pCADohsNkd5FeYMFm1vDYn390whFcvlnIOWzJLAa2Xr4aGRv2UVrtbsy3ek8dzf+3k/+bvAWBwO+nxcxp6/ZLCeO78nqzYX8iu7Kb19NVonWjGn8YJh92huEIOMzdmMuSlxXyy7OBxHlXrISzAx5WIvUpV9NdaKWloaNTHloxS1/t+SWGYbQ7X/6d1jMKgE8Sq2qPtogKZMiQZaL7Mi0brQpN60TjhmLnJXbxQaZaFHyXVluM1nFbN0+f04FBRVYP9OTU0NE5tPr9GFnM4W2duTCsBwJnRZ3MoBPnK64eiKHy7+hCgpZKc6ByV508IMVkIsVMI4RBCDDrMchOFEHuFEAeEENOOZp8aGs+d15MLVZFQZw6KQUs+rpfwQB9XsraGhoZGbUL8jS7DD3BV+o7rHsOmdGkI7vQI8b44ZzcA5/aNO4aj1GhpjtbztwO4GPikoQWEEHrgA2A8kAmsF0L8qSjKrqPct8YpyoC24S6l+nP7xJNTZuKqYZp4qIaGhsbRkhQuQ7xju0fTsU0Qp3WM5IlzugNSbeGr6wbTKTqIAB8tcHgic1RnT1GU3SC/EIdhCHBAUZSD6rLTgQsAzfjTOGr0OsFtZ3Q83sPQ0NDQOCmY0DOWg4VVhPnL3OHHzu5OYniAa/6Z3aKP4+g0WopjYbonABke/2cCQ+tbUAhxC3ALQHJy8n8/Mg0NDQ0NDQ0XfkY994/rcryHofEf06jxJ4T4G4itZ9YTiqLMasnBKIryKfApwKBBgzRZWg0NDQ0NDQ2NFqZR409RlHFHuY8sIMnj/0R1moaGhoaGhoaGxjHmWOj8rQc6CyHaCyF8gCuAP4/BfjU0NDQ0NDQ0NGpxtFIvFwkhMoHhwBwhxAJ1erwQYi6Aoig24C5gAbAb+FlRlJ1HN2wNDQ0NDQ0NDY0jQSittOO7EKIASPuPdxMKlP3H+zgWRAGFx3sQLcTJck7g5Dkv2jlpfWjnpHVyspwX7Zy0PppzTgoVRZl4uAVarfF3LBBCfKooyi3HexxHixBig6IoDYpsn0icLOcETp7zop2T1od2TlonJ8t50c5J66Olz8mp3tv3r+M9AI06aOek9aGdk9aHdk5aJ9p5aX1o56QeTmnjT1EU7UvRytDOSetDOyetD+2ctE6089L60M5J/ZzSxt9JxKfHewAa9aKdl9aHdk5aH9o5aX1o56T10aLn5JTO+dPQ0NDQ0NDQONXQPH8aGhoaGhoaGqcQmvGnoaGhoaGhoXEKoRl/rRQhxJdCiHwhxA6PaX2FEKuFENuFEH8JIUI85vVR5+1U5/up0y8XQmxTp796PI7lZKE550QIcaUQYovHn0MI0U+dp52TFqKZ58QohPhGnb5bCPGYxzr3CiF2qOfkvuNwKCcNzTwnPkKIr9TpW4UQoz3W0X4nLYQQIkkIsUQIsUv9PO9Vp0cIIRYJIfarr+HqdCGEeFcIcUA9BwM8tvWq+lvZIYS4/Hgd04nOEZyTbupvyCyEeKjWtpp//VIURftrhX/A6cAAYIfHtPXAGer7G4AX1PcGYBvQV/0/EtCrr+lAG3X6N8DY431sJ+pfc85JrfV6Ayke50Y7J8fhnABTgenq+wDgENAO6AXsUKcZgL+BTsf72E7Uv2aekzuBr9T30cBGpFNC+5207DmJAwao74OBfUAP4DVgmjp9GvCq+n4SMA8QwDBgrTr9HGCR+jsJVM9ryPE+vhPx7wjOSTQwGHgJeMhjO0d0/dI8f60URVGWA8W1JncBlqvvFwGXqO/PArYpirJVXbdIURQ70AHYryhKgbrc3x7raDSTZp4TT6YA09X32jlpQZp5ThQgUAhhAPwBC1AOdEfe3KoV2Y5yGXDxfz32k5VmnpMewD/qevlAKTAI7XfSoiiKkqMoyib1fQWy1WoCcAHSsEZ9vVB9fwHwrSJZA4QJIeKQ52u5oig2RVGqkE6Hw3aS0Kif5p4TRVHyFUVZD1hrbeqIrl+a8XdisRP5xQCYDCSp77sAihBigRBikxDiEXX6AaCrEKKdesO70GMdjZahoXPiyeXAT+p77Zz89zR0TmYCVUAO0qv0hqIoxcin5lFCiEghRADS66Gdk5aloXOyFThfCGEQQrQHBqrztN/Jf4QQoh3QH1gLxCiKkqPOygVi1PcJQIbHapnqtK3ARCFEgBAiCjgT7bwcNU08Jw1xRNcvzfg7sbgBuEMIsRHpJrao0w3ASOBK9fUiIcRYRVFKgNuBGcAKZJjLfqwHfZLT0DkBQAgxFKhWFGUHgHZOjgkNnZMhyM86HmgPPCiE6KAoym7gVWAhMB/YgnZOWpqGzsmXSMNiA/A/YBVg134n/w1CiCDgV+A+RVHKPecpMoZ4WO03RVEWAnOR5+knYDXaeTkqWuCcHNH1SzP+TiAURdmjKMpZiqIMRP7wUtRZmUhXfKGiKNXIH+cAdZ2/FEUZqijKcGAvMq9Ao4U4zDlxcgVur59zHe2c/Icc5pxMBeYrimJVQ4z/IkOMKIryhaIoAxVFOR0oQTsnLUpD50QNH96vKEo/RVEuAMJQP3vtd9KyCCGMSCPjB0VRflMn56nhXNTXfHV6Ft7eo0R1GoqivKSer/HInEDtvBwhzTwnDXIk1y/N+DuBEEJEq6864EngY3XWAqC36oo3AGcAu2qtEw7cAXx+rMd9MnOYc+KcdhnufL/a62jn5D/gMOckHRijzgtEJrLvqbVOMjJf5sdjO+qTm4bOiXrNClTfjwdsiqJo164WRgghgC+A3YqivOUx60/gWvX9tcAsj+nXqFW/w4AyRVFyhBB6IUSkus0+QB+kx0mjmRzBOTnctpp9/TI0d8AaxwYhxE/AaCBKCJEJPAMECSHuVBf5DfgKZChRCPEWsvJKAeYqijJHXe4dIURf9f3ziqJoT2lHSHPOicrpQIaiKAdrbUo7Jy1EM8/JB8BXQoidSI/FV4qibFPn/are1KzAnYqilB6jQzjpaOY5iQYWCCEcSM/S1R6b0n4nLccI5Ge7XQixRZ32OPB/wM9CiBuBNOTDKsjo0SRk7mU1cL063QiskHYL5cBVapGBRvNp1jkRQsQi0yNCAIcq6dJDDRU3+/qltXfT0NDQ0NDQ0DiF0MK+GhoaGhoaGhqnEJrxp6GhoaGhoaFxCqEZfxoaGhoaGhoapxCa8aehoaGhoaGhcQqhGX8aGhoaGhoaGqcQmvGnoaGhoaGhoXEKoRl/GhoaTUYIUVnPtK5CiKVCiC1CiN1CiE+FEBPU/7cIISqFEHvV998KIUYLIRQhxE0e2+inTnvoCMZ0vhBimvr+QiFED495S4UQgxpZf7QQYnYD8z733J7H9OuEEO83sE6dz6il8TzmY4UQYrIQYqcQwtHYZ6qhodG60USeNTQ0jpZ3gbcVRZkFIITorSjKdmTnGYQQS4GHFEXZoP4/GtmM/DLcXRumIJvGNxtFUf5EquIDXAjMRu1wc7QoinJT40sde2od87FiB7J7wCfHeL8aGhotjOb509DQOFrikP2lAVANv8ZIA/yEEDFqm6OJwLzaC6ntpFLVNlNhQgi7EOJ0dd5yIURnpxdOCHEacD7wuupl7KhuZrIQYp0QYp8QYlQD4wkSQswUQuwRQvygjsnLcyiEuF7dxjqkOr9zjO2FEKuFENuFEC/WGv/DQoj1QohtQojn1GntVA/pZ6onbaEQwr+hD0oIcY8QYpe6jenqNJfn0cPDukUIUSOEOEMIESiE+FI97s1CiAsaPyWHR1GU3Yqi7D3a7WhoaBx/NONPQ0PjaHkb+EcIMU8Icb8QIqyJ680EJgOnAZsAc+0FFEWxA3uBHsBIdblRQghfIElRlP0ey65CesMeVhvPp6izDIqiDAHuQ7Yaq4/+6vweQAc8jDtwNVh/Tp0+Ul3OyTvAR4qi9AZyPNY5C+gMDAH6AQOdhqs6/QNFUXoCpcAlDYwLYBrQX1GUPsBttWeqx9oPeArZ/mkV8ATwj3rcZyIN4sBaxxRcy3D0/KsT6tbQ0Dh50Iw/DQ2No0JRlK+A7sAvyJ6ua1TjrDF+Rhp/U4CfDrPcCmSf5NOBV5DG12BkL+um8Jv6uhFo18Ay6xRFyVQUxQFsqWe5ocBSRVEKFEWxADM85o3wGP93HtPPUv82I43WbkijDyBVUZQtTRgXwDbgByHEVUC9fVSFEJ2B14HLFEWxqvudJmTP0KWAH5DsuY6iKBVOw7GevxYJm2toaLRONONPQ0PjqFEUJVtRlC8VRbkAaaD0asI6uchG5OOBxYdZdDkwCulBmwuEIY3MFU0cntOjaKfhPGdPr+PhlmuI+pqkC+AVD4Oqk6IoXxzB/s4BPgAGAOuFEF7LCiGCkIb0zYqiOD2PArjEY9/JiqLsrrWe5vnT0DhF0Yw/DQ2No0IIMVEIYVTfxwKRQFYTV38aeFQN7zbEOmRo2KEoignpmbsVaRTWpgIIbuK+m8Na4AwhRKR6rJM95v0LXKG+v9Jj+gLgBtU4QwiRIISIbs5OhRA6ZHh7CfAoEAoE1VrsS+ArRVE8jeEFwN0euYv9a29b8/xpaJy6aNW+GhoazSFACJHp8f9bQCLwjhDCpE57WPXqNYqap9fYMmYhRAawRp20Ahkqrq+wZDrwmRDiHuDSpoyhiePMEUI8C6xG5uht8Zh9L/CjEOJRYJbHOguFEN2B1aoNVglchfT0NRU98L0QIhTpzXtXUZRSdXsIIdoij7OLEOIGdZ2bgBeA/wHbVAMyFTi3GfutgxDiIuA9oA0wRwixRVGUCUezTQ0NjeODUJT6ohUaGhoaGhoaGhonI1rYV0NDQ0NDQ0PjFEIL+2poaGi0AoQQH1BLYgZ4R62m1tDQ0GgxtLCvhoaGhoaGhsYphBb21dDQ0NDQ0NA4hdCMPw0NDQ0NDQ2NUwjN+NPQ0NDQ0NDQOIXQjD8NDQ0NDQ0NjVMIzfjT0NDQ0NDQ0DiF0Iw/DQ0NDQ0NDY1TCM3409DQ0NDQ0NA4hdCMPw0NDQ0NDQ2NU4hW2+Fj4sSJyvz584/3ME4qtmeWNbpM78TQYzCSujRlbPVxvMbbktR37E09riP53E6Gz+x4cLjPWvtMWx/a+fLmSK+xcGp+Xic4orEFWsTzJ4T4UgiRL4TY0cB8IYR4VwhxQAixTQgxoLFtFhYWtsTQNDQ0NDQ0NDQ0PGipsO/XwMTDzD8b6Kz+3QJ81EL71dDQ0NDQ0NDQaAYtYvwpirIcKD7MIhcA3yqSNUCYECKuJfatoaGhoaGhoaHRdI5VwUcCkOHxf6Y6TUOjSQibiaCMpQi7+XgPRUNDQ0ND44SmVVX7CiFuEUJsEEJsKCgoON7D0TjOhO/5iY6zzgdAby6l/YJriNzxxXEe1XHCbgNFOd6j0NDQ0NA4CThWxl8WkOTxf6I6zQtFUT5VFGWQoiiD2rRpc4yGpnHcsVkIzF4NID17Div6miLi1r6IovcBwO4XgSUokbCUP4/nSI8fG76EN7tCWebxHomGhoaGxgnOsTL+/gSuUat+hwFliqLkHKN9a7R2VrxBh7mXE5C7jq7TT6PDnMsJyN+I3lpB7qBHAVD0PhT2uhH/4l34lKUe5wG3AJZqqCpq+vK7ZkFlHqz8n3uaohC/chrBGf+0+PA0NDQ0NE5eWkrq5SdgNdBVCJEphLhRCHGbEOI2dZG5wEHgAPAZcEdL7FejAWpK4LuLoayOc7V1Ya0BhwP0RgD8C3dgrCkgMG8DekslADb/SNfiNW36AuBTnnbsx9rS/HEbvN6h6aHcov3y1VrjnlZVSOSeH4ld+1LLj09DQ0ND46SlRUSeFUWZ0sh8BbizJfal0QS2ToeUxfDvOzDpteM9mob5bIw0Zm5ZgvLPSwRlLQcgbezH6M0lADgMAa7FHXo/AHQnQ9FHaTpEdgLh1uIMOTQf/4It5A2e5r2swwFVqu6lzcP4C2qDJTCOmjZ9jsGANTQ0NDROFlpthw+No8AsvWb4BB7fcRwORYH8XfL9tp+xBCcRooYva6J641OZRXHXKdh9QlyrmCK6snvqBuy+J4HavH8ECA/Hu8NO279vAahr/NUUg2KX752eP6sJHFYchgCE7SQwhjU0NDQ0jhmtqtpXo4Uw+svXnhce12EcFnO5fO07FdLX4FuRTlnbs6iMH0HsupfxK9xB1qhXUYxuzx86I7aAaBS97/EZc0tiM0HWRph5AwDBWcsASBvzYT0LCxh8k3zrNP72L4RX2+NbnorO0xuooaGhoaHRCJrn72Rk4HXQ+SyI7Hi8R9IwlaqUT4fRsPVHqqIHkj7+cwC6Th8OOiNFisPLOyas1bTZ9hEVSWdSE91oh8DWjdOIy5Pez4C8jShCR0Xb8XWXDYyEc96EhIGgk/mRpC4Dgx/5vW/x8o5qaGhoaGg0hub5OxnR+0DeDig+eLxH0jDBMTD1Z7BUwMGlXqFchzGQsJQ/6P59X69VhMNCzOZ3CMjfdKxH2/I4vbJqYYtPRTpCcdBhzuV1l7WZwW6FflOhz2Q5rboIgmPJ738vRT2vPzZj1tDQ0NA4KdCMv5OR7T/DzOth3/zjPZKG8Q2GLhPg0L8A2H3DXLMcxiAAFL2/1yrKiVLwoSiw7jOoyG14mRH3wpBbwFwBQFm7s7H5ReCfv7nusuu/gBeioCgFStVGOZZq8AkARUHYLf/BQWhoaGhonKxoxt/JyLYZ8rU1FwLk74G98yBQinnb/cJds+xGWaji8Mz3A1euX6svcMjeBHMfkn8NYa0BYwCYK4ja9inVMYMp6nEdAgUUh/eyVfmgM8CyV+HrSer61WAMIHHpfXT+ddx/dywaGhoaGicdmvF3MmJSiyns1uM7jsOx41eYPlWGfwFzqDs/0RzWCfCWeQFACBx639bf37dgr3xtf0bDy7zVXXbtCE0kbt2LdP9xoMvoE45a562yQBrJxgBZ5QvQ/yoYcC2K3lcr+NDQ0NDQaBaa8XcyUiM18mjNRlJVPgREQkgiAJVxw12zcoY/R2XcaTgM/nVWU/S+rT/sm79b5l0OvK7hZawmGHANXPypa1JI2kL5xmH3XramWH5WRn93oUjfK6DfFBwGP83409DQ0NBoFlq178mI0/iztdJcMHMl5GyDwGiX589YU4AlzO39K+twbr2r7pmyFkdrl3rJ3QYh8WCpAv+wuvMVRUq9GP0hugfZw58navtnlHS+FHvaAhn69cRmAoOf/HMaemWZ4BOEwxiAsJn+80PS0NDQ0Dh50Dx/Jxs2i9TQ63oODG+lXfSWvgLZm2X1avwA6HM5pvAurtnhe34kfO9PFHe7ss6qDmOgzH9rzYx7FkoOwcIn6p9vtwAKpK+Bj06jMn44e6/4l6LeN5F67i/yGD3pdQn0v1Iaiw6bDOd/NhYWPYVi8EfnsMjpGhoaGhoaTaCV30U1mo3eCNMyZNsw3+DjPZr68Q2BvlPgtLvk/xd/ij2zzDVbby4loHA7OksZDo8qYICorR9h94ugpGs9kiithfj+ENFRVuTWxuGALT/K9wY/KMsgYvcP5Ax/zqvVmxf9r5KvWRvBXy2MUQtGqiIHkd/3DoTiqO0v1NDQ0NDQqBfN83eyIQT4hcCBxXBw2fEeTf2MfhQu+qjB2U6pl8QVj9aZF5Yyi+D0Rf/Z0I6amhLY8ZusxrXWMv5SV8CrbWH2fdDtXClwDUTt+hqEICR1Hp1/ORNDVS2JmKoiKQmTMBCG3CwNfLXatyp+BHmDp6HofY7F0WloaGhonARonr+TjYJ9sPk7qQ3X5SzocJiK0+OBwy67djTk5QJ32LO25AknQMFH3i6psQgQ2cl7XsZad1u7obdCQJTXbJ21Er+ylLrVzF9NhJiecN47UJoO4e3BYZXVvw4beksldp+g1h8O19DQ0NBoFWiev5ON/F2w6l1ZGGCzSK+RUxi4NbDjN3i9IxSnNriIU+JF1GP8OfS+rbvAoSJHvoYm1fX8lWW63xfuA4N34Yqitm4Tilrtu2cOfD5Orqf3hQN/w8cjZTUxgNGfkEPz6fF9H3xLU1r0MD5ZlkJKQWWLblNDQ0NDo3WgGX8nG9VF8jU4ThoYr3eAD4fVlQ851pgrZZHCnAfk/6GJDS7qbPVm963bs1YxtHLPX3mWfD3jERh8k/e8skxZ4Qww50HI3ACAovYvVlTPnUvnryIHMtdLI9LgKz19IIs7zn4d2o9CUeVwWlLupcZi55V5e7j8kzUttk0NDQ0NjdaDFic62agulq/BsbJAAGT/2LR/wdi34fX+a4SALGnsMOgGmbfWAOawzgBUt+lXZ55D74uhNVe2lueAT5DU8KtNWSbE9ZEePICgNhCaTGmbQfJ/l/GnGup7PdrzGXxlgQgACgy9BQBHRrZctQWNP6tDelyTI+rqLGpoaGhonPhoxt/JRk2xrKb1kUUTGAPgki8gaRjkHkcxYJ9AuG6u7Oox6MbDLuow+JE76BGqowfUmZc+7rPD5gsed8qzpMZfdbEs/oh0axfisEFUV1kJvO4TMPjDNX+Qly/PizUghvKkMe7OJsLDMW/wlVIvIL27eTshrK1LCFtnb7lza7FJ4+/C/gkttk0NDQ0NjdaDZvydbJjLpRzIBe/D6g9lJ41uaj9YjqPxt3s2tOkG09IaXdThE0xBv7vqn9maDT+Aia9Io2/lW7Duc3jSo3L37g1S4HnvPNX484XIjlhrpMxNTXR/0iZ87V5ep5evycOh8wS38Ze1EWZcBVN/wWGQIXLRgp4/p/Hno9eyQjQ0NDRORrSr+8nGBR/A3RshLBnO/j+49Es5fdEzxK16+viNa9YdsObDo95M6IE/ju9xNEZoIsT2BmOgLLqpnWspBBxcIt8bGwmrhreXr0Nvhfaj5Dm98COI6uJa3xYQQ+7Ah1z9kFuC2BA/wgKMbM8qa3xhDQ0NDY0TjhYx/oQQE4UQe4UQB4QQ0+qZf50QokAIsUX9u6m+7Wi0EHoj7P8bNn7jnlaRS9Sur2mz9YN6JVT+cyxV4Bd61JsJKNhC+P5fW2BA/xFrPoasTeCjhm6dFb9ZG+GnqVCUAjt/l9OCYrxW9c/fTLcfBxOQu05OGKL+THJ3gKlMenT7TZV9fgGMAdj9winofw/m8K4tdgg6ncDXoMNm12SjNTQ0NE5Gjtr4E0LogQ+As4EewBQhRI96Fp2hKEo/9e/zo92vRgPMmwZbZ8COmfDXPfDXvXJ60hAAorZ97J1Ldiyw22S+W2Oeribg0PvW1cFrLVhrYP6j0rPnrMx1dvko3A9758j3ycOgTXcIiPBaXSh2jNV56JxSNv4R0O8qWPEGbJ0uP8f0NXJbID9PRcFYmY3eVNJih5FTVkNeuZndueUttk0NDQ0NjdZDS1gBQ4ADiqIcVBTFAkwHLmiB7R53vluTxpWfn2ByF5u/g5wt4Oz4YKmSr8nDATCYy4je9PaxHZMzH81VrXrkKAY/2cv2eHgvG6OqUL4GtnEX3FjVz79cVuUSHCvz/gp2y1ZvHiiiltTLus/g0Ar5Xu8DNhN8OQE2fy+nqcZ01xmnEbXjixY7jJwyaXymFlS12DY1NDQ0NFoPLWH8JQCeKsKZ6rTaXCKE2CaEmCmESKpvQ0KIW4QQG4QQGwoKClpgaEfHwp25/Hug6HgPo+nYzFLWJSDCLSDs7O8b04P9F82jrO0Ewg783uAmHA6F675ax7J9Lfj5W1VPVgt5/gCE3XLU22pxqtTPLLANJA6Gc9929+KtyAXfUFn1vGe2nOY08lTcOn+qlE15JpSqBTIGP/fnF9dX5nYGRYMQOAyB6KwtJ8jsLPigldfWaGhoaGgcGccq/vcX0E5RlD7AIuCb+hZSFOVTRVEGKYoyqE2bNsdoaA3TKyEUo/4EugM6Nf78I9yeP6fxB5gie1Id3R/f8kMEpy+udxNmm4Olewu4+ZsNTdrlFytTyS6tv9L071153Pj1et5emce8od/KfrZHicMYhM03rFWEfmdtyeLfA4XuCZ6ev6hOUs/QZfzlSK8fwA0LpNxNrX68zg4fKKrxZ/cwDg0+svpX7yO30/8qaUgi2+HprC3npXMaf2O6RbfYNjU0NDQ0Wg8tIfWSBXh68hLVaS4URfF0n30OvNYC+/3P2ZNTjtWu4HAo6HQngBHo7O4REAnFB+V7D+MPoLj7NYSl/EnCysfYM3VdnU04FJnknxwZ0OjuCivNvDB7FyarnTvPdFebmqx2Hvx5K3O2y1Zni/cAGDh0dlzzj6kWxT2uobhHPQLKx4HvVqcR6GtghHGf7KYiVGmWwCgZ0s3bAX4hEN5OFrvE9pbzk4fJv1rYfUMpbX8utgDVSPQ0/lSPJwZ/KNgru4MkSnFouzEIvbWixY7LafzdOLJ9i23zhKOqUIbujUefqqChoaHR2mgJz996oLMQor0Qwge4AvjTcwEhhOdd/3xgdwvs9z9nyV4ZxrPYW2F+WX1Ya6SnKTAKht8JbUdATC+vRRw+QZR0mYyxOhdDdX6dTdhV4++KwfVG5r2osUgZkzbB3j1q9+RWuAw/gHDKuVS/DMq8nglaJT+uTWfWlqaN09eoI7AqHb46WxbWhLeDe7dCSCLYzfDZGNigSu1c8D5cevi8PFtgLBljP6Q6ZqCc4AptC7fhaPSDffPga7cX1eHTsp4/q/p9N+hOYSWo1zvCjCuP9yg0NDQ0/hOO+uquKIoNuAtYgDTqflYUZacQ4nkhxPnqYvcIIXYKIbYC9wDXHe1+jyVm2wli/CUNhkcPQbuRssvE9XOh69l1FquMH0F+3/pFlA06wYX94ukUHdTo7mqs0vjLKTV5TbfVMpbbi1zeMH4C+buaeCANo68pJPnvWwnKXHbU26qPx3/fzr3TtzS6nNlm598DRThytrsnmsqkAag3yPy8hAGySjdt9ZENxmm495sK4W3l+ws+kPmEasgXoKD3rRR1v/rI9lEPE3vFMqJTJI//vr3xhU9GnEVSzjZ8GhoaGicZLfJoryjKXEVRuiiK0lFRlJfUaU8rivKn+v4xRVF6KorSV1GUMxVF2dMS+/2vGdI+gmEdIgj1b7gPbaslcyMsedktNeKBOaIbeYMfwRZQN6crwMdASbWV2dty6syrTbXq+ftzq7enrLTau5DBV6j/t0C1r8MQQOihefgXtrxhUlrd9CKSwkq5bEehVvFe+BEUp3hrKyYNhco8+GoifDAMUlccdpuG6jx6fNOD8L0z5IQzHobAaMhY6z6PncdL8Wdft3Fe3uFcKtqe1eSxN4YQAl+DHrvjFNX5q1C7shgDD7+choaGxgnKKRzXaRyz1Y6vQX/M97t8XwHtps3hr63ZzVtx6wz4+RqZb7bmA1j2aoPeC52lkrYLbyRs3y915pWbrOSVm+pZy5tqsyxM0NfKh6xUpzvpFK6mlrZAta9iDMDq3waf8vSj3lZtwgJ8GNEpkvZRjd/0iyplwckH9gvggT3SO7d/EWz50b3QwOtkS7uIDlLaRXf4FFtF6NFbKxF2j88+rg8UHZA5hSBz/VL+cUvJII1Gv6KWy6RYnVLEP3vyKWmGMXxSodNDz4vhur+O90g0NDQ0/hM04+8wbM0sY9m+ggarWWtTO9x5pKQVybDT6oPNkJnJ2wkLHoOUJaDTueVVGiDk0DxC0hcRmOdd1ZtTVsPm9FJW7C9sYE03CeHSmIsO9vbo2Tw8Rted1o6uUarRY/DODTxSLMHJ+FS0vPEHcNmgJG5oQqFDker565MYhj0oFg79KzX5nBW9AJEd4c61Mv8SZEj4MNSReplxNRxQq7KdXtNFT0N1oZfxF73lfdrPvbzxg2siu3OkuLMzp/OkZP0XsOCJej3jhLeDyV9BwsBjPiyNU5yN38CLsTD3Ydj8Q+PLp65w5xVraDSDVm/8KYri1h07xtw9RlawFlc17gHZkVXGGa8vZUtG6VHvV68m2tub014rbZWs9jWrXRni+8vXBgyO0i6TMYe0Q2fzNmyb09KrbWQg7SIDiAj0liwZ3lG2H7tmeFuePrcH6/erIWTD0Xv+ACwhyfhUZDS+YDP5bPlBMktquHpYW+8ZZZmwe7b0ojrs8HYvzpzemb7iAD+1+RZ92krZuxhkrmVt0tfK11rt3Oogahl/FTmAej4M6mfs9J6Ofcq1mt0YiN5SKcWjWwBngZNQHbo2u+O4/QYPx8a0YlbsP0I9yvWfw+r33a32PFEUWPYa/P3sUY1PQ6PZzL5PiuKv+xS2NMH4++ZcmH1/i/32NU4dWr3x1/6xuXR5ct5x2ffAtlKjrSkFH+2iAqk02/hyZepR79dZcWtvzg+631Tv/0c9ALevlmHDBnAY/BE2b8+Ho6n7tFmoqKykrMbqKvxwkhDmTzu/asbue4EpH/7DEkd/Jpr/D8IaryBuCqaI7tj8I1tkW56sP1TM9PXpdUPei56RlZ/fXyI9RmXS8OyrSyFw9wwcOdvcnrngeuRstv8sXxupnnV7/tQcSU8ha+f2DX4Q3UMW9ag4jEEIxdZi2odOQ+/KodIIvuyT1cftN3g4LvloNVd/UVeuqEk4jeicrXXn/f0sLHlJhtc1/husJilK/1+QvRn2zPlvtv1f49m5KO1f+Vq4Hz4eBZUFDRt5NS3X3lHj1KDVG3/Hk0W78gBZ2dkYT/2xg7Iaa5NDxIejxiI9P01OuM/fDaUZ0ti7Tb1g6PQQU1+LZTcOQwA6q7fx59xnsF89+WmlGbBvobwAvTcQ4zs9Kam2csMI7zDpgfxKQsw59K5ciU/2OsoJZI+SzF87i1whxaOhsM9tpFzwZ+MLNpNqi52M4hrGvlmrknjwTXCt2pUjb4dr8s3tZWg8zeQvexdD/Z6/m5fA9Y0bT4rOSHGXKzBFdJcTvESeVePP6C+rpgv2umY51MKElpJ7sdgc6ATcP74LAJvSS1tkuy3NBf3iSY5oXI+yXpyC6AeX1A39VsrffWOpExpHSOF+eCkGdrXQb7giD54NlWF8gE9Hw/Sph13lhEFRwFwBudvgy7Pgre7e8yf+n3x1dgLS0Ggirdb4q7HYmfbrtuM6hh/Wyryypnj+MorlDaSqBfKknNXFNofCw79s5bJPGpEK+edF+OVaaezF9jr8sh4Ud7+akq5XeE1zev5evqi398I7foP/9YIfJ0P6Gojuhp+1FFAY0DbMa9GfN2SQrUQRISrpJLLoI1K4wbiQ+37awFuL9jV5fMeaKtXoNnl6MvfOk1012o+SVbbp7nMRXSYrjstEqOyd7B8O3c+ru+GEAdD2tMYHoNOTdfprVCSPlf97ev6cOX5Oj9V6t2ag3SjntWSLN1+DngqTND6Hd4hkcLvwFtt2SxHoa6DaYmt8wfqoLoKQBFlM8+tN3h6VCjVNwXr0D3Ia9ZC5Xr5mb26Z7VWohXGr3/eefqKFQut72LCZ3BqfxQfld9Pze9l1EpwxTQr7a2g0g1Zr/GWX1TB9fcvndR0JTent4TT6yqotTP1sDZvSj9wNf/ngZDY/NZ7XL+1DbrmJ3dmNeMtKDjVaTFAfpZ0vpqzj+V7Tgv2MTB2aTLtIj4pXhx1m3eUOaRbuhY5jAIiinDUHi722UW2xca2/lDXpJLIZrdvK0/qvURDszzv6ThQhqXPpOOt8dOayRpd98o/tTQ5ZVqlVyjaH4i7emfsIrPtEvu95oatjSikh+KpFJ8UES2Ftc0Wdlm1HhPOm1VE1AgOi3Dl/w1V9Rg+dv6rYIWSMfge7X8TR7xt4aEJXrjmtLYNelJXi5SYrVruC0lI30/zd8McdRx32+3Ftuktyp0lU5EovkblC7nvwjXDWSzK8lu9RLV24X75a6ykG0Th6bKqR01KhyupahXFG6Q3W2U6w81dej7i8qRy+u6jWcqqxu3+R7BN+xqMQlvzfj0/jpKLVGn/+Pnp89MdveM7w5/3jujC6a+M9Tp2h2u5xIaxKKeLhX+rJJWoG4YE++Bn1JIb74+fjITdjqRXaUxQoOcSa0hBemdc8uQ+9qRhjuXe4ICbEj87RQVz+6Wp3tWd1sby4jH2anT0eYOLMGux7pEHVRZfB/81TZRvtNpjzIH1zf2eyQ87vpMvCT1iwYcCBDmtzilgaGre5lICCLfVe3H/ekEFOmfvJ+Ps16U0uVvAxuL9vJptDfraVue5CjXHPwujHOBg8mM/t52APTsCsGCl0BMOAa2Ro9ygNpB7fdCd23cvyn0mvySf7ao/Ka6eR76HzZw1pS2mni3D4eLfy8y3Ze8Tj8dHrXJ0+dmaXsyWjlHJTPV621BVQ3Mw815R/ZDL7651llfRR0uT0iFXvSe/1K4kw9BYY9SAMux3u2+5OkSjPkTdh//DGC3Q0jgxnmL2lutJUeRh/u2fDnevghoU4WuJB7FjiGwLjX4C7NsDFnwFwxxf/YMmtJY7/4XCZ07htBqz+UBrRpf+N+oHGyUurNf7sDgVfg46oIF96xIW0nNehiTjz/HyNTfuIqi12rhicxINndQVcNZpHxFsL99Ju2hw+XpbCnG05FFSoHpIdv8HL8ZC/x/30V1UIlkpWFwXX6bTRGLHr/4+Osy/1mqYoCooij8cVUgtqA3eugX5TmRV0GVlKFPpDMi+uq8hw50SWZ8L6z5mc+yaxQj7VdxJZtA/TU6M4Q9lHXzWq6GX+m87mfbwHCyp5ZOY2Zm91C1SP6x5D97iQJm139t2jeP6CnoAa+q0pkaFXzyKOjmP4uO2bzPSfjOO+HXQ1f02uEim1/JKGgE7HLxsy2JnduFeyfnQIxcPI6ncl9LjA/X/WJvlqdOe6CZuJgJy1GKrVXDXFQUDeRrr8Op6o7Z/V28YP4JcNGfy+ObPO9O/XpPHePwdwKPJ36MzprDLXY/x9cy68P7h5hzj4ZvlqLoOSIy+QCvDRc9PI9nV0JutFUWDnH9KbGttHSiOBLGn2C1Fzq9Sw+Yh74bq5cMeqIx6bxmFwPsDWJ7NzJHg+HM24Unp4k4cSv+ppEpY/gr6mGZJZx4ut06GmGEbcA1GdIbYPFSMeY2deNT6mIhjzFNy2Ui5rN0sZqNztMiT8/cWyvaRGg1SZbZRVW4+5HdGaabXGX3mNjQqzjfen9mfuvaMQoinBV5msfs9PmzlYcHT5T2arNFL+b94e/tmT1+ByxVUWnp61g8HtI+idGIpBL8c5xuktVJQme19mbcnij81ZHFDH/t3qNJe3xe5QZAcJgH//Bz9fqw5UhoS31UTw59ZsUgub/jTtMPjXkXrZklHK87Plk2Z1PfmL4UoZY3TSADH7x3BASSC9qJqFX72AUivJeqm9L6kDn6B7lA8mVOOvBTx/DkP9xt+sLdkIAX2TwsgskTeWSrO1/uKVBhjUNoInz+mOn1HvTvwPVj1Aaz6G5yMx11QR5GfAKBTuOr0d/du68+HKaqw8PHMbV36+9oiOTdHp3VIvb/WgPGUNGeM+di+wXRXl9hCMNtQU0nHOZIIzlgLQ+4t2tF14PQBx616k+4+D6v0OPjxzG/fPqOuhXpfqDuNb7Q5XTmdt8W6XseTw7ujSJJKGytddf8Lvt9W/THk2LH8dilLqzHI4FKotdgJ8m3huS9Plw0nHMbI4J+UfKDzgnv/+IJg/DULiYPzzjRZLaRwFFvV70+eyltmeqHUb+2IcfDCUyD0/ELFvOqGps1tmP83kYEFl07oGWWvg91vhgyHSi/5sKHw4lMr2ZxOJmvIT1RmiurjXMfjK9ITY3hDZSeauajTIt6vT6Pv8whOnVesxoNUaf0bViCqpslBSZWlyaGd3Tjl/bs1uUn/Wwkozc7fn1KvjF+Rn4Meb5Q3qUGHdJ9SyatkF47MVB/l2dRrju8dQY7Fz1tvL2fncBJ48twe7ssspfns4vN20Iox7p2/hvhlbXEaX5822ymKTuX2B0VJ3rvignBHZkZSe97LWIavAnEZPU6iv2tdT6sUl4fLPizBdNrnvk/Yt7/h8CIDvRe+RPPhc+iu7GXPoLaps8pztu2Il9xue5P/Cn8XYfwobU7IxI0Mwn107qMnjawhFNf68OmEA+/MraB8VyAM/b+HNhbKwZM3BYtalFpNbdnivqM3u4NbvNpBZUs1NozoQ5Gtwt/kKUoWbfYMAhck5b9LNkAPPR/DQnssZ1bmNazurU6QX4v8u9pbYOZBfQX4TuqYoOqO7cri6mHUpBVz1xVr3E6sztyd5uHvsaq6f3lTsMvIM5lIsQW5pnabkP1lsDkqqLF5hcrPNwawt0stcUTvs6/Q+D7i20W17sfg52bLuzvXSi1F0QOY22W2QoUq3lGXBn/fI717+Ltm1xgPnd/PdxfubVmGfoRrjycPcnlzPnNGIjnLfJWmyR/OeufD1ufK9RssS3ha6ndtyxt+w2+HxHLh7k3tagbuDqMPYeJ/y/4Ibv9nAq/Mb72RaluFWEODzca63Ss4WLtcvxa4zQvvTpcH3aBrE9ZX5qIpdFvhFdZFKDA15UqsKYecfJ4YH9D+i3GRFJ8B4HFPJWhut9pNoqxYc3P7DJvq/sIiskqZV3jlDQA06Ch0OV6L59qwy7vhhEz+urVsmb9TrGJAsPTrZpTVu48Fhh6pC+j6/kKEvL+ac3vJG4u+jx9coc/OqLDYcDoVLPlpFRPlu6XGoTWm6TD73oGtMMBN6xngZfx2iApnUO5YQP6N80qvKl50kOpzhWm9J7HVUIw2ivPKmJ9E7DAGqPpzb+PVsUuIK82Wsc1VA5vq6E4tzawT28lx661IxCAfVoV3B4EeXLj1ROo2j2ia4+8PfKFDCuMnyEDNvG+76TI8Gm18kVdEDUfTeHUOqLXaCfA2EB/i4WpM5w7ilNYd/Aq+y2FmwM4/9+ZUcyK+U+Y5JQ+CWZRDXl2qLjYd/lRfp2CBB7x5yu5Rnej08rNhfSJCvgbHdvfNEx721nFGvLWn84IT0/GUUV+OwWdhdYCKtqJps5/cvQC3q8At1raIY/HHofTGYisEjZGwO6+R6r7PULbSpHRK/60f5W3OKPPdPDqPvcwtdkkcVJiv/+3ufhxGrQKfxMOj6xo/LE0sVBLaBNl3ALwxqSmH+Y/BCJHwxXoppFx+EA4vk8r/eBJ+M8tqELXc3l+pl6kFhZQPf+dIM2VN51yxZoe4TDDE94aJP4MwnIa6/e9mkIbKQ6csJ0hPp/J2Zjy6CoFGLXbOg/WiZ01aU4u2RdjRTKSF3uyxEM1eCT4DsqFOL/RfNo7TzJUc15CPF36hv0vX4ws88vO+hia638YvvYUJ7A+YRD8scVAD/MLh5qewlbgyEpGEQ1QlQI0PWGndKg5NtM+CXa/EvqjX9FOKf3fk4FFjbnK5ZJzmt1virncdTbW2apIPTcHpkQrc68xwORbZAezEaHA4qVU/Gloy6T/fFVRZ+3iCrjT9fmcqwV9Q2W6s/gNc78qHxfwCEBchw5q3fbWS22ot3yEuLOet/yzmzWxvmGMe7PUee/K83vNnFa1Kl2Uagr8FVaGF3KJSbbO7CF8/wV0iC621kkA894+VNPL+i6Xl/DrXjhvAI/To9rO0iAwgL8KGkyoK1NAtCpRepJNQdDqv+61FuTXuAJL8abIqOwJpssJlYuDufjeklpBdX007kcpvhL0KpYlN6CV+uTJXn4SioadOXg+f/jinSOzRXY7HjZ9QTFmCkpFqGIp19eitMNv7YnOXqyVsbp6G7K7uccW8tkzl7PoEQ3w98g1h7sJj1dmlMdZp4F7eOc0vh3P79Rtf7HdnlVJptXpXqTq9dU0IOxd2mUpkwiuziSnTYsSoyrFmmHo+rQrLCndeIENh9w9GbS0BnpCLhdACCM5dgDYglZ8jj2H1DqU1KQSUH8t1G4ULVyCuqstA/OYwRPge5U/8H/piICvKhxmLnf3/v5/Hfd0DmRulNO/89mXDfnFxOa407Z9E/HEylsndx4hAZwlr0jMx/cmIzeYvfAqG/XsEbxk+IoLxuONpJULT0KmZvlnl8l30t9S+D2sAZD3uLbieqeYsVORDW1j0+Te6l5bBbZe/xz8fIDhbvDXCHgFe9D89HuD2/TaG6CDZ/J3NO/3mxzuyi7tdgCu/aQoNvHla7A5vDQXpx4x73VCVOiuCDl/EHcDCgLz/71fKQ6nRS1P++7TIlxRkOLtwvH1y+vdD7e7tXFt/pLaeuF9sZ0So3HUGKyklKqzX+0ou8fzRN7TMaHezLrWd0qFf89X+L97N53TIUoQchKKtp+IuQVVLD07PqeVKK6gzAJP06Boh97kpXpO6YE4vNQXGVBYcxWEpL1Caml7zRee6ztIbfNmXROSaIcNWoLKw088eWbFJyS2TIykmoO6R3Uf9E5twzimBfA/nN8PxVJowkc+QrXh40p/H32qV9aR8VyO0/bKSiJN/lcbrporOxoWeF35nsEx2IFBVc3y8IfVAkgVO+gns288QfO1xSMfsc8mL2hO8MXp67h+dn76LySLXZGuHTqwfx4ZUDCA/wceXafLPqEACphVXcN2MLL86pvyLaWdzibFXnf2gxjvcGsWWL7H28bF8Bh5Q47u66FEc71et6/vu8E/uy1/doUq9YdALe+dutZ+g0Tu4YXdczUZv8AfdR1vF8bDa5TSuq8efch9Por1XJaPOLwGAqQdjN5A18kNKOskhk7+SlFPa5DaWe1nqHiqroneA2CrvGyGrhSpOVIF8DfSybeNj4M4GYmXZ2dyZ0i+BV42cMCymQN/A/74aNX8EPlzRPtsNa7WH8hUnPX+E+6ZUbdKMU0s7a5L1OYBt5Q/vxcunx6SXlL0bqtlNtbuDasOhpmY+Ys1WGGjuNq385cGupgVzWqad4qsi92MwyPGj/b36bgDtVxVQGfz8j31fkyfSKhapAc8oS2PIjLH318NuqyHXL81Rku7d95pOuRYTDQuz6V2k/e3ILHkTTSC+uZl+ejCIcDovNQaIoYNKY0dIzXcv4y9i1mm9WNyDgHKhq+0V2gvPeBb1Rfner8mHNR7BfSjU500j05tKjOKITG2ck8HD3/FONVmv8VdUyEJpq/LWLCqRrTDDP/lXXcNuTU47FrmCJH1zL+HN7ohRF4ad1dVt8+WOSoanEwaTcvI8yJYBrDQtZ65Ec3ybIbUTZ7A6yUndzXvVvUtKg9kU1LNndtaEWT0zqzoYnx3Pw5Ul8d+MQ7jfMxL7pB7jiB4jrJxdKGlJnvX7JYc0qbjBHdKOk25WuHDqArpkzeKvXIWJD/LDZHeiAUCrdYQe9kSy/rgSa88lXQgm0l5GaU4AS2EYmy0d0oMZix18NgecijcY+uI0hlxfrCDFWZtN55liC0xZ6TQ8NMBIV5Et4gJGSKgtmm52/d8tK1xT1IjyxVz1eWKBKNSCcxp+uIhtd0X5un76LrNIaQvwM9IwP4YlJ3enz3EIpqzPgajIiR1LucUG59YyO3D66IyUelWVFqhZdp+jGc4+EzYSw1WCzO5huG81uRYbZXd/V3pfCo4ekR9KDnOHPkt/vTsL2z6TTnxcgbCYUISuHg9MWYajKrbOv6GBfusQEY3cozNyYyTPn9yAy0IfXLu3LpQMT8c2Rhu8I3Xba7fkc69xpXK5fwpXbb4Lr1PZZy9SbdGVene03iLXGbVzF9pZeN1Op9GB0nSinO/uaOuVrUpfBax1h3wKwVLO754OUEswZ+m11rhUoCvx4BaxVC2VS/oHtMw8/poAImYcG8rfpMv5OEc9f2ip4vSNkHmG7vNpkbYQdv3pPc+bh6X3A+cBZliENPlCFzBX443ZY+vLht5+6XBboRPcE31AYeb+c3uEMGHILAEHZ/yLsZvyLdh1mQ/8NnoUe9UpNFadistjYs30Dy3zu4+xDr4GlAhQHOQb3g/0F+lWkFTVSxGf0h4HXymKw1TIfm8XPyYcycHUK0ptKj+aQTmicigXlNf/hw80JRqs1/gBXKBPqrzytjxqLnQP5lfyzJ9/VocDJpvQS4inCN2sNPBtK14PfcKZuM1aL+wK/O6eCx37bzsJd8mZ5zxjpnfPBhm39l1gXPU+pVc88+xDG6Dajr8jmtg4yyb9bXDCgkEABFSYbCULmF6SM+0yGm5xYTbB3rlerMIB3rugHQEm1Fb1OoNMJ2gT7cq/hN7qse0L2dozpKb0/Hjf/h37Zyu3fb+S7G4e6pGaags5SQUjqPLr9OAi/ol2EHvyLNhvf5RyxijPeWMJP6zOorK5mt39/HFFyu6/N38P9ZZfxlPU6ciyB6HFwwcEL6Jj+ONd+uY5/DxRSbbGxKsWZWyHY70hgCe5Cj6N9+lKEwK90P4ZaCcyfLk9h0a48LhqQyIsX9XYZdOD2vsWE1G9wOxSFhDB/YkPV+eqFsoQg8spNPHBWV+bcM4o2wb5Umm34GeT5DPEzuo5HURTKTVbCA3xcIXuA+DB/3p/an83ppXW+k7Xp+OcFJC25BxNGptluYamjH4CXgekyxD2oihtG1PbPSFz5GAChaQtwGAIxVmbTbtGNBORtqLNOXrmZ6eszmLkxg4d+2crunAo2PjWegW3D8dHrMCA/v/a6XAbtfxvfzV8CUCAi3dW6rgHULyfjZFtmKXty1crFHhe4e1H3ugTGPiXfR3WRkjmRnaCqQHoH79vmNhSsVYACcX0oyzvESnsPTtdtq1vJrChuI6aW9uFh6aXeLMPagn8ExPQGfdMfpk44bGZ3mzunkesUuD5alv4frP3Ue5qzJaHdAtFqWk5Zpjzng2+CaRkwVK38Pu3uw2+/SpV3uWYWPJrq9twmDYFJr8N1c0gf8yHWwFj01ooWa33YVIqr3L/XOqHGnK3wbj++e/cJDvzxMmbhy9SUsWyMugCG3sZzbb/hrNA/2dnuGu613EGTsmQq89V8ytOlXqATRXEVLZ3Knr/LBiWhE1rY15NWbfx1jg5iRKdIbjujI+3bBDa+AjBzYwYfLpW5cZ49SRVFocpsIUa4PXXjMt7lZp9FjC/6yTUtpaASgYPT2YzAQaVqQJQRhMWmYNzyDeF7ZvCFfRIvhz/PeP1GpmXfwxvGjxkk9vJB0hIeMv5MhdnGy2Ol16vIr513BYqnLpUHYQHS6zTurWU8OnMbj/22nUc8xKIty99y945VFJbsySejuJq0oipKj8CbFpC/ibaLb8VYnU/i0vtI/udOKWpsq5H6xiYb23JNnFvyIOuCx2GxOdhwqAR74hC+e+w6cm3ynESIChR0LNtXwJWfr8WhuI0tf6Oej3r9yPWmB1z7bUoezOFw6/x5e2U+XZ7Kkr359EsK4/y+8a6czjcn93UVNlz9xdp6k377J4fz77QxjOgYJbdtKsGh98WEL/vzKlAUhY1pxXyyXH63nB7WUH8jVRY7VruD8hobfZ5dyO+bpVJ/UaWZQ4VV+Bh0CATfrUkjq7HKVKFHOKzYbA6cHumpQ5NpF3X4779v6QHCUr2b2TuM/i7hZ/1hWr9lq/qQL8zexdf/pvLUHzv4etUhfIT8Tt0V4i3E/ELSpzLEdN0cOPd/cmLlYYy//X8z56NpTPyf7PrCgKthyM3u+SHxUsfMeQO/bg48WQAPp7g9cMPucC1u+uxshv05mnQlhvKpf3FBf+9QGTodTFUlcc55A57Ig96XUm2x0fvZBfyp5ubWIb4fTHoDItrLlny3r4SEgQ0f1xGwMa3kP7kBebUkbCprPoJ3+qlFcGqkY/dfLNmTz6wt9XSbaApVhTI0X5ErCw88DfO2I9zvIzsBQhp/yUPhnDfleds1S87vfJY0Tle8BUtegS/P9vbCOlNp/MO9H6ydtBtJTZu+2AKkp78+z3dtCivNLaYD5yw4W/HImUTVigjd/p70iHav2cQINqN0Pgvf8Hh+aPMARHZkRKdIiiotfO5/I7McIwEaH9fBpeoOTNJB4KSmRD6YJQyksPdNxK96ipBa14lTgbTiaqYOTWZA27oPzqcqrdr4+2NLNr4GPdPO7kbHNk0r13d6CKOCfLjrh00uT0tJtRXFauZn+2j+Cr+Wqo7nADAsrJQrmSOlJoB9eRVcpl/GuTvu5VL9cr78NxWBg4cMMwgQMp+uQ+fuLHrlVsZNuICFdunRulS/nMSif+lh200fQyY3jWxPgEmGwqJ3fC4rD50486OG3u6alFlSzbVfukMuqUVV/LQunUNZMrF/hm00fZcPYn3IeBhyMw6HwvVfr+fhmVspq7ES4m9gw6FiRr++hN05jbSDU3F45IH5l+xBEQbKwnuyOcUp7eG+SV3x6Rqe/WsnNVY7EQFG/Iw6Jk08h3/a3scThh84T+ctiDupt7zofnndYJ4+112Y4WvQ8f2aNGasP3JFekcDUi81Fhv+Rj1l1VZWpxS5On0E+RlcFaoVJhtF9Uj7OIkM8uHli3oTb6ymWi/z4R79dTuXf7KGhTvzeG2+9F44jb9RXaJ48pzuOBTFVVHsLDJ5ZOY2Rr+xlPk7cpi7Q62WbkRyRtEZEIqdc5KtHPS7ikt0y5l2djeGtD9867Y2W96vM80U1gW70/irp9rXietzopr8uS/z65q9pBRUEY40GDOiR/OdkD2L99GWz65Tc0/bjYReF8v3ZfVUtDuP6cfJPGb8iUN+U2HjN7JAxClLkbEOPhsjpWuceorBsbKdnU+A1AEcPQ3Gv8DqCbN5z3YhfvmyJ+w/9n4Y1RxcQBoLBfsgYx1bM0vJu3Un9L4MjPL7suFQCRUmGy/NaSAMGNFBGqU+TXvQbC4mq51LPlrFTd/U9cIeKRd9+C/tps1pvP93fQTHSbmb3K1u489UxvVfr2+SVFa9ZG2CffOhTTcZxvTsPNFuBExQw7lCB+e+BR1GS4+gMy3mgJqntmeOzO1c+gos+z9IX+Wd52oul9WujXhmTRHSwxi39oXD6q1uyyxl0It/88eRGr21KFGvMeGB3rm5WaU1GJHHOsvUjxhRyjbfgYT6uyMIozq3oajK4tLb1OtE48Vizt7hXSbCuOdkyzeA19pDn8vh0q+w+UcTuesb2i6+veHtnKRMemcF/kY9ZzahW9epQosYf0KIiUKIvUKIA0KIafXM9xVCzFDnrxVCtGtsm35GPT4GHUWVZjJLqpucJ+Y0/t66rB8VZhvfr0lnV3Y5DkXhqpHdeNJ2I3fnTGD0zklUBySQnnQBwlQmw7BARfo2LtZLD8Wd9z5Fh6hAbu1QzF2GWXxqO4cDAf0gcTAmq519eZX4RyayKOBseZy9LmZeQSTtyeLG0xLI2PoPAO0OzYBSj6RdZ6il2zmuSbUrFp0FH+UE0MP0Jc/armFIlyS69hrAipir+FpNAj6ndxzlNTZC/Y1EBPpwqKiabZmlTfqsHAbvopiaNn2w+ITjh7xwlVRbuC4+gxU+99JTHKKsxorJasdid/Dy3N0EJfSgZsDNjNVtppNOGozn9onj9ztO43RV++6fPXleRu2C+05nVUoRj/663dU+7FBhVbOeuJ0FKp4iz4qiUGOVuYZbMkuZ8tkaNqRJI/vW7zZitjv4/kYZqqysp03Zwp25XP3FWqx2B9HBvryz3cCsancRQGK4v9cTfJCvPD8DksO5YUR7Xp23l+X7CgA4u1ccG58c59r/J8sPMmebNP5q55LWOTadAeGwgsOGDgUbOgoqzI16dmq3dgPIOv11HAZpyNQn9eJMqwj1N9IlJogr9Yt5xPgzF+tXcFvHIiZYXiVfCWN7Sjqf6y/nbPMr3BPyP1IKKnlr0T5Zte0XSvUl33Mg/vyGx+jRjYRdf8Bno2GO6gk2+MqqzcK97mUK9kqh2yUvQ8pi2Pg16A30HTicvUHuXNcDSgK/fvcerz7/gAwpL38DPhiMY/qVGObez6I0u1dFb4aqgdkkra/KfGmU7v6r8WWbiNM77ymifWTbcT+8OAu8Ugua9xvCWgOdxgJC9ohVvWqKKho/tJGHjQbJ2iC32W+K/N+Z2mI1yTxAvzD5f0gCDLpBvv9giDzPICVgbl8t8zU/HytDxAChydIL+M158MedskDIt/GQvimyB4cmfE1x96vRm8sI2/eLW0fTg3k7pGfQ11CPF7GZ5JebCPE38vCErtz8zQa+WCm72CiKQklRPolCXieGhstQ9AMbIggLMFKqGn9OqaWs0hr8jXoOvHS2FJ1vAJvdgS0oXnrKh98lPamDbnTlPrLuU8jfTeSub4762E5ErHYHNVY7Rr2uaaLbpwhHbfwJIfTAB8DZQA9gihCitjz+jUCJoiidgLeBRkq5ZMjXYnOwNbOMka8u4Yd1buOp9kXOane4xI2rzVb8jXoGtQvngfFdeHX+Hia9u4LIQB+eHAwDk+QFo4Bwnhe3c8323pQZY3Ds+B2qi3k28yaG6vbwszKWtm2CSbSnc3bhV5gVA+/ZLuK5yNf4cUsJo15bwqvz9/DkOT1Y1/Y2ntDdh19iH3Y7ktEpNnIObGVtdTx/2NUnMtWzSFWRW8Yi5R9X+MKZnzZ1qEzwd+vhCWKiIqnBj2fO60GIn5Grv1jn6sIRH+ZPuclKiJ+RdpGBBPsa2J7VtJJ+p+cvc+T/oQgDlbFDsen8XMafyerg2TOjSNIVYMZAhcmGyWYn1N/I92vS+WL5fkIKNqITCkWK/FyvGtaW/snhrhvsZytS2Zopx3PfuM60jQzgov6yYvVQYZX0Vr6x1CUz0iSEjvKkMViC3YnRFrsDhyL1Fp2Gc8c2QWx9+izaBPtSVGlxVbbWNrQdDoW0ompW7C9ECMFXq1L53H4OT9hu5OphbQHolRBKVLB8ih/dtY2reMNktfPD2jS+/DeVp9Tq8NhQX1coFSCzpIZAtT9zY9XYDr0f+ppithySYdQHz+7FDV+v59Fftx12vdxBj5I64VsOTppOcVd549VZKkGnx24MQm+ta/xd2E+eh3vHdeGSAYkki3wKlBDO06/mqsqvsaPnReuVJIkCehmz2a20ZU9+DWPfXMa7i/ezRg2f/6sfwrjP9rq+d44df/DTr7+wXT3vpZfNYlbMXdiNQfLBx7Pgw2kMzL7fPTDnw9Haj6VUS2kalGUR4GPghbtuYortWUbxOdExcXQoWspV9j+kqHfqcgAsNjvv2y6sU/F/5dC23HlmR8qqrY2HSX1DZDXpgcV15zmsBGatPPz69VCfmLyTHVll/L0rz/VA1BD78yoY9OLfzN7m7Z2vMNsorGz8xrZkb770Pv8wWXaViOsDaf+6wtsOSw1jdRt53G8mn85d1eQoAkijtHTzHyhJQ2VOqNBhO7SaDTNexr5voTSmnRp0ncbJPsobv5L/R0uReox+7veeRHWGHTNlWHnL95QEd4Eb5jVpXBVJY6hIHktg7hqSlj9I8uI73DmDKmsOFtEnMZRJveMa2ErTefavnbwwexfXDG+L0aDj42Up7Mwu44zXl9Lvx37c7TeXefbB6AMjeLP9Z4TGtiPU3+gyTO6fsQWAi/sn8OddIxCNKFMMfulvRr+xFAKj3A87wTEybxXg8h9g64/Er3n2qI/tRMQpTv/h0hRu+Hr9cR5N66ElPH9DgAOKohxUFMUCTAcuqLXMBYDzsWMmMFY0tV8bMl0uv9yMw6Hw8bIURr22hMI1P0GGPJGT3lnByFeXYHconL//ca4wLCXAx8AVg+K5XL+Exww/cPNr38BHw/nC8RR6NZF9elEH0k0B/FwzEGX/IuzFh1jX80n2GLvziWUia2e+xbc1d9PXspnljj5UEEBRpYXdOeWufrtlNVZ+2mXmh+ohVJltrurMA3++wRu2y+l2xSvyIMzlsOlbeL2DW8tq5VuykwFunbllewuICPThjK7Sc9ZTpDKl9FM6BtRgsjr4dLl3q6sbv9lAckQAvRJC0ekEHaODmtziTVHDKKGpcxCKjaq44Wzs/woXWp7nisFJnNGljStEXaoEU15jJT7Unw5R0vBZsTeHUSuvASAkIpo7RndkWAcpP1D7Juaj12G2ORBCcONIWXn107oMVuyXF+EdTTRYnaRN+JrSLm4JB5NF7s/fqHcVdSzZk0+Iv4HwACMzN2ayJlUaK5VmGyarna//TeXLlalMfu0X4pfcS+dQhWBfA/8ecOcEOgWEeyeGEhkoPX83j+pA19hg17ifqiUJFBbgQ9fYYC7sF8/WZ86if1IYsaF+BPjoGy12Ke5+JUW9bqBmvzRkIoKDCPEzsiql6LD5gg6fICqTRlMVfxpl7aVHOWGldMIfmvA1hT29hZhtdgdr1c/DbLWTVlxNoKghJDSCAV3a41N6gBcNX1BBAP11B7ija4Wr4tnJb2puY35WKtfp57Ns026Usiwss+5l7cZNPDxzKw6HQninQYy94TlKk8aRl5eDpabKLT2jFq+YYzwEl51ivaYylHLpMf1pTQpf/5tKeJAv0b1G061DexbcdzoH9e1IEEV0CLSwI2Aw+wc8Sbeyd5nnGEq5yeqqtHRKGN15Zie2PHPWYT0pgDRCukyUxsk358OsO12zElY+Tod5U/Et2XuYDdSlW2wwv95+GiseObPOvO9Wp3H/z1sa3cYPa9OxORR+XJuOw6FQYbbRNykMwPW7b8gDqCgK13+1nncX75Mh1ZAE+VdVJPMdB92IviyNd4wf0Df1c9qtfpJpjTx0ANIzm76GBf8sIax8L4uUITJ0fsMClpi7Mmj3q+h/uVou2+Us+VqZB9umSwFi8JKuQghpPPqFuiuwIzsyo983fNT9O2wY+HNLJuaQto2PDRDWaoLTFkmjDwhNmy/lZFQsNgdbMkoZ0Smq/v7VDeGRg1hWbeXhX7aSUlDJsr0FVFvsfLAkhZtGtqegwsw5767EXCxTI/zie2PCjzElM3nw2suYf9/pXNgvgRtHdnCNB2QRmhDQbtoc+j63sEEN15JqK5n1NUFY+5F87X5unSIxYW+6JNiJRpXZxuoU9zXcs1iuvJ6oz/HErto07//TQoVWzaAljL8EwCOhjUx1Wr3LKIpiA8qAyMY2vOKRM/n19uEoCny96hCzt+fw+oK9ZJVUETX/NvhiHNUWG5cVf8xo3RYqTTa6V63n6uiDsPFrov+XxKvGzxiu20VPs9QNC7t2OrPvHc2UIfJiExPiy/u2C/nIdi5fpwQxZPLDHDz/d1KUBOaVd+BN3zt4RPcQA+/4kltP70BMiC9ZpTUu79Jjv23n1tPljzbQ10CKEs87tov42C5zpELC1Kev0nR3X9bk4TBZtYXVMIvzojO0ZjlT21XI9mJAb10qtxjmEB+sZ11qES/Prdsu6K4xnbhQ9aa1iwyotx1dfVgD4yjpdDG5Q55k7+TlVMUNw6wPwIQvd4zuRHSIL58tkp/biN4dKa+xMuPW4Tw0QVb+mvGBq36DiA48dM1lPDLRLax9+eAkVj82hm6qkdQ5JoiEMHnDd3rNvvw3lXcWyy+9pRGPR2OE+BvY88JErhyWTEyIH7ee3oEZGzKY/PFqV7htZ3Y5Y7pFEx/mz87scp79axflJitXVP/IOcpy3u2xB50qLr7U535m91js8hL2iAuha2wwfkYdhzykF4L9jK75TqKDffEx6PjfFf0pr7GydG8BQ9pHsP6JcTxxTj1eDQ/K259DSdcrMAu1qMUviHKTlYIKM0//seOw6zqpjpaGlC1Q5tBVxw7BGpzsvYxVyuBM7BnL0+98zKNpt3B2aAa+ASEYgyLQVeVzlWExz7SX37eePfux7dkJzL57JIsfPIPHJ3WjTbA0hv3MBTxr/JY7d15O5funY7CUc9C/J3tyK9j672ysG75l+a5MZu0zEWAvx2CvIatKfs5mQyD36B7jzJw7qbbY2J1TzpU/pZDn154HLbfxWM3VFOhjeHpJiSuMfteZnXhgfBeEENx06fkADBW7OHfrcJ7NHwXIbd/142YW7srl8xUH+d/f+5j88SqMeh16naDSbGtcPqr3pfI1fbU7hAaEHpIeJ5+KhvMc60OnEwxsG05SLY+kw6GweE8+Rr2O2duyySiuduVhLtiZy5g3llJUKUP/v2/OIiHMn+EdIqm02FAU6K8af7O2ZPHR0hTGvLmsjqGQXVrj8sx2C6iQ1eyxvWXeZrsR0hPW62KKxv0Po8HAWkc3hul2kVZYTmm1hY1pdUPVn684yF3v/Yzy130w9yEuO2sURfo2PH2gMxsOFUPSED7J7shtfq/JFYJiIWGQNPSCYmDo7SgGP9L8uvHtmjTmq6HXLRmlzO33ETx0gJpAeV2r9ovh0b9SeHXBXsr1oVzr+IOUZT/VGVN9GMyltFt0I0KxUdD7VjnRQ0S8tNpCiJ+Rj5amcOePmxrYivf5WjLvZ3gplqp5z/Dp8hTu+mkTy/YVYLY6iFTTQ2Zvy2ZU5yimhO3mDePHnB0gdQl/rBlKJKWEWnIgewsAZ/WMdUV9nPl9s7Zm8/0ad85kRnE161KL2Z/n7cWfPDCRmBDvbkcA9LsKLvhAvq9l/IWkzqP358n4FjfvAaYhPlmWwqjX/uGSj1a5vru1+XzFQaZ8uuaw22nM890UXpi9iymfreGjpSlUW2wuz19UkC/55SbeW7yflfvrL7p0svZgkZeGr6IoLi1Yp6rD5I9Xcet3GyirttYp4qowWXlv8X7mbZcPrzaP46pSnQ8/r8/gnHdX8H/z9vDGwn1Umm0899dOpq9LZ8ybS10PcYWVZq78fA0ZhymU3JldxiUfraIofQ/8+06TPqdWpWMghLgFuAUgOTmZpIgAkiICuGN0Rz5cmsKyvQUE+ui5Z4AvqL/RgLSl3GyYS4k1mD255fRLGk6HilQpEqrYYezTVMZcxa1r74OithASR/cQuHFkB35al8Flg5KIDe3Md6vjGFAsn4bGdIvmiUnduXJYMv7GC1EUeeF+LA42HCrm0o9Xc+vpHfhk+UEig3y4a0wn7hrTCSEEX14/lA5RY5jio2fJnnyeX5TJxwBLXnIfaE2JTIgGVzg4NtSPiwck8NauqTiUMejCL+bQ/52DsmwXLIG3rx/LoVLvp5ZhHSLYk1vBol15nNtHVgGP6BSFn1GPoig06lzVGcgc/T+vSYMt//JLp6X4+4xjf14loqYEh38gY3sl0S3B/aP+8aahsha1UxTcs7m+c0lcqD9/3DkCi90h29Op+Bn1vDelP4/M3EZ8mB/je8QyuJlVWO1nT8Yc3hUuf8+1P09vzqMTu9E2MpCUgkruGtOJrNIaLh+UhEGvI6u0hjvUrhxXDE7G0Os9+LgX3Te/AMPO5uMrB9D2t0JEQhj3derMqM5RBPoaCPQ1sOC+00kKd9+8O0cH8ejEbkwelMgVn66hY5tAl0EIMHd7Dha7g3vGdvYSAW+MA+Ej+dbyEB+2H8VVQzN5ae5uBjcxD8vhE4zNNxSrv0xuDsxaic5hoSJpjGsZq3qDCQ80Elm9nVCrWgQR2dbrRtEuS815i5DeWiEEHdsEeRVgZfl341rLo9wXv4t2QTa2OuKYEbcPx+7ZBKzIpUhEcldZOHfqgwgW8jtUYNKRCKQVVfNndW/O7xuPTghenb+Hf1OKeajzJ/QfGM7SvfmMyOnPtHO7ce1w6enpHOPO9QpuKw3dMdseBH5kSLtIbj+jE2U1Vu76aRN3/Si/mz56HYPayXSE/XkVjH97Oe9O6c/5feMb/iC7ToLr50sjyTcI1DD2vkv+pvtPQzBWNq84YO3BIj5elkLP+FDuGdsZH4N89s4uq3F5mO+fIav7B7UN57NrBnHrd/J7Om9HLkPbRxDqb+T/Lu7NaZ2iKDdZmTIkibN6xNA5JoiBbcNdFdVDXlrM+ifGsS2zlI+WprgMZ4DYclVBILYPd64wEh54Oi+ufBvWf0Hkk7nQ71wi1s4haMX93N7LwVVfrGVHVjmbnhrPiv0FdGwTRI+4EF6cs5sXDdMRBgVytyMK9+L/wCbEu+t5Zd4e3p/anw1pJTx01hi+1q3CVlPBTb5BcL/7IeapLn/y+6YMqmbtZFTnKMZ0i+bW7zaQV25mSdtYFgdewyumkVxX2R5I55w+cezp9jtJf1xCyP7fYexVjX7uNn+3n8EU0R2bXySGmlLXtOgQP7Y+cxbXfbWu3laB2zJLeXH2br65YQj+PnrWHypm7crFnGmEwLX/43XTAKwYeHRiN3rEh7BsTBrWfYuoufBrRP4uXjG9AHo4LygNc5mRSwo/xE+vhugz1kJ8P6rMNnLLTbSNCMBsszOpdywlVVa2ZpZyft94/tyaTXapibt/2oxRL9j/0iTX+KKCfckrN9P72QW8fmlft5bpRLdWoj1uIHrgF9vpXBywhcjd3wIQkL8Bc8TRd0HpmxTGqpQilu0rYGtGGXGhdUXlX5m3B7tDkTqwPnU974cKqxj9xlK+vWEIp3dpU2d+U7DZHczfKR8i/tqazWsL9vDQWV156aJeBPjoeXTmdt5ctI/5941ie2YZWzNLuXRgouveoSgKB/Ir+X5tOn9tzWba2fI+/c2qQzz71y5+uGkoz/y5k/+7uDeju0bz+oK9bMtcTk6ZiZSXJ7E5vYQ+iWG8uXAfX686xBld2pAYHsB576/kx5uHclrHKHo+s4BgP5lGFexrYMqQJOwOhW9WHeKrfw+5jsWhgF7Iz+XfA0XMWJ/hcry4lnEo6HQCf6OeHVllzF6whmuznpMdjRqhJYy/LMDDZ0+iOq2+ZTKFEAYgFKijt6EoyqfApwCDBg1yxS4entCVm0d1INjPwEsX9UKPA5I/hj9ug/mPoiD43j6ODz9dw+MGX24xqILCV/4KncdxmqkMfpwL0e5UxPk7cgj2NXDtae2ICvJlQs9YVz6Wn1HPzao3D9wqLSarnUd/3UZCmD/3jO3MoHYR9E4I9TKyPKuJLh+czA9r0/k88kFuKnpTThxxn3xd/5l8VT1//ZPD6R8fALtA1+40976ri8AnmKiwEPz9vY2/9lFBVJntzNqSzbl94hnfI4bJg5KYPCiJudtzuOOHTWx6arxLuLgpJFduJTnnJ+6fewO/b87icn0i1m4XcH7feGx2B5d8tIqrhiVzUW15jQbwM+rrDbGd1zeen9alY7E5mHZ2N1d+WFMxmEuxV7vlRbJKa/hs+UGmDk2mS0wwOp1wPUnX5qOlB1x5iLGhftIT0f8q2Pw97JrFRL9Q+eDgH8HAtvLPibPntBOdTnC72rkjwEfP1lqtAq8a1paze8URF+rPd2vSqDLbuO2Mxjt9VOlC+McxAKPRyM2nd/D6PjaGsJkwmMvwLZd5sm22f4LeXOZl/Dk9rWduvo+OelX6ZPhdcMYj3vpsPS+Cnb97h+VUbHYZxi+vsbLM0ZfEhPN46aLeDCw8AO+rEindz+eN6ilQrvCJ/Tx0p91Fl/TpJHWQLeicocpLBiYy9OXFlNVY6ZsYykdXDSTI18D94zpTabZ5GdReBMeSPvgpPlyVw6DkMO4d567+rbb0Ydpv2+mXFMbGtBIGtZPnsV1UID56HTuzyho0/iw2B/fP2EKP+DbcEWNHfH0u7c12HMZAMka/g0Pvi09FRr3rNsS61GKW7C1gyd4CpgxNdnnCnZ6Jsd2iWbxHfqfTiquxKwqPTOzKa/P38uQfO9j34tksfWg0Qsjcv+nrM7hvXBdiQvw4rVOUS0cxLtSPCT1jiQz0cYU0ATqIbKoVX3x2TCdHF0lEbH/mbJf9k18cZcKu92X2lizO7RNP51GXwYiLudUvhN4phUz9bC0r9hfw+uytPGZ+G4NfJWt8c4gS5aRFjKDtpAchti8BOh3Xj2jHy3P38LV6I5vQM5Z3Fu9nY1oVN53t/ZkM6ZpEaGgoHyxJIcTPSH6FibxyM2O7RdM+KpCAwBDs6MksMxPgo+fNyX0RAgpnOShT6hoY9eHZwcga0IYDF86hW/u616+oIF+W7i3gp3XpXDE4yXVdn/3bd3xY9Bqb9y3htF6dqDTbSBBuz1EYFRQQzo3D4iBlCWL2vfgAPtWHXK3VAHzL07AZ/DHYPTxjnWUY/K+t2Uz7bTurpo3BbHPQJsiXrJIawgN9eO3SPlx7WltXqpHVrjD+rWVcOTSZ60a05yNV2qzCZOOlubvqFbIviDsDXyWIMgLZdc0OkhdLPUVF1/R7w+EY1iGSuFA/znh9qctDVpsPrxzArd9tZE9uOf1r9Xi/7quWERdfl1pMabWVj68aSICPnmu+XMeA5HCGd5QPAO2jgjBb7XSLDeGdv/fz9t/7GNwugq/+TaVnfAhpRdV8vjIVg07QPzkMu0Ph/hlbXJ69//29jwP5lZRWW5nUO47XF+wlp8xEUoQ/B/IrufTj1dw0sj07s8sY0i6Cb24Y4vLYbU4vdUWIKkw2PrxyAAOSw4kN9aPGYuf89915xD3jQ/htUyb/7Mnng6kD8Dfq0VXmwL5D0GUCP6xN44nfd3DL6R3oHhdMSn4VVw5ty6G185ps1bWE8bce6CyEaI808q4AptZa5k/gWmA1cCnwj9KM0jQhhCyZL83AsPFrmYvTezJkroedv2EO60TvoGT+PVBEiqJezC//ATo6c2uE7KYx6kHXNu8a05lLBia6Kjijgny9qjnrI6/cREJ4AI9M6Eqgr4HxPWIaHXuInxHl0G4wyFZdxjMegc/G4uoqMvN6+OtelIAIRHt5Q0SRuQBXfr6Ga7K3My44HB9kWDk2xI8aq537xnWmd0Io5/WNY+pna+ngoYOoKAr3Tpcej/Ti6mYZf2adH752C12tu9nmez+X257DcNEtWO0Osktr2JhWwsSe9XfJaC5hAUbm7cjllbm7SS+uxu5QuHtM58ZXRMq96DykXnJKa/h61SHGdIumi4dnqDY3fbOBrZmljOgUKVXfM9bJ3q9nPgldz4HYXrLvMkDb4c06njHdoll1wPuZxukxBJnPmVlSzW1ndCSnrIayGivdYkPq2xQ6AUG+Bq8e103y5oKsFpZrAGDzjcC3ZJ/XMlabgh47Z+ndfYnR+8g8qz6T4dAK2VXjok/g/Pel9IoH61KLueLT1fx48zDO7xfP5ytTSS+uZsmefAa2TSak27lkJ57Nn/bhbNuSTd8kHZvTSwkJDeOc2931XodU469fYpjrpjGsY6Qr7UEI0bDhpxJwxt2s3PEv73pICgGuB6G1B4u4/NM19EuSBT9GvY5uccHsyG74geNQURVztucwZ3sOg9uGMyRzA0G2GsyhHXAYA0k5/08sQc0rDijxUCzIKze5jD9nysc1p7Xjrcv7UW2xIRBEBcn0C6NOx/tLDpBVWuOSEcorN/PFylTGdY9x5bjqhKB9VCAzbh1GdLCcdnbvODZ0jOSzJbt5eP1U0h1tWNT+UWbuT+PCAyW81XkHEzPehNLRmPDh3ulbGNQugoQwt3d7iGo03zt9C9O65nFO2jqwAgKs/a6l7fDbIMb92Z/fNwF/o54FO/NICPOnU3QQPeJDmL0th4ziauZsz+H0zm14d/F+hnaI4OEJ3ZjYM45O0UF0f3o+IFNZflqXzrerDwHyOjqxZ6x8kNw7nwRRRJr98Nfr+rD5R2MNiveqFJ6/I5fZ27KJVK+Tj/22ncHtIlzpKffpZxIgytl9YAn06kRRlYV3bRdj6nIun+8yMH5wT24a1Qmfr8Z7C/f/+w606SoNvNPuhugeGCpy4OOR8nc2zR3SdfaIL6228vjZ3QkP9OGb1Wn4GnT4GfUMbBvBM7PktnsnhLI9q4w523O4eng7AC4ekEBmcQ3mBsKmeVUObjW/Qi4R/OFQyB7+AgE563D41H/9aQ5Wu4NFu/JcAvm1GzIoisL+/EqX4bMzu67xt3Rvget9oK+e4ioLV3+xlifP6eEy3JpCUZWF8AAj/ZPDXHqrnik5/TxSJL78N5XIQB9+25zp1YsdwOZQiAz0Qa8TLN2b78qrXX9IVZD4fiMPeTRUGN891qXk0DkmiN83Z7nsg4Qwf3wNOl5fsJfXF8gw+61ndPAqLtqaWUp6cTVThiTz07p0usYGk1Vaw7wduWzNLCU+zI9z9z4G23fBtAz250kZLqvdwZI9Bfgc+psXEjfyHTocQt+kfL6jzvlTc/juAhYAu4GfFUXZKYR4XghxvrrYF0CkEOIA8ABQRw6mMf755QOy3j0LVrwBv94gtaTOeROEDr92Q/nhJqk9tteRRKpPZ9miySn+6RcCT+a5c3hU6nNNH462kYF8e8MQenn0Q22Mc/vE8ZLtKq6xPMrXtglYFz0PBbul8dpbbdjd80LM5YWyIARgyYvoBKw5WIzBXkO1Mcy1vSHtI4gI9OH6Ee0Z1C6C0zpGkfrKJFcYrsJkpdMT87DaFa4cmuz6sjeV7bny6bJz+WpCRA0f+n2IXif4eUMGZ7y+FAA/Y8vIQ4b6+6AoUgpl3o5cFu7KcyXmN4ZD74fwkHqpUas36wsneFJlttEuMoAfbhrG2O4xMvF78fMQEAndJsnvzdhnYOrPzRb4vW9cF36+rWGDMdTfSLkqlzP8lX/cosf1cPfYzux4boLr/ys/X8MVjeTLOHH4BJNy7q+kj5H5PjXR/fCpyvEKU1rsDgKplUC+8i3YMxfC20mR46AYKcXiW1djMyLQB4cidQv7JIbx3Pk9iQz04fqv15NaWA1X/MBS4+n837w97Mopp0dcCMkij65rHkXZM5eiEnkRrTDZiA3xIzTA6JLZaFfLu9oYUUG+rHx0jEeFvDfOoqK+iWGuaT3jQ9mZXbeSIZC6vwABAABJREFU9UB+BSv3F3oV1+RXmmVvYaCo+9UgBKbI7jh8w+qsfzg8ZSa+XJkqpXKAPolhrH5sjCusGxcqO82sTimipMrCTaPas/HJcS7DD3DleE35bI3La94lJpgF953uMvychAX48HCcDPUq8f0589wprPQ7nft/3oIZIwGYcZRnY9PJ9UKcLSI3fAmLnsag17mMk7MTzZgUI6/2WwTjX8A48m4vww+kN/3q4e34/NpBfHPDYIQQdI6Wxtbi3Xn837w93P7DRv7enefyZvVODMXfR8/7U/sztH0EfRLDmL4+gz25Mr/NZHPw1uX91JMktQA7JR4mZN8AtoAYQg/+Bes+c03bnlXKvB25JHqkcyzdm8/2zDI2pZfgHyA/9wNV/uCw0zM+hGvGD6HrsHPJI4IJvRPpEB3s1tob+QDE9pG6k6fdDVf+IjtvBEbJnu79r4Ip073GFeIvP9+yGiuXDU5iTLdor+nztueQFBHAV9cN5hY1ClBWY3Vd97rHhtA/OYzd2eX1tpOLDfXDFhRPGJUkL74dv+Ld7LlqE+XtJtRZtrmUVFlklCmthClDkrwcEQBfrEzlrLeXc+YbSwHYVauCvLYf6PbvN/HTunR2ZpcTGdQ0x4XJaqfPswuw2h1sfvosooN9XTl7oQF1Hx6/X5NGWY2VmBA/ukTX7ywIV5suxIT4ua4hTuwOhVfnu3MC9+dXcPO3Ur+ze1wIRVUW/Ix6Jn+8itt/2FhHp7FbbDDL9xW4cgGHtQ1hd9AdPBUj9Tq7xgS7cqqv/3ABqQUVfKpITdXSQ5vZlC6vn2XVVooqqnnU+gl+lem01RVQZWhaClWL5PwpijIXmFtr2tMe703AkXfXLs1gzM7HAfhJfz5TzrpUCrKayqRSvPqj++W24Uz+GF5K+IjP4/oc8e5akssHJ7Eju4zCilhe2tmX67arbYs6jZNJ5J3Pgj6T+bW0J6cffIskpOSJ08Nzi/VBvho/AKcP8/kLetbJHfP0BgX7GXnxwl58tDSFKUPqD3seDqtOfuGCdfKiHCNKwW7zytnzbaxSsolcP6Id/x4o9Or4YbE5GjXgABSDP3qTO2nbmbzv38jYgvwM/L07j4r1PxFceUjeSNqf4e3ZGvVAg+sfDU4h1xnrmxcuBOnVsdqb3sWhOnaw631VrNTGC8hdT1knmUAfF+rH7afFuHJnXWSskS2yonvALcsa3L7zKT+nzMQ21ZPqLI7pqHpM+iS6H5ISwwN4YFQsI9ctgOkLeNr+EO8//yQPTejKA+O7ANKjYbbZuWJw3RDz0RAZ5MPITlGuRHyA+FA/SqutWO0OL92/cW/JKuv1T4zjlYt7sy61WOZ4XvY1qekZVCbJX2JA7noC8jZQ2LfpgrnF1VJuaGj7CD5fmcrtozvSMz4UH4PO60F0c3oJi3fn88HSA9x1ZicePKsrBr23x9fTwAv0dX/nnXmEddg7DyI60Hbqu1C8lfGdQvhlWxH/pFmYogOlPAeLTt40XL+h7C2wZzaMf54Fdw+nsrKCtknnsDr5fO7tEAvGuv3FPfEz6umk3lg7q9+JzWoIOqukBptDqVP8cm6feFf+cqRHxMIp5QW4RLujI8MOu39P9l+0AEVnwO4XRkjqPCjf6+oyk19upk2QL0M7RPDA+C78sDaNF+fs4qDvVcwOuphett38bhvNsspErn+9Ez0HXkdP/3Bm7Yjibv1iTv/pKjj7NdlWLnODzOO7bo67C4knQriLMDwI85fHWlJtYUdWGXGhfsy8bbjLq/vB0gO0CfLlplEd+GGtTOeosdqpVn9zL83d7drWntxy+ng86IA0YJ4+twfp2dlErJtLWNYS0sZ9SmXiGU3+DBvCWUHbJliOrzYLd8p7ms2h0CEqkEsHeofcaz/v51eYeXOh9JDd89NmZt01wvVgaLbZ8dHr6kRA5u3Iodxk453F+7l4QKL6wBHkbtdZC/l7KyE21M+l3ABg0Als6oAiVMMzNtSP/fnuDknBvgYq1M/9vL7x/LU1G5tdcRl4+eVmfrp5GJFBPpz19vJ69//0rJ1UmGwceEnNg9gzB52pGJ9Vb5IQ9hE94kMwWR0EUc0Wv1v5J3IKf/lfBJkwe/48tuWOAqBTwULeKlTrCfo/SEfLXMrDRtOUppatusOHi5B4Ho96lxesV/FT8PWyN2hMD/APgxsXUt79Ms54fQkH8iuJDm48fHssEULw4oW9eXiidBFv6P+yGl7sIz2SfaRNPN/an2mhr0FgXQVyH6Pb8AoL8GlUpHbKkGSWPTya71anNbtNk9P4i7QXUq34Unn3TtAbCPV3j6ExA6updIkJ9vrhgfxxN4XK+NOoinN72Zrq+QvzUejJQbZuWCE7B5RlyifxY4CzFVxKgbyQDO/QcDhj+rp0nvh9u+t/o16H1X5kradM4d2wG4MIzHNrXAX6Ghjd3uMJ/ezX5atvMJSkwW83yx6kDRDkayDYz0BeuYnHftvO47/tYM3BIqKDfV0hW8/w+9AOEVw4oq/r/zK70dVpxVlhHR/mT06ZqUmh7eZw/Yj2fH+Tdy/i07u04dnzeuCo5XVwVvFHBvowZUgyb1/ej75JYTjiBlCeONq1XFDOKuLWv+LlfZ6zLYdHVHmb+qgw2QgLMHLpoETO6ROHr2qobcss5d3F+13G88a0Et5fcgBFoY5x5CTE38Czhq9Z5POwyzt0OMpyU/mnIIR9f38JX0/i0dMjeeGCnjx6ofwN1XQ5j3/jrpU9nZ3Xl6jOUoC7upiY2dfQ8duBUFXI8K4JjUvl1CIpIoD4UD+Xp895g/UsnqpNeIAPCWH+JIT5szm91C1eHyYLf9YFNN1wMUV2xxwuU0rsviGufrcAeRVmYkJ86ZMYxj1jO3PnmZ3oF25CJxTOr/qVr0NvZ55xHJ8NyZVVwivfgkVPYdu/mAeNMxGKwy37EhAhdROFDkJri140THSIL3qdYMX+As59byW/b85iULsI1/m32RWW7C3gpTm7eOJ3Gf6tsTioqhVi/euukfWmvWSX1iCAM3rLfGOdrYb2868mftVTTR5jQzi1JkP8jDgcCiar3fVdVhSFzJJqxnWX97WL+ifU8dDrdYJD/3cO707pT2yIH5cOTOTs3nE8d75UDMjykLF5/q9d3Pb9RsqqrWxMK8FktfPmwr2uQqm0omqX4bjogTP47sZaPchV4tWUi5gQXzq2CXLl9Tu/l9ed1o5pqnqF54OWj0HnKkbxM+p48pzuvHZJH87q6U4Be+bPnQzvGEmXmGBXuDg8wMiUIclc0C+eUZ2jqDDZMOiE+7e2+XsAdENu4vFJ3RnRMYroYF9i1Xa0Z9hX83YXeT+4MDLNde/IsHpEIUvT6VS2moSra/XUboATw/jT6SkI6ckX9kkEBNQN1fob9aQVVfPYb9vJrzC7rPLWRESAD30SQ6lIHM3zQU8y5XN3gquiKOzIKiM5MRkGXisn2uRF8mXDZ8RmzK1vk4dFCMGi3XmsP9S8bgK7Ys6jnekHyia+x4zhs/D1kcag5w2mpYzrnLIaFtUSd64vZFEfhX1uI3foE17rCdG4YTq4YhGzfZ/EHNZJPoFfOVOGe48Bof4GAnz0XDowkRm3DOOnW4Y1uOyWjFL+3u3+bIx64ZJBqLbY2FVPyLJBdHr2Xrac3CGPuyYVV1lYd9AjlOH8DHxD5EMVwKp3D7vZmBA/sktrKDdZWXeomBX7C71Ctj4GHX2TwhjWIUJe8EMTYNxzlIT1Yq8jkaJKmdezUK3OSwz3p8Zqb7H+qoejb1IY141oX6ejQ3JkIKM6R7H+UDEb04qx2BxUmW2Mf3sZ13/lNp4tQfLGbqxy9wlef6iYedtzcShKvccw87bhfH7tILrFhvDB1AF0ig6m3CRvYm8t2ueqwHa2DgRv75cnQgiuMyyksy7La3k5kM9h5dtek7ITJpAkCuiyTcquRMUkcfXwdnRqK70wQR2GsSVkjPfDU6Saf7vybSlIb62Gz8fVO57G0OsEqx4b6xIWd5IU0XDqTUSgkeIqiyuM6PLcBsr+28/8trGOob0vr4IPlhw47FgcPtL423ComFfm7ia/3EQbjxv8NcPb8cclYQD84RjF3/pRVMcOwujwTpOYNNHdocnVc/28d+SDVDNbBEYF+fLp1QO5fLCM1vjW8uAeUD1Pnj3cx3RrQ6CP3lUFDzJ8Xp9h/uXKVO6evpl9+VVk97nLNd239PCfVWM899dOLvpQtvYM9jMw5OW/6fbUfHo9swBFUThYWEV2mcnVW720xsqyfQVe26gwWdmSUcqYbtGseXwsb0zuywdTB9BD1RT1jAytTS3GocCDv2zhko9W0e2p+UwdmsxNI9vz5XWD6BAVyMGCxnVuE8Lk+b5meDv8ffQoiqywd7YlvXp4W9dDaLtIaYDfProj+148m/7JYQDohSAmxI/LBifRM14aYX0SQ8kqrXEJ4H9zvQzTz7pzJK9c3Jt3rujPq5ZXmKxfitc3tzQdelyA7oyHOadPHDqd3PYhRY5HlzxUtjwEgkIi+OmWYfzfxb1pO2Ac4/Rf8NWAmVJBxGGlMNtbC7ghTgzjb98Czq2SzbBD6kn+9vSE6YSsLmtthAf68OddIzmrZyxf/pvK6oPuwoDMkhps1WW8svNMWK56YGpKAYXL9MsIKq2r7dcUooJ8XE/aTcWuCEDQIzmG6ycOd3n8wtTXJ8/p3qwE3MOxVQ0BRQX5uHJcGu1h6YmiuPp1Th6UxMGXJxHXgJvfSVud/Nwrks+SHr/OR3YzOxKuPa0du56fSJ/EMIYexusHMifP83tt1OtcFbpP/L6DSe+uaFynzgO7fxQOo/uGtDe3gmdW23naXzUIp6s1Wj5BbqmX9MPnGA7vEMmF/RMor3E/bCVHentyesaHkFtmchtDI+9j04TfKCCc/fkVrNhf6Lqh3T2mE8sePrPFPX/1UWOxsze3ok63l+IqM7tzyrnzx028Om8vZ76xlKdn7SSloIpij5w9a5A0mjy1/oqqLFSYbXR6Yl69nQSEEF7G5ouzd9Hn2YWkFcmbmzOdw9k6EDhssZZV+LBd6YBv7UjAnAfh72ehKMX1EJnb904+tXsYK2rolMA2mHpfybwtqVzRGWbc6vFAEtNTvq56V4pBT5kBF37U4HiagqceWo+4EJcHpj7CA32osdoZkBzOu1P6uwpkUHt7xygF5Ne6vt3+/UZeX7D3sL8Nu28o2M28MXcbnyw/SJCvga6xtfJac6V3bbrtDALzN3OosIqXcodgHu3KZsK/vUd+b4hq1IYmwtBb3BIRzWBs9xhXnlfth5LrTmsHuFMpxnWP5rVL+xId4sdzF/TikgGJvHNFP/7cms3f9XRLqlYjIw/+spVNHe9k99T1lCeNRW8ubfY4PfGUJgn2M3o9PJhtDkqrrfRKCOG9f6SRuWBnLjd9sx5FUXhr0T7OfmcF2zLLuPCDf+n1zAKvbTs79GQUV5NRXM1HS1PIKK6mbUSAV2FgWlE1T57bgzO7RpNTZmow1OuJM83Ceb9Z8ciZfHz1QEqqrEQE+vDmwr2u7jZTVNWIaPXcTOgZi59R5wrJg3xwBXfl/ucrZEu/sAAfHp/UXV4Xd/wKX04kPm8J0ZR6D+j6uTDpDdj2s2xtuXU6saF+jOgSR54umnKTnfScHHLCBjItfzw7s8u4oocftyVn8fe0c7nuvHEQLh8C9nx+C03hxDD+dv7O6OKZgJRpOBx/P3DG4bW7WiE+Bh3Xn+nuI8tZL4HRj0PPno5BOIiJPjJjtk2wb7ONvzFRZczv8As+Cx6Gbb+4pidHBHD9iHZMHthy+Vihap7LzaM6cPmgJG47vUOTQlgAoQf+oOfXXaDcHdYWQjRqOHT0r6JACSU08tg3+HaObf6OXF6cvYuJ/1veYMsvq13Bx+OmfmbXaC5SvSYxIX74GHRNyo10EnrwL6K2q0nulQUuL+I63+HkEeEO8foGy0pEgAkv17MlNy9c2IuJPWO9upY4ZW+cXDW0LRNqSU84z/FeNZnfaQAY9Dqv9IL/ku1ZZUz433K2pJeieHjqzujShsJKC4WVFuLC/Fxtt5xP+04sqvHnWURT5KERt2Svt3dDURQe/mUrS/bkoygK/Z9fyOdqz9dN6SX46HWufD1vz18DXnaHHT0OqhJGNmxovDdAGoEF+4gyZ1Go1FOo5hdCt/Xn0D7lB3z+edK7+jwsCZKGycKfEfdC14nNroD35IuVqczbkSvlay7pw9x7Rx02heWGEe0J8TOQX2H2vqZ3nkDG6W+w0tGbVSneifjXqkZSQ3IjAHa1wrVrqJ2EMH9m3n4aD09QdVf3zodPz4SkIWwf8hp36X/nNdsr5FeY+WxFKvnJ51BABOX6CAjxqPYOOfp7TpXZxjVfrAXAt1ZR3eOTurP3xYmEqUUIj07shsXmcPVbf2NyHy7ol8Bnyw/y3Rp3K1SnZ9TTGLbYHNgCYrD5RXjlTR8Nb1/el+SIAAKM7u9uldnGwLbhzL57lCsVpG9SGFa7QqXZxq7sMnbnlHt1d7rpmw2u922CfPE16Egvrmbq52t4df4ezDYHSREB9E0KY+lDowG4+ZsNbEov4Z89+dRY7V6/w4YY2TmKrc+cRV/VmE6KCGBzeimrDxZRXGVh7vZcV9WyUwLOGf5Nighg45PjmXGr+7fgNASd+bfOLlZezLxBCsYDDxt/RlE8HB2BUdLD/pvMQ3WGgZ/okkVwUBDmTmcT6KhknyOB1QeLCDy0GMfB5fDNeTgKD8h7S4i8JhXam1bIemIYf6XphMR1JPWVSTw+6fAdEpwVOq2Rm77ZwAuzdxEeYGRcd3eOQEyIHw84Lz4Ap90lb8CmUvm/MwzXTNoE+Tap36cn3UOtdMv+Hd2GL2CvO9ys0wmeOa9nvZVTR4qzgjA5IoD4MH/O6RPf5Ju/YvBHZze7enTO2pLF07Ma74ChlGeRo0S4nrCPJRnF1dw3fTO3fb+Rz1emsie3gsoG2g1Zbd6ev0sGJnL3WPm0W2m2ui6mTSU47W8idn1DSOpceKMT/nmbOF23lWeLHyEG9QbgGyLbaen08GwZDLut0e3WbjlX2/PaIz6Ex87u7mWUt40I4KGzurimxYc1/qTe0oT4y8+v3GRlZ3Y5XZ6cx+Ldebx4YW9XqHVU5zaEBxopqbYwtH0kBp1wGYnWwFgUofcK+3oKBG9/9iyv/VVZ7PyyMZP9+RUIIdB5fB7bMsu8ijacxt/lg5KIrq9zA0BNKTr/UIbZNkDxQe95Iz36JG/5AT4YTO/fRtNB5NS7qek3DyVCVHCo1MHc7bWWuWE+PLQPht5a/ziaQUGFme2ZZdx+Rkcua0JRj69BR7XF7rpOuNDpSBh9EwF+fszcKD2vX/2bys/rM1wPTLXlRjwp6TwZnsgjwxpCYaVZ9jp2svVHyN4EoUm0T4hjpH4nOqCt6tEuMMRQogSQGdLPe6PBR98T2NegI0UNWfrUMop1Ouk1dn43skprGPry30z9bA3dnprPPlX6IyHM3/WbLDdZ6fD4XH5al+7Vts4ZQbD7RWAwlXA0fHuDLPpJDA/A30dPgMf3uNxkc+VwD20fQY+4EEar+XKl1VZXEcVnK9zf383p7vHodIIJPWOJC/X3qsh1pgokhPtz2aBEKsw2DhZUuQywxqIqIIuRQv2NXtclr6Ii3F73LjFBrHjkTFfL1bIaKyv2F3rlC+t1gsVXRfHDVd3Z88LE+qNjU3/2+veOwerDmN0G/7zkqmIHpFPDXEmXlfcRYCvD2OM8Qqgmo8bI5fqltP37FrZuk9V61/5eICWzojqxdOAHPGm9odHjhxPF+Cs5hAhr26RwUFM9R8eD/AoTKQWVrH5sLG9f3pcle/L5eX0GMzdmSomTUQ9JmYDC/fDHHRS8OxaACpqXP+IkMTyg2bIsJVYPb1JA0zpKHClOQ29zRilmm53Uwqom99Z0qfZXS+NvzcEi5qntoQ6Hjx7ydDEuN/2xRFHgjy3SWIhVL1RVDXgogvwMXgaq1e5weTMqTDaKqyx8qXqOmoLDJwi9tZLgjKVy+4VbiBdFDNO5qwTrrU5shKSIAObfN4pr1LwjrxtpA0SH+HHXmM746N2FHscaZ/pIeY2VCpMNq11x5Yt+cd1gZtwyjEsHJhIW4ENmSQ0HCyoZ1C7cXZmoM7B76nryB7gNLV+DnisGJ7Hu8bF1tAmd3lHnfnU672uZZwV/z/hQNj01npcu6tVwYUVgJFw7G/J3uVqEuRj7DDxVBENu9Sps2OFQvRG1CpyG/XM50aKUvBpR9zvVgiH4qCAfLHYH7/1zgM5PzOV/f+877PIpBZXYHEq93ymdTjC+RyyrUoooq7Hy3F+7eOTXbUz7TSbFN/S7AlAMfmD0o7DSTCf7QS545Re34V6SJqv/w5IIipbf6bCIKJ49T4bADxZUcbb5FTb0UgslpmXIz9pw9E4HZ/J/qL+RPg1IdDlF5p/9cyftowJdckXOh4fEcH8yS6pRFIXZW6Uh//OGDFdBHOAqHDNF9qAi8QxwWDlShrSP4KvrBruKMgJ93N/jlQcK6fvcQtYeLCI6xI/8CpPLoMqvMLnW8XRQ1M6UfXdKf24Y2Z6PrnLLbnVqIw1Bo17HBWo0JCHMn14JoayaNuaI1QJqO46cxV8GvY6kiADXA3dWSQ23fb+RNxZ4tMZTFDrOPIvQXy7FryKdemnj3Z3j9n7qNcJcDstfk/d9J8UH4ZUE6QCqLiK4Oo1SgjhYHUCBLgrhsBJXuZMCJYQV6VIQHsDacTyVNFxE5Umrau9WL8WpUJ7Ffn0Hxk+bw2uX9Kn3qfGZ83qwYGeulyhua0OGkKxszypj0a48Pl0un3jaRgZwyYAEGPuUzNN5bwAAzgY3Ft/mtT5z8tCErnXawTTGr9uKuMn5j/9/a/w5n+jtDoWM4hru/3kLT0zqzrAmPLnZ/NRlVM9fcZWFiMN5fdUfR+jNfzH+6IZ9xCSE+yOEHEpiuD+55SaqLTZ89HVv8G9M7uv1/8tzdzNzYybbn53gMpA3pBUzuF3TzpHdGITOWkVlwkgi9k1HZyomkNo9OBUoSYXIxjuQeNItNoSbRnagxmInoQlGtaIoZJeZqLbY6dtAgvp/jdODUm6yuqoV31i4lx1fr+f1S/u4biph/kbyK8ws3JXH45O6e11f7P5RXtv86+6RgOy+8daifezLq2DyoCSmDEl2NZd3Ppx69vrsmxjKdx7VyD4GHalZVdgdCkNqt/SzWWDhE9KAU8M8VHrkeJnK5DWkTTcpWO7BM7dMYd/aIroMqqW6FRIPWWDG2KxUgubifJh5a5E0+nJKD/+gUGOpWwDjyXMX9KR/cphLz21Ep0hWpRS5crMawlCdB/Nepl11B+4zvosZIyG+U8FuhfzdMmcPoE13CpImsK/Lra50oxqrnVcnD2CAMw3A7+hFkj1pGxlA38Qwd35jLdpHBdIlJogOUUEMahfOpvRSwG10JUcGYLI62JhWwowNUlIqNsSPq4e1JTkigB/WpruK6ko7XURpxwsRdjOKrvlOE5PVztTP1pBRUoPZaufC/gmc1zeOlQcK8TXoSC2owmxz0CUmmF3ZZRRWWlzRjC0ZZa7KWk/qK5Qqq7YS7GegZ3wIyREBXnnFW9UKcOfndTQPkuGqYfrxVQOw2BVXiL02zujXvB25vO68TjsfnLM3w7v94Oo/PJpMqKx6z+vfwGo1ZUTt8kVoEpSphmNIAthMstoeMPx4KWfyGZV2G1eG7IQaiC7ewBa1IMT52xrVOYqNTzYtj731ev4UO6SugNztoDOw1iB1y1KL6q/kuX5Ee6bfcuT5KMeCsAAfUguruOyT1S7DD6RL3OXVDPA2fN6xXQxtRxyzMZqFxxf+P/b8BfgY2Pr0WTw+qbsrx6WpBR82P3VsHsZfeOBhLmAvRMEfTddk+y/Q64TL2+k0kqrMTSva8NHrXHl6Fw+QN/2mVLU5cRiD0NnNlLebCBEdaetTwQ2DZd7jafZP3Pl9zaxSdJIcGcDrk/vWSVSvD0WBka/+g0EnmHXXyCPa39ES6GNAJ6QX1alTtim9VOpMehij43vEuAywIB/9/7N31uFRnF0fvp/1uCeEQEhwd6fFWlrqQmmpu7vLW3f3fnWnpV5KW6Qt7u4OISQh7r463x/PrEUggQQSmPu69trdsZ3Z2Z05z5Hf8RMhD0mbS/zyp2ptu6TKzg+r01mXVszi3TL3z238hXmMP7mdq0d04MoRSX6FbE6XwqQPl3Hxx8tr73j2Jlj1CXw8GmY9BDqDv/GXvho+HSevm70uhIFXwe2r4YZ59ExOoMslL0oBb19UYz8kKLDJZJzqoqZKQHA9Rp2bPu3C+PKaIfWm+gSbDRRX2pi2Ko2BieHcNb4L+146i5WPnVpv5xwApykM1nzBG71SeN9xPj106ZhS50P+LnBaoY16QzeYuNV2D5f/Xe3xPrpcChcNakdHn97WTc2crdm1CpF8KaywYzHq/LT83OHWc/u1pUNUIHN35NItLphHzujOB5cNZGTnaM7u05aHTu9GJx8R5tgN79L7q67ganjxmJv8civr0orJK7N6/kOXDEkkxGLg0qGJbMksoU9CGBFBJj69ajBvXdKPAYnhTL1+GAMTw7lwYAJnqPnA7jSoQJP/b+L39Rn0e/YfTn51Pj/cNJz/u9z/t+v2vjWkyONQBFRmsc18LcV7Vh20bsAtgh7tK0BdVSN38sBa//cOq6zC73423LtVTivcBykL4QfVEx+mDuaG3Qp3b4J7tsB5/wdtB4C1lLP7ytSC8DbSg6+zldOjRx/+7/KBnuuHxaj30zM9GC3X+CvaD1+fDUknwcOpFAdIb1/L9esdmnBV5Nc9uFn04Djum9CV+33axBAQLlvT9Z1CpWKmg8iuX7j1EOzMLuPKz1f6JdQeCqvi88NpZs8fyFGUXic80gYN1flzmUIp6H4ZxMpcycIKm0yOz9spfzu+2KvA5ZB/tqmTZEu3Y4TbO9k5JpiRnaJqCXa7ef6vbbz5jzesYNALT7jmzD7xTBnSnqLKhudzukzyZmWoyoPblmM5900S9EVUK0bOHdkfht8Gj2VBSPNXyut0gmCTwXPDOBbodIJXL+pHUaXNU3XuxnfEP7ZbrPTKA49N3+LXncBSuJ3orV+is5WzL7+Cq75YxYb0Yr8bkVuSx+pwEWw2eC7St4ztREJ4APdO6EpBuZWf1niFvw8avChKlc/x/WD8/2QxRlkOVBXB/Bfhz7vk/JA42Znl3Pcgpiu0G0TSI39z1Rd1/PYjpTDvRro2q+ev5g36woGH1sEb1z32oJ7hSLUg5oPLBzYo1wvUsG9EMsbVH3HfqZ2wBsTB3Kdl3t4570Ki1wvr7jBxoLiKXc+fQUSQibSCynq2fOSUVNmxOlyetoc1qbI5yS+3Mn1DJj3ivXlw7hzB8ECpKvHwxO68elE/bhnTCZ1OsHZ/IaXVdk7uEuNnHDgN0hDU2ctpDEt25zP61fm1plfaHJRVO9hyoIRV+wrppmoOxoZauGBAO0IsRk7qEs2AxAjevLg/D6qRqWHJkUwe1M6j+uDGXflu1Ms2jzVTv/688ySeObdXw+6RaSthRf3V6r1smwkUVvq0P/h9L8Ri5PnzevDtdT4i54FRcOFnUuoHaqfQuAdoXU+XRl7fKdK79825kKPqubYbLI3DMQ+B3gCmQBhwOXQaD1VFvGx9kdT7OvLg5FMAASPvJGDcA35t4hpDyzX+3C2lSg+AOYQpQxMZmhzpKXlvjfROCPUbWdtdLu46pYtfyTgAPc6GCz8mUFg5X78Mo9K4og03LkVh8W7/Dhq+KIrC039u5etlqZ5pZYZw+ig/wQO7ZUuio4TbY2RzuNhfUMGzf23l/fl7OOf9JR6Plx9CkHnSy7JTCjL/IzbUDB8MhXdqdHdx3zCDotWk2mM3hDijTxvMBh1XjUji+xuHM6hD3SH9VamFbPYx2o16HU6XgtOlsL+ggmq7s1FSL4XdL2fb5evp/sMIWPcNZT/cAGu/YiOdpcEthLzYHCVCLAa+WpbqV5l4tBndNZqpK9LIrFG0UrPAwPc8+HpkrGHSY2Yu2cuBoioW7crDanf6/Z9TCyoptzoY3TWGLc+cTh+1uvD2cZ1Z+sh4gswGXpq1gxkbvIUjfjc4m2oE7PgbVn4Cxer3dc1MabQFx0F5tjT8Fr3mrX4PrtuIr9mmCoBIeRypZaJZPX+dYoLpGBPEWX3jSX35LI822pHgziErUPPGckqrueD/ljLXRyOzLlyqNEulORbz+e9KT+msh2DAlbLFo4p7H50umXN79w/rmd5I4fzG8Nx5MlRfU+fPjTuH++GJ3QmxGDmleyyndI/1+834Fs0t31vAQ79s5Pqv1/Dj6nQ2ZhSTW+YNt7sHhfpGGn8ZRZWe/Fe9TtBHbXn6xHTp1VqzXxZuRNcRgp+9JZslu/NRFIWOMcH8eNNwrh2VxGuT+/Hc+f6pCu4Csl71tFTt1TbMU+F9SL44DWbX31k2KHsFmMPoNWCkd2JdHlGHlSvmDKD9lv+D4nTY/ItUSeg7GQZdAzE9wFbuXX/us5C6RL53FwZd+LEnpOuh94Vw4adeqS03ZtWLvWuWdGQERMCEZ+HUZ2uldjSGlmv8GVXj76OTYNsMooPN/HTzCGJrGkqtiEuGJPLShV5Jl1PeWHjQi5RdkRdik+nwjtkdZqlP7kUIgdXuZINbOR8Z1tDpBATH+ksZNDNez5+LnNJqVqcWMUcV/y2tqichWXGBTRq2s+8ZzVOn1dPOzl0NueMv+dx2QJPtd2N58PTu7Hz+jENWTdudilf9Ha+Wpd3pYtKHy5i+IbNRN09Fb8JUrmrShcST4pQZpV1v+pYnz+55kDWbB3eCstXe+HBTU+GuFNXpBDeP8balqllxvjfX64Up99Gps4a7jb8Uiquk8RERJDvwdIwJonubEHS42PrXe/WG1ap+uI7HDd+yZr9/2OjdSwcwf5IOXmwL+xZJr/WsB8EYCNfO8g6OL/tJau+t/kzeeHqo7dSNjbhmxHRndtRV5OvjPJ6Y5qKs2uHtHdwEuD1zZ7+3xCP0vj6tmKxDFB4VjHuFbxwTWCN6SQmbU56SN+YanqVbxnTiybN7csGAdlz9xSoURXqpmgt32kt96RNCyG4Ybkmlz68ZwufXDKlzWYC0wgp+WpNBcaUdFwqPT9/CyhTvb82p3md1tsYZf0U+YtOLHhrnyXeNDvF6zUPMBk7uEl1r3Vdn7+CKz1dyvSrrMqxjFGmFlYx9bT7zd+T6LdurbSivTOrjd99sNlKXgrUEvjgdds2R/9kvToftf/kvV6zm5S19B+Y9D79eL6Wy5r0AX50tNfs6jYeFr8ko0+I3vClH7siKyyVlXzqOgycLZeFQXB94u4/U6fTFJ6/0pPc3yhaJo+4C3ZGZby3X+LP7eKtqxtNbMatqdNw4mM6V8c6VcMHH6OooCGgIkUEmdEL2X73w/5Yyb4e/obkju5QtmaXsyS2nWr0Jn9u/LU+dc/SNAZNBx92ndGFwhwg/3TigVgsjN8l/XwLf+SSvq8KsRNTQWPKVwhB66VI/xlTZnIx5bX69ni+70+Un9zAkKZK7TumCUPPUbh7d8aAdQmpiKkmlwz+qBEB4IruiZdlLUO66oyKqXBO3xE19ie1Hg1dnq22gtuXQPiKQIJOeIUkRtTx/U28YxvJHxwP+nj9baAcUocdcvNcjdO0O6867fyx/3DGKRxI2MWzz06ycNZW7pq2vldAeuvt3bjDM8pN+ATi3bzzJ62U3DjZMg2G3yFDvum88vcwBCI6R3gfFBV1Oh8lfwf/qHlCe068tt4+ro5gnKIrF7W4ix5TY4Hyhw2XOPaN5eGL3Qy/YQHxFsE0Gnafw4WA6fwBFpniedFxLSJCa/3byfdKbUuM8mAw6rjspGZNBx8YM6QHuV08lblPwsxr+b6q/ZBufntHu36ZvJMVlkmFZvf3Qlf6VNofnPuFOOXnqnJ609Qnn+xbdXTsqiZGdaht/Z6v5dAaf/AaDTkdqQSWv+lbQIo3dS4Yk1tnc4bCpq4NQZSEUqp0xMlbDL9dLL9uBdbIvti/uEK5OB/0uka8XviordlMXSwPwh8tg/vPeYg6QAvoRSfK1yyFTvM56Q0prWUJl5X5lPhxYgx+J8v9epZjIUGKaLDWj5Rp/5T4jgPB6PDqtkMhAE51jg/nkSlm6Xl/OFyB7a/abctifpdcJooLN/Lg6jXVpxfxdQ8PL16O2M0f++Qd1iPQUFBxNdEJwao84OkQFUeyzXwI8F5yayDZNxaQXVnLdV6vZUmyQuWvXzZaCme7fUHw/efNMGAyX/nAUjubQmAw69hdU8tniFL/elW7sThdGvffiODRZNp0XCE/+WGPQWwsxVqnCw+HtybFIA9n0R8PU4JuaM9Q8lYZUBzcXPeO9I+pPF6ew9dmJ/HzLyFpeF71O0CbUgk5AuU+BjqI3Yw3riM5e5ulc4dYPBOm9ubFDLljCmeMczPwdufUa2j/5CMZ6OOt16enb+L28ifS/XN4gVAFYQCaW/3CpfB2RJG8k9Xj93rt0gFfMuAaBJj0FFTbW+eisNQeRQaZ6qygPhw6RgZzcJdoziHCHrQ9VSOUeYPoZ+oewuC4ckMCAxPBmrU6/aJC89kYFN8135GuYuaumbT7GnzU0idx+t2MPiKm1bk2u/XI13Z+YzX/bciiqsBEfZuHaUcl+v2nfgfvevAq/Aik35/aT/31fI9otVZNRT4rSYVGaBeU+YuuPpMl0prrOc2EK6M2yJzPIbhnmYIjrKT3vT4dJQxBkHULfKTItyl0clLLAuy1TkOzWAfL/OPRmMAbJzzareZoGk2wvGtUJ3h0IL7aT1eZQ2ziN6QbBcSzUDQXEQfthN4aWa/y57N6Cg/AOB1+2FfHA6d34774xnj9gY2/ijaV/+3CPi35XTjm5pd5wiK9Hzd3KJq2gsnF9Y5uQXTmyibfbKNUJ+O3WkXU2KgdwmMNxVhZx8qvzmbcjl8KAJJj4EpRlyc4Gbld78mg44xW4cS50Pa3ObR1t3JIh+wsqefyPzbXmJ4QH+I3aq+1OckurPdIGi3bnceqbC1m1r5CierqE+OJyp1EAWMKxuXSsd3VGcYcJjzK91b6dx0Ljz81vt43k8bNkJan9EFXmQgimDEmkV1v/KtLdk/4la8QzBJn0dIkNrpUzp2RtwK4P4KZNkznNtMl/o4oCgdEQ1YXeNXOahICEQfIGAVCa6Q3p7vDp9V24DyrcRv3hD5LduoMrUgoOsWTLwp0a4RbD1ukEgSb9IT1/JZX+1dcN4c1L+vP7bc2rvDB5cHtSXz6rVtXr4RLv8/8KNBnQ64Rf/3R7aAdyhjyMPfTQ91i3d/rPTZm0DQ+oLUOEvzfv781Z7Mqp7VHsHBvCogfHcfNob6qF2wlyQQOKgBrMm93hHR/JLFMwGANkyLUm7QbDYwdkhTx4bY6ASK/8SpmPjuyFH8PF38rKevDm+AH0ngT91XaZ2/+S/+OAiNo5fm4K94KtDCLViNXw2/znV5dATDf6jbuIp8/peXCHUSM49vGv+lBc4FRvamFH3xPVnBRW2LjvJ9lOy1fZvzn49KrBuFwKv68/wDtzd5NeVOXJm3TrxY3sFOXpdfjO3N2sSClg6SPjm3W/6uKFmdsZ1CHC02HBpcDGjJJ6iyJc5jC1B7IkVimATQvgN1Wp0N2yLH+PHMnpW6YAeF2yDt/f6B/SnbExk4d+8RoPQgj25Jbz3N/bOKN3G24b2/mgn+FUwzvW0CTMQmB1urjE9Ty7LjmjCY6g8UQGmzmpc7TnXB8LLEa9p39oQySGLh2aSGGFjffn7eayYR1kyFH1FFw5IokrRyT5r+CwIXK38bt1BBcbFtI5oEY4Vgh4qJ4m7Nv/lNvufaGsEHRL8Fw3B6K7epdz95S94tcjKthxC9yKVqinULOIZWhyZO0iuhq4/3NNGk5sgQSbDYSYDSTHBDE0KZKpK/b7F9ApCnprCYre6Nf7uy7cSgwpeRW8M6XuvOm7TunChJ5t+HjRXv7alFVL3sdNzR7gFqOejU+edkj5n0YRmgAdx3rfv90XSjPg3m0QVoeRqTd6c/LUPrl+0mvFafDbTVKPT2eAoTd6C7BAet5vWgCWcPnfDoqFtV/C2W95w8MHIzBSdlaqSUA4XP0n8cA1h95Kg2m5xh/ImDuA4ei34mpOrA6nZ/TVlCGQ+tDpBJMGtavlQXMbfw+c1s2Te+hSlGMmlG026LDaXVw+rAOn9ojj1Tk7mL7hAHanq07hZ6c5DL2jgiuGtsVsMtNtzmX++aH2KpnL8f4gmc8z6u6jeDSHpn1kAOmFVQ0a5dds93Ry52hW7ZPH2pCuKO4Le2GPK4lH9p68YEATjrIbybn92raIHtzuakRbXRXldfB/C/awcl8hfdqFM6ZrDIE5a4hd+yZc/KG/523vfPj5aoTTxlpdL85TltLVpI78HTbY+besVNebZf6PtVRe59yVfovfkKGi7mf5ay8m1sjzdN/ESjM5Ek7rGcfLs3bQJqz1XWvvGNeZTrHe7+ira6UEx+aM+iWupCBx24PL6hwnbHr6NIQQbM4o4ZEzuvt1DtLZy+g5tS+Zw56koM8NB9kKVNnlf6RmS0dfDHodfdqF0SkmGCG8XTIaQqNahzps3q4qiiL/L10neqtfFUVqwLqNN0WRhh9I8eSa/HaTzKV1h2XdRmC7IbD1N/l62XtyGxFJYK+GhS/L6ac9D9v+kAUivpW6ty6Vz4dK4Bz3OGRtaOiRNxktN+wLcNHncPfGY70XTY47NPTk2T2bPex7MNqEBTCiYxRGvY5KmwO704XDdWyNP5tTji7jQi28OqkfG9KL2VeP5lV5/HAY8wjPn9ODJ87qgSjLgvj+cuY578DDqVKxH2T5fQtjXLdYIoNMFFbYasm2XPn5Sqb6FIP4FgbFhZrp6RN+zDxEpwQAlyEIBeFp5RQbYjmoEO6JQp+EMAKMes5pgCHqUhRPVbonD1VxEpK5hG9nzOHR33zC99mbZbhm3OOsCRqDWTg4peQ3+PUG2PIr/HwNvNQOno+BF+PhjW6w5G25buoS2SmgSwN60bilI2Y/2vCDrgN3+68AY8v2B9TFA6d344IB/tGhkko7S/fk+xXYTF9/wE9PUa8Tx6TY6WhTXGnnn63ZlFTZGZgY4Zcz5lJ1/hpS8OH+zRdW2Bj/xgI+mL+n3mXnbM1GUfBTLGgybBXyf7PyE/m+aB/Mew4yVnmr6q1lUrB72bvS8PMtIH1vIDwTITX/crZJXdjtf0HeLhjzsMzNG3i1XHbEbd7XbuOxKBXa+FQfdz9L3m/OfM1/P4Nj5eNQjHkQpnzX6K/hSGm5xl9MDzkydlfHHEe4q3UOlZfSlCiKwkO/bGTWFm/Rx5iuMTx2Zg+2ZpZwyScr2JpZKqVejtH10GzQY7W7eGrGVn5fn4FeJ3XH6lO7r2wzjLzB95FvFbIHor0S2vaXMx02+af/6kz5PrbpKgybimfP680ft4/ilUl9sTldfvlWK1IK/PTn3MUfY7rGkFNq9ftO9uQ1QKZBpyd76KOUJ0jtxoW78jxSJycyRr2OO8Z35pTuh75I64TwhNfdxro1TL535W4n3TdZPW+n1OAb8yCxEeGsMw2W07f/Kbt01IXba734DRmyGnbzoQ9Ab5St3ty5gYeJWw6qvuKq1sQNX6+h37P/8PLsHaT7FFN9vnSfp7r+3205/O/3zbjqKEg43nhx5nZu+nYt+wsq2JhezI5sn5xunR6nMahBUi9XjejAWX3jSYwMJCWv4qAyTelNWbjhxlYpCzjcUivuDlQZajeNv+6FP9XoTqVPKoCtwq/HNSDTymY/Ah+OkP83e4VMLxOqzFlAuHfZugZhvS6QKRi3Lpd6m3G9ZN5gK6LlGn9Gi9cFe5zhDuG9/s/BG5s3JUII9uZV1Kl/FaPmZeSUVuM8xp6/KruTTRnFlKjSGcEWg0cWpBYuBx/+uYRJ78z1hr3iVLf/svdkWMBdvRV2eM2+m5v2kYH0jA9l/o5c3p27G7vThaIotXX+VI9TudXB2G4xdIgKok0jNS/z+95CdbT8ft7+b5efF+RE5vZxnTlFbS91KNwDtwp14Oa0RFIV1YvzK34iyeBzw8nb4WnkHh9m4W7xCJz+kgw57Z0vE8nDahRouCsTszZJnTBjA4thzvsAep3fsGXrYUzXGL69fmiLCMUfKf/5aKeu3OcdUIVYDJzaI5bvVu7n9/UZ/Lg63VPocjyzK1cadnqd4NPFKfy6zn/Q5zIGo7eXobOWSKOoHq4dlcwHlw1k+u2y6OVgKUtLHh7PysdOaYK99+Hrc+D1zj5C5rHyP5O+QlbFx/byKjyYQyGqi3xdmV/b+NP5eLg3TpPPddUW7JoDf95Tu9tVbHeZghF39GXRmoojMv6EEJFCiH+FELvV5zoz84UQTiHEBvUx40g+83jgWIUaLEYd1XanJ+H3+b+38cyfW4kKNqMTkFtm5YaTk3m0nl6azc1lwxIZ1Skah0vx9J8MNhvq9fwF5m3kyV0XMs6yy2v8hSfKfohX/CLf371JjtBaaHhHURQW7spjwa5cXCgY9TpPw3OTj9RL55hgEsIDWLu/iNcn96N/+3A+uPzwxKodThfbs0o9qvwaDUcnBJ9fNZhJbjkkIUgb/wF6xckNuS9Kb7OiSM9fjPQ2D0qKoGe7CG+hxsn3w1V/QN+L5eDk1KfBHCardq3lshNNm75170AzIYTg5C4xx5UxFB9mYcuBEqwOJ5sziimrdrAxo4QfVqczc3N2s3YzaUl0jfVW+kcGmcgv96oDFFbYqNYFYipLo9e3fYhd/26928ksrqLC6vBEj9zdauoiIsh0yKKbRuPWv3N7/g6slcbgztlyoBXa1qvBFxQtc/EAKgq8xp97wNXOpzXbwQpL9SZpPIbWGBT5Fl21Uo7U8/cIMFdRlC7AXPV9XVQpitJffRwbbYkWxoSecXRvc3Q9mxajnllbsrn8s5U4nC4KK2y4FDkijA42k1tazeCkSMZ1a0CeQjPQq20YLjVHp7favaJNqKVeXS2HORyAp8uegqjOMPEV+Tzgco/XhfD2tZPkWxBCCD5ZtJe9eRVUWJ1U2hwebSzfPL/2kYFcPlxeuNx5omWqR/S1ixpnKOzNq6Da7qJ3gpbzdzjE1vhN2sI6cq/zThYk3SNz/f6+DzqMgESp3Xf5sA58fOVgH4FXO8T3hZyt0tNy0r2yy0RFntQWu30lDDs2+ovHA3ef0oX+7cMZkBjB9qwyZm3J5rHpUgD+siFeb6ulGfsYtySeOa8XL1/Yh57xobQJs5DjE/15ceZ2ni86laIwGREISfuvzm24XAojX57HJ4tS+N/v8rscXI8KQ5NSlg0OtUNVSDz0u8zr3VMHV5RmSM9ccJz0Cn56Cnw/Rf4XQRpvicOl+PmVavHGgMvhgk/g8l+8n1VXdMgdWq4uhVuWyGrcp0uOi6jkkWb3ngeMVV9/DSwAHj7CbZ4QVFgdR73Yw6zesKwOJ3qdoNLm9PROjAu1kFNazZYDJbgUhb7two/qvoH0gv2ohiIjVAmQxw7ihXSafUaeQdEw/JZm3b/mIjbUQmm1DM3kllqJDTXTr12Y38jZ6nCy9YDM1TEbdOSXW7nmy9UAjdYE26L2qtU8f4fHnK3ZmAw6zyDJ6VIoaz+OgOQEKFwHa76AG+dDwkD/FcPbSw+f+8aRONybEN73Yikeq3HE3DuhK/dO6Mr/zd/DzM1ZHu25TjFBdG0TQpBJT4XNecJ4/gJNBqYMTWRzRgltQi2UWR2Uq/efjOJKdjrH0aN8H9cg0xjqolqVeQk06XnuvF70bx9xdCJYb3STLdCmfCf1W6M6ynzYnudLKRWAKd9D8hiZu1eR59W93DVLGoXuIhC9URaCdD1DhoQTh0lFCL0Jht4ku+XUxP1fje3uX+RxHHCk1kecoijuCoJsoL7EGYsQYg3gAF5WFGV6XQsJIW4CbgJITDx+unrUxbK9R19MtVtcMOmFlQSZDbgUKK6yEaQaUGf0boPd6eKV2TuosDr4rZnFTOtCqF0+fFXpQRbG7MgqY2CNkabdJD1X26JOo2crHonFhpjZo+bl2JwuAk0G/rjD3xDYnVPu6dAihPDzCj41YwvPnNvbo1l3KNxSDYmRB9f10qib/7bnYDHqPcafXif44Sa1Q0eBqtKfs7W28Wcww90bvNItJ93jndf5VPk8+1Hp7Zj8ZbPt/4nCoA4RfHbVYMICjHy6OIXBSZEkRgZiMUrjrzECz8cLbdRr66WfruCZc3uhKNAj2kCX5CRK9GdQ1HVyneu5C5wsRn1tPcvmwu3xS5kvpVW6ToRFr8Pkr+Hir6V+K8iCDnOwHDwtedN/Gw/vk89758v+1zv+gnPfl4YfyLzaq2ZAbD1OhsiOcOFn0LmJ8xdbAIc0/oQQ/wFt6pj1P983iqIoQoj6Sqc6KIpyQAjREZgnhNisKEotdVNFUT4BPgEYPHjwcV2G9cbkfrV6iDY3d5/SlXX7iymstDF1xX4qrE76qy12Tu4iRz0rUgqPWcEHwI0nd6w17eNFKWQWV9Uy/hRhZNqpK+iZWNfPs/XgK4Rqq0dsuGYPaLfXon/7cDakF1NUaWuw8XfHuM5cMyoJk6Hl1nu1ZAJN9Vege/pKz7gDBl5Zx8p1e1awVcgWUxu+k8UeGkdMoMng8YqHWoysSS3kimEdOLdfW4YkR3Km2mLwRKJvQjijOkezdE8+Xy9PpX1EIPdEr2TUoufZefEibKFJda7nlQI6it5Sq4/8jDlE9q1+oY0M53ab6K3I/e1GqefX+RSZauFyyNZubmkWlwv2LZSGH9TW+etQR2tFX/rWbRC3dg559VcU5VRFUXrX8fgDyBFCxAOoz7n1bOOA+pyCDA0fXqb6ccSkQe0aXGHYlLj/xBFBRs7pG8+wZCmCWW13kl5YSbUaEm5JKIpCQR0tzPQ6waUn9aBf4lHIPWlGfKt2bU4XWSVVnPnOYhbv9valdEu9/E8Ng7vf71U9hmX1VUTXgU4njvvOBs1JoMng1zt2c0YxY1+bL9si6tRLqq6RQZW05fDRSTIxveO4JtxbDQCEzHUFuHBguxPS8AOpnnBy52hAaiG+dlFfTG1k7lz8imfRV9UdkapWBZ6PWp7kvkWwc6bskXvJVJkba1Cvk/Ofh8VvgiUMTrpPTsvZIj2FactlL/fblsP9u2D9d/D+YCjY6xV8nvmA1Pc7wTnSof8MQFVA5Grgj5oLCCEihBBm9XU0MArQvvljwFfLUj3GX3SwmZtGd/IYestTCrjt+3XsL6hsccZfVJBZLU7xdwbbnS62HCjx9OlsrYzpGsNjZ8gLsM3hotLmZFtWqZ/ws9vz5/YWu/NtyqwOBNQrhA2wal+Bn77jt8tT+XzJvqY+jBOGQJOeA8VVzFUlRXLKrKQWVHpbNT6YIoViG0PSaBliAs3z1wy8N2UAb1/SH5AhzId/2cSni1KO7U4dI0Z1juaOcZ0pqLBRbXcxM0tWA4em/Ue7xQ/VuU5kkIknzu7p6cnd7Gz8EeY+K1uo9ThH9mp/zaeFZb9LZQ7f4Ovke0u4N9cveTRYQiEkTnbqKNwL22fIYkA3x1nXsMPhSI2/l4EJQojdwKnqe4QQg4UQn6nL9ADWCCE2AvOROX+a8XcMKK32GklbM0spqfK+d3uCCitsngbeLYWoYBNOl+K3vwD55VbOfm8Jc3fk1LNm6yA0wMiAxAhem9SXXm1DsauhX7NPiMUdoq2p0QUwJCmS2VuyPL03a/LF0lR+WuNd789NWczZml3nshqHxh1KfHvubiptDo9X2lOgExRVf3i3PgwmKRh720pZGKLRpIQHmugUI42c1//ZyY9r0lmXVnSM9+rYMaZrDDee3JEAkx7Fp8hD56hbnDkyyMT1JyXTMSa4zvlNjkWVPtr2h+zEsekH2Trtyt9lhW6o6rnNVU2JgHAp1fJUMfQ8z7ud5DFgUPUywzt4p5uO0nG0YI6o4ENRlAKgViakoihrgBvU18uA46tMppVi8cnxmrExUybvDpd/iFC1ofYtYzoxsXfLyqGLVCt/Cytsngb04M2PMxtaf9Wexaine7wcVduc0ovn28/XbZy7OzEAnNmnDZszSpgypD1L9+ZTWuUgJqT2d6EoCt18ZIVKq+y0b2B+oEZtLh+WyPQNUmhWrxMUlFsJDzTWK0nUYIyWFtmJ5njDLdR9olT71oXFqPcIegeY9PSp/oxlSZ+hd9Tdt7es2k5OaTXtIgKP/HdeF/m7pXEXJEPS7Jwpn3+6yrtMXO/aXvHvL5bPlnD5XNNxoTfIfr8Zq6VxGBIvq4ZN2vVPy/g+gXD/ad1RXbfBB9L7BNAxOshTBNJS6BoXwl3jO/sVRoCv8df6f8Y2h4v/tuewv6ACm9Pt+fMeV4BJT0J4AP3be/Mby6odBJoMdIkL4ZqRyX4N290oikJmSTXbMr0K96VV9hOy0rGpcLoUBHDZ0ET25VWwIb240d1WNI4d7uvgiaLzdygCTXrKCMRqDEVnrzt9ZPneAk59cxF7G9JKsrEoCky9UHbTcFPkk5YSrDojagot++Lbjq0mbQeCMQjG/c/bp9eoGX+t/66p0WDceWJjusrK3hCfpH+3Z+nPTZlsSC8+6vt2MKKDzUzo2aaWwVKXkdRasTldvDN3NxvSiwkyGRjRMYpwn+N1uRQOFFf59YNevDufnTllKIpCudXhlyPoplgNlRdV2j1N7ks04++IWLInHwUoqLDx4K+byCqpZlwDegNrtAzcHr8T2fPni/t7sAlLvWFfd654s3j9SjJk1w57Pf2A3d7wkDqKdLqeAXF9Dt4Rp+tpMOhqWeUbECHX0WnnvvXfNTUajNuYsDmlERAa4PX8WYw6bhvbicW78/l4YS0VnmPOntxy0ov8Lw529TiOh7CvO8Rrc7joER/KtJuG++XXuEtd5u3wFtT/c+9oPr5iENV2F5d+usKvqMONb5jY6nDhdCm4FLRq3yNgcIcIzu4T78mbjAs1c+f4zodYS6OlEKh6/MK1ARAgc4bfnTKAym4XktvvjjqXqW5OqRd32zZbuWzZVhN3K7Xk0bXnBYTLCvmD5al3PhUmviS1AFd/JtMrNI5Y5FmjFdFX7cW4dI9sQO9rAAghOKN3PLO3Zre4al+Ap//cyoiOUdw+znuTbR8RwJsX96NjTOsXK3ZLt7i9mTXR6wSPntGdsT6t97rGhWC1u1AUBb1O1Kk9FxdqoUd8KNuzSrE6XFiMerY/NxGX67iW0WxWooLN3DymE3vzK9ieVconVw5udJcVjWNH//bhJEUHcu2o5GO9Ky2C0AAjoQFGqqLHU3fGn1fkuXmMv7Wyy8aqTyF7C1z4qXee3uRt4xbbs/a6WRuhJK3hn6XTS8FoDc34O5GoaRy0DQvwe59eVElKXkWLbPsVaNJTWSOsGRVsZuxxEm4TQmDS67A5XMzbkcud09bx222jPMUuADeP6VTvusFmQ53GX1iAkdN6xrE9q5Qqu7erga4FGvitjWfO6YXd6Wpx1fEaB6dHfCh92rW8a9yxoqTKzpLdeQxpo6O9sQRreNdanrQqt85fY4y/7C3Sm3eo3urpq2XYVmeA8hy5DsDg66HX+VK3r8c5EFRH+7VJn0P6iobvU94O+dDQwr4nEu4QoE7IC2Cwxd/2/2C+bJcTE9zyNJCk8edv3BRW2Fi1r9ATkmjtGA0Cm9NFabWd1EbqLdZn/K3bX0ROqRzpWu1OMooquffHDezKKau1rEbjCDDpPYVSGq2H3LJqRr86n3+3tW6JqKaitMrOR4tSCNg8la6/TkDUUfE7vnssz53fG0tj8qv/fQJmPVz//Pw9stgjIgm6nyX7XJfnShmWezbDms+lV9ASJufVNciK6+nV+tNoFJrxdwIxpmsM707pT0J4ANuzSmvNv3l0Rz68fCAPn9Hy5CaCTIZanr/VqYVc/PFyiiprd/9ojbw2qR8XD2qP3dn4KuZgs4HyOrp8fLBgDzuyy3h3ygAig0z87/ct/L7+AGXVrVsYW0PjcFm2t4C0wkpP+suJjlv6phI56K+r6KNbmxCuHN7BUzR4SBw2abQVpkgDz+WEbTPka4AdM+H9QbDjb7jwYzj5PgiOk54/nQ7CVK3LTT8d8fH5cfsqqaepoRl/JxJCCJKjg8nxKQLwJTk6mDP6xNfqI9sSCKjD83c86fwBtI8MJCLI5BV5boTxd2afeE71aRfocLrILasmt8zKkKRIkqODyCuzUlhpY2hSJH0Swpt69zU0WgXuML2iaHmv4C2AqXDJFJO6jL8N6cXsL6i/i1AtMtfB1t/BWgqVhbB+Kvx0JexfKudnrJLPvgUewXFQXQxPh8Hfatu23CbuBxHTTXoLNbScvxORj68YRHEra4k2eVD7WsUQh+Mha8ks3JWHxajD5lQwGXQNH2UjwzJuqmxOLv5kOV3jZLVwYmQgf2/K9IRNHji9m6djiIbGiUafBCmmfix6q7dE3Hl85Yrq+bPXDvve++MGerYN5YPLBjZso4U+On2Fe6URZwoBoZc5fn0mw5K3YMmbkL4Srp0J/S+VfXsB1nwhn4V2nWouNOPvBCQ62FxLMLml49uhwo3tODP+fl+fQUSgiVGdozmtZ+NuTBVWB0WVNtpFBHpG6B4xW4OOjxalMLiDFIiOCjbVux0NjeOd5Ohg9r10ZqMGV8czOiGwGHWUOesO+yqKQk5ptd8A85D4ijTPehiKUmXbwj9ukx6+a2fJXL+iVG8rxNAEKcbsFpq+7GdIaKCxqdFojo+7psZxT1ZJFcv35vuFamwOFwadwNACw9SHg0mvw+50cWqPON5v6Ahb5dd1Gdz+/ToURWFvvrx4Rgeb0QlZFQ3Qs20or03qS7uIgINtSkPjuEcz/Px579KBDBl+Mhknv4o9uJ3fvCq7k0qbk7jQRjgMCvbIzhxXzZAh4KpC2V5t+G2QthxmPgAXfCyXje6mflCRLOxwE9PV2+5No8k5Pu6aGsc9S/cU8OKsHVgd3tDvuG6xfHjFoGO4V02LyaDz5DE2lhCLAZciL9TuFkwxwWbevqQ/QWbpATTqdHSPDz1uciQ1NDSahjahFvRhCUyzj6XKHOU3r6BCFtTFHaqFocMKc5+V3Tp2zYHOp0DHMd7uG2HtYNC1siPH6s9g7nNyulvHLzASzn0XTn9JvjeHNtXhadSBZvxptArcBoxvxW/7yEAmNDI82pIx6nXYnC7enbebiz5c1qh1wwJkKLe40k6KavxtyigmOTrYY+wtSylgiVbhqKGhUYMN6cVc//Vqpi9Yju3vhzEX7fbMK1SNv9iQQxh/+xbD4jfgz7vhnHeklw8gShXmH3kn6A1w8deymtel5p1HJHm3kTwarKoMlcnb4Uij6dGMP41WgVtZ3rfid09uOcv3FhyrXWpyzKrnr7TKXqdm38GIVvP48sqttI+QTcu3Z5excl8Bep0UkN6eVcqPqxuhhq+hoXFCsOVACQUVNizCxvDcHwko2OKZlxQVxGdXDaZn/CE8cZXqtThrE/S5CNr0lu+jOsvCjVA1nBzVCe7dAud9ID2Bbfv7b6fXBXDGq2DQcpObE83402gVBJllbZKv5+/39Qd47PfNx2qXmpxbxnTihQv6YHe6MDeyjZK7gCe/zMr9p3Xj7D6yCfrc7bIX8AeXDyQxMlATJdbQ0KhFTIi8fmQosouGqcw7SAwLMHJqzzjCAg9x7Sg9IJ/v3uA/PTgWFJfU/PMluguc8zboa2w3pisMu7mRR6DRWLRqX41WgVuLytf4sztdx02lL0B4oBzp2p2KR3i1ocSEmLllTCdPVbTbyHOHy9uEWrA7XZ72bhoaGhpuYlXjz4qJIl0kxrJ0z7wd2aWUVNk5qUu0FGc2BUHxfuh+trdSFyCiA/Q8H8w1lBn6XwZOmzT2NFoMmvGn0SpIigrixQv6kBwd5JlmO86Mv9T8CubvzKWkyk74oUbZNTDqdZzVJ54/N2byv9+3cGZf6fnT6+T3s3h3Hlkl1fRvH97Uu62hodHKiVaNP71OICKS/Iy/6RsyySqpYt79Y+GHS70rrfkCblogX1eXQPdzoPek2hs3BcGI25tv5zUOi+PnzqlxXBNkNtAnIYxgs3e8YnO4jqvK1Zyyan5bf4DoYBMnd2m8xEFmcRULduVidTg5q7c0/tyyLu0iAhiSFMHwjlEH24SGhsYJSNuwAEZ3ieG1SX1RIjqgt5UhnDZ6fNuXYYV/EBdi8bZmc5O5Hj4/HSry4eVE+EMz8FoTR2T8CSEmCyG2CiFcQojBB1luohBipxBijxDikSP5TI0Tl3VpRSzened5b3O4MDem0XgLp0OU9GqO6BjNTaM7NXr9t+fuZldOOYlRQZSqvXtDLdKDmBwdzJNn92JgYkTT7bCGhsZxgV4nePD0bpiNej4Mf4Cd5/1NQM4aDNZibqj4TGr8CeHV5ovqDF3PgCHXe7twbP4J/r7/2B2ERqM40jvnFuBCYFF9Cwgh9MAHwBlAT+BSIYTWXE+j0fy5MZPPl+zD6ZIj0FvGdOLhid2P8V41HbEhZgKMetamFR7W+klRssr3+lHJtAmz8O11Qxmhefo0NDQayK6cMj5Zsp/vV6VRtfBtAIZZP2CUczV8MBx0auRlzMNw2Q/Q92KZ93fFb3J6zaIOjRbLERl/iqJsVxRl5yEWGwrsURQlRVEUG/ADcN6RfK7GicnorjEUVNg4//+W8txf29AJ6J0Qdqx3q8nQCUFydBArUgp5ceb2Rq9/zcgkPrlyEN3ahKATgvBAU6MLRzQ0NE5cRneJYVCHCFasXUPvihUc0LWlGhOTdz8Iedvh1+vh4m+h03j/FTuOhWG3woTnjsl+azSeo1HwkQCk+7zPAIYdhc/VOM44qXM0pVV2csus/LsthxkbMzlvQMKx3q0m5d5Tu7I7t4wpQxMbvW6gyUCgSavh0tDQODxMBh1Pnd2TvLKObEsHXXRnfkldCZuBrhMhJB56nlt7RZ0eznj5qO+vxuFzyDuFEOI/oE0ds/6nKMofTbkzQoibgJsAEhMbf/PTOL4x6nWc118aexcNbOfJazueaBNmoU2YhcggTeBUQ0Pj6COEIDY0AGevSTgBQ0Qy9BsovX1aT+TjhkMaf4qinHqEn3EAaO/zvp06ra7P+gT4BGDw4MFKXctoaABEBJmI0AwkDQ0NjWbFZQqFdqcc693QaGKORqnkaqCLECJZCGECpgAzjsLnamhoaGhoaGho1OBIpV4uEEJkACOAv4UQc9TpbYUQMwEURXEAdwBzgO3AT4qibD2y3dbQ0NDQ0NDQ0Dgcjig7XFGU34Hf65ieCZzp834mMPNIPktDQ0NDQ0NDQ+PIEUpN1e4WghAiD9jfzB8TBpQ082ccDaKB/GO9E03E8XJO4Pg5L9o5aXlo56RlcrycF+2ctDwac07yFUWZeLAFWqzxdzQQQnyiKMpNx3o/jhQhxBpFUertsNKaOF7OCRw/50U7Jy0P7Zy0TI6X86Kdk5ZHU5+T46c31uHx57HeAY1aaOek5aGdk5aHdk5aJtp5aXlo56QOTmjjT1EU7UfRwtDOSctDOyctD+2ctEy089Ly0M5J3ZzQxt9xxCfHegc06kQ7Ly0P7Zy0PLRz0vLQzknLo0nPyQmd86ehoaGhoaGhcaKhef40NDQ0NDQ0NE4gNONPQ0NDQ0NDQ+MEQjP+WihCiC+EELlCiC0+0/oJIZYLITYLIf4UQoT6zOurztuqzreo0y8RQmxSp79yLI7leKEx50QIcbkQYoPPwyWE6K/O085JE9HIc2IUQnytTt8uhHjUZ527hRBb1HNyzzE4lOOGRp4TkxDiS3X6RiHEWJ91tP9JEyGEaC+EmC+E2KZ+n3er0yOFEP8KIXarzxHqdCGEeFcIsUc9BwN9tvWK+l/ZIoS45FgdU2vnMM5Jd/U/ZBVCPFBjW42/fimKoj1a4AMYDQwEtvhMWw2MUV9fBzynvjYAm4B+6vsoQK8+pwEx6vSvgVOO9bG11kdjzkmN9foAe33OjXZOjsE5AS4DflBfBwKpQBLQG9iiTjMA/wGdj/WxtdZHI8/J7cCX6utYYC3SKaH9T5r2nMQDA9XXIcAuoCfwKvCIOv0R4BX19ZnALEAAw4GV6vSzgH/V/0mQel5Dj/XxtcbHYZyTWGAI8ALwgM92Duv6pXn+WiiKoiwCCmtM7gosUl//C0xSX58GbFIUZaO6boGiKE6gI7BbUZQ8dbn/fNbRaCSNPCe+XAr8oL7WzkkT0shzogBBQggDEADYgFKgB/LmVqnIXuQLgQube9+PVxp5TnoC89T1coFiYDDa/6RJURQlS1GUderrMmA7kACchzSsUZ/PV1+fB3yjSFYA4UKIeOT5WqQoikNRlAqk0+GgnSQ06qax50RRlFxFUVYD9hqbOqzrl2b8tS62In8YAJOB9urrroAihJgjhFgnhHhInb4H6CaESFJveOf7rKPRNNR3Tny5BJimvtbOSfNT3zn5BagAspBepdcVRSlEjppPFkJECSECkV4P7Zw0LfWdk43AuUIIgxAiGRikztP+J82EECIJGACsBOIURclSZ2UDcerrBCDdZ7UMddpGYKIQIlAIEQ2MQzsvR0wDz0l9HNb1SzP+WhfXAbcJIdYi3cQ2dboBOAm4XH2+QAhxiqIoRcCtwI/AYmSYy3m0d/o4p75zAoAQYhhQqSjKFgDtnBwV6jsnQ5HfdVsgGbhfCNFRUZTtwCvAP8BsYAPaOWlq6jsnXyANizXA28AywKn9T5oHIUQw8Ctwj6Iopb7zFBlDPKj2m6Io/wAzkedpGrAc7bwcEU1wTg7r+qUZf60IRVF2KIpymqIog5B/vL3qrAykKz5fUZRK5J9zoLrOn4qiDFMUZQSwE5lXoNFEHOScuJmC1+vnXkc7J83IQc7JZcBsRVHsaohxKTLEiKIonyuKMkhRlNFAEdo5aVLqOydq+PBeRVH6K4pyHhCO+t1r/5OmRQhhRBoZ3ymK8ps6OUcN56I+56rTD+DvPWqnTkNRlBfU8zUBmROonZfDpJHnpF4O5/qlGX+tCCFErPqsAx4HPlJnzQH6qK54AzAG2FZjnQjgNuCzo73fxzMHOSfuaRfjzferuY52TpqBg5yTNGC8Oi8Imci+o8Y6ich8me+P7l4f39R3TtRrVpD6egLgUBRFu3Y1MUIIAXwObFcU5U2fWTOAq9XXVwN/+Ey/Sq36HQ6UKIqSJYTQCyGi1G32BfoiPU4ajeQwzsnBttXo65ehsTuscXQQQkwDxgLRQogM4CkgWAhxu7rIb8CXIEOJQog3kZVXCjBTUZS/1eXeEUL0U18/qyiKNko7TBpzTlRGA+mKoqTU2JR2TpqIRp6TD4AvhRBbkR6LLxVF2aTO+1W9qdmB2xVFKT5Kh3Dc0chzEgvMEUK4kJ6lK302pf1Pmo5RyO92sxBigzrtMeBl4CchxPXAfuRgFWT06Exk7mUlcK063QgslnYLpcAVapGBRuNp1DkRQrRBpkeEAi5V0qWnGipu9PVLa++moaGhoaGhoXECoYV9NTQ0NDQ0NDROIDTjT0NDQ0NDQ0PjBEIz/jQ0NDQ0NDQ0TiA0409DQ0NDQ0ND4wRCM/40NDQ0NDQ0NE4gNONPQ0NDQ0NDQ+MEQjP+NDQ0GowQoryOad2EEAuEEBuEENuFEJ8IIU5X328QQpQLIXaqr78RQowVQihCiBt8ttFfnfbAYezTuUKIR9TX5wshevrMWyCEGHyI9ccKIf6qZ95nvtvzmX6NEOL9etap9R01Nb7HfLQQQrwmhNghhNgkhPhdCBF+ND9fQ0Oj6dCMPw0NjSPlXeAtteVTD+A9RVHmqO/7I4VJL1ffX6WuswWvoCzApcim8Y1GUZQZiqK8rL49H6hlrB0uiqLc4O440ZKoccxHi3+B3oqi9EW2j3r0KH++hoZGE6EZfxoaGkdKPLK/NACKomxuwDr7AYsQIk5tczQRmFVzIbWd1D61zVS4EMIphBitzlskhOji9sIJIUYC5wKvqV7GTupmJgshVgkhdgkhTq5nf4KFEL+onq3v1H3y8xwKIa5Vt7EKqc7v3sdkIcRyIcRmIcTzNfb/QSHEatVb9ow6LUn1kH4qhNgqhPhHCBFQ3xclhLhLCLFN3cYP6jSP59HHw7pBCFElhBgjhAgSQnyhHvd6IcR5hz4lB0dRlH98ujmsQPZ71dDQaIVoxp+GhsaR8hYwTwgxSwhxbyPCgb8Ak4GRwDrAWnMBRVGcwE6kN+8kdbmThRBmoL2iKLt9ll2G7Iv5oOpl3KvOMiiKMhS4B9lqrC4GqPN7Ah3xMe7A02D9GXX6Sfh7F98BPlQUpQ+Q5bPOaUAXYCjQHxjkNlzV6R8oitILKAYm1bNfAI8AA1SP2y01Z/p4WJ9AelmXAf8D5qnHPQ5pEAfVOKaQGoaj7+NQ3tPrqMNY19DQaB1oxp+GhsYRoSjKl0AP4GdkT9cVqnF2KH5CGn+XAtMOstxiZJ/k0cBLSONrCLKXdUP4TX1eCyTVs8wqRVEyFEVxARvqWG4YsEBRlDxFUWzAjz7zRvns/7c+009TH+uRRmt3pNEHsE9RlA0N2C+ATcB3QogrgDr7qAohugCvARcrimJXP/cRtWfoAsACJPquoyhKmdtwrONRb6hbCPE/dT++O8g+a2hotGA0409DQ+OIURQlU1GULxRFOQ9pGPRuwDrZyEbkE4C5B1l0EXAy0oM2EwhHGpmLG7h7bo+iEzAcYplDLVcfdTVJF8BLPgZVZ0VRPj+MzzsL+AAYCKwWQvgtK4QIRhrSNyqK4vY8CmCSz2cnKoqyvcZ6jfb8CSGuAc5G5nBqjeE1NFopmvGnoaFxRAghJgohjOrrNkAUcKCBqz8JPKyGd+tjFTI07FIUpRrpmbsZaRTWpAwIaeBnN4aVwBghRJR6rJN95i0FpqivL/eZPge4TjXOEEIkCCFiG/OhQggdMrw9H3gYCAOCayz2BfCloii+xvAc4E6f3MUBNbfdWM+fEGIi8BBwrqIolY05Dg0NjZZFY0e3GhoaJzaBQogMn/dvIhP/3xFCVKvTHlS9eodEzdM71DJWIUQ6ssgApMfvUqCuwpIfgE+FEHcBFzVkHxq4n1lCiKeB5cgcvQ0+s+8GvhdCPAz84bPOP0KIHsBy1QYrB65Aevoaih6YKoQIQ3rz3lUUpVjdHkKIDsjj7CqEuE5d5wbgOeBtYJNqQO5DeuyOhPcBM/Cv+vkrFEWplYOooaHR8hGa515DQ0NDQ0ND48RBC/tqaGhoaGhoaJxAaGFfDQ0NjRaAEOIDakjMAO+o1dQaGhoaTYYW9tXQ0NDQ0NDQOIHQwr4aGhoaGhoaGicQmvGnoaGhoaGhoXECoRl/GhoaGhoaGhonEJrxp6GhoaGhoaFxAqEZfxoaGhoaGhoaJxCa8aehoaGhoaGhcQKhGX8aGhoaGhoaGicQmvGnoaGhoaGhoXEC0WI7fEycOFGZPXv2sd6N44rNGSWHXKZPu7CjsCe1aci+1cWx2t+mpK5jb+hxHc73djx8Z8eCg33X2nfa8tDOlz+He42FE/P7auWIQy3QYj1/+fn5x3oXNDQ0NDQ0NDSOO5rE+BNCfCGEyBVCbKlnvhBCvCuE2COE2CSEGNgUn6uhoaGhoaGhodE4msrz9xUw8SDzzwC6qI+bgA+b6HM1NDQ0NDQ0NDQaQZMYf4qiLAIKD7LIecA3imQFEC6EiG+Kz9bQOF7IKqli4a68Y70bGhoaGhrHOUer4CMBSPd5n6FOy/JdSAhxE9IzSGJi4lHaNY2WzqPz3kYJ2MGV3W4kVPTg9/UHuGp4B8IDTcd615qEwgobHy7cg0mvZ/HuPMZ0jal32XKrg2Cz9287M+1Huob1pnNYr6OxqxoaGhoaxwEtqtpXUZRPgE8ABg8erBzj3dFoASxPKWDr7iSCO//Citx5FO4PYtHufIYnRzE0OfJY794R4XIpPPTrJubsXE9ZeRSgIybEXO/yd01bz4yNmUy7cTgjOkXhdDmZuvs9AO7rPIOBiRHoxCGLvDQ0NDQ0TnCOVrXvAaC9z/t26jQNjToprrTx4uz1vLFoNklhHQgzxrAsJYdFu/NJigrE6XLx45p0fl2bcax39bCZvzOXXzdugfZvYI77i0CTnrwyK9NWpdVa9u89//HXzpUAZBZXAVBkLfLMf+bPbaxPKz4q+62hoaGh0bo5WsbfDOAqtep3OFCiKErWoVbSOHEosuazIX+55/32rFLWlU/F1P5DRg3aSJmjkEp7NQad4O5TujKiUzTzd+Qyf2fuMdzrI+OLZbsRhnIAzOHr6d4mBIAFdRzTI0vvJSj5A/q1C6Nn21AAoixRxFjiUao7AKCgOcs1NDQ0NA5Nk4R9hRDTgLFAtBAiA3gKMAIoivIRMBM4E9gDVALXNsXnahwfOF1Obl9yPgDfjV+MEIKIQBPtwiLIBf5I+wyAwUkh3HPOSPQ6GdrU6wQOZ+s0eBRFISXgYaI7WqhSoE/QJIrLXADYahxTma0MgFj7hbxxcX86xwYDIITg9PYXsU1XzsJ9tNrvQkNDQ0Pj6NIkxp+iKJceYr4C3N4Un6Vx/LEwY6HntVNx4HDo6NYmhD4lZuaqyQFnJ15Gl7BeHsMPwKATOFyuo727TYIQAofLRrVSCkBZcSIDEyNwuRQyS6r9lk0tSQXgsQljsBh1lFTZCQswcs/038hzZHFpt6vJzkgjwKQ/2oehoaGhodEKabEdPjROHDLKZN7ewOhRuBQX363cz5+bsqiwl3mWmdTxOobEjvFbT68TtbxkrYUd2aW0DxhAh5Aknh/8Ndvy9+GkjC5xIdid/gZtamkqANN2TOOkV+Z7cgIXpK1gU8UvRIboeH1yP/q1Cz/KR6GhoaGh0RppUdW+GicmE5MnYnC2pXfEYIQQzNmaQ5XdSXCHDESgXKbKUUGprZiYgDae9Qx6HdKp3Pp4Ysnj7K5YTrQlhgpHEQEJ05iXEk0bc69aFbvF1mIANmanAGBzuHC6FKpdRRiB2xafxzfj5iO0Sl8NDQ0NjQagef40Dk7GGlj2XuPX2zMXng6Dgr2HXDQ2MJY+kUPYnVvOz2vScUd2naUDuazzbbw+/Hs+2f4yb2/+n996r1zYh2+vH9b4fWsB7K1YDUB+dR6/7fsCgLzyKhLCA5h243C/Za/seSXm6qG4cCAE2J0uiittYJAhY6fi4M4fVjBvR+stftHQ0NDQOHponr8ThB3Zpbz5704uHtyedhGBDV/xs1Pk85AbwWhp+Hprv5TP+5dCVKc6F3EpLu5bcB/xQfFklZYz/8DfVKbcQ5QlgQqbE7N1CGd3kMadUWfE4bL7rd9aPV12lx075VgcXak27GJnySY5Q7gwG+oej7mcZhSsmPQ6bE4XBRU2dKrxB5BWUkhxZfs619XQ0NBoDKn5FVTbnXSPDz3Wu6LRTGievxMAh9PFlE9WMH9nHh8u2Ht4odLynNrT1n4NGWvrXt4utego3Cefi1LBVuG3SIm1hLlpc5m6fSpzD0zHhZ34CAMRQbJzh8lcTJWjEgCjzoTdZfNb/8+Nmbz9367GH8sxpri6GIBoMZTJXSf7zHGxPauU1+bspMLq8Ex9edXL2AOX4lKNP7tDocLqQG8sJUgfDoDQV2Fzts7iFw0NjZbFnT+s58FfNx3r3dBoRjTj7wQgvaiK4ko7ydFBbDpQwv6CysZvpNwnpFiRD4vfgD/vgl+uhcwN8N3FXoMPILordD8bxj4KigLv9IOvzvLbZKXDux8R5mgAQgIgyKQHFKriXmDG/m8BMNRh/G3MKGbO1jqM0hZOYbVsgx1iCmZn4U7PdCGcFFbaWLQ7jwqb1/hbmL4QhItAXSwPn9GVib3bMCAxgk3XLeGWXo8AoNNXYXNoxp+GhsaR0VrzqDUah2b8HacoioJLkcZAu4gAZt9zMtePSmZQhwgOK1pani2fMzfAuwNh7rNgCgFjAPzzOOyeAxmrvctPfAmmfAcGE5S5110PPtIsFXavJzDGEg9AiAWePLsn15+cIA0egxQ+NuqM2GuEfaXOX+szeBwuB0mhHRnZXbApX46u7+/1Lo7KZELMRgA/Q67cXk6i4RQe6Pk5VwxP9rS1E0KQGNyZC5KuwaCEY6+j8nl/QQX3/rSB7VmlteZpaGho1EQBTPWkn2gcP2hn+DgkszyTYd8P46+UvwAw6nV0bxNKv/bhPH1OLzpEBTV+o+6wb3w/uHoGTJkGtyyG21bAGa/IeRV5/utkb4FZD0PmOvl+4sv4Wp6RlkgmdboMgCiLrOINskij5uRuUsg4yCCfR8ZN4NLOt/ptXur8tb5Raq/oXvx5wR9MSPZK16zZFUavNm0Y1z0WAKtq/CmKQrmtnNN6JDNpUDv25VeQUVTJU//9wKnf3EaYKYLJnW6gf3wn4sNq52T+sDqdPbnlPP7HlqNzcBoaGq0anRBcPSKJib3aHHphjVaLVvBxHBJhiaDKUUVupQzVTl9/AJ1OkHw4Rl+fyRDXGwZeLd8LAW37y4cbk7rdov3yefuf8OfdcPIDsPIjqFJ70HY708/4C9CF8+3cEAKTINIcxSkJ5zG+bXeW7c3n3z2bwABBquevR0R/ekT4fCbS81dTE681UGlz8M7c3QzuJL+Lyzvfzn9b5+N0dSA6uC0AVrs8ripHFQ7FwfaC7Vw962pSt59HnzZJpCqryXGuwqAzUmwt4L7Tkggw+Bfy7MopY8mefAAs2kheQ0OjAezLLyc5Oohz+sYf613RaEa0O8JxyH/7/wPgnXXvcOfcO/l86R5+Wp1Opc3BtV+tYtaWRrRVnvQZnHQP6I1StmX6bf7yLUvflfl8IIs6XE4ozYTKAkg6SU6P7Qk3L4asjbDmC++qKem4HCGQcyVTOt3C9d0fJDm0E+lFVazPkPsYaJSevxJrISmlO/zyUQJNBgJbYVeLqVt/5NvUB8guksZffnUOOeavSK/aSoXVQXigEZd6nFanlfbB7Vm8q4R1uevQG6uwO12UOwoxKBFYndXctuQ85h6YXutzMopkTuWQpIg6Q8IaGhoaNflvey7P/rW11aopaDQMzfg7DsmuyPa8XpCxgIySQhKjAjEb9OSX2yiutB9k7TpY+zWs/hx2/wsbvgOdj8PYt8gjIBze7AmzHgKdUXoMAyKhYDfE95UewYWvehZffGA+wZ1fx1Xdjn351bw3dye5ZZUEmfS47JG0dVxKu6BkAOZn/cXjq2/AoXj3/ZYxnfjnXv+uH62B/SUH0AVkEBscDsCGguUACOEiLtTCt9cNo3dCGCC9uD+c9QfVhVLyRq+3Y3O4qHaVYyQIk05WRs/ems4H8/f4fY47JB5oMrRKD6mGhsbRweF08dAvG9l8oASrw0W13cXVX6461rul0Yxoxt9xSJG1yO99cVUlbcMs/HvgFyxmK5U+laQHpWAvvJggq3o3fA9750FUZ4jo4F0mRM0LGf8EJI70FoaEtAGdDoJiYP1UKfOSMBDKsqBUevUKqmT7NpfTzOacVJZzPctzZxNo0qM4woh0jvdUARtVI6dm0UdroNzqoMrm9LyvtNtA0RMRaOaRoY9wTbf71DkuzIbankybw4Xiksev09uwOxVsSjkmXTB6nQGd0FPlrKawwr8aOjEikHP6xhMWYMThUjzeRA0NDQ1fckqtbM8u4715u7E65LWquNJ2iLU0WjOa8deMzNg7gxvm3HDUPm/WvlnM2DuDEmuJ33Shs2E17uSbXe9givuTCh9D5KDYyuXDGCiNttTF0Gm8/zL9L5eFHCPugC6nQViinB4oK1IZ9ygMvh4Q0hMIkLcDgKKqcgCqbHq+XCL7+xoMTixGPTrLAarxFpCYPMaf94I0f2cu9/64oWHHcgzp98w/9Hhytud9pd0Kip7wQCOX97icjqHd5QzhpKjSxnN/bWNdmjTgN+Ru4N6Ft6AzyHOq19uxOV2YdYFEW+IA+d3odE6Pzt/j0zfz89p0useHctPoTozsFMVVwzug2X4aGhp14R4Y6oTw5Bu7FHC2woI6jYahFXw0I/tL97MyeyUuxYVONL+d/dCihwA4OeFkDMKAQ5EevoDEL5idJZXa9fpqKq0N9PxZpXFGRDLkbpWv29dop6Y3wHCfKtwJT8Mv10GMatD0ukA+AIKlsUKFLEIotZajKDop46K4w5IOjHodlvhfyTZGAKMBqfMH4PAx/vYXVPD35izeuqR/w47nGFHzAlplt6EoesIDpKyLXqjePuFCCFiVWkhWcTUkyhD+hvw1KK4+xFs6c073JHqEd2Jst18B2JxRgklnRtHZPaHdXTnlGPU67P1duBSFnvGh9GobdvQOWENDo1UyoWccmzKKPe/tThd6XevLq9Y4NJrnrxkJNUmDy1fPrjmZ0GECncI60SOqB90iu3mm64zFZFelARAXFEm3NiHklVnJKa32W7/C6vB39dvcxl+S+pwsHwej3RA46T4Y91jteUEyhEuVFDnuFGcg0BBEx+gQxnSW4WO7y0bP+BCMlnx6RnfxrOoO+9p8jD+9Ttcqdf7GdurGmA6DiQ42A2DRB3BW5Os4SgYSbJbjMXfopdQm9fnO6TGIZ4a8TxEb6dHO35ic1PF6QpwDPMZfeKCRQJOB6esPcNFHyymrdpBdWt2yRvEzH4QZd/rnjGponMgoiiyKOwa0DQ/g2+uGclafeK4ZmcyYrjEAOLRCseMWzfPXRKzJXsOe4j1M6T7FM232PhnqK7GWEGIKafZ9CDAEUOWo4s4BdzK562TeWvsW53Y6l1v+uwWAb8YtQCcEOqHn3h83sCevnCfP7smQJBmiveLzlThcCqkvq504fI0/oYNr/oawhIPvRHginPpUPTsYAY9lyW1Nv41r8jYxvve5nHvZyazYW8Aty3TYXDYqXHm4sNE3tqtn1W5hfbi915OEmSI90/RChiZcLgWd7uhWpv27/18yyzO5utfVjV73ut7XcV3v6zzvdULPhb2GcEonu2c05tb5K7fLc/DieUN4YeULzNg7g/JKM/+lrGBKtyuYkDSWCe0uoCg7nQqrA5vDRVZJNXanQruIAISxkO+3/sHfK9rw+VWDiQ1tRH/m5mTfYsjbDuu+hUczwCyrusnfDVXF0H7IMd09DY2jzpZf4dfr4eJvoee54HTA95Nh1D3QsXkL2/Q6waaMEtqGB9A5NphTuseiFwKd5h46btFObRNx7ZxreWHlC1idVs+0LQVSWNftvWluZuydQWZFJgBtgtrwyuhX2JfejuSAYXSN6IpBLQ5QFIU9edKoWLY337N+LcHksEQYcCWMugueyD+04XcohABTICx+HTZ8x8ADmzlt/250OkFIgJFzOlxOt/A+pJTKnMCkEK/xFxMQz6g2pxFo8GoV6vW6uvf7KHDfgvt4fc3rnj69DUVRFO6atp45W7P9pi3KmU6ZsgezUYZY3B0+ym3l6IUek87MjL0zAJi+IZUqww4Kq+RnF1TnML63kWtHJVNWLQti8sutOFwKgYlfsKjkbUBpOXIvTgcU7FE9ygoUpnjnvT8YPj/1WO2Zhsax4buLoUjtg75vkXwuSZNFdj9d1ewfn1VSxWv/7OTntems3FdAoMnAvRO6EmjS/EPHK5rx18Rszd/KrqJd2J12DEL+cRZnLCa9LP2o7cOoaaOYum0qaUXFvLToexRrOzqEduCyuSfx5PwPue7rNTx+Vg8Ayqq9+X9jusaQFBUotfiKUqX35bz3ZeXu3Gea5iK07D1Y9Bq06ctlulv4WIzwzJrS+Wb6RQ0npXQHBmEkMbiTZ16FvYxtResot3sN6WCzgbZhlqMTznQ5YfZjkLUJKguJVkP6/6TMlLqGB8HXKZlRVMX87Pf4ePsTnmlCCL7Z9Tbr85djNuiID7MQoOoXhpvDSQ7pSef/zeambk/LXdHJ7yAyIByAdzY/yafbZZeVSp9iHqfLhau8N3qMwDEQxHa5IGdb7elFqeCyQzfVw1ywp/YylYWw6Wdva8AWRnphJX9uzCS9qJK8MuuhV9DQqI+qItkec97zkDwa0qT0k1sV4WikRmQWyxSgvDIrHy1MaZwWrEarpEmMPyHERCHETiHEHiHEI3XMv0YIkSeE2KA+jl4J7FHif8P+B8Ds1NlMmjGJV1a/QmJoIgadgfc3vM+Zv53ZrJ+vKAoGYWBy18mU2kqZuSWLie/+gy7ue1Jdv3qMz0oyKbfaGZYcxXWjkhjUIcKzDZNeh85WDn/dC6s+leE3l0tenJa+A9v+OOz9K7GW0OfrPvy2+3cAnLG92BCzhX9Y4Fmm0lFBlaOS09tfxP39XsagM3rmpZXv5fl1d5Fatssz7aw+8Sx79BSPodQs2Kthy2/w6w2w4gPI2QIfncRH+3YCsGLFa7KbiUp+VT6/7vqVnIocz7QlD49n9j0nA7Dvv08Za16IQ/E3GPXCgEuRlc6fXDmYiwe3B+CqXldxf+93ARgYM4r+lltwVssuINGB8tyZdCbSikq46ds1VKgyPvee2gWHU0EnXOjUgpKjbvztngMfjoCMNf7T1Wpvup0hn92i4dYy/2V+uwE2/9L8+3kY3Pb9Oj5ZnMJt363juq9XH3oFjeOLqmJY/Zlfr/JGYS2DfHXQ4yuaby2X15j/GwlL35bTRt11JHvaINxKATohsDqcrEsr4oL/W0paYWWzf7bGseGIjT8hhB74ADgD6AlcKoToWceiPyqK0l99fHakn3u0ya/K59SfTyWlOKXO+VO6T2HaWdM4u+PZAKzOXo1BZ2B4/HDPMk6Xwtr9hc2yf3aXHYfiQEF6wVanVNIrPsYz373fRr2earuLFSkFnNsvgTN6e1v47Nqxkc4Va+WbNn3gt5vg8wkyR+8Icbea+1qUQ0QS/9dhAPrANEKc3ovLoyuv4fqFp5FRsY9+Uf5VxUbVEDzqOn/zn4dfroWtv0FMD9nbuPQA3Wx2Zva8g4dD+8Huf+Dna8DlYnX2ap5e/jSn/nIqTpfXC5cQHkC13Ylj+9/YhSBI+N809EKPU6lbgsfmlNODTBY6WsagOGXoOzYoHACj3owTGwXlNrJL5Ai+TVgA/duHExS5FbtSDcKG/WiHx4tS5XO4jy6kwwrGAOgwSrYIDGkrw74pC+CldjD6Ibhtpby5AuyajYZGi6FovzTaXukAf98vw7LVpWBrhJFkr4bfb4GPTpLC95Ed4bwPILob9JD3D3K3yuvu47kw/nE5bd8i2Dq9yQ8JwO5wG38y3zjAqMfhUlplQZ1Gw2gKz99QYI+iKCmKotiAH4DzmmC7LYq00jRyKnNYk7Omzvn7S/eTGJroyflTUNALPUsOLAHgtv638cH8PUz6cDlr9xeyM7uM/QVNVwVcaZcXn192SU/JXWP78PU1ozzz3VWyYYHylL8wczsgK3zdLDTfxyemt+Qbl0N6bmK6gVmGOGnvNWQbi1vqpqc5EqUin0+2vA9AZLnXk+eu6N1SWNuTYqxD52/t/iKu/HxlLXHjJsVphw4nwSVT5eOANI4XBVjI/+9x4rb8zhqLGfve+aC42JS3ybNqamkqACNfnsfwF+eyMb2YFHskDiEwCn9vpU7ocarSPM/8uZVvlst1n13+LFP3vAaAUS8odu1CGMowOtvSPkxWT5t0ZhSk/t8b/8rvc/nefAYnRVKlFABw7aj2xIWYm+c7qo/yHNnpJTBKvq8shOdjZVHHtTPBHAIj74Sup3m9ysVpENsdqlWtyhYoTuhOMxjQPpzebUPp3qb5i7k0jpzQ1NmE7pvlP3HlJ/Dvk3WvsHMW5GyV3Y0c6jXmr3vg/UHeZfbOg89OgTd71PZwu5ww91l/zx6A0QIXfCy1UP+8Ry434Aq4Y5XUS71K5vayazbkbpODKGs5fH0O/Nz4ArOG4Pb8IQQ2h4tgi0xZajF5whpNTlMYfwmAb0JbhjqtJpOEEJuEEL8IIdo3weceVSItsso0yBhU5/xJMyZx4z83si5nHc+MfIbXRr/GT+f85Jk/OG4wO3NkWOtAcTWnv72IMa8taLL9q9mHsUdcLIEmU63lQgLg/glduWJYItNWpXHZZytwKUrtvLk/bpfPCQNlocad6+CKww/BuY3iCZVWsJXzYvenOSk/hgeLyj3LVDrk6xhL7Ybiden8FVZYWbw7v+EdSw6HM16Ba/+GHudAdGfodxnct4O3ugzhuvg4Xu85hmvj43in+0ioyGVH3iZPZffWgq2eXsTOqGl8tfsVspMvxK7TY9T5J1LrdQaP52/N/iKe/GMrC3bmsqd4DwVWGUI2G3QsLHuOM/uFsu66OfRqI8O/Jr00/tx0iAxkW1Yp5VYHFyVJDcZTe0YTFXwUjT+nAwr3ydy+9wbAgXUynAUw+2HvciNukzqQ5dIzTNfT4fVu3rwnWt7Nx+50ccGABM7vn0CgyeApztFo2XT47yY6zL3Zf+KsB2VKS02qimU6x67Z8Pd9sOMvORBJXwU9z4OEwTDpcxh0jfRcVxfDum/8t7F/KSx+A+b8z3+6yymr26/4VYZ/X+8MKQvlPIMZKr1FeHwyVvZOr7ntJsadEnLFMCnS75ac+nzpPvbklte7nkbr5WgVfPwJJCmK0hf4F/i6roWEEDcJIdYIIdbk5eXVtcgxo7C60O/ZF6vTitVpZVvBNj7a9BEXdL7Ao7MXExBDp7BO7CvZR8946UEb1SmKUIuBS4c2nQ0cZg7jtdHSQ+SsakdCcG0DCiDcFMXYbrFcMiSREIsBlyK9f85yecFJdalCzP0uk88J6ig3qpP01BwmCcEJvDX2LbqOfhTRdSKje5zOA+2G0LG61OPdKbZJL1VsQNta65vq0fmDo6xFpTdAaDxWWzkOIfi6SlboFYa3g7d6UVy4h0EOMCDYV7LPM6I2hq9jSfYsHr/+YnoPuJ4+iWP9NvvCkM+Z3FGmwnaNk7InWzNLqbBXEBkQwg0nJRMRaMKsN9E2wt9wHBt/Nt1MF3vel1kduBT4eNFe/livnteCMsobKu59JCgKPBcLz0XBtumgN0nPRWkmJJ0sWwCC9KaADAMX7JUejh7nSjmg8mxv5WNVsbf6sRkoqbJTbW9gxxsVi1HPWX3iSS2oYGdOGUOSIw+9ksYxRddYxYW9c6XnOmGw7GWetVH+hm3lsijjxrnQ5yKI6QqPZUrx+/zd/ttwa/aZajgMvjlPCuHH9oBzVMNzw3fe+cve81++41hY8BIMulbuSzN4w0/v1Yafbx5Br7ZhvH1Jf07tIe8D27NKeeS3TYdYW6M10hTG3wHA14ppp07zoChKgaIo7pK4z4BB1IGiKJ8oijJYUZTBMTExdS1y1HF7brbkS6/FrH2zeHPNm37LlNmkRy8xJBGHy8Gt/93KP6n/8NDCh8irymNvyV5eW/0aLtW7FmIxUmFzEhlU2zPX2H2btmOaxyANMAQAYCy+iB4xslL28WGPe5Z/YcjnXN7lds/7EIvMoyurdqArkOHCD53nUnnR9/KidP1/0HbAEe2jmzBzGD/t/InHdk3lne4jybSn0ykhHqE4Zd9fH2LqMP7CTJHc3/dl+kQO9kwzqGW0jsNNuj4Uebvgk3GQtrLWLFuF9FTFBsjfaY/YvhAcR7mtlNCSLNrZbOxPXVDbK/TP4zy4fQn3DLrHb3JMQBuCjXJw8NpF/QA5Gq+0VxIXEsrjZ/ckKtiMQWdi6vapjPjSa+z1ihzI6IQJGHSCPglhFFbYcLmkN9cVuAGAx//YxLr9/j2f68PhcrAhdwMFVQUNWt4Paxn4yB1x6jPyuTxbepAnqO/dnWJWfwbvDZSe1T6TQa1gpteFMh8wd6sMd1X4eEOakEs/WUGvp+bUEjw/GBVWByn5FXy5LJWSKjtBzVlwpNEkuEyh5Pe6Fpe+hvd7rCpG76yRS7xrDgREQtJJsi1l5jrIV1NUorv6L2swy2n5u/ynj7wTgtv4FzI5rJC53psK0f9SqX16rjT49uVX8GPgpSjD75B512MehgnPgbVUehJD2oKj4b/VhqITgrX7i1i7v4hOMcF0iQthZCe5j5pn+/ikKYy/1UAXIUSyEMIETAFm+C4ghPB1Q50LbG+Cz212vtv+HWN+HMPTy57mn/3/ALA5fzNfbv0Sh8vrRXEbf0lhSQAszVzK8yueZ1aqN7+k2lnNWf1iGNcthgU7c3G6FD6YXyMXpJHsK9nHiytf5Lnlz7EqaxV3zLsDgKhg7zKXdL+EL07/AoAqp7+RFRogPUil1XasoR343HEGDxp+xCrMYDA1qdBuflU+m/I3sT53PZ9t/ozZe5aws0QNVasXx/aqtEuMpU2t9U16M4NiTiJK7WcLUpgUmikvpXAffHmGvOgbahvpNnWaUHMZrU4rjLiDac5Y7rvgJy6tdjFOMasXTu/+5a3+RRY3bPnNb3v/ZvzO2jyZH6oTgum3j+LSoYlUOiqx6AIpq7ajKApOpzQ0KsjwrFtkzScqMoffbxslpXpATdZWcJr2e5ZraLVvqa2UK2ddyZzUOQ1a3o8KH499cBwMvQkQMjn+6TDI3Q5Pl0Abtc9zqJoh0udiKWxrCZfv9Sa4ajqcogqG+2oBNhGKorAtqxSnS+GHVQ2XYvphdRovzvRewtanFTf5vmkcHi6XUm8aSHVkDyrih4Pi8z/oeroc6Pp605wOWcTV5TTQ6WXqy75FsHGanF/T+AM4+T64bnZtr9yI2yCqM5TlyHlrv5bew24+6g+mQGlAAjd9s4aHt7QjZdCjcMsS2Skpvq9cLn8X3L5CFkw1Mav2FfLy7B1MW53GrC1ZCOCq4UkATBnS6rK0NBrAERt/iqI4gDuAOUij7idFUbYKIZ4VQpyrLnaXEGKrEGIjcBdwzZF+bnPjcLqYnTKPImsRv+7+FZtThhvdnRl8W7a5RZyTQpM804qstb0swQEO5u/M469NXg2lxoacfEkIkTfOXtG9qHR4q83yQt72FIDMTZvLvpJ9GHQGnl93l0cPDiBU9fyVVjkIimqHMuxWokUpps3TDnuf6mNdzjrvd6boeef3WK5eHEHpJb/LUB/wyrCv+WzMbEw1R+cqG/KXk17uNQKCLQa6xAZ7PIBNhq0Cpl4oc2+iOssqvBpY1Yt1TqXMx3O4HDDyDqJvWkhUwhAucwVwDsEEmPR0a+MN+2wzFHF5fBwvbPfPfJiZ9gPLc+Z63vdvH05cqIU+0X3IL4qgz9P/UG51YBBqP2C8BuncA3/w5JqbUBSFuTukR9LpUnC4XJhtvYizJKI4whtsJLvP07Qdh/E7qFS9hZ3Gy7BZwR6w+PQVVgtmPLiNvxy1d7R72Q3fy3WTTpLvm8H4K63yGgnl1oZXkRfUKDBan17cVLt0TMksbv2t9n5ck87JT/7E1L/nASAc1YTv/pVu04ajt5WROvFbr3pBVREsfEWKjfsO8DJWy3ndJsr3ncbLore2A6ShGBxHLSI7QnQX6d0GmP0o/HYzjLxLDog+GQvTLpU5hm36yFBuHbQJkx149DVyuJn8tdTFNAYe3hdzCLZlyXtYZnEV/7dgL/sLKgmxGHh4YndO7VnH8Wq0epok509RlJmKonRVFKWToigvqNOeVBRlhvr6UUVReimK0k9RlHGKouxois9tTp7/ezur98qL/GenfcYpiacA0C6kHeBv/LUNassTw59gRNsRtbbzxPAnePnklwFYvFf21w22GLh6hJS/qHkjaQgFVQXsL92PSWfCoDNQbiv3GHtm6wAEwhMCvmf+PTy34jnaBcv93l/uFdSNDTEzZUh74sMsWHI3EoJM7A3a0fTaar6dT5zWaMBANlFYuoyV1W8qgYbg2iurvLPlSRZk/u15369dOP/eN4YucU1YbakosuVYYYqsurtzrRyZ1+CriV8xpp235dLY9mOpclTxwYYP2FqwFac5hANV+eh0Dr6+fqBnuTvaxLLJYqbcUSk9DCpunT8309bs4NbZD3NlzyvpEST18Ix6Hae3uR2XLcpT/QzefEi7y+YReX7z4n44nApCKJ7G7LYGev7cv6ViazEAF824iD5f92FNdt2V7h7KcmDlR/K122jbNh0i1X7Qox/yhn3dhKoh/t9vks+WMJlQv3+J1Jv8fIKc3gzGX2iAgTWPn8oPNw3nxpM7Nni9gnIb0cH+3uAW1Tf5MFi0K4+RL8/z6zzT5Gz/C/bMPfRyR8De3HI+NL3NFasvQF8tB+DtF96LqSIT4agCl4PEf2+E/cvk73XnTNj9rzT23ATFwPDbpNEHMiXhns0w7BZZ4FHTMHOzdbrsWZ2yQKYz6Axy2bTl0tPddzIMvVkacvVs44IBcjBUa3av86Xky9QLIXPDYX479WNTe4m7rx/FVTYu/3wl69OKSCvQtP6OR7QOH/Uwb0cutsKRPDn4DTqGdWRXkczneHb5s4C352qlvZK5aXM5t9O5DI8f7jGy3FgMFl74MxWA3zdJw6va5mRkZynTUVjeeOPvjN/O4Ozfz2Z51nIcLgf7SvZ5PI2ju0YTbAquVf3rlh3xrZYNDzRx+bAOtI8MJHTh47Rf9TwAShPo+tXE1/iLC4wFIJRyTNt/g5KM+lbzI0AfSLWzGS5EigK7/4MPhsMz4XJUfsHHB+2n2SOqBy+c9AIPDn4QkDqEJdYSPtr4ETsKdrDcZGSicy8Lt88mv8zOrXGn0dbuNfYMBXvguWjPe72P1AvAu/M3sSRnJksPLPXk3Jj0OjoE9sdljcGo83pH3a9tLiu924bSLS6EQJOB03q1QTHvIbNyH8KY32DNLvfAxi3P49aOXLX0ZcjeXH/HgSVvyf6kkZ1kW8BLf4ST7pV5VaEJMPhaj5fXQ0i8LPS4+i/5XqeHi7+RmorlXqHs5jD+hBBEB5sZ3jGK2FCLJ7/3UBRUWGkb7h96qzoCD35LYKPqvdyb14yVnT9eLo2XJmDLgRImf7SMKpv/9352v7a0FzL1IH7lc5iLvUUYis5Any86ErZ/Dkyb4q2qXf6+NAbzdkrR5ujOMPElf491QHj9Rp+b7E2w6hNZ0CH0MmS77hsoSQdTMPSeBGe+Kovn6iHEYqRdREDdNR1Om5SWaeD1struZORLc5m5+dDdOmw1ogJBalu3f7bl8PGipv/vaRx7NOOvHpwuBVd1IiPansSzK55ldba/9pxb+mVB+gJeWPkCk2ZMQiBQUAg3h3uWCzGGkJndlvLdj6CzS8NweUoBs9Q/ZGFl442/Koe8+e4vlflc89Ln8fIq6V38d/+/nhxE8N7A3fjq5CmKQkG5lfJqBwHVOWQTSfrkWYi7NzZ6nw6Fr/E3vpP0hLURRbKR+Vu9GlSNZ9EHUOUT3t6XX86kD5exKaP4yHZuz1z4bhLkqXlcJenQb0q9i9tddn7a+RM5lTkEm6Sn8uVVL3u+92BTMBYlGZ2ikDL3Tq5891++XzuBHKc39dWgKPjmAupqiDzrzTJ8+uXWL9ldsRSjXqDTCTIqdyD0VXQI9oaifT1/L13Yl0kDE5i2Ko2TOkdjVeTN/LJhMX7dXA6G2/hztyfUq5qE23PWw8ej4Zvz617R7fUbdRcEx8qwmcEsdfzu2+b18vmi08El30Lyyf7TfW9w5jCvJ7E+bBWw5kspo9FAVqQU8Na/u/hlbQbzd+Ry+WcrOfXNhVzy8fJ60zEURaGwwkbH6CC+uHoI141KAqhlhLQ22kVKY9ZX9L3J6XamNIqagKV78lmdWkR2aTXnvb+Ef7fJgUL/9uGs6fUEGbp2ROz+hS7TZQvBsoSTqWzjIxxvr/bPT135MXwwFP75nzQEfbzyDWb8E3DtLDj/Q7h5oeyF7s5hbdew/OnNB0oICzCSFF2HpJi7GKqB/cTn78gls6SaV2fXDrSt3V/kNxi01yjqcEu9AGQ3ohhKo/WgGX/18NEVg5g8ykV2VQohxhACjYHEBkiPVb+YfqzLWcfq7NVkV8owSX5VPi7FxW/n/sb3Z33PL+f8wror1zEucRwoJhRHOEW2NHTmbLJKqpm+IROjXhzWTePMZJksXKSGNca2G1vvsvMmz2P2JG+XBF/jD+C6r1fz+7o0gmx5ZCuRmNoPhPDERu/ToXDnTE6bMJdT4q5hVOcoIiKiPPNdxkOHbgMMQX6ev2q7i7X7iyiqPMKuHwfUcObkrygXgso/7z7oxb/SXslzK57jo40f8dbatzzT3d7gEGMIcxMeItwWwP9FhGPr+CmZ9n04Ld6bjVEBfDQjfXX+AAx6r2Fodzow6uVfdVv1D3RrE8ZnZ73s3ZaaI2lTDez16cX8tSmT3NJqbu32EgCDksPoEFW3RmVNukd2ByA2MJbN2euoUo3aKp0OupwuqxUdNfrZOh1ez0juEWZ1/HE72Mqg+9lqyG2TDLcdjPVTpQDv5p8b/DGLd+fx/vw9fLY4hffm7WZ5SgEuRWHlvkLS62lr5VLg6hFJDO8YRUyI2ZM329qNvxL1PxQWYDzEkkdAdFeZb+dySdHkA2tlla2j8QNgg/p/SCusZGNGCW//JyMzWw6U0Hv8JbR7civpo9/AYQ6nvM0wUs/4DnugT+7a5K/8K8j3qTp7K/5PFnoVewulGowQ0GEk9L9MiuOD/P1e9rMMGTeAvLJqcuvrFe02JN3dbw7Bn5tkC8n/7vOPYOSVWXn6z60s3eut5nehEGTSc+VwmY4U5GP8aRyfnLjGn6LIpNyNP9Q5u0+7MDJ1P/DZ1vcJMgZxoPwAuVUymT6zPJP7F97PdXOuI7M8k1BTKCsuW4FRbyTQGEj7kPZ0i+zmaUk2vkc4CUlLSbW8QFDHt5k4pASLUcfuF85kYu/ala2HoldUL89+BBuDaRssPSqhNpmj4s73A4gKiCIhOIH1V67nkk43kxjc2TNPCIHFqMdoLUSvOMlWIrj0kxWsSDkMiY9DcHrS6Xx86sf8vDqHW6eu45lze/PIhd4cyfbzbiNixzTilz9V7zYC9IFUOby5lu5q3yNuQZSzRRZ29LqAEUntGRshZPixHtwt5rYVbPPkxemEzs/zd+mQRCKd8u+lM+cRlPx/ftvo0XEC2Cs8nqpH+r/BXb2f9cw36L3H1K9dHHeM76xu20KASSHQ5L049wjvz529nyHUJD17Bp3AqSi8MGs7f22SHpHUgjKySg6S0L/8/+CNHlCWQ0xgDJf3uJwtBVu4bM7VpJZLL1y1Ti+lKZxWf10ygNIMbxXlyg/r/5yGcObrMOYRKXNxyVTp8ajIl2G5+hh4tUyGr9llAaCiAHK2+U2atiqND+bvJdCoJ8hsYGP+ahTFyWVD5cBnfx15ToUVNr5flcawjlH0ahvGUzO28Pbc3TxxVg9iQ49y95Qmxt0fe0N6w+SAGs3ar+RvxmWX4dYZd8Cn4+HdgfDeIKkFWXNAcRAOFMnf8uwtMoLiNtYf+Hkj3/3+B5TlUNx1Mi5DIPZgmUfntMj/R/aQh6H7mbJqNjhOGqTDb4fr/oHkMbKo4yCh2UYhhPR86xp2q12fVkxemZXtWXVEQsyhgGiQ509RFJbszmfKkPYeQ1lRFN6dt5tdarOBwgrv933/hG5Mu3E4Z/eN56PLB9E23OK3vdae06pRmxPP+CvaD4vflLlJK/4Pfr+5ziTk71buZ19hMSa9yRPac5NX5fXgOBUnyWHJtXLs3ljzBn2+7kNaaRrPn9+HsoC/vOtXFBAZeHgaf/sLi8koKeKTCZ9gd9kpt5fz+57fGdV2FMbi8xEYmdK9dsjSoDNwXtKVPNDvFb/pFoOegGppIOQokaTkVzRLu7S2wW0ZmTCSaruCxaijc2wwAzq3gyt/hw4nEZi7noD8TYTv/aPebVzR9S6u7XafzzEdWuplTuocnlj6xMF3LmcrxPXyvK3S6Q6a3+P2Yro7eXQIlaPlcpv0/AUbg0lM/Zl3C/ag90neeS87j0CXiyuN8VywRu3+ohZXBBtDCTB4C0uMBq8naViHeG4bK40/o97I5vzNvLHmDc/8mIB4RsSd4llfrxOy2tepUGT4D4DPl+5hxsbM+r+D0gNQlgnznye9LJ2x7cfywOAHABhb7SBK0dFdHyxDd53Gw98PyDxJgLJsqYsG0PN8GPto/Z/TEIwBMO5Rr8QFSG9MzU4JfutYZK7m7jm15TamXQIfjoBtMzzzthyQ7eNuH98Zp2kfgR0+xxw7h8FJMp1jfx2ev62ZJfy0Jp2yKmn8r1MlXrrEhmAxtm6tv3HdZVTjQHEzhfh2zpJh1l4Xyt/85l9khKEkTT7e6Sevyw3EbbjM2CB/02GBcqBdXGHjkYzb+e2jJ7CWFWCqyPT8l12GQFw6E4aqAvl7TRgED+yCoFipo5c4DK6ecWgvczOSr+aA13kN1unkPvvmItZDabWDuFALQWYDD/2ykbSCSooq7fy7LYeiSht6naCs2j+6sTatiAU780iICKj1ez4qAvEaR5UTz/jL3w1zn5H9HO9aL6elLqm12DN/bqOkugK73UCwsf4K1KdGPMXUM6fWmv7V1q8AKKmu4tkZuxkR69V12pSVyWm92vDIr5s8PVzr4osl+xj/+gK/ac/OXsa03Z+xfMMCojPk/sdYovio4yWUVNnRKQ4qsxquyG426kijDbMH/B/2hKHAkcnP1MfWgq3MS5tHld1JgO+FpdN4iO+HqSKTqB3fobOVEbXlC8yFtb08SSFdSAzxei71DRB5/mDDB0zfM/3gyfw3zIXTnve8jfMND9WBO3/RbfwJBNWOaiYmT2TZpcuINLVl4+5U2jscPFnozb80KQqP5xdyRqr6u7tyuqdryoLMv/gvY7pn2UuGejskOhwm8svlZ7rz+3w7zZTbS9lSuIZyu/QW6HU6qfHnUqjUyXCYUVg8RrJH0sNaLgc+FQVeb0L6ambtm8WN/9zo8XC+VG1kQZmRx7tfBXqjrFaM6ymT2xUFFrwMsx6S65/xKox95KDf32HRdoBXDqZmJwWQlcH7l8newL65XCClOwB+utIz0IsPs3BazzhuGdOJEIM0+BRnAO0iAggxG3jur208Pn2z32a2ZZViMeroGON/PXhn3m6SHvnbE3psjZj1akV4cwn6VhXLDi+Tv5RePsUJ/S6V8859X4oXu3NuG4DbU1mhhtsrrPLZXl2GQbjYUazDVSH/I1VRqqakECg6g6z6/fFKr/c6cTi07X+kR9gkuK9T9Z6HG+dK8ehDEBZg5N/7xnBe/7b8tCaDHdml5Kq5e3GhFkLMBkqrHR7tzx9Xp/HMn9v4cOFefl+fgQDO7CPzP9+d0l8TMj8OOfGMvy6nwsRXpKfD5ZSaS5nray1mc7hA2DHoTJyUIJPNB8UNYt0V6wDoGtGVy3tcjrOeBPNYtaLValeYvTWb5atG8/gw6YFKiFJ48PRuLNtbcNCuC2XVspOAb1jTJaTHYnP6t0xJWctku4Hyynz49nxOtf6HUygcSF8CO2bW2t5/GdN5cPkVuHxETi1GPcXOABIGnc2Vp8juGdX2pr8B/LbrN55Z/gxVdmdtL0mw/K7sgbHoXHbarniaLr9PrLWNfaU7WZL9j+d9gFFPv/bhnryruthXItuEVTsP4tEIjPTkOUZaIv0kXOrC7flzDwpSS1OZmDwRndARYgphX34VP26W56ko2Ou9musYwpkVldwUH8tXoSF+uZXLc+axKMsrCn5e11N4YPADjGo7is8X5nLxR7LXrVnN77PovWGZ9PIUXlx/D6ll0vgwuD1/LhcWEugXNQyTMwm7w+WR9FiZUgA/XyOrL+c+A1XFrDeb+NCeSYVV7vs762TrqdSYTnDjPO9NxxIqE9sv+1F6VbI2yhv7I2kQ0kyaYDHdpGdy8y/w/mDY8hspJSlsL1ANht3/gsEiQ7/FNQSbnyySFciRHaHTOLCWccf4Lnxylfy9BxmkJ6VHfDjBZgMxIfI79tUBBGn8dYsL8Qw63KxV/8N1hYpbC/f/vAFoRuOvusTrsXIb7+5Bd5cJENtd9n9e+FqDii1uHu0fli2vdmB1ODHZ5WCrlCB+SjEyZ+JCCnpd61lu5yVLyRr+pJQfWvaevE5e/DUMvv7Ij7EJGKq2CjyoLJPDBsveh8pC+Pla+KX+fXfncJZVOzyFG3GhFoItBuZszebCD5dRWmVn5T7vYPKb5fsRQnBK91ieOKsnydHBntCxxvHDiXVGFUXmDnVRtcN+u1F6FHw0nvp83Ycb/rmBkB6PoDOWYtSZ6RbZjS4RXQgzhWHUyz/T3uK9XNztYm7+92aWHlha66OeG/kc7UPaE2KQ7b9KqxRS9vUhyBDChN4hBJkNBJsNB3WnvzN3F8FUYivLZ2fhTirtlZQ7ZT7eGoue3SYjwVUlFLqqeTcijNeMH7N+Xxof5BXjW0nqpsJRxoHKVBwub4HEhQMSuKx9PuY9Mz1hVKuj6T1/VqcVs95Mtd3pGbV7GHI96WPeJq/fHZ5JQqm9D8tz5vLpdm+hQ2yohT9uH8XoroduBejWrqvF0ndg1aeet3cPvJuO4QfXfEsOS2bG+TMY236sZ9ppHU7joYUP8fbat0kvqqJMkXmXU3O8xt8mVxfmXPoP5TodDiGkt0rNRdMLvZ/O36Y0B8bycXw04SP0rghMBvlXdYuMWwxe40+vk/l/bqmYS4cmMv32UTJPR7jQCT1GvQ67y8Xu3HJO1a2l289j5cAHPKK2V7Vtw/9FhFGx4gO/473Uvocxf5zDxX9d4p1oDpGGX8Fe2QUlvl+DwlGHjVtoe/238nnR69z856VcO+daWTRQegAGXA6PHoB2Pt0jKwtluOzWpXDzYnh3ACz3P75bxsvBx8BOcmDy9XVDiQoyUWlzsCunjPt/2khZtZ3U/Aq6HkRT0mJsvZfTEjWU3XzGX7EsWHi1E8x8QBrqI+6AITdCSBt5fkvSYf7zsG+Bd72iVFkgUoOk6CDCAoxcPaID/zuzB2GBRvLLbYQJmRNcogTxy7oMbp5+wCvqDDgDolAMAT5iyep18lAyLkeJ+ybI7iH1duNJXQLPx8iq5KVvS8eFUnvZZ/7cyt0/rPfkBlfaHOSohSSxIWauUgs7AIqr7H6fZ1Z/x0/O2ML8nbnM3JzFgeNAAPx4IL/cWm8xWmNpvVerw6E8B17rBCnz5XuHFc5+W5blA9Vqz8SVWbKXa3X2eYxrex4V9gp2F+1mXvo8+nwtb5hOxcmc1DmszF7pV6XpZmTCSGZeOBOXy+uV+nhhCskBJ9MjqgcAIRbpeq8PlwIzTY9ifLsLF/15EXfNu4tyu3eEdndcDNODpBFQFhgBYx/DAOju3Qrdz6q1PbcwsEPxGn9ju8Vyctls4hY+xAsztzM0KZLo4KZPXncbfw9P7M4TZ/f0n2kOobjLhTgCorAHxFDeZrh/ZZ6KxRCI3WXD6Wp8/olvBxQPLhcsfVeKsKrsLd7r8XjVh0lvIjksmXM6nsOEDhOItETy2ebPmJU6i8+3fE56YSVVyO8wrDKWOekHeDK/gAO2zry1SRa0GHtfJCsMy2TOUk2dv2nrV/LW8qnYnDZKquwe72an8E7ohM7jAXSvC3h+h3qdQCcEVw5PwiayWJ+/DF3gLiqsTrrEBvOC8XPCq9JkVeLYRyFvB8T392wvT187xFPtqPZoRXooOSD78oLM5WpOYmQFMikL5HPuVuIqiugT0V0W7CguiEj2T6zP2Qpv94GUhTKP0ByMS1GYnb2SyR8v4c1/ZGpBvi0VgNQS+dw+MpBOMcFUWJ18uTSVX9dl8OPqdMwGPV1i608BqWylFb+KolCuhk1DLM1U5akoEBghBZQ7nwoP7JZFF2e9LufH+LRMc4sYp62UuYBrPpfvd86GX28ARWFNaiElVXaKq+zcGLuD1VcEErv8OV4dI/8XJXgr2yvqGmCf+boc+B9KQugoE2DS0zUumMD6wqwRSZ6XVSkroGgfbP1NCkz7sGhXHuXVDo9kS7nVidXuJDbEjMWoZ0SnaEZ3iSY+zEJiZKCf0W8xqCF1q5Mle/L5cOFetmceWopLo/k57a1FnPzq/FrT16QWMn39gUY5bk6Meu75L8quDeqNlqgu8uJjsHirOp12vzwqxWXAXjSM+IAkb2ipBv+3QVZwDosfVud8qC3+OrHNrVzYJQmQgp6HGlGtdPXgVIP09o1LHMenGRv8THb3eNUc0VFqpTnvl6G3qmKpMG/23qzc1cd2p81z5gvKrcSUZlNCGFFBJr67cfhB9+dwcRt/vRPq9w6VdDyHko7nELPxAwLXbUDYK1F82hkF6OXrKmclwbpQyqrtTHx7EbeN68y5/erQkPPBXrNxO0Bxqqw8TJZhXrvLzuIDi6lyVOF0OT2dMWqSUZbB3LS5nJl8Jjqho7C6kKnbZd7nlG5TSD9Qic0SDS4wYeeX6nPIqooiy5lId3WbhjBVDNxaBhbZ4cN3EFHMZqojpmF33a3qysnzuKNwBy7FRadwb9hLr+rxuY3iDenFLN2Tz40nd2Rqth6HE0Z3D2JgVCKdYoJxLFIHJAV7ZQK5zgh9L+acPS7Wpszy/KZMOhM2VRoowhJBZnkmiqJ4i5vCEmRFbkx3f29bcxCRBJM+l548gwlcTko3vEawtQx+uwkCo6RRseQtKM2EM1+TvVgdVq+HE/gjMoYnrXug/B96W6Unc0uWzBFM2XEaqNkGgWY9RRU27pvQlWmr0nApCj/cNNyvluSnm0ZQbnVw3dcyp7C06gglh5qZA8VVWAw6onwGd+e8twSHS6G0ys6kge247qTkpvvAtJXw89Vw0ZfwwE5pANoqYdNPtduUJQyCvpdIIyZ9lZy2WS2K2vE37PkP9i8HawmMeYSvlkljZNneAtghcweNQN9Op5Ay+m2sayNAFS3YmFHMyE7RbMooxqVILUDaDYKbFjTdsTYRd01bT//24YzvXnf6hDMkgcfsN2IKjqSiLJI3kY4KMlbLLiBAUYWNvXkVTBrUDotRR4jFgILCVSOSPFIuuaXVLN6dT6+2oThdip/Is9lQ2ydUr/yMxlHFHZ0rrLARGeQtGs0oquKhXzaxK6eMhyZ2b9C2jj/P35ovYMtv/tOqiuWfvfvZ0jsQ30/mmVlC5fy1X8HbfWlriebGPjcCIHQOTh62CsWQ76n2dQsmm3xaawF+XphDEWjS8/rq11lyYAntIgKICjIddPkZrpGUqt6MUFMoDw27jdut3ny421xq0UHCeZz+m4OtPe6WkhivJMGef/225fb8Lcv5zzPtq+Wp5Galk6uEE3yQ3LkjxW38zduR4+kmUBch6fOI2vIFe87/y8/wA+n5A/y0/nZkl5F/kAtT76jejEoY5Q3llmbCvOdlqDB7i5zWRiaEl9vKPTmCbiHtuthbvJfX17zOutx1zEmd45meGJLI/4b/j/SiSkqi+sET+azWx/NRYjq/huuJCzNj1EtDzeiuILfKHKWaIs86nRyJG/+8j7LyCiLVdmL/7v8XvdBzVkevZ9fg8fxJ4y+1oILZW7PZmV3Kg72l8HK7SAtd1Xy1hL6yVSHTLpF5r49mQHw/hsQP48zul3Br3EmMMMV4DD+ACHMECoqnCMTDuMegdzN7/QD0BuhzEQy7SVZj9pvCPpORpSW7YMAVcOGnEBovO4Fs/ll6dbdOlwVFgZGezWw2ye+x2mklPEC+3pYtrQQ93t/bhfF5TOykIybETPvIAH5bdwCdEH75fgEmvZ8YbsRhVvAfLUa9PI9Bz//nNy2ntJrtWaWUVNkJsegpqGoimSd7NXw3GcqyYKfaklEISBwBtjI2/PCUf2gzvh9c+An0vRjSV8hUnBG3y3kH1spwZ8IA+T51EVbVU1VaVoYv5Xn7iRt1Jb8+eD5/3D6KX24ZwchOspPO/6Zv4Yk/tjTN8TUTBRW2g4beS6vs/Ogcx7cl/Rgeo/4XdQaZL6myXJXqGpQYgRCCzU+f7lELcA/c/tiYiQJsySxl8sfLEAJO6R5Ltzj/ynWTXodBJ0gvar35rMcT70yR/4GNamOD3TllvDZnB+f2a0tMiJmskoZX6x9/xp9bT8qXM16RemFTvoO7N3iV0t0ExUqvYPoK7hp4FzEBModsQ+l0dpSuJEgV43UXSrhvik+PeJoZ58846O4MTIxgzj2jPe9/O/AiX2/7mlv/u5WnzunJ1Bvq9xomRQYwpW0uZarx9+rKF4kIy+CWi+/yLBM5QVapOu1B7MwpQyeEWkChyLCcD1EWOZr8dve7VDoqiF37JidVLSBSKSLbGUqoxcB57y/h3bl1VFMeIY8MfYSnRz7NE9O38nU9Fc6GiiyS5lyDsSoPlyEQnc3/wu72/FWrIdyGVPt+OfFL3hzjIyGx6lNY9Brsmi1blQkdxMowtK/BV2eYWMVd7evb39kgDPx8jhQYfmfKAN6+pL+sjBUu9OY8zLGzuW50HGEmOeDoGKmGuaxSHua2Xo/z6rBvPNsTQh6TYdMPvDighLP7yso7o96IU3Hi8Al9R1va8GC/1+gW3k+uo34vj03fwvwd8kZQVl3N0j35vDt3NyftvgQuVnPnQuNl5eXzsQzN3kWOvRzH2IeYPNJfriVC1UirWThz9w/r+W7lYQjiHikmH8HqUXdDZ9Wgje8HVUW4dv0jc8h6nOO3WqpD/peCyjoQrsqDCCFvoi7LEvjxCvj6XD7KuJ+0vAd5edYO0gur5CCjvPYgw2zU8f6lA9jw5ATevKR/0x9nM7B2fxGXfrKC4kobt46VHuQRnaKYuuV3xv40ltzK3CP7gP+ehhl3Shkng0V67n6+RhpxHaS251/bivhqaapnlXKrg9u+W0tet0ul4bjrH1mgc8lUKcNiK5eGfHgHWP0Fiq0CMzaG6GTo/j7bLfwedyfBpXuwLXoHXC50QmA2eA2ZIUkN63BzLCkstzF9QyZ/bDhQ5/xi1bv85sX9KHRYKCUYhtwA6SuhqphV+/K47TtpCPZtF+5Z78WZ27nrB29hozu8/+Bp3bA7Fe47tSt3ju/Cs+f14tnz5GD486sH8+U1Q4gNMZPWRHlmGkdGr4RQdAI2qDJTD/yyiQ/m72XpXilYXtKI6MPxY/yt+waeDpOVhwV75bR/n4S5zx00mXdT3iacHUaCzsii+U/y7Pz7/cJ9Okx+lZW+TOo6ieQwNUySvxv2+sfiHU4XZdV2OscGc++pXTEZdBTa93nml9vLZRhk0et1qtz3j9VxVv4XHs9fsb2cd/+5na9Tl3Bep/PQCZ2nqhjVAxgWYJSJ1cagWj0g+0QO4eQ20mtYYS8lbN9fjKr4l0ilhDwljBCLgQPF1c3Szic5LJkuEV1kwUc9mmjCp3LaXLKX7j+MwFTi/b56Rw7m5WFfExsgZVAM6vdyMJ2/ouoiHln8COty1JGxW49u049ScDZhkMwHw5vzCQcpEMFr/LurfbtFdMOhODwe4OhgM8lqe6bTengrevNKHcQGxpIclszghJPlzU39bIPO6CncAOn50ynyDzquY5DHe+H2zMzc563mthgCGRA9ggizXMbXO7XLIcPRuWWVvDx7B5sOFJNRVMWqOeoAKbQdrPgQnDaqhY4/U/7km63fEG8Mo4s+mAS7g0u6TGZUwihOSTzF73vILavmjw2ZPPXH1nq/q6OOmru4+mdVzzJplN/svu0H0Kc4EoM93GP8oZPn02VYBdv/5PPCdaQbjRRai9mTW05YgJGPrhhYp5deJwQdooIIb+Fev7JqeVO4bWwnXpuzg+UpBSzbW+CpaL5saCJRgfL37O4cVBcVVgenvLGAtfsL615gwzQZes/fKeVTBlwpvbFbf4fKIghrx9TR8/nceYZfysuszVnM3JzNS5uC4M610E8tLupymhRfBhn6H/c/yNnMGcXTmGZ6nqkm2cHmgBLDT8p4pjnGYUxfSvJjf3PO+0t4/u9t/L5eXgeTooLQ6wSuBvZwPha4q3x9PTiKonjkmYrVdqARgSam5nVkdPUb7I45FRQnazd8xfWLxjOgSwmfXDnIU1j30sztfLIoxU/CK0T1WCdEyOtPakEFO3PK+GVthiffMDbEQmiAkTZhliYrMtA4Mka+NA+Xgufa5W4veeXnqzhQXHV8GH82l42vt37dsGbr2/+UI003xWkyrLd3nqxErIf1ueu5fOblfLnnF2g3mHVlKfy+/x/+ucDbDi2jwE50QDS39LuFfjHSs/LsyGdZedlK/429Pxi+Pd9v0i1T19Ln6X+49qvVXD48kYUPjuWkBO/N6I9Nu/n2vcdh3nPe0IgPV/eVBkRs0vm8NfRxALYYFKavfp+Va4oYGDmefjH9mHnBTEJFF0D9UQgh87FKazcAHxwrvZDW4l1Yw7vQvnon59meo7D3dfSMD8Ni1DWLzt+c1Dmsylp1UOPPafJWUtpCEtHbSgnK8hZjBBtDSQzuhEk1sox6gVEvDlox/d7695ifPp8D5QegNEtqiYW2gwFXwalPww3eMJjb8zel2xSvUV0HHqkXNXSrqBWDM/fNpMLq4L25u9mRLXOSEiPCPet9uiiDq3tdzSNDH5FhzLvWw2ApQ7E8Zy4/7FF747rs9Cubh1HNvkutMHrah7k9fr6Gqs1pZXXeInKr1OIRH+Mv3ym16tqFSq9vdWkBs0wPM7RE/Y0HRkLBHgDuT//Lcxy//X0jFdXFDHIIHh/5JJf3uJy3x71NqOq5BFiRIg2AX28dWe931ZT8lfIXC9MXet7f2u9WAH+5pbheKELPBuFiVvKtMs3Dh3vGvsAO69UUmqrpZMiDnK0MjzoPZ3UbDFSBzsiyttITvMsVSmm1ne5tQpjYO76WkLsvP6xKY8on8rdaVGFj/s5cKm0tRxjXbUx0jw8lvVD+zkMsBt5StQl3ZJdh1Mnfc0nBLsjfU+d2NmYUszevgnfm1jE/fw/8fZ+U/blhnsyn7nsJ9DxPzlerwft17YSCzlPBDngMsmq7E8Lbe7dpMEO5bKFJRBL0mQynv8R6fV+ShBSnz534MRuUTuwudPE0N1N0/lQU9da2JbOEpXsKqLY7mb01G6ea39hScd/ufHvtfrIohZEvz2NffgUdo4P58pohvP7PTjKKqykmhL3mHtB7Er/lyJB2h3YHOK2Xt3OUu2OTbzGPu9DQncv38aIUduWU8fPaDOZu9/f83jW+C99eP4yCOjzfGkcPu9NFudXBvad25dpR8roWFeSfctaYorMWa/yllabx+prXyanMOfiCmRtkSCFhMDy0D855V4ax8ndB7nZZ0VUP7vBucXUxnPUGefF9iAmMQfx4uWcZHSaEENze/3amnjmVzVdv5oIuFxDom49W6TMKVm9EiqLwn/onWrRLJpTHhwXwyNBHeHLEkwBklRWwqVA1hNoOrLV/xmq5vrXdWZza4xKC1Zy3JHs2N+RnMCHmXnlR22Anp7Qao154DavQhFphX4BggzSwwhfcQUj6fIKdJVRhYvywQXRrEyIlQQ7iSTtc3lv/Hr/s+qVunT8Vl4+Yti00CYc5gsBcb6iixFbEnPRfyauSLZ2EEIzrFkvb8IBa23LzV4o0aCrtlTLE+Xie9Cx0Pa3Wsu5Q7ykdTvE7v4XVheRXSbe6oige489tCO0q2uV5ziqp5o1/d7EzW4asL+yf5P0ARY9Jb+KWf29hbpraVcZhI2HRQ+zKWcSCTLmvptI0rtm/iR917VlxVQpjf3WxLq1IeujUoiWdj3xFpaOctzY9xsYCOSAx6nWeog2DCOCUhPMZ024MOgFtRQE9dOnMc/bH3v9qOVBQc/YsPp1s9prMZBoNzAjQ89bat+ochC3fW0CI2UCvtqG15jU1DpeDzzd/zi+7fwGkwec2hH1zEzEG4IjtzYfx5cyMjmNvfoXfvv+0Oh1H1FeMiv2U3r+MgQ9HEmYJxlXdFkVvh/D2HFCNklxhoaDcSmgD+t3ml1tZkVKIzeFi8Z58rv1yNbdOrX/gebRpGx7AN9cNJTrYxIHiKs7qE4/ZoMeEnacCf6O7Lh2XRUYuSn+/Ed6vu4DHfW24c3zn2jNXfSyvf5M+k4MbgPZDoLsaelfTbXonhHLr2E6M7+4dYLl7V4/tVsegy64OdNzV3CNu49orrqLs2kUABFVlYkUKoUcFmTxSJQDtwgMprLSRX271dLRwtOBWZRcOlFENu9OF0+XkoYUP/T97Zx0e1dl1/d8Zt7h7CAka3B2KS3GtUXej7k5dnqfuSgttaYtDKS0UdwLBLQnE3TN+vj/ukQwRoEDf9v3edV1cZGbOHJtz7rPvvddei6VHxKQir7yOAIOaIW3Cya8wM8glcVVplmHq5+wzi+zz9HbDfdbplnsxab3XcTvXPRtm0hIVoCPSX+ehi7hLiG4EGTVMfG8T3V5Yc+FWmv+H88L+nAoKXJU496QlQO8N4u+c7x1jXpnSgVemdODeeuX95vCPDf7cxHK3vl0DOOziYXjid9Hpd+WPIosR1hqQYNtH4LQ3G/zFmGK8zRoR7SkKjCHMGIVcT/dPKZ1DOeeoyKLYTNEcyxU3zgFXa7xbGsKdSlcr1aQEprhWXksggvOFPsgrPVJ8nGqzjQ+XiZv+mGxh3el1+GkDAfBzOsmWQymtsbBwVzZzVxzij8OF9E4K8WYnus2GHg3FP0N1kQyJHE2ItZYql5jxp5FLqKooweGUUSmki36DpxWmkVWZhUqhwSnTUOfPjfrdtZJEbXgXDIXei7vEXMBXR9/iVPUJz3sfX9Pd08HWGFSuUqqHw6dUCSuwRtAupB0fDf+IvOo88mvyOVl+kle2v8JVK65iyA9DuHXNrTyx6QkmJE9gzdQ1DbKDx3PVjPyPeCC5hYLbRnm7m6MC9JwsP4mMjEpSwS+3wqeXEXx0AX4FuzwNH+q6IkKdTnbrZpJZLHiFwUYNbHmPfq7yXX0XkjN1/oa0DmfBzaJrW8aBUlKiUioINmqIkkQW4B37JI71dLmaJA+DB0/i0HgD3hZaLz/q8/2fs+zkMgYuGMjBEq9HbtrpcrokBDHqvxt4acW5uzP8Fews2Mnx8uOsO70OgKzKLD5J/4QE/wQkfDNyJ0d+hENl5URxBUPf+JPDrkB8V8EuXtg/FVlVhp/Re40HZj+PNnA3VmzIAfGeQF+hrMFaUdCsiLgb/h4xXZsQ0AbKai++TeJfhUmrYmCrMLrEBTG1WyzX9EngRFE1yVIO1zkXMqT8Z1KcaQBUuOVyGgn4i1yZorDG5KDy9gmJKb8z/MoLxTVjVpooqbZQWWfnip7x9Ej0NuJM7hpL5stjmd49jgboMBXmHPA26AEtw0wkJIomLuOfzxLpL+7pYJPGZ3IZE6SnrMbqsUt7YULqJZGyulh4eUpHtCoFFoeToroiVmauJF8nvLL7tAzheGEVqw/kE2BQe7jOlWYbdoeT01XHCCSVvnGdfdZpdJV462f+OsUGsuj2fiSHm3jviq68f2VXT8VAdYaIuUKSPHI5lkulA/kXkVtex7ojF8hRrbeuxEeWs/pA/kVZ38XAuHc20u/lPwAvn2/+9tN0enY1lWYb5bXeLHaQQcOR/CoWpTVj41kP/9jgD+CKNlfw4PoH6fVdLx768yHvB7Wl8PONsOoR0eV0/xFvR19Md3g839v91Ezwt7doLxaHhcI6cfFkVGYQY4rBFtGJladzGJidSqze2zb90d6P6PBVh4bSLx2mwYxvSSl+jeHvCmN5t2K6W7FdV494HKQLIlwfjlYNgZII/j578TYO7dsGvz0JGX+i+WokE5SbAfizai9z1s0hyiBmhSank2J1JMXVVrJKRHAQ6a/jmxvqNY+0nyS6IM9AmD6K21rcRCubjZrovpS0uYKCoK5cv+AIuRV19GkZctEzOVtcpdtySxmL7ujnmd02hpqI7hR0uQeA2vCu6MqPoXA5TqjckiaN6Co2BXeGrNZeK/ycl9/f6EMNwKg2EmmI5KnNT5FWmMabu95k3qF5ngzxppxN7Cncg16lJ8IYQZg+jBBdCAkmkQVZd6jKY4Ae7ud9wCy8fCFtFLdj1Ko8mSu1Qi24UPmiLOvwS/CIPKurc9ms11GQ9SozV3RgoeYZws2ZABisLi/gelm6M6VeQGRS7h/eCodsZnX2T/yevYhQk5Y4SWShs+UwMku8DSsYQzyNLACt/bxcRQCD2kCZpcxnIvbCxPbcMzQFpyyTXXb+IrCyLPPZxgw+3XDyrMuerhKuHW7+bbVN3DcP93jYR/AaINsuzsdpfsKQ+A7bMwtZcHgBr+94HVlRi14RSE1YkrD0M4Sy5tRvOAEzUBmShMVhIdHQkVsqC3nQuNyTJWkO7gCx0mz3+Ab/k8qLe06VseZgAXqNkifHtmPGx1t5b+1x2kinxAK7v0IviwBJBaAxeXynObBI6Os57BRWmVFoClic5nVRkWWZD/d+SNbUj2D82w03bgwFlY6teU66vbCGbi/8xoBX13KyqLrBotUWe8Mss0IJbmkkF37alS2C7LFvwtCn2PrYUNbcN5AXJ3XwGWtjg/TYnbLHfSXQoKbaYsf5D87+dU8MIspfR6QxkvYh7dETS4tQI5IksWxfHjd/s4tQk5ZNx8Uko6LOxuk1H/BtURrPVRzk5C83+Ahjm7TifHQ4Q2bLHeyplQrxzxX0n+lgA3DrINEY1KT49CWC1e7kyUX7fTiHTqfMc0sPcrywiqs+3ca1X+y4KMYEe1xNFPO3n7rgdV0MuJMwdqeMxe7wBH9hfloq6mzszxbjzBW9xFi9P7eSBxeeu7XrPzb4c8pO9Co9dfY6/NQmNuZs9A4KG98SJu0gmixs9R487szOtUth5vwGg4YbH/55iOc3vQUIgnOVq7O0U3gnbGGpxNodvGdbQYdj86C2FFmWSStKA6CopkBkHre8B+teEV2dbccBEmM6iFmvSiERaFDz7TZxISnq3VAJ/gn8Pv13+kQNIBDxAE6Rs7CeEHZHzlPb0OTt4jdnVwZZ3qTSacNf489T3cX++jmdVOuiyCypYW92BUaNks+v7dHwII/+Cssf8JSi3VCYy7ABdl0IR3u8wIslgwCJEKOG5yakcudlKWf9fc4H7kaBLuGd6RwXSFRA02Xak5f/TGG3+wGojh1EUcdbkVxBzZkZLoAXlh1kwnsNHVbccGeQ9Sq9EPs9uLjJBqCTFSc90i17i/byZ7bgl5VZvJng01WnWZWxig/SPkCSJKxOK1nVgv9k0nv3K8zkDUhaB7dmx4F4jhdWewSZkfAKFwO2oFbYXcelrslludHA0iDxurviKMFfDQSFEoVZZJTrc++8QbFY/nhhNf/9/Rhto/wJ1okmkCp7JXcOSeb69hKySo9/aHSDGNhdzlYpVLQMFvsW5soABrqyzvUDxG4JwXRLCCIqQEdexfkFf7Is0+vF33l+2UHeXXu8cSFeFwpqClhxUjS4aJQiE19trfbsz5nyMxan90Gh1OewJzuPudvmsr9EcKKiDUlUOszCYeKhExSnjCPGKjOvJArrZY/RP6Y/Q6Jm0L0skhF+mdxwDtp3bhut0horuS5+XVntPyf4+27bKZ5YJI7fqFVipI6o8j2kKr1BnEOS6BTYigmdboQHT4hmtOoiodWX/iMsn0PXoMMYW77FziyvDVu1rZr30t7jhW1zcdbvwnajzx3wRAE7Tosx1l12dXelLth+inZPraL7C7+R+vSvTP5gM52eXd1wPfXw0srDIsPR4wYYIMaL5HA/OsYGolaK+1shQUygHn+dytOteuf8Pcz6ZCvzd/wzHvD1UVxtoeVjKxjTIYprXZyulKAUbMo8csrqWH+0iPJaG346led6AwgxamiR3I72VivbKWdW+VY+WHI14xeN57Y1t+HUHSY1Ts3I9pFNbRoApbLxzB/g4WdeKgcYm8PJ3fP3sL2ezRzAzqxSvtmaxUP1gpq8SjOfb8rgms+2c6urW/1kUQ0XCvcY5vY0/p+GSqngU5cF5c7MMoKNGm7s34JeroTShuOiQjG8XQSvTe2IRnl+LjX/2OCvVVArPtsvlN3H6mOpslVR6tagGv4c3LUTrlwIthqhC3Um9EHsDYlh/uH5zDs4j7TCNM9Hsizz9uG7OVq5m37R/Xig+wO8n/Y+34z4ibEJUzCmjmVemyEMTmpLzNF3qcvZT/9HvyK7VFxg0o5PhcXOr4/B4aXgdFKbd4Qd2lsZrxaCr7P7JvLng0OaPcZgo4bvw+9mo6M90VIJBpeziCL9ewA2ODpSookFhRl/jT/h/ga+CJzN7IoqIuJbMaFzNN0TgrhvRGtPat8HhYdgxyew+kmfY5+VdgtdW8TzQfkGDuZWcKSgimCDxsMNuViwOWy8vVtkArZfuZ1pybNZsP3UOXeO1YV1Ir/nYzj0IYDQwgPfDJfdKTeaQRCfiSzCHZ3vELZoVXng1/SNvSNvB+/vFcLdeTV5tA1uy/CE4UQbfQWkP9//OZ+mfwpAlbVKfF4+iKK8zp5l/OvxMiYtnoQh8T2CjRqvG4fTARHtPcuoUXiOzxzcBpskoa5n0Scl9ofglvSsq+XzkZ/7iDwrznD4KK2x8ufRIjYdL+bpzqKr1+l0kBBiRBkYh9R2HL8/MISxHX3PxeSUyTzZ+0m+G/Md9hCx/tmtprNu+joMbo1FV6PJ8cIqVqbnYbY5iPTXk38e+lIARdUWCqssTOwcTXmtjZ92N2xOciO9OJ2dBSKjXmWtwuF0eDJ/c9bN8WgzuhEX4jus7S7e7PM6KTCGSmulZxJQXleD06kjvuYAYbpgPhj2ASOTBlAa2wlF8QERBJ0FCSEGOsYGYLE7PJIwlWYbq/bnk/jIck+X5v8U8irMRAaICYlKgqXaJ/lR+xwzA9JF1zlQHRSPyRAmxle1Djb/F15PFlIiALu/JnvNzQCobevh+RA4vga/kgySZRVb87bS6etOnrL5mTjzwV5RZ+NQXiWP/JxOrdXhaULYc6r8rF2LFrvDR4x43tYsEh9ZzuH8SiRJIvPlsSy+oz99W4by7Y29MWpVPkHNlhMXSc/wIsJid3qoNwBP/vk6i44vosZehl2qZIfL1STQoCba9VvOnZRK55QK3inewe9GA/E2O7UKBe9X7COjIoONORtZW/Eit446+/XXt6UYZxNDGwbwBo0SP50K2yXKmKoUEkv25vLl5jPu5SAx7tSfXFa4JlUpEX6ebObRAl9ZsL+CE0XVBBnUTDuDepBdVsvOzNILynqmZ1ecW/PqGeibHIJaKbH6QD6H8qp4fGxberiCv4W7sgkxavh8YwYHcitJChPVoMYyt43hogR/kiSNkiTpiCRJxyVJeqSRz7WSJH3v+nybJEmJZ1unWqEmzJW1GOASX83a8b4YiCVJDFgpw+GW9dBicKPreHPnm7y47UVe2fEKL2x9ge+2ncJsc5BXYUaSxECjUZh4d8+7zDs0j2FvL6bn3LVgDOELZRUlcg2lCiWqwnQ26e5h/MkSOoZ2pNuxP4Wd1ODHhF+oQkGeWUOYVEn26Uy+cenY+etUaFUKbhrQMHPw8PqH2Vj4Ez/fMZCjxBMllRBRvsvzuYxEAUF8fE03VGoR/P2evZwvlGkYUkbxxMyhTOoSy0Oj2jSdmeh/L/S8Gba+J4zvxW+BzqWXt6x8iydonNpNZEhvm7eLm7/eebaf55xwvPw4n6R/wsnyk+DU0Pm533jk53RPWexcINnNaMuE7qA7w2Wvl/kLNmqoMtsbnZGqFCr2XrOXmzuKBxaVeeDftBNIfQ27NsFt+OHyH3hl4Cu8Nug11kxdwzejhTZecV0xWpUo697Z+U7eHPwm6soJIIv9u7p3gk9n6PHy4yj1pxnbIYoEf8FPDNAG+AR/9xTl8sVg8RtVxQ+jyi8RtSxT6N+BUy2mw/SvwRiKsraUHpG+WV6lpOTJru8yMGq067jFtr/YnMne05VISNhlOzlldfRf35a5uvsaPf6bO97M9NbTaRvSltTEy2gb3JYBSWMI0Yd4jtd9jpbvy+e2b3djdzqI9NdSUGXxlLzPBe4JwITOMbSJ9GPRnsZ1zQD6xfRjcOxgpqRMYe30tSgkhY/GosXu24XokB0E67x8soLqchL9XfeIU8VNna/mxf4vej63Os0Uamy8HKKlKEdM3ooce3lYu5ljKgW71jev5QmQFGZiyZ396dUihOV3DeCeoSm0CDVyIFdc627e4UVBRQ4sfwDb4ZUsOLyAa1Zec9YHS25FHdGBrmz0kRUkSYIXZKg+JbQQnyzBQmc25W7itW2vwVupODa/I2gzY9+AaV9B79v5PeEyAMZW1wiNzHlTqP14IMk13nvabZMH8PaGjcxZsFs8QLN8JWRKa6ysP1pEkEGNQlNIQKuXUOpP0iZSNKU118VvsTvRqhU4ZdEY4Q4WF+4Ukwi7w+lzTq7pk8DX1/fk+n6JhBg1dE/452n+WVwqCw//lM5LKw6x8OA6ZIeBW1LnYFBrKKu1Ul5rJVCv4YpeYhwJ1Gu4/tcb+fjwN8yNa023awT//K4zEvH3L9zJhmNFzW5fq1Ly8219mdK1YbVsctdY0p8ZScwZzXX7ssv5YefpBsufC7acKOHydzZSabYhSRLto/0pqrLw/Y5TnrEkLtjAbYNbkllS6+med0+kbh3Ukj8OC8rW8cLGEwDngxv6J/HWjM4efqgbi9NymfrhlrN20j65aD8vrjjUoMu/sNLMzd/sZHl63nkFgPO3n2L0fzfw6Oi2lNfZuHXeLpbszfXwyVUKiandYknPqeDn3dkE6NX0kg4RYzy3bVxw8CdJkhJ4DxgNtANmSZJ0hnkrNwBlsiwnA28Br5zLuhd0uJuFOXkkJgttuqy98+DleNjzreckHlUkMeH9zT5t6BaHBVmW+XTkp7QKEmK6bQK78Ngv6bz521FMOhWdFS9hzp/Ayh1G1mWvo39Mf6qrg7E6nOzILKW8xn0CJdRHlgJwk3kjvWw3o9f4IY9/h7SWt5BbYeZoQRVHq9Q4ZQlqinnt1yMMem0ti9NyifDXNWqNc6DkAKsyVpH969N0lY5glCwY7KW8HZjEHq2Gn/39SWm9k3A/HZWWSvw0fmzJ2cn6kr2kDX3atzmiOQx/XpQXl92HZDejsFSgqKcn1z46gHdndeFylz1apdlGSc3FyVK4y2xtgtugqpeSbqrbtzFEbX2GlksngdNGsDaM//T9gd7h3oyq2+JmRXqe5z2LwyIyVMd/R/rhGuZufpY3d70pOmWbyfzVF3Z2y7eoFWr8NH5EGCOI9YtlWqtpIhhyNQrd0ukW/rOiDrvDyYzucVzbN5F+ySGNrj+nvM7j6xyiDxHi0vFCJkVRj0unsFRgUypRyWBNGET87E8Ep3XggzDzuwbrlSSJtkGdPSLe3pmfk9Ulc5GRccoODrnkZ4qrrXyw7gST3vctl1daKz0lVH+NPz9c/oPHGSVQG8i4pHFEGcX5O11WS4S/llG/XMZx+Utm9og7L96NW24kLljP+M7R7D5V3mhGWJZlimqLeGvIWzzT9xlC9KKpqVVwK7qECz5v/VI0wK6jARjzX2DPVaLrbXTHIH4c9wsPdn+QWzreStuQtj6WjDqNA6dCYpGficmbHmTEwhFoFeL3zVKYiD35wzkfl1Ih0S7anznDW/HH/YOZ2EXwW3PPYuN4zrDWwk83wI5P2PjrPczdNpc9hXuazLaBOId55WYv3WL/T5TjzzJpEBkjv0Ye8AAb8rYQ4ZiMvTaRL3avo0OwROcW8RSa2ooHcfuJMOoldhYFEVcez2f299l1y28s9DMyJzyUVSZvtqi4rpi5yw/yzJoFfHLyNjZXfMSv+/ORZZEhdcPulHH6beTZK2xMumw/ZrkMTdhvHteU/Io6CivNnCyq5vVfjwjek6UCp9OJXZFPpTODR9Y/wqzls/DTi2veXWpPfnwl4+vRQRSShJ9OzaQusXx5XU9PWfWfBLPNNYFV1PJ78TuoDFkoa7vy+o8R1ClPkla1kHJX5s8dAL2++ghWmzj2a1KvJyU0Fb2k4rCzltf6PMsHw0SziBMrZ5ubnS6t5YtNGQ2Cn6ZgsTsY/+4mHlq4j1MlTWfHZVnmYG6lZ9J/oqia0horZpuD9JwKXlt1hGeXHsBfp2ZHZhkP/5TOj66AcldWGT1djUHuJkqLw0mwUYOfTsW8rUJg/mLwa5PDTew5VU6PuWt8snzpLm7dyysPN/nd7LJavtmaxcfrT/LeWl8ZpBCTFptD5s7v9jDm7Y0ezc2zIbO4hrwKM9f2TfQc+z0L0ggxapjaLZb/zuzCA6OSqbCWUGm2o607SquY95gb8/VZ1ixwMep8PYHjsiyfBJAkaQEwAThYb5kJwDOuvxcC70qSJMnNhMEWu5PA7HTCbQ7qkobR6eAXmAr2gdNGjiaRG/67gdendQJk9uXl8tvBfGb2FLOhj/d9zMKjC1kzdQ0/jPuBDceKSAzxI+vYfn7encMtQ6J5fnICOB5h1NePAdAtvDsrETyRyjoblQV90UUuRq8KglNerbldGcV0rHiTL4O6M6Xe4OKnVTHCEMzQCAUvHLZTabYjSXCqtJZTpbUeWxY3RiSM4NP0T/mhei+95BB2a3rwWkI0++17+CRIcDNa+Kcx/t2NXDPwZqZ0i+XRP4RTRXrhYTpHtD23X0etEz6nX11OxK7XCT78LZWxIji5J/U5vjv2PpfFjAeXEbpKocDu4vJY7U5Ka6yectG5Iq+iDrtUxju73yFKn8DGQzJX9VZwfb8WfL4pwycQPBuqYwcTcvg7jAW7qInqTbjeN3PnFt699/s0UmP8SQ73Y/D3g5mYMJJbf/8vbwYH8rM5jZ4RPYT+WHOZP7sZtULNDR1uoEdEQw6l1WLkkR5P8NTmxyirq2T3qTK6xgeRW15Ht4QgXpnasdH1jkgYwYqDx/jjVCEvT+/Lx8M/FpkplR6uX0nd273ZZi9g8YHnuSXlXtrP74kqxIRaoaBWHUhueZ2Qswltmou5OX8NEYYYWvq39Qn+TplFNjnamICpsoZ92hv5seguMrXjyXB1EldYKnhq01P8cfoPbul4C3d2uRMQMgPXfbmDlfcMINQUzEsDhKCuLMuUVFsIDCgn11LB1qKV7L3mZcw2B1klNSSENML7Qjws1AoFCoXkCfRigwyMSY3iUF6VR4rj1wP5BOrV9EoKocxSxthfxtIn8DqeuWwmPx//mfEtxxOiC+G+bvdx9cqrqbbW8cKygyTEH+W7Yx/RQ/Uy2WW1qJQqDCoDUUEyWpWCa9pfA0B+TT7pxen0je6LUW3ks5GfYXfambttLiszVlJuKcdiFdmnd+WRvNTvLhp3WvXFM0sOsCI9j7uHpjCpSwxGrcrzIM1s5uF4zpBl+HIMjtw9HB7+FFvsRZAp9EG35W9jXNI4CirN/Hh4KaWOQ0xInkCnsE5U1Nkw2YoxODLJLFaQOOgh0g2XceeGYCZmRTMg5Dee2fIMSaqJ4NCjMHofXlcejSBq0Vw+vPw+9Co9tXljOWh1kByfww2rn8ERKsaSYG04Zkc1tfZa1mXuYeG+bVyWqkZ26KjVbSa77gifze7Oz7tzyCqpZVTvbDZVvMv76XB3l7u5v/v9KCQlqzJXkl76Ncak43yensF3a2IwhG6jtqgvWaWVFJreQK8IRhd9klUlxdiLReD/bC8t4X5arnOJ3p4NTqeMJNGsduPFwKbjxSh1uTjMUfRLFo1jRbVFBGoDUSsFb+94ocgKu4MjSXJQIG8AoLKgN0hWDHFfkuWEO3u3wV8d7MmKZhTXoNfH0ja4Pdemius7UhfMb7Kd15w6LKFiTJKUdVQ7CrE5A1BKSg9VpD6OFVazdF8eUQF6TzLAjf05FXyw7gQxQXraR/szoXMM3+8QAdptg1sSF6xnwfZTdIwNJD2nHLtTJiAsHatFx6It/qw/WoQkwe4nhjP0jT+RlNV8OfsykkKNfLM1C41KwRU949mafRilPotHF9fw87FF7M0pYGb7cfz5aCcWHvqF3NpUooIk/jOjM5M+WooiaD2jWw2kczsrkIrZZmd7wWZK6kqYmDwRSZLILqslKkCPUiFxMLeST7av4eo+iegcLXl/yx+UqX/FX25HoEFPvKEDDqfMpxsyOFVaw1Pj2rMvpwyV/x7mb3cSatJw77BW3DV/N1f1SsBfryY1JoAtJ0VWdXLfGq7qHcPRsqNkVWYxLH4Ycze/SWK8jtLjeo6WZ7L3dFtaRtl4cfuLTEqeRFphGp39phIa4GR/loJtmbnERxfw2Z7DBMVk88iGP1GElzAm+kq0UiB2qZLxfSroGduJmctmYko5QNWRp3j98Psc8DNxiBwGnMO1eTGCvxigft43GzjTs8yzjCzLdkmSKoAQwGe6KknSzcDNAJrIZCqzDxIa3BK1LoSde26lh2op1THRzPmmDJ1awZq87wjQ6TG1eoMX08PYfOJ17h6awle7/iQ8MBi1Uk1hlZmbvt5NVICeB0a25u75e5i7bgG/Fb7LyskrebjPDby6vZpUv9HAHu4f0ZqCSgu2sj7YyvogR77BH+ZE0lLupI/mBK8N7MOAd/by/a4cbh/ckp1ZZQxqFcbrq49QavAn3p7Fr6Zn2a3tQa8WQ/no6m4egd76uLvr3YLPUX0abat2RE58hlkFu3n9ZwORgWuZkDKZ6QNeIGXbKgxSLClBKVjqxCOoVWjTAUyjaDEQZsyj1BmHpjKTNpZ9HNJqsDltLDv1HQHaYMbGzwSEcLJby2vOD2ks35fHiRfHeAKK/HrcocZgdzjp89IftG+/iQq5guzj1/HE7oOMaBdFhL+WJ8e1o5/LreJcUB3dH6dCg9+pNZRHdGXFqe9pH9SV5ABRMk0MNRJi1FBSY/XM+g0qA7XFR6hUSPzsJ3gQlbYqGPVfj52aG8fLjhPrF4tOpaPOXodepeeOznc02I+yGit9X/6DCH8NFf4ZKDR2Jr+/mcyXx1JQaaZjbECD77jxxuA36OOXTdwoPeGGkAYSMU6VgSxnFRvzf+VOv94o7HW81PJG6kpOMHVzOLMDcrllUEsoyxLC5UqNsDG8aqFnHZ8dfpXB0eNo6d/WK57rsoiblXwbA6NGo1AdwF+qZVz3JD4pVnhK5T8e/ZE/Tgs5Aa1Sy70L9pAaE8DB3EqKqiysPlDA0LbhqDW1XL3iavJr8gmtm4PZuA6AZROXYbU7uOz1deRWmMl4aUyDh6rDKdP6iVVc2zeRZ8a3JyXCxMwecejUShJDjbwzyzs5uuUbEbBmvjyWrEoxs/99n0xL00HmZX/E7sLdlNaV8uIAUbo9XFDKpxsr0UasQBOcjUPxMcrofCyOwZjUJlae/I1vD82nm/pxPps5lZzqHO5bdx8PdH+AUYmjOFZ+jP4x/Znbfy4mtYlqWzUJ/pHIssRpvZ7UtmcWMhqH3emksMrCE4v20yU+kGeXHvTw3E6VnBsh/Uh+FQfzKpjUJZbSGisGjRKdWimClbIMpNw9/NnnBu45/iUA/SJ6sqlgO49ueBRH7mlWZ3bhT8sbSKoaducf4LueT1Gw73NaJC3jy3INaUve55bhb9Nz1HT8tq8jwKDgjV1vAHDSvgiVn+/+ZEfsIr8qk0c3FDEwZiR1itM8NKY3h+2/khx4A0v3lJFVVkqNbQCjBuxl8YlfWH1qKfroKiz2SdSeugFD4vsszHuIEtUQXpryBq9M7cjru14AV6U4yhRFtCma2zvfxqrMlWiCxaR6fcFCNMHdUIauxmDaxbq6KrDWUJczg1kdr+aA4w3yanJYMXkFQbogtj/eeHPfmVhzqIApH25myyOXUWm2U2Oxk1qvE/a+79NYsT+Pw8+Pxu5wMn/HafRqpSjDpUaikCReX32En27rS9so0Xi1+PhiOoZ19Do+Icra1//wFZqYL6nLncaS2ffSKtLAZT9expjEMbwySBTAhr253vOdCH81NaFfonO0pKa0PbItFBRmZFsIkrqEd9PFNb/vmn1seuQyvtyUwScbbuSL6726pV8O/ZC8dS+gXDALXeo0ALRha/g2dw3f5kK7wC480e2dBuel2iLGz9xGmrdKa6wsr1ddcQd/qTH+PDyqDTaHk3fWHkQdvInsAj96peax77AQ0HfkzmFI61TWHiliy8kSJHUpxhZv8+qeVSjjygk1RtIrrg3hwQZMLcW16LQGc8heiiYCIoOHcfNvN5Bb45UwaenfGnVsKUptERurt7BxMzjN8Ty0aB2G+C8BkFDx+tqNFFbVcW+P2eTJa1l0YCey4SBrVsnc1/lJ1pW9i6Quw2k7gEJd7qJEPcUrv6aDLFFZZ6fQuQ19zPckx/rxwToltw9OZsX+U/xR8l+k8mG06bSI0koF/v7j+a3sNYIOHuGHo6Ja8Pu03/nxhNif6ORkksNCiQu+liXph1h3ep1Hugq+QOkIpfzYPRhjv0dh3o8+VigQbM0LYk6vOQyJ60ygLpAfj/7IL8d+YWDsQPrH9OdAyQHGDtrN+vxTtLFYCYpv1eD3awwXl+F/gZBl+WPgYwBtVIq8v6AOkxRGbLUVM1resk8mSPoBpSmYMT0dfHbgG+93VUUsSc9gyd4cTK0yqaoQOmcLtp9GNu6hJOg3nlh8Hyq/g/xWKEjwkcZIOkQZsORPwWpTs/fpEdRa7fR56Q9PELQ5eQ6Pb7JxU3hb+gwXSvVDWuex9WQp6x/ylh97JwUTfHgcyuBEWtd9SOvwCgjQERnQdIeVSW2kGgeHAizc8ssoVk1aR1GpmcdTemNWd2Lga+sAkYHberKE9P3d6NO+pU/J6pzR9nKs2RVkD/4vs37qzim1ivcPPg/A4KixnsVUCoWHb+HW8qqx2vHXqVmclsM9C9L46bY+dEsIbrgNvGWXzAIls/pP49ODItDJKq3lpZWH+eaGnj6dz2eDU2OiLrQDxvztJP0wiO/DlFwTM80T/LWN8ueL63ow/t1NVNbZWHFyBYV1hZTqwrC2mwBVO1E4FZSaS8E/GqvdSXpWKd0SgrE5bExaMokYUwyrpqzilo63kKwbyfJ9eQ2aIbRqBUh2amMewVk0DEXRFYAo5RZXW4nwbz476uZUNnWMKkcBqMB0YjFOpZagwY/x4ZoscjlJlJtnk78Plt0Loa2FfZa5EhAPH6Wk8nAhW0X48dS4djy3QnRTumf5els5ABERMWjKRfBXZ3X4yF5olBoWpeWyKC2X727qxc97cnhp5SGeWZqONkXQeVNDUskocFJjFA1KkaZI+n92M0Xmvoxo18kT+OWW17EoLYetJ0uZ4SJRf7k5k2fGt2dUahSjUn3PcY3F7plktI7w40h+FV/vFhw8pzWMD9fmY0qBHfk76BLehUhjJPd2vRdrRThQyvj4m/i9did5zvWgkdAoNDzR+wnuX/ojsqkAm02PQiHRLaIbA2IG8PrO13l95+sAvDboNUYljvIIsAO0CuiExf8Yit1fcVwJhE1q9jcWXqqii9Rfp/YEflEBOo89H4gS0YsrDjEqNYoj+ZXcOSTFo335/LKDbDxezLC2EfxnzWG+3nKKCZ1j0CgV7Dlykm8Hv0b/1MvouqOEfUUHKD09kWGKvRjqSuiz9nEOmiKQglV019/Eul2h2DKuQ1d7gpCE1uCsIk0pc9sfd9EmKBVbKFiUU6myVvFMn2d4ZsszyLISSfJOVlWGTAD+OP0HG3M2ow7oTNvwSdzeRjRy3d0VvtyUwTNLDzJvWS9GdunCtvLvUGhP8+e2HoACrNGgzWHt6bX469RkFNeQU+md9w+IEXmKBP8ERsdexcrsefQJH8nA0Gt5Lu9jAJQ6ob1WlzsNe2UXpnVuy5NR31FprSRIF8T0pdNJ9E9kROII+sX048vrejTZhGTSqrDanZwuq2Oiq3qT+bJ3DDyYV4nZ5mTAq3+gkCSySmoJ0KupqLOxqx5v8dcD+Z7g74lNT6BValk5YZOHk1VUZcEhiayeQlPMqdJaEsLE77w8YyVtTMO5rtsw/HQqNEoFJTVWnpwUwaPbc7AUz6K2WDhK4dRxd4/ZvJP2JhIKRsSP4UjZEU5XnWaz5b9sePQTn+7f4JAUgrvfCumLUOz/keev+oonN3mb/g6WNy4C7JYrivBrOJa5RbjdOFpQxYHcSp4dL8bhtKJdlPt/gEJzEn0c7KtH6+7UeS2yciP6ShXv71+O7BhG99Ch7CpbjkFlwGI4Tq8WfSip2+v5jkJTSoKhEwfSxtNveGveP+oN/GSnmhOVR3BL9Lrx0C8bQFIim+PR6qp4Z/e7FFuCUPvn8+GB15EN+3FqTaQGDODJAbexIWcDkroMpSUZWRJlVaVCQq+vQBP/DjX5o9iWYQQX13xAQkf2HKylrNbKmF6lbKjYg8Gg5Hi54KR3a2lllxlOl1d69unZVWJSbVKGEROoIa/mFEv35vL66gqMKUYUKjEpNDo6UJzXEWQlCtN+z/cf6P4A17S7BkmSuGrFVYTqQ0kKSCK9OJ1jZceY2WYmH+37iFzzYUYog3m1pgTl4Lca/X3PxMVo+MgB6rfHxLrea3QZSZJUQABw1naraytu5gbLHOpsDvRxn5PU+SPs+jT8QnfxW54I/Jw2Pxx1MYwJfJP4Dh9gSHoLSWnhnv4iMJvdJ5GZPWNRaEq4d1Q4uihvtkSlUBFsFBd8Wa2VAL3aI2I6vJ3Ish1RJlMnawk2eG+u5HATp0pr2Xu63MMN6JYQjHLkC6IzLqQllJxdu+yFLnO4o7yCcoUEsoI+czdRh47CqCEUOgM8lkyfb8pg5sdbAQXdI3qedb3Nwak20mngp0xoe7/nvfpZmp4tghncWpQnWkWINIBbhmPZPjHzy2umszPIdZ6Gx07mid5PMKytCP7cZYrz4fu5YdeHois7gr5GXFaWegLEAH6uQctRfNzTFeo0hmAdJLQh7bZgysxlyLLM66uPMOWDLRzOrySrQgwoOdU5WBwWQvQhPDQ/nzu+83VmeHnlYZ5fdpBQkwFkCXByfV8hhbJqv3goRZ4l+GsOpa2vwBolDO+NGcuoTBzNT5krWX5yJVBPM9DgCiCKhZk9Fm8TgVKh8ugEghAXf2CE0B/89ti7fHP0HVTubnljKBqVArtTpu1Tq1i8x/sg1ig1dIgJYEjrMLrGi/MsGmq8+zt/3HzmXzuFp3u+wQfDPuBk+UlqNdtRaIoZ1s5bIF25P59XVx1h/dEivtsuMnj/mdEZWZapPIP38uCPexny+jo2HhP7cvuQltzx3W5WHN6NWqHl4FMzaRMWR6CzJx1DO/Jc3+cI1gVzQ4cbqKoOQqWQuW1oGF0jhFOOEr1wgIkfQlWNyP5e18tbln+wx4M+2//6QEOezCO97+KRng+zZcc7XLnvLY+jSFOY2jWWt2Z04o1pnQj313oeyG/P6sL0Ht4h8qM/T7IiPZ+75+/hvbUnmP7RFg9pXqGQiAvWo1XLLCm9C4Uul8VpuSxKy+F4tYYnT3VFE5rMzSlvUHboCU4W6Lli8HKKc2ezutUtfBeswuSQ0WUokO0BVPW4B0XYUAbEvse0lOmefThcth+1/372VC9AJalIDU0FwF7lpZPYq1OQHAHc0UGcK6vTjOzUkVNex8yPt3g6LKd2j6NtlD+z+yTwa5oCuzqTQDoytVs8X1/fk8CKu7CW9Ecl6dlwrIghr68jLTebcH04bwx6QzQ/ITQ5TYgu872HUnjipyxs5V76xeSkK7FXdOOpce3YfKKErGILoXpxT5RZyliZuZI56+YwftF4eiQZaR/deDY+ylW5yCyuoVsjjR/jO4vKyunSOo8+YP0OWD+PaLL4fd3XRUe/8fSYu8bj7lNSY8FRK47HaQ2hpMaCUW1ErzQhSTJv7p/DyE/+S610zPMcqXKI6yBC5xWu7xATgL9WTABlnGzO28i0pdO4b919nKrKYuKScazJ8tpUApDQB9pNBLWBiUnjmZIypdFzUR+DWoXx8Kg2DUq+gI8Vn1IhERuk5+fb+3o4rfMPz0dh8H3mKSQFWqWWkxVH2VW4A1XgFkL9IVBn4ub2D7B2+lqWT17ON6O/4Zr21zCn+92smeo9DpOzHUZVAKmRUWyYIcrgrQzDqD7yLMgSDrM3sXJN8oMotMV0SHAyKvhFqOxDoTkXtf8BFJoSaks7UJcznZpjj/LRyLdIDU0lRBfClJQpLJ36LW+6Aqb+Mf2Jj8tEIZsIi96DUavkrmHi3q1TZKAJ+5VPNx2ke5z4fTrHhDNvjPBPD40Q43In/3E4zJHITqXn+fBYz6cJ04cRoA2gQ2wgIOG0iLFyXNT9DPB7GIc5GlPrpwGYljKTBP8Eekf1RpIkdubvZG/RXqKMUXSLEO47k5dMJlQfSqg+lHYh7XijzWyUIPoizgEXI/jbAaRIktRCkiQNMBM4sz1uCTDb9fdU4I/m+H4gCLoggoZAvZqYECdFFvEAaaMRq1KiQ7YHEqPpwysThlNmLUCpFbX3UIPgogQY1IxvLwa0VjF27mr9Aeb8CcyKfw4QnKNFd/QjNsjAyysPE+an5YtrezB3YgfAq2gfVM/UPT5YkJYnvLfJR2Hbg+CWQsC3ntBmY+ioDSHJqaRCqUSn9AOXU8GTi/ZzKE/MHowaJbVWB4khBl6e3MEjtnkhqInuR1W7axkZOxWADw7M9Xx2ff8WPDpGnK/NLpsfd/B380BB/q8vonomlAqJ4NBM3E5C949ozX9ndvZ0sjX33aZQ1PlO8rs9iMp1xThkB5LDS0r216mIppjS7dP58eiPANSZyz22Xw5LFG2C2mJxWDydsBF+Ov48KWzZHFUdKa0r5YcjP6Dy20991FkdfPjnCeZvP01xlRVZVqEJXcu+StFVd6ygilk94+iXfO6l7DNR2WK0x8e3MGUi2QNe4fsj3xMVI8TEW7pa+Ak846auH/xJSo8ETlGVhXfXHseoVRFtEINUnb0aldkV/BlCaRFqZFCrMKIDdCTrRrFistDR0yq16F3X3IkzJHTuTn2OFZPEci1CjUxtO4L+Mf09IssBBpn1R4s8wuMZxd7vbzpeQq8WwUzsEkNpjZWOz6z2dMUDnsaoG12d5tUWO8cLq1Hoc4jQJqFXa3hjWhfmT3yHb8d+S2JAIg6ng9OVpymoKSMmzMyExZdzoFCsU6EQF8uxsmO0TDyJAg1DWnmzry0CWvBA9weYlCyyeWdqBQL0jOrJgNgBVIYkUouTU9WN+926oVBITOoSy5RusWhVSnY9MYw/7h9Ej8RgCqvMnvsoqN5EskdiEObiLFbtFWNbRa2VFqEm0rLzcChK6deuGnXgVsLavs4DSRmcLv+Rh9Y/xGe7l4CsxmxzUFjj5FdnD7oPepT7W89n4bTVJHcRFl83745nQMZsnvwtj+EJw3mk5yP4qb213Zb+7flq9FeszhK6eld27o+5YCyO2gSuaDObu7vdjJYIEnRi0nlVz9YEGTRsPVnKiLfW88n6k5i0KlbeM4AZPeLRhP6OpDQTq+7L69M6MbBVGEoMyLIah2xhZ2YJ2vAVmBUZdInowohEX5vF+euV1J2+mgBFS1QBu1AH7CJRmsGo+Aks3Siuf7PdwcsrD3Mwz5thMaq8wVl+TX7jrlAuRAfqUSkkjhZU0SrCz5Opc6O02ju2xLiW3Xu63PPe27O6IEnerlO3PuaGI+K6zy6r5bZ5u7j6s+3IDnFv6LU2D/1HJXm3l6v5FEPiR1S6dCsr7GKCfVtfMRl8alw75gxPIc7QFkuhaHyssnn3BYS9oVun1gdJg8FWy4ENL3LN2neYHDMFf3UQEfrGqxCSJNE/ObRRqRC3rM6tg1ry+bU9MGhUdI0P8kxwHuv1GFpzF8z5E5DNIiDcedVOdl61k/ah7QnWBXNV26v4YOQbpD01gr4tQz2BS+fwzp7tRBgjuKnDTQDsOGKk2mJHoZAI1AVyfer19IxpDygILn6F4f4voy4RPMcxrbuRlHgMXVAaBZVmwlRdaR/iVVMIjFnLd7Pu4Kvr+xBocNngtZ7OM32fIS7YQHiAeFavPbUWp2kTfaL6Uyedpk9SCKH+YixZcPIttKFr+bH4Wr489C4SEhptrRgzVXp+OyXuoQkdWqGxdsRaOgjZ4UeAow/JIeHkVOfgr/H3yNM4LZHITg1XtJ9AqJ8W2RaItbQv5vxxqCsmsmzSMloHtwbgw73C971NcBvP+eoeITQAU0NThcxX9+thymci6D8HXHDZ18XhuxP4FVACn8uyfECSpOeAnbIsLwE+A76RJOk4UIoIEJuFRuHkB82zvGefiE49krjAYAoKQCWpmX/dCA6WLOCbTcUsOFRNcicTXx/4mqSAJIrqipjVZhY/b7Px4/rd9GwRTI8UUaK8bc1tvNH9N2xlfRiT3A8QmajOcYEs3ZvLh3+eYErXGIa0CcfplHljWidqbQ5+3p3jY6DcNSHQ83dIvaDQ+2YS2OuErlxA024W6SoFeVd9Q0XGCvQKX7JNbkUdkgRX9k7g4/Un6RIfxMye5xbRnytmt76X0zUnGwwmbrgzfdUWMWgFum70OlvTXZ13/vYQtrBVSEFWoAuVdTYSQ4wekVWd+vznG3VhnVBaylECEhKq0oO02dyTI9PXAwH469U8G/Iby/VioJ1slul8dBPOLmZkhxZbWR/enH0Ng38YTHv1zQToYxn3zkYK5C3oo8FZ1YURP4mHkDqgDfaqVJbtyyU53NRQPNSpRlLZ2FGwEUjm7qEpzXoLnwuU5jIisn4n0Ah53R8iXKXH5rSRGGjix3rlKAJi4K7dsO8H+PNlEfy5Nl2/7GuxO9iWUYpJq+L1Yd9yz6Zp2GU7Fv9EyltOJNAQzITOSiZ0jmHCuxspr7VRYalgYvJE2oW0Y3uGsM87U+k+Ttsbu9Wf3w8VcKKomlHto4gPMQgBbWBGz0jeX5rHzB7xJIQYySz2lstuGtCC0R2i2H2qzKfZw41eScG8K6xl6Z4QxJurRWBuLb6Mo8VObv92F+9f6es3W2uvZcwvY3ig+wOM7Z7APeug6HR/9NE/EWEUk78P935ITt0RkgOTUSh8r73Z7cUkMjU0tVkqRafwbpB1lOMlO2jh1/qsTQJFtUWUW8pJCUohKczEwdxKxry9gRHtIrh1YCItcxYTRjRFBHFd9zDGLBtNfk4EOA5SXG0lzE/LjE82YkqB+Mgq0uoWUeWAK/OfZH5UEiszrEQra4HR1NkcFFaJTHyYScu1vUUG70i+CKLdAdKPt/aha0wQerWOKps3UOgV24aOYSIj+vG+j+ka3pXPShMJsA4jVtcSVa3Ek4sPICmHY2q1HTV62kZ5x6pWkd6//fUqZLsJBUo+njrL836QQUNerQYZJ1q1E5X/PpCcnqxdffx482X8fiiVijobWSdOoQnaRn7+g7w0dAI//rqRni2CPRp99eWdjGeIS9fZ64DGrTnVSgUtQo0cLahiV1ZZAzHuTzd6teZm9Ijjzd+O+nyeFGbk6XHtXBkcb7e5OmAXb4y8h6FtI7jhK3H+Vf7iuzf0bc+NvZPIq86jyl6CvboVKpN3vQp1OU5LJMXmAvw1/tRZxSR5bMcoIvx1WOyhWEsGo9DmEhWZ26C7u77jjwdxPaHHTdx/fD6dAwO4TduK4b1mN1zuHKBTK4kK0JFZXMOYDpGsPVxIrdXB0HZBFNUVEaILIcZ+C8Vl5aT4deW1sa2FixHw2YjPqLZVczTPxg1f7OWN6Z2aFfq/u+vd3N31btYfLfLx1Z7TbQ4AW9M2YdSoGNcpijZRk5jc4xqC9cG0j4jht6zfsJtfY4DfI6RG9+VAyQGijdE80/cZekY3TlXakruFt3e/zZO9n+T5rc8TZgygf2IKGwqtXNE3iE/r2aX1CBvIjqL1lDlOkGyKY93pdVRaKmkX0o6MigxqbbXMXDGNx/vMZ8mJpVzZvSWD469l0A99qbXX0iKhBcFGDR9e1Y1yhYMVmVbiQxWEmrQMVaTRJ2Uy76bZ+ejPTPy0Go/hQu/o3mzL30abwFYY1UYWjFtAnJ/ISF7R5gpOF+0XzmfxvcS/c8BF0fmTZXmFLMutZFluKcvyXNd7T7kCP2RZNsuyPE2W5WRZlnu6O4ObQ7hBQU/FEfRYyKuow2l3zaCUAUITKLQ9LYPEwSuUdby28zVOVZ3CqDZyV5e7yCs2sjw9j+eXHSTaFI1JbeKJXk94tKbcnrsAi9NyWLJX/MDuDJ9CITGlWyyTu8Sw+I5+dIzzlhCSw/2Y2i2WqABd4/y1sLYi+lY27wn6y/FfmLv9RcqtlRjOYFrnV5jRKBU8OLI1Cgnigi4swGgKfuoAqm3eGfQzSw4w4NU/PFI6LcOMtAgxIssyX27OZHi7CJ/B/0xsK9iArbIDQ6NmcO0X25nx8Vau+GSrJ4P6V8q+6sosAo//jENtRCkpsGqMqMylBGSK7Js6cx3Da5ZiDoilg9nCs3mnmRQ9gC7Rvag++iyO2iQOlx6nxlbD/tqFVNTZyCmvw1HdhtqsG1HavAG67BAByZ3f7WFlej5mm4N+ySHsfXoEq+cMRCmJ31SW1dw5JPmCAz+A0H0fcnlxFivsiZ5uZrvT7hk8fRDSEjpOh5huPh7FD3Z6hektxYxZIYEx+SU2FAmxcKWkxCk7qI4bwukhb3tkguwOJ3uzK9hUsIpZy2dhd9pJDvCShavNvmXOnHIzC3ac4oavdvLiisOcdGX23MGfQikyIG5P24x6ZbVwPx3+OhWT39/MPQvSAJHRlGWZh9c/TI7jd47NHc0LE1N578quvOrqnHbUtMJR0wadWklJtYVPN5wko7iGijobJwvFNWVxWKiwivtaMqfQUjvCUxpxPxRntJ7R5Pmf3nq6R3+xMURGdSXcbudIwTqu/GMAS0982uhyJXUlLD+5nMc3Ps70Zd4Sa0qE2IfVBwv4ft5HTMiayzbtnYRSQW+rEKCOdBbA3u+ocxZhCMhkYhdBl1iS4aWpXB+bgEonsu8Oh1ssXCavwoxKIRHkymjIsszqgwU++9YyzITNaePZLc8CkKjtR92RV7gmVZyXjmEduSLsB+74wi3ELPPs0oMs3J1Dv+QQBrQWwVVFjZKkMBMvTEylRajRRy/PT6fGVtaPu5J+xqj1TpbvHpqM7NSgUxrQqkF2aDE6OvBIzwaSsKTGBHDPsBS6xAfiNAtOaJV+FV+7ssR9W4bQxUVHqO+dXD/zB+7gr2lc2SueIW3Cm3VheXBk6wayHAF6NTGBeq7t14LtGaUkPrIcpyyCUKWugNYRfh7JoxCjBkklAu2lO228ufk7fj0s+GG2yk4+65XU5czqGU+MKYYAuROP/7Lfsz0AGRvXDfJnUtx9rJ2+lts73+7zfaO6kQ77iPYw5jV0ssxyk5H5uYsJ0AYToG08CGoOyeEmtjw6lFUH8nn053Q+35TB++uO8+WBLxnz8xh6fdeL6wcFcveEMh6+PISfjv3EqJ9Gcbj0MJIk4afxQ5IkNp8oYdR/NpzTNge2CqNzXGCD94/mV5Err+K+HSP5vfIRIowRqBVqQnQuiS3JToS/jg05Yju/Tv2VPtF9mtyOzWljf8l+T0CtU+mIMYlnwjNbnmZFWh1XpNxEp7BOJCq9vN/sqlMYURCoNvHx8I/5c8af3Nf9PiosFQxup6Ncs5JfTy1Gp1Z6qA2jWwgt1lGpkcxsN56vx3xBgDaAcS3gM80b3JD5AL20WTyumodUT+T/+tTr+TlkIK3f7Q2yTPuQ9h6Xpz7RfZh+aj+83bmBm1dz+Ec1fNSH0SlumgI5iN8PFbL1RC2aQCgrC+XxX9KZO6mDZ9YZZgyGOvHAzK/Jp6SuhNggPTsyy5jQOYZAvYEtVwi5lgP+FUQF6HwcMf675hgnXbIXgfVmGruySgn309GpkQvwQG6lx6aoARL7iX9ngSn/INXmcq7tey2bTxRxEJh/U29mfbKVMD8tXROCyK8w45SFQfmlgJ86gCqbl53rcMpUm+3UuEoU07vHEWAQXdPfbjvFU+PakRzeMPhblbGKrXlbsThrcNTFcSi3hnVHRAm+xuogKczI5kcu8/G8Ped9zF5H0PFfOHTFLt5VqdEqtFgO/07s+gcge5nwIVVqeXvqMmxfjqVGKqS6981EAJO7xPDLgTRe2vkeACq7mDBIyipQ2HDUJoPG+zvKTu95PlVay5zhrZjsEj0N0KsJsA+hTLkInCoi/C+OQbzTNXA7XBZqIAYklaKJ2zOkJdwkiMS4NKhiTUmejyWFjKSqRKHL5bldd5Bfl028XzI47eBa54r0PB75SVgmqYzigXSs7BhVFpFFemxMGx9Hhuv6JdIzMZjXVh/xvBfqaghyl30lhXgYl9ZYWZyWQ055HVO7xbIjs5RFaTmM7xzNw6Pa4HA6CTVpiQ8xcLTsKCsyVrAhewMz28zkqt4iCIvw1/HpzWHc8s0OHHUJGDUqaq0OXlh+CL1GyWu/HqG81op/WwU/7DrJaFdDrs2mIy3tMhZMESUyk9qEXqVnZpuzFhuahBTWmnYWK3sqD4JSyZqs77m85Y0Nlrvz9zvZX7KfAG0AEQYv99FNllfg5BX7q+JNlZqn21YSdOhnyjWRPGW+grc7XUHo0aGsrSjla2cEa1xTc4Us45Qkjisd3N9pEu+kvY1ULYLb/smh3DigBTN6xHkmopIk8dNtfbjuix0e1wyjRklO9WmOl4vSdUtuJN1ZQLXF7uGunaiX5S52lT4ziqpZ+UAq436+jYktZnFlm5EAXNU7wfNbuWHSisaFF5Yfol2UP31dVAihntCPxbc8yQub30ShLscsNe8I0yU+EKdVfF926Al3NSH8fqiQBTf3prLOxqx6lZCeUT09HuIggr/mpplunb/nlx3kmj6JnvfdEjB3DUnmdGktC3Z4hSzuGZrCNX0SUCkV5JbX8coqofvmrwmiV8QgjpVm8MPO0x5P1sfHtuWjvevJBfJ1H/LFsSrM2VejiwVNkK8rlUJdJmgRqdeRtr8zFYFl/HJHX89keUf+DhYW3u7hl41MHMn7ae97vl+/lO8DWy1afRDYK9mnVdO64iBpJVuYmHgNqsYml83AzUs8kFtJVICODjEBdArzBrGXt2/LoO9v5Yuj5Z733I5AAO1czTFnc285G2qsDmy6feDEIz4PLu1UQHbo6J4YxKK9Tevy1Yc7iPrx6I/0iuzFY70ew6DQMELZltVVO9BH7+CGDjvw199M6quvEe4fT5j2BCc1aiTZQVBNKRqlhrzqPExqMdG77Echhp5ZmUnv73oTa4qldVBrhicIOgYVOfBWO7h+NcT3IiJTaAlLpSe4SfkN3VV7WSrdDtZYUKpRKNWk7BS/PeYKKDoiZMucdmG/WHAAWo85d/1f/sH2bqpaodw9e2QfAg1qnHVx2Mq7UJd9rUefbFCrME6+OIZHRnhlIrqGd2XwD4O5olc0l3eK5tkJ7X3W2z46gOvOEPh0Z/sC9GpU9bqaZn2yjft/3Mv3O041UOY+lFfpsZlpEiUnxA/VBPxLTmLFSe/o3oxpOYxZPeM8MirD2kbw5vTOjHhLyAC4rVsuNvzUgVTbKj3NAiqlhN0hezJ1e7OF+O6+0+I4TDqVR1B7S+4WHt/4OCV1JTy4/kF+OvYTALItsEGpxOaQBddGef6XnDsoUlor8NcEolXpyR74OsXtroXsnXB4GYdUrXl8yUmMVy/iv8PnMGXLo6QVpmEJ/op7hkeRWyMG8R4JIWhUCozx8zAlv4oqYBc1VsmTZQszBHocBnZllfm4VuzLLufUyd4onP7IstqnJHEhcKoMHNaoeZRT5NQI7pfNYfPogJ0Lthb8we5i0blYaM5AkmTU/ukcLt9LmC6KNoGdaLHiChJXXgmIkpk7MJCUIktypOwIL691cf9USk+TTmqMP0+ObUeH2AAO1+NZue8btULNtiu2cUeXWwEhFnvPgjTGdIhkStdY3r2iIwfyijlZVMNtg1ty52UpHgpDpUWsr767iizLfH3ga17c+Qgt2gr6sEGrJDZIT4hRw66sMqZ2jQUkFKg5XV6BXRa+yYnBIqvhfmg6ZSd19rqzNms0i8AExnS6gesrKomx2elib/wads/uKywV9Ijs4cMj/PWqSFYPdgUSna9C8XAWl0+5Fknrz64Wt7DC3gOzuZY8iwi411UexS3UPyq8By/GifJ/u+CulBx8kmOnQhiQEsq8G3sR7qfz8kJd6JYQTOtIP/y0Kl6YmIpKqfCRGFprvZE+XdMw1rN0tDfCUZZlkVWzy3bahCXQJrxpkXSlQmLjw6LRzj2ZBuGV+svtfQn307KtZDGS0oJDUcGG7KYzQDGBeia1GYS+cgaWwjEEuniS6TkVGLUqnhnf3hO0AtzY4UZWTl7Jc32fo2t4V48Ie1MQGdM6zDanR1QaoMpiR5Zhf25lA+eKoW3DCXFNeB77JR2ATnGBqJUKIkwBaDU2tmWUMH+7+N5nGzOodvnOK9QimRFkEOO7Uu+7bklVzu5TInutUSqQZdkT8IJ3gnXViqv45dgvWOwWUoJSuLvL3XQK60SgLrDxA9UY0QWLxi+txp+TlYf4OeMLHtp6NccrDjb+nUZQUWdj1sfegDWvwkxMkJ6ekd4GxKySOipqfIMP9z0B3nuyfvPIX8HJF8fQMUo0e9TP+LqDPwkF4zpGM3/sfH4e//NZ1+fex+K6Yj4e8TFJgUlEHlzK+Bzh7W4pHkx6yTacshN9zA9cFhTOpCpR9ZAliQCnkxPlJxjx0wge2/hYg/VrlVpMGhMHSg54M9KZG8X/ruqN1ezlqP6hHghAtDMPXoyC76+Cqnzod49YoPgYfD4C/pMK+3+CimwRBPa8+ZzOnxv/2OCvSBXJLmcKA7qmIstgK++FOU+UKOp7OioUEjq1dxAwqA1olVp6JEbwzqwuPjd2U3CXS6LO0K9TKSS2Z5Ty3NKDDXg+fz44mI2PNOPdW3AA3ukKh5Y1/rm1FlONSDNvyN5ATKidq3sn8p81R+mWEESyqyzdJsqPASmh9Eg8/1T9uaBDSA9mtLzJU7pQKxXYnE6PP+mK9HzWHSlkz+kyFBI8tHAf37hU1ddnr2fJiSV8sPcDn3U6rQ0dLn47mM/bvx/zkRU5Vzg04uZM+O1GFmd+w47CP6mN7EVe3+dg9lJ4LI9X/B8jrWohy/O3oNf6U2ur5XTVadbnrqFjjDcLE+HnJ7hCWjH4Bobt4+6hKSgkcU3dNrADM1ydmadKa0l9+lfWHhETkY3Hi0Gy4pBqQFb7yCtcCCRkKhQKNsqlVFrFw3/xxMU83OPhxr8gy/BBf9j2keetpVnfsiZ7EQA2py/ZfVbybYyKm4bKXILTNTOtPwAnhnn/XrhTlAufXnKAaoudoW3CWXbXAMrrbKw7UkhhlYVZPeO5eWASUfU6nA1qAzq1ihCjhoo6GwpNIRvs17K/Yh2v73sAvzZPNbCGAuEqAl5fYoAfjvzAaztfo6iuiH4xfQAJk0aFJEn0bBHMtpOlDG4tAhmbXUmYn5JRLYfyaM9HWXJnf7Y/PtSzLvd1XeiaTP4lKBSMjhvK1IDeBGmCKWli1KxfWl50fBFXLL/C87r1qQUkbn+WL9t/xotcx6qjFWLgv+IHBk6/l2NzR5ORnYFGFuNMZWgyW2fvo2NoRzZVHiPdKLITSS6qy51DknlrRmcAvt6Sye+HfMu8IALAmT3jPBk6vUrPde2vY0yLMThlB6Pbx/nQVl6YmMr1/Vpw7zCvmLhTlj2l80/TP/X8Xk3B3cVdf2IUoFejNebx0IYHsDrr6BouspZ+mqbpI5Ik8fr0zjw7+AZw6gjQq/n+5t78eGvT5btYv1gmpUziq9FfeZx0msK2jBL6vCSy52/+dtTTvOF2ivjjcGEDR4z6PDV3hSg2UM+R0iMsObGEvJo8Ivx0tAw3sfTO/hzIraS4xsuv7BjWkbjghmOGrbIDtoruWJ1m+i/oT67zT3IrzHy6wcuO0ih9+YttQ9ry8/ifuanjTcwbM8/D/2oM7kA4qPQoAWYxvuTXZZ+1gckHMg3s+WIC9Ty28TGCdcF8OuJTvt2ahd3uu5/1gz+A7Y8PZcsjl537dhuBQiF5OJ71uY6jE0VJ1WGOpqTGQmpoKilBTQvjN7aP7ucAR39lRaCY6Cj1p/h4//sY1IIStNi+k0yN93cMShnd6OTSXTq2OWzYnXaK6opYuv8bkRQqSAelVlDEgMpec2hv/oyu5g9xJInxK7LaFZxn74Q3WkNumnh9oF5AmzQYBjwgLBoT+5/1WOvjHxv8BYdGcmrSIlYfLnGRlp0YEt9DFbALbTMdoxtzNjawezrrtoxqIv11fH+z78Di7noKNjUkDieEGH1mZg0Q3k5YiR1d1fjnOz7BzypmAXPWzWHx8cWcLqtlcVouz45vz/L0PMa/uxGNUoGlEd/ai4U2gZ0Yn3i1pwSgUgh9ww4xAfx8u7Aeq7Y42HOqnPbRAWhVCk/XmltWZU+hVzcq3DEGp6Vhk8uq/fn8Z81R/oqgvsN1c2orTvLr6YWkldQrmcR0BY0ByRBCkfQnW3K3YFAZsDltno6/xxee8Cyur5pCSoQBkBgaP4xfr/yI+4a34tGej/LygJfpEzaKF1cc8ixfZ3N4gpYggwZ93BdI5gQsBeM8ZYwLhc0QgcaVWXYPIiaNyTPYNIAkiW7ycm9DhlJS4XA1fMhK35Ka0qXzpzKXYnd53mrqZWAtTm+WRpa9k6VXpnTk4dFC0ua9tce59guhuTe2QxSPjWnrEzh8kPYBS04sYdeTw7llUBIKV2ZjQ84GMmtEeTnI1PDHdwcT7iANoNRcyoSWE+gf058gxxASQgx0SxQ8r3ZR/uSU13k6kS2FY+gbOYxOYZ2Y0WYG/jq1z315X/f7WHj5QqJN5ymMfgbkuJ68kNiZ/XIlhX6RBB/6Bn296x5Ar/YNbsvMroelLMOx1RwzduWdwwF8uq2A/TmVVFgqKKgrQq1UIEkSWbYISg7P5csha3j6yj9AkjCqjVRYKph/eD4AIQaDZ1w6lFfJgFf/4KnFB1h9oGHw98joNszqGe9xkHCfD3fQ5XnQuRAbZOCpy9v5lOUcsuyhHxTXFVNtbd5D1c1V89P5TrrLzGX8liW8q1sae/PLmD99ujybgrsSEmLS0CsppMlJ8Kfpn9Lhqw5sz9t+1nWCl7LghttdJtCg5j8zfPcrKkDH3qdH+HQFuyd+y9Pz2JblbQgI89OSXVZLQqgBSV2K7PBmpvYV7aNC4yvJEqltizlnBpsfHMch6XkqLBV0jg0l1KT18autn8ms//dNq2/i0Q2PNnust3W+DQD/qhwS933uef9oRTofHnzRRyKqKTSWrYsN0pNTnUOroFb0iuqFn06N7PQ9r+6SqhvhfjpP9vRC4C6v1uc6OnHSJWgYDnMMlXXnnuk/cx8BKDjACp2rGmY86dmeGz/5eV9fFn8Z8f6ikmGSoVedGH/buqxlq2xVDIwV2Tz/356GD/uLQE6SYMEVkLuHIL2aGvSU4s+4Pl2wSDrCc1zXSrCL0pOzC3rdBoWHQG2EJ4shtjv0uR1mzON8H67/2OBPqZDoGh/Eoz+ns/lEMerAnSj1pwkMLBCCu2dgcsrkv7ytIKOG0lor/nrfAcs9yLozg+cFSYKUEXBibeMkzL0L6B/akXcvexeAyhqNx9lAq1K4tNWcbMso9eFeXWyIGUkeZpevbee4QGb0iEOrUtAlLhCFJKReCqssdIkPRK9RUmdz8MbqQxwtFTPHo2XeEq/RWEHvJO8AfW3fRHF8Zjs6tfIv2SnV58KpFCqfLJEb/no1TqzoVDpPA0KFVZSq8yvsxKr7Yc6byH/WHGNGz0jGJ01maqspBGmDKaqyMDJhAinGgVz2+laPw0nPFsH46VQkuTS+AvVqkNWoVA5Swv0IvwBtv/qoDetEaee7ALDJIgPxn13/YX32+qa/pPXzkXpRKVTI5lL8Tq2hzi6CuSi9oDe8lf44L+++F6W5FLuLi1b/Hsqv8E6WJndO4LExIuBLCDF6tB5buM7Bf2d2pnN8YIPdWZ6x3FPGq7Y4PELB9TMWhXXiIbkyYyWDvh9Efk2+p+zbMsArYXRb59t4of8LfDDsA9bsVdAyzOQRSZ7YJYaWYUZ6thDXmL2iOznOVTz050PkVJ8pLyoelG65hAtBdlU2K0+LBpqXen6BvjCNpOXTkVwTTbvTzk2rb6JlQEs+GPYBo1uMptxSLugip7ZAWSZZwf0oqalDFfIbJr2VSYsnMWzhME6X1vLQwr1sOFYEKIgJCCC9KJ2H/nzI04XcN7ovj/V6DEmS8NepeHftcX4/VOjxSA40Np6FfnnlYe78zjdI7Rct+Mj1+Vr18cWmTM/fU7r6yoI02lVaD9tcY5X/GcGfu2wJ8PWmAl5ZeXYdVBBc55cmd6BdVNMOOiBUAADe2fMO4xeNZ8XJFc0u71ZpcHOQ3QoGfjq1R7vOjR9u6dMgy18/s7nEJdNze+s3UCokqsx2skqqMCW/itqYQZS6s2dZvc6K3tzX87q0thKQuP2PmzhZIc7J6NYd2fnEMF6e4tWl9An+6vHctuZtZdnJZQ1oSfXRJbwLrYNao24xAYPk3e/1eStZn7eCorr8Jr/rhjv4c0+E35jWiQEpYdTaazGoxCTVT6cC2Tcx0yRv+QLhvg77x3izXf4af74e/xa777/TUzk7F6gUKvpG96WjywqP6iKoKeT7ulBGV4ux1D0Rb+yeiVjxCPp9P/KkHMw3OXk85gwEYODhtUQ4JQbG9Pc0oPk7nGCrhcwNImt3/Df4eDDKb8Zz77AUvr+5Nx3iAtF2nIzanWXP3i6yhMOegZEvQu/b4LLHz9pQejb8Y4M/wFOy7Z4YzJhO4uYPMepJboT/lhSQdFaeR1O4eUAS6x9sWMJ1a8LV58WcFxL6gbUKChvhViT2J6D9VA8PJ1DnHdyGv7We3w4WoFUr6ZMUctHKi43hZNVh7tk8jSMVIjszon0kL07qwLaMUr7ZmoVRo6LaYmfNfYN4Ymw79Golp0preXf9bpzYCTpDcDnDvIloV3kkxKjhmfHt+fjqbgxICf1Lnb4ANlfWpi6kPQpJ6clw1YefToWMBYPK4LlRs6uykWUJ2anj0L7LQWFFF/09PeKjeHHgU/SP6U9RtYUec9fwn40reHHnw0gqb1krp6yOvi1DPDzFWqsDkLCrszhZs9uHD3ghsPknYE4UnC67iyf21YGvfDKqDaA1+QR/ChSoKk5gytngCf5uaDuHJP+2QgPQUoaETJ1LzDfCX8eYDpE8PKoNtRlzmJkoSsyJIYGeB+lXmzM56DIUdwfAYSZto1QKvUpPnb2Oj/48weO/pIMr+FMr1Nzf+WmGRI8n3BCO2W7msQ2PUWouxeKw0Cq4FTNaz+CHy39ge952nLLTJwuoUynJLa/znOu4YAO/3z+YtlH+zLuhF71aBFPtLGBl5kqe3/L8eZ75c0ekySsoq5AU1ET3ReGwoKkSGc6CWpF5u7rd1fSP6U+b4DZYHBbqrNXwhShHFUYORGnIRBv2O6XyQYrqREOUxe7kh53ZrMpchiH6Z/7MW8Ltv9/OysyVnvFhRusZzGoj5FPcOmV7TnnLcI2NEW+sPsLqgwUYNL733ZD4IWyetZkOYR0aPdZeLYKJCdST+fJY5k7yXebMrtqm4K/z3Z/6wR9OLbnlzXfjuhHup2NWz/iz+ou7M0BqpZqMigzh6NMMAg0aFBKebJ7ZFfwVVprZnlHKugcG88TYtoxOjWyUrlBf4mtPtvgdBybHMKtnPFO7xVIhiwmx0nCSUyVO4kwJzGg9gwpLBVab9/ewKnNAYSE5MJmn+zzNT+N/8ghu10eoPpQxLcYANPqca25SfbzsOPd1v4/xqY9SMvTjBp+b1GevYCgVEkqFxGVtwvn6+p5c1mivZPgAAQAASURBVCYco1ZFra3We+5VCiwFYhy7qcNNbJm1pblVXhDmdJ1D+ux0RiaObPBZgOH8n5cO2UGQzvUsKzkOSES1HEsHi5iMy7IMBxYxL7eAW9sJuZybykVyIffEb7DkLqZnppFss6GP6c44/9a0Ks/jivJShjk05FeLia8puitctwpCkqHXrcKqEyBlBPcOa0WvJBdlatIHQrfPnZ1vPxF63gSWSojtAX0aWpCeL/7ZwZ9r9hgTqOeqLsICqH9MX+4a2rCOP7v9bH4Z/wuAJ8V6rggxaYkM0DW4gV6b1knYvWj+WtBCnIsMe7qRUsSY16jqPJNXd4juv1C9lyfnHqy1SgXzb+5N2lPD/9r2zwEahbj43ILIIMjQK9PzeO3XIxi1Ko84rUalQK9Wsu5IAZKqBoc50pOZeLH/i+iL7qOPbi6z+yZyfb8W3D4kmV/2ZNMi1EiEvw7dXyT6ykot5oBkLP6JorzZCL+iU2wAKOzoVDo6hXXioR4PoVPphIq6rGJI6zBGdFISEXGK5Ei1h4wf7qdFp1awMPs5dhVvQFKYPe/nlNfROtI7MPZuGQKu9nuFpqjZ2fb5QqvUE6qLRCmpkGUZu9yE1IvnCyLzF77nvxjytqG1lON0WKiJ6kuSIZGJidfQKqADL/T4hA7qCJRVpyjqcAu1YZ0B4d7y/pXd6NlCDHgtA1ozMf5WXl+Zw1xX2fu1X494uGQtwsQA/+Ou7EZ3R6/SY7abSc+poKDSzNV9BF9GrVBzbaepvD18LhaHhUXHF3n1CB0Wekf15oneT/D27re5YfUNLDy6kG7zunmyiJklNRzOr+LPow05e/1TQvn+lj5EuwIzf+3FKcM3BrVCjUFlIs7Uko8PvUy+S0ReUyE04XJdg3t6cTqv7XgNi11kBMtyd8GVC2HI4xAY77m+WgV7O2WzzWkoVVVUS8dQ+x3mcNkhyi3lAGS41l+fH/f9LcK6MrheAHJmsAV46BnGRoL15vh239/Sh01n8LKuansVBpUB5Vm6CS/vFE1iiIGUCN/165UigLq34zPYq9pf9AmtOwBxZ/3PJvWiVEg4ZdG5CuJcVZltTP1wC9M/2oJKKXHjgCQuaxPOiv15Db4/oFUYT44TLeaSJK7nV3e8SligmdendaLcKvjcMk7U/vvoGDgEf40/ZZYy7MZtKCpGeH6DV6Z04rVBrzG11VRaBTXuy+qn8eO2TrcxoeUEoozeppv6DRdNYcGRBTyyXsjqxPkl003yJhq0Ch3GpjqFz0CAXs3qg/kcLajip91iHKi11Xom21qVAqclgnHBb3F1u6vPmiW+EMjIVFgqcJyHtElz+HTEp7xzmcvvOKEPPJZDUO+rCHGI9ZsdZtj9FWRvx5AjJuWprsDQ5GqoIWkIzJjHc3oH2RoN7e9I4/qAVCYd/pO0HCHppG83Uaz/ju0i8zfmddAFQrdG9Bf73gU9boLbtsB417692gLmzwTHBTSwufCPDv60KiUapYL07Ar0jlaElrxCfkFik8u7B//eUb0vyvaHtA5n8yOX8eKkxmfIZ0VQIsz8DtpN8H3f6QRZRikpqbHVMK3VNB/+i5tM7C7N/ZVS6blC7Qr+bC6V+k83nKTlYyvIKq0lxKjhg6u6Umdz8MQi0d1234hWBMQtxtjiHfbf/CszWs+gT1QfOod1pqI8khZ+KXSKC+TJcW1ZtCeHOd/v5eWVh9lyouQvZ/4A1HWFyAoNKqnxsu/YTqEoJAWSrOGNZZXo64bwcI9Hqc24F4Bh7SJoGRpKtbWKZzY/w6DvB+GUnUiSRGKI0SPbIzvEw2N8p2jGdYxidh/vQzomUM+gVsL67ureyX+pc7kpRBhieLvfQrqF9fdkNpsN/uL7QlhrIna9Qcvl03hI15G3Covxz1zJ5b/ehkJSctOfIuNkLD+BbKumrNU0HPWEdfdll3P/wq3oYuZxqDCHAeFTwCkyLG5OlDtwcPt9uuUezoQ78xdoUONwygT7ifMZqg9le952Xt3xKkN+GMLcbV43GZtD8DL3FO7hq4NfAXCk9Ah2p907C3fB0Ez2PdLoCv4a4+5cRHw6aBUzW97CutxlLCjfjAxoKzMBb0PJT8d+4uuDX2NQG7jO1Artt9PFQ2HQQwTo1R7dN53OwgfDPuCpPk9x19rb8Ev6GElVg0EZ4AlgAE8QGFJvcuiuRATXE55vrPPcPWk9M/P3V1Btqz6nEp6fTuXhz9WHQW0gTB9GTKCRJ8a25z8zO1/wPtWHuzNeo9CgkBRnDf5AaAa6IUkSv+zJ8YjRu8/nV1sy+Xl3QzpByzATV/YSPC83r2934W5PBnhc0jie7Ss0FZ3WEFbn/Mj2fJEEkBRWbut0C5+N+IzrU69netezNyU4ZSdWp5V7u91Ly0AvReKj4R+x66pdzX7XbDdTZiljT/FmlAoVZSYRPCb7t8fiNFNpLT/r9gHemdWFgkoLLyw/xAvLxQSxX0w/j5PGZW3CeWqqkZiY4w3u34uNtafX0n9Bfz7c9+FFW6fPc1ZjBFMEJqe45i9PHCOSON1vwNBmPADPxySQfsV2wgY+DN2uhcv/A20vx6QNoMRSDgGx0O06KMvgwaRJfD7yc1K6uTpyFUpBDes2Gx7OBF0jtAaFEsa8ChHtwF3ql51wehuUZ13w8f6jgz8Q2b9VB/K5+eud6JV+LN+Xx5ebMhpd1j2TatTq5i9g28kSiqosZy05NAlJgjZjwXiGkv2JP2BuJIbCw/xw+Q881ecpDGpxkT07vr1ne+6OxksJjUJcVFanS6XeFdAUVloIMmroHBdIek4ZOa4yzbiO0ThN2wA4WHKQ7pHd+XjExwRro7DYnQQZNWQW1/D9jtOk54i0+O+HC4kPNrD4zrNrHzaFrKEfUtD9AV7o+Sl3pz7b4HOD2sCeq/bQL2wKqw6e5qHFv/H11iO8Pk1wNDYeK0aNAavTyqrMVUxvNd1DeE8IMWArF1Y5bp2/WpuDd6/o2oCcPCBWZKC7xIb95WM5G9yl32YftqNehB43eF5GWmoIUehx6IIod9RgdtRicZp5YMuVHNfqsKn1WOplFTKKaxj/7iayyktQ++/n2117MddrLHphohjQ3dl3hUJi71MjPB2mZ8KgMuCUnQQZNJTV2jBY+vHp8C+4PvV6bv7tZr45+A0huhAmp0z2dDFbHBYeXP8g16wUFk3jksZ5HmzugM5tedhc1767NKpTXhwOZnMI1ws+2Or8FRw3Bnskqc50XOgR2YP7bDpCAxNBKfZ9QucY7h4p9nVbwRr6x/RnUOwgQEguqdW1tIuI8jmOO7vcyeKJi0kK8Oo4LkoTwUhMkJ5hbcP59JrujKjnqeyGO/i7GJOUftH9uLLtlWddzmJzUlJjbfB+pDGS1we9zubczUzqHtB8s9xfgJt+EmmM9ExEzobxLg/bLY9eRs8WwR5u9XMT2uOvU7P6QD77cyopqGxck1CnVnJt30ReHTuZ94Z8Bogg2V0RmJwymThjS5Cs2OQaH6mdz7Ov4puD3zCn25xzmtw7nA6mLJnCL8d+8XlfpVA16AQ+E+6qTpWtAlmWOVl1mCBtKHd3EOPo8S33nnX7gEe8uj5eGvASk1KE8HGoSUum5U8+Sn+PvOqG2dKLiaxKEfzU2c6NPnBe2P0N/P4cdqfMMrPIgOtLjoO1GhL60iVCSMsF+cWAWi9Kspf/VyR7gM25mzlddVpwkNuNh7t2o4ntSY/IHo03ZfyV5E5Qi7Mvcxb844O/n27rS9+WIeg1SlRKlwxCIzNLEFycR3o+wmXxF9ZK7sYjP6cz7p2NHrP5v4SCA7Dzc9/3KnPAbgajN4AwalXc0L8FbaP80WuUdE8I4ob+F/4Dnw2ezJ9rgHCf48IqM8EGDV9vySLbsoej6kfIqMggs7iGTwcvB2DW8lke3lG1xU5UgI5wPy2/7MnhkZ/TfbZTWmP10eU6X9TE9MfmF4daoUHZSFC0P6eCdk//yg87s1Fo8zG2fJM3j02jRrmXe4elsHJ/PoUV3pvs2vbXev5OCDFiKRhH1ZFn8NPouG94K65owkqvR6Qwmv+r/NKmUGev5cU997K98E9ssgj+zjaooxcPvLrgdmytO8n3gcE41CZe89ey4pRoTsitzaJXnZn++mSfrypdA45bmPn5y7v6uMi4CfD1y4kBBrVncnAm3hz8JvPHzfeU855blEv7kM7U2etwyA7u6nIXa6at4dm+z9Inug9jk8YSqA2k0lJJj8gePNHrCZ7s/aSH9B7s6kq+Z6jY7+ayV25JhUtFLvfZljGB2a3uBSBt+Mfk93ocpbmMtoEpXNX2Ks9yfuZqqnN3URviDdrmrJ3Dx/sE56rSWsm8g/O4+4+7ARgRfQVKdQ0mVaAn8+ev8Uen1PkEfgC/udw7WoQa+HR2D4a1i2g0q25wvTela9MWk+eKUS1GNXCVaAxPj2/HynsGNPrZ8fLj/HL8Fx9O58VCt4huLJu0jFs63sLA2IG0CDj72OnO8rknFsPbRfDs+PYe0We3v3xz1N5nxrdnSrdYIkwiczN361x+zfqVMT+P4XjZcYotuR6NvwktJ3gcHursdVTbmu+crg/3tf32nrc5VXnqLEv7wh2MqiQhlzRAl8TY0nyKawVVwV64A1XN2YM1t2Vdc8itEet00xUuFdzj7/looZ4zjq+BQ0tRKRX8UDeVqkNzGaEJB0kJCf1oFdSKjmEdCdU17ufunsBqlVoRHIa0bHS5v4Qxr0PPW0Bx4aHbP9bhw40WoUb0aqUP707bDHfsXGan5wp3t+8fhwvpn9L4D31WHPsN1jwNHaYJnhaI4A8J/Lwkcp1aSdsof77aksmo9pGYbZdO3qU+DCoTs1vdS+tA0emkdl1UxdVWgo0anl5yAG3kISrtRXx14Cuyj41jzaECQtrrMZv1HMmvokt8EBH+OrY8KvSJ3l/nqx/lp1NxpKCK+dtP+ajy/xWsPPUDAKPjp/u871CUIYf+wPac4eD0Bk3rj+UyOklk/6Jd5Y4AbYCPKOqYDlFIEszbksV/ZnZmaNuGWRQ33Fnl+qW5i4X9pTvpFNyLnuGD2HvN3uYfkvt/gqX3cnL0d1j94lie8RHHNTUMURupOmNguKKigqCW/Sip955GpUChzfWIzcYFBWFQeoeDOd/vBYSP6bnAnb2IcHVAK41HGPPLKwxLGAZAkC7I8wBrGdiSlwe8DIjzmRSYxIw2M5Blme+PiKDVnZV1y8k0l/kbmTgSjVLTJF/qYqNdUFeiDPHISjVKcyltv+2ONORReiaPYN4hocKvSF9InxA192pl3PnZNae8Mh+l5lJe2fGK5/XY1CTSa0NJCIwhSBdElDGKheMXNir30zE2kHVHihidGkXa6XJWpudx66CWHtFtN5LD/RjfKZqu8Ze2BFcf/jo1/lENH8iyLPP8VtGQcym4YCqFymPR9+pAwaNOz25aYB/g/XVCAur2b3dzbd9EJnT2DZLPpVy+I7OUd3d+xRGrGJdOVZ3i+8Pfk1+Tz4acDT4ZyGBdMPUcuzyNVeeC+tnBs04Kz4B7HHHfU48HDeeeisPM2yMmHhUKJX6n11LW5oom1wFCsQjg3mEptIovo8NXgg718oCXGZskGj3cfs3nu4/niykpU8ipzuGG1BvOvvC5IGO9mExHdoC6Us/E+qreifRPDoMkDSQOAP8ozHYz+4v3exIBZ+I/Q/7DltwtjXpXXzB63nTRVvWPD/7WHy3i98OF9EgM8twszQV/FxPubl9dI9Iy54wAl1RCRQ6ECwkNig6DKaJBq/aurFJW7c/nvSu60uvFNZwsrualyR25lNAotYyMm+p57c78LbqjH3FBejrGBvD20TcwA2mFacSoxqGL/o4eplv59VAQuYlmjuRX8fyyg3x4dTdMWhW6M3QYk0KN7M2u4Kdd2Rcc/O0sWo9Mw+BPVlaiCdzJidOp4PQKnq5NV/H7LhHIDIztz5fHDIxKHOXz3c5xgXSOC+TR0c0LwwLsLtgNCDupiwk3v8+d9VNIigY6bD4wRYKlEmP+Nmpi+iOpDNglCafaSM0ZftOl7a/HmjzR52bXqhQYk972vDaoDATp1UT4a7E7ZEpqrNwyKMkj8XI2/Jr5KxtzNvJ8v+fZl13Od6c+pcxS5tGCbMp+qthcTDetkEGQJIlfxv/ikxHx0wkx7ebcVLRKbYPf9FIizpTEG32+A8Bw6nck2U7Jyd8xWbzBRkSHWYQUrCbLr6HgucMcRd4ZmZbZq2azZdYWT2A0tdXUBt9zI8jVzVhtsTPxPeHq0liVoE/LEJyyTK3VQWATkpF/F+oHL39Hef5csPiOfizZm8tnGzNoF+1PcriJ+GCDZ18NrglHc41d0z7cgib0FNqwarZfuR2dUsfUpVPpHN7ZQ124POlyukV0I94/npWZKz3f/atc7vMNrPrF9GN11mr81CKgsRvC0NU7psKAOMqTz10qbWaPeHaXeCf49cepx3o9RofQDh5pk0sFnUrHQz0eOv8vLr0Xaopg5re+7391uQj4Hs6EujLwF8/tFybW4/sbRDXicOlhnLKTw6WN28cF64I9wfA/Gf/4su8fhwWnRqtS8vYsUWvXXkDjwPnAfX/oL2R7nuDP1SV5/Hc4uBhSG95s87efxuGUcThlymttqC5CavdccLr6JKVmIVfQKsKPmwcmERekJ8SkZXzXIMyIz4rqiqh1lKMO2IdGU0eIwY+iKjM2h5ONx4tJffpXiqstPiWoga3CmO5yzChthAt0vlAqVI1KvdhcnEWcalqFRjJ/1DKqjjyF0+rl2YQYdXw9+usms8Pv/nGMnnPXNDvYu8sN5yskfjYoJfGgsTttFNXl8dyW53z0ExsgSkwKIvb8l8BjP2MsP4nTXkttWCfKDOHEK/wIdXF0PqzYyJ3bfbvJNCoFDnMEskNLhCESk8ZEuL+ObY8NY9ndQjsrMcTYZJn3TBwtO8ri44uRZZkaqwOlUpyfkjqRb6yf7cmqzKLHvB58f/h7KiwVPu4EyUHJPs1PY1Ij+W3OwAtqFrpUOFV1nC2mAEraXMlN9iwezPudj/IKebGoFFV5Jgnhnchyye7Ut3pTaIo8jQEA0UbBPasfEP5w5Ace+POBRrdbUCnO7dF8L7e5seC42mznms+3s3L/2XXc/k5cygY2gHv+uIf71t131uU6xQXy4EihAfnFxkyGvL7Op+JidGX+xnVX8ND6h3x+Qx9IdlQKFXqVnuK6Yo6WHaVfdD9P08OklElMaTXF06jmDoyandw1g/MNnuP94mkd1JoAjSv40/sGfwWh7ZFVZ19ncriJdlH+hPlpUdR7Nrl1/kBQFa5se+Ul/43/MnZ9IZomzBWw6lGoKRE6vAqVaM4AqC3zZP4agzsb3yuy19+xx5cM//jgzy3WOK17LAoFDG4d1qju0qWAu7Pxgh48nuDP5eUY1hqmfSkEG5vAM0sOYLE7/7YM55M7bmLlaVG2SI0J4JaBSXy+KYMNGUc83ZndIrpRaa2k3CYeJFHGCPx0KmosDtrWc7pQKxWe/R6QEsrX1/dkTKoot7aOPDdJgeagbKLb111e6RgTyqp7B5IakcDa+8b4LBNs1NE6uHWTfKDXVx+lsMrS7MDlDsguNqdFkiRUkhq700appYgfj/5IcW0zXFOt91xG7ngRv6I9OB1mzKEdqdYYaK0M4tWiYnrUmYmozsfi8CWta1UKTHonvSIGsmbab56SaZXZ5tIzhN8Pnbslml6lR0Ymu7yC77adwo7YXowphveGvke7kHaeZVUKFWaHGYvDwj1d72k2i6pSKi6amPbFxEt77uOR7dfyStr91IV1okQBoZV59I3qxeXV1fDjtbQwxZDp6gZ2S78AmDQGnuz9pOe1Wz5l8pLJpBelk16UzvNbn+fXzF8b3faI9oKWkFgvK9vYGOW2JXRrNf7/ghp7DUW1Ree0rHussjqcgmJUr9QbZNQwuWsMh2qWsTJjJQU1DV1URKbQ7pkUfpL+CSBEud1NKG7NQXc3ujuITA5MPnN1zcJtVXa+mb/ukd1ZOH4hsSYx7ln94tC6gj+1QsNEvy6E7P/0rOvx06kIMWlQKiRsDm8g3KQT0T8NLjtVEvrBigdh6/uwfA4suVt447qf1ZKiYZNmPbiDXXfz378V//jgL8UV/AUaNKw+UEB0oJ6BrS5dp2V9PDZGlAEvqOxrihRE0UqXXEBALLSf5G3dbgTuAagxJ5NLAbVC42n4sDucHCmo4r21J/ju8DxWZqxkRusZHu3ESqcIemL9I4kLNuCnU3lkYEAo+/dPCWV8p2jGdIhi3tYsbE4nYX5ajzn7hUApKRvV+XMHf31beG28rPW6VxXShRuKgzfjV2OrOcuS549EvxT8NIFYXdvQnW02fsd2KuOHo64tROV04gBw2pkSPYnBfh1oFTGE1/2H0MJqw+q0+mQ0VUoFdXIR24t/87wnyzIdnlnN0DeEofn5TN7dHMhquyh9GnQ2zzEMjB3oaeAAr7akTqXjxg43+gSG/xZk14jGlK6h/agK7UCZQiEyrbHdPcskBKVQai6lwlIhdMKAwbGDWT55CW2C23iWO+0SigaRDaqyNa9W0DU+iMyXxxJ9lkmwuzvzn5KESfRP/FvK8+5uX6vDctbmEkmSPON72zPsGkNNWt6c3pmeseI5EFjPaciNlfcMYHqPSE/wN7v9bO7rdh9tgtt4st3uIN7Ned1XtI97ut7D5S0vP6/jmtN1Dle0ueKCG5vshnCcYaKK1jt8CL3Lc4na9kLjTlT1UFpjZcOxYqFDWm8M/tcEf/nCyIDAeNgnuMUcXAxpgqfL8vtERnBOOoxoWjDe4yBVj+bxb8Q/PvhzZ/5W7c/nQG5lox6WlwqXtQln95PDmdIt9uwLNwWlCm7fCv3uFa/3/SC8+ZqB23f1XEtuFwqNUuuRetlwvJgrPtnmel+JSW3iid5P0CG0Ax1COyCZRKCXGBjF19f35M7Lkpm//TR3DGnJvBt6IUkSEf463p7VhY/Xn+SJRfvJKaujqMrSqP7X+UKt0DSamZNlGZPaxKwe3tn0gwv3ev4ecg6yOa0izk5Ef7zX49zR+Y6LpiVZH8/1+Jix8TM9v8VZg7+w1tS5Aqe7y8r5JPo6dKUHufP3R+kY3I1Twz8mp//LVHS+GxkndrnxstWta27F4vDNeK5/cAjvXtHlnPfdzVlcmSVMxx2IYNzutLP21FqfTIE7c5FVmdVoNuXfAJNKBAomdQAnNVpkSSIktpcwV289BtqOp19MPy6Lu4xZy2dRai7l6T5Pc2+3e9EoNZwoP8EHwz5g6cSlbJixgT9n/MnXo7+mXUi7i9ZMNKR1OIEGNdf3u/SqAeeCFgEtLrn+G4jMTJm5jGvXDWXesXfOurxJK67dznGBjX7unujVp3rsKtiFw+nAqFXRIbwtQ+KEQ1SMKYbrUq9DkiRiTDG8OvBVnywviCDwxg43+tAdzgXhhvALsjGtj3HthehzubWMNKUDSXaiMjevajEqNRKNSvhQ1y+BN9X1+o9DhssuM7E/XPEjJPRvuIybntUM3PfnhpwNF3Pv/nb84xs+3DprdoeT40XVFFdb2J5R6vH2vJTYnlmKwynTL/kCL+4wVxfirq9g6d0w8CHhzXcGUmP8CffTeUoR7aOb97O8WKif+VPX43I4qPMo5/eI7MF3Y7/j9R1vUFqXSs/4RABOlQi5hD5JoZ6O6KIqC59vyiCjWAyaWpWSD6/qSptI35n1X8E9HRqfkY1qMYpRLXyzCqdLawnz01JUZfFoDjaHJXf2x2JvPlMQqAvk1k63nvsO/wW4S7RnDf4Ap8tw3CTLGIyxWNUmTqhV1Lk4nCiUqF3lJqvD4pH2AbCVd0EduIdNOZsaCErHh5zfbH5k4khUChWD4wbz3op5GIsf5JdbL2PJiSXcvfZutl+5HTUuIV5X8Pf1wa/5NfNX1kxb09yq/5Fwu5SszV3KjiLxUAnqfhMkXgYthdRUK4TW251/3InVYfU0cWRVZvHU5qd4qs9TPt6k7uzo+QR/tw5qSYR/41WEcH8daU+NOO9ju1R4+7K3z77QRUCH0A6syBDevqtO/8g1re5pdvnr+yfy6qojjEqNbPTz4+WiuWFH/g5GtRjF5pzN3LLmFh7o/gCz289meuvpjX4P8Ei7uLF44uImm5/Ohqc2P4VOqeOr0V/9pe/XR7xfMt8N3chXR/7D07nLGAmoaos83t+NwWLzUpGmtZrGuKRx6FX6fy6/70wYw6DNONG40WoEBCeB7ID3eooKXXU+ZG6CdS9B//sgpmujqzGoDXwz+hsfse1/I/7xwR/A0RdGo1ZKjH9XdLZdTFut5vD4L+mcKKrhj/sHkdSIn/B5wekQgR80qftzVa8E9BolZa7GiG4Jf49Eg0ah9ZQalfU6Re1yHSa173Hf132Oh6j83trjfPSnkEvw13svpT2nyvjAJaMAonw9KjWKS4kaWw0GlcFnIIoK0BMVoOPyTtE4z+Ga0amV/6ONBW/te5xYYwuijPHoVXqPJVZzcLqC8606LSsrtjAzpB1TY6K4dv/LXHt6PaeGfUSyfzsmJF6NUvI9NkddIupAYVX0V8nnbgRoA5icMpnP0j/DkPAJ2UefJMwQRoWlAq1S60NS1yg0TGs1jR+P/uhjVfVvgts/WSkpUUkqT6nvTLhLYoW1hRwoPkBiQCLxfqLj/bktzzG2xdgGZbPzIfQ/MrrhNv9/x6C4Qewv2c/yk8sJ10efdfmreifQOsKP2KDGJzzuYLzSKriTFVYxkTyzY/tccKZm4/ngYEkjHvF/EaeqT5BTkykm/i4OtbqukMblrAW+3JyJpC4mrzqPKFPUP6fce2wN1JZApxlNL7PgSvCP8e3yDXVViYISvcHf6a1waCn0uLHZTdZvSvu34oJGfEmSgiVJ+k2SpGOu/xuNViRJckiSlOb6t+R8t+NONcsukaSLwd06F+RXiFsh5xxNyJuFQilsngACExpdZGbPeCZ0jqFDbCDX9Uv0CPFeasxoeQsj46YAoFZ6t2lxek273agfJGQU13gEt+sLOJ8piqq5iOXrdbnL+Prof33eO1J6hAmLJvDkpid9Jga1Vju/Hy5kSOtwJne9gNL934Tsmgzyak/RP3IE26/cTpTp7IFRedI4jkxbz2/d7+DnghXYVXrskoRGlpFcAX2rwA7MaHkLunpdedXWalQBey76MXQIFdIIg/qt5tP0T/niwBcEagN9gnKlQslTfZ6ifUj7Zj1m/8noEyE0LVODe6BSqLku9Tri/RvKGLknT7sKdjFz+Uz2F+/3ORf2RjrXjWojLQJa8Nbgty7R3v/vRpxfHC8PeJlRcdOosJadNVngr1M3q+35RO8nAG/w5/bTdQfx9627j1t+u+Vi7Prfhg15q3hn/9McLN+DTbYjIzJ/zUGjVGBKfp0RP41gY85G5m6d23QH9KVG2nxY+YhIqmz7AH65GSrPCMYX3QE/3wIOGxxeJowVGsOUz2DKJ6DSwYm14j1T09fD/xZc6FP5EeB3WZZTgN9drxtDnSzLnV3/xv/Vjbn9PZWKvycosjnEoHFBUi/1MfVz0eUb17xGXLifli82ZbL64N8j0dAtrD/tgkSK220F9d4VXZmUMp4praY0+T23FIJRo8RP5838xQX7ZqwuZuPKsYoDbC34w+e9DTkbKKgtaCAxkOkqSWeX11607V9KqBTqJnl5TcGpDcQakAiukmGtKzhXy+B0BVZ2p51Ka7kPSbuorgiVIbPB+jrEBJyztl9jcDdv7C7a5vG7bYwo75SdVFgqGmSW/y24utXdfDd0I5H6WIrN+ZyqPNWoybz7+ErMQvLG3Rhwfer1ABhVDc91mCGMJROXeASy/w9/DT3CBjIt6cZG1QHOBzqlDrVC7Qn+3BPiWrsYVwpqCi669FNjuL3T7Yxv+Zcfnz6QEfSWwtocZGT2z9hMWUrTYz3Apke8zln7i/ez4MiC8xKqvqjYt0AEffu+hzGviQ7dze+IYK/UpcSQNk8s90qieB3ahIdybHfRBNL1GiHwrPWH0L9HMP5/Ehf6VJ4AuAkIXwETL3B9zcJtudWc2v/FhM15EaRe6sMQDP3niCxgM6ixiof038WlyKnJJKPyCABRATruHZZC2yg/xiePb5ZgbNCq0CgVHHhuFKH1PHDbRwew7oHBPDG2LS1CjQQbLp7au0pSNciWHCs7RqQxkrYhviLNIS7Hg79LMudCoZbU2Jw2thT8zqMbHj0neoOqJp+28zoTkCMoERanmN2qZRmHi+uXXrqDWzeMI7PKqxvofnA5LaEesjrA0rv6s/aBwX/5GEwaEya1iX7R/TyBTn03FTcGfz+Y7OpsjJq/Hmj+E2B08bfG/jK2Ubsuf60/3SK6ec6Fu4R4b9d72XvNXo/My5l4fOPjvL377+HI/W9F26AujImfccHdsYtPLMbmtFFpEcHft4dE6bBTWCc252xmX/E+4eN6iXFb59uY23/uRVmXe2hRu/i3dbogjAU7MeTvaPI7YX5aekf1pnNYZ+xOOxJSAyrJ3wJbHWRtFn9veAP8oiB5uAgEszaJ/2tLvcu7ZZb8z0IBGPMahLaG+N5nfUb/b8CFPhUjZFl251rzgaZypTpJknZKkrRVkqSJTa1MkqSbXcvtLCpqmIKODNAxtkNUs2r/FxPuG+Tv5oH9eUQc++G8v0ef67vj7/PJYWE1FeGvIy7IwJK9ueTX5DcraWJQK7E6nD6SKm4khhq5cUASax8YfFGM5d1QKlQNpF6Olx9vVDPLzYfSqv4dN7JKIXT+MiqPsCZrzTkF/6q6IlTmUvzzRIe2u1lEJSlwuDJ/GoUIPKxOb9mj1iaCv6tS7rvoRPz1M9bz3tD3PI0djSnxq5VqdEodlyedn9zFPw0dQ3qhdXEzGythB2gD+HLUl55SoTsIlCSpWZ7lkhNLPJpx/4e/BqfsIK/2NBXWsgtazzbXvdUrqhdO2cnJipNEGiPpEdmDNiFijCkzX9g2/n6Ih1v3sIE82OlVNE4H0Zsew1C4q9lvaZQaLA4LNqcNlUL1P9PsUXQEHFYISYGS4zA3EoJbQG2x0NM9tQXKMsWykz+BR7Jg3FvQdkLz67VbwRTupWf9L8dZn8qSJK2RJGl/I/98zqQs0hRNpSoSZFnuDlwB/EeSpEY7HmRZ/liW5e6yLHcPC2uo5dc7KYT3ruzqk2W6lLhtsNjNC9L5+wuIDBCE74i/Sdy2fsOH3eFk/vZTLNh+mslLJvPOnqalEqJcOmMP/7Tvb9lPEAR7Z70yjs1pI6MiwyOAWh9Wl0j338URvVAk+KUQbUzA4jSjbUYHsj5kV3OA0lU+VClU3NzmIdoHd8Pu8pZszJXErYv4U86zrM5cfdGOAURgp1QoPdtt4d9QakSj0DA0YShdIxrvqPu3oFVAKgOjRuOv8W82mDPbz72D+/9wcWB1WLh/yyzW5624oPXYnDbi/OJ4aP1DPLflOUrNpSglJYdLD3PLb7cwu91svhj5xUXa678Hbv3DSH0sXUL7otSY0JafQHEW/dL12eups9dhc9oaKAT8bXBLpQ2s54DT5w7xv8YPTq6D8ix4LA/aTQCNEbpfL2TXmoNKA9cugz63X5Ld/qfhrPlwWZabJJ5IklQgSVKULMt5kiRFAY1aAsiynOP6/6QkSeuALsCJxpb9J+Ghka25Z2jKRW1YOBeM7xSNWqlgZPvGpQcuNupLveSWm9mZVQbIBLg6aJvC1G6xrDtSSNrp8r9lPwH0SiP6ejwpBQq+GfMN/uqGMjL7c0TmVPEvkSK4rrWwpPro4Ivn3PFpc/mH9k19gK+TxqGUVAyOGY9Om0hpgMiGujN/Hgs8vJk/i8PCIxseYUTixZcEcXfyHik7Qmpoqs9nCknBjrwdlJnL/hbtt0sFq8PC8YoDzT4Ir1xxJTGmGF4e8HKj/Mem0NiE5v9w7tCpDGgVOiovMPNndVg9Qtw/HfuJdiHtyKnO4eoVV2N2mIWfbViHs6zln4VOIb34NXshepWBnUUbaB/UDafagLKZ4E+WZSQkRiSOwGw3XzQ9yvNCwUHIT4eQZEidCmFtRJYvMB5u3SQygT/Ohh+vhZnzoc2Ys63x/1tcaFSzBHCbhs4GFp+5gCRJQZIkaV1/hwL9gIvXs34JsSOzjF8P5KP4mxpM3JAkiTEdov62xhaNwivyXOuoQBWwC0lVhVN2+niyNoYqs92n2eNSY3LSdbw/wHuZKRVK2oe0J86/oWDqw6Na88GVXQnz+3syxRcLVqflnAdWp8aP9BtPUZs8CZVCjdVp4VjFfooDEpFdUgwaVyBZ3+JtUNwglk9aDnDJOvYGxAj7o7TCtAaflVvKKawrZN3pdZdk238XTlQeJKPqiKehozEU1xajklSMTRp7zpm/tdPXMm/0vIu1m//fwl8TdMFlX6vT15PcXeJ1u7acr03bPwGdQ/vw3dCN6JQG3tz3KMXmfJwqQ7OZP5vThoxMtbWaB3s8yLoZ6/6+Hc7ZDb/cCh/0ga3vwU1rRSYvujO0nyiWiUwVmb77Dotyb6tL7ybzb8aFBn8vA8MlSToGDHO9RpKk7pIkuc0C2wI7JUnaC6wFXpZl+V8R/N3+7S7uWZD2t+kK/k+hfubv4c13oI/+EVPKiwDNdmPuyirjz6NF5JY3pw51aVFQU8Avx36huK6hOn2gQcPoDv8eHblvj73LK2n3o1XqCTec3ZGkPk5Xn+TLI29xsGw3T++8lYNlXhkXf00gM1reQoKfN5OkV+k90iQdwzpenAM4A2UW8ZBsrOHD3cl6tsnFPx1GleD5jUsa1/QyGiOHSg+xM3/nOa83VB/6z9FR+xfDXxN4zsHfmqw1TFg0geK6Yp8xXy15s7pKSemTxQ7QBvxr5YoAj+i7zWnFqTaisDetjOCminx3+Lu/Zd98kLML9s73vm6qmiNJ4B8FHaeD4t9B9/mfwgWlbGRZLgGGNvL+TuBG19+bgX9XTtyF4moREP1rFMz/IoZEj6NjiCCkF9Tk4qiNR6HPQZIczT6A3I0edmfzrhgXEzuK1rMhbyV3pT6LWqHhWPkxntr8FN+M/oZQ/b/EZqgJVFjLyKs9zcOd36BD7Pm5u5Railid/RNRBpEBrd/haFCZmJB4tc/yO/J3kF6czh/T/rhkAdjSE0sBqLE2zCZMaDmBn4/93EBH8t8Gd7dv94juTS+jMpJWlMZta25jx1VNd1P+Hy4+/DVBlJobZSP5oMxcxpx1cwAY8/MY6ux1pM8WVpbvDH2HCksFL2x9gVWZq3hl4Cs41jn44/QfhOn/Hp/5S4X6wV9+j4dxaJt2zqrPGV5weAG51bnc1/2+S76PAER19v49/DnQ/nsD7n8K/i80/j8Q75dMl9C+2J12auw12GtaEa0TOkepIalNfs+oFV20gX9T9zUIXaqdRRs8mnUWVxu/u7ng3wx3t+9fgVYhyok1diE3oqqXrZBlmaK6PCqt5Z73NuZs5L097xFmCLtk3B13YNeYWLU7U/tv1flzw+DK/LktwBqDW87m/5o9/n6MipvG1KTm3RoAZGSmuHTu3BmuKUum8OI2UQEJ0AZ4BMzr7F7by15RvS7Fbv9tqB/8VbYYS010nyaXrd/QtLNgJ+uy113q3RMoOgJZG72vg/4ZXtX/dvwr7N3+p/DH/YM4UdR899P/BhTV5XG65iSJJhHwjWyThM4QRHleJgn+jbuRgFd0+74Rrf+W/QRQuHSlHC6tPzfv5ly7Y//JUCs0WJ1WPj/8Ou1K47mp403n/F2NK/itsVW51uUbkN+7eToTEq9hekuxzlpb7SUvK85uP5u2wW3pG9O3wWf3/3k/8O8P/nQumZcDJQeaXKZ7RHc25Wz6XzFB+behQ3CPc1ouWPf/2DvL6CqutQE/+3jcSYDg7m6FAm1pC3V3v+1X721vb1vqfuvu7tRLgUIpUNzdCSSBQELc5fiZ/f2YORIBEghSmGctFieje2bP7Hn3q/E8POxhfk3/FavRisvnYkfZDipcFVgMFpIjkhmUPIjzO53P+F/Hc36n83n6pKf3mwf1n4B/nPAoHiwVWRg8VTgTGzbUJYYlckf/O3h//fu4vK5Dzp/YaHLXw5yngn+n/CMNicccuuZvP3RMiuT0nsd/mZfVRYt4dcNDuBQn1/a8lpuHjaZjfBIOr4MCe8E+9/Nr/uyu+iWqDhf+Acef68/tU03zTamHeqxiM4bh9NrZUraGHWU7DrxDCFbt+u1eVfgzhgh/QggsRlutaN+aA0RyNwcmg6lBwQ/UBLkAKRFHJqL9cCGE4OVh3/D+ae/vc5ub+9zMhPYTjk505AlOpbucrWVrA6ms9kWNp4ZiRzHPjnw2oAEEKLAXsCBnARuLNtIrsReXdL2EKncVo1qP+scLfgCtItrz+MB36BLTi+TVL9Fm3r/3u71/AmP32o9cqpcqLZVwSl9oe5Ka00/nkNGFP52A9kJKyYNDHqRfUj/GthlLp5hO+9UORWiVVqqcR1L408wUUhX6Apq/40Cr0iaiI30ShuDw2ptsIrQYbBiFkVYR7bmn99MB37/gemutaN8qdxXR1vrpcY4UbaPa0jqy9XER1JAa2eGAfpNOn3O/eQB1Dg+bS1fx3Np7KHLm8cvOz3h05b/YWra23nbzs+cz/tfxtI1qWy+gwe1zB5IbbytVc8yVucro81WfgF/rP5VwUwQ94gYQaY7WAj72belaV7iON9a8wYT2E/BJ35HT/FXlq/n7rvwBrvnlyJzzBEA3++rQO34IAsHCvBmc3LETYaYweiT04PcLft/vftE2M4sfOuWIJaMGiDbH0iKsVcDn76wOZzE4eTAx1qYFSByLjGp5JqNansnNC8Y3WSuXaEvmm1MX7HO91WitlbKi0l15VKMUc6pzjkhJrGOFK7pdEZio6Bw5Yq0JAJQ6i1hTtJg8+x7aRtZPzeKvZLShaAOgjiszds3AorlimA1m1hasDfgA/pj2I8A/vk9dPierixbSMboHLU37z/NX5VatCtf2vJbPNn922FJE1T9xHkSlQEzrI3O+EwRd+NMhKSyFXvGDmLr7W6bu/paZF8+kdWTjXrTUuCOruRmUNIpBSaMCf8dYY44Lwc+PIhUc3pomR+D6I9LLXMXsrcmia0yfgB8ggNlgxR3yofpg3AdHbvBugH9eOaxDY1/mb53DS8twNZ1Rrn03bsXFwMSRRDaQEN6f9Nxf0Shaq4t9dsez+XvP35gN5lpme39N5sPtOnG4cXhreG/LM9zU7b/0N0eqef6kbDCVij8QJq8mj5dHvxwo33jYqcpXhT+dZkW3Q+gAMDBxZOB3U6oQHG1W56/m+7TvD7zhP4B1xcv4v4VnAaLJvnBSSj7c+j8+2fYS/1t3LxXu0lrrL+xwA6e0CtbRDTeHH1Wh+duzvuX3838/aufXOTGItSQQbookpyYLu7eaHRWb+Tvn93rb1WjmTn/Oyx+2/wDAw8MeJt4WT5wtrpaLwr96/wuAISmNCyg5VjEFAj7cKOZwhPQh9uEf6U/1cv+C+8mpyjlibeSKSXDBB0fufCcIuvCnA8DJKeM5pdW5mAymY3o2W+Yq5vm1/2ZjyUoA5mbP5c01bx7dRjUjdm81Tw1+n0u7Xtqk/YQQLCuYw44KNTeZqY4z9qiUM+iTEPxQvbnmTZbuXXroDT5IYqwxdIptsMS3jk6zIYSgdUR7cjXhr9RVyOSsr+tt5w+AemPsG7wx9g0A7up/FzajjWkXTuOO/ncENH/PjXyOk1NPZtP1m5qcjP1YI7T0Y2X78ewe9wlS02rWxV+fGuCZ5c/w2abPDl/DCrbChh/AXgoRCRBbv4KTzqGhm311gGCy2lhr7DGf1HpL2RqGtTgFUPP8HS/508KMqtDt9DkOan+rwUa1V61nXFf4K3MVU+Euo31UF7yKl882f4bVaNXNkTrHPdd0uQuLwUpa+QaWFfzNzso0pJTMz57PlMwpPD/qeca1HUfHmI7E2eIY124cEeYI3l3/Ll9u+ZJlVy0DCAh/9v1UwfinYQpJ9eKK7YxrP6XqWka0xGa04fQ5WVOwhnjbvhNCHxJlu+GbC6E6Hwwm6HcFDLtdLd+m02zomj+dAIvyZjZYJu1YItyk+sLZtWTGTp/zuIj0BbUQPcAL6+5ja0nTKyBaQtLdhCZ5Bvh911f8b929QNC5/Z9clkpHp7F0ielNu6gunNnmEgYlnYxXesgsz+Seeffw956/KXWWMjB5IJd0vSSwj/8dqfZUc9uc25i9e3bAD/DVVa8eles4HBiEAaMw4VHcGB0lRGbPw+CqaHDbk1NP5v1xwZRGhy3at3ArOErhjOfBZIMdf4H0HZ5zncDomj+dAHf2eoLEYzx2wmKwYhBGHD51cHb5XMeP8GcMOpQfTDBG6H2oOzBHmKOp8VShSIVKtyo468KfzolAhauUlUULSAlPxaqZOX/L+C1kfQVexYvZYCY1KrXe/kv2LmFEyxFYjBZGth5JubP8SDX9iPDM4I+IscRjK9xIh1nXk3nuZOzJg2pt41W8pJWm4Qi59sOW56/DaLhjOSR0ggFXgyUSjEeuitSJgi786QQYlnxKk2vKHmmEEIQbI7BrDtou7/Ej/IVGIUaZmy6YxVjiiTbHcX77a+tp/iLN0UjUSGJ/ygZd+NM5EShw5vLF9tcAOD1VTcz8zdZvAuvLnGW8suoVTAYTn52p+rHNuHAGP27/ka+2fgUQiGzdWLiR+LDDZO48SnSI7sbdiy+ivTmBTwCDu7LeNpuKN3Hdn9cB8IQnkmfM1YdH+MtdD4oPUjXhMyyu+c+hA+hmX51/IB2juxNjVgeF50Y9xwfjjo9IsEhzNDd1+6/6u4mpXgCeGPQeTw5+n/6JI+r5bfoFyxpvVcCk5Tdj6egcz8RbEwO/hyaN4eEBakDH5d0uB6DcVU61p7pWNG+b6Da1ApIsWnL5Kk8Vuyt3H4lmHzFm5/xGiauQNdXbGN+mFZay9HrbfLXlq8DvSyM70ttnICEsofkbs/AVmHJH8x9Xpx665k/nH8fEAa8Hfh9POf6AgDn7YGveZlWlU+oqrJW6ByDCpGr5qj2VnJYyjHXXrkNwbAf26Og0B7GWoPAXY4nnp50fE2WJ4oZeNzAvex6g+vhFmCNq7dclrgtjUsewIGdBQPPXN6kvQ5L/2eld6vJ7SPSzw2CkoHQtdXV6FSF+gFt2zuJdUzgJA+5u/sZU5EBMfdO7TvOjC386/2h+2v4T0dZoxrcff7Sb0ix8n6FqMQ+mDuy03ZP4PuN9IkxRfDLmz1rrOkZ3565eT5FgS2Zd4To6xnQ87gRnHZ2GCPV/jTBHcX3XezGFFZIalcrfl/4NwCurXiHCVFv4653Ym4eGPMSeqj2Bd+W7s747cg0/QkSYougS3Zsz2lzEc2vvYbZ9O2fV2abMWUZPWwtuz9rCFa1TeCKqL5cqChiayXi48WfI3wjle6BV/+Y5ps5+0c2+Ov84vs94nzc3PgbApG2TmJU16yi3qPmItyYxtuXZB5VuJ6tqOwBmQ/3M+3HWRE5KGcfvu77i+j+v55117+BT9Ag6nROLcFMkCbZkRrVWqwSVOku5ZsY1lLnKAome/UgpSQxP5NfzfmV06uij0dwjQk7NLjaVrqRn3EBaWBLZ02povW3KqvPoVZhJ/+gOADxTtZEpC58Az8GlpaqFosDMh2DnfDXKV9f8HRF04U/nH0eZq4RdmqDj9DmPXJmhI4DNGH5Ief6g4RQMPsXLrzs/56+cXxjXbhwXdbkoUKJKR+d4574+z3NZx1sCSY39XDX9KjYUbaBjTMd6idU3F29m6HdDWZa77Eg29ajg8Km5C6NtyZRJd611ilQo99mJtURhuW5KYHnu+q/g99tV4e1QKN4O9hI1yhegjvld5/Cgm311/nGEmSKo9lSiSB8unwub8fhI8gxqDdJc+8E5lFu1VDFGUf+1VlD4ddfnALxw8gvHTYS0jk5jGNJiDEMYU2/53uq9AEw6e1I9nz9/8vg7/76TX879hW7x3Q5/Q48C9/X9X+B3rDWe4vKtxOycRkVHtRykIn3cZkpmcHI7LCGRzmYJbJkMPS+AXhc0/cQ7/oLSncG/B1wLlgjof+XBXYhOkzgk4U8IcSnwFNADGCqlXL2P7cYDbwFG4FMp5YuHcl6dE5sesf2ZnfMbywvmHVd5/kA1+3oV70Ht2zG6OwAFjr311pkNFkYkn8bQpLHH1f3S0TkUWke2Zm/13nqCH9T2u+0Q0+FINuuIMiQpaNKOscST6SolcdMnOBL6YC1Pxx3TgduvnlNvP/Oo/0BRLhSlNf5kVQUQlaz+XvMVFGyGcm2ym9QNTnnkUC5FpwkcquZvM3AR8NG+NhBCGIH3gNOBHGCVEGKqlLLpJQx0dIChLcaSGtGBHzM/ospdhdV0/Agzb53080Hv2zde9dW5vNOtDa6/u/fTB31sHZ3jkZ/P/Rm3z93guoSwBKLMUdw14K7jyrVkf5zV9nIurPGyvuALWk0+lfZeL9k9r6OwYxvibfGYDCYeG/YYz614DlNkCxhyH1TmwcengC0GSjOhx3kw7mkw1hEvCrbCh6Pg/HeheAdsnw6DboAe54LXBcd4WdHjjUMS/qSU24ADOacPBTKklDu1bX8Azgd04U/noDAIAzd1/y87K9O4c/BVx5XvmvEQSibFWOOZdNriZmyNjs7xzf4SnYeZwlhy5ZJjvtZ5c9IyvC0MnMgT1cvY4y3nmpYXsM6+k3U/n8av5/1K17iunNn+TH5J/4UEm5bnL7IFVOaqWrzUobDsXWjRAwZcA7sWws4F4CyH9ZPAZAWPHRaruRbpeAp0HnfUrvdE5kj4/LUGskP+zgGGHYHz6hzHdI/tR/fYfgeVDFlHR0enMZxIgl8AIbhzyAd8su1FPs/7DYMwckufW+gS2wWAWFssP58bYqEwGOH/5oHRChEJMO3fYItV1+1dqwp6UoG+l8OQmyF3LVz2NUipav10jgoHFP6EEHOAlAZWPSqlnNLA8oNGCPF/wP8BtG3btjkPraOjo6Ojo9MIksNb8+jAt9lTnUGcNZGRHdvvf4foVsHf57wJbi1tzqh7YcRdqrbPplUUanN8Jcn+p3JA4U9Keag62b1Am5C/U7VlDZ3rY+BjgMGDB8tDPK+Ojo6Ojo7OQSCEoF1Ul4PZEawhFhmjCYx6KcljjSOR528V0EUI0UEIYQGuAKYegfPq6Ojo6Ojo6OjU4ZCEPyHEhUKIHGAEMF0I8Ze2vJUQYgaAlNIL3AX8BWwDfpJSbjm0Zuvo6Ojo6Ojo6BwMhxrtOxmY3MDyXAiWB5RSzgBmHMq5dHR0dHR0dHR0Dh0h5bHpWieEKAIOrtRB44kBKg7zOY4EiUDx0W5EM3G89AkcP/2i98mxh94nxybHS7/ofXLs0ZQ+KZZSjt/fBses8HckEEJ8LKX8v6PdjkNFCLFaSjn4aLejOThe+gSOn37R++TYQ++TY5PjpV/0Pjn2aO4+ORIBH8cy0452A3TqoffJsYfeJ8ceep8cm+j9cuyh90kDnNDCn5RSfyiOMfQ+OfbQ++TYQ++TYxO9X4499D5pmBNa+DuO+PhoN0CnQfR+OfbQ++TYQ++TYw+9T449mrVPTmifPx0dHR0dHR2dEw1d86ejo6Ojo6OjcwKhC386Ojo6Ojo6OicQuvB3jCKE+FwIUSiE2ByyrJ8QYpkQYpMQYpoQIjpkXV9t3RZtvU1bfrkQYqO2/KWjcS3HC03pEyHE1UKI9SH/FCFEf22d3ifNRBP7xCyE+Epbvk0I8XDIPv8WQmzW+uTeo3Apxw1N7BOLEOILbfkGIcTYkH3096SZEEK0EULME0Js1e7nv7Xl8UKI2UKIdO3/OG25EEK8LYTI0PpgYMixXtLelc1CiMuP1jX90zmIPumuvUMuIcR/6xyr6eOXlFL/dwz+A0YDA4HNIctWAWO03zcBz2q/TcBGoJ/2dwJg1P7fAyRpy78CTjva1/ZP/deUPqmzXx8gM6Rv9D45Cn0CXAX8oP0OB7KA9kBvYLO2zATMATof7Wv7p/5rYp/cCXyh/W4BrEFVSujvSfP2SUtgoPY7CtgB9AReBiZqyycCL2m/zwL+BAQwHFihLT8bmK29JxFav0Yf7ev7J/47iD5pAQwBngf+G3Kcgxq/dM3fMYqUciFQWmdxV2Ch9ns2cLH2+wxgo5Ryg7ZviZTSB3QE0qWURdp2c0L20WkiTeyTUK4EftB+633SjDSxTyQQIYQwAWGAG6gEeqB+3OxSrUW+ALjocLf9eKWJfdITmKvtVwiUA4PR35NmRUqZJ6Vcq/2uArYBrYHzUQVrtP8v0H6fD3wtVZYDsUKIlqj9tVBK6ZVS1qAqHfZbSUKnYZraJ1LKQinlKsBT51AHNX7pwt8/iy2oDwbApUAb7XdXQAoh/hJCrBVCPKgtzwC6CSHaax+8C0L20Wke9tUnoVwOfK/91vvk8LOvPvkFqAHyULVKr0opS1FnzScLIRKEEOGoWg+9T5qXffXJBuA8IYRJCNEBGKSt09+Tw4QQoj0wAFgBJEsp87RV+UCy9rs1kB2yW462bAMwXggRLoRIBE5B75dDppF9si8OavzShb9/FjcBdwgh1qCqid3achMwCrha+/9CIcRpUsoy4HbgR2ARqpnLd6QbfZyzrz4BQAgxDLBLKTcD6H1yRNhXnwxFvdetgA7A/UKIjlLKbcBLwCxgJrAevU+am331yeeogsVq4E1gKeDT35PDgxAiEvgVuFdKWRm6Tqo2xP3mfpNSzgJmoPbT98Ay9H45JJqhTw5q/NKFv38QUso0KeUZUspBqC9eprYqB1UVXyyltKO+nAO1faZJKYdJKUcA21H9CnSaif30iZ8rCGr9/PvofXIY2U+fXAXMlFJ6NBPjElQTI1LKz6SUg6SUo4Ey9D5pVvbVJ5r58D4pZX8p5flALNq919+T5kUIYUYVMr6TUv6mLS7QzLlo/xdqy/dSW3uUqi1DSvm81l+no/oE6v1ykDSxT/bJwYxfuvD3D0II0UL73wA8BnyorfoL6KOp4k3AGGBrnX3igDuAT490u49n9tMn/mWXEfT3q7uP3ieHgf30yR7gVG1dBKoje1qdfdqi+stMOrKtPr7ZV59oY1aE9vt0wCul1MeuZkYIIYDPgG1SytdDVk0Frtd+Xw9MCVl+nRb1OxyokFLmCSGMQogE7Zh9gb6oGiedJnIQfbK/YzV5/DI1tcE6RwYhxPfAWCBRCJEDPAlECiHu1Db5DfgCVFOiEOJ11MgrCcyQUk7XtntLCNFP+/2MlFKfpR0kTekTjdFAtpRyZ51D6X3STDSxT94DvhBCbEHVWHwhpdyorftV+6h5gDullOVH6BKOO5rYJy2Av4QQCqpm6dqQQ+nvSfMxEvXebhJCrNeWPQK8CPwkhPgXsBt1sgqq9egsVN9LO3CjttwMLFLlFiqBa7QgA52m06Q+EUKkoLpHRAOKltKlp2YqbvL4pZd309HR0dHR0dE5gdDNvjo6Ojo6Ojo6JxC68Kejo6Ojo6OjcwKhC386Ojo6Ojo6OicQuvCno6Ojo6Ojo3MCoQt/Ojo6Ojo6OjonELrwp6Ojo6Ojo6NzAqELfzo6Oo1GCFHdwLJuQoj5Qoj1QohtQoiPhRBnan+vF0JUCyG2a7+/FkKMFUJIIcTNIcfory3770G06TwhxETt9wVCiJ4h6+YLIQYfYP+xQog/9rHu09DjhSy/QQjx7j72qXePmpvQaz5SCCGeFUJs1PpxlhCi1ZE8v46OTvOhC386OjqHytvAG1rJpx7AO1LKv7S/+6MmJr1a+/s6bZ/NBBPKAlyJWjS+yUgpp0opX9T+vACoJ6wdLFLKm/0VJ44l6lzzkeIVKWVfrU//AJ44wufX0dFpJnThT0dH51BpiVpfGgAp5aZG7LMbsAkhkrUyR+OBP+tupJWT2qWVmYoVQviEEKO1dQuFEF38WjghxEnAecArmnaqk3aYS4UQK4UQO4QQJ++jPZFCiF+EEGlCiO+0NtXSHAohbtSOsRI1O7+/jR2EEMuEEJuEEM/Vaf8DQohVmsbsaW1Ze01D+okQYoumRQvb140SQtwjhNiqHeMHbVlA8xiiYV0vhHAIIcYIISKEEJ9r171OCHH+gbtk/9QpOh/BAQrO6+joHLvowp+Ojs6h8gYwVwjxpxDiPiFEbCP3+wW4FDgJWAu46m4gpfQB21G1eaO07U4WQliBNlLK9JBtl6LWxXxA0zJmaqtMUsqhwL2opcYaYoC2vifQkRDhDgIF1p/Wlo+itnbxLeADKWUfIC9knzOALsBQoD8wyC+4asvfk1L2AsqBi/fRLoCJwAApZV/gtrorQzSsj6NqWZcCjwJztes+BVUgjqhzTVF1BMfQfw1qT4UQzwshsoGr0TV/Ojr/WHThT0dH55CQUn4B9AB+Rq3pulwTzg7ET6jC35XA9/vZbhFqneTRwAuowtcQ1FrWjeE37f81QPt9bLNSSpkjpVSA9Q1sNwyYL6UsklK6gR9D1o0Maf83IcvP0P6tQxVau6MKfQC7pJTrG9EugI3Ad0KIa4AG66gKIboArwCXSSk92nknCrVm6HzABrQN3UdKWeUXHBv416CpW0r5qJSyDfAdcNd+2qyjo3MMowt/Ojo6h4yUMldK+bmU8nxUAaV3I/bJRy1Efjrw9342XQicjKpBmwHEogqZixrZPL9G0QeYDrDNgbbbFw2ZQAXwQohA1VlK+dlBnO9s4D1gILBKCFFrWyFEJKogfYuU0q95FMDFIeduK6XcVme/Jmv+QviO/WsrdXR0jmF04U9HR+eQEEKMF0KYtd8pQAKwt5G7PwE8pJl398VKVNOwIqV0omrmbkUVCutSBUQ18txNYQUwRgiRoF3rpSHrlgBXaL+vDln+F3CTJpwhhGgthGjRlJMKIQyo5u15wENADBBZZ7PPgS+klKHC8F/A3SG+iwPqHrupmj9Nu+jnfCCtKdeio6Nz7NDU2a2Ojs6JTbgQIifk79eBVOAtIYRTW/aAptU7IJqf3oG2cWl+Zsu1RYtQTcUNBZb8AHwihLgHuKQxbWhkO/OEEE8By1B99NaHrP43MEkI8RAwJWSfWUKIHsAyTQarBq5B1fQ1FiPwrRAiBlWb97aUslw7HkKIdqjX2VUIcZO2z83As8CbwEZNgNwFnNOE8zbEi0KIboCCGrBTz/9QR0fnn4GQUg/Y0tHR0dHR0dE5UdDNvjo6Ojo6Ojo6JxC62VdHR0fnGEAI8R51UswAb2nR1Do6OjrNhm721dHR0dHR0dE5gdDNvjo6Ojo6Ojo6JxC68Kejo6Ojo6OjcwKhC386Ojo6Ojo6OicQuvCno6Ojo6Ojo3MCoQt/Ojo6Ojo6OjonELrwp6Ojo6Ojo6NzAqELfzo6Ojo6Ojo6JxC68Kejo6Ojo6OjcwJxzFb4GD9+vJw5c+bRbsZxxaacigNu0yc15gi0pD6NaVtDHK32NicNXXtjr+tg7tvxcM+OBvu71/o9PfbQ+6s2BzvGwol5v/7hiANtcMxq/oqLi492E3R0dHR0dHR0jjuaRfgTQnwuhCgUQmzex3ohhHhbCJEhhNgohBjYHOfV0dHR0dHR0dFpGs2l+fsSGL+f9ROALtq//wM+aKbz6ujo6Ojo6OjoNIFm8fmTUi4UQrTfzybnA19LKSWwXAgRK4RoKaXMa47z6+jo6Ojo6BwipSUYfvgajCaUUWOgV9+j3SKdw8SR8vlrDWSH/J2jLauFEOL/hBCrhRCri4qKjlDTdHR0dHR0dMSKJRh++xHDz99hfPvVRu1T6a6k0l25z/WZRdU8+8dWnB4fbq/C0sxinB4f78/PoMLh4b5593H33Lub6xJ0GskxFfAhpfxYSjlYSjk4KSnpaDdHR+eYp8+nbWm1eOLRboaOjs7xgNsNgDJoGFTVFuhmZs3kg/Wqx5aUkpV5K5FSMvL7kYz/VfX62lNi519fruL+nzYE/j7ttQV8tngXm/aW88acHTz7xzbmbCvg5Znbueaz5czZM4dK176FR53Dw5FK9bIXaBPyd6q2TEencUgJ4oDR6yckCWmTyB314tFuho6Ozj+cyhGDKG/1CCntBmE2h9Va98CCBwC4vf/tzNg1g4mLJvLgYHXiWeWuAuDnNdn8nVbIvP+OBeCRyZsAsMQv4KYFE6lKewaTsNIyJgyjQbC5IIvIKOgZM7rRbdxb7iDaZiLKZj7Uyz2hOVKav6nAdVrU73CgQvf302k0io/en3ckaf27R7slh5VCRy5bStc2aR9XVFvKO5xdb/mygr+56u9RLM2f01zN09HROY5RpI/Vns08VPkypVFAXPw+tzUbVMFrfaYNAIEgrWQ7n217hT7tvHRIjKDC7mFxRjH/Pq0LFw4PihpeRSIEZP7vLK4fq07of9+6FDUk4MCMfHEuF7y35CCvUsdPc6V6+R5YBnQTQuQIIf4lhLhNCHGbtskMYCeQAXwC3NEc59U5MYjcuxAhfSRt/PBoN+Ww8tqGiTy/7h7s3uraK3wecFU1uI9iicbgddRbnlO9C4Bc++5mb6eOjs7xx5bStcxa8CKnbFAw7diO4atPwBEcWyZ0mEDbQnBs3IiCAsCKDBdxyhDaRbfj1fnzMcauICo+nWdmLmBzbgUbnzqDm4alkFpdAlIwpH0yAB/MzyStJJ2omAIAqs0rmbs9l75P/cXSXXtYX7ieLbkVtJ84nfPeXVyvrZlFNUfgjhzfNIvwJ6W8UkrZUkppllKmSik/k1J+KKX8UFsvpZR3Sik7SSn7SClXN8d5dU4M4tJ/AaC65fCj3JLDy4UdbgBgddGi2it2L4EXUuHTcbUWT8+YyjJHJuGF6+ody+lTB22bMazeOh0dHZ26eKWXQRmS22coGDN2YvjmM6goC6y/svuVPLOuI7nPPEuZXRW+yqLf46JO1/PNhG/o0cYHwCbnV/ywdTpzthUQbTMT9fdDODNmgZBc73qeHilRrC5cxKV/XMSKvBWB4+8pL6XS6eXllS9z7Z/XsmKXahzcmFNBcbULUH0NhYC7T+18pG7LccsxFfCho9MQZV0vp6zzhZR1u+JoN+WwMqzFKSTaUlhdtLD2iqz6M1+Ar7Z+xW9RkRT1u7PeOqfPDoAQ+iuuo6NzYHzSi9Gnml69UREAiE0bMI0bTvEnn7C7cje2zTtxb97ME1PVgA6DuRK3dQOxtlgcSikx1hiSw5OJjirhiyVZfLggE8PmX/Fq1cZ2yM28etJmxg8rBGB4q+Hc1uMxAHaXlQCwObMlAGtydwbatna3KoS6vApSgs1sPNy347hH/zLoHPNUp44mZ+xbVLUdd+CN/8FsLl1NsTOfSnd57RUFW9X/jZZai3eUZ5JhNiMN9eO2XJrmz6O4D0dTdXR0jiMqXKXYvdWYFPAawBuhWgzEZlXIq1m6lE/WfYzB7QXAW909sK8UDj7c8CEFNQUkhycTZYmixrKSKNsOxs87B3wuhjqdAOw1GflvxiT+2PmHehzFS26ZKhhmlhQRZTUhvIkA7CjZRY+W0QDsLlEns4rmF/jKX9sP6/04EdCFP51jnvCCNYTnrcBannG0m3LYMDrLmJs7FYA2kR1rr/SoAx++2oKcT/rYazbRavlT9Y7XKrwdAF7F0+xt1dHROb54atq5iJefYUCmBJOJmHgtOUduDgDS7aGkZE9g+0glkudHPg9AjaeGzzd/jk/6aB3ZmsQwVXiL6TiVVHLhvHf5VLxDP5eZXeHR5HgqALiz/51sKtrExqopAGSVFdM2IZyE5C0A5FRnc3KXRMItRvIqVOEx3GLiooGtSY3T3VkOlSOV6kVH56BpM/cOLDV5uCPbsP0KLcrrOEr9Epk9jw5/XY/oexZtIjvxr+4P1N7A66r9fyO4qOONXNDhOgxCN4/o6OjsG6/Pwzsf+gJ/y3ALYTEpAIi9mvDncBDpDO7TITwHm6kzm67fxNtr38btc/P+uPeRUlLkKOK55c8xL3sepUYjLWJSsUdIDIbWZBiyAse4rd9tfLvtW7pFjWDz+rMZ1bsFy933YZFqlHFUVAWD2sWxo6CKmLBgWpcoq4lql7fZrr/C7sHl9dEi2tZsx/wncMxr/qSUvDwzjVVZpUe7KTpHCYNPFXoMHjUK1vDWy5hOH9HgtlVODw63r8F1xyrW8kwAFMWNsSFhbeB1ENUSErvu+yBSqbeoQcFvVybbhwzFU1BwsM3V0dE5jqioCmZdc51zLtue/w9V8WF4p/yNHHYSAN7iYiI04W9Jn7G4W2Tw8KKHAbAYLfikD5/iQwhBi/AWXND5AgA2Wi14jBYMPEOGOavWeZ9c+iQVrgpahLVAemPokJqLV7qwo7bn+XE3cGavFL68cSj/HtcFgG15lXy1bDfldg9SSn5enc21n62gMXy1NIvLPlpWb/lZby9i6P/+bvT9agyrskr5dvmxnWnhmBX+FAmb91ZQZvfw/vxMNuZUHO0m6RwlhFcddQweLbzfYUdarA1u2/fpWZz9thotm15QxVNTt+BTGpc/6mihmMMBcJvCyarawSvrH6y9Qf8r4f40uOSzWouHtRxGhFBnxAa/aVjjgWXXcPXfJzM/d3qt5YYpv6BUVVE9d24zX4XOkeDlmWn8vDr7wBvq6DSSqvKcwO8ik52nCl9kt30nRERAjTrhNrVoQaRDHUdbjxtFv3Cwaj7IFu3/W2ffyuK9anCa3/R7X3ISt296hzZkY/UZuc/SM3Cu39J/AyA+PAZL4t9kVwYnpJ1junN6p2H12mp3BzV+To9CbrmTRenFeH31J791eXLqFlbuKq2XT3BvueofXVrTfP7Rf23O538ztjXb8Q4Hx6zwl11q55x3FpNZpD58z/6xlW+OcUla5/AQ0PwpbhSPA8xmiI6ut53T40NK8Gkv9/0/b+DLpVl8t2I3y3eWHNE2NwWjlh1f8alCbq59T+0NyrPBXl/z3SqiFWFCHXgN3mDeK6/iZa89C4lka1nTkkbrHB2klKzOqv9hCmVPiZ3352fy7B9bG31MHZ0D0YZgKVXfkr85ZYOCT/owfPkxcsTJeKfPp8MvP3PyGf/H01cZ6Dr7N2547k+6FBjBUYalUtXUrchfQdHCl6Asi6Sw4DFXlG4h02Kmi9dOj93z6p2/S0Iy4S3mMys9+FxXekpZU7AGgB9X7eHU1+bjUyQOtyrkRVlNLEwv4o05OwBwehsW/qSUTN2QS6Uz6Pvs8DRsGdpV3Hy5Az9dvAu723dMv4PHrPBXpXVWaIf8tTmfaz5dQWGlc1+7HRd4fQofLcjEuY+H9IRC8SKkD68tgQ1WC9csPB3nzq2I4iLIqS0kbc9XhaiHJ6iRaMM7JgDwxJQtXPHx8iPb7ibgF/6eLa6gZ+wAFFmn37+YAC93gC/OCi7b9gfO3YsZX1EMgFCCM2J/pC+AW6ntJyh79QXA2lnPk3VIpG3B8Ml7zXa4PzbmccmHy/hh1b61ekVarrNK54H9nS77aBm3fL0G5RjXeuscfYz24BjRrgguWqqgSB/irz8QK5eBVfWFO6P9adx8/rO4N6tC2qCtLpj3Py6f9TI/jvsEAFvOajBaSPzzkcAx20a1YY/ZTInRyGfxqj9fvCU4eW8f0w6rIQKDqRKzwUKUJYpCeyG3z7kdALdPsrOohtxyRyDf36RbhpNfEZQD6n4rdxZVsyi9iJIaJw/MfYp3Fy6ne0oUZqPAYqwt9jx1bk/evLw/g9rF1bs3P63KZkvuwVsd3Y3QSB4tjlnhL9yi+itV2IMS+7KdJSzOKKbMfnxHME7dkMsLf6bx5pz0o92UYwBB1hmfk3PyS0zrfq66pEzVghnvv5OSz78IbLlpr/qSWs1G8iq0JMdmA+f1a0W7hPAj3O7GU9LzOlzR7WhdnUeLsFb4ZJ2Pu2b2Jn9TcNmPV7PIVQCKh13jv8UT2Tq4eUiEr6dOhLA8fQI90rYRPmRIs1/HiYRh+u8YfvwGlOYZ3Ddrz+6P+xH+yppgllq5q5Q52wro+MgM5m0vPOT26Ry/pFny+Oo0A7ffYWRJD4FPqJkEZOeuGGbPQPz9F4WvvY7rtEvZOzmYgD6ixgErP8YMyMq9ANhMYbDqU8xbfuOzvAJu7HQR0y+czgCnizyTiRVWM08Ul1DqrgTAZDDRL6kf1XYTpsgdeBQ3Uy+Yyh397sDhdeBVvKRogRgT3lrEvT+uByDMYsATIljV9fO++avVXPvZSj5euhpL/DI2VPzJzHtHk/bsBEx1hL8bRnbgggGtaYgHf93Ihe8tPeh763Trwl+TMRkNdE+JosrpCUjqft+t5oz0ORJIKXls8WOsL1zfqO2NBjWKVXJ0Zu3b8ipr+VYcVQxGqtqOo6rdGRRHtSbcFIm1tyq4iJIiCl9+GftatcKF0+PDYjRw05er+Hl1DjUuL06PwtLMYsqPtQnDjlmw4mMAvOEtqOhwDn/JMtYWL8FXV/PXULSvNZpqg4HlYTakoXaBc48MCgl1NX9IieJ0Ij0e3puXwYcLMpvtkk4kZGstFYanaX5CNS4vH8zPZGNOea3ld53amVO6JbE+u7zWhDeUMnvjzuWuYwKbn6YLfzr7Zol3A9OHGiiJERgV8BnVOr9yvDrZNkz+EVvfPgAM/WEmMTffBMBJlW5oNZBtFjNPbVJLb9pi2qoBaqc+zlCni//MeROE4AK7h2sqVIFvVWrfwLktBgt2rx2pBFO3RJgjCNf8oO1eO/ER6vjm/+53TLJw7vf38Ee6akLukKgmpPY/97nlDnZqFkOXW/UNVzxxlNa4+WVNNjllQf9oKSW55Q4u+XEiV/z0XL170zo2jHP7tWrS/QzVtu/LxHwscMwKf61iw5g4oTv/N6YT6544HbMxmNbjWLajN4RX8TIlcwofNrI2bbRNfdjP7JVyOJvVIC6vjwlvLeL2b4+Mr5hP8fHt1m9x+xpOYyI8dqJ2z8JansHesg20C2+P78HHa21T9ddMAG4a2YGPrxtETJiZ4moXp3ZvAUBxtZsKh6dRTsFHjEmXwp9qSpeo3bMJL1rPt9ERVHrK6RE7oPa2fqHP51JT3IA6wAIZFgsdZ1xOTObUwDqTMDMkaQxWYxgmgykQCfzF9tcpf/UhtvcfQPmvv/LKX9t58c+0w3+txyFilyY0u5sm/P2wKpuXZqaxKL241vIom5nxvVMwGgTV+5h4+YW/CItxv2NgTZ3JcefkqCa1Uef4JKd6Zz0fYPHLJC55egatSiTXzfExfLskIaIVXWP6IIeNRBk+EuWGW4k65ZTAPs5bLsbapRORDjd0m0COyUSaIx+A6LgOENceRv8XBl6Pd/yLnP/7+ThPe5SrKlX3lj+dqpbwvu7XsmL4C0Qse5++4cEJz9DvhvLZOtWl4vf033HKolptjuv0BabY1ZS4swCYdd9oTn55Hl0f+1P9e4valvn/HcttY9V8p2WuUm77dg0P/bqJDdlBM26lw8tJL85la9kGMio3UReb2YDT2zQBrkpzy/jXqA4kRloOsPWBURTJN8uymt0N7JgV/uxuLzd8sYpdRTVEWE2c3z+olj3WozfrYjaaCTeF0zGm44E3Ri1hA2A1Hfnu8VuxlmUemQCJTcWbeGnVS6wrbli1brYX0H72zcRv/oK9VZlsq9zMI2v+L7A+6f7/UHX6uWQWVSMEjO3WgiibiSqnl9N6JNc6VmN8pY4GiZs+ITJ3CT5gSNxQ7unzdHCllKrQ50/b4lMHydA3wAe0nXcXtlLVF2fwjGt4yW7ji7Gzeaj/a/T5rD0tv2jP7Jzf2FQYTHUwqnMiA9vGHtZrO14x/P2X+qO0BNO44aT17deo/dIL1A+gK2QgL7e7eXduOv3axJLx/ARaxzacwDY52sborklsfvpMxH5yXNa1jNQVBnVOTD5Ne4Xn1t5Ta5nxw7dJKLLz5sc+Rm5VR5Uwawyx1gQwmVCeew05eBjCZOKNCwxMGmPg/N/PZ4NzJ2U+E7QZisUSCcD37hh6tT8tePDz3sY47DZ2V+4mrXI34pRHa527S9FO+PYSyJjL5xWlXNn9ysA6r+au8srqV7hv8bWc0kX1xxvVzcKOClVI8yheomwmTIbgu6AoEpPRwOB2cbRPjGBPVRYAZb7trNyluguVO4ITNjUQRGIMy8FtrB1QWun0kFlUw/SNeTQFp9dH95QoBreLq2diPhj+2JTH41O28PbfzesGdswKf3nlqp/TK7O2892K3bx6aT9O7qKGj1uOglB0KDi9TuxeO0V2dQZz77x7GfXDqH1uP7ZbEiM7J/DRgp373Ga/VOyFp+Mgd12Td/VHyh4pwdOg1Z61GBtOsGnQ/N18YQnMzd7LuMi+XPSdGuGljB1H4i23sFqJ5sw3FlJUpWrIIq1mqpxeiqpcgeSgu144i/iI/c/CMgqr+GThTjIKq5vl2vbLWM0h2ufF6KnCFdMRZ2QK53+bjuGph4LbSQXOehWG3QYdx4JmElZ2Lwls4tEEgUUFc5m+5wfCSraQtPmTWqeL07SecVb1HZI+H2ajwPsPm0gdK0jtnvv9T2UjNYBZJao5qsIR1HQUVbl4ddYO0guq9yvUnd+/NV/fNHS/2wDU1NEchn4cjwV+W5tDeSNN2DrNh19oCkW59OrAb1tcCr6+/Vh938UUOnIDy6WUZJRlsKyHgd9PUsfrKcMEfw0RENUS84i7AXCf/Rr0u6rW8YUQWI1WJmf+zjvFq2qt22kvhPB4aDuM8LLduDzBQLXhYa14fezrADh8Dr7InsDCa2Ip9ATLuvVtE82vt5/E2W8Ha58XVbu4Zng7frldzU/od6FJjAxOqB6dvJmvl2UB2ntoUL8b0lA72rd6H8qCKz9eXk8Qu/v7dbw2S21bcrSNT64bTEZhdSCNzKHg0zQyzZmKBo5h4c8fJbNwRxFLNS1U95QowsxGBrStH5VzLLOrYhcA87JVH4W/9/xNhWvfEUQ2sxGbyXjwQsieZarQsO7bJu9qNgoeP6cnk24ZfnDnbiIOr/pyVLgb1jQKzRzsDUvEJiXdzPG0LvThGjEc5bHn8BQWYp47E4vLQbQm6KmaPw93fLeGljE2/rp39AE/mAAfzN/J8zO28dz0xqXSOP31Bdz9fdMFbAASOkGH0eB1YnRVYk/sh9sUTteNRRgWLwhuZzDC0Ftg/P/guilgVgcxg9fJHSZVs5k55nX2jH2bN/N+4rv0d1nWqj8j27fj3c1P8XnaqwAYgZSw1EASaen2MG97Ua38mQWVTjbvrajlSK2zD/r0B0BaG8436cddJ+DGn70gVPjz+wUVVDp58JcNvDF7B+/ObXiWn5ZfyW3frCGjUNUgzt9eyNLM2ibkUE1fvzax3Hxy4ywOR4LMomr+89MG/vPThqPdFB1AGTUm8NtsjcBhhlf2vMiW0jWB5dP3fM+FUy8M/G0ymFjTxUDxkIFUrk7H0m4kANfPvpkKT1W9c9hM6sTelr+FnnHdAstLPZUQFgcJnVliNZJesiWwLtUYxunTHuHqblcSZjDjA2ThNnZXb0EqamEyr8+L1yfZmlcZ2G9Pae18px7NUnLHwOtrLX9iinquSocHYQzuoyiSPzflMe71BQEN+ltX9K+1b16Fg3V7ymot27K3olZmktxyB6/N3sHuZkgfc3IXNW1Oz1b105sdCses8BdKmNnIqa/OJ72wmu9uqZ/48XCRXWrn2s9WsPoQq4vYy1Xhz+Vz8cuOXw64/frscv5OKwxoCZpMW636RUqfJu9qNRn516gO9EmNObhzN5Eih6oN3Vy6usH1fuGv2GzhlfhYClwlWLzgtaqCnmvbNnp++QY97fnYzKpgc8+pXfj3aV2wu32kxoURG27mgZ83sLbOC1uXoR3USUVjo8nTC6uZs/UgK2VkzoVWA8AaicFTiZA+pNdOfixkpIT4tXrdkL8JxV7CjrIdlDnVaxCF24jNV5OIlrU9lYrOFwQChMrM4VQKSVZVOmuK1VnxlMgI8h05eLWUMA1pqob972/OeWdxs+a7+iezKn9VYHJSFxkbj2zbHnz79sNZX7ieQd8OYnmemmbI7VUoqKyfrsWuRSq6fQo/rc7hp9XZfL4kq97xbvhiJbd8vZqZW/LJLnNoy1Zx1Se1Kxx0ToriixuHEGk1ERdurnec5uBg/Wf9UZkFx3m6rn8KYm8wujzHlUPkmg2M2qzUCjrzawEv7XopAGGmMOKqJFe9sJW99z2ApSw4Xvgn2YWvvUbuQxMD2wOY3VUkeL30NMUwK7eYe9xmsMVCQmfSLGY2lafTw6KmglHMYcxw5OBwluNQPGSbTLw9Jx2DLRfF2QoTkeRVeLhtxhNE9ZgYOP+eEjunvDqfL5YEv7kA0hPf4PVXODwIY/Add3h8PDx5ExmF1RRrlqQwc+1KSTazsZ451+72BTKUzNqSz1WfrggcryHcXoXHft/UqLR1kVZV2G3uQNd/jPDn9im4PArP/rH1iKUuyC61syi9mJ9X5xx44/1gn/MUAF3iuvD0sqfpndC7VhLMuqzXhBS723dwg6xVc/B2NV1z6PUpXPXJcl6ftf3AGzcDJqE+2PUiXDUMWuLjEiH4OiaaEl8VFi/4TOqLZk5NBaCdEhyARnVJ5KTOiTjcPsIsJryK5Oc1OezIrz8rDeXyIW05u0/LQI7JA5EcbeW8JkaCBchdByWZICVGdzW20q38lLERc2Q0FREieD+q8uDDUbh/v4OLp17M2b+puf4cQrDWZuVWp4UYewlRe4LliXwl6wEIN0UEAmm+i44i3BRJy5PUGXzYgP60jg3jooFBX1r/4LUhu/yE9xPLqcrhpr9u4ullTze4XpQUIvZkIfKC5rH12eX8+4d1AcfsSi2dhV/b6vYpDG0fz7Pn9+L9qwcG9vN/IBI0t4S8CielNe56Dt57yxy0iFK1KJv3U/EoJtxM1+Qoql1e5m8v4k0tEW5zsTSjmM6P/llP+9EY/JkMIix6WfmjhRJSCtLwrZoqq6RlNCVWdUJ48haJT/pQpMITq24lvWIzACe1OolXxrxClbuKCasVLA51jOhiSOHeXmpOvjCjKuiVfPIpFVOmADC8pWpFMktJpquEUgO0dNkx7l4a0PxFWdWJt0cLbosNS+ShFon8tvtPLm5zGtGKQryoRHG2wmvvxLrrlzEo5lLKzP5xTyE1Lowom6nW5NUv/P13qlrp6Kw+ahDlfeO6IqWka0oU14xQv8Wfn/k5EVYT95+haifLNe38K38Fv4VLM4pJy6+qN3nJr3TykyYnZJc5AnEJ+xL+5qYV8u3yPTzdiITta/eUMaJjAhcNSD3gtk3hmBb+rhzaFlAjbsxGA8t2lrBuTzlFlY0vcH8ofK/l3NpesH+h4UDYK9RkxD3j1dI2H4z7gLmX7bu8VmhiyJKDsfPnahFdeU03rZTUuFmaWcLbczOaft6DoFWkKjxFm2MbXF8U05El496jKrY9ACmJQwhXzBitaioAQ6Qq6CaIoMC2p8TOkoxiatxews3GgPbjQBo9r0+hX5sYBjbSraCg0kXpwfouFW6FtD9gzzK2X7aQ4r63Ea8oJORUMihTBoU/bTD0alq9Kq2+sVMIZkZGEF+dT2RVNu1n3Rg4dKVBfa3DTZF4FLV9doOgf8JwEs++nh5p24gYOhSXVyE0aNQ/w3zgl42c/vqCf1xUfXNi96qmoO2lDU+ClDPPUX9UlAMQe/nlfLd8N1PW5wZ8df0m32gtoW2k1cRPt43g2hHtA1pqAKemDYuPqG1CrvuBsbt9tEsIZ0THBH5ZmxPon7bxtXNY7i6pYe3uoGC2dk95o665sSxIV7X1yw6iak635Cjm/Xcsn1w/uFnbpHNgrMYwbMY6wUT2GqpS4pg0SuGly4zsTjGiGNRUL3ZvNRmVW9hdrX4LHlnwPGv2qMEPDmvQjWbPtdcx7Mb3MQojJoMJqfmohfXvD8BTJz2FRUrMEl7pcg1vjXiW6jwrSs8r4dRHISKR6AmvaMeNYNPJ73BxuzMCx7/DaVTHRlGFq/Ac3EVnAuDxSnwVw1G8kdw8qhN/3TuaZC0nYGqc+k4MSh4EgCl8FxMndOf9qweR9eLZ/HtcF4QQdEqKZGQ3ddsYa4x2n9Tx03+F6SHuV8u1oBHDftyI7CET5wPVmXd5Dqzc2VNiZ9nOEpRmHo+PWeHPKAQXD2xNtM1EhLV2RI+riaHXB4tbO0/dvFn7w+nxMXNzHtl+3wOvG7v2MZ6SOQWDMDAlcwo/bf9pP+dVzze2WxKNcFWrT43mA9Tz/CbvekQjqRUfnSerzsKJYS3rrbaVbOOVDfdzW+ZLOI2qANehxUgs/YZh66gK0sYoNdJsXNuIwH4/rNrD9Z+vxO72EWYxEmY2YjEZDuhkfs1nK5iztZBXL21c5CbA7IM1+/qpKcYT1QZPeDKfxkSzqW805REEzLP+BM8eLaLOj7dVf/X8EeFU1ckHWaHdq3BTFB7Fzabr06iObMXemizW5C/AW1aGr6qK4moXk9ftDewXKpDkVjiZv712ioUTiQiz+jyFRiCGItu2V3+0bY93znJaPv0UVrP6nl8zXJ207q1W7+2KnDSmrA/e5zlbCwLO4QCn90xm3eOn06+Oq4W/gkFOmZ2lGcW4vD7CzEYuHNCa3SV2dhRU8+D4bjx/Ye9a+81NK+Tu79exZOKpjOycQHUjNdmNxf/hO5jqIQaDoENiRCAQS+fIcW+fZ3mw36v8Z9kVzMr+VV1YU8PKLpJFndVnzaQIvAbwSm+tZPEADlnM77vVQLL+FlXIijn/fJTKSoweHz7pQwiBN19NtRJzwQWBfe+rcjPG7qBvXFc604HsBQnkLQZaqmOtf4Lkc1dBx7FERAUtEg5HGeusFqb7gi5fA96/md/Sf8NiUrAYzAE3pc1aNY5WsWr7WkW2IiksiUirNTAhklKyt9xBdqmd7FI7HcMHc3bbK7j6t4dZn13Og79uBKBbShTXj2hX61n1R+uHTozr+kjXhAh8Tq+C26vw/vyMWpr8/m1iAeiQuO/iA37ri3+/pkYdH4hmEf6EEOOFENuFEBlCiIkNrL9BCFEkhFiv/bv5QMfs0TKaMruHaXeP4t5xXWvZ2F1NEMYOBY9P7eCmlGgprXFz27drWZKhCWDuagY6XZi1h0WRCq+ufpVnlz9Ljadh3yq3dt4vbhgSMPM0CX9FiIPw+Tuiwp+9BFPuegC8Sn3BLDprBhHlO7EIEz7tXkXU5ON95mV8510EgAgLA6OR9iET2kibauq959QujO+dghCC5GgrOQeIvPL4JGZT46TtZtOKle0iacN7WCp383lMNJUmDyaDBeGfd/o1f9aIWrt5h98BwOowGwWayfvxFhcRYYoixeNmghJJii2ZeGsSis+BR/GyuzoDy7OPkz7iJIreeKNeU/yDzZm91ECS1bsPzdf1n4zfNGY11g/oiMhdSsonWlSj0wFSIn0+SqrddG4RyW9r93LjFysD0f3PzVzCv39Yz/rsck57bT6fLNrJxwuDkfwmo4G4CAtRNnOt0lP+vH6/rd3LVZ+uoNrlxWY20i0litFdkzAaBFcOaYuU6kfpzklr2V1SE+jHxEgLkVYTNa7mnSwP75hA95SoWum3GktafiXtJ07ns8W7mrVNOgemVXg7Sl1FFDpy+XLHG+B2IzzugBbv/GUKrQu9dE8cxMjk0/GECH/9ktTco05FFX42WdRxydKpE4Z2asJzq1sdE71F6nPv3LIZ6fXy8KKHWdy2H4NcLjCH4S1RNcbujB1QrAY2RVlUC06+z0Gfr/owvzJoeXrPvoP7W6SwSXYkpddbXHnGNry2LRjC9iJt6XgNZWwu3MmEtxbx6GTVRO3/bmZXZlPkKMKjuJm1tYCSahdeRXLZh8u48P2lTPxtIzd+sQGzwYLDmM4ezc9+ZOcEWsaEYbMYa5ludxXX0C81hk+vD1ZIMghBp6Tg+Gx3e4m2mVj3+OlcPrgN363Yzcszt/Pl0qzANsnRVt6/emDAuiml5LPFuwKVfj5dtJNeT/6lFirQ5J1FGbUDuw6VQxb+hBBG4D1gAtATuFII0bOBTX+UUvbX/n16oOMqUnLL16uZs0317zunb1AzdKSEP78GrlcTomz8+3gUSaW7kszirbTzerm6or7peJ/Cn1fBYjIEnGc35VSwp8Te4LYN4hf+CjY3fh+NI635WxGmvqRJYfV958z2QpJ9PlLcDhSP6j9VuWsK18wdzeqihYHtyl79EO/5lwb+jtKSZJ8/oFWgvm+/1NiAeW1fuL0KSzJKGPzcnAOW0hJCML5XCt0ONoFuK83nq2g7Katewlq5C6+AkWsdRFa5Axnu/X3ptYQIf4qC11ke+NNjUDV2w8M78cno6VxUXcPLu7dyXdzJvDPqN/p9OwDFpQ64Bo8qGChuNzeN7BAw9QL854yuXDY4lWuGtyMhwnLsVUU5giSHJzOq9ahAKqJQTM4SSrer/WH48iNMp49g24ABVLu8JERYKKp2sSSzhJYR6pglpZGuyZGU1rjILKohOsyMy6sEZvTLMkt4aWYaBgMsffhUAJ44pyfje7dkSUZxoOTb2K4t6JsaQ782sXx901BS48L4Y2Mu132+kpdmbmf6xjxOf2Mhr8/egdkosJqMRFrNze4oPqZrEjPvHU2b+H1rLfaFP13FjE3Nq8XQOTC/7vqCd7c8BcCQpDFgV78/Dm1+0zFfHfujbPHE25LwhlQKCjfWtjxk2dRti15/HXOHDgA83OZfAIT160fyIw9T/vMvKNXVOKsr2L1zO+VnvAwJnVEc6pgmKnergW9A78TeRIjgWKSETHa7eaHIBL2MW3HJYlrEGBEYAIU2ijoJ+2zpZkxaIYhxPZIDab2m7ZwGQKcWqnbAajZiNhp496oBFFe7WJJRQkz8Thbl/4kQkm35qnbwogGpzNqaz0cLduL2KiiKREpJVkkNg9vHkxQVnBQaDYKTOiUSq7kXtY4NY3jHBOIiLFhMBnK04KxQfUFOmQOjQZASo37/5mwr5Nk/tvL0NDUKedIK1VUst9wRGCf8/v/TNuTWi/A/GJpD8zcUyJBS7pRSuoEfgKbbG+vgNy08+8dWlmWWcOcpnTlNq9gQeuMPJ26vwvCO8bx1xYADb6zhF0y/XLKLq6ZfxQXzbmePyURmfP1ZstPbcKTPf07vyvtXDWTQs7NZn13OLV+v5uHJGxvfcH9FiMX1tTsHwndE/byCBexSwlRn1uhdMwjPVyOlbGXb8QF7zGZyXYWsLnDR123mnQ+8xM9VkxVXOr1ctaCCGXuDfqBRmkCzdneZlsQT3rlyAJ/dsP96tn7BvbjaFdhvXyiKxONTDt4F4ea/QRigWjUbOxJ64TE0YApL7AIXfEBMx1NojYXWYUngKMM3M6hgdwtBsdHA20V/srNiG85IdSa+emtGYMSZvWcv57W8EKOmVZYuN2aTqGWyuHpYO16+pB8nd0nihYv6BGalJyIWo4VV+atIL6ufckUKU9AhqEyLvnZ7+PqGwXx38zASIy24vQqjWo3TNjLy0sV9qdY0cP4kzv5nbHVWKR/Mz8QgBEYhuGZ4W/qkxlDh8LCzKJgr7JkLetXStqXlV/G4lrLikkGpPHBmN/VDJYNWizbxYQET2MGiKLKWyarG5eWpqVsOKhG8v13HWOrBE4KFeTMCv80GC0RE4n33c9b2CKNzdC+6JgxExiew8MpB7KrcXkvztyx/Ua1j5SYIFK0PZUEhk8YYqImx4quowFdZiSFCFRaVmhqS0ot5/SMP85ZPhYhEIkeNpO3N/Wg5tAyMwTHPERL0ZzVYub3f7dzZ/046u9Wx/enkr/FKjxY9bKB9oo3nzlODSYTRSWpcOG3iw/j0+sGBwCJ/wEf7RBsZz08ITHb7tI4JVA3zhW2gxKlqK1O3f0QM1azeXRpIIRNmNuLyKlQ6vLSMCSOnzM6ni4Ka+wq7h7T8Sjonqdd865hOfHzdYF6btZ2/txVwoVY3+M/NedzwxUoAlmYWc+s3a1i4QxXivtK0gpFWE3a3N1CeLqfcEWizPyvA3d+vqxfhfzA0h/DXGgitRp6jLavLxUKIjUKIX4QQbRo6kBDi/4QQq4UQq4uLg/5G+ZUOpJQ4vT76tYnlssEN7t7sPHdhb54+r/eBNwzBL0BIYHelmjH82+goFin1NX9100j4fRAsJgMRVhMlNW7sbi9xERbCzE2IjovQIol9TQtGMDz+AOLR+3np4j4seGDsAbd3exVu+nIVUzfkHnDbBjGHo/S9DIDsmp0gFdr9fRud/lC1eD5TOF5tErC4aBHCaMHq9JBcDtKpakJLql2MyN1Mu23BBKJRNvVe3fbt2oCfRGPy/Ll9SiCsv+oA1UDyKp1aOp4maGRDMRhUn8xoVePpCU/BF+K7l1e8HT49HXbOh/5XEd7lTGZev4aZl80Fr4P2Xi+ftVfvk9May9rRL/JXzWYeW3Mrt3ccxMD2bdi192deXHcfxUYDET7JNff8TO/dmvDndvHRgp2ByYrT42NrbmUg0vmMXin0bn1k0v3sj2qXN5CZ/0hS7izH5XORWVG/9nFc+s8YLQrEROHrFRwfFIcTk9FAgha48ctqTbslvORVOCnQfPgCwp8WTejw+DAZBGajgVdmbadrchRJkVZOe20+00M0ZP4i8XtK7Ix8cW5AIwjqhOXOUzrzq5bc1s+947ry8221lzWV/83YRvfHZ7K33EFJtYtf1+bw5dIslh9EwId/fGzM+6hz+NhVlQZmM3TvSXkktIpoh80Wjc9o4KNdr7OyaD6xlgSu7Hx7vX1v6nUTuQmCL19W8/u5t6UhBbyy4wOqFyxg57nnITWBzVtaSpf1qoDT4Yd0dl9zDQARA3phjfaBWx0/JZL3T3ufNlrUr9Fg5I4NM7ktcy3Rg28BoMSrBl6EmcIQmPApXqZlqpq9ZGM+3SMdlNXUnrT7hb9Hhj1Sy3XMZDQE3kODKfhtPrPyW8YbV/H9ymw2ZJcDsOHJMwizGIkJNzPvv2NpEWXjvXlBs3R2mZ1VWWX18ml+uSSLxRnF9GwZzf+N7kie5kctpQwIcv6UNN/ePIxRnRMps3vYWRS0CO4tc3DzyR2Z0DvlH5vqZRrQXkrZF5gNfNXQRlLKj6WUg6WUg5OSgqlQwsxGrvt8JRmF1bx1ef8j0mCArslRzE0rZMJbi+qt25Bdzs6i+qlU3FreLynVjrq82+VU9764weM7fbU1fye/PI+TX57HlPV7+Xih+tHJLXdSXO1qmoap72XQ/ZxAKbDGYli2CNfChVw+pC3tEiIOuL3RIJibVsj2/MoDbtsgYbH4tCokC3KnY7LXD564p6yc1h4vu6p38FyUEZ9HfZndmixsd/u4MHMhSTMnB/bp3yaWx89RPQ/86Us8PoWrP10eyOweyry0Qjw+hcsGt+ECbZZ2IM2fP4rrlG77TtmzT9x2eH8EdB0PPS8AQCpeJApuE8zpL/A6SyFnJaz5EvYsx+4oZX3hejU5uEd9bqxL3wHAaxCUxHUOHD7PU4RHCPqylo1lqyk1GHktMbZWExR38Pp8imR3iZ2z3l7Egh3qpCu9oKpZTAuHyt2T1nLZR8uOeEWIAu1Z3Fxc33XC4K4GAYaeXQIphwAe/X4lC9IKAvU8P970AQDtE63c8d1a0rRUQ620j45/guHw+AKTjgXbi1iVVUaLaCvF1W7WhETtjn5lHj+u2oPRKAIO634e+11tZ7/UGH6+bQRT7xrZPDcC+Fz7QI18cS6DnpsTEFoPJhm4f5+jqvkrKqR88u94S09cn9aLO/wLCgsQf07ljR4fcX77a1lWMh9TURFDdkgU6SPaEssprc5lgFBdWy73qFq6VpGtmDh0Ig+PezlwvNRiSYd8ieJw4i0oQNjUZ7xm8WJ6L1UnMJZKA/bVa8id+DC7P99GpeUsZJ8r8VVXYxAGRqaOokOS6qeuSAVi28C2aYRrLjLVZV6QkjBTGElhSRSUG/gjQ0318oDlGx7adjHVLi+3fxtMUO30OkkMSyQxLLHePQi3mABJiTeDKEsUMUoKEiiTqgav3O7BZBD1KorZzAacIVG6fp9A/7fmzu/W8uAvG7BZjDg9PmZvK+CywW24foRaZ9jjk4F9QiN4z+7bkgm9UwJaPyCg9Y+wmpo9+X5zCH97gVBVXKq2LICUskRK6bfLfQoMasoJrGYjJoOgRZSNh37dyBuzmzdv1b6YsSmPOdsKAtn0Q7noi28Y9+4P9ZZ31XzA2qSoAtHg5MHYi3fQIeRje0W3K2gT1QZDyO0PDSCYm1bIPC3S8utlWRRVuSipbuLHzxoNroNLUXPXpLVc+9mB1cr+bOqhGogm4XUjS9QZlCJ9eCNaYk8aQHVLVVOx9+QX6ejxMsipCjuTrQoml1/4Cwbj1JhtGBzBFyYh0srQ9mpSz3Atn5jZaCC71FFPW7Exp5wbv1zF89O3cfvYTlw9TDV1Hkjz5zeDHZRp1ONQU704KwMmepOrgpVZ2RiFEYcFSvI1s8KeZfD5mWRtn8q1f17LqB9GUVidS67JyPfRUTxTVELXiM7InHnBw1dnYZKS3xQ1XUKF0cBXMdFUJaoCvW3IYCLOPQ+AO8Z2otMjM3hViz6N1vwlP164k/uPgSoM/qotR8rP14/fISEQdR2CkD6kT6AsX4dpa7AqQeSUH2lxwVhaCc2nyeiggzuBx7teAlISHWZidNckzuyVTOb/zgpUKnJ6fNi0D8fecgfTNuSSWViD2SgCZtInz9Wi2w2GgKCYr6WCaRsfzn3jugKqRmNI+3j6psYCajT6Be8tOaAP6/6oa2nxf4MOxkUkQjNhWUKE5iON2JFG3sMPU71Q9Rt+auoWPlxQX8N7PGM12hAZ2zG+9j+ce/NZU7CScm2+33s3eBUfdm8NJc4Cnq1RNdktqoq4vc8tPLfiOXoW7SLeGfy+jNksuXl9PFIbn03x6rNdvSDom+0PYqv4/Xfsa9aRPzWLvY88zY7BQwLfv8HJagqgpLAkGHILeOy0+fNRPvEOoeevEfw3vRMdYjow58qf6GG9Dq9XfZ7CFQWjVL+xhpCZhdvnpthRzIydQZO3n0+vH8zjFyZh91Vw/6D7WXzq0yT5FJ45VfUTr3B48CqSG79YGTD13vjFSqwmIy6vDykllU4PyzX3h+s+X6m6ahTXUFrjIcxspMbl4+5J6/hy6a5AZgin1xfwP/cHdz46eRMRVhO3jukUKFN6y8kdGNExgXf+TsenSBY8cAoAWS+eTdaLZ9e7nhqXl/YTpzfan7Y5hL9VQBchRAchhAW4ApgauoEQIjSPx3nAtsYc+L9nqANamJZRe9PeClbsKiVXk4Z9iuSD+ZnNrg718+KfaazZXYbHJ+ulNQhv9zERHd+qt0+UzUyb+DDiTK2ZOHQiC7f/Qm75Dozax+SesE48OvxRZlw0gz5JwWjcomq1w586t2et1DL+8lvmptTaXfQ6bJgEroPTyP2xMY9F6QfW+vi1kQddH7ZgE221AIQwUyRfbH+dWyOdeCLUaFNPVFsWJLRlnS0YyuvsrNaiTIjWZlFehRqTDYO9dvDMil3qC+mfjQH0SY1h097ayXH9H9flO0uocHiICTNzTt+WJEbu36/UL/xlFtXsd7sG8ft6/vkArP6MrVevw5nUlzApMXp8nLtSUl1ZW3D3GoN1icsdJRQZjUyPjCDR5yNKkVi2fR5YX2UQoJhYrqi+qiWRrTh7pUJUcQ3K0BF0+OYbrKeN046lDpj+gckvbMWGm2sFfMxLK+T7lXuafq2HyMjO6oy9oXRLLq+vXiLk5sKfZzE0Ia4fR1I/2p1arPpTCpjbV7CjFQzLUwXBduFGbh3TEYPBw9mrPCTdfBlnZS1jbLcWfH3TUExGQ8AnCVQtcuhzChBhNQYEpfgIS+A+2Mwhwp9mRp79n9H8e1yXBq+jyulhfXb5ATXZ+2Ncj+Raf/utGx5v09/7MV2TWP3YuFpJro841eq4mDfxYaSUrN++l3UZ+UevPUcA/yTGn+dvxp4fAgEfE5d/ztcbZ/DTaCMui0AxChTpI71iEw+vvJG9TtWt5534WHLK1HHVsvgtKNxK8qOPBs4R5lAC5l5b3750+O1XpFQgouHAIF9FBVWzZwOgVKjj8o29b2TT9ZvoldgLWvWHdiMJ37OcDgu3IYCrr7qXISlDkOV7eKj4UcwIojy9ONPuQIYnYjEZSI0Nfi9u6H0DAsFPO37igw0f8ODCBwPrWsWG0TalEoFgQIsB4FTbEKWVYW0ZY8NqMjBvexFlNR427a0go6gam9kQ8Ku95avVvBaijHJ5fNjdXiKsaoqx3HIHbp/Ct8v3sEH7ljs9voDmz58T8Oc1OWzZW0GFwxNY9t8zuzG6UyxXLjuX6Ky/DtjHuzUXpLp1h/fFIQt/UrVv3gX8hSrU/SSl3CKEeEYIcZ622T1CiC1CiA3APcANjTn2oHbxtIiyEmk1BZwzIagF+HNzHi/NTOO1WdvZvLeCV0MycTcHoR+cA6V78TtF55TZaRFlY2y31rSKaMW0ghVkmU1kWNSP9y5jGM8se4ZZWbNq7Z9ZqL6InVpE4vYqJEZaOb9/q4Cz5/AODZenqUvfr/rynxw1mzlX7TuXYHPgT1Dp8x2k8Ofz0NXjoZ0iiDRHMTvnN9ZTQ85YVaiOS5vEJwnJZIfkn1NS+qGMHEPbjqp2sGtyFMP7tMVYkMf2gYMCCUb9E4JWIQNB39YxZJc6amlB/H08vGMCw//3N18vy+LdqwYyqF39RM8l1S7GvjKPHQVVAbX/SzPTmn7doYE+jnJ8YQk4DQZeio9l1bmqliXBUFuo8ZqDTvuVNXn4tFqVUyMj2OvKx4Mg0i756QUv9/8oMUgDbxtUs3Dm0Ac5dYPaXnv2DrJ3rMGZrWajn7RiD23ig/coWvOXjA234PAEhavPl+zig/mZRzzxs//8DWn+xrw8n+6Pzzws51W05+il0S/VWycRGOOsSKORqlNG8+HZRsyd+5Oq5deUTgeb91YQEebDUKyabe/e8Bs15apAb3d7efi3TSzcUcTOomqeOLcXs+8bU+sckVYTERYT5/RtyZQ7R/KH5ldrMxmxahPBIe3jePLcnlj3o0XzC5AH0mTvi3V7yjAZBY+d3YMnz+3JZ9cPDrwzB5t0NjHSWivK/IhTFZxYVS9YwKOTHuOSb1/g+yWZzNxcXwj8Zvlu2k+cfkja06ONQPBgv1e4rNP/AbA7fx2GT94HwJu0AYNNHQ+MPpAGAz7pDQiMMY5SunrUvp6W8xugVuvAHIalvToJr7aBq7wERdP8GWNisHbrhis9g7DTTiHvjvMgPAyEIOaCC4iaMB6kJOEW1Z/PnbMX6fXWG1/kJd/g7Xk1eRXhSEWQ/eS7SCmZ+O35LIvIwCKrSQq3kh3Zj6rTX8XtVTCbJMVp02DeC3QNS2Z4y+F4FA+/pf/Gn7v+VF1nNE5vdzpLrlxCjaeGs1a9xlaLmd2lqnLp8iFt+ExL6eL0+sgrd6rpX7Tvkcvrq1eC1eVVqHH5CLeYsFmMAe18rW08CteNaE/HpAhqXF58isTtVZi3vZB+T8/izN4ppD8/AYEgY1cmid48brN/yH9+XI/T46P9xOm0nzi93nH97+P+ElCH0iw+f1LKGVLKrlLKTlLK57VlT0gpp2q/H5ZS9pJS9pNSniKlbNQXs8bl5a0rBtC7dQzmEGdN/+BTqZWXcbh9/LZ2Lz+uPkjz4z4IFfhCfzf0Abz/5w10f3wm6/aUs2Z3GWEReczTZhD/qqjkrrJyAKZVb+bnHT9z/4L7WZgTVInHhptJjLRw7WcrSS+sJjUujLeuGECPllGM6JjAw2f1aFSbJZLZ7kKIaQNthx/MZTca/wc5VMBqEj43bsABeBqIfG654jkUn4uecQO5oP11GBBEy13Yn3gKZxfVuTYuwkLbNmoUuGK3o9jVF/fecV3Z/tx4OiQGfRf7aAEMW3KDGtH4CAsXDWjNdSPa4fYp9fw7QimudpNVYie9oJrWccFrbnKy29Br3bua5NWv4PZU821MNE6D+kxHKrU/jqGav6rsFXg1P9KZkRF8teszBrhcfFuhChB9syT9vB2JNEbQXlrAVU6Y5nQRmVdC9XnXUHb/fYHj+StEWIyGQOqBuHD1fOV2Dzd9uYrsUjt7Su3sLK5hT4md12dtPyKC4HfL9wTaVpfYw1S3FoKav4ZSvfhscVRsEQifD1NJCYmmJJLSg0FPvsoqxkx6gwlr8omvCt6jZ79exFWfLMdoEHy/cg83f7WaU19bwMRfN9Z77iJtJi4a2JrRXZJweHyBijthFiMGg+Dcfq24YEBrbhzZYb/XcTB1QR/6ZSNXfbKcuWkFXPj+Um74YhVbcyu5cWQHTuuRTNuECMb1SOap83o1+ph+fl+3l/YTp/PDUdAi+xFVwfe/4J33KDfaSM3LZNmbn/LAL/VdHfw1Xvdl5n5q6hZe+LNRxqyjhtFgpEtMbzaWqNGmvXZLREkRslMXqsIBaWb0JgWTTzKi9Zlc0P76QHUgIloyUXSqdTwzEszh+MrKiLv2Whw929POkIitVy/irroKfD4KX38dabeT0dbEg/F/E375xbT4739p9eILRI1TLQ/WbmopNfeuXaT17kPR67UzVDiz8kh/Yh7WNPX9cm7eyqasheyx1LDZasErjOz0rGXKaZeRZu5JJHYWln7IKSse4dEtH3PZj6eyae8SvDXF5Neogr3/fz9RlijciptsXwHlBiNFSjTT7hrFGT1TCLOo7+WqrFL2ljtoHRvGNcPbsfGpM4i0mnjp4r4ADNOUM06/5s9i5JfbRvCGFqPgn7A9cGY32sSH0yY+nI+uGcS7Vw/E7lbfzbbx6reqsNKF2Wjg5zXZ3PqZKiO4pYnf1u3db8Uvf+qlCb1T9v0ghHDMVvgAeHXWdr5cqjobnxZievCbGyOsqgQ+olMCZXY3FQ5Ps36Q3F6F9gnhgRQzwfMrVO94jKrtTwSW+SslbMwpB2D2nllMzlCDELq5PNxaXknH7FNrHSf0IezRMprXL+uvLq9wBj4GTo+Czdz4bhrZeiS9DOFQlQ8bfoC1X8PiNxu1r/f1D3D+685AepAD5fzz98NzdSoMNBqvm78iwik0SM6IGURnt5tWPmi98AGQCkZPNV4hMAoTBmEkWhpoueoF/rvsKr7erl5TfoWTjSep9W7D+vXDEBbUkNXViHRMiuSUbkmBSgygZnF/7bJ+WEwGfIrEbDQw9Pk5/G9G/cHc3w9Oj48OiRE8cKY2cDXVEddkg46nQKw6a26x/h28UsHok4yaqvprVBap93aB5h7rMQUFnWpLON6K4Mdzfdlq/owIR+xWc2IKk8KTncfTO7IlU3dnMW7RE4S5YefY7tg1GdLg9fCyNnAtyVBNOU+d1yvgI+kviVda42ZRehF9NB+yeWmFPPr7Jt6emxHIX3U46ZsaQ8sYG20T6puOuqdE1dJaNic9EnpwebfL2VpSv/ZmVeoYCjZoJdvmLeKZKRFE5gXrjXuy93By7kaunFtEfBVUak0cGOnF7vZhNRmxmQ2B52bW1oJAqoe7T+2MQaiuLvef0Q2vIvltrTq2hJmNgYnWO1eqk+LQoI+G8At/TanV/OPqbJZmltC7VTDae0lmMZd+uJSPFmRy7fB2fHqQ5dn8Jev+2nIUzazVVRiiozHExODr0Ilbxj1EpTmc1OrCBjWkfk3PvuoRZxRWs+ooRKQ3BZfPxdzcaawvUVNk5afY8N11P77X3sdgAqmYaVGubhtt1fL8aale9k6YRHrvu2sdz6Jp/sonT8a5eTNdu5+EtcZD1NixpDzxOAhB6WefE3PRReQP6UCrvU48F44j4V83AWBOUQUUY0w0LR54AHOqGmhX+s03tc7jDcn6kZ2s1XOvqsAkYZtMZXzix7SJasOe4q0M/WUo352Uzx63GqA5NSqSbbipNhjw2IO+3iWO4O8XVrzA5PTJ2Izqd6NamPFYYuiTGsNjUzZz34/qZODlmdvZW+6gZYwNm9lItM2sFQ9Q97NGpWOw5eD0KIzqnEj3ltGYjQYqNNcZfwYKfzDY4vRi9pTaKax0MuaV+QC018a4Dxdk8tLMNLolR5EvVaFyiaJ+Y0uq913aNibMTNaLZ3P3aQ27gNTlmBb+0vKr+GtLARUOD+f1a0Wqpm3ppQ1KbePDuXRQKtM35jF53V7cXiUQQt0cuL0K43u35LMbhgQc4UGdRUtfJFcP6c7mvRWc/faiQMfN2KQOagvScwLbT48MZ+O4/zHZ+2Wt44emeimpdgUSU751RX8+uW4w3R//k5gwM4VVLka/PI/GkGhLpEjxgOKBybfC1LthzpONu+C+A3BedCX+mnIHii5KjQvnnlM7B0Lmm4zPjdTO1clZw+S9+UypsBBeuBaDlgDbJwzsqNhEoSOXSaI7zl12XnmlgOgc1cS2ZncZD32/GoDos89CGPdtAkuJsfHFjUMZ0r62Cf2XNTmMekm9vxaTWke6oQAbv8/GrmK1ioLfj6rJwl9CJ7jud+g4NrDIY4nE4gWhydsFkb3p6/yE1EtehMu+oVtSXx4xtqSz201s7nqYdk+tQ34eG0NGpSo4SsXIPXOqKPBFIaSXri4PEW5JamQLLNq3TbrdgaSooPqaXj4k6Ng/pEM8k24eRqTVhMcnGdQ2lvgICzuLa7h4YOrBXfdB4PIqgVlzXaZuyCW79PAIoFajlfSydJbnLa+3TkoDgSRnwM5o9VmNPu9c4m+4gdCajAnVkNlS/TvOVR74CMSEmembGsPwjuqz+HeaKjwOahfH7WM7IYRASslPq7P5e5vqj/nIWd1rabIf/m0T9/+8/6Cc+AgLA9rGBvwEm0JchCUwJhVUuliVVcYLf6pGm7f/TufDBZlc//lK/vXlqv0dphZ+q01jTVPVLi/Xfb6SrSHa+kNFueYm2n/3LWG9euHZpgr35dZI4rQAudI62pU0LZtBjbu+YCilJDnaFvC/PFYpc5bxfYZq5o21JJAb60NecClERgEKg5MHcXI7NT3vkjEpbChZgVcLoDAJMy+kBS0F0UYbMT4FzOF4snNwrFtH3FVXkvr+eyhuN9LrRZhMiLAwjDExpLn38MKXPvK/Cyb5CBs4kDaffUr44MEk/OumgDAofXXcXbRqIXtTzCzurg6ONmxUG+PxmcN44pQkorweqncvQfEKEr75hYQytZ/6WhICx/FEJmHSAk6KHeoxpZRMzpjMjrIdgUo+isHHiLbhfLdiN7O3FIRkolXplhLFrk2LeXfyXAqrnEz8bRMAW9xf0qnTWqJsJj6+bjCXDErlry35/L5+L7/ePiKQPeOlmdvJKKzm08U7ue/H9dz27drA8+bX3C3OKGbahly6pkRRQxjtnZP4MFod7/3BIFD/+1xY6WRxenFAk3ggjmnhz48QqraltMbN5YPb8F9N49K/TSyjuiQGHB2h/ot7KMz49yhuGtW+3vJd5TlE9ZjIDt7l0d83syW3klO6t+Dcfq24aKA6g1GEC7OWtHdmZATfZ8ytd7NDkzxf9tEynpmmDkRF1S6sJjWc/KTOCQzvmEBhlZMX/ty2X8nfq3iZkjmFQjwo0VqqxQ5jwGCunV68IZxOjOecQstJH/Hu5X1Z/di4WrVeG8L/IXrxz4PwewNo0R2fZr5cX7aaDIuFH+MT8SgeDB41jY5XgMvnYHH+X1QaTUiXl6gaBZcMpptozwIAChbOwZN74JyDodrhb5bv5oFfggm0LUYD8REWSmrq3+dCTWtR4/by69ocPlqgRuR6DjYSte2IwE+v0YIxZNzbWZFGJRHIFj2g53kkRrbkyitnMHnQo5ycOoaTHE5WnDO51uFqfNoHVZHsSp3JvBLJdS1bsMCiCufmFZsxaU31Ol38JySat09qbK0ghMRIKyd1TgwIuCkxNpKjbbg8SkCAqT5IP7KmsDGnnKwSe7BcooaiSA61GM01M67hwikXNrhub/Ve1hauZU9lffNk64UPALCrpfp+rIgr4P47wmj10kskT3wIQ2SwGsLPFyYxY7B6XytzigKauJgwM61iwvh3ixo6lecEUp+M7daCB87sDsCdk9ayPrs8IIBVhWjvLnx/CSt3lR6wRm6b+HAm3zGSkzrXT3WxL166WA1Ee/Wv7Q0G1Dz++2Zen72D+dsLWbCjKCC4Ngb/B6uxXbdqVykLdxQFUl7UZX3hepbuXdro8wMQF4+1SxdiL78ce0f1WzLllGuZ1O10gHra1E3apK+wsv6YsGxnCb+uzSG3wlnPUtLx4emBMf1o4wlJ+1XuLiGlVOLLUgMDvIqBsiobBrP6LP2R9R0L82bQPbY/d6deTZ+5tSeaN/W+kcg7VkJMGzw5qpLD0qkT4YMGkf/kU2ScrmYZkA4HpV99RZvotrhNkPDjPArffBNQ8zxGjhyJISwMT0EB7l27sPXuTeuXXqx1Lm+x+t5/+u8ulGjFlGzWJEos7YiRpTz39Ui2OvKp8TmosYyhalMhLyxP5c6KGs7yqQJdN5ebb8e8wSCjqq0vqVGf11JnKQ6vg9SoVKwmdVuXEIQPuIRHJ2/G7VPo1TKGjOcnEG4xclKnBM7v35rW064mYc3b7CqqYUN2OUaDwC2KyFeW0j5kcrY9v4o/NubRp3Us95zWheRoK6U1bvIqHDjcPipDxs/f7xzJFUODk+8wTbs4KLqCxzvv4s2L1eDXUOHPUefdXLazhGs+W8F9P67fx1NQm3+E8GczGXlpZhp2t4+HJnQPLPcpkv/8tIHtBVVgsCNMFYF6mE3Fn2A5lM4totiUU8GQ5+fw9qovmL1bjUzKq1JnDmmVS3nsbNUX75RuLXjnygGBD6MUTtpFt2P2Jeo+/UvqaxD8CSgVRZJd5qBvagwGAU9M2cKva9WXauWuUoqqXDg9Ch8t2Mkjkzft8xrcWlLnsaljkRd+qC60RKhaQEcZwudC7KOqCC4nwunA8d03nNnaesBoV1Ad19fuKWdVVmmg4HWTiO+IzFcFr+9dGVzYOoVXyaVa+jC6VeHvoRYXcEWn2wB4RdmN9GiJcTXfOLdPYXuHcn49ScDiVbh27r9m6O3frqHDwzPo8+RfVDk9OEJmSUM7xDO4fTzxEZYGJxF+h1qjEIGP4gsX9Qk41TeazLnwZh+1qPmo+1AMFnzIgGD2yZkGnLFOHjZ9x7Vv/8H78zMoshextGAl9j6XQFx7AMzT/l3rsEatBFxpJFg8BhZ6e7LOZmNJtI1fbndiP6V/YFvprn19DWnXZm7OD6QNSI62MeOeUbx2WT9enaVGtx1sEEFT8PuVVjhqR6v6BaFDqfazoWgDGeUZDa7zC30FDeSe/EWqz2ZhlOZ7HA7ZMR7umrQWpaYGT04w09WUTqVs7Cj4z9V9mdVuaKC90TYzM7fkEzvxbt6d/2aD75t/8pUYbiTc4+TlmdsDmQ78GrQDCX/7Qsr6GQz8nNQpkYsGtuajhTsbtKT4ndj9CXUHto0NtGlV1v7Nny5N+GtshgD/+W/5ejVdH/2TM99YWGv9tX9ey61zbm3UsfyIWdOpmj+f6DPPIP2auwDoOO5kdsW0qnVOP51aqMJ8Q5ru0IS8xSET8wq7B0UGcyQGr8fL9I15AfP3kSK0WgfAq2knY3liIlG7/qR6+9Ns3taH2bt/AaBnhhOf9JESnsqZ1g4k5S2ntTmGCdXqtWbbC5GJXcBkIfK00wDw5udTMW0a3pJiDJagfzKKwr/6/AtzeO3ycKHkP/0MBS+/Qodffib6LNWFp+KP6RS++Sa+4mI1eMQWSVkkpLUGm9FMx9hUpCuS32xmwlySKpOZrDZqOqSWPi9Xl5Xyo0m9x3aDIOabS/gkYxMRioLTrX6rcqrVb2zryNZEmiMZFNaSpHxwVdgCbldRNhMmo4HLBrdhfXY5N828idviLVxpmhdQOoUK/dmldgY9O5uZm/NI0Ey8ny3exZiuSXx6nRo84nDXz1JQ6fBgNRm5b1xXIq0mwrTo/7PDtvCvnEfpuP5VYsPNtbR93jqBlv4a3o0ty/mPEP7MRjX7vc1s4NVZ27nyY1WQ+t+MtMCNj+7yGpFdXgjk2Wsqj0zeVCu3ncvr49NFO9m8t5KimnI+2fo6j85/hdxyB9XeoKDjT9GwaW8Ff2zMJcpmpnOLSDC4iTRHUuZUo/0SNXV2K2Hlpt430T+pP3E2NaK0oMqp+hcmRnCVlmdu1a5STAbB/O1FtSpo7M/Pyi/8DW81HKNN89fZruU3KthC7y+6EL/9+4Z3dgUHrvdnbePU1+YHPjShKIoM+A9NXZ/L4oxi8iqcnP7GQrKKa+ptv1/spSgl6uzTYwp+/By4ccW0J+3ypcR0vJQ2kaqz8RpZDlpqGKchqPnzmgRLe6iPslJdP/F2KP4s71UuL0szS2qZDW88qT3928SSEGlp0Ozr/+BeMbQtDq3awmWD2xxQQ1oPZwWUaxoljxNptJISnsqcPeqkwmcAc00ut5qmE+6rIr/CyYr8Fdw6+1ZO+n4EX+6ZyXqrhcdqthGmBAeDTVf1596nWnPb3SasFhdLlP4AZJrN/BQThStCVS+FnXUmyq3qR+9srWZ2Q9fwzLQt/LQ6h/5tYmkVGxaoyuAvfn4kijRcf1J7gHqDpT/p80Pju9fdpVloKMWLnxrtng/boY49lWHqjdi8eRfbBw0m673XA9s+7DuT78dPYm9KJe7IYk7uoiYFf/mSvrWOecZX/2P3tdfhLS2l5LPPKXzrLUbM+4nWVYVM+OMTfp3+GEgZ6Ce/GfdAwp+UkglvLeKzxbt4d24607Sx5K8tBXy/ak89bZWiSC7+YClLNT/Q2feN5q0r+tfaxt8X27UJ3y1aZYN35qZz6YfLWK9VRmgIfxoOn9I4bXlov7t9SuCcfka0HEHfpL51d9svhu++pHKqmo3MYjRgMghcOzO5W+xi41NnMKJTQq3trwsk592/8JcXYvrdoeWG7d06GrdXCeybVWznzklrAz7iRwq3Uns8ExUVmI01tP/7VkYYtiLMZTg0ma1lkRdF+ih25rOtOgMFtdyhDzg9tie/pv+Kb9m7oCikvvUm3davw7FpE7kPPIg7cyfCqo7lbT75hPa//ILJYMJiUX3jDLb6pQYNkRH4KiqoXrSISi31S8lHH1Hy4UcYIqNIvON2Hh/+OOf07MqGSxSiihfz5dpPGVPai3t+l3z1uo+xO038tkTtU1/fat6rSSJcK53mMpr4hAoEsKzvg9zeT1Um+Cd4rSNbE2eL4+29XYn7I4ai117Cqn0n/Kmvzu3XigdKV/Kvx5axSvMrrxvpC/DDqj2U1Lgx+FykmNT1/owQAZ9xzT2tc4ugQHzd5yvZWVTNv8d1oXfr6MB7fmoHGwVGI+dUzuGnAZO5dmhqIM+f3yLgx2/uDXXn2R/HtPB3Rk81yEMIgckgcHoUZm0pCMw8q0JyV0mDeqOb/CHWWJReTFaJnQd+3sCfm/Kodnp5bvo2NuaUYzCpPh8O8vjPT+tJiAoOAk9PVdX6r/y1nbsmreO9eRkMaBOLtewKnhv6CA9OUwtPJ2jC319hfbhv0H18c9Y3XNvzWiCYn6ddQjjPXdCHlGhbwPcMamfDv/vUYCWHuvgrhsxZ+RY5sx6qvVLL+Wct30cyU3dQ+Pt52U52FtU06CT+9tx0ej35FxUOT730G3W1M0szi3lk8qZa/VSLrb/T06UOSmZD8EGuiG4HBjOeqFQWliwhszJoOinuqToMD22tmhY8XgV3yRhO7qLOGJWa/Qt/oa/Frd+s4ZvluwN/by+owunxMaZrEuf3b1Vv3xq3D7NR0LlFZEDlviqrtFHO9F7FS5+v+vBj2o/B2svrvoUVH7LjEjVLvRTqs3vjbIX4ErW/bFYrlQ5PIO2CTyoU5q8jx2xmRmQEAogyxwKQUpGNVWjCgDSBVH8LZxS3TfdhrlLvddIVV+E9XU0SGmY2cs3wtiTUGUgAOiRF0DoujN/vHElytI3pG/O4c9JaErQ0RCObYEo8WPz9UPdZ889uq52eAwYmfbwwk/PeXQxAZnkmfb7qw6r8oJ9aQ0FiPrlv3+HSKBv/d7cRrzZ6FmnzLFOYKtjM6uHi+csNzO0r6P/KDLxeF8Mz9/CvqjRO75lMQU0BeRXqpMN51gUAtMnYiH3VKuwrV1L4yiuUfPAhvedN5pbN03AkqQK61ecJCH1+E33sAYQ/IQTZpXY+WbiTV2ftCESzbs+v4tHJm9ld5wNW5fJSWOUKjLFdkqNq1ROGYFk6ULXlpXY3UsqA1WV/QXfXjmhP2rPj+eKGofttt5+6/X5O35a1/vZJHybRRM27FvABcOngNtx3eleq/5rFWZPfw7Irg6K336l1Df5I84bcO7LL7LSKsTHtrlF0C1E8bNequdxzahe6PvYn8zTTuL/f/9h4kCUxDwKv4mVFXu2k/SX5aXjDDXiBopR5mCJ2sLqL+kxVRVvwKT4W5s3kgYIfUIBdziJmRUbg9XowIDDNfgKEQJhMGGw2jNHqS+AtKgoIf5EnjyKsd+2IcNGA8GeMjMSbl0f2Lf/H3rvvofCNN2n3/SRMLVrg2LiR+Ouvp3NcZ64aej9PFeRj2qSmMNvoTsKuHe70X91ctlhhx+ltuCqhivOnmnhyksIDHW7m3Zd8rMuL4oK2bZkelwAW1beu0l1J68jWdIxRJy+Onaq/vmdPZkDz1zdVva5B7eI4t19L4qshwiFxCBFwRRAiOFaUVKvvzYgF13DatKBbDwRlE3+ev76pMax6dFxgvd3to7jaRWmNO1Cfvn2Eh7nhYVQY4IesP2H34n30clBjfURTvRwu+qbGMEAzKfgFoeJqFy7tw+s3O4VbjNiMqslr7Z6y+gdqAj+vyeH279YGVPyRNhMYgrOmHQVVVLmDs8+VWUW8dUX/wMczp8yBy6vw4LjhtCvNJktoWjLz1cw0n86P9jb8Z/5/WLJ3Cdf/eT0zs2YGKmX4U26UO9xYTIaAA/7AtnEM7RDP3ad2ZmAD+ef8+DV/q3Gw2gj8n+oLx0n3gKZZCyveh4O4MzhrtWj+IQ3lVvNrIQsrnfVKzhnr1Gy6/vOVTFqxZ99qaJ+Hnm4PE4gkLCT30s4RT2Ir3kTS+nf5KfMjVhUFTT2ebsNRxk1gfslsZmb/zIQ+Lfn+2sv5z+iHAcgv3EV25b5T/jRkorUYDVw0oDVvzklnzrYCzu/fmgcb0ChF2dTghw3Z5QGNxBUfL29wBliXGi2AxeVzBVO9WKNQvZ8kRY48nmsbxY5/dcbqhRaaMJ4cE06V01ur0oQzPB7fAHXiYDcYiLXE09bjpeeMXK6YXMJDP/loVeKjY5gbISWWGiOnbpQo4apWeevSP1DStoCU/LImh7P7tCKuIeEvMYJtuZWBD+Hu0hqmb8wjt9xRb9Z5uPA70tfV/Nk2fs00yyM8NW3rAUu//W9GWiBZenq5qmlesndJYH1drQgENX8/nF2/ik+NUCiPFGxrI8juEEN1uKA6/SHMEarw5zQL9vRIIMIJ+Ykmrvn7JoanSU6fO49tuRsY98s4nl/0JUhJRIqaSSD+3nsBcKVnQEjQUnFYDGNOUj+gUR57wDzvtzic0evAaR0irMZa1UAAql3qO3nqawvwhmi0Kh0Nv6tf3zSUp8/rxaz7RgdUvj1aRjOuRwsenbyZGrePljHq9e8oqGJznWTqodjMxv2mVAqlbvLruhPMlfkrWVu4tsFKLLVw2CE3B8OLTyMqyjFEBH2zwi1Gym2q4JZ+2RUUv/8+nuzgGPLMH+rksyGzb2Glk04tIumTGhMw1YFqEfjr3tF0S1GP6/fv8ltT/KmUjgQfb/yYV1e/yhWdbmNIkpoOylxZzbYwOxURLSmIycFgKcakvWLSaNTy/LlVQQ9IQtV+zqtOR0GCKayW6t8YowrT0u1GWOtfW9I9qt+gwVY/ONAQUdskXPLRR7i2bSPuqquwL1+OY9NmNhZtZNqO9WQuG4Jd6cXbsbFsbbWaPwfVfo4s7Xtw3d/BfhpiVK1GQ7dDphH+2PIdd8z6P2bsnMFlnS9ixtBnMRrUflu0R3VncZc4sRnhpH5ZmKOD30trJ/VYLUuhwqAmau+bGsOih05lVEvV/L2zRHV7iCqt754VZjESZTXx2qztnN2nJfef0Y2kKCtvXN4PUJ/Dqz5ZTsfESE4dtoPr/7weT015QGGR4vXx3rIi2k+cTseHp9cLgvIHJDW2DNwxLfzddWoXJt+h1qgMTfLsfwmrtAFsTNck+iX1xmdvx7y0Qqas39uk1AYN4TfxRVpNiBDhr8JVwqackI+9wUuXFlG1HJjnbS9EiVzOyrSfiVIUTDKajZEX8QS38aExndm7Z3PbnNtYW7iW3zN+p3erGC4YVcgfe77mfzO24fQoWIzGQCqR03sm89OtIzi7b0tmbMzb58w63BzOxV3UAIoSoxGStVmXNQrcmqnOt48PZXg4MlwdEC3aQNpQPWGbyZ/gUgkkeQa4eVQHereOqbWtXyOzzwhsr4tqISjBhyPkA+z0OYjIX0HK6pfxSS+donvQPbYfvSK7ERuRTs5d17LZuZUZe36kRsklNraYF7eo+aF+W/8tF0+7mCeXPsm2kvrpWiaO786zF9ROTXPTqA7cNErNl+af5dvd3lofRYA7xqqRzee/t4Qvl2YFfJ08jUhybfeoAn6kJTKo+QtXIz1TVr9ChbuUKREWvFrURwupTmnDrBaqnN6Az06YBKctCm8bVXNya5d7+W+/l5mWV0r8jko6ZjkZlCkZLtsypGc3+rvcxGnBK0o79RprZs/BdvfNtIpQ+7LC4W7wmTIIgdunBAR+v1+aV5F8sSSLH1ftO1eb26vwyORNAU3HwXL392rt59S4cM3Hdz0bc8rptupx+hiyECg4DxBwM6F3Cl00E0ufRDWYoV10u0BAlsPTgHuDJvz9vedv+nzVJyC8A7iUWK5c4KNnjiSu1IXPlYRUrISFWcFs5rT1CrcU9mTYDon0qe/SzEEGohxOqn9Wk+TWuLx0Lc/G9/nHxF17LS3+dROWdu1wpadjTk5mU09VSOvZOpaaGX8AEOm2B0pXndojmXtO6xIQLvaHP8gkIcLChN6q5qzaFXwn/b5Cf27K47KP1FQg43q0YNLNwwLbjO6axPUntVeTqneM5z+nd+XHW4cHsiBUOjyBMfehXzcFfJbr8twfW2k/cXqgdvmBuGBAa6bfMyrw974qD4X2Tz18Poz/uR3D158hO6gfcHOKeh8e/GUDL8/cTplVfT5MHnUccm4LBrElRVlJjLTUMweDKnyP753Cb2tzWBzSNovJwJT1ewNpPHLK1Pc/V5vM7CttzOEgqyILgHhbC1YVLUBISZQdtoW7WBipjtlmKembpY4B462jub3nY3gVL0YMbFXaUZw9rPZBzbWFOKOmSQ3r14+Y886jLlHjxhF7+eVYu9ZPQxIaIOVn97XXIRX1uSz94nNmZc3io/Uf4t69F29ZGbssNpKr99K2zICiSTHFUVC1ejkjtwbHsqiIONxhggotU5TMWcWivGU8tOghyuc+jeGzcZC/Gfvq1fTaro6x0iP57vyOWGLX8viSxwPHqpo9B4CWpZIyo4HXL+vP1LtGkRobyentx6G4Elm1p4CWMUHtZr/W0Yzpqrp6JEZa2fT0mRRUuvho4U7itQmA//sYbjERbjFR4/by4soXWVu4FntlSUD4u6i6ms27VR9kRUJJjatW7e/LB7ehb2oM/drE1rufDXFMC3+hDGoXTM/hcAc1f61jw7h0cCr39X8Ca/WZLN2Zx79/WM+DIRGcTeXFi/oEhL9WsWEM6xQcYPt2kJjsQ6hKe46qtGdBsfDl0l3BAAHhpkbJ5cWVLzM9byWJPgtDWvbl3SuHYjMZKPapBdj7Jqp+KrHWWHq2iiY8Jp1pO6cE8gApUgYeCpvZSGmNmx9WZvPUtK2U7UOTlhiWyJMjnsQkJZUCWK4Wlmfe8/D3s2rzfPvQwrVKxffpJApvvpeCcH/N0fof1QfGd+OkTgm0ig3D5VUwGQRZL57NY+f0rLet3xq3zwSzPje/R0WyEgdPumNIlAYujOjDhMXPYrIXoRjM+KTEKIyEmyJp4XGTuvhhnl93LwDFznx+2DKTifP+xy87J5P5zaNkntsXl8/Fb+m/8da6+uX3YsLNXDu8HVcPa8sZPZNZ8chpTJzQPVBM22IyMC+tkJ5P/FWvFBxQK+fiRf6UJ42I9vV/nObtmQexbaH7ORCufkzi0n/BJ320KJN0/k0VtKoK1L7vnRrHgHaxAc1GJAKnowxfpfpx7Zd8CklhKUiDCen2EhWvukqMT+zBZYPb8HVeAWPL1OsIt5TxwPM9SB+gDkYfXKz22W3frm3QAf/GkR0Y0zWJsV1V7ZT/2fRrbUJL29UNHli7p4xJK/Ywdf2hmbeEgIsGtOb0nsmU2938tnYv5727BNnrIu1+OA9Y4q3G7SPcauKXNTlkFarb1nhqmHT2JB4a8hAWY31NxcmtT+aBwQ/wyaZPAMirzgPFQ3jBGrqHD+XCpRKjDyIrnLgKzsGaNJt28eFgs5JYBe1nq9oixaoKR9vaCsq6tMQ2YxGpRZJ3fp/HWwveBiCsdy/cu3eT+sEHtHz+OXw1NeSFufn9qg6k9T4J52o1lVFUiJB6Tp+WDO8Qv2+XihAirSbGdE1izeOnc9/patRg6OTYP4neUVAd8Fu7aWSHehHCWcU1fL54F7eN7sQ9p3XhzDcWBvyZKp0e2icEtWlfLMlqsC3+4/++rvHPRVy4hdHaBxRqa4GfG/mcen73vlPBGL7+FJG+HTlwCPLya/B+/A2xl10KwPrschweH+XW2gKIuXXQ1O1TJG3iw3F5lXpa5jtP6czVw9rx1t/p/LwmqC18d246U0Keff83y6/5czYwsT5cnNvpXACW5M9CYKBlWFtev9DAkh4GKnteB8AoYyYRmkEiHDMx1ng8ihuT0cYbnT6nf6c6GmZz7bybhhhViIw680ziLrusXhu8hUXEXnwR4QPrl/WLOvUUwhpYboyIoMPUKaQ8/TQlzhLcmrws0+ZgEIIR2+DOKV58LVTZILEK+qyrDATOAVh35qKYBPGasW6MPfgO2fI0GSE8gd3XqJYUl00Vtao3bmTl1iTcilobGKBmpZogu1WppGzQdYHjVLor8UkX9uybaBWZzJ2ntWJ+z9Oh6wTKnd5ayehDJ9m/rVPH8EcnqzJBmMVIpNVUa4JjOv1RwuwpPFZcSoxPwWkPujV9tGAnF3+wlIU7VF/xjkmRTL1rFA9PaFxBiH+M8Ndfk2Z7t45mfO+WuLw+zuvXin+f1oUHft7Iawvm4G3xMdlVqg/X6t2q+vXXNTms2Fmyr8MGOLef6lt065iOnNQpMWDy7NwikutGqrNEZ9Y9fHPNZarJS5q4dGAHQPDTarUTo6ILMEVtIaLT67h8DmKdZewye1mWv5iUGBsveV4InO/WfrfSI74HVe4qMgqrWJm/mr3VewOmkyuHtuWC95ZgMRlwenwMfHY2X2qJYBsKxADVt8PlcxGtSKqEhL+fDq7UAivKul2x75vQIpnycedQZosmMdJSz+QCalTzpFuGEx+hDsgTJ3Qnp8zOlR8v32fi1n1qYX0e/ENgT7ePqd4O3GnuTHzRBkyOYny2BBTpw6N4MAojo8O7ULw1kneeL8Tok0Sb41iWs5HtBerAb4+2ICyWgNbGua/IZuD5C/vw8XWDiQkz41Mk92gaJovJEDCBvjM3o5b276mpWwICT6sYWyC4qDFq9motdc2uyl3QbQJc8V1A8wegSB9RDrAUq1q6rLDedHR+y/+drb7Mp7U9jQ/GfcBpMpwe1eWY1/9AvC0eo0EbEYUB6fFh0IS/z5cVkllUjSO+J0M0X78EpQqr0UZ5pDrAmcpCBhlDfT+RDokRfHXTUGK0wcuv+Xvxoj4kRVkDgkdWcQ0dH5nBmt3BSE9/JFr/Rs5C94XLowSScidEWnnmfFWb/UG2asKOpuaAwt+arFI2ZJfz35838N4ydfa+oWgDHWM6cnWPqwmv8yEDMBvNFNqDKUx8K9dhWjSLTtMu5NxSrb7pkM64bruX+PhCLPHLePWyPrS4TXUmXxZXTNS/72De3UG/H9dpQzDtzuOipQrmrGwMUerzk/vQRHZdfAnWjh0wRkWRMGsyX58imdQum7cLgm3r2DkokKzLLuOqT1eQUbh/H1dQ/fJ6tlI1M06PD58ia03I/Jq//MrguNKygdydaflVPPPHVnIrHHy7fDd5Fc6Atr/K6eWyIW1qmXMb0ia7A9G+jTNNfbMsi4d+3cjXNw3lWa3vQ+sUR1nUexjqilOL9O0YvvsC5cxzkKdPUJd17IJB80srrXGTHG0lLyIBrzDwa6fRXDHhSe56ZQrVi5fgq6igsNJFekYufZ+aRf9nZgcO7VNkwMk+OdoWEGwVRfLW3+m10tP4r/uh8d2JsBgDwuCRoGucKvBvKFmORMFqDmdVNwPZLQQFWvqTfmY3Y09Sc/lt6GpjYd6feKUHs8HCPad1YZ377cDxTIh6mj9DRATtf/6JyLFjUGrqa2ELX3+NvCefarB91i5diBwzpt5yY0Iitq5dMUZF0VZLFwMgfQKnJZlwt4LBZsHReQ+rugi8pvpjWPHjT2OrUoivVp/Frh4PSeYozupwFlH2cug8DhmhTm73tLXx4/Vm2l4czfek4kV9t9YVqt8GqQUTnmzowPSKk7n0w6Vc/ely8qrzeGb5U5za18PzF/ZmccVb3O3YTtEF7zDpluG1gtJu+VqdyMVHWBhaJ99suMUYKFzRwtSHvgm9iYhvw3mPr2FxYirvxsWQ5wta1/zBT/6xe+WuUpZmNqwZb4h/jPDn9/U4r18rXrusH1aTkZtP7khStJWSGjd7vWpWb/8M0K+Ju//nDVz+8fJ6Jry6/PeMrtw3risD2sTy5pwdJEZaWTrxVEZ3SeKUNqdwaYsP8ThaEG42sqTkWyI6vkme6QdstmoiLEZiwswkd/6VsFbBero15jZYq9sRQTs25pTjCwlqMBvMfHLGJ7w25jVu/3YtBXZ/Sg11m7wKB+N2Lef9FR/SKan2rHRfPnQr81cy5LshlBoNVFkjIboV9L0CX+pgFKDCIHjdUsXKwgX19hWL52McP4oBO1bw5cXdWPjgKQxoW9+/MC2/kk8X7aSwysnQDvF0T4lm1EvzWLazhD0h+RZDach3EIBuE5C9LgBgirEah8nCz65dbLGYMdfk4QlPwid9mA1mVhUtZI+vCqmAxQt3932WluFtsPvKA64n0VMXY/trWeDwUsqAH2RDrN1TRvfHZ3LR+0H/L6vJENBwzU0rZFnIxMFfvQXUKDD/h64xmj+/2ddvagQCFT484Smq43rIYXJd20AYMGpm6FaRrRjVehSPjn2FWyoqudCcyILLFxBlVgeD9POmgEdBSVIFBIfHysOTN3Fbh55MazsMg0nBYAGr0UaxOt7z5GfBxOGiEU7CrWPDsJgM9E2NJcpqCvjc7ixWB8VQ5V+5Q73vTSkr1hAur8L3K7MDuSSvGNKWkzolUFSi9otZeA8o/IVqpX1Sbdfo1NEM+nYQ/1vxv0DfhLK9dDtfbQ0mpVX+/QQ8q2rPo3eoptv3OuVzV/IknJHTtba6iL1cnVyVRwg8V52DO1G92Tf1vomTr3sIZ/tk+u+UlCXaiL/xhsDxpcuFKz2donfepaqiCLdZkFwq6VyegxSCOUPPJc0a1H49/vsWQK3BfCCuHtaOb5bt5t8/rKP74zPZWVTN+1cP5J0rBwBB/z+/+8LVw9rWSibtx6/1PvvtxTz2u6qtGKAJ918s2cW6PWV8dWMwkKOh9/7/qXvLADmqtWv7qmrvnu5x17i7e0IEAiRYgBD04A4H1+Du7gRCkISQhABx4u7uybj7tEtVfT92T/dMEuQ8D+/3nvf+k0x3demuvW9Z91rN78rfpXo5EeZSC4TUSHa+JcXQJ3s/EZ/9gfMnVYmAVL3w0tPa01VVo84dYHzXVDxWB+9Nup/vek+i0WRncNFuSu+/n5MXXcS/5zzL18teIMHbuhJwrMpJ1+lLWbyvnPTYKNFzjdtPUNFa0RANayeyqBlxFj6/dkAkA/v/h9V4axiVFXWuPEWH6XVSRR/SaKg6glWRsQd9pMfmAbC3cgPLS+YxLvNCHjB1J/u3aejlaJn6grbnw7W/tDqGJElYevSg+OZbqHj22dPOwbdvP/5DhyLZs5amNDai+X3Yzz671ef6pGjm+cYeNzLrIrG2qgp4LRlYFB8u2cfxriqvTdFR0DOFhvCwtXTMAr0ewo2W6dMuZEhcR5JCCsu638tLAx/Hvf8Emj0TtXA3AMc6QqXFg+2er/l2TxWGWOH07Tm4ioYFC1CamkicdgGjstaj7FnPtoI6Suq9kUbLrZ63sMUWUtBUAIDzw0FkhkpayZ9uOlHLdUPz2PzoWDqEkwc9s2J5N/U3DFs+iGDS+zmu4H5nAF7K4vje79iAl0MmB4e1nMi+dJKEJIngDkS3/bTPtnD+e+tOu8dnsv9nnL/fD4ta94SuaaiqxqUfb+RfM7ZGygtlQeFRJ8cqLL13JKseGN2qC7Cs4fQGhWbzBRUqm/yc3T2V7QX1zNtVSmmDl4w4C43eIH2fWcWPW1zEpP3OiI9eZlflHmRTBXuafuWT6zrisBiY0DUVn9oYlWgAvJ2vpKb4NioO3cbhCifxsbFCEBuw6C3EmmIx61uzw8eEx8mifeUk15QSW1F0GrN888J6qjU7Oi8Of5EHxr8nUvPuavobqrgqK5ufhz3BktL5vL3vcdxBJx3mjiV59/vhk/UihUK4pz9O35pjEZmvU+2dFcd4/rdDLD1QSUWjL5JhhdYktCAUCd6f1ofxXVNP3Y2wjN4oVQKX965V4VZDJZ94d7PNbMbgLidkSealQTOY0vZGAH5w7kBTJZAlBqadRawpAa/SgCyJBSVh9V6GHore/51VO+k3q98fLgzNgFlfC+Li7HgrWfFW7h0nsCktFxp3C5yUw2KgTZKNz67pfxrW8Ux4wSEZQ4g1xdI5oTOseEbw/CW2g4y++BJEZGgLd+c+M02mqIuB5w1f8smKffR5dhnH64+zonAFWt5wSO0OxtYBQdCajZaaDulpeJPTCOr0BEIqlf4qXut0gpm3BpBNMkbZTHWMuEdJ3tPL2n9miTEm1j00hvYpMcSYo85fMzxgd1EDX6wXvGbNAcoNX2//j45xqjU7do3eIF9tyGfcm2t474o+3NKujmBsW649fyyZcdHs2JmCvH4tmqQqncJRTbSIkvsPR37gUN3p2NDmxpBWZhBj5L4k4YS55RCNgej4/3jtET5e8BgADTaYvGByJDPVPq49+oQEsufPxW+AitwYAidOttq9Pz+fmg8+wPPAU3Qs0bhmpcrTm79E0jROeCVOlkWP1dxt3jxu/8zKG324/CGy48V9qnEFMBt09M+L59kLupEV/ry52aPoDyTjzsSkcFHfLN6+vDeL9lVw0Ycb+XzdyUh29kyOf3OW/FSOsj8yf0hBr5Pp+MTiyFzfsimlWX5PUf8gAPCEr8VyeiazwSu4+Nonx9AzKw53x67EWAVeq7TvCNTGRkJl5bjbd8Ea8pPpqWnVFd9M+pwYYyIt7PxpmkZ5g5jPO6aKdzTeamBc11T8IYXP1p4k2W5icNsoftAfUv5WAPk/tYUnFrKmJBrwDz6s8fhslYFuPx1cNdx2siMX1Nezb6cIsDLLPCiaQq69A91rXXjKDtI3cSR54WeW7yoF++lzetOSJQRLSpCMf8y92ZxxbWm+Q4eo+fAj4qdNQ2rBEahPit4jg2wgI6kNtkH90VtVOup0mH166s0SQSQsPo20g5U0WUFr48Parzed9+xGFxdH3LgB9C37kE/9NvJCIfQhH+5lv1G0MoH62XNR5omMZ4bZTHe9A7/bxDUHF2MMPxPz94spf+RR0DTerV3Cl7F27rLMwIaPGJO+VYWp3F1O9ySBKW8MOsHXGo5gNugInqIh7zAbmNz4LSx7IlKBNOsNfOE6TIFez+u73iGIhlOnY0Tpbl7b+TWTmo4QVFQSrMaI5nQzTOzvqs38P+H8Has/xhf5d6CzHkMnS7R9bBHbCupZdaQ6Uu+WEZPgLaMz6JRmJ81hZva2KAZj2cEKOj2xJNKC39JK6r1c9skm7vl+N5+HF69NJ2p49/dj1Lj8+HTH8McsRY45iEe/D9lYh6aICTO/tgFZklh1tJJGf+vFtLw+OiHlJljplpvGOJ/CuJxx9E7pzeri1by57d1WTlNmvIF7xnbgjjHt8Xm8BGQDJ1qUdgzxm/j4yMPc+fudPL3x6VbHayaN7pLQhVRbKlQfhhO/EwL2GSQCNbsBuL/Hi5h0FswNx0jb/mr4x9EBs/N4JSNeXcnMTQWn3avmBcDpC/Ly4kO8vSK6SJ6q+HDzyHac3/N0ypSI1eWj1UWB38dCYnHzyDInz59L8Zh3SbFkEGsUi7dXC4jmWEkDVSHWmIBPrUeSxeAPWATh56nWzLV4qjV33PlDCp1S7Qxtl0hKWKvxnrEdKHj5PM7tkR7ZxukL0iMzls+u6c+LF3Un1mJgfNfU04iGu05fGknvN5skSTiMDlGS9jVCwCNUV0J+NFlP94T+vNUknL+QLGH1VzJNXoGmhKj3BPnt5CLuX3M/z6y8l6vlapZIfu5aeVcECxh/8icsL99DzNAM+o7dSUmumJybKXSW2awcLavjpi4P88bFX1Bx56PsSu5A35y4VgDlv7JmLctuGY6I3GLzYry9sI7nfj1Ifo27VVfm/0Z15/lwc44/qFBU56UmLIOYZtNhMJr417A2pLU4/8s/3cyt3+xohUFccShK1FzRJLJHLbt9W8osNltLnr/O9vYgScjnj0cJSgTD0m56fWvHq9Lp4qznlwHQEPbNp/d/kH3X7mNNyRoeX/848SETJtlIYaYRQ3YW+f0zODGpNzkzv0YXFweAvPcwGXUajvh0EsOLxy37FrI04WjkWK9e3INuaba/1TX6yDyBbeqe2axw4Ofd34+xq6iBa4bkRZ5pMyntumM1Z6TPaen8XTc0j4PPnk2bJFsrsXlvUIk0M5wJ7tEMAzhVNuuPzB9UI6UwgP658RFoDEC2PZvz2p7H0MyhZ/y9NnIMoW8XQNrp81AgpEbeebc/RMdUO1sfH0eXdAdl3Qagz0jHPmECIx8XZOo5vgaafEI/XlNVqsJqCyl2E2kOMwFFpaTey+L9Its4NJztS3WYqXH5Kar18MKiQ/y8u7RVeW74K6s45+21/J+yluP7zm5PMUk3HBwxfFJXRY6+I43EYFVc/BrTDrXfII70SUPVFE40HeKoWodXM2HUGQlIEh0kCxX1x2Dvj6cdp/bzLwAiVC+tLOygSH/S7etauwYtEMDYvh3WIYPRJye33s5iIWfG1ziyfDxy6BdMTen4jJBmiqd7oUaMD+JcUPPyk6Q89Rqu1atRGhqoTnDxcSCRJnMqXPIF5I0gUCueXcDSE7VSQMXGmWzcV3Ic71uXc8XR34nzBhiQOpjznpkROYec4gCscfBLYxxzFzzJ+AMrW91fZ8DJQwMeYnpNLQdNRj49Prf1PXIH+HZLUSsHbX0L9aLmQLXAv461RpnqThNoCHMk+vDxgncd3Yv28dy4Ntw4oi217gDPhbvRm52/M2H1z2T/Tzh/z21+jmp/IXrHfnYXN2ALY9Hm3DKEER3EC2aQxYDbWlTCpR9vZOXhqlZqGGvDIMozlYiaI9SWBKLzd5Xy5vKjNHmD6GwnMCatwKAlIBvqkA0NdE0UafsvNhyhwROg1nO6gzH1wFcRoHJekg0MFl6tbeStMaIzdUflDr47IoSsJ2cJ4eygGuTf4zuSm2ijV9UxEvxOMioLIvsc2K2EQs9u1pSs4adjP7U6XnPmb8/Ms3n65ysYnZ3JOosZOzqudHrxNIrIro+9a0Tn0JUhuqlbkjzP3nCC4jrvGSWVmisnTl8If0ilbZKNh87pRJzVECkfgSiplDd6ufv7XSzZ/wci7hveZrDbTcIpw7AxJgNN1qMaHSws+IYjDXsZkzGJezs/hqZJSKgYnUVc3u4Wxljfx+Q6m2eHPktWagfsAR1TO01lWudpkf2daXEHEZGDKE8pmsbucHlJXGfrEtGA51dQ1uijd3Yc47um0j7Fjjeg8PuhykgnX0tbdaS61d+byzdT7CxGJ+lEt6/eDM5yqDpAU46gCUCvR4rRcdtvCh1PikDCEHYwfKEgekmPv3I/1Tod+bLC6uLVyJK4dym73iH2xEIIO4MhxDtilE2cvV3luqUq6/KdOIxxxMckUT/0LCptibRNjolo9f4n9tLFPXnhItE524zBemBCJyQJFuwq5bZR7XjjUkFhcKpyzn9il/bPpn1KDL6QQmWTjzSHWTybxhKoPkTpprmtQPjFdR6WHKhgxKurqGrycffX63h1yZHI95awrzTz4MzIZ2fChrbMJDnqJdA0Gg8d5+hP6TicEosf6UhVpyjnpqbqiLfpON7WTGOsniNZ4fHzQhqU76XB30BRUxF7vce59U49ywboSbn3Xh4eX8Wj3fdjGzgQXWxcZH9eI3TJ6YscG0vnvXuQHQ6MZcX4DoqJflzVl/zWcAG6M9DUnGrN/HTNmui1rgBfbyxgxv4vmbrw2ohk1EsX9+SOMe0wG+TTaJugtQqM2aDDatSjaVqrzl2bSU+S3UTbZNsZHciHzulMwcvnse6hs/7yvEE0Rpj0UefvzrPat3L2FVUR79QfmckMqWmiBHiKpcWa+e6mwfTIjOVwhZMu6cI5PlTexLKjtaTOX0jmO29jzspEQWLqvkWcc2wdzj17Ody1G/5doiyYbDdxcd8stj0+ji/W5/PxGnE/pg3MoeDl88iKt3DNF1spCMNiVh2p4s7vdkVUkfrlxHOyxv2XfJX/U2s5/3WL74e9qhGLUcAmyiUDs9MqedY2Do/RjPrKO3gdVlQ1yPz8r/jUWI4PI3tqN1Mmg17TSPa54eCC046jc4gs95moXppNNp/uGMoxYWWiL74EIPnOO8mdMQNdbOxp2yLLcO7rlF/yM5/1G8onE3UkXvIlnfL6A1A1uB0d2wvO18oXBca+zKIwap6Jf+9dAT2mQEIb4i4RDWNyQioGQyOZLzyGJTms4OQrACDWE2JMgQXufw50Ovyj+nEsU2LIYY3ev4vrOHvND6SOvw0p/OycAScp1hQudbp5OTGB9wpFp7476GZx/uLIZbTM9H59/UAO5lwFeguVm3eweMEDVJz8WezPaKEh/I43yjKhRhcxo0cTd/FF3DqqLZ1S7ZEMdDP+9K9gMJFb+be2+r9sMyfOJMXYAdlUyeGKJhbfM5IV941kYJuESPbBpDdg1cfwy+YEthXUC36+FrYjLDt0Jn6yUzvmBuTFR4D9tjDVi4SB9glZBHSlIKm0iRUTf1mTky+vG4Ckiy5wVlUlVpHwSDocZj1mg0yK3cSXZTm8bB7OrctvpdxVjt1ox6/4sHd5hHK/wNA0Z+8AbGGMTabipm2SjbvHdkCv++MJohl7sNoAPzXsp1avo1Svx4WKLaEtZnclaaEQG8p+o6hBOMbO7PAk3ML5MyghdLJEoyfIioOVfLT6RGSBb8YFucLOn82k5/bR7RmQl0CKPTop17j9DHlpJQv3lP0x51coQPdAgOtUR6uPq7JHkbb9NYyVO/jhxCccqNvBTV0eZmD6eCyJAeLbe9AFmrDqbdw/vjuzpl3DRR0uwmCLwRhU0ct6Hhn4CC8Mf4G+KX3JjMk84+FjWzh/GbEWPAGllezSa0sP8+byoxTXeSI8XU6Xi1feep1dRfXUewLc8PX2VhQPAG2TbUzs3ro7bk+V4It6ZugzEPIK3sUwaFoOeTnasI9n2wXRbkolox7S6sULbwyXGgNKEL2sx6Iz4ZMkQmk9kJAizl/QKVP/zT7UYwWUrI9n7JHtWHSQWRmic4lG50KZz5Xz2Fu7lY/2fIT+5HF6VB9n7o6SCMYxYs4KkZ38CztQc4B91fsw6mQy4yy0S45hWLsk3l15jJmbCshLauat/OuO1MomH8/8cqDVpBhUVHYW1eP2h/AHVSqafJEsVbN9/utq3lh2lL0lgnuxyunHmryGSm0d783+lddOXkQ7KaqmcFb70/kbF+cvpqp0G3w0DJzNVAotlFNCR9mXm439sMhy1zjAZLVjMYlxqwYScB15AaucQpM+hOaIIWCQyAiG+CjOQY9lV7KlfAvuoJsFcy8noAaoCzQAMCxjGF0SRHdec+YPYHKPy8FmFYo1BgP6xEScy1dQev8DYoPmTv5Tykpnsm9vGsyLF/UgI86CLAmuVKc/xOHADxyo39lKQejBsztz+LmJZ9xPu+QY1j88Boh2fEuSRGULzdvmzuKV948m3mpk3Jtr+GnHmWlf/o5lxVvplhGdH8oafK1k1EJqiIUnFvLdoe+YvmE6le7WcnzSjq1I3331p8do5ufzBRXe/f1YJMD1SnokSWL8uxupscSS5Gvk9r0LaPpSOCm6/buxm/XYTHpiLQaS7SYOlTfRJd3BwWfPjnR5OswGmnzBiAJSlzSHwBq+tZadRfVM6Cay9GeqSv0T1uz86SQ9MToblJagZeVyTlYGM5q24rQXs8TSH78m5hprYz76hhOEFB9GTcOHkVy7IEI+hI89OvW0hg8A2S6e05lKu47zzwfOnPnTtaB66bRzB45zzvnDazk5+QKqNnl46uQO6nvMpTBVwqgzUmMUY2LUpNtJs4m5N/2lF8mb/QOBtrEEdNDjcBDt5Foqn34U3yvj0NlMKIoJnVHDse9OZmlHGJGTic4Ulk70Kjiq3fgOHqS2azq6w/nUh0819pR49vsJM7HoLdRWFzHzrgmcnxrNNAfVIO/ufJeH1j6EbKxCRiXeGvVPRnVMpus5N8JFH+F5+ykAeuaLddYdn0u94ie5SeXm3xWcVY0sKPTy+Jdruef95STbTVSH34dmWNLfxdP+P+H8ASQZ2qMzl4GmkZNopX2KiDLirEYMOglNU+gROxYtIDJt3dJF1HDFwGzaJNlwh1OiE95aG/GMC2vdtHtsEatPydI0SzBBmBRYDmDWWRjdXuDAFE8OObaOaJqEzlxOtbcIQjGMSRLYtAfq6llSUodDSqa43osvqCJJEodiBvN9bCMbyjYQUAMRPBDA0cZd3NzzZlKsKZHPrPHiZUoJuVn5wGjuG98Rpyc6aF4f9Xqr8+4c35mb2l1CRgtsY4HBgIbGp8Fybm5s4rfiMj4q+IydtZsI2DKQmqPCtu1RxwjVDIMaJN5qpMET5MaZ23llyWGGvbSS/Bp3JIvg9AXxh5RINuCza/rzQJiXEKDJGy35/BnVS40sU6y1zrwEgo0kHpqJoUlgoiIdrbKB+n+9R2qfJnT+Rio9pcw69h6HXSt5ZesrlDtPYgzCrEOzuOP3O5jcbjJfT/xacOudwZpLZn1z4iIcXi2zG3tLGllztDrS9LHs3yO5rOEzHm58jiNbl0cbPk7BmVmNutPA7u6QG6NsxKAzRDJ/x9zlXJKRxreFM6n2lfO73oeiBlH0OrI2VVF31IbB2FyaFs6fWWfEJ0sotqRWIOxQQCZQ0ARuD756A0PNAR5w7eG2t/Yx6IhGRbyeCV1TOVC/gw93f0jKws94dcPHjC3aTrXLz8nGkzy89mHBJ/hGJ/iwNTv9qfbl+nym/jaVaYumcd2wNmx45CxkWeKdqb3plGrn6V8ORiSsWmbmTlS7zojLm/7zfmZsKGjVYFPvCXDxhxsJKhqD2yayo7A+mpEKLz4OPHyzuZAPVh2PZKpjknahjznKsHQwSUFSpAZA4OPemHQ5I2x52FSVySmCu2xZ4TJuWXUPVO6H3d8CoBI9R69Z4sfO0ezoLYtUui/Yw5AmcS6KTwQXx2tq6VwYIq64gXbWdLoEAhyIEwuRSWfCE2jCpYl34a0xb6FpGlaDNRK06eKimQ6dLYaZRXNBUaiYPl1kPIBAfj6h+noY9ZDY8I+6XFtYm7BspE6WuPOsDvTNiScQUskxi+YMZ9g5v+yTTQLqcWA+bP3stP0Y9TLpsRam9Muie4bjtO+hNSmz1aTjRLUrgiEMKkEu+WgtPZ9eypPhhpG/ssfO7cI7U/tE/56/j++3FDFnezH+kBLBbr69823mH5/Px3s/bvV7aetG5O9nciabva2I0a+tiuAQp/98gA3Ha5orlJEymtMXpKbvsMjv3pWEI9QmwdxKcembzYVsya9jUJsErEY9hyuc5D3yG/N2ldLkDZJf6ybOamgFs9A0IsHj1vy/ZqX4n1iz85doSqHbN/2Q6mpx95pEpcFGWTCMW9SHiA9Vk7P8Ru619efb8gpCITfIFvaqbRmSNrL1Ts/o/Il51jb09BK8Y+JEEq67Dp399Lm4Jc+fbD29876lherqCBQUEAjUM+yASveyGCx6C5vcYjwFCqOKTbaBA7H06oVsMbCjg8TQgyqhz6dS98MCqlbVknj+AFIffIigW4erwoQUggadjpBFDID7ki+kp5yNYtCx2VyKvrIu0nHc0vblSjgcyYzNHEmnzWUMWF7MsC3RzHm9r55UnZUYj8Y9ecnsMd1EzLL7I99rNcdh0weQ2B5TlWAYcHg1dIpGnT0TjxbkuYUBeu3UYfSHqDHYuO79G5j0y/OsP15DtdOPpqp8f9MgHjy7ExeeQZ3qTPZf7/zVeGu4e+XdxJhBDSQS72idRZg2MIdXLunJbxesYmjqWGSzwPnFWg1kxllw+RV+v28U14U1Qr1BJcLflmw3oaga324RA0YyViMZ6rjrrPYR7U2TXqZtigGLzkK6NYNcezse7zqdyzMG4S26AVPyclavvpSzOMRZmSKVvNtkIkZ1onek8fqUnvx6lyAptelUVIOIsg2yAYcxOoE2Bhqo9lS36gY9cZ0AouqbGthRWE9hrZuieoH/kyWZXsm9Wt2LHsk9uLvthaQqUWerTidzb7ZIg3slCSPgkC3UKi788R1wFAnqC23wMNRHn+boDQ+wLbULiTZjqwjbZJCxm/XceVZ7bhvdjn8Na9OKhqOlKarG5+uiYHZP4I+dv+8ddn7U+Xi2upY2+nhezvoXr+4QqgoBfTgz1qKs407qQ/HQV/DFd8AZbOSbg9/wxIYnmHVoFj922UnJFQ0ArCtdx/i545l3bB7FzjMrfqQ5zBx69hw+u6Z/RDO5JRA31WGmstHH5hO1JNqMdEiJQQpnhKzmM3f7NnqCzK+5gMuqWnMMugNuAmqAt3e8DXkjoMv5/FKwmKMmI2t0fhRNoVuBin5ePbqQguQJUnMohrbJDqb0y0IlJJw/2SAyf776Vs6fGtYakwwykk4j1iAxMFVE4HoVKjI1LpdWYNKJezozdTcAlx1byQerTvDriV9ZlL8oSm/S9Ofao3/k0CfGmHjhoh6Y9DL7Shp5elLXFnQgQca+sSZSFmtpzQtty4WxmUT8gQkduaRfFlcPzuWGMBk3Zz0BgEMSjsW28l1MXToOSefGSwUGx168YR1oE2LOSHOYCYRUbLHZJCkK0xMHck9fgeeqDpPIF3oq2VaxjYvbX8wtHV8EIKtaI90ZzYQmOSFlZ4hL3CEuT5xNoGYsffouZupwA87MOAAuMqUzweMnlN4bgARzAp6gB5cs09OWzdCMoTT4G1heuJz8RoEzlk0m0l98ESSJcrWebR0ksFpwrvidwInoPSvbvIpH67bikSTw/wHVi7MSlj0J1VGcoDfk5a6xbSKqSTlWkXFsCoiS49b8OqFpffBn2Prpabv0BRU+XnOCKwbmtFIWWffQGJbeO5IxnZLplxtPWYOXyz7eRKcnlqBpRLBxo+eM5rjxaZp8oT8kgW42TdN4csF+NobxUOf1SI+Q176x/CgPzd1LcZ2HOZPmkGHLiDg4wzKGtd6R13vGZg+A0gYfhXWeCIXRwDYJrZCILl+I15cewR1QOHnpjdw89kEAGqrqCFps5OLj5pHtovchjD9vVmFqVqUC0Qx3rNJJ5zQ75hYOsqppzAsHSQfK/jqL+4emhKJjofIA7Po28tWTg5/EbrBT5StDF2zC+vA0tAnnYdZbQRaBxx2uD3jS8xKxhctot/MtHKpGIODBF9OO4/2ejKhcPZkxgXcqq4XCxymmj4tDMhiw9Ot32nfWvn1IfeThMzp3zZJvxtzcv7xM2WjEuXgJU77fzL+Wq9xYMJSO8R25dYR4Np5wKb6lGRyZgmTdo1G8SiRcfHVGnAfrkNPa4VQHUbw6kdgwXtwddv4y9y3FWO9Gcpj4fpTMC5fJ5HSPBsXF7cW+XBb4eMULPLf6M0YWC9aOgUe0SCm4tmAtzg1v0KFCYtzrDyOVq0i7ogFJ4S3/pvTT5XD4N2LOtiLbQ7jMEi/MVOj54Nd8nH01CR6xrz1n5bChbXcMNgWDJ4SeEK7yKg4OG0HCni3cMaY9b7cIlv70Xv6trf4vmF/x89Huj6j2VLOqeBWD0ofiyb+Hdgmty2lVTh/3zdnDvtImlpZ/hTltYeQ7X1Dhlz1lyLJEky8Y0cvbXdQACEbt9ikxtEmK4eOr+hLT7g1i2r+KJEkoqkaCzYhJL9M53UyjR2LNrnQ+P/tjrtx0GUmf9UFvF12Ca60mdrdbwM6yD+jijGG4V7xQyek5dEi1Rxa/gY3Rmr9BNrTK/AHMPz6fCncUH7fAZcOtNyM11HHJRxsZ9dpqbLIoEaiaytk/XsDHG7az4XgNX6zPx+l3UueuxN6CQ6s8Pou48HHuTk3mze4XkmBKps5fjaq3IgfdoKpw8jjIMpWDRlPkSGN4hyT65caz7+kJzLllCHXuAC/8dojumbE8fE5nemXHcfPItlw/TCzGryw5TL/nlvPTjhJ0ssTGE9EotmWXbCtTAqgxKeglHRe53HyYegU9DCnYwqF3UCcmhZaYHu2Tz3A++x0hWzpxptY8ST69hL8FVqnCXcFTG59iY+nGMx5eliUsRh2SJDFjg1iAW07YqQ6RUreb9ZzbIx1Jkigz5on7H5sbUQNpmflr8PgxSAqjldbHdIdEyWdn1U4YfCuMeYxdVbsBqDY5UDWFRCdoxVGnSvHq6Omv5vVLe3Fbnxt5/6z36YaZ81xuYhpKybFH2/41RVx3IKUTbnMSewvqCVVES2DXWVw0FezCGMbGrusuUzd1HJnOaoxKMJJBsenCk/PAm894z5otzmrAXzMKvaTnxd8OMv3naCanX2482QlWMuMtXDesTYSqKMakJ8FmPGM3aSCk0i83PsKdCFGqkNIGL32fW87gtomM6RzOjOcORXNk4kDcV2/Mb/gUN+f0i96/c/bezRqLGSMBXryoB23iDYz/4A6WlK2jRqfHV76H67tfz7CMYWTZsyGhHbdWruD6pdejez6VdjUCdzNxh8ptG6P60s2mM8uM7JjEbWOTOO5dg1GnMvKnlXTcvIlrJ33Fuf9agxIm9+6Z3JPB9ra4ZBlFp2dZwbJIp+pNPW5iTfEaRv4wkuox3fn+s0t4p3E+5YkSakYK5u7daTN/HtmffoJkMLD6p7f5tXY3+2vt1M5dKvCPs6+CI9H5haoDsPFdOCTmwwp3BSO+HcrKKyZwfPYCJAkqgwID3OD1RKAvsRYDlO+FhtPVWzRNaJhvza9r9Xl2gpVOaXZm/GtghPh8a0F0m2qnD1XVaAo0oeqFg/RX3b7eoMI3mwuZ9vkWnv3lIB9c2Zef7xgWySzeMLxNpPrTLk44YBa9hbNyTsESer1gOXM2qc7tJ85iwKCTWXrvSL68bkCr7v6tBXW8v+o4AB+uPkFxTAqNRhvmUIAfepyLc8DQVviqVy7pyZ1j2kc06Y0t5hKzXsfHV/Xjjct6R/SZgUjD4sV9MxnVqXWDw39k1YfhpUw4uBBmXgg/3y44UYC82Dz+1f1fAEgyBHuNxJ+YjElnRtIJx1ynaeTGivXxd6uFT2MdVDQ2kl/tY+qAHH4+KRoXLhh4H2dljoTuF592CgnXXkv255+juv8zjK8kSZg6dMDU8a/pb6SwI9/uYClWPySlCEf7qp7X0mbhz2S99dZpv1Fzh3AoR+LA6Fz89dFn4t13kNKHH6Z2s8DrW8LOvdsok32jnT2+Gpp+/RVbXAzP1deyp51Mr6yoOtQSk6DPGXJYI/2HtciA3rkPVQJZgxgfSJqGZ8Gv1Ms6DmdqOK16SjbE420Iy+FpGr7jRTQVW/D8+AYluSN47vzzSHBptK0AS3UTnY7Y0HlkdnSBT7vI2C0etiYasPicHDdfw7+KFyHX17Hjw88puOXWv33f/xHnT5KkcyRJOiJJ0nFJkh45w/cmSZJmh7/fIklS3l/ts9Zby4d7PmRVseAiM3Dm0t3OwgYuObaS5MkjqfdWIBurSbCJ7NkHV/Zl+vldWXW4igZPkI2PnkVmnIXdxQ3sLKrn0Xn7SLAaafAEGNkpWnKpcFcwtksy47qkkBhj4pURr6CU3EGs2SbwBL4GAoAxQXQMemUZvz7I/OrfmFVzkHh5GJrBRpf+p0xExugkpJd0p0ep0CpLNaj8IC5LDPkJXnRWMQl1NV6LzTueJFM6quTh1eXbufLzLTz360Fe3/IRYzc9jC07ut/E9L48fWI2AJstZk460oizZtLoKiK2YDHmhmNIe3aiv/kqpM0bmChV8+N5mTx2bhcePbcLdrOBgW0SBOg+qLD5ZC3fby1i88laJnRLY2wXMdGVN3ipdQf4LJzxe+Gi7gxsk0CPzNhWpdRWNuxe1LzhhDSF9+NiKdF8bPLm80VsmDxZf7rzR0hBQsHQVEissbXzl1Rup3ZbrIi4NI025WKBeX7L81z+6+VnPoewfXndAMZ1SWk1MWeHJcXO7p4WkYRrlsczGAxR5y+kElRU/CEFr0cs9oUdrm21/+ZmnKASjHS+NfgbAPCoXpoCDejCPuTigQZ+HiOyMsFyEUlm27PpkdyDsd2v4oWaOm7NnsDcydFOssruQjvTn9qNJmsasqqxf3c066NLkvH7fegQZWSDZOHj/Ex0aOQ1lUeCDo8vvGjb0//0fsVZjWghOyEtxPbiUo62aJbyBEIcr3JR4wpwvMrViv+xW4bjjBmOiiYfbZNsvLz4MA/P3Uu10x+hZnpvpRj7uYktFvHCTWCMoQzR8KV4hdNxy/Aop996i8ydaSlMHRnD+b3S6WOr5UIEJ98kl4vhDWtZV7IOVVMpbSxAqztBSZgHcKtR5q0q8X7HeKHiFKyhbFAplTzcsWksM/NFFjJwcB7yK2noFl4L2z4HRyZKyTYApnScwqtpY3DLEk5XOfevuZ/fi34HBA1QU6CJen89Bz9+ndSlu0GScLg15OOF6FNTMHfpQszIkcSMPYtOO6qRVQ3byhiqPvgSz4p5cOgXWPF09ARrw5nCje8B8Oq2Vxm4P0DOngpsrzzF0cdG0ajkY/IOZt72Bj5eI97bOKMCdSei+tNh2121m1UlopP5lSWHT8PxHa5o4oNVx3H7Q6fpZ684VEXf5xeJe1Qryod/RfJsNeojXIMVTV4Ka91sPXCUbYlPsXzEcR4/twuN3iB3/X5XJHNq1Blp8p8ytrzuP8z81boCJIazfp3S7MSY9ARaQGZO1RGWTDU8PvY81md0Z3H74Yxf44sQ7wPE24w8cHanSFd0doKF20e346FzOvHouZ2xmfRkxlkY3zU1Ms80j+3p53f9c2aEP7J9c2HrZ3xz5Ae2mU1gtEH7ceDIgrBm7S8nfqFval+2uBIJNOrxbz7K3qNlVDWqIIUgEItV06jvMIWQOZFNFjPfxtoZUpnH03UnsW98iRkTvuKJQU9gis2EK+dAzuDTTkULBim69lqcSxaf9t1fWcJ11xJ74QV/uZ1sjr6HehXWNa2NcPuaO3ZspdncbEMzhnJR+4vIfPwJEnu1TkQ0LfyFUG0jksmEfavA0V6Ulc6RS14idp84lnXYGCa6PeTpbKwpW0b7CyoovPffrG/TlTnnd6LBBt0KNaosvblsbCxTH9Hz8PU6nFaJpb4BWGduwVQn4zVJLH3qHKRYO+VbzGi7v0cpK0DzB0CVKF6bQPsKD8P7T2PyLh3mXC97P72W6kE5KF4duSEHU1cVkqLbzfF4HVZPiPoTViYc2IY5MUBvaT2e9evp9djC0+7BGe/l39rqT0ySJB3wATAR6ApcIUnSqVpfNwD1mqa1B94CXvmr/TqDYjH56sBXAPTNSqd379+ZV/pCq+22FdRx5WFRuoxp8iPpfFw7XGQxBrdN5F/D8qhx+Vl5uIpaVwCzQea3feVc/OFGvt9aRF6SlfJGH9VNGs8NEySu1y6+lm3VK3l1Si90ssS4Nzfg8umjJc4r5/7hjTMCS3IeQHq8DNqMaPVdXIfBxIezRMbirSiaQqzWo9U2LUmJuy39nhO2VO6N/w1r7uf0yo4jzmpAqT2XUfGiJCzpo2zq5U4nJr2ZoZM/49KOl/LFhC+Y0nFKq/3HajIZspWqQC01OpkQQKGYPLVOXfA++G+yVy1EJ0u8s+JYhO7FYtDhDSq8uuQwj87bx/1z9nCgrDHS6Xq0UpQc7gxjYEZ0SGbOLUP45a7hvHl57zPfrNwhqFWCrPaT+FhuKvuSje4jzAiLhFtNiXw04hdGZZwX/Y2qYPBVk3hoFgbZiEGLckHF1kqM36VhDMGYvRqvfKXQ57i4381Zlj+yYe2T+PzaARHtVIALemfSMyu2FYWNEl600uq2IssS3900iH658XSdvoQl+yvwuxsAmLWrdXbkzdFvMjprtMDUfTISZl+NO+iOlP4bA/XEIiabxUPMlOWKYx4uqKb9Y4uYuWuFcBYsCTTJElv8rXGqiiMFrU07ZKOGJzmZclsiKd56jnSJ46a7dWzXSRikEKFwhjDb3Ie9CW14fsA1GHJz2FcjGoBK3RWQ3gtcrYHzEWsogs/HEatVY077lS5x/XD5JOzmKFyhuSmoyRvk2i+38vbvwgl94Me9rDtWw4GyptN4zVY/MJq1x6r5eM0JZm8vZuOJmtMoC1qSnf+85E6uckh8Kgun/rJu48Sx1eiCfcIozmlAUgIOs4FYXAQlCZuqkhJe5O9ceSebyjfxsLU9tXILvKfJRHm4Q9TuAS0xlvfP13Es7BNLJpUUrfUs8PnxeQzLycSVvwbcNaA30SEozifeFA/9r+c9Rz/eqW4AhMoIwMqilZFAoOPXaznrx+PEGRx0Lgk3Vxmi98F3/SU8ep2OyYoROfxx9beioxBNQ23mtasTzpzm8xIM+tlQuoH9uRLbO4hzLps7H2fAyaA8gVdsLsOmaGLcNsoyPx79MSJtdfXiq3l43UOR8xh9SpZqxcFKXlt6hE/WnMBm1CHpnFhyP2JEbwFzaQyJ8ar4ROVG1aKSgKqq8frSIxyuiDpuvqAS6cY363WMem01VT/cha3+MB1SYnh8wT4mvr2W9aXrSbIk0Tu5N43+Rp7b/Fyr8/qzzF+tK9CKtw9AHx4D824f2oofEiCr/RKqes/DlbWbUEMDOU0VrQh8TzVJknjonM7cNqodl/bLjjiFWfFW1j40huapxmyQsZsNFNV6/pCLttm+2VTA8oMt3s39P8GOr3m78FfWWSws2f4ePZrWU2+KXvPr219n0YlfsFbvorE+FfndNzlUVIvm6cqo9HO5OOlDRnh9FB/ZTn2HS9BpUKfTUeztw5hgBev2HiPVlsHlnf88gPYfEw1RSuN/Xr6Ou+QS7GPH/uV2ulgHtqHR0muRUope+nOuy1hTLM8Oe5Yh2cNRAnqM9hBZLz5M3KWXRraRbVYyXDW0CQsFF736OjY/lJ9tIOWxp5GuWchNPW8mUTZisKhk1D+OocPnzO1xgh/GG4lzQ/2MKtKLwg14Rol+tQHYICBllw28AYBqi4vU+x7CX6/H/eE9+D+6AgC9NYQalKmbvZzLFt2D5A8xY7CB5w7PYE3FUvLGV5N0rIkRBzXilWqqYyX0KtQcTsQUGyT3rBosiUEkRSGj+swwp1Ptn8j8DQSOa5p2UtO0APADcKoLfwHQTJc/Fxgr/YWkgKZpjMgcQYZNREPJtnj65saxo2pbK9mgvOxiGmLELNhHFdsO7aIy+/Bsbl9xO9ctuY5ku7jMLzfk88JFPTivRzSrceuodgxpm4jFqKN7osjulLnL2Fq+JbJNv5670cfuECLmx3+HtJ7ogfbGBG5xBZnocnN2Iww2JKEZrNx//uk6hQBDBw7mxgH309Efom7Fxxh1RhLddzDA+y6di8U1tez2DXp9BHXRRfWza3qyxfccLvNSbhoqMImSzslbl/fCbJCpdrkx6UzEmWKZPmQ6A9MHnsZxl128jlsLd/Fp5g1857Bza1oKqjfsQFqshCSJ+u++Z/bPm3hrxVG2nBSLgdkgJImaF/bSBi/nvbue934XkevDEztzcZ9Mzu1+esZI0zTum7Ob3/aWt/6iZDuKswJriwpQvCGOJlnm6HmzCSZ0JtYYj1nXYoJVFNDJ6AJhKhQlGi27w1HfN28o3LREjIma2DAnm6RHURWaAk3MOTLnjNJTp5rFqOPnO4a1wjeNOU+8rF3ThCMytF0SA9skoGpwtNJJyC3u93OGr6I72vUtbPoQo7OCYNAjsiqyDnfQTaeETqRYMhiQMpJbFFHS9MshjluKkIwqsiS6t1aUzuP9Xe+z+PgChuVmc+PBj+nxdTRwiEsoxf7QJcTXrmJCuzl83ftcVmT3Z10XjUabhKzpMKDQxT6GHyf9SKqxG76clRzv1oVO7VMiXcOazgA6kygjncnWvw0l20ipFBm0oaljcPtkHGYDDb4GKtwVxFoMvH15bz67pj9xVgONYcLnQ+XRRWFDmOfMH1LYW9KAJEmtMi33/CDGywfT+nJpvyxSHaZIVybAE+YAezUP3drV0i6zkQt6ZzK53WQSNJnHa8SY3R3uOrx4dSKBGZOZdvBWgpKEW5Z5NyGu1WWdLzkoi4t2hbtaBAF2lwNHUnvW9pBY303cJ6NJxSi3dhwOGvXogRhNg4Q2IEk86gyxL/V8TjScYMTskRji82jvrCHZkszReuEUzzo0izJXa63bdgkdGHTpXcyaYGTB2OhCntNtEJ9es4B/F9dgsgexds7G3jURTYOG/W6O9O2He+PGSOavcqeJ4ssu47URr/DuZbNIf3kZFdZ4Ns/+FW/Iy9rKn+jRxoUvoNA/N55MWdy7oATPbnqWr5bfC03Rc3tkYmd+vHVIJGPWbM34V3dAkDIbU5aitxZSbZhHbqKVEe1S6JPShzH9i7ljfByxFkOkK3HujhLeX3Wc934/zuGKJj5ec4IL3t/AzjA8x6iXQPaSJ1VAh7NhwA3kJtooa/QS0kIMzhjMN+d+E3EAW5r60tsoz7/BmaxfXnwrzWCA28eIEnKsxcCojsmcePFcCl4+j4xYM2l6QScim8uYdngFb619j8y4v+bIlCSp1ditdvrZml9H+xQxh2THW1l5uIqRr63ijWVHW81Na45Wt5LzfPLnA605RI8sQqvcR0BTWGW1cFQK05Y5C2H5dEBgPS2GGA5etZvajAvR9Hq21ip0Ml7O7X1uZMqAXGp0KXRpWENxKJaTYZ7G3Q4nZgL4MLYqYf+R+cOk5aGqqr/Y8n9u6c89R/rzz0e0hL0mCcsZ8Id/+Pt3ZtB27vfYL74Oc/doCVepq6dNMMTCwgK6+/10XlUgPo+vh5OrwWRncs/reSZW4OkaZJkms5jP1nSFp64MwxHW6OhpTmNGWQUPfg0N28rxtkmj3dmPMDJ1ICWuUmInXwjZNrxI+E4IeEXGBFHtMtr8NKYcpeBiJ/Pbmul3TGX0lycxxUXnxqy4g/SPbeKbs2RCToXYPC+yDixJInHUpwXO98/sn3D+MoGWrmZJ+LMzbqNpWghoBBL5E+uU0Il3xrzD9T2uJ8OWgcPooEdSD5wBJ8sLo/qK3xdN5+XLNUIytEcsnvmN+fxw5Ae2VWxjZ9VOfq8UXHprjlYzuG0iH1wpnLMBefG0TY7h+5sH8+6e51lSsIQPhjxPT5+f/SeXRY5x3LuSs3qUc9v+K2DWxVCwDnpNY372RdxZXc70RonEymF8rM9DiknFbmm9KLS089pcSbfC8TxeLrKCtS4/ww9t4rl16UhqazmydIvMqNLdfPeNuFXHnftwaYVcMyyZeLOISh86N5OL+mSx6oHRdM2wYAoF4dlEcNewo3IHj60XigNvVorI226KJ9NdTbwGXfwBtppMFFfsQZMkMJmoScsDwPrrT8T7mmgXpuswG3T4QiqBkMrwsOC7IWENWRkiYzCqYzJvXt67VeYM4OuNBfR/fgXzdpZyx3c7W9+MRQ9wTl0Fj/sM5MaIjGG8JQNNkphe9Dnl3mLmnPiUAmeLwawoIMvowpN8ouc6Omh3M3/yfKZ1vzKyWbNUWnk4eA+pQYref4s579zJ718+w46K1iTMfsV/RiWQSIyiabD2NZICYiG0SNGX0aTXkZdo5WilC48pmVKt9dBesuIBrt77NpvqDpLYUMomfKA3M3fSXF4d+SpvD51D57heSFYTxjgNszmW4jiF7f8KII8TkkfNVC+GFlFu57AyCA31WJZ9jWP/j0haM8+fzI8dzyI4WkTTqj+ZWs2BPyjTOaEz7lA9xoSN2E1PkLT9Ua7oLJzakL9RAMZPoXrRNI37V9/Pao+YrPQO4Wg3qPk0cZhVvpsZMXsErz8/ieoPPuCC3hkkleUTZzXQ4A2y5WQthyqauGVkW24Z2ZaMWAurjlRx7jvrmPLRJgpr3YwMd9nfM1Z01f+4o5gRHZN47dJebHlsXKvzMYXXx661b1Bt/ZAP37sOKybaYSA9FKKnP8jOMKdYgbIdY6FQOAi2iDnH546P/H+3t5xdStQ5dfUU4vQZZcPI9jZR7AlwlprE4gEyd09PwTlrE6Wj3uDtymqeq64lRlXxyDIdA+H3Nz7cmGK0QsCNJEk0+Bv4qGgRBwx6sm2tscvVXvF+esI+VYYtg5v73Ir34rH8Vro8ktE06owkrdzL4TIDlRc1kfvg+ST0saEGJMpXi0Hv2rABmsrQDLE0FVowJsYwKJhN252V5NiNzO/Sg02dopnwoGUbCXFu5t42lDZG8dyTblxNpimeveVbYM/3kW2vH57NgGZNUm891Bcw9+hcjDYxD1jtRdy3+j5UfypBZxdKXSUUNRVxB+t5uKaOzeWbiE85RO/+P3Htt/P4YNVxHl+wj7xEK+9P68MPyzdyYOmXrThX67Td2Ds9g18nnCBnfT7rG95G0olqQzMsJM4UR4O/geI77+RQt/DCbjTCGUqBIHR27xjTvtVnzco0E99exw9bi5AlMfarnH627e2C4s3EYVGpM9uxhvykzPmKqrffbrWPZuctUFJK6f0P4N1/oNX3hyuauOO7nRytdJGXaOWHmwdHHMFP157klSVHeOSnvTR6ROb8+q+2UVznwRdU6JMTx+xlz1L/oyBZLt0Ux5G5YiwVGA1M0olnU6XXQ9EWVE0Vzt/2GVjzl+Or81BrdlBY76VnViwlrnxe3HUvj2c+wPn+53l6t4MYv5jfX/atxSb58UumvyX/aOklEhKW3r3+Ysv/uRkyMzFkZJD13rtsvfcsDna1/q1zi1jOIKRc4cTHTbmEdksWk/vNTLLejWoXj/D4WN1D7FOe9h4sewLmXAu7ZonAXZLpEAiiQyLHnEy8opKfLtHmnCp2PnkJR/01dA8ESOkSxOmQmN2hig8X38T+xuOcaDxBgbuYy6708drQPCyDx+AYMwTri9vJ+ewjMqffw5bEJB7qJBYuqx+0/fnUJz9CbC/h8K6Ns9Ct80B83X3YXx6H75rrqLv8a/RXfIzSuy8TS09ZZ//A/qsaPiRJulmSpO2SJG2vqa6h4dPP6Tr9B+ZfMJ8YYwxn54mF8P4197Pl57spuHAi19Z3ozwBrnxIh3HMCL48+0vG5Y6joKmAaV2m0S+1H/nOAwxtl8grl3SPRNv7np7ANzcIqgdN01hdspo6Xx0jAyEGe30cU1zs3PE9fsVPjbeGbDmAXHsUBt8O3S6Ciz4SXZuA7eL3eOT5j9DlDIKYlDNfHDBvZwn9nl/BTOVs1gbFwl3nDqCVzaOpoQpNlthcvhlfyIeiKmhBMbkZGtzoJB3BgJ+2J9w4zDasBittYrLoro9h14xxhEoXEyhYg8lTB5oCBivJlmhUazr3dfJs7Rhg7YTBXYku4GR4aZDZryi0/W2TIEOVJLbeMp16Uwzt1/3Gd0ueZXSayDxeOSiHG4e3IaioxFkNzL99KObUxXx67OE/faZ5LRQAmjnCIhYK0NMfYHLFCX44tJG3Oj6JJV7clwOuIxyp38OCgpmUuPIjP9GGjcTWwx5x/mZcO5KPLr6a9vHtkfd/d9rxr7Oe1Ty4aIgzMOyLbdz7s4pzU1TuyBfyMXn+ZBa/eic7Xn6EL/Z9ESnJRcxdAyufh+/DpY9ga+Lojql2jlU6GdGjHQW5opyghGkU5thjKNPr+LSiij4+HzfbYbvmIduRTZJFTLTz8r/ig24eci/08/DQD7nMnE0flQjBbVANoZf0jBrxOF+OeJ3dV+/m23NFR5909BBVP9cTqvMhqSGq9tp5btPXxPpdTM29g1f7L+DG4CM8E7o2sj8dIlruc1LjooWlZH6wEH1Iw191EIJugmW7WpVQ2TuHZYXL+FYW191kFovVT8d+wpK8hqDmQVY1bpjvoua99znafwCF11xDglGm3hPgqYUHyI63cvfYDtwwog35NS5eWbaVhkAVH17Zl9xEG29P7c2K+0bx7/Ed+fWu4bRJsqFrnth3fwd7ZkdO51KfKI9dEqxlWIWBh35S6f/rcXxNpSyzWbm941RknQjCEu2b+TQMJejj83NO9nhu6nETL/pNzPVYmXXuLK4OHGdW2KF9s8cdOMJ8f0muHFaf4+On3tWkh/VRTaZEMJhA0xjr8TLJ5WZlUSkmSU+HjDAWKkHQgWCwQNCDzSD2Pc+gsMNsIteUSJIliXfGiK7wzJhMeiX34t836Vj++DimdREk5efknUOdr44DNcKB2FG5gyM/foH7qJHZDjv4ndBURskGsegn/utKUh98EPVfK6gx3ozi19F44DAnzzuf0vvvZ0/tYlZN2MjvLYoTpdpS6mJfZW3JWnrsfp6T6xI48sL7DDancdBoJLD8WXbsK2XfFVsw6loEtsVb4avzWXFsARurvmLGjW35peJlNpZtZM+/p7P8WpFx09uO07vgAzLyBYbyZMNJdtZsZFvxSd7d9Sbp7X7lx1uHIkkSj5TdzXvG9zES5JnJ3RjbOYWeKWJOWJcoU/jJdrbedSF7GlZjTFot9h/ueo81xdLgb8C14ndQFOxFK9B/8hrSuqiGdbP9UeZ/2qAc1j44hoCi8si8fXR8YjFtHl0kspSyl5wEKx3TTdSbw52eX3yGZ3O0StS0eDHHR47CfzKfimeeoem336h+s3XmsSUNW7XTT2KMiTZJNv41LA+ATzbsZM7+9RHpzLbJNka8uoqD5U0km3U4PE0oNSJz3lRoRQu1aGKoEU5zYXpX8NTi84u/Lb5GXl5VyuH9J1ASkuibE0eF8Wse2nI1++u202gwU6SlsldrR58B3/H5iF+JVxW2qx3ZRO8z3qtTzdqvH+3XrMEx8cw8kf+krUys5HXLWhqMf4/Q+Ewm6XQY8/KwDhiAfcJ4eLoRhtxJkqLw4Xkylz+sw2hNFJ3zjUXw8x0i4LEmkt5uAlsLS/nN1JklRUVsbnM15ltnojis+LQQa60Wksdk0+EaM0v6SnxUs5UkSxJTO03lsQ1PgCRx9VmvYbjzK+LffR9JlrGNGI1hwj0csNqJVRR+SzuXBy4UY6fqs+9Jn9yGxitruSKhJ71tGbxZVYM9/3cualjOx00Hodfl5N50PZ2mXvi3rv+fcP5KgewWf2eFPzvjNpIk6YFY4DRSI03TPtU0rb+maf2Tk5Opeeddgjt2sXbd8zD7KqxFm3m01x30SelD9hfz8R4uYOLWEFPXqpy9Q8OsN9Pml93U7txCSA3RPq49doMdv+rju5sG803+01yy8BJqvDXYzYYIBqOm7jiN/kbax7UHayI9ZSuXrlOxXPksoz/thyvoYgI20So1dnoESEtWP3isDKnTRBF9tB8HE57/wxvVUpZorLyD0OZP+eLaAWRW+zC5Arzd9kFKVy1i4fxXWVqwlEC4HKu4XEzUJ9N+Yz5PfaeSXOwCVeWjQ1vovOJFbpeqeGv1g5xXdpx/NTYBEhgsQuItbMO7TeOFQV9hSeiKpIWQA048lg6R79W7BXlsoX8HnwwYg3XoUNDpyFr9KzUffcSEbmlM6pVBIKxL2CenNR7mj2xUx2TuHdeB5y7ohuKs5tDrEzieH+ZiUgKU6HUcNBqICfnIiWmL3RBtvEkyi4i2JdWLNm4itkGZkbJvqsNMqsPM8sLlrAy1Lp0BDD0hnNeXR7xMt8tvIuYC4QQYlq6ObGPWm+mf1p9us7Zi/epn3t75Np/v+7z1jiLl+LAzEmzd0dYx1U5hnYfqkuPg3Y9TkvA1iWxOvU6mp18QWudbxfELCfHl/i85Xn+cDw88x9yTn3NccyMpQVIsGTxi7oRjmQH9yiWAILPVy3oMOiMD2p6NTtZFF+KweLmEhqQphHwy3SqP8cPipzEf2IdREo7a3We1JzPOgicQon1YNH1PG3E90sIV9CjQCARcaMAvsXH0/aYvj60TmWNp/s0kh0JkZgyApxtpSmwbuXaHQ7zKcwZ9hLFdOySLBVOnTqQ9/hi5TeVct/AdPEePcdPItthMeg6WNXHrrB2UOh4lkP4C48Ldkc3d9wDdM2P54toB0QacBbfB/GgH8sNNflYVllCPn/MHCFzrKucOfixewUJ7DMdCTYzIFsGG21bJe+Ey7wWDH+S1MW9wd9+7MYeCdGqqontid2QNRvoVvimrYPzB5VjK96LTNO5O3sehHJl9OaV8W/YTfY+pvPb4IY7ffzm2DQJ/vF43lAq9Dr8WooM1DTL7gy0sSj/heeh/Q6vSVKJk4ObsCcw8Z2bEKRyeOZzXBzxOvV0iY9CoiD5o31Thpe2p3sOG0g18sPsDNhuKyaqE9rv0wvm77BvSXnkHd8dUppp/oKriJIcHD6bmi2+xD+9LebiB2tq7J9VaI5Km0cdl5GO6RM4poTIJw+V3k9Ck4fPFo65YzzFPBX5Z5vjvyZz4NRXN0zobHNi6iKYD1RgKN1FdtpU69SC1vlreHfMuVoOVrJgs7ux9Fy+cex4PJCdxS1oKFr2F1cXrxQ50XkyOY9gdFSTbTdz7wy4OKz6+jLUjoZGdYOGL6wZw58hBjMgcwSZjEqGAGUuDyG6r/mQUfwo/bhFQizhTXKuyb86i65EXzEXat5tTrdrlp/OTi5kbblyp8dbwytZXONF4NCIcAFH86uX9s7HmfoJO1vHu2De59Ykb8Nx4B+1X/k7eDyIzWvPRR5T++z5C1dUYszLJev89Yi++GPfGTXh2RilIVFWjc10hA3NimX3LkIgjekFvUTBL7/IZtryP+G6ryLInxtcDGpWNPtYfEEurZArToziCyJaoA/SxXxThjqkhqD2G59U8ACyqxh61HbEBF0lZaTwzuTsGXTRjpiM6x7r8Kgadg8Bls3kr5332ytFx8ldmSP3j5Mc/ac3UPnmxef/sjkfcT58Ok7m3z13MOf8H+u2ZD+4qyAnjDGU9XPEDTH4PoxqC3d9iis3BNvIh6Hwed/W5iwf9BkZ6vND/euJzhpMREuN1WOYwbut9G/trBTNCt+zhzD4ym+kbp6NpGkFFSAdu0yn0l6zknP0KOV1Fgso2cCASIQYrfi5KHwYWsf7GGu1MSO7HgsOz8a97A3ufNqTcf//p13UG+yecv21AB0mS2kiSZASmAqe2mywEmtsfpwArtb8BupLj4wB4sGih6Gb75iKm+TRmTpyJZhZlFX2jm9HHjFy/XKXvzG1Uv/EmoevvA4SYuiXoxeutp9xVztoSoZ/48Z6PueyXy3hv13u4Ai6OrRANyh0cbaHtaEZM+4ULD4qXIU0Rk/PAvT9DYvvTyS2NtqjmWVJ7yB74h9czpF0i6x4aw7RBOZwtb0fe8DaD28STVqNgVMCyaANTlrhI/nkjZr2ZJ67R8dsACRkYf3IfpeuFXI1R84CzjMyQQkJ9EVOT+rPcZsXrbcvFLjcYrCBJmHQmkixJXNzhYmRJRpIkXBmCgFM12mlKFYvj8Uwd6njBBbi64WV2jliMISMdfUICgePHqZ89h2qnn6OVTj68si93jGkfkb9qSUr9R3bvuI5cPSQP487P6eLaAnu+FRFU7TG+jHVwW3oYBK430RsbFzpFxvOtfY8Dp3T7ulxUdbyB8sGCCf2bTQWsOlLF1rLNfNbDRPaDrTuo953cBJpG1++2Etyzn4w8Hds6gWNHkRBhd5Xz6d5PWXhiYauXIcJ312yBMC7SHOZmzGjNpXRx30xuHJXEkS2zuTWmiCmZ6eAWTlGdI434Xlfxw4WvsjzMq1Ufm85bO97icP1hKjxiwh6xS6FosRk0jc+PVOIs0WEqyufaIbkYdJogiD6ThScXSVJBDUViEwBDjA2TQceM9HmMOPE618zYQq9nltHkERuVJ0qsvlQEAQ4PDDIm07NNDk8lNDeiiMX0204jqNbr8fobIegj2ZqM7B6IjIF2ce34ZPwnZHfoR9tff6HTzh3kffctcZdcwoRuaQyoPMw7NasYVyg6X61GPTprOJsrqQRKSjjUuQvefVE5RhA8nBEYgc4EqVGMDpd9zdYu47kjLZl2mYJcPKAHV7hb+Y3S5UxK6EZC2DHuHt+J0M3rqe91M8Hm1IveBCE/OllHojWJUIfxtAmGWFG2gYuqithdUEz/6sV0OwyxTlFS7RwQcW77+hLMhavZaBxKky5OnCIyPfrdCjf9Hp0TukyC3CFYDVHcXuLU78nqNIlsR3bE+XOdXEXiB4P5quc9GIK+iFJFkiWJbHs2Oyt3cuuKW9lWsQ2jScxBfnSC5NmWiGnIJBY8NJzqOIlbNt/HyqESwXvOI+PDGeSninNJSVzG8BNbMAfg0fc8VO6KKtNctqeEuFo/ww5puDukUhULYzQTif4QUq0Yd8O+H8+uqrATc2A+5V8vonR9Ah0PyBToJFzhSkWnhE7h8ShxS6+bubh7f7ZZrXSzpJFkScIZFM6aJAfplBpHXpzACRfUergjzcFbCfH4JThU7qTPmy8z8adJ2I12pixoINCgYfSLZ3FVj/H4TtzLkeOiv3B09mju7ns3ac8/R8Ag8ZotATUkgbmlM6cy5eONfLEuH19QjVDH1PnqmHVoFkVNRa2gK53ThOdc7wmApJBsTiPBnED/rtn0e+BODBlRzLFn924AEm64HsloRDaZSHnwAQxZWRTfeCOBklK0YJD+Dfm8tfY93tIJ6qzmsmXXdAfbnxhHik2Mp5VHT6CzHmdB9b8xxAl5uPgwNKHygw/Je+Q3lIQ8LPFBEhUHCUE7hxFz6ZTyQkLAJVnpjHV7GKsN4Px9G3h86M0UXnMXIUXFJEfximZDFE7y6tIjFNd5iDHr6ZUVyzVD8vhvs+Y14YOxH/yzO7Ym0GHyR9zQ6xY6J3XDun+++Hzw7dD1Qtj3I8RmQ0wy3LkDbMmQHe18NuvNXHP9JvQ3r4Z+10JGHzLDTTwOo4MEcwLJlmSGpA/h4bUP88neT1hbspYv939J31l9eWHLC5QSYoCqByWEPj6e7C8+J/Pon4wFAACmS0lEQVTtt4TyEoiqwvhnI5XHCbvm4UXl7V3vsmTr6VQ3f2T/a+cvjOG7E1gKHALmaJp2QJKkZyVJmhze7AsgUZKk48B9wGl0MGcyQ0qqIDqVJNSBd1JzMAa1vhzqC8m8qjdJ3Zyo+UUkusVAaPghWhYyykbaxLZhyP5FTCg/SpEzyls1+8hsDtUd4tO9n7KzaidHQy6G71dJef8bqC9ATuqANVZQR3yScTYri0qQOk2Evq3pO/4nlp1gpWdmLMnbaqne5Gbxyt2Yws2kJQe2oFc0AoWFLMlfwn2XvElJopgY7H6YHwbiph76GWpFowVTv6dToojMiuwy9bIsopOwZdgyWoHJQ7Z0Csd+TEO7C1B9YhLNbtChFB6LbJNSr9H0y6/okpMw9+xJqKKCTxftYcpHG+mZFUe75Bh0so591+7j90t//9vXHkrsiFeS2OTIwb1DSCSpGX3RhRU4NNmITtJRZNBjVlW8isiu6Vpcj/zMIwTe+QZ3unjh3l91nKX7KzBLMi5ZpsYaxduFZAg1NuDwgG/WHDav/YH5sg9Llo/SDD03zr+SCT9N4L1d7512rqc5f80Eqr5GVEsatGnNeJ+baKPe8iNPO38BoMygx+aIR1EVGvwNxEt6SsOO1N197ia7nVBTseltxJnEOScEk/HVmUCS+DDlEG6jEVMowDMXdOftsS/zzJBnznxjmzN/koozewzH7b0jX2lmM7EWA/3NZVC+G19QZVj7JObviC78X2afJH9oHoFkO3FbW2c8XQFx3XNU4VT5TqyEF1LpXnEEqi8n6E0lv9pD161VbJ37IZf9ehnOoJOAEqDCXcFW02YAzHt30PDUk2iqWHD19gNImpFHusyPEBhrwT+RgYvNguROkVL0jUe+4mGP4NlMc4lxnNSk4WyRka1YMR1H2M87XHeE7as/ZOzMqUxZOFV8qDdHKE2SLMnMK1vLXLuNf6cmc9AunknAqWf0UgPtw7RBZzeGu7h1MuV+I5nJSUwKLKJNMMTWsZ/RPr41hozqI1C6kyRzEqZwvJtojBcwgqCX9nHt+fmCn5lRtppb0lJI+e1hntj+ClsqoqXEt0a/xdVdr478fbCri/IuNn7rp4fSXbD6FdA0zo8R2djjjSdY3sdLj565KCWb+GKEn803pWBJCNKzdA/vZ52F2wzFlWIxMQY1VvQUk1BKvYZ5VxGmILTxelleVkZMuOEpxgvlrnDT1v55NIU7341ASJI43iDmJLM+6lQ4A06+3P8lbgkGWdJJMkfpmcwGjcN1h1lbKoLyGH2IPn7xPPpzjBypErdSTYmrgDRLEjEuMc5lv0qCOYFrNy7it58fQkKFZU/Q3+vh6q5XE3fxxdz1eCKNFgk00FoQC1c66yHpJz7bJkrBzXKfzRnDLS0a/QBendKTa4bkUuPyI0kKRxp38c3BbziTJd92G3JMDHGXRBkW9PHx5H79FY5Jk5AtZhp++omSm24S11HeukBm1MskxZjIlQTeVDbWojeJANJgLqK8volVepHVkdzivQy4fLjLTPT0VGKSoUiKJzOo0NftoUoyU6fTYYtvS+3nR7j4xFqcRit3LClkb2kjRl30OZ3TPYOXLoo2kAVCKtfO2MqHq09wzilSlf8NpgtHuIr2Py/7/pEFlAAri1byzq53qb12AdyzB7pOFlW/kE9waoKoALqrIWdQ6x3oTdHkwN459Atr3tsNIpBYNmUZH477MNLln+vI5e2dbwPCNwHoVXkC1gkFr5hhw9DZ7dAxLHuXHFbS8jZAXC4DfaIqNSvWwSfVW//2df4jmD9N0xZpmtZR07R2mqa9EP5suqZpC8P/92madqmmae01TRuoadrJP9+jaBv3HzlCm2ro3+Cn9mgC1XsdNK7dK8hLd35NXHs37b56BS0YQDmFS27FpEWY9WYuJJYrjnUjZ+ZqFl28iAUXLIhoaQK8vPVlrO5aRpbr8S1aJR6sppH65BPYRgwnYc83JLc5Cy78CIbe+U/cLqwmPWmFddTtt/L6gm1Ux0k02CC9wk9GHeRUQ3VDMW2XHyLTnMyK3hI2FAYWiYHe5WAFVISzJBm9SYgRkfP7SY28lhAPXSdFjpUZk9mqiQSgqc25pOx8m7g9YhIzuQOYXn8ZgD7JA5i6PwHN70eflISpg8gKDfnxAzKrClmwq/SPtXr/wkyKm/0mI68Wv8K+re/DwJtR07o3F1LRdEZUSc9Osxmpxe9aZv4kRUHSgtgLl4OmMivwbwY2LMaEREIjLJv7C+vPFeTHehWSQxbONQnG+UX+HWyQfHzVx8RDlwTZ6mydaYocQ9Wo9da2xrzpxSLRcNLCkRkygROnd8NWuGrR+eGyRhdWvRVVb0Yr38vbVfVMXPUOhk3vowNu6jyNBGMcAFaDFYdBpPAtkhVNb2i+GQQNMqrPiz+kkGLJINuRfdoxgYjzVzL6DbwpfSm0dYt8VavoUVQNRTaQFqPntSk9mXHdAG7qfy5jrUIKyxGXyurrerAp3c2RptavZoW7AjQNn1dka3xh0uLQhneYzidoio3ywC6K33wV07KNHK47jCvgot+sfly56EreOfY5Wguhd9/evYJYW+ci3pTIlQPbEwrjl/QpovzrV/yt7z1AYwneA/Po+01f3t/1Pl5ndOGUS0R5PbEJXClRicHnkhK4zR1ugJHgaMUv9JGPIDVPe3qzwMcqIeLDJfpVYUfh59h4nk5KQAmIbZssYkTq2sSinjUBw0AHSihItT+8r1EPY4zLO/3ZrHgaFt5Nqi2V+xqFY5PQWAavtYP8tZj1ZtrGtUXRm9Cj8Z1DBEL2xnJoEBnhTkdXcXy+IOk1IGE0eckfWUG1RcPld0LpdpAk7KEoJVFOMMgJzUflto9xmyC2WZ4sLpeBqp7KWJiwS+Od2T7e+UThytViDI3braH3q5iCkFDXi6pNccQNEe+T1Q8VngpuX3E7R9xleAI6dreB7jkiG5Vtz+bZoc9Gu6B9TfxesDwSXA06uJQvOt3AOS4xhk7t0rx2UBb1wTSSQgpzTS8wafW5SHoXOs1C35hckrxhzVWfSr2vHu9PgoQ7w7EDNr6H9vUkThauIf/RBxm8vo41YV7VKq2e6dtuxhNyU+dvwBi/BVOSCFqbqV6Cihhvp6oBdU5z8OwF3TlW5QIphCvUyGd7T5e+A7D07k2n7dswtW3T6nNDZibpzzwd0Wduntt09iihuaYolLz2Et+8+hXrDoog4aoRNl64UDRP9JRP8Ojec3kiIRrc2mN24+sdA0i09QSZqvbFIrswayovGocwt9f1AAzsEF0Prju4mB7Vx4kx6TGFnb8sWxvMOivdM2N5ZpKYOzwBBSWcIW/ZbfzfYs1rwls7/n6m6+9aQVMB96y6h8/3fU69yQbxeeKLxHbQ7zrIGiD+9jWCNRFyT+frjVjdCc7OE4F+s6iDXtajl/VkxIiscbY9m0cGinxYz+SerBn/NZ0CAZFhbGlnPS5wicmdBM9p5T5QQ5g1jRsbxJpcqrjRlL/nEP9XNXy0NM0fIP7KK0lq0HivoQ3+EwIn5jpQRsX3Gzm+KB1XiQX58DcQDLGzjRiodTdN5tFrdVQH60FVUOqqqFlRQMOMr8i2Z9Murh0fjvuQFS4zNzU0Uu4s5aKyY/Q/4EX1a2iZ/cHXSMyWm8kZWYNeqoPBt0XLOP+AndMtDX1KHJJOxZJi5+cnBrG5k0RSC3qkQ+X7CL7xMQMdXfh0og67ScHWkhW/7Ri4bCbY04mLi+KvymkPk9+P/P3yyJeZcc6MVseX/Y0kHp6FwRodJAGjjKqpKPipt4lFJHbyBZjCesbp+7fyrz0LeODHPfy6t5wqTxU9vu5Bv29Ol/L5IzN6a9hgERPOSS0A1kTU4i3ofI3UdrkaVW8BnYEnaup4u1I4BNd2vJeeCS1K6UoIfaCWvOU3IAfddKCIi4tfxKwzYQnAiAMavfVRrGNXYy53pogGjAPmWopRKDIIB6tbfDQIMLeIgq2a0EOu9baApab1gNhslDAMIPRba75JgD012ykzu8kKyHhCHn6cdT7//nkKw12NtA8GMWgaCjD+m/5U7BPNKTaDDYte7NMeENkF1CAmTQVdkJDHS6cnlvDgkhmsK1l3xvuq9e6H8vI7aGk56N0VKI5oeThkNHO4ooltRU5sOoXOaQ4BrJ/YhbcvHcbo7NHEm+PxhrzIqsbyU+SXKj2VhAJufLLEZKeLD8Jd46/6i3g3+xCvjHmYUXIX9FX1+HqLseIOO4gd4sXfWnY6lr59Qa/H+ftKrEYdwYYB9Iu9hKm/TmX3frEQe3ZsR9VU+s/qz2W/iOxHlaeK+cfmo424P7JofrL3E5rqRdn49l63o5njAJg3TMYb8mLXR7s7zwkZ0IVfm0KDHkXSOFLuYXdxA8HkLtDzckpqGritSOBwctuKruKtOoVfbDaUsHPnCvspit7K9+NvRLWZGCgfoX/NAvHFmMfO3OxlsEL4fky58yDLLllGfPOk7qklpIb45uA37G08ToyqMSvcmOJY+iS8I7onWfIw+xSR6TGpKsmKygVON8vb/wtbYxGedmNYXricqQeiGezVNisXnZjJRJ+4rvSO50P3KWCJA08tql3czeQiA4lO6BYujDTfq+0dJMz7S2gMZHGjaQ+fT5CpdcDyguUU71iL+moZjmodikWme9xwHnD0ZqJP4aI25yHVnYTSnfByNhP2L+bu1BH80HYacYpK8T2v0WOTnhSfhe+vuDdyvlrpLsYffZak9u2o0eso1uvx5p5FP8Mu4g0xjIrvgiMMu7X27Y1ZF6WamTwgA+7cTqMsc+HqO3EvXc6/VqiM3qeBrLFDO8rxpoOsLvsVS7hBQDaIDG4zT19z6bVZ0/njq/py04g2EQqbPjnx6MM3pxlv1mxlrrIIH+JfmaVXTzRFQbbbRQD/bBKoCpK/Ee/3X5K09Gs8NkGIPa33EMbmnsXdve/lFnMaAYOdZWkmjmTLaCYTZP9Alf8IAPOsdlKcv9NHdwirqrIqpYT57tUAxJgS0NIFnvCS42voXSOcv3aOLozNvJAXB35JaWU8Ly0+FCl5t+QbfGph627l/wZrdpxazdH/kDVn6IDWDU4Ak96Bc4TsI+m94IblkPInmMgHjpJ53rvMnTSXYZmtncTMGPFMMmwZXNnlSn676DfeHPUmCVs/xwAQeyppSgtr5mEdJsj976lv5NHkYXgliZqC1X/jKv+LnT8ALRzJKn3vJFAigLmuo07qtzcQbJJQR06noVTwMu3NE4PWse8EJzIkftzzIbiq+L7FQvDSmqf5cPeHNFQdILX6KNnBECFUigx6Ql4RSWjWDNCbaNhdS8WP28EUKxytf9CMehlb9w7ojBqD4+qZ1uYcMLaGQMY1Q8yMBi5qchEfVCkOry3HDAYB+Ox6AUgSeRn9+XHk22J7XSwo0ayJLMkRDrdmk1RxXx05PrpMLaMkVU9RsAxPyMXe6r04reKeWXp0x5CRjqmTyKb4dUZCqoZRJ1EXxlYF1NZZxT8zLWtAZHEpNeiF8wfIyJQNewFNb0GTDVzudJHUR3QRK5rSquwreP7E33IoWuIzWpMjotsxC7eRMtRIm7nf0/bBawiWiGi+OhaOhLNQ079VuH+xcJL0kp7+af1JPVu8bB+PfI/vzv2OhBYlKoCA3shvHdPD9/CPr/vNZOFArdPqWG2zst5qwSVJGMLXXqHX802DWJStBisdYrvTOa43WQEVneZHVgIYNRV3rIIhLg6AHY1zWXB8wZkPmJhErKOIpGMzSd77EVNiv+Cu0ffyVZeJBMwWQopGED06LZoZavQ3ctOym1hdvJqmQBOXvbiFe35WaWzB52WUjYzPHY/PW4tXkojPGUbzk3DLEiZNY3LXAXSuF45zsKPQ5mx2/hwG4cgEu+RhzM7CNmQIqt9Hos3EN9OuZN7aLE7UF+EqE57HD3Oe5pyfzqFbgYp591GUhgbW//sqnlvzJPs6j8OMxHtJQie7wGhgoi2P23rfhhYue5zX6UIubGpkY8JonqmuZV5JOZX/Wsj0rteTFFIoNBgE1Yum58IPNtBhpgQXf4oBhbTwYtfGLDrk3WhISNSbBc7wim6TGeP2UCPFs62gnmrlFMUhZ0VEuaWVGSwQ8KCoCkO/H8qC4wuQbeEufE8tsiTz6rZXxVhooXrhUFXQVCjfA4Nu4/rGJr7r9xjLikq4raGRJFUlbfkzSEBlenfuWy1wznmBcImpheTgRxVV9Gysgos/g8tngTGG3okJaGYj8wfDj8Mk9Fk+XrpUpjE7hJwIjmGN6I6dhKx4DjoUlvWTaYiROFx/mFH7xb63DrEQSkmh7K2DXLl1CcFFT3LguSvR3u0Ln4k507p3Djdt/pZuv7+Mv1GP/3g+A7brMGs6JOCSDpcA4CvbAQcXMCFL/G6DxYylcCVmfT3ZOtB8TahBicTLz2HxnRPxKj7q4jU2dZZIjLdCQlviJD2dFVBD4h4YQuC9ty3BgSJTs75iKZIsvsuIi+HqwbkRNZLmTJIa1u4+p3s6j5/XlaASxBvyYtCBwz+Bnkk98Sm+COYZ4OyfzmbMnL+3Rpi79wBVJW36dFLa54MaBDWE71g+Ia+OtJpaJNmPSc3hrd9cvLqohJt63cCY8hU4ApVIMjQkmAkGg1h8Gm3WiXfPFISZCVYudjVyqdNFT2RqQi4mbVbJuPQFUq++ktCvq8W91hmxm/X0SRrKDZ0fQC8bKG3wsvFELU+GZRr9LUjY1b/Bifr/t/VL7UeiOfGfb/gAbMaoz3Ca89fSJElkA//CTHoznRI6EWuKbfV5s6Rm50TRzZ7jyGFpwVLmNIWrSs3zxJmsGXveIgjKbi/YUIoLV//lOcF/ufPXMFvUv5W6OrLee5c2Hz7V6nspxk7T+t1sby+xtL+M1iEdR2wc5+8KMaHcAs4ybJ5oxm7d1rl8tOcjHtn8DBvNZrI6ng/AHXnRUpFiTAG9meq9DuqPxuBXMmiFoP8HrKyoktp1ewh5dVz86Ud0fv9Obk2qZKZ4dhSMy0ENn/bqAyuZ+qEZNXYaAweJTEBaQBGancUCQG/UGcViAUxwb4CXsv70+IolWjq4wXM/8Q0aDbIbXxhjV+EWmcRAURGSLNP25wXU9R9Oqkc4fAadfFr0+3csvvsEgmEG/WK9HizxXGHN47EGV0SHUjXYaGg7CdnRFovOxrz8GVR6WmBjQqGI86dJeh4JCvzMVSmDeWVctATgyPVh3vMChkXXEqosQ5ecRMAgbuqE3An07TASy+b9nF2bwchdAXoY86hP2EXuJRX0ajeMHsk9Wr/4e+ew31XC9kZR/qz2NvHmjjf5dO+n4lxOmSDH1CTgDmcT7k5NpkyvJ1WJOl/D7O1YeelKsu3ZDEwZxfR+72NOisecGERSgphliRUXGUh/+imMehm/4jxNCzpipcUYls0l9tAcJFVBQcfxuCxmdxqLotMTVFQKtDScMdFylKqpbC4XeLwqTxVpyW2we4WyA0CqojFn0hxeG/UaNkXBJ0msaDzKR3EO1JCEX5OxqioFDScpPRLmlcoSGddm4L/DJCao+rsuJ+OVV8j+9BPSHnsMo15GZylF0jdyzSpot0Zg/kwuPxWuMp76XmX69yrVz95HlzXFjNyvsf7ITzQ4Migrjmomm5QQvN4JLX8TAFfkpzPs5FZOvryMgUuMdEjqxseHZvLBiZ8Y6vVy0hzDUdJBi77PIUUlRvKwPxwUJDlFZjOohfBpJlzGnuji4rjWW88L3lgcZz9BgzfAjNTHqe0c5ZXkjU4QihK0R8xog6AHXcCNX/HzzYEZYHIIXK6nDlmSI0GGzRB1KJvfZz4ZCUcW0S4YokdjNXZNI3bKVzD5PX7pOIJvHHa8tuj7PMXpYqaxI5d6o2NtqNeHbc614GsQH1z4AY4pj2Dr3pO5w2R+HKnjs2kJ7GovYw+pmKwxXHZXPkp9CINyFEnVyK3UmPFmiE/e8CHpDUiyxqrxcXg6iGeeL8Xye1EK8uz9+BtaBGstmnTcFWKhuu12HV6jjw93fxJpDvHUHAWdiXO6TkPWNN6Pj2X52Afo7g8wxJjMpvJtfDdKprJzIntLBGXM95NV5oyQSV35ML7lL9BkSmegswld2C+Lc2nUSj4SYzIxyibOz7mCarczPDZNEclGgIHpA9FLenolt+aoW1KwhIHfDmR1wTaKCwYwJG00AD7FJwjPnxYLetvYtvwds/QQx6z94gvRHGiOBb2JpuWrQZMw+4O88NMJFKWRpUf388PuHdy49EZ2Gg24JYn4RuiS78ZvkCMJAgBjCA4R4NwGLxepFmySiSe+V7h6lRhHvopKlLD6i09vxBrGj++v286T227Cq0VVQ64alENKCznD/z7XT5gn5MGqP7N6y//GbPq/6fz9L617Unc6xXeK8I0WO4t5bftr/ByfBBNfhZRThdJaWDMUqnC9COgu/5bs1N4AVGSdWWTiVPuvdv6aLXRoHcasLEyjLyN+2rTI53LtAYz+g6TXieGpG7yX3Ptu4LrfVbLn/wxpPbGmRiXW0urDafuiKg5Yh9B94ttcZRjOWx9Gj6WZU0CSUMLcSeoFp1B+/APmOpmPPhhgTXYv5JDCt207clbvthxPFy9k0qjJyOE3zmNSkTRQskbT5RJxLrYeV8P6t2DLR5F9frRY0GDEK2oLWpI/tsNTN7Ov4BIeWPg9Nr+CUxeg0hOWYnKISSJQUBjZPql9Hpn+RtA0DHoZb/B/gAPx1NGcLysOZ/56GBMZ6Wyg+wwRQalGO4opHmvDCe7p8RyekIvGQFQqTb1gCvpBApciKz4evuffeK76FbmxiNDyKOegrDThLaij5kAMqY8+TPsZL5EUTufH+T2EJrenwhLghk+LuHWxSs9dZazbkcrMYDz7q3Yz79g8DtUeip67q5IGncz4XWIyrfa5mbF/Bu/teo+j9UfR0EgluuhtVHqw3RKdQBNUhUkuD8M84r4FJUi2JmOQoyVa47gB5IyqQ1ID3GfK5BJVfGcyKPi0xkip41STtm+hfkEhml8BLYS/1MjCXx+lc10hIUUjoKi8GprKjkFRItPmLlOAhRcuxJyQjMOrkaIo7MkvYmmtj3Zx7dA0DaenimXFZXRw5DIvKYOakk5c95EBq6KxtWwTCU4Nr0UmMSWPgWnREn2zs9qsWtOSjPWOlbfSRf2FcRuFM21K1tPT2IaYFsPK2kVgzXxGuG3VB+y1x/KSRWXEfpU5L4UYRjq4KlDdAu/iObif3cEG/JVe3KY8GP0oTeW7qQo0EmvPpFoK0ejsR9Apxs958mZ0L2VQeXgzEqAPaXQp3cvXuhy6xQ4HJMx33Ev255/D5PconLIUW1wyDZ4gcVYD+lNLTvrWqheAKPsG3BDWnHWGvCJjYEkATy0c/o3uZpHSH5g3lm4O4UQkXDpLqFkANITfQzUEPS+HtJ7Q9xrWZHTi+9weeJWoDu8eezzO5A50PS/6rOXbN8OUGbDnB5grcGCxk84nZ8aXrL5iLWvIJQ8DXywLIJcb8Ra7ONxTOEFm2Y1ehde+VLD5we6D9MogHpuZN6vHMm3fagDelg1syBDPV9MkAZMAiMuJnIe70kQoxUptrERmQYBJz8xi+aZZ4tnVn4SEthS6SlAliUadjvtOzuE+xcZtciJmVBYM0RE4so9rH96Axa/hV2Te+EzBUSzz9oYqXmwcT3tvMFJdOHuXhnHdSfLMw5ne/WeGpo3nRLV4DofK3adJqWXEZLSCfwAR2UPZXIpkqEOSW5R+V4hkRLIliT4prbv//8j0ycmkv/QStsGDqZizE2Q9i078SumBDSCJfXes8GIJNmDJ/B6dqZwtFVuYFWunptbM5M0qjiaJWWfnYGoBizUFof9RlSM/pVM9+ktS63LoWaChdM4jKOtomvk1pssEo4PeakUnS2ysWM6Lu+7lRNMhaEFaP6VfdqQRBiC2hXTjf4utL12PN+Rt1cj5T5muRbLnVBWff9Ku6HwFcyfPxRTO3pW6RJLDr6kw6JY/h5o1Zydd1YJRoMv5ZNmzWXjhQiZ2uPBvHf+/1vmT9NG0sy+/krpvZlFwycU0/bKA1OsEiaQcakQNSmTWQWaNhlnTIOBGb1EIOX0g67EgwPQhvYRVEQ918maV3j9XYXFWcHN9JtSKBciR58fYa7Q4aHO40yJb80+Z0SUWq0k6kXnZkuLAVOfjotosFg6SSNixm/Zl4gSqY8JYlO0/Uv3i0wCYhl8oPP8WtDMrbCIC6hz4e2XYYEwGujClCsDyPjLFbpGBOdRhN8lzvyX+qmhmI7lDHnIwQLzfiUEnMG3/qWmLHiQQHs9PTfgUcoZwRHGy22REa/GS2YtXYqk7EOnkasXzN3Ey+oFiYTE6i4n/5V9YNR+H6o7wtSEKmpTx4KnUUb3PgRoEedZ5rDh6gH35RTzZ4CJt+6s8dZWOnZ30fHieTHWKj0FHNfosN7Fp3688tfGpCDUQAAG3kPSxigvoEW+MANZtBhuyJDMNR2Rzb+K2VtceGy7DeYziNysaDvPB7g9aZQy1cHlbUkOMU+3kbVIoe+xxDCYxXtJtp0vnAS2oXhQkVUFCjyEU5K217xFvM0a4ygwtmqJaRrQ5jhwqdC5sXvDHZnJ8YS4VKyUIeHhwwaXcuO0F0pK6kmpLw6c3EkwZhU6VSHFqxBtimDlOx4sP59EvtR9fnP0FXRK6cEP3GxiXM471U9czNjesMhIIcHLSJGq+/oqR25q4PZzxEzcxEaPT1yqbYc4V19szpg0S4MwUEe1FYX3Y0bIIGOL6i3J9+da1/FhsQZFAGToMOp3DyfDiMGTsS8ydNJeXx97La+fcyKMTOzO2axpSyEvQWU2/fPjuNYXs3Ufoe3w9NikVTbESm56KpXs30Ok5UuNn5qYC/CGVc51ziS1cgitjKDXdbwSj/cyTdc/LYeIrcFCwXyXpw9m90Q9Dl8nwwzT6nBTzQL+GKvLK9pEVDGJQQ8LZa7Yr58KI++DiT4V0HBBnjscVdEey8Be0u4CNNht3lP5GTIssIildoPvFgiHg5Gr46nzY/T2SwUCCOYGEvtdxuzmX2D2wo7PEzLPEOJFkjRhziKC+9XX1ytewOP1UfjQLLRTGDjo1/M29SiEJGorQNKiZv5aQP/z7uGykTulctVLhsTkqKTU+6ioKeW7Yc2TXFUJiu4giEUCOPQdiUin5dBWWT78npV4joLdh9kuk1cMle0PIgN2nURWysSPmLDIDCqUJ4OspxkhSUGX+rlLun7eeFfmbSZC7oXizCLnb88hP0YavQ7WH6J/Wn8ntJtPSmpvlxnfJIKb9q/hCbjZesVFka/tcBfYMqr017K3Ze/qz/wOLu+hCFJeThj0l7As5eWTtI5TkH8KW6ifz8gbuebIbTqsEUoiBbeIAqJfseNfEcvYu8S4bDR5svnBDxhgPJ9Pgmt/FHPPr8g/otaOKRiuo/bdz0tE6aOyQI8qJ+hZzrr6Fw1PW4MVq0PHVdQPITbBiN/+5du7/DfOFu/RTral/seX/zJ4a8hTvn/V+qyD5/7QlmkUG/2+VsrP6w9TvBOVL2PSynjZFO5B2f/u3jvdf6/zpw4tsWv8GYgb1pfKFFwiWl6I4PZh6DCBm9Gj0GRmYYsUEOa3GRW4oBJ4a9GaVkFeGn+9Eszcwb6jES48kc6i/GPR+IxhdPvj130hbos0RUk5fIccEaGHRdm3X9/wT5s/P51DnLni2bcPoFIt5U4FwBIotQdpWavT5pYAjeRqBBesZZ+kFH9zJ1k4SKqAc34R2YAH6lGRsSW5wlkGLgdlOMtM7YOAz31TUK+f/rXNSm0QJRJUlTmRIrZQ0/HmprTI10phxuD79jk/vGssFvTMi303M+w/Y3AMu2geCDA+l0Dt3FBjMfKLW8nRSAlqzM6KGMLpKiD/2E6/teRA4heevugpXTA9OnvsDHtkGxVtoWvUOlcUbWeuwoE0Zi2TQIcmg1wSVReHUK3CWmqI0pvF5OIJ+mmwSL18Mq3vKLCoX/GUOL8TlH8EsG2kKtOjA8Ts51w8DZSPG2CDG0TdgCgW43NGZzJhMXAEXNbZ4LOGjdLKcS8+EIVjc5xByt4PHa1h77Y/sCs+jpYF6vj7wdat77Ju/nuK1CUhqgE9Ouiitk/Hu3Mk5vUQ24g+dP6XZSVaQtBBaC/LWpBgTOQkWPshdx7D1Z6Yq+nTvp+wPFuLwwFg5DsUTpClfD7u/JadoK4ecBbw/eCrFWgBfyEewUDhUkwvTiLOLheXyvtdF9pdoSeTefvfSLakbsabYSHZTNhoJVlVzdPcqJm9VifGHOHC5yMz7Cyqp99UzLfW8yH6CRYI65Fw5k6cTE9jhq+HGJQodO4oxp+YMB6Mdnc6HuWtXYl0qVy0VTQvSfqHkM0oS70i3pG50SujE2d0TOb9nKreMasfFA4TzWOfozJO1opu25mAMy60WhmcNZ4r1ZdRvZhAoFJm3g+VN/LijBKtRR05QOK5NOeMwNp78Y2hIYjtY9AAsfZSVRSUs7HGv+HzAjdBhHHSZRC+/nxhV5eTJFdxfV8/X5VUw52o40YJGKaUrBDytcIUWvQWf4osshFd3vTqCt8xe+xYOg50ru7QoTevNIttYsE4Q1zZbjymAhKTTCMVYKA1XkXPH1hCf5aOrv3UlYcXF0SCnLAxLSnRrPDZbOB9qSAJfIz6ng+q9DsoOCEB8zqx5xNx4DoYWPq3NpxFrdIA5Fi2pWytt8yJnEef7nThPgnywgfc/VpDCqhcXnvSRu1eMqzyXSj12nhyo0Vnz89tVAa45r4b4qZXEXfNvDvnmYGn/PF+efICmQCOegjsJVJ+DvgWfX4mrhHnH5rV+5wmXd4FmCGWsyY7daBc4al+jKNsCx+qP8XdM1VR6ft2To1oFSkDmyvQUpq1RaV8BhhiFmIRUpnQVTUdtkk1cMUhAeKpIRQpK+MJC6NN+raRngfj/QL2bTz9XSWsQx4gpPk52YSN12QpXZqeRmhQNBN7veRHrwg0KLbNaVkP0/7d/t5NdxQ1YjDoGt03k7Bba5v8t1uyUTWzzf0ZNZErHKYzKHvWfScf9L61DfAdeHvEyTw156q83Buh8HhhaZ6pLd8/kyx3v/sEPWtt/rfNHWMM0Jt2HFC/KIlIY69U07xvSn3gA6/k3kzIug+xXHueauxfC+W+BrBfOn08Hu2eRZSzDMtyBbDThMIpJq02FhrHRi2aMIRgmu01/4QUUOTnCxC7bxbZa1d97qf/KnEuFVnDT4iXomhpafTepwwV4w+9eXIN4JEMTBtClz0TmV5YjG1TUkISmCJER7RsBkm6Z+XPLMruNQb5QziWQN+pvnVOoUTihsqpxb8KtDEubgEMSPGXN/G7Ntt8tc+miMtDpSYoxMTZnLPuu3cero1792/dA8jtp15TNSPOVrPz1VnZWbEeNSUGyJKA1lz+l0xfRls6f7t+3on71Le6MoXjCWQdH2TqMJwRvV4XOh6FdW7hpJUaLWEj8x48TdJv4OcZGjzY5bNSrrahkLl+jcN3CaMbUcGINjqBPLAQFG0SJPeDGHHRjbGjC5zKwRJG41OVlsGrkQO0BHl73MN+4T/DqWW8zMW8ij4yZyLeTPsVbNQ5v0U3IOj2r8sWCe1OPm8iMyTwNrxLwWXEaOuO1ZfNJSog9dhuqz8dzZ1/Iiikr6JHcgzNapLVfpa7TVJZZopq1gZBKm6QYBiX5iak7eMafv7frPQ63NbCrv4xXNnAyDbRBvaHtaBLD+/5k7ycUO4sF2L1cdBh2MXQnTufgrp8VkveXcbD2IOfNO4+t5Vtp9DfiCXp4a8dbbC2Pck95k+0UH9pGciOsbNuOYVP/ReawOpbdZuGNiyT6/BLVca5dtkM8jxyNnxwx5OfnM2GXhueDLwD4Jf93MMfi3n0Q38FTrm2XAK7fGUphyaYqEj4exfzDcxj83WBe2PICbn+IwiZxbUrAR7BZIuz8s3k1MZUfj/zIw11M1L37DoGCAkA40gAvX9yTlNgYArYMAvYcHMUro3i6U61F9i5ZUbGHO5Nx10L1UbCn09vn59y0oSSHO3lTWlI1pHaHJ6pg0wfwYjrMjGamzHoz3pCX/qn9mTlxJtn2KDVE9pHlbLjotwiFhLiRLRYKS4tmpoAbyvcgGY0M2u6hU6kWPnUJEtrxhBrX6pISq2oF/yrgi1FJ6dVIecfEiJ62Ov418W+4EceT74JuF4OznDy/lxEtqgbJjZA//XEOr0qg6KtDeIMejLIxIns4ZbnYVm0Uz8eTKByZjBbNtUpAJrW8lph33sfilegedlY1HVTEJOEKNUS23VW3BnP6bJD8XNw3io0OhZ/TrEOzWl2rP4zj3FEksKAVngre2P6GoIQ5ugyqDzEwufdpzWF/ZL6QDw2Ntc5dyArE+jXKMkwcGZdDQkcXvo4P0OaBJQz1DcGv+AmFm/dyqn1oqoQULg1b/BopSjonHBmU7U/CXqexqYvMT0MlnPH1mF97nKJBfvSaRtyQKAmxKuvYVCLmdmOLZoGh7ZK556wOdEoVUI0al5/nfj3I7O3FOCz/fWXfZkm/lo03/6R9feBr7l117/+Rff+Zndf2vD/Gdv8Ny7BlcH2T66835L/Y+dMkMeCCXh01XwsRa8c5YlFr2JCPb+MiiElGunsL2/tmcdehz4QYe48p6EbfjKLa4aaV5J73LfdcspTXjo7kvd29+Hb0e7QP85Sqqi3i/AUKCnCtXk2gSET5ed9/h6Otii4uln/CQlVi4ffs2IFz3k+Rz/Vt23JH7zv4cJKgY7lpqZhBvXv2UPPDEtKcKkkd3VhTAmiWdIIV1VTuDkfeLbqSjmtR3I8v+DdeiMpyTE31Eez74L1eusT3Zvpw0TXYFGji6wNf8/zm59E0DYtBx7n5G1nx+VxOVovBpWpqJOvwtyzgxCtZyG3cysuVa/nuyA+oqoJOVSIlTySJin4PcOzCXyM/a1n2RQkhESL2xM/oXNFGEHO4PH9s/0aCk8ZCZj8Ml0bpWPS9zuKoUYypQyGR8Vw5fgYbrtjApTEjSaiIZhwMIQmHEqLJ3wRfnSu42lK6sMRmpcFrQFagdN433F1dwbjk3vxe+HukRNwmtg2vjnqVAWkD8AUV2iTZGN0pmaCicnzLUgDOTuhJ98RuxBhbd4xqigoGI4omgaYjYJDwuxuZ8NM5BEP6CDbkNGu+9qnr8KQN4oC1d+SrfaWNeAMKXlV3WofyD+f/wJiwBNquNvD6WTJLJCcBPciKBvF52LWomxxviMEoGwk1hp3qQ9uxlZYw4qBGXcFRFFWhyFnE2pK1DP9hOLurd/Pl/i/ZXb07so9AcizdCjVkDQw52aSnZ+LI9tFo1/PyRx7kvYc5lAXPXiHTJBmoStJYaKnCrqgo9a0nNbPTCX2uxFn6x6WZyp/LaFqdQKC0gg/3CX42g2xgV1ED988TXXWpxYu5XFsNwP3myygNpZK1dz0LFgqSVV2smAOSwjioWpcfJB26QCNaM0asz1VnPgGDBc4WyjzIBmh+5iufhS/Phq2fYgCeHPsO2ZZTSlijHoGp3wos4T4xBxKXG/naorcgIWHSm+iT0gerwcpscxem19SK4OaU8UUL8uVItyDAjq/BWYYc7pTomS8cjKJVSQQtnfG1xBBLGkarjXcnyzw3VSbFFCSxixtviti30rsL1pGCjNaW4ic2zwNouJOmUDDlAvyrf6BHmjOyu45lGkM2N+DVqXi2b6f77kburujBm78mklanMeiohqVjFAsQnyOC0+RCIy4z+I0Sm4LZ9At4sRwt5LvYp8n8NYb2pRr3pCbzyYmP8LZoxCl0HcIQt4u7LylgSLsWhPBh569Z+73ZRmSJzPT5vcW2Df4GvjrwlXD+zn8TgHRj7N9uDLAarBhkA12yBUVWl3yJVZ1C/Dhah8mhsGJXKbklR9A7Q+idPjpPfpwR+1R6FYtFy+SOLtkd0tuy4xw/arl4R8+96jFmj9LhTw0Rm5vMB5kOQpJE7oRoJ/Ide+dzWzfx7I1ydD4x6kyM65rKQ+eIBpzKJh/7y0QWtKjuP4f4/J+2Eqdg//hPyu3/ib2+/XV+L/r7Agb/LSbZU8BV9dcb8l/s/Omz2tFx5nQ8Uj9CFZWg15Py8ONkDhNp/+LpH+I/KcqU/179b1YXrxakh+5akm65hbaLl0BmP8oefoSCW27GX1RIcM8+uuujXrUSMkYyQLWfiYVBDROQmjY+RObACsx5/1975x0eVZn24fs90zOZ9J5ACr0jvUiRJiIKytoQxb6uva1td13L+qlr11V37b27KzbsoCBdpPdOQkJ6nT7nfH+8Z0pIQhFU1HNfV66ZnDZn5p0553mf8ntaT7I/VDL/9lesHTrg27gRLRDg2z/Jbg1pM2eiCIW4xOiFyJSUhHvJEioee5xQ4VTSh8aR8M9FqHq/Ty0oZLuZvtGQzmv9bmWGuT8g8AZUDoiqsX3IePb20C9qFj/LKuYRQl6YH13+KA8se4C3Nr5FQA1gt5iYsnU+GfM/Z+2eej7c+iF9Xu7DwNcGHvzsy9fIJ+k7eUV8SU/NzLqqdahVm1G8dVR1OzeyWcUxV+FN602P5P50TuxFXkyVKqEQJtVD+zlXEh/zw7fpEg09d2qIdRvh+5cwiehNxtJlAAmJ8sZZr2t5pQsrCSveItnRPK/TEoSE+JzmIaBBl/BxdifekelrePZuoVEIQl//g1OKot6Yyz84g7KmMqY+8R2Xv7ac3dVuNpU1YFIEcfrr3vb5JXxb/A05zubfLcVTj8VbjlK/m/ZUIqhH9Xopd5dx6v/OpS204ycTfOwZMJmx1W4hzirfd7XNRVBVmb2mlPdXV0QkfsL0SO0RMf4a/A1YAhrWb/bStRi0ZSvh+YnEx+S8/qnHBSybsYy0IYnUxUFVZT0JpdIF0/+YEyLt58LVvk6LE4FoNkHI7dg3RneviDKzjVH57dm2LXqDn99DYU2BQjAgyKgUmEtDdEospEOD9HQ3he9Zdh/bHl5MzRc/YE5PZ2dRjLFjsaBpGo2bpHdbs8Rz3hchBm9QsZgsOKwmykihpONZJAUrGZq3jvv7n0n19ytIrRNc+77KMW/KKICwS8MmVff8PffddsyeckyBJhK365OUHqe2OT7Y9PO6ajkU6FpfjhTwRAuZ2PBRy4KR426JCsyGPfHHXhtZPbP7TFaeu5Kd9Tv5YOsHBNUg3V35nNbQBCYr7NsO0BWTNmCL8S7ofUKFkJODvUkxfvFjr+aCeJUHTlUIjbTQ6Tw7qTMuxWcVbOroIKv9KILpQzh3vjSa2p/3R8yZUSM2ob2HuHZ23CvW46m0IXpPwd6zD10uT8bdrzNxul22t0cx9p7dOOOjehKrfNiXrOXsGimBkVUY/W50GXIyiUM6ENeosbJQ8P5ggTppGn30MHbnD98nv0RgC2okqiHcvkrUGImjBLvM795aF5NvStT427dq/4TCE7hj2B2c0El2cUi0yomAJ+iBuDQahGBWyTdSDP0gsZqslPbIZFk3WJsvP+tVTVKOqvvulwBo8m/lVu8YAC4qLmT0xug1tvr2yWA2E1e9gy/CsV7AY2oi3q3ReYGVyldiUn+EwNZJGs0mNcSkIjn2ybZ0Tmx/Jv8c/AollRZum7WGmibpafTF3ENeWbTjoN/bz8WJRSdyUa+LmN51+oE3/j0Rnynlgw6Co9b4AzANOgvLhCvlP8EgwmrDnhR9Y8IsPULhH671uYnw9rmYZ1+CJUMmo3hqq1jYsJp5Nd/RsLeYNzdHfxSaxUl676iBAKA2yots6ce7qd7obDl7/pEIIejw8UdYcnKIO6Yfm5NlFVwoHHqNj76OOSc7ktsjNC+q4iJkTiV+tLxRa6qQKt8xIpC9e53FMX3vpVt2AtrBFOdn57Bw6iXsypYX6u983/PQqlu4ad5NDEs7jZUVK+mS3IUnxj6BIhTsFhM7E7IorC/DYlKa5bgctNbfiOuoMFlpUgTdrCnsbthNvepHoFHZ+48tNreb4vCF9qkqDoUiXTBCqsYKtYiQyYYjU8rgpDSC+vEc+PAqxEfXkNZTGnDmhbcxbdQ/6JPWi7P6XQEXfilvhp/cgKVWhiWzzpSixH0tmdzT6zLuH3V/dPyDXmoIUV4kv3MNmomhBe14PcFFO2Fh9qmzGeELsTPUxPh3x0Pceqqa/NS4A+yp81LT5EcV8ua+zmbDE/LRPiFaCQmg+N1YvHsxNZaRiJc6V4ia7HjQNJyhHrRJegaJtu1kL76LrCX3MF28yP3DzufRY06jwRskEFIJaiaEFpLacTGEi1YaA41MWaQx/Ru53jWgHkqW0cEfoI8evnM4UhBCkDLQyTe9BDaPIFgiK8SzO/WN5Pa59RZrNpMNu9neLI/L1X9A5PkiXyZBr4lqBTbmCmZPSsdrgWPXqoxZoWLeLr0dXedVk5fZh7IsO8kjO1GdAEs7CbSCbHybpNEhNDeZ7hjjNhDAs1xK0GSflEdQTaPft6Vc/pGKRbEQV1VG0e49rOzzd9JzCggl2vF17sndC55hRon8DNa1l+9H2OS4pTitDC5M4Y8jO4A+bfTH66HDqubGRDMKjoVTn40YWUBLQeg5/xf1zCW1h4R95JrO+R+c/kozXTGTYkIIwZxdc/jL/L8gEFFplVArv8l+58jvfXYfiEuLLo+TIcuCcdKQ79uxN86+8rpoyioAYEkXBduQdMw3rWDMgEvJcGQwMm8klnP/R+W6ROzzpUFRtm4Z3o2b4PxPacy8gKYyG+3O6Sq/dkLDkuSA5AIUzUOvV95h0JBTCQmoV3aTftmlxHs1ury/AoBKXzULx6ZG8roBKnOc3DrJTpPTxPKOgveOVbBkpxDcJFMREqulEXZ81ynY4/OpM5nplhNNr8jR5HbBfSZCEZHnfX4fTYEmxrYfS8+0ntw86GaG6b3RPUEPfPcINaZDkwHbUrOFpkATS9jOmydCvVPQOb6dDGOOuoksRe9WI/LInysnH9n5HcnvW8eOztIAHJTVg4YUO/Hzirn8w+j5vlj1DXcuTCNnlRXThuLI8rgBAyj68ENC1+vFNOHJjD2DsztdQV58IXWeAD/sruWGd1cCzUWej0KZP6wmK1f3u7pZz+wjyYDMAQfe6GjE2YrQfBsc1cYfyNY4AFm33w6A0ntyZJ3ikDeucNGBGWDnfALrFlHx5JNSp67Jg8cGxU5Qaht4bNfHANhmnoptzLmYBp7Z7PVUvWdi7Q/17P0hkYZNzROAfwyBvXspufFGmhYtIrBnD7bOnXl3nZSJ8K6RuUnmlBTix8iZXrsnniD9mmvke5z6EMWrerH7j5eSMuNsrIUFqCEBi/8D1dubvc6EHlnMvnoE2YnN2ya1SmU5wYZGvvTI8IPbGw0JrdyzG6ti5V9j/8XIvJGYFTNJcRZ2JGSR7a7CFvA0q/Z1B9oOC1S4K6IX2n7nEnKlYdWgi0saPuPjC7mlqgbF3/Jz9qs+djZuoTEQsy4YRNNbrdXZc5nq/wc1uWMo8jRwx7A7WhzDZNUwx1sw21TS/vsnXh1yF1lpXaHdQNmXEXDYZfh4z9qtpJ1ZRuaIIeQE/DLv6NYS2VLn9dOp9VbRY4t+U9WvjTZNg/oS8lx5TG2MGqoum4XqpugNuNrtxxOIenay4rK4rv91zc5VFLbDkRrAIkLEm00sGmDmiSsLSNB6k+Sb0uZnzIa1KJ99QPKmt0GTOn+buw5kSVZ3atx+/CGN3WTQmD1UtjOLIRxK/vfYJ3HZLDHL5U0lf/AVXBQvQ0Fb63dwx2d/Znuth297Kmyc4MG/pxQUBUtmZsT4awpKT41VsWIz2ZoZf2t6JzDvpfPxXDaKRquDtB2f4VBVGuME20/swweTUrA4XVw6W8XkkZ9f/N4mxr60nORdNZTmuGhXAW4b2Imeb6CyiRSt+Xeo4rHHUVwuXDmNlH4rj1XnlDd0cc2fuGXZq7jr68FdRUOdC2elfC9FWxv0bXUxcf1maVIEfz2xO33bJVGtexz8+veY2X9ue3xSiiAhG967GOr1Ptv7Gn+uLJj2DFy5HDqOg9R9dOPaD5H9RWNYX7We2xfczo76HVgVq5SoCLeeaot2A+GP30J27+iycP6ffpMvSMnH3v0cUBRE2VIs+t0/3i9/5/X+ejokdWBM+zGw+QssAdkScGknQejpV6n/6EPIH4rb047qzU7I7E6geA+WuBBi7Xuw5j1eN/mY8ckMnHtq2ZsEbnsctu4x5wSgqbgvOhNxxaKI9/XaxbfwvWcjb17ckQXdpMGWf9d91Jkd7MjtHNl1OhZcwka9AgOzj2FU9iQe2VtBe70yft/2gVM7TqVfRr8WQrxXf301E96dQIO/gbO7nU1PPfriCXhg10I8utF4fo/z9/+565R7pIdyRtezuaROfs82Ne4mqAYJ2BMw6VIyItBETfYyggU+nk1cy9JcE5s6yN/k6n/ezcZcea3xxTh3v21aSV6cjJK4xsoUqaC7ILpBg+7osMv7g6ZpfFn8PtcsOB2/Fk2puOK4jvTIiX4OR6PI80/NMxOeYdmMZb/0aRw63U6CW0oOvB2/IuMv7LFQsqM/cKEbf3ePuJu5p81B0W8+oVAclY//C+/GjWhNbjw2qHMKTCENe5380XuccZDZg4a45hdUYW0eetHajeBwCZSUUP/Bh5Q/8CAA5owMRnVO5/VbnyH3AZkcLSwWrAUFCLsdS3a2NEItFswZGYj4eNSmJjS/H2F3oCV3hfJ1Uv3/R2K68iJO+vYN0nTpkeLyaDl/sn8Sdw2/C0UofLXrKxof6kbaO6dSMFBenFeteKGZyPNxb41i8cJoHmOgpARNF6m95ItLuH7u9aCqsHcd/pBsc9Y1VdfqEyb6+vwUfXR6i3McmD5SHi/Gs6hefDkMl6GzPJfCxn9MJGnqfVC1leD6D3j1OIX4226EEbIBesppU+h022iEAtQXw6KnwNcIy1+BYinHYk8OYu+usaFW5aKcTHaveo3l39zBUyufYmWF/hk3lFGLYMKH8jtm1e1Zu6ZBnZxlW2KMnESHneomP/+nN0uvdQcQ/mhSuDfkbTFrNU0/hcxj6rEpIS41JXCNSOGFiS/QUbkwEobZWdXEq4t2UhNjWCpzvqDxo/WgqQg1gEuz8vTzl3HGtm+pdQcIhFQ+EqPYfuJbMu8shuG5w5l/5nyGpPXFQjS8VrNSenLUdoPoEZ/HZxUeUuwpJL/4Md4Xa6iJB39eEAIBbB2KEBYLTouT0XmjI6Exq6ml8Tdn1xxeXv8q/arfoLMoxqp6SVRVplizeHzs42wZVcQ3p0kP7Jr+cexNAnu5j+x5Ozjna5W9S2Rhx6g1GoVf7iRuSDSZ3VtjZs0p8O0pRRR+9CHZd95BzhWnYKpbR/qZ4/AcP4ziVEGmI4P4K2VbpMnvDIM171G11sSM+a/iTU4jb4v0xouQRqd532LOaDmbNuvtvLzhPuGZbRTjgPy+rXgdNs2OeuTi98nv27UQ0jpLXcCJ98LMD9s+ns5e917e2/wexQ3FOMLFX+ldoP1Q+MPzLXfYNheeGQs1O5sv1z2S1Zt1L7fJQtXr74OqIta9z8mNTaSFVLLL1sGz40m0JfL0hKeZXDQZXvsDlpAMWb49QsEfb0NtkkZiqKock1Vl210fUT97NtYkDSrWg2KmfsB5nPrEGtxffEVJuiBoT0RLS8F33tTIaZ34eR2X9L4EMrqR++ADvHJee0qapPGsdOtMSK9qb+qk8fehF1KTGfWkiyWPk1m5hnpFIS0wnpmdbmKs20NW2PgLtQyN5bnyWkiHNAQacAfdvLXxLTbXbI5EVXx+aUh59YrhQdmDOBjC1diF8XkMdTefNDd98TcUi8r2DIVibTPn9EtjzglBllPKd6VJNNnkazm2mbl/AgQV2JMKARO8P0RQmSjY1V96jFMmTETTTIRijD/T03r7P92QbgjU8fzGByj37CHc2EcRcHyPLHKTog6Efu1jPNa/E8zKfnKsj2Ys9miayQE46o0/c7oMT4SrcEX/6Tj7yQtueEZuUSykxqXJJsuAKVHeVENVVdDkxm2F0mSoyQqBBn8/24Ty7FtUP/8fGl57NPJa2ffeQ/qVVzR7fS3YPDzwYwhWyBtF8vTpWNq3J37USF66YBB3nXsswhpNFFY9bhImTcL9/fdUPfMslpxshMmEEheH6naz7ZRT8a1fj2uCbBTNPsbD6uI6pvxrPquL61o/kUAA8eVsaYg1NJCYkULvk4Yze8wQ1uR1jGxmFxlMKprEqopVXDPnGkq8FbBzPtkDZc7Q5o0fsKV2S2T741ZqxF16O6HGRjRNY8fZM6h57XX8IT9barfw9e6vwVcHTw3F62vApmmkD7mSj0/5mM72dJbZba1qpIV1/mKrfbXJp6D1lt5KV8k8bM+MxOypxEeId5u203T6eNJPPwvG/A2u+B5Oeap56H7z5zJ/6oMrYOMnkcXJffby+EkmxsxRKK5ysBgPT654khmfzKDirmRClZvoK6Tx5shPYnKOHtpUVagvgVAAS0zuY5LDQaMviFm/QXkCIfaKaGFCra+WBn/zlIOw1qEa9NPLL+i1BcrPOJdMtxRqBlnA8df311DZGJOEHwpJL40WQgn5sOv9ec/e+AWDC1MIhFQsppafL0gDLdGWyItrX2StK/pdDHn18LaAMbXz+TLOhsujMWq1Rt0I+fvL2G4i5bQTKPpQGiqpjlQeH/s4M3vM5MpjriTJlsTsabO5c1hUi6oh0BApIlHQUIJuEkMqdWny+7eldgsLGqTBnZCdSI2epubM9rK+u5OEhqgXIkm10/65Z+m8aCEJHUKofoU3XCb+070Ue8eOWPPzceUFQDGTeNWDdH/wCSa/t4CL+1xCYjeZT+avl5MeT9CK12SlJjHaUinRa8Kcno5oJbSXvEVOdvwJ+QTisiCnT4ttItTsgLD2Vji0m95N6vyFSSmC71+Eh7rK/L+DIByyr/ZWR56jmOCCT6HntJY7+BqgZBk8doyUjQmTkA0n3I83lI9iVUk+75LoOk0jXlVpNFshtVNzj6GOxSm/9xl1GiG7BbWpiYavv6ZpwSJMVi2SaRA3ahIkF0JyAY74TGxBjTX5gnP6lnBR2U7q/HU81CT1EBOnnEzqeTMjhRSusWPZ0zc7YjyNyBvB6MxBdDcn8HKXsWxKbk/vvvI7ZE2zYrKojHZ7uLmqhvs/XU11k5sXJr3MiqrpmBuHkB3fXDbp611f4w/5+fuw5jIb4UnuhuoNnPrBqayrWsfyc5YzI19Gm7xDLwfg0+2ftmpQ7ktYRWFF2RJ2Wprr5zUpAltCiNvON7GtvYXBG1RMWkemLlKZOMdEWoKfkElKf6XVg1mV+ZmX3xDPG6PkrfwG6/tUfPYU1pwchAgxqnsrt3jdwRFb7WsJa4wKwaa9DeQmO3jrEjmxykv+aUKrBr8sR5964z4IRSH3kUciCasitYikmZdiyvkCYd7n9J1p0FiGOTEeRA3B8grS/3wDy3bey8Y8wbqJZ1O19V2qEjQQgsCmH9DKNoBwACJiTMaiVbSdy7O+azfSLr+8hcG4L8Eqafw5jx1O0qmntLldw5df4hp9HG49Vyn/BVkBrDidqE1NKMiLYlJuORQD1jg0TcO9ZClxgwbiC4ZYWVxHjbv1HDyxcjmme+8gZLEivB5qzQ7MDSVcl/Ffgul/5RV9O5NuiNn1G5UnMQ8a6zAVKZxzvQmfNUSur47c+FziLfEU7l0HJoXdF12Mo09vgmVlBMvL2Va3Lfri+s2mh89BesiOQIoL31y7HktyIg+4W372n+x6U77/2GrfbZsJJSaxZcqH1G9fTr/tH+FeOQuLBuv91YxP7RE5b5LzYe86qNosNREDTZA/LJrsXhfNi7GiETAjpUQGKyS0i+bSlJnMpIf8XG7pCiwgaXhHdk+cAev/jaP9MClP89wEkrP6AtIz0Ss3hYtHpHLXR9JT5fWH2KzlEg90cuayuakkep46wXsfp7Qpkdqhbr4qt1AYUGm3bh39ZtbQL1smnAd0IzCoxoRiQiEwCdkgPuilSZNGptlqoXdeEqoGY4Pz6fz2jWw96X0gGtKp3PI5r5Yv5rnNb3O+5gViqhYLRuDUw5r3OxVenjUHaxDKJvTkyoXLyPnSie9sV4uLSJeULpG2Xc0oX0+DpxqXMxPYwRmDi8C/gvFuN//aM5/n1zzPv8b+i6r6vfDo9XRcWo9Z8+HGhiXdz99P9DH2B5U/fioP56vyUP7QQyROmYI53g4E6Fqs4U02U3r77ZhT00jpoGJSgxAKYjfbI595k15x76s380Xu5ZQENpBiqsfcrhBtz2a8KS667aqi4rHHSLvyyhZ6X8XH3kf8nu/QTDYs7jLp3WuL2Jl4eMydqXCG/ovbuVAafy/KDgwcpLBs+L3U+GpId+ynD2jktXUDUQs1r/y1OmHwJSg5S1FKfsCUnI5wOEg+80wwbcOlqni1IOrly1Ba0TMMG38j1mgE7RZCTY0UXyaNInuPnijxiZhz/KTd9hi8fgZs+pSC3cvZZRd0rlXRFPjHMZMYVb2evtvk9zr9uuuxZDb3uMa+xyHZQzipw0kAvL54F2ckO+gYKsLTPovE0Mcom3fQx+dnWYenMdtf5vmtH7Kudile5yQCu6fyz8tPbHbsrbVb+XTHp9x97N3NloeNNXejbH9mNVlleoNXTrC9egrKrK2zuH7A9SSb9u8lCxuvs3/4N6HMXEA6F65L7kfKjt3Q/zzOSE6iomQn5/9vMSDzXsvTLVzir2VHO8GOWgfD1svP6eohN2DfW0fNovmcebzMZ3Ta5fXt9qG3N8sr1rr3ArM5MtGO1fmL150QcVYT17+zkjMGtuPsQe255YSuzbyABr8djnrPH0DCxOOxdYhpoKypJE1rpbpu3B2Q1RuR1Q1TcjLBqipSZ8yg00h5kShqP4KEJo3RqzUIBAnVNUotKw1y/nkf/t27KfnzjWihEEKXBdH8rbdK0/ROGuECkf0RqqwCITCn7F8LKlRRiWflSkxJSc2Whz1/qs+LFlIJfftvucLioG7WLHbNnEn9Rx9ht8gLc1tSL1oX6bER66Sy/Td7vMzZLs9/Suc0JuScS4b/DBQ9lBH2JnjTOoIjGbfaiM8q113a51I+nfYpT094mvxyDX9WCp41a9BCKorLherzNpNNCOkX0ezgNL6z/Quscby+/nVWN27Gozko9bWUSuiaJL0pZl3zEU3DfMk5KB+9jye9D6V+OXM1b/0sYoAsLl0cTdpuLIenhsp2WOd/InOdJj8sPaZCgVoZruLatVi6nkRAv6+ZQyLaWxVYbbPypdVB5jbpkSorreC11d9yYtGJFEx6BL79J+xZTo/hf+bdk95lWqdpjCgq4uIRRTR4gwwtSiXNZUMLpJFe+QDvTZvN8nOWN2vtBqDWuqnOmcyezDE8lJjD6xa9mMLZwJmD5EW8Wq/Ge2vp7uiOuudPM9spG3QLD6mT8ZutNF14BTsqm+jbLomBuTZs9TtRYmU7/E00vXkWz21+W34vUoPMvqwz3wyTN48ds+Mpf+LNyOa2D+fyQ5HALHZxij6eu86/gIYvv4RQEE/xUka/NZqnVj7FnsY9aJrGS2tf4uW1L8us8SeH0FC5gQRbInQcz/mjukLAzR9r60nXFHbV76J/Zn8mdJqE4/hxiCwHaT0aSO3WQEqe9MBYY7TqGrdspvq559l+8hRq1+vhPBNk1ynUvvkWlU88gbpR79JSuoJQYyNbJ55A1XPPU/P66/I9K0DIhyPow2u20jTtbL64+Ti2OKVXtvKZZ1sVevUndaC6e0wFdu1+2kzF6nbFGl17VkD5BsgfCq7MaGa95eButuHf55XHXMljYw5C2DW2mlhpeekPBa0Ea5rw7S5DsdtRPW5oP4SLautZcOJ7rRp+XLcB8y1rWXtWPE9MVgjazGgeL86RMl3GlJqOJSuLQFkZlK2BYplHNXLRiwzcZSahUqAOvJa3q5bz3qb3cOunGI74xBIOyfZO643T4mR3w26aAk1MH9yekZ3TKUlrx/xuIxAuaYC5hWCD5kGx1GLVK37tmZ8wvLClcH84L/nmeTdT6alkc81m1Jcm06RXrnvK1wIyyvT8mud5abOU3hnx5X3c1E4a7b6DaKsZTvWw+hrxxXyXx9qycGhQ0vtmet20iKEL5XeuLll+5nXxAk0Ff5kVlxu+OgaKzziWwlNnUPfkf1CWr40cq0uynHhN6zyNgVnRHFDN4Yh0A4Lmk+ouWYlMH9Se0/rnYVYEm/c28vx3O+iWnUB+6s/X5cLg5+NXYfztS8Wjj1Hz9tstV3QaB5fOg2nPYk5LI7BnD96NG/nHMX9l0fRFdLz7bR5/08llH6ugqvirmmTxBFA36wOCe8tp/OorUBQ6PfcXEouaMKelE6ypibyEpmloqorqkTcjc/bBqJ9rWNq1a+mpbAXfpk0IvZq18dt5AMSPGEHa5ZejeX3Uf/QRO77SL4yWOBR9xmYtLMKmt+/yBduQejFb0FLTEMsWy/dstmN1SK+EU/g5r9sl/HfGTTx9jgyrhj0L3vJ1YLZR56tj8AaVq2aFqPHWEFADVDSV07UY4raVQTAow2Q2G5rXR0lDNPHUp/c2Vc02/Pr5/W+LrLy2EyCktfwqXtztJh4Z9jb2sBiyLn6rmUwkb3yLrFrpIW0c8TdEJxkKX1y2OBIuJqy9FZ8JOX1llaPFIWe+Vhd0HAvnzwZXNubTXyagD48pBMEGE3e+EqTnDpX3XfHEvZfM3jflrF2dv5te/13NtE7T5Mx6wIX6m2ygS0oXbh92OznOHIpr5XfktAF5xNvkwbdVBBFCtDD85PsLgtlCMKRKnT/9fKxeKzsq9SIKfYzrPNEQk9vto4Y43j9+IU05w1ll6cUdlz3FK4k9ufLNH3hveTH1+n2pmdbf1jkyZ1FnQYqTFxK34dWbuntWrqTuvf8CUlRWVNawpYMDtyKojosaRGpTE3x9F+Znx1HlreKZVc9w/HvHE9JCfFP8jdTL8tSwwWrhh0ANCQg5Jsn5UCiNhEbUaOgSuPtEL1Mm1TJlQBqOvo3YEkL8Z+SDXDb94cg2ojzaW1f167lYFgg5YtpW9dAFz5Pao8TF4S8uxv2D/N48OXwmyd099Jv7Br2rtuE1WUltn427MJMmRX6+iu0AeT9CsPmUz2Q1bls08/zFHO/pUfDk4JbllNaDu9k6zA7izHGkOlIpTCw88A4HMCpDVfLzDOzZQ6imhto33wKz7FnjakV8HZAh44QckrKk5l7ghovI/MtfcI2RmkhZf/sb3s2bCJaWEnz7SnDLKIgA4ofIfrim1GxS7CmUNJbw1kiFii/+jWjFOB2ZN5Jr+1/Liye8yJ7GPUz67ySGvD4kIrPy2doyrnzjB4JOaSSutVn51HsPiq0Sh6bi0Cd0q+wrmwv4zvk/gnr+9JrKNUydNZVTPzgVdfs8bqqW161wYYdFsbBgzwI+r9vA7isW8kG8kySf/G02M/7qiptFFsKc2ulU+qZ0R1WD+DzR+8p8dzFlNgfvzl1CftUuEovle6pNkMZak9nPJZ0HE/KaiPPDlJQOjB9VwOufXBg5xrG5x9IxqWML/dAwyvdLIhP/FuuEibMGteeUY/IwKYIdVU28v6IEt++nEVE2+OX5VRp//u3baZj9acsVTbJROt468l97lfSrr2b7lKk0LVwg+69arTjK5Y/Z1rUr/p2laHrhQdP8+QiTgup2E6quxrTsMXIG1VH8twfYPFSW96t+P8VXXEnVM89GjL+6WR/s91wb53+HtUMHOn7+2YHfmMkEZjOKTd68QrXy4uAcMoS0Sy6OeBs11SwNmZSiSE6iKd55QM+feOc1RFUl7N5F6E/XsCmpXSTE5G6s593vi6n3BEiKk6/vMOmeP28N9JtJpjOTAaYijl2n8dKcB7ln8T1c9sofmr2GOS0NxWZD83k5NnNo5Kbk1Y2/V+PfotwiDYpw2MFOgBWWlo3RzYqFDEeMFl5Yc85kJnvRHXSrkN8Bc0ZnOPud6H5hT6EekmHlG7Dtm+YHt7nkzTB/GCx5GvH5Xxnf8QT98C5G/eE1uhbDzC9VBn1rIrkJ0v4wjHajqqAoG2sQttdtlx6DQRcDsO39izj5rTEs3LOQ6iY/pz65AIDlu2rITrQztmsGPXISaJNggLjqVSRVfs8osQafRd5wlm2oZ+Kj0oMV1MO+pXWeSN7f/JHT+POgi/hy/V6cJfPJCezGpECirsz/6qKdrCuX31cRm5e0cTZxMT1gtwiFq98PcfynFc1OK7FRw2MTdPlhOX+991sWNe5kUsfopMeSlwfFSyPe14AawCRMkaRpX8jH++te5bTcbNIs8dxuaQ/rZsmNO47jsa7D8QiaGX9hlftyk5m4jB5w9nsMaz+GgmNGcsd1Ks+PV9D6dGrxEVYmgM2VFPlfjP0LXL8R4jMQioI5ORnvGuklaUxMZaVrFFUb4qlNSeTF7pNIcdqwmWzs1Q8hDmT8Ad7UbuBIansDs00W2gy/pvX+v5Flh+b5a+dqx+KzFxMIBZr3oW4Lx/5DkmFvoGK3kfv4YxS88zZ0OQGuWiHlZ9qidhf99m7hCY+NvsOm4F68CJ8uveJdt568xx4j89ZbMbXvDrYEOEl6KXOuOIXOp5Qi4tNIc6TJxvZC4GhDvmNQ9iAu6HkBFsXSahcElz7Bqhl0Hfe6biUhFJ0EW9QQjhgje03lmuiO39xHcJPM//WH/EwskCLVASE4u66WR1OGMtkttSotioU0RxpVnioum3cTf0tP5d7KhfK96nqWgVCApkd6wsOtyzNZQwECAnwx34V76lexuvNxbCyRqTLmGhlm7mqVv9t+AS97FJk6Ezz1OM494d+wYx6v1ES1TldVrKJPetu5p6H/e4jQNTc3W3ZWx8u4qe+D7K0LcOO7K1m7pw6zIvDp9xBTG7nCBr9+fpXGX5vs+QHenA7vnIfJ5ULzyB+LySUvFI6+fSObusaPI378OPLfejeyzJSshwuWL2fnpzYaS204hw9B0RX+FasVoQgqn3oKVS+b961f30IYNJbdF13EnutviLSI2h9dli6hy5LFuCZOJOe+e0m9UM7qVI8Hf3ExKefMwJKbixpSILEdmG3S6wK4v1+O02amf35yxHjbF6GHqIUaQhszgR2ONBTdK+FzN/DSwh3c8eFa/rtczliz47N5cfi9DPZ4weZictFkzjtHdj3ouUNDIIj3QklMNPvOTY+xdXg+qtuN+bizuCzxZJJtyQQSsuDkx/GLYKRReFgUWNHgO8vQA34+kTZmZhOayYbP5GRBqDsWe/MbQSRMF05o3rMcfmjetolz34cOY2D9hzIZf+G/uDN7HMJhJjGukIoLbwQgvwJOXKZLXfTpQny2D5MzEWtA465Fd0mlf0cKuLJREWz3VnDJF5fgVqMq668u2sW60nrsFtN+u6+IYBBbw1acDVtJp4EGB6xrB2ZnEv6giqZpTOufR6LDwqJt1Qz4x5dyx/QMuibuZuaeO8n/4iJO8n+CSRE4rXIycMHwQgZ2kMZaM6Hnku+J90aLg/oHzQzXc4nSe0VlU3qWS0+g4nCgOJ18ECiPVFoCWNKTIb0LArDqHs1wor7dJHX+Ptkt2+9V+xuwFS8Df4NsnddUhVkvlBFCyFZjtycSXyZzJV2ahsmZJr36envH//NaEV09ZI5qWYk/rXAUD016MrrAZJYyKuF/U1MJlkmvSq63BusLWwh5TeR2KuSVe8+hb7skLCYLr40xsap/yoE9fwfLma81E2VvlVxdW+wQtLoAnl39LO9vef/AG6Z2gJE3Qr/WezynXnwRIFUUEsaPx9Grl+wEklLYUjA6Fl8DKarKSGc7LGu3UnbHnQTKpPESrKjAmpdHyrnnIPKHgq8+4v1TrBZM570BBSNItaeSbE/m8TGP0ymppVEPspXXBZ9dwKVfXtrM+Au3+nLZ5TnWugP8u6In//RF36dNDRIXk8oRUAOyAGaTbLsZp1/D/aqfYzLkRHStzcpmi4URjY1Mqa/nro5nkufKI9WeSrW7gnNC0kiv073pfr2S++IvLmZIQTsZXVBDzTy7j3z/CEvqNhNARIy/XL06vqnP6dSZ5WQ8vkFO0lxO+Zhb6MfrqcJv1Ui3pTL947O4V6vEIUxcermJu24p4JHjHuGsrme1OUzaoGFok6c2W3ZS/nT6pA7GH1JZX9bAPz/diNmkRKJHptYmKwa/CX6Vxl/6ddeRevHFLVek6KGPnQtonDefkj/LG7jilAaOo290VpR06qnk/OMfzS7uts5SRsa7bh3ujaXs/iaVpu8WyepYoGnRIjwrV6F5vTKHRSdUW9vmuVrayX6btXr4bH8ocXEocXEIRSFxyhSERV7MGr7+mq3jxpN46qm4xo1FC4RkRWAoiOqWM0PPih9IcVp570/DGN89KldQ+cwzlNx4I1srGpm7XM4q1ennwZ5ifD4fFqudjad9S0kn2Z7qy/XlfLRKJhk7zA76x+eTrKow6zJwV2PrJC/Ml3+s0knLYFu24No/mgnoBt1qeyW7TxuKEi8vzp1LNL4981sy03ugHXMOKkFO7i29CBbFghUz11fX4ozpv9kmYePPZEY129nu7Ms5ob9hTZI39/N7nI/dFJNTFdtyybqPNyGtE6x7H76+OyJ4u65+O5Y575Ny+Z2o9S11B20WGcY2m0VE6sVhdkgP42kvRvTQgBbtntbtqefj1aVsrWiiLbQBA3CkBEi2CRItCqWpgttnmPF37ouqySKPBLuFgQXNPTiZa5cxevdyhrjnYgq68WJFEYJx3TP564ndmNw7m4Azi/r241DDXiVNg6AHAaSEQpzc0MgTe6K6kbHzmbGefEaVJLD33vtQvV7suoFnTpc3O/NH54A9CRQzFv19h9+/zSw9f2VeGVJUheBdvYsM/kZ4/0/Ela2NfpaVMk80vnw9AImhoMwT2xCtzC6a8jT30o5QTTSEbU600vmUUk7tNRJ7fNserkjerdlMbUYeJt1z3rR4BamlO+S56x5pU0CN6MsdNuXrYU7zYgIumQtnRXMqmXiP1PmLS+Vg0DSNG7+9kW1125p5TffLmL/Aya3nB4ajGa0Vvu2XcB5j7zMov0/2+naNH0/HOV+TdFpMZKCdLsvzlV79/eZ0WSgTn0GaIw2H2cHodqNJCvc/3ocKTwVLy5byXcl3zd5vWA3gmPZJKAKWzfkfr1j+jxQt6uXurSRyUW30Nx1QA7DwCZ7++EJuzcjgj45CzutxHoFQgG+KZZTglQQXp+Zl82WgglqTwlQlmWR7MqmOVDyqn8ItcyPHe/ekd+mYLIsSv98re1LT4Ti4MwUW/zuy3ebazaRZ4nmkvJJ/DpWVxSV+OQFzB9w0Kg4CJqgqsFE/qZ5vOpn4blSQT/Id+IXA6hfUvPEuVd5qTN464oSZ6gSBP9nJwKyBrRda7YfXNj/B+XPGYVbCItcaVxzXkTFd5QQkvNzgt8dhGX9CiBQhxBdCiM36Y6tXXSFESAixQv/bf5z0IEi75GIyrr+u5YpEvbF5Uj6+LVsiM3wlXs6m7D2ibnjF6URTVUrviAoD24qKsHXvBqHmOXNqQwOq3497ydJIj16A3EelTEwwxhDcF8XpxFpQQMrMtttzHQhFl+4IlJSAYkJV9WETCgknSdFr1dd6snHFgw9R/8GH7K52Y/O5KUvNRUtNw3z1JVw3KIvRXTPxJxZgiYtWgJr0H3xIDfHhzi/YqBe/XPbN9dw072aauknjreubSyL7bOuaiDcvjbIUwWPLHsGqV2ffb9K9U02VBHcvRkPDarLywnfbKa0N0sGRRqdAgNtsrx/4g7DZCP35r2j9B6Ga7BQlmdj6f5Mi5xtQAxEvgPzgFJiie4H2zYPZ8In0+tkTocdUAGaufYKps6bSUFba8rXtIZQ4adCaA7UR4y+iBRXwYInprGJWzEzqFfU4Fdfs06mkFbSrriW5o5t4i8ofQgpP2Lvw/YzvcVjka/iCKku2V7NqHymfnAWf02FTNL+oMCuV0/q3w2Y2MbgwFSEEnoxj2DnhefwJBXIjIeDqlVB0HJ/vLuHuympsMdf5yjUyPJ36x0uYeOJV/MU6lerXXkNYrbw++S1O73gKSdlenNleRPkaGHEdnPEqE3NHS6NeN6DiNQWT30296qezTxprP+gC0oT8EHCToxtgI/NGQoUMF8br1czxZif0nQ7v/yl6cvlDKds9jLqPP6HoEynaLkwCk01DWMwozjgK3nmHok+iBmMY5/BhpFxwAV1/WE5DTn6zdXUfSYmVs7qdxWkbk0mqC1D43rstjvGj+P4FOdmIJecYGVaNnFya9M61ku/WGkIIvtwpf18HZfx56+CJIbCiZcEDQKBYTm4OJje5GeEJRcATCWHHjzgWS3Z2c89puDtJ//OiXtAvboOgn38c+w9uG3obC/YsaDOSkuqIGsWxRTgmvRAlP9XJpF7Z/LBxOyNMa7jP9BJC0xgbN5oTzDnkaGYKNBsn+hWZrrH9Wx5PSeJDpx0KR5Ibn0vHpI7M3j4bgCUOO2ZN40m7yj2pyayo2Yg/5CfdkU6yYmdJjJHcJaVLizEIrddvdaujKSmN/kYKbWlkhEIMTG+e6uKe9wCW+HjW5Av2ZAa5qE8KjxS6eHSYnbuyHTTq34uq9vJaZgv6cOgpLj9Wk+7jXW/gU72Ra6gQMKQolQK9yMNkGH+/WQ7X83cz8JWmaZ2Ar/T/W8OjaVpf/e/kNrY5fMxWmXh97vsRDxWASW+dptjtJJ1xBmmXXYYSH8/mkaOofSM681YSEij673+JP250i0OHamoiM2MA/46dWHKkVlRgz542TyluwAASp52KOa1l9drBosTJH+Luiy8huHcv6Sf2lA3lFQVLRgb27t0jbeImPvItz87b1upxnAEvVZqFpV/Jgo9BvfLpmBFPyrpXyNk7J7Jd2NUvhODWDc/zdZy8qO1pKiWgBrjvVFidL7AtXMW0+SrXvxfi/Y41vNxT9ir9y1sqFf+U4tW7guVc/fXVbF3zJk2PTGbmFyG++moLd3y4jjU/TOGSrJEstduwWfcTVgpjtaEdPxnyC9FMNpK2fwSP9pGhQmBb3bYWIq30OQsQLTQRKV0hHys3yZvRtTLMOPPLEDWPSYPRniqNlVWj/HSZXA6dZS5QxumTqLladoaJXHRfmYo55p5lMVmaVcmF2yXNunx4m28vrPMX8PnI84UYEkxg94lTyF0ob/C+QIh5a3YzcM03/OfsY/jribrAcDCIKqI/5Z31Kh3SD7JCz+okiOC+lCRW2Jp7K51ZXjKuvRbXqFGoe8qwZGUhFIVOyZ3425DbSB+eRvtR1dDrNGgogzfO5Pbk/jzV+xqu7HQGAH/duIgPNvxAnerj2Lg8bvFZuEXRxyjog4CbxKy+ANT56qBiAwDDA4IUTTDClCDHd58iCCUuDrWxCWthIV2+X0bRe29JdfsuJyCEwNGrJ7ailkUQqRdeSOaNf0ZYLFw5oRt0jBEG1ounEqwJdA6lkbuz6dANobao2XFkjrMP4U4VLb73raGYpcjyrMtaXZ1yzgzynnoSa35+q+vbRjcQFjxG7oMPkPv4Y61f74SAv9fCSY/CVH1S1rAH0FCEwivrXuHOhXe2Wl0NRHL9ZnaX4dyx7ceSZEtqJllyz6m9+L8zZY62AtxdUUVmsY/y/tcTf8YK7jv2HbK6XkKP1B5gttNRz6N+MbsDqypW8fBxsqDosr6XcWxCB7JUgcORwnK7nXMqvqbaW81JHU7i23bT2BBzzXpt/Wv8Y9E/qPXWMqH9OC6urSNSInPig5Ht3EE3PzTu4g1XPJ+VL+G5AX/hv8WlmDWNJiHompfMPWeYCCYGGbJexR1TETwiqLDtb51YfoN8fxZhilQPu2wtcyAPhajxJ9hQVk/P3ERmXT48kqJj8NvjcI2/KcBL+vOXgKmHebzDp8MYSMjB3qM7ANYOHTAlRr1a2XfcTvpVV8rkbz0EpLhcKE5nZJZaN2tWi8MqDgeqx40pJYWEk0/Cv3MnJTfcAMik5rbI+utfSGstRH0IhD1/AM5jjyWtYDciJJOL3UuX4l23LhJ63lDWwD8+Xs/60pZhy8/zB/JJwVCGrJNVxCv2uql1+0lb8zSZu6NekvCFQBEKNpMNj15JWxdoINGWyB9H/hlr397Q2ETPchtZNRrfd1L48hj5dfLHXC+Kdvr5evfXVHirCDaYOHGZRn2xDZtZ4aLhnXlgz3e8luCiJLR/GRx5YB+sXQW1Newc/wzLs06XN1U97BNQAy3aM7FrAaC1DPuOuF7mWOkireE+yf22aIS2bANFkNGnHsVu5SRzPYpZi3g4HB3bU9FFhkUiWn3xmdhj+oKaMDHIsycSP3X7pfFnMbX9k1Om/4HydcmU1Pl4symTK9Td+HfsoIM5wN2n9MRhNVH02btc8cO7DC1eyUUjZAuwJJuJ+Jg8z41VQb5aX97s2I6KlXR9rT/OPTI5nTX/hTfPBk3j1UQXryYmsPnkB5vtkzpCTm48q9dQ/8knWHJiim9MZjhP/84UHBv1bgSaGPy/Kzlllky5oLEcv4BsRzqZlnimNwVInfKUXBfyg99NpllOziyKBSplz+g+7ga+aXJw5dblMicz7NXXsXXrilpfz65zZ8rfbnYXOOPVg6qULf3bbdS+/z4DClLo9tFn/H2mnKiYXNLbubF6I06X9DJVv/RSm8c5muiRup/ez2HC39V9+teGUeLicB133KG/uCsLhl4BZ76BJTeXhPHj29421rDL0T1fZhtrK9fy2Y7PSLbtvyhlwVkLuGGgvO4+ctwjzDtzXjO9TJfdwprK6PtbFrqSt5IX8t7mp0AxEbKnMLZwBi9MfAF89ZxdL1MQ5u/5jmV7l1HlkekJXZO7ssVsIitnAJZQNE82ElkIuPGYohe6e5fcy1sb3+KBZQ/w4HEPc9WJMR1WkqLGdKO/kSAqT+YUcMOy+1gdaqCTqvBi6V6ma06uH9eHi7ufS+/d+Uyfq+KLaUP319JiTtz8DXF2+T11d5/C3af+l8XTF/PvcdHQ8o8hfF1KcVp57KvNvLV0F4oQbRriBr9+Dtf4y9Q0LRwjKwPamn7ahRDLhBCLhBBT2zqYEOISfbtlFRUVbW12UJiTk7Hk5GDv0rlZF41m2+gyLakXXkCX75ehOOWNI/PGG8m44frIdklnnIEpIQHN40FxOMj95z+x9+xBYOcu2r/4AmlXXN7suKGGBsoffRT3Dz8c1nsIEz4vkJV4wd0bqd7kRAuFqH1XhqXUxua5ZBaTiBRugLRB5rTrz9ft+1On3yD/NmsNq4rrUM1xpGybxeIub5CTYIvo/IE0brx2FxpQG2gi0ZbIuPxxjOg2ETSNvp50SI+GY7okd8FvgUC2XNalQs6OfQEP6N0UckrN+IIqHtsySnwloAkWVhyE56+yEvPVlyCWLCDgaseucD9iPRl9Z91Olpcvb77PO+dDwQg4Zp+wu9kGF38FI29otjgs95I05SSck2bQeeE3ONL03LIqKfjt+34ue2a/T5ojDSXscSs6joSEdjw74VnO6X4O/q+/JeuWy5nXz8cL5w+kT14SAOe9sISQ2npYi7paKnpdxve5M7jLPoiFoVJUAakWlbMH5xNnNaN49SrznSWsKalD1TQsqDjsNoL2VHaMfhxP4UQs5n1+2pqGxVOBEu7JXLwUtn4NztRI+MpiTaBo9ifkPibTGULH3o6maey5URpyyWdPb37MuFSY8gR4amGTrGY/bfNLzMjOZHcvqcP5VUF//pqZxUdlNUzfsw36nStD7d2nQEIuBNwUbPqC73eX0ze+vWxPBnhQ2eqvxR2++SQXNHvpxJOkdqd76dLWP8s2qPvwI2rfeYem+d8BMHt1KVvK5ERJ0T3cm2o2MbdcVmrXf3oQVfoHw6XfwUVfHZljxZCfkM+AzAH0y+x34I3DOn29TjuyJyEEHH83ZHQ9tP3O+xiukVW3JY0y5Nxi8rYfShpLmmmJgsyDvPWTHZH/TYFlhAQIPTwav3su6Sv+JVf6GhCuPPKEncZd8yltKuXMj6VHP7G2hC21W0hGwVwZ7WZkUSzUemu5pmoRi+1WhpqT+SQ5Wnh0Rvog1lSu4ZINz7M93MFjw0cQ8MKCx+lqlh66Rr0fus3sgIxu9PH5STc5WLzFS9aN3xG/eBuN+6RehgtE0hzSq5plduKyulq0ifwxJNjNTO6dzTmD8zEpgoXbqvjXnC1tX6sMfvUc0PgTQnwphFjTyl+zTvOaTNRo65uSr2naAGA68IgQokNrG2ma9rSmaQM0TRuQnn4QivUHwNa1K/7itpscm/XX2LefrxIXR+pFF5Fy4QUA+HfuJFhZier2RG4Qqh5mtXXo0HJ2pKpUPfVv3IsWsWn4sVQ+/cxhvQ9zRjqWfBmesvfqhbvnP9i7PJGmhYtQ3W6shYWkX3UVZXf/X/QUNHjw8+iF0VFZRlFtCXEBLxePu5Gvbn1CLreaUHUdvcydHzLn8p48cFq0hZNNE3gr1uPuPJGgFiLJlgSAKVE+BnbtoqCDnMGPzx/PCxNfwG+GYMCH1wLJAWl4e4Nugj75dUvWZV/eXSsTq82okaKa/aJGCz5cOz9nVP1HhFAiN7Vw0/RmWOzSyHAeXBK93wz2fseQfc99MPlhhCMp6qzIlfqH9cVOznx5F4Pt3aI7OpKhqYrB2YO5ceCN2NvJ8XLZTPT4+DV6vvsfeY4NvtYrflUVoapoZrPevcMEQhA0C7yNTawpqcPtD+KxS8N9aY3K5Mfn4w+q+LwBtgYS6O1+knWp45kx8VhGdW7++9F0AzlS7euuAmc6TLyPuI7Ss2s2mbEVFkbCfiVXX40QgvYvvkDh//5LQritYJg3zoRv/glf/l0KagPBkJ+Vdhs3B3YCsNtfw6cOK00126HXH2DUn2HB45DaEYpGyVzBrpOxBr0yDDz2NrhmDT9MeYipKVauy9PDsinNQ7iK3U77558j78knORTUJr3iXQ9xf7hqD0l6d46w99xisuA7iLnIIZHVE/IGHOGDQpYzi/YJ7Vt0i2mTW4ph6uF5iY4YVickSY9u73R5zbmw14X726MZE9+byLQPpjXLERRCUBWKTpZXZ8piIrOejxdfMo9Fm55h6vtTcfsaeMoeYoCrgFx/865I2Zrg8bIKrlvzDRZdwgWk8SeE4CufXhQX8OKIMQ6Dsy7jrI/PYmHVaipNJt52xXP22id54KNzGbbh3zxcMI2z88YS1EWnbWYbJLVjgcPOp+YA736/k7wmKeBeH9f8vjKpXQ5vpuWQmyajWkWrZ8Hylw/689ofZpPCH0d2oF9+MmZFQdWkbqKR8vfb5YDGn6Zp4zRN69nK3yxgrxAiG0B/bOXuC5qmleiP24C5QEtRt5+A9KuuJPX889pcb9Ebtqsed6vrM//8ZwDcixZR99FH5D76CAXvvMPee+5l7z33yn29Xkquu46mBQsi+9V9LJPQmxYtlsKpMWGDH4MpPh5rXjusRUVY27Uj/vSLMSUmUvPqq6hNboTFQsnVV1Pzyit888d+rPz7BBp9QUpqPaxK78isomNJvOgMnpj7MKdt/poGq5Nip5w9xllNqDGJyvNXbcFmjgq6OtQQ3qrNqKc+zdSOU+mYJAs5TEmJCD0cndquExf3upiReSNxWV20T+uIo7IRewA6W2Q41RfwUKd7yYRtL1aTApqcGStAsXoQxlmk2tdE0pb3SVarCcY0Fzuh4ISWuU/eOlj1JlS3ngcZy5DsISzrpOBd/gOeVVH9LHKOgY7jZcL67XUknHUJigbZs2M8uzvmoQaaGPXmCP698t+YU+X78Xt8VD39NK5PZ3HnFBmaa9X404seEnd/QZe9H3OZIosPAlaFveV1TH58PlvKG1nfbzQPjL+c2iFSvDgY0vhw6mXc2uN0zP46rBs/wOze2+LwWrh3Z1jkOeCWeZDWOOL16t1wZxTFp3vdFXlTtWRmYu/WjRZsmwO10siTuVtg1b/rlsYKqC8lq4+sIp+cm8FmswLuatgxP9Lpgf7nQdfJ+mfgkS7qpHYomfIGFwhXvh5zTouXdw4bhmvMoYUpwxX98cNl7mXHDBfbEnPYNeMykmfIc7UpNmr0+qBDrnz9mXl2wrPcMeyOA28YxuaKSOYcTWQ5s1g9c3WzjhQHy76T76Azk9sD57LCMQSrbhia9e+4ZrLRSIitdVvx/+E5PGYrDkscoZhjvDD4DjIwM9rjIa+xgmuqaxltlykPFmHGGdN+z6GY5cRF57246KyhQVFY4LCzSm3ipfr1NJgUtN6nY6mPFpTZTDZIyOUdVzz/tobYWLOOGofeCtMGXzj6sGDHbl5Dvr5QzPTIG86sKbPoV128/84yB8Gf+9zPpd3/0mxZOO3HpBhh398yh3sV+ACYCdyrP7ZIltMrgN2apvmEEGnAcOCfh/m6B4W9a1fsXdsORbjGjwehkDx9eqvrVY+HzkuXsGngIELVNQhFQdjtKAnR5FpTUhL1n8zG1rUbjd99h7BYIrmDgRK9es5x+L0RUy+6kJCu06dYraRccAEVD+vdDmJ+oKm7NhFfmE1OonzNm4ZfitPvYcq2+QCkJ8m7Wo1b5pLEWU2oMWGDf32yjK69+kf6OT6W2I+44lm4bAnc1XmGbO4OuI47jk5zvqbk2mupynZSmJgR6bU58rRrKZ4jk8pTQnZy43Oxth+CWtAE638gxeXgxQsGcv4saeAowPeBfBoW72TG4P0km0dEnk2oinwfi21DGamv/ueoVr5WYR27qq2yf+p+eGLsEzQNqKRs2FjcS5fi6K17QDN7NJONsXXowMoCQfdVtQBoqgpnvIWycy7Vq+7jiRVPMKNQGi/uvdH0hXAHFm9rHVj092av20hGQx711AIutnRPpEN+AeyV1b5/PnsE3tOHMXuNrDAPhFQa4xJJdGziXesdpK2pZ0fOCzS0b24Eh4tJIp4/v1vmQW77hvi170OCK9J31JruwuwI4cw6cLuqZtiTsMSlQJMbW8ADZavJTZbfl2qTidCWr2DuA1IwuHYXfPeoLKLRQ2Bs/xb+Mwqm/Iv4Wpn7lx/uNRyj1Xc4xPXrR8dv5mLJlJ9Pp4x4EIL2F86MFIZZTVZWFSnUxUNS0f6/Mwa/HMm2ZGp8NS2Wf339KBp9w3lu7kYa9l4IBCIddVSzHas+yQmmd8IT8vFG1XJwRq+Bqe9djCkQnbD39Pu5VqRyUuMezMVLEQ2lxAkTE+Lac0PQib1hK+jBo1muqKpAY0IOxUrzdJzxb44kGIwWDtpMNuh3LsmihnmVy3Gmf0hQn3vnCDcZ9mTQNNLNTgiC1V1FnCWOIsUhJ0rm5lGrQ+WYtJb6qmZT1Pgz+O1yuDl/9wLjhRCbgXH6/wghBgghntW36QYsE0KsBOYA92qatu4wX/eIYO/WjfQrr8Cc3HqS8ZYJEyi//wHMWVkESkqofOopat55J+LVsXXqhMnlwpSURMNXX1L93PNU/fs/NHwtK2cDxTLnTrEfvvHnHDq0WSJ1yvnnRQpZnCOOpeDNN8BkiuQZprvkRWF4ySqemvNAZL9OIWkM1bqlB8hhMVM8MpronyiasMfkixWFNLLMTnx3JqE9MUj2sdUxJSbS/vnn+bxDE7fOvzXiOXKNOQ73AGl0i6DKp9M+ZWKfC/FdfRUA47tkUZjmRNPkVe6qmlpSRD1vLd2Nuh/B7FjPn2qJwy3ieCn7bwf3AR5EXsyG6g1s8u2my6qVpFxwQXTFlCdkT+AY1Kw0nPqE371oEbuuuoX68gzO/VKeo2eFbBclvB6Wp0sD6Kb3ZGulVj1/QkGdeBLWFEFGnIJTvwF8dU53tKmnA+ALqJh3bqNiQF8KX5Z5S4GQSoclXzKgZD1pItxCr6W3KmR1UdthCv54vWjDlQUpHaBsNYM9XlwqDMoaJNcpFtSgQLEcRCg+lp6nYomXRppV06BqM7nb5kVWJybroVs9zIqvAZ4YBMv1oory9VIE2NdAz8/v4uG9Fdy4SVamE+NdOVzChh9Ap0x5s95cHu3RHdFo1DSE/QiJPBsccd49+V2enfBsi+VJcVbyPjyLCY2z2BSQ16H8ePkb1Ey2iB6nZ/mLkWrp4xub+HNH+TvbZrHIjiw6a6xWSpNymVC9F7HqTXjvQuIDPmgoJTE+G0tjObMzJlDgD8SeBjWDL2brPhX0e/21nGnO4PM9VbxywivyN5fZg+S0rvhCPqqDWwiYQXOGWDPAxM3uTTyVlMCTmlRSsIZbST6kOzUONtx/CJw3rIBuWS5D4+83zmF5/jRNqwLGtrJ8GXCR/nwB0OtwXucXIxCk9u23seTk0Dh/Pp5Vq3D06onreCn5kXO/NIQseXl4V65CiZdeBO/q5v0Tw3mCRxLFasXRvz8IQdatt2DJzSXjumux95IfdXjW9telzXNCXi8YwU3ju5LhsnF8jyySnRZUxUTAkY7FU8Fpprmk1k+CeBmZ/7ZhO02uBFZ1Gczs8mXMmfcQot9MQiKe0j+dQdLEsWxVPgTg611fMy5/HKrPR8OOLexoB2nDd1KkhqBiA4Hq9XjiwG6xkeq0gWrGhEJGMMQfrAv5ytsff1CNtKlrQVYOodv+D61zN9QdS3BoHp6beYA8qsF/gsVPHVQV6NmfSO2x1TNb738Zy9juJ1GzXHYN8e3YgXvZMiy5uUz8XuONURohvQOM67TT+EdFEVkJNjqWFtPepuGfMpGyt96lyR7PV+v3kua00SnThXrDX4h7fRYhCwzz+XkhZTg9xjzMplLpgfOHQix9+R3SAHtlGSRAIKTRY/FnJFqcoDupNFMrxp8jjd3HPR5dEJbaWPoc49wextUJSJKpuJoKakDBU9l6oVQLFDMMuwo6jmV0yVyW7V2GXSjQUEbyjnkRr0hiRg/gvxDuaerTxZ7Tu8p8Sm89ICCzJwDj3B7ZN7lwxEH3uz1UCtPkcb/ZWMHJfaRh3DejL8fUJRNKcLfMczQ4asiIyyAjro1uKNvmMpS5aAnTsQg7nZPkdVEz2TDrxl/9N/dBrpysNCa3Y4Izn+XxRfTftQcm3isr2Hcv4ZVEF5+Ufspz7XszaNtcAAoDQd53eDnZlczArN7kKXayTHZ2EMIVUskIBakJeYlN+GknbOzWfKT6msgWFrIz+soVvgaSv30IUqUTYkOeoLvLxw05LgK+PXRwxrE1JKuQrYV6nMPihEBTtIvREaRrVgJdsxOoaPQfeGODXy2/yg4fPxeqngRsLchHrasjsHs3wuHAnCplSYJ6I3RLbi7W/HyKPpiF81iZS2Tr1ImOc+eQOGXKj9DNOjjaPfkE7Z74F5ZcmVeXeuGFOAcNiqwf0D6p2fZ3DzyHb0JJLN9ZQ+dMFwMLUrCZTcTvWUB9wQns6HAOJ5qWwNOjI/u849vD83aNHfY4MhLzESEfVG1GuCtoWLad3f94Fne99HCGk85rXn2NzEp52TPv+YFLZ5/Hi3Nuwvfcg3zTS2CdfgpWs8Lk/HM5zzma5XYb7VL0NnOthUTDuBLQRo6BtHRCFicCDf51AONPL9JoIfJ8mKRfcTmdl0qR62BpGVgsxI8dg1mFgr2g1tdhyc3FYjYzcedizE0NPD73Ef782aNQXcXbL37CjGcXU3r/g7zwVLT7i6ZY8Po8JAcC9LdlUHXtjVhvvwmQnr+tJdID4PI38dDpfUiKsyDUEP4YrbPWPH9tEvaIxqQOCJudzP615A5rGVJrlQs/h2FXwme3MvOL+3nB0Y3T/Qp4axEBDxfW1mHWwJGia2+G++CGQ/I5/aRn1eKAuJTmHS4ScqDHKQf/fg4Rm9nEgpvHcPcpPSPLLIqF7sndSClt2m/3HoOjnzO7ncpFXf4SiUpUdz0Lz7gXGJ7WB6eqcnv+yaQ50vguUM2L397GI6nDSDr9VdkO8rSX4NhrsejpIjdTBU2yNd1jejrHqpQcmPkBHH83rqIxAExwe3i/wcTJnaYwOm90pBVdjzT5Hdvkr+GWZCdvbniTam81NFWSHIpGA77ppaBYVdIa5DknpHaOrGvv0gugwr+h+ENrBXgwbCxroF/7ZF4479DzLw1+PRjG3/7Qf5Dxo48j799PyXw/RxwWvZKz7O+3A9LQUxITMWdnk/fww+Tcfz/JZ0/HkpVFzn334ujTdrPtw6X6pZciod5gTQ2+rVsj66b1ioa3tg0/nq26lt0X6/fy3ZZKlu2QhoSzbCkp61+hYfRdcuOYhOa4jhNoiEtiZ/1O8p16yNDXgNj5dWSbW6pqGJnWlwGZ0hALh8oK9kLatw6WVa3hQd9OdpWqjNvuIitOzrYfPK0P7zQtZrYzjho9LBMWQ26V2hrEssXQ2Eh1t3NY4xhEg/sAnTN26bp2++r8HSZKXFw0t7O0FEtWVmScO+/RCNU3ECgpof65Z7hkzYdcP/fpZvtXORJo8gY4ffMc/jn/KSjbg2nCMGp2xrOzQfAG3ehd+j/2Vu3C0lDLI2f0pXe7JERAhpaU+lpO7ZeH02Ym0aLQtV3UYFJb8fwp/ka6v9iV1DW6/tgbZ8H8R6LdGWIxO0jp5Mba//j9fwjdp0BaZ0jrAp/eAqUy1D1g53IGmhKlBIzfTVJIpY8pHqH3keasN2U/ZK+uRWm2yUrupnJp+MUK1v4EYa19yUlyNPM2V3urSdVb/jV8eeTlWQx+Hnyu9gwoSOapDX/j+0qZ86yZbHRLH8q/e19FQTDItNzjIr18t1rN0G6Q/C6WroDGvTDu71gKpJRLqmIDocCom/Dok6XYrh4J1gTSHencfsU2uG4dRYlFPD72cS7qJXsmO/W2dTtS8/nIbuLuxXdT2lgKCTmMcntw6ooHHUo1tB/iSQ7K60tConQeXHnMldH2bWmdIG9gpDvRkeS95cU800ajAIPfDobxtx80/cdoSkrENXo0WiiE4nBgyczAOXIEpqQkQHqBCt9+K1IZlXjSZFwTJrDnpptoWrykrcMfNo3z5rP3nnsjWn+VTz3FjjPOjKyf2CWay7hn2PGUxkdV9+/9dAMPfymlYByVqxBoOMuWQP6x0TZMQFFSB0qaytjdsJuijL6yE0bHcYh6WcxizzBRFAjyRPLgiOcvXCGZNmYc6nZ7RKg0GABneT3iXdk+6ft1X/LsPXXkrjOT0a4zj515DMlxbYcaxfo1mG6+GvYUE7Q42dWk4NPaCBGHqd0lDYr4A3dAeHPymzw8+uEDbgfg3biJsrv/j8Decmn8ZWdHcslmfqUSqpaGdf3bbwOQXy8LNEJCoSEhhZcqHXjcMo/ty2GnQjCIUFUq+l/D56nncp9NhncqtQYUn4+px+SSm+SIGH+h6hqWbK+m0RfEpKnEx9nxJRRS324sgfjcFuerKWZMQXdEHJxdC6GuOOr5C7fbAkjIhtvr4KzW24BFOP4eOP0V2DFPVlSHic+Ci7+G016EQBPndT6dF89ZKOVdRt8KrmzZeSVLzwapK5Y9UJsqodfp+xh/P3/OXVOgiQ+3yNo178aNP/vrGxwB/lrOptPmUOGRVegh/Rpkq95I9qI7cJetpkkIVvsq6BCfByA79BSMkG32AJ6WFfVmXSMwOS5dVqcPvJgnMuQE1qGq8Fg/uD2RW0QGX/zhCwBunnczDyx9ANb8l2EfSJ3M93Z/hVXVyDPHVAtbHGC24eh+CgE91/TqD+R9x58uz8Ox8VPMwkSjP5qXiiMlmj5xhDGbBLuq3YYB+BvHMP72Q9I0KVQrrFYp5RIIoOhVYcHyCjR/y5yI+s8/Z33PXgT2lFI36wN2zZz5k91ANL/MBQtVyvCzyZWA2tQUMVpdIhpCXb9sLdZQ84Rkh1UaTia/9MAUfXw67JwPTXqF6t61dNs6P7J9n8x+shOG2Qbj/k6neXPJv0NPQP78L7DuA5kkv3MuAFZXEqgiUhhh01/eu07W+/zrM1kMcMwiM3GmIIVpzv12wCDcXs/hoKl0A5OURbiCB7gA2lxSg085gJGI7JIwLn/cAbcDCO4to+aVVwiWSa+fvZcM6WTcfBNpV15B/isv4zz22Bb7vV90LE91kjmj9pD8/jQKS0TqBUXh75tP5Qzz5wBoNiuqx8PibVWU1HowBeU+vuGjOeup+WyraMTvD7DXHWDT6d+w8/gX0FrxloWlXrKX3ivbpQU80hvaabxsuTXqxuY7eGoheICcn8RcKey77Zvmy7N6gi1efubh1wFIzofRN8FH10BaRxjyJ9nqq7ve8bHzRKkDqJjgjNdg2nOyY8/PjM1kY1c6LO1pI+fee3/21zc4AphtoFhYWyNF32t8es5cYzHFm19h8LpHGFLQjunf/x/9sofQxefHbImTMjhxzVvTWXSNzJSMHjDmb/DmWWy1yGVxcWlQLaMt5rpiRrw6kJceymN3+WpeWvcSF619itKYFoH/7Hoe/cxJkf/Dgs1Me5bnJr4QkdICsCbKybtDDRHUQryw9gVWV+j5yLn9oWoL7Fx4hD6wKOF88e93/jTGpcHRgWH87Yfk008HiwVhtVI3axbmrCzSLr0UAN+GDfg2bWqxjzCZIBikPOam0VaHkcPF2l6Gn8M5f4orHjQNtTE6Q7T36MGW/qO5eM5zPDAoodn+Dj3UVTL8bhryRkdXDLpEPu75ga5rpWahy+qid2pPKeq7VVYzm9MzUYK10f3ePgeWv4SyTnq76v4nPZIXfq7SZbdGZkB+3TSftAYdur2jCUFJQl8+WrWHqsb9yIuE9RgdDprKpb6cLdiwv48Itn8jL5JHGCVeeqdC9Q3kPvhARBPyvMT3+F/xbLaMG485q6W3cdrWb/nD5jmc59+CXTeuxm+eHzH+sn6Qrcame+UNJS+tiJDHyxlPL+KTVaV8NmAyL513J8EbbyOkmAiENB468+/c3+lE7FVrSd70dlQMOxZhav486JXhfSFkuLahLLre1wj35cPDB9EyDEDX5IuQ3RfWvAdf3SlFhcfcJperIenl2/o11O6WnT76nwfZfcDqklqM4WrvbpOlKHSMF/rnwqpYCZkE958Uwt6l84F3MDhqyY+XxlSaXf4WVZON4D7adQ5LHMGUAiyF0tO3ryD89K5SCizFniLliIqXYgp4IvuGmZvThQYtgE8IhifI7+2mQC1LYyrGPZldsVRFPWoui7yOmBQTfTP6Uu2t5sFTFKxTJnHn8Lv4uMO53FlZzW1OqbMZqUTP0/PxAs2lZI4E4Spfxaj2/U1z9Kl9HkVYcnLo9O03mJKS8K5dR/CDD1H9fhSrFXNWFo5ePVvsE5aBUT3RXDTlCOj8tYatUyfav/xSRI8u3Js0VN+AKSEBc3o6he+9y5y7/kPH7+dSmJPCqAY/32ySnr04qxx+b2oPdkx8mV7P6snEI66Tj7W7SA+pfHHKJ2S68mT79m/uAzUIXU6UN+YFj8GM96BsNXx5O3x4NdYEeVx7kg9PpY1j12l09ikE4+KAOlSvNPBcqry4BIWZHWoG//l2NXnJcaTGtxHqC3+m9jj2uPU+wpl92a9p7a46lI/0oDElhI2/umbLd9TvYINbZUS5SsNn0ntXGZdEmrsW1wkTaZj9KUX1pRQVObCldYTPwV5TiaYbf7bGnZAoqwlXF51HbXwhTfGZ4AV/SOXZm6agahpb9jYgNFXq/JkdhOxmOv3vBABqOk5recJCsLfftagmG9kVG+Qyi0MafU+PgsKRMPPD5vt4qg/uw+g7Q+bmaRr87xLI7ScrJVe9JTt2hL2u7qqoQTn/Idi9BCbcKXMGXZlS8sWZDmMPUr7nJ8Jq+mkmawY/P6NzJpPrLKBTorxWayYb3n2Mv892fMbWpj0MzNMrafXcvDC58bm8NPElkjfMho9la7yhHi9LHXaZ53zGa2CN44dq6WVUgPN7nM9b1SuZmdiTc7a8Sv/4Aq4xVXPLvFu4oaomUtm7r4jyw6Mf5j8p/yF/7H2yj7BVnkucPnmLfDfdsvAEceT9NyZFHtOQevltY3j+9sPuy6+g5NrrEEIgLBbQNBo+k70+O82dQ97jj7fYx6qLwiafMyOy7Kcy/gCcgwZFcuzC4tNqY9Qb5tuyhaGvPQLA1f9bx7humWQnyu0THc17WJUO/hsM+iPU7JAhv6YKRFwKWQnt5EVKiGg+Vu3OaAVt4SjoHc01NJ98pzy33OjFI2NrgGv+0ERxvhPNpxt/IenlMWGTHT8A//4KPrzhsK+dgEnmzViOvWr/H9Alc3+SdlaKbmjXvv0OWyeeEBH0BijTUy1VXe7ltWOmArBse9QQTTerTBjamQXZPSl1pkByMuopp9PQ7w9UpukV2+5qkqadSs7fpefMFwjh/24e7tdfxTRpNCNLVhIIqRy38H/03r0m5uRaD3GX97uWzOWPwLLnoN1g2VorXHRRvydmf31O6DzISkJFgd6nQ58zZK5gu0HyBuqtgw+ugl2L5HaOlOb77VoAz4yBvWuiUi6O1jU3f04M4++3gxCCzkm9IkaWarYx1OPlz3FRj264aOOCnheEd4Ki4yBP/g631G5hZ/1O2tuj4WCXnlrjDrqll7rDGLqlSu9cj6IJOLJ6M/f0uVyQexwWYLA1uu8Yt5svaMesqS16ItAvsx//Gf8fzIqZdVXr6LX+MT6Id/KWV7Z8i3w31+gKAY0VLY5xuEzulQ1EZZAMfpsYxt9+8G3ZgnvRIvzFxViyZYJvcG/L1lmxmBIS6LZhPUlTp0aWHYkOHweDo0cPsu/+B2a9bZ1340a2nXJqZH1NUPDIl5u4emwnbjy+C2cPbt9s/8peF0P7wfBoHxmCa6pskf8SMf7iUqNyAxs+lkUC530C3acSypAhCSW9PbmPPRrZ1RzUqEt3YE6TxwylyfN0pidh00PQ+5N60cZOJHTPI2Ayc2yPAgBEbBJ0a+QcA33P2v82PwJTgguEwL14McGKCsx6sUe/jH5kd5dVzwknn0ThB7NYUdCXZ3pMpsuGpZH9PbUNLFhXii3kx+51E0jLRL38OqpOuof6wTfIjcJGE2AzCXxBlRUPPMGu194Cv48Ubz2BkMaIH76g055NhKzNw/qtEbK6pLfgws+lhErYUIw1uix2OPEhOP+TH/8Bhb8by1+KttYzmZuJ56LLb2C2QSe9sjiuecjtl8CsmHFZXJzR5Yxf+lQMjjCayYYJOHdTNFcuPU72wW4IxKSQ5A2AApmz+78t/+O2BbdRJqITU5uenuCNER+fVDiJj075iKFTngPFJA1OvZrekRXtl+5SpXB+UeL+u8d8W/wtAKttVn4IygiDNSzp1O+c6HkeYcwmQfuUOMZ0OfIyMgZHD4bxtx/UOvmDUxsbSTjpJLLvvYeUc8896P3bPfM0ydPPkl7DnwFLTg5J06ZhTpEellBdHQSiRR4+k4WqJj9byhsZ0Smd/NRWZnZhI8BTLXO09m2rZdMNDGd6NDzyuR6mKxgOp79EYJtszeWvB/+OnZFd//pmiO2dXOTcJ/Mhjx1xGrMnDcQ3ZSxWvatIW8af8sJ/EMW70AYOke8tLEfz4QE8fz8Rwm6n69o1WAsKiBswAKEndb90wks8ePpLdPh0Njl33429c2cUszlS3JFz//2IuDj27q3m27c+oX/5JtK8dfxnzib8TR5QVVZpHfAkFMGYv1L30cds6NWbPF8tvqBKdW0TVZZ4hM3GGYUOeuUmomghMJnYNO1Ltk5+b7/nrVpdUW8fyJZ3E/4Bp+/TIH7ghZBS+OM/oNjQWWx3FWdai00xO6DThLbX/wIMzh58wJuzwa8PX1JnVl+4EwqOpYMqrzk5uoTVQ98/FN1wzF9h3N8B2Fwjr2fbg9GJ5kmNTbySdzJ5rrzIMiEE+Qn7aLp2PRFur8M07u9c3e9qACpNJnoFN/Dupnf3e65JtiQAmjocR7pdXtMjfYWLRksv+0+QE5uXHMe/zjqG3nmJR/zYBkcPhvF3EAirFaEoJE2dekjFG/EjRpB1220/W3NsLRDAs2oVgb3l8n9ftFpzd24nvHrI4LO1ZfzfJ+up8wRaHiQcmnNXw1mvw7n7hCbCoV5nmkzYb4W446eRfWZfMh94XlZJ63TfDb2boqG/MUWJvNFtJY9m+SJ9b/1tGX+vvYDplmsQS6U37M4vSthry5cVor8AQgg8y5fj37GD+NGjWqy3FhREjP74kI9zNsj8v8STJuMaPQqR1y5iEAJUfTOPuCnHwYZ1vLWikqniUehwHEpcHASD3D46l+mD22MO+VEtFswZGbTT3KS7ZMeCYwrTCDqzcGftX5g1ZImHnQvgiSHSsyiEFGhOyDmCnw5Rzx80786R1kmG08KePpCev0a94CRW5uUX5OHjHmZ6t9Z7fhv8igmnr7iruFvJ4fVJr5MU1t+r29H6LugSXjb92pXRAzPQN+3QGld59J6+9XpO3Xub9j9RC59Xgz2eobnHkuXMIu4g2lQeCYQQP9t9y+CXwTD+DgJh/XX09ww1NrLj9DNo+OxTALRA1LhY03UIqh7i213jYeG2Kpp8wZYHidMvcOFk/30vADPeha6TZVeGNL1jwz4eImGxk3T7GygZheTcdy9Zt98eWdfus1UUX3MtADuef5KXH/RTVbqGBLuFZ84ZwHGthRrUqEGo/OcxADZXNBFQFTD9PF7V1ii+UnodE0/ZfweKJ87q2+z/3IceQjntrEi178zxt2IKv0ezmaCqRpurJycBcEyCoHOmC3MwiGa1YkpLo2JHMXtq3Ag1hNNxcJMS1eqShlbFelm481PRZRKc8758HnvDGvwnGHaFzJPSOydgcchJhyUOUjv9dOdk8LtHBD3kzrsJSpbRw5lNr/ReZMbJlI3w477cOfxOLutzGT3aj4Qhl8kiJqEcsgD506uk0HujEjYm9+9Zi3j+Ak2YhIlyd/khvZ6Bwf4wjL/94BwuW7UJ6y9nYBwKJpdegaoXGoQLKwBqd+9psX26qxWjNuz5a9wru0Bs+Lj5epsLznxNJvendpAXwOy2O5hYMjNJmHQCtluvAUD4AniWy6q4Lbtk/uStz63HpAiyEu0R7cFmKApq/8HyuV3m0Lj9QfIC22H9hy23/5nIvOVm2v3n35GCm7bo2D69xTKH1RTx/PnMVkyR/DcTIVWL6B2ak2UYfvuWEhZurcISCoDZivPEE3lB5PPdJnlDKGloxYvbCmUDboSRUpaGn9KLIIQUc05qLzX/wqR3gXkPyuVnvyu1/OxJMmXgL6UtZDYMDI4kmmImabPucdPzS7OcWdhNdnqn9251nyxnFn/q+yeU9M6yh3V6Zxh/l9TIPAQ6JnVkXM4IumbJlpPn9th/ClG4LVxQDVLnq4u0qDMwOBIYUi/7wTVhAp7VqyNtvI52hNmMEheHWi+NP1NiInGDBlGDhUkrFsIFl/LyomgOXquCyrZ4mQOW1Qu+/kdLkd31H0LxMhh/BwS8Ui/uAN43U0ICGUU92A1gt6PqRqldz0e0BmTy9H+XF1OUHk/fdknNDxAIgJ5TpzkcBEMq3oAKJiC54GA+mp+ExJNPPqjtPllfSRGgOGX4c89NN6NU12IPyv9fLZ+NGvb8mcwEVW8kDG7Sjb+5SzfzhbsdtSMu5fShhYw7bRiz1nzCmRqcO/0R+rZL5GCyHz0Zx4BFl4n4qUNIGV1hwt2QGRMeqyuWuoJNlVKottcfftpzMDCIRbHgTe1OnBmZ16cTVINSWmV/aBp8/lfYNgduPPTuF3HmODyoZOxZw+q+Z0HOsP1u3ympEx9M/YAsZxZmYW5ekGJgcJgYxt9+cI0dg3PYUEyJv57EV1NqaqS/r3PYMJzDhlF31Q34TRZS420MLUrlxN7ZdMvaT2XosCthr+zC0aL68pv7pKZf9ynS49fjVJnUfAA0fwB7797Yu3WjbpbMI7Tr2nb2gIaqaby5dDfju2dGjL+yOi8Lt1VyilKOsvg7eSBHHE1+WXX3SN/ZXHNC67P1o4mn523j73YnOXoFeKixEaW8jKouU9hQupqu3y+Obmw2EwxpxNuk8ae4XCSddSaao4g9tR6WPTIDTa80TA55CAZVAprAfJBFRbaazbBSb8V2hPsdt0r3fQzktf+Tj+/pnWFmfgSFI3768zAw0HGn9yVuy7uR/GVN0whqQZoOJJhcVwxr9l+ksT9WVa6ST3x10Qr4/WA1WSlMjKbUpJhS9rO1gcGhYYR990P5Aw+ya+Z5v/RpHBKJU6fQNH8+te/9lw29+8i+s59/TLqnjoe/3MSwDql0yXRFqmtbJeCFFa/J5870lutA5mkpJjjtBenBOQCuMcdR8OYbmFNT0LxeNE3DFpDGn6IBAT82i9Ks2ve2D9bw/Hc7qK+IERt2OFBVjd55iSSmZTcPKR6lmBVBozCzaKMsalDi4sDjoXDkYN7pPbn5xgmJ/HFkEbdOkpphQlHI/vvfof9gKhv97H3+RTzff0/9Bx/w+od/w1W6g5lL3qb9rg0HdS6J2z6ALV9IUedforginB8arlp8zfD8Gfy8BJ2Z4G+MpIwIIVg+Yzk3D7p5/zsepqd8aPZQ8vU+wuxavP+NDQx+Ygzjbz/Uf/IJgT0tc+WOZlJmzKDgzTew5rdH8/vZclzzsO2DX2xqvco3Fn8TLHpKPk9q13xd0Wj5uK9ReBAIRcGSk4O9d28IBrGPGcOeZP0r6PFiNSnNRJ6rmmROnNUjJRY0iwV18ikkO63cPbUXAwp+HTNhsyJ4tcsElhZJTS4lLg61qYllyzZiboqGcjYX9QFXAkXp8fTMjXqbtWCQXIv8XCoeeID1sz7HnC4///jKMiZu/Y60qhIOBlVvJ8UZr/4ygspDLofJD8Nxt8j/Y3TSDAx+Dmo7nCILi7KjUQOLyYJyoG4Zh+kpf3rC03x0ykfyn9E3HdaxDAwOFyPsux80/wEa2x+FmBITcfTtu99tVhbXMqF7VtsbOFNl8n3NjpY5dcf/Hwy97EfrsSX94Q8k/UF6e9qdPJW51TYyqjaDxYzNYop4/pp8QQJBlbMGtsOxS+YpikAAbIdWYXc0YDEpfF4wmNGF0mBT4uJQ3W4mzH+XMcXLI9t12raSoKqyZGctvmAoYtzuPO88OnlDKEVnYVJDVPu1iJD3MJPU7FMP8nMJ6UnkeOvblOr5STGZYcAFsPnLn/+1DQyAQHwOXLns0Hc8xOreVlFMUp/PwOAXxvD87QfXCb+Mhtzh0jj/O7addDLWDlEB0LKYKsqQqh34IGabrMxssdwalej4kXhWr2bXxZegbN/GRWeMpNct10GcE5tZYfDCD1HuvYN1pfVoQFFtCaEP/hfZV/ywlCXbq7n45WWU1HjafpGjiHibnGOZdX0vS24uSadMxR7yU62HXsvS9HBQMMBz87fx0sKYwpyMDOwVpTx1uiycEDZbxPOXuHIJAMeMHnRQ52Ly6zeeFa8f3ps6XNI6/rKvb2BwqIRlr1KN767Br5/DMv6EEKcJIdYKIVQhRJt9ZoQQE4UQG4UQW4QQB0isOHrIfeghuq5dc+ANjzLcy5bi27wZR98+dFnxA5Z27diYms/AgmQyXDaGFP7CchpCoWnePLZPmULJjTcSKCsDv4+7TuzG6EwL6twv0QJ+/nZiN469/zqspcXs7irzCpWvPqPW46es3ovF9OsQIb11UjeyE+1YzfJ8U2acTdZtt5FAkFB6JsFP5/PyhXcz85zHwWojqGpYYpqqxw0cSGjvXrp6pKyLsFlREhLQrFbExnVoFiuOzgenj1dXOBnyj4V+B9+p5ichsd2BtzEwONoYextMvPeXPgsDg8PmcD1/a4BTgW/b2kAIYQKeAE4AugNnCSG6H+br/iwIIRCmVnTnjnLC7d2EoqDY7bjGHMe6xHYUpsXz3MyBJDt/2cb19h7dMefI5uG+DRvZMvo4xNwvSZxxEo1l5ZiDAZa89zn9c6IFCa/GywIIdfp5uH0y/81p+3VkLbRPjWN4x7QWFdY9Szeg6jI2LrsFjz/EhtJ6yht8zWR4nMOkJETVF18B4BNmhBB8MGAKVYnplGcXsKHSfVDnEnDlwfl6L+ZfEsUEf/xW9oM2MPi1MOL6Q9b3MzA4Gjmsu6emaeuBA7WBGQRs0TRtm77tm8AUYN3hvLZB24TFqRMmnwRA5i23cGud96gJkwohyLr1Vuo++BB7925UPPIopn/eBcDDFHEXc7jmyyepyvBTf9sDpN95A6Mr1uH9bAH13iA/fLUZAa0LQh+lPHBacyHsYKXU2ltuz2I8cP6wAqb0yeHyN5bjsJgYXBQtZrG0by/bxS2Zzx3n3sdtZ8oQ7+aRJ/HvjMEITeWS8ka67k++52hkP+LgBgYGBgY/HT+H6yQXpL6vTjEwuLUNhRCXAJcAtG/f/qc/s98otg4d6LZhfbNlWYl2Khp8bezx8+MaNw7XuHFooRCKw0Hplt1U1jbi7TiIDZYKMqr3YJs6DXtKMp7jT6JPShpmk0JVo4/lu2ooTHOi/Ip7T5rT0nDO+Y7pFjMVXg2zSSHdZeOcIQUM65DKcV2jbe6EEOQ++iihulreGBTN7bvn1F7MeG4xm/Y2kpnw6yuEMTAwMDD4ZTig8SeE+BJorTT0L5qmzTqSJ6Np2tPA0wADBgw4iKoEg187wmQiZeZMSorrSAHuAZjW3CNk+fNfIs+L0uN565Ih2C2/Hq9fW7TPlt69imJZhCGE4OQ+Oa1ua+/SucWyjAQ7D57Wl2BIxdxatxYDAwMDA4NWOKDxp2nauMN8jRIgNrs7T19mYHDImBRBnPXXkev3c2EYfgYGBgYGh8LPcddYCnQSQhQKIazAmcAHP8PrGhgYGBgYGBgY7MPhSr2cIoQoBoYCHwshPtOX5wghPgHQNC0IXAF8BqwH3tY0be3hnbaBgYGBgYGBgcGP4XCrff8H/K+V5XuASTH/fwIYmg4GBgYGBgYGBr8wQtOOzroKIUQFsPOAGx4eicBvoddOGlD5S5/EEeK3Mibw2xkXY0yOPowxOTr5rYyLMSZHH4cyJpWapu23RdlRa/z9HAghntY07ZJf+jwOFyHEMk3T2uyw8mvitzIm8NsZF2NMjj6MMTk6+a2MizEmRx9Hekx+72WCH/7SJ2DQAmNMjj6MMTn6MMbk6MQYl6MPY0xa4Xdt/GmaZnwpjjKMMTn6MMbk6MMYk6MTY1yOPowxaZ3ftfH3G+LpX/oEDFrFGJejD2NMjj6MMTn6MMbk6OOIjsnvOufPwMDAwMDAwOD3huH5MzAwMDAwMDD4HWEYf0cpQojnhRDlQog1Mcv6CCEWCiFWCyE+FEIkxKzrra9bq6+368vPEEKs0pff90u8l98KhzImQoizhRArYv5UIURffZ0xJkeIQxwTixDiJX35eiHELTH7XC2EWKOPyTW/wFv5zXCIY2IVQrygL18phBgds4/xOzlCCCHaCSHmCCHW6Z/n1fryFCHEF0KIzfpjsr5cCCEeE0Js0cegX8yx7tN/K2uEEGf8Uu/p186PGJOu+m/IJ4S4YZ9jHfr1S9M04+8o/ANGAv2ANTHLlgKj9OcXAHfpz83AKqCP/n8qYNIfdwHp+vKXgLG/9Hv7tf4dypjss18vYGvM2Bhj8guMCTAdeFN/HgfsAAqAnsAafZkZ+BLo+Eu/t1/r3yGOyeXAC/rzDOB7pFPC+J0c2THJBvrpz13AJqA78E/gZn35zcB9+vNJwGxAAEOAxfryE4Ev9N+JUx/XhF/6/f0a/37EmGQAA4G7gRtijvOjrl+G5+8oRdO0b4HqfRZ3Br7Vn38BTNOfTwBWaZq2Ut+3StO0EFAEbNY0rULf7suYfQwOkUMck1jOAt7UnxtjcgQ5xDHRAKcQwgw4AD9QD3RD3tzcmmxH+Q1w6k997r9VDnFMugNf6/uVA7XAAIzfyRFF07RSTdOW688bkK1Wc4EpSMMa/XGq/nwK8LImWQQkCSGykeP1raZpQU3TmpBOh/2KCRu0zqGOiaZp5ZqmLQUC+xzqR12/DOPv18Va5BcD4DSgnf68M6AJIT4TQiwXQtyoL98CdBFCFOg3vKkx+xgcGdoak1jOAN7Qnxtj8tPT1pi8CzQBpUiv0gOaplUjZ80jhBCpQog4pNfDGJMjS1tjshI4WQhhFkIUAv31dcbv5CdCCFEAHAMsBjI1TSvVV5UBmfrzXGB3zG7F+rKVwEQhRJwQIg04DmNcDpuDHJO2+FHXL8P4+3VxAXCZEOJ7pJvYry83A8cCZ+uPpwghxmqaVgP8CXgLmIcMc4V+7pP+jdPWmAAghBgMuDVNWwNgjMnPQltjMgj5WecAhcD1QogiTdPWA/cBnwOfAiswxuRI09aYPI80LJYBjwALgJDxO/lpEELEA+8B12iaVh+7TpMxxP3Kf2ia9jnwCXKc3gAWYozLYXEExuRHXb8M4+9XhKZpGzRNm6BpWn/kD2+rvqoY6Yqv1DTNjfxx9tP3+VDTtMGapg0FNiLzCgyOEPsZkzBnEvX6hfcxxuQnZD9jMh34VNO0gB5i/A4ZYkTTtOc0TeuvadpIoAZjTI4obY2JHj68VtO0vpqmTQGS0D9743dyZBFCWJBGxmuapv1XX7xXD+eiP5bry0to7j3K05ehadrd+niNR+YEGuPyIznEMWmTH3P9Moy/XxFCiAz9UQH+CvxbX/UZ0Et3xZuBUcC6ffZJBi4Dnv25z/u3zH7GJLzsdKL5fvvuY4zJT8B+xmQXMEZf50Qmsm/YZ5/2yHyZ13/es/5t09aY6Ncsp/58PBDUNM24dh1hhBACeA5Yr2naQzGrPgBm6s9nArNilp+rV/0OAeo0TSsVQpiEEKn6MXsDvZEeJ4ND5EeMyf6OdcjXL/OhnrDBz4MQ4g1gNJAmhCgG/g7ECyEu1zf5L/ACyFCiEOIhZOWVBnyiadrH+naPCiH66M/v1DTNmKX9SA5lTHRGArs1Tdu2z6GMMTlCHOKYPAG8IIRYi/RYvKBp2ip93Xv6TS0AXK5pWu3P9BZ+cxzimGQAnwkhVKRn6ZyYQxm/kyPHcORnu1oIsUJfditwL/C2EOJCYCdysgoyejQJmXvpBs7Xl1uAedJuoR6YoRcZGBw6hzQmQogsZHpEAqDqki7d9VDxIV+/jA4fBgYGBgYGBga/I4ywr4GBgYGBgYHB7wjD+DMwMDAwMDAw+B1hGH8GBgYGBgYGBr8jDOPPwMDAwMDAwOB3hGH8GRgYGBgYGBj8jjCMPwMDAwMDAwOD3xGG8WdgYHDQCCEaW1nWRQgxVwixQgixXgjxtBDieP3/FUKIRiHERv35y0KI0UIITQhxUcwx+urLbvgR53SyEOJm/flUIUT3mHVzhRADDrD/aCHER22sezb2eDHLzxNC/KuNfVp8Rkea2Pf8cyOEuF4fq7Rf4vUNDAwOH0Pk2cDA4HB5DHhY07RZAEKIXpqmrUZ2nkEIMRe4QdO0Zfr/o5HNyE8n2rXhLGTT+ENG07QPkKr4AFOBj9A73BwumqZddOCtfn72ec8/G0KIdsAEZLcUAwODXymG58/AwOBwyUb2lwZAN/wOxE7ALoTI1NscTQRm77uR3k5qu95mKkkIERJCjNTXfSuE6BT2wgkhhgEnA/frXsYO+mFOE0IsEUJsEkKMaON84oUQ7wohNgghXtPPqZnnUAhxvn6MJUh1/vA5FgohFgohVgsh/rHP+f9ZCLFUCLFKCHGHvqxA95A+I4RYK4T4XAjhaOuDEkJcJYRYpx/jTX1ZxPMY42FdIYTwCCFGCSGcQojn9ff9gxBiyoGH5KB4GLiRAzSbNzAwOLoxjD8DA4PD5WHgayHEbCHEtUKIpIPc713gNGAYsBzw7buBpmkhYCPQHThW326EEMIGtNM0bXPMtguQ3rA/643nt+qrzJqmDQKuQbYaa41j9PXdgSJijDuINFi/Q19+rL5dmEeBpzRN6wWUxuwzAegEDAL6Av3Dhqu+/AlN03oAtcC0Ns4L4GbgGE3TegOX7rtSf699gb8h2z8tAP4CfK2/7+OQBrFzn/fk2sdwjP1rLdQ9BSjRNO1HeWgNDAyOHgzjz8DA4LDQNO0FoBvwDrKn6yLdODsQbyONv7OAN/az3Txkn+SRwD1I42sgspf1wfBf/fF7oKCNbZZomlasaZoKrGhlu8HAXE3TKjRN8wNvxawbHnP+r8Qsn6D//YA0WrsijT6A7ZqmrTiI8wJYBbwmhJgBtNpHVQjRCbgfOF3TtID+ujcL2TN0LmAH2sfuo2laQ9hwbOVv3T7Hj0P2Hb1tP+dpYGDwK8Ew/gwMDA4bTdP2aJr2vKZpU5AGSs+D2KcM2Yh8PPDVfjb9FhiB9KB9AiQhjcx5B3l6YY9iiLbznGO9jvvbri1aC4MK4J4Yg6qjpmnP/YjXOxF4AugHLBVCNNtWCBGPNKQv1jQt7HkUwLSY126vadr6ffY7FM9fB6AQWCmE2AHkAcuFbDZvYGDwK8Mw/gwMDA4LIcREIYRFf54FpAIlB7n7bcBNeni3LZYgQ8OqpmlepGfuj0ijcF8aANdBvvahsBgYJYRI1d/raTHrvgPO1J+fHbP8M+AC3ThDCJErhMg4lBcVQijI8PYc4CYgEYjfZ7PngRc0TYs1hj8DrozJXTxm32MfiudP07TVmqZlaJpWoGlaATLHs59uwBsYGPzKMKp9DQwMDoU4IURxzP8PIb1AjwohvPqyPx+sUaDn6R1oG58QYjewSF80Dxkqbq2w5E3gGSHEVcAfDuYcDvI8S4UQtwMLkTl6K2JWXw28LoS4CZgVs8/nQohuwELdBmsEZiA9fQeLCXhVCJGI9OY9pmlarX48hBD5yPfZWQhxgb7PRcBdwCPAKt2A3A5MPoTXNTAw+A0jNM0o2jIwMDAwMDAw+L1ghH0NDAwMDAwMDH5HGGFfAwMDg6MAIcQT7CMxAzyqV1MbGBgYHDGMsK+BgYGBgYGBwe8II+xrYGBgYGBgYPA7wjD+DAwMDAwMDAx+RxjGn4GBgYGBgYHB7wjD+DMwMDAwMDAw+B1hGH8GBgYGBgYGBr8j/h8MrC7AzIX67gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(len(hidden_factors), 1, figsize=(9,10),\n", + " num=1, clear=True)\n", + "for hidden_factor, ax in zip(hidden_factors.values(), axes):\n", + " hidden_factor.plot(ax=ax, style='--', legend=False)\n", + " for a,b in vspans:\n", + " if a >= min(hidden_factor.index):\n", + " ax.axvspan(a, min(b, max(hidden_factor.index)), alpha=0.2)\n", + " ax.spines[\"top\"].set_visible(False)\n", + " ax.spines[\"right\"].set_visible(False)\n", + " ax.set_xlabel(f\"LSTM with hidden_size = {len(hidden_factor.columns)}\")\n", + "plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n", + "plt.suptitle(f\"LSTM Hidden States Process\", fontsize=12)\n", + "plt.savefig(imgdir / 'lstm.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dynamic Factor Models" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EM start iterations, llf=-1.1843e+05\n", + "EM iteration 20, llf=-1.1774e+05, convergence criterion=3.1004e-05\n", + "EM converged at iteration 29, llf=-1.1773e+05, convergence criterion=9.4463e-07 < tolerance=1e-06\n", + "EM start iterations, llf=-1.1327e+05\n", + "EM iteration 20, llf=-1.1147e+05, convergence criterion=7.3906e-06\n", + "EM iteration 40, llf=-1.1146e+05, convergence criterion=2.7273e-06\n", + "EM iteration 60, llf=-1.1146e+05, convergence criterion=1.0928e-06\n", + "EM converged at iteration 62, llf=-1.1146e+05, convergence criterion=9.9257e-07 < tolerance=1e-06\n", + "EM start iterations, llf=-1.0902e+05\n", + "EM iteration 20, llf=-1.062e+05, convergence criterion=1.8777e-05\n", + "EM iteration 40, llf=-1.0617e+05, convergence criterion=3.7322e-06\n", + "EM converged at iteration 56, llf=-1.0617e+05, convergence criterion=9.9476e-07 < tolerance=1e-06\n", + "EM start iterations, llf=-1.0478e+05\n", + "EM iteration 20, llf=-1.0301e+05, convergence criterion=2.4994e-05\n", + "EM iteration 40, llf=-1.0299e+05, convergence criterion=4.3864e-06\n", + "EM iteration 60, llf=-1.0298e+05, convergence criterion=2.0342e-06\n", + "EM iteration 80, llf=-1.0298e+05, convergence criterion=1.0751e-06\n", + "EM converged at iteration 83, llf=-1.0298e+05, convergence criterion=9.7809e-07 < tolerance=1e-06\n" + ] + } + ], + "source": [ + "dynamic_factors = dict()\n", + "for i in [1, 2, 3, 4]:\n", + " mod = sm.tsa.DynamicFactorMQ(endog=mdata,\n", + " factors=1, # num factor blocks\n", + " factor_multiplicities=i, # num factors in block\n", + " factor_orders=2, # order of factor VAR\n", + " idiosyncratic_ar1=False) # False=white noise\n", + " fitted = mod.fit_em(disp=20,\n", + " maxiter=200,\n", + " full_output=True)\n", + " dynamic_factors[i] = DataFrame(fitted.factors.filtered.iloc[seq_len+1:])\n", + " dynamic_factors[i].columns = list(range(len(dynamic_factors[i].columns)))\n", + " mse = nn.MSELoss()\n", + " prediction_errors[f\"Dynamic Factors {i}\"] = float(\n", + " mse(torch.tensor(fitted.fittedvalues.iloc[mod.factor_orders+1:].values),\n", + " torch.tensor(mdata.iloc[mod.factor_orders+1:].values)))\n", + "#print(fitted.summary(0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot dynamic factors" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(len(dynamic_factors),1,figsize=(9,10),num=1,clear=True)\n", + "for dynamic_factor, ax in zip(dynamic_factors.values(), axes):\n", + " dynamic_factor.plot(ax=ax, style='--', legend=False)\n", + " for a,b in vspans:\n", + " if a >= min(dynamic_factor.index):\n", + " ax.axvspan(a, min(b, max(dynamic_factor.index)), alpha=0.2)\n", + " ax.spines[\"top\"].set_visible(False)\n", + " ax.spines[\"right\"].set_visible(False)\n", + " ax.set_xlabel(f\"Dynamic Factors = {len(dynamic_factor.columns)}\")\n", + "plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n", + "plt.suptitle(f\"Fitted Dynamic Factors \", fontsize=12)\n", + "plt.savefig(imgdir / 'dynamic.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Correlation of LSTM hidden state process with (linear) dynamic factors" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average variance of LSTM hidden states explained by dynamic factors\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", + "
# hidden states in LSTM:1234
R-square0.6752130.7487990.7624010.691161
\n", + "
" + ], + "text/plain": [ + "# hidden states in LSTM: 1 2 3 4\n", + "R-square 0.675213 0.748799 0.762401 0.691161" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rsq = dict()\n", + "for k, hidden_factor in hidden_factors.items():\n", + " rsq[k] = [sm.OLS(y, sm.add_constant(dynamic_factors[len(dynamic_factors)]))\\\n", + " .fit().rsquared for _, y in hidden_factor.iteritems()]\n", + "print('Average variance of LSTM hidden states explained by dynamic factors')\n", + "DataFrame({k: np.mean(r) for k, r in rsq.items()},\n", + " index=['R-square']).rename_axis(\"# hidden states in LSTM:\", axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mixed Frequency Dynamic Factor Model" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EM start iterations, llf=-92416\n", + "EM iteration 2, llf=-91150, convergence criterion=0.013791\n", + "EM iteration 3, llf=-90240, convergence criterion=0.010031\n", + "EM iteration 4, llf=-89627, convergence criterion=0.0068229\n", + "EM iteration 5, llf=-89255, convergence criterion=0.0041555\n", + "EM iteration 6, llf=-89046, convergence criterion=0.0023402\n", + "EM iteration 7, llf=-88909, convergence criterion=0.0015453\n", + "EM iteration 8, llf=-88812, convergence criterion=0.0010921\n", + "EM iteration 9, llf=-88753, convergence criterion=0.00066705\n", + "EM iteration 10, llf=-88727, convergence criterion=0.00029207\n", + "EM iteration 11, llf=-88707, convergence criterion=0.00022797\n", + "EM iteration 12, llf=-88692, convergence criterion=0.00016295\n", + "EM iteration 13, llf=-88681, convergence criterion=0.00012769\n", + "EM iteration 14, llf=-88672, convergence criterion=0.00010445\n", + "EM iteration 15, llf=-88664, convergence criterion=8.6644e-05\n", + "EM iteration 16, llf=-88657, convergence criterion=7.2039e-05\n", + "EM iteration 17, llf=-88652, convergence criterion=5.9846e-05\n", + "EM iteration 18, llf=-88631, convergence criterion=0.00024251\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/terence/env3.10/lib/python3.10/site-packages/statsmodels/tsa/statespace/dynamic_factor_mq.py:2648: UserWarning: Log-likelihood decreased at EM iteration 19. Reverting to the results from EM iteration 18 (prior to the decrease) and returning the solution.\n", + " warn(f'Log-likelihood decreased at EM iteration {i + 1}.'\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EM terminated at iteration 18, llf=-88631, convergence criterion=0.00024251 (while specified tolerance was 1e-06)\n" + ] + } + ], + "source": [ + "scaler = StandardScaler()\\\n", + " .fit(qdata['GDPC1'].values.reshape((-1, 1)))\n", + "gdp = DataFrame(scaler.transform(qdata['GDPC1'].values.reshape((-1, 1))),\n", + " index = qdata.index, columns=['GDPC1'])\n", + "\n", + "mod = sm.tsa.DynamicFactorMQ(endog=mdata,\n", + " endog_quarterly=gdp,\n", + " factors=1, # num factor blocks\n", + " factor_multiplicities=8, # num factors in block\n", + " factor_orders=2, # order of factor VAR\n", + " idiosyncratic_ar1=False) # False=white noise\n", + "fitted = mod.fit_em(disp=1, maxiter=200, full_output=True)\n", + "dynamic_factor = DataFrame(fitted.factors.filtered.iloc[seq_len+1:])\n", + "dynamic_factor.columns = list(np.arange(len(dynamic_factor.columns)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot fitted GDP values in 2007-2010" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: fit through current\n", + "beg = '2006-12-31'\n", + "end = '2010-12-31'\n", + "fig, ax = plt.subplots(figsize=(9,5), num=1, clear=True)\n", + "y = fitted.fittedvalues['GDPC1']\n", + "y = y[(y.index > beg) & (y.index <= end)]\n", + "ax.plot_date(y.index,\n", + " (scaler.inverse_transform(y.to_numpy().reshape(-1,1))/3).cumsum(),\n", + " fmt='-o',\n", + " color='C0')\n", + "x = gdp.copy()\n", + "x.index = pd.DatetimeIndex(x.index.astype(str), freq=None)\n", + "x = x[(x.index > beg) & (x.index <= end)]\n", + "ax.plot_date(x.index, scaler.inverse_transform(x).cumsum(), fmt='-o',color='C1')\n", + "ax.legend(['monthly fitted', 'quarterly actual'], loc='upper left')\n", + "ax.set_title('Quarterly GDP and Monthly Estimates from Dynamic Factor Model')\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / \"mixedfreq.jpg\")\n", + "\n", + "\n", + "# Show \"Nowcast\" of GDP\n", + "#Series({'Last Date of Monthly Data:': mdata.index[-1].strftime('%Y-%m-%d'),\n", + "# 'Last Date of Quarterly Data:': qdata.index[-1].strftime('%Y-%m-%d'),\n", + "# 'Forecast of Q1 GDP quarterly rate':\n", + "# scaler.inverse_transform(fitted.forecast('2020-03')['GDPC1'][[-1]])[0],\n", + "# 'Forecast of Q2 GDP quarterly rate':\n", + "# scaler.inverse_transform(fitted.forecast('2020-06')['GDPC1'][[-1]])[0]},\n", + "# name = 'Forecast').to_frame()" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/jegadeesh-titman.ipynb b/jegadeesh-titman.ipynb new file mode 100644 index 0000000..83fd2d3 --- /dev/null +++ b/jegadeesh-titman.ipynb @@ -0,0 +1,528 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Jegadeesh-Titman rolling portfolios\n", + "\n", + "- Relative strength, momentum effect\n", + "- Overlapping portfolio returns, Newey-West correction\n", + "\n", + "Copyright 2023, Terence Lim\n", + "\n", + "MIT License" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import DataFrame, Series\n", + "import matplotlib.pyplot as plt\n", + "from finds.database import SQL, Redis\n", + "from finds.busday import BusDay\n", + "from finds.structured import CRSP, Finder\n", + "from finds.recipes import fractiles\n", + "from finds.display import show, plot_date\n", + "from conf import credentials, VERBOSE, paths\n", + "\n", + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(ndigits=4, latex=None)\n", + "\n", + "sql = SQL(**credentials['sql'], verbose=VERBOSE)\n", + "rdb = Redis(**credentials['redis'])\n", + "bd = BusDay(sql, verbose=VERBOSE)\n", + "crsp = CRSP(sql, bd, rdb=rdb, verbose=VERBOSE)\n", + "imgdir = paths['images']\n", + "\n", + "begyear = 1977\n", + "endyear = 2022\n", + "retdates = bd.date_range(bd.begyr(begyear), bd.endyr(endyear), 'begmo')\n", + "rebaldates = bd.offset(retdates, -1)\n", + "percentiles = [20, 80] # quintile spread percentile breakpoints\n", + "maxhold = 6 # hold each monthly-rebalanced portfolio for 6 months" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overlapping returns: hold monthly spread portfolios for 6 months" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "mom = []\n", + "for rebaldate in rebaldates:\n", + " \n", + " # determine required dates relative to rebaldate\n", + " beg = bd.endmo(rebaldate, -6) # require price at beg date\n", + " end = bd.endmo(rebaldate, 0) # require price at end date\n", + " start = bd.offset(beg, 1) # starting day of momemtum signal\n", + "\n", + " # retrieve universe, required available prices, and momentum signal\n", + " p = [crsp.get_universe(rebaldate),\n", + " crsp.get_ret(start, end).rename('mom'),\n", + " crsp.get_section('monthly', ['prc'], 'date', beg)['prc'].rename('beg'),\n", + " crsp.get_section('monthly', ['prc'], 'date', end)['prc'].rename('end')]\n", + " df = pd.concat(p, axis=1, join='inner').dropna()\n", + "\n", + " # quintile spread breakpoints determined from NYSE subset\n", + " tritile = fractiles(values=df['mom'],\n", + " pct=percentiles,\n", + " keys=df.loc[df['nyse'], 'mom'])\n", + "\n", + " # construct cap-wtd tritile spread portfolios\n", + " porthi, portlo = [df.loc[tritile==t, 'cap'] for t in [1, 3]]\n", + " port = pd.concat((porthi/porthi.sum(), -portlo/portlo.sum()))\n", + "\n", + " # compute and store cap-weighted average returns over maxhold periods\n", + " begret = bd.offset(rebaldate, 1)\n", + " nhold = min(maxhold, len(retdates) - retdates.index(begret))\n", + " endret = bd.endmo(begret, nhold - 1) # if maxhold is beyond end date\n", + " rets = crsp.get_ret(begret, endret, delist=True)\n", + " ret = rets.reindex(port.index).fillna(0.).mul(port, axis=0).sum()\n", + "\n", + " mom.append(float(ret) / nhold)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meanstd
Overlapping Spread Returns0.00440.0262
\n", + "
" + ], + "text/plain": [ + " mean std\n", + "Overlapping Spread Returns 0.0044 0.0262" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "show(DataFrame(data={'mean': np.mean(mom), 'std':np.std(mom)},\n", + " index=['Overlapping Returns']), **SHOW)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Non-overlapping: monthly average returns of past 6 months' rebalances\n", + "\n", + "Jegadeesh-Titman rolling portfolios" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "ports = [] # to roll 6 past portfolios\n", + "jt = []\n", + "for rebaldate in rebaldates:\n", + " \n", + " # determine required dates relative to rebaldate\n", + " beg = bd.endmo(rebaldate, -6) # require price at beg date\n", + " end = bd.endmo(rebaldate, 0) # require price at end date\n", + " start = bd.offset(beg, 1) # starting day of momemtum signal\n", + " \n", + " # retrieve universe, required available prices, and momentum signal\n", + " p = [crsp.get_universe(rebaldate),\n", + " crsp.get_ret(start, end).rename('mom'),\n", + " crsp.get_section('monthly', ['prc'], 'date', beg)['prc'].rename('beg'),\n", + " crsp.get_section('monthly', ['prc'], 'date', end)['prc'].rename('end')]\n", + " df = pd.concat(p, axis=1, join='inner').dropna()\n", + " \n", + " # quintile spread breakpoints determined from NYSE subset\n", + " tritile = fractiles(values=df['mom'],\n", + " pct=percentiles,\n", + " keys=df.loc[df['nyse'], 'mom'])\n", + "\n", + " # construct cap-wtd tritile spread portfolios\n", + " porthi, portlo = [df.loc[tritile==t, 'cap'] for t in [1, 3]]\n", + " port = pd.concat((porthi/porthi.sum(), -portlo/portlo.sum()))\n", + "\n", + " # keep only last 6 months' rebalances\n", + " ports.insert(0, port)\n", + " if len(ports) > maxhold:\n", + " ports.pop(-1)\n", + "\n", + " # compute all portfolios' monthly capwtd returns, and store eqlwtd average\n", + " begret = bd.offset(rebaldate, 1)\n", + " endret = bd.endmo(begret)\n", + " rets = crsp.get_ret(begret, endret, delist=True)\n", + " ret = np.mean([rets.reindex(p.index).fillna(0.).mul(p, axis=0).sum()\n", + " for p in ports])\n", + " jt.append(ret)\n", + "\n", + " # adjust stock weights by monthly appreciation\n", + " retx = crsp.get_ret(begret, endret, field='retx')\n", + " ports = [(1+retx.reindex(p.index).fillna(0.)).mul(p, axis=0) for p in ports]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meanstd
Non-overlapping Returns0.00430.0455
\n", + "
" + ], + "text/plain": [ + " mean std\n", + "Non-overlapping Returns 0.0043 0.0455" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "show(DataFrame(data={'mean': np.mean(jt), 'std':np.std(jt)},\n", + " index=['Non-overlapping Returns']), **SHOW)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Autocorrelations of portfolio returns" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import statsmodels.formula.api as smf\n", + "import statsmodels.api as sm\n", + "sm.graphics.tsa.plot_acf(mom,\n", + " lags=13,\n", + " title='ACF of Overlapping Returns')\n", + "plt.savefig(imgdir / 'overlap.jpg')\n", + "sm.graphics.tsa.plot_acf(jt,\n", + " lags=13,\n", + " title='ACF of Non-Overlapping Returns')\n", + "plt.savefig(imgdir / 'nonoverlap.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Newey-West corrected t-stats" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
All stocks overlappingAll stocks non-overlapping
uncorrectedNeweyWestuncorrectedNeweyWest
Uncorrected and Newey-West corrected standard errors
params0.00440.00440.00430.0043
bse0.00110.00200.00190.0021
tvalues3.95032.18532.23092.0696
pvalues0.00010.02890.02610.0385
\n", + "
" + ], + "text/plain": [ + " All stocks overlapping \\\n", + " uncorrected \n", + "Uncorrected and Newey-West corrected standard e... \n", + "params 0.0044 \n", + "bse 0.0011 \n", + "tvalues 3.9503 \n", + "pvalues 0.0001 \n", + "\n", + " \\\n", + " NeweyWest \n", + "Uncorrected and Newey-West corrected standard e... \n", + "params 0.0044 \n", + "bse 0.0020 \n", + "tvalues 2.1853 \n", + "pvalues 0.0289 \n", + "\n", + " All stocks non-overlapping \\\n", + " uncorrected \n", + "Uncorrected and Newey-West corrected standard e... \n", + "params 0.0043 \n", + "bse 0.0019 \n", + "tvalues 2.2309 \n", + "pvalues 0.0261 \n", + "\n", + " \n", + " NeweyWest \n", + "Uncorrected and Newey-West corrected standard e... \n", + "params 0.0043 \n", + "bse 0.0021 \n", + "tvalues 2.0696 \n", + "pvalues 0.0385 " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res = []\n", + "keys = ['All stocks overlapping', 'All stocks non-overlapping']\n", + "for out, label in zip([mom, jt], keys):\n", + " data = DataFrame(out, columns=['ret'])\n", + " reg = smf.ols('ret ~ 1',data=data).fit()\n", + " a = Series({stat: round(float(getattr(reg, stat)), 6)\n", + " for stat in ['params','bse','tvalues','pvalues']},\n", + " name='uncorrected')\n", + " #print(reg.summary())\n", + " reg = smf.ols('ret ~ 1',data=data)\\\n", + " .fit(cov_type='HAC', cov_kwds={'maxlags': 12})\n", + " # coef, stderr, t-value, P>|z|\n", + " b = Series({stat: round(float(getattr(reg, stat)), 6)\n", + " for stat in ['params','bse','tvalues','pvalues']},\n", + " name='NeweyWest')\n", + " res.append(pd.concat([a, b], axis=1))\n", + "show(pd.concat(res, axis=1, keys=keys),\n", + " caption='Uncorrected and Newey-West corrected standard errors', **SHOW) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot monthly average returns of Jegadeesh-Titman rolling portfolios" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_date(DataFrame(index=rebaldates, data=np.cumsum(jt), columns=['momentum']),\n", + " fontsize=8, rotation=90,\n", + " ylabel='Cumulative Returns', xlabel='Rebalance Date',\n", + " title='Monthly returns of Jegadeesh-Titman 6-month momentum portfolios')\n", + "plt.savefig(imgdir / 'jegadeesh_titman.jpg')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/link_prediction.ipynb b/link_prediction.ipynb new file mode 100644 index 0000000..769f735 --- /dev/null +++ b/link_prediction.ipynb @@ -0,0 +1,628 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Link Prediction\n", + "\n", + "- Random graphs\n", + "- Link prediction: resource_allocation, jaccard coefficient, \n", + " adamic_adar, preferential_attachment\n", + "- Accuracy: precision, recall, ROC curve, AUC, confusion matrix, \n", + "- Imbalanced sample\n", + "\n", + "Copyright 2022, Terence Lim\n", + "\n", + "MIT License" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import zipfile\n", + "import io\n", + "import time\n", + "from itertools import chain\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import DataFrame, Series\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import networkx as nx\n", + "import networkx.algorithms.community as nx_comm\n", + "from finds.database import SQL, requests_get, Redis\n", + "from finds.busday import BusDay\n", + "from finds.structured import PSTAT, CRSP\n", + "from finds.sectors import Sectoring\n", + "from finds.graph import graph_draw, graph_info, link_prediction\n", + "from finds.display import show\n", + "from conf import credentials, paths, VERBOSE\n", + "\n", + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(ndigits=4, latex=None)\n", + "\n", + "sql = SQL(**credentials['sql'], verbose=VERBOSE)\n", + "bd = BusDay(sql, verbose=VERBOSE)\n", + "rdb = Redis(**credentials['redis'])\n", + "pstat = PSTAT(sql, bd, verbose=VERBOSE)\n", + "crsp = CRSP(sql, bd, rdb, verbose=VERBOSE)\n", + "imgdir = paths['images'] / 'tnic'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Retrieve TNIC schemes from Hoberg and Phillips website" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tnic2 (50402140, 4)\n", + "tnic3 (25657918, 4)\n", + "tnic2 nodes = 3197 edges = 792040\n", + "tnic3 nodes = 3197 edges = 509824\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tnic2tnic3
Graph info of TNIC schemes 2019
connectedFalseFalse
connected_components236
size_largest_component31953131
directedFalseFalse
weightedTrueTrue
negatively_weightedFalseFalse
edges396020254912
nodes31973197
selfloops00
density0.0775170.049897
\n", + "
" + ], + "text/plain": [ + " tnic2 tnic3\n", + "Graph info of TNIC schemes 2019 \n", + "connected False False\n", + "connected_components 2 36\n", + "size_largest_component 3195 3131\n", + "directed False False\n", + "weighted True True\n", + "negatively_weighted False False\n", + "edges 396020 254912\n", + "nodes 3197 3197\n", + "selfloops 0 0\n", + "density 0.077517 0.049897" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# see https://hobergphillips.tuck.dartmouth.edu/industryclass.htm\n", + "root = 'https://hobergphillips.tuck.dartmouth.edu/idata/'\n", + "tnic_data = {}\n", + "for scheme in ['tnic2', 'tnic3']:\n", + " source = root + scheme + '_data.zip'\n", + " if source.startswith('http'):\n", + " response = requests_get(source)\n", + " source = io.BytesIO(response.content)\n", + " with zipfile.ZipFile(source).open(scheme + \"_data.txt\") as f:\n", + " tnic_data[scheme] = pd.read_csv(f, sep='\\s+')\n", + "for k,v in tnic_data.items():\n", + " print(k, v.shape)\n", + "\n", + "# extract one year of both tnic schemes, merge in permno, and require in univ\n", + "year = 2019\n", + "capsize = 10 # large cap (large than NYSE median)\n", + "univ = crsp.get_universe(bd.endyr(year))\n", + "univ = univ[univ['decile'] <= capsize] \n", + "lookup = pstat.build_lookup('gvkey', 'lpermno', fillna=0)\n", + "nodes = {}\n", + "tnic = {}\n", + "edges = {}\n", + "for scheme in ['tnic2', 'tnic3']:\n", + " tnic[scheme] = tnic_data[scheme][tnic_data[scheme].year == year].dropna()\n", + " gvkeys = set(tnic[scheme]['gvkey1']).union(tnic[scheme]['gvkey2'])\n", + " df = DataFrame(index=gvkeys, data=lookup(gvkeys), columns=['permno'])\n", + " nodes[scheme] = df[df['permno'].gt(0)\n", + " & df['permno'].isin(univ.index)].drop_duplicates()\n", + "nodes['tnic2'] = nodes['tnic2'][nodes['tnic2'].index.isin(nodes['tnic3'].index)]\n", + "nodes['tnic3'] = nodes['tnic3'][nodes['tnic3'].index.isin(nodes['tnic2'].index)]\n", + "\n", + "\n", + "# create graphs of tnic2 (full graph) and tnic3 (subgraph) schemes\n", + "for scheme in ['tnic2', 'tnic3']:\n", + " e = tnic[scheme][tnic[scheme]['gvkey1'].isin(nodes[scheme].index) &\n", + " tnic[scheme]['gvkey2'].isin(nodes[scheme].index)]\n", + " edges[scheme] = list(e[['gvkey1', 'gvkey2', 'score']]\\\n", + " .itertuples(index=False, name=None))\n", + "\n", + "results = {'info':{}}\n", + "G = {}\n", + "for (scheme, node), (_, edge) in zip(nodes.items(), edges.items()):\n", + " print(scheme, 'nodes =', len(node), 'edges =', len(edge))\n", + "\n", + " # populate graph\n", + " g = nx.Graph()\n", + " g.add_nodes_from(node.index)\n", + " g.add_weighted_edges_from(edge)\n", + "\n", + " # remove self-loops: not necessary\n", + " g.remove_edges_from(nx.selfloop_edges(g))\n", + "\n", + " # graph info\n", + " results['info'].update({scheme: Series(graph_info(g, fast=True))})\n", + "\n", + " # Plot degree distribution\n", + " fig, ax = plt.subplots(clear=True, figsize=(5, 4))\n", + " degree = nx.degree_histogram(g)\n", + " degree = DataFrame(data={'degree': degree[1:]}, # exclude degree 0\n", + " index=np.arange(1, len(degree)))\n", + " degree['bin'] = (degree.index // (2*capsize) + 1) * (2*capsize)\n", + " degree.groupby('bin').sum().plot(kind='bar', ax=ax, fontsize=6)\n", + " ax.set_title(f'Degree Distribution of {scheme.upper()} links {year}')\n", + " plt.tight_layout(pad=3)\n", + " plt.savefig(imgdir / f'degree_{scheme}_{year}.jpg')\n", + "\n", + " G[scheme] = g\n", + "\n", + "show(DataFrame(results['info']), # Display graph properties\n", + " caption=f\"Graph info of TNIC schemes {year}\", **SHOW) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Predict links\n", + "- jaccard_coefficient\n", + "- resource_allocation\n", + "- adamic_adar\n", + "- preferential_attachment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "links = link_prediction(G['tnic3'])\n", + "\n", + "# Sanity check that tnic3 and prediction edges strictly in tnic2\n", + "def isin(e1, e2):\n", + " \"\"\"helper to count number of edges e1 are in e2\"\"\"\n", + " num = sum([e[:2] in e2 for e in e1])\n", + " return num, len(e1), num/len(e1)\n", + "\n", + "\n", + "records = [[src, tgt, *isin(G[src].edges, G[tgt].edges)]\n", + " for src, tgt in zip(['tnic3', 'tnic2'],\n", + " ['tnic2', 'tnic3'])]\n", + "records.extend([[src, 'tnic2', *isin(links[src], G['tnic2'].edges)]\n", + " for src in ['jaccard_coefficient',\n", + " 'resource_allocation',\n", + " 'adamic_adar',\n", + " 'preferential_attachment']])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sourcetargetsource edges in targettotal source edgesfraction
Counts of edges
0tnic3tnic22549122549121.0000
1tnic2tnic32549123960200.6437
2jaccard_coefficienttnic214110848538940.0291
3resource_allocationtnic214110848538940.0291
4adamic_adartnic214110848538940.0291
5preferential_attachmenttnic214110848538940.0291
\n", + "
" + ], + "text/plain": [ + " source target source edges in target \\\n", + "Counts of edges \n", + "0 tnic3 tnic2 254912 \n", + "1 tnic2 tnic3 254912 \n", + "2 jaccard_coefficient tnic2 141108 \n", + "3 resource_allocation tnic2 141108 \n", + "4 adamic_adar tnic2 141108 \n", + "5 preferential_attachment tnic2 141108 \n", + "\n", + " total source edges fraction \n", + "Counts of edges \n", + "0 254912 1.0000 \n", + "1 396020 0.6437 \n", + "2 4853894 0.0291 \n", + "3 4853894 0.0291 \n", + "4 4853894 0.0291 \n", + "5 4853894 0.0291 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "show(DataFrame.from_records(records,\n", + " columns=['source',\n", + " 'target',\n", + " 'source edges in target',\n", + " 'total source edges',\n", + " 'fraction']),\n", + " index=False, caption=\"Counts of edges\", **SHOW)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate accuracy of link prediction algorithms\n", + "- roc\n", + "- auc \n", + "- confusion matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATsAAAEYCAYAAAAj5FFfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAf9klEQVR4nO3deZxcZZ3v8c+3l+wLSTqBbBCQNYIg5rIKBkUJXC84rhB0xMHLoKCOC4wKFxlURsfR8eqEQVBwQUAYVFADgXHIC6MsCWjQBIEQIDshO1lIevnNH+d0Ut10d1Wnq7qW832/XufVdc55znN+VdX1q+c5zzmnFBGYmdW6unIHYGbWH5zszCwTnOzMLBOc7MwsE5zszCwTnOzMLBOc7MwsE5zsekHSYEm/krRZ0p19qOd8SfcXM7ZykHSvpA+XYb8/lPSVEtW9VdJBpai7i31dIGlef+zLajTZSZopaUH6j7s6/VC+uQhVvxfYFxgTEe/b20oi4qcR8Y4ixNOBpOmSQtIvOi0/Ol0+t8B6rpZ0S75yEXFmRPxoL8OtSBExLCKWljsOK76aS3aSPgN8G7iWJDHtD1wHnFOE6g8AnomIliLUVSovAydKGpOz7MPAM8XagRI1979TTSQ1lDuGqhMRNTMBI4GtwPt6KDOQJBmuSqdvAwPTddOBFcBngbXAauAj6bp/AnYBzek+LgSuBm7JqXsKEEBDOn8BsBR4BXgeOD9n+byc7U4C5gOb078n5aybC3wZ+H1az/1AUzfPrT3+64FL0mX1wErgKmBuTtn/DywHtgCPA6eky2d0ep4Lc+L4ahrHDuDgdNlH0/X/AdyVU//Xgd8CKuB9ex3w38B6YB3wU2CfnPVvBJ5In//PgNuBr6TrRgG/JknyG9PHkzq9fl8B/pA+n18BY9J9bElf7yk55QM4OH08GPgm8GL63swDBud5LncCa9LyDwGvz1k3Brgn3e9j6fs6L997kq67GvhP4JZ0/UfL/XmrtqnsART1ySQf1BbSZNNNmWuAR4BxwNj0Q/DldN30dPtrgEbgLGA7MCpdfzUdk1vn+Snph6UBGJr+Ux6Wrhvf/o9PTrIDRqcf0g+l252Xzo9J188FngMOTT98c4GvdfPcppMku5OAR9NlZwFzgI/SMdl9MP3wNZAk9zXAoK6eV04cy4DXp9s00jHZDSFpPV4AnEKStHKTzibgzd3EfTDwdpIvorEkSeLb6boBJMnm0+k+30uSiNuT3RjgPen+h5Mkm192insJSUIdCSxO4zw9fR4/Bm7OKZ+b7Gal208k+dI4ifSLsYf/r79L42j/Uv1TzrrbgTvS/40jSb6E5vXiPWkG3kXSI+sx6Xrq4r0pdwBFfTJwPrAmT5nngLNy5s8AXkgfTydptTTkrF8LnJA+7pAEupifQsdktyn9IA7uFMMF7El2HwIe67T+YeCC9PFc4MqcdR8H7uvmuU0HVqSPnwUOSz9g59Mp2XWx7Ubg6K6eV04c13Sx7KM588cDG0iS03l9eB/fBfwxfXwqSQtcOev/QJrsutj2GGBjpxivyJn/JnBvzvz/oWNCCpLkW5f+Lxzdh+exT1rfSJJk2QwcnrP+WnKSXQHvyUOl+uxkYaq14y7rgaY8xzMmkHwY272YLttdR3Q8JrcdGNbbQCJiG/AB4GJgtaTfSDq8gHjaY5qYM79mL+L5CXApcBrwi84rJX1O0lPpyPImkg9kU546l/e0MiIeJem2i6QFUxBJ+0q6XdJKSVtIumrtsUwAVkb6iU+9mLPtEEnfk/Riuu1DwD6S6nPKv5TzeEcX8129nk3AIJIvx0KfR72kr0l6Lo3lhZy6xpJ8Cea+hi922j7fe9Lj6289q7Vk9zCwk6Rl0J1VJAMN7fZPl+2NbSTdp3b75a6MiDkR8XaSLuxfgRsLiKc9ppV7GVO7n5C0AmdHxPbcFZJOAS4H3k/SRd+H5BiT2kPvps4e7wcm6RKS7tuqtP5CXZvWfVREjCDpzrXHshqYKEk55ffPefxZkhbs8em2p7aH04v9d2Ud8CpJ97dQM0kGwk4nSVRTcmJ5meQQyeSc8rufRwHvCeR5/a1nNZXsImIzyYH4WZLelX7rN0o6U9K/pMVuA66UNFZSU1o+72kW3fgTcKqk/SWNBL7QviJtrZwjaShJAt4KtHVRx2zg0PR0mQZJHwCmkhxo32sR8TzwFuCKLlYPJ/ngvQw0SLoKGJGz/iVgSm9GXCUdSjIQ8EGSrvnlko4pcPPhJK/PZkkTgcty1j2cxvrJ9L18N3Bcp213AJskjQa+VGjMPYmINuAm4FuSJqStthMlDczzPHaS9DCGkCTx9vpagZ8DV6f/l1NJRslzt+3pPbE+qqlkBxAR3wQ+A1xJ8o+znKQ798u0yFeABcCTwJ9JRvn26gTViHiAZHTwSZLRs9wEVZfGsYrkONZbgI91Ucd64J0kLZT1JN/u74yIdXsTU6e650VEV63WOcB9JAfqXyRpweR2kdpPmF4v6Yl8+0kPG9wCfD0iFkbEs8AXgZ+0J4f0nMdTuqnin4BjSVoyvyFJCu3PYRfwbpLjnBtIDg38PGfbb5MM3KwjGXi6L1+8vfA5kv+R+em+v07Pn5kfk7yeK0kGQh7ptP5Ski7zGuCHwM056/K9J9ZH6ngoxMysNtVcy87MrCtOdma9kF7XvLWLaVG5Y7OeuRtrZplQUdfXNY2ujymTG8sdhvXSorVjyx2C9VLz5g20bN/W19NzdjvjtKGxfkNrQWUff3LnnIiYUax9F6qikt2UyY08Nmdy/oJWUY78zsfLHYL10vM3f6uo9a3b0MqjcyYVVLZx/HP5Tl4viYpKdmZWrYLW6Oo00srhZGdmfRZAW4Vf4OFkZ2ZF0dblBUKVw8nOzPosCFor/MwOJzsz67MAmt2yM7Ms8DE7M6t5Ae7Gmlk2VHYn1snOzIogCFrdjTWzmhfQWtm5zsnOzPouEM19vhN+aTnZmVmfBdDmlp2ZZUGrW3ZmVusCJzszy4i2cLIzsxrnlp2ZZUIgmqO+3GH0yMnOzPrMLTszywjRGpX9Y4VOdmbWZ8mdip3szCwD3I01s5oX4W6smWVAcqdij8aaWc1zy87MMsADFGaWGa2+XMzMal0gWt2yM7MsaPMxOzOrdW2IXb421syywAMUZlbzIvCpJ2aWBaLNl4uZWa0L3LIzs4zwqSdmVvN8p2Izy4Tkd2PdsjOzmqeKv59dZadiM6sK7S27QqZCSJoh6WlJSyR9vov1+0t6UNIfJT0p6ax8dTrZmVlRtKatu3xTPpLqgVnAmcBU4DxJUzsVuxK4IyLeCJwLXJevXndjzazPIlTMY3bHAUsiYimApNuBc4DFubsERqSPRwKr8lXqZGdmfRZQzNHYicDynPkVwPGdylwN3C/pE8BQ4PR8lboba2ZFkNypuJAJaJK0IGe6aC92eB7ww4iYBJwF/ERSj/nMLTsz67NkgKLg0dh1ETGth/Urgck585PSZbkuBGYARMTDkgYBTcDa7ip1y87MiqKVuoKmAswHDpF0oKQBJAMQ93Qqswx4G4CkI4BBwMs9VeqWnZn1WaDetOx6riuiRdKlwBygHrgpIhZJugZYEBH3AJ8FbpT0aZKG5QURET3V62RnZkVRzPvZRcRsYHanZVflPF4MnNybOp3szKzPIqC5rbKPijnZmVmfJd1YJzszywBfG1vj5j84nAvffDgXnHQEP/vuuNesf2lFI//4/tdx8dsO47L3HMzLqxp3r/v+V8Zz0WmHcdFphzH37n36MWrLdfIBy/jVh25l9t/+lAvf9ES35U5/3XP85ZP/wevHdXt2Q2a1n3pSyFQuJU12+S7mrXatrTDri5P4yk+XcuPcv/Lg3aN48ZmBHcrceM1ETn/vBq7/7dOc/+k13PzP4wF49L9GsOTPQ/iPB57mO795lruuH8e2V/zd09/q1MaV03/Hx+5+J2ffci5nHbqEg0ZveE25IY27+OAxf2bhmtd+oRmQdmOLdSOAUijZngu8mLeqPf3HIUyYspPxB+yicUAw/ZyNPDxnZIcyLz4zkKNP3grA0Sdv3b1+2TMDOeqErdQ3wKAhbRx4xA4WPDjiNfuw0jpq37Us2zSSFVtG0NJWz73PHsxbD3rhNeU+ccJj3PT4G9nV4iM/3WlLf4ci31QupUyzuy/mjYhdQPvFvDVj/ZpGxk5o3j3fNL6ZdasbO5Q5aOqr/P7eJMH9/t6RbN9az5YN9Rw09VUWPDicV7eLzevrWfiHYR26uNY/xg3bxpqtQ3fPv7R1KOOGbutQ5oixL7Pf8K089MIB/R1e1UhGY+sLmsqllF9ThVzMS3pd3EUA+0+svW/Ni65ayawrJvHAz0Zz1AnbaBq/i7p6eNP0V3h64RA+ffahjBzTwhFv2kZdZd/VOpNEcPkpf+CKB04rdygVrZgnFZdK2bNLRNwA3AAw7ehBPZ4BXWnG7NfcoTW2bnUjTeObO5Vp4aofvADAjm11zJs9kmEjWwGY+amXmPmplwD4548fwKSDXu2fwG23tVuHst+wPS25fYdtY+22PS29oQN2cfCYDdz8nuRqpaYh2/nuO+/lE78+k0VrffwuV5Z/SrGQi3mr2mHHbGfl8wNZs2wAY/ZrZu7do/j8rBc7lNm8vp7ho1qpq4PbvzuOd3wgOfjd2grbNtczYnQrSxcP4vmnBvGmt7xSjqeRaX95aRz777OJiSO28NLWoZx5yBIun7PnbkFbdw3klBs/snv+5nffzb/OO9GJrpNe3gigLEqZ7HZfzEuS5M4FZpZwf/2uvgEu+eoKvjjzINpaxTvO3cCUw17lR/+yH4cevZ0Tz9jCkw8P46Z/noAUHHX8Ni65dgUArc3is39zCABDhrfyj99dRn3Z29nZ0xp1XDv3FL53zq+prwt+sehwntswmkuOf4xFa8cy9/kDyx1i1aj0k4qV59rZvlWe3Bf+2+y5mPerPZWfdvSgeGzO5J6KWAU68jsfL3cI1kvP3/wtdqxeXrSm2OjDx8XbbnpPQWX/8+TrH89zi6eSKGlboquLec2s9gTQUuEtO3eczKzPsn7MzswyxMnOzGqez7Mzs8zI8nl2ZpYV4W6smWVAAC2+U7GZ1TofszOzzAgnOzPLAg9QmFnNCw9QmFlWuBtrZhkgWj0aa2a1ztfGmlk2RHLcrpI52ZlZUXg01sxqXuABCjPLBF9BYWYZ0dbmZGdmNS7C3Vgzywh3Y80sE3zqiZllgruxZlbzAlV8sqvsi9nMrDqkdz0pZCqEpBmSnpa0RNLnuynzfkmLJS2SdGu+Ot2yM7PiKNIxO0n1wCzg7cAKYL6keyJicU6ZQ4AvACdHxEZJ4/LV65admRVFhAqaCnAcsCQilkbELuB24JxOZf4vMCsiNib7jrX5KnWyM7OiiChsKsBEYHnO/Ip0Wa5DgUMl/V7SI5Jm5Ku0226spO/SQ8M0Ij6Zr3Izy4ZeXhvbJGlBzvwNEXFDL3fZABwCTAcmAQ9JOioiNvW0QXcW9LDOzGyPAApPdusiYloP61cCk3PmJ6XLcq0AHo2IZuB5Sc+QJL/53VXabbKLiB/lzksaEhHbewjQzDIs2opW1XzgEEkHkiS5c4GZncr8EjgPuFlSE0m3dmlPleY9ZifpREmLgb+m80dLuq7X4ZtZDStscKKQrm5EtACXAnOAp4A7ImKRpGsknZ0WmwOsT3PTg8BlEbG+p3oLOfXk28AZwD1pIAslnVrAdmaWJUW8XCwiZgOzOy27KudxAJ9Jp4IUdJ5dRCyXOmTk1kJ3YGYZUCN3PVku6SQgJDUCnyJpWpqZ7VHhNwIo5Dy7i4FLSM5zWQUck86bmeVQgVN55G3ZRcQ64Px+iMXMqlnxRmNLopDR2IMk/UrSy5LWSrpb0kH9EZyZVYn28+wKmcqkkG7srcAdwHhgAnAncFspgzKz6lPEy8VKopBkNyQifhIRLel0CzCo1IGZWZWJAqcy6ena2NHpw3vT+0ndThLqB+h0/ouZWTm7qIXoaYDicZLk1v4M/j5nXZDcS8rMDABV+KknPV0be2B/BmJmVSwEtfC7sZKOBKaSc6wuIn5cqqDMrApVa8uunaQvkdwzairJsbozgXmAk52Z7VHhya6Q0dj3Am8D1kTER4CjgZEljcrMqk+1jsbm2BERbZJaJI0A1tLxxnpmlnW9u3lnWRSS7BZI2ge4kWSEdivwcCmDMrPqU7Wjse0i4uPpw+sl3QeMiIgnSxuWmVWdak12ko7taV1EPFGakMysGlVzy+6bPawL4K1FjoVnnhzCGROOKXa1VmKv3uqfJqk2bYNLcIuSaj1mFxGn9WcgZlbFyjzSWoiCTio2M8vLyc7MsqCaj9mZmRWuBu5ULEkflHRVOr+/pONKH5qZVQtF4VO5FHK52HXAiSS/vg3wCjCrZBGZWXWq8NuyF9KNPT4ijpX0R4CI2ChpQInjMrNqUwPH7Jol1ZM+FUljqfjeuZn1t0ofoCikG/sd4BfAOElfJbm907UljcrMqk+13/UkIn4q6XGS2zwJeFdEPFXyyMysegSowvt7hdy8c39gO/Cr3GURsayUgZlZlanwbmwhx+x+w54f3hkEHAg8Dby+hHGZWZWp9GN2hXRjj8qdT++G8vFuipuZVaReX0EREU9IOr4UwZhZFav2lp2kz+TM1gHHAqtKFpGZVZ8yXx1RiEJadsNzHreQHMO7qzThmFnVqubR2PRk4uER8bl+isfMqpCo4padpIaIaJF0cn8GZGZVqsKTXU9XUDyW/v2TpHskfUjSu9un/gjOzKpEke96ImmGpKclLZH0+R7KvUdSSJqWr85CjtkNAtaT/OZE+/l2Afy8sLDNLBOK1LJLD5/NAt4OrADmS7onIhZ3Kjcc+BTwaCH19pTsxqUjsX9hT5JrV+ENVjPrd8XLCscBSyJiKYCk24FzgMWdyn0Z+DpwWSGV9tSNrQeGpdPwnMftk5nZbmorbCrARGB5zvyKdNmefSUXN0yOiN8UGl9PLbvVEXFNoRWZWYb17o4mTZIW5MzfEBE3FLqxpDrgW8AFBe+RnpNdZf8IpJlVlF6cerIuInoaUFgJTM6Zn5QuazccOBKYKwlgP+AeSWdHRG4S7aCnZPe2vCGbmbUr3jG7+cAhkg4kSXLnAjN37yZiM9DUPi9pLvC5nhId9HDMLiI29DFgM8uQYp16EhEtwKXAHOAp4I6IWCTpGkln7218/ilFMyuOIp6jERGzgdmdll3VTdnphdTpZGdmfVbun0kshJOdmRWHk52ZZYFbdmaWDU52ZpYJTnZmVvM8QGFmWVH1vxtrZlYQt+zMLAvcjTWz2te7u56UhZOdmRWHk52Z1bqq/nUxM7PeUFtlZzsnOzPrOx+zM7OscDfWzLLByc7MssAtOzPLBic7M6t54WtjzSwDfJ6dmWVHVHa2c7Izs6Jwy87Map9PKq5N06Zv4eIvr6K+Lrj3ttHc8e/7dljfOKCNy76zjEOO2sGWjQ1ce/EBvLRiAMNHtfD/bniBQ4/ZwQN3jGLWFZMAGDi4jSu+9wITpuyirRUeeWAEN107oRxPLZMGL9xC049XorZgy2lj2HT2vq8pM/SRjYy+aw0gdh4wiLWXTun3OCtdZgcoJN0EvBNYGxFHlmo//a2uLrjk2pV84dyDWLe6ke/OfpZH5oxk2bODdpc547wNbN3UwEdOPoK3nLORC69cxbUXT2HXq+JH39iPKYe9ypTDX+1Q713Xj2PhH4bR0NjG1+9YyrTTtrDgwRH9/fSypy0Ye/MKVn3hdbSMaWTSlc+w7diRNE/a8342rt7JqLvXsvJLh9A2rIH6zc1lDLhyVXqyqyth3T8EZpSw/rI47I3bWfXCANYsG0hLcx1z796HE8/Y3KHMiWds5oE7RwHwu1/vwzFv3goEO3fUs+ixYeza2fFl37mjjoV/GAZAS3Mdz/55MGPH+wPVHwYu2U7zvgNp2XcgNNSx9cRRDH284/s5/MH1bH5HE23DkrZB68jGcoRa2YJkgKKQqUxKluwi4iFgQ6nqL5cx+zXz8qoBu+fXrW6kqVNiatqvhZdXJR+ItlaxbUs9I0a3FlT/0BGtnPD2Lfxx3rDiBW3datjYTMuYPcmrZXQjDRs6vp8DVr9K4+qdTLj6WSZe9QyDF27p7zCrgqKwqVxK2bIriKSLJC2QtKCZneUOp6zq6oMvXPcid/+giTXLBpY7HGvXBo1rdrLqyoN56dIDGHfjcuq2tZQ7qsoTBU5lUvZkFxE3RMS0iJjWSOV/wNevaWTshF2755vGN7Nudcduzbo1DYydkLQO6uqDoSNa2bKhPm/d//CN5ax8fiC/+P7Y4gZt3WoZ1UjD+j0tuYYNzbSM7vh+toxuZPuxI6BBtIwbyK7xA2lcs6tzVZnWflKxW3Y15Ok/DWHigbvYd/JOGhrbmH7OJh65f2SHMo/cP5K3v28jAKe8cxML5w0j+Xfo3ocvX83Q4W1cf5VHYfvTztcNoXHNThrW7oSWNoY9vJFtb+o4MLRt2kgGP7UVgLotLQxYvZPmcQO6qi67Cj1eV8Zjdj71pJfaWsWsKyZy7a1LqauH+28fzYvPDOJvL1vDMwsH88j9I7nvttFc/p1l3Pz7p3hlUz3XfuyA3dv/6NHFDB3WRsOA4MQztvDF8w5i+9Y6Zv7DWpY9O5BZ9z8DwD03N3HfrWPK9TSzo16su2AS47+2NDn1ZPpomicNZtSdq9l50BC2v2kkO94wnCFPvsLky54i6sT6mRNoG+6PTmeVPhqrKFGmlXQbMB1oAl4CvhQRP+hpmxEaHcfrbSWJx0rnuVuPKXcI1ksrv3gdO5eu7Lm70QvD95kUx57yqYLKPvTryx+PiGnF2nehSvb1FBHnlapuM6swAfg3KMwsEyo71znZmVlx+EYAZpYNFX6LJ596YmZ9l96puJCpEJJmSHpa0hJJn+9i/WckLZb0pKTfSjqgq3pyOdmZWZ8lJxVHQVPeuqR6YBZwJjAVOE/S1E7F/ghMi4g3AP8J/Eu+ep3szKw42gqc8jsOWBIRSyNiF3A7cE5ugYh4MCK2p7OPAJPyVepkZ2ZFUayWHTARWJ4zvyJd1p0LgXvzVeoBCjPru95d5N8kaUHO/A0RccPe7FbSB4FpwFvylXWyM7Mi6NV1r+vyXEGxEpicMz8pXdaBpNOBK4C3RETeWyY52ZlZUah4V1DMBw6RdCBJkjsXmNlhX9Ibge8BMyJibSGVOtmZWd8V8UeyI6JF0qXAHKAeuCkiFkm6BlgQEfcA3wCGAXdKAlgWEWf3VK+TnZkVRxFPKo6I2cDsTsuuynl8em/rdLIzs+Ko7AsonOzMrDgKPK2kbJzszKw4nOzMrNYpArU62ZlZFrhlZ2aZ4GRnZjUvKPQi/7JxsjOzovBorJllg5OdmdW8CGir7H6sk52ZFUdl5zonOzMrDh+zM7NscLIzs5oXQPHuZ1cSTnZmVgS9ulNxWTjZmVlxeDTWzGqeu7Fmlg0B4ZadmWWBj9mZWc1zN9bMMsMtOzOrfb421syyIHCyM7OMcDfWzDLByc7Mal94NNbMMiAgfFKxmWVCq5OdmdU635bdzDLDAxRmlgXhlp2Z1T7fvNPMssA3AjCzLAggWlvLHUaPnOzMrO/CN+80s4wId2PNLBMqvGWnqKARFEkvAy+WO44SaALWlTsI67Vaft8OiIixxapM0n0kr1ch1kXEjGLtu1AVlexqlaQFETGt3HFY7/h9qy115Q7AzKw/ONmZWSY42fWPG8odgO0Vv281xMfszCwT3LIzs0xwsjOzTHCyKzFJMyQ9LWmJpM+XOx7LT9JNktZK+ku5Y7HicbIrIUn1wCzgTGAqcJ6kqeWNygrwQ6DfT3q10nKyK63jgCURsTQidgG3A+eUOSbLIyIeAjaUOw4rLie70poILM+ZX5EuM7N+5mRnZpngZFdaK4HJOfOT0mVm1s+c7EprPnCIpAMlDQDOBe4pc0xmmeRkV0IR0QJcCswBngLuiIhF5Y3K8pF0G/AwcJikFZIuLHdM1ne+XMzMMsEtOzPLBCc7M8sEJzszywQnOzPLBCc7M8sEJ7sqI6lV0p8k/UXSnZKG9KGuH0p6b/r4+z3dpEDSdEkn7cU+XpD0ml+d6m55pzJbe7mvqyV9rrcxWjY42VWfHRFxTEQcCewCLs5dKWmvfgs4Ij4aEYt7KDId6HWyM6sUTnbV7XfAwWmr63eS7gEWS6qX9A1J8yU9KenvAZT49/T+ev8FjGuvSNJcSdPSxzMkPSFpoaTfSppCklQ/nbYqT5E0VtJd6T7mSzo53XaMpPslLZL0fUD5noSkX0p6PN3mok7r/i1d/ltJY9Nlr5N0X7rN7yQdXpRX02raXrUCrPzSFtyZwH3pomOBIyPi+TRhbI6I/yVpIPB7SfcDbwQOI7m33r7AYuCmTvWOBW4ETk3rGh0RGyRdD2yNiH9Ny90K/FtEzJO0P8lVIkcAXwLmRcQ1kv43UMjVB3+X7mMwMF/SXRGxHhgKLIiIT0u6Kq37UpIfwrk4Ip6VdDxwHfDWvXgZLUOc7KrPYEl/Sh//DvgBSffysYh4Pl3+DuAN7cfjgJHAIcCpwG0R0QqskvTfXdR/AvBQe10R0d193U4Hpkq7G24jJA1L9/HudNvfSNpYwHP6pKS/SR9PTmNdD7QBP0uX3wL8PN3HScCdOfseWMA+LOOc7KrPjog4JndB+qHflrsI+EREzOlU7qwixlEHnBARr3YRS8EkTSdJnCdGxHZJc4FB3RSPdL+bOr8GZvn4mF1tmgN8TFIjgKRDJQ0FHgI+kB7TGw+c1sW2jwCnSjow3XZ0uvwVYHhOufuBT7TPSDomffgQMDNddiYwKk+sI4GNaaI7nKRl2a4OaG+dziTpHm8Bnpf0vnQfknR0nn2YOdnVqO+THI97Iv3RmO+RtOJ/ATybrvsxyZ09OoiIl4GLSLqMC9nTjfwV8DftAxTAJ4Fp6QDIYvaMCv8TSbJcRNKdXZYn1vuABklPAV8jSbbttgHHpc/hrcA16fLzgQvT+BbhW91bAXzXEzPLBLfszCwTnOzMLBOc7MwsE5zszCwTnOzMLBOc7MwsE5zszCwT/gcMA1NcIy/7UwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def make_sample(prediction, edges):\n", + " \"\"\"helper to transform prediction to labels and scores for roc and auc\"\"\"\n", + " scores = [e[-1] for e in prediction]\n", + " label = [e[:2] for e in prediction]\n", + " gold = [e[:2] in edges for e in prediction]\n", + " return gold, scores, label # actual, predicted score, predicted label\n", + "\n", + "\n", + "for ifig, (method, pred) in enumerate(links.items()):\n", + " y, scores, label = make_sample(pred, G['tnic2'].edges)\n", + " fpr, tpr, thresholds = metrics.roc_curve(y, scores)\n", + " roc_auc = metrics.auc(fpr, tpr)\n", + " plt.figure(clear=True, figsize=(6.5, 5))\n", + " plt.plot(fpr,\n", + " tpr,\n", + " color=\"darkorange\",\n", + " lw=2,\n", + " label=\"ROC curve (area = %0.2f)\" % roc_auc)\n", + " plt.plot([0, 1], [0, 1], color=\"navy\", lw=2, linestyle=\"--\")\n", + " plt.xlim([0.0, 1.0])\n", + " plt.ylim([0.0, 1.05])\n", + " plt.xlabel(\"False Positive Rate\")\n", + " plt.ylabel(\"True Positive Rate\")\n", + " plt.title(f\"Receiver operating characteristic: {method}\")\n", + " plt.legend(loc=\"lower right\")\n", + " plt.tight_layout()\n", + " plt.savefig(imgdir / f'{method}_auc.jpg')\n", + "\n", + " thresh = scores[sum(y)] # set threshold to equal class size\n", + " cm = metrics.confusion_matrix(y, [score > thresh for score in scores],\n", + " normalize='pred')\n", + " disp = metrics.ConfusionMatrixDisplay(confusion_matrix=cm)\n", + " disp.plot()\n", + " plt.title(f\"Confusion Matrix: {method}\")\n", + " plt.tight_layout()\n", + " plt.savefig(imgdir / f'{method}_confusion.jpg')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/stock_prices.ipynb b/stock_prices.ipynb new file mode 100644 index 0000000..684cdc4 --- /dev/null +++ b/stock_prices.ipynb @@ -0,0 +1,1294 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stock prices, dividends, split-adjustments and identifiers\n", + "\n", + "Copyright 2023, Terence Lim\n", + "\n", + "MIT License" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datecomnamncusipshrclstickerpermnonameendtshrcdexchcdsiccdtsymbolnaicsprimexchtrdstatsecstatpermco
019821101APPLE COMPUTER INC03783310AAPL14593200406091133573AAPL0QAR7
120040610APPLE COMPUTER INC03783310AAPL14593200701101133573AAPL334111QAR7
220070111APPLE INC03783310AAPL14593201712271133571AAPL334111QAR7
320171228APPLE INC03783310AAPL14593202203311133571AAPL334220QAR7
\n", + "
" + ], + "text/plain": [ + " date comnam ncusip shrcls ticker permno nameendt \\\n", + "0 19821101 APPLE COMPUTER INC 03783310 AAPL 14593 20040609 \n", + "1 20040610 APPLE COMPUTER INC 03783310 AAPL 14593 20070110 \n", + "2 20070111 APPLE INC 03783310 AAPL 14593 20171227 \n", + "3 20171228 APPLE INC 03783310 AAPL 14593 20220331 \n", + "\n", + " shrcd exchcd siccd tsymbol naics primexch trdstat secstat permco \n", + "0 11 3 3573 AAPL 0 Q A R 7 \n", + "1 11 3 3573 AAPL 334111 Q A R 7 \n", + "2 11 3 3571 AAPL 334111 Q A R 7 \n", + "3 11 3 3571 AAPL 334220 Q A R 7 " + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import DataFrame, Series\n", + "import matplotlib.pyplot as plt\n", + "from finds.database import SQL, Redis\n", + "from finds.busday import BusDay\n", + "from finds.structured import CRSP, Finder\n", + "from finds.recipes import fractiles\n", + "from finds.display import show, plot_date\n", + "from yahoo import get_price\n", + "from conf import credentials, VERBOSE, paths\n", + "\n", + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(latex=None, ndigits=4)\n", + "\n", + "sql = SQL(**credentials['sql'], verbose=VERBOSE)\n", + "rdb = Redis(**credentials['redis'])\n", + "bd = BusDay(sql, verbose=VERBOSE)\n", + "crsp = CRSP(sql, bd, rdb=rdb, verbose=VERBOSE)\n", + "imgdir = paths['images']\n", + "find = Finder(sql) # to search identifier lookup tables\n", + "ticker = 'AAPL'\n", + "find(ticker)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Show dividend and split adjustments for AAPL" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cookies True crumb None\n", + "https://finance.yahoo.com/quote/^GSPC\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
openhighlowcloseadjClosevolumeretx
AAPL
198012150.120.120.120.120.09175884800.0NaN
198012160.110.110.110.110.09105728000.00.916667
198012170.120.120.120.120.0986441600.01.090909
198012180.120.120.120.120.0973449600.01.000000
198012190.130.130.130.130.1048630400.01.083333
........................
20221223130.92132.42129.64131.86131.8663814900.00.997202
20221227131.38131.41128.72130.03130.0369007800.00.986122
20221228129.67131.03125.87126.04126.0485438400.00.969315
20221229127.99130.48127.73129.61129.6175703700.01.028324
20221230128.41129.95127.43129.93129.9376960600.01.002469
\n", + "

10602 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " open high low close adjClose volume retx\n", + "AAPL \n", + "19801215 0.12 0.12 0.12 0.12 0.09 175884800.0 NaN\n", + "19801216 0.11 0.11 0.11 0.11 0.09 105728000.0 0.916667\n", + "19801217 0.12 0.12 0.12 0.12 0.09 86441600.0 1.090909\n", + "19801218 0.12 0.12 0.12 0.12 0.09 73449600.0 1.000000\n", + "19801219 0.13 0.13 0.13 0.13 0.10 48630400.0 1.083333\n", + "... ... ... ... ... ... ... ...\n", + "20221223 130.92 132.42 129.64 131.86 131.86 63814900.0 0.997202\n", + "20221227 131.38 131.41 128.72 130.03 130.03 69007800.0 0.986122\n", + "20221228 129.67 131.03 125.87 126.04 126.04 85438400.0 0.969315\n", + "20221229 127.99 130.48 127.73 129.61 129.61 75703700.0 1.028324\n", + "20221230 128.41 129.95 127.43 129.93 129.93 76960600.0 1.002469\n", + "\n", + "[10602 rows x 7 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Retrieve price history from yahoo finance back to 1980\n", + "yahoo_df = get_price(ticker, start_date='19800101', verbose=VERBOSE)\n", + "yahoo_df.rename_axis(ticker)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Get price and distributions history from CRSP" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
permnobidloaskhiprcvolretretxbidaskshroutopenprc
date
198012121459328.75028.875-28.8125NaNNaNNaNNaNNaN55136NaN
198012151459327.25027.375-27.3125NaN-0.052061-0.052061NaNNaN55136NaN
198012161459325.25025.375-25.3125NaN-0.073227-0.073227NaNNaN55136NaN
198012171459325.87526.000-25.9375NaN0.0246910.024691NaNNaN55136NaN
198012181459326.62526.750-26.6875NaN0.0289160.028916NaNNaN55136NaN
....................................
2022122314593129.640132.420131.860063771000.0-0.002798-0.002798NaNNaN16319441130.92
2022122714593128.720131.410130.030069007800.0-0.013878-0.013878NaNNaN16319441131.38
2022122814593125.870131.030126.040085438400.0-0.030685-0.030685NaNNaN16319441129.67
2022122914593127.730130.480129.610075703700.00.0283240.028324NaNNaN16319441127.99
2022123014593127.430129.950129.930076960600.00.0024690.002469NaNNaN16319441128.41
\n", + "

10604 rows × 11 columns

\n", + "
" + ], + "text/plain": [ + " permno bidlo askhi prc vol ret retx \\\n", + "date \n", + "19801212 14593 28.750 28.875 -28.8125 NaN NaN NaN \n", + "19801215 14593 27.250 27.375 -27.3125 NaN -0.052061 -0.052061 \n", + "19801216 14593 25.250 25.375 -25.3125 NaN -0.073227 -0.073227 \n", + "19801217 14593 25.875 26.000 -25.9375 NaN 0.024691 0.024691 \n", + "19801218 14593 26.625 26.750 -26.6875 NaN 0.028916 0.028916 \n", + "... ... ... ... ... ... ... ... \n", + "20221223 14593 129.640 132.420 131.8600 63771000.0 -0.002798 -0.002798 \n", + "20221227 14593 128.720 131.410 130.0300 69007800.0 -0.013878 -0.013878 \n", + "20221228 14593 125.870 131.030 126.0400 85438400.0 -0.030685 -0.030685 \n", + "20221229 14593 127.730 130.480 129.6100 75703700.0 0.028324 0.028324 \n", + "20221230 14593 127.430 129.950 129.9300 76960600.0 0.002469 0.002469 \n", + "\n", + " bid ask shrout openprc \n", + "date \n", + "19801212 NaN NaN 55136 NaN \n", + "19801215 NaN NaN 55136 NaN \n", + "19801216 NaN NaN 55136 NaN \n", + "19801217 NaN NaN 55136 NaN \n", + "19801218 NaN NaN 55136 NaN \n", + "... ... ... ... ... \n", + "20221223 NaN NaN 16319441 130.92 \n", + "20221227 NaN NaN 16319441 131.38 \n", + "20221228 NaN NaN 16319441 129.67 \n", + "20221229 NaN NaN 16319441 127.99 \n", + "20221230 NaN NaN 16319441 128.41 \n", + "\n", + "[10604 rows x 11 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "found = find(ticker) # locate names records by ticker\n", + "where = f\" where permno = {found['permno'].iloc[-1]}\"\n", + "dist = sql.read_dataframe(f\"select * from {crsp['dist'].key} {where}\")\n", + "crsp_df = sql.read_dataframe(f\"select * from {crsp['daily'].key} {where}\")\\\n", + " .set_index('date', inplace=False)\n", + "crsp_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Merge yahoo and CRSP" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "df = yahoo_df[['close', 'adjClose']]\\\n", + " .join(crsp_df[['prc', 'ret', 'retx', 'vol']]\\\n", + " .join(dist[dist['facpr'] != 0.0].set_index('exdt')['facpr'])\\\n", + " .join(dist[dist['divamt'] != 0.0].set_index('exdt')['divamt']),\n", + " how='inner')\\\n", + " .drop(columns=['vol'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Select distribution dates where divamt and facpr are not NA" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "dist_dates = df.index[:1].append(df.index[~df['divamt'].isna()\n", + " | ~df['facpr'].isna()])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Display cumulative adjustments" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AAPL: 19801215-20221230\n", + "Cumulative dividend yield 0.2826\n", + "Cumulative stock split-adjustment 224.0\n", + "Cumulative total stock return multiple 1298.5\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"{ticker}: {min(df.index)}-{max(df.index)}\")\n", + "print('Cumulative dividend yield',\n", + " ((1+(df['divamt']\\\n", + " .fillna(0)\\\n", + " .div(df['prc'].add(df['divamt'].fillna(0))))).prod() - 1).round(4))\n", + "print('Cumulative stock split-adjustment',\n", + "(df['facpr'].fillna(0) + 1).prod())\n", + "print('Cumulative total stock return multiple',\n", + " ((df['ret'].fillna(0) + 1).prod()).round(1))\n", + "\n", + "fig, ax = plt.subplots(num=1, clear=True, figsize=(10, 5))\n", + "plot_date(np.log10((df[['ret']].fillna(0) + 1).cumprod()\n", + " .join((df[['facpr']].fillna(0)+1).cumprod())),\n", + " (1+(df['divamt'].fillna(0)\\\n", + " .div(df['prc'].abs().add(df['divamt'].fillna(0))))).cumprod()-1,\n", + " legend1=['log10 total return', 'log10 cumulative split-adjustment'],\n", + " legend2=['compounded dividend return'],\n", + " loc2='lower right',\n", + " fontsize=10,\n", + " ax=ax,\n", + " title=ticker + ': total returns, dividends and stock splits')\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / 'splits.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reconcile CRSP and YAHOO adjustments\n", + "\n", + "CRSP \n", + "- prc: market closing price (negative if closing midquote)\n", + "- ret: total daily holding return\n", + "- retx: daily capital appreciation return\n", + "- facpr: factor to split-adjust price prior to ex-date\n", + "- divamt: dividend amount on ex-date\n", + "\n", + "YAHOO\n", + "- close: split-adjusted price\n", + "- adjClose: split-adjust price, capital appreciation only (exclude dividend)\n", + "\n", + "reconcile Yahoo and CRSP\n", + "- price: CRSP price adjusted by cumulative split factor\n", + "- adjprice: CRSP split-adjusted price excluding dividends" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Cumulate factor to adjust pre-split prices prior to ex-date\n", + "facpr = (1+df['facpr'].shift(-1)).sort_index(ascending=False)\\\n", + " .cumprod()\\\n", + " .fillna(method='ffill').fillna(1)\n", + "\n", + "# Split-adjust CRSP market price by cumulative factor\n", + "df['price'] = df['prc'].abs().div(facpr)\n", + " \n", + "# Reduce CRSP split-adjusted price by dividend income\n", + "adjret = (1+df['retx']).cumprod().div(((1+df['ret'])).cumprod())\n", + "df['adjprice'] = df['price'].div(adjret) * adjret.iloc[-1] " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
closeadjCloseprcretretxfacprdivamtpriceadjprice
AAPL
198012150.120.09-27.3125-0.0521-0.0521NaNNaN0.12190.0948
198705110.340.2777.0000-0.0238-0.0253NaN0.120.34380.2678
198706160.370.2941.50000.05730.05731.0NaN0.37050.2887
198708100.430.3448.25000.03890.0376NaN0.060.43080.3361
198711170.310.2435.0000-0.0454-0.0476NaN0.080.31250.2443
\n", + "
" + ], + "text/plain": [ + " close adjClose prc ret retx facpr divamt price \\\n", + "AAPL \n", + "19801215 0.12 0.09 -27.3125 -0.0521 -0.0521 NaN NaN 0.1219 \n", + "19870511 0.34 0.27 77.0000 -0.0238 -0.0253 NaN 0.12 0.3438 \n", + "19870616 0.37 0.29 41.5000 0.0573 0.0573 1.0 NaN 0.3705 \n", + "19870810 0.43 0.34 48.2500 0.0389 0.0376 NaN 0.06 0.4308 \n", + "19871117 0.31 0.24 35.0000 -0.0454 -0.0476 NaN 0.08 0.3125 \n", + "\n", + " adjprice \n", + "AAPL \n", + "19801215 0.0948 \n", + "19870511 0.2678 \n", + "19870616 0.2887 \n", + "19870810 0.3361 \n", + "19871117 0.2443 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# display first five distribution events\n", + "show(df.loc[dist_dates].head(5), caption=ticker, **SHOW)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
closeadjCloseprcretretxfacprdivamtpriceadjprice
199511210.340.2938.6250.00310.0000NaN0.120.34490.2939
200006210.990.8555.6250.09880.09881.0NaN0.99330.8466
200502281.601.3744.8600.00820.00821.0NaN1.60211.3655
2012080922.1718.98620.7300.00570.0014NaN2.6522.168918.9754
2012110719.9317.14558.002-0.0381-0.0426NaN2.6519.928617.1388
\n", + "
" + ], + "text/plain": [ + " close adjClose prc ret retx facpr divamt price \\\n", + "19951121 0.34 0.29 38.625 0.0031 0.0000 NaN 0.12 0.3449 \n", + "20000621 0.99 0.85 55.625 0.0988 0.0988 1.0 NaN 0.9933 \n", + "20050228 1.60 1.37 44.860 0.0082 0.0082 1.0 NaN 1.6021 \n", + "20120809 22.17 18.98 620.730 0.0057 0.0014 NaN 2.65 22.1689 \n", + "20121107 19.93 17.14 558.002 -0.0381 -0.0426 NaN 2.65 19.9286 \n", + "\n", + " adjprice \n", + "19951121 0.2939 \n", + "20000621 0.8466 \n", + "20050228 1.3655 \n", + "20120809 18.9754 \n", + "20121107 17.1388 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# display 1995-2013 distribution events\n", + "show(df.loc[dist_dates[(dist_dates>19950816) & (dist_dates<20130207)]], **SHOW)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
closeadjCloseprcretretxfacprdivamtpriceadjprice
20200807111.11109.61444.45-0.0227-0.0245NaN0.820111.1125109.6045
20200831129.04127.29129.040.03390.03393.0NaN129.0400127.2887
20201106118.69117.28118.69-0.0011-0.0029NaN0.205118.6900117.2813
20210205136.76135.34136.76-0.0031-0.0046NaN0.205136.7600135.3396
20210507130.21129.08130.210.00530.0036NaN0.220130.2100129.0752
20210806146.14145.08146.14-0.0048-0.0063NaN0.220146.1400145.0845
20211105151.28150.41151.280.00360.0021NaN0.220151.2800150.4057
20220506157.28156.80157.280.00470.0033NaN0.230157.2800156.8000
20220805165.35165.08165.35-0.0014-0.0028NaN0.230165.3500165.0748
20221104138.38138.38138.38-0.0019-0.0036NaN0.230138.3800138.3800
\n", + "
" + ], + "text/plain": [ + " close adjClose prc ret retx facpr divamt price \\\n", + "20200807 111.11 109.61 444.45 -0.0227 -0.0245 NaN 0.820 111.1125 \n", + "20200831 129.04 127.29 129.04 0.0339 0.0339 3.0 NaN 129.0400 \n", + "20201106 118.69 117.28 118.69 -0.0011 -0.0029 NaN 0.205 118.6900 \n", + "20210205 136.76 135.34 136.76 -0.0031 -0.0046 NaN 0.205 136.7600 \n", + "20210507 130.21 129.08 130.21 0.0053 0.0036 NaN 0.220 130.2100 \n", + "20210806 146.14 145.08 146.14 -0.0048 -0.0063 NaN 0.220 146.1400 \n", + "20211105 151.28 150.41 151.28 0.0036 0.0021 NaN 0.220 151.2800 \n", + "20220506 157.28 156.80 157.28 0.0047 0.0033 NaN 0.230 157.2800 \n", + "20220805 165.35 165.08 165.35 -0.0014 -0.0028 NaN 0.230 165.3500 \n", + "20221104 138.38 138.38 138.38 -0.0019 -0.0036 NaN 0.230 138.3800 \n", + "\n", + " adjprice \n", + "20200807 109.6045 \n", + "20200831 127.2887 \n", + "20201106 117.2813 \n", + "20210205 135.3396 \n", + "20210507 129.0752 \n", + "20210806 145.0845 \n", + "20211105 150.4057 \n", + "20220506 156.8000 \n", + "20220805 165.0748 \n", + "20221104 138.3800 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# display last five distribution events\n", + "show(df.loc[dist_dates].tail(10), **SHOW)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tcn_var.ipynb b/tcn_var.ipynb new file mode 100644 index 0000000..626c9f1 --- /dev/null +++ b/tcn_var.ipynb @@ -0,0 +1,1459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TCN and VAR\n", + "\n", + "- Contrast Vector Autoregression and Temporal Convolutional Networks for modeling the time-series persistance of multiple series, and compare prediction errors.\n", + "\n", + "Copyright 2023, Terence Lim\n", + "\n", + "MIT License" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import DataFrame, Series\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import time\n", + "from datetime import datetime\n", + "import random\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "import statsmodels.api as sm\n", + "from statsmodels.tsa.api import VAR\n", + "from finds.display import plot_bands, show\n", + "from finds.unstructured import Store\n", + "from conf import VERBOSE, credentials, paths\n", + "\n", + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(ndigits=4, latex=None)\n", + "\n", + "imgdir = paths['images'] / 'ts'\n", + "store = Store(paths['scratch'])\n", + "factors = store['approximate'].factors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Vector Autoregression Model\n", + "\n", + "- predict multiple time series (of the extracted factors)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "maxlags = 16\n", + "train_split = '2014-12-31' # training period up to this date\n", + "test_split = '2019-12-31' # split test period into two (due to COVID)\n", + "train_index = factors.index[factors.index <= train_split]\n", + "test1_index = factors.index[(factors.index >= train_index[-maxlags]) &\n", + " (factors.index <= test_split)]\n", + "test2_index = factors.index[(factors.index >= test1_index[-maxlags])]\n", + "test_end = max(test2_index).strftime('%Y-%m-%d')\n", + "train_data = factors.loc[train_index].copy()\n", + "test1_data = factors.loc[test1_index].copy()\n", + "test2_data = factors.loc[test2_index].copy()\n", + "M = train_data.shape[1] # M is number of vectors to autoregress\n", + "model = VAR(train_data, freq='M')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Auto Select Lag Order\n", + "\n", + "The lagged coefficients estimated from the Vector Autoregression produce a \n", + "multi-period cumulative forecast \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IC:aicfpehqicbic
Optimal number of VAR(p) lags selected by Information Criterion
optimal p:9932
\n", + "
" + ], + "text/plain": [ + "IC: aic fpe hqic bic\n", + "Optimal number of VAR(p) lags selected by Infor... \n", + "optimal p: 9 9 3 2" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "show(DataFrame({ic: model.fit(maxlags=maxlags, ic=ic).k_ar\n", + " for ic in ['aic', 'fpe', 'hqic', 'bic']},\n", + " index=['optimal p:'])\\\n", + " .rename_axis(columns='IC:'),\n", + " caption=\"Optimal number of VAR(p) lags selected by Information Criterion\",\n", + " **SHOW)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Collect one-period ahead forecasts and errors in train and test sets" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1961-07-31...2019-12-31:Train ErrorTest1 ErrorTest2 Error
TrainSampleMean0.9671620.4700561.995821
VAR(1)0.6565840.3521342.098398
VAR(2)0.6074990.3252442.052948
VAR(3)0.5821780.3167592.092601
VAR(4)0.5653620.3161492.129980
VAR(5)0.5495560.3198312.207206
VAR(6)0.5350290.3214372.224921
VAR(7)0.5196720.3257632.252013
VAR(8)0.5056020.3201662.281718
VAR(9)0.4895500.3250772.180160
VAR(10)0.4783690.3213472.235600
VAR(11)0.4671260.3313542.246976
VAR(12)0.4586340.3389602.244229
VAR(13)0.4504510.3471272.277507
VAR(14)0.4394290.3503682.357079
VAR(15)0.4332120.3488682.366113
VAR(16)0.4249310.3507422.413987
\n", + "
" + ], + "text/plain": [ + "1961-07-31...2019-12-31: Train Error Test1 Error Test2 Error\n", + "TrainSampleMean 0.967162 0.470056 1.995821\n", + "VAR(1) 0.656584 0.352134 2.098398\n", + "VAR(2) 0.607499 0.325244 2.052948\n", + "VAR(3) 0.582178 0.316759 2.092601\n", + "VAR(4) 0.565362 0.316149 2.129980\n", + "VAR(5) 0.549556 0.319831 2.207206\n", + "VAR(6) 0.535029 0.321437 2.224921\n", + "VAR(7) 0.519672 0.325763 2.252013\n", + "VAR(8) 0.505602 0.320166 2.281718\n", + "VAR(9) 0.489550 0.325077 2.180160\n", + "VAR(10) 0.478369 0.321347 2.235600\n", + "VAR(11) 0.467126 0.331354 2.246976\n", + "VAR(12) 0.458634 0.338960 2.244229\n", + "VAR(13) 0.450451 0.347127 2.277507\n", + "VAR(14) 0.439429 0.350368 2.357079\n", + "VAR(15) 0.433212 0.348868 2.366113\n", + "VAR(16) 0.424931 0.350742 2.413987" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results = {p: model.fit(p) for p in range(1, maxlags+1)} # VAR(p) models\n", + "from sklearn.metrics import mean_squared_error as mse\n", + "mean_error = dict() # to collect unconditional mean error each month\n", + "var_error= {p: dict() for p in results} # collect error each month for each p\n", + "\n", + "for sample in [train_data, test1_data, test2_data]: # loop over 3 subsamples\n", + " \n", + " for i in range(maxlags, len(sample)): # start at maxlag'th obs\n", + " \n", + " # accumulate to error of unconditional mean forecast\n", + " mean_error[sample.index[i]] = mse(sample.iloc[i].values,\n", + " train_data.mean().values)\n", + " \n", + " # accumulate to error of VAR(p) model forecasts\n", + " for p in var_error:\n", + "\n", + " # include p prior for VAR(p) to forecast i'th obs\n", + " pred = results[p].forecast(sample.iloc[(i-p):i].values, 1)\n", + " var_error[p][sample.index[i]] = mse([sample.iloc[i].values], pred)\n", + "\n", + "# Collect mean test and train set errors of all VAR(p) models\n", + "errors = {0: Series(mean_error, name=\"TrainSampleMean\")} # VAR(0)\n", + "errors.update({p: Series(var_error[p], name=f\"VAR({p})\")\n", + " for p in var_error})\n", + "out = [Series({'Train Error': e.loc[e.index <= train_split].mean(),\n", + " 'Test1 Error': e.loc[test1_index].mean(),\n", + " 'Test2 Error': e.loc[test2_index].mean()},\n", + " name=e.name) for p, e in errors.items()]\n", + "out = pd.concat(out, axis=1).T.rename_axis(columns=\"1961-07-31...2019-12-31:\")\n", + "out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot Train and Test Error of all VAR(p) Models" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAFgCAYAAACmDI9oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACaFElEQVR4nOzdd3hU1dbA4d9K7wmQ0DuE3lFABARRQBDECgr2hp+K2AsWxIvtqmAFUcGCFysqKlaUjtJEeu89lIQU0tf3x0xCCElmEpJMEtb7PPMk55x99lkzTMjKnn3WFlXFGGOMMcYY4+Dl6QCMMcYYY4wpSyxBNsYYY4wxJgdLkI0xxhhjjMnBEmRjjDHGGGNysATZGGOMMcaYHCxBNsYYY4wxJgdLkI0pISIyXUQGu9n2axG5pIRDMkUgIgki0vBsj6GsE5EPReQ/no6jtInIWhHpWcRzVUQaF29ExlQMliCbs56I/CwiY/PYf5mIHBARnyL02QZoC3zn5ikvAfn+cheRniKS6UyUsh7fFzau0iYi9Z2/hPN9DUVkjIik5XpusaUYZoFUNURVtxXmHBHpnuO5JDpfg5zPr25Jx5BHTE/kuH6yiGTk2F5bhP56isieXPtaicgvInJYRMpEkf1Set43ishyETkuIntE5GUX73l1vi8SRGSviLwmIt5FeX6q2lJV5xTlXGNM/ixBNgY+AoaLiOTafz3wqaqmu9tRjl+KdzrPdStJUNUlQJiInFNAs33ORCnrMdDduHLEV6RfwqXg81zPLSKvRnklHYX9A6Yof/AUlqrOz3ouQEvn7ogcz29XacbjjOn5HDGNABbniKelq/PdlAZ8AdxaTP2dsVJ63kHAKCAS6Az0Bh5ycU5bZ0y9geuA2wtzwdJ63xhztrIE2Rj4FqgCdM/aISKVgEuBj0Wkk4gsFpFYEdkvIm+JiF+Otioid4vIZmCzc/clwNwcbW4SkYXOc+NEZIOI9M4VxxxgQGGDF5HmIjLHGd9aERmU49iHIjJRRGaJSCLQS0RqOqd0xIjIdhEZmaO9t3PEbauIxDtHxeo4j70uIrudo2TLRSTn69VJRJY5jx0Ukdech+Y5v8Y6R8vOK8LzO+X1zRrBE5FHReQAMFVE/EVkgojscz4miIi/8/y82keKyA/O1+yoiMwXkTz/P5QcH0M7X8+3ReRH5+vzt4g0KuTzGSMiX4nINBE5Dtzk5nus2GLII6ZmIvKb87XYKCLX5DjWX0TWOa+1V0QeEpFg4Cegppwcja2pqhtV9QPArZFZF++pMSLyhYh87Lz2WsnxB6SItBeRFc5jnwMBHnzeE51/FKWq6l7gU+B8d2JQ1Q3AfKCV87qXishK53thkTg+jcqKaYfzfbwKSBQRH+e+i5zH8/05cB5/2Pn+2icit+R6LU57voV9PY2pUFTVHvY46x/Ae8D7ObbvBFY6v+8IdAF8gPrAemBUjrYK/AZUBgKBYOe+qBxtbgLSgfsBX2AIEAdUztHmAWBGPvH1BPbksd8X2AI8AfgBFwLxQFPn8Q+d1zkfxx/EQcBy4Gln+4bANqCvs/3DwGqgKSA4polUcR4bjuMPCR/gQeAAEOA8thi43vl9CNDF+X1952vhU8BrPwaYVsDx3K9vT+dr+RLg79w3FvgLqApEAYuA53K8drnbvwBMcr5+vjj+OJICrt84x+t5BOjkfB0+BT5z8d465TVwPt80YLDz3yQQ995jRY4hj5huAhY4vw8GdgM3O/trDxwGWjiP7we6O7+vBHQo6D3pPNYYUDfiKOg9NQZIBvoD3s5/s7+cx/yAnZz8ebrK+Zr+x5PPO8d1vgVedPGezvr3bOF83rc6YziEYxTaG7gR2AH4O9vuAFYCdYDAHPsucn5f0M9BP+AgjkQ8GPhfrjjyfL72sMfZ+rARZGMcPgKuEpGsUagbnPtQ1eWq+peqpqvqDuBd4IJc57+gqkdV9QQQ4dwXn6vNIWCCqqap6ufARk4dMY7PcW5eajpHlbIe1+BIqkJw/DJOVdU/gB+Aa3Oc952qLlTVTKA1jsR9rLP9Nhx/HAx1tr0NeFIdI4Gqqv+q6hHn6zBNVY84X4dXcSSbTZ3npQGNRSRSVRNU9a8Cnkdersn13P7MdTzn6wuQCTyjqinOfcOAsap6SFVjgGdxTJEhn/ZpQA2gnvPfY76qujtn9htVXaKOqTefAu0K+VzB8TH/t6qaqaon3HyPFXcMWS4FdqjqVOf1/wG+Bq52Hk8DWohImKoeU9UVZ3CtU7h4T4EjmZ2lqhnAJzj+YAPH+96Xkz9PXwFLC3n5EnnezpHZc4BXXDRdISLHgO+B94GpwB3Au6r6t6pmqOpHQAqO55vlDVXdneNnIaeCfg6uAaaq6hpVTcTxB0hOJfbvbEx5ZAmyMYCqLsAxejTY+XF1JxwjLIhIE+fH8QecH4k/j2OuYU67c3wf6/wamqvN3lxJ2E6gZo7t0Bzn5mWfqkbkeHzhPH+3M/nN2W+tfGKrR65EG8foczXn8TrA1rwu7vyIeb04pojEAuGcfB1uBZoAG0RkqYhcWsDzyMsXuZ5br1zHd+fajlHV5BzbNXE87yy5X9vc7f+LY+T9VxHZJiKPFSLWAzm+T8LxB0phnfJ83HyPFXcMWeoBnXO9J4YB1Z3Hr8QxirtTROZKEabJ5MfFewpOf54B4ph7W5O8f54Ko9iftziq1rwAXKKqh10076CqlVS1kao+6fwZrgc8mCumOpz6Xs79s5BTQT8HNXOdm/v1KrF/Z2PKI0uQjTnpYxwjx8OBX1T1oHP/RGADEK2qYTgSytw39GX/onaOzmzFkTDmVEvklBsB6wL7cmw3B/4tZMz7gDpy6vzZusDevGLD8Qtye65kNFRV++c4ftp8Vufc0EdwjEJVUsdNdHE4XwdV3ayq1+L4aPcl4CvnfM3iqmSQu5/c2/twJBdZcr+2p7RX1XhVfVBVGwKDgAfk9DnhJSl3/O68x0rKbmBurvdEiKreBaCqS1X1Mhz/tt/iuAkPzvDf1tV7yoX95P3zVBjF+rxFpB+OT2MGqurqQsaSM6ZxuWIKUtXpOdoU9LoX9HOwH0eynfPYyU7zf77GnJUsQTbmpI+Bi3DcTf5Rjv2hwHEgQUSaAXe50dcsTv+IvCowUkR8ReRqHAnxrBzHL8BxA1Bh/I1jZO0RZ789gYHAZ/m0XwLEO2/0CRTHTXmtRORc5/H3gedEJFoc2ohIFRyvQToQA/iIyNNAWFanIjJcRKKco2Cxzt2ZzvaZOOY6l6TpwJMiEiUikTjmWE/Lr7HzRqjGzgQrDshwxukpRXmP5UkcN2yOKcQpPwBNROR653vIV0TOFcfNn34iMkxEwlU1zRlj1ut0EKgiIuE5ri3OaUp+zu2AnDeJ5VLge8qFxc5zs36ersDxqU9hFOfzvhDHVJcr1VGRpqjeA0aISGfnaxksIgNEJPenUfkp6OfgCxw3hLYQkSDgmRzxF/R8jTkrWYJsjJNz7uciHDewzMxx6CEcZZjicfwC+9yN7iYDw3KNcP0NROOYyjEOuEqd83udCWpCYX+5qmoqjoT4Eme/7wA3qOPO+LzaZ+CYe9kO2O48530cH20DvIbjF+mvOH5JfoDjJrJfgJ+BTTg+mk3m1I9r+wFrRSQBeB0Y6pxbm+R8rgudHxnnnEuZ0xA5tU5wgohULcRL8R9gGbAKx02GKyigrjSOf4ffgQQcydY7qpp73nNpKsp7LD91gIXuNlbVeKAPjnno+3BMa8i6oREcc1h3OKd+jMAxDQHne2w6sM35b1sTx+jlCU5WsTiBY659Xly9pwqKORW4AsdNd0dx3PQ6w60nfLKP4nzeT+H4GZqV4/1b2D92UdVlOP5Afws4hmMa0E2F6CLfnwNV/QmYAPzh7PePXOfm+XyNOVuJun1fijGmMETkfzjm1n4rIjcBt6lqt3zafg18oKqz8jpujDtEpDaO91xXT8dijDHlmSXIxpQCVwmyMcYYY8oOm2JhjDHGGGNMDjaCbIwxxhhjTA42gmyMMcYYY0wOPp4OoLC8vLw0MDDQ02EYY4wxxphCSEpKUlUtF4Oz5S5BDgwMJDEx0dNhGGOMMcaYQhCRvJZIL5PKRRZvjDHGGGNMabEE2RhjjDHGmBwsQTbGGGOMMSYHS5CNMcYYY4zJwRJkY4wxxhhjcrAE2RhjjDHGmBwsQTbGGGOMMSYHS5CNMcYYY4zJwRJkY4wxxhhjcrAE2RhjjDHGmBwsQS6AqrL9cCKZmerpUIwxxhhjCrQ9bjtpGWmeDqNCsAS5AD+tOUCvV+awdt9xT4dijDHGGJOvRXsXce2P1zJhxQRPh1IhWIJcgHPrVwZg3uYYD0dijDHGGJO3bzZ/w//N/j9qhdTi+hbXezqcCsES5AJEhfrTokYY8zZZgmyMMcaYskVVeWPFGzy96Gk61+jMR/0+onpwdU+HVSFYguxCjyZRrNh1jISUdE+HYowxxhgDQGpGKo8veJz3Vr/HFdFX8FbvtwjxC/F0WBWGJcgu9IiOJC1D+WvrEU+HYowxxhhDXEocI34fwY/bfuTe9vcy5rwx+Hr5ejqsCsUSZBc61q9EoK83820esjHGGGM8bG/CXm746Qb+OfQPL3R/gTva3IGIeDqsCscSZBf8fbzp0rAy8zYf9nQoxhhjjDmLrT28lmE/DiPmRAyTL57MpQ0v9XRIxUZE6ojInyKyTkTWish9BbQ9V0TSReSqkorHEmQ39GgSxfbDiew+muTpUIwxxhhzFpqzew43/3IzAT4BTLtkGudWP9fTIRW3dOBBVW0BdAHuFpEWuRuJiDfwEvBrSQZjCbIbukdHAVbuzRhjjDGlb/qG6dz35300DG/ItP7TaBjR0NMhFTtV3a+qK5zfxwPrgVp5NL0X+Bo4VJLxWILshkZRwdSKCLRyb8YYY4wpNZmayStLX+H5v5+nR60eTOk7hcjASE+HVeJEpD7QHvg71/5awOXAxJKOwaekL1ARiAg9mkTyw7/7Sc/IxMfb/q4wxhhjTMlJTk/miQVP8NvO37i22bU8eu6jeHt5ezqsM+UjIstybE9W1ck5G4hICI4R4lGqmnsp4wnAo6qaWdI3JlqC7Kbu0VFMX7KblbtjOce5wp4xxhhjTHE7mnyUkX+MZFXMKh465yFuaHFDRalUka6q5+R3UER8cSTHn6rqjDyanAN85nwtIoH+IpKuqt8Wd6CWILvp/EaReAnM23zYEmRjjDHGlIidx3fyf7//HweTDvJqz1e5uN7Fng6pVIgj6/0AWK+qr+XVRlUb5Gj/IfBDSSTHYHOQ3RYe5EvbOhE2D9kYY4wxJWLloZUMnzWc+NR43u/z/lmTHDudD1wPXCgiK52P/iIyQkRGlHYwBY4gi8gVbvSRrKqziimeMq1HdBRv/rGZ2KRUIoL8PB2OMcYYYyqIX3b8whPzn6B6cHUmXjSRumF1PR1SqVLVBYDb80hU9aaSi8b1FIv3gO8oOOAewNmRIDeJ5PXZm1m45QgD2tTwdDjGGGOMKedUlY/WfsSry1+lXVQ73rjwDSoFVPJ0WGc9VwnyT6p6S0ENRGRaMcZTprWtHUFogA/zNsVYgmyMMcaYM5Kemc6LS17k842f06deH8Z1G0eAT4CnwzK4SJBVdbirDtxpU1H4eHtxfqNI5m+OQVUryh2lxhhjjCllSWlJPDLvEebumcvNLW9mVMdReIndGlZWFPlfQkTOqpnjWXo0iWJfXDJbYxI8HYoxxhhjyqHDJw5z8y83M3/vfEZ3Hs0D5zxgyXEZcyb/Gh8UWxTlSPdoxwo28zYd9nAkxhhjjClvtsZuZdiPw9get503er3B0GZDPR2SyYOrKhYz8zsEVCn+cMq+OpWDaBgZzLzNMdzSrYHrE4wxxhhjgCX7lzDqz1H4+/gztd9UWlZp6emQTD5c3aTXHRgO5J5PIECnEomoHOjRJIrPlu4iJT0Df59yv+yjMcYYY0rY91u/5+lFT1MvtB7vXPQONUNqejokUwBXCfJfQJKqzs19QEQ2lkxIZV/36Eg+XLSDZTuOcX7jSE+HY4wxxpgySlWZvGoyb618i07VOzG+13jC/MI8HVaFJiLHXTUB9qtqk/wauKpicUkBx3q4uHiF1aVhFXy9hXmbYyxBNsYYY0ye0jLT+M9f/2HG5hkMbDiQZ7s+i6+3r6fDOhtsVdX2BTUQkX8KOl7om/REpHJhz6logv196Fivkt2oZ4wxxpg8JaQmcM/se5ixeQZ3trmTcd3GWXJceq480zYFJsgicr6IrBeRtSLSWUR+A5aKyG4ROc/VlUWkn4hsFJEtIvJYHsfrichsEVklInNEpLbLp1NG9GgSxfr9xzkUn+zpUIwxxhhThhxIPMCNP9/Ikv1LGNt1LPe0v8fWTihFqrrtTNu4GkEeD1wD3Ab8CDyrqo2Ay4BXCjpRRLyBt4FLgBbAtSLSIlezV4CPVbUNMBZ4wUU8ZUaP6CgAFmy2UWRjjDHGOGw8upFhs4axN2Evb1/0NpdHX+7pkEwOIrLanXaubtLzVdXVzg5jVHUBgKquEJFAF+d2ArZkZegi8hmOxHpdjjYtgAec3/8JfOtO0GVBixphVAn2Y96mGK7oUG4Gvo0xxhhTQhbuXciDcx8kxDeEjy/5mCaV8r0HzJQgEbkiv0NAdXf6cJUg5xxhfjzXMT8X59YCdufY3gN0ztXmX+AK4HXgciBURKqo6pGcjUTkDuAOAD8/V5ctHV5eQvfoSBZsOUxmpuLlZR+dGGOMMWerGZtnMHbxWBpHNObt3m9TLbiap0M6m30OfApoHscC3OnAVYL8lIgEqWqSqn6btVNEGgEfuxtlAR4C3hKRm4B5wF4gI3cjVZ0MTAYIDg7O68l6RPfoKL5duY91+4/Tqla4p8MxxhhjTClTVd78503eW/0e59c6n1cveJVg32BPh3W2WwW8oqprch8QkYvc6cBVmbfTVtITkeqquhV42UXfe4E6ObZrO/fl7H8fjhFkRCQEuFJVY12HXTZkLTs9f/NhS5CNMcaYs8Dx1ONsi93GtrhtbI3dyqqYVayMWcmV0VcyustofL2sUkUZMArIrxayW5PCRbVwA7IiskJVO7jRzgfYBPTGkRgvBa5T1bU52kQCR1U1U0TGARmq+nRB/QYHB2tiYmKhYi5J/SbMo1KQH9Pv6OLpUIwxxhhTTGKTY9kat5WtsVuzk+Ftsds4dOJQdht/b38ahjdkYKOBDG8+3CpVuCAiSapaLobXXU2xyItb//qqmi4i9wC/AN7AFFVdKyJjgWXO0emewAsiojimWNxdhHg86oImUUxZuJ2k1HSC/IrychpjjDHGE1SVo8lH2Ra3jS2xW05Jho8mH81uF+gTSKPwRnSp2YVGEY1oFN6IhhENqRlcE28vbw8+A5MXEQkC7sExB/lNYCiOGQsbgLGqmuCyjyKMIP+fqr5T+HCLR1kbQV6w+TDDP/ibKTedw4XNbEK+McYYU9aoKjEnYk5JgLO+j02JzW4X4htCw4iGNI5oTMPwhtnJcLXganhJoddWM7mU1giyiHyBo1BEINAUWI/jxr1BQHVVvd5VH4Ue8vRkclwWnVO/EgG+XszbdNgSZGOMMcaDVJUDiQfynBoRnxaf3S7ML4zGEY25qN5F2aPBjcIbUTWoqk2TqBiaqOo14vjH3A9cpKoqIgtwVFBzqcAEWURaA+/hKNn2E/Coqh5zHluiqp3OKPwKIMDXm84NqjBvc4ynQzHGGGPOCqrK3oS9p06NcN44l5SelN2uckBlGkU0on/D/qdMjagSUMUS4bOAMymepc7pEs5tt6ZOuBpBngiMAf7CsZreAhEZ5KxiYbdpOvVoEsVzP6xjz7EkalcK8nQ4xhhjTIWlqjw2/zFmbZ+VvS8qMIqGEQ0Z3HiwIxGOaETD8IZUCqjkwUiNBy0TkRBVTVDVW7J2OssUxxdwXjZXCXKoqv7s/P4VEVkO/Cwi15N38eWz0gVNInkOR7m3azvV9XQ4xhhjTIU1c+tMZm2fxbDmw+hXvx8NwhsQ7m+lVs1JqnpbPvu3ikh3d/pwOeNcRLLfdar6J3Al8AlQz804K7xGUSHUCA9g3iabZmGMMcaUlH0J+3hhyQt0qNqBh895mHZV21lybNwiIpPBMc3CnfauEuSXgOY5d6jqKhy1jWcUJcCKSEToER3Fwi2HSc/I9HQ4xhhjTIWTqZk8ufBJVJVx3cZZeTVTWOcUpnGBCbKq/k9V/8pj/y5Vvb2wkVVk3ZtEcjw5nX/3xHk6FGOMMabCmbZuGksPLOWxTo9RO7S2p8Mx5c8h101OKnJRv6yhauPQrXEkIjDfqlkYY4wxxWrLsS28vuJ1etbpyeDGgz0djimHVLVfYdoXmCCLSOV8HlWA/mcUaQUTEeRHm9oRNg/ZGGOMKUZpGWk8seAJQvxCGHPeGCvPZlwSkXNE5E8RmSYidUTkNxGJFZGlItLenT5cVbGIAXZy6vLS6tyuWrSwK64LoiN5688txCWlER5kVfCMMcaYMzXx34msP7qeCb0mUCWwiqfDMeXDO8AzQASwCLhfVS8Wkd7OY+e56sDVFIttQE9VbZDj0VBVGwAHzyz2iqd7kygyFRZtPezpUIwxxphyb+WhlXyw5gMua3QZvev29nQ4pvzwVdWfVHU6jsIVX+H4ZjYQ4E4HrhLkCUB+VbZfdjfKs0W7OhGE+vvYqnrGGGPMGUpKS2L0gtFUD6rOY50e83Q4pnxJFpE+InI1oCIyGEBELgAy3OmgwCkWqvp2AcfeLESgZwVfby+6Nq7CvE2HUVWbJ2WMMcYU0avLXmV3/G4+6PsBIX4hng7HlC8jcAzkZgJ9gbtE5ENgL+BWFbZCV7Gw6hUF6x4dxd7YE2w7nOjpUIwxxphyaf6e+Xyx6QtuaHED51Y/19PhmHJGVf9V1b6qeomqblDV+1Q1QlVbquoid/pwdZNeXgpVaPlsc0GTKADmb4qhUZT9xWuMMcYURmxyLE8veprGEY25t8O9ng7HlFMi0hcYDNRy7toLfKuqv7hzflES5EIVWj7b1KkcRP0qQczbfJibzm/g6XCMMcaYckNVee6v54hNiWXiRRPx9/b3dEimHBKRCUAT4GNgj3N3beA+Eemvqve56qPQCXJhCy2fjXo0ieLLZXtISc/A38eWwjTGGGPcMWv7LH7d+Sv3dbiPZpWbeTocU371V9UmuXeKyOfAJsBlguxqoRAvEblFRH4UkX9FZIWIfCYiPYsa8dmge3QUJ9IyWL7zmKdDMcYYY8qFA4kHGPf3ONpFtePmljd7OhxTviWLSF6T188Fkt3pwNUI8gc4Fgp5AbgKOA7MB54UkdZWySJv5zWqgo+XMG/TYbo2ivR0OMYYY0yZlqmZPLXwKdIz0xnXbRzeXvbpqzkjNwETRSSUk1Ms6gBxzmMuuUqQO6pq1p9xC0TkL1V9WkTmASsBS5DzEOLvQ4d6lZi/OYbHLrGPiIwxxpiCTN8wnb/2/8VTXZ6iblhdT4djyjlVXQF0FpHq5LhJT1UPuNuHqzJvaSLSCEBEOgCpzgun4Fhy2uTjgiZRrN13nJj4FE+HYowxxpRZ2+K2MX75eLrX6s7VTa72dDimAlHVA6q6XFWX46iN7DZXCfLDwJ8ishn42rmNiEQBPxQl2LNFj2hHubeFW2zZaWOMMSYvaZlpPDH/CQJ9Anm267O2wJYpSYMK07jABFlV/wDqAeepagNV/du5P0ZVHyl6jBVfy5phVA72Y94mW3baGGOMyct7q95j7ZG1PNXlKaKCojwdjqnYCvXXl8uV9NThtGFQEbm4MBc623h5Cd0aRzJvs2PZaWOMMcactDpmNZNXTebShpfSp34fT4djKr6OhWlc6KWmc/jgDM49K3SPjuRwQgrr98d7OhRjjDGmzDiRfoInFjxBZGAkj3d+3NPhmApIRPqKyK0iUh9AVTOd+29x5/wCq1iIyMz8DgFVChHnWamHc9npeZtjaFEzzMPRGGOMMWXDhOUT2HF8B+/1eY8wP/v9aIqXiDwPdANWAE+IyIQcpYnvAaa46sNVmbfuwHAgIfe1gU6FC/fsUy0sgKbVQpm/OYYRFzTydDjGGGOMxy3at4j/bfgfw5sPp0uNLp4Ox1RMA4H2qpouImOA/4lIQ1W9HzfnIrtKkP8CklR1bu4DIrKxsNGejXo0ieSjRTtJSk0nyK/QK3sbY4wxFUZcShxPLXyKBuENuK+Dy9V+jSkqH1VNB1DVWBEZCEwWkS8BP3c6cFXF4hJV/TOfYz0KG+3ZqHt0FKkZmfy9/ainQzHGGGM86vm/n+foiaO80O0FAnwCPB2Oqbi2isgFWRuqmqGqtwIbgebudODWTXoiUk1EOjgf1YoW69mpU4PK+Pt4Wbk3Y4wxZ7Wfd/zMrO2zuKPtHbSMbOnpcEzFdjWwJPdOVX0Sx5LTLrm6Sa89MBEIB/Y6d9cWkVjg/5xL+ZkCBPh607lhFeZvtgVDjDHGnJ0OJR3iucXP0TqyNbe3vt3T4ZgKTlVPAIiIr6qm5Trs1hLHrkaQpwL3qWpzVb3I+WgGjHIeK5CI9BORjSKyRUQey+N4XRH5U0T+EZFVItLfnaDLmx7RkWw5lMC+2BOeDsUYY4wpVarK0wufJjUjlee7PY+Pl92PY0qWiPQSkT3AfhH5NavUm9Ov7vThKkEOzlo9LydV/QsIdhGcN/A2cAnQArhWRFrkavYk8IWqtgeGAu+4E3R5k1Xubf5mm2ZhjDHm7PLFxi9YuG8hD5zzAPXD63s6HHN2eBnoq6qRwGTgNxHJKpniVhULVwnyTyLyo4gMEZGuzscQEfkR+NnFuZ2ALaq6TVVTgc+Ay3K1USCrAGI4sM+doMub6KohVA8LYN4mm2ZhjDHm7LHz+E5eXf4qXWt2ZWjToZ4Ox5w9/FR1LYCqfgUMBj4SkcE4ck+XCvycQ1VHisglOBLbWs7de4G3VXWWi75rAbtzbO8BOudqMwb4VUTuxTEifZE7QZc3IkL36Eh+XXeQjEzF26tQy4EbY4wx5U56ZjpPLHgCXy9fxnYdi4j97jOlJk1EqqvqAQBVXSsivYEfALcWpnA5EUhVfwJ+OqMw83ct8KGqvioi5wGfiEirrOUAs4jIHcAdAH5+bpWvK3O6N4niy+V7WLUnlvZ1K3k6HGOMMaZETVkzhVUxq3i5x8tUC7YCWKZUPQZUAw5k7VDVPSLSE7jbnQ4KnGIhIt4icqeIPCciXXMde9JF33s5tZRGbU5WwshyK/AFgKouBgKAyNwdqepkVT1HVc/x8Smfk/u7NY5EBJtmYYwxpsJbd2QdE1dOpF/9flzS4BJPh2PKARGp4yzcsE5E1orIaSvJiMhlzqIOK0VkmYh0y6svVf1dVf91nlNZRCo798eq6jh34nE1B/ld4ALgCPCmiLyW49gVLs5dCkSLSAMR8cNxE97MXG12Ab2dT6A5jgS5Qt7JVjnYj9a1wu1GPWOMMRVaSkYKT8x/gsoBlXmyi6uxNGOypQMPqmoLoAtwdx7FHWYDbVW1HXAL8H5eHTmrpH0mIjHA38ASETnk3FffnWBcJcidVPU6VZ2AY/5wiIjMEBF/XNwF6Fzi7x7gF2A9jmoVa0VkrIgMcjZ7ELhdRP4FpgM3qapbk6fLox7RUfyzO5bjyblL8hljjDEVw+srXmdr3FbGnj+WcP9wT4djyglV3Z+1voaqxuPIHWvlapOQI08MJv8b7j4HvgGqq2q0qjYGagDf4iga4ZKrBDl7wq+qpqvqHcBK4A8gxFXnqjpLVZuoaqOsIW1VfVpVZzq/X6eq56tqW1Vtp6pu1aYrr3o0iSIjU1m05YinQzHGGGOK3ZL9S/hk3ScMaTqE82ud7+lwTNnj45wakfW4I69GzlHe9jhGf3Mfu1xENgA/4hhFzkukqn6uqhlZO5zLTX8GVHEnUFcJ8jIR6Zdzh6qOxbFISH13LmBOal83ghB/H+bZNAtjjDEVTHxqPKMXjqZeWD0e6PiAp8MxZVN61j1lzsfk3A1EJAT4GhilqsdzH1fVb5yL1g0GnsvnOstF5B0R6SwiNZ2PziLyDvCPO4G6KvM2PJ/975PPvA+TP19vL85rVIV5m2JQVSt5Y4wxpsJ4ccmLxCTF8PElHxPkG+TpcEw5JCK+OJLjT1V1RkFtVXWeiDQUkUhVzV0B4QYchSCe5eQ0jT3A98AH7sTidkmInPXk8to27ukRHclv6w6y40gSDSILXIzQGGOMKRd+3/k7M7fO5M42d9Imqo2nwzHlkDhGDT8A1qvqa/m0aQxsVVUVkQ6AP45CEqdwLlA30fkoEldTLHLKnXG7lYGbU2UtOz1vk02zMMYYU/4dPnGYZxc/S4sqLbiz7Z2eDseUX+cD1wMXOsu4rRSR/iIyQkRGONtcCawRkZXA28CQ/Io7iEhfEblVROrl2p/fvOVTzy9vRSOCg4M1MTHR02GckR4v/0mTaiG8f+O5ng7FGGOMKTJV5d4/7mXxvsV8OfBLGkY09HRIpgwTkSRVLfGPz0XkeaAbsAIYCExQ1Tedx1aoagdXfRRmBDn3xV1WsTB569EkksVbj5Canum6sTHGGFNGzdg8g7l75jKq4yhLjk1ZMhC4UFVHAR2BS0RkvPOYWzeAFTlBBtadwblnte7RUSSmZrBi1zFPh2KMMcYUye743by89GU6V+/MsObDPB2OMTn5ONfjQFVjcSTMYSLyJTlKGBfYQUEHRSS/Oi2CG3WQTd66NqqCj5cwb1MMXRq6VY7PGGOMKTMyMjMYvWA0XuLFc+c/h5ecyXibMcVuq4hcoKpzwVEDGbhVRP6DYx6zS67e0c8DlYDQXI8QN841+QgN8KVD3UrM35y7KokxxhhT9n249kP+OfQPT3R+ghohNTwdjjG5XQ0syb1TVZ8E6rjTgasybyuAb1V1ee4DInKbOxcweeseHclrv2/iSEIKVUL8PR2OMaYUHUw8SGpGKnXC3Pp/2pgyZePRjby18i0urncxlza81NPhGHMaVT1RwLG97vThahT4ZmBXPsfOcecCJm89mkShCgu22CiyMWeL2ORYXln6Cv1n9GfIj0OIS4nzdEjGFEpqRiqPL3iccL9wnurylC14Zco8EVlR0HZ+CkyQVXWjquZZsFdVD7ofnsmtVa1wIoJ8mbfJEmRjKrrk9GQ+WP0B/Wf055P1n9CzTk8SUhP4YLWVkzfly1v/vMXmY5sZe/5YKgVU8nQ4xriUu6SbOyXewEWCLCLVRWSiiLwtIlVEZIyIrBaRL0TEJh2dAW8voVvjSOZvdiw7bYypeNIz05mxeQYDvhnAhBUT6FCtA18N/IpXe77KwEYD+XT9p+xP2O/pMI1xSVX5efvPfLj2Q65qchU9avfwdEjGlChXUyw+xFHObTfwJ3AC6A/MByaVaGRngR7RURyKT2HjwXhPh2KMKUaqyp+7/uSqmVfxzKJnqB5cnal9p/JW77eIrhQNwD3t7gHg7ZVvezJUY1zaHb+bu2ffzcPzHqZZ5WY8fM7Dng7JmCITkdXutHN1k161HCuP/J+qvuTc/6aI3HomARro3iQScCw73ax6mIejMcYUh5WHVjJ++XhWHFpB/bD6jO85nt51e582V7NGSA2ubXYtH6/7mBta3kCTSk08FLExeUvJSGHK6im8v/p9fLx8eOich7iu+XX4evl6OjRjCiQiV+R3CKjuTh+uEuScI8wfF3DMFEGN8ECiq4Ywf/Nh7ujRyNPhGGPOwLbYbby+4nX+2P0HkYGRPH3e01ze+HJ8vPL/b/b2NrczY8sMJiyfwDsXvVOK0RpTsPl75vPCkhfYHb+bfvX78dA5D1EtuJqnwzLGXZ8DnwJ5zWENcKcDVwnydyISoqoJztpxAIhIY2CT22GafPVoEsUnf+3kRGoGgX7eng7HGFNIBxMPMvHfiXyz5RsCfQK5t/29DG8+nCDfIJfnhvuHc1vr2xi/fDxLDyzl3OrnlkLExuRvf8J+Xlr6ErN3zaZ+WH3e6/MeXWp08XRYxhTWKuAVVV2T+4CIXOROB1LebhALDg7WxMRET4dRbOZuiuHGKUv46JZOXNAkytPhGGPcdDz1OFPXTGXaummkazpDmw7ljjZ3FPrO/uT0ZC795lKqBlXl0/6fWtks4xFpGWl8tO4jJq+aDMAdbe7gxhY34utt0ylM8RGRJFUNLoXrdAd2qupppYpF5BxVXeaqD1cjyHld9AdVtcrgxaRT/cr4+Xgxb1OMJcjGlAOpGalM3zCd91a/R1xKHAMaDuCedvdQO7R2kfoL8Ang7nZ38/Sip/lt52/0qd+nmCM2pmB/7/+bcX+PY3vcdi6scyGPdnqUmiE1PR2WMUWmqvMLOOYyOYYiJMhArSKcY/IR6OdN5waVmb85z3LTxpgyIlMz+XHbj7z1z1vsS9xH15pdGdVhFM2rND/jvgc1GsTH6z7mjX/eoFfdXnYTlCkVh5IO8crSV/hpx0/UDqnN273ftvJtpkIQkSDgHhxzkN8EhgJXABuAsaqa4KqPotxo908RzjEF6B4dyaaDCeyPy3dlRGOMh6gqC/Yu4Jrvr+GJBU8Q7h/O5Isn8+7F7xZLcgzg7eXNqA6j2Hl8J19v+rpY+jQmP2mZaXy09iMGfjOQ2btmc1fbu/jmsm8sOTYVyYdANaAB8COO1Z//i6OKxUR3OrA5yGXAhgPH6TdhPi9f2YZrzq3j6XCMMU5rDq9h/PLxLDmwhNohtRnZYSR96/fFS4q/iI+qcvMvN7M9bjs/XfGTWzf5GVNYyw8uZ9zf49h8bDPdanXjiU5PUCfMfu+Y0lGKc5BXqmo7cdzUsR+ooarq3P5XVdu46sPVSnphIvKCiHwiItflOmY1iYpJ02qhVA31Z55NszCmTNh1fBcPzX2Ia3+8li2xW3i80+PMHDyTSxpcUiLJMYCIcH/H+zmafJSP1n5UItcwZ6/DJw4zesFobvr5JhJSE5jQawLv9H7HkmNToaljFHiW82vWtlsjw67mIE8FNgNfA7eIyJXAdaqaAljdl2IiInSPjmL2hoNkZCreXnYXuzGecPjEYSb9O4mvN32Nr7cvI9qO4KaWNxHsW+IDHgC0jWrLxfUu5sO1H3J106uJDIwsleuaiisjM4MvNn3Bmyve5ETGCW5rfRu3t77dPqEwFd2yHGWKb8naKSKNALeWL3aVIDdS1Sud338rIqOBP0RkUNHiNfnp0SSSr1fsYc3eONrWifB0OMacVRLTEvlo7Ud8uPZDUjNSuarJVYxoO8IjCeq97e/lj11/8O6/7zK6y+hSv76pOFbFrOI/f/2H9UfX07lGZ57o/AQNwxt6OixjSpyq3pbP/q3OEnAuuUqQ/UXES1UznR2PE5G9wDwgpFDRmgJ1axyJiGPZaUuQjSkdaRlpfLX5Kyb9O4mjyUfpU68P97a/l/rh9T0WU4PwBlwZfSVfbfqK61tcT92wuh6LxZRPscmxTFgxgRmbZxAVGMV/e/yXvvX7Wo1tc1YTkcmqeoe6efOdq8l03wMX5tyhqh8CDwKpRYrQ5KlKiD+taoYzf/NhT4diTIWXqZn8vP1nLvvuMp7/+3kahjfkf/3/x6s9X/VocpzlrnZ34evtyxv/vOHpUEw5kqmZfL3pawZ+O5Bvt3zL9S2uZ+blM+nXoJ8lx8Y4Klm4rcARZFV9JJ/9PwPRhbmQca17dCST520jPjmN0ACrg2pMSfh7/9+MXz6etUfWEl0pmnd6v0O3Wt3KVAIRGRjJDS1u4N1V73JTy5toFdnK0yGZMm79kfX85+//sCpmFR2qdmB0l9E0qdTE02EZU5YcKkzjIpd5E5GbVXVqkU4+AxWxzFuWv7YdYejkv5h8fUf6tKzu6XCMqVDWHlnLmyveZOG+hdQIrsE97e9hQIMBeHt5ezq0PCWkJjDgmwE0imjEB30+KFMJvCk7jqce561/3uLzjZ8T6hPK8DrD6VGlh71fjEcFBARQu3ZtfH1PHewrrTJvxaEoK+lleRZHlQtTTDrUrUSwnzfzNsdYgmxMMVkVs4pJ/05i/t75hPmF8dA5DzG02VD8vf09HVqBQvxCuKPNHby45EUW7F1A99pu3VdizhKqyvfbvufVZa8SmxJLvxr9uKvVXdSrXs+SY+NRqsqRI0fYs2cPDRo08EgMIuIN3AbUBn5W1YU5jj2pqv9x1UeBCbKIrMrvEI4VSkwx8vPx4rxGVZi3yeYhG3OmVh5ayaR/J7Fw30Ii/CO4r8N9DG06lBC/8nN/8TVNruHT9Z8yfsV4utbsWmZHu03p2nxsM+P+Hsfyg8tpE9mGiRdNRA6JJcemTBARqlSpQkyMR9d2eBcIApYAb4jIXFV9wHnsCuDMEmQcSXBf4Fiu/QIsKlysxh3do6P4ff0hdh5JpF6VcvEphDFlyrIDy5i0ahJ/7/+bygGVub/j/QxtOrRc1n319fZlZPuRPDzvYX7c/iODGlmFzdIQkxTD5mOb8fLyItgnmGDfYIJ8gxwPnyB8vM7kw9eiS0xLZOLKiUxbP40QvxCeOe8Zroi+Ai/xYv2h9ZYcmzKjDLwXO2WtlicibwHviMgM4FocOaxLrn7KfwBCVHVl7gMiMsdV5yLSD3gd8AbeV9UXcx0fD/RybgYBVVU1wmXUFViPJlGAo9zb9edZgmyMO1SVpQeWMvHfiSw7uIwqAVV46JyHuLrJ1eUyMc6pT/0+TF07lbf+eYu+9fuW+akh5U1cShxrj6xl7eG1rDm8hjVH1nAoqeB7eQK8A7KT5WDfHAm0i+1g3+A827hKuFWVX3b+wn+X/JdDJw5xZfSV3NfhPioFVCrOl+KMHDlyhN69ewNw4MABvL29iYpy/D5bsmQJfn5++Z67bNkyPv74Y954w/2qLfXr1yc0NBRvb8enKj169CjU+abCy37DqWo6cIeIPA38gZtliot8k57Ljh3zPzYBFwN7gKXAtaq6Lp/29wLtc654kpeKfJMeOP4j7P7ynzSvEcZ7NxSqIokxZx1VZfH+xbz777usOLSCqoFVuaX1LVwZfSUBPgGeDq/Y/L3/b2779TYeOuchbmx5o6fDKbeS0pLYcHRDdiK89vBadsXvyj5eN7QuLSNb0qpKK5pXaY4gJKUnkZSWRGJaouORnsiJtBPZ3yemJWYfT0pPOmVb3VvRFn9v/1OS56zR6qzR693xu1l2cBnNKzdndJfRtI1qe1of69evp3nz5sX2Wp2JMWPGEBISwkMPPZS9Lz09HR+f4ht5r1+/PsuWLSMyMv/FfHJf090YMjIyshNvU3R5vSdL6yY9EZkGTHNWXcu5/zZgoqq6LBVW6HeriNyhqpPdaNoJ2KKq25znfQZcBuSZIOMY9n6msPFUNCJCjyZRzFy5j7SMTHy9XZWqNubso6os2LuASasmsSpmFdWCqvFE5ye4IvqKCjnC2rlGZ86veT6TV01mcOPBhPuHezqkMi8tI41NsZtOGRneGruVTMe6V1QLqkaryFZcHn05Lau0pEWVFsX6uqoqJ9JPnJZg55VwJ6U59+VIuGOTY9mbtpek9CS8xIvHOz3OkKZDytU89JtuuomAgAD++ecfzj//fIYOHcp9991HcnIygYGBTJ06laZNmzJnzhxeeeUVfvjhB8aMGcOuXbvYtm0bu3btYtSoUYwcOdLta/bs2ZN27dqxYMECrr32Wr7//vtTttu1a8dDDz1Eeno65557LhMnTsTf35/69eszZMgQfvvtNx555BGGDh1agq+MKWmqOjyf/e8D77vTR1H+nBsBuJMg1wJ259jeA3TOq6GI1AMa4Bj6zuv4HcAdQIEf01QUPaKj+N/fu/hnVyydGlT2dDjGlBmqytw9c5n07yTWHllLjeAaPNXlKQY3Hoyfd8X+v+H+jvdz9fdXM2XNFO7veL+nwylTMjIz2HF8hyMRPryGtUfWsvHoRlIzHetZhfuH0yqyFRfWuZBWka1oWaUlUUFRJRqTiGSPBBNYopc6zbPfr2XdvuPF2meLmmE8M7Bloc/bs2cPixYtwtvbm+PHjzN//nx8fHz4/fffeeKJJ/j6669PO2fDhg38+eefxMfH07RpU+66667TyoUB9OrVK3uk98Ybb+T++x0/F6mpqSxbtgyA77//Pns7OTmZ6OhoZs+eTZMmTbjhhhuYOHEio0aNAqBKlSqsWLGi0M/RlC8icrGq/uaqXVES5JKYeT0U+EpVM/I66ByxngyOKRYlcP0ypWvjKnh7CfM2xViCbAyOFcL+3P0n7/77LuuPrqdWSC2e7fosAxsOxNf77FhUp2nlplza8FI+Xf8p1za7lurBZ2cpSFVlb8Le7CkSaw6vYd2RdSSlJwEQ5BNEiyotuK75dbSMbEnLKi2pHVK7LNw0dFa6+uqrs5PYuLg4brzxRjZv3oyIkJaWluc5AwYMwN/fH39/f6pWrcrBgwepXbv2ae3+/PPPPKdYDBkyJM/tjRs30qBBA5o0cSygcuONN/L2229nJ8i5zzMV1gdAXVeNipIgD3Sz3V6gTo7t2s59eRkK3F2EWCqksABf2teJYP7mGB7q29TT4RjjMZmaye87f+fdVe+y6dgm6obW5bnzn2NAwwH4ep0diXFOd7e/m593/Mw7K99h7PljPR1OqTh84nD2yHBWUhybEguAr5cvzSo3Y1CjQbSKbEWryFbUD6tfrqYhlISijPSWlODgk9NNn3rqKXr16sU333zDjh076NmzZ57n+PufnCbl7e1Nenp6ka+Z17a755nyS0Rm5ncIqOJOH0VJkD8GLnSj3VIgWkQa4EiMhwLX5W4kIs2ASsDiIsRSYXWPjmLC7E0cTUylcnDF/ujYmNwyMjP4deevTF41mS2xW6gfVp/nuz3PJQ0u8ViJrbKgVkgtrm12LdPWT+OGFjfQuFJjT4dUrBJSE1h9eDVrj6zNTooPJh0EwEu8aBTRiF51ejmmSUS2pElEk7PmE4SKIC4ujlq1agHw4Ycflvr1mzZtyo4dO9iyZQuNGzfmk08+4YILLij1OEyp6A4MBxJy7Rcc98i5VNiFQgRokrU/q8ZcXlQ1XUTuAX7BUeZtiqquFZGxwDJVzcruhwKfaUmV0yinejSJZPzvm1iw5TCD2tb0dDjGlIr0zHR+3vEzk1dNZnvcdhqFN+LlHi/Tp16fs35UMMvtrW/nm83fMGHFBN7q/Zanwyk2a4+s5Y5f7+B4qmPubN3QunSo1oFWVRwjw80qNyv3JfvOdo888gg33ngj//nPfxgwYMAZ95dzDnKbNm34+OOPC2wfEBDA1KlTufrqq7Nv0hsxYsQZx2HKpL+AJFWdm/uAiGx0p4MCy7w5h6iP41hx5ASOBHk+0A1AVXcWPuYzU9HLvGXJyFQ6PPcbfVpU479Xn17Sx5iKJD0znR+3/ch7q99j5/GdRFeKZkSbEVxU7yK8xCq55Pb+6vd5fcXrTO07lXOql/9ykOuOrOO2X28j1DeUp857itaRra1SRyGVpTJvxoBny7wVhwJ/86jqIOBrHDfItVXVHUCaqu70RHJ8NvH2Ero1jmTe5hhscN1UVGmZaczYPIOB3wzkyYVPEugTyISeE/hq4Ff0qd/HkuN8DG8+nKpBVRm/Yny5//9h/ZH13P7r7YT4hjCl3xS61epmybExptiJyKWFae/yt4+qfgNcAvQUke/IsTqJKVndoyM5eDyFzYdyT6ExpnxLzUjly01fcumMS3lm0TOE+4fz5oVv8sWlX9C7Xm9LjF0I8Ang7nZ3sypmFbN3zfZ0OEW28ehGbv/tdoJ8g5jSdwq1Qmp5OiRjTMVVqDub3brbRVUTgQdEpC1wXlGiMoWXc9npJtVCPRyNMWcuJSOFbzZ/wwdrPuBA4gHaRLZhdJfRdK/V3cpwFdKgRoP4eO3HvL7idS6oc0G5q+qx8ehGbvv1NgK8A5jSdwq1Q08v42WMMcWoUL9kCjVMo6r/quokyK4+YUpQzYhAGlcNYd7mw54OxZgzkpyezKfrP6X/1/0Z9/c4qgdV592L3mVa/2n0qN3DkuMi8PHy4b4O97Hj+A6+2fyNp8MplE3HNnH7r7fj5+3H1L5TqRNax/VJxhhzZu4sTOMzqZf0K24UWjZnpnt0JP/7exfJaRkE+Npd/KZ8OZp8lO+3fs/UNVM5knyEjtU68nz35+lUvZMlxcWgZ52edKjagXdWvsOlDS8tF1UeNh/bzG2/3Iavl68jOQ6z5NgYU/xEJAToh2NNjgxgk4h4qTrXm3fBVZm3N/I7BEQUIk5TRD2aRDF14Q6WbD+aPeXCmLLsYOJBZu+azexds1l2cBmZmknn6p35b9v/cm71cz0dXoUiItzf8X6u/+l6Pl73MSPalu2SVVuObeG2X2/Dx8uHKf2mUDfMxliMMcVPRK4BHgJWAb2ARUBn4GURGaaqq1314WoE+WbgQSAlj2PXFi5cUxSdG1TGz9uL+ZtjLEE2Zdbu+N38vvN3ft/1O6tiHOXTG4U34rbWt9GnXh+aVrYVIUtKu6rt6F23N1PXTOWaptdQOaBsLk+/NXYrt/56K17ixQd9P6BeWD1Ph2SK0ZEjR+jduzcABw4cwNvbm6gox++sJUuW4OdX8P39c+bMwc/Pj65duwIwb948Ro0axapVq/jss8+46qqr8jzP29ub1q1bZ28PHTqUxx57rDiekinfngS6qGqSiEQCn6pqXxFpA7wLdHXVgasEeSmwRlUX5T4gImOKELAppCA/H85tUIl5mw4z+szrqhtTLFSVrbFb+X3X78zeNZsNRzcA0Lxyc0a2H0nver1pGN7Qw1GePe7rcB9zds/h3X/f5fHOj3s6nNNsi9vGrb/ciiB80PcDGoQ38HRIpphVqVKFlStXAjBmzBhCQkJ46KGH3D5/zpw5hISEZCfIdevW5cMPP+SVV14p8LzAwMDs6+YnIyMje0GRvLbdPc+UK4Jj/Q6ARKAqgKquEpEwdzpwdZPeVcDKvA6oqv0PV0q6R0ex8WA8B48nezoUcxZTVdYeWcvrK15n0LeDuHzm5byz8h0CfQJ56JyH+PnKn/li4Bfc3uZ2S45LWYPwBlwefTlfbPqC3cd3ezqcU2yP286tv9yKokzpO8XeG2eR5cuXc8EFF9CxY0f69u3L/v37AXjjjTdo0aIFbdq0YejQoezYsYNJkyYxfvx42rVrx/z586lfvz5t2rTBy6toJR/r16/Po48+SocOHfjyyy9P254+fTqtW7emVatWPProo9nnhYSE8OCDD9K2bVsWL15cLK+D8YhZwM8iMhrHPXNfAohIZdysZlHgCLKqHs363tnpKftM6egRHcWLP21g3qYYrj7HbmgxpSdTM1l5aKVjpHjnbPYl7sNbvDm3+rkMbz6cC+teSFSQTf0pC/6v7f/x47YfefOfN3n5gpc9HQ4AO+J2cOsvt5KpmY7kOMKS41Lx02NwwOUUy8Kp3houedHt5qrKvffey3fffUdUVBSff/45o0ePZsqUKbz44ots374df39/YmNjiYiIYMSIEYUedQY4ceIE7dq1y95+/PHHGTJkCOAY1V6xYgUAjz32WPb2vn376NKlC8uXL6dSpUr06dOHb7/9lsGDB5OYmEjnzp159dVXCxWHKVtU9VER6Q+0AMaq6m/OQ7FAB3f6cHWTXl3gZaC3s1NxDk3/ATzmXFnPlLBm1UOJDPFn/ubDliCbEpeWmcayA8v4fefv/LH7Dw6fOIyvly9da3blrnZ30bN2TyICIjwdpsklKiiK61tcz+RVk7mx5Y20jGzp0Xh2Ht/Jrb/cSoZm8H6f92kU0cij8ZjSlZKSwpo1a7j44osBx3SFGjVqANCmTRuGDRvG4MGDGTx48Bldp6ApFlmJcu7tpUuX0rNnz+w50sOGDWPevHkMHjwYb29vrrzyyjOKyZQNqjoLx0hyzn2Z5H1f3WlczUH+HJgADFPVDAAR8QauBj4DuhQyXlMEXl5Cj+hI/th4iE0H423REFPsUjJSWLxvMb/v/J05e+YQlxJHoE8g3Wt156J6F9G9VndC/EI8HaZx4eaWN/Plxi8Zv3w87/V5z2Ol9HYd38Utv9xCWmYa7/d9n+hK0R6J46xViJHekqKqtGzZMs9pCj/++CPz5s3j+++/Z9y4caxeXcyj3U7BwcEFbuclICDA5h1XcCKyWlVbu2rnKkGOVNXPc+5wJsqfichzZxKgKZxhXerx+/qDXPL6fIZ1rsv9FzWhUrCt+m2KLiktiXl75zF752zm7ZlHUnoSob6h9KzTk4vqXUTXml0J8AnwdJimEEL8Qriz7Z28uORFFu1bxPm1zi/1GHYf380tv9xCakYq7/d5nyaVmpR6DMbz/P39iYmJYfHixZx33nmkpaWxadMmmjdvzu7du+nVqxfdunXjs88+IyEhgdDQUI4fP14qsXXq1ImRI0dy+PBhKlWqxPTp07n33ntL5dqmdIjIFfkdAqq704erBHm5iLwDfARk3flRB7gR+MedC5ji0bFeJeY83Ivxv21i2l87+W7lPkZdFM3wLvXw9S7aTQzm7BOXEsfcPXP5bedvLNq7iNTMVCoHVKZ/w/5cVPciOlXvhK93+Vqy2Jzq6iZX88m6Txi/fDzn1TwPLym9/x92x+/mll9vITkjmQ/6fGDl/c5iXl5efPXVV4wcOZK4uDjS09MZNWoUTZo0Yfjw4cTFxaGqjBw5koiICAYOHMhVV13Fd999x5tvvklAQACXX345x44d4/vvv+eZZ55h7dq1p10n9xzkfv368eKLBY+g16hRgxdffJFevXqhqgwYMIDLLrusuF8C41mfA58Cmscxt0Z+RDWvc50HRfyAW4HLgFrO3XuA74EPVNWteRzFKTg4WBMTE0v7smXKxgPxPPfDOhZsOUzjqiE8OaA5PZtW9XRYpow6fOIwf+z6g9m7ZrNk/xLSNZ1qQdW4qN5FXFT3ItpXbY+3l32kWJHM2jaLR+c/yvPdnmdgo4Glcs29CXu5+eebSUxL5P0+79O8SvNSua5xWL9+Pc2b22tuyo683pMikqSqrue6nCERWQ7cqKpr8ji2W1Vd3tBVYIJcFlmC7KCqzF5/iHGz1rP9cCI9m0bx5IAWNK5q80QNHEg8wO87f+e3nb/xz6F/UJS6oXWzk+JWka1sqecKLFMzGfrDUOJS4ph5+Uz8vf1L9Hr7EvZx8883E58Wz/t93qdFlRYlej1zOkuQTVnj4QS5O7BTVXflcewcVV3msg9XCbKI9AVqA7+r6s4c+29R1SmFD/vMWIJ8qtT0TD5atIM3Zm/mRFoG159Xj1G9mxAeZB+Tn61WHlqZfYNUdKVoLqp7ERfVu4joiGhLis8ii/ct5o7f7uDhcx7mhpY3lNh19ifs5+ZfbuZ46nHe6/MeLat4tnrG2coSZFPWeDJBLg6uplg8D3QDVgADgQmq+qbz2ApVdauWXHGyBDlvhxNSeO23TXy2ZBdhgb48cHETrutUFx+bn3xWSUhN4KrvHUuyTrpoEvXD63s2IONRd/52J2uPrGXWFbMI83Nr8ahCOZB4gJt/vpm4lDgm95lMq8hWxX4N4x5LkE1Z4+ERZB8cU4QvB2o6d+8FvsMxRTjNVR+usqeBwIWqOgroCFwiIuOzrl+UoE3JiAzx5/nLW/PjyO40rx7G09+tpf8b85m/OcbToZlS9MKSF9ifuJ8Xur9gybFhVIdRxKXEMXXN1GLv+0DiAW755RZiU2J59+J3LTk2xpwREakjIn+KyDoRWSsi9+XRZpiIrBKR1SKySETa5tPdJ0A7YAzQ3/l4FmgLTHMnHlcJso+qpgOoaiyOhDlMRL4ErMZYGdS8Rhj/u70zk4Z3JDktk+s/WMJtHy1l+2Ebda/oftr+EzO3zuSONnfQvmp7T4djyoDmVZozoOEApq2bxsHEg8XW78HEg9z6y60cTT7Kuxe/S+solyVFjTHGlXTgQVVtgWOdjbtFJPcNDduBC5x1jJ8DJufTV0dVvUtV/1LVPc7HX6p6F+DWL0hXCfJWEbkga0NVM1T1VmAjYJ/llFEiQr9W1fntgR48dkkz/tp2lD7j5zLux3XEnXD5qYIph/Yn7Oe5xc/RJqoNd7a509PhmDLk3vb3kqEZTPx3YrH0dyjpELf+eitHko8w6aJJtIlqUyz9GmPObqq6X1VXOL+PB9ZzsoJaVptFqnrMufkXjnvk8nJURK4WOVnnUkS8RGQIcCyfc07hKkG+GliSx5N4Ekc9ZFOG+ft4M+KCRvzx0AVc0b427y/YzoWvzOHTv3eSkVm+qpeY/GVkZvD4gsfJ0Axe7P4iPl6uypubs0mtkFoMaTqEb7Z8w9bYrWfUV0xSDLf+cisxSTFMumgS7aq2K54gTbl35MgR2rVrR7t27ahevTq1atXK3k5NTXV5/pw5c1i0aFH29muvvUaLFi1o06YNvXv3ZufOnXme5+3tnX2ddu3auayBbDzOR0SW5XjckVcjEamPY6T37wL6uhX4KZ9jQ4GrgIMisklENgEHgCucx1xydZNedVU9UGAHbrQpTnaTXtGt2RvH2O/XsWTHUZpVD+XpgS3o2ijS02GZM/Teqvd44583GNdtHIMaDfJ0OKYMOpZ8jP4z+nNO9XN488I3i9TH4ROHufnnmzmYdJBJF02iQ7VSv0fbFKAs3aQ3ZswYQkJCeOihh4p8zp9//knnzp0JCgpi4sSJzJkzh88///y080JCQkhISCiw74yMjFOWj8697e55pnCKepOeiIQAc4Fxqjojnza9gHeAbqp6xEV/VQBctcvN1QjyLDf6cKeNKQNa1Qrn8zu78M6wDiSkpHPde39z5yfL2HnE/uAor1bHrOadle/Qr34/BjYsnQUhTPlTKaASt7S6hTm757Di4IpCn3/4xGFu+eUWDiYdZOJFEy05Nm5Zvnw5F1xwAR07dqRv377s378fgDfeeCN7dHjo0KHs2LGDSZMmMX78eNq1a8f8+fPp1asXQUFBAHTp0oU9e/YU6tr169fn0UcfpUOHDnz55ZenbU+fPp3WrVvTqlUrHn300ezzQkJCePDBB2nbti2LFy8uvhfDuEVEfIGvgU8LSI7bAO8DlxWU9IpImIg0UtUjOds5z3fJ1WexbUWkoMXRBSidxdNNsRAR+reuwYXNqvLBgu28/ecWLn5tHjd3q889vRoTGmD1k8uLpLQkHpv/GFFBUTx13lNW49gUaHiL4Xy24TNeW/4an1zyidvvlyMnjnDbL7dxIPEAb/d+m47VOpZwpOZMvbTkJTYc3VCsfTar3IxHOz3quqGTqnLvvffy3XffERUVxeeff87o0aOZMmUKL774Itu3b8ff35/Y2FgiIiIYMWJEvqPOH3zwAZdcckme18m91PTjjz/OkCFDAKhSpQorVjj+IHzssceyt/ft20eXLl1Yvnw5lSpVok+fPnz77bcMHjyYxMREOnfuzKuvvlqIV8cUB3H8p/QBsF5VX8unTV1gBnC9qm4qoK9rgAnAIWfSfZOqLnUe/hBw+Vd+gQmyqtpnCxVUgK83d/dqzFUda/Pyzxt5d+42vl6+l4f7NuGqjnXw9rJkq6x7aelL7I7fzZS+U0qkxq2pWAJ9Avm/dv/HmMVj+GP3H/Su29vlOUeTj3Lbr7exN2Ev71z0DudWP7cUIjUVQUpKCmvWrOHiiy8GHNMVatSoAUCbNm0YNmwYgwcPZvDgwQX2M23aNJYtW8bcuXPzPB4YGMjKlSvzPJaVKOfeXrp0KT179iQqKgqAYcOGMW/ePAYPHoy3tzdXXnmlu0/TFK/zgeuB1SKy0rnvCaAugKpOAp4GqgDvOP/IT1fVc/Lo6wkclSz2i0gn4BMReVxVv8HNMsV2N89ZrlpYAK9e05Ybu9Zj7PfrePTr1Xy8eCdPX9qCzg2reDo8k4/fdv7GjM0zuL317ZxTPa//G4w53WWNL+OjdR/x+orXuaD2BQXe0JmVHO+J38Nbvd+y5LgcKcxIb0lRVVq2bJnnNIUff/yRefPm8f333zNu3DhWr16dZx+///4748aNY+7cufj7F3659ODg4AK38xIQEGDzjj1EVRfgInlV1duA29zozltV9zvPWeKcs/yDiNQB3KpSYMusGQDa1I7gyxHn8ca17TmWmMqQyX/xf58uZ/fRJE+HZnI5kHiAMYvG0KpKK+5qd5enwzHliI+XD6M6jGJ73Ha+2fJNvu2OJR/j9l9vZ9fxXbzZ+0061+hcilGaisDf35+YmJjsBDktLY21a9eSmZnJ7t276dWrFy+99BJxcXEkJCQQGhpKfHx89vn//PMPd955JzNnzqRq1arFGlunTp2YO3cuhw8fJiMjg+nTp3PBBRe4PtGUJ/Ei0ihrw5ks9wQuA1q604ElyCabiDCobU1mP9iTBy5uwp8bYuj92lz++8sGElPSPR2eATI1k9ELRpOWmcaLPV7E18vmjJvC6VWnF+2i2jFx5USS0k7/Azg2OZbbf72dncd38uaFb9KlRhcPRGnKOy8vL7766iseffRR2rZtS7t27Vi0aBEZGRkMHz6c1q1b0759e0aOHElERAQDBw7km2++yb5J7+GHHyYhIYGrr76adu3aMWhQ3hV6suYgZz0ee+wxl7HVqFGDF198kV69etG2bVs6duzIZZddVtwvgfGsu8g1Gu2srdwPuMWdDgos81bgiSIhqlpwbZUSYGXeSs/+uBO8/PNGvvlnL1Gh/jzStylXdqiNl81P9pgpa6Ywfvl4xnYdy+XRl3s6HFNOrTy0kut/up5729/LHW1OliGNS4njtl9vY1vsNt688E261urqwShNYZSlMm/GQNHLvJUVZzKCvK7YojBlUo3wQMYPaceM/+tKrYhAHv5qFYPfWciyHUc9HdpZae2Rtbz5z5tcXO9iBjce7OlwTDnWrmo7LqxzIVPWTOFYsmNRqbiUOG7/9Xa2xm7l9Qtft+TYGFNuicgPZ9rG1UIhD+R3CBitqpVdBVDcbATZMzIzlZn/7uPFnzZw4HgyvZtVpW+r6vRqWpWo0MLfPGEKJyktiSE/DCEpPYkZg2YQ7h/u6ZBMObctdhuXz7yc65pdx4i2I7jjtzvYfGwzE3pNoEftHp4OzxSSjSCbssaTI8giEgvMK6gJ0FJVG+bXwFUVi+eB/wJ5TUB1OfosIv2A1wFv4H1VPW0NSGetujE47ir8V1Wvc9WvKX1eXsLg9rXo07Ia787dxudLdzN7wyEA2taJ4MKmVendvCota4ZZPd4S8MqyV9h5fCfv93nfkmNTLBpGNOTyxpfz2cbPWHpgKVvjtvJ6r9ctOTbGVATuTCovcA10VyPIi4B7VXV5Hsd2q2qdAs71BjYBFwN7gKXAtaq6LkebaOAL4EJVPSYiVVX1UEEB2why2aCqrNt/nD/WH+KPjYdYuTsWVagW5k+vplW5sFlVukVHEuRnlQTP1Oxdsxn15yhubnUzD3TM70MdYwrvUNIhBswYQLqmM77neHrW6enpkEwR2QiyKWvK+xxkVwlyU+CIqh7O41g1VT1YwLnnAWNUta9z+3EAVX0hR5uXgU2q+r67AVuCXDYdTkhhzsYY/thwkHmbDpOQko6fjxfnNaxC7+ZV6dW0KnUqB3k6zHLnUNIhrpx5JTWCa/Bp/0/x9baqFaZ4Ld63mACfANpXbe/pUMwZsATZlDXlPUF2tZLeRgARuVpVv8x1uAeQe19OtYDdObb3ALmLaTZx9r8QxzSMMar6c+6OROQO4A4APz+/gkI2HhIZ4s9VHWtzVcfapKZnsmzHUWZvOMQfGw7x9HdrgbU0qRbChc2qcWGzqnSoG4GPt1UZLEimZvLkgidJTk/mpR4vWXJsSsR5Nc/zdAjGGFPmuPv59+Ocngznta8o14/GUby5NjBPRFqramzORqo6GZgMjhHkM7ymKWF+Pl50bRxJ18aRPHVpC7bFJPCHM1l+f/42Js3dSnigLz2bRnFhs6pc0CSKiCD7wye3aeumsXj/Yp4+72kahDfwdDjGGGPMWaPAITwRuURE3gRqicgbOR4fkveNezntBXLOUa7t3JfTHmCmqqap6nYcc5ajC/UMTJnXMCqE27o35H+3d2HF0xfzzrAOXNS8Ggs2H+a+z1bS4bnfuGbSYibN3crmg/EUtTZ3RbLh6AYmrJhArzq9uCr6Kk+HY4ypaFZ9AeNbwZgIx9dVX5xRd0eOHMlerKN69erUqlUrezs1tcB7oQCYM2cOixYtyt6eN28eHTp0wMfHh6+++irf80SE4cOHZ2+np6cTFRXFpZdeCsDMmTN58cXT6gMUyNvb+5TFRwp7fmGNGjWKefMKKrhwkqoycuRIGjduTJs2bVixYkWe7fr160fbtm1p2bIlI0aMICMjA4Avv/ySli1b4uXlxbJly045Z9WqVZx33nm0bNmS1q1bk5ycDMDo0aOpU6cOISEhp7R/6623mDJlSmGfbqkQkdUisiq/hzt9uBpB3gcsAwYBOW/Uiwfud3HuUiBaRBrgSIyHArkrVHwLXAtMFZFIHFMutrkTuCmfwgJ86d+6Bv1b1yAjU/l3Tyx/bjjE7PWHePGnDbz40wZqVwqkd7OqXNi8Gp0bVCbA19vTYZeqE+kneHTeo0T4R/Bs12etKogxpnit+gK+HwlpJxzbcbsd2wBtrilSl1WqVGHlypUAjBkzhpCQEB566CG3z58zZw4hISF07eqov123bl0+/PBDXnnllQLPCw4OZs2aNZw4cYLAwEB+++03atWqlX180KBB+a7Cl5/AwMDs55KfjIwMvL29891297wjR47w119/MWHCBLdi++mnn9i8eTObN2/m77//5q677uLvv/8+rd0XX3xBWFgYqspVV13Fl19+ydChQ2nVqhUzZszgzjvvPKV9eno6w4cP55NPPqFt27YcOXIEX1/HtL6BAwdyzz33EB196vjlLbfcwvnnn88tt7i1MF1pu9T59W7n10+cX4e520GBI8iq+q+qfgQ0VtWPnN/PBLao6jEX56YD9wC/AOuBL1R1rYiMFZGsd+svwBERWQf8CTysqkfcDd6Ub95eQoe6lXiwT1Nm3dedxY9fyLjLW9GseiifL9vNjVOW0H7sb9z+8TI+W7KLg8eTPR1yqXht2Wtsi9vGf7r9h0oBlTwdjjGmopk99mRynCXthGN/MVq+fDkXXHABHTt2pG/fvuzfvx+AN954gxYtWtCmTRuGDh3Kjh07mDRpEuPHj89earp+/fq0adMGLy/X96r079+fH3/8EYDp06dz7bXXZh/78MMPueeeewC46aabGDlyJF27dqVhw4YFjkznpX79+jz66KN06NCBL7/88rTt6dOn07p1a1q1asWjjz6afV5ISAgPPvggbdu2ZfHixaf0+fXXX9OvXz+3Y/juu++44YYbEBG6dOlCbGxs9uuaU1hYGOBIfFNTU7MHWpo3b07Tpk1Pa//rr7/Spk0b2rZtCzj+4MlK5Lt06UKNGjVOOycoKIj69euzZMkSt+MvLaq6U1V3Aher6iOqutr5eAzo404f7s5B/s2Z1PrgGEk+JCKLVLXAUWRVnQXMyrXv6RzfK/CA82HOcjXCAxnWuR7DOtcjOS2DxVuPZM9d/m2do2BKq1phXNisGr2bVaV1rfAKt+z13N1z+WzjZ9zQ4ga61rSVzIwxJSBuT+H2F4Gqcu+99/Ldd98RFRXF559/zujRo5kyZQovvvgi27dvx9/fn9jYWCIiIhgxYkShR52zDB06lLFjx3LppZeyatUqbrnlFubPn59n2/3797NgwQI2bNjAoEGDuOqq06ewnThxgnbt2mVvP/744wwZMgRwJI5Z0xoee+yx7O19+/bRpUsXli9fTqVKlejTpw/ffvstgwcPJjExkc6dO/Pqq6+edq2FCxeeEsP999/Pn3/+medzfOyxx9i7dy916pycvVq7dm327t2bZwLbt29flixZwiWXXJLn88xp06ZNiAh9+/YlJiaGoUOH8sgjjxR4DsA555zD/Pnz6dSpk8u2HiIicr6qLnRudMXNVaTdTZDDVfW4iNwGfKyqz7g7h8OYogjw9aZXs6r0alaVsapsPBjP7PWH+HPDId76YzNvzN5MZIg/vZpG0bVxFVrXCqdBZAje5ThhPnziME8vepomlZpwX4f7PB2OMaaiCq/tmFaR1/5ikpKSwpo1a7j44osBx9SCrCSuTZs2DBs2jMGDBzN48OAzvlabNm3YsWMH06dPp3///gW2HTx4MF5eXrRo0YKDB/OuVFvQFIusRDn39tKlS+nZsydRUVEADBs2jHnz5jF48GC8vb258sor8+xv//792ecAjB8/vsD4C+OXX34hOTmZYcOG8ccff2T/W+QlPT2dBQsWsHTpUoKCgujduzcdO3akd+/eBV6jatWqbNiwodhiLgG3AlNEJBzH6nnHALfmhLibIPuISA3gGmB0kUI0pohEhGbVw2hWPYy7ezXmaGIqczc55i3/vPYAXy53jHoE+XnTokYYrWqF07JmGK1rh9M4KqRclJNTVZ5c+CSJaYlM6TsFP2+r6mGMKSG9nz51DjKAb6BjfzFRVVq2bHnalAKAH3/8kXnz5vH9998zbtw4Vq9efcbXGzRoEA899BBz5szhyJH8Z2r6+/ufEmNhBQcHF7idl4CAgHznJwcGBmbfDAeuR5Br1arF7t0n/7jZs2fPKXOu87r2ZZddxnfffVdggly7dm169OhBZGQk4Ji2smLFCpcJcnJyMoGBgQW28STnQndtnQkyqhrn7rnuJshjccwXXqiqS0WkIbC50JEaUwwqB/txefvaXN6+NukZmWyNSWT13jjW7I1j7b44vli2m6RUxx27/j5eNKsRRquaYbSuFU6rWuFEVwvB36ds3fj3vw3/Y+HehYzuPJpGEY08HY4xpiLLuhFv9ljHtIrw2o7kuIg36OXF39+fmJgYFi9ezHnnnUdaWhqbNm2iefPm7N69m169etGtWzc+++wzEhISCA0N5fjx40W+3i233EJERAStW7dmzpw5xfY83NWpUydGjhzJ4cOHqVSpEtOnT+fee+91eV7z5s3ZsmULPXv2BFyPIA8aNIi33nqLoUOH8vfffxMeHn7a9IqEhATi4+OpUaMG6enp/Pjjj3Tv3r3Afvv27cvLL79MUlISfn5+zJ07l/vvd1WLwTE14/zzz3fZzlOcifEzONbuQETmAmPdSZTdSpCdi4R8mWN7G5D35wXGlCIfby+aVg+lafVQruro+HgwI1PZfjiRtfscSfPqvXHMXLmPT//eBYCvt9C0eiitaobTslY4rWuF06x6qMeqZWw6tonXlr1Gj9o9GNJ0iOsTjDHmTLW5plgT4ty8vLz46quvGDlyJHFxcaSnpzNq1CiaNGnC8OHDiYuLyy5ZFhERwcCBA7nqqqv47rvvePPNNwkICODyyy/n2LFjfP/99zzzzDOsXbs23+vVrl2bkSNHFkvsuecg9+vXz2Wptxo1avDiiy/Sq1cvVJUBAwZw2WWXubzWgAEDePfdd7ntttvciq1///7MmjWLxo0bExQUxNSpU7OPtWvXjpUrV5KYmMigQYNISUkhMzOTXr16MWLECAC++eYb7r33XmJiYhgwYADt2rXjl19+oVKlSjzwwAOce+65iAj9+/dnwIABADzyyCP873//Iykpidq1a3PbbbcxZswYwDGHOuv7MmoKsAbHDAiA64GpwBWuTixwqensRiJNgIlANVVtJSJtgEGq+p8ih1xEttS0KYrMTGX3sSTnSPNx1u5zJM6xSWmAo6JGdNUQWtYMp3UtxzSN5jXCCPZ390OWoknJSGHoD0M5mnyUGYNmUCWwSolezxhTMdlS0+VXt27d+OGHH4iIiPB0KIXyzz//8Nprr/HJJ5/kebwsLDUtIitVtZ2rfXlx97f/e8DDwLsAqrpKRP4HlHqCbExReHkJ9aoEU69KMJe2qQk45p/tjT1xSsI8d9Mhvl7hmNMsAo2iQmhVM2teczgta4URFlB8Sz5PWD6BLbFbeKf3O5YcG2PMWejVV19l165d5S5BPnz4MM8995ynw3DlhIh0U9UFACJyPnDCxTmA+wlykKouybVggauV9Iwp00SE2pWCqF0piH6tqgOOpPlQfEr21Iw1e4/z9/ajfLtyX/Z59asEZU/NaFXTcUNgpeDC31S3YO8Cpq2fxrDmw+heu+D5YcYYYyqmzp07ezqEIinopr8y5C7goxxVLI4CN7lzYoEJsojUVdVdwGERaQSoc/9VwOmVqY0p50SEamEBVAsLoHfzatn7Y+JTWLsvjrX7jrN6Txz/7o7lx1UnfwRqVwqkVc1wWtQMo3mNMFrUDKNmeEC+q+AdOXGEJxc8SeOIxtzf0fWNEMYY44qq2sqbpkwoSoWQkqCqK3FUsQhzbrt9J2iBc5BFZIWqdnAmx+8CXXHUkNsODFfVHWcQd5HYHGRTVsQmpToSZmcFjTV749hxJCn7eHigL82qh55MmmuE0bhqCP4+Xtz7x70s3reY6ZdOp0mlJh58FsaYimD79u2EhoZSpUoVS5KNR6kqR44cIT4+ngYNGpxyrLTmIIvIcFWdJiJ5LkSnqq+56sPVFAtxdrQVuEhEggEvVY0vdLTGVDARQX6c3ziS8xtHZu9LTElnw4F41u0/znrn47MluzmR5ig75+0l1Ki9grjguXSvfCsHYipR2TeFyBD//C5jjDEu1a5dmz179hATE+PpUIwhICCA2rWLb+GZIshKwkOL2oGrEeRDwGf5HVfV4qmpUgg2gmzKm4xMZeeRRNbvj2fx7nXMjHkYr5RGxG6/EeffoESF+mePMjevEUqLGmE0iAwuF4ucGGOMMe4ozSoWIuINjFTVIi1P6CpB3gnku7SOqn5UlIueCUuQTXmVmpHKdT9ex6GkQ8y4bAbemWGsP3CcdfuOs35/POv3H2fzoXjSMhw/k/4+jhrPzas7kubmNcJoXrN4q2gYY4wxpcUDZd6WqGqnIp3rzhzkIkdWAixBNuXVK0tf4aN1H/HmhW/Ss07PPNukpmeyNSYhe3qGY6pGPEcTU7Pb1K4UmGO02fG1TuVAm3dojDGmTPNAgjwe8AU+B7KTR1Vd4epcV3OQU10cN8a4YfG+xXy07iOGNB2Sb3IM4Ofj5RgprhGWvS+r9Ny6fcdPmds8e/1BMp1/34b4+5wcZXY+mlQLIcivZBc6McYYY8qwds6vY3PsU+BCVye6tZJeWWIjyKa8OZZ8jCtnXkmoXyifXfoZgT6BxdLvidQMNh6MPznavO84Gw7Ek5DiKFEu4hhtblotlOhqoc6vITSKCvHYstrGGGPOXqU9gnwmLEE2pgSpKvf9eR/z985n+oDpNKvcrESvl5mp7Dl2gnX7j7PpYHz2Y1tMIunO4WYvgfpVgomuFnIyea4eSv0qwfj52E2BxhhjSoYHplhUA54HaqrqJSLSAjhPVT9wea4lyMaUnK82fcWzi5/loXMe4saWN3osjtT0THYcSXQmzAlsOhDPpkPx7DicmD1Nw8dLaBgVnD3a3KRaCNHVQqlXOciqaRhjjDljHkiQfwKmAqNVta2I+AD/qGprl+e6uEmvckEnq+rRwgZ7pixBNuXF9rjtDPlhCG2j2vLuxe/iJWUvyUxOy2BbTOIpo82bDiaw+1gSWf81+Pl40SgqhKbOhNmRPIdSu1IgXl52Y6Axxhj3eCBBXqqq54rIP6ra3rlvpaq2c3Wuqzt4luOYzCxAXRyr6AkQAewCGuR7pjFnsbSMNB6b/xh+3n6M6zauTCbHAAG+3rSo6VgaO6ek1HS2HEpwjDY7E+cl24/y7cp92W0Cfb2JrhZCdNVQmlY/mTzXKGCJbWOMMaYUJYpIFRy5LCLSBYhz58QCE2RVbeDs8D3gG1Wd5dy+BBh8BgEbU6G9tfIt1h1Zx4SeE6gaVNXT4RRakJ8PbWpH0KZ2xCn745PT2HzIOUXDmTzP3xzD1yv2ZLcJ9fchuloITXLcHNisRqitFmiMMaa0PQDMBBqJyEIgCrjKnRPdmoMsIqtzz9fIa19psCkWpqxbsn8Jt/16G1dEX8GYrmM8HU6piE1KPWW0OWuqRs76zZEh/jSvEUqz6qE0qx5GsxqhNK4agr+PVdQwxpizgSeqWDjnHTfFMQNio6qmuXWemwnyL8B8YJpz1zCgh6r2LVq4RWcJsinL4lLiuGLmFQT5BPH5pZ8T5Bvk6ZA86nBCChsPxLPhQDwb9jvK0G06GE9KeiYA3l5Cw8hgmtUIo1n1UGcCHWbTNIwxpgLywBzkAOD/gG44plnMByaparLLc91MkCsDzwA9nLvmAc/aTXrGnKSqPDj3Qf7c9SfTBkyjZZWWng6pTErPyGTHkSRn4uxYKXDDgePsOXYiu01YgA/NaoTRvHpodvLctHqoLXxijDHlmAcS5C+AeE4O8F4HRKjq1S7PtTJvxhSPbzZ/w9OLnmZUh1Hc2vpWT4dT7hxPTmPTgXjW5xht3rD/OImpGYBj4ZN6lYOyp2c0q+5InOtWDrJqGsYYUw54IEFep6otXO3Li1vDMSLSBHgIqJ/zHFV1uVSfMRVdemY6H679kLdXvs251c/lppY3eTqkcikswJdz6lfmnPonq0tmZip7Y0+wPithPuD4+su6A9ll6IL8vGlS7eT0jKw5zuFBvh56JsYYY8qIFSLSRVX/AhCRzsAyd050d4rFv8AkHGXfMrL2q+ryIoV7BmwE2ZQl2+O28+SCJ1l1eBUX17uYp7s8TURAhKfDqvBOpGaw+VA8G/bHs/7A8eyvsUkn772oGR6QPT0ja7pGg8hgW/TEGGM8xAMjyOtx3KC3y7mrLrARSAdUVdvke66bCfJyVe1YDLGeMUuQTVmQqZn8b/3/eH3F6/h5+/FklyfpV7+f3VjmQarKofiUk6PNzq9bDiVkL7Pt5+1Fg8hgGlcLIbqqsxRd1RDq2TLbxhhT4jyQINcr6Liq7sz3XDcT5DHAIeAbICVHx3aTnjnr7E3Yy1MLn2LpgaX0qN2DZ857plzWOj5bpKZnsu1wQvYo89ZDCWw+lMCuoydXC/TxEupHBhNd1ZE4N3Ymzg0igwnwtTJ0xhhTHDxR5q2o3E2Qt+exW1W1YfGHVDBLkI2nqCozNs/g5aUvIyI8eu6jDG482EaNy6nktAy2HEpgy6EENh+KZ/NBx/c7jiTiHHDGS6BelWAaOxPnrJUDG0WFEOhnibMxxhRGhUuQyxJLkI0nHEo6xDOLnmHB3gV0qt6J585/jpohNT0dlikBKekZbD+cyOaDjpHmLc7kefvhxOypGiJQu1IgTaqGOqdrOEacG1UNIcTfStEZY0xeKmSCLCKtgBZAQNY+Vf24hOLKlyXIpjSpKrO2z+L5v58nNSOV+zvez9BmQ/ESm696tklNz2TnkUQ2H0pwJs+O+c3bYhJJzcjMblcrIvCUEefGVR0rBoYHWlUNY8zZrcIlyCLyDNATR4I8C7gEWKCqbq1nXZwsQTal5WjyUf7z13/4bedvtI1qy7hu46gXVuB8f3MWSs/IZNfRJOdocwKbnctsb41JyF4xEKBamD/RzmQ5uloITas5qmvYiLMx5mxRWgmyiNQB/gvUAn4C/pu1xLSIfKuqg1324WaCvBpoC/yjqm1FpBowTVUvdnFeP+B1wBt4X1VfzHX8JucT2Ovc9Zaqvl9Qn5Ygm9Iwe9dsxi4eS3xqPPe0v4cbW9yIt5fNOTXuy8hU9hxLyp6qkTXivPlgAifSsqtlUr9KEC1qhtGiRpjzazjVwvxtbrsxpsIpxQT5N+Br4C/gVqAjMFBVj4jIP6ra3lUf7g5dnFDVTBFJF5EwHBUt6rgIzht4G7gY2AMsFZGZqrouV9PPVfUeN+MwpkTFpcTx0pKX+H7b9zSv3Jz3+7xPdKVoT4dlyiFvL6FelWDqVQnmohbVsvdnLX6y6WA86/YdZ93+46zdd5xZqw9kt6kc7JcjYXZ8bWg1nI0xxl1RqjrJ+f29IjIcmCcigwC35ha7myAvE5EI4D0ci4UkAItdnNMJ2KKq2wBE5DPgMiB3gmxMmbBw70KeXvQ0R04cYUTbEdzR+g58vW3eqCleXl5CncpB1KkcRO/mJxPn+OQ0NhxwJs3OxPnDhTuy5zf7+XjRrHroKYmzTdEwxpg8+YpIgKomA6jqNBE5APwCuDWCXegqFiJSHwhT1VUu2l0F9FPV25zb1wOdc44WO6dYvADEAJuA+1V1dx593QHcAeDn59cxJSUldxNjiiwxLZFXl73Kl5u+pGF4Q57v9jwtI1t6OixjSMvIZFtMIuv2x50y2pxzxUCbomGMKS9KcYrF/cAKVZ2ba3974GVXU4ShBMu8uZkgVwESVDVFRO4EhqjqhQX1a3OQTXFadmAZTy58kn0J+7ix5Y3c0/4e/L39PR2WMflSVQ4cTz5lpHnd/uPsPJKU3camaBhjyiIPrKR3vqoudLUvz3NLMEE+Dxijqn2d248DqOoL+bT3Bo6qanhB/VqCbIpDcnoyb/zzBtPWTaNWSC3GdRtHh2odPB2WMUWW1xSNjQfjSXVW0vDPmqKRI2luWt2maBhjSo8HEuQVqtrB1b68lOT/jEuBaBFpgKNKxVDgupwNRKSGqu53bg4C1pdgPMYAsDpmNU8seIIdx3cwpOkQHuj4AEG+QZ4Oy5gzEhrgy7n1K3Nu/crZ+/KaovHzmgNMX+KYySYC9asE0ygqhDqVA6lbOYg6lYKoWyWI2pUCCfKz5NkYU/44B2m7AlEi8kCOQ2E4Kqu55Pb/fs4R3mo5z1HVXfm1V9V0EbkHx4Rob2CKqq4VkbHAMlWdCYx03lGYDhwFbnI3HmMKKy0jjYn/TmTKmilEBkby7sXv0rVmV0+HZUyJ8fX2omn1UJpWD+VyZ1GjvKZobD+cyKKth0lKzTjl/MgQf+pUDnQkzZWDHN87k+ga4QE2ZcMYU1b5ASE4ctbQHPuPA26t4eFuHeR7gWeAg0BW5XtV1TaFibY42BQLUxQbj25k9ILRbDy2kcsaXcajnR4l1C/U9YnGnCVUlaOJqew6msTuYyfYfTTJ8TiWxK6jSeyLTSYj8+TvCx8voWZEYPbIc+3sJNrxtVKQr90oaIw5RUFTLJyLe3yMYzBWgcmq+nquNs2AqUAHYLSqvuLievVUdafzey8gRFWPuxWrmwnyFhw32B1xp9OSZAmyKYz0zHQ+XPshb698m3C/cJ457xl61e3l6bCMKXfSMzLZH5fM7qNJziQ6iV1HTybSRxJTT2kf7OedXc7OMXUjMPv72pWCCPSzhXeMOdu4SJBrADVUdYWIhOIoKzw45/oZIlIVqAcMBo65kSD/DxgBZOCY+hsGvK6q/3UVq7tTLHYDcW62NaZM2Ba3jScXPMnqw6vpU68PT3Z5kkoBlTwdljHlko+3V3bCm9fEpMSUdPYcO+FInp1J9J5jSew8ksiCzYdPWT0QICrUnzqVArNHnetUcn6tHEiN8EC8vWz02ZizifOetP3O7+NFZD2OpaLX5WhzCDgkIgPc7LaFqh4XkWE4lpx+DEfiXWwJ8jZgjoj8CGQXIVbV19w835whVeV46nHC/Qss8mGATM3k0/Wf8vqK1wnwCeC/Pf5Lvwb9PB2WMRVasL9P9nzn3FSVwwmp7D6WlD3i7EikT7Bs5zFm/ruPHLM38PUWakUE5hqBdnytWzmI8CBbwMeYisy55kZ74O8z7MpXRHxxjDi/pappIlKsK+ntcj78nA9Tyib+O5H3Vr3HY50eY0izIZ4Op8zaE7+HpxY+xbKDy+hRuwdjzhtDVFCUp8My5qwmIkSF+hMV6k+Huqd/ipOWkcn+2OQcUzecI9BHk/hp9X6O5VgYBSA0wCc7Wa6TPQLtGI2uVSkQfx+bvmFMGeUjIstybE9W1ck5G4hICPA1MMrd+cIFeBfYAfyLY6npejhu1HOpxOogl5QyOwdZFTIzwLv4yyIdSjrEgBkD8PHyISEtgSFNh/Bop0fx9bJRlCyqytebv+a/S/+LiPDouY8yuPFgu0nImAogPjmN3UdPZE/byDmNY/exE9m1nsFRuq56WMCpI89VTlbiiAq1VQaN8RRXdZCdo70/AL8UNEtBRMbgWGiuwDnI+Zzro6rprtoVmM2JyARVHSUi3+O4o/AUqjqosIFVSOmp8MX1ULU5XDSm2Luf9O8k0jPT+WrQV3y16Ss+XPshO+J28GrPV23KBXAw8SDPLH6GhXsX0rl6Z8aeP5aaITU9HZYxppiEBvjSoqYvLWqGnXYsM1OJSUg5JWl2jD6fYMHmwxw4nnxK+wBfr+yKG44bBgNPGYm2hVOM8Qxx/OX6AbC+uKbwikg14HmgpqpeIiItgPOc1yn43IJGkEWko6ouF5EL8jqee43r0lBmR5BnjoQVH8P130Cj4quSsCNuB4O/G8zVTa5mdJfRAHy35TueXfws1YOr89aFb9EwomGxXa+8+XHbj4z7exxpGWnc3/F+hjYbipdYbVZjjENyWgZ7Y09kT9nYlWP+8+6jScSnnDqQVCXYj9rOKRs1wgOoGhpA1TD/7K/VwgIsiTamiFxUsegGzAdWc7Kk8BNAXQBVnSQi1YFlOKpRZAIJOG/Ey6fPn3CUhRutqm1FxAf4R1Vbu4zVplgUk9REmNwTkuPgrkUQHFks3T4450Hm753PrCtmERl4ss+Vh1Zy35/3kZqRyss9XqZ77e7Fcr3yIiE1gef/fp7vt31P26i2jOs2jnph9TwdljGmHFFV4k6knZI055zGcfB4MslpmaedF+TnTdVQf6qGBVA11JE0O7b9qZaVUIcFEOrvY9M5jMnBA0tNL1XVc0XkH1Vt79y3UlXbuTzXzTrI0cALQAsgIGu/qpb60GWZTZABDqyG9y6Ehr3gus8dk+HOwJrDa7j2x2sZ0XYEd7e7+7Tj+xP2M/LPkWw6tokHOj7ADS1uOCv+M14ds5pH5j3CvsR9jGgzgtvb3I6Pl43oGGOKl6oSn5LOoePJHDqewqH4FA4eTz7la4zz+9yrEIJjOkfV0ACq5RiBrhqaI6kO86dqqD/hgbaoijk7lFaCnDXPWETmAFcCv6lqBxHpArykqnnOjDilDzcT5AU4VtIbDwwEbga8VPXpM3kCRVGmE2SAv9+Fnx6Bfi9BlxFF7kZVuf3X29l0bBOzrphFiF9Inu2S0pJ4cuGT/LbzNy5rdBlPn/c0ft4Vs9BIRmYGU9dO5e1/3iYqKIoXu79Ih2odPB2WMcaQ4EykDx5P4VB8VkKdYzs+hUPHU0hIOf3eID8fr1NHonOPTof5ExXiT6UgP7ysPrQpx0oxQV7hTIg7Am8ArYA1QBRwlaquctmHmwnyclXtKCKrs+ZtZO07s6dQeGU+QVaF6UNh6x9w22yoUbTVuBftXcSdv9/Jo+c+yvAWwwtsm6mZTPx3IpP+nUS7qHaM7zX+lOkYFcHBxIM8seAJlhxYQp96fXj6vKftBkVjTLmTmJLuTJZPjkTHxJ8+Oh2ffHoi7eMlRIb4ZyfMWV+jwgJO3Q71J8DXSt2ZsqcUE+ScUyp8gKaAABtVNa3Ak7P6cDNBXgR0A74C/gD2Ai+qatMixl5kZT5BBkg8AhO7gn8o3DkX/Ar3XsjUTIb+MJTjqceZOXim2yPCv+z4hScXPElEQARvXvgmzSo3K0r0Zc4fu/7g6UVPk5qRyuOdHrfybcaYCu9EaoZj+oZzNDom/uSUjpxfjySmkNev8bAAH6rmSpyrhjmS56qhAc6vNr3DlK5STJD3APlWwnCnSoa7CfK5wHogAngOx92D/1XVv9wNtriUiwQZYNtc+PgyaD8cLnurUKfO2jaLR+c/yvPdnmdgo4GFOnfdkXXc+8e9xKfG83y357mo3kWFOr8sSU5P5pVlr/D5xs9pXrk5L/V4iQbhDTwdljHGlBnpGZkcTUzNTpodiXPyaYn0ofi8bzj08/YiKtSfSGfCHHXK14DsBV6iQvzx87EKQebMlGKCvB+YiGPU+DSq+qzLPlwlyCLijWNC80NFCbK4lZsEGWD2WJj/Klw1FVpd4dYpaRlpDPp2EEG+QXw58MsilSyLSYph1J+jWHV4FXe3u5s729xZ7kYINh3bxCNzH2Fr3FZubHEjIzuMrLBzq40xpqSpKompGRw6fnrynDOpjolP4WhSap6j0hFBvlQPC6B2pUBqVzq5gqHVkDbuKu05yGfSh8t3s6pmOGvTmcLq+bhjJPn7UVCrI1RyXYbsq81fsSdhD2/3frvI9XyjgqKY0m8Kzy56lrdXvs3W2K2MPX8sgT6BReqvNKkq0zdM59VlrxLqF8q7F71L11pdPR2WMcaUayJCiL8PIVEhNIzK+6bvLGkZmRxJSD0tcT4Un8L+uGT2HEvir21HT7vhsFKQrzNpDqJ2ZcfqhVlJtC0BbkrZGY8KulooJKtMxkSgFvAlkD18q6ozzjSAwipXI8gAx3bApO4Q1Qxu/qnApaiT0pK4ZMYlNAhvwNS+U8941FdVmbp2KhOWT6B5lea80esNqgVXO6M+S9LR5KM8vfBp5u6ZS/da3Xnu/OeoEljF02EZY4zJRVWJTUpj9zHnoivHHCsZ7j52gj1Hk9hz7ASpGadO6agW5n9K0lzbmUzXqRxIjfBAvK1CR4VXiiPIlVX16Bn14SJBziqTMTWPw6qqt5zJxYui3CXIAKu/gq9vhR4Pw4VP5tts0r+TeHvl20zrP422UW2L7fJzd8/lkXmPEOQbxOu9XqdNVNEqa5SkxfsWM3rBaGJTYnnwnAe5rtl15W5aiDHGGIfMTOVQfMrJxDlHEr3n2An2x50gM0f64eMl1IwIpE6OkefaWdM3KgURGeJnvxMqgNJeKORMuEqQs8tklBXlMkEG+PZuWPkp3Pg9NDh91bujyUe55OtLOK/meUzoNaHYL7/52Gbu/eNeYpJiePb8Z7m04aXFfo2iSMtI481/3mTq2qk0DG/Iyz1epmnlUi+OYowxphSlpmeyP+7EaaPPu50rGR5OSD2lfaCvd46E2fG1engAlYL8CA/0pVKwH5WCfAn09bZEugwrxRFkf1VNOaM+XCTIZ1wmo7iV2wQ5JQEmXwCpSXDXQgiqfMrhl5a8xP82/I9vBn1Dw4iSWaDwWPIxHpjzAMsOLuPWVrcyssPIIs9zLg47j+/kkXmPsO7IOq5ucjUPn/twuZgnbYwxpmQlpaazx5kw50yes6ZwxOex4Ao4qnJEBPk6H46kOSLQj4hgx9dKpxzzy25r86NLhwcWCvlEVa8vSh+ubtLzBkIohsnOZz3/ELhqCrx/EXx3Dwz9NHsp6r0Je/l84+cMbjy4xJJjgEoBlZh88WSeX/I8H6z5gK1xW3mx+4sE+5bupx2qyndbv+P5v5/H18uX8T3Hl+tydMYYY4pXkJ8PTaqF0qRa6GnHVJW4E2kcPJ5CbFIqx5LSiDvh+HosKZU459fYpDR2HE7iWFIssUlpp82JzinQ15tKQb6EO5PqSkF+hAf5nkywnfuykuuIIF8iAn3x8bbSd2WUn4hcB3QVkdPKiLlzD51bc5DPLMbiVW5HkLMsfht+eQL6vwKdbgfgiflP8OvOX/nh8h+oHly9xEPIqhTx8tKXaRDegDcvfJPaobVL/LoAx1OP85/F/+GnHT9xTrVzeKH7C6XynI0xxpy9VJUTaRnE5kies76PO5HGscRTE+3YrDYn0sjIzD9PCvX3ISLYlyrBJ2tIVw0NOGVxlqqhAUSG+FkyTamOIHcDhgHXADNzHXbrHjqbg1zaMjPhf9fA9nlwx59s9PXh6u+v5qZWN/FAxwdKNZTF+xbz4NwH8RZvxvcczznVzynR6608tJJH5z3KwaSD3N3ubm5pdQveXvaxljHGmLJJVYlPSSc2MY3YXMnzyUQ7lcM5yuIdSzp9JWMRqBzk50iiwwJOWZQld0Id5Fdx60mX9k16InKrqn5QpHNdJMhnXCajuJX7BBkgIcaxFHVQZf6vSTtWHl7NT1f8RLh/eKmHsvP4Tu6ZfQ974vcwustormpyVbFfIyMzg8mrJ/Puv+9SPbg6L/V4qVirdBhjjDFlRWp6JjEJztrRx5OdKxk6lgvPXtnweAqHE1JIz2N0OsTfJzuBjsqRQOdc4bBqqD8RQeVvmXAPJMh+wAigh3PXXGCSqp7+V0zuc91ZarosqRAJMsDWP1j25VBurlGNUR1GcWvrWz0WyvHU4zwy9xEW7lvIsObDeOich/DxKp6/YPcn7Oex+Y+x4tAK+jfoz5NdniTU7/Q5ZcYYY8zZJDNTOZaUmp1AHzqeTEyCI3nOGo3OSqZPpGWcdr6vtxAV4k+Uc0Q6K4Hu2iiSTg0q53FFz/NAgvw+4At85Nx1PZChqre5OrfALKg4ymSYvGnDXoyv24yqJ2K4jtIfOc4pzC+Mt3q/xWvLX+OTdZ+wLXYb/73gv2c8ov3bzt94ZtEzZGRm8Hy35xnYaGAxRWyMMcaUb15eQpUQf6qE+NO8RsFtE1LSs0ejs0eh45OJOZ5CTEIKu44ksWzH0ezpHWU1QfaAc1U150fWf4jIv+6c6GqYcDFwRmUyTN7+2PUHq9KOMUYjCPzxAajTGSLqeCweHy8fHjn3EaIjohn711iGzxrOGxe+QYPwBoXuKyktiZeXvszXm7+mdWRrXur+EnXCPPfcjDHGmPLM3WXCU9MzC7yp8CyUISKNVHUrgIg0BE4fjs+DqznIa4DngeeAh3Mft6WmiyY9M50rZjqqjszo9io+k3tC9TaORUQKWIq6tKw4uIL759xPWkYar1zwCl1rdXX73A1HN/DIvEfYEbeDW1rdwt3t78bXy7cEozXGGGNMeeCBKRa9ganANhwli+sBN6vqn67OdVVzZATQHYgABuZ6lI2l2MqhmVtnsj1uOyPbj8QnMhoGvAa7FsH8VzwdGgAdqnVg+oDp1AipwV2z72Laumm4mqueqZl8vPZjrvvxOhJTE3mvz3uM6jjKkmNjjDHGeISqzgaigZHAvUBTd5JjcPMmvTMpk1HcyvsIcnJ6MgO+GUD1oOpM6z/t5B2oM+6E1V/ATT9CPfdHbEtSUloSj89/nD92/8GV0VcyuvNofL1PT3gPnzjMkwufZOHehfSs05OxXcdSKaCSByI2xhhjTFlV2iPIZ8LdBLnIZTKKW3lPkKesmcL45eOZ0ncK51Y/9+SBlHh4twekp8KI+actRe0pmZrJ2yvfZvKqyXSo2oHxvcZTOeBkbAv2LmD0gtEkpiXy8DkPc03Ta8pd2RljjDHGlLyKmCAXuUxGcSvPCXJcShyXzLiEtlFtmXjRxNMb7F0BH1wMTS+Baz7JXoq6LPhp+088tfApIgMjeePCN6gfVp8JKybwybpPaBzRmJd7vEx0pWhPh2mMMcaYMqo8Jcjurnt4rqreqKp/OB83A+e6OklE+onIRhHZIiKPFdDuShFRESnZpdw8bMqaKSSkJjCqw6i8G9TqAL2fgfXfw/IPSzM0ly5pcAkf9vuQtIw0rp91PUN+GMIn6z7h2mbXMn3AdEuOjTHGGFMmiMjwHN+fn+vYPe704W6CnCEijXJ07rJMhoh4A28DlwAtgGtFpEUe7UKB+4C/3YylXDqYeJBP139K/4b9aVq5af4Nz7sHGl0IPz8Gh9aXXoBuaBXZiumXTqdRRCOOnDjCmxe+yROdnyDAJ8DToRljjDHGZHkgx/dv5jp2izsduFtT7GHgTxE5pUyGi3M6AVtUdRuAiHwGXAasy9XuOeAl8igjV5FM/HciGZrBPe1c/OHi5QWDJzmWov7qVrh9NvgGlk6QbqgaVJVp/aeRlpmGv7e/p8MxxhhjjMlN8vk+r+08uTWCXMQyGbWA3Tm29zj3nYxQpANQR1V/LKgjEblDRJaJyLL09HR3Qi5TtsVt45st3zCk6RBqh9Z2fUJoNbh8EhxaC78+VfIBFpKXeFlybIwxxpiySvP5Pq/tPLm9KoVzyelV7rZ3RUS8gNeAm9y49mRgMjhu0iuuGErLmyveJMA7gNtb3+7+SdEXO6ZbLH4LGvWCZgNKLkBjjDHGmIqjmYiswjFa3Mj5Pc7thu50UJLLtu0Fcq4vXNu5L0so0AqY4ywLVh2YKSKDVHVZCcZVqlbFrOL3Xb/zf23/jyqBVQp3cu+nYcd8+O5uqNkewmqWTJDGGGOMMRVH8zPtwN2b9IpiKRAtIg2cdZSHAjOzDqpqnKpGqmp9Va0P/AVUqORYVRm/3FE3+IaWNxS+Ax9/uHKKozbyjDsg063lw40xxhhjzlqqujPnA0gAOgCRzm2XCkyQz6RMhqqmA/cAvwDrgS9Uda2IjBWRQe4EV94t2LuAZQeXcWebOwn2LWLZv8jGMOAVx0jygteKN0BjjDHGmApGRH4QkVbO72sAa3BUr/hEREa51UdBC4WIyApV7ZD7+7y2S0t5WSgkUzO55vtrSExLZObgmXku0ew2Vfj6Nlj7Ddz8E9TtXHyBGmOMMcaUgtJaKERE1qpqS+f3TwDNVPUGZ2nhharaxlUfrqZYnHGZjLPVrO2z2HhsI/e0v+fMkmNwrKh36WsQXtuRKJ+ILZYYjTHGGGMqoLQc3/cGZgGoajyQ6U4HrhLkMy6TcTZKzUjlrX/eolnlZlzS4JLi6TQgHK6aAvH74IdRjlFlY4wxxhiT224RuVdELscx9/hnABEJBNwatXSVIDcTkVUisjrH91nbBSwHd3b7ctOX7E3Yy30d7sNLivE+yNrnQK/RjqkW/0wrvn6NMcYYYyqOW4GWOEoJD1HV/2/vzqPkKss8jn+f7uo13VlYkkASCEsAUUQWQWXksIgmhC1wRsUMIozHAwKCqOM6nnE56qCjxEHFiJiITDgYQCCGLYgICGGJSIhsEQJJTEwgJOnudHp95o/3Vup2dVVXh3TVrer+fc6pU3eruk9fis6v33rv+26Otr8H+NVg3qBQH+R9B3rxYO8EHErl3ge5rauNU289lQPHHsh1H7yOaAi7odPbCzecBWuegE89CHseNLTvLyIiIlIEpeqDPBQGHAc5OwCb2e7A8cBr7v5UMQurVPNXzGfT9k1cceQVQx+OIUxFPevncO1xsPBC+OQSqKkf+vOIiIiIVCAzu2Og/e5ecDS1AQOymS0CvuTuz0bDZCwDniTMSjLX3a/eiXqHvTfa32D+ivmcsu8pHLbnYcU70ei94MyfwoKPwJL/ghnfK965RERERCrLe4HVwAJgKW9hYIlCHWT3c/dno+ULgPvc/XTgWMJ4chIz95m5dPR0cNkRlxX/ZAdPh2MvgqU/gxfvKf75RERERCrDROArhBmb5wCnAK+7+4Pu/uBg3qBQQN7lYTJGitUtq7n5xZuZNW0W+43ZrzQn/cA3YMJh8LuLoWV9ac4pIiIiUsbcvcfd73b38wk35q0E/lhokru4QgF5l4fJGCmu+cs1pCzFxYdfXLqT1tSHod+62qOpqPU3i4iIiIiZ1ZnZ2cBvgEuAHwO3Dfb1hQLyLg+TMRI8v+l5Fr+ymNlvm834xvGlPfmeB8GM/4ZXHoQ/zyntuUVERETKjJn9GniU0Lj7DXd/t7t/y93XDvo9BhrmrRyV4zBvFy25iOUbl3PXOXcxunZ06Qtwh4UXwHN3woX3hPGSRURERMpICaea7gXSYTEedA1wdy8Y1gqNYrHLw2QMd4+ve5xH1j7ClUddmUw4hmgq6qthzVNh6LeLHgoz74mIiIiMMO6+y7O0FZooZCMDDJMx2DsBh1I5tSC7O7MXz2bDtg0smrWI+lTC4xG/thR+NQPecTac/YsQnEVERETKwLCZKIQwTMYpwLnAx4DfAwvcfUWxC6sES15bwvLXl/PN930z+XAMsM+xcMKX4YFvQ283vH0WHHAy1DUlXZmIiEjp9PaEG9i72qF7O1RVQ1Uq86iuySwPh8Yk9/Dvfk8X9HSG5970cnf03BkdEy27wwEnJl152Rp0H2QzqyME5e8TOjxfU8zC8imXFuTu3m5m3T6LKqviljNuIVVV6G+NEuntgXu/Bn+9Cdo3QXUdHHASHDITDp4Bo/ZIukIRERmJ3ENw69oWBdf2TIjd8dgWAm36mMHu644d07UdejoGX5dV9w3M2QF6x3o1VNUMcj392qx1q46Ca1cmzMZDa84wGz+2q28IjgfhnZVqgK+VdojY4dSCnA7GMwnheCo7OUzGcHXbyttYtXUVV594dfmEYwj/g07/LpzyLVj9GDy3CJ7/Pbx4F1gV7PPeEJYPmQnjpiZdrYiIVKLuDmj9J7RuCM8t66Pl9ZltHa39Q7D37Py5rApqGqGmIYS6mvSjEepHQ/PEzLZUbF9NfXhO1YH3RmGyJwTK3u4QRnu73+J6D3R3Qu+2zHpPV9/9O9a7M6273gPVtSE4V6cftVHAji2nt9c29d9WlfW6ftsLvGdVKtpWO/Sfi2GkUB/kXxNmIVkM3BSbVS8x5dCC3N7dzsxbZ7J3097cMOMGrNy/nnGH9c+EoPzcItgQ9ZCZcFgIym87DSa8Y3h8zSQiIm+NO7S/mQm46Ud2+G1ZD9s3536Pxj2gaQI0jYe65kyw3RFYo+VUfY596RCcta+6Rv8+DROV1IJcKCDv8jAZQ60cAvJ1y69jzrI5zJs+j6MmHJVoLW/Jppfh+cXw/CJ47THAYey+cMhpITDv857QEi0iIpWvuxPaNkDLP/sG39Z/9t+W66v6VH0UeidA84TMcva2UXuGMCuSx7AJyOUo6YC8pWMLM26ZwRETjuAnJ/8ksTqGTOtGeGFxaF1++YHwy7Fx99Bf+ZDTYP8Twl/xIiJSPnq6Ydsb0LYxhN/W9POG/uG3fVPu92jcHZomhtbeXOG3OdpXN1otuDIkFJCLKOmA/MMnf8i8FfNYeMZCDhp3UGJ1FEVHC6xcEvVZvgc6tkLNKDjwZHjb6TDtFGgYl3SVIiLDU3dHCLhtG8OjdUMIvW2v91/e9gZ9v9iNVNflD7rxMNw0Xq29UnIKyEWUZEBe37aembfO5ENTP8R33v+dRGoome5OWPVQ6Ibx/OLQ96wqBVP/JdMVY/TeSVcpIlK+3KGzNQq3r2daePsE4PTyRujYkvt9aptC94Wm8eE5vrxj2/gwSlH9GLX2StlSQC6iJAPy1x/5OoteXsSds+5kUtOkRGpIRG8vrH0qCsuL4I2VYfuko6IRMU6DPQ9OtkYRkVLp7YVtr8OW1bBlDWxd17+rQzr0drfnfo+GcSHUNkXBdtR4aEoH3awwXNtY2p9PpEgUkIsoqYD8981/5+w7zuZjh3yMLx7zxZKfv6xsfCEE5ecWwT+WhW27T4tGxDgd9j4SqnZ5lkcRkWR0tsGWtZkAvOOxGrauDfuyx9m16kzQHbVH7hbeplhLr7o3yAikgFxESQXky/9wOUvXL+Wus+9iXL364e6wZW10k98iWPVwGOuxaSIccmpoWZ76fkhprEWpEL290NUGndvC2Kl1o/XH3nDT2xO6NqQDb3YA3rKm/01tVgXNe8GYybHHlMxy817QsJs+KyIFDBSQzWwK8GtgAqGD/Vx3n5N1jAFzgFOBbcAn3H1ZUWpVQC7s6Q1Pc95d53HJuy7hosMvKum5K0r7m/DivSEsr1wSZjSqbQ4TkjSnbxSZGJ7jy00TFKLlrXEPkw90toabTDtbw+QE8fXOtmhbS2xfa+7XdLbR58YnqwohuX4MNIyF+rHR85g8y+Nix44pz1ZC9zAb2fat4Ubcjq2Z5e1bwzWJb4tv72rPjFdbOyo80ss1jaErQM2orH3pbY3RelNYTjUUJ1B2tPQPvH1agP8R/pCPqxsTC76TcgfgcvxvKVJhCgTkvYC93H2ZmTUDTwFnufvfYsecClxGCMjHAnPc/dii1KqAPDB35xN3f4JXt77K4rMX01ijvmCD0tUOL/8xBOUta6BlXRhyqG1DmNEoW3q4oeYJ4R+jpui5eULfIF1TX/IfRQpITx+bngI1PmtUb1c0+1RX31ms+uyL7d8RdnMF2pZY2I1ty/V5yiXVAHVNIaDVNYU/3uqaojDXFCY12LFvVJiudvtm2L4F2jf3X27fXHg629qmrAA9tm/YHih45xpesbcnCrAtOQLtlhzhtiVa3hJb3to/IOZSMyrMUlY3Olyb+tEh4Kan8+1sDS3tXdui57bBvW+fczRmQnRt08CBuk8QHxU+d1vX9A/A27NudLNqGD0pq/U3HoAnhesuIkW3M10szOx24Bp3vy+27efAH919QbT+AnCCu68b6lrLaI7k8vTQ2odYtmEZXz32qwrHO6OmIYylfPCMvtt7e8LNKy3ro3E6o+Dcuj5sa1kf+ji3rM89JWnDuMJBOj3taCk9czPc/83wj/SYyXDy1+GdHy7+ed3D2NWdbX2Dyo7g0pb1nGN/d0eecJsdcrv7Hpd+fitTxw5GeprVeJitHxuu745w25R5ji/3CbvRo7oIv+7SITpfgN6+pe/y5lcz+ztbC/z8dSG41TWHUNrREv4gKMSqo2DbHFpG60eHgFg3OrZ9dCz8ju4fhGub39r16u6MPl9tA38Wc30uO1szy+1v9g3fna35P2cN48JnYuw+sO/7MgF4dLr1d6ImPhIpHykzezK2Ptfd52YfZGZTgSOApVm7JgGrY+trom0KyKXU09vD1cuuZkrzFM456JykyxkeqqozIXYgvb1hnM94cG5Z33f9jYfDc29X/9fXj+kfpEftGYaqs6roYVnPsQc2uOOsCl55GB7/eaY1cctquP3SEPQPPDnHe1rUNWCgELET23c2oKYa+n4VnqoLXx9X1YTrU9MQlquj9apUZjl+XHUqz3E1mX05X1sdOy5aTy+n6jPhthK63dTUQ80gPs+59HRnBejNuYN1R0toNc0OsTuWx/QNvzWNyQ3zlaoNj6EeLz3XH4IQhpqsaxrac4lIMXW7+9EDHWBmTcAtwBXuvrU0ZfWngDyAe1+9l5fefImrjr+Kmir1Pyupqqpwx3fTnjDxsPzHucO2TX2Dc+v60Crdsi60Ur/2WNhe6OvwodTTAQ/9IDx2muXvv9m4e56vofP1Bc3aX9OoG4nKRXUKRu0eHjIws/CHXKoO2C3pakSkSMyshhCOb3T3W3McshaYElufHG0b+lrUBzm/rp4u7l51NzP3n0mVKVRUtPSA/b09gId178165NlGru2x439xEjlntMLg47/LOj56jVmOIBs9p+o10L+IiAw7BW7SM2A+sMndr8hzzEzgUjI36f3Y3Y8pRq1qQR5ATXUNpx9wetJlyFAwC18/F8OYyaFbRa7t+59QnHOKiIgML8cB5wHLzezpaNtXgH0A3P1aYDEhHK8kDPN2QbGKUQuyyK565ma48zPhRqq0mgY4/celuVFPRESkAlTSRCFF7TdgZtPN7AUzW2lmX8qx/yIzW25mT5vZw2Z2aDHrESmKd344hOExUwALzwrHIiIiFatoLchmVg28CJxCGIbjCeDcrAGfR6fvUDSzM4BPu/v0gd5XLcgiIiIilUctyMExwEp3f9ndO4GbgDPjB2QN3zGK3Hc6iYiIiIiUTDFv0ss1mHO/6QDN7BLgSqAWOCnXG5nZp4BPAdTWVsDYqCIiIiJSsRIfu8zdf+LuBwBfBL6W55i57n60ux+dSmngDREREREpnmIG5J0dzPkm4Kwi1iMiIiIiUlAxA/ITwDQz28/MaoGPAnfEDzCzabHVmcBLRaxHRERERKSgovVXcPduM7sUuAeoBq539xVm9k3gSXe/A7jUzD4AdAFvAucXqx4RERERkcHQRCEiIiIiUnQa5k1EREREpEJVXAuymfUC7QUPHDopoLuE56sUui656br0p2uSm65Lbrou/ema5Kbrkls5X5cGd6+IxtmKC8ilZmZPuvvRSddRbnRdctN16U/XJDddl9x0XfrTNclN1yU3XZehUREpXkRERESkVBSQRURERERiFJALm5t0AWVK1yU3XZf+dE1y03XJTdelP12T3HRdctN1GQLqgywiIiIiEqMWZBERERGRGAVkEREREZEYBeQBmNl0M3vBzFaa2ZeSrqccmNkUM3vAzP5mZivM7PKkayoXZlZtZn8xs0VJ11IuzGysmS00s+fN7Dkze2/SNZUDM/ts9P/Ps2a2wMzqk64pCWZ2vZltMLNnY9t2M7P7zOyl6HlckjWWWp5r8v3o/6FnzOw2MxubYImJyHVdYvs+Z2ZuZnskUVuS8l0XM7ss+sysMLOrkqqvkikg52Fm1cBPgBnAocC5ZnZoslWVhW7gc+5+KPAe4BJdlx0uB55LuogyMwe4290PAQ5H1wczmwR8Bjja3d8BVAMfTbaqxMwDpmdt+xJwv7tPA+6P1keSefS/JvcB73D3dwIvAl8udVFlYB79rwtmNgX4IPBaqQsqE/PIui5mdiJwJnC4u78d+EECdVU8BeT8jgFWuvvL7t4J3ET4wI1o7r7O3ZdFyy2EwDMp2aqSZ2aTgZnAdUnXUi7MbAxwPPBLAHfvdPfNiRZVPlJAg5mlgEbgHwnXkwh3/xOwKWvzmcD8aHk+cFYpa0parmvi7ve6e3pmtMeAySUvLGF5PisAPwL+AxiRIw7kuS4XA99z947omA0lL2wYUEDObxKwOra+BgXBPsxsKnAEsDThUsrB1YRf0r0J11FO9gM2Ar+Kup5cZ2ajki4qae6+ltCi8xqwDtji7vcmW1VZmeDu66Ll9cCEJIspQxcCdyVdRDkwszOBte7+16RrKTMHAe83s6Vm9qCZvTvpgiqRArK8JWbWBNwCXOHuW5OuJ0lmdhqwwd2fSrqWMpMCjgR+5u5HAG2MvK/L+4n61J5J+ANib2CUmf1bslWVJw/jkI7IlsFczOyrhG5uNyZdS9LMrBH4CvD1pGspQylgN0I3yC8AN5uZJVtS5VFAzm8tMCW2PjnaNuKZWQ0hHN/o7rcmXU8ZOA44w8xWEbrinGRmv0m2pLKwBljj7ulvGBYSAvNI9wHgFXff6O5dwK3A+xKuqZz808z2Aoie9fUwYGafAE4DZrsmMAA4gPBH5l+j372TgWVmNjHRqsrDGuBWDx4nfLM54m5g3FUKyPk9AUwzs/3MrJZwE80dCdeUuOiv0F8Cz7n7D5Oupxy4+5fdfbK7TyV8Tv7g7iO+RdDd1wOrzezgaNPJwN8SLKlcvAa8x8wao/+fTkY3L8bdAZwfLZ8P3J5gLWXBzKYTunCd4e7bkq6nHLj7cncf7+5To9+9a4Ajo987I93vgBMBzOwgoBZ4PcmCKpECch7RDRGXAvcQ/vG62d1XJFtVWTgOOI/QSvp09Dg16aKkbF0G3GhmzwDvAr6TbDnJi1rUFwLLgOWE38MjcmpYM1sAPAocbGZrzOzfge8Bp5jZS4TW9u8lWWOp5bkm1wDNwH3R79xrEy0yAXmuy4iX57pcD+wfDf12E3C+vnXYeZpqWkREREQkRi3IIiIiIiIxCsgiIiIiIjEKyCIiIiIiMQrIIiIiIiIxCsgiIiIiIjEKyCIy7JhZ63A8v5m938xWREN9NcS2P2BmH8o69goz+1m0vIeZdZnZRVnHrDKz5Wb2TDQl7b6xfQ3RtuoCNS2JZgcUERk2FJBFRHaBmaV28fVmZoP9XTwb+K67v8vd22PbFxAmqYn7aLQd4F+Bx4Bzc7znie7+TuCPwNdi2y8kzMbVU6CmG4BPD658EZHKoIAsIsOWmTWZ2f1mtixqKT0ztu8/zewFM3vYzBaY2edzvH6qmf0hamG938z2ibbPM7NrzWwpcFU04+aj0Tm+nfUeXzCzJ6L3+EbsfV8ws18Dz9J3WnvM7GQz+0v0ftebWZ2ZfRL4MPAtM7sxq9SFwMxo1k/MbCqwN/BQtP9c4HPAJDObnOdyPQpMiq3PJprFzsxOMLM/mdnvo7qvjYX6O8gdvEVEKpYCsogMZ9uBWe5+JGHq1f+JWmzfDZwDHA7MAI7O8/r/BeZHLaw3Aj+O7ZsMvM/drwTmAD9z98OAdekDzOyDwDTgGMJMgkeZ2fHR7mnAT9397e7+auw19cA84CPR+6WAi939OkIY/YK7z44X6e6bgMejnwVC6/HN7u5mNgXYy90fB24GPpLnZ51OmKKWKGjv7+6rYvuPIcyMeChwAHB2dO43gToz2z3P+4qIVBwFZBEZzgz4TjTV9RJCC+kEwpTpt7v7dndvAe7M8/r3Av8XLd8A/Ets329j3Q+OI9Od4YbYMR+MHn8hTC19CCEYA7zq7o/lOOfBwCvu/mK0Ph84Psdx2eLdLOLdKz5CCMYQpp3Nbu19wMzWEsJ1+jV7AJuzjnvc3V+OfuYF9L0WGwgt1iIiw8Iu9Z0TESlzs4E9gaPcvcvMVgH1Q/TebVnrnuMYI/QZ/nmfjaELRPbrd9XtwI/M7Eig0d2firafC0w0s3Sr895mNs3dX4rWTySE4RuBbwBXAu30v07ZP198vT56jYjIsKAWZBEZzsYAG6JwfCKQHqXhEeB0M6s3sybgtDyv/zOZVtnZZPr0Znsk67i0e4ALo3NgZpPMbHyBml8ApprZgdH6ecCDBV6Du7cCDwDXE7UEm9lBQJO7T3L3qe4+FfguWa3I7t4NXAF83Mx2i7pNVEfdPdKOifpaVxFapR+OzmHARGBVoRpFRCqFArKIDGc3Akeb2XLg48DzAO7+BKE/7zPAXcByYEuO118GXBB10TgPuDzPeS4HLonOs+NGN3e/l9BF49Fo30KgeaCC3X07cAHw2+g1vcC1g/ppQzA+nExXiXOB27KOuYUcN9W5+7rodZdEm+6lbzeKJ4BrgOeAV2LvexTwWBSyRUSGBXPP9a2giMjwZmZN7t5qZo3An4BPufuypOsqF1FXjc+6+3lmdgLweXfv19JuZnOAO9z9/hKXKCJSNOqDLCIj1VwzO5TQf3a+wnFf7r4smoBkwIlCgGcVjkVkuFELsoiIiIhIjPogi4iIiIjEKCCLiIiIiMQoIIuIiIiIxCggi4iIiIjEKCCLiIiIiMT8P3aDRa7JdUTbAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(10, 5), num=1, clear=True)\n", + "ax.plot(np.arange(len(out)), out['Train Error'], color=\"C0\")\n", + "ax.plot(np.arange(len(out))+.3, out['Test1 Error'], color=\"C1\")\n", + "ax.plot([], [], color=\"C2\") # dummy for legend labels\n", + "argmin = out['Test1 Error'].argmin()\n", + "ax.plot(argmin, out.iloc[argmin]['Test1 Error'], 'o', color=\"C1\")\n", + "bx = ax.twinx()\n", + "bx.plot(np.arange(len(out)), out['Test2 Error'], color=f\"C2\")\n", + "ax.set_title(f'Var(p) Forecast Errors in Train, Test1 and Test2 Periods')\n", + "ax.set_ylabel(f'MSE of Train and Test1 [{train_split}:{test_split}]')\n", + "bx.set_ylabel(f'MSE of Test2 period [{test_split}:{test_end}]')\n", + "ax.set_xlabel('lag order of VAR(p)')\n", + "ax.legend(['Train Error', 'Test1 Error', 'Test2 Error',\n", + " f'Test1 Min Error (={out.iloc[argmin][\"Test1 Error\"]:.4f})'],\n", + " loc='center right')\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / 'varerr.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Temporal 1D Convolutional Net (TCN)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "class TCN(torch.nn.Module):\n", + " class CausalConv1dBlock(torch.nn.Module):\n", + " \"\"\"Conv1d block with ReLU, skip, dropout, dilation and padding\"\"\"\n", + " def __init__(self, in_channels, out_channels, kernel_size, dilation,\n", + " dropout):\n", + " super().__init__()\n", + "\n", + " print('kernel', kernel_size, 'dilation', dilation)\n", + " self.network = torch.nn.Sequential(\n", + " torch.nn.ConstantPad1d(((kernel_size-1)*dilation, 0), 0),\n", + " torch.nn.Conv1d(in_channels, out_channels, kernel_size,\n", + " dilation=dilation),\n", + " torch.nn.ReLU(),\n", + " torch.nn.ConstantPad1d(((kernel_size-1)*dilation, 0), 0),\n", + " torch.nn.Conv1d(out_channels, out_channels, kernel_size,\n", + " dilation=dilation),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Dropout(dropout))\n", + " self.skip = lambda x: x\n", + " if in_channels != out_channels: # downsample for skip if necessary\n", + " self.skip = torch.nn.Conv1d(in_channels, out_channels, 1)\n", + "\n", + " def forward(self, x):\n", + " return self.network(x) + self.skip(x) # with skip connection\n", + "\n", + "\n", + " def __init__(self, n_features, blocks, kernel_size, dropout):\n", + " \"\"\"TCN model by connecting multiple convolution layers\"\"\"\n", + " super().__init__()\n", + " in_channels = n_features\n", + " L = []\n", + " for dilation, hidden in enumerate(blocks):\n", + " L.append(self.CausalConv1dBlock(in_channels=in_channels,\n", + " out_channels=hidden,\n", + " kernel_size=kernel_size,\n", + " dilation=2**dilation,\n", + " dropout=dropout))\n", + " in_channels = hidden\n", + " self.network = torch.nn.Sequential(*L) if L else lambda x: x\n", + " if L:\n", + " self.classifier = torch.nn.Conv1d(in_channels, n_features, 1)\n", + " else:\n", + " self.classifier = torch.nn.Sequential(\n", + " torch.nn.ConstantPad1d((kernel_size-1, 0), 0), \n", + " torch.nn.Conv1d(in_channels, n_features, kernel_size))\n", + "\n", + " def forward(self, x):\n", + " \"\"\"input is (B, n_features, L)), linear expects (B, * n_features)\"\"\"\n", + " return self.classifier(self.network(x))\n", + "\n", + " def save(self, filename):\n", + " \"\"\"save model state to filename\"\"\"\n", + " return torch.save(self.state_dict(), filename)\n", + "\n", + " def load(self, filename):\n", + " \"\"\"load model name from filename\"\"\"\n", + " self.load_state_dict(torch.load(filename, map_location='cpu'))\n", + " return self" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Form input data from training set" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "seq_len = 16 # length of each input sequence for TCN\n", + "train_exs = [train_data.iloc[i-(seq_len+1):i].values\n", + " for i in range(seq_len+1, len(train_data))]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fit TCN models with increasing layers of convolution and dropout rates" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TCN(\n", + " (classifier): Sequential(\n", + " (0): ConstantPad1d(padding=(0, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + " )\n", + ")\n", + "TCN(\n", + " (classifier): Sequential(\n", + " (0): ConstantPad1d(padding=(1, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(2,), stride=(1,))\n", + " )\n", + ")\n", + "TCN(\n", + " (classifier): Sequential(\n", + " (0): ConstantPad1d(padding=(3, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(4,), stride=(1,))\n", + " )\n", + ")\n", + "kernel 3 dilation 1\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.2, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.3, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.4, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.5, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "kernel 3 dilation 2\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(4, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(4, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "kernel 3 dilation 2\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (1): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(4, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(4, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "kernel 3 dilation 2\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.2, inplace=False)\n", + " )\n", + " )\n", + " (1): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(4, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(4, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.2, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "kernel 3 dilation 2\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.3, inplace=False)\n", + " )\n", + " )\n", + " (1): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(4, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(4, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.3, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "kernel 3 dilation 2\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.4, inplace=False)\n", + " )\n", + " )\n", + " (1): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(4, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(4, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.4, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n", + "kernel 3 dilation 1\n", + "kernel 3 dilation 2\n", + "TCN(\n", + " (network): Sequential(\n", + " (0): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(2, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(2, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.5, inplace=False)\n", + " )\n", + " )\n", + " (1): CausalConv1dBlock(\n", + " (network): Sequential(\n", + " (0): ConstantPad1d(padding=(4, 0), value=0)\n", + " (1): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (2): ReLU()\n", + " (3): ConstantPad1d(padding=(4, 0), value=0)\n", + " (4): Conv1d(8, 8, kernel_size=(3,), stride=(1,), dilation=(2,))\n", + " (5): ReLU()\n", + " (6): Dropout(p=0.5, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (classifier): Conv1d(8, 8, kernel_size=(1,), stride=(1,))\n", + ")\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
blocksdropoutkernel_sizeTrain ErrorTest1 ErrorTest2 Error
TCN0_1_000.010.6563190.3539922.104663
TCN0_2_000.020.6088360.3262412.044283
TCN0_4_000.040.5714050.3170152.108552
TCN1_3_010.030.4079640.4372082.842631
TCN1_3_1010.130.4404000.3890562.528358
TCN1_3_2010.230.4722050.3599622.077393
TCN1_3_3010.330.4909210.3799502.218563
TCN1_3_4010.430.5329180.3764122.105014
TCN1_3_5010.530.5482590.3617662.079798
TCN2_3_020.030.3562770.3857202.081886
TCN2_3_1020.130.3715280.3623102.161206
TCN2_3_2020.230.4041030.3704822.368183
TCN2_3_3020.330.4569230.3817102.291235
TCN2_3_4020.430.4944420.3967332.633804
TCN2_3_5020.530.5059320.3735502.267425
\n", + "
" + ], + "text/plain": [ + " blocks dropout kernel_size Train Error Test1 Error Test2 Error\n", + "TCN0_1_0 0 0.0 1 0.656319 0.353992 2.104663\n", + "TCN0_2_0 0 0.0 2 0.608836 0.326241 2.044283\n", + "TCN0_4_0 0 0.0 4 0.571405 0.317015 2.108552\n", + "TCN1_3_0 1 0.0 3 0.407964 0.437208 2.842631\n", + "TCN1_3_10 1 0.1 3 0.440400 0.389056 2.528358\n", + "TCN1_3_20 1 0.2 3 0.472205 0.359962 2.077393\n", + "TCN1_3_30 1 0.3 3 0.490921 0.379950 2.218563\n", + "TCN1_3_40 1 0.4 3 0.532918 0.376412 2.105014\n", + "TCN1_3_50 1 0.5 3 0.548259 0.361766 2.079798\n", + "TCN2_3_0 2 0.0 3 0.356277 0.385720 2.081886\n", + "TCN2_3_10 2 0.1 3 0.371528 0.362310 2.161206\n", + "TCN2_3_20 2 0.2 3 0.404103 0.370482 2.368183\n", + "TCN2_3_30 2 0.3 3 0.456923 0.381710 2.291235\n", + "TCN2_3_40 2 0.4 3 0.494442 0.396733 2.633804\n", + "TCN2_3_50 2 0.5 3 0.505932 0.373550 2.267425" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_features = train_data.shape[1] # number of input planes\n", + "batch_size = 8\n", + "step_size = 100 # learning rate scheduler step size\n", + "lr = 0.01 # initial learning rate\n", + "num_lr = 6\n", + "res = [] # to collect results summaries\n", + "tcn_error = dict() # to store prediction errors\n", + "\n", + "kernel_sizes = [1, 2, 4]\n", + "dropouts = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]\n", + "blocks = [0, 1, 2]\n", + "for block in blocks:\n", + " for parm in (dropouts if block else kernel_sizes):\n", + " if block:\n", + " dropout = parm\n", + " kernel_size = 3\n", + " else:\n", + " dropout = 0.0\n", + " kernel_size = parm\n", + " modelname = f\"TCN{block}_{kernel_size}_{dropout*100:.0f}\"\n", + "\n", + " # Set model, optimizer, loss function and learning rate scheduler\n", + " model = TCN(n_features=n_features, blocks=[n_features]*block,\n", + " kernel_size=kernel_size, dropout=dropout).to(device)\n", + " print(model)\n", + " optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n", + " scheduler = torch.optim.lr_scheduler.StepLR(optimizer, gamma=0.1,\n", + " step_size=step_size)\n", + " loss_function = nn.MSELoss()\n", + "\n", + " # Run training loop over num_epochs with batch_size\n", + " num_epochs = step_size * num_lr\n", + " for epoch in range(num_epochs):\n", + " idxs = np.arange(len(train_exs)) # shuffle indxs into batches\n", + " random.shuffle(idxs)\n", + " batches = [idxs[i:(i+batch_size)]\n", + " for i in range(0, len(idxs), batch_size)]\n", + "\n", + " total_loss = 0.0 # train by batch\n", + " model.train()\n", + " for batch in batches:\n", + " # input has shape (batch_size=8, n_features=8, seq_len=16)\n", + " # Creating a tensor from a list of numpy.ndarrays is extremely\n", + " # slow. Please consider converting the list to a single\n", + " # numpy.ndarray with numpy.array() before converting to a tensor\n", + " nparray = np.array([[train_exs[idx][seq] for idx in batch]\n", + " for seq in range(seq_len+1)])\n", + " train_ex = torch.tensor(nparray)\\\n", + " .permute(1,2,0).float().to(device)\n", + " model.zero_grad()\n", + " X = train_ex[:,:,:-1]\n", + " Y = train_ex[:,:,1:]\n", + " output = model(X)\n", + " loss = loss_function(output, Y) # calculated over all outputs\n", + " total_loss += float(loss)\n", + " loss.backward()\n", + " optimizer.step()\n", + " scheduler.step()\n", + " if VERBOSE and (epoch % (step_size//2)) == 0:\n", + " print(epoch, num_epochs, block, dropout,\n", + " optimizer.param_groups[0]['lr'], total_loss/len(batches))\n", + " model.eval()\n", + "\n", + " # Compute MSE of one-period ahead forecast error in train and test sets\n", + " e = dict()\n", + " for x in [train_data, test1_data, test2_data]:\n", + " for i in range(seq_len, len(x)):\n", + " X = torch.tensor(x.iloc[(i-seq_len):i].values.T)\\\n", + " .unsqueeze(0).float().to(device)\n", + " pred = model(X)\n", + " e[x.index[i]] = mse([x.iloc[i].values],\n", + " pred[:,:,-1].cpu().detach().numpy())\n", + " model.save(imgdir / (modelname + '.pt'))\n", + " e = Series(e, name=modelname)\n", + " tcn_error[modelname] = e\n", + " res.append(Series({\n", + " 'blocks': block, 'dropout': dropout, 'kernel_size': kernel_size,\n", + " 'Train Error': float(e[e.index <= train_split].mean()),\n", + " 'Test1 Error': float(e[test1_index].mean()),\n", + " 'Test2 Error': float(e[test2_index].mean())}, name=modelname))\n", + " #print(pd.concat(res, axis=1).T)\n", + "res = pd.concat(res, axis=1).T.astype({'blocks': int, 'kernel_size': int})\n", + "res" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot monthly mean squared error" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(10, 5), num=1, clear=True)\n", + "ax.set_yscale('log')\n", + "legend = []\n", + "for col, (modelname, parm) in enumerate(res.iterrows()):\n", + " if parm.dropout in [0.0, 0.5]:\n", + " tcn_error[modelname].plot(ax=ax, c=f'C{col}', lw=.5, ls='-')\n", + " legend.append(f\"depth={parm.blocks} kernel={parm.kernel_size}, \"\n", + " f\"dropout=.{100*parm.dropout:.0f}\")\n", + "#for a,b in vspans:\n", + "# if a >= train_index[maxlags]:\n", + "# ax.axvspan(a, min(b, max(test2_index)), alpha=0.3, color='grey')\n", + "ax.set_title('Mean Squared Error of TCN Predictions')\n", + "ax.axvline(max(train_index), color='black', linestyle='--')\n", + "ax.axvline(max(test1_index), color='black', linestyle='--')\n", + "ax.legend(legend, loc='upper left')\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / 'tcnmse.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Display train and test error of TCN models by dropout parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
blocks12
Test1Test2TrainTest1Test2Train
dropout
0.00.43722.84260.40800.38572.08190.3563
0.10.38912.52840.44040.36232.16120.3715
0.20.36002.07740.47220.37052.36820.4041
0.30.38002.21860.49090.38172.29120.4569
0.40.37642.10500.53290.39672.63380.4944
0.50.36182.07980.54830.37362.26740.5059
\n", + "
" + ], + "text/plain": [ + "blocks 1 2 \n", + " Test1 Test2 Train Test1 Test2 Train\n", + "dropout \n", + "0.0 0.4372 2.8426 0.4080 0.3857 2.0819 0.3563\n", + "0.1 0.3891 2.5284 0.4404 0.3623 2.1612 0.3715\n", + "0.2 0.3600 2.0774 0.4722 0.3705 2.3682 0.4041\n", + "0.3 0.3800 2.2186 0.4909 0.3817 2.2912 0.4569\n", + "0.4 0.3764 2.1050 0.5329 0.3967 2.6338 0.4944\n", + "0.5 0.3618 2.0798 0.5483 0.3736 2.2674 0.5059" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res[res['blocks'].gt(0)]\\\n", + " .rename(columns={s+' Error': s for s in ['Train','Test1','Test2']})\\\n", + " .pivot(index=['dropout'], columns=['blocks'])\\\n", + " .drop(columns=['kernel_size'])\\\n", + " .swaplevel(0, 1, 1).round(4).sort_index(axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Display train and test error of TCN models by size parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
blocks0
Test1Test2Train
kernel_size
10.35402.10470.6563
20.32622.04430.6088
40.31702.10860.5714
\n", + "
" + ], + "text/plain": [ + "blocks 0 \n", + " Test1 Test2 Train\n", + "kernel_size \n", + "1 0.3540 2.1047 0.6563\n", + "2 0.3262 2.0443 0.6088\n", + "4 0.3170 2.1086 0.5714" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res[res['blocks'].eq(0)]\\\n", + " .rename(columns={s+' Error': s for s in ['Train','Test1','Test2']})\\\n", + " .pivot(index=['kernel_size'], columns=['blocks'])\\\n", + " .drop(columns=['dropout'])\\\n", + " .swaplevel(0, 1, 1).round(4).sort_index(axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot Train and Test Error of TCN Models" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAFgCAYAAACmDI9oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAC/FUlEQVR4nOzdd3yV5dnA8d99RvbeJAECISB7bxkO0Io4qhWFaqW+1betWtxdWmpdHSraWltfq7RordaNA6EqghYIyJQVVoAEErJ3ctb9/vGcHJKQCTk5J8n1/Xz4kPOcZ1zPISTXuc91X7fSWiOEEEIIIYQwmHwdgBBCCCGEEP5EEmQhhBBCCCEakARZCCGEEEKIBiRBFkIIIYQQogFJkIUQQgghhGhAEmQhhBBCCCEakARZCNEllFIfK6W+5wdxLFVKveLrOLoLpdTVSqnjSqlKpdRYX8fjDR35nlBKrVVK/Y+3YxJC+JYkyEKIFrmTovo/LqVUTYPHizpyLq31t7TWf/dWrOdKKbWowb3VuO/Xc/9ncb40pZRWSlla2WepUsre5HUuPacb6Xx/AG7XWodprbfVb1RK9WsSt1ZKVTV4PEMp1Ucp9Tel1EmlVIVSap9S6tdKqVD3ObRSapdSytTgvI8opZY3F4hSarb7mHeabB/t3r7WK6+AEKLXkQRZCNEid1IUprUOA44B8xtse7V+v9aSwO5Ca/1qg3v9FnCiyf17y+sNr6O1jmpup+Ze446+7mf579Qf2N10o9b6WDOvz+gGj3cDG4BgYKrWOhyYA0QB6Q1OlQxc34F4CoCpSqnYBtu+B2R14BxCCNEqSZCFEB3mHsnLUUo9oJTKA15WSkUrpT5QShUopUrcX6c2OMbz0bRS6mal1JdKqT+49z2ilPpWK9f7qVLqkHsUco9S6uoGz7V6LqXUAKXUF+5j1wBxZ3G/yUqpt9z3dkQpdWeD5yYppbYopcqVUvlKqafcT61z/13qHlGdehbX1UqpHyulDgAHWnjdA5VSy5RSJ9x/limlAt3Hn7F/M9cwKaV+qZQ6qpQ6pZT6h1Iq0n3eSsAM7FBKHepg+HcDFcB3tdbZAFrr41rrn2itdzbY73fArzuQvNuAd3En1UopM7AAeLXhTkqpaUqpzUqpMvff0xo81+r3hFJqilLqv0qpUqXUDqXU7OYCUUoNcp+nTClVqJR6vZ33IITwc5IgCyHOVhIQgzHCeCvGz5OX3Y/7ATXAn1o5fjKwHyM5+R3wN6WUamHfQ8AMIBL4NfCKUqpPO8/1T+Br93O/wRhtbDf3x/8rgR1ACnARsEQpdYl7l2eAZ7TWERgjo2+4t890/x3lHlXd0JHrNnAVxv0Ncz9u+rr/ApgCjAFGA5OAXzY4vun+Td3s/nMBMBAIA/6kta5rMjKc3syxrbkYeFtr7Wpjv7eBcncM7fUP4Cb315cA3wAn6p9USsUAHwLPArHAU8CHDUadW/yeUEqluI99BON1uxd4SykV30wcvwFWA9FAKvDHDtyDEMKPSYIshDhbLuBX7kSqRmtdpLV+S2tdrbWuAB4FZrVy/FGt9f9prZ3A34E+QGJzO2qt/621PqG1dmmtXwcOYCSCrZ5LKdUPmAg86I5zHUay2xETgXit9cNaa5vW+jDwf5wuC7ADg5RScVrrSq31xg6e/zr3SGX9n8+bPP+41rpYa13jftzodQcWAQ9rrU9prQsw3kDc2OD4pvs3tQh4Smt9WGtdCfwMuL4TymZigZPt2E8DDwIPKqUC2nNirfV/gRil1BCMRPkfTXaZBxzQWq/QWju01q8B+4D57fie+C7wkdb6I/f32xpgC3BZM6HYMd54JGuta7XWX7YnfiGE/5MEWQhxtgq01rX1D5RSIUqpv7o/qi/HKDGIcn8E3py8+i+01tXuL5ut9VVK3aSU2l6fRAIjaPyxeEvnSgZKtNZVDfY92r7b8+gPJDdMYoGfczqZvwUYDOxzf5R/eQfP/4bWOqrBnwuaPH+8yeNGrzvGPTa8p6PubS3t31Rzx1to4c1KBxRhvFFpk9b6IyAHuK0D518B3I4x8v1Ok+ea3hPuxym0/T3RH/hOk3/v82n+Xu4HFJCplNqtlPp+B+IXQvixbj+xRgjhM7rJ43uAIcBkrXWeUmoMsA0jgThrSqn+GCO2FwEbtNZOpdT2dp73JBCtlAptkBD1ayb21hwHjmitM5p7Umt9ALjBXYrxbeBN90f5HblGa5qep+njEzSeSNePBuUG7Yij/vh6/QAHkN+xMM/wH+BqpdSv21FmAUapyGvuP+2xAjgI/ENrXd2kOqfpPYFxX6to+3viOLBCa/2DtgLQWucBPwBQSp0P/EcptU5rfbCd9yCE8FMygiyE6CzhGHXHpe4a0F910nlDMZKXAgCl1GKMEeQ2aa2PYnw8/mulVIA7iZnfwetnAhXuiW7BSimzUmqEUmqiO57vKqXi3UlgqfsYlzteF0Zdrze9BvxSKRWvlIoDHgI60uf5NeAu98S1MOAxjM4ajnOM6ykgAvi7+00OSqkUpdRTSqlRTXfWWq/FqCVuV4241voIRgnPL5p5+iNgsFJqoVLKopRagFHD/UE7videwSjFuMT9bx2kjMmOqU0vopT6ToPtJRjfp+15MyCE8HOSIAshOssyjJZehcBGjNG6c6a13gM8idEyLB8YCXzVgVMsxJjkVoyRtDetV23r+k7gcoxJcEcw7u9FjAmDAJcCu90dH54BrnfXZFdj1GF/5f6ofkoLl1igGvcTrlRKJXQgxEcwEr6dwC5gq3tbe72EMRq7zn1/tcAdHTi+WVrrYmAaRp3uJqVUBfApUIYx8tucX2JMjGvvNb7UWp9oZnsRxr/ZPRilHvcDl2utC927tPg9obU+DlyJUUZTgDGifB/N/76c6L63SuB94CfuGnUhRDentO6sTwGFEEIIIYTo/mQEWQghhBBCiAYkQRZCCCGEEKIBSZCFEEIIIYRoQBJkIYQQQgghGugxfZBNJpMODg72dRhCCCGEEKITVVdXa611lw7q9pgEOTg4mKqqqrZ3FEIIIYQQ3YZSqqarryklFkIIIYQQQjTQY0aQhRDibJWWlnLy5Elfh9Gj9enTh6ioKF+HIYQQ7SIJshCi1yssLCQtLQ2Zx+AdNTU15ObmSoIshOg2JEEWQvR6drudoKCgM7a/uy2X33+ynxOlNSRHBXPfJUO4amyKDyLs3oKCgrDb7b4OQwgh2k0SZCGEAJRSjR6/uy2Xn729ixq7E4Dc0hp+9vYuAEmSO6jpayuEEP5OEmQhhAB+vXI3e06Uex5vO1aKzelqtE+N3cn9b+7ktcxjAAxLjuBX84c32mf58uWMGTOGMWPGeC3Wjz76iG3btlFWVsZvf/tbTwK6YsUKZs6cyTvvvMM777zD1VdfzZQpU5gyZcoZ53j99ddZsGBBs+dfu3YtK1asYOTIkS0e35KXX36ZuXPnkpIibyKEEN2XJMhCCNGMpslxW9ub43K5ePbZZzl16hSXX345H3/8MT/96U9Zvnw5F198Mf/4xz9ITEzE4XAwbtw4Xn/9db7zne/wySef0L9/f6ZOnYrdbue///2v55zXXHMNa9as4emnn+Yf//gHO3bs8CTju3fv5sYbb2TJkiVkZ2ezZMkS5s2bx8KFCxk/fjxr1qxh3759PProo2zYsIEFCxZw0UUXsXDhQgoLC3nggQfOuIfQ0FBuu+02pk+fjsPhYPPmzXznO9/hq6++IiYmhtLSUhYtWsQ999zD4sWLue6663jqqad48MEHO/aCCyGEH5EEWQgh4IyR4OlPfEZu6ZmtN1Oignn9tqntOmd1dTVKKfr168enn37KzTffzN/+9jeys7NZsGABu3fvJiMjg0OHDgEwZ84cLrzwQoqKijhy5AgVFRXN1ka3xGaznbEtPT2dRYsWsWfPHkwmEwEBAezatcvz/IgRI7jllltYsmRJo+Pmz5/PVVddBUBgYCA33XQTa9euJSoqigsvvJCVK1fy4IMPcvfddwMwffp0Lr/8cgBKSkraHbMQQvgjSZCFEKIZ910ypFENMkCw1cx9lwxp89hXX32VtWvXMm/ePEpKSkhKSsLpdJKenk5mZia33XYbcXFxjBo1ipqaGoYPN5Jzk8loTV9WVobVamXv3r3cdtttTJo0qdH558yZw2OPPUZZWRk33nijZ3tAQMAZsdSfc8+ePQQFBeF0OnE6T99TS/XBK1euJDs7m/Hjx3vO0fB8MTExPPfcc8TGxjbaXlVVRXR0dJuvkRBC+DOltfZ1DJ0iNDRUd9VKejKzXYieZe/evQwdOvSM7Z39fz0zM5M333yT3/3ud+cSbovqa5D79+/vlfO3x8svv8ycOXNITU1ttL2l11gIIdqilKrWWod26TUlQe6YpjPbwRhVevzbIyVJFqKbkuTN++Q1FkKcLV8kyFJi0UG//2Q/NXYnJu3iju1v8kn/yeyL6c/vP9kvCbIQPciER9ZQWHlmTW9cWABbfjnHBxEJIYToKqa2dxENnXBP2omsq2RU4SEGlxxvtF0I0TM0lxy3tl0IIUTP4dUEWSl1qVJqv1LqoFLqpy3sc51Sao9SardS6p8NtjuVUtvdf973ZpwdkRxlLEVbEhTBjy+4m/fTzwcgPcSXUQkhOsOCv27w/GnPfs1Zvnw527dv90J0p3300Uc8+uij3H///TQsk1uxYgVHjx5l2bJlzJo1i2XLlrFx48Zmz5Gdnc2yZcsAWL16NbNnz6a0tLTRPvPnz2fZsmW89NJLHYqvqKiI559/vkPHCCGEP/FaiYVSygw8B8wBcoDNSqn3tdZ7GuyTAfwMmK61LlFKJTQ4RY3Weoy34jtbDWe211oCAehrL+fpj/5EyZAqohdc5+MIhRD+wh/6IP/iF78gMzMTh8PBtGnTePfdd0lPTyctLY3MzEy2bNnC3LlzG12jqdDQUNauXeuJ78knn2ThwoVERUWxdetWysrKuO+++7jzzju58sormTNnDkePHvX2yyuEEF7jzRrkScBBrfVhAKXUv4ArgT0N9vkB8JzWugRAa33Ki/F0ivo644Yz2++9cBhxofsImTjBx9EJIc5Fw/7GaT/9sF37tcbXfZALCwsbXWPgwIFER0dTVFTEBRdcwKRJk5gwoeWfW+np6Z7+yGvXrvXE9+6777Jo0SLuvvtunnrqKTZs2MC6detITExk4cKFnuPtdjtWq7Xd8QshhL/wZoKcAhxv8DgHmNxkn8EASqmvADOwVGu9yv1ckFJqC+AAntBav+vFWDvkqrEpZ07Im/Rrz5cVn35K2MyZKPnFIESv5C99kJteIy8vj/DwcHbu3El8fDw7d+5k48aNWCwWNm7cyPPPP8/999+P2WwG4NChQyxbtozg4GCGDBniia/+73nz5vHII49QWlrKfffdx1dffdXo+pIcCyG6K6+1eVNKXQtcqrX+H/fjG4HJWuvbG+zzAWAHrgNSgXXASK11qVIqRWudq5QaCHwGXKS1PtTkGrcCtwIEBASMr6ur88q9dETtnj0c+fY1JPz0AWJvvtnX4Qgh2qG5FmTe6GLRG/ogg1GD/MYbb/DDH/7Qs03avAkhzlaP6oOslJqKMSJ8ifvxzwC01o832OcvwCat9cvux58CP9Vab25yruXAB1rrN1u6XlcuFNKWyi++IHTaNBlBFqKbkOTN++Q1FkKcLV8kyN7sYrEZyFBKDVBKBQDXA027UbwLzAZQSsVhlFwcVkpFK6UCG2yfTuPaZb8WNmsWymrFWVlF7j33Ys/N9XVIQgghhBCinbyWIGutHcDtwCfAXuANrfVupdTDSqkr3Lt9AhQppfYAnwP3aa2LgKHAFqXUDvf2Jxp2v+gubEezqfrvf6k7fNjXoQghhBBCiHaSpaa9zFlZhTks1P11JeawMB9HJIRoqv7j/wV/3cC141P5zoS+2J0uvvviJq6f1Jerx6ZSY3Ny88uZfHdKf+aPTqa81k5E0JllVMuXL2fMmDGe1mve8NFHH7Ft2zbKysr47W9/i1IKOF2D/M477/DOO+9w9dVXM2XKFKZMmXLGObKzs3n33XdZsmQJr776KkePHqWwsJCnnnrKs8/8+fO56KKLiIiI4Pvf/36745MaZCFEZ5Klpnug+uS4Zvt2jt32v6Q+s4zQZn5ZCSF6nu7SB3nRokUALSbB0gdZCNHbyFLTXcTarx9hM2YQOGSIr0MRQrTg9dum8p0JfQGwmk28fttUrh6bCkBwgJnXb5vK/NHJAM2OHjfVUh/kQ4cOERsby+7du4mIiKCkpAQ43Qd5woQJVFZWUlFR0aH4W+qDXH+Nhn2QBwwY4OmD7HK5+NWvfsUdd9zR6Pj6PsgLFixoFF96ejqLFi3i008/5cEHH+Saa65p1Ac5Pj4eMPogCyGENyml+iqlPm+wKvNPmtknUim1Uim1w73P4rbOKyPIXcQSE0PKH34PgHa5qFy7lrALLvB8NCqE6Dm6Wx/kV155Ba01X3zxBaNGjZI+yEKI7sQB3KO13qqUCge+VkqtaTJ37cfAHq31fKVUPLBfKfWq1vrMXp5uUoPsA2UrV3Livvvp+7cXCZs+3dfhCNHrdVV9rPRBlhpkIUTHdaQGWSn1HvAnrfWaBtt+BvTFSJTTgDXAYK21q8XzSILc9bTLReVnnxF20UUygiyEH5DkzfvkNRZCnC2llA3Y1WDTC1rrF5rZLw1j0bkRWuvyBtvDMVoNnweEAwu01h+2dk2pQfYBZTIRfvHFKKWwnzzJiZ/+DGdl90juhehVdr4BT4+ApVHG3zvf8HVEQgjRGzm01hMa/GkuOQ4D3gKWNEyO3S4BtgPJwBjgT0qpiNYuKAmyj9Xs3EXl2rU4Tp7wdShCiIZ2vgEr74Sy44A2/l55pyTJQgjhZ5RSVozk+FWt9dvN7LIYeFsbDgJHMEaTWyST9Hws4pK5hE6bijk8HABXVRWm0C5t9SeEAPj4p5DX4BO8nM3grGu8j70G3rsdvv678ThpJHzriUa7dJc+yK+//rqnO0VTa9euZcWKFYwcObLF41vy8ssvM3fuXFJSUs7u5oQQogOU8QPwb8BerfVTLex2DLgIWK+USgSGAK2u4iYJsh+oT47LPviQU7/9Lf1fWUGAjyfZCNHrNU2O29reDH/ogzxv3jwWLlzI+PHjWbNmDfv27ePRRx9lw4YNLFiwgIsuuoiFCxdSWFjIAw88cMY9hIaGcttttzF9+nQcDgebN2/mO9/5Dl999RUxMTGUlpayaNEi7rnnHhYvXsx1113HU089xYMPPtihl1sIIc7SdOBGYJdSart728+BfgBa678AvwGWK6V2AQp4QGtd2NpJJUH2I0HnDSFk6hQsffr4OhQhep8mI8E8PcJdXtFEZF9Y3OrcDo+W+iBnZ2ezYMECdu/eTUZGBocOHQJO9xkuKiriyJEjVFRUEBQU1O5baNoHGfD0LN6zZw8mk4mAgAB27To9Uj5ixAhuueUWlixZ0ui4+fPnc9VVVwEQGBjITTfdxNq1a4mKiuLCCy9k5cqVPPjgg9x9990ATJ8+ncsvvxzA09dZCCG8TWv9JUbS29o+J4C5HTmvJMh+JHDQIFLc7Z9cNTXUbN9O6NSpPo5KiF7qooeMmmN7zelt1mBjexv8pQ9yw3Pu2bOHoKAgnE4nTqfT83xLnXRWrlxJdnY248eP95yj4fliYmJ47rnniI2NbbS9qqqK6OjoNl8jIYTwZ9LmzU+deuppil56ifRVqwhIlVo+IbypxRZkO9+ATx+GshyITDWS41HXnfV1ekMf5Jdffpk5c+aQmpraaLu0eRNCnK2O9EHutGtKguyfXNXVVG3aRPgFF/g6FCF6PEnevE9eYyHE2fJFgixt3vyUKSTEkxzX7NpF/hO/RTf4WFQIIYQQQniH1CB3A1VffUXFf/5D7G23YpHaPiG6xu8zoOrUmdtDE+C+A10fjxBCiC4jI8jdQNz//i8D3n4LS3Q0WmtcNTVtHySEODfNJcetbRdCCNFjSILcTZgjjBURC//4J7IXLsJZUeHjiITogV6ed/pPe/ZrxvLly9m+fXvnx9bARx99xKOPPsr9999Pw3kkK1as4OjRoyxbtoxZs2axbNkyNm7c2Ow5srOzWbZsGQCrV69m9uzZlJaWNtpn/vz5LFu2jJdeeqlD8RUVFfH888936BghhPAnUmLRzQSPHYOzogJTWJivQxFCtMEfFgr5xS9+QWZmJg6Hg2nTpvHuu++Snp5OWloamZmZbNmyhblz5za6RlOhoaGsXbvWE9+TTz7JwoULiYqKYuvWrZSVlXHfffdx5513cuWVVzJnzhyOHj3q7ZdXCCG8RkaQu5mwGTNI+sXPUUrhKCigdu9eX4ckRM+x+MPTf9qzXxtaWijk0KFDxMbGsnv3biIiIjwLa9QvFDJhwgQqKyup6OAnRU0XCiksLGx0jYEDBxIdHU1RUREDBgxg0qRJTJgwocXzpaens2TJEs+S1PXx1S8+8umnn/Lggw9yzTXXsG7dOhITE1m4cCHx8fEA2O32DsUvhBD+QkaQu7GTv1pK7a5dpK9ZjakDq20JIbzLXxYKaXqNvLw8wsPD2blzJ/Hx8ezcuZONGzdisVjYuHEjzz//PPfffz9msxmAQ4cOsWzZMoKDgxkyZIgnvvq/582bxyOPPEJpaSn33XcfX331VaPrW63WTnxVhRCi60gf5G7Mnp+P7ehRQpv88hRCdEyzPXq90MWiNywUAkYN8htvvMEPf/hDzzbpgyyEOFuyUMg56I0JckPln6zGUVBAzHcX+ToUIbodSd68T15jIcTZkoVCxFkrX/Ux5R9+iHY4fB2KEEIIIUS3JjXIPUTK73+Pq6YGZbGgbTYwmVAW+ecVQgghhOgoGUE+GzvfgKdHwNIo4++db/g6IpTFgjk8HK01uQ88QM6SJWiXy9dhCdG9vDwPtr1qfO20G493vG48tlUbj795y3hcW9bsKbpjH+RXX32Vxx57jLvvvrvRPtIHWQjRW8kQY0ftfANW3gl292p2ZceNxwCjrvNdXG5KKULGjUfbbCiTvP8Rwpe6Sx/kRYuMuQvf//73m70P6YMshOhtJIPqqE8fPp0c17PXGNv9RMyN3yX2FuMXXd2BA9jzZWlcIdpl8Ycw1j3R1Ww1Ho82egATEGI8HnGN8Tgoss3TdZc+yC6Xi1/96lfccccdjY6XPshCiN5KRpA7qiynY9t9SDud5Nz5E8wxMfR/ZQVKKV+HJESv0N36IL/yyitorfniiy8YNWqU9EEWQvR60uato54eYZRVNBXZF+76xvvX76Cab3ZjCgwgMCPD16EI4be6qgWZ9EGWNm9CiI6TPsjnoMsS5KY1yADWYJj/rF/UILem6OXlBGZkEHb+dF+HIoRfkeTN++Q1FkKcrR7XB1kpdalSar9S6qBS6qct7HOdUmqPUmq3UuqfDbZ/Tyl1wP3ne96Ms0NGXWckw5F9AWX83Q2SY5fNRtn771P+wQe+DkWIbuPDwx8y9825jPr7KOa+OZcPD3/o65CEEEJ0Aa+NICulzEAWMAfIATYDN2it9zTYJwN4A7hQa12ilErQWp9SSsUAW4AJgAa+BsZrrUtaul5vX0mvPZyVlZgCAlABAbjq6jAFBvo6JCH8QnOjmx8e/pCl/11KrbPWsy3IHMTSaUuZN3BeV4fY7ckIshDibPliBNmbk/QmAQe11ocBlFL/Aq4E9jTY5wfAc/WJr9a6vt3CJcAarXWx+9g1wKXAa16Mt8czh4UB4Kqp4ejNNxM2fTrxd97p46iE8A+/zfwt+4r3eR7vLNiJzdW4K0Sts5aHvnqIN7PeBOC8mPN4YNIDjfZZvnw5Y8aM8bRe84aPPvqIbdu2UVZWxm9/+1vPBNz6GuR33nmHd955h6uvvpopU6YwZcqUM87x+uuve7pTNLV27VpWrFjByJEjWzy+JS+//DJz584lJSXl7G5OCCH8gDcT5BSg4Wy2HGByk30GAyilvgLMwFKt9aoWjpWftp1EBQQQPHwEQcOG+ToUIfxW0+S4re3N8Yc+yPPmzWPhwoWMHz+eNWvWsG/fPh599FE2bNjAggULuOiii1i4cCGFhYU88MADZ9xDaGgot912G9OnT8fhcLB582a+853v8NVXXxETE0NpaSmLFi3innvuYfHixVx33XU89dRTPPjggx17wYUQwo/4us2bBcgAZgOpwDql1Mj2HqyUuhW4Fc5sbyRapsxmkh46/curZvt2AocMwRQc7MOohPCtpiPBc9+cy8mqk2fs1ye0Dy9f+nK7ztlSH+Ts7GwWLFjA7t27ycjI4NChQ8DpPsNFRUUcOXKEiooKgoKC2n0PTfsgA56exXv27MFkMhEQEMCuXbs8z48YMYJbbrmFJUuWNDpu/vz5XHXVVQAEBgZy0003sXbtWqKiorjwwgtZuXIlDz74oGf1venTp3P55ZcDePo6CyGEtyml+gL/ABIxynJf0Fo/02Sf+wB3k3sswFAgvr5SoTneTJBzgb4NHqe6tzWUA2zSWtuBI0qpLIyEORcjaW547NqmF9BavwC8AEYNcmcF3ps4Sko49v1biJg/nz6/XurrcITwGz8Z95Nma5B/Mu4nbR7rL32QG55zz549BAUF4XQ6cTqdnudb6o++cuVKsrOzGT9+vOccDc8XExPDc889R2xsbKPtVVVVREdHt/kaCSFEJ3EA92ittyqlwoGvlVJrGs5501r/Hvg9gFJqPnBXa8kxeHeSngVjkt5FGAnvZmCh1np3g30uxZi49z2lVBywDRjD6Yl549y7bsWYpNfizcgkvbNX8fnnBI8ahcX9i06I3qalCWQfHv6QZ7Y+Q15VHkmhSfxk3E/OaYJeb+iD/PLLLzNnzhxSU1MbbZdJekKIs9WRSXpKqfeAP2mt17Tw/D+Bz7XW/9fqebzZB1kpdRmwDKO++CWt9aNKqYeBLVrr95UxdPEkxgQ8J/Co1vpf7mO/D/zcfapHtdatfqYpCfK501pT8OSTRF51FYGDBvk6HCG6jCRv3ievsRDibCmlbMCuBptecFcRNN0vDVgHjNBalzfzfAhG9cKgtkaQvVqDrLX+CPioybaHGnytgbvdf5oe+xLwkjfjE4058vMpfe89TJGRkiCLXm/267Mpqi06Y3tsUCxrF6zt+oCEEKL3cmitJ7S2g1IqDHgLWNJccuw2H/iqreQYfD9JT/gRa1ISA997D7O7ftBls2GSyY+il2ouOW5tuxBCCN9QSlkxkuNXtdZvt7Lr9bSzZbBXV9IT3Y8lJgalFPb8Uxy+fD5lH8jKYaL3WLxqsedPe/ZrzvLly9m+fbsXojvto48+4tFHH+X++++nYZncihUrOHr0KMuWLWPWrFksW7aMjRs3NnuO7Oxsli1bBsDq1auZPXs2paWljfaZP38+y5Yt46WXOvZhXlFREc8//3yHjhFCiLPhLtf9G7BXa/1UK/tFArOA99pzXhlBFs0yhYYSNGQIAQPSfB2KEN2WP/RB/sUvfkFmZiYOh4Np06bx7rvvkp6eTlpaGpmZmWzZsoW5c+c2ukZToaGhrF271hPfk08+ycKFC4mKimLr1q2UlZVx3333ceedd3LllVcyZ84cjh496u2XVwghAKYDNwK7lFLb3dt+DvQD0Fr/xb3tamC11rpdE9YkQRbNMoeFkvrHZz2Pq7dsIXjcOJRJPnQQPVfD/sYj/95yS/bu0ge5sLCw0TUGDhxIdHQ0RUVFXHDBBUyaNIkJE1ou60tPT/f0R167dq0nvnfffZdFixZx991389RTT7FhwwbWrVtHYmIiCxcu9Bxvt9uxWq3tjl8IITpKa/0l0Hy/ysb7LQeWt/e8kiCLNtV8s5ujN95E4i9+Qcx3F7V9gBC9nL/0QW56jby8PMLDw9m5cyfx8fHs3LmTjRs3YrFY2LhxI88//zz3338/ZrMZgEOHDrFs2TKCg4MZMmSIJ776v+fNm8cjjzxCaWkp9913H1999VWj60tyLITorrza5q0rSZs379FaU/bee0R861uYAgN9HY4Qna65FmTe6GLRG/ogg1GD/MYbb/DDH/7Qs03avAkhzlZH+iB32jUlQRYd4aqt5dQfniTuxz/CIqtliR5Ckjfvk9dYCHG2fJEgS0Gp6JDavXspfestarZu9XUoQgghhBBeITXIokNCxo5l0OpPsMTHA6BtNpT0ShZCCCFEDyIjyKLD6pPj2j17OHjppdTs2OHjiIToHItXLebdg+8CYHfZWbxqMSsPrQSgxlHD4lWLWXVkFQAVtopmz9Ed+yC/+uqrPPbYY9x9d+NFTaUPshCit5IRZHHWzJGRBA4YiCUpydehCOGXuksf5EWLjO403//+95u9D+mDLITobWQEWZw1a0oK/f72ItbERLTWVEtdsujmXr70Za4adBUAVpOVly99mfnp8wEItgTz8qUvc+mASwEIDwhv83wt9UE+dOgQsbGx7N69m4iICEpKSoDTfZAnTJhAZWUlFRXNj1K3pKU+yPXXaNgHecCAAZ4+yC6Xi1/96lfccccdjY6v74O8YMGCRvGlp6ezaNEiPv30Ux588EGuueaaRn2Q492fMtnt9g7FL4QQ/kJGkEWnKP/gA07cdz/9lr9M6JQpvg5HCJ/qbn2QX3nlFbTWfPHFF4waNUr6IAshej1p8yY6hbbbKX33XaKuvRZjWXQhuo+uakEmfZClzZsQouOkD/I56MoE+cPDH/LM1mfIq8ojKTSJn4z7CfMGzuuSa3cHjqIiil78G/F3LcEkHS5ENyDJm/fJayyEOFvSB7kb+PDwhyz971JOVp1EozlZdZKl/13Kh4c/9HVofqNy/XpK/vUvbIcP+zoUIYQQQogOkwS5g57Z+gy1ztpG22qdtTyz9RkfReR/oq66ivRVqwg67zzAKL8QojsqW7mSAxdexN6hwzhw4UWUrVzp65CEEEJ0AUmQOyivKq9D23sra2ICABWffsrhK67EfuKEjyMSomPKVq7k5IMP4ThxArTGceIEJx98SJJkIYToBaSLRQclhSZxsupks9vFmcwxMVj7pmKOivJ1KEK0Ku+xx6jbu8/zuGbHDnSTtmm6tpaTv/glpW/8G4DAoeeR9POfN9pn+fLljBkzxtOb2BsyMzN57LHHWLp0aaPrfPbZZ5jNZrZt28aqVauYNWsW48ePZ+7cuWec4/3332fOnDkEBwef8Vx2djZ33XUXs2bNYtiwYc0e35JVq1YRGxvLxIkTz+rehBDCH0iC3EE/GfcTlv53aaMyiyBzED8Z9xMfRuW/QsaOpd8LLwDGstS1WQcIHjHcx1EJ0bamyXFb25vjrYVCJk2axFVXXXXG9VavXs0TTzzBrFmzKC0t5Yc//CG33XYbhYWFzJkzh9dee43Dhw9z++23s3XrVmbOnMmCBQu49tpr2bt3L48//vgZ5wwNDWXp0qXExcUxa9Ysli5dyuLFi8nOzsblcnHixAkef/xxZs+ezY9+9CMWLFjAz372M0mQhRDdmpRYdNC8gfNYOm0pfUL7oFD0Ce3D0mlLpYtFOxQ892eOLlwo5RbCLyX9/Of0X/EPzx9LcnKz+1mSkz37NB09bsrXC4UAnsU76hftiIuLY8OGDZ7nBwwYwE033URNTU2j42bNmsWSJUuYPn06AAsXLiQ8PJzp06dz+eWXc+jQIe68804iIyMpLCxk9OjRngVF6urqOhS36JmcDhefv7KPkrwqtNYc31Ps65CEaDcZQT4L8wbOk4T4LMQuvpnAgQOwtpB4COFPEu5awskHH0LXnv60SAUFkXDXkjaP9fZCIVlZWaxevZrdu3fTv39/oqOjgTMXCml4zuzsbJxOJy6XC6fTefqeWuhb/sUXXwCQkZHR6Dz1f6enp/Pss89SVlZGXFycZztAYGBgm6+R6PkqS+o4srOQxAER5GeX8+nyvVx511hSh0T7OjQh2iR9kIVP1B04QMXna4n9wf/IwiLC51rq0Vu2ciWnnl6G4+RJLH36kHDXEiLnzz/r63h7oZDPPvuMoKAgpk2b5pXzt0dLNcjSB7n30C6NMhk/1+uq7QSGWHE5XRzceoqMCYnyM190mCwUcg4kQe5eTv3hD5S+9x4D33sPS0yMr8MRvZwkb94nr3Hv4LA7+fgv39BveAyjL+zb7D6VJXUUHq8gbVRcF0cnuitfJMhSYiF8Iv6ee4i+8UZPcqwdDpRFvh2F/8g6fwbOwsIztpvj4hj85XofRCSE/1MmhTXAhDXA3OI+G989RPY3hdz4yDQCg+XnvvBP8p0pfEIphTUxEYCil16mcu1a+j7/Z0yhXfoGUYgWNZcct7ZdiN7MbnOiXZqAIAuX3Dqi1TKKmdcPZnRhX0mOhV+TLhbC5yzx8VgSE1FBQb4ORfRyR2+8yfOnPfs1Z/ny5Wzfvt0L0Z2WmZnJVVdddcZ1PvvsM7744guWLVvGpZdeyuOPP87q1atbPM+SJUtaPd+iRYtYtmwZy5Yt61B8drudJ554okPHiO5La82qv+ziw+d2GvXHbdQYBwRbiO8bDsCBLfnkHS7rijCF6BB5+yZ8LnL+5UTOvxwAZ2kpzvJyAvr183FUQpw7f+iD/MILL7Bnzx5KS0tZvHgxf/jDHxg2bBjnn38+e/bsYe3atcyePbvZ89ULDQ0lOzube+65h8WLF7NixQquvPJK+vbty8cff4xSioULF/Lss88yffp0zj//fGpqarDZbM121hA9i1KK86b1weVweSbntYfT4SJz5RGik0K47IejvBihEB0nCbLwKyd+/gtq9+4lfdXHmKRVlOhi/Vf8w/P13vNanlDWcL/WtNQHOTs7mwULFrB7924yMjI4dOgQcLoPclFREUeOHKGiooKgDnyy0lwf5E8//ZQbbriBvLw8oqKi6Nu3L0VFRfTv359hw4Yxe/bsFs8XHx/vGWXOzs729EBevXo1Cxcu5He/+x133HEHAK+88gqBgYHcdJMxsp6UlMSxY8cYNGhQu+MX3Yut1kFpfjUJ/SPImJDY4ePNFhNXLhlDYKjVC9GJ3kIp1Rf4B5AIaOAFrfUzzew3G1gGWIFCrfWs1s4rCbLwKwn33ostO1uSY9Gt+VMf5Dlz5lBVVUV6ejolJSWEhoaSk5NDWVkZFRUVrF69mrS0tGbPV1BQ4CmvmDdv3hm9kC+77DL++Mc/opRi0aJFvOBeNRMgLy+PfvJJUI+2/o0DHN5WwI2PTCXoLJPcsGjjDaDT7mL9vw8w7pJ+RMSeufy5EK1wAPdorbcqpcKBr5VSa7TWe+p3UEpFAX8GLtVaH1NKJbR1Uq+2eVNKXQo8A5iBF7XWTzR5/mbg90Cue9OftNYvup9zArvc249pra9o7VrS5q3nqVz/Ja6KciIuu8zXoYgerrkWZN7oYtEb+iCDUYP81FNP8cADD3i2SZu3nqeqrI5TRysY0Ant2kryqnjrd19z/nUZnDelTydEJ3qSjrR5U0q9h5FPrmmw7UdAstb6l+2+prcSZKWUGcgC5gA5wGbghiYZ/c3ABK317c0cX6m1Dmvv9SRB7lm01hy/7TYchYUMeOMNaQEnvEqSN++T17hnqKtxsG/DSUZdkNrpC37UVtoJCpNyC3EmpZSN04OmYJRRvNDMfmnAOmCE1rq8wfZlGKUVw4Fw4Bmtdau1ct7MOiYBB7XWh93B/Qu4EtjT6lFCYEz6SH32WVxVVSiLBe10gskkKzAJIYQP7dtwkv++eZCUwdHEpbZ7DKtd6pPjguMVZL5/mDm3DCcgSAZH/EVnryzaQQ6t9YTWdlBKhQFvAUsaJsduFmA8cBEQDGxQSm3UWme1dD5vfuelAMcbPM4BJjez3zVKqZkYo813aa3rjwlSSm3BqC15Qmv9rhdjFX7IFBSEKSgIrTV5S5cCkPTww5IkCyGEj4y6INUryXFDVSV1FJ+soqbCLgmynyhbuZKTDz6Erq0FwHHiBCcffAigK5PkFimlrBjJ8ata67eb2SUHKNJaVwFVSql1wGiM3LNZvu6DvBJI01qPAtYAf2/wXH/3u4WFwDKlVHrTg5VStyqltiiltjgcjq6JWPiEJT4ec1ycJMfCq47eeBOlb78DgLbbOXrjTZS9/z4Arpoajt54E+UffQSAs6Ki2XN0xz7IH3zwAU888QS33nordrvd87z0QRYAtVV2Vr/4DVVldSilvJocA6SNimPhr6YQGW9M1tMu782VEmfSLheO4mJq9+6lYu1aSt54g7xfP+xJjj371dZy6ullvgmyAWUkBn8D9mqtn2pht/eA85VSFqVUCMaA7d7WztvqWzOllAmYorX+b2v7tSAXaLgQeyqnJ+MBoLUuavDwReB3DZ7Ldf99WCm1FhgLHGpy/AvAC2DUIJ9FjKIbUEoRf+ed1NfL244fxxwRgTky0seRCdG67tIH+fLLL+fyyy/njjvuwGazYbU2rgOVPsi9W1lBDcf3llB8oorQyK7pMGS2GuN3Wz46QmFOFXNvGYbJ7Osxve7PVVODIz8fe/4pHKdO4TiVjz0/H0f94/x87AUF0OCNcmscJ096OeJ2mQ7cCOxSSm13b/s50A9Aa/0XrfVepdQqYCfgwmgc8U1rJ201QdZau5RSz2Ekpx21GchQSg3ASIyvxxgN9lBK9dFa17+6V+DO5pVS0UC11rpOKRWHcfPemfYtug2lFNrh4Pitt2FJSKDf8pdlRFl0qob9jZXV2uixKTi40WNzeHib5+tOfZCfeeYZ5s+fT2iD5d6lD3Lv5nJpTCZFYloENz461SflDpYAM5YASYzbop1OHIVFOE7lG0nuqVNG0pufj+PUKeynjCTY1cwnX6aQECyJiVgSEgieMJ6IxEQs8QlYEhOxJiZgSUgge9F3m02GLX1833FEa/0l0GYyoLX+PUbntHZpz3f7p0qpa4C3dQdaXmitHUqp24FPMNq8vaS13q2UehjYorV+H7hTKXUFRp1xMXCz+/ChwF+VUi6MMpAnGna/EL2XslhIeuhBTGFhkhwLv9Xd+iDv3LmTr7/+Gq01EydOlD7IgppKGyuf3cG4S/ozaHyCz2qBx1zcD62N5asdNidma++arK21xlVRYSS5DUd6TzUYBc7Px1FYCC5X44PNZizx8VgSEggcMIDQyVOwJCRgSUzAmpjoSYrNYW2XzCTcfVejGmQAFRREwl1LOvmO/Uebbd6UUhVAKOAEajCydK21jvB+eO0nbd56p9K33iIwI4PgUbJMqTh7XdWCTPogS5u37sJW62DVC98wdk4/+g6N8XU42GodvPvUNtJGxjJp/kBfh9MptM2Go6DAnei2NPJ7Cl1Tc8axpshIrAkJ7oQ30Uh6679OSMSSEI8lNhZlNndavL7sYtGRPsiddk1vLhTSlSRB7n1cdXUcvuIKgoePIOWpJ30djujGJHnzPnmNu4eaShsBQRbMFpNn5NYfaK1Z/68s+o2IJW3kuS9M4k1aa5wlJadrevPzcZwqcCfAp792FhefcayyWt0Jr5HkWhNOj/RaE90JcHw8puDetdqgLxLkdn1m4i6DmOl+uFZr/YH3QhKifUyBgaS9+iomd82kdjo79d2yEFmb8tjw3iEqi+sIiwlk6pXpDJ6c5OuwhPAKh93JO09uI75vGHO+P9xvkmMw5qDMvGGI53FVWV2XTRhsyDPJrX6k95R7pLfBqK/j1Cl0M5PczLGxnpHe4JEjsbjrexuVO0RF+dXr3pu1mSArpZ4AJgKvujf9RCk1XWv9M69GJkQ7WOKMkQSXzcbx224jfPZsYr73PR9HJXqCrE15fP7qPhw2o66vsriOz1/dByBJsuiRLFYzI2elEJvSpQN1HZZ3uIz3nt7GnFuGM3BMfKecs9Ekt6b1vg1Gfl3lTdefABUS4ilvCB43zj2xLbFxvW9cHEo6unQr7RlBvgwYo7V2ASil/g5sAyRBFn7FHBmFOSrK12GIbmr9G1kUHq/0PM4/UobT0bgEzWFz8dmKvez+8gQAcX3DmHHd4Eb7LF++nDFjxjBmzBivxfrBBx/wzTffcPjwYZ577jlPW7bPPvsMs9nMtm3bWLVqFbNmzWL8+PHMnTv3jHO8//77zJkzh+BmPqrNzs7mrrvuYtasWQwbNqzZ41uyatUqYmNjmThx4tnfoOhSlSV12GocxCSHMnJ2qq/DaVNcahjDzk8meVBUm/tqrXFVVp6u6fWM9Dap921pkltcHJbERALS0gidNPnMcoeEBJk03kO1d1pqFEaXCQBpPiv8jikggJSnn/L8kKo7cICAtDRUk36uQrRX0+S4re3N8VYf5Jb6FjfXB/m2226jsLCQOXPm8Nprr3H48GFuv/12tm7dysyZM1mwYAHXXnste/fu5fHHHz/jHkJDQ1m6dClxcXHMmjWLpUuXsnjxYrKzs3G5XJw4cYLHH3+c2bNn86Mf/YgFCxbws5/9TBLkbmTNS7upKq1j4dLJ3aLXsCXAzIwFg9E2G7acHAr35xFmLzrd09dd41vf01dXV59xDlNEhGekN3DQoNMjvQnu0d/EhE6f5Ca6l/YkyI8B25RSn2N0sJgJ/NSrUQlxFuqTY0dxMdkLFxF55ZUk/fIXPo5KdBdNR4L//vOvqCyuO2O/sJhArr5nXLvO6c0+yM31LW6uD3JiYiILFy7kxAn3qHdcHBs2bPA8P2DAAG666SZPv+N6s2bN8mxbs2YNCxcupLy83NML+a677uLpp5/m8ccfp7CwkNGjR7NgwQIA6urOfN2E/5q9aAh11Q6vJMdn0/lAa42ztPR0kttMZ4f6SW6H0y7jWN+Lmbz5EYJri41Jbu5yh8ChQwmbPevMcoeEhF43yU10XHtW0nMBUzDqkAEe0FrneTswIc6WJSaGxJ//nNDJk9reWYgWTL0yvVENMoAlwMTUK89Y9f4M3u6D/Ic//KHZvsXN9UGuP2d2djZOpxOXy4XT6fQ839JHw1988QUAGRkZjc5T/3d6ejrPPvssZWVlxMXFebYDBAZ2/eQp0THlRTUc213MiJkpRCd5p+a4bOXKRr1zHSdOcPLBh3AUFhI0fHjLPX1bmuQWE2MsXpGQQPCIEVgSE4mMSiSxJoihd7+INSlJJrmJTtOePshbtNYTuiiesyZt3kRztNYU/+1vRMybh9UPVvwR/qmlFmSd3cWiN/RBbqkGWdq8+Zcv3zzAvv+eZOHSKYREeGfy2IFZs3Hk57e5nwoObtDDN+GMcgdrYgLm+HhMbUxyKy+qwWl3eS3hF77jl32Q3V0sCoHXAU8GqrU+s4GfD0mCLJpjP3GCw1dcScz3FxP/ox/5OhzhpyR58z55jf2Ly+mivLCWqMSQTjunttup3raNqvXrqVy3nrr9+1vct+/fXvS0N+uMSW5aa958YgsOu4vrfzkJZZJR5J7EX/sgL3D//eMG2zTQM5ayET2aNTmZAe++gzU5GQDtcqFM/j8JRfjeS/d/SU35mTW9wREBfP935/sgIiHOTVlBNRvePsQFNw0lMNjSKcmxPT+fynXrqFq3nqoNG3BVVoLFQsjYsZjCw3FVVJxxjCU5mbDp08/52g0ppbjwpqHG4iaSHItO0J4a5J9qrV/voniE6HQBqUbbIkdJCcduuYWEn/yEsFmzfByV8HfNJcetbRfC35XkVXPycBlVJXUEBre3iVVjnlHideuMUeKsLAAsiYlEfOtSQmfMIHTaNMxhYWfUIAOooCAS7lrSGbdzhtiUMM/XB78+RcqQKILDpPewODut/g/RWruUUvdhlFcI0b1pjSkkxLPynhBNvfPk1g7t11w3i+7SBxlgyZIlLFu2jMzMTB577DGWLl3aKO5FixZ5aombdrlojd1u58knn+SnP5WGR/7A6XRhNptIGxnHd38zFWtAx1qX2fPyqFy//sxR4nHjSLj3HkJnzCRwcMYZZRL13So62sXiXFWV1fHp8j0Mn5HC+ddlePVaoudqz1vI/yil7sXPa5CFaIslJob+K1Z4fojXZmURmHHmD3UhOos/9EF+4YUX2LNnD6WlpSxevJg//OEPDBs2jPPPP589e/awdu1aZs+ezVVXXdXifYSGhpKdnc0999zD4sWLWbFiBVdeeSV9+/bl448/RinFwoULefbZZ5k+fTrnn38+NTU12Gy2ZjtriK5Tml/Nyj/t4MLvnkfKkOh2Jcfabqd66zaq1jcZJU5KIuJb3yJ05gxCp07FHBbWxpmMJNnbCXFToZGBXHX3OOJS245PiJZIDbLoVeqT4Zpd35B9/fUkPfQQ0Quu83FUwl80HBF+7n8/a9d+rfGHPsiffvopN9xwA3l5eURFRdG3b1+Kioro378/w4YNY/bs2S3GHx8f7xk5zs7O9vRAXr16NQsXLuR3v/sdd9xxBwCvvPIKgYGB3HTTTQAkJSVx7NgxBg0a1K7XSnhHQLCFiNgggsJbXzTJnpdn1BKvX0/VfzfgqqoyRonHjyfhvnsJnTGjWw0oJA6IAMBuc7Ltk6OMvzQNs1Xmn4j2azNB1loP6IpAhOhKQcOHkXDPPUTMm+frUEQP5E99kOfMmUNVVRXp6emUlJQQGhpKTk4OZWVlVFRUsHr1atLS0li9ejW7d++mf//+nvMVFBSwbNkyAObNm3dGL+TLLruMP/7xjyilWLRoES+88ILnunl5efTr168TX1XREZUltYRGBhISEcCVS8ae8by22ajeuo3K9cYEu7oDBwCw9OlDxLx5hM2cQciUqZjDundJWs6+ErZ8fJQ+6VH0HRbj63BEN9Jimzel1P1a69+5v/6O1vrfDZ57TGv98y6KsV2kzZs4W9pup+ill4n9n1tkWdFeqrkWZN7oYtEb+iCDUYP81FNP8cADD3i2SZu3rlNVVsfrj2Qy7PxkpjRY2MZ+8iSV69ZTuX4d1Rs2GqPEVish48cTNmMGYTNnEDBoULcZJW6v0lPVRCV0Xjs70fX8qg+yUmqr1npc06+be+wPJEEWZ6ty/XqO/+BW+v7f/xE2Q9p39UaSvHmfvMZdR2vN1k+OMnBENAE5e6lct56q9euoO3AQMEaJ6xPinjBK3F75R8o5vL2AKVcN7HFvAno6f+uDrFr4urnHQnRboeefT9q//03wyBG+DkUIIc5aYU4F5opi2LGRhPXrOfXzDbiqqz2jxAlXXU3YrJkEpKf3ygQxe1chB7/OZ+ycfgSFtV6TLURrCbJu4evmHgvRbSmlPMlx3eHDmAIDsaak+DgqIYRom7bZqP76a8q/+JKPD6YTWJHPuB3PYknuQ8T8+cYo8eQpvWaUuDWT5g9g9EV9CQqV5Fi0rbUEebRSqhxjtDjY/TXux81PqxaiG3PZbBxb/H0CzxtCv7/+1dfhCCFEs+wnTrhriY2+xNo9Sjxu4lyiZ40m6dGVvXaUuDVKKYJCrWit2fjeYUIjAxl1QaqvwxJ+qsUEWWsts5VEr2IKCCD5t08QkJbm61CEj7zz5FbOm9qHodP64HS6eH/Zdoadn8yQyUnYbU4++OMORsxKIWNCInU1jmZXI+uOC4W0dD5ZKMQ/uGw2ar7+2jPBznbQaAtoTU7GeelCHBljGXndZFkEqZ20S1Nysoq6aoexNLW8kRDNOLu1JoXooUKnTAGMSS7248cJkDZV4hx0l4VCWjpfPVkopOvZc3OpXL/emGC3cSO6uhpltRIycQJR11xrdJwYOJBVL3xD0eFKRgQE+zrkbsNkNnHJD0ZgMiuUUmiXRpkkSRaNSYIsRDOK//Y3Cv78PAPfe5eAvn19HY7oIg0XADGbTY0eWwPMjR43N3rcVHdaKKS588lCIV3HZbNRs2WLp3TC5v6esKakEHnlFYTNmEno5ElnjBJfvHgYdVUOWQSjg8wW4/WqLrfxwZ92MPnKgfQfHuvjqMTZUEr1Bf4BJGLMkXtBa/1Mk31mA+8BR9yb3tZaP9zaeSVBFqIZEfOvQLs01uRkX4ciuqHutlDIzp07mz2fLBTiXbacXM9yzlWbNjUYJZ5I1HeuJWzmTAIGDDijBODkwVJ2rc3hou8Nwxpgbtfy0aJ5ZovCEmDCZJYR5G7MAdyjtd6qlAoHvlZKrdFa72my33qt9eXtPWmLfZC7G+mDLLzFVVWFCgmROrUerKt69MpCIb27D7LLZqN682aq6keJDx8GwJqaStjMGYTOmEHo5MmYQlpf1GLPlyfYtuYYV98zjpAIKWE5Vw3rkO02p7zh8EMd6YOslHoP+JPWek2DbbOBezslQVZKVdBKOzetdUR7L9IVJEEW3mA/dYqj372RmO/dRMyiRb4OR3jJ3r17GTx4MGZZSdErnE4nWVlZvTJBtuXkULnOWM65atMmdE0NKiCAkIkT3UnxTAIGpLXrDbjT7vKUUjjsTixW+X7tTNk7C/n81X1cuWQsMX1kwqM/UUrZgF0NNr2gtX6hmf3SgHXACK11eYPts4G3gBzgBEayvLu1a7bWxSLcfdLfACeBFRgt3hYBfdpzQ0J0d5a4OEInTyZo6DBfhyK8KCYmhqysLF+H0aPFxMT4OoQucXqU2CidsB0xSh6tffsSdfXVhM6cQeikSW2OEjd14kAJa17aw+W3jyY2JUySYy+I7hNCn4GRhEbKqHxzsjblseG9Q1QW1xEWE8jUK9MZPDmpqy7v0FpPaG0HpVQYRhK8pGFy7LYV6K+1rlRKXQa8C2S0er62SiyUUju01qPb2uZrMoIsuoK0BBJCNNXmKPHMmQSktW+UuCVlBTWs+9d+LvreMCmr6AIul6auyk5wuLzWYCTHn7+6D4fN5dlmCTBxwaLzuiRJbqvEQillBT4APtFaP9WO82UDE7TWhS3t055JelVKqUXAvzBKLm4AJBMVvU7xileo+uorUv/8HMokM8aF6K1cdXVUb97imWDX7Cjx5MmYgs+99VpZQQ2R8cFExgcz/44x53w+0T5rX93HyYNlXPfziVgDe8dovdYah81FTaWN2ko7tZV2atx/Z6483Cg5BnDYXGx471BXjiI3SxnvPP8G7G0pOVZKJQH5WmutlJoEmICi1s7bngR5IfCM+48GvnJvE6JXUVYrympB19WhOuEXnxCi+7AdP356lDgz8/Qo8aRJRN9wPaEzZpzzKHFThTkVvPnE18xYkMHwGSmddl7RtvOm9iE2OaxbJ8cOu5PaSge1VTZPotsw6a2tdG+vOr3daXe1feIGKovrvBR9h0wHbgR2KaW2u7f9HOgHoLX+C3At8EOllAOoAa7XbZRQeLWLhVLqUozE2gy8qLV+osnzNwO/B3Ldm/6ktX7R/dz3gF+6tz+itf57a9eSEgvhbfX/V6TEQoiez1VXR3XmZirXG0mxLTsbAGu/foTNmEHYzBmETJrUKaPELcbg0mz5KJtRs1MJCrO2fYDwivLCGoLCrAQE+a4zrtPpoq7K0ezobm2lnZqqM7fb65wtni8wxEJQmJXgMCtBYQHG16FWgsKsjbYHux+//mhms8lwWEwg33tsujdvHehYF4tOu2Y7apAHA88DiVrrEUqpUcAVWutH2jjODGQBczBmDW4GbmjYl86dIE/QWt/e5NgYYAswAWPU+mtgvNa6pKXrSYIsuoqjuJj8Rx4h4b77sPaR+apC9BS2Y8c8yzlXb8pE19aiAgMJmTTJkxR3xVL0OftLiEsNIyhUkmJfs9uc/PNXG0kaGMklPxjRKed0uTR11U1GdKsaJre2xglwlZ26akeL57MGmY1ENrRxUns60XX/HWokwkGhFkzmjpUJ+nsNsje05+3Q/wH3AX8F0FrvVEr9E2g1QQYmAQe11ocBlFL/Aq4EmjZubs4lwBqtdbH72DXApcBr7ThWCK9ylpZRtXETtXv3SoIsRDfmqq2levNmY6GOdeuwHT0KgLV/P6Kuvfb0KHELqxl6Q22VnY+e38mg8QlceGPva4vnb6wBZqZdM4jY5LBmn9daY6txNF/C0FJpQ7W9xSa6lgCTO6E1ktmIuODGSW5YfZJr9STFXbGKYn0S7MMuFl2uPQlyiNY6s8nHyi2/lTktBTje4HEOMLmZ/a5RSs3EGG2+S2t9vIVjpQBL+IXAgQMY9J81HW7TJITwPdvRo6dHiTM3nx4lnjyJ6O9+1xgl7t/fZ/EFhVqZ98NRxPVtPiET3qO1xl7n9IzaNkxui3LzqK20U3yiChTUVRtJcV2lHZer+WzXZFaNktq41LAzR3brR3Xdf/x5kZLBk5N6dELcVHsS5EKlVDru9ztKqWsx+iJ3hpXAa1rrOqXUbcDfgQvbe7BS6lbgVmh+iVUhvKU+Oa788itcNdVEzJnj44iEEM1x1dZSnZnpSYrtR48BENC/P1Hf+Y4xSjxxYpeOEjfn0LZTWAPM9BseS8qQaJ/G0lM4bM4zEt1GJQxVZ9byOh3NT1JTJkVAkIm6aieR8cHEpoaRlH66brdRLW99shtoljkr3Vh7EuQfAy8A5ymlcoEjGIuFtCUX6NvgcSqnJ+MBoLVu2GLjRaB+/dVcYHaTY9c2vYB7FZUXwKhBbkdMQnQarTWFf/4zuFyEX3yx/CAUwk/YsrPdCfF6qjMzjc4zQUGETJ5EzI03GaPE/fr5OkwPl0uzddVRrEEW+g6L6VE/SzprcQmnw9WkTrdBF4Yz6nht1FY5cLQ2SS3UYpQxhFoJjwkioV948xPU3AlwYLAFZVIc2JLPwLHxmDtYwyu6n1Yn6bkn2v1Wa32vUioUMGmtK9p1YqUsGGUTF2EkvJuBhQ2X9lNK9dFan3R/fTXwgNZ6inuS3tfAOPeuWzEm6RW3dD2ZpCd8wVFQgCk0VMothPAhzyjxF+uoXL8e+zH3KHFaGqEzZxA2YyYhEyf4fJS4NbWVdkwW5dNOCZ2tpYldsxYOof/w2CYju7ZWR3tttS0nuwFBZndy28wEtdDT9bz12wJDOj5JrSlbrYMj2wsYMkXmoXQFv5ukp7V2KqXOd3/doexTa+1QSt0OfILR5u0lrfVupdTDwBat9fvAnUqpKzBqmouBm93HFruXuN7sPt3DrSXHQviKJT4eAG23U75qFRGXX96jRn+E8FctjRKHTp5MzPduImyGf40SN+fA5nxy9pcwe+GQHtnG7b9vH2x2cYlPl+9t8Zimk9Qi45ufpOZJhEOtmC1dP5q78/McMlceISEtguikLs3bRBdpT5u35zEmyP2bBivoaa3f9m5oHSMjyMKXSt98k5O/fJD+r75CyPjxvg5HiG6tbOVKTj29DMfJk1j69CHhriWEX3xxg1riZkaJZ84yRokDA30cfftlfnCE3P0lXH7HaL+enNVelSW15O4vISerlNz9JVQU1ba474wFGd1uklpDLqeLU0crSBoY6etQegV/7YP8cjObtdb6+94J6exIgix8SbtcVG/aROjUqb4ORYhurWzlSk4++BC6tkFyZTKBUuB0ekaJjaR4JgF9+7Z8Mj/lsDmxBJjRWuNyap+MgHaG6nKbOyEuIXd/CWWnagCjvjdlcDS5+0ua7d/bVYtLdJUTB0qpLrcxaHyCr0PpsfyuxAJAa724KwIRojtTJpMnObYdO4Y5IgJzVJRvgxLCz7nq6rDnnsCem4M9Nxd7Tg7Fr7zaODkGcLkwhYaS8swz3W6UuKn9m/LIXHmYq+8ZR1h0EGZL9ynJqq20k+tOhnOySik5aQxKBQSZSR4czYiZKaQMiSYuJQxlUi3WIE+9Mt1Xt+AVX6/KprKkjoFj4s65tln4jzYTZKVUEHALMBzwzHDwtxFkIfyBq6qK7OtvIHTaNFL+8HtfhyOET2m7HfvJk9hzcrDl5mLPyfUkwvbcXBwFBY32V1Yr2m5v9lyu6mrCzu/+o44xfUJJ6B/RLVbJq6u2c+JAKbn7S8nJKqEopxIAS6CZ5EGRnDcliZQh0cT3DWs2Mewti0tc8j8jcNhdkhz3MO0psfg3sA9YCDyM0eJtr9b6J94Pr/2kxEL4i/JVnxA0YgQBqbK2jejZtNOJIy+v2eTXlpuLIz8fXA0maZnNWPv0wZqSgjU1BWtKCgGpqe7HqVji4zl48RwcJ06ccS1LcjIZn33ahXfXuUrzq4lK9O9uN7ZaBycPlpG7v4TcrBIKjlWgNZitJvqkR5IyOJqUIdEkpIVLm7NmaJdm43uHGTAmjqQBUpvcmfyyxAIYpLX+jlLqSq31393LTK/3dmBCdFcRl17i+dpRWIglLs6H0Qhx9rTLhaOgsFEJhCcZzsnBnpcHjgY1pkphSUzEmppC6KRJnsTXSIRTsCQmoiyt/9pJuGvJGTXIKiiIhLuWeOkuvS97ZyEfPb+TebePpv/wWF+H42G3Ock7ZCTEOftLOHW0Au3SmCyKpAGRTLgsjZQh0SQNiOyS5Yy7u7oaBwe3nkKZkAS5B2jPCHKm1nqSUmod8CMgD8jUWg/sigDbS0aQhb8p/MtfKF7xCgPffcfTDk4If6K1xllcfDr5bTIKbD9xAm2zNTrGHB9HQEpqg+Q3+fQocJ8+qE5Y1bS5LhaR8+ef83l9xWF3sm31McbN7e/TRNNpd5F35HRCnJ9djsuhUSZFYlq4Z4Q4KT2y23ST8De1VXYCQyzS7rOT+WsXi/8B3gJGAS8DYcBDWuu/eD+89pMEWfibukOHKPvgA+J//OM2R82E8AatNa6yshZKIHKw555A19Q0OsYcHX1m8lufACcn+/ViG/7m8LYC+g2PweKjZNPpdHEqu8KTEOcdLsNpd6EUxPc7nRD3GRTZoxYo8QcVxbV8vmIvF9w4lPAY+T9zrvwyQe4uJEEW/kzbbJ0ysiZEU87KqkYlEPbc3EYjwa7Kykb7m8LDsaamEpCagjX5dAmE1f3YHCaLHnSG4pNVvPbwJiZfMZAJ30rrkmu6nC4KjlcaNcT7SzhxqMyz3HJsahipg6NJGRJFckYUgSH+P0mwOyvMqeDDP+/kkv8ZIb2SO4FfJshKqYea2661ftgrEZ0lSZCFv7KfOMGx//kB8Ut+QsTcub4OR3Qzrpoa7CdONN8JIicHZ1lZo/1VSAgBKSmN6n+tqSnGttRUzBERPrqT3uf43mKSB0d5bUKbdmkKcxskxAdKPUsyR/cJJXVwFClDokkeHEVwmLxB72pOh8vT41q7jFIWcXb8dZJew6wzCLgcaHmdSCFEI+a4OALS0qQvsmiWy2bDceLEGfW/9SUQzsLCRvurgABP8hs0ckTjEojUVMxRUVL/6EM7PjtOn/RIEvpH0HdoTKeeW2tN8ckqd0JcSu6BEuqqjEmSkQnBDJqYSOpgIyEOjey+vaJ7ivrkeP+mPL75Ipf5d46WUpZupD0LhTzZ8LFS6g/AJ16LSIgexhQQQN8/P+frMISPaIcDe16ee+S3vgTCSH7tOTk4Tp2Chp/kWa1Y+/QhIDWFoAtmY01JbdQWzRIXhzJJRwF/ZKt1sPOz4xSfrCKh/7mP1GutKTtVQ457hDg3q4SaCqNPdHhsEANGx3tGicOipc7VXwUEmbEGyaTH7qbDNchKqWhgs9Z6kHdCOjtSYiG6g5LXXqN27z6Sfr1URvl6CO104igoaFD/ezr5tefmGq3QnM7TB5hMWJOSWiyBsCQkoMzyy7S7qiqrIzjMetaLRpQXNkiI95dQVWZ0EQmNCiRlSBQpg6NJHRJNRFxwZ4YtvExrjVIKp9MFmm67vLiv+GWJhVJqF1CfRZuBeIwFQ4QQHeQoKMSRn4+222XSXjehtcZZWHh68lt94pvrrgk+cRKarP5mSUjAmppK8PhxRDRZDMOamIiyygSpnmTzh0dwOlxMvmJgh0sbKoprPcs35+4vpaLY6P8cHG4lZUi0JyGOTAiWN9XdmFIK7dKs+us3WKwm5v7PcPn39HPtKYa5vMHXDiBfa+1oaWchRMvifvwjUEo+IveCs+2dq7XGWVraTAnE6Qlxuq6u0THm2FisqSkEDx9OxNxLGrVFs6akYJI3P72G1prK4lpcTm0MJbWR81SV1bkT4lJy95dQVmC02QsMtZAyOJqxc/uRMjia6D4hkkD1MMqkSM6Iwhpgkn/bbqA9XSxanWWgtS7u1IjOkpRYiO7EWVrKqaeXkXD3XZgjpQXQuSpbubLZ1df6/OZhIufPx1lR0XIJRE4OrurqRuczR0aeUQLRcFlkU7B8vN3baa1x2FxYA81ol0YDpma6FNRU2oxk2D1KXJJnfK8FBFtIzogidYjRei02OUy6HPQyVWV1hEQESLLcDv7a5i0b6AuUYLw3jgKOuZ/W/rKiniTIojup2bGDo4u/T+rTTxE2a5avw+n2Dlx4EY4TJ858wmLBFBKCq7y80WZTaKiR/DZdCc79tzksrIsiF91V5gdHOLytgKvvHUdg8OkPY+uq7eRmlXpGiYtyjT7UlkAzyYMiSRlilEzE9Q1vNqEWvUNFcS1vPLaZsXP6Me6S/r4Ox+/5ZQ0ysAZ4R2v9EYBS6lvAVVrr27wamRA9WPDo0Qz69D9YoqN9HUq3pJ1O6g4epGbHDmp27mw+OQZwOIi8/PJGyW9AagqmyEgZtRHnpE96JLVVdtCa7F2FRlK8v4SC4xXGJCyriT7pkUy+ciCpQ6KJ7x/utX7IovsJiw5k+PnJDBwb7+tQuj2lVF/gH0AiRqHTC1rrZ1rYdyKwAbhea/1mq+dtxwjyLq31yLa2+ZqMIIvuqiozE2UyETJhgq9D8Vv2U6eo2bGD2p07qdmxk9pvvvGURZijonDV1JxRJwxgSU4m47NPuzpc0UNprTl1rAJblYMcd8nEqaMVaJfGZFEkDagfIY4iMS0Ss1USYtE+RbmVxKbIJ1ctaW0EWSnVB+ijtd6qlAoHvsYYyN3TZD8zxqBvLfBSWwlye0aQTyilfgm84n68CGhhuEYI0RHa6STv4YexxMTS7+/LZVQTY+W42j17qNmx8/QI8cmTxpNWK0HnnUfkt79N8OhRBI8ahbVfP8o/+KDZGuSEu5b45iZEj+GwO8k/XE5OVglZm/IoLzS+x0wmRUJaBOMu6UfKkGj6DIzEEiDt+UTHZW3OY81Le7jqrrGkDJZPFTtKa30SOOn+ukIptRdIAfY02fUO4C1gYnvO295Jer8CZro3rQN+7S+T8+rJCLLormzHjmGOicUc1qXlVX5Bu1zYsrONZHjnDmp37KR2/35P32BrairBo0YZyfDo0QQOHYopsPk2WmfbxUKIhpwOF6eyy8nNKiFnfwl5h8tx2l0oBbGpYQQGWxgztx/Jg6JkVTTRKRw2J7u+yGX0RX2lLr0F7a1BVkqlYeSpI7TW5Q22pwD/BC4AXgI+OOcSiyYXjgZKdUdXF+kCkiCL7k47HFRt2EjYjPN9HYrXOEpK3GUSO4ykeNcuzwQ6U1gYQSNHEDx6NMGjRhM8ehSW2FgfRyx6OpfTRcGxSk9CfPJgKQ6bC4C4vmEkZxhLd4+/LI3gUOlfLbyrrtpOSV41SQOlu1FDSikbsKvBphe01i802ScM+AJ4VGv9dpPn/g08qbXeqJRaTjsS5Bbf/iqlHgLe0FrvU0oFAh8DowGnUmqh1vo/Hbg3IUQbil95hVNP/JYB77xN0NChvg7nnGmbjdp9+9yjw0ZSbD/mboBjMhE4eDARl15qJMSjRxEwcKD0hxZep12awpxKY7W6rBJOHijFVmt8YhGTHMrQacnGinUZ0QSFWTm2p4iVz+4gIS2cwROTfBy96OnWv36A7F2F3PjotEbdUQQOrXWLE3WUUlaM8olXmybHbhOAf7nLGOOAy5RSDq31uy2es6XBYKXUbowhaq2UuhVYCFwEDAb+rrWe1L576hoygiy6O1ddHZXr1hExZ46vQ+kwrTX23Fxqtu84XSqxdy/aZiyTa0lI8CTCQaNGETx8OKbQ3ldSIrqe1priE1We5ZtPHCilrtpY6yoqMYSUwVGeFetCIppf4CVnXzEpQ6JljoDwuupyG0UnKul7XqtLUPQ6bUzSU8DfgWKt9ZJ2nGs55zKCDNgalFJcArymtXYCe5VS8rZGiE5mCgz0JMf2Eycwx8RgCgrycVTNc1ZUULtrlzEyvN2YSOcsNqYlqKAggkYMJ/q73/UkxdYkGXkTXUNrTWl+Nbn7S8jZX8qJAyXUVBhLgUfEBTFwTLwnIQ6Lbr6eXbs0G987zNDpfYhKCCFVkhXRRUIiAgiJML7fcvYVExIZSEwfGUxow3TgRmCXUmq7e9vPgX4AWuu/nM1JW0t065RSI4B8jKLmexs8F3I2FxNCtM1ZWsqRb19DxOWXk/TLX/g6HLTDQd2BA6dLJXbuwHboMLjfPwekpxM2a9bpiXQZGSiLvIcWXUNrTXlhDbn7Sz1lE9VlxicXYdGB9BsWa5RMDI4mIq59KyBWlNSy58sTBIVaGTu3nzfDF6JZTruLz/6xj+g+Icy/Y4yvw/FrWusvaXOR90b739ye/VorsZiMMWQdDyzTWv/Gvf0y4Eat9Q3tDaYrSImF6ElKXnuN0GnTCOjf9Sss2fPz3ZPojFKJmt270TU1AJijo42uEmNGG6USI0dijojo8hhFz5a1KY8N7x2isriOsJhApl6ZzuDJpz+FqCiuJdddMpGTVUJlsdEDOzgigNQGJRORCcEdKovQWnv2l2WAha8Vn6giJDKAIJkc6p9LTXcXkiCLnspZWem1pY9d1dXU7t7tnkRnTKRz5OcDoKxWAocNNTpKuJNia2qqJAzCq7I25fH5q/s8nSTAWJVu6LQkXA5NTlYp5QXGG7agUOvpGuIh0UQnhZz196fLpfnsH3tJTItg5OzUTrkXITqDy6X5+uNsRsxKITis+Tr5ns5fl5oWQvhIwXPPUf7+StLeevOck2TtcmE7csRTM1yzcyd1WVmnew737UvIxImevsOBQ4diCuidP4yF72x471Cj5BiMj5u/+eIEAcEWkjOiGDU7lZQhUcQmh6E6qW+sdmnqqh3UVds75XxCdJaSk1V8veooQaFWefPWhSRBFsKPhU6ZgquissXFMVrjKC72rERXu2MHNbu+wVVRAYApPJzgkSMJu/UH7r7Do7DEyEQk4Ttaa/KPlHvKJZpzy5MzOn0hBZfThdOpsQaY+db/jpSFGoTfiU0J44aHJhEZL9O/upIkyEL4sZDx4wkZPx4wRoBb6hPsstmo27PndKnEzp3Yjx83njSbCRwymIh5lxnlEmNGE5CW1uN6DjsdLnatzaHv0BhiU8JwOl2YTEpKQvxcSV4VWZn5ZGWeXsa5OWExgZ2evGqt+c/yvVSX13HFnWMwmXvW/wnRc9Qnx+WFNXy96igzFwzGbJXvV29qV4KslJoGpDXcX2v9Dy/FJIRowpaTS86dd5D0y18SPHYs9uPHPTXDNTt3Urd3L9pufDRsSUoieNQooq+/3ug7PHw4puD2zd7vznL3l/DVmwf57m+mAkYt61dvHeT6X04iLDqImkobZrOJAGm+73PV5TYObMkna1Mep45WoBSknhfNxHkDcDlcrP/3gUZlFpYAE1OvTO/0OJRSpI2MparMJsmx6BZOHirj8LYCRl/UV9q/eVmbk/SUUiuAdGA74HRv1lrrO9s8uVKXAs8AZuBFrfUTLex3DfAmMFFrvcW9lvZeYL97l41a6/9t7VoySU/0VM7ycqo2biL/scewJCRgP34cZ0kJACokhODhw08vwDF6NNbERB9H3HUqimspPllF/+HGktT5R8pJHGB01ThxsJQDmfnMvH4wyqTY8M5BdnyWww+enonZYqIotxKTWRGdJL9kuoK9zsnh7QVkZeZzfG8x2qWJ6xvGkMlJZExIJDTqdBlRW10szpXT4aI0v5rYFO9MfhXCm2qr7L2us4VfdrFQSu0FhukOtrtQSpmBLGAOkANsBm7QWu9psl848CEQANzeIEH+QGs9or3XkwRZ9ATa4aAuK8vdZs0olbAdPux5PmBQurtm2FiAI3DQoF7dc/jD53ZQcKyCGx+dhtnS+ghg/pFyCo5XMGJmCgAfPb+TohNV3Ogecc7eWUhAiIXkQVHeDrvXcDld5OwrYX9mHoe3F+KocxIWE8jgSUkMnpRIbLJvEtT1r2exb8NJFj08tcXV84Twd3u+PEFhbiUzrsvo8aVk/trF4hsgCTjZwXNPAg5qrQ8DKKX+BVwJ7Gmy32+A3wL3dfD8QnRrWmsceXmnF+DYsYPa3bvRtUYdpjk2luBRo4i8Yj7Bo0cTNGIE5vBwSt98E/upUwSdd56P78A3ju4uIjEtgqBQK+dfNxhlos3kGCBxQIRndBlg6tXpngUlADa8e4jwmCCSb48CYOvqo8Qmh9F/RGyn30NPprWm4FgFWZvyydqST025jcAQC4MnJTJkUhJ90iM7rfPE2Ro7tz/x/cIlORbdWml+NWWnqnE5NGZrz06QfaE9CXIcsEcplQl4phdrra9o47gU4HiDxznA5IY7KKXGAX211h8qpZomyAOUUtuAcuCXWuv1TS+glLoVuBUgQNpRCT/nqqqi5pvd1OzcQa17iWZHQQEAKiCAoGHDiF5wnbtUYgzWlORmRwWqt2/HcTIP7XD0utHj8sIaPvzTDsZflsbk+QOJjD/72uropNBG5RXfvncctVUOwGj5tePT42SMT6T/iFi01qz5224yJiYyYHT8Od9HT1ReWENWZh77N+VTml+NyaJIGxnHkElJ9B8R6/MJRQ67k6zMfIZO60NYdCDnTe3j03iEOFdTv52Oy6Uxm01ol/b5G8+epj2/XZd648JKKRPwFHBzM0+fBPpprYuUUuOBd5VSw7XW5Q130lq/ALwARomFN+IU4mxolwvboUPGyLC773DdgQPgMiYeWfv3I2TKFKNcYvQogoYMQbXzTV7SQw+hzGaU2ezNW/AbDruTkwfK6Dsshoi4YObfMYbkjKhOv05giJXAEKOuT5kUNz8+HYfd+Peqq3ZQmFtFyhBjxLm2ys67T21jylUDSRsZh3ZpUPT4jzmbqq20c3DrKbI25XHyUBkAyRlRjJ3Tj4Fj4/2qTnLfhjy++Od+YpJDSRoQ6etwhDhnSinMZoXd5uTjv+xiwKg46ZPcidpMkLXWX5zluXOBvg0ep7q31QsHRgBr3b9UkoD3lVJXaK234B6t1lp/rZQ6BAwGtpxlLEJ4laOwsNFqdLW7duFy18SbIiIIHjWK8Isu8kyms0RHn/W16hfvcFZUUPTC/xF3x+09ekGPzR8cYfua49z46FTCooPoO6xr+jUrk8IaaLwJCQq1svBXk6mfilFXbSc0MsDTEePU0QpW/mk7l/1wFMmDorDXOdEu3SM7ZjhsTrJ3FZGVmcfRb4pwOTXRfUKZctVAMiYmEhHrnx1Ths9IluRY9Egms/GzyhIgnVg6U3sm6U0B/ggMxZhIZwaqtNYRbRxnwZikdxFGYrwZWKi13t3C/muBe92T9OKBYq21Uyk1EFgPjNRaF7d0PZmkJ7qKq66O2j17jETYnRTbc93v/SwWggYPJmj0KM9kuoC0/l7pOVy5bh3Hf3w7/f76F0KnTev08/tSWUENSkFEXDA1FTYKcyvpe57/LmRSdKKSnZ8eZ9L8gYRGBbJ/Ux7/Wb6Hhb+aTHRSKJUltdjrnEQlnv1SyL6kXZrcA6Vkbcrj0NZT2GqdhEYGkDExkcGTk4hLDfPL+7LbnHz15kEmXT5A6o1Fj6a19vwftNc5PW/uewp/naT3J+B64N/ABOAmjNHcVmmtHUqp24FPMJLql7TWu5VSDwNbtNbvt3L4TOBhpZQdcAH/21pyLMTZKlu5klNPL8Nx8iSWPn1IuGsJkfPne57XWmM/erRRqUTt/v1Q33M4uQ/Bo0YTvWgRwWNGEzRsGKagoC6JPWzmTAZ9sgprcnKXXK+rOOxO3vrdFpIzorj01pEEhwf4dXIMEJscxgU3DvU8jusbxqTLBxCZYDT3373+BF+vOsoPnp6JNdBM3pEy7LVOUs+L9svEsl5RbiX7N+VxYHM+lSV1WIPMpI+NZ/DkJFIGR/v9qnMlJ6vIysyj73nRpI9L8HU4QnhN/c+RgmMVrPzjduZ8fzh9h/r3z01/154R5C1a6wlKqZ1a61Hubdu01mO7JMJ2khFk0VFlK1dy8sGHPF0jAFRQENGLFmEKDjYm0+3YibPMqK1UISEEjxhxum541CisCf7xS7d66zbM4WEEZmT4OpSzorUmP7vc8/F39q5C4lLDCYvu+BLb/qi8sIaCYxWeJG3VC9+Qn13G9x6bDkBWZh7KpMiY4Pse1pUltZ6V7YpyqzCZFP2GxzB4chJpo+KwBvj/yFTD0bSaChvB4TJ6LHqHumo7n6/Yx7RrB/ltudPZ8Nc+yOuAi4EXgTyMCXQ3a61Hez+89pMEWXTUgQsuxHGyhe6FShE4aJBRKuHuKhE4KN0vJ8a5bDYOXXIpgYMz6PfXv/o6nLOSlZnHmpf2cNVdY0kZcvb12d1FXbWdiuI64lKNPsBv/+FrLFYTV/zEGHfY+O4hIhOCGTqtaz4dqKtxcGjrKbIy88jNKgUNSQMjGDwpiUETEggO6z4Jpq3Wwcd/2cWIWSmkj/WPN7BC+ILWmuoyW6NFeLorfy2xuBEwAbcDd2FMvLvGm0H5s6zzZ+AsLDxjuzkujsFfntGJTvgRR0GBewGOHdRs295ycgwM3pyJOax7rLJlCgig75+fw5qS4utQOsRuc1JVWkdUQgjpYxOwLXSSNKh3TKBq2DED4Oq7x1FX424xpzU5+0uw1TmpL9p4b9k2MiYmMmx6smefcy3NcDpcHP3GmGyXvbMIp8NFZEIwky4fwOBJiUTGh5zT+X3J6XDhckhjI9G7bVt9jG2rj3HdLyYSHtM1pX89SXu6WBxVSgUDfbTWv+6CmPxac8lxa9uFb2ibjdp9+4y64e3bqdmx4/REOquVoKFDMYWGejpNNGRJTu42yXG9oKFGKqVdLmp37SJ4tF99wNOsD/64g7pqOwt+MQmz1eRZ4a43UiblaYmmlOLaByYYreMw3kiYzKeTYVutgxW/3MD538lgyOQkXC6No87Zro4ZWmvyDpWxPzOfg1/nU1flIDjcyrAZyQyZlERCWrhf10S3xlbrwGw1ERBk4eq7x0lPWNHrpY+Lx1brIKwHjCD7Qps/UZVS84E/YHSwGKCUGgM83I6FQoToMva8vEbJcO3u3Wib0bPWkpRE8OjRRH/3u8aKdMOHYQoMbLEGOeGuJT66i3NX9Ne/UvDcn0n/YCUBaWm+DucMZQXVhMcGYzIpJsxLw2w2SSLTgvrXxRpgZv4dYzzb7XVOBo6OIyLOqC8syqnkjcc3c9kPRzFgVBx1NQ6qy+oadcwoyavy1BWXF9ZisZoYMCaeIZOTSB0ajdncvdtDOZ0uVj67nfDYYObeMly+p4QAIuNDmHJlOgA1lTacdt1j5nV0hfbUIH8NXAisrZ+Yp5TapbUe2QXxtVtX1SDvPW9oi8+FX3op0dcvIHTKFK/H0Zu56uqo3W20WatPiB15eYB7RbrhwwkeM8aYTDdmNNakpBbP1VYXi+7GWVZG5dq1RFxxhd+NBBbmVPDvx7cw8/rBDJ/Re0eLO1tFcS17/3uSYdOTCYsO5MCWfFa/uJvL7xhNaV41e748QfFJ42dj32ExDJmUyIAx8QQE9awezdv/c4zw2CCpOxaiCa01b//+axx2F9f9bGK3fAPpr5P0NmqtpzTsXNGwo4W/8IcE2RwXR9wP/oeY730PZ3k5lV98Qdjs2ZjDw70eV0+ltcaee4KaHduNEeIdO6jdu9fTZs2aknI6GR47pkMr0vV0jsJCzNHRPp1YqLWmsqSO8JggtNZs/eQoQ6clS09aL7HVOtj735PsWX86KQ6JDKC6zMbCX08mOjGU3P0llBfVMGRKH79v09aW2io7tZV2ohK7b720EF3hxIFSXC5NajedBO2vk/R2K6UWAmalVAZwJ/Bf74bVPWV8sRbtMCbaVK5bz4n77kdZrYROm0b4JZcQfuEFmKOifBukn3NVV1O7ezfV7pHhmh07cBYY9d0qOJjgESOIvfl7RlI8ahSW+HgfR+yf7PmnOHL11UQvWkj8j3/sszi+eusgWZn5LPr1FAKDLYy/NM1nsfRULqeL43tLyMrM4/D2Ahw2F+GxQYz/Vn8GT0oiNCqQotxKohON3y373SvgnTe1DwDfrMvFXutk7Nx+vryNs/Kf5Xsozq1i0a+nYLZ27zIRIbwpOSPK83VuVgnx/cJ73KdIna09r84dwC8wln5+DWPhj994Myh/Zo6La7GLhTKbPaN1EZd9C2tKMhWfrKZi9Woqv/iCkxYLgz79D9bERLTL5ZXV1boTrTX2Y8c8ZRLV27dTtz8LnE4AAvr3J2zaNIJGjyZkzBgCBw9GWeQ/dHtYEuKJXriQiG99q8uvbat1oJSx9OmQSUlExgX3uFWdfE1rzamjFWRtyuPAlnxqKuwEhlgYMqUPQyYlkpQe2ajEJnlQlOfrCxadR1WZzfP8iawSqitsngT5i9f2ExoZyITL0rryls7KtKsHUVFSK8mxEO1UVVbHyj/uYPiMZGZc1+aab71amyUW3YU/90HWWlP7zW6qMzOJveX7AOTedz+OggIiLplL+MUX94qRUGdlFbW7dnrarNXs2IGztBQAU0jI6eWZ3SUTluju+VGQP3LZbJi6oPSkrsbBa7/exJDJiUy9epDXr9fblBXUkJWZR1ZmPqX51ZgtJtJGxTJ4UhL9R8RitpxdouhyujC5J+qtfvEbwqKDmHaN8e/3xmObGTgm3pMw221Ony4WUlNp49g3RQyZ0sdnMQjRnWXvKiR5UFS7Ot/4C7+qQVZKtbYUNP7WxcKfE+TmFL7wf5S98w62I0dAKYLHjyN6wYJuPUGsIe1yYTtyxFM3XLN9O3UHDoD7+y0gPd0zic6fF+HoCQr+9ByV69eRtmKF1+qza6vsnjZlWz7OJnVINEkDe0dPY2+rqbRxcIuxiEfe4XJQkDI4isGTkkgfG9+on3JnczpdrPvnfpIzohgypQ92m5MX717HtKsHMfqivmiXpiS/mujEkC6b+LPhnYPs+CyHRb+eIr1dhTgHLqfLM8HX3yfu+VuCXAAcxyir2AQ0evW01l94PboO6G4JMhgjy7aDByl3l2GEzZxBwr33ou12Sv75T8IuupiA1O4x299ZVkbNzl2nO0vs3ImrvBwAU0SEsRpd/WS60aMwR0T4OOLeo3z1aqo3biThpz/1yijy/k15fPHP/Vz/4CRP6zFxbhw2J0d2FpKVmc+xb4pwuTQxyaEMmZxExsREnyWGddV2dn6eQ99hMSQNiKQot5J//SaTi28eypApfaitslNwtIKk9EivldU4nS6Kc6uI7yeTn4U4F4e2nWLVX79h3o9HkTYyztfhtKq1BFkp1Rf4B5AIaOAFrfUzTfa5EqM82AU4gCVa6y9bvWYrCbIZmAPcAIwCPgRe01rv7shNdZXumCA3pe12lNVK9datHF24CICg4cMJv+QSIubO8Zu+ttrppO7goUadJWyHDhlPKkVgRkajNmsBAwb0+nprf9EZK7DVn8dhc2ENNFNZUsfWVdlMmj+QoDDvjWb2dC6XJjerhKxNeRzaVoC91kloVCCDJyYyeHKSZ1lqf1JbaefwjgL6DYslLDrQ8wv3mvvHkzQwkpK8Kk4eKmPQ+IRzmhBUXW5jw7uHmHFdhkwsEqITnTxYSp8GcxT8VRsJch+Mxey2KqXCga+Bq7TWexrsEwZUaa21UmoU8IbW+rxWr9meGmSlVCBGovx74Nda6z+1+666SE9IkBuyHT9OxerVlH+ymtqdOwFIe+N1gkeNQttsXdrKzFFS0qjncO3OXZ4V6MxRUUYyPGa0sQjHyJHdbhW63sKWk8vJn/6UpF8vJTA9/azPo7Vm5R93EBhs4ZIfjOjECHsfrTVFuZXs35TPgcw8qspsBASZSR+XwODJSSRnRHWrVmy2Wgf5h8tJzojCbDWxdfVRNrx9iFv+MIOgMCtHdxdxKruccXP7d2hiXfauQta8tIcr7hxD4gD59EmIzlaaX83R3UWMvrCvr0NpVkdKLJRS7wF/0lqvaeH5qcBLWuuW+/bSRhcLd2I8DyM5TgOeBd5pT4Di3AT07UvsLbcQe8st2E+coOKzzwkaPhyA/D/8gar//peIuXMJv+QSo7tDJy0KoR0O6rKyqN6+ndodO6jZvgPb0aPGk2YzQUOGEHnlFZ7JdNZ+/fxuQQrRPGW14CgqwnHq1FklyA67E4vVjFKK/sNjsQaaO21EurepKK7lwOZ89m/Ko/hEFSaTot+IWM6fnETayFgsPpwEdy4Cgiz0HRbjeTz24n4MHB3v+WTh5IFS9vz3pGfC3/b/HKO8qJaZC5qfTa9dGmVSpI2M48ZHpnrq3IUQneubL3LJ2pzH4EmJBIf5ZZ96i1JqS4PHL2itX2i6k1IqDRiLURrc9LmrgceBBIzctlWtlVj8AxgBfAT8S2v9TTtuwGd62ghya8pWrqT0329SvWULuFwE9O9P5DXXEHfrDzp8LkdhoWdkuGb7Dmq++QZdUwMYrevqR4ZDxowhaPhwTCHSkL87007nWU2GPHW0nA+f28mlt42kT7pMvjsbddV2Dm0tYP+mPE4cKAWgT3okgycnMWhcQq8pT6l/owXw1ZsHKMmv5vIfjwbgPy/vwRJoZvbCIVSW1PHhn3cw47rBjXq4CiE6n8vporK0johY/5xH0p4RZHcZxRfAo1rrt1vZbybwkNb64tbO19oI8neBKuAnwJ0NRokUoLXW8jmXj0TOn0/k/Pk4ioqo+M+nVHzyCbZjxiiv1pqiv75A6NQpBI0a1Wh0T9ts1O7b16izhD0313jSaiVo6FCirr3W01nCmpIso4M9TH1yXPb++7hqa4m+7rpW93c6XZjNJqKTQunjxYlXPZXT7uLo7iKyNuVxZFchLocmKjGEyVcMIGNiEpHx/vnLyJvqk2OA6ddmNHouJDIAi7v0QpnAZDb5/ex6IXoCk9nkSY53fp5DcLiVjAmJPo6q/ZRSVuAt4NXWkmMArfU6pdRApVSc1vrMhS3qzyl9kHuG+o+6bTm5HPrWt8Bux5KQQOB552EKC8N+4gR1e/agbTYALElJjXoOBw0biilIWib1Blprcv73h2i7nb5/e7HFN0GZKw9zfG8J3753nCQpHaBdmpOHytifmcehr09RV+0gOCKAjAkJDJmcRHy/cHnj2U5SwiNE13I5Xby3bDvB4QFc8oPhfvP/r41Jegr4O1CstV7Swj6DgEPuSXrjgJVAqm4lCZYEuYdw1dVRu3uPsSLd5s1Uf/01rrIyz/MBAwYQNns2gUOHEjJuXLdpHye8w1lZhSko8IyVCbVLgwKlFPs35ZF/pJxp307vtjWxXan4ZBVZm4xFPCqKa7EEmBg4Np4hk5JIPS/asxCHEEL4M1utA4vV5Fc/s9pIkM8H1gO7MNq4Afwc6Aegtf6LUuoB4CbADtQA9511m7fupjclyFpr7LknGrVZq927F+x2AKwpKZ6R4cAhg3Hk5RF+8cWYQkMpfOH/KF6+nPCLLiL8kksInTwJZe0dtY/iTK6qKkr+9S9iFi+mptLBR8/vZNQFqQyelOTr0LqFqrI6DmzOJyszn4JjFSgFfYfFMHhSEgNGx0lLMiFEt2WrcbD6pd1MuCyNpAG+nXvii4VC5Kd3N+CqrqZ2926q6yfT7diBs8Aom1FBQQSPGEHszd9zL8IxutVlq4NHjSR0yhTKP/yQ0n//G1NkJBGXXELSr5f6zUcpoutUfPYZ+U8+RfDYsQSNGUtwmPWslyvuLWy1Dg5vLyBrUx45+0rQGhL6h3P+dRlkTEgkJMIvZ4ALIUSH2G1Oyk7VUFlcBwN8HU3XkxFkP6O1xn7sWKPOErX794PTCYC1fz+jo4S7s0RgRsZZjQC76uqo+uorKj75BG23k/LUUwAU/PnPBA0eTOj550tNci9waNspNr+zn2t+OQ2rlFG0yOl0cXxPMVmZ+RzZXoDD7iIiLojBk5IYPCmR6KQuHdgQQogu4XS4PIMmLpf2WV92v1pqurvprgmys7KK2l07T7dZ27EDZ0kJAKaQEIJGj2o0mc4SHe21WFzV1Ry86GKcJSWokBDCZ88ifO4lhM2cIe3depj6yU8nDpSy6f3DzPn+MMw5B7HEx2FNkvIKMF6j/Oxysjblc2BLPrWVdoJCrQyakMDgSUkkDYyQT12EEL3CiQMlfPFaFpffPtonS91LgnwOukOCrF0ubNnZ1Gzb7mmzVnfgALj/DQLS0z3LMwePHkPgoPSz6ll7TjHa7VRlZlKxeg0Va9bgLC4m8ec/J+amG3HV1KCdTlkprxtzOV188VoWEXFBjL80DTASQV1Tw8ELLyJk6hRSn37at0H6WOmparIy88nalEdZQQ1mq4kBo+IYPDmJfsNipARFCNHrFByvYN1rWVzygxGERQd2+fUlQT4H/pggO8vLqdmx8/QyzTt34iovB8AUHu6pGQ4eM4bgUSMxR/rXAgza6aR6y9cEDkrHEhtL6dvvkPerXxF6/vmEXzKX8AsvxBwh7bC7m9UvfkNkQgiTrxjYaHvVpkwCB2d49VMKf1VTYePAllNkZRqdO1CQMjiaIZMTGTg2gcBgma4hhOjdfNl2URLkc9CVCXLZypWcenoZjpMnsfTpQ8JdS4i47DLqDh5q1FnCduiQcYBSBGZknE6Gx4wmYMAAlKl7jUTV7s+i7O23KP9kNY68PLBaCZ06hdRnn5V6ZT9WlFvJ+tezmPP94YRGBbb5Q067XNiOHDmr5ai7E7vNSfaOQvZn5nF8dzEulyY2NYwhk5LImJjok1ESIYQQZ5IE+Rx0VYJctnIlJx98CF1be3qjyQQWC7gX4TBHRRnJ8Fj3IhwjR/aosgTtclG7axflq1djO5JN3z8/B0DhX/6KOSqK8IsvwhIX5+MoRb2ygmref2Y7F988jD6Dotrc/9TTyyhZsYKBH33Y4+qRXS5N7v4SsjblcWhbAfY6J2HRgQyelMjgSUnEpvSc/6dCCNFTSIJ8DroqQT5w4UU4Tpw4Y7spJISkXz1E8JgxWPv163WTd7TWZF9zLbV79oDJRMj48YTPnUv43DlYE7vPcpU9xTfrcik7Ve1Zyrcjs4/tJ09S+cUXRC1Y0CO+j7XWFB6vZH9mHgc251NdZiMg2MKgcfEMnpxE8qAoWSlQCCH8mCTI56CrEuS9Q4d5JtU1ohRD9+7x+vX9mdaauqwDVKxeTcXqT6g7cJDY224j4a4laJsNR0EB1hRZwa8rfPXWQYpyKph3+2jM57AakrO8HFN491gaOWtTHhveO0RlcR1hMYGMvqgvTruL/ZvyKTlZhcms6D8iliGTk+g/MhaLVdraCSFEdyAJ8jnw9QiyJTmZjM8+9fr1u5O6w4cxhYRgTUqicv16jv/gVoJGjiTikrmEz51LQL9+vg6xx6ittPPVWwcYdUFf4vuF43S6MJnUOSW2tpwcjt6wkLgf/5jo6xd0YrSdL2tTHp+/ug+HzXXGc30GRTJ4UhKDxicQFCqrRgohRHfjiwS5e80S8wMJdy1BNZmQpoKCSLhriW8C8mOBAwd6algDBw8m4d57ADj1hyc5NPcSDl/9bez5p3wZYs+h4PjeEgqOVQBgNpvOedTXmpxM2MUXETx2bGdE2OmcThenjpaz8/OcFpPj0MgAvn3veEbMTJHkWAghRLt5dQRZKXUp8AxgBl7UWj/Rwn7XAG8CE7XWW9zbfgbcAjiBO7XWn7R2LV93sYicP79Lrt0T2HJyqVizhurMTFKf+xPKZKLoby/hqq4m/JK5xuqA3eAjfV87ebCUrM35zLx+MEopHDYnFi+uhqedzi7vy91QVVkd+YfLyTtcRt6RMgqOVuCwn5kUN/Xjv1zYBdEJIYTwlh5VYqGUMgNZwBwgB9gM3KC13tNkv3DgQyAAuF1rvUUpNQx4DZgEJAP/AQZrrZ0tXc8f+yCL9su9+27KP14FWhMwYADhl8wl4luXETRksK9D81u71uawdfVRrr1/AqFR3m1JVvDcc9R+s9vzhsbbnA4XhccryTtSRv7hMvIOl1NRbHSOMVkU8X3DSRoQSeLACJIGRvL2H76msrjujPOExQTyvcemez1eIYQQ3uOLBNmb3e8nAQe11ocBlFL/Aq4Ems5k+w3wW+C+BtuuBP6lta4DjiilDrrPt8GL8QofSnnqKRJ/9jMq/vMfylevpuiF/8NxqoDkxx5Fa03tnj0EDRvWq0eWXU4XOz/PISoxhLSRcQyfmcJ50/pg9eKocT1zZBSWuFhwOCAgoNPPX1VaZ4wMHy4j/0g5p45V4HSPDodFB5I4IJJRF6aSNDCSuL5hZ0ywm3pl+hllFpYAE1Ov7Nm9nIXwZy/d/yU15bYztgdHBPD9353vg4iEaD9vJsgpwPEGj3OAyQ13UEqNA/pqrT9USt3X5NiNTY49o/2BUupW4FaAAC/80hZdyxIfT/QNNxB9ww04ios9vabr9u0j+5prsST3IWLuJYTPnUvwmNHdbqGVc6WBPV+dJDkjirSRcZhMClMXJMcA0YsWdtqbE6fdRcHxCk8ynHe4jMoSY/TXbDER3y+cEbNSSBoQSdLACMKi216EZvBko9a9YReLqVeme7YLIbpec8lxa9uF8Cc+Wz9VKWUCngJuPttzaK1fAF4Ao8SicyIT/sASE+P52tq3L30ef5yKTz6h5NVXKV6+HEtCAn1f+CtB553nwyi9r7Kkju2fHmPqVemYLSa+fe84AkO6/r9tfXJsP3GCvN88QtLSpVgTE9p1bEVxrScRzjtcRsHxClwO479reEwQSemR7mQ4krjUMMzWs3vjM3hykiTEQvgB7dL0lA5Zovfy5m/aXKBvg8ep7m31woERwFr3L98k4H2l1BXtOFb0IuawMKKuvoqoq6/CWVFB5dq1VHz6madNXPE//0ldVhYRc+cSMmkSyuKz932drii3km/W5jJwTDzJg6J83onBVV1N7e7d2I4caTZBdtidFByrdI8OG7XDVaXu0WGriYT+4Yy+oK9ROzwg0uu100KIzqO1pq7aQVVpHUFhVkIjA6kormXrJ0epKq2jqsxGdZnx99xbhrd6rpOHyuiTHklFcS1lBTVEJ4UQEhHQq8vohH/x5iQ9C8YkvYswktvNwEKt9e4W9l8L3OuepDcc+CenJ+l9CmTIJD3RnFNPL6P4H/9A19Rgjooi7KILifjWZYSd3z0nZx3fW0xNhY3Bk4zR0KqyOkIj/SeRdNXVYQoMRGttjA4fLifPnQwXHq/A5TR+pkTEBZHoLpNIGhhJbEoYZkvvKosRoruw1To8SW5VaR1RiSEkpkVQXW5j1V93UVVWR1WpDafDqPOffu0gxlzcj9L8at783RZCIwMJjQokNDKA0MhABk1I4PVHNrd4vRsfmUpEXDA7P89h/etZAAQEW4hOCiE6MYSp3x5ESEQAtloHZqvpnBY8Et1fj5qkp7V2KKVuBz7BaPP2ktZ6t1LqYWCL1vr9Vo7drZR6A2NCnwP4cWvJsejdEu5aQtz/3kbll19S8clqKlZ9gqOw0JMgV2/eTNCoUZgC/SfJbM32/xyjpsJOxoRElEn5TXLssDk5dcxdO3y4HNuX/6G2FgrjRmOxmkhIi2DMxX1JHBBJ4oAIv4lbiN6uvLCGytI6qkrrqHYnwLGpYQyZnITT4eJv967HXtv4V+zoi/uSmBaBNciMyaJIGhjpSYJDIgNI6B8BQFRiCP/z5MwOxxQRFwzA4ImJRCeFUJJXTWleFcV51RzfW8yMACMh3vJRNjv+c5zIhGCik0KJSgohJimEjElJmGSJeOFFspKe6HFcNhvO4mKsSUnY8/M5OGs2ppAQwi64gPBL5hI2Ywam4GCyzp+Bs7DwjOPNcXEM/nJ9l8XrtBvdKYZO60NQmJXqchsBwWafLoWstaaiqNbdc7ic/MNlFB6vxOWqHx0OZNRXT2CJiSb+qT8RmxomIzxCdCHt0ih3gnh0dxHlBTXuEWBjFDgmOZTzr80A4KX71lNTYfcca7aYGDq9D7NuGALAhncOEhhiNUaA3aPAYdFBWAPP7WdQZ3SxyNlfwvE9xZTkVVGaX03ZqRqsQWZueXIGSinWv5FF8YkqohNDiEoKJbpPCDFJoVK+1cP0qD7IXU0SZNEcbbdTtXETFas/oeI/n+IsKUEFB5P6zDKO33pbi8cN3be3y2IsPlHFvx7JZOaCDEbMSu2y6zZktzkpOFpOnmchjnLPLzZLoJnE/uEkDjQm0iWmRRASEYCjqAhzeDhKOsiITuQoKMBRXEzQECN5K3z+ecJmzSJo2DAfR9Y1tEtTU2mnrtpOdJKRD+xen8upoxXuMgcjAY6MC+Ka+ycA8PqjmRQer3R/4hRASGQgqUOimHr1IAAOby/AEmDyjAAHhli6ba2v0+miqrSOiFhjBHrzh0c4+k0RJSersLlHwWNTQrn+QaNp1paPs1EKohON0efIhGB5M98NSYJ8DiRBFm3RDgfVW7ZQ/sknxP3vDzk4a1aL+3o7QS4vquFEVinnTe0DQEleleeXobdprSkvrCHvsDEynHeknMKcSrR7dDgyIZikgZEkDYggcWAkscmhmFr5heKqqaH8o4+JuubbXRK/6NkOz78CU2goaf96DfupUxyaM5eEe+8l5sbv4rLZqPn6a0ImTux2k3EbTnCrKq2jtsrumWfw9apsDm8vpLrMKIFwuTShUYHc/IRRJvbR8zvJO1Ju1PdGBRIaGUhMn1BGX2TMZS8rqMYaaCEozNpryw601lSX2yjJq8blcNFveCwAbzy2mYJjFZ79TCbFeVOTuODGoQAc/PoUYTGBRCeFEhjcvb6nepMeVYPcU0nj8+5LWSyETplC6JQpbe5bv6yy/dQpzFFRmDp5lHT7muPs33iStFFxBIVavZoc22odnDpa4ekqkX+kzPNxqzXQTEJaBOMu6WeMDg+IIDisY/da+uZb5D/2GEFDz+s1o3yi85SvWUPJP/9JvxdfRJnNJD30IOa4OACsCQkM/u9Xnn2rvvqKnB/+iL7/9wJhM2bgqqlBWSwoq2+7u9htTiqLaz0T3KrK6qgutTH120Z7xk0rD7Ptk2OeCW4AKEgfn4DZbEJrCAyxENMn5PRktwYlAt/635GtjvhGxod48/a6BaWM+RpN5z5c9/OJ2GodlOZXU5JXTUlelef1ctidfPLiN0aTeSAkIoDoPiEMnZbMkMlJaJemsrSOsOjAbjviLs6eJMgdJI3PewdlNmrvTv7s51RlZhKUkUHQ8GEEDRtG8OjRZ5UIZu8qJDLemGgyaf4Axs7t1+lt27TWlJ2q8XSVyD9SRlFOJfUfFEUlhtB/RKw7GY4kJjn0nEecohfeQPDIEZIci3bRWlO7YwcBgwZhDgsDl0bX1OIoLMSamEjIxImN9jeFnn7zGDplCil/fJbQycbH5yX/ep3Cv/yF9FUfY4mO9lrMlSW1nDxU5pngZtT51nHxzcMIiw5i1+c5bHjnUKNjLIFmxs7tR2hUIAn9whl5QSph7gluoVGBhEUFYnInXRO+lQbfavn6kpydm4AgCwn9IzwTC+uZzSYWLZ1CSV6VJ3kuyavGXmeUalQU17LilxuwBJqJTgwxOmwkhTBwTAIxyV06mCl8QEosOui5//2sxedueGiyUd8kray6hb3nDW3xufoSi4rPP6dm61Zqd++mdvcenGVlhEyZQv/lLwNw6plnsMTFETx8OIFDhmAKDm72fHXVdv7xiw0MGhfv+WivM9hqHeRnl3tareUfLqe2yhgdDggykzggwt1qzRgd9nYf5dr9+/+/vTsPj6q8Hjj+fWefTPY9ZCGEVZBFARVwq6LFFSu2oq2tVm1ttbbVqq3dtG51b221ajeX6k+rte6KVhEVF3ZB9jUJgezLZCaZ/f39cYebiRAIQlbO53l4yL1zZ+ZNbmZy5tzznhd7QQHW1NR9HywOSYF169h6ztfI/+1vyLjgArTWXzoAbFu6FN/7H5D7058AUHvvvUS9rRTcfNNe7xeNxmj3hnC4bThcNppr2lj38U5zgtuuMojTfziBISPS2bComrf/sQYwJrh50o1WZid9+zDS85Jo2OGjvtLX0eYs3YnDJfmngS7gC7NpWW2nANrXGOSrlx/OiMm57NzUzDuPr40HzkaNc0a+h+ziZOy9tMrpoWJvJRZKqWLgCSAP43rAo1rrP37hmG8CNwAKaAV+oLX+bK/PKQHy/tlbgAwwdHwWZ145EYBl88pJSnOQke8hIy8Jh9Q39Sv728VCa024agexNj+uUaPQkQibvnISkbo64wCLBefw4WR880Iy5s4lHIyweVEVY44bCkBtufeAegHrmKa5ts2YSBcPhht3dGSHM/KTjNrheDCcUXDg2eH9EW1pYdPJM0k9bRYFt9zSa88r+jetNTW33IotN4fsK64wauBff53kE07Emrz737sDKWOrufseQo3NuH5wA/6WINY3nyZj+mQiI4/gw+c2mhPc2ltDoOGUS8cyamo+OzY28eL9K8wJbruC3PEnFpFZ4CHgD+NvDg74CW7iwIWDUZQCm8NKbbmXZfPKjRZ1tW3mCqHnXjeZguFpVK5rZPPSWiMGyE8iPT+JlAyX2X1EdN8+AuQCoEBrvUwplQIsBc7RWq9JOGY6sFZr3aSUOg24SWt99N6eUyK2g2jmJWPNZYCjkRiLXtnaqebMk+5k0sxiJs0sIRbT7NjQREaBR1YP6iP728pNKYWjqLBj22ZjxPsLiFRXE1izhsDq1bSvXg3x8ozV8zaw8PVq2u69mbyR2bjGjSUwdizuceM6XTbuSrA9Qu1Wb6dyiWBbBDAa6ucPS6XsiGHGZLphqTiT+rYO05qWRsEdt5N05JF9Og7R92KBAIFVq4zJdEoRbW42u50opUg744wu77u3MraGKp+5YIW/OUheaSrFYzPxtwR5/vdLaGuZbLQivH0xlmiYEz57FqcthmvMkfibAuQ2fIY6fCpJuUPwpDvJKzWudOQPT+eKP5/Y5QdKl8fe56tYiv4hsfVd7tBUZn1vPACxaAxvQ4Dm6jayCo33d29dO5uW1RL0R8z72BwWvnXLNDxpTqq3tOBrCpIR767Rl609BzKt9U5gZ/zrVqXUWqAQYy2NXcd8lHCXTzBWaN4rySDvp71lkK98+KRO29FoDG9de6fapqHjshg5NQ9vfTtP/upjIGH1oAIPY2cMoWB4mtlv9lCdkTxQtdS1EWyLkDs0lWB1LZsff5WU8qUEVq8mUlMDwJC77ybtrDMJlZfT+r93cI0bi3PMYXjbbPHMsNFZonGn37hYpCCzwGN2lcgvSyMjL6lfZyG01kSqq7EXFPT1UEQfqLnzLpr+9S9GvL8AW0bGbmUUWmtC7RFiUY07xQic139aTXtriIXPb+r28xxxagnTzx1BNBzjvafWJfTxdZKU7iAtw4HTHsPi8dC+6nO2ff3rFNx+O+nnfo1YIIAOh7GmpBz071+IXbTWBHxhMw5orm1n+teGoyyKd59Yy9qPdgKgFKRku8ka4jEnZXrr23G4jO4khzqlVAhYlbDrUa31o3s4rhR4Hzhca+3t4rF+BozRWl+21+eUAHn/HKwuFuFQlOpNLTTV+Gna2RFAH3f+KEZMzmXHxmZe+uNy0nOTzMszGQVJFB+Wud9dBkTv0Frzf79bhN1p5bwbJu92VSBSX09gzRpcY8cSTUpj81NvsvU/7+FNHYY3pZSI3ZhZ7XRZyBueQf6wFPLL0skdljrg2g/V3HkXLa++QtnLL/fo5CnRPwS3bKXq17/FedlPCWUVE9hSTmh7FfZJkxl7rHHVZd5fP6ehykfAHybgj6BjmtIJ2ZzxwwkA/PP6D2nbx2TnE0/2GJPc4p0e7B4nttxcLA4HOhxGx2Ioux1l2b2MSUejtK9YgXPkSKypqbS88io7bryRsv++gHPEiIP/QxFiH8KhKM01bTQnJNEi4Zj5mnj5gRVUrmnElWw365zzhqUydsYQgAOq3x9outPmTSmVDCwAbtNav9DFMV8BHgKO1Vo37PXxJEDuX3b9wjdV+1m7cCdNNW007fTjrW9Ha5hz/WTyy9LYtqqeVe9VmasGGctveuSTZi/TWlO5tpGiMZlYLIqabV6Sv9CiScc0jTv91GyNL8KxpYWm6jbAyBqkpykyrc2ktmzBs3kR455+BFtGOnV/fpCWF17ANW5c/N9YXOPGYcvM7Ktvt9sCGzbgX/gRmRd/55B5Ax8MYjFNsC1MwGf8i4RjFB9m/L6t/qCKmq1eYxELf5hITTUet+aMW84k0tTE5189l7Wl59GY2TEJNW9YKufdYCxmMf+pdQR9YVzJdhwOjSPkwxNtZvhJY3EUFVK7YDENt93Mu2XXdDm+k967crd9pc8+g3viRJqff56dv/q1sdNqNQJlu53SZ5/FWTaM5v++SMNf/2ru19Eo0ZYWSp99BntODlXX/gz/okV4pk3D4nQaxzkc5Pz4aixuN/5PPiWw+nPz/rv+pZ51FspiIbhxI5G6OnM/djsWp9MMvqOtrehIBIvDYd4+2F8b/WW10oGqan0TtRWtNFf747FAG1lFyZzz0yMAo8dzLKaN4DnPuAqdU5xCet7ga/u3rwBZKWUHXgXmaa3v6+KYCcB/gdO01hv29ZwDKy11CNj1hpmR72H6nI6sRiQcpaW2nbQco0tCJBTD3xKkakMT0XBHnfO3b59OSqaLijUNxvKbBUb2WSYG9IwdG5t55YHPOPniwxhzTAF5pakE/GHKP2+geksLNVtbqNnqNVd4cnns5JWlMuqofPLKUskrTe1ytrtz9CjckybSvno1rW+/DYByuxm9ZDHKasW3YAFaa9zjxmHLyem177k7XKNG4Ro1CjDqUS0uVx+P6NATjcYI+iO4U4xArLbcS11Fq5HBjQfA4WCUWd83aijn/2sdaxbuMHvCAjg9Ni6793jA+F2vWt+EK9mBK8nCYfNvQw8dDZyJLSODrCf+w/Sojtfr2rC1tUDtdkLl5TiGDmXGCclUXXst4YpKok1N5nP4nTfjOP8bpA/NITx+DOwlz1H8178ameKEf/aSEgBchx9OzrXXoEOhjttDYaxpRp2xNSMd5+hRCbeFsHiSzAVHdCSCbmujfckSdDhMtLUVYjFyfnQVAL733qPxscd2G1Pq2WcD0PjEkzQ/91yn21RSEmOWLQWg+qab8b72WqfbbQUFjJxvlO3tuOHn+BcvSgi+HTiKiyl6wJiMX3vvvQS3bO0UnDtKSsi+wlgRtPHpp4k2NpmBvbLbsQ8pIOUko/TP9+FCdCjUcX+HHWtGBs5hwwAIV1V1+mBhPo71y9fF7ik43tt+0Vnh6AwKR3e+AhcJRc2vi8dm0rDdR+02L5uW1oKG0cfkM/PisWitefORz0nJcpnt6TLiSbTB9sFMGd/Q3zEm4XUVHJcALwAXdSc4BgmQBwyb3UpWYbK5PWJyLiMm56JjmtbGAI07jXXqk+OZy62f1fP5gqqO+zssZBZ4OO+GKSiLon67D4tFSVu6LyEcjNJU7Sd3aCr5w9OYdu5wQoEo7zy+huotXpprOrLDWUXJjDwqn/yyVPKHpZGW6+72m1PqKaeQesopAES9XgJr1hKpqzX/YNU9+BCBlSsBsOXk4Bo3Ds+MGWRe9K0e+K6/nODWrVR891Lyf/0r8w+1+HJC7RFaGwNGcOsP0x7/f8KJRTjcNtZ/spOV71WZAXCo3ZgYdPn9x+Nw29i0pJblb1cAxvuBy2PHlWwnGo1htVooPiyTpDQH7mRjv8tj71TONTV9A2N871D0+z+hlKJ18u0op8sMgAuHuqm65lp8lRU0ba9CBwIAZP3gCnJ//GOsKSlY3EmkzJyJvaQYR3EJjpJiHKWlADhKSym89x4c332RkGP3NoGOkJfk487p8ufjGjMG15gxXd6ecuKJpJx4Ype3F/3xD+bXWmu2zZ2Lc8QIc0Kta+xhDJ/3Jtb09E4B+q7Xc9bll5F2zuxOAToJV2jTvvY13BMndr6vq+NKk2vcWLBYOt1uTU83b480NRGuqur0+GYHHaD5+ecJrum8AmjStGPM1131zTcTrqzsdHvyySdT/OCfAdj6jfOJNnS+4px61lkU3n0XABuOOw4i0U4BeOpZZ5Lzwx+iYzEqvnNxp+Bb2fdeChiuqsKWkyNL1e8nW0L7uGnnDDe/3pVEs1iN38dQIIq3oZ2K1Q1EEpJoU88cxlFnDiMUiLD6/R1kFBjBc0qWe69znvr5ImkzgIuAVUqpFfF9NwIlAFrrh4HfAFnAQ/HXbERrPWVvDyolFoOU1pr21jDNNX4a4zXOoUCUk79tXP58+Y/LqVzbhLKo+OIVRouwI79qtCSLhmNY7RI4f1G7L8QbD6+irqKVnKGp1Fe0mk3lXcn2eJs1IxjOGZrSo71Qoz4/wXVrjR7Na9bQvno1zhEjKfrD/QBsPe/rWDMyzNIM97hx2AoKejV7EAsG2XH9DWR973Lc48b12vP2Z5FwlIAvQsAfIuALk12UgivZTl1lK+s+3tkpwxvwhzn9BxPIKkzm8wXbWfB/uyc+LrzpaDLyPWxcXMPaj3eaga87HuSOmVaA3WmlzRsiGonhSrZ3q0er1hrf/Pk4R4zAUVJC0zPPUP+Xh7EXFRHesYNIdTVoTdo55zDk93cYQeX5c7Hl5uAoLsFeXISjuATnqFHY83K7/fPpL5fltdboYBCLy0W4ppZNJ5xAzjXXkP29y9GRCJHaWuxDhvTaeLpDR6NGJnxXgA7mHIDgli3E2trR4Y4A25qWjvtw43XZ8tprxNrazOy6DodxDh9uBtg1d96FDgY63Z40bRoZX/86OhSi4tLLdsvuh7Zu3et4c37yE7Kv+D7h2lp2/uJGbDk52HJzjf9zcnBPmog9P78Hf2KD364kWlO81jlvWCr5ZWnUlnt57o4l5nFWm4X0PDfT54ygZGwWwbYw3voA6flJ2B3W/WpQ0BP6YqlpCZAPUQ1VPuq3+4zlN3f6aaxuIyXTyVk/mgTA0zd/Sqg9Yl6WychPIm/Y7isRDXQbPq3m45c242sMkpzpZNrs4Yw62nhDjkVjNOzwU7OlhYo1jTRU+fDWG1kxFOQUpyR0lkglNbv72eGeomMxVDwLtfM3vyWwejXBzZshagTxmZdcQt4N16MjEaODxuHjsBcW9tq4B9ukknAoisLI6gT8YSrXNJqZ3V0B7vgTCikYkU7VhiZefXAlkWC002OcceUESsdns/WzOt7+5xozsN2VxZ16xjDS85Jorm2jvtKHy2Mzyhw8dlzJtgNqDaVjMaItLWYQ1fDPx2hf+RnhikqCW7ei29pwjBzJ8FdeRmtN+UUXQTRmBr+OkmKcYw7DNXrUgfwYB4Tgli1YU1OxZWfj/+QTKi6+hOK//43kGTMG3e/1wbK3xZgKbr3FmFtx2GGEtm2j6vobiNTWEqmvh4hx9WPInb8nbfZs2pYvp/KKH2DPzYkHz7nYcnNJ+9rXcJYNI+rzEW1qwpaTI+Vc+yHgD9Nc02Zcga5uo6mmjcmnDSV/WBqbl9fy5iOfA5CS6aK1MdDl40iA3M9JgHzgEt/kl79dQUOVz2xNEw5EO9U2vfSHFaRkOjs6bOR7SM12YbEOnKzzhk+rmf/UOiKhjstPFpuieGwmkUCUmvLWTsFMWq6bsTOGkF+WSk5Jaqd+mP1ZLBAguH497atX4xo1iqQpUwhs2MDWs2cDYElLwzX2MNzjxpE2ezbOkSN7ZBz1Dz9MeGf1Plc5+zIOxuU/HdO0NnWUMOz6P6cklYLhafhbgvzvn2s6ZXgj4RjHzx3F+BOLqN/u49lbF5mP50yy4fTYmTFnBGWTcvDWt7Pyve3x0oWOIDirMBmXx95jQZYOhczL2N55b9G2aBGhygrCldsJb9+OfcgQhs97Ex0KsemUU4iFwrjHjsVWVIj2t5Fy+umknvSVgz6ugSxcU4v3lZfJuPBCLElJND3zLE3/fpah//hHp7KIQ113Viv9Ih2LEW1qIlJbiy0/H1tGBsEtW2j617+I1NURrq0lUldHpK6ekr8+iueYY/C+8QZVPzUmd1pSU7HFA+n8X/8aZ1kZwS1bCa5f1yk73dWqp8LQ5g2xY2OzeRV64+KaLo8drAGy1CALU+If5yNOKTG/1lrjbw4RixmB5K6Sgoo1jaz7uNo8bvJpQzlm9nBCgQjL36owapvyPOYlmr6ktSboj+BrDsYXGgiy8PmNnYJjgFhEU76ygZySZIZNzKZ0fBb5w9Ko2tDE0MOzSUodePVyFpcL98SJuCdONPc5S0spfe45szwjsHo1jY8/QdLUqThHjqRt8WLq/vRnI8Mz1ijRcJQO3WP7rO6KtbUbl3AjEXNi1MGyt8UlGnf4yRziQWvNole2EvCFO2V5R0zOYcrpwwiHojz5y493e4wjZw2lYHgaVpuFSChKcrqT7KJkM8DNL0sDICMviQt+c3Q882vb7cNiarabY8/r+sPHlw2OdyU5lFK0LVuO/5OPCVduN4Lgikqira2MXrYUpRS+BQtonTcPe0kJzpEj8Rx3rBkoKIcD54iRJE2dQvYVV3ypsRwq7Hm5ZF3W0ULVmpmBs7QUS5rxu9D4xJPEAgGyv3d5Xw2xX7BmZ3dZLtMVZbFgy8rClpVl7nOWlZH/m990Ok7HYmaNt2v8BApuu80InM0Aus78YOhbsIDaO+/sdH9LSgplL7+EvaAA34IF+BctwpaTgz0hiLaXlBzQe95AlpTqYMTkjtKovQXIg5VkkMUBCbZ1NEDPLkohpySFuspWnrt9ccf8FGVcojn+/FGUTsgm4AvTuNNPRkHSQenpHA5F8Td1BL67Vtkyt+MrbyWuargvx5xTxqJXt3Lhb48xO4cMdjoUAqVQdju+DxdS98ADBNetM/YDlqQkSp9/HmfZMEKVlehAAEdZWbdnuetYzHj8vQSC0UiMUCBCqD1KqD1CKBDBarOYQejn71fR2hgg3B4hGD8uq9DD0jfKu3zMkVNyOfWywwH42zXvoyyqUwa3dEI2Y2cMQWvN2o92dmR44/+cSfZ+s2BPaNs2/J8uIlxZQaiiklBlJeHKSoa//Ra2jAzqHvgT9Q89hC03t9NEuMxLL8XicBDb1cUgfg523HADre8tYOSC97C4XFIqcJBUXXc9MZ+P4r88BEDLK6/gGjOmx67OiL2L+vyEd1QRqa3rFETn/uxaLC4XdQ8+SMMjj5rvdbuMXvkZFoeD+kf/in/hwk410va8XFJPPx2gRz709zdSgzyASYDcv0TDMZpr2zqtIjhpZjG5Q1PZvKyWNx81apvMBugFHo48dShpOW6ikRgWi0JrTZs31Cng9TUHaWsOxjPBxv5ds/UT2Z3W+KpaDnNlrV3/J2c4SUpz8N97luFrCu523+RMJ+fdMIWtK+oYe1xhvwmO+oIOhwlu2ULgcyPTnHvD9VgcDmruuIPGx59Aud1G94B4ltl24izafUZgGwpEzXMzOl7XvXJ+JfWrykl+9wmqj/k2gZhxLs680shu/+euJVRv6bz4UWIv3WduXUTTDj8Otw2H24rdZaNwZDor52/v8nu44DdHkznEeF/VMd2v2x1GGhtpX7YsHvxWmJngogcewDV6NE3PPUf1r39jtPAqKjKC4KJisn9wBbbsbKI+H8pq7fLycfvnq6n5/R0U3ncf9txcAhs2EPP7cU+aJIHxQbYraIoFg2yYNp308+aQf+ONAATWr8c5apT8zPsRrTWxlhazjCPa1EzamcaS6A2PPUbrW2+bwbUOBrFmZjLqo4UAbP/R1fg/+sjMPNtyc3EMLyPnhz8EjL7wymbHlpuLNblXY7yDpq+7WEiAfAAkQB442ltDbF/XRG2Fl4YqYxEUf1OQ0kk5RIJR6ipb8e8hcAVj6e2kNEfHkrLpTjxpDpLTnSSlO41FOtKcOLqx8tyeapCVgpkXjzUn6g120bCRsXV57CiLMiZtxjue7MrghgJRjpldhlKKlfO3s3lZLUFvO8HWdsKBKLFolBMW/xrlSWLbxQ/vdinO5bbw3TunoxwO/vfYGlo/WcyIjx5g+ynXECs7nNQcN8d9w5jktWFxNQFfBIfbisNlw+G24U6xkzXEaHEYjcSwWHfPQvd1dqO7YoEAgTVrEzLARhlE9o+uInnGDHwffEDl5d8DjNpwR3Ex9uIicn74Q5wjRxL1eon5/dhyc7uduQ9t2wY2O46iQkLl5VRe8QOG3HE77kmTeu4bFZ1EGhrQkSj2vFyCmzax5cyzKLjtVtLnzEFHo2CxSLA8QGitibW2Em1uxhHvwd3yyiu0r1oVD6CNLLUtO5vSp58CjBZ6u1pyqqQk7Dk5JB1zjDkfo/nFF1FWa6cMtSU5WX4nEkiAfAAkQO4fwqEo/uYgbfFsr5n9be5cArGncgenx0Zyhsus9YyEYwTbwgT9RhbyolunkZLp4rN3K6na0ExmgTE5MD0+SXB/l2OuXNvIsnnlNNX48TeFcHpsTPxKEVPPLDsoP4uetCuw3VWOkJ6XhN1ppXGnn6r1TZ0yuKFAhBlzRpKU6mDNwh0sfbOccPx+u87Dd+8+FneKg09e2rxbuYLForjs/uOxO62s+F8FW1bUGRnceADrdFs5+uxhROvrafC7aPOGaH3yn4QWfYTF14gtEsBJgJRZs8yequ2rPsc5ehSWg9QDtb8EyDoaJVxZSSihBji0vZK0M84g9bTTzOAIAKWw5efjKC4m6/vfI3nGDKI+H6Gt23CUFGON17MeiFhbGxuOPY60M86g4JbfGWOUMoo+FW1tpfWtt0k+4Xhs2dm0vvMO1bfeRsk//m4u2iEGl7ZlywlXbTdKO2rriNTVYi8qJveanwKw8bjjO/W0BkiZNcts2bnz17/GkpTUKYB2lJZiLyjo9e+lr8gkPdFvxaIx2rzhhCD3C0FvvNwh2LZ7uYPNYcETz+7ml6V1lDskZIA9ac4u+y6HQ1G8de2kZhuXjaORGN56owF6LBqfpOGxc+m9xwGw9qOdhINRcxnupDQHSimqNjSx9I1tzPreeBxuG288sopwoKNLRdAfYdGr21j1/o4eu2QUi2mC/vBudbY5JakkZzhprmlj7Uc747d3BLnT54wgr9QoT3nrH6uJRTp/sJ1zw2Tyh6VRvaWF958xeuVaLMosRQi1R0hKdZCU4iCvNBVnQomCw2Uzf/bjjiukbFKOGfw6XFas9o7s1qSZJUyaWcKeWPLyMPPuk65Hx2KEKypoj08EtGUZE3N0LEbFJZcQCwSw5efjHDGclBNOIOmoo3AOH77Hx94Xd6qjy8t/B1vU5yNcUdGpDMI9cQLpc+YQa29n86zTzGOV04m9uIhY/MO7vaSE4kcexl5cgr2ocLcPCNbkZNzjDz+g8TU+8SSBtWsZcsftWJKSKLznHlyHd/SgluC4b1lTUkifc27Hdno6SUccgaOoCDAW/AisXUfeL34+6OtaDxVJRx4BRx7R5e1lb7xuBM67JhjW1mKP/z7oWIy2pcuIVFcTa2sz75PxrW+R/6tfokMhNp95Vkd5R04OttwcPMccg3v8eHQ0Ssznw5KaKq/9/SSvvkOc1ppgW2SPWV5fQia43RviixcblEUZwW26k/TcJApHZexe85vuxOGyHtAL0+7ovIrg5FmlTJ5VSiwaw1tvrCIYDkTM72fNh1Wd6lhtDgtlR+Rw2LQC2lrDbF1ZT15paqfgONGeAq1dtavRaIzGKn+n8oNQe8TsEe1vDvLRfzd1Cn5DgShHnz2MUVPzqS338p87l+72+KdeOo6RU/PwNQdZ8XZFpxpbp9uGjhk//PS8JCadXGwGtrtKEdJzkwBjhcXS8dk43Fastt0v25ZOyKZ0QtczyFMyXaRkHpw+ospiwVFaiqO0lLQzzui4IRaj4NZbaV+5kqann8ZfXY3/vQVkXfF9cn/yE2J+P9W33tbRQWPMaCxJSXt9roP5gUbHYkYdYmWlGQTbcnLIvPBCtNZsOvErxHw+83hrRobZ2suanMyQu+/CXlCAvbjYWCksYRa8xeEg+YQTDtpYwchaty1eTNLRR6OUIuozLv/qcBhlt5MiLdr6taTJk0maPNncDlVuJ7BunRkct7zyKra8XDxHHdVXQxQ9zJqcjDU5GWfZ7lcQlMXC8NeNJcqjPj+ROiMLbcvKBIzFmNzjxxOpqyO4fj3+Dz4g5vejfnYt7vHjCe/cyeaZp6Acjo42d7m5ZFwwF88xxxBtbaV95UozuLamp+/x73V/WcCnN0mJxSAWCUV3C3h3zwCHiIZ3L3dweex7nuQWzwQnpTlwpzj6fAJbNBojGo7hcNnw1rfzwt1LmT5nBENGZrBjUxOLX91G5hAPOcXJTDndePP5+88+IOAL7/Vxs4uTOzK4gQhHnFLCMbOH094a4h/Xfbjb8UfPLmPKaaW0NgZ48b5lnUoQHC4rh00voGhMJu2tITYtrcXhimdv47en5bhxJtk7tew6FIS2V2HNySZWXw82u1GjuXEj5d+5mGhjo3GQxYKjbBh5v/gFyTNmEAsEIBo1lwCG/X/zjoVChLdXmbXAgLlE99Y55xFYvTrhQayknHQSRX96AIDm/7yAxePBUVKMvbgYa0rKwfpxfCktr7zCjuuuZ+i/niRpyhQpoRgEdp1DrTWbTzkV94TxFN53HwDtn32G67DDZIlm0aVYWxtojcXjIdLURMtLL3Wqj47U1pJz9dWkzvoqbUuWUP6ti8z7KocDW3Y2+bf8juQZMwhu3UrrvLeo+8Mfuny+rnpaH0xSg3wADqUAORbTtHtDRleHpj2XOnRZ7mC3dC5v2FXi8IXg90BW5+pJgXh5QmqWm0goyj+u+5BJM4s56qwyYtEY859cx2EzChgyMmOP99daU7PNS3N1G+883vWLunR8VkKQa6VwdAYlY7OIRWNsW9UQr721YXcZGVxnkg2r7dDsl3kwxIJB/AsXmsvaaq2J1NQYPZrjHTSyr7oK9+Hj8L45j6qf/hTHsGFm94wv9jhNVHjfvUQam8j81jcBo7VZy8uvkHhJxFFayvA33wCMAFiHgtjjLdLsBQUou70Hv/v9E/V6qb7pJlJmziT19NOJtbfjW7CAlJNOkqBpEIoFAkRbvNjzcok0NLDxuOPJ/uEPybnqSmM57HD4oNXyi0NP1OcjuG5dp/Z34dpasi69FNfo0Z0WYemKBMj93GAIkM1yh676+cb/tXVR7pCU6uiyq8OubLDDbRtQ2aXm2jYCvrDZB/fxXyykYEQ6p15q1FQum1dOfllqlwHx3vSXiV0C6v/yF+oe+BNlr722x8uMiYKbN+N9800Ca9YSWL2aSHX1Xo8HwGplzIrlKLudlpdeIlS53Qh+i4qNCXFZWf36dRFtaSFUUYl7/OHoWIxtcy8g7ZzZZF54YV8PTfQiHQrhW7gQ54gROIqLaf/sMyq+eynFjzxM0pQpfT08MUjFAgHWT+q6hnqwBshSg/wlbPi0mo9f2oyvMUhyppNps4fvsy1YJBztMuD1t4TM/r6RPZQ7OD02o39vupPMwuR40Nu51Vl/KHc4GOoqWmmubWPklDwA3ntqPcG2MOf/0qi/O/YbI/GkO83jj/zq0D4Zpzi4Mi+5BNeECfsMjgGcw4eTc+WV5nakoYGNM7quQR720ks4iovMLHDa7NkHPuBeVnXtzwht3crwt99CWSyUPvtMvw7oRc9QDgcpX+moKbd4PKScNgvnKKNNovfNeXjnvUnBzTdjTU3tq2GKQcbiOjjzUgYaCZD30xd75/oag7z7r3W0NLSTXZi8W8C7q+53V6uyRFZ7R3eHvKEpeCZmJ5Q9dJQ/2Pp4meaeVL21hco1jUw9wwiM1ny4gw2LqhlxZC7Koph+7vBO3//wI3K7eqj91pudD8TeWVwukmfMACC4ZSv2wiFYnM593MuQuCTtnrhGjzrg8fU2/6eLqP/Tnyh+5GEsHg85P74aZbOZE/4kOBYAzhEjGHLrreZ2tLmJcHkFlmRjUrP3jTdAa3PFNyFE90mAvJ/++8RqkqOd/zhFwzEWvbzV3FYKs9whLcfNkJHpncocdgXAzqSBVe5wMNRs8/L5e9s5bu4oHC4bNVu8LH2jnMNPKMSd7GDyaUOZeuYwc7Wz3KE9lwXpjdV/xP4J19ay9bzzyLhgLnnXXdfXw+lVgfUbsGVmGJ0vHHaiXi/hnTtxjhiBe/z4vh6eGAAy5s4lY+5cc7vpmWc7BchtS5bgHDVKsstiv1mzs7ucCD1YSQ3yfvrzFe+g2D2o1Wi+/vOpJKc7cacOjnKHg6GhysdHL2xixpyRZA7xUP55A+88vobZPzmCrMJkQoEIVqulyx7I4tDT9Oy/ST7xROx53b9aMNBbEEXq6th4wolkff975P74x4dcNxPRM3QsRrSpCVtWFrFgkI3TppOasGhMtLW1z7uwCNEdUoM8AHiVJk3v/kfLqzR5pYfup/JYNIbFaqG1McAbD69iymmllB2Rg81hxdcUpN0XAjyUjM3kkruONf/wO1zyKyg6yzj/G4AxaTXa3IwtY98TMAdCEPxFdQ8+SMzrJe8Xv8CWk0Ph/feTdNRUQAJjcXAoi8UsQVJ2OyX//IdZfhHaXsXmWbMYcufvO/cpF0IA0KNpO6XULKXUeqXUJqXUz/dw+xVKqVVKqRVKqQ+VUmPj+0uVUu3x/SuUUg/35Dj3x/uuCGE6Z93DaN537V5jPFjFojECfqOPcCQc5YkbP2LZvArAKC1xJdvNjHBajpsLfnM0haOMIEdZlPzxF91Sc8cdlF/4TXMVuoFOh8P4P11kbkebW4g0NpnZ4tSvntqtDwNCfBnKYsE9caK5WqWy28m65BLcEycC4P/kE8q/czGh7VV9OUwh+o0eS98ppazAg8ApwHZgsVLqZa31moTDntZaPxw//mzgPmBW/LbNWutJPTW+L2ud01h97fiAjVSt8CojON61fzAKtkdo94ZIzzNWM3vqpk8pGJ7GzIvHYrNbKTsih6xC48qH1Wbh7Ksn9eFoxWCRcvJMbBkZKLe7r4dyUDQ+9RS1v7+Tstdfx1k2jLwbfyEfFkWfseflknttR3/bWFsbMZ8PW7aRcW59913C27eTceGFsuS1OCT15G/9UcAmrfUWAKXUM8BswAyQtdbehOM9wIAoiF7njA7qgNjb0I63rp2iMcZSlq89+BmxqOa8G4w+m0eeWtKp1dqxXx/ZJ+MUg5vn6KPwHG2099ORyID7Ix2uqaX65pvJvOhbeKZNI+2ss3CUDMVRUgxIGYXoX1JOOslcqAfAN38+bUuXkXGRscqa/9NF2AsLcRQV9tUQhehVPVliUQhUJmxvj+/rRCl1pVJqM3AXcHXCTcOUUsuVUguUUsft6QmUUt9TSi1RSi2JRHqnxCE7ec8twLraPxA0VftZ/UHHZbUlr2/jzUc/R8eMzytTzxzGtHOGm7ePO66Q0vGDd+aq6F+Cmzez5cyzaFu+vK+Hsk+RhgYC69cDYE1PI1RRTqS+ATDa0aWc9JUBF+iLQ1PBLbdQ+sz/mUte7/jFz6lJaCkX2cOkWCEGkx7rYqGUOg+YpbW+LL59EXC01vqqLo6/EPiq1vo7SiknkKy1blBKTQZeBMZ9IePcyWBYSa+3NOzwseHTGqaeUYrNYWXZW+V8/MJmvnvPsbiTHTRV+4lGNFmFHslyiT4XbWlh+1U/Ive6n+GeMKGvh7NXW849F2WzM+zfzwLGREN5DYnBIFRRQSwQwDVqFNHWVjZOn0HOj68m67LL+npo4hDQF10sejKDXAUUJ2wXxfd15RngHACtdVBr3RD/eimwGRh43f77ieaaNt55Yi3NtW0AtNS2s+J/FTRVG9uHTS/g4jtn4I5nwTPyPWQXJcsfdtEvWNPSGPrkE/0yOG59dz7ll1yCjl/Byv/FLxhyx+3m7fIaEoOFo6QE16iOP8M511yD51ijl3xgwwa2nHU27as+76vhCXHQ9WSAvBgYqZQappRyAHOBlxMPUEolFq+eAWyM78+JT/JDKVUGjAS29OBYBxV/c5DXHvyMitXGpV2tNVs/q8Nb3w7A0HFZXH7/8eSUGP0v3ckOPGndW7VMiL6itabhb3+j7qGH+nQM7atWEW1tje+IEfO3EamrAyBp6lSzS4AQg5U1JYWsSy7GNWYMALq9HWt6Ovb8PAD8H39M7R/+QNQnV3XFwNVjAbLWOgJcBcwD1gL/1lqvVkr9Lt6xAuAqpdRqpdQK4BrgO/H9xwMr4/ufB67QWjf21FgHqmjUWO46Eo7y/J1LWPE/o9Wa02OjtTFAKGBMJEzPS+LSe46jZKwxO9lqtwzq5avF4BXctJngxo3oWKxPnj+0aRPbvv4NWl58CYDkk05i2L+fxV5Q0CfjEaI/cE+cyNAnn8CWkwNA+2ef0fz8f7C4jMSLf9Ei/B9/bB4fbW1Fh0J9MlYx+CilipVS85VSa+Ix5Y/3cMwYpdTHSqmgUupn3XpcWUlvYIjFNAFfmKRUowziuTsWk1WUzEkXHQbAW39fzdBxmYw+Rv5Qi8FLh0Jgt/da6YLWmtrf/x5Laio5V14JQMtrr5F8/PGyApkQexELBLC4XABsO38uKEXpM/8HQPm3v4OORil96l8A7PjVr7CmppF3vbG8fNOz/8aakU7qqacCRgmHNTUVe35+H3wnoj/YWw2yUqoAKNBaL1NKpQBLgXMS2worpXKBoRilvE1a63v29Zyyvm8/FQpEqN/uM7df/uMK3nx0lblddkQOhSPTze1TLx0nwbEY9JTDgVKKSH091bff3iNZqFgwSNuSJcbzKUWksYloc4t5e9oZZ0hwLMQ+7AqOAYoffYQhd91pbmdcMJfMb33T3FZ2e6fuLo2PP473jTfM7e1XXkXtPfea21vO+Ro1d99tblffehstr71mbnvffpvgpk3mdszvZ7AkA8XutNY7tdbL4l+3YlQtFH7hmFqt9WIg3N3HlX5D/YS/JUhteSvDJhjt0z54ZgPlqxvMZZnHn1BILNbxAp88q7SPRipE32tfsYLmfz9H6mmnkXTEEQf1sev//CANjz3GyPnvYsvOZshdd8pkOyEOgDUtDWtamrmdetppnW4v+O1vO22XvfpKpw+/BTffhCXhQ6ln+vROEwb9H3+MNTUVMK76VP30GrIuuYTca69Bx2Ksn3oU2Vd8n5yrr0ZHIpR/52IyLriAtDPPQIdCNPzzMTzHzsA9bhw6EiG4eTP2IUPkg3D/YlNKLUnYflRr/egXD1JKlQJHAJ8e6BNKBrmPeOvb+ezdSqIRo5Zy7Uc7ef2hleYSzuO/UsTMi8eaS6cMPzKXkVPy+mq4QvQrKTNnMvyteQclOA5t20bFpZcRWLcOgPTzz6fkkYexZhoL5UhwLETvUhZLpwy0Z/p03OPHm9t5119H2uzZ5vbw114l5+ofmdtlL/6XjF0Z6miU3GuvNTtuxAJBI1sdf1lHW1qou/9+AitXAkZ/562zzzEz2OEdO9h4wol4337b2K6tZedvfkv76tXG/b1eWt95h0hDfFJ8NIoOdztJKbovorWekvBvT8FxMvAf4Cd7awvcXRIg9xJvQzufvLiZ1sYAALXlrXz47400VBllFGOOyecbN07F4TaS+rlDUykZl4WyyB9nIfbEnpsLgO/99wlu3rxf9w1XVxPcYjTGsaanE96+nUhNDQCOokI806ejLPL2KMRAo5TCOWIE9jwjoaTsdrIu/S5JRx4JgDXZw9DHHyPtjDMAsOXkMHrFctLOPde4PSWFwj/+Ec+0acYDWq14Zsww32+iTc20vvMO0XhAHNy0me1XXkVgjVHu2r58OevGT8D/ySfG9uerqbj0MrPkI1ReTuMTT5gBddTrJbRtmwTVB0gpZccIjp/SWr9wMB5T/gL0kDZviPlPrWPHpmYAwoEoy96qMOuKS8Zl8u3bp5M71LgslJzhIqckBYsExEJ0W6ytjR2//CX1Dz7Y7fvoWIxtF1xI7V1GDaM1PZ2yN98g+YQTemqYQoh+zOJyYXEaHTcsHg+pXz0VR7GxjIM9L48ht9+Ge+JEAFyjRzFq4YckH3+8sT1mNKXPP4970iQAbPn5ZP/oKhxDhwKggwGivlaIf+AOrF5Nze13EG1qAsD33ntsnnUaoe3bAfC+/jqbvzqLcPwDu3/RImruuIOoz4gdQhUV+BYuNANqHYkc8vXVyrjM93dgrdb6voP2uIPlB9vXXSwi4Shv/W01pROyGTtjCOFglCdu/Ijpc0Zw2PQCdEwTCcewO6W9mhAHU2D9BhwlxVjc7i6PaXn5Zbzz3qLoz39CKYVv4UIcQ4fiKCrqxZEKIQ51Ohol1tqKJTkZZbMR2r6d9qVLSTn1VCxuN/6PP6b5uefI/90tWJM9ND3zDLV338PI9xdg8Xiof+RR6u6/n9ErlmNxuah76CEa/vIwo5ctRdntNP/nBXzvzafwgQdQStG2eDGhigrS58wBjBISHY1hz8vt45/E/tlHF4tjgQ+AVcCuHqA3AiUAWuuHlVL5wBIgNX6MDxi7t1IMmaR3AF7982ek5yZx7DdGYrNbCbVHiIaNc2N3WvnuPcea9YvKoiQ4FqIHuEYbk3V0KET7ypUkTZliLOixdCnuCRNQDgexQICY10ustRVrairJM2b08aiFEIciZbViTU83tx1FRZ0+qHumTeso7wAy5s4lY+5cczv93K+RNGWyWaOddOSRcPllKLsdgJjfR6S+wYw9Wl57jdZ5b5kBct0f/0jre+8x6oMPAKi5626C69dT8ve/AdD8wn+JNjWRdel3Acxaa/e4cYAxCbK/zcvQWn+IWVXe5THVGCs6d5tkkA/Ah89vJCXDxcSTi/d9sBCiR9Xeey+Njz3O8LfmESqvoOLiiym8715STz+9X76pCyFET4sFAkS9XrOGum35ciLV1WYnkcYn/0WovJz8X/0SgKqfXUeoooJh/34WgIrLLifq9ZrbO278JUNuv63Xv4+9ZZB77DklQBZCDAbR5mbaliwhZeZMdCyG97XXSJk5c6+lF0IIITpLTCgEN20iFgjiPtzIILe+8w4pJ5/c62OSAPkA9FqAfPdI8NfuYQC5cN3Gnn9+IYQQQohDSF8EyNLFYn/tKTje234hhBBCCDGgSIAshBBCCCFEAgmQhRBCCCGESCABshBCCCGEEAkkQBZCCCGEECKBBMj7y9PF6jNd7RdCCCGEEAOKtHkTQgghhBD9Vl+0eZOlpvfTic+eSEOgYbf9Wa4s3jv/vd4fkBBCCCGEOKikxGI/7Sk43tt+IYQQQggxsEiALIQQQgghRAIJkIUQQgghhEggAbIQQgghhBAJJEAWQgghhBAigQTI+ynLlbVf+4UQQgghxMAifZCFEEIIIUS/1Rd9kCWDLIQQQgghRAIJkIUQQgghhEggAbIQQgghhBAJJEAWQgghhBAigQTIQgghhBBCJJAAWQghhBBCiAQSIAshhBBCCJFAAmQhhBBCCCESDJqFQpRSMaC9l5/WBkR6+TlFz5BzOXjIuRw85FwOHnIuB4++OJdurXWvJnUHTYDcF5RSS7TWU/p6HOLAybkcPORcDh5yLgcPOZeDx6FyLqXEQgghhBBCiAQSIAshhBBCCJFAAuQD82hfD0AcNHIuBw85l4OHnMvBQ87l4HFInEupQRZCCCGEECKBZJCFEEIIIYRIIAGyEEIIIYQQCSRA7gal1Cyl1Hql1Cal1M/3cLtTKfVs/PZPlVKlfTBM0Q3dOJfHK6WWKaUiSqnz+mKMonu6cS6vUUqtUUqtVEq9o5Qa2hfjFPvWjXN5hVJqlVJqhVLqQ6XU2L4Yp9i3fZ3LhOPmKKW0UmrQtwsbqLrxurxYKVUXf12uUEpd1hfj7CkSIO+DUsoKPAicBowFLtjDm/OlQJPWegRwP3Bn745SdEc3z2UFcDHwdO+OTuyPbp7L5cAUrfUE4Hngrt4dpeiObp7Lp7XW47XWkzDO4329O0rRHd08lyilUoAfA5/27ghFd3X3XALPaq0nxf/9rVcH2cMkQN63o4BNWustWusQ8Aww+wvHzAYej3/9PHCyUkr14hhF9+zzXGqtt2mtVwKxvhig6LbunMv5Wuu2+OYnQFEvj1F0T3fOpTdh0wPI7PL+qTt/LwFuwUgkBXpzcGK/dPdcDloSIO9bIVCZsL09vm+Px2itI0ALkNUroxP7ozvnUgwM+3suLwXe6NERiS+rW+dSKXWlUmozRgb56l4am9g/+zyXSqkjgWKt9Wu9OTCx37r7HjsnXsb2vFKquHeG1jskQBZCDGpKqW8BU4C7+3os4svTWj+otR4O3AD8qq/HI/afUsqCUR5zbV+PRRwUrwCl8TK2t+m4kj4oSIC8b1VA4qeiovi+PR6jlLIBaUBDr4xO7I/unEsxMHTrXCqlZgK/BM7WWgd7aWxi/+zv6/IZ4JyeHJD40vZ1LlOAw4H3lFLbgGOAl2WiXr+0z9el1roh4X31b8DkXhpbr5AAed8WAyOVUsOUUg5gLvDyF455GfhO/OvzgHe1rMDSH3XnXIqBYZ/nUil1BPAIRnBc2wdjFN3TnXM5MmHzDGBjL45PdN9ez6XWukVrna21LtVal2LMDThba72kb4Yr9qI7r8uChM2zgbW9OL4eZ+vrAfR3WuuIUuoqYB5gBf6htV6tlPodsERr/TLwd+BJpdQmoBHjF0n0M905l0qpqcB/gQzgLKXUzVrrcX04bLEH3Xxd3g0kA8/F58xWaK3P7rNBiz3q5rm8Kn41IAw00ZGQEP1IN8+lGAC6eS6vVkqdDUQwYp+L+2zAPUCWmhZCCCGEECKBlFgIIYQQQgiRQAJkIYQQQgghEkiALIQQQgghRAIJkIUQQgghhEggAbIQQgghhBAJJEAWQoheoJSKKqVWKKVWK6U+U0pdG19ZrK/G8xOlVFJfPb8QQvRn0uZNCCF6gVLKp7VOjn+dCzwNLNRa//YLx9m01pFeGM82YIrWur6nn0sIIQYaySALIUQvi6/s9z2MBTCUUupipdTLSql3gXeUUplKqReVUiuVUp8opSYAKKVuUko9qZT6WCm1USl1eXy/UkrdrZT6XCm1Sil1fnz/iUqpV3c9r1Lqz/HnuhoYAsxXSs3v9R+AEEL0c7KSnhBC9AGt9RallBXIje86EpigtW5USv0JWK61PkcpdRLwBDApftwE4BjAAyxXSr0GTIvfPhHIBhYrpd7fy3M/oJS6BviKZJCFEGJ3EiALIUT/8LbWujH+9bHAHACt9btKqSylVGr8tpe01u1Aezz7e1T8+P/TWkeBGqXUAmAq4O3db0EIIQYHKbEQQog+oJQqA6JAbXyXv5t3/eLEkb1NJInQ+X3e1c3nEEKIQ5oEyEII0cuUUjnAw8Cf9Z5nSn8AfDN+7IlAvdZ6VzZ4tlLKpZTKAk4EFsePP18pZY0/9vHAIqAcGKuUciql0oGTE56jFUg5yN+aEEIMClJiIYQQvcOtlFoB2DEyu08C93Vx7E3AP5RSK4E24DsJt60E5mPUGt+itd6hlPovRh3yZxgZ5eu11tUASql/A58DW4HlCY/zKPCmUmqH1vorB+U7FEKIQULavAkhxAChlLoJ8Gmt7+nrsQghxGAmJRZCCCGEEEIkkAyyEEIIIYQQCSSDLIQQQgghRAIJkIUQQgghhEggAbIQQgghhBAJJEAWQgghhBAigQTIQgghhBBCJPh/mA7FHIDK0eMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(10, 5), num=1, clear=True)\n", + "bx = ax.twinx()\n", + "col = 0\n", + "for block in np.unique(res.blocks):\n", + " select_block = res['blocks'].eq(block)\n", + " for kernel_size in np.unique(res['kernel_size'][select_block]):\n", + " select = res['blocks'].eq(block) & res['kernel_size'].eq(kernel_size)\n", + "\n", + " Series(index=res['dropout'][select], \n", + " data=res['Train Error'][select].values,\n", + " name=f\"Layers={block:.0f} (Train Error)\")\\\n", + " .plot(ax=ax, color=f\"C{col}\", style='-', marker='o')\n", + " Series(index=res['dropout'][select], \n", + " data=res['Test1 Error'][select].values,\n", + " name=f\"Layers={block:.0f} (Test1 Error)\")\\\n", + " .plot(ax=ax, color=f\"C{col}\", style='--', marker='s')\n", + " ax.plot([],[], color=f\"C{col}\", ls=':',\n", + " label=f\"Layers={block:.0f} (Test2 Error)\")\n", + " Series(index=res['dropout'][select], \n", + " data=res['Test2 Error'][select].values)\\\n", + " .plot(ax=bx, color=f\"C{col}\", style=':')\n", + " col = col + 1 \n", + "ax.set_title('Train and Test Error of TCN Models')\n", + "ax.set_ylabel('Mean Squared Error')\n", + "ax.set_xlabel('Dropout')\n", + "ax.legend(loc='upper center', fontsize=6)\n", + "plt.tight_layout()\n", + "plt.savefig(imgdir / 'tcn.jpg')" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/weekly_reversal.ipynb b/weekly_reversal.ipynb index 1447f30..9e6bb12 100644 --- a/weekly_reversal.ipynb +++ b/weekly_reversal.ipynb @@ -4,13 +4,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Weekly Reversals\n", + "# Backtest weekly stock price reversal trading strategy\n", "\n", - "- information coefficient, slippage, cross-sectional dispersion\n", - "- structural breaks, unknown changepoint\n", - "- rpy2, CRSP, Wharton Research Data Services\n", + "- Contrarian strategy (Lo and Mackinlay 1990, and others), statistical arbitrage\n", + "- implementation shortfall, structural change with unknown breakpoint\n", "\n", - "Terence Lim" + "Copyright 2023, Terence Lim\n", + "\n", + "MIT License" ] }, { @@ -19,106 +20,78 @@ "metadata": {}, "outputs": [], "source": [ - "import pandas as pd\n", - "from pandas import DataFrame, Series\n", "import numpy as np\n", + "import pandas as pd\n", + "from pandas import DataFrame, Series, to_datetime\n", + "from tqdm import tqdm\n", "import matplotlib.pyplot as plt\n", - "import os\n", - "import time\n", "from finds.database import SQL, Redis\n", - "from finds.structured import CRSP\n", - "from finds.busday import BusDay, Weekly\n", - "from settings import settings\n", - "sql = SQL(**settings['sql'])\n", - "user = SQL(**settings['user'])\n", - "rdb = Redis(**settings['redis'])\n", - "bd = BusDay(sql)\n", - "crsp = CRSP(sql, bd, rdb)\n", - "logdir = os.path.join(settings['images'], 'weekrev')" + "from finds.busday import BusDay, WeeklyDay\n", + "from finds.structured import CRSP, Benchmarks\n", + "from finds.recipes import fractiles, lm\n", + "from finds.display import row_formatted, show\n", + "from conf import credentials, VERBOSE, paths\n", + "\n", + "%matplotlib inline\n", + "VERBOSE = 0\n", + "SHOW = dict(ndigits=4, latex=None)\n", + "\n", + "endweek = 20220330\n", + "sql = SQL(**credentials['sql'], verbose=VERBOSE)\n", + "rdb = Redis(**credentials['redis'])\n", + "bd = BusDay(sql, verbose=VERBOSE)\n", + "crsp = CRSP(sql, bd, rdb=rdb, verbose=VERBOSE)\n", + "bench = Benchmarks(sql, bd)\n", + "imgdir = paths['images']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Custom weekly trading day calendar\n", - "- select Friday end" + "## Construct weekly reversal" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last FamaFrench Date 2022-11-30 00:00:00\n" + ] + } + ], "source": [ - "rebalbeg = 19730629 # increased stocks coverage in CRSP from around this date\n", - "rebalend = 20210101 # a Friday, so can include last week in 2020\n", - "wd = Weekly(sql, 'Fri', rebalbeg, rebalend) # Generate Friday-end weekly calendar" + "begweek = 19740102 # increased stocks coverage in CRSP in Jan 1973\n", + "middate = 19851231 # increased stocks traded in CRSP around this date\n", + "wd = WeeklyDay(sql, bd(endweek).strftime('%A')) # Generate weekly cal\n", + "rebaldates = wd.date_range(begweek, endweek)\n", + "retdates = wd.date_tuples(rebaldates)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Retrieve weekly returns, standardize scores, and compute returns and i.c." + "### Retrieve weekly returns, standardize scores, and compute returns and i.c." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [], - "source": [ - "june_universe = 0 # to track when reached a June end to update universe\n", - "year = 0 # to track new year to retrieve prices in batch for screening\n", - "res = DataFrame()\n", - "tic = time.time()\n", - "for rebaldate in wd.date_range(rebalbeg, rebalend)[:-1]:\n", - " d = bd.june_universe(rebaldate) \n", - " if d != june_universe:\n", - " june_universe = d # update universe every June-end\n", - " univ = crsp.get_universe(june_universe) # usual CRSP universe screen\n", - " univ = univ[univ['decile'] < 10] # drop smalest decile stocks\n", - " start = wd.begwk(rebaldate) # starting date of rebalance week\n", - " beg = bd.offset(rebaldate, 1) # beginning date of holding week\n", - " end = wd.endwk(beg) # ending date of holding week\n", - "\n", - " prcdate = bd.offset(start,-1) # require price available at start of week\n", - " prcyear = (prcdate // 10000) * 10000 \n", - " if prcyear != year: # retrieve new batch of prices each new year\n", - " year = prcyear \n", - " prc = crsp.get_range('daily', 'prc', 'date', year+101, year+1231,\n", - " use_cache=True)\n", - " X = prc[prc.index.get_level_values('date') == prcdate]\\\n", - " .reset_index()\\\n", - " .set_index('permno')\\\n", - " .join(crsp.get_ret(start,rebaldate).reindex(univ.index))\\\n", - " .dropna() # retrieve prior week's returns, require start price\n", - " Y = crsp.get_ret(beg, end).reindex(X.index).fillna(0) # gross return\n", - " Z = crsp.get_ret(bd.offset(beg, 1), end).reindex(X.index).fillna(0) # net ret\n", - "\n", - " z = Z['ret']\n", - " y = Y['ret']\n", - " x = (X['ret'].mean() - X['ret'])/(X['ret'].std(ddof=0)*len(X)) # standardize\n", - " res = res.append(DataFrame({'ret': x.dot(y),\n", - " 'ic': x.corr(y),\n", - " 'n': len(Y),\n", - " 'vol': y.std(ddof=0),\n", - " 'net': x.dot(z)}, index=[rebaldate]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Compute gross and net annualized sharpe ratios" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2516it [01:02, 40.26it/s]\n" + ] + }, { "data": { "text/html": [ @@ -140,68 +113,181 @@ " \n", " \n", " \n", - " Sharpe\n", - " Net Sharpe\n", - " Total Return\n", - " Net Return\n", - " Information Coefficient\n", - " Cross-sectional Vol\n", + " mean\n", + " std\n", + " \n", + " \n", + " Alpha, IC and Vol of Weekly Mean Reversion Strategy\n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " 19730706:20201224\n", - " 2.591748\n", - " 2.217857\n", - " 0.002525\n", - " 0.002161\n", - " 0.042005\n", - " 0.057823\n", + " ic\n", + " 0.0372\n", + " 0.1239\n", + " \n", + " \n", + " vol\n", + " 0.0443\n", + " 0.0174\n", + " \n", + " \n", + " ret\n", + " 0.0017\n", + " 0.0080\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Sharpe Net Sharpe Total Return Net Return \\\n", - "19730706:20201224 2.591748 2.217857 0.002525 0.002161 \n", - "\n", - " Information Coefficient Cross-sectional Vol \n", - "19730706:20201224 0.042005 0.057823 " + " mean std\n", + "Alpha, IC and Vol of Weekly Mean Reversion Stra... \n", + "ic 0.0372 0.1239\n", + "vol 0.0443 0.0174\n", + "ret 0.0017 0.0080" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "DataFrame({'Sharpe': np.sqrt(52)*res['ret'].mean()/res['ret'].std(),\n", - " 'Net Sharpe': np.sqrt(52)*res['net'].mean()/res['ret'].std(),\n", - " 'Total Return': res['ret'].mean(),\n", - " 'Net Return': res['net'].mean(),\n", - " 'Information Coefficient': res['ic'].mean(),\n", - " 'Cross-sectional Vol': res['vol'].mean()},\n", - " index=[min(res.index.astype(str)) + ':' + max(res.index.astype(str))])" + "june_universe = 0 # to track when reached a June end to update universe\n", + "year = 0 # to track new year to retrieve prices in batch\n", + "results = []\n", + "lagged_exposures = Series(dtype=float) # for \"turnover\" of stock weights\n", + "\n", + "for rebaldate, pastdates, nextdates in tqdm(zip(rebaldates[1:-1],\n", + " retdates[:-1],\n", + " retdates[1:])):\n", + " # screen by June universe\n", + " d = bd.june_universe(rebaldate)\n", + " if d != june_universe: # need next June's universe\n", + " june_universe = d # update universe every June\n", + " univ = crsp.get_universe(june_universe) # usual CRSP universe screen\n", + " univ = univ[univ['decile'] <= 5] # drop smallest half stocks\n", + "\n", + " # retrieve new batch of prices when start each year \n", + " if bd.begyr(rebaldate) != year:\n", + " year = bd.begyr(rebaldate)\n", + " prc = crsp.get_range(dataset='daily',\n", + " fields=['bidlo', 'askhi', 'prc', 'retx', 'ret'],\n", + " date_field='date',\n", + " beg=year,\n", + " end=bd.offset(bd.endyr(year), 10),\n", + " cache_mode=\"rw\")\n", + "\n", + " # get past week's returns, require price at start of week\n", + " past_week = prc[prc.index.get_level_values('date') == rebaldate]['prc']\\\n", + " .reset_index()\\\n", + " .set_index('permno')\\\n", + " .join(crsp.get_ret(*pastdates).reindex(univ.index))\\\n", + " .dropna()\n", + "\n", + " # convert past week's contrarian returns to standardized exposures\n", + " exposures = ((past_week['ret'].mean() - past_week['ret']) /\n", + " (past_week['ret'].std(ddof=0) * len(past_week)))\n", + "\n", + " # turnover is abs change in stock weight, scaled by total abs weight\n", + " delta = pd.concat([exposures, -lagged_exposures], axis=1)\\\n", + " .fillna(0)\\\n", + " .sum(axis=1)\\\n", + " .abs()\\\n", + " .sum()\\\n", + " / (exposures.abs().sum() + lagged_exposures.abs().sum())\n", + " lagged_exposures = exposures\n", + " \n", + " # get next week's returns\n", + " next_week = crsp.get_ret(*nextdates).reindex(past_week.index).fillna(0)\n", + "\n", + " # get next day's prices, to compute one-day delay cost\n", + " next_day = prc[prc.index.get_level_values('date')==bd.offset(rebaldate, 1)]\\\n", + " .reset_index()\\\n", + " .set_index('permno')\\\n", + " .drop(columns='date')\\\n", + " .reindex(past_week.index)\n", + " avgprc = next_day[['bidlo', 'askhi', 'prc']].abs().mean(axis=1)\n", + "\n", + " # if no trade next day, then enter at askhi (long) or bidlo (short)\n", + " bidask = next_day['askhi'].where(exposures > 0, next_day['bidlo']).abs()\n", + " avgprc = next_day['prc'].where(next_day['prc'] > 0, bidask)\n", + "\n", + " # drift to next's day price => delay cost is -drift * exposure\n", + " drift = (avgprc.div(next_day['prc'].abs())\\\n", + " .mul(1 + next_day['ret']) - 1).fillna(0.)\n", + "\n", + " # accumulate weekly computations\n", + " results.append(DataFrame({'ret': exposures.dot(next_week),\n", + " 'ic': exposures.corr(next_week),\n", + " 'n': len(next_week),\n", + " 'beg': nextdates[0],\n", + " 'end': nextdates[1],\n", + " 'absweight': np.sum(exposures.abs()),\n", + " 'turnover': delta,\n", + " 'vol': next_week.std(ddof=0),\n", + " 'delay': exposures.dot(-drift)},\n", + " index=[rebaldate]))\n", + "\n", + "# Combine accumulated weekly computations\n", + "df = pd.concat(results, axis=0)\n", + "dates = df.index\n", + "\n", + "# Plot returns, i.c. and cross-sectional vol over time\n", + "fig, ax = plt.subplots(num=1, clear=True, figsize=(10, 5))\n", + "df.index = pd.DatetimeIndex(df.index.astype(str))\n", + "df['ret'].cumsum().plot(ax=ax, ls='--', color='r', rot=0)\n", + "ax.legend(['cumulative returns'], loc='upper left')\n", + "ax.set_ylabel('cumulative returns')\n", + "\n", + "bx = ax.twinx()\n", + "df['ic'].rolling(250).mean().plot(ax=bx, ls=':', lw=1, rot=0, color='b')\n", + "df['vol'].rolling(250).mean().plot(ax=bx, ls=':', lw=1, rot=0, color='g')\n", + "#bx.axhline(df['ic'].mean(), linestyle='-', color='C0', lw=2)\n", + "bx.axhline(0, linestyle='-', color='black', lw=1)\n", + "bx.legend(['information coefficient', 'cross-sectional vol'], loc='lower right')\n", + "ax.set_title('Profitability of Weekly Mean Reversion')\n", + "plt.tight_layout(pad=2)\n", + "plt.savefig(imgdir / 'weekrev.jpg')\n", + "\n", + "show(pd.concat([df[['ic' ,'vol', 'ret']].mean(axis=0).rename('mean'),\n", + " df[['ic' ,'vol', 'ret']].std(axis=0).rename('std')],\n", + " axis=1),\n", + " caption=f'Alpha, IC and Vol of Weekly Mean Reversion Strategy', **SHOW)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Plot returns, i.c. and cross-sectional vol over time" + "## Structural Break Test with Unknown Date" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -211,45 +297,60 @@ } ], "source": [ - "fig, ax = plt.subplots(num=1, clear=True, figsize=(10,6))\n", - "res.index = pd.DatetimeIndex(res.index.astype(str))\n", - "res['ret'].cumsum().plot(ax=ax, ls='--', color='r', rot=0)\n", - "ax.legend(['cumulative returns'], loc='upper left')\n", - "ax.set_ylabel('cumulative returns')\n", - "bx = ax.twinx()\n", - "res['ic'].plot(ax=bx, ls=':', lw=1, rot=0)\n", - "res['vol'].plot(ax=bx, ls='-', lw=1, rot=0)\n", - "bx.axhline(res['ic'].mean(), linestyle='--', color='C0', lw=2)\n", - "bx.axhline(0, linestyle='-', color='black', lw=1)\n", - "bx.legend(['information coefficient', 'cross-sectional vol'], loc='lower right')\n", - "ax.set_title('Weekly Reversal Profitability')\n", - "plt.tight_layout(pad=2)\n", - "plt.savefig(os.path.join(logdir, 'weekrev.jpg'))" + "import rpy2.robjects as ro\n", + "from rpy2.robjects.packages import importr\n", + "from finds.pyR import PyR\n", + "importr('strucchange') # R package to use\n", + "\n", + "# Set up data and formulas for R\n", + "Y = df['ret']\n", + "#dates = to_datetime(df.index.astype(str))\n", + "formula = ro.Formula('y ~ 1')\n", + "formula.environment['y'] = PyR(Y.values).ro\n", + "\n", + "# Call R strucchange routines to compute breakpoint statistics\n", + "fstats_r = ro.r['Fstats'](formula, **{'from': 1}) # Fstats at every break\n", + "breakpoints_r = ro.r['breakpoints'](formula) # candidate breakpoints\n", + "confint_r = ro.r['confint'](breakpoints_r, breaks=1) # conf interval for 1 break\n", + "sctest_r = ro.r['sctest'](fstats_r, **{'type': 'aveF'})\n", + "\n", + "# Extract output from R results\n", + "confint = PyR(confint_r[0]).frame.iloc[0].astype(int) - 1 # R index starts at 1\n", + "output = dict(zip(confint.index, df.index[confint])) # confidence interval\n", + "for k,v in zip(sctest_r.slots['names'][:3], sctest_r[:3]): # significance values\n", + " output[k] = PyR(v).values[0]\n", + "output['mean(pre)'] = Y[df.index <= output['breakpoints']].mean() \n", + "output['mean(post)'] = Y[df.index > output['breakpoints']].mean()\n", + "fstat = [0] + list(PyR(fstats_r[0]).values) + [0, 0] # pad beyond from and to \n", + "\n", + "# Plot breakpoint F-stats\n", + "fig, ax = plt.subplots(num=2, clear=True, figsize=(10, 5))\n", + "ax.plot(df.index, fstat, color='C0')\n", + "arg = np.nanargmax(fstat)\n", + "ax.axvline(df.index[arg], color='C1')\n", + "ax.axvspan(df.index[confint[0]], df.index[confint[2]], alpha=0.3, color='grey')\n", + "ax.legend(['F-stat', 'Max-F', 'C.I. of Break Date'])\n", + "ax.annotate(df.index[arg].strftime('%Y-%m-%d'), xy=(df.index[arg], fstat[arg]))\n", + "ax.set_ylabel('F-statistic at Breakpoints')\n", + "ax.set_xlabel('Date of Breakpoints')\n", + "ax.set_title('Structural Change with Unknown Breakpoint: '\n", + " 'Weekly Mean Reversion Spread Returns')\n", + "plt.tight_layout(pad=3)\n", + "plt.savefig(imgdir / 'break.jpg')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Structural Break Test with Unknown Changepoint Date" + "## Compute delay slippage and performance measures" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PyR: ndarray (2478,) \n", - "PyR: ndarray (1, 3) \n", - "PyR: ndarray (1,) \n", - "PyR: ndarray (1,) \n", - "PyR: ndarray (1,) \n" - ] - }, { "data": { "text/html": [ @@ -271,115 +372,225 @@ " \n", " \n", " \n", - " 2.5 %\n", - " breakpoints\n", - " 97.5 %\n", - " statistic\n", - " p.value\n", - " method\n", - " mean(pre)\n", - " mean(post)\n", + " Period 0\n", + " Period 1\n", + " Period 2\n", + " Period 3\n", + " Period 4\n", + " \n", + " \n", + " Subperiod Performance of Weekly Mean Reversion Strategy\n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " changepoint\n", - " 2000-01-07\n", - " 2001-12-28\n", - " 2002-11-15\n", - " 41.48704\n", - " 0.0\n", - " aveF test\n", - " 0.003626\n", - " 0.000872\n", + " start date\n", + " 19740109\n", + " 20010808\n", + " 19740109\n", + " 19860108\n", + " 19740109\n", + " \n", + " \n", + " end date\n", + " 20220323\n", + " 20220323\n", + " 20010801\n", + " 20010801\n", + " 19851231\n", + " \n", + " \n", + " Sharpe Ratio\n", + " 1.5271\n", + " 0.5427\n", + " 2.7053\n", + " 2.0848\n", + " 4.5409\n", + " \n", + " \n", + " Average Return\n", + " 0.0017\n", + " 0.0007\n", + " 0.0024\n", + " 0.0022\n", + " 0.0027\n", + " \n", + " \n", + " Std Dev Return\n", + " 0.0080\n", + " 0.0096\n", + " 0.0065\n", + " 0.0077\n", + " 0.0042\n", + " \n", + " \n", + " Market Beta\n", + " 0.0877\n", + " 0.1134\n", + " 0.0655\n", + " 0.0771\n", + " 0.0496\n", + " \n", + " \n", + " Jensen Alpha (annualized)\n", + " 0.0810\n", + " 0.0272\n", + " 0.1211\n", + " 0.1095\n", + " 0.1357\n", + " \n", + " \n", + " Appraisal Ratio\n", + " 1.4494\n", + " 0.4086\n", + " 2.6697\n", + " 2.0120\n", + " 4.6081\n", + " \n", + " \n", + " Information Coefficient\n", + " 0.0372\n", + " 0.0119\n", + " 0.0562\n", + " 0.0492\n", + " 0.0652\n", + " \n", + " \n", + " Cross-sectional Vol\n", + " 0.0443\n", + " 0.0426\n", + " 0.0456\n", + " 0.0493\n", + " 0.0408\n", + " \n", + " \n", + " Delay cost\n", + " -0.0006\n", + " -0.0000\n", + " -0.0011\n", + " -0.0008\n", + " -0.0015\n", + " \n", + " \n", + " Turnover Fraction\n", + " 0.7336\n", + " 0.7294\n", + " 0.7367\n", + " 0.7362\n", + " 0.7373\n", + " \n", + " \n", + " Num Stocks\n", + " 936\n", + " 946\n", + " 928\n", + " 1004\n", + " 828\n", " \n", " \n", "\n", "" ], "text/plain": [ - " 2.5 % breakpoints 97.5 % statistic p.value method \\\n", - "changepoint 2000-01-07 2001-12-28 2002-11-15 41.48704 0.0 aveF test \n", + " Period 0 Period 1 \\\n", + "Subperiod Performance of Weekly Mean Reversion ... \n", + "start date 19740109 20010808 \n", + "end date 20220323 20220323 \n", + "Sharpe Ratio 1.5271 0.5427 \n", + "Average Return 0.0017 0.0007 \n", + "Std Dev Return 0.0080 0.0096 \n", + "Market Beta 0.0877 0.1134 \n", + "Jensen Alpha (annualized) 0.0810 0.0272 \n", + "Appraisal Ratio 1.4494 0.4086 \n", + "Information Coefficient 0.0372 0.0119 \n", + "Cross-sectional Vol 0.0443 0.0426 \n", + "Delay cost -0.0006 -0.0000 \n", + "Turnover Fraction 0.7336 0.7294 \n", + "Num Stocks 936 946 \n", + "\n", + " Period 2 Period 3 \\\n", + "Subperiod Performance of Weekly Mean Reversion ... \n", + "start date 19740109 19860108 \n", + "end date 20010801 20010801 \n", + "Sharpe Ratio 2.7053 2.0848 \n", + "Average Return 0.0024 0.0022 \n", + "Std Dev Return 0.0065 0.0077 \n", + "Market Beta 0.0655 0.0771 \n", + "Jensen Alpha (annualized) 0.1211 0.1095 \n", + "Appraisal Ratio 2.6697 2.0120 \n", + "Information Coefficient 0.0562 0.0492 \n", + "Cross-sectional Vol 0.0456 0.0493 \n", + "Delay cost -0.0011 -0.0008 \n", + "Turnover Fraction 0.7367 0.7362 \n", + "Num Stocks 928 1004 \n", "\n", - " mean(pre) mean(post) \n", - "changepoint 0.003626 0.000872 " + " Period 4 \n", + "Subperiod Performance of Weekly Mean Reversion ... \n", + "start date 19740109 \n", + "end date 19851231 \n", + "Sharpe Ratio 4.5409 \n", + "Average Return 0.0027 \n", + "Std Dev Return 0.0042 \n", + "Market Beta 0.0496 \n", + "Jensen Alpha (annualized) 0.1357 \n", + "Appraisal Ratio 4.6081 \n", + "Information Coefficient 0.0652 \n", + "Cross-sectional Vol 0.0408 \n", + "Delay cost -0.0015 \n", + "Turnover Fraction 0.7373 \n", + "Num Stocks 828 " ] }, - "execution_count": 7, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import rpy2.robjects as ro\n", - "from rpy2.robjects.packages import importr\n", - "from finds.pyR import PyR, savepng\n", - "importr('strucchange')\n", - "Y = res['ret']\n", - "X = pd.DatetimeIndex(res.index.astype(str)).to_numpy() # x-axis as datetime\n", - "formula = ro.Formula('y ~ 1')\n", - "formula.environment['y'] = PyR(Y.values).ro\n", - "breakpoints = ro.r['breakpoints'](formula) # candidate breakpoints\n", - "confint = ro.r['confint'](breakpoints, breaks=1) # conf interval for 1 break\n", - "fs = ro.r['Fstats'](formula, **{'from': 0.15}) # F-stats for all points\n", - "sc = ro.r['sctest'](fs, **{'type': 'aveF'}) # aveF-test for break point\n", - "out = PyR(confint[0]).frame.iloc[0].astype(int)-1 # adjust R's starting index\n", - "out.iloc[:] = X[out.iloc[:].astype(int)]\n", - "out = out.append(Series({k: PyR(v).values[0] for k,v in \n", - " zip(sc.slots['names'][:3], sc[:3])}))\n", - "out = out.append(Series({'mean(pre)': Y[X <= out.iloc[1]].mean(),\n", - " 'mean(post)': Y[X > out.iloc[1]].mean()}))\n", - "out.rename('changepoint').to_frame().T" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Plot F-statistics and breakpoint confidence intervals" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def fstats(x, tail=0.15):\n", - " \"\"\"Helper to compute F-stats at all candidate break points\"\"\"\n", - " n = len(x)\n", - " rse = np.array(np.var(x, ddof=0))\n", - " sse = np.ones(n) * rse\n", - " for i in range(int(n * tail), int((1-tail) * n)+1):\n", - " sse[i] = (np.var(x[:i], ddof=0)*i + np.var(x[i:], ddof=0)*(n-i))/n\n", - " return ((n-2)/2) * (rse - sse)/rse\n", - "sse = fstats(Y) # F-statistic at all break point dates\n", - "confint = out.iloc[:3] # confidence interval from aveF structurel change test\n", - "fig, ax = plt.subplots(num=2, clear=True, figsize=(10,6))\n", - "ax.plot(X, sse, color='C0')\n", - "argmax = np.nanargmax(sse)\n", - "ax.axvline(X[argmax], color='C1')\n", - "ax.axvspan(confint[0], confint[2], alpha=0.3, color='grey')\n", - "ax.legend(['F-stat', 'Max-F', 'C.I. of Break Date'])\n", - "ax.annotate(str(X[argmax])[:10], xy=(X[argmax], sse[argmax]))\n", - "ax.set_ylabel('F statistic')\n", - "ax.set_xlabel('Breakpoint Dates')\n", - "ax.set_title('Breakpoint F-Statistics for the Mean of Weekly Reversal Returns')\n", - "plt.tight_layout(pad=3)\n", - "plt.savefig(os.path.join(logdir, 'break.jpg'))" + "market = bench.get_series(permnos=['Mkt-RF'], field='ret').reset_index()\n", + "breakpoint = BusDay.to_date(output['breakpoints'])\n", + "out = dict()\n", + "for period, select in enumerate([dates > 0,\n", + " dates > breakpoint,\n", + " dates <= breakpoint,\n", + " (dates > middate) & (dates <= breakpoint),\n", + " dates <= middate]):\n", + " res = df[select].copy()\n", + " res.index = dates[select]\n", + "\n", + " # align market returns and compute market regression beta\n", + " #res['date'] = res.index\n", + " res['mkt'] = [(1 + market[market['date'].between(*dt)]['Mkt-RF']).prod() - 1\n", + " for dt in res[['beg','end']].itertuples(index=False)]\n", + " model = lm(res['mkt'], res['ret'], flatten=True)\n", + " \n", + " # save df summary\n", + " out[f\"Period {period}\"] = {\n", + " 'start date': min(res.index),\n", + " 'end date': max(res.index),\n", + " 'Sharpe Ratio': np.sqrt(52)*res['ret'].mean()/res['ret'].std(),\n", + " 'Average Return': res['ret'].mean(),\n", + " 'Std Dev Return': res['ret'].std(),\n", + " 'Market Beta': model.coefficients[1],\n", + " 'Jensen Alpha (annualized)': model.coefficients[0] * 52,\n", + " 'Appraisal Ratio': np.sqrt(52) * model.coefficients[0] / model.stderr,\n", + " 'Information Coefficient': res['ic'].mean(),\n", + " 'Cross-sectional Vol': res['vol'].mean(),\n", + " 'Delay cost': res['delay'].mean(),\n", + " 'Turnover Fraction': res['turnover'].mean(),\n", + " #'Abs Weight': res['absweight'].mean(),\n", + " 'Num Stocks': int(res['n'].mean()),\n", + " }\n", + "\n", + "# Display as formatted DataFrame\n", + "formats = dict.fromkeys(['start date' ,'end date', 'Num Stocks'], '{:.0f}')\n", + "show(row_formatted(DataFrame(out), formats=formats, default='{:.4f}'),\n", + " caption=\"Subperiod Performance of Weekly Mean Reversion Strategy\", **SHOW)" ] }, { @@ -391,8 +602,9 @@ } ], "metadata": { + "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -406,9 +618,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.10.9" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }