diff --git a/ml_dataset/README.md b/ml_dataset/README.md new file mode 100644 index 00000000..c5057e69 --- /dev/null +++ b/ml_dataset/README.md @@ -0,0 +1,108 @@ +# Enhanced Web Attack Detection for TANNER: A Machine Learning Approach (Google Summer of Code 2024) + +The dataset used in this project is derived from web traffic data collected by SNARE sensors over several years, with annotations based on regular expressions to identify various types of web-based attacks. + +This dataset includes *four* primary types of attacks: +- **SQL Injection (SQLi)**: Malicious SQL queries are injected into input fields to manipulate databases +- **Cross-Site Scripting (XSS)**: Attackers inject malicious scripts into web pages viewed by other users +- **Local File Inclusion (LFI)**: Exploits vulnerabilities to access files on the server +- **Remote File Inclusion (RFI)**: Allows attackers to include remote files on a web server +- **Index**: Normal, benign web requests + +To enhance the dataset's robustness and reduce noise and imbalance, supplementary data from external cybersecurity repositories were integrated. The dataset is constructed with 67 features extracted from URLs, followed by preprocessing steps such as label encoding, TF-IDF transformation on a character level, and meticulous cleaning to remove duplicates, address missing values, and eliminate outliers. Despite the imbalanced nature of the dataset, with a higher proportion of normal traffic, it serves as a robust foundation for developing a machine learning-based classifier intended to replace the existing regular expression-based detection in TANNER, aiming for improved accuracy and lower latency in real-time web attack detection. + + + +**Data Preprocessing** + +To prepare the dataset for modeling, I began by addressing any missing values—removing rows where essential data like path and payload were absent, and imputing values in less critical columns with averages or the most frequent entries. Duplicate records were eliminated to ensure the integrity of the dataset, and outliers were either transformed using log scaling or removed entirely if they were deemed erroneous. The target labels, representing different types of web traffic and attacks (SQLi, XSS, LFI, RFI, and normal traffic), were converted into numerical form through label encoding, making them ready for model consumption. + +A significant step in the preprocessing was the application of TF-IDF (Term Frequency-Inverse Document Frequency) at the character level to the path and payload columns. This technique helped capture intricate patterns within the URLs and payloads, which are crucial for accurate web attack detection. Normalization and standardization were applied as needed to ensure that the data was on a consistent scale, particularly for features with a wide range of values. These preprocessing steps were crucial in laying a solid foundation for training robust machine learning models. + + + +**Modeling Approach** + +I tested several machine learning models on my dataset to determine which one provided the best performance for web attack detection. The models I evaluated include Random Forest, XGBoost, a Multi-layer Neural Network (Dense), LightGBM, and a Decision Tree. Each model was tuned with specific parameters, and their performance was measured using accuracy, f1 score, log loss, and a confusion matrix. + +Among the models tested, the Random Forest model stood out as the best performer, achieving an accuracy of **94.48%**, f1 score of **94.18**, with a log loss of 0.1312. This model outperformed others in both accuracy and log loss, making it the optimal choice for further deployment. The confusion matrix for the Random Forest model also showed the best balance in correctly identifying different types of web traffic and attacks. + +Screenshot 2024-08-19 at 12 29 18 PM + + + +**Comparison with Baseline (RegEx)**\ +Screenshot 2024-08-19 at 6 03 34 PM + + + + + +- Number of Samples (**Entire Dataset**): 149,488 +- Number of Samples (**Train Data**): 104,641 +- Number of Samples (**Test Data**): 44,847 + + +Class Distribition Guide: + +- Label 0: Index +- Label 1: LFI +- Label 2: RFI +- Label 3: SQLi +- Label 4: Unknown +- Label 5: XSS + +**Entire Dataset** + +Class Distribution\ +Screenshot 2024-08-16 at 12 51 11 PM + +Statistics: +[full_data_statistics.csv](https://github.com/user-attachments/files/16646880/full_data_statistics.csv) + + +**Train Set** + +Class Distribution:\ +train data label dist + + +Statistics: +[train_data_statistics.csv](https://github.com/user-attachments/files/16646855/train_data_statistics.csv) + +**Test Set** + +Class Distribution:\ +test data label dist + +Statistics: +[test_data_statistics.csv](https://github.com/user-attachments/files/16646870/test_data_statistics.csv) + +**Future Work** + + +The Random Forest model’s significant improvement in detecting web-based attacks highlights its potential for enhancing the TANNER system. To integrate this model into TANNER, it could be deployed in many different ways. + +*Microservice*: The Random Forest model can be deployed as a microservice within TANNER's existing architecture. This approach would allow the ML model to analyze incoming web traffic in real-time, alongside or in place of the current regex-based detection. By using a microservice architecture, the model can be updated or replaced independently, ensuring that TANNER remains adaptable to new threats. + +*Real-Time Processing & Efficiency*: To ensure that the ML model can handle real-time traffic efficiently, optimizations such as model compression or the use of more lightweight models could be explored. Integrating the model with TANNER’s existing caching mechanisms could also reduce the computational load and improve response times. + +*Continuous Learning & Adaptation*: One of the strengths of ML models is their ability to learn from new data. Future work could focus on implementing a pipeline that allows the Random Forest model to be retrained periodically with new attack data, ensuring that it remains up-to-date with the latest threat patterns. Also, we could try out a hybrid approach combining both regex-based and ML-based detection could be explored to leverage the strengths of both methods. + +*Neural Network Approaches*: Transformer-based neural networks, known for their ability to capture complex patterns in sequential data, could be employed to further improve detection accuracy. These models, particularly those fine-tuned for cybersecurity, could be integrated into TANNER for more sophisticated threat analysis. + +*Ensemble Learning*: Combining the Random Forest model with other models, including neural networks, through ensemble learning could lead to even higher detection rates. By leveraging the strengths of multiple algorithms, TANNER could achieve a more robust and adaptable defense against evolving web threats. + +**External Datasets Used** + +- [XSS Payload List - Cross Site Scripting Vulnerability Payload List](https://www.kitploit.com/2018/05/xss-payload-list-cross-site-scripting.html) +- [Deep-XSS](https://github.com/das-lab/deep-xss/blob/master/xssed.csvl) +- [RFI Payloads](https://github.com/infosec-au/fuzzdb/blob/master/attack-payloads/rfi/rfi.txt) +- [XSS-attack-detection](https://github.com/shalayiding/XSS-attack-detection-using-deep-learning/blob/main/XSS_dataset_mixed.csv) +- [Cross site scripting XSS dataset for Deep learning](https://www.kaggle.com/datasets/syedsaqlainhussain/cross-site-scripting-xss-dataset-for-deep-learning) +- [XSS Payload List](https://github.com/payloadbox/xss-payload-list/blob/master/Intruder/xss-payload-list.txt) +- [LFI Payloads](https://raw.githubusercontent.com/emadshanab/LFI-Payload-List/master/LFI%20payloads.txt) +- [SQL Injection Dataset](https://www.kaggle.com/datasets/sajid576/sql-injection-dataset) +- [sql injection dataset](https://www.kaggle.com/datasets/syedsaqlainhussain/sql-injection-dataset) +- [SQL-Injection-Detection](https://github.com/saptajitbanerjee/SQL-Injection-Detection) +- [Malicious And Benign URLs](https://www.kaggle.com/datasets/siddharthkumar25/malicious-and-benign-urls) diff --git a/ml_dataset/model_training.ipynb b/ml_dataset/model_training.ipynb new file mode 100644 index 00000000..8194e934 --- /dev/null +++ b/ml_dataset/model_training.ipynb @@ -0,0 +1,943 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: pandas in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from -r requirements.txt (line 1)) (2.2.2)\n", + "Requirement already satisfied: numpy in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from -r requirements.txt (line 2)) (2.0.0)\n", + "Requirement already satisfied: scikit-learn in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from -r requirements.txt (line 3)) (1.5.1)\n", + "Requirement already satisfied: matplotlib in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from -r requirements.txt (line 4)) (3.9.2)\n", + "Requirement already satisfied: seaborn in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from -r requirements.txt (line 5)) (0.13.2)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from pandas->-r requirements.txt (line 1)) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from pandas->-r requirements.txt (line 1)) (2024.1)\n", + "Requirement already satisfied: tzdata>=2022.7 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from pandas->-r requirements.txt (line 1)) (2024.1)\n", + "Requirement already satisfied: scipy>=1.6.0 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from scikit-learn->-r requirements.txt (line 3)) (1.14.0)\n", + "Requirement already satisfied: joblib>=1.2.0 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from scikit-learn->-r requirements.txt (line 3)) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from scikit-learn->-r requirements.txt (line 3)) (3.5.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from matplotlib->-r requirements.txt (line 4)) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from matplotlib->-r requirements.txt (line 4)) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from matplotlib->-r requirements.txt (line 4)) (4.53.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from matplotlib->-r requirements.txt (line 4)) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from matplotlib->-r requirements.txt (line 4)) (24.1)\n", + "Requirement already satisfied: pillow>=8 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from matplotlib->-r requirements.txt (line 4)) (10.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from matplotlib->-r requirements.txt (line 4)) (3.1.2)\n", + "Requirement already satisfied: six>=1.5 in c:\\users\\richard\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.12_qbz5n2kfra8p0\\localcache\\local-packages\\python312\\site-packages (from python-dateutil>=2.8.2->pandas->-r requirements.txt (line 1)) (1.16.0)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "[notice] A new release of pip is available: 24.1.2 -> 24.2\n", + "[notice] To update, run: C:\\Users\\Richard\\AppData\\Local\\Microsoft\\WindowsApps\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\python.exe -m pip install --upgrade pip\n" + ] + } + ], + "source": [ + "import sys\n", + "!{sys.executable} -m pip install -r requirements.txt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
path & payloadlabelurl_lenurl_n_doturl_blacklisturl_entropyurl_suspicious_keywordurl_n_digiturl_n_specialurl_n_upper...L_IP_HostL_Hyphen_In_PathL_ForwardSlash_In_PathL_Equals_In_PathL_AtSign_In_URLL_Username_In_URLL_NonStdPortL_URL_BlacklistedWordAppearsL_Host_HasPortNumL_Host_NumOfTokens
0/%C0%AE%C0%AE/%C0%AE%C0%AE/%C0%AE%C0%AE/%C0%AE...Unknown81103.3649470102830...0070000001
1/setup.phpIndex11103.0271690020...0010000001
2/sitemap.xmlIndex13103.5465940020...0010000001
3/OpenVASTest768531477.htmlIndex27104.4306320925...0010000001
4/wp-admin/Index11003.2776130030...0120000001
\n", + "

5 rows × 67 columns

\n", + "
" + ], + "text/plain": [ + " path & payload label url_len \\\n", + "0 /%C0%AE%C0%AE/%C0%AE%C0%AE/%C0%AE%C0%AE/%C0%AE... Unknown 81 \n", + "1 /setup.php Index 11 \n", + "2 /sitemap.xml Index 13 \n", + "3 /OpenVASTest768531477.html Index 27 \n", + "4 /wp-admin/ Index 11 \n", + "\n", + " url_n_dot url_blacklist url_entropy url_suspicious_keyword url_n_digit \\\n", + "0 1 0 3.364947 0 10 \n", + "1 1 0 3.027169 0 0 \n", + "2 1 0 3.546594 0 0 \n", + "3 1 0 4.430632 0 9 \n", + "4 0 0 3.277613 0 0 \n", + "\n", + " url_n_special url_n_upper ... L_IP_Host L_Hyphen_In_Path \\\n", + "0 28 30 ... 0 0 \n", + "1 2 0 ... 0 0 \n", + "2 2 0 ... 0 0 \n", + "3 2 5 ... 0 0 \n", + "4 3 0 ... 0 1 \n", + "\n", + " L_ForwardSlash_In_Path L_Equals_In_Path L_AtSign_In_URL \\\n", + "0 7 0 0 \n", + "1 1 0 0 \n", + "2 1 0 0 \n", + "3 1 0 0 \n", + "4 2 0 0 \n", + "\n", + " L_Username_In_URL L_NonStdPort L_URL_BlacklistedWordAppears \\\n", + "0 0 0 0 \n", + "1 0 0 0 \n", + "2 0 0 0 \n", + "3 0 0 0 \n", + "4 0 0 0 \n", + "\n", + " L_Host_HasPortNum L_Host_NumOfTokens \n", + "0 0 1 \n", + "1 0 1 \n", + "2 0 1 \n", + "3 0 1 \n", + "4 0 1 \n", + "\n", + "[5 rows x 67 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import zipfile\n", + "import os\n", + "\n", + "# Extract the zip file\n", + "with zipfile.ZipFile('tanner_dataset.csv.zip', 'r') as zip_ref:\n", + " zip_ref.extractall()\n", + "\n", + "file_path = 'features_tanner_dataset.csv'\n", + "df = pd.read_csv(file_path)\n", + "\n", + "df.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(0)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Remove duplicates\n", + "df = df.drop_duplicates()\n", + "\n", + "df.duplicated().sum()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "path & payload 0\n", + "label 0\n", + "url_len 0\n", + "url_n_dot 0\n", + "url_blacklist 0\n", + " ..\n", + "L_Username_In_URL 0\n", + "L_NonStdPort 0\n", + "L_URL_BlacklistedWordAppears 0\n", + "L_Host_HasPortNum 0\n", + "L_Host_NumOfTokens 0\n", + "Length: 67, dtype: int64" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "missing_values = df.isnull().sum()\n", + "\n", + "#Drop rows with missing values\n", + "df = df.dropna()\n", + "\n", + "df.isnull().sum()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(33663, 67)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "#Remove outliers using IQR on numerical columns\n", + "def remove_outliers(df):\n", + " numeric_cols = df.select_dtypes(include=[np.number]).columns # Select only numerical columns\n", + " Q1 = df[numeric_cols].quantile(0.25)\n", + " Q3 = df[numeric_cols].quantile(0.75)\n", + " IQR = Q3 - Q1\n", + " df_out = df[~((df[numeric_cols] < (Q1 - 1.5 * IQR)) | (df[numeric_cols] > (Q3 + 1.5 * IQR))).any(axis=1)]\n", + " return df_out\n", + "\n", + "# Apply the function to the dataframe\n", + "df_cleaned = remove_outliers(df)\n", + "\n", + "# Check the shape of dataframe \n", + "df_cleaned.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
labelurl_lenurl_n_doturl_blacklisturl_entropyurl_suspicious_keywordurl_n_digiturl_n_specialurl_n_upperurl_prop_digit...¸¹º»¼½¾¿âã
0481103.36494701028300.123457...0.00.00.00.00.00.00.00.00.00.0
1011103.02716900200.000000...0.00.00.00.00.00.00.00.00.00.0
2013103.54659400200.000000...0.00.00.00.00.00.00.00.00.00.0
3027104.43063209250.333333...0.00.00.00.00.00.00.00.00.00.0
4011003.27761300300.000000...0.00.00.00.00.00.00.00.00.00.0
\n", + "

5 rows × 205 columns

\n", + "
" + ], + "text/plain": [ + " label url_len url_n_dot url_blacklist url_entropy \\\n", + "0 4 81 1 0 3.364947 \n", + "1 0 11 1 0 3.027169 \n", + "2 0 13 1 0 3.546594 \n", + "3 0 27 1 0 4.430632 \n", + "4 0 11 0 0 3.277613 \n", + "\n", + " url_suspicious_keyword url_n_digit url_n_special url_n_upper \\\n", + "0 0 10 28 30 \n", + "1 0 0 2 0 \n", + "2 0 0 2 0 \n", + "3 0 9 2 5 \n", + "4 0 0 3 0 \n", + "\n", + " url_prop_digit ... ¸ ¹ º » ¼ ½ ¾ ¿ â ã \n", + "0 0.123457 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "1 0.000000 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "2 0.000000 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "3 0.333333 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "4 0.000000 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "\n", + "[5 rows x 205 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "\n", + "# Label Encoding for the 'label' column\n", + "label_encoder = LabelEncoder()\n", + "df['label'] = label_encoder.fit_transform(df['label'])\n", + "\n", + "# TFIDF for the 'path & payload' column\n", + "tfidf_vectorizer = TfidfVectorizer(analyzer='char', max_features=1000)\n", + "tfidf_matrix = tfidf_vectorizer.fit_transform(df['path & payload'])\n", + "\n", + "# Convert the TFIDF matrix to a DataFrame and join with the original DataFrame\n", + "tfidf_df = pd.DataFrame(tfidf_matrix.toarray(), columns=tfidf_vectorizer.get_feature_names_out())\n", + "df = df.drop(['path & payload'], axis=1).join(tfidf_df)\n", + "\n", + "df.head()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9424264722277967\n", + "Precision: 0.9440585016729094\n", + "Recall: 0.9424264722277967\n", + "F1 Score: 0.9422107803269438\n", + "Confusion Matrix:\n", + "[[13830 3 2 651 22 12]\n", + " [ 12 8049 0 1 1 0]\n", + " [ 1 0 673 0 0 0]\n", + " [ 1779 1 0 10793 1 0]\n", + " [ 38 7 1 0 190 8]\n", + " [ 42 0 0 0 0 8730]]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.metrics import accuracy_score, f1_score, recall_score, confusion_matrix, precision_score\n", + "\n", + "# Split the data into features and labels\n", + "X = df.drop('label', axis=1)\n", + "y = df['label']\n", + "\n", + "# Split the data into training and testing sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n", + "\n", + "# Initialize and train the Random Forest Classifier\n", + "rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)\n", + "rf_classifier.fit(X_train, y_train)\n", + "\n", + "# Make predictions\n", + "y_pred = rf_classifier.predict(X_test)\n", + "\n", + "# Calculate accuracy\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "\n", + "# Calculate precision\n", + "precision = precision_score(y_test, y_pred, average='weighted')\n", + "\n", + "# Calculate F1 score\n", + "f1 = f1_score(y_test, y_pred, average='weighted')\n", + "\n", + "# Calculate recall\n", + "recall = recall_score(y_test, y_pred, average='weighted')\n", + "\n", + "# Generate confusion matrix\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "\n", + "# Print metrics\n", + "print(f\"Accuracy: {accuracy}\")\n", + "print(f\"Precision: {precision}\")\n", + "print(f\"Recall: {recall}\")\n", + "print(f\"F1 Score: {f1}\")\n", + "print(f\"Confusion Matrix:\\n{conf_matrix}\")\n", + "\n", + "plt.figure(figsize=(10, 7))\n", + "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues')\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Class Distribution:\n", + "label\n", + "0 48193\n", + "3 41793\n", + "5 29253\n", + "1 27171\n", + "2 2281\n", + "4 797\n", + "Name: count, dtype: int64\n", + "\n", + "Class Percentage:\n", + "label\n", + "0 32.238708\n", + "3 27.957428\n", + "5 19.568795\n", + "1 18.176041\n", + "2 1.525875\n", + "4 0.533153\n", + "Name: proportion, dtype: float64\n" + ] + } + ], + "source": [ + "class_distribution = df['label'].value_counts()\n", + "print(\"Class Distribution:\")\n", + "print(class_distribution)\n", + "\n", + "class_percentage = df['label'].value_counts(normalize=True) * 100\n", + "print(\"\\nClass Percentage:\")\n", + "print(class_percentage)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary Statistics by Class:\n", + " url_len url_n_dot \\\n", + " mean std min max median mean std min \n", + "label \n", + "0 364.787687 1399.339509 1 45578 91.0 5.510116 32.099716 0 \n", + "1 83.912149 100.558410 1 1076 64.0 7.329395 39.187473 0 \n", + "2 51.976326 19.938686 10 127 48.0 1.293292 0.679521 0 \n", + "3 78.096763 82.078042 1 5436 54.0 0.229369 0.754917 0 \n", + "4 53.417817 122.561521 5 1896 21.0 1.900878 2.534974 0 \n", + "5 115.668068 175.149325 5 11312 95.0 2.016785 4.859438 0 \n", + "\n", + " ... â ã \\\n", + " max median ... mean std min max median mean \n", + "label ... \n", + "0 1209 1.0 ... 0.005955 0.046618 0.0 0.595791 0.0 0.005191 \n", + "1 525 1.0 ... 0.000039 0.004571 0.0 0.541012 0.0 0.000039 \n", + "2 8 1.0 ... 0.000000 0.000000 0.0 0.000000 0.0 0.000000 \n", + "3 14 0.0 ... 0.000319 0.012479 0.0 0.568396 0.0 0.000319 \n", + "4 38 1.0 ... 0.000000 0.000000 0.0 0.000000 0.0 0.000000 \n", + "5 352 0.0 ... 0.000239 0.011456 0.0 0.641198 0.0 0.000198 \n", + "\n", + " \n", + " std min max median \n", + "label \n", + "0 0.042891 0.0 0.595791 0.0 \n", + "1 0.004571 0.0 0.541012 0.0 \n", + "2 0.000000 0.0 0.000000 0.0 \n", + "3 0.012479 0.0 0.568396 0.0 \n", + "4 0.000000 0.0 0.000000 0.0 \n", + "5 0.009641 0.0 0.562872 0.0 \n", + "\n", + "[6 rows x 1020 columns]\n" + ] + } + ], + "source": [ + "summary_statistics = df.groupby('label').agg(['mean', 'std', 'min', 'max', 'median'])\n", + "print(\"Summary Statistics by Class:\")\n", + "print(summary_statistics)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlation Matrix:\n", + " label url_len url_n_dot url_blacklist url_entropy \\\n", + "label 1.000000 -0.111027 -0.080967 0.005741 0.207325 \n", + "url_len -0.111027 1.000000 0.671643 -0.000239 0.123435 \n", + "url_n_dot -0.080967 0.671643 1.000000 0.000059 -0.043172 \n", + "url_blacklist 0.005741 -0.000239 0.000059 1.000000 0.003443 \n", + "url_entropy 0.207325 0.123435 -0.043172 0.003443 1.000000 \n", + "... ... ... ... ... ... \n", + "½ -0.011950 0.057619 0.016285 -0.000048 0.008961 \n", + "¾ 0.000822 0.058792 0.013943 -0.000038 0.005751 \n", + "¿ -0.002823 0.002722 0.002010 -0.000009 0.005890 \n", + "â -0.070882 0.082927 0.023056 -0.000270 0.072042 \n", + "ã -0.066930 0.089939 0.025364 -0.000257 0.063251 \n", + "\n", + " url_suspicious_keyword url_n_digit url_n_special \\\n", + "label -0.169878 -0.063059 -0.049982 \n", + "url_len 0.127030 0.359682 0.905367 \n", + "url_n_dot 0.069168 0.202218 0.730959 \n", + "url_blacklist -0.000889 -0.000963 0.000097 \n", + "url_entropy 0.227291 0.058113 0.070926 \n", + "... ... ... ... \n", + "½ 0.004867 0.017636 0.071016 \n", + "¾ 0.004491 0.019514 0.075086 \n", + "¿ -0.000628 0.011703 0.002680 \n", + "â -0.005897 0.010986 0.067284 \n", + "ã -0.004017 0.009655 0.072574 \n", + "\n", + " url_n_upper url_prop_digit ... ¸ ¹ º \\\n", + "label -0.017605 -0.200888 ... -0.019510 -0.016949 -0.004508 \n", + "url_len 0.254885 -0.084253 ... 0.062737 0.019405 0.002793 \n", + "url_n_dot 0.062076 -0.063295 ... 0.020028 0.005620 0.001301 \n", + "url_blacklist -0.000289 -0.002133 ... -0.000066 -0.000057 -0.000015 \n", + "url_entropy -0.036886 -0.422108 ... 0.017279 0.015298 0.007286 \n", + "... ... ... ... ... ... ... \n", + "½ 0.186747 -0.006269 ... 0.486012 0.042506 -0.000054 \n", + "¾ 0.196088 -0.006525 ... 0.084668 0.043697 -0.000043 \n", + "¿ 0.006125 0.000093 ... 0.106160 0.024096 0.277143 \n", + "â 0.190397 -0.029372 ... 0.267984 0.272483 0.032178 \n", + "ã 0.204064 -0.031534 ... 0.287794 0.294951 0.027159 \n", + "\n", + " » ¼ ½ ¾ ¿ â \\\n", + "label -0.020325 -0.013054 -0.011950 0.000822 -0.002823 -0.070882 \n", + "url_len 0.055991 0.023359 0.057619 0.058792 0.002722 0.082927 \n", + "url_n_dot 0.017425 0.005685 0.016285 0.013943 0.002010 0.023056 \n", + "url_blacklist -0.000068 -0.000071 -0.000048 -0.000038 -0.000009 -0.000270 \n", + "url_entropy 0.013645 0.015968 0.008961 0.005751 0.005890 0.072042 \n", + "... ... ... ... ... ... ... \n", + "½ 0.179985 0.050674 1.000000 0.095485 -0.000034 0.224068 \n", + "¾ 0.138048 0.406146 0.095485 1.000000 -0.000027 0.188681 \n", + "¿ 0.051222 -0.000050 -0.000034 -0.000027 1.000000 0.051551 \n", + "â 0.356370 0.254971 0.224068 0.188681 0.051551 1.000000 \n", + "ã 0.385185 0.275225 0.243104 0.204703 0.027872 0.976115 \n", + "\n", + " ã \n", + "label -0.066930 \n", + "url_len 0.089939 \n", + "url_n_dot 0.025364 \n", + "url_blacklist -0.000257 \n", + "url_entropy 0.063251 \n", + "... ... \n", + "½ 0.243104 \n", + "¾ 0.204703 \n", + "¿ 0.027872 \n", + "â 0.976115 \n", + "ã 1.000000 \n", + "\n", + "[205 rows x 205 columns]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\seaborn\\utils.py:61: UserWarning: Glyph 129 (\\x81) missing from font(s) DejaVu Sans.\n", + " fig.canvas.draw()\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\seaborn\\utils.py:61: UserWarning: Glyph 134 (\\x86) missing from font(s) DejaVu Sans.\n", + " fig.canvas.draw()\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\seaborn\\utils.py:61: UserWarning: Glyph 139 (\\x8b) missing from font(s) DejaVu Sans.\n", + " fig.canvas.draw()\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\seaborn\\utils.py:61: UserWarning: Glyph 144 (\\x90) missing from font(s) DejaVu Sans.\n", + " fig.canvas.draw()\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\seaborn\\utils.py:61: UserWarning: Glyph 149 (\\x95) missing from font(s) DejaVu Sans.\n", + " fig.canvas.draw()\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\seaborn\\utils.py:61: UserWarning: Glyph 154 (\\x9a) missing from font(s) DejaVu Sans.\n", + " fig.canvas.draw()\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\seaborn\\utils.py:61: UserWarning: Glyph 159 (\\x9f) missing from font(s) DejaVu Sans.\n", + " fig.canvas.draw()\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 129 (\\x81) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 134 (\\x86) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 139 (\\x8b) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 144 (\\x90) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 149 (\\x95) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 154 (\\x9a) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "C:\\Users\\Richard\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Glyph 159 (\\x9f) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDUAAAPWCAYAAADwB6NDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gUxfvAP3stl3YpkEaAUAIh1NClBaSINEFKkNCrKIooIIIKoYiKWEBAUZAmoAiCVOlNQESQ3gm9hCRAermyvz/yu/UuuYQAwQDf+TzPPcnNzs68O1tu5523SLIsywgEAoFAIBAIBAKBQCAQPGWoClsAgUAgEAgEAoFAIBAIBIKHQSg1BAKBQCAQCAQCgUAgEDyVCKWGQCAQCAQCgUAgEAgEgqcSodQQCAQCgUAgEAgEAoFA8FQilBoCgUAgEAgEAoFAIBAInkqEUkMgEAgEAoFAIBAIBALBU4lQaggEAoFAIBAIBAKBQCB4KhFKDYFAIBAIBAKBQCAQCARPJUKpIRAIBAKBQCAQCAQCgeCpRCg1BAKBQCAQCAQOmT9/PpIkcenSpQJr89KlS0iSxPz58wuszaedJk2a0KRJk8IWQyAQCJ5KhFJDIBAIBALBY8E6IXb0ee+99x5Ln3v37iUqKop79+49lvYLggsXLvDqq69SpkwZ9Ho9BoOBBg0aMG3aNNLS0gpbvAJjyZIlfPXVV4Uthh19+vRBkiQMBoPDsT537pxyjU6dOvWB279x4wZRUVEcPny4AKQVCAQCQX7QFLYAAoFAIBAInm0mTJhA6dKl7coqV678WPrau3cv48ePp0+fPnh6ej6WPh6FdevW0aVLF5ycnOjVqxeVK1cmMzOTP/74g5EjR3LixAm+++67whazQFiyZAnHjx9n2LBhduVBQUGkpaWh1WoLRS6NRkNqaipr1qwhIiLCbtvixYvR6/Wkp6c/VNs3btxg/PjxlCpVirCwsHzvt2nTpofqTyAQCARCqSEQCAQCgeAx06pVK2rVqlXYYjwSKSkpuLq6PlIbFy9e5JVXXiEoKIht27YREBCgbBsyZAjnz59n3bp1jyoqsiyTnp6Os7Nzjm3p6enodDpUqsIz1pUkCb1eX2j9Ozk50aBBA5YuXZpDqbFkyRLatGnDihUr/hNZUlNTcXFxQafT/Sf9CQQCwbOIcD8RCAQCgUBQqGzYsIFGjRrh6uqKu7s7bdq04cSJE3Z1jh49Sp8+fRSXDX9/f/r160d8fLxSJyoqipEjRwJQunRpxY3g0qVLecZxkCSJqKgou3YkSeLkyZNERkbi5eVFw4YNle0//vgjNWvWxNnZGW9vb1555RWuXr163+OcMmUKycnJzJ07106hYSU4OJi33npL+W4ymZg4cSJly5bFycmJUqVKMWbMGDIyMuz2K1WqFG3btmXjxo3UqlULZ2dnZs+ezY4dO5AkiZ9++okPPviAwMBAXFxcSExMBGD//v28+OKLeHh44OLiQuPGjdmzZ899j+O3336jTZs2FCtWDCcnJ8qWLcvEiRMxm81KnSZNmrBu3TouX76snIdSpUoBucfU2LZtm3IdeHp60r59e06dOmVXx3puzp8/r1jjeHh40LdvX1JTU+8ru5XIyEg2bNhg56Z04MABzp07R2RkZI76d+7cYcSIEVSpUgU3NzcMBgOtWrXiyJEjSp0dO3ZQu3ZtAPr27asct/U4mzRpQuXKlTl48CDh4eG4uLgwZswYZZttTI3evXuj1+tzHH/Lli3x8vLixo0b+T5WgUAgeNYRlhoCgUAgEAgeKwkJCcTFxdmVFS1aFIBFixbRu3dvWrZsyaeffkpqairffPMNDRs25J9//lEmwps3byY6Opq+ffvi7++vuGmcOHGCP//8E0mS6NixI2fPnmXp0qV8+eWXSh8+Pj7ExsY+sNxdunShXLlyTJ48GVmWAfjoo4/48MMPiYiIYMCAAcTGxvL1118THh7OP//8k6fLy5o1ayhTpgz169fPV/8DBgxgwYIFdO7cmeHDh7N//34+/vhjTp06xcqVK+3qnjlzhm7duvHqq68ycOBAQkJClG0TJ05Ep9MxYsQIMjIy0Ol0bNu2jVatWlGzZk3GjRuHSqVi3rx5NG3alN27d1OnTp1c5Zo/fz5ubm688847uLm5sW3bNsaOHUtiYiKfffYZAO+//z4JCQlcu3aNL7/8EgA3N7dc29yyZQutWrWiTJkyREVFkZaWxtdff02DBg04dOiQch1YiYiIoHTp0nz88cccOnSIOXPm4Ovry6effpqvse3YsSODBw/m119/pV+/fkCWlUaFChWoUaNGjvrR0dGsWrWKLl26ULp0aWJiYpg9ezaNGzfm5MmTFCtWjNDQUCZMmMDYsWMZNGgQjRo1ArA73/Hx8bRq1YpXXnmFHj164Ofn51C+adOmsW3bNnr37s2+fftQq9XMnj2bTZs2sWjRIooVK5av4xQIBIL/CWSBQCAQCASCx8C8efNkwOFHlmU5KSlJ9vT0lAcOHGi3361bt2QPDw+78tTU1BztL126VAbkXbt2KWWfffaZDMgXL160q3vx4kUZkOfNm5ejHUAeN26c8n3cuHEyIHfr1s2u3qVLl2S1Wi1/9NFHduXHjh2TNRpNjnJbEhISZEBu3759rnVsOXz4sAzIAwYMsCsfMWKEDMjbtm1TyoKCgmRA/v333+3qbt++XQbkMmXK2I2fxWKRy5UrJ7ds2VK2WCxKeWpqqly6dGm5RYsWSpn1HNqOp6Nz8eqrr8ouLi5yenq6UtamTRs5KCgoR11H5yIsLEz29fWV4+PjlbIjR47IKpVK7tWrl1JmPTf9+vWza/Pll1+WixQpkqOv7PTu3Vt2dXWVZVmWO3fuLDdr1kyWZVk2m82yv7+/PH78eEW+zz77TNkvPT1dNpvNOY7DyclJnjBhglJ24MCBXK+zxo0by4D87bffOtzWuHFju7KNGzfKgDxp0iQ5OjpadnNzkzt06HDfYxQIBIL/NYT7iUAgEAgEgsfKzJkz2bx5s90Hsqwv7t27R7du3YiLi1M+arWaunXrsn37dqUN2/gQ6enpxMXF8dxzzwFw6NChxyL34MGD7b7/+uuvWCwWIiIi7OT19/enXLlydvJmx+ry4e7unq++169fD8A777xjVz58+HCAHLE3SpcuTcuWLR221bt3b7vxO3z4sOJmER8frxxHSkoKzZo1Y9euXVgsllxls20rKSmJuLg4GjVqRGpqKqdPn87X8dly8+ZNDh8+TJ8+ffD29lbKq1atSosWLZSxsCX7uWnUqBHx8fHKOOeHyMhIduzYwa1bt9i2bRu3bt1y6HoCWXE4rHFIzGYz8fHxuLm5ERIS8kDXn5OTE3379s1X3RdeeIFXX32VCRMm0LFjR/R6PbNnz853XwKBQPC/gnA/EQgEAoFA8FipU6eOw0Ch586dA6Bp06YO9zMYDMr/d+7cYfz48fz000/cvn3brl5CQkIBSvsv2TO2nDt3DlmWKVeunMP6eWXzsB5LUlJSvvq+fPkyKpWK4OBgu3J/f388PT25fPlynrLmtc067r179851n4SEBLy8vBxuO3HiBB988AHbtm3LoUR4mHNhPRZblxkroaGhbNy4MUeg1pIlS9rVs8p69+5du+smL1q3bo27uzs///wzhw8fpnbt2gQHB3Pp0qUcdS0WC9OmTWPWrFlcvHjRLn5IkSJF8tUfQGBg4AMFBZ06dSq//fYbhw8fZsmSJfj6+uZ7X4FAIPhfQSg1BAKBQCAQFApWa4BFixbh7++fY7tG8+9rSkREBHv37mXkyJGEhYXh5uaGxWLhxRdfzNOqwIokSQ7LbSen2cmePcRisSBJEhs2bECtVueon1fMCIPBQLFixTh+/Ph9ZbUlN7nvJ2te26zj9dlnn+WadjS3Y7l37x6NGzfGYDAwYcIEypYti16v59ChQ4waNSpf56IgcDT+gBL7JD84OTnRsWNHFixYQHR0tF2w2OxMnjyZDz/8kH79+jFx4kS8vb1RqVQMGzbsgY45r/PkiH/++UdR4h07doxu3bo90P4CgUDwv4BQaggEAoFAICgUypYtC4Cvry/NmzfPtd7du3fZunUr48ePZ+zYsUq51eLAltyUANaVfNtsF0AOi4f7ySvLMqVLl6Z8+fL53s9K27Zt+e6779i3bx/16tXLs25QUBAWi4Vz584RGhqqlMfExHDv3j2CgoIeuH8r1nE3GAx5jrsjduzYQXx8PL/++ivh4eFK+cWLF3PUza9CxnosZ86cybHt9OnTFC1a9JHT6eZGZGQkP/zwAyqVildeeSXXesuXL+f5559n7ty5duX37t1TAtJC/o85P6SkpNC3b18qVqxI/fr1mTJlCi+//LKSYUUgEAgEWYiYGgKBQCAQCAqFli1bYjAYmDx5MkajMcd2a8YS66p89lX4r776Ksc+1slvduWFwWCgaNGi7Nq1y6581qxZ+Za3Y8eOqNVqxo8fn0MWWZbt0ss64t1338XV1ZUBAwYQExOTY/uFCxeYNm0akOUaATmP8YsvvgCgTZs2+ZY7OzVr1qRs2bJMnTqV5OTkHNvzyhTj6FxkZmY6HEdXV9d8uaMEBAQQFhbGggUL7M7b8ePH2bRpkzIWj4Pnn3+eiRMnMmPGDIfWQlbUanWOc/7LL79w/fp1u7Lcrr+HYdSoUVy5coUFCxbwxRdfUKpUKXr37p0jpa9AIBD8ryMsNQQCgUAgEBQKBoOBb775hp49e1KjRg1eeeUVfHx8uHLlCuvWraNBgwbMmDEDg8FAeHg4U6ZMwWg0EhgYyKZNmxxaB9SsWRPISin6yiuvoNVqadeunaJM+OSTTxgwYAC1atVi165dnD17Nt/yli1blkmTJjF69GguXbpEhw4dcHd35+LFi6xcuZJBgwYxYsSIPPdfsmQJXbt2JTQ0lF69elG5cmUyMzPZu3cvv/zyC3369AGgWrVq9O7dm++++05x+fjrr79YsGABHTp04Pnnn3+wwbZBpVIxZ84cWrVqRaVKlejbty+BgYFcv36d7du3YzAYWLNmjcN969evj5eXF71792bo0KFIksSiRYscun3UrFmTn3/+mXfeeYfatWvj5uZGu3btHLb72Wef0apVK+rVq0f//v2VlK4eHh55uoU8KiqVig8++OC+9dq2bcuECRPo27cv9evX59ixYyxevJgyZcrY1Stbtiyenp58++23uLu74+rqSt26dfOMeeKIbdu2MWvWLMaNG6ekmJ03bx5NmjThww8/ZMqUKQ/UnkAgEDzTFFreFYFAIBAIBM801nSgBw4cyLPe9u3b5ZYtW8oeHh6yXq+Xy5YtK/fp00f++++/lTrXrl2TX375ZdnT01P28PCQu3TpIt+4cSNHOlZZluWJEyfKgYGBskqlsktHmpqaKvfv31/28PCQ3d3d5YiICPn27du5pnSNjY11KO+KFSvkhg0byq6urrKrq6tcoUIFeciQIfKZM2fyNS5nz56VBw4cKJcqVUrW6XSyu7u73KBBA/nrr7+2S4lqNBrl8ePHy6VLl5a1Wq1cokQJefTo0XZ1ZDkrpWubNm0cjisg//LLLw7l+Oeff+SOHTvKRYoUkZ2cnOSgoCA5IiJC3rp1q1LHUUrXPXv2yM8995zs7OwsFytWTH733XeV9KPbt29X6iUnJ8uRkZGyp6enDCjpXXNLr7tlyxa5QYMGsrOzs2wwGOR27drJJ0+etKuT27lxJKcjbFO65kZuKV2HDx8uBwQEyM7OznKDBg3kffv2OUzF+ttvv8kVK1aUNRqN3XE2btxYrlSpksM+bdtJTEyUg4KC5Bo1ashGo9Gu3ttvvy2rVCp53759eR6DQCAQ/C8hyfIDRFQSCAQCgUAgEAgEAoFAIHhCEDE1BAKBQCAQCAQCgUAgEDyVCKWGQCAQCAQCgUAgEAgEgqcSodQQCARPDE2aNGHYsGH5qrtjxw4kSXrkCPOlSpVymEFBIBAIBAKBQCAQPPmI7CcCgUDw/yxevJi5c+cSGxuLp6cnCQkJZGRkIEkS1apV49NPP6VUqVJK/TFjxvDbb79hMplQq9W4uLiQkZFB9erV6dChA5mZmaxevZqDBw867K9kyZKkpKRw7949ZFnGYrEAWdH4LRYLkiSh0WiQJEn5v1SpUpjNZk6fPp2jPUmSlAwEarUas9mc72PXarVotVpMJpMi/zfffMOVK1dwcXHBaDTi6+tLYmIiycnJuLu7k5ycrMisVquxWCzIskxgYCAZGRncuXNHad/Pz4+0tDQSEhIcZkmwyq9SqZS2ihQpgsViIS4uTtnHxcUFk8nExIkTefHFF5EkiUOHDjF58mSio6MB0Ol0pKen4+rqSmZmJmFhYfTs2RM/Pz/+/vtvfvzxR27cuIFarcZkMin9azQaXF1dSUtLo0KFCvTu3ZsJEybkmZLSdsxzw9nZGbPZTNGiRblz5w7p6en3PR/Ozs6oVCpSUlKU8S1fvjzvv/8+RqORcePGceXKlfu2o9Fo8PDwICEhAbVanSMVpJeXFwkJCXbXnkajwWKx4ObmZne+rMdqPU/W66tYsWKEh4dz6tQpTp06RWZmpkNZXFxcSE1Nva/M1uN9kOv3YXj77bfp1KkT7u7uHDp0iKioKC5fvpxrfZ1Oh8FgIDExkQoVKtC3b1++/fZbbty4QVpaGiaTiaFDh9KlSxcMBgMpKSmo1Wr0ej1xcXG4uLjg7OzMzJkz+eWXX0hISGDEiBGo1WoWLlxIXFwcISEhfPjhh1SrVg2A77//nqVLl3Ljxg2760yr1SLLMt7e3qSkpCjXSV5YU5Jaz/WTiJOTExkZGahUKvz8/EhPTyc5ORm1Wq3c07Is53kdaTQazGYzer0es9mc6/VoJT/3sC16vV65h4cOHUrnzp0ZPXo0e/fuVdpxdXXN85xk77N48eLcvXs3X+fxWeVBz0N2rL+bgsfPf/F8/i/w8vIiPT1d+d0zGo33/Y365ZdfqFq16n8k4ZPBrl27+Oyzzzh48CA3b95k5cqVdOjQIc99duzYwTvvvMOJEycoUaIEH3zwgZLZ63EhLDUEAoEAWL9+PR9//DFDhgwhMjKSuLg4MjIyeOutt6hduzanT5+mX79+yqRw5syZrFixgubNm/Pyyy+j0WgYN24cbdq0ISkpialTp3Lp0iUOHjyITqejTJkyqFRZj1y9Xk9gYCBXr16lWLFiijKgbNmyAMqLWeXKlZFlmczMTCRJYurUqTRu3Nih/JIk2f21WCzo9XpKlCiRo27dunUd7v/xxx/TsWNHTpw4wVdffUWzZs3Q6XRMmDABPz8/rl+/jkajoUuXLiQmJmKxWAgNDbVTvgBcv34dPz8/AJo3b05ERAQxMTEkJCSgUqmUcbDWtxIUFITZbCYkJITw8HBiYmLsLHGssrz//vs0a9aMqKgoYmNjyczM5Ntvv8XFxQWVSkWTJk3Q6XSMGzeO+vXro9VqmThxIqdOneKzzz5jyJAhBAQEKAoNSZLQ6XSYTCZSUlKoWbMmFSpU4N133yUhIYE6deqgVqsdjrssy+j1egICAnBxcVHKPT09lf/T0tLo0aMHt27dUiZDOp0uR1tOTk7KmFjPOUB4eDhLliwhOTmZXr16cfv2bV544QWcnZ2pXbu2Mp7Zz6f1mO7cuUO1atUcHoP1PAKEhYUBKJNBq7KtRIkSdgoNf39/zGYzWq2W0NBQYmNj+fnnn7l+/TpGoxGtVmvXR/HixQGUl8Xs5932u06nQ61W56hji0bz73qMXq/P0Z8V2+NVqVR2bQ4cOJDu3bszbtw4evToQVpaGnPnzrXbx7YfqxLn9ddfZ/r06VSoUIEPPviAN998k+TkZMxmMwMHDqRXr15ERUXx008/YTAY0Ol0nD9/Xhmzli1bsnTpUsaNG8fEiRPx9vZmypQptG/fnpUrV1K+fHl69OhBfHw869ev56uvviIoKMhOWQlgMplQqVTExsaSkpJCjx49cHNzU2R1hKurKxaLBV9f31zrPAq5nYe8cHNzs3t2ZWRk0KJFCyIiIrh16xaJiYm8/fbbVK9eHYCUlJRcJx3Ozs5A1rNPpVIpz06rXNnlq1ixIkCOibTtec+Oh4eH8hvw1ltv0bt3b7p06cKePXto3Lixkno2N+WEq6urXZ9qtRqVSsW1a9cUJViFChWU+tnvWet5u9/5y8/51ev1ed5nD0L2/hw93/KiSJEij6TQAB6LQkOv1yvnrDDIz/nJ7Zn1OHlQhYaTk1O+6tnKn9c1ZH3f0Ov1ObZZ91Or1RQvXpywsDDl+nRycqJr165KP3fv3qVXr14sX74cV1dXQkJCAPD29qZDhw6oVCpFad+lSxeKFy9OlSpV8nfQzxApKSlUq1aNmTNn5qv+xYsXadOmDc8//zyHDx9m2LBhDBgwgI0bNz5WOYVSQyAQPJEsWrSIWrVq4e7ujr+/P5GRkdy+fTtHvT179lC1alX0ej3PPfccx48ft9v+xx9/0KhRI5ydnSlRogRDhw51+MI5b948IiIi6NixI+vWrUOv1+Pm5oZGo2HWrFlYLBZu3brFli1bAFiwYAHFihXjq6++4o8//mDQoEGcOnWKCxcusHDhQuLj41m+fDk6nY5hw4axYcMG5cc2MzNTUWQcO3YMrVZLt27dcHJyUl7MAc6cOYOXl5ey8nj+/Hn69euHwWCwmwy4ubnh6elJzZo1UalUShtqtZouXbpQtGhRu2PVaDQ5fpgHDBhATEwM48ePx9fXl5iYGJYvX85bb73FiRMnuHbtmuLus2HDBuXF+9q1a7Rv3x5Zlu2UFZcvX8ZisfDRRx+xevVqnJ2dkWUZs9nMa6+9hkajsXsh0Wq1pKen06hRI44dO8alS5do0KCB0q5Wq2XAgAGcPHmS5s2b8/333ytWML///ju+vr7Iskz//v35888/6devH9HR0Wzfvp0WLVoQFxfHnDlzKFu2LB07diQmJkbpu1q1avj6+gJZL2tHjx4lKioKs9mMq6src+fORZZlu5fHevXqKS9GsiwTFxdHWloakGW5MH36dLvx/fnnn+natauy/fDhwzmuwddee03539PTUzmPkydPZuPGjYoC4oMPPmDVqlU0a9aMBQsWKGNui3VCZ/3/zp07eHl5KW1mr1+uXDmKFClCYGAgycnJigLD29ub1NRUihQpgl6vR5Zlbt26BWS9IDZr1gyz2YxOp+POnTuKQsRKiRIlqF27tl1f/v7+dOvWzU5WyLJcyszMpEWLFkobtvWs15dOp1OslwIDAzEajQQFBeUYz+wv3rYKoF69evHdd9/x559/cufOHUaNGoWvry/u7u4A+Pj4KJMZrVaLxWKhffv2xMXFce7cOcaPH4/JZGLatGlotVp69OhBr169OHz4MFu3bqV169YsWLAAFxcXKleujEajwWAwcO/ePbp06ULr1q3p0qULixcvxmKxMGDAAIKDgxk3bhySJLFixQrmzZtH165d+eeff3ByciIyMhKNRoNWq0WSJEwmE87OzhQpUoTMzEzUajVubm5YLBbc3d0xGAx25zoxMZFixYrx3Xff5ZgAFitWTLmnba8N6/9arRZnZ+cc141Go1HG1Gg05joJczQB0ev11K1bl6pVq1K6dGnlOoiKiuK3335Tnhc//PADU6dOzdGm9Vq29p+WloYkScp5MxqNyj1brlw5Pv30U0UW6/VasmRJuzbd3NwoWrQo4eHhSpmnp6fSR/fu3ZVx7dOnD4sWLSImJobAwEAOHjxIx44defHFF4Gck01nZ2c7xYpWq1UUsVYaNGjAzZs3lTKz2awoPiRJUpTV1vNnfQZZFVpWsj+vrNgqRby9vXOcr2LFiuHt7a2MU3bc3d3t5LXWadKkid33zMxMZZxs5czebqNGjQCIj4+3Ux7kppSxHlNe2wtyYp+enp7jfUGv1yu/qdkV+o5kzQtHk3IrlSpVUp5zVhwdm+1zztby8H7tP6hCKy9FmSOlha1Va/Z9sx+XtY7V6jU4OFh5FluxfcZblbq2CzS21x5kjcu1a9cYNWoU7u7uitL0ww8/BP49P//88w9lypRR3hUMBgO+vr58+umnlClThuDgYE6fPs3WrVvp2LFjgSkCC5uMjAwSExPtPtktOa20atWKSZMm8fLLL+er7W+//ZbSpUvz+eefExoayhtvvEHnzp358ssvC/IQciBSugoEgieGJk2aEBYWxldffcUPP/xAQEAAISEh3L59m3feeQdPT0/Wr18PZJm2Pf/884SGhjJt2jT8/f0ZM2YMx48f5+zZs2i1Wi5cuEC1atWYNGkSbdq0ITY2ljfeeINq1aoxb948ZFlWfjzT0tIICQkhJCSE1atXA1mmiSEhISxYsIDY2FgMBgNxcXFs3bqVjyZ9hKSSlB9GX19f4uLiyMzMxN0rgLSkWEwmE927d+e1117Dw8ODnj17OpzM5obVHcT2MV1QJrb5NfV1d3cnKSnpkfsrCDQaTY6XtofB6pZStGjR+7rEwL+mtr6+vsTGxt533Kzth4SEULp0aX7//XeMRqNdHUmlRraYKVmyJNevX8dsNuPu7k56ejpOTk6kpKTctx/bc/ioptuC/xZxvp5dxLkVCJ4O8vM+VbJkSYoXL86ff/7J9u3b8ff3L7D+12lDCqytB+XA+90YP368Xdm4ceMUa7PckCTpvu4n4eHh1KhRwy5e3bx58xg2bFie7ryPirDUEAgETyT9+vWjVatWlClThueee47p06ezYcMGkpOT7eqNGzeOFi1aUKVKFRYsWEBMTAwrV64E4OOPP6Z79+4MGzaMcuXKUb9+faZPn87ChQtJT0/n+++/R61WK9r+5ORk1qxZo7Tt4uKCj48Psizz+++/M2DAAH7++WemTJmCk94JlUpF6YBAzGYzt27dwmQyIanUJN29qSg03nvvPb788kvCw8M5fPgwERER9zXNtV35lGUZHx8fZZvFYqFMmTKPPL5uBu981cuvQuO/WL2wKjTyY9rcvHlzRSaN9t/6KpWKUaNGERISws2bN0lOTubbb7/N1TxWkiRlJez27dvIsoyLiwtFfPxyrT9q1CgaN27M+fPnWbNmDS+88EKOerIlq80rV64oq7AjR47E29ub5ORkJEniww8/VLY5OmZJkmjYsGFWezbKDUHhc7/zYLWEEeTkYdxY7odKdf9V84JCKDTyj1qbP7cEgeBBkKT8TW8tFgve3t6KFZ8jd86SJUuiVqtp2LBhgSo0CpvRo0eTkJBg9xk9enSBtH3r1i3FBdmKn58fiYmJikXr40AoNQQCwRPJwYMHadeuHSVLlsTd3V2JJZE9OGK9evWU/729vQkJCeHUqVMAHDlyhPnz5+Pm5qZ8WrZsicViITo6moULF2KxWNi1axeQFQvC9oX0ueeeo2fPnmzbto1Ro0axZ88evvnmG9q2bYuHhwcAYz78AFmWqVKlClqtFr2TTpmstG/fnmXLlrH+963cvXsXV1c3hgwZksMstXTp0kDWy3zZsmXtVg6sP7S23Lhx45Ff/JMS4oF/fbzz6/OaGw/yIn8/2bO/kFhfMqz+rlZT+7y4fv06RYoUAcBk/DdQYIsWLXB1dVXclEwmEwcPHqRnz54O+8x+XKGhoXh4eORQrll54YUXMBqNbNmyRYmf8ddff+UwA9Zo//1uNBp54YUXyMzMJCYmBg8PD2RZJiYmhgEDBtq5kljRarW0bduWPXv22JVnl1fKZTKXm4l5uXLlHNb/L7BVPj0u8jLHLgis45nb9Wlbntc98zhiXhQm2geYvGa3aoKHV9ZJqixzfbVaVSBj+jgULv/LSEIBJPgPceS+8/HHH/Pjjz8SHBxMUFCQ3ftXREQE169fZ/fu3XTu3Pm/FPWx4+TkhMFgsPs86ntgYSOynwgEgieOlJQUWrZsScuWLVm8eDE+Pj5cuXKFli1b3jeSvS3Jycm8+uqrDB061OH22NhYJdOGFauLQ2RkJG+88Qbe3t7cuXOHvn37sm3bNu7cuaNYggC8OfxdICsuw7Rp0/D19UWtVvPtt9/Sq1cvjEYj5cqV44MPZrBy5UqaNWuGxWIhMDCQtLQ0EhMTuXbtGpD1Mn/hwgXg3wByxYsXZ9++fXZy5yd7Rn6x+gvn5kv5OHA0abFFlu3NQa3n58yZM0rZ/QKVWRVb2dm4cWOOYFXfffddjnq5maTm1m5e7cfGxuaoZzJmncPKlStz48YNNm/erOxnNc/MLtfChQupW7cuixcv5uuvv1bcpPLCahGSHWtmmuwT63Pnzt23zceFrfLpcVGQ944jrOOZm5tUfgPsPWtZHIzGR3u+PKz1g2wx/X//eT9z8ktBtSPIwmR6/Pe84H+P7O8QVhw9l19//XWcnZ1JTU3l7NmzdtuWLVtG5cqVAR5LgFBJ+2xa6/n7+9vFLQOIiYnBYDDYxY0raJ6tpQCBQPBMcPr0aeLj4/nkk09o1KgRFSpUcBgkFODPP/9U/r979y5nz54lNDQUgBo1anDy5EmCg4NzfH788Ucg62W5Xbt2yoO2du3avPTSS4wePZr58+cjSRLXr19n1KhRJCYmAvarhslJdwF46aWXMJvNfPXVV6xfv57p06czYsQIVqxYQXp6Oj179mTt2rV88sknaLVarl+/jiRJSrrU7JjNZoxGI5cuXcoRqOxp16Y/iRSGK0D58uW5fPmyEgDQ09PTYfA+K2+++Sa1atVi4sSJ3L2bdd0FBgba1bdmGhEIBAKBQJA3er0eo9GYQ5H82muvsXv3bmVynp/Ar4Is6tWrx9atW+3KNm/ebGdZ/TgQSg2BQPDEUbJkSXQ6HV9//TXR0dGsXr2aiRMnOqw7YcIEtm7dyvHjx+nTpw9FixZVAhiNGjWKvXv38sYbb/D1119TrVo1qlSpQmhoKL/99pvSxoYNG+jevTsAly9fpn///vzyyy+sWrUKgBkzZpCamqpo+W0j40OWqfjGjRvp06cP3333nRJlv2rVqhw8eJBLly4hyzIZGRmKz6ZOpyMhIUFRlFjJrsUODQ3NYZ3yX1pV/C9QkAqNB2nr9u3b1KlTh/j4LFege/fukZycrMTJyE5CQgJJSUnKqnWxYsWUbDxWrJlJbLHNQiAQCAQCgSALtVrt8J3Kzc2NWbNmERsbS/ny5XPEiCgIVBqp0D4PQnJyMocPH1YC3V+8eJHDhw8r7uCjR4+mV69eSv3BgwcTHR3Nu+++y+nTp5k1axbLli3j7bffLrCxc4TIfiIQCJ4YbLOfLF26lDFjxnDz5k1q1KjB6NGjeemll/jnn38ICwtTsp+sWbOG9957j3PnzhEWFsb3339P1apVlTYPHDjAmDFjOHv2LE5OTg4nnZIkKWlMdTodhw4dokGDBrlGaS5WrBg3btxw2I71kerk5ERmZqYIGid4pnBzc8s1nohAIBAIBM8aVndgWZYdurBY04wHBQUxefLkfLuq/G4ILWhR882LiXm70tpifd/OTu/evZk/fz59+vTh0qVL7Nixw26ft99+m5MnT1K8eHE+/PBD+vTpUwCS545QaggEgmee4cOHs3btWnr06EF8fDybNm3CbDaj1+tp3LgxPXr0ID09nUGDBiFJErVr12b//v1A1ip3dmsKyApqmFsMAL1er/juq9VqJEkqkFSkAkFhU7ZsWa5fv/7YY1MIBAKBQPC4KV26NBcvXsxR7unpyb179/D19aVBgwasWbOGYcOGUbt2bQIDA0lMTKRnz57Ex8czbtw4GjVqxOXLlylZsiQlS5bMV99Pi1LjaUG4nwgEgmcaWZZZv349KpWKX3/9lc2bNxMQEABkxSPYt28fSUlJ+Pn54ezsjMViYf/+/YpFhyOFBvwb1FByEFHfdsJXpUqVx+5HKBD8V1y4cIH09HTat2+Pu7t7YYsjEAgEAsFDc/HiRbRarV12JI1GQ9u2bdFqtcTFxTFhwgRKlSpFRkYGYWFh+Pj4sHLlStRqNSVLlqRbt26UKFGChg0b5luhASBpVYX2eRZ5No9KIBAI/p/o6GgsFgsDBw5k1apVvPLKK0o2iosXL+Ln58f7779P586d7WJX2BqxqVQqu1Rgti4s8n2yFMTGxnLkyBF0Oh316tWzS5lpmx7wYYJQSZL0zKV+/F/ExcUFtVqd72vAz89PScVbWPz2228kJSU91j4aN26Mv78/arXaYSq+7BgMBooWLYpOp3ts4+Pu7o5Go6FYsWJ89913HDlyhHnz5hEUFJSjrouLC1qtlsDAQNzd3dFqtdStW5eNGzfStGnTHPW1Wi0eHh55XguPM3K8QCAQ/C+SPVCoyWTixx9/VMobNGjApUuXiI6OVups3bqVhIQEnJycqF+/Ph06dGDZsmWFIb7g/xFvwwKB4JnGalYYFhZGUFAQ4eHhfPrpp6hUKtRqNW5ubjg7O9OuXTtMJlOuMTds3UcexGvv1q1bvPDCC1SvXp3MzEwlZaY1layPj4/Sh4uLS74DTbq5uSHLMh4eHvmWRfDkodPp6NixI2azGbPZjLOzc66BQq3ExMQoGXE8PT0d1pEkye5aehxBzh4nTZs2Ze/evajVasxmM6VKlbrv/ZGYmMidO3fQarU5MgbZotfrlTg6D4JKpaJTp0506NCBunXrMmzYMGbNmkVaWhpz5861U0TodDomTJhAsWLFlExHX331FSkpKfTv35/Lly/naN9oNJKamorZbMZisThUbKSlpT2QzAKBQCDIGzc3tzy3N2vWDK1Wy+bNm1m5ciUAV65cISMjg7p16zJ37ly6devGpEmTlO354WkJFPq0IJQagqeaHTt2IEkS9+7dK2xR7ktUVBRhYWH5ri9JkpJ9o7Bp0qQJw4YNK2wx8sXq1aupXr268jGbzXbbGzduTKtWrfDw8MBoNLJr1y5u3LjBihUrAMcKC0ersPnFbDazYsUK9u/fj5eXl1JepEgRypcvr1iNmEwmNBqNnSWHIyRJok6dOsiyjCRJ+QramJ9VbkHhMGDAAH7//Xfle1paGm3atEGn0+Vr/3379jmc6MuybHctx8TE4OLi8ugC/0fcvHmT4OBgrl+/rnx3c3O77/1hsVjsFBru7u45sr+kp6fj4+PDzp07H0imDh06sHPnTt566y08PT1JS0tDr9fz0Ucf4ePjY3efDRgwgBMnTijKi8TERJKTkylRogQxMTFcvXrVYR/W9M7dunVTVg7vd/8+iLmzQCAQCOwJDg7Oc/uaNWuYNWsWXbt25aeffgKy3u0MBgMffvghFStWpGvXrkRERCjbBf89IlCo4KnGGpH37t27ua5YPikkJyeTkZFBkSJF8lX/1q1beHl54eTk9Jgluz+2WUmedJKTk5UUmQApKSm8/PLLvPfee/Tt21cpr1+/Pvfu3bOzztDpdLRu3Zo///yT2NhYxUKjbNmyXLhw4b59W1eVs2PNiqLVatHpdGRmZuLr60tsbGyOdK0Cgb+/v8PUrE8jb775JomJiaxbt474+Pj7WjnVqlWL/v37c+bMGebMmSMyrQgEAoHgiUClUqFSqRgxYgSffPIJ9evXZ968ecr2JUuW8M0337B79+58tbeleP6ypDwOml87Vmh9Py6EpYbgqcW6ovW04Obmlm+FBmRNbJ4EhcbThpubG0FBQconNDQUjUbDpk2blDqJiYnEx8dTrlw5LBaLshJavHhxVq1ahUqlwmw2U6ZMGVxcXOxWzVu0aJGjT5VKhbOzc66m8daJnMlkIiMjg6CgIGJiYkS6V4FDHkShUaxYsccoyaMxcOBAZFlm8eLFZGRkKC+EeaHX61m9erXiqpEfbGPT/BcULVr0P+1PIBAIBIWH9ZkvSRIGg4FPP/0UrVabIwvYpUuXCAwMLAwRBQilhuAJolSpUjksAcLCwoiKigKyHibffPMNL730Eq6urnz00UcP1P7ly5dp164dXl5euLq6UqlSJdavXw/A/Pnzc1h6rFq1ym6SeuTIEZ5//nnFnLlmzZr8/fffdvuvWrWKcuXKodfradmypZ2JsSP3kx9++IFKlSrh5OREQEAAb7zxhrItu/vJsWPHaNq0Kc7OzhQpUoRBgwbZrWI6chHp0KGDXV7oWbNmKfL5+fnRuXPnBxlChXXr1uHh4cHixYsBuHr1KhEREXh6euLt7U379u25dOkSALt27UKr1eaYqA0bNoxGjRohyzI+Pj4sX75c2RYWFqZkKAH4448/cHJyIjU1FcjyZWzfvj1ubm4YDAYiIiKIiYlR6lvHes6cOZQpU4Y7d+5w6NAhRo4cSZUqVahevTqQdU1YLBYlXoZGo0GSJG7cuAHA9evXcXNzs7O+2Lp1a47xsFgspKWl4e3tfd+xc3V15fLlywwZMsRhmlcRI+N/C0eKS0mS8j1RX7p0aUGLVGD07NmTuXPnYjKZSEpKwmw289prr+Wq/FOr1fz1119s2LABQHGxuh+PQ8EtSZIS7yY7wnpEIBAI/neIjIwEsn6TDAYDGo2G0qVLc/ToUb799lsuX77MmjVrWLZsmVJX8N8jlBqCp4qoqChefvlljh07Rr9+/R5o3yFDhpCRkcGuXbs4duwYn3766X2DA9nSvXt3ihcvzoEDBzh48CDvvfee3cQjNTWVjz76iIULF7Jnzx7u3bvHK6+8kmt733zzDUOGDGHQoEEcO3aM1atX5+rXl5KSQsuWLfHy8uLAgQP88ssvbNmyxU4Jcj/+/vtvhg4dyoQJEzhz5gy///474eHh+d7fypIlS+jWrRuLFy+me/fuGI1GWrZsibu7O7t372bPnj24ubnx4osvkpmZSXh4OGXKlGHRokVKG0ajkcWLF9OvXz8kSSI8PJwdO3YAcPfuXU6dOkVaWhqnT58GYOfOndSuXRsXFxcsFgvt27fnzp077Ny5k82bNxMdHU3Xrl3t5Dx//jwrVqzg119/5ffff6dhw4asXr2azMxMRXmRlpZmt3J89uxZZZKp1+tJSUkhNjbWLqifJY9sJ7dv385z7GRZJiEhAaPRyMqVK/Hy8kKn01GsWDFFjoSEhHycBcGzQkZGRo4yWZbzPVFv3LhxQYtUYISHh+cIbDlz5sxcLZTMZnMOd6zCsmaSZVmJd5Od7KtzgsJBrVZTs2ZNVq9ene8MNNaAzNOnT6dZs2Y56pcoUQK9Xg/8m+VKq9XaBal94YUXqFixYp6yubq65jsujkAgeLKZPn06kPX+d+nSJYxGI507d2bGjBmsW7eOtm3bMmvWLMaMGcNLL72U73ZFoNCCRSg1BE8VkZGR9O3blzJlyjxwcLQrV67QoEEDqlSpQpkyZWjbtu0DTeqvXLlC8+bNqVChAuXKlaNLly5Uq1ZN2W40GpkxYwb16tWjZs2aLFiwgL179/LXX385bG/SpEkMHz6ct956i/Lly1O7du1cg3EuWbKE9PR0Fi5cSOXKlWnatCkzZsxg0aJFdhYK95Pf1dWVtm3bEhQURPXq1Rk6dGi+jx+yJiSvv/46a9asoW3btgD8/PPPWCwW5syZQ5UqVQgNDWXevHlcuXJFUVT079/fzu9wzZo1pKenExERAWRZmVjr7tq1i+rVq9uV7dixQ5m8bd26lWPHjrFkyRJq1qxJ3bp1WbhwITt37uTAgQNKH5mZmSxcuJDq1atTrVo1unbtSnR0NNu3b+fMmTMsWbIEyHIdadKkCaVKlQL+nbBkZGQgSRKNGjVS3FPu95JapUr+/SOvXr1KzZo1KVmyJDdv3sxTWSIQCASCf2nRogWLFi3i8uXLdOrUicTExFwz0Pj5+SkZaObOnYssy7z11lsOlVNXr15VFI1dunTBz89PyUrz8ccfI0kSmzZtUmIs6fV6uzS7ZcqUQZIkUlJSco2XlN0Fy93d/ZHHQyAQFByNGjVCp9MpVpNdunSx216iRAl69+7N888/z5o1azh27BgbNmxQ3mkFhYNQagieKmrVqvXQ+w4dOpRJkybRoEEDxo0bx9GjRx9o/3feeYcBAwbQvHlzPvnkkxyBIzUaDbVr11a+V6hQAU9PT06dOpWjrdu3b3Pjxg2HK0WOOHXqFNWqVcPV1VUpa9CgARaLhTNnzuSrjRYtWhAUFESZMmXo2bMnixcvVtw58sPy5ct5++232bx5s93q8JEjRzh//jzu7u64ubnh5uaGt7c36enpyhj16dOH8+fP8+effwJZ7joRERHK8TRu3JiTJ08SGxvLzp07adKkiaLUMBqN7N27lyZNmihjUaJECUqUKKHIULFixRxjHRQUZGc+/ttvv1G6dGnatGmjpFcFqFu3LjNnzqR9+/Z2x2vNHmF9qZVlWXkJzk0BUalSpXyPpyzLbN68mfPnz//nMQEEgoImv6mIBYKCYOzYsWzZsoW4uDiMRiPvvvturhlorl27BmTFUoqNjaVhw4bIsqyk186OLMtUrlwZDw8Pu0WDHTt20Lx5c+BfC6v09HQ7i7/o6Oj7Whdl//0YOHDgAx69QCDIPw/+27R7926MRiPe3t4YjUYlO571/o+JiWH//v2PLplWKrTPs4hQagieGFQqVY6Xgewm2LaT+gdlwIABREdH07NnT44dO0atWrX4+uuv8913VFQUJ06coE2bNmzbto2KFSs+UD5qW2xXdgqK+x2Du7s7hw4dYunSpQQEBDB27FiqVauW73S41atXx8fHhx9++MGun+TkZGrWrMnhw4ftPmfPnlV8C319fWnXrh3z5s0jJiaGDRs22LkPValSBW9vb3bu3Gmn1LBaXxiNRurXr/9A45H9WilVqhQmk4lVq1axatUqJW7Gvn37GDJkCMuWLbOrHxkZydatWxk7diwbNmzgnXfeoXjx4kiS5DDYobOzM9u3b1fcSQwGA5IkIUkSJUqU4N1336VixYoO9/X29hamyo8R67k8evQo/fr1y5cSSaVSoVarMRgMdql4rej1eiVV6IO2r1Kp6N+/PwsXLiQkJES5JlxdXdFoNLi5ud1XSfDGG2/YBR4ubKWCCHor+C9p1KgRP/zwg/I9IyODatWq2blzzZo1y85CEGDUqFFs3rwZyNtd8Pjx43z//fd2Zb///ruyb3YexdLuiy++eOh9BQLB/Xi43yZZlomPj7f7bd2yZQsArVu35rvvvisQ6QQFh1BqCJ4YfHx8uHnzpvI9MTGRixcvFmgfJUqUYPDgwfz6668MHz5ceWnx8fEhKSnJLtr+4cOHc+xfvnx53n77bTZt2kTHjh3tXphMJpMSOBTgzJkz3Lt3j9DQ0BztuLu7U6pUKYdBJx0RGhrKkSNH7OTbs2cPKpWKkJAQ5Rhsx89sNnP8+HG7djQaDc2bN2fKlCkcPXqUS5cusW3btnzJULZsWbZv385vv/3Gm2++qZTXqFGDc+fO4evrS3BwsN3HNujlgAED+Pnnn/nuu+8oW7YsDRo0ULZZ3Tx+++03Tpw4QcOGDalatSoZGRnMnj2bWrVqKUqK0NBQrl69aheE9eTJk9y7dy9PP+dq1apx9epVdDodQUFBysuvyWTi5MmTfPbZZ0qgT41GQ//+/dm2bRtffvklhw8fZsaMGbi7uzNgwABatWqFJKmQVBo8fUqh1WrJyMjAw8MDT09Pbty4QWJiIj4+Pri5uxMTE8OUKVM4efIkgYGBjBgxwm7ie/v2beF+8pho1aoVo0ePZubMmbRo0YIFCxbw3nvv5UuxaLFYSElJcRjnJCMjg8TERKX9WbNm5bv9hg0bsnTpUkaOHMmZM2dwdXVFpVIxatQoihQpQnJyMpIkMXbsWEXhMWfOHMVFCmDGjBnEx8crMWBkWUatVj8WhalAIBAIBM8Stm5fjhYFihYtisFgICQkhEmTJgFZLm3FixdHpVLl6l4mKDyEUkPwxNC0aVMWLVrE7t27OXbsGL1797bzj31Uhg0bxsaNG7l48SKHDh1i+/btisKhbt26uLi4MGbMGC5cuMCSJUuYP3++sm9aWhpvvPEGO3bs4PLly+zZs4cDBw7YKSy0Wi1vvvkm+/fv5+DBg/Tp04fnnnuOOnXqOJQnKiqKzz//nOnTp3Pu3DkOHTqkWI5kp3v37uj1enr37s3x48fZvn07b775Jj179sTPzw/IGr9169axbt06Tp8+zWuvvWZnhbF27VqmT5/O4cOHuXz5MgsXLsRisShKkfxQvnx5tm/fzooVK5T4H927d6do0aK0b9+e3bt3c/HiRXbs2MHQoUMVs1+Ali1bYjAYmDRpEn379s3RdpMmTVi6dClhYWG4ubmhUqkIDw9n8eLFdu4uzZs3p0qVKnTv3p1Dhw7x119/0atXLxo3bpyne9KePXsoU6YMTZo0ISQkRAlCqtPpqFKlCu7u7iQmJgJZyq9x48axYcMGXnzxRT7//HPatm1Ls2bNmDNnDqNGjcLFxRnZYuJebFbQqKCgIKKjo5XVP5VKlaUoS062y3Jy9epVBg4cSL169ZQyW4VGfjKoCPJP3759WbZsGb/++isxMTGYzWZatGiRa5BgZ2dn2rVrh8ViQZZlzGazQ4WT1TLB2r7RaMxX+xqNhuDgYFJTUxXT9qSkJFq0aEFmZqZSZrFYuHXrFj169ADgxx9/VDIK2WJVzqlUKrRabY7AnAKB4OEobOsngUDweNBoNCQlJSnuatktDd3d3YmLi6N+/fqcPn1aWSDMzMykbt26rF69+oECguaGCBRasGjuX0Ug+G8YPXo0Fy9epG3btnh4eDBx4sQCtdQwm80MGTKEa9euYTAYePHFF/nyyy+BrInkjz/+yMiRI/n+++9p1qwZUVFRDBo0CMiKsh4fH0+vXr2IiYmhaNGidOzYkfHjxyvtu7i4MGrUKCIjI7l+/TqNGjVi7ty5ucrTu3dv0tPT+fLLLxkxYgRFixbNNcWqi4sLGzdu5K233lKygHTq1MnObLVfv34cOXKEXr16odFoePvtt3n++eeV7Z6envz6669ERUWRnp5OuXLlWLp06QPFgQAICQlh27ZtNGnSBLVazeeff86uXbsYNWoUHTt2JCkpicDAQJo1a6aY50PWpKtPnz5MnjyZXr165Wi3cePGmM1mJXYGZCk6fvvtN7sySZIUa5Hw8HBUKhUvvvhirgohK6+//jqVKlVi6tSpnD59mp9++klpb+vWrYrVjEaj4fr168q1FxkZqSglqlWrhizLdvJYyX6tWtO8qtVqu5Sw1jHMjrUPk8mEJEnIsqzEKMmeDleQfxwF7sorQHBaWhpr1qx5bO2bTCY7s3krGzduZNOmTXZltuat1qC5uWGxWERWDoGgABEuVQLBs4nt+5YjjEYjAQEB7NmzB8AusHx0dDSfffYZrVu3/m+EFeQbSRZPbYHgkZk/fz7Dhg3Ld3yK/1X69+9PbGwsq1evLmxRmD17tqIUKlmyJDqdjvPnz9vVqV27NidOnCA1NRWdTkfdunXZvXs3AEWKFCE+Pl6pW7VKFWLOnCEmm0miVUHxIFSrVg2LxcK1a9e4e/fuwxye4BF5mPMmEAgEAoHgySKv33MXFxd+//13Jk6cmCNmTlhYGN9++y06nY6GDRsyfPhwxXqyINhVuXqBtfWghB//p9D6flwI9xOBQPDYSUhI4I8//mDJkiV28TgKC1mW7VbBr1y5YqfQcHFxQa1W061bN1xcXIAsDb1Va1+0aFG7mCAACYmJ/PT77w77elDOnDnDsWPHCAgIeOB9BTnR6/UPVN/d3V0oNAQCgUAgeAZw9HtujUfl5OTEuHHjFItaq4XxpEmTlFhX69atw2w2F4jLieDxIdxPBM8MrVq1UlbRszNmzBjGjBnzH0v0dHDlypU8A2yePHmSkiVLPlIf7du356+//mLw4MG0aNHikdoqCK5du0ZycjKQFQA1e3pea6rbd955B41GQ82aNYmKiiIuLo6oqChKly6tZE9xcXHBZDLh7+/Pn/v3ExQUxOXLl5W2HLmfWFGpVKhUKnQ6nV16XWv9U6dOERwczHvvvcehQ4eYPXu2w7aEVUHePKhbRlJSkt13FxcXjEYjvr6+JCYm5tienYCAANLT00lISFBSA9+PvK6Tpxm1Wk1YWBjjxo0jPj6eqKgoLl++zJtvvslff/3FgQMHsFgsyjXs6uqqxAWxjWUiSRIBAQEkJycrsW8Ali5dSmhoKCqVitu3b+Pi4oKLiwsffvgha9euzTH2FSpUYOjQoSxYsEDp28XFhQEDBrBkyRLi4uKUuhqNBhcXF9LT0ylSpAhGo5F79+4psVZyQ6VSYbFY0Ol0WCyWXE2c88vQoUPp0qULBoOB2NhYXFxccHV1JTY2FmdnZxYsWMDy5ctJSkrC19eXpKQkUlNT8fHxISMjg6SkJHx8fEhNTSUlJYWiRYuSkJCgPHOs8kqSRJEiRZR9HlYmR/+npaXh7u6OSqVi+vTp/PLLLyQlJTF+/Hjatm2r+LZbtyUkJNjJ7OXlRWZmJl26dKF///54eHgoMS8WL17MnDlz6Nq1K126dFG22WaaMplM3L59G2dnZ5ydnRk3bhxr167FYrHw3nvv0b17d7RaLbIsY7FYuHTpEu7u7vj6+irXkNlsVuRLTk7Gx8eHtLQ0UlJSqFGjBoMGDeLHH39kz549ODs7k5iYqMjg7OxMamoqTk5OdgG/rWNvi/VeUKlU+Pv7K781AoGg4LDGo7p79y7bt29Xyq2/Lx988IFStm/fPoKDg+1cqgsClfrZjG1RWAhLDcEzw5w5c3KkFbV+Bg8e/Fj77tOnz1PrelKsWLFcx+3w4cMUK1bskfvYsWMHqampSgyTwiY2Nlb5f/78+Zw5c4ZXX301Rz2tVouXlxdXrlyhS5cuJCYmMnfuXJo2bcqRo8fR6XRMmDCBsLAwTpw4wdSpU5UMFdaX9LwUGtWrV8+RiletVmOxWChdujT+/v5cv36d119/nR9++CHXtmRZVn5s8xtcV5Ikh6lKBfZYz7Gfnx/Xr18HspR0eXHz5k28vb3zrdCAR0sJ+aTSokULFi1axOXLl+nUqZNy/wwePJizZ8+yf/9+DAYDgwYNwsfHB4DSpUsD/46HVekHKFmF3njjDYoXL87AgQMJDg5mwoQJ/PTTT/j7+2OxWGjZsiUbNmxQ7kFbzp07x+eff87+/fuJjIykX79+WCwWvv76azvlV82aNTGZTISFhfHGG29w8+ZN4uPjadmy5X3PqTWzUWZmpnLPPmzQyYEDB9KzZ0+ioqLsjvGXX37B39+fRYsWsWDBAqKioujQoQPXr19HkiRefvllbt26hSRJVK1alRs3bpCWlkarVq2IiYkhNTWV6tWrK2Ot0WgoXrw4cXFxdpNutVpt90wxGAz3lcnR/waDgZSUFNq1a8eiRYt4//332bRpEy1atGDcuHGkpKTw/fffs2jRIjp16kTXrl2JiYlBpVIxc+ZMQkJCkGWZ6tWr89dffxEfH8/FixdZvXo1H3/8MW+++SZ9+vRh9+7dyrVjNBoxm80YjUYyMzMJCAhAlmVatWrFpk2bGDduHK+++iqdO3dm/PjxXL9+ndjYWNLS0ihdujQ+Pj5YLBZiYmKQZZnvv/+eJUuWMH78eDp27MiNGzeQJInFixeTlpZG3759OXToEBqNhvDwcJycnChWrBguLi5Uq1YNjUajjK31eW1VJtli3Va/fn07hUbRokUf6hoSCAT5w2q94ezsjJubG/Xr1weyAoJHR0fz448/FqZ4gvsglBqCZ4bAwMAcKUWtnyc9o8SOHTuQJKlQFCPWbAy5fRxNDJ5UoqKiCAsLy1G+evVqqlSpQkhICCEhIfTp00fZVrZsWT755BMlcKgVayaVuLg4YmNjSU9P591338XX15eYmBiMmekMGDCAU6dO8ddff5GcnEx8fDy7d+/G09Mzx+qsNSWtlX79+qHVanF1dbWbNBQpUoTy5ctz8eJFbt68SVpammIlULx48VyP3bq6YLs6aUWlUuV4cbamABXkzYABAzhx4oSSyScpKYlt27ZRrly5PPe7cOECsiw7vB5tqVq1KpB1Pp6mey0/jB07li1bthAXF4fRaFTun379+ilBUe/du8eSJUtYsWIFAMePH7dT8FivZ1tFQpkyZQgJCaFXr15888037Ny5k/bt2zNz5kzc3d25e/cuJpOJIkWKEBQUZCeT2WxWLLM+/PBDLl++THp6OrIsk5KSotwTR48eBeCjjz5i4cKFaDQaVCoV69evJyIiIk+XJusKoFVu6733MPeb9Ri3bt1K69atmTlzJgaDgfbt2zNjxgyWL1/Oq6++ysmTJ9m+fTvlypUjISGB33//neDgYBITEzly5Igi15o1a/Dx8UGSJM6cOaP0YzKZFLmt46/VavH09LRTpqakpOQpU27/f/311zg5OXH16lUyMzNp1qwZvr6+7NixgxUrVqBWq1m4cCGDBg2iX79+rFixgsGDB5OUlERSUhJffPEFKSkpvPbaa7z55ptIksScOXOYPHkyERERNG3alCVLltCsWTMyMzP5+uuv0Wq17NixA1mWcXFx4eLFi7i6unLnzh3MZjMdOnSgf//+JCUlsXz5cpYvX86WLVvQarXKObt79y5eXl789NNP/Pjjj7z22mu4ubmxZcsW+vfvz927d7ly5QpDhw5Vxnjw4MH88ccfREZG4urqSmJiIi1btiQ9PR21Wo2TkxOJiYmKa2N2JdnIkSMB7FJG6nS6R7b4EQgE9qhUKuU+hH+ffQEBAfTv3599+/ZRvHhx3njjDTp27JgjmLfgyUIEChUIngB27NjB888/z927d/H09CxscZ5akpOTycjIoEiRIjnKr169qgTdNBqNSmab27dvKxOB7AQGBhIbG4vJZFJW3T09PUlPTyc9PR2NRuPwRdPT0/ORFFRWM3Cj0UhqaipqtZrg4GCGDBlC5cqVOXjwIGPGjLFzWbHu9zge6REREbz55pusX7+e7777zi5AqiOcnJwoXbo0Fy5cwGg00rhxY86cOcOdO3cIDAzk9u3bZGZmYjQaHe5fpkwZUlJSiI2N5Y033mD//v053BTUajWSJGEymXB3dyc5OVk5drVajVarzdXtxHreHJl+CwqW7O4nw4cP586dOw7rSpKEVqtVJnP5OT96vR6TyZTjPrR1jxgwYAAHDhzIsx1bF4yyZcty7dq1XK+fvOSy9pvXvWKt4+7uzqRJk9i8ebPiDufIGkur1Srl1n6tFl3Z7/f/yhXNeq5kWaZEiRKkp6dz8+ZNu75t7/vSpUtTrlw5/vzzTxISEggMDMRkMtml/R47dixXr15lzZo1JCQk4OvrS2pqKsnJyWg0GsxmM+3atWPXrl0kJiYya9Ys6tevj8Vi4fbt2+j1elxdXZkzZw7Lli3jzp07eHl5YTKZSEpKonTp0gwcOJCmTZtiMpmwWCxYLBbld9fqxpOSkkJYWBjdunVDr9dz5coVFixYoFhq2Y6xVqvFxcWFtLQ0KlSogFar5eDBg4pbYvXq1enQoQPffvutnVtiXtdQ8eLF8fT05MSJE8KtUCAoZNRqNT4+Puj1esqWLcusWbMKrO091WsWWFsPSoN/DhZa348LYakhEBQyuU3sCpLMbBk5nlXc3NxyKDSs5aGhodSvX5/69esTHh5O0aJFcXV1RZIkIiMjc+xjTe2amZlpZ9WQlJR033Rg5cqVQ6d3f6hj8Pf3R6PREB8fT2JiIkOGDKF69eqcP3+eEydO8PbbbzN8+HDFTNKWvKwvrCb88K95fH6oUKECGzZsYODAgXzyySe0bt2auXPnOrQIsZKRkcHp06fx9PRkwIAB7N27Fy8vL4oVK4bFYiElJUW57h21Ex0djV6vZ8CAAbm6KZjNZkUxERQUhCzLFClSBCcnJ7y9vZUJqSMrLetKtXVS8TB+snkdvyCL7O4nO3bsICkpKddrVJZlMjMzFTN76/mxnnNHpKenYzabmTBhgrK6buse0bhxYw4cOEDLli1zWCvZWsaoVCpatGiBh4cH58+fz/OZaZUrKCjILh6Rtd/XXnvN7l6x7ddWtubNm7N+/XrGjBmjKE0dXVdWparVTcQ6Vo+i0LB9HjwoVapUQa1Wo9PpkGUZf39/EhMT7QIbN23alL179xIQEEDv3r3RarWsXbsWd3d3Ro4cSUBAABkZGXh4eKJWqxk4cCB37txh6dKlvPbaa7zyyivcunWLxMRERo8eTZ06dZBlmRUrVuDs7MyoUaOoWbMm8+bNY/Hixfj7+6PT6Rg3bhzffPMNAwcOpH379sTGxpKSksJ7771HlSpVmDBhAkuWLGHatGlkZmZy7949fH19GTVqFAsXLiQqKorZs2eTlpbG5MmTKVmyJLt37+bGjRvKc1OWZbRaLT4+PhiNRhISEpg2bRoVKlTgn3/+QafTMXHiRF5//XXOnTvH1KlTc1hsOVJohISEoNfruXbtGsePH3d4LsVzRyB4vFifsdbfKZVKRZcuXbh06ZKifBY8mYino0BQwJQqVYqvvvrKriwsLIyoqCgg68Xzm2++4aWXXsLV1ZWPPvrogdqfP38+np6erFq1inLlyqHX62nZsiVXr15V6ljdMObMmUPp0qUVU+krV67Qvn173NzcMBgMREREEBMTk2O/2bNnU6JECVxcXIiIiHBoxeCIHTt2UKdOHVxdXfH09KRBgwbK6lR+254zZw6hoaHo9XoqVKiQQyt+7do1unXrhre3N66urtSqVYv9+/fb9WHlwIEDtGjRgqJFi+Lh4UHjxo05dOgQa9as4e7du0rQvG+++UbZ57PPPgOwm6zYrqpJkqS4kuQ2OTt48CCZ6XkH2suNn376CaPRqExaZs2axdSpU8nMzGTGjBn8/fffNGrUKNdAfo5WetVqtd0k7UEUadbgpKdPn0aWZVauXEnt2rVp2bLlffeNjY1l7969BAcHc+rUKS5dusSVK1dQq9XKy7nty72touby5cv06NGDLVu2ADndFKy0b9+eEydOAPDHH38gyzIdO3ZUjtuRkqtcuXLKhCF7TBMr95v0CQuP+zN27Fh27typuJ8sXLiQTp068cILL+S5n22wTsgZj6J69er4+voq959Go2H37t3KebR1j7h37x4qlYopU6bkOKe2Skm1Ws3mzZu5d+8eGo3Gzgw5O1YrhcuXLzNnzhxFPmu/1gnpypUrqVWrll2/trLFxcVhMpl48cUX0Wq1vPnmm8iyzHPPPaccW+XKlXMoO9zd3XO4s8GDZVrKryuDl5cXYWFh1K1b127f0NBQkpOTMZlMSJKEi4uLEggUsuLKNG3alMOHD9OzZ0+io6Nxc3NDp9Mxffp0pk6dyt27d/Hz88VsNtOzZ0/mz59PnTp16NKlC7///juDBw9GlmU+//xzPv74Y8xmM5IkUa1aNbp27cr06dOZMmUK7dq1U2KvnD17lkqVKtG1a1fOnDlD1apVMRgMLF++nI4dO6LX69m6dSvLli1DlmWKFi3Kxo0bOX36NIMGDeLevXvUqFGDdu3acffuXY4dO8Y///xD+fLllWvCxcVFuQasrF27lqioKCwWCwMGDFDildy5c4f4+Hg2bNiAu3veiu4zZ86Qnp6eq+JCkqQHzuQkEAjssb2HrAoM28UP67PRutjh5OTE999/T+PGje2srQoCSa0qtM+ziHA/EQgKmFKlSjFs2DCGDRumlIWFhdGhQweioqKQJAlfX18++eQTGjdujEajITo6Ot/uJ/Pnz2fQoEFUq1aN6dOno9PpeP3119FoNErK0aioKKZOnUqjRo2YPHkyarWaypUrU7NmTdzc3Pjqq68wmUwMGTIENzc3duzYYbdf3bp1+fzzz0lMTKR///7UqVOHxYsX5ymXyWSiaNGiDBw4kMGDB5OZmclff/3F888/T8mSJfPV9uLFixk5ciQzZsygevXq/PPPPwwcOJAvvviC3r17k5ycTLVq1QgMDGTy5Mn4+/tz6NAhSpQoQb169YiKimLVqlUcPnwYgG3btnHjxg1q1aqlvByvXbuWw4cPc+fOHX744Qd+++23+65+SZKEp6cnd+/eRa1Wo9Fo7PzmHxa1Wk358uV5//338ff3VzIZ/PzzzyQmJuY6SQkODmbmzJl4eXkxb948li5dqgT+69ChAytXriQwMJDt27eTkpKiZO2wumjYZudwcXEhMzMTHx8fpQ5krY7fvXtXUYA4WgUW7hsPjzWrhiRJ+cp6EhAQQGJiol0Qx/+KEiVK8Omnn1KxYkXGjh2rpLfLC+tzLDU1VVHS5YY1U0X2Nm1dSObMmcOCBQuU2DGOrsdatWrRr18/9u/fr7gROOpLkiTc3NxITk52eP0+SGYPFxcXxYUkLS0NHx8fkpKSSEtLUzKRpKenM2nSJNq0aYNKpWLq1Kn8+OOPyjPENvON9Z5ydXXFaDTi4+NDSkqKkknHltyy8uR2X+p0ugey2nta72+rkqUw7hUgV7dEgUDwZOLn52e3wGeLJEmULFkSPz8//Pz8mDp1aoH1u7dW7QJr60Gp/3feLplPI8+mqkYgeMKJjIykb9++lClT5qHSpRqNRmbMmEG9evWoWbMmCxYsYO/evfz1119KnczMTBYuXEj16tWpWrUqW7du5dixYyxZsoSaNWtSt25dFi5cyM6dO+38zdPT01m4cCFhYWGEh4fz9ddf89NPP3Hr1q08ZUpMTCQhIYG2bdtStmxZQkND6d27t93x3a/tcePG8fnnn9OxY0dKly5Nx44defvtt5k9ezYAS5YsITY2llWrVtGwYUOCg4OJiIigXr16DmVq2rQpPXr0oEKFCoSGhvLdd9+RmprK33//TcWKFZk6dSrnz5+nc+fOyj5WpYUt3t7eSjyOefPm5WkOn1/Cw8NZsmQJCQkJDBgwAK1Wy6JFi5gzZw6vvPIKs2fPzrFCXbZsWSpXrsz58+fp1asXX3/9NfPmzeODDz6gRo0anDhxgi+++IJKlSqxbt06PvjgA7sI+jNmzMDPz0/JzmE1k7bN7PHdd9/h6urK7du3MRqNqFQq1Gq13YTKukr8NE54ngR0Oh0dO3bEYrFgNptxcXHJEdAyOzdv3iQlJeWhs2g8LFbZ+vXrR7Nmzdi8eTNjx47NM6ipJEkkJiaSmJiIp6fnfS0IfH19cyg0bN00xo4dy6xZsxQFXbFixRy2qdfrWbx4MT/++COpqakO3YqsyhCr0jD76nl+M3sEBARgsVh48cUXWb9+PR9++CGBgYFKpgzrS7Isy7z//vu0aNGCDz/8kHfffZeff/6Z8ePH07hxYyDrmWPN+gJZkffHjx9PYGCgkmFj1qxZdspXa1aeEiVKKPdup06d7Nyqsq/qWxUa+Q1IW1j396MGzLUGfQV7d43s9879LCdseZAgryaTqcBTPwoEgsdHbgoNyHqeXL58+aEsqwX/LUKpIRAUAtbMGg+LRqOhdu1/NbwVKlTA09OTU6dOKWVBQUF2k+9Tp05RokQJSpQooZRVrFgxx34lS5YkMDBQ+V6vXj0sFotdpHxHeHt706dPH1q2bEm7du2YNm0aN2/etKuTV9spKSlcuHCB/v374+bmpnwmTZqkZCs4fPgw1atXz3c2m5iYGAYOHEi5cuXw8PDAYDCQnJzMpk2bqF69OtWrVyc4ONhuQmVdNbbFNthf7969FXng4TIaQFZWhU2bNnHjxg3c3Nx49913Wb58OeXLl2fx4sU899xzNG/eHMh6MQ8ICODChQscP34cSZK4ffs2S5cupV+/fpw9exadToe3tzf37t1j+fLlDB48mJSUFMUsPykpieTkZBo2bAhkZefo16+fnetScnIyd+7c4fnnn1cmALVr184xuck+AbU9H7ZpBx/UVPpBYn08zQwYMIDff/9d+Z6amkp8fHy+riVZlunWrVuedQrS795qTZCenk58fDxms5mXX345TxcS24Ctt2/fvm8fjl4obd00rNd3ly5dqFmzJjdv3rTLGmSNXv/HH3+wZ88efHx8CA8Ptwv0ab2ebYNrWmNC5NZvXpk99u/fj7u7OykpKZhMJlq0aMGNGzcYMmQIycnJXLt2jSFDhpCSkkLbtm1RqVSsXLmSNWvW8Prrr9O2bVtOnjwJZN1PVsWExWJh8ODBnDhxgosXLyoT9KSkJJo1a6bIOXDgQE6cOEF0dDSQFetn06ZN1KhRQzne4OBgh+NtdRlxhEqlcnjfvvzyyw7r2yJJEuXLl79vvfy0Y0t+nwuO6tmWZW/Xatliq1DKjezPvPspFxMTE/9zBaRAIHhw7qfsVKlUvP3221y8eFFxIy8oVGqp0D7PIs9W/jiB4AnAkY9+9hgGjvyhC5r/oo/szJs3j6FDh/L777/z888/88EHH7B582aee+65++5rdXv4/vvv7fy34V/FgbOz8wPJ07t3b+Lj45k2bRpBQUE4OTlRr149ihcvTr9+/fjll18UJYeV3MyGDQaDsrrr7OysTPTz4zrgiEaNGin/x8XFKXEErH+tqT4ha6JjqyCyXl8mk4l79+4xePBgihQpwrRp05g/fz5JSUncvXuXDh06cPjwYU6fPs3EiRMJCAigUqVK/Pnnn9y8eZMFCxbw/fffExAQQFpaGsnJyUydOpWkpCSlj7/++ivH9ZyZmWmXLcI2m4VtPITcskfkxn8RNPdJ4Ntvv6V8+fK0adOG9evXExcX90AByJYuXZqna0BBrbCrVCpUKhVGo5Fp06bxySefcPPmTbtr04qzszNpaWnKd1mWqVGjBp06deLdd99Vyg0GA0aj0a6uI6ypOQFF6WpNuyxJkp1rQfYsQLdu3cphWebIsiMjI8POjSwwMNDuvrT+bxtz55tvvqF48eJ2WTsAqlWrBsC0adOUMuv/NWvaR7ifMmUKU6ZMUb6bzWa758iXX35pVz8zM9NuDAFmzpyZ43iSkpI4ePCgcrzHjx/PUcdKbtYzFovF4X27cuXKXNuybfPs2bP3rXc/sj8H8vtccFTP9vzmdl9cvHjxAaTLIj+e28K7WyB48sl+n2aPV2axWJRn8qVLl/jjjz9o1apVrgHbBYWHsNQQCAoYHx8fuwloYmLiQ7005YXJZOLvv/9Wvp85c4Z79+4RGhqa6z6hoaFcvXrVLqDoyZMnuXfvnl1QzCtXrijuCgB//vknKpWKkJCQfMlWvXp1Ro8ezd69e6lcuTJLlizJV9t+fn4UK1aM6OhogoOD7T7WlbSqVasq8TDyw549exg6dCitW7emUqVKODk5ERcXx5UrV5g9ezZvvfUWcXFxOSZFAHXq1LH7npiYiFqtpm3bto88abS6dDjCNmf6/YJVtmrVitGjRzN9+nSaNm3K3LlzGTt2LP379+fdd99lxowZvPzyy5w+fZq5c+cyfPhwJkyYoCgeRo0aRaVKlbh58ybp6el07NiR+Ph40tPTeeuttxQlktUcPDw8nDp16iipEFu2bGn3QpB9pVSj0dgdjyArc8Svv/5KfHw8CxYsoFatWixduvSBXo60Wu19r8FHtdZQq9VUrFgRtVrN0aNHGTNmjJ1FRfbVLEdKigMHDvD+++8r32vVqqXEm7Be27ndB3nFfnhck0WrtYQjbO/F7AqN/wKx6i8QCAT/PUWLFkWlUinvQcOHD2f9+vV88cUXj9y2pJIK7fMsIpQaAkEB07RpUxYtWsTu3bs5duwYvXv3fmgXhdywRsrfv38/Bw8epE+fPjz33HM5JuK2NG/enCpVqtC9e3cOHTrEX3/9Ra9evWjcuLGdO4xer6d3794cOXKE3bt3M3ToUCIiIvD3989TposXLzJ69Gj27dvH5cuX2bRpE+fOnbNTtNyv7fHjx/Pxxx8zffp0zp49y7Fjx5g3b57y49GtWzf8/f3p0KEDe/bsITo6mhUrVrBv3z6HMpUrV45FixZx6tQp9u/fT/fu3XF2dmb//v2YzWbGjBmDj4+P3STJw8MDQFnxtMVsNrN27doHnmAUK1bMzse6WbNmVKhQwWFd28lhXhO70NBQ+vbty7Jly1i+fDkxMTGYzWa6dOnCgAEDWLZsGStXruTChQuMGzfObvU1IyODFi1aEBwczPHjxylatCguLi6sWbNGmQxrNBrlerL6iH/55Zd2cVu2b99uZxHk7OxsN/kzmUz3XZH/X0KlUvHhhx9y8OBBYmNjAdiwYQPFihWjZ8+e+WrDNqhkbmg0mkee+Pfo0YNWrVqRnp5OWloaKSkpqNVq6tatq8SWuB96vd5u9Tw6OlpRlGVmZqLX61GpVHbKMA8Pjwe2yHoUHN3LjpSJlSpVeqB2H8aVylaW7HKJVX+BQCB4PNjG8cn+rI+Li6NkyZKYTCaCg4Pp0KEDbdu25ejRo/+1mIL7INxPBIICZvTo0Vy8eJG2bdvi4eHBxIkTC9xSw8XFhVGjRhEZGcn169dp1KgRc+fOzXMfSZL47bffePPNNwkPD0elUvHiiy/y9ddf29ULDg6mY8eOtG7dmjt37tC2bdscaVVzk+n06dMsWLCA+Ph4AgICGDJkCK+++mq+2x4wYAAuLi589tlnjBw5EldXV6pUqaJkktHpdGzatInhw4fTunVrTCYTFStWdGiKDTB37lwGDRpEjRo1KFGiBJMnT2bEiBGK1YUjrClm85o4PugEw9Y6BWDz5s2P3PapU6eIiIjIUV65cuUcZtiyLBMeHm5XtnHjRjZu3AjkTKEJ8Pnnn9t9T0xMzGFGn5mZaad4sWamyN63IAuLxeLwnGU/N3mRH3engsi8sGDBghxlRqNRSZ98P2RZzmEBld3CypGbQ37TRxcUjq5PR8rEf/7554HafRhXKltZxH0jEAgE/w22v5nWFPG2XLp0CchSzIeGhqLX6+3ebR+WZzW2RWEhUroKBE8Z8+fPZ9iwYdy7d6/A286eEvVpaftB+OKLL5RsKs2aNWPr1q122zt27MiaNWvynJQ4Sif5pODt7a1MHvOzqp8XT/JxCvJGp9NhNBqV1KAqlapArGacnJwKJJ2xQCAQCARPEtljQ1nRarV274SBgYFs27btkfs70PD+8eYeF7X/+LPQ+n5cCPcTgUDwP4Msy/zyyy8AlC9fnnHjxgH2pt6rV6++bzuPmnKwoHAUtd92NbwgUiPaUpBZNQSPl8zMTGRZJjk5GQ8Pj0dSbtkiFBoCgUAgeBZxpNAwGAyo1WoMBgNVq1alaNGixMXF5WohLCg8xBuqQPCE0apVK7uUprafyZMnF6psucnl5ubG7t27C1W2/HDt2jVl0n/t2jUlRaLt5N1kMikaeUmSGDp0KBMmTKBUqVJoNJocGvvcsE05+bi4n1tTRkYGkiTh6upaIIEGCyqrhuDBaNu2LVu3buXw4cO5xmLJjrOzM05OTlStWhWj0ZjDpcLNzS3f14QkSVSsWJHKlSsrZa6urowaNYrdu3fTqlWrXPe1piP28vJCq9XeN82vJEmo1Wp8fX3vG1vDVmknFG4CgUAgKGgSExNJT08nMTGRo0ePcu/ePQwGA7Nnz37kdyJJLRXa51lEuJ8IBE8Y169fz9VM3NvbG29v7/9Yon85f/58rtsCAwP/0wB/D8OhQ4fo1q0bACEhIdSrV4/58+fb1bGmyvT09KRPnz5UrlyZgQMHUrRoUQYPHsyOHTvyVOCo1WosFouiKLGm+C2MR21QUBDx8fFKutCAgAC7zDyCJx9fX1+0Wi21atVi06ZNpKWlER4ezq5duxzWL1OmDNHR0QB4eXmRmZlpl/40O56eniQmJub5cmZ73ZQoUYKrV6/i7+/P3bt3KVKkCDdu3MDT0zOHS1yLFi0oUqQIP//8MyqViuHDh7N79+5cA/tCVmwe27Si+XGByiu9rUAgEAgED4urqytpaWnKb0zFihU5ffo0KpWKo0ePPtLi1d+N6xWUmA9MrZ25/w4/rQilhkDwH9CkSRPCwsL46quvCk2GHTt28Pzzz3P37l08PT0LTY5HpVSpUgwbNkwJHpoXq1ev5v3331dWqR3FA9BoNLkGVty9eze9evVSLCLc3NwoVaoUJ06ceCAlRWRkpF1q28JAq9VSsmRJLly4UKhyCB6M+fPn079/fzv3kdDQUCRJ4uTJkznqe3t7U6xYMY4fP55VIAMFtChjtdjIHkitfPny3Lx5k6SkJLvyXbt20bJlS0VJ6+TkxLZt22jYsGG+7h9JklCpVDlcZ0SsF4FAIBA8bl566SX+/vtvbt68qfzmlClThkuXLuHv78/27dsfqf2DzzcoCDEfiprb9xRa348LYa8pEPyPUL9+fW7evKmkLC1sSpUq9diVPE2bNmXZsmXMmzePefPm8eWXXyrbrJk88soU0a1bN65du6Z8T05O5uTJkw88oXpQhcbQoUN5++23KVasGDqdjsqVK/P888/nGiOjVq1afPTRR5QuXRqdTkf58uXp1q2bYjkTGRnJxo0bWb16NcePH+fMmTM0bdrUocm+Tqfj+eefx8fHB51OR2BgIN7e3nmmqCwI1xaBPTqdDo1Gw6hRo3JYZ506dYqzZ8863O/OnTv/KjSgwBQakOWm5Sgy/NmzZ0lKSkKn0+Hl5aVcD+Hh4WRmZlKzZk1Wr17NN998Q+vWrZFlGbVarZTPmzePoKAgwD4VqkajQZIknJycUKvVimuKLbm5VlnrCwQCgUDwMKxevZobN27YvfNZM6EMHjy4kKQS5IZQaggE/yPodDr8/f3/p1703dzcCA0NpX79+tSvX1/JPy5JUo5V5exIksS1a9fs4mfo9fqHMnMvV65cvusOHDgQPz8/pk+fzmuvvcbUqVMxmUxs376d999/H4PBkGMfo9HIBx98gKurK6tWrSIpKYmlS5eSlpZGZGQko0ePZubMmXTq1EmxOpEkCYvFgqurq11bmZmZbN++ndTUVFQqFdevX0eSJOrVy2kmab2WxKp5wVOqVCnq1atHTExMjlSoUDBpW/PNfU6vWq0mLCyMzMxM7t27h7+/PwAvvPACixYt4vLly3Tq1ImVK1diMplo2bKlXXliYiJz585VsvX4+fkBKFlbMjMzsVgsaDQa1Go1sizj5OSEXq/HbDYr15+7u7uiqCuowKgCgUAg+N9ApVLZKdYduZZYLBZKly5N165d/0vRBPlAKDUEggImJSWFXr164ebmRkBAAJ9//rnd9rt379KrVy+8vLxwcXGhVatWnDt3Ttk+f/58PD09Wbt2LSEhIbi4uNC5c2dSU1NZsGABpUqVwsvLi6FDh9q9uC9atIhatWrh7u6Ov78/kZGR3L59W9m+Y8cOJElS/N6t/WzcuJHQ0FDc3Nx48cUX8x1zoU+fPnTo0IGpU6cSEBBAkSJFGDJkSL6CaDZp0oTLly/z9ttvI0mSnaJlxYoVVKpUCScnJ0qVKpVj/LIzZ84cPD09ldSsx48fV4Kt+vn50bNnT+Li4li9ejXNmzcHsibhjla6nZycKFGiBCqVCp1Op0yQnJycABQ//wfl+vXr+a7bq1cvvvzyS5o3b05mZiajR48mLi4OtVrNzZs3Hf6QHjlyBFmWOX78OGXLllViKBgMBjp27MiyZctYsWIFp0+fZtKkSciyzM6dO9HpdGRkZDi02EhJSSE9PZ2wsDCSkpLYsyenqWJ2Zcb/ksLscXP27FkldovZbH6ix9ZsNiupmmVZJiYmBoCxY8eyZcsW4uLiMBqNrFmzhldffZVJkybZlb/77rv4+Pig0WiwWCzK/pClZKtVqxayLCsBTzUaDQEBAaSnp9sFQE1KSrJTOsqyTPHixf+bQRAIBALBU43FYrF7hzWbzZQsWVJ5B4SsrHOXLl1i5syZnDp16pH6k1RSoX2eRURMDYGggHn99ddZt24dP/zwA76+vowZM4adO3fSr18/vvrqK9q3b8+5c+eYPXs2BoOBUaNGceHCBU6ePIlWq2X+/PkMGjSIJk2a8Omnn5KUlETHjh2pWbMmnp6ejBs3jujoaDp16sTChQuVSe4PP/xAQEAAISEh3L59m3feeQdPT0/Wr18P5IypYe2ncePGfPzxx6hUKnr06EH16tVZvHjxfY+zT58+rFy5ksjISN566y3Onz9P165d+eqrrxg4cGCe+965c4dq1aoxaNAgpa6/vz8HDx6kTp06REVF0bVrV/bu3cvrr7/OrFmz6NOnD2AfU2PKlClMmTKF9evXU6dOHe7du0f58uUZMGAAvXr1Ii0tjVGjRmEymVi9ejXR0dF06dKFjIwMux8pWZYdThqt8TbyirvxX1MQsmg0GrsVbkdYVysMBgP37t0TK99PKPk5lwKBQCAQCAqeM2fOPPS+h5o1LEBJHowaW/8otL4fF44dtAUCwUORnJzM3Llz+fHHH5V0oQsWLFBWC8+dO8fq1avZs2cP9evXB2Dx4sWUKFGCVatW0aVLFyDL7Pqbb76hbNmyAHTu3JlFixYRExODm5sbFStW5Pnnn2f79u2KUqNfv36KHGXKlGH69OnUrl2b5ORk3NzcHMprNBr59ttvlX7eeOMNJkyYkO/j9fLyYsaMGajVaipUqECbNm3YunXrfZUa3t7eqNVqxarEyhdffEGzZs348MMPgawAhCdPnuSzzz5TlBpWRo0axaJFi9i5c6fiVjJjxgyqV69ul/r2hx9+oESJEty4cYOqVaui1Wpxdnbmn3/+oXr16qSlpTlUaOj1esUyw2QyoVarGThwIN9++22+x+dxUBDKFdtJsDVOR/Z2y5Urh0aj4ejRo7nG8hAUPq6uriQkJABZ12xGRoZQcAgEAoFAUABkD0zdsWNHVq5cCcD48eMfqW3VM5patbAQ7icCQQFy4cIFMjMzqVu3rlLm7e1NSEgIkBXgT6PR2G0vUqQIISEhdmZsLi4uiqIBwM/Pj1KlStkpJ/z8/OzcSw4ePEi7du0oWbIk7u7uNG7cGIArV67kKm/2fgICAuzavB+VKlWy8zl80P2zc+rUKRo0sI8G3aBBA86dO2dnKfD555/z/fff88cffygKDchyw9i+fTtubm7Kp0KFCgBK1g9XV1cyMjJYuXJlnpM/g8Fgd2xms5m5c+cCjzeGRG7pwQrS/cBWfm9vb0qWLJmjzsmTJzl69CiQpfDIK1CooPCwKjTg6Ykj8SS70ggEAoHgfxPrYpst1vclZ2dnnJ2dadSoERqNBhcXF/7+++/CEFOQC0KpIRA8gWSfQEqS5LDM6j+ekpJCy5YtMRgMLF68mAMHDiiaZFuf8/z08yAT9rxkepw0atQIs9nMsmXL7MqTk5Np164dhw8ftvucO3eO8PBwIOuHqUKFCnz00Ud5xsi4fft2jkmi1dfycU7KzGYzERER7N69m+PHj3PkyBGOHTvGzz//TJUqVRzuo1ar0Wg0+Pn5KVlLfH19cXd3R5IkIiMj2bp1K0ePHqVfv3525y0+Pp5Lly6h0+nQarW4u7uj0Whwc3NDrVYr5WazGZ1Ol0PpolKpHilPu6DgMBqNT5yVhm2Wkx9++AEPDw9FRmssF0mS0Ol0QJbSUavVUqlSJebPn0/Hjh1zvd+CgoLo2LGjw75sM6oU9PEIBAKB4NnDbDaTlJTk8DcnLS2NtLQ0PvvsM/z9/UlLS6NOnTqFIKUgN4RSQyAoQMqWLYtWq2X//v1K2d27d5WglKGhoZhMJrvt8fHxnDlzhooVKz50v6dPnyY+Pp5PPvmERo0aUaFChUeymPgv0Ol0OZQGoaGhOQJS7tmzh/Lly9tNJurUqcOGDRuYPHkyU6dOVcpr1KjBiRMnKFWqFMHBwXYf2ywfOp3OTqGRX/cK68TL+je/SA4CceZGhQoV2LBhAz/99BMA0dHRxMfHc+7cOebOnYter8+xj9lspmLFity+fZukpCTKlCnD7du3SUlJoXPnzkr2kxEjRrBgwQLGjBlDiRIl7JRYOp1OSR1qMpno1KkTarXaTimmUqmUc6ZWq3F2dsZisTw1FgKC/5YWLVo4zH5Srlw5tFotFosFlUpF2bJllZfIwMBAqlatyuXLl+nbty+rVq1ClmW8vLzs2vby8uLKlSv8+uuvDvtKTk5m3rx5drFzspP9vs/rOWDdZjab82xTIBAIBE8nTk5OuS7uubi4ABATE8PVq1cBFJfxh0UECi1YhFJDIChA3Nzc6N+/PyNHjmTbtm0cP36cPn36KCuS5cqVo3379gwcOJA//viDI0eO0KNHDwIDA2nfvv1D91uyZEl0Oh1ff/010dHRrF69mokTJxbUYT0WSpUqxa5du7h+/TpxcXEADB8+nK1btzJx4kTOnj3LggULmDFjBiNGjMixf/369Vm/fj3jx4/nq6++AmDIkCHcuXOHbt26ceDAAS5cuMDGjRuVyVH16tW5desWhw8fpkmTJkpb+Y1TYZ3g52X94gj5AaxXZs+ejdls5u7du/z888/07NkTb29v9u7dS3p6ut2PrYeHp/L/iRMnaNu2LQaDQcmmY7FY6NKlC8uWLePXX39l3759ODs706JFC1JTUylbtiwWiwU/Pz+Sk5O5c+cOmZmZuLi4sHDhwqzjlLMsACwWi6IIcnFxwcXFhbS0NKV/6w++oOB42t00HGU/GTRoEHfu3FGuY4vFwpUrV5RgvWfPnuXgwYMkJycjyzIWi8XORQ4cpxLO3teIESMoWrSoEtvIEbb3vSRJeT4HbLfp9fqn/twIBAKBwJ6MjAxeeeUVqlatalceHBxMamoqkLUAVKdOHSwWC2vXri0MMQW5IKK/CQQFzGeffaa4Qbi7uzN8+HA7v/d58+bx1ltv0bZtWzIzMwkPD2f9+vWPFLPAx8eH+fPnM2bMGKZPn06NGjWYOnUqL730UkEc0mNhwoQJvPrqq5QtW1YJblijRg2WLVvG2LFjmThxIgEBAUyYMCFHkFArDRs2ZN26dbRu3Rq1Ws2bb77Jnj17GDVqFC+88AIZGRkEBQXx4osv0qxZM6pXr05kZKSSItXKg7rdqFSqx+ZmY42FsmTJEqXM+gO7bt06u7oJCfeIjIxk8ODBFClShGnTpimZSnr27Enfvn0pWrQoAFWqVGHkyJFKlpq7d++Snp6uXHeenp4kJydjMBhISkpSxkNS5RwbWysX69hZf/AF90elUlG+fHnq1q3L+vXriYuLc3j95XVNPs5r0LYPtVpNjRo1iIyM5JNPPsk15bOzs7OdkkuSJEaMGEGnTp3s6s2dOxej0WinJLifktAaD8eWu3fv2n1v1KiR3feMjIwcL6Z58SD3v+3zXCAQCATPDkuXLs1RFhsbq/xvMplITU3Fy8uLr7/+mrZt2z50Xw9ixSu4PyKlq0Ag+J8iJiaG8PBwNBoNzs7OACQlJeVrX1dXV1JSUh6neHh5eSkTNltli0qlQq/X2ykPWrVqxZQpUxg/fjy7d+8mPj6eqKgoLl68yLBhwxg3bhzp6ek899xzvPjii7Rp04bY2FicnJwwGo1ERUXx66+/cvjwYfR6PS+99BLLly/HYrHw1ltv8d1335GRkYFKpcJkMhEeHk56ejp//fUXAC1btmTjxo2KPFqt1i7Hu0ajQafTPaUKDwko+J/HKlWqMHHiRAYOHEhsbCytWrWid+/e9O7dm4yMjHy1kX2cHfGoSg+1Wk1oaCjnz59HkiRUKhVpaWn5blOSJCRJQq1WK7LWqlWLgwcPIssyOp2OzMxM1Gq1cF8SCAQCwRNHqVKluHbtGiaTCUmS0Gg0VKpUiWPHjlG0aFE0Gg3btm176PaPtm5ScMI+IFXX7yi0vh8XQkUkEAj+J2natCmDBg0iOTk536bkqampj8XsXK1WExISgkajITk5WSm31Tlbg3ba0rdvX5YtW8by5cuJiYkhICCALl26MGDAAJYtW8aqVau4ffu2otywkpGRQYsWLahWrRrHjx+naNGiuLi4sGbNGsVVSqPRUKdOHWRZxmQyYTAY+PLLLxWFhiRJbN++3S5WibOzs52MJpPJbvX+6eLx6Ps//PBDDh48qKz8bNiwgWLFitGzZ8987Z8fJYBGo3nkgKHdunWjVatWpKenk5aWRkpKCmq12i5zkyM8PDyU//V6vZ3yJTo6WlEkZmZmotfrUalU97VSU+VjNSsyMtJhuaMYNAKBQCAQOKJ06dLK/5cuXVJiKMmyjNFoJCkpCY1GQ2xsLO3atXukvkRMjYJFWGoIBAKH2KaPzc6GDRtymHvbsnv3blq1apXrdtuJ+39NSkoKNWrUYNCgQQwZMoRq1arlWvdB3VL+Sx5lJV6j0WA2m/M8NutE02AwKC4tgieP/JxLgUAgEAgEBUdwcLDdQtDDcKzt8wUo0YNRZe32Quv7cSFiaggEAoccPnw4122BgYF57lurVq089y9MrAqVy5cvM2vWLCB3BUH2iWJ+zP7/Kx5lEms7CbZmdcgeJLFcuXL4+fmxffv2fGeHEdyfgna3cHV1VWI86PV6JT6NQCAQCASCB8fWDdgRkiRx9epVfvnlF7p27fofSibIC/GmKhAIHBIcHPxA9S9dukTp0qX5559/CAsLe+D9/2u2bNmimKb7+fnlGgDRlifNWkGv19u5ldhijVlgxVZxYzvp9fb2xs3NjejoaLv9T58+rZSZTCZ0Oh2SJOU77gM82ZYuhYVtWtyCwDZo5ZN2fQoEAoFA8LRx9+5du3cm68JO7dq16d69OyNGjECj0fD3338/klJDpX423UAKCxFTQ/Cf0KdPHzp06PDA+5UqVUpJ12lLVFQUYWFhjyyXFUmSWLVqVb7rz58/H09PzwLrvzDYsWMHkiRx7949pcwa3C+3T1RUVKHJC1mKE0mSHskKxMvLS4lhYQ36aRvZOi8ffEfWHCqV2kHNRyMiIoLdu3dz/Phxjhw5wrFjx1i2bBlVqlRR6siyrCg01Go1Go0GPz8/fHx80Ol0eHp64u7ujiRJREZGsnnzZo4ePUq/fv3sYhjEx8dz6dIldDodWq0Wd3d3NBoNLi4uGI1GpdxkMiHLsl3WmKzjV+Uos5VRYM/jtPQxGo1P3Jir1Wpq1qzJ6tWr+eGHH+xibljNdiVJUmKxuLq6otVqqVSpEvPnz6djx465xrEJCgqiY8eODvuaN28eQUFBj+V4BAKBQPBsY/u+ZzKZMJlM7Nu3jxo1ahAUFERycjK1atUqRAkF2RFKDYFAoHDz5k3l89VXX2EwGOzKRowYUdgiPjI6nY7AwEBOnTqllFnTngK5Wj5Y97X9C2Cx3H91XKXKv1FchQoV2LBhAz/99BOQFVwxPj6ec+fOMXfuXDulS2hoRSBrhb5ixYrcvn2bpKQkypQpw+3bt0lJSaFz586MHj2amTNnMmLECBYsWMCYMWMoUaKEnSWFTqfD29sbyPoB79SpE2q1Ooe1h9UaQK1W4+zsjMViERYCAoe0aNGCRYsWcfnyZTp16sTKlSsxmUyUK1cOrVaLxWJBpVJRtmxZRXERGBhI1apVuXz5Mn379mXVqlXIsoyXl5dd215eXly5coVff/3VYV/JycnMmzdPCfLmiOxuVXm5WVm3mc3mPNsUCAQCwbOH9TeqUaNGnDlzBoDOnTs/WpsiUGiBIpQagmcCi8XChAkTKF68OE5OToSFhfH7778r2zMzM3njjTcICAhAr9cTFBTExx9/DGRZgwC8/PLLSJKkfH8Urly5Qvv27XFzc8NgMBAREUFMTIyy3WppsmjRIkqVKoWHhwevvPKKXWrRpKQkunfvjqurKwEBAXz55Zc0adKEYcOGKXUyMjIYMWIEgYGBuLq6UrduXXbs2KFsv3z5Mu3atcPLywtXV1cqVarE+vXruXTpEs8/nxWgyMvLC0mS6NOnD/7+/srHw8MDSZKU776+vnzxxRe5jnF2zGYz/fr1o0KFCly5cgWA3377jRo1aqDX6ylTpgzjx4+3i+UgSRJz5szh5ZdfxsXFhXLlyrF69ep8j7vFYuHjjz+mdOnSODs7U61aNZYvXw7A6tWrqVq1KuXKlePKlSt2K9q3bt3KV/vWCb7tRD9/cpnuX+n/mT17Nmazmbt37/Lzzz/Ts2dPvL292bt3L+np6XZyX7t2Xfn/xIkTtG3bFoPBwLlz5/6/XwtdunRh2bJl/Prrr+zbtw9nZ2datGhBamoqZcuWxWKx4OfnR3JyMnfu3CEzMxMXFxcWLlyoHKfRaMRisSgKHxcXF1xcXOwym7i4uDzQmAiefcaOHcuWLVuIi4vDaDSyZs0aBg0axJ07d5Tr2GKxKPejJEmcPXuWgwcPkpycjCzLWCwWypYta9eu9eXS9l7I3teIESMoWrQozZo1y1W+7M+e7HFlcqur1+sfSxYkgUAgEBQuBoPB7nvx4sWBf39v1Gq1otjesGHDfyucIE+EUkPwTDBt2jQ+//xzpk6dytGjR2nZsiUvvfSSMrmbPn06q1evZtmyZZw5c4bFixcryosDBw4AMG/ePG7evKl8f1gsFgvt27fnzp077Ny5k82bNxMdHZ3D7+7ChQusWrWKtWvXsnbtWnbu3Mknn3yibH/nnXfYs2cPq1evZvPmzezevZtDhw7ZtfHGG2+wb98+fvrpJ44ePUqXLl148cUXleMeMmQIGRkZ7Nq1i2PHjvHpp5/i5uZGiRIlWLFiBQBnzpzh5s2bTJs2Lc/jut8Y25KRkUGXLl04fPgwu3fvpmTJkuzevZtevXrx1ltvcfLkSWbPns38+fP56KOP7PYdP348ERERHD16lNatW9O9e3fu3LmTr7H/+OOPWbhwId9++y0nTpzg7bffpkePHuzcuZOmTZvywQcfcPnyZQBq1KjhsI1evXqxe/duRo8ebWfBkRsqlYr69evnSz5rfauVgyMaN25MamoqS5YsYeLEiSQnJ1O1alXWrVtHeHi4XUyLpCT7eArr1q3j9u3bdpYTERERTJw48f/rJ5GcnEzDhg2Jj4/n/PnzAEo8EaPRSEZGBqmpqcoPeI8ePdi6daviuuLi4qIoPnx8fJTJXWpqKpDlPuDt7Y1araZPnz5s27bNoduLFY1Go7Rhu+/90nwKnnwaNWrEDz/8YFf25ZdfEh8fb6ckyMzMJDMzM1fXmQsXLtgFbZNlOUcQt+x9ZWRkULVqVdavX58vWR/EbSchIeGJc/MRCAQCwaOTmJho9/3atWt2SuzMzEzKlCmDp6cnX3/99X8tniAPhFJD8MQzatQo3Nzc7D6TJ0+2qzN16lRGjRrFK6+8QkhICJ9++ilhYWFKPI4rV65Qrlw5GjZsSFBQEA0bNqRbt24A+Pj4AODp6Ym/v7/y/WHZunUrx44dY8mSJdSsWZO6deuycOFCdu7caacwsVgszJ8/n8qVK9OoUSN69uzJ1q1bgazJ54IFC5g6dSrNmjWjcuXKzJs3z26yeuXKFebNm8cvv/xCo0aNKFu2LCNGjKBhw4bMmzdPqdOgQQOqVKlCmTJlaNu2LeHh4ajVasXVwNfXV7HMyIv7jbGV5ORk2rRpQ2xsLNu3b1fGc/z48bz33nv07t2bMmXK0KJFCyZOnMjs2bPt9u/Tpw/dunUjODiYyZMnk5yczF9//XXfcc/IyGDy5Mn88MMPtGzZkjJlytCnTx969OjB7NmzcXNzw9fXV/GTHDlyJK6urorM7u7uBAUFsWXLFl599VU++eQT2rZty6uvvqr04Sjehl6vZ+/evUiSxB9//EGJEiXylNPqrmFr5WCLVSZb6tSpk6+V4fymeM2+EpEbrVq1YtSoUcycOZMWLVqwYMECRo4cSXh4ODExMSQlJdlZNpUrV460tDQSEhJo3bo1w4cP57vvviMiIoIFCxbw3nvv2SlzrLE6su8LKPE8SpYs6VC2IkWKADxSOjWBQCAQCAQCR7zyyitoNBpFia1SqdBoNKSkpBAcHPzIMbIklarQPs8iz+ZRCZ4pRo4cyeHDh+0+gwcPVrYnJiZy48YNGjRoYLdfgwYNlLgJffr04fDhw4SEhDB06FA2bdr02OQ9deoUJUqUsJvcVqxYEU9PT7s4DqVKlcLd3V35HhAQwO3bt4GsOApGo5E6deoo2z08PAgJCVG+Hzt2DLPZTPny5e0UPjt37uTChQsADB06lEmTJtGgQQPGjRvH0aNHH+qY8jPGVrp160ZKSgqbNm2yU5QcOXKECRMm2Mk6cOBAbt68qazyA1StWlX539XVFYPBoIxLXpw/f57U1FRatGhh18fChQuV8XCEWq3GxcUFNzc3vv32W2JiYjh58iSyLLNy5Ur27NmDTqdDlmXS0tKQZdluldYquyzL+Pj42AVefRisbkG2nD59ukADFPr6+uarXt++fRXXlZiYGMxmM82aNePYsWM4OTlhMBi4ceOGUj8mJoYmTZpgNpvp2bMny5YtY+3atYr1iPXcqNVqJEnCaDRSunTpHPtalXc6nY74+Pgccnl7e3P37l2KFi0q3F6eUJ4USxvhJiIQCAT/m0iPGMh92bJlBAYGKt8tFgsWi4WkpCROnTpFu3btHlVEQQEiUroKnniKFi2aIz2o1cogv9SoUYOLFy+yYcMGtmzZQkREBM2bN1fiLRQG2V/6JUnK90o7ZFkXqNVqDh48mGPC6+bmBsCAAQNo2bIl69atY9OmTXz88cd8/vnnvPnmm49+ALnQunVrfvzxR/bt20fTpk3t5B0/frxdtgIrthYQDzsuycnJAKxbt87uRwiwC+xnNptRq9WcPXuWlJQUSpYsyeXLl7l58yatW7e22y8pKYnjx48rctwPW6XTw7J27docZdnNIR8Vq9vJ/YiIiMhRFh4ervxfsmRJwsLC2LRpE7du3SI1NZVt27bluu8777xD06ZN2bBhg3JMFy9eBLKO0bqvFes5zY7VHSkuLi5fxyH4F0mSKFmyJJUrV+avv/6yy/xTkDzOLC8PgnATEQgEgv9N5HwEcs8Li8WiuCzbllndHzdv3szbb7/90O0/qwE7CwthqSF46jEYDBQrVow9e/bYle/Zs4eKFSva1evatSvff/89P//8MytWrFAmR1qttsAyOISGhnL16lWuXr2qlJ08eZJ79+7ZyZMXZcqUQavV2rmrJCQkcPbsWeV79erVMZvN3L59m+DgYLuPv7+/Uq9EiRIMHjyYX3/9leHDh/P9998D/2bwyM9x53eMAV577TU++eQTXnrpJXbu3KmU16hRgzNnzuSQNTg4uEBcCCpWrIiTkxNXrlzJ0X52l5AKFSqwd+9eAK5fv47JZCIkJIS6deva1XvQtMG24/6/gFarZe7cueh0OiIiIhRXElslm62S6t69eyxbtozExESee+45pdy2vrC8eLxUqVKF9PR01q1bV6BpsQUCgUAgeJKQpId/t3S0kGUNur9z5048PT1p1arVo4gnKGCEpYbgPyMhIYHDhw/blRUpUuS+MQjyw8iRIxk3bhxly5YlLCyMefPmcfjwYRYvXgzAF198QUBAANWrV0elUvHLL7/g7++Pp6cnkOUKsnXrVho0aICTk1OO9IGOMJvNOY7HycmJ5s2bU6VKFbp3785XX32FyWTi9ddfp3HjxvnOae3u7k7v3r0ZOXIk3t7e+Pr6Mm7cOFQqlfKgLV++PN27d6dXr158/vnnVK9endjYWLZu3UrVqlVp06YNw4YNo1WrVpQvX567d++yfft2QkNDAQgKCkKSJNauXUvr1q1xdnZWLDweZoxtefPNNzGbzbRt25YNGzbQsGFDxo4dS9u2bSlZsiSdO3dGpVJx5MgRjh8/zqRJk/I1Llas6bRsqVSpEiNGjODtt9/GYrHQsGFDEhIS2LNnDwaDAS8vLz744AOCg4M5d+6cco4tFguzZs1ixYoVfPHFF3bnKHtg1pxIwL8rwT/99BNNmjR5oGN5mjl06BCyLHP+/HliY2NxcnLCYrFgNBrRarUYjUb0er2yam9rIXLq1CmcnJzIyMiwU6w9KSv8zyq2Lmi7du0qREkEAoFAIHh8yHJOK183Nzc7K1Db1PaQFTfDYrHYlVnfZ1QqFSqViuPHj5OQkODQ8vhBEJYaBYuw1BD8Z+zYsYPq1avbfcaPH18gbQ8dOpR33nmH4cOHU6VKFX7//XdWr15NuXLlgCwlwZQpU6hVqxa1a9fm0qVLrF+/XrEQ+Pzzz9m8eTMlSpSgevXq+eozOTk5x/G0a9cOSZL47bff8PLyIjw8nObNm1OmTBl+/vnnBzqmL774gnr16tG2bVuaN29OgwYNCA0NtXPVmDdvHr169WL48OGEhITQoUMHDhw4oARXNJvNDBkyhNDQUF588UXKly/PrFmzAAgMDFSCd/r5+fHGG2880hhnZ9iwYYwfP57WrVuzd+9eWrZsydq1a9m0aRO1a9fmueee48svvyQoKOiBxgWygjdlH/uYmBgmTpzIhx9+yMcff6wc87p16yhdurRd9pMlS5YoAS5lWWbcuHH07t0bNzc36tati7e3NxqNJh9xAWRcXV1p3rw5/v7+vPDCC/mKJeCoTp06dZTMH/lxddFoNMoPbF518ourqytarZbKlSszefJkqlSpct99rJlYVCoVycnJBAQEMGPGDM6cOaOk4UxKSrJTxllJSEhQ9tdoNGg0Gvz8/PD09ESSJCIjI+2yrjgaM9s627ZtY+jQoQ6DudqOR2BgoHJ+HWWgUalUFCtWTLFkepaxzaQj+JehQ4eya9cuBg0aZOe6lhuVK1dm1qxZ9O7d+4mJJSIQCASCnGR3a83uoujI3dm62BIfH09SUhJDhgyhbNmyOVydBYWLJAuHU4HgqSAlJYXAwEA+//xz+vfvX9jiPPUcPHiQyMhI/P39KVmyJFOnTmXFihXMnTsXb29vrly5QkhICDdu3CApKSnXdry8inD3bjzly5dn1KhReZ4bq2VCdmrXrs2pU6dwc3Pj1q1bSJKEm5tbnv2q1eoCc5mSJInx48eza9cu9u/fj9FoZNWqVURGRuY7na5er6d27drs27ePXbt28fLLLxMTE5OjH0c/OSqVijp16vDnn3+i1+tp164dY8eOZdy4cezZs4e4uDjGjBnD1KlTlawxrVq1YsqUKYwbNw5XV1fCwsJ49913lTEJCgriypUrSn9hYWFUqlSJJUuWoFKpcHd3x83NjWvXruV6TAaDocDjmTwxyGQZGgnsGDhwIIMGDeKVV14hOjoarVZLjRo1+PPPP3PdR6/XU716df788888Y3hYVwAFAoFA8GSg0+nsApQ7wvq+5ebmhslkIiMjg0mTJtG5c+dH6vtM15aPtP+jEPLzxkLr+3EhLDUEgieUf/75h6VLl3LhwgUOHTpE9+7dAWjfvn0hS/Z0snr1ajvLDusPWGJiInfu3CE8PJxFixZRsWJFrly5AmRl5EhOTs7T4uHu3azsHGfPnmXGjBlUqFAh17rZFRrW7DcXLlygQoUK3Lp1C8iyKMjIyMjTWiL7D/CjZHl44YUXMBqNbNmyhaSkJNLT0/n111/p1KmTw/oqlcouCCxk5W4vVqwYJpOJFStWULlyZcVqQqVS0axZs39lzDbvs1gsyqTRYDAomVNss65YM6dYsc3Mcv36dWbOnInBYFD67Nq1q13qWi8vL9auXYssy8rLSXBwcJ7jlp9VesGzRa9evZg1axYXLlxQMh2dP38+V4s0gPT0dPbt24csyzg7O+dqPSUUGgKBQPBkYTQac1VoZH/3s2Y/8fDw4KWXXnrkviWVVGifZxFhqSEoNBYv/j/2zjssiuv7w+/sLktbqiJgAxXBLii22Plq7L1rVOwajb0mUdEkmtiipttLNJbEqIkae49dsSIqFtQgVnpn9/cHv52wsHQUJfd9nnlgZ26b2dndueee8zkbGDZsmNFjLi4uXL9+/Q2P6F8qV66cTvFYz08//SQbGF4nly5dYvDgwQQGBqJWq6lZsyaLFi3KVliAID1RUVEG6UETEhJo27YtRYsWNciiUalSJW7cuIGZmRkJCQliIpILvL29UavVnD59Ot+uX58+fRg4cCAODg4sXryY9evXp9Pf6NWrF3fu3OHChQtotVpMTEwwNzcnKioq3TgcHBwIDw/H0tKSsLCwAlth7927NwMHDmTr1q2sXbuWuLi4TMtbWlqSkJBA0aJFCQsLkz1XBAKBQCAQvH5Kly7N/v3789zOrV4t82E0ucP9l78KrO/XhRAKFRQY7du3T5dtQk9BxyXv3r07Q8FCR0fHNzIGLy8vLly48Eb6+i+g0WgMVvp1Oh0mJiY8f/6coUOHYm5uzpIlS7hx4waQ4lUxZcoUvvzyywxaVJDicvDvZNjc3LxQTTJzO5kPCQnh8ePHALRo0YK9e7Pp5phBSISPjw9Tp041CEfp0KED27ZtMygTHh7OuXPnKFOmDHZ2dly6dEkOHzEzMyMpKUnO0GJiYoJSqZRTs0mShLW1NeHh4XKbFhYWxMTEyNdA/zq/eP/995k2bRo9e/aU7zu1Wk1SUlKG133kyJH88ccfBAQE5Ns4BFlT2D7bAoFAUNhRKFRotUk5qqNSqUhKSsowXBZSFkXyAykfMv8J/kVcTUGBYWVlZTS9p5ubW67EI/MTFxeXDMemDxl4UzRp0oSxY8e+0T4LAl9fXzp27Jjt8keOHEGSJMLCwgBYs2aNnM0mO+zYsUNWs16/fr3RumndyA1FKLWkjaNIncK2MJBb74THjx/L106hUGBvb5+9iv9v0Ehb3snJiW3btsnhKAqFgoCAAIPwEkdHR/76K2Xl4d69e1y8eJEBAwYAKQ8pf/31l2zQAHj+/LnBJLVkyZLpMjGlNWDkp0EDUtI/b968mevXr8uhDoMGDaJv375Gy5uYmHD37l0Dg4YkSQVuBH7XySzrk56sPGgEAoFA8HaRHYNG2ucNMzMzTExMZIOGUqk0WMxUKpU8fPgwfwcqyBdE+IlA8JZw5MgRmjZtyqtXrwwm2E2aNMHT05PFixcX2NjeBL6+voSFhbF9+/ZslU97vWJjY4mMjKRYsWLZqn/48GGGDx8uv9Zb5fXeCZlZ6QXZRy/CpVQq0Wq1KJXKLLNuKJVKihYtilar5fnz5/J7Id4PQ/ShKB4eHpQpU4a//vor05S4arWahIQEuW5MTEyG11Tc/wKBQCAQGHqt2tvbExsbi7+/f57bvd2ndZ7byC3lN+wusL5fF8JTQyAQFArMzc2zbdAA+PbbbwFo3bo133zzDc7OzsC/3gk6nS5T0U9j5EWss7Di6OhIcnKyvPqR3TSioaGhREZG4uHhkS5nfGEnO/eRJElMmTKFxo0bc+fOHf744w+qVKmSZZ3KlSujUqmIjo5GqVRmWDYn6YAFAoFAICgspPV+1D9/lCtXDqVSaTQdfG5QKKUC2wojwqghEOQTTZo0YdSoUYwaNQobGxuKFi3K9OnT5S/D9evX4+3tjZWVFU5OTvTu3ZunT58CcP/+fZo2bQqkZGmQJAlfX1+5ba1Wy+TJk7G3t8fJyQk/P79sj0uSJH766Sfatm2LhYUFFStW5NSpU9y5c4cmTZpgaWnJe++9R1BQkFwnKCiIDh064OjoiEajoVatWhw4cEA+fvPmTSwsLNi4caO8b8uWLZibm8vaAJmRnJzM+PHjsbW1pUiRIkyePNlorvC5c+dSpkwZzM3NqV69Or/++muGbaYNP/Hz88PT05NVq1ZRunRpSpQogYeHh7xdvXpVvj7vv/9+Og8RSZKEy3k+oHfTjIiIQKvVZpgZIjV6JXJra+s8pa19F3PIS5KUrawrqTPW6O/Tq1evZmiokCSJjh07cv36dTkMJ3U4Tloy8/gQCAQCgaAw4u3tLf/+6Re29M+nLi4uPHv2LMcLXoI3gzBqCAT5yNq1a1GpVJw9e5YlS5awaNEiVqxYAaRMEj777DMuX77M9u3buX//vmy4KFWqFL/99hsAgYGBhISEsGTJEoN2LS0tOXPmDPPmzWP27Nk5Ul7+7LPP6NevH/7+/lSoUIHevXszbNgwpk2bxvnz59HpdIwaNUouHxUVRevWrTl48CCXLl2iZcuWtGvXTk51WqFCBRYsWMCHH35IcHAwjx49Yvjw4Xz11VdUqlQpy/EsXLiQNWvWsGrVKk6cOMHLly/5/fffDcrMnTuXdevW8eOPP3L9+nXGjRvHBx98kCPdiqCgIPbs2cNff/3FV199RUhICE5OTlSqVEleDd+0aRNVq1aldu3aBnV1Oh3379/Pdl/6Ov8lvL29GTx4MKVLl0atVme5ul+1alW6detmoIWRGU+fPuX27du5Hp9erPRdQqfTZcuYtnfvXj777DODfUlJSRkagXQ6HZs3b0aSJFxcXGjTpk2+iZ0JBAKBQFAYOH/+vPz/zZs3DY4dOnQIgL///hsPDw/atGmTp75EStf8RWhqCAT5RJMmTXj69CnXr1+XJ8xTp05l586dRr0Xzp8/T61atYiMjESj0WSqqZGcnMzx48flfbVr18bHxyeTzBz/IkkSn376qTwBOn36NPXq1WPlypUMHDgQSJnYDxgwIFN1/ypVqjB8+HAD40fbtm2JiIhArVajVCr566+/suU6X7x4ccaNG8ekSZOAlMlYmTJlqFmzJtu3byc+Ph57e3sOHDhAvXr15HqDBw8mJiaGjRs3prtea9asYezYsbJwqJ+fH/Pnz+fJkyeyuGvLli0JDAxk+fLljBw5Um7X0tKSjz76KN31nDNnDp988sl/zliRXSpVqkRAQADlypWjbt26/PzzzxkX1oFbeTeCgoLQ6XTUrVuX06dPAykaGukm47qUH3xx7Y2TW82LTp068ffffxMaGkrz5s3zJS2dQCAQCASFGQsLC4oUKYK9vT1ubm4cPHiQDz74gI8++ijXbd71bZuPI8wZZdf8WWB9vy5E0KxAkI/UrVvXYFJfr149Fi5cSHJyMv7+/vj5+XH58mVevXolazcEBwdn6d1QrVo1g9fOzs5y6Ep2SF1fr+JctWpVg31xcXFERERgbW1NVFQUfn5+7Nq1i5CQEJKSkoiNjZU9NfSsWrUKd3d3FAqFgTEnM8LDwwkJCTFI56tSqfD29pYnaXfu3CEmJobmzZsb1E1ISMDLyyvb5+3q6oqVlRU7d+5k5syZxMXFYWpqKk+g9ZNpa2trLC0t09X38/OTx6TT6eSJpNDOSEFvrLtz5w7Pnj3D1NQ0Y80MKaWcnoCAALl8Zt4FAuOkTT+bXVJ7RB07diw/hyQQCAQCwTuHnZ2dnN49taB2kSJFePHiBQC2trYolUqSkpJ48OAB4eHh1KxZM0/9ipSu+YswaggEb4C4uDhatGhBixYt2LBhAw4ODgQHB9OiRQv5yzMz0ooWSZKUo3SbqevrJ+TG9unbnDhxIvv372fBggW4ublhbm5O165d04318uXLREdHo1AoCAkJkcU280pUVBQAu3btSqeLkB29AT36c/Tx8aF69epMnjyZyMhIOXWnfjIdEhLC9OnTDeqq1WoDzQH9NRIGjX/x9vbG09OTffv28eTJkyzvSW9vb8qVK8eePXuynpCLy5wpuTFoQMr9W7p0aapUqcLZs2d59uxZPo9MIBAIBIJ3B71BAzB4zk39TPPPP/+kqzdkyBCuX7/+egcnyDbCRCQQ5CNnzpwxeH369GnKly/PzZs3efHiBV9++SUNGzakQoUK6Twt1Go1QJ6EEfOLkydP4uvrS6dOnahatSpOTk7p9CVevnyJr68vn3zyCb6+vvTp0yfT8BU9NjY2ODs7G1yrpKQkLly4IL+uVKkSpqamBAcH4+bmZrDpDRI5QaPR4OLigrm5OWq1mooVKxoIKioUCsaOHWtQJyEhQQ6PERgnJiaGlStXolar6d69e6bCkwBhYWFs2bKFiIgI6tatK+/PLAuHIH+pWrUqcXFx7Nq1C09Pz4IejkAgEAgEBUpGemCpjR3FixdHrVbz+++/o1AosLCwYPjw4W9qiIJsIDw1BIJ8JDg4mPHjxzNs2DAuXrzIN998w8KFC2UhxW+++Ybhw4dz7dq1dCJ/Li4uSJLEn3/+SevWrTE3N0ej0RTIeZQvX55t27bRrl07JEli+vTp6Vbhhw8fTqlSpfj000+Jj4/Hy8uLiRMn8t1332XZ/pgxY/jyyy8pX748FSpUYNGiRbIWBoCVlRUTJ05k3LhxaLVaGjRoQHh4OCdPnsTa2pr+/fvn+Jx27tzJmTNn0Ol01KhRA29vb9mwolarWbx4cbo6X331VY77+S8hh5/czkb4CTkPPxHkP1euXJH/F+EnAoFAIPgvI0lSlgsyCoUChUKBVqvlyJEjmJmZERsbS+fOnfPWdyEV7CwohKeGQJCP9OvXj9jYWGrXrs3IkSMZM2YMQ4cOxcHBgTVr1rB161YqVarEl19+yYIFCwzqlihRglmzZjF16lQcHR0NBDnfNIsWLcLOzo733nuPdu3a0aJFC2rUqCEfX7duHbt372b9+vWoVCosLS35+eefWb58OXv27Mmy/QkTJtC3b1/69+9PvXr1sLKyolOnTgZlPvvsM6ZPn87cuXOpWLEiLVu2ZNeuXZQpUyZX5+Tj40O1atUoW7Ys27dvZ/DgwfKxuLg4LC0t8fPzo06dOtjb26NSqeTwlcxCTiwtLWnWrBlOTk6o1ep0oULGMFamdu3a2Nvbo1QqsxXiolKp5B/azMpkF0tLS0xMTKhSpQpz5swx0FzJCoVSQVRUFM7Ozvz0008EBgYapDxTKBTpzik8PFw2gKhUKlQqFY6Ojjg4OCBJEr179+bgwYNcuXKFgQMHGr1mqcscOnSI0aNHY2ZmluE4VSoVJUqUkN9fY7nmFQqFvCJT2MnMAPVfZvTo0Rw7doyhQ4dmK9ytSpUqfP/99/Tv3z9bn3+BQCAQvB1kR7tLq9Xy6NEjkpKSWLJkCSYmJrz33nvvZNr4vPDdd9/h6uqKmZkZderU4ezZs5mWX7x4MR4eHpibm1OqVCnGjRuXrexuuUVkPxEI8okmTZrg6elpdMVf8PZx4cIFevfujZOTE6VLl2bBggX89ttvrFy5Ent7e4KDg/Hw8OCff/4hMjIyw3ZsbGwIDw/H3d2dKVOmMGjQoAzLZuTJUKtWLQICAtBoNDx58gRJktBoNJn2azRjSC6RJIlZs2Zx7Ngxzpw5Q2JiItu3b6d37968fPkyW22YmZlRq1YtTp06xbFjx+jUqROhoaHp+tHpdKDjX80MXYpRpHbt2pw+fRozMzPatWvHjBkzmDlzJidPnuT58+d8/PHHLFiwQA5xatWqFfPmzWPmzJlYWlri6enJ5MmT5Wvi4uJCcHCw/MDi6elJ5cqV2bhxIwqFAisrKzQaDY8ePcrwnKysrDJ9D95pUr8HApkhQ4YwdOhQevbsyd27dzExMaFGjRpyph5jmJmZ4eXlxenTpzN9QNav9AkEAoHg7UCSpCyFty0tLYmOjjYQi1+0aBGtW7fOU98PhnbMU/284LJse47Kb968mX79+vHjjz9Sp04dFi9ezNatWwkMDKRYsWLpym/cuJGBAweyatUq3nvvPW7duoWvry89e/Zk0aJF+XQWhghPDYFA8J9g586deHl5yZt+8vvq1SsePXpEo0aNWL9+PRUrVpSzvISGhhIVFZWpx4P+h/DWrVt8++23Bh4KaUlr0NCnmg0KCqJChQo8efIESPEoiI+Pz9RbIq1BIy8Cpu+//z6JiYkcOHCAyMhI4uLi2LZtG126dDFaXqFQ4OPjY7AvISGB4sWLk5SUxG+//UaVKlVkrwmFQsH//ve/f8eYeqhSyiqIftJobW1N37592bJlC9u2bSM0NJTk5GSaN29uEI41YMAAuczjx4/57rvvsLa2lvvs0aMH1tbWcnk7Ozv+/PNPdDodycnJaDQa3NzcMr1umXl9vPMIg4ZR+vXrx/fffy+nHtbpdNy5c4fy5ctnWCcuLo5Tp06h0+kwNzfP0HtKGDQEAoHg7UKn02UpvD1mzBi5rJOTEzY2NjRr1uxNDO+1ER8fT0REhMGWmffmokWLGDJkCAMGDKBSpUr8+OOPWFhYsGrVKqPl//77b+rXr0/v3r1xdXXl/fffp1evXll6d+QF4akhEOQTBeGpsWHDBoYNG2b0mIuLS4GpMmemBbJnzx4aNmz4BkeTQlRUlJyaC1K+0Nu1aye/1lvgnZycZOOCIO+o1WqSk5NRKpVotVqUSmWWYQ9KpZKiRYui1Wp5/vy5QTrd/OR1tPkmsbS0JCEhAQ8PD8qUKcNff/1FYmJihuVTp6qztLQkJiYmw/N/16+NQCAQCASvg/fff59vvvkmz+0UpKfG6uKezJo1y2DfzJkz8fPzS1c2ISEBCwsLfv31Vzp27Cjv79+/P2FhYezYsSNdnY0bN/Lhhx+yb98+ateuzd27d2nTpg19+/bl448/zu/TAYRQqECQbxw5cuSN99m+fXvq1Klj9FhBxnb7+/tneKygYhA1Go2BsWX8+PEA1KhRgwEDBjBr1iyeP39uYNCoXr06ly9fznYfwr0c0IHGSkNiYiLx8fE4Ojry8OFDLC0tSUxMzDxDTqqQiNDQUMzMzPDw8ODmzZs5mmBbWFgQExOTaRkTE5NMDQBvO5IkMWXKFI4dO8aJEye4du0aXl5eXLp0KdM6lStXJjAwkOjoaFQqVYYCaSqV6p2+PgKBQCAQ5JTMnuP0IcT5lTlMykQT7XUzbdo0+TlYT0YaUs+fPyc5ORlHR0eD/Y6Ojty8edNond69e/P8+XMaNGiATqcjKSmJ4cOHvzaDBojwE4HgreDIkSNIkmSQASQ7WFlZpUt56ubmxqNHj3B1dc1xe/mFsTHpN2PijG8KPz8/PD090el07NmzB0mSCAgIYPLkyQwcOBBAdh2XJCnH8ZLv8sp2ZoKjOSovpRiQ9EKbDx8+BCAiIgKtVpt5P/9v0NA/UFhbW8sT69T1JEnKNA1sZgYNfRjBuz5hTx0ypBfeunr1aobXRZIkOnbsyPXr12VDRmaK7+/69REIBAKBICtSh6kCmJub4+LiYrBP//yh0+mws7Pj4MGDb2x8rwtTU1Osra0NtuwIY2eXI0eOMGfOHL7//nsuXrzItm3b2LVrV7rMj/mJMGoICiW+vr4GLlLZ5fLly7Rv355ixYphZmaGq6srPXr04OnTp/k/yFS89957hISEYGNj81r7eZ1IksT27dvzpS29kUe/OTo60qVLF+7evZsv47l37x5arZZBgwZhbm5ObGws8+bNA/798XJ1dZX3ZZd32aiRUw+TzMo/efLEqMBmfHx8tvrRX8enT58SFhaGra2tQTYavS5Gbrh9+3au6r1t7N27N93DQVJSUobXRafTsXnz5jcxNIFAIBAI3gkiIiIMXkdHR/PgwQODffrnloSEBJRKJUFBQfnSt6SQCmzLCUWLFkWpVKYTfw8NDcXJyclonenTp9O3b18GDx5M1apV6dSpE3PmzGHu3LmvzaNZGDUEgv/n2bNn/O9//8Pe3p69e/cSEBDA6tWrKV68ONHR0a+1b7VajZOTU57EHgsjgYGB/PPPP2zdupXr16/Trl27fMn4oTeO/P3337x8+ZKhQ4fKsYX61ev79+/z6aefpqubkaeBeO/yH0mSePnyJTExMXTr1k14DwgEAoFAIHht2Nrayp67adFnTYuIiEg3wS/MqNVqatasaeChotVqOXjwIPXq1TNaJyYmJt3zst6T9HUtAAqjhkDw/5w8eZLw8HBWrFiBl5cXZcqUoWnTpnz99deUKVNGLnft2jVatWqFRqPB0dGRvn378vz5c/l4kyZN+Oijjxg7dix2dnY4OjqyfPlyoqOjGTBggBwysmfPHrmOsfCTkydP0qRJEywsLLCzs6NFixa8evUKSFnxHj16tOxR0qBBA86dO5fp+f32229UrlwZU1NTXF1dWbhwocFxV1dX5syZw8CBA7GysqJ06dIsW7YsV9fy/v37SJLEtm3baNq0KRYWFlSvXp1Tp07lqJ1ixYrh7OxMo0aNmDFjBjdu3ODOnTucO3eO5s2bU7RoUWxsbGjcuDEXL140OBeATp06IUkSZcuWxcvLi61btxIbG8uhQ4cAuH79OtbW1gwdOpSmTZsa9K3T6Zg9e3a6MWVsYS7cRo3Mwj1eF/rsEwkJCezcuTNfXSMFAoFAIBAIUqNQKNi0aRMKhSJdBjQzMzMePHiAiYlJjp9njSEpFAW25ZTx48ezfPly1q5dS0BAACNGjJDnNZCSOWzatGly+Xbt2vHDDz+wadMm7t27x/79+5k+fTrt2rV7bc+TwqghEPw/Tk5OJCUl8fvvv2doRQwLC8PHxwcvLy/Onz/PX3/9RWhoKN27dzcot3btWooWLcrZs2f56KOPGDFiBN26deO9997j4sWLvP/++/Tt2zfD2H9/f3/+97//UalSJU6dOsWJEycMvBQmT57Mb7/9xtq1a7l48SJubm60aNGCly9fGm3vwoULdO/enZ49e3L16lX8/PyYPn06a9asMSi3cOFCvL29uXTpEh9++CEjRowgMDAwh1fyXz755BMmTpyIv78/7u7u9OrVK9M4/szQa3EkJCQQGRlJ//79OXHiBKdPn6Z8+fK0bt1aDnnQG3hWr15NSEgIhw8fZvv27bRs2ZLQ0FBZyFSSJF69eoW3tzeNGjVK12dOrMk6XeEWCM0PD5m8EBsbKwtVOTg4CM8YgUAgEAgE+YreO1Sr1cp6VXqePXuGTqfLMoNbYaRHjx4sWLCAGTNm4Onpib+/P3/99ZcsHhocHExISIhc/tNPP2XChAl8+umnVKpUiUGDBtGiRQt++umn1zZGkdJVUCjx9fUlLCwsxxoPn3zyCfPmzcPa2pratWvj4+NDv3795A/t559/zvHjx9m7d69c59GjR5QqVYrAwEDc3d1p0qQJycnJHD9+HEiZDNrY2NC5c2fWrVsHpGgOODs7c+rUKerWrcuRI0do2rQpr169wtbWlt69exMcHMyJEyfSjTE6Oho7OzvWrFlD7969gRRRP1dXV8aOHcukSZPStdenTx+ePXvGvn375HYmT57Mrl275LSvrq6uNGzYkPXr1wP/5uOeNWsWw4cPz/LaSZLE77//TseOHbl//z5lypRhxYoVDBo0CIAbN25QuXJlAgICqFChQqZtpR1/SEgIXbt25cGDB9y9e1cWodSj1WqxtbVl48aNtG3bNt149Pj5+TF//nxCQkKoU6eO7HVhamrKrFmzmDp1qsH5TJ48ma+++irLcxe8ZnSgUCqoXbs2p0+fxszMDHNzc9lzSSAQCAQCgSA3KJXKLBduJEnCwcGBhIQEwsLCmDJlSoZhKtnl0ahueaqfF0p+u7XA+n5dCE8NgSAVX3zxBU+ePOHHH3+kcuXK/Pjjj1SoUIGrV68CKUKihw8fltODajQaeYKeWjioWrVq8v9KpZIiRYpQtWpVeZ/eSJKRAKneU8MYQUFBJCYmUr9+fXmfiYkJtWvXJiAgwGidgIAAg/IA9evX5/bt2wZf5KnHLUkSTk5OeRJJTd2es7MzkPE5G6NkyZJYWlrKuia//fYbarWa0NBQhgwZQvny5bGxscHa2pqoqCiCg4MzbMvPz49ffvmFkiVLUqtWLdzd3YGU9J9RUVEsXbrUoLxOp2PRokUGr/U2YGELzj6SlA8/M1KK4er06dNAilq5vb193tsVCAQCgUDwnyb1c7AkSZiZmaHRaAzKSJLE8+fPCQsLw83NjRs3buS9Y0kquK0QIowaAkEaihQpQrdu3ViwYAEBAQEUL16cBQsWABAVFUW7du3w9/c32G7fvm0QvqDP0qBHkiSDfXrX+Yz0GQoq7amxcedFpTgn52yM48ePc+XKFSIiIvD396dOnToA9O/fH39/f5YsWcLff/+Nv78/RYoUISEhIcO2hg8fLqfpMjExkcVfY2JiUKlURERE0KVLF4M6qYUp9ZlYUp+LIGteR1jO06dPiY+Px9fXlxIlSoj3QyAQCAQCQZ7R6XTExcURFRVlsF+r1aLVajE1NeXly5dGQ5YFBYswaggEmaBWqylXrpw8Aa5RowbXr1/H1dUVNzc3g83S0jLf+q1WrVqGebDLlSuHWq3m5MmT8r7ExETOnTtHpUqVjNapWLGiQXlIESJ1d3cvEAHI7FKmTBnKlSuHlZWVwf6TJ08yevRoWrduLYufphZrhRTDRWrr+86dO/nnn39Qq9X8+uuvWFhYACleMwkJCXz22Wfs3LkzXRupMZb5xNTcOt0+wWtElyIg++jRI9asWcN7771X0CMSCAQCgUDwjqN/LswM/YJK+/bt89zfu5LS9V1BGDUEhZbw8PB0HhUPHz7MsPyff/7JBx98wJ9//smtW7cIDAxkwYIF7N69mw4dOgAwcuRIXr58Sa9evTh37hxBQUHs3buXAQMG5KuQ4rRp0zh37hwffvghV65c4ebNm/zwww88f/4cS0tLRowYwaRJk/jrr7+4ceMGQ4YMISYmRtavSMuECRM4ePAgn332Gbdu3WLt2rV8++23TJw4Md/G/CYpX74869evJyAggDNnztCnT5903i2urq4cPHiQJ0+e8PLlS7777jsSExNJSEigQ4cOtGnTBkjJs61UKlm8eHE6A09ar5J0niwKJfGx/+Y4L2pvm49nKTCKhIEB68yZMxQvXrwAByQQCAQCgeBdRe/tGRMTQ+PGjalcuXKGZTt27MhPP/3Epk2b3tTwBNlEGDUEhZYjR47g5eVlsM2aNSvD8pUqVcLCwoIJEybg6elJ3bp12bJlCytWrKBv374AFC9enJMnT5KcnMz7779P1apVGTt2LLa2tkZX8XOLu7s7+/bt4/Lly9SuXZt69eqxY8cOVCoVAF9++SVdunShb9++1KhRgzt37rB3717s7OyMtlejRg22bNnCpk2bqFKlCjNmzGD27Nn4+vrm25jfJCtXruTVq1fUqFGDvn37yultU7Nw4UL2799PqVKlqFGjBnFxcXh7e6NWq1m9ejXlypUDUrxxlEolDx48QJIk2bAhSRLJycn069ePcePGYWZmlk7xWqc1NGQ9fxmW63MyNzdHoVBk+z7KTshFfoRl9O7dm4MHD3LlyhUGDhyYzrCTFmdnZ1asWEHDhg2xtLRErVZTp04dunTpYnBuKpUqnXeTpaUldnZ2mJiYYGVllS6F66xZs/D29jbQNAkODsbExISffvpJFuvNiCJFimBvby/CVQSZYmFhgYmJCSVKlEjnJWaM1Pd1fv4OGGP06NEcP34cf39/2rdvL/eXeszGYsErV67MggULKFKkSLpxZvR5UKlU6USZBQKBoLCR+pni6NGjsoC+MbZv3050dHSm8wlBwSCynwgEgkLPxYsX6dWrF8ePH5eNH1qtlooVK1KsWDF+/fVXGjVqRIcOHdixYwcANWvW5Pnz50RERMhZNry8vFAoFFy4cAEApYkZ2uRE2bghSRI2NjaEhYXJfdvZ2WWZpUOtVtOsWTP27NmDTqfDwsKCcuXKyQK1GWFlZSWnsTXG+++/z5UrV3jy5EnmFygDWrVqxbx585g5cyYnT57k+fPnfPzxx8ydO9doat7atWtjYWHByZMnZaFVSZKYNWsWz58/R6lUolariY2NNajn6uqKubk5N2/eRKFQoNFoiIuLIz4+HhMTEwNtE0iZbOn7VyqVlC9fnjt37jBjxgxmzpyZTshVkiRsbW159eoVlpaWxMTECLFXgVHUajVz5sxh8eLFPHr0CCsrK3x8fOTvhYwoWbIkjx49yrSMJEkG913a11kxZMgQhg4dytSpU7l8+TLR0dHUr1+fY8eOGYxZrVaj1WpJSkpCpVLh6OhISEgIdnZ2JCcny99PpUqVytR7UU/qz5tAIBAUdkxMTOTvvLTf0S4uLjx8+BArKyvOnj2bp37+GdcrT/XzQvGvfymwvl8XwlNDIBAUOnbu3GngoWPsgVyhUFC0aFGePn3K8uXL5Xr6VUt/f39+/PFHA4NEeHg4K1eulFcvtUkJBt4aGitrA4MGQEREBFkxaNAgDh8+LP94xsTEpPNsMIbeoJFRubp16+baoAEwYMAAtmzZwrZt2wgNDSU5OZlmzZplKPYaHR1Nt27dSExMpGfPnjx79oxHjx7JK8c1atTggw8+MKhjZWWFn58f4eHhNG3alOTkZMLDw4mPj0epVBr1DNG/nwqFguTkZG7evElSUhLff/+97M2UGp1OJ7+P+pTIAoExBg8ezPXr12UDRWRkJIcOHaJ8+fKZ1tOXVygURu9BDw+PdPtyaljr168fP/zwAwcPHuT58+ckJSXh7+/P8OHDDcackJAgG/uSkpJ4/PgxWq2WV69eGYjfZcegARh8f+ozAwgEAkFhRb+QYmJiYhCWbGZmxoMHD9BqtbRs2bKghifIAOGpIfjPsGHDBoYNG2b0mIuLS6buZv915syZw5w5c4wea9iwIXv27MlRe61ateL48eNGj3388cd8/PHHOR5jaqKionjx4oX8OiEhgbZt27J9+3YqVqwo7+/Tpw/BwcEZppk15iVga2tLREREnrLCvKuYmZmRnJxMsWLFiIyMJDIyMsOJWaNGjThz5owcsmNsVfp1rACbm5sTHx+PVqtFoVCke5+yk49eIBAIBAKBwBgqlYpZs2bRtWvXPLUTMqF3Po0o5zgv3Fhgfb8u0i8nCASFlPbt28spQdOSlU7Af53hw4fTvXt3o8dyk352xYoV6UIQ9Njb2+e4vbRoNBqDuHKdToeDgwOnTp2SjRpRUVFcuXKF7t27s2HDBlQqFYmJiQaT3jJlynDr1i25HU9PT65cufKfNGioVCq++uorli5dSlBQEJaWlqxatYohQ4YYNUwcO3YM+NeNU2/QSG1o0P9NazxSq9WZpufNCHNzc/m+mjdvHrNnzzZMy6b7Nx+9ubk55ubmvHz5Msf9CAQCgUAgKHxIkoSdnR0xMTHExcUBULRoUQOB8l69evHFF19gb2+Pj49PQQ1VkAYRfiL4z2BlZZUuDat+c3FxKejh5Qs6nY6hQ4fKYoi2traMHTtWPu7q6srixYtz3K69vX2G165EiRI5bq9EiRJG2xo8eDCzZ8/Odjtr1qzB1tZWfu3n54enp2e6cpIkGbhuBwYG0q9fPxITE/n555/R6XRy5piBAweiUCiQJCmde6G/vz+Ojo5vTGjydYsO5oSqVavy7NkzgoKCgJQwjvv371OyZMkM6+gNRak9NFL/rzdq6A0aemHQ1O9pRhi7NqkNZaGhodSqVSvD+rGxsezbty/LfgSCgkAvopsbo7FAIBAIcodOpyMyMlI2aDg5ORkYNCwtLWnfvj1du3aVQ5dzi6RQFNhWGBHhJwJBIWLPnj106NCBI0eOULZsWRQKBebm5rKCv6urK2PHjjUwdLxNNGnSBE9Pz2wbXtasWcPYsWNlHYuoqCji4+Nlhf/U6HQ6li5dyubNm3n16pXskaGfWOtfOzs74+fnR926dQkODmbUqFE8ePAgW+MxFq4iKBj03ldVq1bFw8ODTZs2pQt/sbKyYuLEifj4+LB//37mzZsnP8gICh4nJydatmzJvn37ePr0KQqFIlcePAKBQCAQ5Cf16tXj/PnzXLp0Kdfe3k8mfZB1odeE0/yfC6zv10XhNNUIBP9RgoKCcHZ25r333sPJyYlixYplKyVhYUGj0Rg1aECKt8aYMWPw9fXF0tKSvn37Gqz2m5ubY2JigpeXFyNHjqRz585ERESwcuVKA6GozLw0sjJo6Ou+TR4YOeF1eajke7u6lFCh/v37c/PmTX755Zf02h+6FMPHwoULGTZsGHPnzqVMmTL5Ow5BrnF2dubFixesWbOG5ORkpk2bRrNmzTKtkzYFcHY8fmrUqJGXYQoEAoHgHcfCwiLTY6l/W5ydnRk7diynT58mMTExy+x2gjfHu/lkLRAI0uHr68tHH31EcHAwkiTh6upKkyZNMvXKCAsLY/DgwTg4OGBtbY2Pjw+XL1/OVn/6UI/169fj6uqKjY0NPXv2zDTFaGqio6Pp168fGo0GZ2dnFi5cmK5MfHw8EydOpESJElhaWlKnTh2OHDmS5Zj0+Pr60rFjR+bMmYOjoyO2trYsXbqU2NhYVq1aZWCEiIqKwsbGhtDQUJKSkrh37x7Dhg2jWLFi6fQ5coNKpZLrajSabE243jbSZg3Ru8jnlXw3akhw7tw5VqxYQUxMDICcsSZ1mZcvXxIREcGNGzfo3r07xYsXz99xCHJN6s9naGgoX3/9NXPmzElnuEiNXpRWT1bGQ0tLyzwLvQkEAoHg3SYjLTdJkoiNjTUIAwwJCWHDhg1UrlwZyNsilaSQCmwrjAijhkBQSFiyZAmzZ8+mZMmShISEcO7cuSzrdOvWjadPn7Jnzx4uXLhAjRo1+N///pdt8cSgoCC2b9/On3/+yZ9//snRo0f58ssvs1V30qRJHD16lB07drBv3z6OHDnCxYsXDcqMGjWKU6dOsWnTJq5cuUK3bt1o2bIlt2/fzlYfAIcOHeKff/7h2LFjzJgxg8TEROzs7JAkSRY/TUpKolGjRtSvX18WBtVqtcTFxXHx4kUGDhyY5zSGqcU0IyIi0qV+NTc3R6FQZPsHMjuGgPwwFvTu3ZuDBw9y5coVOnbsaOBmGR0dna68s7MzK1asoGHDhlhaWqJWq6lTp066FLUqlUo2iuhDgCwtLbGzs8PExAQrK6t0E9hZs2bh7e2d7rxcXV356aefCAwMxN3d3eh5JCQkUKRIEVlvJi0bNmzg4MGD2bwqgtdNq1atDF5HRUXh6emZznCRGVl9j0VHRxvNtGRhYYGJiQklSpTIlqdb6vv6dXthjR49muPHj+Pv70/79u3l/lKPObURFlK+BypXrsyCBQtkT7bU48zoe0KlUqU3BgoEAkEhQ58OOy06nQ6dTpfuee3Zs2fcvXsX4D/lDf22I4waAkEhwcbGBisrK5RKJU5OTjg4OGRa/sSJE5w9e5atW7fi7e1N+fLlWbBgAba2tvz666/Z6lOr1bJmzRqqVKlCw4YN6du3b7YmhlFRUaxcuZIFCxbwv//9j6pVq7J27VqDiX9wcDCrV69m69atNGzYkHLlyjFx4kQaNGjA6tWrszU+SLHAL126FA8PD5o0aQIgZ+No2rSpwZgeP35skC2jZs2ajB8/nq+//pq4uDg8PT2pWbNmpv2l9cBI691gDLVaTdOmTdHpdGi1WiwsLKhatWqmdXQ6XZY/ps2bN8fJySnL/jOiVatWTJs2je+++47mzZuzdu1apk6dikplPHFW7dq18fDwYMSIEZw6dYq5c+eycOFCgoKC+O2335AkSV7xSEpKko0irq6uVKxYkZiYGCIiIrCwsCAhIYH4+HgDI8rMmTM5f/68QTiQUqnEzMyMkSNHsnnzZqMGL72a+YsXL3I0KRa8fbxukV61Ws3s2bNxdHTk8ePHAHTo0CHTOlqtVhbMzSwzUtqx5/RchgwZQt++ffHz86NZs2bs378fHx+fdGNOSEiQP6MqlYrixYsTEBDA3Llz5ew/Wq2WUqVKARl7nyUlJRm0JRAIBIWRjBatVCoVZcuWlV/rv7NVKpUsTB4eHp7rfoWnRv4ijBoCwX+Uy5cvExUVRZEiReQUqBqNhnv37skZLrLC1dXVYGLt7OzM06dPs6wXFBREQkKCQYpde3t7PDw85NdXr14lOTkZd3d3g/EdPXo02+N79uwZZmZm1KxZEy8vL9loUr58eYNy9erV49mzZ1y/ft1govHFF1/I8ZI6nY7bt2+zcuXKTFcv01r0IyIishznoEGDOHz4sDy5iImJSefZYAx9qE9G5erWrcuTJ0+y7D8jBgwYwJYtW9i2bRuhoaEkJyfTrFmzDCdu0dHRdOvWjcTERHr27MmzZ8949OiRvHJco0YNPvjAUBjLysoKPz8/wsPDadq0KcnJyYSHhxMfH49SqTQqwKV/HxUKBcnJydy8eZOkpCS+//57oxMwnU4nv4/R0dHZMjQJ3j7UanWuw7+yy+DBg7l+/bq8chcZGcmhQ4fSfWekRV9eoVAYvQdTf7fpyem5pM7g9Pz5c5KSkvD392f48OEGY05ISECpVFK+fHmSkpJ4/PgxWq2WV69eGRhtHz58mK1+UxubJUnKs9eaQCAQvE0YEwjXaDRYW1tTtGhR+vXrZ/D7k5SUJD+bvKsaaYURYX4XCP6jREVF4ezsbFSjIrt6D2knnJIkZbpSmROioqJQKpVcuHDBYGUeSOdenRH29vbodDp++OEHADlzglKpRKlUyg//58+fNzrBaNWqlbxfkiSio6Np0qSJwUN+VuhXRjNDP77U+Pn5ZbuPjK55TtLjGkMfnqPHzMyMZs2a4ezsTGRkJJGRkQbX7fr164wcORJI8bTZunWr7BkhSRLnzp0zCItSqVRERkbi6+sLwD///GPQX3JysqyJYYy05/3kyRPMzc3lrDYKhSJdGaVSme3wKsHbxZvIfPL999+n26e/17ODVqs1+nkMDAzM89gaNmxo8DoxMZHnz5+zdOnSdGXj4+PTeS1lNLacoNPpRIYggUBQ6NEbgM+ePcvZs2cNjikUCho2bMjp06cz1OMQvHmEeUkg+I9So0YNnjx5gkqlws3NzWArWrToa+27XLlymJiYcObMGXnfq1evZD0LAC8vL5KTk3n69Gm68WU3pEKpVKJWq3FxccHFxQU3NzcUCgWvXr2icuXKnD9/HicnJ7RarazfkNpTI3U2DEmSKFGiBJGRkflmuHmXUKlUfPXVV5QuXZrHjx+TnJzMqlWrMnRNP3bsmBw+IkmSbPxIvaqhv45pPV9yFcevS9EliY2NRavVMm/evPSK5rp/jUzm5ubiYUQgEAgEgv8oGT1rWFlZ4ejoKL/+3//+h7m5ubzA1qtXLw4fPkylSpXy5qmhUBTcVggpnGclEAiypFmzZtSrV4+OHTuyb98+7t+/z99//80nn3zC+fPnX2vfGo2GQYMGMWnSJA4dOsS1a9fw9fU1+HFwd3enT58+9OvXj23btnHv3j3Onj3L3Llz2bVrV676lSQJS0tL7ty5g52dHT///DOPHz9GkiS8vLyAFPdzSZKQJImWLVvKdXU6HY8fP6ZEiRKvPa5fz9vk1li1alWePXsmh/5ER0dz//59WUvAGCqVisTERANvjtT/640a+hV4vWEpO55Cxq6NPsYVUjJm1KpVy7CAZFh23759WfYjEBQEehHd1Kr7AoFAIMg/jIW3QopR49mzZ0BK6OCZM2ews7MjOTkZpVLJixcvMDExMXjmEBQ8IvxEIPiPIkkSu3fv5pNPPmHAgAE8e/YMJycnGjVqZGChfl3Mnz+fqKgo2rVrh5WVFRMmTEgnuLR69Wo+//xzJkyYwOPHjylatCh169albdu2ue7XwsIClUrFsWPHDPafPn0agN27d/Pjjz9St25dgoOD2bFjBw8ePECtVpOQkEBwcHCGbZuYmBikic0rb5NHyKVLl7h06ZLBvlmzZmVax1iYTmY6AvpQlezosqS7NmnsTHqX/Bo1auDh4cGmTZvS9d20aVNmzZqFj48P+/fvZ968ecK1/i3CycmJli1bsm/fPp4+fYpCoXgjIShvA3oRXfHQLBAIBK8HYxncwDAUVh86qA9HSU5O5tixY3h6enLx4kUSExMzNI5kxZtaIPuvIOlet+qWQCAQvEUsW7aMZcuW0a1bN9atWydPvDUaDfHx8TRv3px9+/bh4uIiZxRo0aKFHLaQOpQip+jrGtN6eBfIy7m/0XZ1UKt2LapXr87GjRuN63LowL6IPUlJSZQsWZLbt2/j5uZGQEBA/o1DkGucnZ15/vw5iYmJODo6MnToUC5cuMDu3bszrGNqamqQ3cbW1jadcG9aatSokS6VtEAgEAj+O1hYWGSo32VhYUFycrL82+Ls7EyPHj1YsmQJOp2O48ePU6xYsVz1++zTAbkec15x+Dz7WQTfFd4e32aBQCB4zeh0OpYtW0ZcXByrV6828CSIiorCxsaG0NBQkpKSuHfvHsOGDaNYsWIGwqS5nXyrVCq5rkajybYY69tE2qwhehf5vJLvqxUSnDt3jhUrVsgPKuliZyV4+fIlERER3Lhxg+7du1O8ePH8HYcg16xatUr2egoNDeXrr79mzpw5coiSMdKm680qfMvS0pKuXbvmfbACgUAgeGfJSF9LkiRiY2MNwgBDQkLYsGEDlStXBvIWJiwpFAW2FUYK51kJBII8U7lyZYNUqqm3DRs2ZFo3ODg4w7oajSbTEI7XyaNHj4iMjGTRokVIkkT9+vUNjiclJclpEbVaLWq1mgsXLhAREZFuUpyZu2HqSbq3tzeOjo4oFArZOBIREZHlCrK+j7RCnEqlEoVCUSB6G2mzhmTkuplT3oTXSlZhC1u3buXcuXOo1WomTZrEiRMnuHLlCgMHDpSvtUKhoEKFCmzYsIEtW7ZQtWpV1q1bR2BgIIGBgfz5559UqFDB4L1RKpWoVComTZrE1atXmT59OjY2NkbHoFarkSQJhUJhkPEnbfaf/wKtWrUyeB0VFYWnp2c6w0VmZJXlJjo6mo8//jhX4xMIBAJB4UD/3JcWlUrFlClT0oVGr127Vl7ksbKyeu3jE2QPoakhEAiMsnv37gz1IbLS3ChevDj+/v6ZHi8I9MJPJUuWRKvVcurUKSDFc8LS0pKnT58aGCRmz57N7t270el0sleHiYlJlmla9R4Znp6eXL58mapVqxIZGUlUVJRsDMlMe8PMzAylUmnUaGCs79cVFvJfIiEhAa1Wy7Bhw/D19WXmzJkcP35c1nKoWbMm06dPZ+zYsfTt25eJEyeycuVKunfvLsfaRkdHExsbiyRJsr5KcnIyrVq1on///gwbNoxTp04hSRIffvgha9euNXiP9YaXtO+lXpws7XuvN3Dlp46LQCAQCAT/FWxsbIiOjjaqASZJklE9rrCwMPn5MTw8PNfhJ4L8RRg1BAKBUVxcXHJdV58mtqDZuXMnM2fOlF//9NNPBseVSiVarZaKFSsSHR1NRESEgTDfsmXLePHiBTY2NnIqWP0E0szMDLVanam3QlRUFNWrVzfIJmNtbU1ERITR8qamplSpUoULFy5k+xyLFSuWLWFNQdYkJSXRuHFjlEolf/zxh+wV0L59e8aMGcPBgwe5f/8+APPmzaNt27Y0b96c5cuXy21YWVlRvXp1Tpw4Ie8bMGAAe/fulVMY9+zZE19fX7Zs2UJMTEyWBimFQoFOp0tnvEpOTs7SwPau0apVK/bs2VPQwxAIBAJBIUehUKTzwtBjZWWFiYkJxYoVo1GjRmzatEleeBgwYABKpZKkpKQ8hp8IodD8RAiFCgSCQktUVBQvXryQXyckJNC2bVs2btxI7969gZQfNSsrKyRJIj4+PsNsA2lXyjUaDTExMe+k4Kcgc7y9vRk0aBBVqlR5LVlRSpcuTWhoaI5CKd5VRo8eTbdu3bC2tubixYv4+fnx4MGDDMtbWVkxceJEmjZtys8//8yyZcve4GgFAoFAIEjBmIckpDw3jhgxgjVr1nD+/PlcGzZe+A3O6xBzTRG/FQXW9+tCaGoIBIIc866kVdRoNLi4uMibm5sbDg4OBqvobm5uREZGUqVKlUzTJyYnJ1OmTBkgxTsiNjY2U4OGSNX17mJhYUFgYCAjRozg888/Jy4uDgsLC6NlfXx8stVmak2W4OBg2aBRENoob4oBAwbQt29f/Pz86N69O7GxsaxcuTJTjRClUsnChQvx9fVlxYrC99AlEAgEgoJHoVBkKHbeqlUrnJycaNOmDVWrVjX4nZYkiUOHDnH27FmaNm2at99whaLgtkJI4TwrgeA/RHR0NP369UOj0eDs7MzChQtp0qQJY8eOBVK+gLdv325Qx9bWljVr1sivHz58SPfu3bG1tcXe3p4OHTrIbvYAvr6+dOzYkS+++ILixYvj4eHB7NmzqVKlSrrxeHp6Mn369CzHrW9zwYIFODs7U6RIEUaOHJktfYCPP/6YOnXqpNtfvXp1Zs+eDaRkv2jevDlFixbFxsaG2rVrU716dcLCwvj+++/lOo8fP0ar1XL8+HHg30mmMTHHe/fuAfD06dNs62oI3h30hihLS0sWL17MtWvXUKlUqNVqYmNj8fLySicYe/bs2Szb1QuAGmPChAnpM7NkMK53jdKlS/PDDz9w8OBBAgMDmTx5Mg4ODpkaNcLCwoiIiODu3btotVqcnJyMlsssC4pAIBAIBJlhbW2d4QKdVqvF1NQUJycnHj9+bCAMX6FCBebNm8ft27cZN27cmxquIBsIo4ZA8I4zadIkjh49yo4dO9i3bx9Hjhzh4sWL2a6fmJhIixYtsLKy4vjx45w8eRKNRkPLli0NvvD1E5P9+/fz559/MnDgQAICAjh37pxc5tKlS1y5coUBA7KXe/vw4cMEBQVx+PBh1q5dy5o1awyMLRnRp08fzp49S1BQkLzv+vXrXLlyRQ4riYyMpH///pw4cYLTp09TqVIlnj9/zubNm+nZs6dcTy/yqJ846r0v0sZZ6kUZBYUXvSHq2bNn/PDDDxw/fpypU6fKmhaXLl1K9xCkv38yIyEhwSDUpHTp0vKkfP78+Vl6Pr2rBrJZs2ah0Wg4fvw4ly9f5ptvvqF9+/aZnq+VlRWzZs3i2LFjDB06lCdPnhgt918I3REIBALB6yEsLCzDRbS9e/fy4MEDli1bxsuXLw1+bwICAtizZw+//PILJUuWfFPDFWQD8YQuELzDREVFsXLlShYsWMD//vc/qlatytq1a42qOGfE5s2b0Wq1rFixgqpVq1KxYkVWr15NcHAwR44ckctZWlqyYsUKKleuTOXKlSlZsiQtWrRg9erVcpnVq1fTuHFjypYtm62+7ezs+Pbbb6lQoQJt27alTZs2HDx4MMt6lStXpnr16mzcuFHet2HDBurUqSMLlPr4+PDBBx9QoUIFKlasyKpVq4iKiuLevXvMmjWLatWqySKh27Zty7LP5ORkzMzMqFSpklglLuQYCz/JLIVvdkidmleEn4jwE4FAIBC8XZQqVcrgN9nU1DSd4cLDwwNzc/MMQ1JzgqSQCmwrjBTepymB4D9AUFAQCQkJBqEY9vb2eHh4ZLuNy5cvc+fOHaysrNBoNGg0Guzt7YmLizPwhKhatWo6N/khQ4bwyy+/EBcXR0JCAhs3bmTgwIHZ7rty5coGExxnZ+dsZ/Lo06ePbNTQ6XT88ssv9OnTRz4eGhrKkCFDKF++PDY2NlhbWxMVFUVwcDCQMuGSJImgoCB2794t19MbLIy5vcfExBAQEGCw0qzIZIImeDc5duxYuvCTxMREvLy8cm3QyqjehAkTCoWRzFiIjAg/EQgEAsHbiDGjRGrxd0mSSExMJDY21uD3pkOHDlhbWwuj+1uISOkqEBRy0qaBBAxc7qKioqhZsyYbNmxIV9fBwUH+35igUrt27TA1NeX333+XJ35du3bN9tjSrn5LkpTtbCK9evViypQpXLx4kdjYWB4+fEiPHj3k4/379+fFixcsWbIEFxcXTE1NqVevnmyQaN26NX369MHZ2dngx6lMmTLcvHkzQ7f3tNdSW8hSagoMSW3AunXrFmPHjqVt27YUK1aMdu3acevWrWy1k1Hq3/nz58v/Z6S0/i5gLERm1qxZBq/1KY5zggg/EQgEAkF+ExMTk25f6mx5Op0OnU5nsA9S0rlDSvj0p59+mqcxSJLwLchPxNUUCN5hypUrh4mJCWfOnJH3vXr1ymCi5eDgQEhIiPz69u3bBl/mNWrU4Pbt2xQrVgw3NzeDzZhYZmpUKhX9+/dn9erVrF69mp49e2Jubp6PZ5gxJUuWpHHjxmzYsIENGzbQvHlzihUrJh8/efIko0ePpnXr1lSuXBlTU1OeP39u0IYkSZiYmDB16lR5382bNwEoUqSIvC+1Qad58+ZGxyMp0q4+F073vv8ydnZ2LF68mE8++YTdu3dz+/btfGnX2toaeHe1M14nhTk8RyAQCARvD6mfIfW0bt3awGPQ3d0dSZKoV6/emxyaIBuIpwWB4B1Go9EwaNAgJk2axKFDh7h27Rq+vr4GEwEfHx++/fZbLl26xPnz5xk+fLiBh0SfPn0oWrQoHTp04Pjx49y7d48jR44wevRoHj16lOUYBg8ezKFDh/jrr79yFHqSH/Tp04dNmzaxdetWg9ATgPLly7N+/XoCAgI4c+YMffr0MTC46HQ67Ozs8PHxoXbt2unaTm2dT20EOnjwoFGvFZ027Qq7mKAWNp48eUJ8fDzHjh1j9erVlChRIs9tqtVqIiIigHc3y0laMkqTlxuy67klEAgEAkFu0Wg09O3bN91+Ozs7vL29DcrpdLpMwygFBYMwaggE7zjz58+nYcOGtGvXjmbNmtGgQQNq1qwpH1+4cCGlSpWiYcOG9O7dm4kTJxrEElpYWHDs2DFKly5N586dqVixIoMGDSIuLk5eQc6M8uXL895771GhQgWjaVZfJ127duXFixfExMTQsWNHg2MrV67k1atX1KhRg759+zJ69GgDK/x3332HSqVi7969zJgxI9N+Uq+ga7Va4uLi8vU8BK+X3r17c/DgQa5cucKWLVuoWrVqpuUlScLNzY2tW7cyY8YM2WNJq9VSoUIFNmzYwJdffslXX33F8ePHCQwM5O+//07XviRJsoFRkiSKFClC69at5fYkSaJ06dJs3bqVjz76KJ2nhiRJFC1aNL8vx2sno1AbgUAgEAjeRqKioli4cGG6/Rs2bODPP/+UX1+8eBFzc3MePnyY904VUsFthRBJJ/xdBYJCR5MmTfD09GTx4sWvvS+dTkf58uX58MMPGT9+/GvvLz/YvXs3kyZNIikpiXXr1vHnn3+yZcsWICUUID4+PtOY/dTaB+aWdsRGv3oj4xbknFatWjFv3jxmzpzJ5cuX6d+/Py1btqRly5a8fPnSaB0TExMD3RmlUsn777/PsGHDGDt2LI8ePeKrr76iefPmbN++nR49erBu3To2bdrEoEGDadbsf/Tu3Zt79+7J94mNjQ1RUVHyawsLC8zNzXn58iVqtVq+34oVK8bTp0+NauEIBAKBQCDICRJZec6WLVuWBw8eAMi/0U5OToSGhrJs2TKmTp0qe++OGzeOjRs3Ur9+febOnZunkb2a+2Ge6ucFu2nfF1jfrwvhqSEQCHLNs2fP+Pbbb3ny5AkDBgwo6OFkys6dO/Hy8sLLy4sJEybQpEkTIEUYdNasWbLrf0RERIZijcbCA4RB4+1mwIABbNmyhW3bthEUFMTMmTOJi4ujS5cuGdZJbdBQqVR06dKFQYMGceHCBe7fv09SUhITJkwgOjqaxo0bA3D69GmCgoL45JOPiYuLQ6fTGYRhhIeHGxgpYmJiePHiBWZmZnJ/CoVCzv6T2kND6EoIBAKBQJAbsl4cuHv3LsnJyfKznyRJPHnyhAoVKrB48WKDZ79jx44RFhbGoEGD8jwySaEosK0wIrKfCASCXFOsWDGKFi3KsmXLsLOzMzim0WgyrLdnzx4aNmyY4fHjx4/TqlWrDI9HRUXleKw+Pj5Ur16dxMRE2rVrR506dThw4AAvXrzA1tbWoGxSUpLRNvST0vyK8x89ejRdu3Zl2rRp/P3331muzFeoUIFu3bpx7Ngx/P39CQ8Pz5dxFGa6d+9u8Fqn09GoUaNs109KSmLLli2yJ09q9EJh5cqV49WrV6jVaooWLUqzZs0MsqboMXbfxMbGGj2eWtPlXdaVGD16NN26dcPa2pp58+axceNGdDodCoUCR0dH4uLiiIqKQqlUEhcXR6VKlbhz5w6JiYnodDpMTU0NvKZsbGxQq9Xy9SlRooTsBqxUKvH09GTmzJm8ePGCmTNnyimcjaFQKORrm9Y7x1hZjUYj658IBAKBoHCifxbT/xalNmpcv36dgQMH4ubmVlDDE2SAMGoIBIWQI0eOvJF+MpuE+/v7Z3gsK4FFb2/vTOvnBo1Gg0ajITQ0FK1WS5UqVXBwcODUqVPY29unOxcHBweePXtmsE+SJJRKpZy/PC8MGTKEvn370rZtW0JDQ2nSpAlNmjTBz88vwzq3b9/m6tWrXL9+naioqGyFKNSsWZMLFy7kaayFEUtLyxxpP9ja2hIWFmb02N27d2nZsiW3b9/m7t276Y7b2NhkywAlv5+6d9uQoUd/j0+dOpUbN24QGhqKWq2mSZMm2NnZsXnzZhQKBRMmTOD48eOcOnWKBw8ekJiYKF9vvUHD2dmZly9fEh4ejlqtZsyYMXz77beyQaNfv360bNmS0aNH06VLFxYsWICbm1umRg2ASpUqcePGDZKTk7P8POkNGmq12qjRSiAQCATvFmq1Gq1Wy/Tp05k5cybw7/PfRx99xKJFi1AqlQwaNIiffvqJTp06sWrVKlxcXOjUqVOe+pYKqbZFQVE4/U8Egv84kiSxffv2Ah1D2vSwqbes0r6am5tnWj8/kCSJfv368cMPP3DixIl0x9u3b2+0jouLS54NGpAyCfv+++8JDQ0F4Pz583Tu3JlmzZplWCc5OZnt27fz/Plzevbsma1+AgIC8PDwyPN432VSC+Nmti8zMjNKqFQqLl26xJ07d+jZs6dBdiGFQkFkZGS2MpvIY5LAzMwsR+N7G9F/vg4ePEhISAharZaRI0fy2WefsWPHDnQ6HcnJySxZsoQFCxagUCiIjo5Gp9Px6tUr2cBgamqKQqGQDRySJLFr1y6Dz+HHH39MYGAgz58/JzExkSlTpnDs2DGD1Mxp0Wq13LhxA0hRuM/MoJHayJRVqmuBQCAQvDkkKffT2YSEBEaMGCEvpJmYmMjf97169UKSJCwsLGTvYVdXV5o1a8a6devyPG5B/iKEQgWCNPj6+hIWFpZjo4Crq6ssNJSauXPnMnXq1HwaXfaQJInff/89XUaQnOLq6srYsWMZO3ZsvowLYO3atXz77bdcv34dpVJJjRo1mDRpEm3bts23PjIjISEBT09Pli5dio+PD3379uXChQsGE6jMREIBIeL4jtG7d28GDRqEg4MDixcvZs2aNRl6Qqxbt84gi8+GDRtYuHChgVeHfqW+QYMGfPvttzx//pzDhw+zevVq2UilX/nXp32TJIkKFSpQq1Yt9u7dS2hoqCw4W7ZsWcqUKcPevXsNxqJQKGRjSEY6LwKBQCAQCN4sZmZmXL58OU9thM//KJ9Gk3NsJn1TYH2/LoSnhkCQj8yePZuQkBCD7aOPCu5L621j4sSJDBs2jB49enDlyhXOnj1LgwYN6NChA99+++1r7z8xMRG1Wk3lypU5deoUK1asIDAwkMmTJ8tl1Go1Tk5ORuv36NGDunXrGhg0zLLwOskIlSp99F9OvQcEWdOqVSumTZvGd999R/PmzVm9ejWSJBl4U6Rm+/btJCQk8MUXX9CqVSs+++wz4uLiDEQ/ExISKFWqFFeuXGHPnj1cuXKFr776StbHqFatGiqViooVK5KUlETFihX59ddfiYiIYNWqVdSsWZOff/5ZNmpUqVLFwKChTwmr1Wpl8TJ92FNaCoNHBwgxVIFAIBC8eWrVqoVSqTR4JitXrhyQEgoNULFiRbZu3UqJEiXw8PCgYsWKVKxYMe+dS4qC2wohhfOsBIICwsrKCicnJ4Mt9WRo9+7duLu7Y25uTtOmTVmzZg2SJMmx+n5+fnh6ehq0uXjxYlxdXeXX586do3nz5hQtWhQbGxsaN27MxYsXMxxTQkICo0aNwtnZGTMzM1xcXHKdhkqSJFasWEGnTp2wsLCgfPny7Ny5M1t1T58+zcKFC5k/fz4TJ07Ezc2NihUr8sUXXzB27FjGjx8vx8dn5zoArFixgooVK2JmZkaFChX4/vt/U1Tdv38fSZLYvHkzjRs3xszMjGXLlmFtbU3FihXZvHkzy5Yto3v37gY5yPVZKYxx+PBh2V1dj1KZtTSRfjKaelJqzNNDrVZn2ZYgZ6TOfhIaGopOp6N9+/bpxGH19OzZky1btrBu3Tru3r2LJEl06NCBvn37yp9lSZJ4/PgxERERNGrUiOXLl9OiRQtevXqFSqVi6dKl2NjY8PLlSxQKBdOnT+f8+fOyJ9eBAwcoXrw4vXv3xszMjL///lvuX++d0bx5c4Nx6XS6dPc/QFxc3FtnEKhVqxbOzs45qlPQnk/ZCQ/SY8wgKRAIBIJ3j3PnztGoUSOSkpLk3wF9iPT58+epU6cOt27dYsiQIXz00UckJiZy69YtevfuXZDDFhhB/DILBG+Ihw8f0rlzZ0aOHMnQoUM5f/48EyZMyHE7kZGR9O/fn2+++QadTsfChQtp3bo1t2/fxsrKKl35pUuXsnPnTrZs2ULp0qV5+PChbDzIDbNmzWLevHnMnz+fb775hj59+vDgwQPs7e0zrffLL7+g0WgYNmxYumMTJkxg0aJF/Pbbb9kOddmwYQMzZszg22+/xcvLi0uXLjFkyBAsLS3p37+/XG7q1KksXLgQLy8v2V3wwoULDBs2jG+//ZaVK1catKtfHTeGPt1maqKjIrMcq37ClnriZqyPjIQoBbknbfYTgN9//z3D8kOHDiUmJkZ+rdVq2bZtm0EZnU4nv5f169cHUrRLAOLj4+XMPpIkUbRoUT766CNevHghhy3FxMQYZGBJmwHlypUr6cal1Wq5d++e0TG/baKi586dy3GdgjZq5KT/jLIjCQQCgeDd4/Dhw8C/vwP6MFJJkqhWrRrXrl0jLCyMqVOnolAoqFatmlHdtZwihELzl7dreUcgeMeZMmWKnGVDvx0/fhyAH374gXLlyrFw4UI8PDzo06cPvr6+Oe7Dx8eHDz74gAoVKlCxYkWWLVtGTEwMR48eNVo+ODiY8uXL06BBA1xcXGjQoAG9evXK9Tn6+vrSq1cv3NzcmDNnDlFRUZw9ezbLerdu3aJcuXJGvRGKFy+OtbU1t27dyvY4Zs6cycKFC+ncuTNlypShc+fOjBs3jp9++smg3NixY+Uyzs7ODB48mL1791KhQgW5TGpjgv5HbejQoen6zEx0UPDuo/eayq/MFu7u7jx79oxnz56RnJwswosEAoFAIHiL0Otepebly5dAStr2Y8eOodFo2LZtGzt27MDKyorbt28bLH4I3g6EUUMgyEcmTZqEv7+/waaPyQsICDAQIISUL8ycEhoaypAhQyhfvjw2NjZYW1sTFRWVYepCX19f/P398fDwYPTo0ezbty/nJ5aKatWqyf9bWlpibW1t1IPBGFmthmY3/CI6OpqgoCAGDRpkYED6/PPPCQoKMiirv/47d+7Ey8uLYcOGUa5cOf744w8gJb2sMQ+XtEKxOp2O58+fZ+s8BO8m1tbW+dKO3oU1MDAQSPGkcHV1NfrwlFHYQ1aeTwKBQCAQCLIiZaqbkf6UTqeTn2urV68O/Pss6uLiQkhICLNmzaJy5cpUqFCBsmXLEh0dzfXr19/A2AU5QYSfCAT5SNGiRfOUclShUKSbMKdNH9q/f39evHjBkiVLcHFxwdTUlHr16mW4ulyjRg3u3bvHnj17OHDgAN27d6dZs2b8+uuvuRpjWoFFSZKy5f5evnx5Tpw4QUJCQjrjxT///ENERATu7u5A1tchKioKgOXLl6czFKWdOOp1EHx8fOQfrHXr1vHzzz8D8PjxY7mOubm5HArw9OlTzMzMiIuLA1KyouivsV5oMqPUrqmzo3h7e/Pw4UNevXqFWq2Wx54dTExM0Ol0Bu7uSqVSbvttCzt4l1Gr1eh0OtRqNWPGjKFDhw5YW1sbZEtRKBS4u7szffp0TExM+Oyzz5g0aZJ8D96+fZuJEydy69Yt+T3SC3x27dqVfv36sWXLFpYuXSqniE19n6vVahITE5EkySCFrF5QVCAQCAQCQU5IeU7SP8ulO5oq5FOfzUT/HPjLL78AMHz48HT1+vXrx7Vr14wuVmSbt0wP611HXE2B4A1RsWLFdGEap0+fNnjt4ODAkydPDCY6+tzZek6ePMno0aNp3bo1lStXxtTUVPYgyAhra2t69OjB8uXL2bx5M7/99pvsXvem6NWrF1FRUenCQwAWLFiAmZkZPXr0ALK+Do6OjhQvXpy7d+/i5uZmsJUpU8Zo/xqNBhcXF1xcXBg1ahSRkSlaGFqtllGjRmFtbS3/6EmSRJ8+fdBoNHJ9vWHBxMQkS2FG/bg9PT25fPkyJUqUQKVSERUVhYmJSYaZN/SYmZlhaWlJYmJiuvj95ORktFqtgUEjJyKHAuMkJCQQExPDkCFD8PX1ZfHixQbZUmrWrMm2bduIi4ujb9++nD9/npUrVzJjxgzq169P/fr16datGzdv3kSn08nvcXJyMs2bN6d///4MHz6cL774gqioKD788EMDEWH9GHQ6XTpdF332k7Qolcos7yWBQCAQCP7rpPXIlSQp05DiHj16cOHCBWbOnEn37t35+OOPgZTnM3t7e3bs2JE3g4Yg3xGeGgKBEcLDw9MZE4oUKUKpUqUyrRcZGcmTJ08M9llYWGBtbc3w4cNZuHAhkyZNYvDgwVy4cIE1a9YYlG3SpAnPnj1j3rx5dO3alb/++os9e/YYuMWXL1+e9evX4+3tTUREBJMmTZKVmo2xaNEinJ2d8fLyQqFQsHXrVpycnDLM/vC6qFevHmPGjGHSpEkkJCTQsWNHEhMT+fnnn1m6dClr1qyRf2Cycx1mzZrF6NGjsbGxoWXLlsTHx3P+/HlevXrF+PHj0/Xv5+cnW90hxb0/MTERhUJBpUqVGDp0KAsWLABSshv88ssv8oTRxsZGzkqhNwaZmZmhVquJjo7O8JyjoqKoXr0658+fl/dZW1sTERFhtLypqSlVqlThwoUL2b2sFCtWLNvhP4LMSUpKonHjxiiVSv744w/ZyNC+fXvGjBnDwYMHuX//PgDz5s2jbdu2NG/enOXLl8ttWFlZUb16dU6cOCHvGzBgAHv37uXMmTNASoYVX19ftmzZQkxMTJbhTHrPpdQeQICc7lUgEAgEAkHG6Bey9JiZmSFJEnXq1JF/m6tXry57a/Tv3x+NRmOQ5WTOnDkkJSXRtGlT2bM4L4gFqfxF0ongcIHAAF9fX9auXZtu/6BBg1ixYkWG9VxdXeWUjakZNmwYP/74IwB//vkn48aN4+HDh9SuXZsBAwYwcOBAXr16JRsZfvzxR+bMmcPLly/p0qULHh4eLFu2TJ5MXbp0iaFDh3Lt2jVKlSrFnDlzmDhxImPHjpUzh0iSxO+//07Hjh1Zvnw533//Pbdv30apVFKrVi3mz5+Pl5dXltfC1dU1w3b12Nrasnjx4myLnq5atYrvv/+e69evExcXh1qtZv/+/QbZILJzHQA2btzI/PnzuXHjBpaWllStWpWxY8fSqVMn7t+/T5kyZbh06RKenp6EhobKehtJSUkMHToUnU5HmTJliIyMJCIiItNJYtoQAI1GQ0xMjAgBKYR4e3szaNAgqlSpwv79+5k3b16Grqu5oXTp0oSGhhIfH59vbb6tjB49mm7dumFtbc3Fixfx8/Mz+j2px8rKiokTJ9K0aVN+/vlnli1b9gZHKxAIBAJBChUqVOD+/fvpfv8VCoWc8SwvRC7JeQbE/MJqzMIC6/t1IYwaAkEBcuTIEZo2bWpg1Pgvcf/+fRo3bky9evXYsGHDG3PlCw0NlY0odevWZe3atXzxxResW7cOSPnBMmasmDBhAgsXpvwQCJ2DwkujRo2oUaMGBw4c4MaNG2i1WiwsLIyqnfv4+HDo0KEs21Sr1UZ1bzK61woDAwYM4MMPP2Tq1Kk8evSIMWPG4O7uTosWLTL87Nja2qLVailatCj3798vtNdGIBAIBAWHSqUymp5boVCg0WiwsLCgdu3a3Lt3j2vXrsleknPmzKFx48YULVo0z2OI/GZSntvILVYfzS+wvl8XQlNDIBAUGK6urhw5coQKFSqkC/fJb/TZTzw9PWnevLm8//Tp03z99dds2rRJ3qfVaqlTp04618Dff/9d/l8YNAovlpaWLF68mGvXrqFSqVCr1cTGxuLl5ZVO5DY76YzVanWGbqYTJkzIMuvPu+qiWrp0aX744QcOHjxIYGAgkydPxsHBIVPjZVhYGBEREdy9exetVouTk5PRcqampq9r2AKBQCAo5KT+3U2traHVanFwcKBEiRK0bduW27dvpwsR1el0+eq9KcgfhKeGQJANNmzYwLBhw4wec3FxyXVqp4L01Mjvcxo+fLicUSQtH3zwgRyCU1BERUXx4sULli5dyvfff0/p0qWBlIw1qYVWC/PKuSBvWFpaMmrUKNq2bUuxYsVo164dt27dyrf2hfePQCAQCAQFT7Vq1QgMDMwwTHTu3Ll07tw5T30IT438RRg1BIJsEBkZSWhoqNFjJiYmuLi4vOER5Z38PqenT59mKIBpbW1NsWLFcjzG10m3bt24ceMGSqWScePG8eWXXxocr169OlevXk1n4LCyskonOAUgKZTotGJCWpgpWbIkz549o06dOnTq1Inx48dnKfKZHfTiscKglh5xTQQCgUDwJkgrvO7o6EirVq04duwYd+/eBVI8EF++fMmuXbsy9CTMLlHfTc5T/bygGTmvwPp+XYjwE8FrZdmyZZQqVQqFQsHixYvz3N79+/eRJOm1hyqkxcrKKl3qUP2W0eTf1dXV4JwlSWL79u15Goevr6+BSGdeyM05ZUaxYsUybC+3Bo3X+X77+vqSlJREcnKy0ZS4ly9fNkjpqseYQQMQBo3/AE+ePCE+Pp5jx46xevVqSpQokec21Wq1bAx8V8NM0pI2VW1eEAYNgUAgEOQ3acMgGzVqxPvvvy+/VqvVPH/+nOHDhzNlyhR5f82aNdFoNJkmDhAUDDkyauR1QjV37lyUSiXz5xc+l5eMyM9JKKRMlCVJ4vTp0wb7x44dS5MmTfKtn8xITk7m66+/pmrVqpiZmWFnZ0erVq04efKkQbmIiAhGjRrFlClTePz4MUOHDgUgNjaWmTNn4u7ujqmpKUWLFqVbt27pwh3y+9plB0mS5M3S0pLy5cvj6+uboxSbGRESEkKrVq3y1MaSJUsM0sA2adJEzkzyuslJX6GhoZiYmBjoVKRm0KBB1KhRIx9Hl3Pu3bsHpGRCSf3jpFD8+7WYkeeJ4N2id+/eHDx4kCtXrrBlyxaqVq2aaXlJknBzc2Pr1q3MmDEDGxsbIGWCXaFCBTZs2MCXX37JV199xfHjxwkMDOTvv/9O174kSfL9JEkSRYoUoXXr1nJ7kiRRunRptm7dykcffZTO60OSpHwRI3vTZJbmWCAQCASCgiZtqOexY8cMQqgTEhJITk7mvffeMwjV/v3333ny5Al79+7N+yAkRcFthZA3elarVq1i8uTJrFq1KsuyxlTiBSmYmZkZWA3fJDqdjp49ezJ79mzGjBlDQEAAR44coVSpUjRp0sTAEyE4OJjExETatGmDs7MzFhYWxMfH06xZM1atWsXnn3/OrVu32L17N0lJSdSpUyedseZNkfp+W716NSEhIVy/fp3vvvuOqKgo6tSpI2fGyC1OTk55FrezsbF5Ldob+f15c3R0pE2bNkY/69HR0WzZsoVBgwbla585Yffu3fzwww8ArFu3ju7du8vHNBpNlu9Tagu/uaXd6xmkIF9o1aoV06ZN47vvvqNTp07cvHmTlStXYm9vn2EdlUrFnTt36NatG7NnzyYqKopWrVqxbds24uLi6N+/PwEBAVStWpXDhw8DsGvXLjp16sSdO0GsXLkSNzc3g9AJa2trwsLC2L17N+Hh4VhYWGBvb09QUBAffPAB33zzDVqtVvZqkiQJnU5n1ItIIBAIBAJBdsjaA7Js2bIolUqDZzsnJyckSeKnn34yEBIdN24cjo6ONGjQ4LWMVpB73phR4+jRo8TGxjJ79mwiIiL4+++/DY77+fnh6enJihUrKFOmDGZmZgDcvHmTBg0aYGZmRqVKlThw4ICBG/+RI0eQJImwsDC5LX9/fyRJ4v79+wCsWbMGW1tb/vzzTzw8PLCwsKBr167ExMSwdu1aXF1dsbOzY/To0QaWu/j4eCZOnEiJEiWwtLSkTp06HDlyRD6ub3fv3r1UrFgRjUZDy5YtCQkJkc9p7dq17NixQ179P3LkCAkJCYwaNQpnZ2fMzMxwcXFh7ty52b6WQ4cO5fTp0+zevTvDMsZW1Tt27Iivr6/82tXVlc8//5x+/fqh0WhwcXFh586dPHv2jA4dOqDRaKhWrRrnz5+X62zZsoVff/2VdevWMXjwYMqUKUP16tVZtmwZ7du3Z/DgwURHR7NmzRp5tbJs2bLy+7F48WJOnTrFn3/+Sffu3XFxcaF27dr89ttvVKxYkUGDBqHT6TK8dnru3r1L06ZNsbCwoHr16pw6dcrgXE+cOEHDhg0xNzenVKlSjB492mD10NXVlc8++4x+/fphbW0te5FASkpBJycnXF1def/99/n111/p06cPo0aN4tWrV9nuIy2p71t9WMWWLVvkNmrVqsWtW7c4d+4c3t7eaDQaWrVqxbNnz+Q2Unuv+Pr6cvToUZYsWSJfI/09f+3aNVq1aoVGo8HR0ZG+ffsaTI6aNGnCqFGjGDt2LEWLFqVFixbydS9dujSmpqYUL16c0aNHZ3g+rq6uzJkzh4EDB2JlZUXp0qVZtmyZfHzQoEEcPHiQ4OBgg3pbt24lKSmJPn368Ndff9GgQQNsbW0pUqQIbdu2JSgoKMM+9Z+51Gzfvj2d2/6OHTuoUaMGZmZmlC1bllmzZrF9+3a8vLzw8vJi3LhxsvhT586dCQsLk9uIiIjIUKzRWHhAbPQrIyUFbwsDBgxgy5YtbNu2jaCgIGbOnElcXBxdunTJsE5iYqL8v0qlokuXLgwaNIgLFy5w//59kpKSmDBhAtHR0TRu3BhIyaITFBTEJ598TFxcHDqdziAMIzw83MATIyYmhhcvXmBmZib3p1Ao5Hje1B4aqb2HBAKBQCAQZJesda/u3r1LcnKy/OwnSRJPnjyhQoUKLF682ODZ79ixY4SFhRXowpzAOG/sSWnlypX06tULExMTevXqxcqVK9OVuXPnDr/99hvbtm3D39+f5ORkOnbsiIWFBWfOnGHZsmV88sknueo/JiaGpUuXsmnTJv766y+OHDlCp06d2L17N7t372b9+vX89NNP/Prrr3KdUaNGcerUKTZt2sSVK1fo1q0bLVu25Pbt2wbtLliwgPXr13Ps2DGCg4OZOHEiABMnTqR79+6yoSMkJIT33nuPpUuXsnPnTrZs2UJgYCAbNmzA1dU12+dSpkwZhg8fzrRp0/Icb/z1119Tv359Ll26RJs2bejbty/9+vXjgw8+4OLFi5QrV45+/frJD+MbN27E3d2ddu3apWtrwoQJvHjxgv3799OjRw8OHDgApKQ8DAkJoVSpUmzcuJHmzZtTvXp1g7oKhYJx48Zx48YNLl++nOG10/PJJ58wceJE/P39cXd3p1evXnK+6aCgIFq2bEmXLl24cuUKmzdv5sSJE4waNcqgzwULFlC9enUuXbrE9OnTM71O48aNIzIykv379+eoj6yYOXMmn376KRcvXkSlUtG7d28mT57MkiVLOH78OHfu3GHGjBlG6y5ZsoR69eoxZMgQ+RqVKlWKsLAwfHx88PLy4vz58/z111+EhoYaeCMArF27FrVazcmTJ/nxxx/57bff+Prrr/npp5+4ffs227dvz9JNf+HChXh7e3Pp0iU+/PBDRowYQWBgIACtW7fG0dHRIFwGUjxhOnfujK2tLdHR0YwfP57z589z8OBBFAoFnTp1ytN9ffz4cfr168eYMWO4ceMGP/30E2vWrOH8+fNs376dIUOGoNPp6Nq1KwCLFy8mMTHRYMJpLHe5fuX8TTB69GjGjRtH8eLFUavVVKlShaZNm6JSqYyW9/b25osvvqBMmTKo1Wr5M2Fubg6khF8cOnSI69evc+3aNQIDA/Hx8TE6WVar1TRt2hQHBwfUajUlSpTA3t4eExOTDMf7NmtBdO/enc8++0x+rdPpaNSoEcuXL89W/aSkJLZs2ULXrl0N2gGoV68ejRs3xsPDg4MHDxq0HxQUREREhEHaOGP3dWxsrLw/9fHw8HBUKhWOjo4Gq0RvM2q1Gjs7O4P7QalUUrNmTXbu3MmqVavk0JvU+1evXi3r+KS+z0xMTFCpVJiamqJUKpEkSf6rx9LS0uj9l7acQCAQCATZQf+sFxAQwPXr1w0WBa9du8bAgQNxc3PLe0cKqeC2QsgbMWpERETw66+/8sEHHwAp6R23bNlCVFSUQbmEhATWrVuHl5cX1apVY//+/QQFBbFu3TqqV69OgwYN+OKLL3I1hsTERH744Qe8vLxo1KgRXbt25cSJE6xcuZJKlSrRtm1bmjZtKrsSBwcHs3r1arZu3UrDhg0pV64cEydOpEGDBqxevdqg3R9//BFvb29q1KjBqFGj5IdbjUaDubk5pqamODk54eTkhFqtJjg4mPLly9OgQQNcXFxo0KABvXr1ytH5fPrpp9y7d48NGzbk6nroad26NcOGDaN8+fLMmDGDiIgIatWqRbdu3XB3d2fKlCkEBATIWTJu3bpFxYoVjbal33/r1i3Mzc3lB3EHBwecnJxQKpXZrp/RtdMzceJE2rRpg7u7O7NmzeLBgwfcuXMHSNFu6dOnD2PHjqV8+fKyIWndunUGeaV9fHyYMGEC5cqVo1y5cplepwoVKgDInhDZ7SMrJk6cSIsWLahYsSJjxozhwoULTJ8+nfr16+Pl5cWgQYPkezItNjY2qNVqLCws5GukVCr59ttv8fLyYs6cOVSoUAEvLy9WrVrF4cOHDdJPli9fnnnz5uHh4YGHhwfBwcE4OTnRrFkzSpcuTe3atRkyZEim42/dujUffvghbm5uTJkyhaJFi8rjVSqV9O/fnzVr1sg/EEFBQRw/fpyBAwcC0KVLFzp37oybmxuenp6sWrWKq1evcuPGjWxfw7TMmjWLqVOn0r9/f8qWLUvz5s357LPPWLVqFS4uLrx48QJJkujcuTMODg6cPXuWEydOpGsn7USyWLFiKBSK1552c8iQITg6OrJ06VJGjBjBggULSEpK4vDhw3zyySdYW1unq5OYmMinn36KpaUl27dvJzIykl9++YXY2Fh69+4th1906dJF1hKRJAmtVptO1DEhIYHDhw8TExODQqHg8ePHSJJEvXr10vWrnzS+i0m09N6AeUVvOMqIhIQEvL29c9aoLsUTql69eoSGhvLy5cs8jPD1o1Qq8fT0JCEhgbCwMFkRvnnz5qxfv54HDx7QpUsXfv/9d5KSkmjRooXB/oiICFauXCl/thwdHYGU+1qhUJCQkIBWq0WlUqFUKtHpdJiammJmZkZycrJ8/1lZWcmGOpEaVyAQCAQ5Qf9M069fP5o0aYK9vT0qlQoTExNKliwJpHj3rlq1it9//70ghyowwhsxavzyyy+UK1dOXp339PTExcWFzZs3G5RzcXHBwcFBfh0YGEipUqUMUubUrl07V2OwsLAwmLg6Ojri6upqkN3A0dFRdv29evUqycnJuLu7o9Fo5O3o0aMG7vFp23V2djZIB2QMX19f/P398fDwYPTo0ezbty/H5+Pg4MDEiROZMWNGnvQQqlWrJv+vf5BMvTqv35f6nPI6gcmPCVDqcTs7OwP/jvHy5cusWbPG4H1r0aIFWq1WntABOZpo6Mes/8LLbh85OY+Mrn9W91NaLl++zOHDhw3GpjfKpL53a9asaVCvW7duxMbGUrZsWYYMGSJPQLI7fkmScHJyMhjvwIEDuXfvnmzoWL16Na6urvj4+ABw+/ZtevXqRdmyZbG2tpY9ltKGrOT0/GfPnm1w/npvlpiYGNq2bSufr0aj4Y8//jAqWlqmTBmD10+ePCE5OZmEhITXOonv168fX3/9Nc2aNSMhIYFp06bx/PlzlEolISEh9OjRI12dy5cvo9PpuHbtGuXKlZPDoKytrencuTNbtmzht99+4+bNm3z++efodDqOHj2KWq0mPj7eqMdGdHQ0cXFxeHp6EhkZmU4IGNJ/lt/WlfG0KudgGGKSXYx5TCiVyky9WIAMhYb1RrJ0SCnG3ePHjwMpE/S39dpCyvj0GYp0Op1sBJ8xYwYHDhzg+fPnJCYm8scffzBs2DA+//xzg/2TJ0/GwcEBlUqFVqs1SDWtNwrpdDoSExNJSEhApVLh7OxMXFycwe9fZGSkgbeLTqeTH0QFAoFAIMgMfdjohx9+yPjx43n58iU6nY7SpUvz5MkTIGXBoVmzZnnW2QOQJEWBbYUR477M+czKlSu5fv26geu0Vqtl1apVBjFJuUkDp38YT/1wbexhNe1DpyRJRvfpH4iioqJQKpVcuHAh3UNnakOIsTaymvDUqFGDe/fusWfPHg4cOED37t1p1qyZQehLdhg/fjzff/8933//fbpjCoUi3Tiyui76h2Zj+/TXxd3dnYCAAKPj0e93d3fPcMx5rZ/ZuFO/d8OGDTOqB1G6dGn5/5zcb/qx6Se62e0jK7Jz/XMaihEVFUW7du346quv0h3TG4Ag/fmXKlWKwMBADhw4wP79+/nwww+ZP38+R48ezXDSltlnCFK8QRo2bMjq1atp0qQJ69atY8iQIfK5tmvXDhcXF5YvX07x4sXRarVUqVIlQ0Nddu7rqKgoZs2aRefOndPVNzMzo3LlyiiVSoYNG8bRo0fRarWcOXNGLlO/fn1OnjxpoCXTu3dvBg8eTNGiRbl58yZDhgwhPDwcSFkdVqvVREZGUrJkSQYNGkS7du0YOHAgFy5cQKfTGf1ekCQJFxcX7O3tuXTpkny8YcOGAOzdu1dW146Pjyc5OdlAsyQjPDw85P8jIiLkMBs9Z86ckY1c2SF1Ol1LS0sSEhLw8PCgd+/e/PLLL1y9elU+ntl3X7FixWjVqhU///zzG19FN9Zfbsbw4sWLdPvSehwaI6PrkvazLUkS9vb2JCUlERkZiU6nk+tWrlyZkSNHUqVKFS5cuMD8+fN59uwZrq6u1KxZk99//z1DLzH9/frbb7+9kWuvPy/9vZyaRYsWsWjRIoN98fHx6UISU3Pu3DmD10lJSbLXXFbfj48ePcrOkAUCgUAgIDo6mrp168qvk5OTDRYE9RqIWS1mCN48r92ocfXqVc6fP8+RI0cM1OZfvnxJkyZNuHnzZoYP2B4eHjx8+JDQ0FB5FTvtw43esyMkJAQ7u5QsBKkfwnOLl5cXycnJPH361OiDWXZRq9VGHyKtra3p0aMHPXr0oGvXrrRs2ZKXL19mqsifFo1Gw/Tp0/Hz86N9+/YGxxwcHGTBUkj5UF67do2mTZvm+lwAevbsSe/evfnjjz/S6WosXLiQIkWK0Lx580zrf/LJJ1y+fNngIVar1fL1119TqVIleX9G1y4ratSowY0bN/In3u3/Wbx4MdbW1jRr1uy19ZEbjF2jGjVq8Ntvv+Hq6pqhBkNGmJub065dO9q1a8fIkSOpUKECV69ezVP61UGDBjFixAjat2/P48ePZbHaFy9eEBgYyPLly+XPmLEwkNQ4ODgQGRlJdHS0bJRJ+3mvUaMGgYGBGb43arWaypUrc+XKFf755x9ZaFgvQKoPf4qKikKhUNCiRQumTZvGzJkzsbCw4M6dO4SHh6NWq/Hy8uLcuXNER0dTokQJnJ2dmTt3LrNnzyY+Ph4TE5N0eh167O3tefHihTw5AwyyZUCKJ1hMTAxOTk6yp0ievUR04OjkaLAanh0kSWLKlCkcO3aMM2fOMHv2bLZv306XLl2yFMjVC2Bu2bKFihUrcu3atXRldDodKpUqS++gt4n81FmpWrUqXl5erF+/Hp1Oh4mJCeXLlycgIACdTsedO3e4fv06K1eu5NKlS7i7uxMdHc29e/cMwsqModcPUSgUNGzYkBMnTrx1IUPv2nsvEAgEgsKLJEmUKVMGR0dHTp06hUKhwNzcnE6dOnH58mWuXbvGjRs3qFSpUu47KaTaFgVFjv1PwsPD8ff3N9gePnyYYfmVK1dSu3ZtGjVqRJUqVeStUaNG1KpVy6hgqJ7mzZtTrlw5+vfvz5UrVzh58iSffvop8O+qtpubG6VKlcLPz4/bt2+za9cuFi5cmNPTSoe7uzt9+vShX79+bNu2jXv37nH27Fnmzp3Lrl27st2Oq6srV65cITAwUHa1XbRoEb/88gs3b97k1q1bbN26FScnp1yl6hw6dCg2NjZs3LjRYL+Pjw+7du1i165d3Lx5kxEjRhhkiMktPXv2pFOnTvTv35+VK1dy//59rly5wrBhw9i5cycrVqzI1ANi3Lhx1K5dm3bt2rF161aCg4M5d+4cXbp0ISAggJUrV8rvrbFrlx2mTJnC33//zahRo/D39+f27dvs2LEj2yKeYWFhPHnyhAcPHrB//366du3Kxo0b+eGHH+T3KK995Beurq6cOXOG+/fv8/z5c7RaLSNHjuTly5f06tWLc+fOERQUxN69exkwYECmRqI1a9awcuVKrl27xt27d/n5558xNzeXBfxyS7du3TAxMWHYsGG8//77lCpVCgA7OzuKFCnCsmXLuHPnDocOHWL8+PGZtlWnTh0sLCz4+OOPCQoKYuPGjemESGfMmMG6deuYNWsW169fJyAggE2bNsnfHWvWrKF06dIG3hGpU7i+ePGCmJgYIGWFPXX2jJ9//pnTp09TtmxZ+vfvT0REBO7u7mi1Wh4+fIi/vz8WFhbyPZyYmIiVlRWenp4GY7S2tubFixcGK+tmZmbpjFD6cTx69Ijx48cbrB5kl3Tu9xKyWGN20F+b999/n8TERA4cOEBkZCRxcXFs27YNCwsLo/UkScLHxwedTiffd/Hx8UbDs3Q6HWXKlMmTAbkgyE/DwKeffsq2bdvkNhMTE1mwYIHsjRgXF8e3337L+fPnadiwIcWLFycsLMzgezG17pAxtFotY8aMybcx54SsxLCFBoZAIBAICpoePXrQuXNndDod0dHRvP/++/Kx6OhoSpcuzZ07dyhWrBiHDh0qwJEK0pJjo8aRI0fktIj6bdasWUbLJiQk8PPPP2eYOq9Lly6sW7cuw8mqUqlk+/btREVFUatWLQYPHixnP9GLvJmYmMgGgmrVqvHVV1/x+eef5/S0jLJ69Wr69evHhAkT8PDwoGPHjpw7dy5H4QVDhgzBw8MDb29vHBwcOHnyJFZWVsybNw9vb29q1arF/fv32b17d67S9pmYmPDZZ5+lczseOHAg/fv3p1+/fjRu3JiyZcvm2UsDkNOQfvzxx3z99dd4eHjQsGFDHjx4wJEjR+R0oxlhZmbGoUOH6NevHx9//DFubm60bNkSpVLJ6dOnDSZtxq5ddqhWrRpHjx7l1q1bNGzYEC8vL2bMmEHx4sWzVX/AgAE4OztToUIFRowYgUaj4ezZs/Tu3Tvf+sgvJk6ciFKppFKlSjg4OBAcHEzx4sU5efIkycnJvP/++1StWpWxY8dia2ub6T1ma2vL8uXLqV+/PtWqVePAgQP88ccfec68YGFhQc+ePXn16pUsEAopq8abNm3iwoULVKlShXHjxjF//vxM27K3t+fnn39m9+7dVK1alV9++QU/Pz+DMi1atODPP/9k37591KpVi7p16/L111/LxhlbW1uOHTsG/Bu6klrsUavVotVq6dOnDwcPHqRatWo0aNDAQOvk7t27LF++nICAAHmVvFGjRuzcuZOjR49y+fJlxo4di6mpqaxNof8uVKlUREVFUaJECaysrGRDRlp9AL1WQ5kyZbC1tWXevHnpUhdnB2Pu91mt7KdGn/p279696bJ/LFu2zCDlcGp0Ol26H3ytVpuhV0dq7ZX/ElWqVMHe3p5evXqlC2Vp3bq1wWR/3bp1BAYG0qhRIy5evJiurezoK3Xt2rVAvDRSeyQZ423zHBEIBALBf4/Nmzezbds2AEJDQ1m5ciUlSpRAq9UiSRKbNm1i6tSpKBSKXC1GC14fku4de5I4efIkDRo04M6dO1lmrBAIBAJjXLx4Uc44pFKpaNy4MYcOHUKn06FWq/nf//7HggULmD9/PtOmTeP+/fs4Ojri7e0tu8i/9957/P3376owRwABAABJREFU33KbmzZtwt7enl27duHq6sqECROoX78+EyZMYOzYsTx48AC1Ws3nn3/Op59+Snx8PEWKFCExMZGIiIgMx6rX/0k9YTU1NZWNDe8CbzId7ruEu7s7ISEhqNVqXrx4IRseX716ZfR62VjbpBiGYqLlMKUSJUrwzz//yOVLliwpdCQEAoFAIMglkiTRpk0bDhw4gFarxcPDg6tXrzJ//nzat2/P8uXLWb58OXv27MnTwl/Myhn5OOqcYTFodoH1/bp46+VPf//9d/bv38/9+/c5cOAAQ4cOpX79+sKgIRAIss3OnTupWrWqnL62f//+8rEiRYpw/PhxatWqBaSsdg8YMIAdO3awe/duAA4dOkRCQoK8at6sWTM+/PDfUCOFQsH+/ftp3bo1S5cu5auvvkKSJD766CMuXLjA/fv30el0xMfHU7t2bRQKBWq1mvDw8EwNGpCS6jjtCvy7ZNAAsQqfEU+fPqV27dqyAGlYWBhRUVE0aNDAaPnwiHAiIyPlMBNbW1sOHDhgUEav0J4aY2mABQKBQCAQGFK6dGl0Oh3nz5+Xw2dv3bqFlZUVLVu25I8//uC7775j8eLFefZkFuQvefbU2LBhA8OGDTN6zMXFhevXr+eledatW8fnn39OcHAwRYsWpVmzZrIgZWHjdV9LgeC/SlRUFA8fPuTVq1cA/PPPP3Iom1KpzDCe38TEhPXr17N69WqOHj0qh3kplUq0Wm2uJutpxUALApVKlaXoqF7Z29ramrCwMKF58JaSnfdSIBAIBAJB/mBra8uIESNk4fvcErNqZv4MKBdYDDQuHfEuk2ejRmRkZIYq+iYmJnkWGfwvIa6lQPBmuHDhAr1795bTNet0OqpVqyZnUjExMaF06dIEBwejVCpJTExMZ8SQJAUKhSRP9jMzjrxtpA4H0Wt6pM08UalSJVQqFVeuXBGZKd5i7OzsZGOdmZkZ8fHxwsAhEAgEAkE2KFasGE+fPjXYlzqMUx/uq39uatOmDXv37kWpVPLJJ5/Qo0ePXPctjBr5S55TulpZWWFlZZUfY/nPI66lIK8cOXKEpk2b8urVq2wLGPn5+bF9+/Z8SYX8trJz505mzvz3x+Onn34C/s24ULNmTW7evCkfVyqVvHz5ksTERFlM1NPT0+Aa6XRaUtswkpOTsdZoiEgj9vg2knrSa29vj0aj4e7duwZlbty4If+flJQkp6cVvF2kzmr1rhjVBAKBQCB4G3j+/Ln8v95w8fjxY3lffHw8NjY2hIeHU7lyZaZNm0ZUVBQBAQGcOnUqT0YNQf7y1mtqCASFCV9f3ywzxBjD1dUVSZKQJAlzc3NcXV3p3r17uuwS7733HiEhITlK2Tlx4kQOHjyYpzFKksT27dtzVCcjjhw5giRJRlMQu7q6snjx4hy36ePjw/bt2+XNzs7O4PiFCxfkrBwmJiZ8+umnHD16lNWrV8seUi1btsyyn6j/T8GaEfqQjrxiaWmJiYkJzs7O2Nrayilks4PeO0XP06dP0xk0jCEMGm8nqQ1UWq0WpVKJs7Mz9vb2mdbTZ10xNTWlatWqFCtWDDC8R/X3iiRJ9OzZkypVqsj3mt7DJ3U6ZGPox2NnZ4dKpUp3/xlDkiSKFClC0aJFMy1naWmZLg2yQCAQCATZJXU4sP73NK23Y3h4OADXr1+nQYMGHD16lKdPnxrVsMoRCkXBbYWQwnlWAkEhZPbs2YSEhBAYGMi6deuwtbWlWbNmfPHFF3IZtVqNk5NTjia5Go2mUGrUpEaj0eDi4iJvbm5uclro1BQtWhStVsunn37K2LFjsbe3Z+XKlajVaqpXr46FhUWm/ehTfqVF74GVH4YBSZKYMmUKHh4ehISEEBUVxY8//pjl5FJPcnIyZmZm8uQ1o3vFy8sr5R8RyfDOoNPpqFChAk+ePMk0vau7uzsPHjzA3d0dBwcHXrx4IbvfKpVKnJycgJT7uUiRIpQrV45t27Zx7do1LC0tqV+/vpwGWR+W5OzsbNCHJEk0b96c7t278+TJEyIiIjIUQE1NqVKlsLOz48WLF7x69SrT77Lo6GjZi0ggEAgEgryQHQ9nxf8bBBQKBZs2bXrNIxLkBGHUEAjeEaysrHBycqJ06dI0atSIZcuWMX36dGbMmEFgYCBg3Mth+fLllCpVCgsLCzp16sSiRYsMvrj9/Pzw9PSU/1+7di07duyQPUOOHDmSo3Hev38fSZLYtm0bTZs2xcLCgurVq3Pq1Kk8XoH0BAcH06FDBzQaDdbW1nTv3t1Al+by5cs0bdoUKysrihUrhoeHB9WqVaN69eoGFna9sWH9+vWyhf7ChQuMHDmSYsWK0axZMyRJokqVKpmOR6VSyT94qWnfvn1+nC4A77//PomJiVy7dg1ImVReuHCBvn37Gi1vYmJC+fLlDfYlJCTIk9GM9Bd8fHyoVq0aZN8+JihgtFot165dQ6fTER0dnaG3xtOnT6lTpw6nT5/m0aNH/PPPP0DKvVK/fn35s6HT6QgLC6Nbt26ykSQqKoqTJ09SvHhx4N8HvJCQEIM+lEolM2bMYPv27bKC/JEjRxg+fLjRz4iehw8f8vLlS/l8sqMPIryIBAKBQJBb6tSpg0KhICwsDKVSaWAoV6lUBhk3VSoVtWvXRqvV8ueff+atY0kquK0QIowaAsE7zJgxY9DpdOzYscPo8ZMnTzJ8+HDGjBmDv78/zZs3N/DsSMvEiRPp3r07LVu2JCQkhJCQEN57771cje2TTz5h4sSJ+Pv74+7uTq9evfJVbFKr1dKhQwdevnzJ0aNH2b9/P3fv3jWIb+zTpw8lS5bk3Llz7N+/n3HjxjFv3jw6depkMOHT/4C1atVKdkWMiIjg8ePH1KxZk0uXLvHRRx9x9uzZTMeUlJRkVNdgw4YN+XHKAOzdu5fPPvvMYN+yZctYsWIFkD7EJTExkdu3bxvsy85kceHChVy5ciUfRiwoCHQ6nWwcSEtYWFi6VLCQcq+kDkWDFM+euXPnpiurN6RmZFBISkqiYcOGxMbGGuz/7rvvsp39RwieCgQCgeB1c+bMGfl3KTk52eB3LSkpiaCgIPl1QkICoaGh2Nvb880337zxsRYk3333Ha6urpiZmVGnTp0sn4nDwsIYOXIkzs7OmJqa4u7uzu7du1/b+IRRQyB4h7G3t6dYsWLcv3/f6PFvvvmGVq1aMXHiRNzd3fnwww9p1apVhu1pNBrMzc0xNTXFyckJJycn1Gp1rsY2ceJE2rRpg7u7O7NmzeLBgwfcuXMn2/VLliyJRqMx2IKDg+XjBw8e5OrVq2zcuJGaNWtSp04d1q1bx9GjRzl37hyQ4snRrFkzKlSoQPXq1Rk+fDjBwcH8+uuvRidWv/32m3y+Op0OjUbDhAkTiImJ4dmzZ7m6Dm+a1GE12dEvEBRO1Go1kiSh0WgwNTWVw0XeBjLz1BAIBAKB4G1BqVQydepU+bWZmRlPnz6lbNmyefYSlBSKAttyyubNmxk/fjwzZ87k4sWLVK9enRYtWqTLHKMnISGB5s2bc//+fX799VcCAwNZvnw5JUqUyNM1ywyhsCUQvOPodLoM484DAwPp1KmTwb7atWvn3WUuG1SrVk3+Xx9v//TpUypUqJCt+sePH0+XDahJkyby/wEBAZQqVYpSpUrJ+ypVqoStrS0BAQHUqlWL8ePHM3jwYNavX0+ZMmX4+++/ZW+R1GlN9f+vWrVKvpaSJBEXF4ejoyPh4eEGZd9mIiMj5f9VKpXIiPEfJXW4SLFixYwK7xYU2fXUEAgEAoHgTaJQKOTfKEmS8PDwMPCGTkxMRKFQEBAQkGHY77tAfHw88fHxBvtMTU0z1GdbtGgRQ4YMYcCAAQD8+OOP7Nq1i1WrVhkYffSsWrWKly9f8vfff8sexK6urvl7EmkQyyUCwTvMixcvePbsGWXKlCnooaQjdRiE3hCQk8lMmTJlcHNzM9hymunAz8+P69ev06ZNG+7duyfnHQeoXr26/L/eYLFr1y75S16n06HT6ZgwYYJ8Dm+7QSMtaX+w8pOcZmD54IMPOHToEFeuXGHIkCFZijsWLVqUJUuWMGPGDKpWrZrhe69f9X/X3ps3iUajoW/fvlhaWhb0UAQCgUAgeGtJmw3lxo0bBAQEyPuSk5NRq9W0adOG48eP4+3tjaenJx06dMi3LIBvgrlz52JjY2OwGQs1hZRFkgsXLtCsWTN5n0KhoFmzZhnq5e3cuZN69eoxcuRIHB0dqVKlCnPmzHmtC23CU0MgeIdZsmQJCoUiwxSsHh4eciiGnrSv06JWq9+J1f2KFSvy8OFDHj58KHtr3Lhxg7CwMCpVqiSXc3d3x93dnXHjxtGuXTtu3boFpFybixcvolAoUKvV6HQ6tFqtwbn7+PgY1R74r6PPwLJlyxauXbuGSqXixx9/ZPTo0UYNKa1atWLq1Kn4+flx/Phxnj9/zsyZM/n555/l90OpVMrXXqlUUqdOHSZOnIhSqcTa2lrOLJNWZ0H/AGJqakpcXNxrPvN3EB3cvXuXu3fvIkkS9erV49KlS+JaCQQCgUCQBhMTE4OwEm9vb0JCQnj8+DGQEvbt5eVF27ZtadSoEWXLlsXExITDhw/z8ccfU6RIERo2bJi9zqSC8y2YNm0a48ePN9iXkZfG8+fPSU5OxtHR0WC/o6MjN2/eNFrn7t27HDp0iD59+rB7927u3LnDhx9+SGJiIjNnzsyfk0iD8NQQCN4w4eHh+Pv7G2wPHz7Msl5kZCRPnjzh4cOHHDt2jKFDh/L555/zxRdf4ObmZrTORx99xO7du1m0aBG3b9/mp59+Ys+ePZmuaru6unLlyhUCAwN5/vz5W5tZoFmzZlStWpU+ffpw8eJFzp49S79+/WjcuDHe3t7ExsbSpUsXKleujIeHBx4eHrK4IaToZ+i9LxISEoyKZ+7bt0+4yhshpxlYRowYwfPnz/n1118JDQ0lOTmZ5s2bG2grpDYmqVQqrK2tSUxMJC4ujqdPn2JmZmawSpCW3Gq/FHpSfdR1Oh2rV68W97RAIBAIBEZI/cxrb2/PsmXLDAToo6KiiIyMpFSpUjRv3pxy5cpRunRp+vfvj4eHBxcuXCiIYecYU1NTrK2tDbaMjBq5QavVUqxYMZYtW0bNmjXp0aMHn3zyCT/++GO+9ZEWYdQQCN4wR44cwcvLy2CbNWtWlvVmzJiBs7Mzbm5u9O3bl/DwcA4ePMiUKVMyrFO/fn1+/PFHFi1aRPXq1fnrr78YN26cgZhkWoYMGYKHhwfe3t44ODhw8uTJXJ3n60aSJHbs2IGdnR2NGjWiWbNmlC1bls2bNwMpq/1KpZKoqChCQkKIiYmhRo0acv1u3brJBg19ysnUkz0hZpgx+gws3t7eDB48mNKlS7NmzRrWrFljtHz79u1p0qQJ3t7e9OjRA2tra+rVq5ehhT8+Pp5ffvnFYF9MTAz79+/PcEwRERG5Pp//EhUrVsTZ2Zk2bdrg4OBQ0MMRCAQCgeCtJDIykkaNGrFo0SJ5X0JCAmfPnqVp06a0adMGSFkwOHXqFPfu3aNWrVrZ70AhFdyWA4oWLYpSqSQ0NNRgf2hoKE5OTkbrODs74+7ubiBYX7FiRZ48eSJrfuU3kk7kTBMI/lMMGTKEmzdvcvz48YIeyhtHp9PRsGFDXrx4gZubG7du3TIIeyhSpAhhYWHvRPhNQWJubk5sbCyVKlUiICCAcuXKUbduXX7++ed0ZSVJQq1WEx8fj5ubG0FBQeh0OurWrcvp06cBw9CTtHXFT1Q+ooPOXTpz8uRJQkNDad68eaaGIoFAIBAIBP9SoUIFihQpwvXr1+nWrRsbNmwgISEBhULBzJkz6dq1a7bbit1oXMPiTWDee1qOytepU4fatWvLaWy1Wi2lS5dm1KhRRoVCP/74YzZu3Mjdu3flRcIlS5bw1Vdf8c8//+T9BIwgliIFgkLOggULuHz5Mnfu3OGbb75h7dq19O/fv6CH9cbZuXMnNWrUICwsDK1WK2s5pJ5MR0ZGGp1cZyVq+V9Dn4Xmxo0b6HQ67ty5wx9//GHUdVGhULBkyRIA7ty5g06nQ6lUEhAQIJdPe831ln1h0MhnJNi2bZu82nLs2LECHpBAIBAIBG8HCoXC6PNeau/myMhInj59Snh4ODVr1mT79u38+uuvjBs3ji+//JIzZ868ySG/McaPH8/y5ctZu3YtAQEBjBgxgujoaDkbSr9+/Zg27V9DyYgRI3j58iVjxozh1q1b7Nq1izlz5jBy5MjXNkbhqSEQFDAbNmxg2LBhRo+5uLhw/fr1PLXfvXt3jhw5QmRkJGXLluWjjz5i+PDh2a4/Z84c5syZY/RYw4YN2bNnT47G06pVqwy9RD7++GM+/vjjHLWXXaKionjx4gU6nY5169axadOmbHtkCI8BQWEkdeq61P8LBAKBQCDImtRabZ988glPnjxh5cqV2aob98tXr2tYWWLWK+PQ9Yz49ttvmT9/Pk+ePMHT05OlS5dSp04dIGWxy9XV1SAM+dSpU4wbNw5/f39KlCjBoEGDmDJlikFISn4ijBoCQQETGRmZLk5Nj4mJCS4uLm94RIa8fPmSly9fGj1mbm5OiRIlctTe48ePiY2NNXrM3t4ee3v7HI8xN1y4cIHevXsDKbF/I0aMYMmSJbx48UIuY2lpSXR0dBYtScB/+GtUf+o5CdHU5bC8IP/RgUKpwMXFhXv37hX0aAQCgUAgeKMoFApUKlWWGg9du3bl119/lV/rw2oXL16Mj4+PvH/atGk8evSI9evXZ6v/d82o8bYjUroKBAWMlZUVVlZWr619Pz8/tm/fjr+/f67q57ehIadGkPxi586dBmmkfvjhByDlR83S0pIZM2akq5OR8cWQ/7BBA7JtnDA1Nf033WvqOsLAUTBIKTGxwqAhEAgEgv8iWq02S4OGQqFgx44dQIoxw8PDgydPnlCmTBkWLlxI+fLlSUhI4OjRo+zcuRM/P7/sDyCHgp2CzBGaGgJBPuLr60vHjh1zXX/u3LkolUrmz5+f7liTJk0YO3Zsuv2///47devWxcbGBisrKypXrmxQbuLEiRw8eDDXY8oNrq6uLF68OF/aOnLkCJIkERYWlmU/+hStkiRhbW1NrVq15B8jHx8ftm/fTt++fQkODpaFiiwtLblz5w6AgUtcZhliBDlHNmgI3mokSaJYsWIiRa5AIBAI/vNotVo5zatOp+PmzZvUrl0bSZK4c+cOrVu3plevXuzbt4/58+fTrVu3Ah7xfxdh1BAI3iJWrVrF5MmTWbVqVbbKHzx4kB49etClSxfOnj3LhQsX+OKLLwzybGs0GooUKfK6hvzWsXr1akJCQjh//jz169ena9euXL16FY1Gg4uLC/b29iQnJ8uT7MjISIYOHcqSJUuwtbWV24mPj2fy5MmZ9mVmYZvpcUE2EAsVbw16j7GnT5++tpRrAoFAIBC8LSiVSjQajcE+c3Nz+X8LCwsaNGhgICDq4+NDcHAwkPIcfvbsWTZt2kTr1q1z1rmkKLitEFI4z0ogeAc5evQosbGxzJ49m4iICP7++2/5mK+vL0ePHmXJkiWyJ8L9+/f5448/qF+/PpMmTcLDwwN3d3c6duzId999J9f18/PD09NTfp2UlMTo0aOxtbWlSJEiTJkyhf79+xt4mDRp0oTRo0czefJk7O3tcXJyyplLXRokSWLFihV06tQJCwsLypcvz86dO3PdXmbY2tri5OSEu7s7n332GUlJSRw+fBg/Pz88PDyYO3cuxYoVIy4uDvhX7drc3BxHR0eDtvRpqPSkze4RFxNm8NpceHcI3mEiIyPR6XRIkrA0CQQCgaDwk5ycLD8P6ilTpoz8v6mpKd999x1ubm7yvoULF8rPzGmfEwUFh3gnBIK3hJUrV9KrVy9MTEzo1auXgXrykiVLqFevHkOGDCEkJISQkBBKlSqFk5MT169f59q1a9nu56uvvmLDhg2sXr2akydPEhERwfbt29OVW7t2LZaWlpw5c4Z58+Yxe/Zs9u/fn+vzmzVrFt27d+fKlSu0/j/2zjs8iur7w+9sS7IppBcgIZTQS4IgKE0RRLFRQ49SAoiAIiqg0lTAglKkSpUiRRSIAqIUJWAHQap0Qknvm7rt90d+M99ssgkBQgv3fZ59kp2dufdOuzP33HPOp3Nn+vXrV2IC0vLAZDIpx1Cn0zF8+HCef/55Jaxk7dq1QEGOj/nz5zN06FBOnDihbG+1WoupvlwvhCKnyINRILgfEfnDBQKBQPCgYDKZbL4XfhdMTU2lSZMmnDx5UlmWmJjI0qVLgeKS9IK7hzBqCAT3ABkZGWzatIn+/fsD0L9/fzZu3IjBYACgUqVK6HQ69Ho9/v7++Pv7o1arGTVqFM2bN6dRo0YEBwfTu3dvli9fXurg+/PPP2fChAl07dqVunXrMm/ePJuwC5nGjRszefJkQkJCiIiIoFmzZreUm+Oll16iT58+1KpVi+nTp2MwGPjzzz9vuryS6NOnDy4uLjg4ODBmzBiCg4MJDw8nKiqKvXv38swzz5CSkoJerwcKXA/VajVPPPEEjz32mFKOJEnFlGeERV7wIODq6qrcH+KaFwgEAkFFRaPR2ISfqFQqXnzxReW7Xq9n2rRp1K5dW1m2e/duQkND6dChAz4+PjdfuSTdvU8FRLytCAT3AOvWraNmzZo0adIEgNDQUKpVq8aGDRtK3c7Z2Zlt27Zx9uxZ3n33XVxcXBg7diwPP/ww2dnZxdZPT08nPj6ehx9+WFmmVqt56KGHiq3buHFjm+8BAQEkJCTczO4VK8/Z2Rk3N7dbKq8kZs2axeHDh9mxYwf169dn6dKleHh4MH/+fDIzM/nmm2/w9PTkmWeeAeDixYvUrVuXF154gejoaKUcq9Vqk1fAarUqFnkxky2oyGRmZir9R2FDn0AgEAgEFQlHR0ebPHRWq1XJlwHg5+eHj48PISEhAAQGBvLpp59y8eJFJkyYIAz/9xDiTAgE9wDLli3j+PHjaDQa5XPixIkyJwytWbMmQ4YMYenSpRw6dIgTJ05c1yByPQonRYICzwWLxXLHy3NzcwMKDDJFSUtLo1KlSjbL/P39qVWrFk8++SQrVqygV69eHDlyhNzcXKZOnUrv3r3Jzs5m5cqVyjbHjx9n9OjRNm6Ejo6OxMbGolarqVGjBlWrVkWr1aLVasuUc0ClUuHg4HBX8xPodDrUajXOzs4iT8J9zLPPPsvu3bs5cuQI3bt3R6MpXY296O9F7z0ZtVqNVqstdg8VZs+ePUiSRP369WnYsKGy3NnZmXHjxhEdHc2kSZNKbJNKpSIgIAAPDw+0Wu11VYUkSUKtVuPr62uTrM0ehesUL5YCgUAguFEMBoONd7PVamXv3r3K9wsXLjB06FC2bdsGwOXLl9m+fTsajYb4+Phbq1ylunufCkjF3CuB4D7i6NGj/P333/z8888cPnxY+fz888/89ttvnDp1CigYoJYldi84OBi9Xk9WVlax3ypVqoSfnx9//fWXssxsNnPo0KHy26FyJiQkBJVKxcGDB22Wnz9/nvT0dBuXwKI8/PDDPPTQQ3z22WdAQcbqnJwc9Ho9Y8eOVdZzcHBgzpw5Ntvm5ubSsWNHJk6cyPnz54mNjeXNN9+08XKxh5zI1WKxkJeXh0qlumsGheDgYAIDA8nKysJqteLv739X2iG4eXx9ffnnn3+YO3cujz/+ONu2baNXr14lrl+5cmUlPliv16PRaGxmoQpjsVgwmUwl/s7/OySpVCpOnDjBsWPHCAwMBApCVGbPnk1kZCTTpk0rFpMM0LFjR8LDw4mLiyMjI4MxY8YQFhZW6v46OTmh1WpJSEggJyen1HtHrlOlUt2SwVUgEAgEAns4Ojry/PPPK4bz+vXrA1CvXj0iIiI4fvz43WyeoBClT/cIBIIbJj09ncOHD9ss8/LyUgYDRVm2bBkPP/wwbdu2LfZb8+bNWbZsGZ988gnBwcH88ccfXLx4ERcXFzw9PXnvvffIzs6mc+fOVKtWjbS0NObOnYvRaKRjx4526xs1ahQzZsygVq1a1K1bl88//5zU1NR7dibf1dWVIUOGMHbsWDQaDY0aNeLy5cuMGzeOli1b8uijjxbbJioqismTJwMFA5/ff/9dGdD/8ssvQEHiUhmr1cpXX31VrJxJkyYREREBFAwAP/vsM0JCQtDpdCVKXhYNTTGbzQwaNKjMXjflyenTp5X/nZyccHZ2vuNtENwaH3/8MYMHD2br1q3KsoMHD6LRaOwaEmJjY5VBvr0QtMLI12qJ6/1/lyAbUyVJUjyn4uLiADh16hReXl5kZGQUM45MnDiRTp06KaFbc+bMYc+ePbRu3brEEK7CbZEkCZVKVcyYK0mSzfbCoCEQCASC8kCtVgP/e+6ZzWa8vb1p3Lgxhw8f5tq1awQFBbFkyRIGDBjAypUr+eSTT+5mkwX/jzBqCATlzM8//1xsNnLw4MFKpuTC5Ofns2bNGsaNG2e3rO7du/Ppp58yffp03njjDV588UXq169PTk4OFy5coF27dsyfP5+IiAji4+Px8PAgLCyMH3/8kTp16tgtc9y4ccTFxREREYFarWbo0KF06tRJ6cjvRebMmcOHH37IuHHjuHTpEv7+/nTs2JFp06bZNca0b99eyU9itVrp1KkTAO3atcNisSBJko1RIi8vj99//92mLAcHB9q0aWNTbl5eHseOHUOv15do1JDRarWYTCasVutdMWgUJScnh3Pnzt3tZghukJdeeqnYMtl7yx5Wq/W25XyxWq1cunSp2PLk5GS76xc11Obl5dGqVasbqs+ed5rIaSMQCASC20HRZ47RaLR5h0tLSyMtLY26desqy3744Qclufz06dNp1KhR2SqTRMBEeSJZxduBQPBAY7FYqFevHuHh4bz//vt3uzm3hddff51t27bRsGFDjh07hlqtVh5c/v7+uLm54ejoSH5+fqkDxrLi6Oio6J6r1WpUKlXJLv4CwX1EzZo1uXr1qnJ93ygiVEQgEAgE9yqF3w9LYvPmzTg4OPDCCy9gNBqZPHkybdq04dKlSwQFBREUFFSmunK/nXP9lW4Tjt1evWt13y6EiUggeMC4dOkSS5Ys4fTp0xw9epSXX36ZCxcu0Ldv37vdtNuC1Wpl586duLu7c+zYMcDWEt+iRQvlWFy6dImmTZsqv8nH5Ea9WAoP+Bo1aiQUJAQVhnPnzpGbm8sLL7yAq6vrDW8vDBoCgUAguFcxm802Sai1Wi39+vVTvteqVQuNRsObb76J0WjE19eXPn36EBgYSOvWrcts0ABAJd29TwVEGDUEgtvM2rVrcXFxsftp0KDBHW+PSqVi5cqVNG/enFatWnH06FF27dpFvXr1yrR9ee/P8OHDSyxv+PDhN1xeUc6fP4/JZGLgwIH07t272O/bt28HCowfOTk5NklT69Spw+jRo5k8eTLBwcFoNJoSlSSK4uzsjFqt5vDhw/z000+3vB83iyRJQv3kPkdWPzl8+LCNy2tpODk54eDgQOPGjfHw8Cj2u4uLS5mvCXvqJ7t27WLEiBFER0fz9NNPl7itUD8RCAQCwf1E4XxVRqORtWvXKt/Pnj1Lz549OXv2rKIe9uijj9KlSxc2btx4N5or+H9E+IlAcJvJzMwsUfZJq9VSrVq1O9yiW6O89ychIYGMjAy7v7m5ueHr63vDbSzMrl27eOWVV1i4cCHt27endevWJCUlUalSJdLS0pT1WrRogclkslFZ2bBhA5mZmURGRuLt7c3w4cPZs2cPBw4cKLE+tVqNxWJR4v5VKtVtzXNQGtWqVSM5ORmDwQBAQEAAsbGxd7wdgpvH19cXrVZLs2bN+PHHH8nJyaFt27bs27fP7vo1atTg/PnzAHh4eJCfn29XCUnG3d2djIyMUj0oCl83gYGBXL58GX9/f1JTU/Hy8uLatWu4u7vb3E9QoH7i5eXFhg0bUKlUjB07lujoaH777bcS69Lr9VgsFsXbqWhSUHuIkBaBQCAQ3AhlebZAwTudJEmKoaN9+/b8/vvv5ObmYrFY6N+/P927d+fo0aNMmzaNqVOn0rVr1zK1IXfrvFvah1vB8YWRd63u24UwaggEglsmLi6OAQMG8Ouvv6LVaosNbm6ElStX8tprr910GYWVTwA+/PBDRo8erRg1OnbsyJUrV/Dw8LBJcGhvYPT333/Ts2dPLly4ABTMbgcHB3P8+PEbMlL07dvXrrrKnUSr1RIUFCSShd5nrFy5ksGDB9uETNWrVw9Jkjhx4kSx9T09PalcubISalWeyB4bRSXsateuTWxsLJmZmTbL9+3bR6dOncjJyQEKku9eT/2kaH1lUT8RCAQCgeBmKemZ4uHhQXp6OlarFUmSsFgsNGrUiICAAH788Ufc3Nz466+/lPU/+OADjh49yoYNG8pUrzBqlC/CX1NQIXjppZfo0qXLDW8XHBzM7Nmziy2fMmUKoaGht9wuGUmS2LJlS5nXX7lyJZIk8dRTT9ksT0tLQ5Ikfv7553JrW2kcP36c8PBwfHx8cHBwoHbt2kyaNKmYBOSsWbOIjY3l8OHDfPHFF0iSVOrndra/ffv2bNmyRfnIUrqXLl0iPz+fq1ev0r17d1JSUmy2szfT26VLF2JiYnBwcADAYDBw4sSJGx5Q3ahBY/To0YwZM4bKlSuj0+lo2LAhjz/+uI27fWGaNWvGtGnTqF69Ojqdjtq1a9OnTx/Ffb9v377s3LmTqKgojh07xn///Uf79u3tuuzrdDoef/xxfHx80Ol0VKlSBU9Pz1LDbkRoS/mj0+nQaDSMGzcOT09Pm99OnjxpI9dbmJSUlNti0ICCEK2iBg0okA7OzMxEp9Ph4eGhXA9t27YlPz+fhx56iKioKBYuXEjnzp2xWq2o1Wpl+YoVKxQPr8LXmUajQZIkHBwclNmyovltSgqtktcXCAQCgaA0SnqnS01NVTxv5XfEmJgYxZBROCQTCjwlr127dnsbKygRYdQQCO5RNBoNu3btYu/evXel/t9//50WLVqQn5/Ptm3bOH36NNOmTWPlypV07NjRRtL03LlzPPTQQ4SEhNClSxdiY2OVT3h4OE899ZTNskcfffS2tdvFxYVq1aopn3r16qHRaPjxxx9JTU3FbDbz1FNPFXuI6XQ6m++SJHHlyhXMZrPSXtlSf6M0aNi4zOtGRkbi5+fH3Llzefnll5k5cyYmk4m9e/fyzjvv4ObmVmwbo9HIu+++i7OzM1u2bCEzM5N169aRk5ND3759mTBhAvPnz6d79+6K14m8L87OzjZl5efns3fvXrKzs1GpVFy9ehVJknjkkUeK1SsPGsWsefkTHBzMI488Qnx8fDEDHNjG/N52rnN61Wo1oaGh5Ofnk5aWhr+/PwBPPvkkq1ev5tKlS3Tv3p3NmzdjMpno1KmTzfKMjAyWLVumZJ338/MDCq5rlUpFfn4+FosFjUaDWq3GarXi4OCAo6MjZrNZuf5cXV0VQ931stcLBAKBQFCYshjC09PTqVOnDg4ODsVUwC5evEiVKlVupMK796mACKOGQFAGLBYL7733HlWrVsXBwYHQ0FB++OEH5ff8/HxGjhxJQEAAjo6OVKtWjRkzZgAFgxOArl27IkmS8v16ODs7M2jQIMaPH1/iOj///DOSJNmEahw+fBhJkrh48SJQ4PXh7u7O999/T506ddDr9fTo0YPs7Gy+/PJLgoOD8fDwYPTo0cpAwGq1MnjwYOrVq8e3337Lww8/TLVq1ejZsyffffcdv/32G7NmzVL275tvvmHVqlVIksTQoUPx9/dXPnLCQvm7g4MDQ4YMwcPDA71ez9NPP82ZM2dK3MfExESaNWtG165dycvLw2KxMGPGDKpXr46TkxNNmjRh06ZNxY7J7t27adasGc7OzqhUKg4dOqSokAwePLhYPfn5+Tg4OBAYGIhKpUKn0ykDJNmwdLPJCGMuXSzzuhEREcyaNYsOHTqQn5/PhAkTSEpKQq1WExsbS69evYptc+TIEaxWK8eOHaNmzZpKDgU3Nze6devGxo0b+eabbzh16hQffPABVquVX375BZ1OR15ent39ysrKIjc3l9DQUDIzM+3mESlqzBAz4+XH6dOniY6OBgoG6PfysTWbzRw+fBgouCbknDuTJk1i165dJCUlYTQa+e677xg2bBgffPCBzfK33noLHx8fNBoNFovFJmdPfn4+zZo1w2q1YjQayc/PR6PREBAQQG5uro1xNTMz08boaLVaqVq16p05CAKBQCC4rymcC01GTrYuEx4ezh9//EGDBg34999/WbRoEZcuXeK7775j48aNFVZJ8H7Avi+zQCCwYc6cOXz66acsXryYsLAwli9fzvPPP8/x48cJCQlh7ty5REVFsXHjRoKCgrh8+TKXL18G4K+//sLX15cVK1bw1FNP3ZA86JQpU6hVqxabNm2iR48eN93+7Oxs5s6dy/r168nMzKRbt2507doVd3d3tm/fzvnz5+nevTutWrWiV69eHD58mBMnTvDVV18VG/A2adKEDh06sG7dOsaNG8dff/1FREQEbm5uzJkz57qKBS+99BJnzpwhKioKNzc3xo0bR+fOnTlx4kSxEIfLly/TsWNHWrZsqczkTps2jTVr1rBo0SJCQkLYt28f/fv3x8fHh3bt2inbvvPOO3z66af4+PgwdOhQEhMTS/SykOMp8/LylPOWn59fbNB+s7O/mZn2E6Hao02bNgDs3LmTnTt3AihGii+++OK629epU0f5PyMjo9h188cff5RZQQNQBqtlQXhs3D7u6rG9QXuKfJ+1bt262G+fffYZn332mc2yvLw8mjRpUmJ5hWOWocBLRTbaXs9z6sqVK2VpskAgEAgEAMWM44WTbcsKJ7JS3qxZs5g1axaSJOHj40P16tXLXpFQ7SpXhFFD8MAzbtw43n33XZtl+fn51K9fX/k+c+ZMxo0bp0iCfvTRR+zdu5fZs2czf/58YmJiCAkJoXXr1kiSZKMA4uPjAxSoDMhu2WWlcuXKvPrqq7zzzjs3lTNExmg0snDhQmrWrAlAjx49WL16NfHx8bi4uFC/fn0ef/xx9u7dS69evZR4/ZJkXuvVq8f+/fsBlHwbTk5O190/2Zhx4MABJaRj7dq1BAYGsmXLFnr27Kms+99//9GxY0e6du3K7NmzkSSJvLw8pk+fzq5du5RwiBo1arB//34WL15sY9SYNm2a8j0wMJCEhAT69u3Ljh07SE1NRZIkXFxcMBgMdgeM9pYJlQWBoBSsgPS/WS5JkkQYiEAgEAjuC+wlDFWpVGi1WmWia+LEiSQkJPDdd9+Rl5dHcnIykydPpk2bNly6dIlKlSrdpdYLhIlI8MDz5ptvcvjwYZvP8OHDld8zMjK4du0arVq1stmuVatWnDx5EijwPjh8+DB16tRh9OjR/Pjjj+XWvnHjxpGYmMjy5ctvugy9Xq8YNAD8/PwIDg7GxcXFZllCQoLNduU9O3zy5Ek0Gg0tWrRQlnl5eVGnTh3lWALk5OTQpk0bunXrxpw5cxTX+7Nnz5KdnU3Hjh1xcXFRPqtWrSqm6tG4cWNlH44cOUJubi4DBw5UXPmtVquiylASRb1OZIPG7Zo1v5dDDASC6/L/l6/FYsFiseDo6Hhjs1YCgUAgENwlZMWtwh7V/v7+5OXloVarcXV1xdPTk40bN+Lt7Y1arSYoKIg+ffoQGBhI69atCQoKuot78GAjjBqCBx5vb29q1apl8ymqNnA9mjZtyoULF3j//ffJyckhPDz8lsJFCuPu7s6ECROYOnVqMdUReUa08CDbaDQWK6NoWIckSXaXyYP22rVrA9gYGgpz8uRJZZ3bgYODAx06dOD777/n6tWrynKDwQDAtm3bbIxQJ06csMmrAf/b5/Pnz2M2m8nMzOTatWtkZmYyZMgQm1nkkowUJRk9bpfxQYRvCCoSWVlZSmJagUAgEAjuZWSDfGEPQ1nNxGQykZmZyeuvv45KpSI2Npb09HQcHBx49NFH6dKlixKaUmZEotByRRg1BILr4ObmRuXKlYslSjxw4IBNiIqbmxu9evViyZIlbNiwgW+++UZRLdBqtbfkhj1q1ChUKhVz5syxWS6HtsTGxirLbiQHQkmEhoZSt25dZs2aVSzc4siRI+zatYs+ffrccLn16tXDZDLxxx9/KMuSk5P577//bI6lSqVi9erVPPTQQzz++OPKQ6V+/fo4ODgQExNTzBAlS7cWRR5U5efnK+dDo9EoLoVQupGiJBlVgUBQNoKCgmxC8gQCgUAguFcp7MUMBZOLMl26dGHYsGEkJiaSl5dHixYtWLZsGX369OGDDz5g8+bNd7i1Ahnxti6oMKSnpxcb0Ht5eZU42L0R3nzzTSZPnkzNmjUJDQ1lxYoVHD58mLVr1wIFye8CAgIICwtDpVLx9ddf4+/vr3SEwcHB7N69m1atWuHg4ICHh8cN1e/o6MjUqVN55ZVXbJbLg/kpU6Ywbdo0Tp8+zaeffnrL+ytJEsuWLaNjx450796dCRMm4O/vzx9//MHYsWN55JFHeO2112643JCQEF544QUiIyNZvHgxrq6ujB8/nipVqvDCCy/YrKtWq1m7di19+vShffv2/Pzzz/j7+/PGG28wZswYLBYLrVu3Jj09nQMHDuDm5saLL77IH3/8Qa1atXjsscdsDEmVK1dWvi9atAgosMpfL0/GHZXOFAgqIDExMcWkgwUCgUAguNeQJKmYl25GRgaOjo54eHjwyy+/8OGHHzJ9+nS0Wi0TJ04ECibdzpw5w/r16+natWsZKxO+BeWJMGoIKgw///wzYWFhNssGDx7M0qVLb7ns0aNHk56eztixY0lISKB+/fpERUUREhICgKurKx9//DFnzpxBrVbTvHlztm/froSHfPrpp7z++ussWbKEKlWqKJn7b4QXX3yRTz/9lBMnTijLtFot69at4+WXX6Zx48Y0b96cDz74wCbh5s3y6KOP8vvvvzN16lSefvppMjMzCQoK4sUXX2TChAk4ODjcVLkrVqzg1Vdf5dlnnyU/P5+2bduyffv2YuEwUOAlsW7dOnr16qUYNt5//318fHyYMWMG58+fx93dnaZNm/L2228DBeosly5d4uDBg2g0Gq5du8aIESPIzs7mww8/VMq2Wq02ITcCgeD2kZWVhUqlQqVSERAQwLVr10QSUYFAIBDcU1it1mLPJovFQl5enpJ37rHHHgMKFPHatm1LWloaHh4eVKtWzSZkWnBnkawiiFsgEFRgrFYr9evXx2q18sEHH/Dhhx+SmZlpd91KlSqRnp6ufJcTRtnLUyIQCG4ce9nlBQKBQCC4l3FzcyMjIwO1Wk2TJk0USVeNRsP8+fPRaDSMHDkSFxcXRR3weuRu/+J2NrlUHDsPvWt13y6E34tAIKjQfPfdd1gsFqxWK++8806JBg34XyJSGYvFIgwaAkE5YrVaUavVNtnlBQKBQCC4V3F0dFQS9detW5d//vkHHx8fJEkiODiYDRs2kJqaitFovLFQS5Xq7n0qIBVzrwQCYO3atTayn4U/DRo0uKtta9CgQYltk/N0CMqHNm3aoFKpyqRoI9zhBYLbj9lsxsHBATc3N3Q6nUjGKxAIBIJ7ltzcXCW/2vHjx7FaraSmpmK1Wjl37hx79uzhzTffxGq18sgjj9zl1j64iDcJQYXl+eefp0WLFnZ/s5e/4U6yffv2Ej0A/Pz87nBrKjb5+flYLBYyMjKYPn06p0+fZuXKlahUKqxW63Vd4Vu0aGGj1iIQCG4BK7i6uZKZmYlKpeLhhx/m999/v9utEggEAoHALn5+fiQlJSkTX++99x6NGjWid+/e5OXlAQVeiK1bt2bQoEFlL7iCSqveLYRRQ1BhcXV1xdXV9W43wy5C3vDO0759e7p160bz5s2vq3hSmOPHj9/mlgkEDxASSgiYxWLhzz//vKH7USAQCASCO4mzszPx8fFAQQ6NKVOmKM8sDw8P0tLS+Pzzz5k2bRrfffddMaVCwZ1BhJ8IBIIKjaw3HhwczJUrV8jMzGTevHm4uLgglcFKXjTPRmk4ODig0+lo0aIFM2bMuK7x6q233uLAgQMcPnyYF198ES8vLxwcHKhfvz6VK1cutr6s+nLs2DFOnTrFP//8w7Bhw/D09MTBwYEWLVowZ84c6tevj5OTE1OnTuX3339n6NCheHh4oNPpaNmyJa+88gqurq6K+3/jxo1p0qSJotbj7OzMCy+8gLe3t3KMJEmy+789VCqVja77vUa7du3w9/dHp9NRt25dlixZwtChQ6lUqdJ1rwk/Pz9GjBhBdHQ0kyZNwtHRsdg6/v7+LFq0iMjIyBJVgkaPHs2+ffuUetVqNQEBATg5Odldf8mSJbz77rtUrlwZrVZ7XfUhSZLw8fHBz88PnU5nN85Xr9cr1+v06dMJCAhQfpOvBUmSqFq1Kl999RVvv/22ck04OTlRt25dAHQ6naJsIiPnzSiaO0M+vmq1murVq+Ps7IwkSUoYSuH9Gj16NNHR0Rw5coRdu3bx66+/MmHCBLy8vOzus6OjI1qtFn9/f7y9vZXyioa3yO0MCgpS2le0rgMHDjB06FA8PT3t3tNffPEFx48f59SpU5w8eVL5O2DAAMUTcOzYsfzzzz+8/PLL6PV6Zf9DQ0P54Ycf+Ouvv/jvv//47bffOHz4MD179sTd3R0HBwfefvttoqOjlTbI9/fOnTs5efIkYWFhyrF0c3NjxowZbNmypdjyd999l6FDh+Li4sIjjzxi9/ouLb/J888/T6tWrUr8vSh+fn4sXryYI0eO0L9/f5trwh5OTk60bdsWf3//6957zs7OVKpUqcxtuR7h4eHKOV++fLnde7kwDRo0oEePHnh7e991b0+BQHDnOH/+vPK/yWRSDBqOjo5Kcvn58+fz6KOP8sUXX5TdSC+p7t6nAiLUTwQCQYUmPj6etm3b0qlTJ1566SX69OnDL7/8wtNPP42bmxu+vr7Ex8cTHx9PzZo1OXfu3HXL1Gg0SnyljEqlwsHBgbp163LmzBkcHBxYvXo1Xbp0IT8/v1gZkZGRDB06lKVLl3Lt2jV+/vln3n77bZYtW4ZerychIYGEhAQsFgsBAQGkp6fTrFkz6tWrx8iRIzGbzfTo0YPY2Fg++ugj3N3dGTlyJFqtltWrV7Nz50769u1L7969uXbtGuPGjaNOnTqMHj2axMRENBoNkyZNokGDBrz00ktkZmbSvXt32rRpw9ixYzGbzfTq1Yt+/frx1ltvcerUKZo0aUKVKlXYvn27sh8eHh6kpqaWeHw8PT1JSUm5mVN3W2jfvj3R0dHUqlWL1q1bk5qaSlRUFCaTicjISB566CGGDRtmE5YkSRINGzbkzJkz5ObmotfrFWnmWrVqcfLkSSRJQqVS0bVrV0wmE1FRUUDBsRgyZAg//fQTZ86cAWDgwIGMGDGCwYMHc+zYMV555RWuXr3K5s2b7YZDubq6Mn78eCZNmkRISAg9e/bk66+/5tSpU9fdX5VKxZo1axg2bJhNklydTsf06dPZuHEjJ06cwGKxIEkSlStX5uLFixiNRlQqFfXr1+fs2bOYzWZMJhMvv/wyLVu2ZOrUqcq9EhAQQFxcnJIEVE7MWxg/Pz9lpgsKBqhZWVkEBgZy5coV3NzcyM/PJycnB/jf/TF+/Hgefvhh+vXrxzfffMOUKVPo378/er2exYsXF9vXqlWrEhMTg1qt5rnnnuPQoUPExMQQHBzMtWvXlHuxsArLqFGjFKnqZs2a0a9fP+bNm8eKFSv45JNPcHNzY9SoUeh0OlavXk1UVBTDhg1j+fLlVK5cmRdeeAGTycSUKVPYsWMHU6dOpW7dulSuXJlevXpx+fJlVCoVY8aMYe3atcTFxeHp6cn333+Po6Mjr776KkeOHCE7O5v33nuPlJQUunbtSr9+/bhy5Qoffvghbm5uTJ8+nYyMDIKDg/n999+JjIzk9OnTSqb9sLAw/v77b1566SWcnJxYt24dmZmZfPPNNwwePJjk5GQ0Gg2urq6kpaUVO0cODg7k5+cryyVJQqPRlDlZco8ePTCZTHz//fd4eXmRmJioHOeSXvK9vLxITk6mcuXKXLt2ze46Tk5O5OTklKtyjmwYDAsLIyEhAVdXV/7+++/rbqdWq/Hx8QEgMTFR5GESCB4QfH19yczMRK/Xk5ycrCx3cHDg2WefpUmTJrz33ntIksSRI0fKlAw798cVt7PJpeL45MC7VvftomKaagQCgQCIioqiU6dOAOzcuZO9e/cC8Pjjj5OdnU1cXBwnTpxQBlsXL14sU7lFDRoAw4YNQ5Ik/vnnHwwGA8nJyRw9epQOHTrYLSMiIoKFCxeyePFiDhw4wPDhw3nmmWeoXbs2586dIyUlRZm1jo2NJTs7m3379tG/f38sFgsLFy7k7NmzvPLKKzz++OOEhobSvn17kpKSOHLkCH379mXBggVcuHCBgIAAZs6cSZMmTQgNDQUKcoU899xzfP/990p+g2rVqtGpUycef/xxADZs2ECVKlWIjY0F4MiRIzYGDZ1Oh1qtLuZdUPj4pKam3lNKF7GxsYohIiIiAi8vL0wmE15eXqxdu5aWLVvanDPZI+Ho0aPk5uYCBYkuVSoV4eHhVK5cGZ1OR58+fbBYLLz66qsEBQVhsVhQqVQ4OTkxfPhwWrdubeMhsGTJEo4ePYrFYmH58uXs27ePevXqKXUWJi8vj9mzZ2M2mzl16hSfffYZSUlJaLXa684YWywWfv3112IeR0OGDOHEiRMcPHgQg8FAdnY2bdu2JSUlRRk4WiwWnnvuOUUFyGq1smrVKkJDQxWjjXxMCw+Ea9WqVawdiYmJNt+zsrIAuHz5MmFhYeTl5WGxWBSPBvn+2L17N507d2b+/Pl8/fXXBAUFsXnzZg4cOEBQUFCxfY2JiVHO0ZYtW8jKykKtVnPx4kWGDx+uzMbL7fXy8iIiIoJVq1YRHR3NM888w7x589i0aRPDhg3j5MmTNG3alJYtWyr39ODBg/n888/5/PPPad26NZ9//jlWq5UdO3ZQqVIlnnrqKUJCQvj55585d+4cZrOZ0aNH079/f+rUqUN+fj5xcXFotVrWrVvH6dOnSUpKwmQy8eSTT9K1a1f279/P6dOniYyMVNrQu3dv4uPj+eOPP2jdujVvvPEGXbt2xWw2Yzab+fvvv2ndujU1atSgTp06bNmyBbPZzIYNGxQjVdu2bUlNTWXs2LHFzlFeXh6ffvqp8t1qtSoGDXuhnEWvvVdffRUPDw9MJhPx8fFYLBZ69uyp9MH2kAcH165dQ6fTUbNmzWLryF5GRQ0a1/MCuR75+flER0fz33//8ffff6PX66/rXWc2m4mLiyMuLk4xaNxL/ZtAILg15Pu5sOeYJEmkp6eTk5NDZmYm77zzjvJ7fn4+VapUoWrVqjg6OuLs7Cz6hLuE8NQQCAQVFoPBQFxcHM899xydOnXi77//JjExkcDAQNzd3ZEkCZPJxIkTJ265rvKcRQREngHBA4c8SPb39ycjI0Nx6xUIBAKB4F6hcIifxWLBYDDg7+9P1apVuXjxouI9dz1yf1p5G1tZOo4dX7prdd8uhKeGQCCosLi4uFCrVi0aNmyIl5cX0dHR+Pj40KdPHxISEsjIyFAMGhqNpsRZ77Lk3rgRbnWGUXBvoNPpbL4XzQlRUSnv+0GmVq1aPPzww1y+fLlEg0aVKlVuuZ57fRatpP7hRo+7vTwqgtIRuTIEggeXku7/nj170qZNG6Dg+aHRaGjfvj21atUiMjKSatWq8fPPP1O/fn2qVq16J5ssKIR4sxYIBBWegQMHsnHjRrZs2cKzzz7LrFmzSEtL49KlS8oAwmw2lxo7Lsu/Fs210KBBA+V3e4MOHx8fZfAbHBxcZg8MeZ0mTZqUyyAyMDCwTOtVJIOLvC9+fn5KWENJFD3GZRncTJ482ea7yWRS5N1kCiepvJnzeL3khTfK9Y6DPYom2pQk6bZIT5vNZg4cOICbmxtQkI+lcePGNuvIv90KFouFxo0bKyEVRa/5wklSZTw8PIDihiyZ8jT0lNQ/lOYJZu96lUN8bjdarfamrqu7wfUMPc2aNbtDLREIBPcChfvOkt4BTSYT0dHRSpJ0eRLsn3/+YcGCBTRv3pzvvvuOjRs30rdv37JXrlLdvU8FpGLulUAgEBSic+fOjBs3jrlz57J69Wrc3d2VZIbyAKK0AYNssCiq+mG1Wm0kX+2VkZiYqCQnvHjxos2ARVbAePTRR0us+8iRI0q5Wq0WjUaDu7u7ouoCtioWc+fOZeDAgcpyrVZLlSpVSEtLU9oeEBCAh4cHKpUKFxcXNBqNoj6h0+mUpJcy8kNcr9dTt27dEgd2JVG7du0bWr+8kI91fHw82dnZpa5b9NwVfrmRB/WSJFGzZk1Fmeadd965bhtMJpPivVG4jsLnpjTpaTmPh5eXl6LEUbly5Zs2Pl3vONijsGeDfN0VTvpZlMIqOQEBAWX2GDh9+jQAGRkZNGvWjLVr19KiRQu8vb3R6XQ0a9aMjz76iBUrVpSY+0CSJLy8vGwG2YWPlUqlwmq18u+//9pIyxZW7ejbty9qtRqr1aos//nnn1mxYoWiEPP6669z8OBBXn75ZZycnGxyivTr1499+/YxYsQIPD09FWUYjUbDQw89RNeuXct0PG6EsibzvB0Yjcabuq7uBtcz9Pz22293qCUCgeBeoCx95+bNm5Uky2azmZycHHbu3Imnpyd6vZ6tW7eyYMEC3n77bZ5//vk70GqBPYRRQyAQPBD079+fvXv3cvz4cSIiImwGajVr1lQGloWNFqWFpMjoHEsekCrYmcWNjIxkwIAB9OzZk19//RW1Wl1sVrooISEhdOjQgezsbCXxo06n47333iM0NJTjx4/z3nvv2Sz39/fn6tWrAMybNw9JkoiNjVUGyN26dcNsNiNJEs7OzgQHByvGHvlYWK1WTCYTVquVU6dOKUaass7Wy4PV+xHZ1TQkJARHR0diYmLKPAPu4OCASqUq5r0hnxs/Pz/l3LzwwgullpWcnEz9+vUJCgoiNja2zPlWSjOYlAU570yNGjXQ6XQYDAY0Gk0x743CyCoofn5+xMbGlnq8Ct9vKpVK+d6tWzd++OEHVqxYwfDhw1m/fj2Ojo50796djIwM+vfvb7esSpUqkZycTHZ2tiI5W/haLnrcqlSpQr9+/XjkkUd45ZVXCA8PZ/369YwZM4bw8HBlebdu3cjJyWHZsmUMHz6cfv360atXLxYvXozZbGbkyJFKHWvXrqVv376sXr1aibl2cXHB0dGR//77T3lBvh516tTB09PzuuuVzO0JExIIBIKKhL1+tvDEERS8C8ybN4+GDRsqkz9Llizht99+4+jRo+zYsYPw8PA71WSBHYRRQyAQPBBMmTKFOnXqUKdOHT799FMeeeQR5bd33nlHMRIUnk03mUw2Rg17Lub5uZnFlhXDjgdHREQECxYsUGa81Wo1165dIyQkpMRiTpw4wQ8//GAjESurWPz5558YDAaSkpLYtGkTw4cP5/jx4yQlJaFSqcjMzMRgMCjKHufOnWPQoEEcPnwYSZLIy8sjPT2dq1evKgaWot4LstymjJ+fX5k9Btzc3BQX/vsJBwcHGjVqxJkzZ8jJycFoNJKeno63t/d1t83Ly7M7eB0yZAjHjx/nypUreHt7k5mZyZ49e+yqhhRm//79nD179oaOY5cuXcq8rj30ej21a9fm/PnzynWn1WrtqlQURlaJuB6FrzHZmwGgdevWfPHFF5hMJgYMGMCvv/7KRx99hNls5q233mLr1q3F1E+sVitpaWlAwXmTJXRL8xTp1KkTI0eOxMPDA4vFwpkzZ5AkiYiICN58801FzePcuXO89dZb+Pr6MnjwYObNm8fZs2exWCxUr16d4cOH06FDB2V/rly5wvDhwxWZ0oyMDAwGAwaDQTEUyX1LUcOp3M/07du3VOWQ6yPywAsEAkFJyM/S+vXrF3tOyLkxJEmiadOmGI1Gfv/9d65evYrZbKZq1ars2bPnluq3StJd+1REhPqJQCB4IIiPj+fcuXMkJCQwbtw4AgMDuXz5MlCQt0B28xcIiuLu7q4MlgV3Hq1Wi9lsRq1WYzabhSqQQCAQCO4677zzDhERETe9fc6e1eXYmhvDqf2Au1b37UJ4aggEggcCPz8/Hn30UWV2VzZoODg4KDOjRWfVZffD26X2ILg/EAaNu4tsxNBqtXfdoOHo6HjD/UFFSr4rEAgEFRm5v5Y96Hx8fJAkSQnXlfOQOTs788wzz9xaZZLq7n0qIBVzrwQCgeD/iYqKIiwsjEaNGlGnTh1efPFFAKpXrw4UhAjIYRUmk0nZrnr16kpSwPJwaCsanykQ3M/caq6OopQmhSt7Z8jGhFvLM/E/ioZ92GtDUXm+3NzcYv3B9fLu3G1DjEAgEAhKp2jeJTnvmsFgoGrVqjg7O/Pmm2/i5eWFyWRi1KhReHl53bX2Coojwk8EAkGFxmAwKIkDU1NTuXz5MpMmTaJJkyYcOXKkxO1UKhWVKlUiNTX1DrZWIBCUhiRJeHh4IEkSqampwmAgEAgEgjuCHAIJ4Ovry6uvvkqPHj1uurycn9eVV9NuGKfH+ty1um8X10+/LRAIBPcxLi4uNl4Su3btAuDo0aNoNBob74zCPPXUUxw8eJDatWvf1+odAkFFonAuHDEnIxAIBILbhSRJijR5fHw8JpMJnU6H1Wrl448/vmF5e8HtRYSfCASCCo0cfiJ/ZCu7LFNaEtu3byclJaVMCg4CgeDOEBMTg9VqVQwabm5ud7lFAoFAILhfqVy5com/6fV66tati06nw2Qy4eDggFarxWg0YjAYqF279h1sqeB6CKOGQCCo0CQlJZGcnMzly5d5+OGH8ff3BwpmfKH02V6j0UhGRkap5bu6uqLT6WjYsCFt2rRR4jBLwsXFBa1Wi7Ozc4kJBAMDA/nqq684cuQIX375JdWqVSu1TJnrJTAsLW/B/YacuEuj0eDu7m73WI4ePZro6GiOHDnCypUrleNY0jnS6XS4uLig0+lo0aIFzz77bKnnU6VSiZma66BWq3nooYeIiopi+fLlVKpUCSg4dgEBAXh4eKDVanF0dAQK5Fe1Wi0NGjTgyy+/ZP369dSqVYsxY8awf/9+jhw5QteuXVGr1ahUKsaPH8+xY8f477//OHDgAAcOHGDo0KFKeZIkUatWLUW6b+XKlRw7doxTp05x8uRJTpw4QZs2bUq8F+Xlzs7OzJ07l0WLFlGrVi2791pwcDBLly5l//79tGrVqsT7cfTo0ezbt49WrVop5Zd2777//vts3ryZxx57jDfffFO5pnft2sXYsWOpXLkyWq2WevXq0aVLF+UYQ0HyY41GQ0BAAJ6enqjVaptr2tPTE71er3y31w5JknB3d7dJpCzfW4cPH+b555+3u13h+++PP/7gnXfeUdoqn5/C6xw7dowRI0bg4+ODg4MDzZs3JyoqitWrV9O4cWMA1q1bx8mTJzl16hT//fcf//33H8ePH2fv3r389ttv/Pvvvxw+fJgTJ05w6tQpJk6cSOXKldHpdPj6+uLm5oaDgwMtW7Zk+/bt/Pvvvxw9elQp859//uGPP/7gyJEjfPXVV3Ts2BEnJyebYxEaGsoPP/zAkSNHiIyMxMvLC51OR5UqVZRjJF/HVapUwdXVFbVajY+Pj12JZ7Dtk0RiaoHgziHLbtsjKyuLEydOcOHCBaAgB1tWVhYAI0eO5L333ruluoWka/kijBoCgaDCkpSUxCuvvMInn3zCjh072Lx5M0ePHgVQcmVIksSUKVPsbl9SAsA6deoABQOe1157jbCwMM6cOUN0dDSdO3cutU1WqxVfX1+ysrLs5gPo1q0b1atXZ+jQoQwfPpysrCxef/31UsuUX5RlA02tWrWKrVOtWjXy8vJKLed+oVGjRqjVanQ6HRaLhczMTMXAITNw4EAGDBjAlClTCA8PJzs7m9WrV6PRaBRvnaIYjUbMZjNNmjThypUrbNu2rcR1oSChWH5+frnvX0WhY8eOrF69mkuXLtG9e3c2b96MyWSiU6dOhIeHExcXR0ZGBmPGjCEsLAyAKlWq0LhxYy5dusTAgQNZsmQJTzzxBAMGDGDDhg088cQT/PDDD3z00UdMmTKFTp068e6772IymfDw8GDNmjUsWbIEi8XCG2+8QdWqVYmJiSEjI4PIyEiaN2/OunXr2Lp1K5Ik8cYbbxAdHU3btm354IMPinl+dOrUiXnz5uHo6Mirr75KVFQUZ8+eBWwHn05OTnTv3p0mTZrQs2dPDhw4QLt27ZgyZYrNdRkZGcmAAQOUdTp27MhTTz1VqnF1zpw57N27lyZNmhAeHs57773H+vXr+eeff5g7dy5NmzZl06ZNAGzZsoWuXbvSrVs3pY0NGjQgLi4Os9msfHQ6HSEhIaSkpJCdnU3z5s2RJKlYO+R9TEtLU2Yq5X2YMmUKHTp0YMeOHahUKhvDUOF11q9fz/79+/n444/x9PRk4sSJdOzYkeHDh9uss2LFClavXk2XLl1Yt24der2eIUOGUKtWLebMmcPw4cNp2LAhp0+f5ty5cwDk5OSwbt06/Pz8cHZ25q+//lKO99atW/nwww8ZOnQoTZo0ITU1FaPRSIcOHcjPz2fQoEFKm61WK9euXUOr1aJWq0lISECj0VCtWjWMRiMajYZx48bx0EMPceLECSIiIpg7dy4rV65k+PDh9O7dm/j4eCwWCzqdjqlTp+Lv768MmJ577jmSkpIwmUxUqVKl2Dk2m81lMrQLBII7h6urK0888YTST6hUKho1akTNmjVtjJiCewORKFQgEFRY/vzzT55//nni4uKIiopi3LhxqFSqYmEnXl5eJCcnl7lclUqFxWKhW7duuLu7s3z5cuU3Pz8/HB0duXTpUpnLc3R0JDc3F4Do6GgWL17MmjVrCA4OJikpiVatWnHo0CESExPLVJ6npycpKSll3o/7jXr16gFw8uRJoGCW08vLCw8PD/777z8AJk+ezOXLl5Vz4+Liwv79+wkNDQWwO4ArTGn5VgrTsGFDjh07diu7U2GJjo5mxYoVNvfH66+/Tu/evWnXrp2iOuTg4MCePXto06aN3evx77//Zv/+/bz22muoVCrc3d355ZdfyM3NZeHChSxfvpwjR47w999/M27cOFJTU1Gr1Rw+fJiff/6Z1157DaPRyL59+5T2REdHs3btWpYuXYqXlxfe3t588803ZGRk8PDDDwMFieAsFgsHDhzg0qVLPPnkk2i1WqxWK7169eKrr77CarXi5uZGXl4eu3btstlfFxcXfv31V15//XUll090dDTLly9nxYoVQMGMvpOTEx4eHpw5c8bucdRoNPj7+7Nu3TqOHDnCG2+8wU8//UT37t1p3749Y8eOZdmyZWzatInU1FTFG8zT09MmH5BsoJCve0mSUKvVmEwm9Ho92dnZyrp6vZ6cnBxcXV2LeasVPa+SJNGrVy8yMjLYvn17sXWio6OVtmZkZLBv3z72799PdnY2S5cuZfny5ezbt49nn32WoUOH0qtXL5YvX07//v15/PHH+fDDD3nyySfJyclRzvcff/yBu7s7+fn55Obmsnz5cl5++WV0Oh1ffPEFgwYNom/fvjg5OfHFF1/Qpk0bhg0bxpdffknfvn2ZPXs2AEeOHCEjI4ODBw/y6KOP8tVXXzF48GA0Gg2zZs3i22+/JSMjgyFDhlCvXj0eeeQRmjVrBhQMeKpUqUJSUhKSJNGnTx/mzp3LiBEjyMnJUc6xfC0YjUaMRiN6vZ6srKwS+x8nJyfy8/OLGVTv1/5aILiXcXJyUp5F9ijcNzZt2pRr166xYMECLly4wBtvvMHhw4cVz7MbJXvfxpvarjzQtw2/a3XfLoRRQyAQVFhSU1OpVq0av/zyC97e3rRr145Jkybx4Ycf3vBsmL0XSp1OZ3em3tXVlczMzJtud3h4OKNGjWL79u188cUX1zW4VK1alc6dO/PLL79w8eLFCuORIbj/GT16ND179sTV1ZWJEyfy/fffY7VaUalU+Pn5kZubi8FgQKPRkJOTQ58+fejTpw9VqlRR7i+NRsPhw4eZOnUqBoMBg8GgvGS+8cYbdOvWDVdXV6xWKzqdThm8f/zxx/z0009cvXpVGSC2a9eO//77j8TERFQqFVarlTp16jBlyhSWLl3Kzp07bdpfpUoVMjIybul+Lk/k41m0bxg9ejQ9evRgwoQJ/Prrr0r/plarsVqtxfoueYbRxcWFtLQ0u3XJxpF7WQFK9hApiwFSIBAIyosxY8Ywa9Ysdu7cSXBw8E2VIYwa5YsIPxEIBBUWDw8PvvzySyIiInj88ceJiIjgpZdeKpNVXVZM8fHxKWbQkOOfSwo9uJUBUN26ddmxYweRkZF8+OGHdO7cmWXLltkouBTlypUrnDp1ipycHMxmM87Ozjddv0BQXtgLU3BwcLAbfhIaGookSVy9epWZM2eyceNGjEYjb731Fr1790aj0bBq1SpFnrlGjRq8/fbb9OrVi48//piUlBS0Wq3NPVm3bl0uX76s3LudO3fm119/xdnZWQkzcnBwwN3dncGDByteDU5OTnTr1g2VSsXVq1cVL6qaNWuWuK+FQy8kSbLJw1Dex3PUqFE2fcPQoUNtQlratWtHhw4dgIKwBjmPkIeHBwEBAUobg4ODSzRoSJKEwWCwMWiUd66Hwrk8SmrD9eoMDg5Wzq+9vChFty/sLl40X47cx7q6utqtS6VSiXwXAsEDiNy31K5dmzZt2lC5cmUCAwNRqVRK/yq4+wijhkAgqNB07dqVadOm4erqytatW2ncuLHiyVCat8Zjjz0GQGJiIhaLhXr16tGwYUPCw8MZOXLkbWvv4sWLMZvNnDp1CqvVyubNm2nevDlt2rQpdbt9+/YRExOj5I94kLhectayUlKySMGNI0kSERERLFy4kN27dyv5BEaMGMH777/P1q1bsVqtmM1m5syZw6effookSezbt08JRVi5ciW7d++mYcOGbN++HTc3NzQaDS4uLri7u9O/f38WLVrEd999h06nY+7cuTZtWL16Na1bt8ZqtTJo0CBiYmKoVasW58+fR6VS0b9/f5ydnfH398fBwYELFy4gSRLTpk2jZcuWSv9gNBqRJInt27fj4OCgvMQ6OTkpxguLxYKXlxdw89dRSfHZcjLagQMHsnTpUmJjY6lSpYrSNwwZMoQFCxYQHx8PwF9//cXhw4cJCQkB/pcIz2AwKCFsRqNRyQ1ir82F+0aVSkVISAiSJKHX6+22s1GjRsqAvyz3Y1HvCnv5ixo3bkz9+vXtlinXlZiYyDPPPAMUGKCDgoJK3A8oMKR4enoqbSic30JuT0lGaYvFYveZUd7GDhGnLxDcXeRnDWAzoXTx4kVeeOEFrl27xocffkj37t1vOvQEAEm6e58KiAg/EQgEFR6DwUBycjL5+fm88MILjBo1itmzZ2M2m8s8IHZxccFgMAAFL9ilJZAUCAR3FzlniiRJxTw4roder8doNOLr61um0JOAgAByc3NJS0sTSR4FAoHgASAsLIyVK1feklEjO/rrcmzRjaFv0/Ou1X27ENNSAoGgwuPi4kK1atVYtWoVTz/9tJIIMDc3l2effdbuNkVlVGWDRqNGjWwMGndidl+r1Qq3Z8EDS2nXfqVKlUr8XaVSERwcfEMGDZ1Ox3vvvYefnx9Xr14F4IUXXih1m9jYWHQ6XZkNGrc0sycQCASC20pJz5SQkBDUajVNmzZl/fr1t96Xq1R371MBqZh7JRAIBIWIioqiSZMmbNiwgd27d7Nv3z6gYEb2+++/x8PDo9g2RdVLZDfzo0eP2jzwyiP0oXB59h6mRqOxmNSkQHCvcjMGONk46O7uXuy3wsaCRx99tNjvhd2DC8sbWywWEhISbAyPcr4ZBwf7L6NDhgzh+PHjXLlyBSgIRdi9e/d173M59KNPnz6lrqfVam/4RdieRLOvr+8NlVERuNG+9no5OwQCgcAehZ857u7uSnhcTEwMFouFWbNm3a2mCUpBGDUEAkGF5/HHH0ev1/P222+zdetW2rdvDxTIrwJlkj+V47bB9oFnNBpvul1+fn707t2bgIAANBpNqbO96enpALRq1eqGDBzCw0Nwp7mZEAw52WPhxJWjR48mOjqaI0eOsGvXLn799VcWLlzIihUrFE+q9PR0MjMzUalU1KtXj9WrV/Pyyy/j5eWFTqejfv367Nixgz/++IP//vuP6tWrA5Cfn2eTzFOv16PT6Th48KAiCSsTHBzM1q1b8fHxUZa9+uqrREdHM3ToUNzd3ZX7bN26dSXuY5UqVZg3bx6jR4++IcNG4dwXMgkJCWXe/n5Eng3t1auXcqyuF/InSZKNAetO5BYaPXo0+/bto1WrVmXqa5s1a0avXr1uSyJZgUBQ/qSlpSn5dvLyCp4b5ZUc1CpJd+1TERFGDYFAUOFxdXXlt99+46WXXqJatWo0btwYV1dXkpKSANsZwKpVq9psK78kb9u2rVzb1KNHDwIDA1m/fj1Go5EJEyYoigWlceDAATIzM5k4cWKpiijyC7aI8RfcjxRWTlm/fj3+/v5YLBb69etHTk4Oy5YtU67xRo0a8e2336LT6ejbty8rVqzg3XffZd68eTg5OTF48GDWrl3LoUOHOH78OPXq1aN169bk5OQABeEg7733HqGhocTFxbFlyxZGjRqlhH2dOXOGb7/9VukvIiMj6d+/P0OHDmXp0qX06tWLxYsX2yTLLIokSSQkJPDyyy8zffp0xbhSFor2SRWdjh07snr1ak6dOsWGDRvIz8/nxRdfvO52cg4VKDks0J5X3s0iX6P2VGdKIi0tjY0bNyrXnj2EIVoguHvIClGFKayIJO7Pexdh1BAIBA8MUVFRhIWF0bRpUzIzM21kWmWKekHID7DSXkJvhldffZWLFy8CBRn8Z82axfTp03FwcLjutlarlX79+pWaK6CoMUNWUBAI7gcKK6d07tyZ+fPn4+bmRlBQEG+99Ra+vr7KwHXixIkcPHiQI0eOYLVayc3N5aGHHuLYsWN89tlnJCQksHv3blatWoWXlxdDhgzht99+Izg4GIBBgwaRlpbGn3/+qYSdBQQE8NRTT+Ht7Y3JZGLLli1KaEtERAQLFizg5MmTWCwW1q5dS8uWLXnxxRdLNSIajUYsFgsNGza0++JckiRpXFzcrR7O+4pJkybx008/2XhajB07lo4dO153W9mbo6SBh6xqVR7I10FJqjP2OHv2rHKNeHl52aivyNi7hmSvQoFAUP7I/YUkScTGxhb7PSMjQ+n/JUkiMTFRkfoW3DsI9ROBQPDAIKugGI1GnnvuOQICApRkgHcDPz8/pk6dysGDB1m1apUiNVsSjo6ONGzYkPPnz5OWlmbXKOPh4UGzZs3YvXs3FosFSZJo3LgxvXv3ZtGiRcVyhUDBQ9rd3Z38/Hyys7OxWq0EBQXh4+PDwYMHS2yLyWSykWWs6EiSRI0aNcjJyVFkMsuCs7MzWVlZt7FlFZPRo0fTs2dP3NzcSExMZMeOHaxbt07Jk9GjRw+8vLz45ptvSExMxMfHh5EjR3LhwgW+/vpr5UU0Pz+f+vXrk5eXx/nz55VBo7+/P82aNeOff/6hZ8+edO/endWrV7Np0yYMBgNhYWF07dqVhQsX2tw3kiQxf/582rRpw4IFC1i5cqWN0VN+QZZVV9RqNY6OjorBRZIku6EUsmLL/YysNmO1WgkMDCQ7O7uYUUatVhMaGsrkyZNJSUlh8uTJXLp0CVdXVwwGg+JxoVKpbI6TJEnUrFmT6dOns2rVKr7//nvlN51Opxh5VSqV3b7xdiD34YcOHWLDhg1KmGBJyNeGRqPBYrGUKBMLBdePi4sLqamp5d5ugUBwa3Tv3p3p06ffUhlZv20pn8bcBM6PdLlrdd8uhFFDIBA8cMTHx9O2bVs0Gk2xQbk9uVYnJ6dy99QYPHgwycnJREVFYbVa0Wq1NG3alN9//73Ebdzd3UlLS8PV1bVEmUl5AK3RaBg9ejQrVqwgLS0NDw8P1qxZQ5cuXZSXf0mSGDZsGKtWrSI7OxudTscnn3zCuHHjlMFX0UeEnPtDnkV1cnIiLy/vjg0i7jTy7LlKpUKr1WIymfDy8lKMY9fD0dFRzOjcBJGRkQwdOpTx48fTokULPDw8ePvtt/H19WXQoEGYzWY8PDwYN24c3t7e9OrVi9jYWDZv3ozFYqFZs2a4u7sTExPDmTNnqF69OufOnQMKpPiuXr2q5KX47LPPaNOmDZGRkZw8eZKZM2fi5ubGuHHjMBqNDBkyhI8++ggouGeGDh1KZGQkY8eOZd++fWi1Wh5++GF+/fVXoCA/iDywVqvVyr0hh7ldzxB4vxo3GjVqxMmTJ5Vrvnnz5hw9epS8vDzlXunYsSMDBw5k9OjRpKenM3PmTMLCwnj22WfJyMgA4Omnn2bnzp3KcZMkSTEGyP2zvf7G19dXOad34hiGh4eTn59PVFQUUHDNJiYm8u2335a4jdw/y8fIzc1N2W+BQHBvUJJhtFatWsTGxrJ+/Xr8/PyoVKnSLdUjjBrliwg/EQgEDyytWrUqtkw2aJSnVGvdunXZuXOn8t3Z2Zlhw4bh7u5uM1N39uzZUl2X5SSKmZmZ6PV6KleuXGwd2SNg6NChpKWlkZqaitVqJSUlhaNHj9rEfHft2pW8vDzFQJGfn8/58+dp06YNYN8N2mQy2biF5+XlMWrUqLIeivsOR0dHQkNDMZlM5OTkYDQaSUpKokGDBmXa3mg0lotCzoPEI488ooSf/Prrrzz99NN88skn9OjRgyZNmjBr1iwGDBjA7NmzsVgsJCYmMm/ePF555RXMZjNWqxVPT0/+/vtv1q5di8Vi4fz580oOGqvVqszyu7q60qJFC3bu3Mn58+cZOnQozZs3JywsjJYtW5KSksJXX31FtWrV0Gg0WK1W+vfvz4IFC/jll1+wWq1YrVZOnTrFqFGjFBdl+YVYbo/VasVkMuHo6KgovNhLFqpWq+9LgwYU9A0hISEYDAZMJhMHDx5Er9fb5A+ZNGkSu3btIikpCaPRyFtvvUWlSpUUI6parebixYs2/W+tWrXw8vLCarXi4OBQogE1MTGRKlWqKOWo1erbGv8+atQopQ+3WCysWbOGffv2ldqHy/1zbm4uTk5OeHt7l6kuET4oENx+NBpNie9+zs7O9O3bF5VKRe3atW/ZoAFglVR37VMREZ4aAoHggWLt2rUsWbKE2NhYvL29SUpKwsXFBYPBYHf9O5Vw8+GHH+bs2bOK+/L1Mv3L7svATXtJ3K8zwgLBreLk5IReryczM5Nq1aoRGxur9AF6vR6TyYSPjw8ZGRlKSIRMaffNnQx9EAgEAsGd48knn+THH3/kiSeeYMGCBbdcnuH3qHJo1c3h0vL5u1b37aJimmoEAoHADtu3b2fGjBm0bdsWQNEet2fQkK31Vqu1TAnqbpTCM4jNmzfnxIkT6HQ6LBYLVatWve4MntVqVWYIofhMXllmKH19fW+i5WWnPL1dBILyQL4mc3JylLwZVqtV6QMcHBx477338PX1VfLtzJs377r3k+yNU5pBQ+5vZEQW/fsXnU4nPLAEggpK4XeXwu9W+/fvp1mzZnejSYIyIN44BQLBA8OKFSsIDw+na9euAHazXNsbnOzatavc2mDP8+PcuXPUrVuXuLg4JEkiKSmJjIwMnJycSiynaAK9ooMpe+7KRQdRctb+24WYsRaUFZVKhVqtVmRUbxfyfefo6EheXh5//PGHTbjD0KFDOXv2LFeuXEGSJAwGAzk5OTzzzDPFyijM9VQ3gGI5WJydnW95f+4n5NCcotzM+S5qILrT5OfnX9ebTiAQ3H94enravLvk5+cTFBSkfA8MDCy/yiTp7n0qIPafMAKBQFDByM/P5/jx4wwbNowGDRqgVqsJCAjg8uXLNi/V9l5Uy3Nwbm9AlJKSQkpKilLXjSplyPH6hbGnpCJCTQT3KoVzUNxO5HugcPJWJycn2rRpw6FDh1i8eLGNlxbAG2+8ccPll4WSQt4qKiUlSL2ZfqksSXoFAoHgRpHfxQoTExMDQHZ2tjBm3sMITw2BQPBAkJqaitlsxsvLi8TERBwcHEhPTy9xlrBoEj9Jkuwm9hMIBPc3FouF7du34+7uzpgxY4RajUAgEAjw8fEhIiJC+e7s7FyuYWciUWj5UjH3SiAQCErh4sWLNGvWrERZVKDYwMZisZCTk6MoGQgEgoqB7Bl16tQpduzYQZUqVe5yiwQCgUBwNyicTyMxMZHVq1crz4TCYYiCew9h1BAIBA8EHh4eqNVqkpOTadWqFXXr1r2h7fV6PZIkKR+BQHB7GT16NNHR0Rw5coRdu3YxduzYUmX0Cs+gqVQqJEmym8fB19eXunXr2vw2evRo9u3bxyOPPKJIJxctszABAQF4enqi0+nw8PCw2yeUVH95IbfZnjS1PerWrUuvXr0USdnScHJyqnAyonq9Hq1WS5UqVXBwcLju+hMnTmT//v20atWqTH2+o6Mjr7zyCm3bti1T+QKB4N6jaLix1WpVkkZv3LiRzZs3s2fPHurXr6+Epdw0IqdGuSKMGgKB4IFAp9PRoEEDfvvtN7Zv387y5ctLXb9wwkK1Wk1OTg5Nmza9E00VCB54IiMjGTBgAFOmTGH9+vX8888/zJ49m/T0dJ577jnatGlTbBuz2UxQUJDNAFTO4+Dp6aksy8jIwGw2KwYLua7XX3+d5cuXk5ubS/v27RUDpr2klLGxsYSGhuLr60tqaqqyvHByX6vVetsMA3Kbe/bsyYEDB1Cr1TRu3LjUbU6fPs3XX39tY7SxhyRJ5OTkkJ+fX44tvrvodDree+89/Pz8uHr1Knl5efTv37/E9SMjI3n++ecZMmQIBw4coF27dkyZMqXYepIk4ebmBhR4961YsYK///6bvLw8YfwWCO4TNBpNqfdr/fr1gQKlulatWtGiRQu2bNmCv7//nWqioAwIo4ZAIHggiIqK4sSJE6xZs4YxY8YUS/ZUdPBhNpuVh5y87smTJ+9MYwWCB5yIiAgWLlzI7t276dy5M5988gmVKlWiWrVq7N27l88//9yuwSAmJgar1VpMElleNzAwELPZzJkzZ5RkuhEREXzxxRecP38eDw8P6tWrR0JCAj169MBkMmEymexKLO/Zs4crV67g7++vhKSFhITYrJOdnQ38T/mjcuXKyiD4VoiIiGDBggWKgpFKpeLatWvUqlWrxG0KS0A7ODjYlVxWqVQVMrxuyJAhHD9+nCtXrijLGjVqVKJct3x8T506BcDVq1fp1q0bHTp0sFnParWSkZGhfM/OziY7O5vQ0NAKeRwFgoqIyWQqdr+q1WokSUKn0ymG4EOHDuHl5YWzszO1a9eucN5s9zuSVfS6AoHgAcBgMHD58mXWr1/P+vXrbX5Tq9WK4cLR0RGz2Yyvry+ZmZlkZmbe0Mtp4bJkJEkSL7gCwQ0SGBjIRx99xNGjR/niiy9ITk6+7jZqtRpnZ2ebgeatUK9ePVJTU0lMTMRisdwz97FKpRKSybcJSZLQ6/V2Vajs9e8CgaBiU/gdrkOHDlitVhYsWHDL5Wb+/cMtl3GzuDZ76q7VfbsQnhoCgeCBwMXFhXr16jFixAgA5s+fr/zm5+dHcHCw8jLr6+vL1atX0Wq1zJs3T3ExLi0+vqhXh0AguHm6detG9erVefHFF5kxYwadO3dm2bJldr0LZJydnTGbzWRkZKBSqfDw8LC7XuEyXFxc8PHxsbueJEmcPHkSo9GIJEml5vO405Rk0LgdIQ+lHfOKiNVqLVFWW+TKEAgeLGTvtYkTJ6JSqZg+fXq5GDQE5c+D9aQSCASC/+fPP/9U/r927RoxMTEMGjSI9PR0rl69iru7O6mpqRgMBjp06EBGRoYSn2+P0mZwi/72oA0SBILSKHo/+Pr6MmbMGIKCgjAajajVajZv3kzz5s158sknSyyn8EBUDjMpSqVKlWzqMxgMJCYm2i1Pvm+Tk5Pp1asXYWFhN7Rf5U1ZVFnKI7SlKBXdI0S+HspisJDDiQQCQcVBzoVU1Chc2EPj888/5/nnny9X47ZVku7a52aYP38+wcHBODo60qJFC5v36NJYv349kiTRpUuXm6q3rIg3a4FA8EAhq6D4+fnZLLdYLKxYsUIZCKWlpeHg4MDixYv55ZdfbNYtyWOjrPrlFX2QIBDIqNVqHnroIaKioli+fLnyQqhSqQgICFDuR0dHR6Ag90VCQgJt2rRh7dq1VKlShYCAAPLz82natCmHDh1Cr9cDBS+c48ePt1FIOXDgAK1ateLSpUt2Q1DmzJnD4cOHmThxIpUrV0an0xEYGKiUKSNJEt7e3sq9vnbtWn7++WfUajW1a9emSZMmyrr2EoneDq5evaoowhw+fJjnn39e6XNGjx7NmDFjim0jSRLBwcEsXryYNWvW4OzsfN16VCoVOp2OKVOmULt2bbvrFD2v8vkrCT8/P5555pky1S+j0WhKNQDr9XocHBxo0aIFM2bMICgoSFmu0+lo0aKFzTHS6XS4ubmh0+moXLmyct4cHR3RarV4e3vj6upa7FgUbYNOp1OUbwqXIxAI7k9ycnKA4hNQVqtVWZaWlvZA3+sbNmzg9ddfZ/LkyRw6dIgmTZrQqVMnEhISSt3u4sWLvPHGG3aTe5c3wqghEAgeKGQVlCNHjgAFLuuydV6WgYSChH95eXmcP38ek8mERqNRHmgleWyI0BOB4H907NiR1atXc+nSJbp3787mzZsxmUx06tSJ8PBw4uLiyMjIYMyYMYoXhKy4odfrsVqtXLt2jStXrlC/fn3at29PQkIC2dnZ1KhRg1dffZXu3bsrCin+/v5MnjxZUQPp06ePTXsiIyNp3rw5EydO5IMPPmDQoEG89957XL58mezsbHx8fGxm6pKSkjCZTDbKKWazmYcffph///1XWVaaB1d5UlgRpkOHDvz0009MmjSJYcOG4efnp6jDNG3aVNkPSZIUqdEffvhB8WZxcXFRyi06O2m1WsnPz2fFihWcPn0aSZJsBvZFz+u8efPIzc0t0QDRo0cPvL292bZtG1lZWUiSRGBgoN115X5WkiRMJpNiAFar1TaeKrKaSYsWLTh+/DgzZ87kiSeeUJaHhoZy+PBhoqKiGDVqFFqtlvz8fLKzs6lcuTJxcXGYTCZlfX9/f65duwbACy+8oNRTOLmqTH5+PhkZGQQHBxMXF4fRaCzxnAmvPIHg3qeksL3KlSsDBZ4cixYt4plnnrmTzbqn+Oyzz4iMjGTgwIHUr1+fRYsWodfrS1USNJvN9OvXj6lTp1KjRo3b3kbR2woEggeCqKgowsLCCAsL48SJE/z0008Ayks2FLzMy7N68gu1SqWibt26mEymUl9eBQKBLZMmTWLXrl0kJSVhNBr57rvvGDZsGO+//z5bt27FarViNpuZM2cOM2fOVLZzdXVV3PytVisajQaTycSPP/4IFAzIJUmiZ8+efPHFF4pCytKlS/n555+RJAmNRsOECRNs1CoiIiL49NNP2bx5M1arldmzZ7N3714CAwNRqVQkJSXRt29fpV4oGGSnpKTg7++v9A2pqak2RgF7oWctWrQo56NpqwiTlJQEQNeuXRkyZAizZs1S2nH48GHCw8NxcHDAYrFw6tQpTCYTu3btUgyzBoOhxPbL32NiYvD19cVqtdoM7Iue10OHDhEaGspTT9lPPDd69GjOnz+vfHdxcVHckYtSs2ZNjEZjsTZZLBZ69eqlfB8yZAgXL14kOjoag8FAcnIymzZtYvjw4Zw4cYI///xTUbcJCAhQVE5MJhMXL16kV69eWK1WRRXl8uXLSJKEwWBgz549xVRsAJu8SiaTiQsXLti0yR7CK08guPcpKXxYXh4WFsbjjz/OI488Ur4VS6q79snLyyMjI8PmI/eZRcnPz+fgwYM2z1OVSkWHDh347bffSty99957D19fXwYPHly+x60EhPqJQCB4IJBffKEgLvrrr79m7dq1QMHLakZGBoGBgVy+fLnYtvJg5k54YowePZoWLVpw6NAhli5dSnp6eqnrOzg4lPggKi/0ej15eXmo1WrF0CPPqNujqNqLTqfj3Xff5fnnn2fixIl8//33dvOMSJKkHGO9Xo9GoyE7O1tJ1BUYGEh2djZxcXFAgdt4UFAQZ86cUcrz9fVFpVIRHx9P1apV8fT0VLxyBHceSZLQarVYrVaqVq1KQkJCiUkYi1K1alX69evHypUrFelSKLgfQ0NDmTRpEsuXL+f777/HYrFQtWpVPvroIxo0aEBiYiJ6vR5nZ2cOHz7M1KlTlXAyrVZLVFQUX3zxBSkpKUoITFpaGrVq1eLdd99l27ZtbNq0CR8fH9LT022MAFBwfU6aNImYmBiWLl1Kfn4+Dg4OWK1WRR5w1KhR9OjRgzVr1vDll19e9z5t2LAhr7zyCqdPn2b58uXXvfcfZISilEAguJP4+Pjw008/Kfk3yoOMQz+VW1k3ymdRB5g6darNssmTJzNlypRi6167do0qVarw66+/2hh23nrrLX755Rf++OOPYtvs37+f3r17c/jwYby9vXnppZdIS0tjy5Yt5b0rCsJTQyAQPBC4uLhQrVo1qlWrRr169Zg4caLiVj5jxgwAxaBRdAbxzTffxGq13tDDTF2KUkpJREZG0rZtWy5evMhnn31GRkYGvXv3pm3btiVuU9S4UFZ357Lm/9DpdHTr1g2LxYIkSTg7O9O+fftStyk8y/3kk0/i6enJpEmTePzxx9mxYwc6nQ6NRmMTh2+xWBSDhjxTHxwcrLTBarXi5+eHwWBQZpvz8vI4ffo0UJBEUa1Wk5CQQEZGBv7+/sTHx9uECRSm6HEKDQ0t0/EQlJ1GjRqhVquV82c2m8nKyrrutefo6IgkSVy5coWPPvqI+Ph4dDod8L/Qh5SUFLp27cqPP/7I5MmT6dmzJ9WrV2fQoEGsWbMGf39/LBYL/fr1A+Crr76iT58+6PV6IiMj+fDDD+nevTsvv/wyKSkpZGZmMnz4cPLz83nppZf46aefqFatGklJScXUUapWrUpOTg7jx4/nyy+/pFGjRowZMwZPT0/MZjMajYahQ4cyYMAABg4cyJIlS7BarbRs2bLU/T579ixbtmxh9uzZNyRJezsUT24nZe17SqMkg8b1cnvY5T47fgKB4PZSuE91cXHBxcWFxMREnnjiiXKtx4p01z4TJkwgPT3d5jNhwoRy2a/MzEwGDBjAkiVL8Pb2Lpcyy4IwaggEggcS2X0dCty1S2POnDlYLBYlmVRZMN9EnH1ERAQBAQGKK7lGo2H8+PHMnTu3xMz8RV/unZycisXA223f/xsQrjfAGDJkCD/88ANWq5W8vDzS09Np165dmZQCTCYTU6ZMUVy/U1NTMZlMvPLKK6xevbrEB2hmZiYARqOR+vXrk5ubi8lk4uDBg+j1emrUqIFGo1EMTXXr1uXq1avKPpnNZtzc3HB3d7eb2EuSJMUtXH55SUhIsEkWKaQbbw21Wo3JZCIkJASDwYDJZCImJgYXFxdq1qxZ6ra5uXk217Wrq6uSNPKDDz5g9+7dXLlyBYvFQn5+Pl26dOHNN98kKCiI3Nxc9Ho98+fPx83NjaCgIEaOHIler6d79+4sWrSIEydOYLVa+ffff9m3bx/BwcFoNBr27t3LtGnTMBqN1KxZkytXruDt7c2FCxcAaNy4MVDgUSG3LzAwkLCwMAICAoiNjcVsNpOfn0///v1ZsGAB586dU5LNnT171m5Yw//2O5edO3ditVrx9PSkV69eNGjQoJjRQqVS0ahRI+XaLpr0GCiW+PRWKG+jidVqLTEB6fUoarQoS19Xhgbd2vYCgeC+pCQlk8JJinNycnjsscfQaDQkJyeTm5t7J5t423BwcMDNzc3mU9J7j7e3N2q12sZjEiA+Ph5/f/9i6587d46LFy/y3HPPodFo0Gg0rFq1iqioKDQaDefOnbst+yTCTwQCwQNLbm6ujYqBPUaPHk3Pnj356quv+Oqrr8jIyCjV7XnevHkcO3aMTZs2kZaWpsxQl4RarUaj0di4poeHhzNq1ChcXV2ZNGkS27ZtK7UMOUO/j48PeXl5pKamCtdswT2DJEmEhITQq1cvVq1axaVLlxg1ahQZGRls27aN9PR01Gp1qS+LkiRRu3ZtHB0d+ffff5XrWw6JcnBwuCsvm87OzowcOZJnn32Wn376iY8//pjc3NzbFh4h90dy3yCH3uj1eoxGI76+vmRkZCiGQTkHhI+PDwaDQVmuUqlsDHs32la5HW5ubiQmJrJjxw7WrVtHQkKCEp5WeJ3c3FyioqJYsWIFSUlJ+Pv7k5eXR9++fenevTuurq7k5eWxYsUKNm3aRHp6Ot7e3uTk5GAwGPD19cXJyYlq1aoxceJEfH19UavVHD16lAMHDihGK9mYI4cA5eTkoFKpWLhwIVu3biUzM5OmTZsyadIkqlatikajsTHaFA4fysrKQqVS4ejoSHp6Oh4eHixcuJAvv/xSycUUEhJCvXr1OHDgAJmZmYSFhVGjRg1+/PFHMjIy8PHxITMzk8zMTKxWq6KyEhsba3M8vby8yMnJUXLJiPAageDe5Lvvvrtpo2xR0v7ZUy7l3AzuYaV73BalRYsWPPzww3z++edAgXetPGkwfvx4m3Vzc3M5e/aszbJ3332XzMxM5syZQ+3atRXvy/JEeGoIBIIHllWrVqFSqWys9ZUqVVK+u7q6Eh4ezrBhw1i9ejUvv/wyjz/+eInlRUZGcurUKZYtW4aDgwNt2rS5bqK45s2bKwYNR0dH6taty44dO3j77bdtFA6KSg0WxmKxUK1aNeLi4sjPz78vXoaFKkDFR5Ikhg4dSqVKlThz5gwzZ85k5syZDB8+HKvVytq1a9HpdLz55pvUqlULKMg2X/jakCQJnU6nhKMcOXKExo0bo9VqUalUmM1mrFbrdQ0aHh4et2Uf9Xo9s2fPZujQocyYMYPq1aujVqtvyz1oT/2kffv2ioKHn58fV69eBf6n4CFJEg0aNFDy0MgJTuUcJGAbLiZT+BwUnr2Tw3fkdqxfv55//vmHuXPnIkmSkpy16Dr79+/n448/xtPTkw8//JCGDRsqSU7nz5/P+vXrWb9+PWvWrGH48OH07t2b+Ph4srKyGDt2LDVr1iQ3N5fXXnsNq9XKp59+ChTMCGZnZ9OvXz/F28ZsNqNSqcjOzubIkSOsWbOGjRs3MmnSJFatWsXly5cZPHgwZrMZo9GIxWJRVExkA8fFixcVD6FTp07h7e3NggULWLZsGXl5ebz88st4eXlx/vx5tm7dypgxYwgPD+fKlSt88803TJo0iS5duhAbG4vValVyuRiNRsWgUVjeNjk5mZycHAICAoRBQyC4Tdys11nh/lCWjn7QeP3111myZAlffvklJ0+e5OWXXyYrK4uBAwcCBZ7Gsveto6MjDRs2tPm4u7vj6upKw4YNb4tBA4RRQyAQPIBERUURGhrKp59+iiRJpKWlKb9lZGQos2V5eXm88847nDhxgtTUVObMmcNvv/1mo3xQmAEDBrBs2TKMRiNXr17l559/LrXz3rNnD4cOHQIKBhS5ubksXrwYs9lMdHQ0SUlJdOzYka5du9K5c+dS9+ncuXP4+/vbqLkURZIkm/jGsjzgvby8rrvOzXC9uu+3PAGC4nTt2hWTyaR4LOXk5LB//34GDRrEsmXLMJlMXLt2jblz5+Lr6wsUJCSzZwiUJElJMHr+/Hlq1aqlhHLYCzEqSmpqqmI4KUr16tVvdhdJSUkhLy+PkydPEh4eTuXKlW9bQuGi6icmk4nDhw8zfPhwjh8/zpUrV4CC8C1ZwcNoNHLkyBHF8FPY+HPlyhUbOevC0rQWi0WRVi3sRZadnc1LL72ktKNz58588skndO/enSZNmjBr1iymT5/Oiy++aLPORx99RPfu3QkKCmLSpElMnz6diIgI/v77bxISEnj66adZtGgRkZGRdOnShR07dvDyyy9jMpmYNWsWM2bMICEhgTNnzhAZGcmyZcsAmD9/PkOGDEGtVrNo0SIaNmzIsmXLsFgsVKpUif3797NmzRqGDh1Kq1at2LlzJ1euXCEuLo4ff/wRnU7H999/T/fu3dHpdOTl5aFSqahatSorV65Eq9Uq19nXX3+NXq+na9eujBw5km3btinH7OrVq2RnZ3P16lUGDx5MTEwMGzduRKvVYjAYyMjIoF27djbn8/3337f5brVaiY2NpU+fPnafG5qbyNMkEAj+h733iqKhem3atKFTp07K9xo1aihGjWrVqt1c3p4KQK9evZg5cyaTJk1SJLN/+OEHJfwxJiammAfanUaEnwgEggcOg8HA7NmzWb16tZJfoejDrrTZMrVafVuVUNRqNd7e3pjNZtLS0nB3d1ckHMuCmOkTCO48Op0OR0dHcnNz8fb2JikpqVSVoAeVUaNGkZuby5YtW8jIyCAsLIx33nmHxMRExowZU0z1RaVSMX78eCRJYsWKFcTFxSkhd40bN6ZWrVrs2LHDJjRQkiQefvhhqlSpws8//0xKSopNmb6+vqSlpZGfn2/Tn48ePbpMijWyN47818fHRzFwCQSCiolOp+Po0aPlVl7a4Z/LrawbxT30sbtW9+1CeGoIBIIHjn379rFu3Tqg4OW0sKqJSqXCy8tLeWEtnEhTdsO+nQaNdu3aMXLkSOLj40lOTmb06NE8/PDDZd7eycnJrkFDJL4U3CuUFkp1O7nd3j/5+flkZ2dTpUoV4uLibDwfbpXb5a57uyjc3xTuQyMjI1GpVKxbt47u3buzbt06HB0dGTp0KFu2bMFkMinnSd5Oq9UyY8YMpk+fTqNGjdDpdPTt25cvv/ySM2fOsH79enr27KmEeECB18Off/7Jli1bislLazQaEhISsFgs6HQ6GjVqpITODBgwgEGDBpWqWCMbjS0WCyEhITRs2JDY2Fjy8vJwc3MTXmYCQQVCr9dTrVo1oCBXj9FovMstEpSEMGoIBIIHgqioKMLCwggLC+P1119XDBMmk4muXbsCEBYWhtVqJTk5GShuvJBn4SpVqoS7h8ct54Ww9/L7wQcfsHbtWqDgxXzevHlMnz69zEaJnJycYvkDJEnCw8PDbn2F47oFgttBhw4dbL7LySrvNCWFjZUnZrOZCxcu0Lt37zKFxZRGpUqVePrpp5Ekya7Hx50wdMghD7K8clkG7EVzijz00EOKpPaAAQNYs2YN9erVo1+/fvz0009MmzaNpKQkduzYwbBhw5TtXnzxRaCg35UVZA4dOkT16tV54403+PXXXxWvjg0bNtCyZUtmz56tbC8bHlJTU1GpVIwaNYr8/HzFiG0ymahXrx4jRozAarXyzDPPsGzZMq5du6Zsf/bs2WLu5nK5ACdOnFDUs1QqFYGBgcWMyndS0lAgENwYRRXgAgMDbd7ttFotzz77LFAQlif3D+WBVZLu2qciIsJPBALBA4HBYCA5ORmj0chzzz1Hnz59WLt2LUlJSXz55ZeMHTsWnU5XJndxvV5Pbm4uFouFMWPG0K1bN9zc3Dh06BCTJ08mJiamxG0bNmxIgwYNFHdpe6jVanx8fJR8BJIklTo7IEmS4vZe1i7dycnphiRqBYKbQa1WExoayuTJk0lKSlLCC1QqFX5+fuTm5mIwGBT1E2dnZyV3hry9xWLBarUiSRKenp6oVCqSk5Px8PBg9uzZ1KpVC71ez9KlS/n6669JSUlBr9eTnp5e7H7QarU4OTmRm5ur5KBJTU0FsMnlUVIIV1lDu25XKIper8dkMhEWFkaXLl345JNPSElJQa1WExISQt26ddm7d68SihEQEEBeXh6ZmZm4u7uTmJhoU5788m4vj4lslLGnTFMWhabC6icGg4Ht27cr6ieOjo7k5eUxbNgwRc1lzpw5bNiwgezsbNRqNX5+for6iVarJTs7m9atWzN16lSqVKnCtWvXcHBwwMXFhaSkJPR6Pc7OziQnJ+Po6IizszMGgwFJknBycuKTTz5h+/btZGVl4e3tTXZ2NtnZ2XzwwQc8/fTTSg4Rq9XK3Llz2bhxI5mZmYSGhuLn58eePXswGAy4uLig1WrJysqiTp06VK9enQMHDijXtdVqVdouh72IV22BoGKwe/duJcnyrZJ65JdyKedm8GjS7vor3WcITw2BQPBAIM8Uurq6YrFYFEmuwMBAAgICAGwGHfZmJOVlcsb8gQMH0rdvX6ZMmUJ4eDg5OTnUrFmz1HacOnWKjRs3kpGRobg9F6Zt27aMHDmSuLg4JfzkejN9vr6+5OTkYLVaadq06XWPhYODgzBoCG47HTt2ZPXq1Vy6dInu3buzefNmTCYTnTp1Ijw8nLi4ODIyMhgzZgxhYWFAgfQo/G9ALaubVK1aFQ8PD5KTk8nIyKBly5Z069aNunXrMmPGDCZNmsSiRYsYOHAgrq6uZGZmFpuBg4J7Nzs7m+rVq3P58mVSU1ORJEmpX0ZOfiYj36dlHZwWDUUpD5dlWeUkNDSU48ePM23aNDIyMnjsscf46quvuHr1Klu2bOGFF15g8eLFSJJEbGwsoaGh+Pv7Kx5o8D8PDIvFYtegodPpFHWQogaNkhSaCieyLKx+smHDBn799Vc+/vhjKleuzMSJE2nbti0REREMGDCAWbNm0aFDB9asWYPVaiUiIoLw8HBiY2MxGAwsX75cOT9PP/00np6eiuFg3rx5bNiwAX9/f3Q6HV9//TU+Pj64uLiwa9cu3NzcMJvNdOnSha1btyrHT1aDiYqKomPHjrzzzjtcvHhRUSpZtWoVkydP5ssvvyQ+Pp6oqCiGDBlCnTp1yMrKIiMjA39/f2JjY4mKiqJ9+wJ5RE9PT8xmM1euXCEtLU0xcggEgvKmfLwNir6DXS9xtLu7e7nUKyh/hFFDIBA8EMjhJ3JW6w8++AAoCNeIiIhQ1pMfcPLgqjDyy6k8QAkKClIy/P/333+8+eabREdHl/rQM5lMSjmnTp2iYcOGNr9PmzbNJvzk888/JzExEZVKVaLrd3x8vPL/xYsX7WbnLuxOKZLZCe4EkyZNYteuXSQlJWE0Gvnuu+8YNmwY77//Plu3bsVqtWI2m5kzZw4zZ85EkiQuXrwIUMwIkJWVpcx6Ozg4EB8fr6iBREVFcebMGerUqUPv3r2V2Xk5Z0JRTCYT//33nyK5bDab+eqrr3Bzc1PWkb2o6tSpAxTkASmce+d6VK1aFZPJpISilAdDhgzhxIkT/PnnnxgMBgwGA82bN+eTTz7hhx9+UMJ61q9fT8uWLZWwnz179nD58mWb/qNovo/Cv2k0GkwmExaLxW7YW1GFJrPZTNeuXXnyySeVdeRz89dff/H0008rCim+vr589NFHfPDBB4qKyrfffqtcI6+88gojR47k+++/x2q1YjQaSUxMZObMmahUKjZu3MiyZctIS0tDo9GwY8cOunTpwrx589BqtXTv3p2VK1ciSRJt2rRh/vz5uLq6EhsbS7du3Wjfvj1HjhxR1HQCAgJQqVR8//33ODs7KwmkR4wYQUhICKGhoUqIXuXKlYmLi1Ou25iYGMVDJDo6ml69elGnTh1FYls2GBUOQ7JnaBMIBDdD+RgLixodZYO23CeGhIQok2BQ8C5ZXlgl1V37VERE+IlAIHggKBx+8uyzz9K6dWuio6ORJEkZAN0ocgb+8kwIKBBUJAqHn2zcuJF169aVmmhXp9NhMpkURYrS7ksPDw9Gjx7NsmXLFDnTe5HyDEVxdXUlLy8PLy8vxWMAbFU7NmzYUExBxB6yxHNWVpYiY10YZ2dn8vPz7XqZBAYG8tFHH1G/fv0Sw08KM2rUKAwGA999953iwWCxWHBxcbEbJtSsWTOmT5/ODz/8wMqVKxWDVlGlkp49e7J9+3a++OILG08UGT8/P6ZOncqhQ4fYuHGjEj6SkZFR6rUlSRJVqlQhPj7eZv/d3NyIjIwkIyODzZs3l6hKJe8fFBjhPDw8FO8QgUBw/6HVajEajbRv356FCxeWS5kp/0aXSzk3g2fjNnet7ttFxTTVCAQCQRHk8JNatWoRGBjIgQMHcHV1ZdCgQbRrV7bYwqKzllWqVBEGDYGgBAqHn3Tt2pV169YxZswYu55EMnKSWwcHh1IHnc8//zzZ2dlMnTr1njZoQPmpoqhUKl577TWCgoKIjY0lNzeXWbNmMXToUAYMGMDAgQNZunQpvXv3Vvo0lUpFUFBQsbI0Gg2urq4kJiaSnZ2Nl5eX8ptarcbR0ZGsrKxiBg1JkujWrRvVq1dn0KBBPPHEE0r4iV6vt9vu0aNHY7VaWb16tRKeV61aNSRJUgwaRZMuOzo6MmfOHGbNmkVaWpri0SZfE3J4y8svv8yHH35I586d2bBhg3JtqVQqBg4cyCOPPMKIESNYunQpI0aMoGfPnqSlpeHo6EjDhg0VT57CHhSSJOHj48OVK1cUA8pLL71Ew4YNycrKYtasWYqXCthX87FYLNSsWRNPT0+MRqMwaAgE9zEqlYrnn38eKGf1Lkm6e58KiDBqCASCB46srCwsFguZmZksW7aMvXv3lmm7KVOm0LBhQ3r27Alwy4Mp+YVaSAAKKiKFw0/k3BgDBgwo1VgRHx+PxWLBYDAAtobEwvdJzZo1bX67VaWR24mc9PdGVVE0Go3Nul26dOHatWucPXsWX19fjEYjFy9eZMiQISxYsIBz585hsVhYs2YNv/32G3q9HovFYjdxsclksklUXNizw2q12lWKUavVPPfcc4wZM4agoCByc3NJTk5Wwk9+/PFHG+OITEREBMuWLVPqbNSoEStXrsRoNCp1hYSE2Gyzf/9+9u3bh7OzM23btiUvL49evXqhVqtRqVQMGjSIlStXcuzYMaxWK5s3b6ZBgwaKwUilUjF+/HhCQkKUMJDdu3fz008/0bJlSyUMsHLlyoCt0pWXl5cSomexWHjkkUdQqVQcO3ZM8R46deqU0n83adLE7vk7d+4cKSkpN6R+olar7zv5XoHgfkc2qvr4+DBgwIBiv8v9hyRJDBky5E43T1BGRPiJQCB4oMjPzyc0NJSQkBBOnz5to6wAxdUFFi1axKVLl0osr7AaQllCWUpSTxg9ejRqtZr169crA7uyoNFoFIlBe+XK8fECwZ2mcKjAzRAYGMgTTzzBjz/+SHx8vI2UZmnI13xJ135ZFUxuF2q1GkmS8PX1vaFQFJ1Ox/Dhw+2GXOj1eoxGI76+vmRkZCj5NeT+QaPRkJ+fb3e/fXx8SE9PLxd1lsLhRsnJyUyZMoVLly4xatQoMjIy2LZtG+np6Xh7e5OTk2MTeiJJEq6urmRkZNCqVStOnz5NSkqKkmzT29sbk8lEcnJymc+fHKJSVpWWjIwM3N3dFSWUtLQ0li1bxpo1a8jOzkaSJIKCghg6dCgxMTF8++23pKWl4e3tTV5enmIcKlqHRqMhLCyM5s2bs3Tp0hKPdVkVuAQCwZ3Hw8OD6OjocjOiJx/7tVzKuRm8Gj561+q+XQhPDYFA8ECRmpqK2Wzm7NmzDB48mPz8fMVKr9VqmTZtGqGhoaSkpDBz5kwWLlyo/F44kaCMbBDx8PAoddAlzyoXfoGXiYyMxM/Pj9mzZ5OZmVlqUlAZf39/4H8J/0p6yRcGDcHd4lYMGt26dcPZ2ZmVK1diNptp165dsRCFoqjVaipVqqRc8yW9eN5tzyg5OemNhqJMmDChWMhF9+7dFVUUPz8/rl69CsALL7wAFOxr9erVycvLK3Y83N3dkSSJxMTEYgPp6x1rexRVu8nIyGDZsmUMHz4cq9XK2rVradeuHb169SIhIYH09HTF80KSJFQqleKh88cff+Ds7IzZbCYgIAC1Wk18fDwpKSkl9nVardbGe2fkyJGKAkthlZbC+1ZYpWX9+vV4eXlhNpv55ZdfsFgsrFixghUrVpCXl8fgwYNxcnIiISGBqVOnsmzZMqZMmUL79u1JSEggPz9fObfwvz5fkiRMJhPnzp1jwYIFpRothEFDILh7lPTMkJenp6fz+eef38kmCW4AYdQQCAQPJGazmS+++AKdTqe8JD/00EOKusDZs2dJTk7m33//VbaRX7iLxo5brVZSU1MZOXJkifUVVRwJCgqibt26QIF79qxZs7BarRgMBsxmM+Hh4XaVB2QKx2ibzeYyZdUvKlspEJQX9gbBt2I8GDNmDAkJCUBBSMrevXsZNWpUqfeE2Wy2CaMoSbb4ZpIClxd16tRRPEUaNWpU6oxf37598fX1Vb6/8MILrFmzhvj4eJo3b863337LL7/8wvDhwzl+/LgSDpeZmcmePXsICQnBaDRy9uxZoPiAOS0trZiBoLDUq0zhcIgWLVqU2N6iajdvvfUWvr6+REZGKuEnr776Kt9++y3Dhg3DarViMpl4+eWXkSQJvV6vtMdkMilKOF988QUmk4lGjRphsViQJMluXhZZdUSmV69eijqVHALVpUsXm2Muq7Ts3r2bzp078/nnn6NSqWjatCkbNmxg06ZNeHp6Uq9ePV599VVatWpFTk4ORqMRDw8PnnjiCQ4cOMDIkSPJysqyuQ8sFgtOTk7o9XpUKhVpaWk27b1XjW4CwYOK0Wi0e//pdDolz9Nff/11F1omKAsi/EQgEDxQZGVl0bRpU7y9valRowYDBw7kzTffxGAwEBAQoLyQQ8HMr72wDldXV8W928XFhfz8/DKHq8guzmVFjlG3l9lfILjXuVH1E41Gg8ViKZP6ye2iLKoahZHb7ODggEqlIjc3t9g+yiEUhfsSnU6Hk5MT2dnZODg4KEbT0igaHrdw4UJiYmJKDD8prMJROByo8PLC/5eErN4iEx4ezqhRo3BzcyMxMRG9Xo+zszP//PMPkydPLhZykpGRQdOmTZkyZQqBgYGkp6ezZMkS/Pz8ePbZZ3F1dSU9PZ21a9fyzTffkJqailqtxmq1EhISQrdu3Vi7di01atRgwoQJuLm5UalSJWUQEh8fj6OjI87OzqSmpuLu7q4YPqxWK3PmzOHrr7/GYDDQtGlTJk6cSI0aNZQBjNlsVs6RvEw2MDs6OrJixQo2btxIUlIS7u7u5OTkkJ2dbROLn5OTQ1ZWFt7e3iQmJhZLsiqrJ7i7uxczcAgEgnuLkvpFtVpNzZo1mT59Oo0aNbqlOpKO/XZL298K3g0fuWt13y6Ep4ZAIHigkAcOycnJLFmyhPbt2yszZgkJCWg0Gvz9/ZX8GIUT340dOxaA5s2bAwWDkilTphAaGsrp06eZOXMmwcHBdut1c3NDq9XaGDRKy6KtUqlwcXEhOTlZGVTJs6gCwf1ASeonpYU2yAlFr6d+UpibCZUoCXuqGsOGDSt1G4vFQpUqVRSPhqJJL6EgP0hhg4ZWqyU/P5+srCxcXFwwGAzXnaF3cHDgvffeIzQ0lOPHjzNz5kyeeOKJUsNPLBYLVatWRZIkNBqNUoe8XP6/aN3yd/mvbNB4+umnqVu3Ljt27ODtt99m/fr1+Pv7Y7FY6NevH9nZ2bz++utERkbahJysW7cOnU5Ht27dOHHiBGq1GldXV/r378/Bgwf55ptv2LJlC2vXrqVWrVpIkkSNGjXQaDS4u7szZ84cZs+ezZtvvskff/zBvn37ANi3bx9r167F19cXrVbL77//jre3NwaDgZ9++gmr1cqCBQtYsWIFU6dOZc2aNZw7d46BAwfaePL8+eefnDhxQtnf8+fP4+joiIODA1u3bmX+/Pm89NJLdH7mGVJTU8nJyUGlUlGnTh10Op2SB6lDhw7ExsZiNBqpVq2aTSihHL4oPDEEgnsblUrF448/Xmx5gwYN+OGHHxg3bhyVKlW6Cy0TlIYwaggEggeKa9euAQUvli1btiQsLIyPPvoIKBg0hIWFERcXp7hGp6Wl0ahRI6xWKzNnzgRg9+7dAAwZMkQJV0lNTSU1NZXo6Gjc3d2L1Zubm4vRaFTi/guXYw+1Wm1jUFGpVCI/huC+oiT1k9KMc7K8p2x89PT0vFPNBf4XjlBYVePAgQN2ZVFlLBYLly9fJj09HWdn52Iz9EAx7y2j0YijoyMmk4nU1FTCwsKKqV7Ihk3Z6Dps2DBOnTrFn3/+icFgIDk5mU2bNpUafgIFKk32kgnL69tLnOro6IhKpSp2rv7880+WLVuG2WwmOjqazp07M3/+fNzc3AgKCuKtt95i+/btvPjii0rIyZgxY9i1axczZswgNzeX/v374+TkxJAhQ9BqtTg7O/P000+zaNEihg4disFgoFevXqxZs4b8/Hz+/vtvnJyc2LdvH9WrV+fdd99VwmDGjx/Ps88+y7Zt23BxcaFdu3asXLkSNzc3WrZsyZw5c1i3bh0jRoygevXqNGrUiCZNmpCSksKePXuU/XrooYeoWbMmcXFxWCwW/P392bFjBzqdjk2bNtGzZ0969erFzh9+4NVXX8ViseDu7s78+fPJysqiY8eOpKens337dsXIFhMTw6hRo5RjKBtRUlNT0Wg0eHt7o1KphNqJQHAP4ebmhpOTk6J2IuPj48N///3Htm3baN26danPhLJilVR37VMREeEnAoHggWLTpk28/fbbGI1GqlatikqlUrLww/+yzxeeKXR1deXQoUPFZo4bN25Mfn4+MTExZGdnK8uv584tz+DFxMTYdcUPCgriypUrygyq6KYFgopNUaUYe/e9RqNhxIgRZVY/kVVWZPUTo9FoN+TkZvqYklRFCiuJFA5LKawqkpuby9y5c4mKiiI9PR1fX1+ys7PJysrCx8eH7OxssrOzadCgAZMmTaJevXoAvPbaa/z4449KqIiTkxP5+fnKPsveLrLSi9zOHj16sGbNGr788kslt5FsKDIajSWqn6SlpWGxWFi5ciWbNm0iKyuL0NBQJkyYgKOjI9HR0axYsYLExETc3d3JyMhQyi/p+MqDJKFUJRDcv0ydOpXevXvfcjmJx/8oh9bcHD4NSs6PdL9SMU01AoFAUAKdOnWidu3avPDCCyxcuJD58+crL8BqtRq1Wk1ISAiNGzcmJiaG9PR0YmNjsVgsVK5cGZVKpYSN5OTkcOrUKcWg0bBhQ+D6iQgvXbrEhQsXaNeuXbHfatasSUxMjOLtodfrb6u7snCFFgjuPrJBQ561tzfoff/9929I/UQ2isrqJ3LCSrANPynNoKHT6XBxcVG+BwQE2CiGyKoikydPZtiwYTZKInJYSlRUFF5eXphMJn755RdWrVrFxo0b6dGjB7179yYuLo7c3Fx69uxJXFwc2dnZrF27VpGw/fzzzxk/fjw7duygS5cuPPTQQ2g0GqZOnUqzZs2UfV62bBmurq5Kfz5+/HgGDx7MkCFDWLp0KVarlTFjxigGIKPRSGRkJC+++CLvv/8+O3bswMvLC7Vazc6dO3FxcWHt2rWsWbOGKVOmsHjxYk6cOMErr7zCkSNH+PDDD3nuuefo3LkzycnJ5OXl0bRpU0XWW5aFlY+vnMy58PEuHDplMpl46KGHbuSyEQgEd4Ci70nTp09n8+bNd6k1gpIQRg2BQPBA4erqSosWLfjhhx/o3r073bt3V9yCHRwceOaZZzhz5gwJCQkYjUaSkpIUFYZr166hUqn44IMPAEhMTLQpe+PGjSXWa894UFjZQObixYv4+vqSkpICoCQXlCVcyxtZgUUgKE/KosZzt7mRNpZ13Zs1EsohCvn5+bi4uCj1Fa73ySefVEJjgBtWP8nLy7MxuMrrl4ZarcZgMKDVanF0dMRisTBs2DAWLVrE7t27FYnsbt26MWTIEEVJ5LnnnlPCUp577jn27NmDWq0mLCyM1atXM3z4cAYNGsQ333zD8OHDyc/PJyoqihEjRmA0GomJiWHevHkkJyczb948tm/fTu3atZk2bRpHjhxh+PDhnDhxgt9//51GjRop4TiffPKJ0vZnn32WuLg4Tp8+jdVqJTg4mIEDB/L0008rxoQXX3wRvV7P4cOHadOmDbt370alUvHoo48SHR3Nhg0bGDFiBCdPnqRp06a0bNmS+Ph45s2bR9WqVVm8eDFRUVE4OjoiSRKHDh3C19cXSZIwGo3odDoljEcOwSpMUQP4v//+K8JRBIJ7DNkADAU51cLDw1m/fv2tFyxJd+9TARHhJwKB4IHDYDCwZMkSdu/eTUZGBvn5+aSmppa6jZzMz8nJidzc3HIPCXF1dVWy6ZtMJpvyS3MPF+EpgoqKp6cnM2bMoGXLlnzyySfXVU6RkSSJgIAAZfb8fkQOX5Akidq1a5OYmEhaWpry/Z133sFoNDJlyhRCQkJo0KAB3bt3LxZmIePh4QFg089JkkT9+vVp164dixYtKjbAdnFxwWQy2aieyBRWtUlOTmbKlClcunSp1LCU8PBw3NzcsFqtfP7552zZsoX09HQqVaqEyWTCYDDYhF9IkoRaraZu3bpMnjyZf//9l2XLlil5kdRqNb6+vuTm5mIwGFCr1eTm5hIYGIiTkxOnT58uFpYjG2icnZ1JT0/HYrHYhJ+kpqbi6OiIk5MTKSkpODg4sHLlStasWaN45MlhPT4+Pkrd3t7e5OXlYTAYaNSoEd7e3uzatcvu9Sr6bIHg/sTR0ZG33noLSZJYuHAh0dHRt1Re4ok/y6llN45P/YfvWt23C+GpIRAIHjhcXFwYM2YM33//Pfv27WP+/Pk2v9ublZUTF8pykxRJtKRSaa9br5OTk93lKpWKjh07KjN5VquVxo0bK7/bewGWEyiW9nKs1+uv2yaB4F6kevXqZGZmMmLECJ588knWr1/PmDFjyuQx4eTkxLVr15QwhPsRi8VCy5YtcXd35+LFi6SkpNC2bVu++uor0tPTiYiIICEhgWXLllGrVi369+/PwIEDWbJkCVarlZYtWwIFA2iVSqUodsieJBqNhsqVK3PixAkWLFhgN2TOYDDYNWgUVrXp3r07GRkZLFu2jOHDhyvhJx07duSnn35i0qRJDBs2jIiICGbMmMF3333HypUrWb9+Pb6+vnTo0IHU1FSys7NtEu+pVCrFM8TLy4sBAwYwY8YMGjVqpPSXcrhKRkYGY8aMISwsDAcHBy5fvszp06fR6XR88ME0JSxHkiQWL16sJIBu3LixEkozb958oqKi8Pb2Rq1Ws3v3bnx8fFi1ahUrVqwgLy+PZs2aAf97PsTFxaFSqWjZsiVxcXFIksQrr7zCyZMn2blzJ0FBQTbhJbI3jjBoCAT3Jmq1ukQ1LUmSyMvLo1q1aly8eJEqVarccn1WVHftUxGpmHslEAgEpRAVFUWjRo2oU6cOderU4aWXXlJ+K5qwrygmk4nQ0FDUalsXYYvFWKrruSRJ+PoVDyGRJIkuXbooEoXyTOVjjz2Gg4NDieXJ4SmAMvNYFBcXFyEDK7gvWblyJVqtFrPZTHx8PJIkERERYZPfoSTkGfXyGDyWJrt8O/H09GTBggVs2bJFSVw8ffp0fvzxRyXHz8SJE/H19WXw4MEsWLCAc+fOKUbRs2fPEhISoqieQIECk9xHmUwmrl69qhyjkgyu8m8dOnQACvorWdVGDj1566238PX1ZciQIaxZswadTkdiYiJms5muXbsyZMgQFixYwLZt22jTpg1ffPEFw4YNo1q1avzwww8MHz4co9HIhQsXbPISPfbYY1gsFiwWC0ajkQYNGnDo0CG0Wi0TJ05k69atWK1WzGYz8+fPZ+bMmTZ995AhQzh+/JgSZpORkUFqaioDBw7EarWSkJBAREQEq1atws/PlyeeeIL58+fj4OBAmzZt2LdvH5s2bcLLy4u6dety8eJFQkJCMJlMmM1mPD09yczM5Ndff8VqtZKZmcmPP/6oXH/ydSurWNlLAlqecsQCgaDsFO7zChsciz435Hcrq9WKTqcjKSmJjRs30rdv3zvXWEGZEOEnAoHggcNgMHD58mXFFfvatWu88847ADz66KOcOnWKrKwsXF1dSUlJwWKx2GSzd3Z2JisrC0BJBicPPGSVgdJwc3PDbDYrZVxPLUUguF8pHKawcePG64aQXM+oWJgH5b6pUaMGzZs355dffiElJYVatWopCk7Tpk3j4sWL6HS6YuonhfHw8ECSJFJTUxXZ3PJSQimJ8PBwRo0aVUwJ5eDBg4wZM4b09HSb62PLli1s3bqVzMxMKlWqRHp6uuJtI4eiODs7k5OTQ926dRk/fjzVqlXD2dm5WKiLrHiyadMmMjMz8fX1JTMzk5ycHBo3bkyfPn348MMPSUpKYsaMGTz77LNotVri4uJ44403+Pfff3nzzTfp3r07er2eNWvWsHz5cpKSkqhRowZ9+/alffv2eHt707dvXw4dOqS0UaVSERwcTHZ2NvHx8UryUtnbTyAQ3L/UqFGDgQMHEh4efstlJZz4uxxadHP41m921+q+XQijhkAgeOA5ePAgffv2pXnz5pw8eZIaNWpQs2ZNtm7dSqVKlUhLS7tujotq1aqh1WqVpHwCwYNOx44dGThwIKNHj1YMiGPGjOGzzz4r1RghSRLOzs6lDgLr16/PiRMnlO8VUg5T7mKkAsNDjx49ePHFF3nllVeIiYlhxowZXLhwgeXLlzN9+nRmz57NlStXcHV1pX379mzduhWNRoOnpycJCQlUqlQJFxcXRS2katWqihdDSQYijUajeEtA2Y0edevW5erVq4SGhtK6dWv69etHWloaw4cPp1atWuzcuZPWrVsXuz4mTJjA6tWruXz5slKnTqfDbDZjNpupW7cuzz33HFBgNFm+fDmXLl1i7969jB8/nmvXrjFkyBD69OnD5cuX+eSTT/j1119Zv349lSpVYs6cObz99tvk5+ej1+v56KOPqFu3Lr/99ht///03zZs3p3nz5hw+fJjmzZtjsVjYtGkTH3/8MRMnTiQ4OJjVq1fz+++/07dvX1xcXJgzZw5t2rTh999/p2rVqly+fJnc3FwqVarEs88+y9dff12mUCg/Pz+SkpLKbNQTCATlT2nGcm9vbw4cOFBudcWfPFhuZd0ofvUqntKS8HsTCAQPHFFRUdSvX18JP5HdCM+dO0eDBg34999/iYqKQq1Wk5WVpSSGk7GXnf7SpUtlylove3MIBBUdOUxBHqhZrVYGDBhw3evfw8NDMWgUvu8K/3/hwgWbbSqaQcPR0ZFRo0ex6ZtNQEE4xqRJk6hVqxa1a9dGp9Px7rvvsmnTplLVT0wmk6LelJGRQXx8vFKHvH5JhgpJktBqtTYv+FarFUdHRzQajd3zKC9bvXo1ZrOZ6P9j777Doyi7v4F/Z2Z7dje9QAihhgQCJCBdRAEBEZAaihBBDIJIQH8WsND0EVRUVDrSUao06UWkCyhNQpNeUkjftO3z/pF3xt3sppGEtPO5rr0ku1PuXbfMnLnPOceOoWfPnli0aBG0Wi0CAgKwfft2BAQEYPr06Q7vj0GDBiEuLs5uarjRaITFYgHDMLh27Rq+/vpr9OnTB0uWLEF8fDzOnj0LT09Pu1SXmzdvYvTo0bhy5QoOHjyIhg0bIjMzE48fP8b48eOh0+mg0WgQFhaGH3/8EVOmTMGBAwdw9uxZKJVKNG/eHACwcOFCbN++HS+//DL69u2LFi1aQK1WQ6lU4vDhw1i9ejXq1KmDs2fPQq/X499//4Ver0edOnWQkZGBHTt2IDo6WnwuUmn+tZdGjx5dLWYeEVKROfsMCp3qdDrd0x4OKQaaqUEIqXbi4+PxwQcf4OjRo8jMzEStWrWg1WqRkJAAqVQqpo9wHAer1Qqe56HVap3+oGm1WmRkZFDxN0JImRLqanTr1g2//vorlixZgqSkJABw6PIhpJ8IQQa1Wg2ZTCYGOGzl1260ICzLwtfX16HziC2VSgWz2Yzw8HC89dZbCAoKgouLC5KTk8UOI9OnTxdrYwjPked5MAyDhg0b4quvvkLNmjVhNBqxceNGLF68WOzswnEcmjdvjoYNG2Lv3r3Q6XRQKpVwdXVFXFycwxj69++PxYsXQyaTQaFQ4MKFCwCQb/eT9PR0KBQK/PTTT9i8eTOysrIQFhaG4cOHQ6vV4sKFC9iwYQPi4+MB2J8MaTQaZGVliR1shNlHFosFJpPJocMVIaTik0qlYkvt0hB/7Xypbau4/ILDy23fZYVmahBCqp2JEyfi77//xurVq/Hnn3/ilVdegclkAsdxYptAAHZF3nQ6nXilODw8HB5+oeL9RTk4lUqlRercQAghAMCynN1siLfeegs9evTAa6+9hlmzZmH8+PEYNGgQZDIZZs6cKXb5AIBXXnkFQO532AsvvACDweBQZ8PFxQUMwzhtIV2QF198EREREQ6dR2wJYwoLC0NKSgo+/vhjmM1mbNy4Ed7e3mBZFt27d8fOnTshl8vFffI8D4lEgi5duuDWrVsYPHgw5syZg927d2PevHlikEDowHL9+nVs2LABERER2LhxI8xmsxjQkMvl4hhiYmIwZ84crFq1CrGxsbhw4QJq164tdj+ZPn061q9fDy8vLygUCpw4cQJeXl5Yvnw51qxZgxkzZmDx4sW4ceMGPvvsM9y9exdz585F06ZN7Wa6BAQEgGVZZGRkgGVZcBwHd3d3WK1WeHl5ObTszvtaF2W2HyGkbNh+Hl1dXR3u02q1T31MpOgoqEEIqVZycnLw66+/YuzYsZg4cSIGDRqEX3/9FSkpKZDL5QgNDRWvZgqt/5o2bQrgv24K58+fR1riDYdtDxkyJN/9MgxDudKk2qB2wiXXu3cvMVigVqsxevRo/Pjjj7h8+TJ4nsfQoUNx+PDhfNNPgoKCYDKZcODAAeTk5CAnJ8du+1lZWXbBDLlcDq1WCzc3N7vlhA4dcrkcLVu2dOg88v3332POnDnicgzD4I033sCVK1dw5swZ/PDDD4iLi8PJkyfxyiuvYOXKlVAqlUhNTYXZbMZbb71l12WG53n06NFDLLC5ceNGfPnll+B5HkqlEjKZDNOmTcOBAweQlZUFhmGwefNmhISE4Pnnnxe3I6SfnDlzBlKpFImJiTh9+jRMJhMkEgmkUilGjhyJhQsX4tChQ+jVqxeOHTsGhUKB1q1bAwA2b96MqKgoxMfHo2XLlnjmmWfw+PFj/PTTTwgICMC5c+cA/JdW8vjxY3HGhtAlZe/evQByp7BnZmbaveZC0VYBpSYSUn54nhd/u9LT0xEQEGD33SQEOkptf2DK7VYVUfoJIaRaycjIgFarxUcffYRjx44hMTERgPM8SiA3v79Bgwa4ffs2kpOTn8oYo6OjwXEcli9fjvT09KeyT0LKglCXged51KpVC48fPxa7/hTG398f9erVw4kTJ6jWQAGEmj+2BT2rurIsDFtQMdTS7A5DCKl8jh07Js7mLam4axdKZTtPokZwWLntu6zQTA1CSLWi0WjQokULbN68Ga1btxZPBgTCVEOZTAaWZWGxWJCWllbigIavr2+RlouKioKvry/mzp2L9PR09O7dG88991yR92N71Y+Q8tS0aVNwHAeZTCZe1RcK7xZESIt49OgRjh07BoCuYDvgATc3N7tK/dUloAE4Lwxb3PS+/FI/atWq5XR5lmUpoEFIFZd3ptoff/yBTp06iX8XpZMRKR909EsIqXaE6YS//fabQ0qIcKDr7e0Nq9UKnU6Hf//9N98c6KISZoQUJjIyEt999524v8OHD+OHH36AXC4v0vq2XQMIKU9ms1nsOmE2m3H//n2o1WrUr1+/wPXypkXUq1dP7EZRXbi4uADITWtQKpWQSCT2J+0MkJaWJhYyrmrdX4CiB2iFgFdR0/saNGhgtw+hI5WHhwcA4MGDB07Xq05BI0KqDKZ4p7qurq7icR7LstDr9WKR+ODg4HyDnk+CZ9hyu1VFlH5CCKlWjEYjwsLC8O677+Kbb74Bz/MIDw8Xc6OLoqA+5sURHR2NgQMHYsqUKUXqfS5MM1er1TCbzWLbS0IqKpVKBYvFAoPBIKaiFOVKV0GfMUoByJ8wm4BeH0IIKV0sy6JPnz748ssvS2V7sdcvlcp2nkTNRs3Kbd9lpWqGagghJB+pqamwWCyoW7eueJXz4sWLDsvZXhUVWvIJSiOgIVTdHzRoEE6cOIF69eoVOhuD53l07NgR2dnZBQY0SvNKAiFPKjQ0FHq9HgaDAZ6enmjQoEGhM50UCgWA3M+YXC4XZyzYohN2R76+vqhZs6b4nUYIIaTkBgwYAH9/fwBAv3798M4775TatnmGKbdbVURBDUJItWQ7M8NZO0Pbqcw8z9vlWQqV7ksiMjISCxYsQEJCAgICAnD37l2MHz8eXbt2dbq8Wq2G1WrF4cOHYTQa852azTAM4uPjSzw+QkoqNjZWfJ8mJycjNja20BNuvV4v/lsul1fJtIqykJCQgNjY2PIeRoVTknQ8qk9ECAkNDUVAQAAA4NChQ0hNTS3nEZH8UPoJIaRaMRqNaN68OUwmk10LwsIMGTIE69evL9WxCOknkydPxsmTJwtdXqFQwGAwFHhiWLNmTSiVSty6das0h1puWJaFr68v9Ho9MjMzwXGc3YkvkHviYjAYwHEceJ6HVCqFSqUCy7JITk52mFmjVCqh1+sLfB1pGn/5mzBhAnQ6HXbt2gWdTodmzZph6tSpSE5OxvTp03Hv3j2n6wnpKQzDoF69epg9ezZmzJiBy5cvO12eZVn83//9H1555RXs2rULP/zwg9ihxdfXFzNnzkTbtm1x7tw5cb+zZs3CSy+9BI7jkJiYCIVCARcXFyQlJcHDwwNKpRIMwyArKwsKhUJ8D0okEjAMA7PZLM4Ge+ONN3Dy5ElYrVao1Wp88cUX6N69u90YLRaLWP/ht99+w7Rp0xy6yDAMg2bNmqFTp04ICwvDkSNHsHv3biQlJYFhGDRv3hxjx47F8uXLcebMmQr33p4wYQLOnDmDs2fPFnk2nFwuB8dxyM7OLuPROdepUydcv34diYmJ4v/XgnAcR629CankNmzYgLCwsBJv59GNf0o+mCfkH9S03PZdVigMTQipVmQyGUJDQ9GpUyfxJKFly5bi41Kp1C7IIZfLIZFIsGXLFvG+onYyKci4cePE9JOTJ0+C4zg0a1ZwjmN4eLjDfXkDMtnZ2VUmoPHiiy8iIiIC8fHx0Ol0eOeddxxeA5lMhhdeeAEMw4DjOGg0GoSHhyM5ORk6nc7pgUdOTk6hnRJoGn/5ioqKAs/z+Pnnn9GpUyesW7cOCoUCAwYMgE6nw/Dhw/NdVwhs1alTB3fv3sXrr7+OpKQk8XHbK/AMw2D06NGIiIjAjBkzMHv2bOTk5GDUqFEYNGgQ2rVrh/Hjx6N///7IycnBsmXLMHbsWPTo0QNbt27Ftm3b4OPjA6vVik2bNsHPzw9ZWVk4ePAggNwA2oULF8CyLEwmE44fPy7u+++//8Z7772H48ePo3v37pg3bx40Gg2io6MRGxsLk8kkntwnJydDr9fj3LlzeO+995CVlYUGDRrYPRc/Pz9cvnwZy5Ytw6ZNm/DLL79g+vTpaNKkCaxWK27cuIH169fj9OnTYtCnooiKisKNGzdw+vRpKBQKsCwrFnTOj6urKwwGgxjQUKlUT2Ooos6dO4vf3RaLBXXq1Cl0Fp8Q0Cjqa1+R/h8RUpUUZyZWYGAggNyg9PHjx9GkSZNSGQMPptxuVREFNQgh1c6oUaNw4sQJ1KlTB0DuyYXAZDLZncwaDAa4uLjAaDSKJ8IJCQnF2h/DMJg1axa8vb3F+4YNGyamnwC5V/BiY2PRsGHDfLdz6tQphxPtvH+npaXZ/V2ZW2F++umn2L59u9gO9Pvvv8ecOXPsDkZGjx6Nw4cPw2KxQK/XIzU1Fd26dQPLspDL5Q6vh0C4ojphwgQAhbeDZBgGXl5epfPESKFGjBiBZcuWwWw2Y9KkSTh48CC+/PJLWCwWfPDBB9i+fTtq166d7/pKpVJ83wD/dR9q27at3SwAnucRGRmJhQsX4sCBA/Dw8IBUKsU777yD999/H+7u7jCbzbh16xY++OAD+Pj4YPTo0fjxxx8xY8YMPP/889i1axe0Wi1eeeUVzJs3D1qtFm3atBH30bBhQ/z444/gOM4uKNewYUPs3bsXYWFh+Pbbb/Hiiy9i8+bNAIA5c+aA4zjcvHkTADB79mwolUqsXr0aDMOgYcOGSE9Ph0wmg6enJ4DcYJ3FYkF2djb27NmDnj17omvXruJ3SlZWFv744w9wHAeFQlFoF5qnacSIEdi/fz+A3MAsx3HYvXt3geukp6eL/y5sBkRoaCiA0g18xMXFoUGDBnj06BGA3HQri8VSpO8JnuehVqsLXMa2IC4FNwgpXcJxREHBDaEjklCnTKFQwNvbu1RSkEnpo/QTQki1YzQa0bRp0yJ3MZHJZGXSm1yY2n737l0sWbIEycnJAICIiAhMmDABWq3Wbsp7foSuKJ6enrBarU5TLmyXpenP5GmJjo7GoEGDoNFo8Omnn2Lnzp0FzoCRSqWQyWQwmUxo2bIlQkJCsHfvXsTHxzu8p1mWhVKpdEjDKMjEiRMxcOBA7N692+4zlx9PT09kZmbCYDAUuu2K2JXFz88PKSkpMBqNxeo+QwghxB7Lspg3bx66dOlSKtt78O+VUtnOkwho2Ljc9l1WaKYGIaTaEa6GjhkzBkFBQahRo4b4mLMIvDDDgmEYyGQysUND/gr/ah0+fDjatWuHcePGYdasWejZsyeWLVuGkJAQ7NmzBx999BEiIiKQk5PjdKq97ZU7i8WCxo0bIyEhARkZGeLVSIZhHNI1KlNAo6pdnZTJC3vfVC1Ch5/p06eja9eu2LNnD+RyeYFXxsxmMwwGA959912kp6dj+fLlyMrKEutF2FKpVHYBjXr16tk93qRJEzHgJ4xn+PDhGDduHGbPno2ePXti1apVBY4nOTlZXN/HxwcSicTpd0RAQIAY0MhvGVu2722WZcUATVEV9UphQkICrFYrGjZsiODgYApoEEJIITiOs/vtEGg0GowfPx6HDh0qp5GRglBQgxBS7SxduhQAsGLFCty6dQtxcXHiYyaTCcB/0w4BiO1TeZ6HyWRyKFTpyP6Kcu/evR1yMN988024u7uLV5+3bt2KVq1aYeXKlbBYLDh27BiuX78uTrWXyWR269umsgDApUu5/c61Wi0yMzOhVqvBsixatmyJIUOGFDLeiqkiXfUujU4IRkNh75uqRUjrOHToEJKSkmA2m/HWW285FMEEIKZr8DwPs9mM3r17IyUlBUBumgHLsli9erVd22PbtsY+Pj64ffu23TavXLmC/v37O4zn2rVr4Hkef/31F1q3bu3w2Zo4cSKA/1K3DAYDVCoVdu/eDavViilTpoiPC6kfDx48gKurKwAgJCRETPmQSCTo06cPAPv3UN73dlhYmDgbRNivUPPHGdvgZEHBP+H1/Pfff8W2hEVZr6zlfc2f1nTukj7ndu3aYfHixaU0GkJIRSL8vgjfr02aNIFarUbNmjXFx/v06YNly5aVyv6opkbpovQTQki1YjQaERYWBqvViqlTpyI8PByLFi3C3r17i7T+Cy+8gISEBFy5UvJpg2XR/aQiToEviZJ2P0lKSnJ4PWxfI4lE4rRjQVV7HSsbqVSKsWPHVsjuJzqdDh988EGRup8In1edTgc3NzexEHF+3U9cXFzwxRdfoEePHnb1FErS/USoJyIES1QqFTIyMirc+7sydj+Jjo4Gx3FYvny5XY2P/EilUjFwXhRFTZEkhDwdXbp0waVLl+yKPj+p+/9eLYURPZnaDUPKbd9lhWZqEEKqldTUVFgsFtSrVw+3bt1CSEgIevfuLT6et1Bn3it7//vf//Dpp5+WeBxl1f3EdoZJZVca3U9sU4sEPM+LJ3j5TTN1dsJX1dJhypqLi4vDfUV9DUeOHFmq3U9ycnLEdqq2MyZYli1295NXXx0udj/Zvn17gd1PrFYrfv31V3h6esJsNufb/aRXr16YN28eXF1dMWnSJMTGxsJoNGLDho0AStb9ROjWJBQq1el04HlevPpYEVTG7idRUVHw9fXF3LlzkZ6ejt69e6Nu3boFriN87xT1c1AaM8QIIfmz/Szm/VyOHj3aoVvWiRMnCi0sTsoHfVsSQqqF2NhYuyvy9+/fx9q1a9G4cWNxujkAhwP9vAeVkZGRePz4cbH2zbIsJk+e7LAd2+4nzZo1K5XuJ8KUfYHtdP3KpqTdT2QyWb6daoT3gtVqhcViKdL09+LUPCBwWsCzKLMDWJYtle4nnTt3FqcR37t3D3K5HB07drS78m21Wh26n0gkkgK7n7z2WqTY/aRTp04Fdj+RSqXo3bt3od1PvvzyS7z44ovYsmULeJ4X3+enT/8J4Mm7n3Tp0kXsAGQwGPDXX3+B4ziwLAt3d/dC/188LZWx+0lkZCS+++478T39+++/IyMjo8ATnpycHABF635CCClbwsUQ279tHTx4ECqVSiyyLJfLYTAYkJOTUyoz3XiGLbdbVUTpJ4SQamHGjBlYuHAhhg0bht27d6NHjx44fvw4MjIyCl23LLqfSCQSWK1WmlpMqjTb9CEh5aGgk09hJoWXlxcsFguSkpKe4mgLFxAQgLp16+LkyZNO05aeFMMw8Pb2RkpKSqlut6D91a5dG6Ghofjjjz+K1UHmaSmrrlOEEFIUedNQGYZBzZo18ejRIxw6dEhs9fqk7t28XtIhPrHABo3Kbd9lpWqGagghJI8PP/wQ33//Pa5fvw6DwYA9e/agVatWGDx4sF2kPm8BTo7jxAJ7tldFS0qr1VJAg1RpedOHOnToUOg6Go0GDMMgISHBYdZR3qtotjN2Cu9IVDoePHiAixcvFmvWjrPZUnmv5vv7++Px48dPJaABAC1atIBer8euXbsqZEADAAU0CCFlRvg9cfb9XKNGDXTr1s0uoNGjRw/Mnz9f/F168OBBicdAhUJLFwU1CCHVgkKhwODBg7Fr1y4xx/z333/H+vXr7a4cC9OUbd25cwc8z8NgMDgtPFkYLy8vh/vynrAJqG4DqSrypg8dOXIEY8eOLfA9np2dbZcaxDAMBg4cCJZlHQ4+bYOCQueQosibUpY3DSNvZw6hDoIgPT0ds2fPLnQ/wvP09fV12KfFYoFWqxX/TkpKcvq6COsV9Jo9SR2dv//+O9/UrKch72taGahUKri5uYl/U149IZWXUEza9rdD+J5NTk7GgQMHIJFIwHEcJBIJ9u7di3feeQevvvoqAODu3bvlMWxSAEo/IYRUK0L3k27duuH06dNISUkRf9wIIaS6UigUmDp1Kg4dOoRDhw6V93AIIaTCWrt2LVq1alWibdy9eaOURlN8dRoEldu+y0rlC5UTQkgJCN1PvLy8xNagRQ1ouLi4VNip2oQQ8qSEjiMfffQRGjRoUN7DIYSQcicUHFepVOB5HmlpadBoNDCbzSUOaACosgU7ywu9moSQasFiseCzzz7D888/DwBYs2aN2Aqwe/fuRdoGBTQIIVWRXq9HdnY2WJbFnTt3yns4hBBS7qxWK4KCgiCTycDzPHieh06nw7ffflveQyNOUFCDEFItfPHFF/j222/RsmVLAEDr1q3Fx4RWgoQQUp0MGzYMhw4dwkcffQS1Wi22OM6P0M1Go9Hku0zTpk3h6upaFsMlhJCn6tKlS4iPjxdbYwPAuHHj0KJFC7z11lu4ffv2E2+bCoWWLqqpQQipFu7evQs/Pz8oFAq8+OKLePDgQYEFP2vUqIG4uDi7+xQKhZiyQgghlZlEIsHBgwfxwQcf4MyZM2BZFl27di0wyEspeISQ6oRhGLi4uCAzM9PuPgBo0qQJUlJSsGvXLqhUqmJv+/atW6U2zuKqV79+ue27rNBMDUJItXDp0iW0atUKjRo1wv379wvtYBIfHw/Avt4GBTQIIVWFRqPBzJkzcebMGQC5U60fPHiAxo0bi8vYdlZp1KiRQ0BDpVI5dDJxVqNIKpWW5tAJIaRE8nYvyq8rFs/zyMzMREREhPgYz/Pw9/dHYGAgYmNjERMT80Rj4Bmm3G5VEc3UIIRUC5mZmXjw4AESExPx5ptvIigoCNeuXStwnfr16+PBgwcwGo1PaZSEEPL0SKVSmEymfB93dXWF2Wym2RmEEGJDrVajR48e2Lx5M3777TcEBRW/m8itEqSulFT9evXKbd9lhWZqEEKqBbVajZCQEDRq1AhWqxW1atUSH2vZsqXD1UUXFxfcv3/fLqDh7e1d4D4YqmRNCKlECgpoMAyD9PR0ZGVl4d133y2wjgYhhFRFdevWRY0aNdCpUye7FJPs7Gzcu3cPLVq0eKKABil91NKVEFIt7NixA9OmTRPTTk6dOiU+dvbsWZjNZshkMvE+Z1cmdTpdgfvgeWspjZYQQspX3om8BoOhnEZCCCFlh+M4pwWSpVIp7ty5g2bNmuH48eN2x4g+Pj6IjY3FL7/88sT75fmqmQZSXij9hBBSLWRmZiI5ORkmkwm9evVyOGDned5pLriAYZhC63AQQkhFJJPJYDQawTAM/P39IZfLcauIReoYhgHDMGjYsCGmTZuGa9euYdasWQXO8iCEkKouLCwMH3/8MZo1a/ZE69+8VX7tsxvUr1tu+y4rFNQghFQ7zz33HBISEuzuyxvUGDx4MJKTk3Hw4MGnPTxCCClVHMehUaNGuHv3LgwGA5RKJSQSiV2bQmfrCFcvWZZFYGAgHj58CJ7nYTabwbIsrNb/ZqdJJBKYzeayfiqEEFLmevTogXPnzkGn08FoNIrfdcIFLiHQGxcXh127dsHX17fY+/j31r3SHnaRNawfWG77LiuUAE4IqfJ27NiBpk2bolGjRmjUqJFDQMOZixcvFjhzgxBCKgNXV1eEh4fjypUryM7OhsVigdVqRcOGDZ0uL5fLwTCM3XRsiUQCT09PmEwmuLq6QiKRwMfHx249i8Xi0AmFEEIqOmfdmcaOHYvXX38dgH0qnhDQkMlkkEgksFgsOHr06FMbK8kfzdQghFR5QueT1NRUmEwmjBkzxmEZZ+knjRs3xpUrVwDkn3NJCCHVCcMwcHd3B8MwSEtLo+9FQkiVlHc2Wn4iIyPx8ccfF3v7NFOjdNFMDUJIlSd0Pmnfvj3+/vtvALlXI23lLYLXuHFjbN26VexdbrVaxb7lhBBSnaWmpiIlJYUCGoSQKstqteL5559H06ZNHR6rU6cOhgwZgoCAALz33ntPtH0eTLndqiIKahBCqoUdO3YgLCwMixcvBgC0b99efIxhGIdp01evXkVwcLAYpbdarXj06BEAx64AhBBSXfA8L944jgPHceU9JEIIKVUSiQQMw+Ds2bNo0aKFmJYnePjwIbZt24Z58+Y5XCQj5YPSTwgh1UJmZiYuX76M1157DUBuDqVt9f686Sccx0Gj0RRYSI8QQqo7tVoNuVwOnU4n1usghJCqjGVZSCQSXLhw4YkDu9dvPSjlURVdo/oB5bbvskIzNQgh1YJarRZ7jDMMU2g7QqlU6pByEhoa6rggFRMlhFRTWq0WmZmZSElJQaNGjSigQQipcl555RWH+xo2bAir1UrfeRUIzdQghFRZO3bswLRp0wDk1sywzf8W2nIJeJ6HVCoVWxLK5XJYrdZCgx+EEEJyUUFlQkhlIXxf5S0IKpPJYDKZ7I4R8x4zuri4oEOHDpg6dSpUKhVcXFyKvf9rtx6W7AmUQHD9WuW277JCQQ1CSJWVmZmJ5ORkAEBycjLOnj2Lb7/9FgzDoE6dOrhz5464rLPuJ3SATgghRSMEhemwkhBSnbz99tuYMGFCsdejoEbpoobihJAqS61WQ61WAwACAwPFg22e5/HggX0uo9B33Gg0ivdptVqkpqaKf7u7u9v9TQghJJdWqxVbvBa1FSIhhFQkeb+73nvvPaxcuRJJSUlgGAYcx8HV1RXJyclYtGgRXnjhhXIcLbFFNTUIIVXWjh07EB4eLt5sZ12EhoaKNTKEYIdtQINlWWRlZdltT6fTPYVRE0JI5ZOcnGz3HUstsAkhFRnLOp4GCwENtVoNiUSCDRs2ICUlxW6ZlJQUBAYG4tdffy3R/qmla+mi9BNCSJVlm34C5AYtevXqBQBQKBQwGo0OVxPz5k0KXFxcIJfLHX7cSiI6OhoDBw7E2rVrsXnzZqSnp4PjOFitVqfFTHv16gV/f3+sW7fOaYBFJpNBLpfDYrEgOzvb6T7ze36EVDTR0dHgOA4bNmxAQkICeJ4v9Oq/7fs7b4cjILdWjpArbfs58PX1xcyZM9G2bVucO3cO06dPx7179xAdHY1BgwZBo9Fg6tSp2LVrFywWCyZOnIgRI0ZArVaDYRhkZGRAIpHg66+/xu7du5GdnY2PPvoI3bp1g0qlgl6vh1arFccn/HfOnDlYtWoVzGYzPv74YwDAvHnzkJ6eDoZhULduXXz55ZdQKpX45ptvcOTIEfE1ECru502RE64mCvWByoNMJoPFYoFCoUBOTg7N2iCEVDlqtRp///33E69/9dajUhxN8YTU9y+3fZcVCmoQQqoNnufRvn17pKSkoHv37qhTpw4WL15cpHUZhsGFCxfQvHnzUhlLVFQUxowZgyFDhuDhw4cYOnQo1q5dC4lEArlcDl9fX9y4ccNunYJy1m2nTAonTDQFnFRWUVFRqFOnDj755BP4+vqicePGOHr0aIEn6jKZDAzDwGg02gUO8pLL5eIyADBw4ECYzWbs3LkTgYGB+L//+z8EBQVh8+bNGD16NCZPnoyLFy8iKysLkydPRmxsLKKiovDhhx+iT58+6NGjB3Q6HXr16oWsrCx88sknSElJQUREBKZPn46xY8eifv36yM7Oxh9//IGePXuC53ksWrQIy5cvx+TJk/HgwQPUqVMHH330EQBg+PDhSEhIwOHDhyGXy9GxY0fs2bMH7du3x+XLlx2Cmnmfq0qlchrYrF+/Pm7duvVE/0+KjAeCGgXBaDTi7t27kEgk5RpgIYSQ4njnnXfwww8/OASMWZbF6dOncfz4cXzwwQfYunUrGjZs+MT7uXIztqRDfWKNG9Qst32XFQpqEEKqlWbNmsFgMDzRuj4+Pnj8+HGpjOPYsWNYvnw5VqxYgbfeegubN29G586dkZycjAMHDkCj0SA7O7vQQqUqlQpGoxFms9nh5MHLywtJSUmQyWQwm80U4CCVxrFjx9CvXz8kJSUByD1pnzRpEhYsWFCsz69Go0G9evVw8eJF8T5XV1ekp6fb7Uv4LAK5V99OnjwJg8GAhQsXYvny5QBygyZ//fWX3f3Hjh2Dj48PjEYjnnnmGfA8Ly5z9+5dDB06FH///TcWLVqEcePGwWAwYPny5Rg7diy6du2KUaNGITIyEjk5OXjppZfE56tWq3HixAm8+OKLyMrKgsFggFqtxunTp9GhQwd06NAB27dvB5A7i0x4TTQajVj3h2VZ1KxZEw8fPoS3tzcSExPh4uICq9WKnJycJ/1fU2xyuRwcx+U7e4wQQioqmUwGtVqNtLQ0WK1WPPPMM4iJicH06dPRt2/fEm2bghqli4IahJBq5dlnn0ViYmKFmMWgUqlgMpng4+OD9PR0ZGZmFrh8hw4dcPHixUKXI4SUDpVKBbPZjPDwcPTt2xeLFi3CvXv38l1eKpVCpVIhJycH06ZNQ+fOnbFixQqsWrWqwGCMMAvL3d0dDMMgNTXV6fdTRfjeelIMw4BlWXAcZ1e/iBBCKpPp06dj6NChJd4OBTVKFxUKJYRUKxKJBEqlMt8TA5lMJv5boVCU2ThkMhlmzpwJX19fPHr0CHq9Xhxffk6dOoWsrKwi90OXy+WlMlZCqiPhMxoWFoaYmBjMmTMHCxcuLDAFzWQywWw248cff8TLL7+MESNG4KeffgLP82jXrl2+65nNZrAsi9TUVLFuj7PPb6ULaNhcNhNaZFNAgxBSERR0vCV4+eWXoVQqwTD/FdccOHBgqeyfCoWWLgpqEEKqBaETSnx8fIFTr20PuGvUqFEq+w4ODsbHH39sFyR54403cOXKFTx8mNun3Gw2IzAwsMD2YFarFTzP23VlYRgGGo3GYVmVSiVeGS7KDzch5YnjOEgkErsDx6dFpVIByA0isCwLHx8fAP99Rm/cuCEWHb506RJu3bqFOnXqiOuzLCveAECv16Nt27aQyWS4efMmACAoKAj//vuvXf71iy++KP5boVDAYrGIBUybNWuGd999126cDMMgICCgTF6DMmPzv1NIjSuP/8eEEJJXfkWWbS8c+fv7IycnR6xZ9PzzzyMtLQ2JiYlIS0t7msMlhaD0E0JItbB8+XKsXLlS7KJge2BtsVjETgJPU34dF/IjlUoxZswYyGQybNy4EbGxsQV2MnHW/YGQp4llWfj6+kKv1yMjIwM8zxdYJ0Ymk8FqtUKpVCIrK6vAmQlSqRQAxPd43s/TtGnTcP/+/QLHp1AoYDKZIJFI7IqHOuPt7Y0uXbpg/fr1+S4jdEvRarVOu6hotVokJiZCqVRi1apVWL16td0sLSGw4ax7iPCdZTtGjuMgl8uh1+srxSyO4OBgeHh44PTp07BYLNSNiRBSabVu3Rpr1qx54vUv34wvxdEUT2gDv3Lbd1mhmRqEkCpv9+7d+PbbbzFx4kR4eHiIJwdCNL6gq5+2fcyFK7ilYcSIEWjXrh3Gjx+P/v37IycnB8OHDy9wHZPJhPnz52Pu3Lno2LEjnQyQCu3FF19EREQE4uPjodPp0KFDh0LXqV27Nho0aICMjIx8l2FZVgxGmEwmMAyDsWPHOnyeunXrBgCQSPNPIxOCAXXr1i10bImJiTYBDcfZBlFRURgxYgSmT5+OiIgI5OTk4N1337W7f/369fDz88OaNWuwdOlSWK1WREdHg2VZseYEANSpUwcBAQHIysoSrx5KpVLwPG8380po32z7PVWRXbt2DSdPnoSnpyfeeOMN+g4jhFRIwoUujuPE79cmTZrg4MGDWLZsGQ4cOFCigAYpfZXjV5AQQkpgxYoViIiIwIABA+xOCGrXrg0ABc54EK5+8jwvzvJ4kgNx21odADBmzBi4u7vDbDbj1q1b+OCDD7Bjxw4EBgYWui2e53HlypVCp3ELV7DLa1o/qd4+/fRTbN++XZydceTIEYwdO7bA9+LNmzdx7do1ALBL6bAll8vtim7yPI+3334b3t7e4ufp/fffx7Zt2xAcHAyzSV/gOHmex9q1ax0+1wWnbf23rDDG1157DQsXLsShQ4dw/fp1fPDBB9i9ezdGjhwp3t+zZ0/MmzcPmzdvFg+a33jjDXTp0gUMw4izWG7cuIG7d+8CyJ0SXadOHTE1ztmMjMrWMvXx48c4c+YM/P39y3sohJBqqLC03Pbt2wPIDRwLM+U4jkNAQACeffZZ8fixJCpbTY358+ejTp06UCgUaNOmDc6cOZPvskuXLkXHjh3h7u4Od3d3dO3atcDlSwMFNQghVZrRaERMTIz4A2V7kiTkuwMF53kzDONwe5Jx2OrYsSM0Gg2OHTuGCxcuoG/fvrh9+3aB6Se9evXC9u3b0b59e1y+fDnf4Irtc2QYBmazma6Ikqfuueeec6hfM3/+/CK/F8eNG4dWrVo5BDZs85sFoaGhWLNmjXjgmZWVhaSkJDFAUphOnTo53Gc2m6FSqSCTydCmTRvMmjVLDDpGR0fj6NGjGDNmjJgG8+yzz2LNmjVwdXWFTCbDlClT8Nlnn0GtVmPUqFH4559/4OXlBZ1Oh9TUVJjNZrz55pv45ptvcP78eTAMg7Zt2+Ktt96Cv78/pFIpQkJC8Omnn4otaGUyGTiOg6urq/i65Pd9VNEDmZcuXcKjR4/g7++PjRs3FrkAMiGElFRhgeBjx47Z/a3RaBATE4NGjRrhlVdeKcuhVUgbNmzAu+++i2nTpuHcuXNo3rw5unfvjsePHztd/o8//sDQoUNx+PBhnDp1CgEBAejWrRsePXpUZmOkmhqEkCotISEBzz33HNavX4/w8HA8//zziIuLA5CbfsKyrDjV3bZdop+fH3Q6HXJychAeHo5z587lswcGdiX+nZDKlDAZ7U/uoqKiMGbMGEyePBkWiwV//vknTCaTmENve9VWoFAooFarkZSUBHd3d6Smpha4XyFfnfLWSWUTFRWF+/fvY9++fVCpVNDr9XBxcSkwLaV///74448/xO4harXaaftjmUzmEGR09hmRyWT44osvsHHjRly5cgVyuRxr1qzBjh07MHr0aAwZMgS3b9+GVCrF6NGjsXjxYlitVigUCvzww49o3boV3n//fbRp0wbDhg2DwWDAiBEjcOvWLXzyySdITEyE2WzGokWL8PnnnyMkJAQfffQRYmJiMGPGDDRt2hTz58/HqVOnoFQqkZycjKCgIHh7e+PEiROQSCQIDg7G5cuXHZ5jfp/9kJAQXL16tVj/L8oED9SoWQM6nQ5ZWVliZxRCCHka8jsuEo4DtVotdDqd3WMuLi7w8vLCgwcP8MUXX6Bfv34lGsM/NxNKtH5JNG3gW6zl27Rpg1atWmHevHkAcmcMBgQEYMKECZg8eXKh61ssFri7u2PevHmIjIx8ojEXhmZqEEKqHeHgOSsrSyxeCPz3JQ0A8fHxYqrJP//8U8DWCg8WmE16eHt7A8jNz6xVqxYiIyPFKemXLl2CRCLBwIEDxdaOFovF4Qq1Xq9HUlISAIgBjTFjxgAAlEql3bJyuVzMvxeen6enZ6FjJaQiGDFiBPbv3w8AyM7OBsdx2L17t8Nytu/7LVu2iAENAMjMzER4eLjDNGOj0SjOrhA4O7gVup+cOXNG7H7yzz//YPTo0Vi4cCFu3boFnufh7e2NcePGoUuXLgByP6dt2rSGXC7H0aNH8dJLL+HHH38Ey7L4999/ERoair59+2LYsGFYtmwZzGYzOnfuDH9/f3EcGo0GQUFBmDx5shic0Wg0uHHjBk6ePAkA8PDwQExMjPga2M7MELYj/Dc0NBRAbk0LYdZauWKAuLg4sZOTUDSUEEKehvzST4QLWzqdzuG7ddCgQWjRogVq1qxZYMHoouJ5ptxuBoMBOp3O7mab1mnLaDTi77//RteuXcX7WJZF165dcerUqSI91+zsbJhMJnh4eJT4dcsPBTUIIVWau7s7OI5DcnIygNyDfI7joFAoxAN+24PpBw8eiP8Wps6bTCaHk6Di4HkeiYmJAHIP3h8+fIiOHTvi8uXL8PDwQFZWFho2bIj+/fvj3XffhaurKwDnufN5rV27FiqVyuHKs/DjJEyx9PT0FK9a08kDqeiee+45ALmzJaRSKQICAjBo0CCH5Qpqz6xUKnHhwgWn04yFejNyuRwSicRpmsmCBQugVqtx7NgxXLx4EStWrMCCBQvQqlUrhISE4Pz587h27RoOHToEiUSCb7/9FqdPn0ZMTIwYVPzrr7+g1WoxcuRIyOVyXLx4EWvWrMH8+fPx8ssvw2q1ol27dkhJSYGLiwt+/fVXvPXWW5g1axZatmyJqVOnYs2aNbh06RKeffZZcBwHnuchlUrF4IxMJnN61VGtVkOj0UChUCAmJgZA7neREBSpiDw9PcUAMCGElJWidIazXUZo9bp161ZkZWUhNja2LIdX5mbNmgVXV1e726xZs5wum5SUBIvFAl9f+9kdvr6+iI8vWgeXDz/8EDVr1rQLjJQ2CmoQQqo0mUyGJk2aiNHkjRs3Asg94enbty8A+4h93tkRwt8mkwlt2rQptXG1bt0aV65cQa1atTB8+HC4ublh7NixmDVrFnr27IkBAwYUug1PT0/k5OQ4rTGQV3JyMgwGg10wh5CKqmnTpuA4DjKZDDzPw9fXF5mZmUVqvaxWqyGVSp1+LvIG9AwGA1iWxcyZMxEWFoaYmBjMmTMHCxcuxNixYx26mSxbtgyTJk1Ct27dwLIsTp06BYvFArPZDI7joNVqkZ2djZ07d4r1PcxmMzQaDaxWK27cuIGlS5dizZo1mDJlCjZu3Ai5XI7Ro0fDaDRi6dKlWL16NT7++GNs3LgRSqUSI0eOxIcffog9e/bg5ZdfxujRo2EymZCWlob27dsjPT3daYA2KysLEokELMtW7M88nztuNzc3JCcnIzU1lQKvhJAylV8RaoGLi4sYEBdS+dauXQutVguTyVQqRY6tYMrtNmXKFKSnp9vdpkyZUuLn5Mzs2bOxfv16bN26FQpF/t3ISoqCGoSQKm/UqFHYuHEjpk6dihdffBFAbvrGnj17AOTOZhAOohs3bmy3ru1siStXrpRoHN27dxenM968eRMhISG4dOkSRo4cibp16yItLQ1eXl7YsmULjhw5gkaNGjndjvCj0KBBAyiVSvA8D6vV6pCCAsBuhkneDiyEVFRmsxkNGzZEZmYmzGYz/v77b6hUqiLNmMrMzISbm5vTx54kzeTw4cNiNxMfHx+8+uqrMJlM+P7779GgQQNs3rxZbMdqNpshl8vx/PPPi7NIVCoVfvvtN5jNZvj5+WH16tV488038dxzzyE4OBhffvklEhMTcfDgQaxevRpvvfUW7t27h6CgIHz11VdITEzEzp07ERQUhKysLJw9exZDhw4Fy7I4evSo3YH4nDlzxGCKUqlEamoqsrOz7YIERemw9FQxuf9fhJQ6q9UKjUZTzoMihFRVDRo0cDoT1jb9wmAwoG3btuLMWdvgdGZmJoYNG/bUxlsW5HI5tFqt3c32t8SWl5cXOI5DQoJ9DZCEhAT4+fkVuJ85c+Zg9uzZ2L9/P5o1a1Zq43eGCoUSQqqFtWvXYunSpWJbVpZloVarHQpBEUIqp+joaAwcOBBTpkzBiRMnCl1eqVRiyJAh+P3333H//v1CZzNER0dj0KBB2L17N5YsWSKmtAn3r1mzBps3b0ZmZiZq1KiBjIwM6HQ6+Pr6okePHhg1ahQ0Gg10Oh3c3NwglUoRHx+Pd955BxcuXIBSqYTJZIKPjw8yMzORk5MDb29v5OTkICMjA3K5HFlZWeB5HjKZDGazOd8UtcpcHFgIXDVt2hQsy+Kvv/4q5xERQoijNWvWoHXr1k+8/oV/E0txNMUT1rB4aX5t2rRB69at8eOPPwLIDT7Xrl0bb7/9dr6FQr/66iv873//w759+9C2bdsSj7kwNFODEFItDB8+HB9++CEkEglq1aqFoKAgp50RhOntarUaPXr0APDfQbZWqy2TsdEMCkJKJioqCiNGjMCgQYNw4sQJ1KtXL9+rTgKj0YhVq1bhwYMHhaY7CNsfN24cZs+ejZ49e2LlypUYP348RowYgVGjRmHVqlWYPn06Ro8ejXv37sFkMuGnn36CVqvFxo0bsXLlSmzYsAGenp4wm8348ccfcfXqVdSrVw9SqRSff/45atSogbi4OFitVgwYMABxcXFgGEb8vlKr1fDx8YHRaBQDGs5maFXWgAYA1K1bFxEREbh8+TL++usvmrVBCHnqhGPBCRMmwMvLC0DuLDeNRgNPT080adIEX3zxRYn2wYMpt1txvfvuu1i6dClWrVqFq1evYty4ccjKysKoUaMAAJGRkXbpK19++SU+/fRTLF++HHXq1EF8fDzi4+OdHneXFgpqEEKqjRUrViAiIgLvvvsurl275vQqp9AZxWg04ujRowD+K7ZZ2rM6hCnyeYt8ElIdleTkNTIyEgsWLBCnx965cwfjx493WpRMqKFjsVjEFqxDhw4FwzAIDAwUC28KgY7WrVvjtddew5IlS3D58mUwDAOpVIq2bdti5MiRWLBgAW7evImxY8fi4cOHOHbsGAICApCRkYGEhASsXLkSSqUShw8fRs+ePfHjjz+C4zjEx8fjzJkz+O233xAVFYUePXrg/v37aNOmDTIyMsSUE51Oh5iYGDz77LPQ6/VISUkRD7g1Gg1ycnLAsqzT4EaNGjUqXX2KGzdu4Oeffxa/FwsqBksIIaVJqLUhHAuuWLECaWlpAIC5c+dCLpdDpVLh7bffxrVr14pUcLQqGDx4MObMmYOpU6ciLCwMFy5cwN69e8Xioffv30dcXJy4/MKFC2E0GjFw4EDUqFFDvM2ZM6fMxkjpJ4SQasFoNCIsLAw//PADGjVqVKQKzLZTuGUyWakHH1QqFUwmE1QqFXQ6XaFXV4VceWE54UfXllwuz7ctFyGVyYQJE3DmzBmcPXu2SJ2AgNJPuxBSS7RaLRITE6FUKrFq1Sps3rwZGRkZ8PHxgU6nQ2ZmJnieR7NmzTBu3DiEhobCx8cHJpMJEolErA2iVCoRExODL774Ajdu3MDUqVPRu3dvsCyLTz75BDt37oTFYoFUKgXP8/D09ITVakVycrLYollof+rs82+LZdkiv24VlRBomjJlCp5//nlERkbi9OnT5T0sQkg1xzAM2rVrhxUrVjzxNs7dSC7FERVPiyDPctt3WaGZGoSQaiE1NRUWiwWenp7YsWNHoctLJBK7k6PSDmjIZDLMnDkTGo0G6enpkMvl+OSTTwpch+d5KJVKWCyWfE9oKKBBqoKoqCjcuHEDp0+fhlarRevWrYs040BI5cpb8NdWUdszCykn06dPx/r16+Hn54c1a9aIaSZ9+/YV2/rNmzcPDMPgxo0biImJEdumXr9+Hbt27YJCoYBUKsXHH3+MtLQ0fP/991i8eDF69OiB//u//8MLL7yAAwcO4NVXXwUAsW3r48ePkZGRgdq1a4sFgYHcgKazTjAsy6J27doAitYSuqJjGAYKhQLjx49HcnKy2BqbEEKehpCQEDRp0gSurq52nTsaNWqE77//vhxHRvKioAYhpMrbsWMHunTpAgAYMmSIWOioIELKSVlN3X7jjTcQExODlJQUAIBer4dGoyl0BklGRobd32FhYXBxcSlwHarZQSqbESNGYP/+/QCAtLQ0nD17FuPGjbNbxtlnUwjqCXm+zhQ2XVir1SI0NBSvvfYaFi5ciEOHDqFnz5749ddfsXnzZowdOxZXr17F4cOHERQUhIyMDGRmZqJ79+7Q6/WYN28e2rdvDwDYu3cvWrdujePHj4s1Ps6ePQtvb2+EhoZi0aJFOHjwIJKSkjB48GBcuHABgYGBYBhGbEmr1WrtpvUK06MZhhEr8wtUKhUePnzo8JxUKlWBz7mislqtuHbtGsxmM3799VckJSWV95AIIVVYhw4dxBRFILfYpa+vLwwGAwYMGAA3Nzf4+PhAq9UiOjq6RDMDK1NNjcqA0k8IIVVeZmYmbt++jYiICIwbNw4LFixwWEboQ/60uLq64rXXXgPHcdiwYQMSExPRsGFDfPTRR9i7dy/WrVvnMBuDZVn4+PiAYRgkJyeL+fTZ2dkF7qsyd0Ig1RPLsujYsSPOnz8v1rKRSCRisLEoXFxcwLKsXSCwuCkZKpUKZrMZ4eHh8PX1xa5du/KdJcVxHHx8fKDX65Gamip+7uRyOSQSCbKysgrcl7u7O9LT0wscn20Hlp9++gkpKSmwWCyIjo4Gx3FYvnw50tPTxeUZhoGfnx94nhc7PwkkEgkYhnEa5PHx8cHjx48Le3meOo7jwDAMGjduLH6vE0LI0+Tu7o5t27ahU6dO2LBhA8LCwp5oO3/fSCndgRVDyyCPctt3WaGZGoSQKk+tVqNZs2Zo2rQpHjx4AAAOnRHyBjTyzm7w9/cv1TENHjwYvr6+mDt3LsLDw7F582bUr18fI0aMwLp16/DSSy85rCMUF4yPj0dQUBBSUlLEgIazIoFBQUEAKncnBFI9de7cGcePH4dOp4OXlxfCw8OLvK7wWc7KyrILaHAcZxcwEGY85DeTSUgRCwsLw8WLF7Fjxw5MmDBBXM92X0BuSkhcXJyYFvLaa6+JV/iys7PRq1cvcdkWLVqIhYIB4LnnnkNqamqBhT3zdmB56aWXsGTJEowZM0b8LklPT0eLFi3EbQgzPuLj4xEQECBuSwgQmUwmu1QdYaZYhQto/P+vMCFAo9VqKaBBCClztt/H7u7uUKlUSE1Nxc2bNwFUjTS/qoKCGoSQamPUqFHYs2cPgNyTioLkbd/64MED8Dwv3kpqxIgR+O6778DzPCZPnoy9e/fis88+A5AbhLh79y4CAwPt1hGuqPI8j8uXLwPIPfGqUaMG2rVrBwB2J1wA7HJABZWtGwKpfh49eiTWvkhKSsKNGzfg7u7utI5EXnk/nx4euVek8s6wEA5GbVMzhBoOADBmzBhcuXIFZ86cgV6vB5B7Ui2VSsXPUP369R2u0iUlJaFdu3aoX78+Hj9+jLCwMPA8j4MHD6Jhw4YAgFu3btl1Uzpx4gTc3d3x6NEj8DyPoUOH2o0JyO3wsnDhQly+fBk8z2PLli1o1aoVoqKixO8SALhw4QIiIiIgl8thtVrFyv0PHz4Ut2U74+XatWtgGAa+vr44c+aM3XNhGAYvvvii+Hfe75enhsn9//To0SNYLBY8fvyYvscIISXi7Pss7/e5EEQFcgPlnp65BTY//PBD+Pv7F1i/qTA8z5TbrSqi9BNCSLXyxRdfYOXKlQ5XbQUymQyffvop+vTpg6+//tppGogzCoVCPPFxhmVZ/O9//8PGjRtx/vx5ALlTyQcOHIi1a9di8+bNyMrKQlhYGPr27YuFCxfi/v37dtvo0KEDPvzwQ5w4cQILFy502mJWGAfDMOLVWPqaJ5WRbarFkiVLkJzsWCl+woQJ0Ol02LVrF3Q6HZo3b46pU6ciNTUVM2bMwK1bt+yW79OnD4YOHYolS5bg6NGjsFgsUCqVeOedd8AwDL7++mu7osDCGDQaDaZOnYqdO3fCarWKnYvydj8ZPHgwBg4ciP3792Pr1q3Q6XTw9vYWlwEAb29vmM1mpKam2n02pVIpOI5z+j2iUCjEWRck93ta+K7z8vJCYmJipW2tKJFIIJVKodfr6buakEpCoVBgy5YtqF+//hNv46/rqaU4ouJ5ppF7ue27rFBQgxBSrWRkZCA0NBTPP/880tPTcfXqVfGxrl274vLly4iPj0ft2rURGxuLSZMmYcmSJXBxcUFiYqJDTr+buyfSUv872dJoNA7FPL28veHt5YVbt26JJ0xRUVEYM2YMhgwZgkePHuGrr76CVqvFhAkTIJPJEBoaiiNHjjiMv379+uKJmpCzn7dOAMdxsFgsFTYvnpDCCJ+PUaNGISYmBsOHD8fzzz+PqKgo8b0eFRUFuVyORYsW4ZVXXsGIESMwZ84cnDlzBvPmzcP8+fNx8eJFh20HBwfj2rVrGDBgAFiWxR9//IHExET07t0bv/32m7jcuHHj8Prrr2Py5Mm4fv06kpOT0aFDBxw9ehRffPEF5s6di4cPH0Kj0WD27Nl4++234enpCW9vb9y9exeff/65uIxarca3336Ld999FxkZGWAYBgzDwGq1QiKRiG2d8xI+47Z1cYTPd7XFA2BygwEBAQG4d+9eqc2ge5q6d++OI0eOiEGsWbNm4aOPPirR8xBmMlXr9wchZUj4LpZIJIiJiSnRts5eTyudQT2BVo3cym3fZYXSTwgh1YpGo0FYWBhOnToFjUZj99i0adPELin3798HwzCIjIxE165d7boP2LINaDAMAx8fH4dl5v34I2bPng2j0QiVSoVp06YhMjISCxYswK1bt/Dmm2/i6tWraNGiBdq2bYvk5GQcO3bMLudeYHvlmed5DBgwAF5eXmK1btsZKLZ59YRUZC1btgTHceL7OG+qxdatW9GqVSt0795dXGfEiBFYtmwZzGYzJk2ahH379uHLL7+E2WzG22+/jYsXL8LLy8uh88e1a9cA5M7aSklJEVsp79q1CxqNBh07dhS3v2jRIhw6dAixsbEwm824cOGC2P1E6DIidD/p2rUrkpKScPXqVYwaNQqXL1/GgwcP4OPjg8zMTKSkpKB9+/biQbHVahW/g/KmiQ0bNkwcu4uLixi8dHV1RWRkpN2yzurpVGn//+vMbDbjzp07GDJkSKXr8BQaGoqaNWvazco5cuRIod2vCuOs3XeDBg1KtE1CqhPb7xJnBUCFoCPP83YXxUj5o5kahJBqJyMjA/3798ft27ftWnc5s2bNGty5cwc//PBDoe0EWZatlFcMCSGksmIYBoGBgZgyZQoePXqEWbNmVdpUFEJI5XL9+vUnXpdmapQumqlBCKl2NBoNDhw4gGbNmon3qdVqh5kbQuvU2NhYpKeno3379gVu12q1OnRVyYtmTRBCSOlp2rQp1Go1xo0bh88//5wCGoSQUhEaGgoAYucotVqNDh06AACaN29eooAGQIVCSxsFNQgh1caOHTsQHh6OZs2aITQ0VJw6WKdOHdSrV88unx74LwCxe/duuLi44PTp04Xuw1nxUdsK24XNDCGkuiros+GsSr1th6In7crBMAxcXV1LvB1Sfi5duoTLly+L6TxCdwJCCHlSYWFhYtqxkGoYFBSEEydOAAC+/vrrchsbcY5+vQkh1Ubnzp2xbds2fPnll1AoFGKayN27d3Hp0iU8//zzdssL3UMePHiAtLS0IhVfs+2cILANdNBVREKcy1uENzo6GseOHcOUKVPg7u5Yqd22sKbVahXbknp6ehZ5RhTP80hPT7fbDqm8TCZTkdr+EkJIQS5evCh23BKOFc+dOwcAcHFxcVrYubis5XiriiioQQipNtRqNQIDA/HSSy/hvffes3vs5Zdfhp+fn919Pj4++Oabb8DzPH755Re4uLg8zeESUm1FRUVhxIgRGDduHGbPno2ePXtiwIABBa4TFhaG1NRUJCcn47333nP4PDsjdCEhVYPJZMLjx4/FFriEEPIk5HK5mHIszOBr3rw5AOCdd96xm+FHKgaaB00IqRamT5+OdevWiX/nner+zz//ICsrS/ybZVnExsaKV25fffVVSh0h5Cmx7X4CAFu2bIFSqXRoX2zr/Pnz4r/9/PyQkpLisIxta1QAoKK+VYswE06v18PT0xMymSzfzlWEEJKfF154Afv27RNbb7u7u+P69euoU6cOevTo4dBVi5Q/6n5CCKkWEhISEBMTI041j42NxQ8//FDgOrYnUCqVCm+88Uah69iuy3EcWrRogb59+2LRokW4d+9evss3btwYCQkJSE9PF7uoBAQEIDs7G/Hx8UV8lvbUajWysrLoxI1UShqNBjKZDBkZGdBoNEhNTS0wPUS4Ms/zPCQSCVQqVZGnCPv6+mLmzJlo27Ytzp07h+nTpzt8XqOjozFy5EioVCqxyxHLsmAYBhkZGZBIJJg6dSp27doFi8WCDz74AJGRkZBIJHbBFOG/DMPAYDBgzZo1+OWXX5CUlAQvLy+YTCakp6cjODgYn376KZo1a4bvv/8ea9euFZ+PEGD19PREamqq07Q3Yh/EKiggRgghxRESEoIVK1Y4TY0sqlNXS57C8qTahWgLX6iSofQTQki14Ovri86dO6Nfv37o168f2rZta/e4j4+P0/Xkcjk4jgPLsqhXr16R9iWRSBASEgKWZXH58mXMmTMHCxcutOt/bsvb2xtXrlxBSEgIgNxK225ubvDz80NmZqZ4slaUKwMcx4nPJTMzkwIapFJq06YNsrKykJqaCo1Gg5SUFEil0gILeQqBBpVKBbPZDJ1OhxEjRjhd1jY1ISIiAu3atcP48ePRv39/5OTkYNmyZXaf16ioKIwePRoMw+Dw4cPgeR5msxnZ2dnivrt3744DBw5g6tSpePPNNzFkyBDMmDEDN27cAABYLBbcuXNHPNHW6/U4ePAgvv/+e3Tq1AmTJk1CfHw80tLSMGvWLDRq1AijR4/Ghg0bsGjRImRkZCAiIkLclkQiQUJCAoxGIxo3buyQbsEwjN3ssvy+f6oynufBMAxatWpFAQ1CSIFsv0N9fHwQHh7usIy/vz8AICUlBZ9++ulTGxspHAU1CCHVwo4dO9C0aVM0atQIjRo1QmRkpN3jSUlJdn9zHAcXFxcYDAZYLBZkZmZi0qRJRdrXmDFjEB4eDoPBgKysLCQnJ+Off/5B165dnS5vsVgglUpx/fp1NGzYEL1790Z6ejpMJhNUKpX4QyucQNl65ZVXxH+zLAuZTEaBDFLpuLm5iS2VWZaFTqdDUFAQrFYrkpOTwXEcXF1di3Rinp2dLda/2b59O3x9fe0eF2ZRCaKjo+Hu7g6z2Yxbt27hgw8+gI+Pj93nNTIyEiaTCT/++CNCQ0Px448/Avgv0KhQKMRiwv369cMbb7yBlJQUbN68WbySx/O8OBOD53kolUqsWrUKAwcOxNSpU7Fy5UoMHjwYSqUSf/zxB2bMmAGFQoEFCxaA4zjwPI+MjAyEhISA53m72Rnx8fHw9/dH/fr1xfs8PDzsiq8WpdBxVSMEkDp27AipVFrewyGEVBDOLhLZHjs1bdoUderUAfBfsKNBgwbo168f3N3dIZFIcOnSpRKNgQdTbreqiNJPCCHVQmZmJh48eIDU1FQAwK5du7B58+Z8l+c4DjKZDDk5OQAcc/GLS6FQgOM4u7odtqKjozFo0CDs3bsXK1asQGJiIiQSibj/vJ555hl4eXnh4MGD4omLVCoFx3HQ6/VPPE5CKooJEybgzJkzOHv2bJGusgcHByM1NRUJCQnifXk/t8X9HAuzPsLDw+3SyKKjozFw4EBMmTIFJ0+eFLfZqFEjJCcnIyUlBSqVCkajEd7e3sjIyEBOTg4CAgKQkpKCtLQ0u/0wDAMPDw+7bizVMQhRVmQyGRQKBfR6PYKDgyGTyfDXX3+V97AIIZVIjx49UL9+fWzYsAHp6eno168fPvvssyfe3smrGaU4uuJpH6Ipt32XFZqpQQipFtRqNUJCQtC+fXukpaVh+/btBV65s1gs4tRDYfZDfikqRWE0Gp3OtAD+6/SwYMECfPXVV+jXrx9atmyJnJycfKfbp6WlYd++fTCbzXjppZfAMAxMJpNdQINaG5LKKioqCjdu3MDp06eh1WoxZsyYQrsPXbt2TQxouLq6QqlUOgQwihrQkEgkkMlkmDlzJsLCwhATEyOmkUVHR2PEiBEYNGgQTpw4gU6dOmH69OkAgOvXr4szSqZPn46aNWsiPj4eDMNgyZIluHPnDtLS0hASEmI31bl27dpITk5GVlYWrFZrsQIattspKD2n2uL/+/5t2rQpgoODceHChfIeFSGkghNmBnIch+joaBw5cgQLFy5EUlISlEolpk6dWqLt8zxTbreqiH79CCHVzooVK/DMM8+IlfKdUavVePjwIYDcA2Ke5/HgwQMxb98ZT0/PfLdntVqhUqnsctyFkxGh08OFCxfQoEEDrFy5En/99Rc8PDzAsizc3Nwctnfz5k3wPA+tVou5c+c6TMv39PREjRo18h0PIRXZiBEjcODAAQC5Abyff/4Zcrm8yOunp6cXOmOJ4zgwDOPw+fLy8oLZbMbEiRNx5coV8Yq+kEY2YsQIrFy5Ugyg/PXXX+jfvz+6desGAHj48CGio6PRokUL3L17F23atEFGRgYeP36Mrl27gmEYPHz4EAqFwm68QuFQnufh6ekJhmGgVqsdxp33s24byHjuueeK/BpVG0xu0Vmz2Yy///4bM2bMoIAvIdWYQqFwCAA7awGtUCgglUphsVjw008/oX///mjdujWA3Fl806ZNeyrjJUVD6SeEkGrFaDQiLCwM77//PmbPnl3k9ViWha+vb6m2BxSmsK9duxabN29Geno6OI6D1WoVZ17Y6tWrF/z9/bFu3TqnXR1kMhnkcjksFku+s0IIqSyE4r5HjhxBfHx8sQs95pdqInQssZ0Nkbf7ybRp05CRkQGDweA0/eTdd9/Fq6++ip9++gmrVq0SP29qtRoSiQQ6nc4u/SQ7OxvZ2dlo3ry5mDZmNBqhUqlgsVgQFhaG1157DUuXLsWFCxfyDZxKpVLxe0EikdjVzCBFw7IsRo8ejcjISBw4cABfffUVpewRQopF6KZ07NixJ57Fe+JKZimPqug6NHYMmFd2NFODEFKtpKamwmKxiFdfPTw8nC6Xt3OA1WrNt77FkxBSTkaNGoU1a9agT58+YBgGLMvCxcUFdevWdVhn3759WLJkiUNAg2VZsCwLo9GIjIwM6PV6p0WwbJ8PIRXZwIEDERAQgHXr1iEjIwMMw6Bp06ZFWtf2ilv37t3tHpPJZHbpHSzLYuDAgQ7dT7p164acnByn6SfffvstXn31VQwePBiLFy+G1WrFxIkTwTAMMjMzodPpIJfL7dJPWJbFmjVrcPXqVezevRteXl5QKpWYOXMmwsPDxUr6Xl5eYkBDIpE4tAs0m81o0aIFgKKl0ri5uTm9Allt8bmBoaVLl+KNN97ArFmznH7XEkKIQJjZFRkZiaFDh6Ju3br48ssvARQ9pdEZKhRauiioQQipFnbs2IHw8HDxJOfPP/8EACiVSgBwyNcXWjbaylvc70kIJ1GRkZFYtGgRbt26haioKOzevRsDBw5Ex44dkZ6ejri4OIcghNA1wZZKpRJrB9gun3emhlardegCQUhFkffEe+LEibhz5w4AICMjAyzLYvXq1UXalvAZ4Xkex44ds0vzENom2y47ceJEu+4nV69exbZt2zBmzBikpKTg5s2byMzMFNNPOnbsiNWrV+PmzZuwWq2Ijo5GVFSU2C3FarVi1KhRuH79uph+kpqaigcPHuCFF14AwzCIi4vDhAkTcOXKFfz5559IT09HSkoKDh06JKbDWCwWDBs2zGG8586dA5B/QNZWWloadUOyxUDsaHD9+nVERESgZs2a5TsmQki5En5/bFMcAwICxN8OtVoNhmGwbds2SCQSWCwWrFq1Cs2aNaPjqgqE0k8IIdWCcFJiMpnQq1evEh3oF6WDQkBAAL788ks0adIE586dw/Tp03Hv3j27ZTp16oTr168jOTkZWq0WZrMZer0e4eHhyM7OLlK7MKEugL+/P1JSUpCRUXA1baVSWaozTggpCxzH4a233oJOp8PmzZvz7RpkS6lUwmq1wmAwiPfl/azapm88CaEbymeffYYePXqAYRg8fvwYKpUKLi4uSExMtPu3RqMRP3NardZuPAzDgGEYmM1m8XP8888/4/vvvxc7oDjDsiz8/PxgMpmQnJxc7LQc8p/AwEBkZGQgMzMTXl5eSEpKsmuVW5aE95K3tzfS09ORmVnwVPSSduAihBSdkF6Sn969e+P9998vUVDjaEzhv2tl5bkmBRferoxopgYhpFpQq9UIDAxEgwYNxPxHYZZGftOzlUolWrVq5XB/YQeWr7zyCurWrYvXX38dAwcORE5ODpYtW2ZX4K9z5844efIk3N3dERYWBp1OB4PBAH9/f1gsFiQmJjpMPXeG53lYrVZIJBIxoJHf81Gr1RTQIJXC66+/Dp7nsWbNGmRlZSE4OLjQzh56vV4MaAjdS/J+VosT0Mib7iJ0Q/n444/RpUsXTJs2DTk5OahRowasVit27NgBPz8/WK1WbNq0Sfz34cOHodVqkZ2djdu3b4snp8IBs8ViwZEjR7B7927873//g06nQ1RUFF544QVIJBKoVCqMGzdOnAIdERGB+Ph4pKeni9vIr/Clu7s7FcXMw/b1uH//Plq2bInatWsjPj7+qdUoEd5LPj4+ePToERiGQceOHQtc50kCGtQNh5AnYxvQEI6pGIbBkSNHcOrUKcyZM4dmaVQw9G1HCKnyhNQT4SYcHAonQLYHi7YHvFKpFJcuXSp2TnpYWBhq164NvV6Pf//9F7///jt8fHwQHR0tLhMXF4cGDRrg6tWruH37Nlq2bAmtVgupVIpr164hOTk53xoCvXr1EsckFD0Upur7+PiAYRh4e3sDyP0R1mq1AOC0iwohFYFQA8bLywtAbveTZcuWiQeW169fx7hx4wo8SbP9HJvNZhiNxgLbwNp+hmwJU5CHDx9ud/8bb7yBK1euoHPnzliwYAG2bdsGhUKB/fv3Q6vVokePHli4cCG0Wi1eeeUVxMTEwMXFBe3bt8cPP/wAqVQKb29vsZuS8F3DsixatGiBFStWwNXVFe3atYNEIsH8+fPh4eEBhmGwYsUKNGjQALVr18bJkycxZMgQMAwjtqVmGMbpAXZqaioYhhGfE8MwhbbGrepsC8TyPI+DBw/i5s2bGDJkSIFtvkvTG2+8gZiYGLHDVkZGBk6ePOm0FlJ+CvtdEurHEEKKR61WIyAgQPxbqFvG8zzu3LlTpNQ/8vRR+gkhpMoTUk8AFCv95EmnqjMMAy8vLyQmJha4nK+vL2bMmIFz585hw4YN0Ol0BY5Lo9FgwoQJsFgsWLhwodMOKADEYqN6vb5EU+0JKW1arRYsyyI7OxtSqTTftJKymmovkUigUCjQpEkTvPjii1izZo1DWpitd999FyNGjIBCocCYMWNw7Ngxh2Vsvydq1aqFnJwcZGZm4qOPPkKXLl2wevVqrFq1yi4thuM4+Pn5iYVFeZ5HaGgoxo8fjxs3bmDJkiX5vjYymeyppUhUJ8LMHvrOJITkp0aNGvjll19KpRbPkZjy61LXqUnRA6iVBQU1CCHVyi+//IIZM2ZAqVTilVdewfr16+0eF04YnJ1UKRSKQlv/SSQSWK1WhytktvmZCoUCvXr1gtlsxo4dOwAAY8aMQYsWLfDmm2/mezKXt4Vjfid+HMfZXY0kpCJo0qQJrl27BpZlIZVKkZ2dDZVKBYPBYPd+LauARs+ePREVFYXZs2fj2rVrMBgMWLt2LYYNG+Y0SBAVFYUxY8bgk08+wdWrV3H//n0MGjQIv//+uxgkdXFxsQs+cByH3r17Y+jQoahXrx6GDBmC27dvQyqVokWLFmKBYplMBovFAqvVCp7nIZPJwLIsOnXqhP379wMoWVV98uRUKhW1xCakGpNKpQgICMDt27cB/Dcriud5eHh4QKFQ4LfffoNaXbK2qBTUKF2UfkIIqVY2btwIAOjbty9+++03h8eFoEHeEwqO45ye+OSdAmyxWNCuXTu7+3r37o327duLfxsMBkycOBFubm5iAGTfvn1o27at2EHBGWf53sOGDXM6BoFtNW9CylNcXByaN28Ok8mE7OxssCwLs9lsl2ZV1IDGk7QpnTJlCn777TecPn0a6enp0Ov1SElJyfczFxkZicWLF2Pfvn24f/8+wsPDMWPGDLvx6fV6yOVyMYVFJpPh5MmTqF27NpYtW4Zbt24ByA1I3rx5Ew0bNgQAGI1GMRVOKpVi2bJl0Ov12Ldvn3jg7ObmRm2Yy0F2djY8PT2pHgUhVZzw/Wr7WW/SpAlcXV3FwLVUKgXP83BzcwPHcRg2bBh0Oh327NlT4v3zPFNut6qIZmoQQqoNo9GIsLAwWK1WdO/eHX/88UehMy8ExZnyTVXqCSGk8lIqlXj99dcxePBgfPTRRzh+/Hh5D4kQUsEolUpcuHDhidf/43L5FW5/PlRZbvsuKxSGJoRUG6mpqbBYLHB3d8ehQ4cwfvx4h2X8/PwA2EfuXV1dxYCGv7+/3fIyheMPg0ajKXAcrq6uxSoIRwgpOwqFotS3WdyZJEInJlIxeHh4YOHChejXrx8FNAiphoTC6m5ubmBZFl9//TW8vLzw7LPPivf36NGjRPvg+fK7VUUU1CCEVBtCrnpKSgpMJhOmT5/usIxQ/Mm2JkZ6ejqA3M4ieVu8GvWOkfa8BTxHjhxpF8RIT0+nnG1CnrL8UrH0er0YiJRIJGjUqFGh2yosaFHcmVrUarliefToEViWFaegU1tcQqo+T09P8d9paWkAco/nNBoN6tSpA57n8fDhQ0gkEqSlpWHgwIHlNFLiDKWfEEKqjdTUVLRr106scO/u7o7MzEwAuSchhZ2oyOVymEymYrfJy69wZ3R0NAYNGgSNRoM5c+Zg69at+XY8KAq5XG7XYYGQyqxTp044f/58vl1+8vL390diYqJdmlhRU8F8fX0xc+ZMtG3bFufOncP06dNx79498TOq1Wpx7tw5TJs2Dffv34eLiwvMZjPCwsLQv39//Pzzz7h06RKWLFmCDh06gOM48DwPi8Uidnsxm81QKpVIS0uDq6srZDKZWKtHKpWCYRhYLBasW7cOy5YtQ1JSEry8vGAwGJCRkQEPDw9YLBakp6fDy8sLJpMJqamp4n7yojS40iEUcRVSFel1JaT6UiqVUKlUSE9PR0xMTIm2dfif8gtmv9C06s0OpJkahJBqw93dHXXq1AEAfPLJJ1iyZAmA3GCAENDo06dPvut/8803+OOPP+zuY4twBU/jXsPhvqioKIwYMQLTp0/HpEmTsHnzZvFqra+vb6FT4uvXr+9wn8FgEK8oMgxDVxdJpdW5c2ccP35cDGjUrl270Pfzo0ePxNkYMpkMQOEzJgIDAzFw4EC0a9cO48ePR//+/ZGTk4Nly5Zh7Nix4mc0IiICOTk56NatG2QyGWbMmIHmzZvj9u3b+OGHH/DVV19h7NixaNWqFRYtWoStW7cCyG0hfe/ePSgUCnAch/3798PLywtZWVnIyMgAkFsA+MiRIwCAPXv24IsvvsDo0aMRHR2N+Ph4pKWlISIiAo8fP0ZGRgbeeOMNxMXFISMjA0FBQbBYLE4DsjzP21XnZxgGfn5+9L1QTEajEXq9Hl5eXhTQIKQKy1uYmWEYqNVqcByHsWPHwsfHB4GBgUhOTi6VDnNWMOV2q4popgYhpErbsWMHpk2bBiD35MFiscBisUAikeB///sfPvzwQ7vl87ZNtaVUKhEWFoZTp06J93GcBBaL8+ULcuzYMaxYsQLLly+Hh4cHjEYjZDIZNBoNkpKSxBkhzsbSu3dv/Pbbb5DL5ZBKpeJsEyD3R5hlWXTs2BF//PEHtFot9Hp9kYucElIRhISE4M6dO+LVcRcXF6hUKiQnJxd7plRBn+mAgABs3LgRS5YswYoVKwAAarUaJ0+ehMFgwMKFC7F8+XJxDEqlEsOGDUNmZqZ4v0wmw+eff44XXnhBXP7kyZM4ceIEunfvDpPJhC1btmDw4MEwGo04deoUOnXqBOC/2VUGgwFarRYDBw6ETqdDcnIy6tSpg2bNmmHTpk3geR4RERE4ePAggNwAbUpKChITExEWFobLly8DcN4hSSCTyfDSSy/h4sWLuHv3brFeQ5Jr2LBh2LRpE0wmU3kPhRDyFHTr1g1Hjx6FwWAAz/NQKpXIyckBx3G4cuVKibZ96J+iFaovC12aln4tqfJGQQ1CSJWWmZkp5kVnZ2fj9OnTmDVrFrRarTglvEOHDjhx4kSB2xG+KoXgw5O0lMzLtqNK69atcfnyZbtaGzVr1oTVakV8fLzDugzDQCKR2B1csywLiUQCjuMoR59UekINm9OnTyMlJaXQYIZUKoVCoUB2djasVmuJrqhLpVKYTCa79JPExESoVCq4uLggKSlJnIY8depU7Nq1CxaLBR9//DEGDx4MmUwm7p9hGDAMA7PZDI7jYDAYYDKZIJPJ8O+//6JmzZrw8PAAAKxdu1ZMPQkODsZHH32E8+fPY+HCheKsFYZhUK9ePXz++efYtGkTtm3bJr42LMuK+6XDu7LFMAxUKlWJUgYJIZWTXC7HpUuXSrSNg5fKL124azPnNaYqM0o/IYRUaWq1GoGBgQgMDERISAgGDBgAs9mM9u3b4/Lly/D29oavr6+4fOvWrZ1uh2EYSKVSzJkzxy6gIZM5/jAoXdyKNDYhoNGqVStcunQJOTk5YFkWNWvWhEKhQHx8PFJSUpyuq9FoxIBGeHg4gEk7YLIAAQAASURBVNzipqGhoU4DGlKptEhjIqQiGDhwILy8vLBr1y6YTCYwDOM05cqWyWRCRkYGLBZLkU/omzZtmu+2bFPE1q9fDz8/P1itVmzatAm+vr5ia+gDBw7g888/x6RJkzBgwABMnjwZu3fvFrdlO0359u3bYmrMH3/8AbPZLKaI7N69G7Nnz8b48eOxfv16BAUFYdSoUfj666+RmZkJlmURGhoKhmFw//59REZGYsuWLeB5Hm3atAEAMZgjPH/b77aWLVsW6TUhRdO+fXsq+ExIFcayLNzd3R0uYqnVaowcObJ8BkXyRUENQki1otFo0KhRI+zZswdz586Fv78/tmzZIj5+48YNu+VZlhVbe5nNZnz77bd27V6NRsdIe052usM2Jk2ahF9//dVhWZlMhlu3bon7adSoEdLT02G1WsFxHMxmM9zc3Bx+VHU6HViWhVQqRVxcnNgS8vz589BqteLyLi4uAEDTpUmFZvuZAnKL6N65cwdAbrcglmWxZs2aIm+vZs2aTrudNGjQAADE2VZ9+vRBSEgIgP8CfxMnTgQAREZGYuHChTh06BB69uyJ7du3Q6vV4pVXXsGePXug0WiQlpaG0aNHo1+/fnj11Vfxyy+/YPfu3WjdujXOnz8vzqgCcgsGe3t7g2VZqNVqdO/eHaNHjxZrXKxYsQIDBgwQU1Y++eQTmEwmKBQKuLi4YOjQodi0aRMkEondLK1hw4YhJycHdevWFfel0WjAsqxd/YwLFy4U+fUjhRMC3YSQyifvbw7g2OXI1dUVer0eHMdBo9EgKChILPzcuXPnpzVUUkSUfkIIqXYyMjLQp08fPHjwQEzZKKjoU82aNREbG1usffj6+mLGjBk4d+4cNmzYAJ1O53D1WKVSicU9rVYrfHx8MG3aNGzbtg179uxx2KZarQbP83bTnalwHalqhOJsQiFNW/Xr18ezzz6LnTt3imllhW2rXbt2uHv3LuLi4jBhwgQMHDgQU6ZMwcmTJwv97MycORN9+vQBy7KYOnUqduzYAavVCpVKBbPZjPDwcPTv3x9LlizBnTt3sGjRIrH7iV6vF9NMMjIyIJFIoFQqkZ6eDg8PD0gkEuj1ejFI4az7iW3Hk+DgYHz66ado1qwZfv75Z8ydO9ehM4xUKgXP8wXW1iCli+M4NGnSBJmZmbh9+3Z5D4cQUory1mRSKBRo2LAhGjdujJkzZ5Zo2wcull/6yYvNKf2EEEIqPY1Gg8OHD+PmzZuYO3eu0/oYthF7oYBg3srY+Yl66//Qrl07vPXWW/jpp58wZMgQLF68OE/aigz9+/eH1WoFwzDQaDRo1qwZxo4diz179sDd3d1hu5mZmWJAo0aN3I4qFNCoPFiuaO+f6o7neYeARosWLfDMM8/g9u3bWLVqFRo0aOD0SptAqVSiYcOGYFkWJ0+eRHJyMt5//32MGDECgwYNwokTJ9CpUydMnz49321ERUXhpZdews6dO9G7d2/s27cPXbp0gUwmw8yZMxEWFoaYmBh88803WLFiBd566y20atUKhw8fxt9//w2pVAqr1YrLly+Ls6327t0LLy8vpKenIzMzEzKZDFarFQ8ePACQ2/1k1qxZeHX4a4iOjhY7nrz99tvw9fXF6NGjsWDBAvzvf/8TAxpeXl7ia2EymWA2m8EwDJ577jkAEL93hLQXUgr+/9euSqWCxWKBQqGggAYhVZBMJoNarYZKpQKQe+x1/fp1qqVTAVFQgxBSrX377bd2gQEhB9125sagQYPs7issuBE5tC/c3NxgtVphtVrx888/o23btujatau4zBtvvIF9+/ZBJpPBYDAgNTVV7Ijg5eUFi8WS70lI7969odPpxAKEwH9TKSUSSYEne6T8WJ+gS051odVqC3z8+++/R/v27cXP6pkzZ+Dm5obatWs7Xd5oNOLff/8VP7MGgwG9e/fG7t27kZCQAAD466+/0L9/f/FzqdFowDAMPv30UwD/pZ+cO3cO9+7dQ5MmTXD+/HmMHTsWV65cwZkzZ5CZmYm0tDScPn0ao0aNwoYNG3Dx4kU888wzWLx4MZRKJUJCQjB//nwolUp07dpVDGLKZDLEx8eDYRjUqlULALBq1SoMHDgQ+/buwr59+zBkyBBotVps374dBoMBCoUCP//8M1QqFRiGQbNmzXDs2DF4eXnZtYEOCAjA66+/DiA3SCSVSsUaPoW1iyZF8P/j00JNjVu3bpXjYAghhXFxcSm0wHvexzmOg9FoBM/z4vFYnTp1YDQa4eXlVeIx8WDK7VYVUfoJIaTaMhgMaNasGTiOKzD9RHhcSPVgWbbATgz+/v549OhRofsPCAjAl19+iZCQEAwePNihnoczEokELi4uyMrKAs/zpdIrnRDinEqlgslkgo+PD3Q6HTIzMx1mR9l2SElNTYVCoYBSqURKSgoUCgVUKhUSExPh4uKCHTt2YMWKFUhJSRHTSRo3bgyO4+w6pDAMA4PBgBkzZmD79u1205+Foqnh4eH4/fffi5yGQ4d7ZSc4OBjPPvssfv31V6Smppb3cAghT4FSqSxRraL9F42lN5hi6ta86s3co8t5hJBqa/78+QDsZ2UIkXrbiH1wcDAAiIWhCgpo1KxZs0gV8QcMGIC6devi9ddfR4cOHXDjxg2wLFvglYTu3bvDbDYjPT1drAOSd1YGTTEnpGRYLrf4o5Bm4uvrKwYp582bJ86qAODQIcXLywscx2H//v3w9vaGxWLBn3/+CT8/P+zfvx9fffUV3n77bWzevBnu7u4YPXo0Hj9+jMePHwPI/S768ccfAQCLFi3Cr7/+iiZNmth9zlu2bIl79+5h69atYkBDKHaalzArg+d5KmxXhv7991/89NNPSE1NBcuycHV1Le8hEUJs5DeDdeLEifnOuvDy8kJYWBg4jsPXX38NAHj55ZcBAG5ubujRo0eJxmTly+9WFVFQgxBSLfE8j02bNgGA0ynswlVNhmHEGRT37t1zWK5f3752f8fGxhbpSt2kSZNQu3Zt6PV6MQgSERGBl156Kd919u3bJ/5br9eDYRh4enraLWM2m8XcT0KqiidJmbBNzyoKlmUxYcIEdGjfFkBuilhMTAwePnwIILfAcGZmJsaNGydu9/XXX8eKFStw/fp1vPzyy1i6dCnkcjmef/55HDt2DFqtFu3atQMAbNq0Cf3790fjxo3RsGFDfPXVV1AoFNi+fbvYYYllWbEo8c8//wwfHx8xfWTYsGGQSCRITU2Fu7u7GFyVSqWQSCR2dYAYhoFKpRK/JzQaDY4ePYo2bdqgbdu2xX4tScFsA+NDhw6l9rmEVDD5zVT77bffkJSUhMDAQLv7WZZFRkYGLl68CJVKJaZI/vvvv5BIJEhLS8PAgQPLfNyk6Cj9hBBSLfA8jx9++AGbNm2CTqdD48aNcf78+WJtQyqVlmpr1CdJPxFajBkMBVfNLixFhhBSuSgUCuj1+vIeBikGd3d36HQ6ShMkpIpo0qQJ0tPTER8fj5iYmBJta++F8ks/6RFW9Wb10kwNQki1sHTpUqxZswbTp0/Hxo0b7aYiCsVB81OrVi24uLigSZMmpTae/v37O6Sf5Ff0UODv7w+dTgeDwVDolUAKaBBSvoo7UwTIf4o0gFIJaBS1gxMpOaVSidTUVApoEFJBFPf7WJj9JpVKIZXmpiV27NgRDx8+LJVjLJ5nyu1WFVFQgxBS5fE8jyVLliA7Oxvjx49Hnz59cOnSJfHxxMTEAtfv1KkTcnJy7NZ5UsKP5DvvvGOXfiJMOxemoTvz6NEjcQrlo0ePqIsBIeVk3Lhxdn87CxZ06NChwG0wDIN69eqJ6zMMI7Z4tl2mNNkWHCVlKycnxy4liBBSvgpKTnD2HW61WhEaGopGjRqJs3TXrFkDhmHos10BUVCDEFLlPXz4EBkZGfj666/xww8/ID4+3i4X0tXV1e7HTiKRIDQ0FJ9++imCgoLETiMFRealUimmTJlSaDE+uVwOjuPQsWNHrF27VrzfarXCbDYjLS2tSM8pPj6epqKTai8iIgLHjh3DxYsXcfDgQZw4cQJjxoyBq6ur04CAUqm0KwbMcRy8vLygVCqdbt/FxcXp/QsXLrT721mw4Pjx4wUeRPM8j9u3b4vrC8varuOs08qxY8cwZcoUu3o6SqUSLMs6zPRo0qQJQkNDnc4AEdo/UwvosmOxWKBUKiGVSuHv70+vNSEVlLPvcJ7ncf/+fVy+fFm8TzgeNJlMhV4QKwzPl9+tKqJvV0JIlSf88LRq1Qrdu3dH586d7epppKamiq1atVotzGYzUlNTMWfOHMydOxf169cXpx7mx2QyYdasWbh27ZrTx4WrANnZ2ZQaQkgpCA4Oxp49e/DRRx9h/fr18PPzw5o1a/DTTz9hyJAheP/99x3WycnJgZ+fHwBAq9XCYrEgKSkJOTk5TgvsZmVllfnzKCqh08q4ceMwe/Zs9OzZEwMGDIBMJsMLL7wgBl5VKhWaNm0KALh27RpiYmLA8zyeeeYZu+0plUpYrVaH76PSnh1S3eXk5MDb2xtxcXH03U9IJZOZmQl3d3e7+6RSKUaMGOFQqJ2ULwpqEEKqnB07diA8PFy8CRH4bt26ITw8HLdu3cKff/5pt45UKkXfvn3Ru3dvALknM3q9Hnv37sX8+fOLlIvOMAzi4uIc7mdZ1q7VKtVnJqTkFi9eDIvFgmPHjqFnz56YN28eNm/ejKCgIPz888+4ePGi04NO4TO6f/9+8T6FQpFvK2bbk/zynHIcGRmJhQsX4vLly+B5Hlu2bMGRI0fw5ptv4vDhw+L3SnZ2NgYMGACGYWCxWMDzPHiex71798R0FyC3mwsAMWDr6elZ6POjmQZPJjY2Nt+2kYSQiikkJATjxo2zC3gLM/yio6Pp+7CCoe4nhJAqJzMzE8nJyeLfRqMRvXr1wsKFC1G/fn0YDAa0a9dOPMjkeR4Mw6Bu3bq4c+eO3bYYhhGvgJZlrjshhBRE+C4ilVNwcDAmTpyIjRs34ujRo1RAlJBKys3NDQsWLChx6+ad58qvxlGvFlWvaDSFmAghVY5arUZgYKB4a9CgAby9vXH37l0EBgYiKCgIrVu3FpcXAhR37tyBXC6325aHhweA3Cu0QjeD4gY0aIoiIaQ0UPeSyuvmzZuYP38+Dh8+jJo1a5b3cAghhZg+fTo0Go3dffXr14dSqURkZGSJW7qS0kVBDUJIlccwDCIjI/HDDz+gWbNmaN68OW7fvo327dsDAGbMmAEgN3CR90poZmYmgJKljNjOGiGEFJ+ztIj8inhWJbYBVG9vb4f7SOVhNpvFgoNxcXHUPYGQCm7JkiVisV8g97u3Ro0aCAgIQPPmzbFy5coSbZ8KhZYuSj8hhFQLPM9jzpw5+PXXX5GRkQGz2QypVCq26RJwHAeLxQKVSoXs7Gyny5SW6OhocByH5cuXIz09HUDulVie58FxHIxGo93yEolEzJEnpKrz9fXFzJkz0bZtWyxatAiLFi0q9L0vk8lgNpvBcZxdR5EnpVAoYLVaER4ejr59+2LRokW4d+9ekdYVvksIIYRUPSEhIdi2bdsTr//b3+WXftK7ZdWb9UczNQgh1QLDMHj//ffx559/4vfffwfgvIWXcBLSokULcBwHjuPEK6SlKSoqCr6+vvjuu++QkZGB7t27g2EYmM1mSCQSdOzY0WEdjUYjnqTlTZMR0FVcUhUMHDgQ7dq1w/jx49GzZ08sWrQIUqm00KvbQiAwODg432XzTifOD8MwUKlUaNasGWJiYjBnzhwsXLjQruhvQYSUNWeKug1SBfH/fU8HBgZSsUFCKhDb340FCxZg8eLFYv21tm3bwsPDA+7u7ggLCytxGhnPM+V2q4rom5QQUu0IXQ8KuoobHx8PnudhsVjELgGlKTIyEt999x0AoG/fvjh//jwiIiIgk8lgMBjQpEkTh8BFamqq+G+TySQeGLMsCxcXF3GWh0ClUkGhUJT62AkpaxMnToS7uzvMZjMePXoEnufx9ttvo1u3boWua7VasWLFCqdBS+C/lLLCvP7660hPT8dff/0lFh/+559/0LVr1yKtX9CsqryzsIqKPs9VAPPfb8+9e/cgk8kosEHIU5ZffSLb2XVvv/023n77bXF54bhMr9fj0qVLGDFixFMZKykaSj8hhFQ7CQkJeO655wpdjroNEFI5UeoHqWwYhkGtWrXQoUMHbNq0id6/hFRQEokEy5YtQ9u2bUu0nR1/ld9nvM8zVa+mD4WGCSHVzs8//2z3t7OrZEqlEjzPQyaTYfXq1U9raISQUlCWJ4T5pX4R8qRYloW/vz8ePXqE9evXw2q1lveQCKlyilucV6FQQK1Wi2kmLMsiKCgInTp1KnFAAwCsfPndqiIKahBCqoUdO3YgPDwcYWFhWLx4sd1jzqa05+TkAMidyv7ll1+WaN+UP09Iwfz9/QGUfU2Y4rREze9zazAYSms4hADI/Z15+PAhrFYrGIahziiElIHCfl/c3NxQv3598e/58+fDZDIhNjYWQO7ntG7dumU6RvLkKP2EEFItCDnxcXFxeO211+weE74G8/vBk0gk+ebnE0IIIU+KYRhIJBK0aNECAQEB2L17NwwGA9zd3ZGVlSUG2G2xLEuzOQgpZ8ePHy9RIfmtZ8ov/aRf66oXOKWZGoSQakGtViMwMNDp1VelUun0ytjkyZPx7LPPUnE+QgghZUIikYDjOJw7dw6bN2/GO++8gxYtWiA5OdkhoOHi4gIAdgENjuOo0CghZcT2s8VxHNzd3cGyLLZu3QpPT89yHBnJi74FCSFVmpB20rRpUzRq1AhDhw51WEav1zu96rVhwwacOnWqyN0SCCGEkKIaPHgwLBYL9Ho9TCYTgNwTp8uXL4szCG0D7s7aEbu4uNCsDUKKydnMXIZhoFarxb+lUqndZ8tisSA4OBgKhQK//PILrl+//lTGSoqG0k8IIVWakHaSnZ2NuLg4JCQkYPr06QgODsa1a9cKXNfNzQ1paWlPZ6CEEEIA5F4d9fX1hV6vR2ZmJjiOg16vL3Q9mUwGFxcXpKWlged5SKVSsf21v78/zGYz4uPj813f3d1dXLe44y2rwIKnpycsFgvS09OpGxchFUxJAhtbzpRfMLJ/66o3r6HqPSNCCLEhpJ2EhISgc+fOeOGFFwD890OU30GiUqnEyJEjIZVKn9pYCSGkunvxxRcRERGB+Ph46HQ6vPPOOwgPDy90PalUCqPRiLS0NPj5+YHjOLGwn1KpRGJiIlJSUgrcRmpqKtzd3cEwTJGK1grLlFVAw8/PD6mpqdDpdBTQIOQpU6lUdn8rFAo888wz4t9btmx52kMiBaCgBiGkWhDSUHr06JHvMnkPYn/44YcybQ1JCCHE3qeffort27eD53lYLBZ8//33mDNnTqF1I4T0DZ7nkZCQAE9PTwQFBeHOnTvIzs6GwWCAyWQqtLBfSkoKeJ7H//3f/xU61pIGGgp7TvHx8bBarWLQxFn6CSGkbNi2cgVyU5UNBgNcXV3BcRxWrlxZou1TS9fSRUENQki10LlzZ2zbtg3r1q0DAHEqs+0VOZ7nxX/n5OTY5SpbrVbwPC/eCCGElC4fHx8YjUa7ApkGgwG3b99GrVq1irQNNzc3WK1WJCUlQafT2T3G8zyUSmWRttOgQYOiD/wJURFqQiqm0aNH4+HDhwByvzeaN2+OI0eOYPPmzWBZFhzH4f79++U8SmKLamoQQqqVhIQEPPfcc/Dz8xNzqzmOg8VigUwmg8lkAsdxkMvlcHNzQ0JCArVzJYQQUiKhoaF49OiRWBujsMNvlUoFq9XqtJaI8JtFCCkb9evXx61btwpc5rnnnsPSpUufeB+b/iy/mhqD2la9eQ1V7xkRQogTQvpJ9+7dAcCuWJxcLgeQW9ma53mYzWZkZWUhPj6+RD3ICSGEkKCgINy7dw9qtVqc/Sf87jjTsmVLGAwGh4CGkONfUA2PotQCIYQUTC6XY/v27QWmfI0cOfLpDYgUimZqEEKqBaELislkwssvv4xatWrh4cOH4HkeLMuC53koFAoYDAaxar67uzseP35c3kMnhBBSwclkMhiNRqePubm5oWXLljh06JDd/XXr1sWdO3cclvfw8EBOTo5dGg7DMJT6SEg5kEgk4oxdoc2rp6cnjh07VqLt0kyN0iUp7wEQQkhZ43kekyZNwokTJxyuklmtVkgkElgsFrurYjVq1BDzKQkhhJCC5BfQAIC0tDSHgAYApwENAE67tNgGNFiWBcuy8Pb2hsFgQGpqKgU8CCkjtinIQkFi24Djk6KPbOmqemEaQgjJ47333sOxY8cwbNgwfP755wAg5kqyLCvmJttWor9//744Y4MQQgipKKxWK+rVq4f4+HgYjUYKaBBSyhiGQVBQENzc3MRjw/bt28PNzQ0AkJGRge+++64cR0jyovQTQkiVxvM8QkND4e/vj8TERPA87xBhF74G8+YiSyQSu3Z6hBBCCCGkehg+fDh+/vln8TjR09MTrVu3xr59+1CzZk2nM7CKav3J8jsFH9K+6tXeoZkahJAq7fbt2zCbzejfvz+2bdsmtuOybetn29bV1scff4z58+c/zeESQgghRcPnzjCUSCQICQnBpk2bEBQUVN6jKjKWZREcHIyff/4Zr7/+epFmRioUCowdOxbPPfccJJLyyaKXyWTivzmOK9a6VMi18nB3d8fOnTsBQKyhcfLkSaSnpwOg/5cVDQU1CCFVmpCzHBQUhMDAQDRo0AChoaEOP0Zyudzh4CQkJASurq5PbayEEEJIcVitVnTo0AE6nQ6RkZG4ceNGeQ+pSJo2bYotW7ZAr9dj+PDhWLlyJXr37p3v8i4uLlAqlWBZFosWLcLp06fzbbdu+/ue30WLkrBYLPD39weQ+/qrVCq7QEdBijNBnrqvPX22acipqalIS0sDz/PQ6XR4+eWXERoaipMnT8LV1RXBwcHlONKnb/78+ahTpw4UCgXatGmDM2fOFLj8pk2bEBwcDIVCgaZNm2L37t1lOj4KahBCqhShdatwE+plnDlzBk2bNkWjRo1w6dIlZGdn261nMBigVqvt7hs+fDg++eSTpzZ2QgghpMj+/7n6kSNH8OjRI7GIYWXw6aef4u+//8bdu3fB8zysViuuXr2Kxo0bO13+nXfegVwuF3+7DQYDZDKZw+wOuVxuFzjw9fVFeHh4qY3b1dUV4eHhePToEYD/ghTNmzd3urxcLncIqjAM4zDLxFngJTMzszSGTIrBNt04NDQUMpkMHMfB3d0dLi4u8PHxgVqtRmpqKurXr1+iffF8+d2Ka8OGDXj33Xcxbdo0nDt3Ds2bN0f37t3z7RB48uRJDB06FKNHj8b58+fRt29f9O3bF5cvXy7Ra1YQqqlBCKlShNatgqysLPTr1w+TJk1CbGwsdu7ciZycHIerJcIBBX0lEkIIqcw0Gg06deqEPXv2iIH9isLHxwc+Pj6IiYkRf28VCgWMRiPVryJF9swzzyAsLAz79+9HfHw8GIaBwWAok33ZtmuWyWRo2rQpAgMDce7cOezbt++Jt7vuRPkdbw7tULzZS23atEGrVq0wb948ALnBn4CAAEyYMAGTJ092WH7w4MHIysoS03cAoG3btggLC8OiRYtKNvh80EwNQkiVolarERgYKN5CQkIgkUiwceNG7NmzB23atHFYh2EYNGrUCD4+Pnb3KxSKpzVsQggh5MnxuSkaEokEBoMBe/bsqVDpC8IMjMePH6Nhw4bihQSpVAq9Xg+e5zF69OjyHGKRFbeORnFR17XCmUwmLFu2DDKZDF988UWpBjSEWTQKhQIMw+Dbb78FkPse/ueff/DLL7/A39+/xDOjynOmhsFggE6ns7vl9xoajUb8/fff6Nq1q3gfy7Lo2rUrTp065XSdU6dO2S0PAN27d893+dJAQQ1CSJXGMAy6d++O2NhYZGRk4PDhww6zMXiex82bNx2m0en1+qc5VEIIIeTJMLkzE81mM4xGIxiGQUZGRnmPSnTlyhXx36dOnRJrWwknhjzP49ixY3B3d893G7b1DgRFqZdRFjU1ylJFm11TEV28eFE8djt06BA8PT1LbdtCrRYh2Pbee++BYRj06tULd+/exaZNm7B8+fICa8BUdLNmzYKrq6vdbdasWU6XTUpKgsViga+vr939vr6+iI+Pd7pOfHx8sZYvDeVTNpgQQp6iSZMmYdeuXeLfLMsiMjISK1euFO/Lr+AYIYQQUhENGzYMo0ePhre3N65du4bPPvsM//zzD4Dc37mcnBywLAur1QqGYaBSqZCTkwOr1QqpVAoXFxdkZGQ89ZPo+Ph4pyc3hRU5dZaeUpSU0cqWVkppOLnyvr/Pnj2LHj16OLzf9+zZAwB47bXXMHToUNSoUQOpqamIj4+Hl5cXfHx8cOfOHXzzzTcIDw9Hnz594OXlBYPB4FAM/vbt23jppZfs7hMucH311Vf46quvwDAMpk6diiFDhpTo+VnL8W05ZcoUvPvuu3b3yeXychpN6aCZGoSQKi8pKQkAsHXrVgBAly5d8OGHH4qPsyxb6b/MCSGEVB8vvfQSpkyZgvnz56Nfv364du0ali1bBhcXF4AHPDw8xAKcMpkMCoUCWVlZsFqtkMvlMJlMSEtLs7uaWuYtKvn/f3N2PyE28r6/s7KyMHr0aKxcudLu/e7h7gEA6NWrF/7v//4P8+bNQ8+ePXHhwkU0a9YM165dQ8+ePbF+/XosXLgQw4cPx8yZM9GzZ0/8+eefsFqtWLFiBTp06IABAwZg2LBhAP77LHh4eECtVuP48eN2t2HDhjmdOVRZyOVyaLVau1t+x8FeXl7gOA4JCQl29yckJMDPz8/pOn5+fsVavjRU3v8bhBCSj7wdUPLOwvj999/tqqFbrVaHXEKtVmv3t3BwyPN8pbvqQwghpGoZNWoUNm7ciC1btuDWrVuYNm0a9Ho9VCoVwOTOhhB+q9zc3OzSKQ0GA4KCgsCyLGJjY8X78/62PbWTtjKOpZDKJ+/728XFBTk5OVAoFHbv9wEDB4BlWYSHh+PcuXPYuXMnHj16hJYtW+DMmTPw8PDAw4cPsW7dOqSkpCA1NRVHjhxBZmYmOI5DZmYmmjZtioyMDFy+fBmpqakAgJo1a8Lb2xspKSkwm83w9vYWb15eXuX86jxdMpkMLVu2xKFDh8T7rFYrDh06hHbt2jldp127dnbLA8CBAwfyXb40UPcTQkiVk7cDitFoRK9evbBp0yZERESgZcuWGDx4MN5//30wDENBCkIIIZVCQSkneUmlUnh7e8NkMiE9PR1eXl7Q6XQOrUJtfwdZloVUKi2zThKEFIft+z0xMREymQyurq5O3/urV692WgzeYrHg8ePH2LdvH7755hvUqlUL77//Pjp06CAWZU1PT8fdu3fx/fff488//0Tz5s2xePFitG3bFgBQo0YNZGVlIT09HW3btsWqVatK/NzWHC3xJp7YiOeKt/yGDRvw2muvYfHixWjdujXmzp2LjRs34tq1a/D19UVkZCT8/f3FuhwnT55Ep06dMHv2bLz88stYv349vvjiC5w7dw6hoaFl8IxopgYhpArK2wGlQYMG8Pb2xl9//YXatWsjPT1djMYLB3INGjRw2E7e7idlXfGcEEIIyU+BKSdOMAyD2NhYpKSkoFWrVoiNjUVmZiY0Go3dcratVQFQQIOUO4Zh0Lt3b/H9/t1336FGjRpQq9UYOXKk+N4X0kUAYMKECYiMjESHDh1w5MgRGI1GWCwWHD16FD/99BNefvllrF69Grt27YKrqyuuXr2K7du3Y+nSpZg8eTJkMhlWrFgBT09PjBkzRiwUGhYWhmnTpoFlWbi6uuLs2bNlWvCyIho8eDDmzJmDqVOnIiwsDBcuXMDevXvF9LX79+8jLi5OXL59+/b45ZdfsGTJEjRv3hybN2/Gtm3byiygAdBMDUJINREREYGLFy+Kf/v4+ODx48dgWRYMw+Dtt9/G999/b7eOp6en3YwPQgghpLxs3LgR//zzDz777DMAuSd+R44cwYABA5CYmJjvehzHwWKxiC0qhUN/Zx2+tFotdDpd2TwBQoqAYRj07dsXw4YNw6VLl/DZZ59h8+bNuHTpErp27Yo1a9bgp59+wunTp5GdnY3nn39eXNfd3R16vR5z5sxBgwYNULt2bfA8j/v37yMhIQGNGjVCWloa+vbtCx8fH2zatEncnqurK44ePYo1a9ZALpdj7ty5SE5OxoYNGzB79mwMGDAAZ8+exf79+zFy5EhMmjSpRM9z9ZGSvU4lEdmp/PZdViioQQipFuLj4/HNN9/gwIEDyMnJKe/hEEIIIeWK4zhIJBKamUEqLKlUKrb9fVJyuRxqtRq+vr64f/++mH7FcRxYlhW3X7t2bRw4cAAbN27E1KlT4eHhgSlTpuDOnTu4fv065s+fj8mTJ+PEiRNo1aoVvv322xKNi4IapYvSTwgh1YKfnx++/vprzJ49G0OHDsUrr7xi93jequ8uLi44fvx48XZS1pXjCSGEkBKw7XZCAQ1S0QkBhxo1ahR5HRa5M22FtKyAgAB89913GDNmDDw8PCCTyQDk1trw9vYGANSvX1+sBxEREYFr167h5MmTqFGjBjZv3izOjuJ5HpmZmeJ6pOKgoAYhpFoQOqJ88MEHWLduHbZv317g8llZWejYsWPxdkIT3wghhFQSZrPZrsNJZW5RSaomlmUhk8lgtVod6po5q4UGAKE1vPDRRx9Br9eDZVncvHkTEokECoUCcXFxaN26NYDcWSDPPvssACAoKAj16tWD2WzG7du3AeQWnR83bhyGDh2KrKwsxMTE4K+//oJer8egQYNK/NysfPndqiJKPyGEVAu2HVHWrFmDNWvWlPOICCGEkPLHcZzYspw8PUJNr5CQEAwbNgzr1q3Lt5ONLYlEApVKhZycHHAc57Q2SnVQGt3rhG3UqVMHd+/ehZubG1xcXNCvXz/Mmzcv33VYlsXevXtRu3btJ973yj+eeNUSG/l8+e27rFBIlhBSLQgdUWJiYrBu3boirdO4ceMyHhUhhBBSDmzOBS0Wi0MKJil74eHhYBgGd+7cwcyZM9GrV68Clxf+H5nNZuh0Onh5eVXbgAaAIgc0VCoV3NzcADjORhL+vnv3LuRyOcaNG4fff/8dQG5KyurVq8Xb2rVr0aVLF7Rp0wbbtm2Dn59fCcdffreqSFLeAyCEkLK2Y8cOTJs2DQCQnZ1d5PWuXLlSVkMihBBCyo+TGEZpFGUkRdO9e3e0atUKf//9N8xmMwDgp59+QuPGjZ0ee6hUKiiVSruObLYtNIH/TtCtVmsZjvzpk0gk4mv0JLKzs+Hn5wdPT0+kp6cjOTlZDIi0atUKf/75J1xdXZGRkYHExETcunULQO7noU2bNnbb+vXXXwHkpquQioXSTwghVZ6QemIymdCrVy80btwYMTExha7Hsqx4cKBWq8WK2YQQQgghpOIQWheXRGRkJCQSCU6ePIlr167ZPdaqVSvUqlULOp0OCxYsKNF+AGDF4RJv4omNeqH89l1WaKYGIaTKU6vVUKvVSEhIAM/zqFGjBuLi4pCSklLgem3atMGpU6cAFG+GByGEEFJp8ECDhg1w69YteHh42M0GIKSyeJKAhu3FKwBYv349jhw5gqtXryI4OBiTJ09GcnIyVqxYgQcPHmDRokVQq9WlMl6aVlC6qKYGIaTaOXz4MNLS0gpdTghoAFVvOichhBACAGCAmzdvgud5JCcng+M46oRSxuj1rRiENBJXV1cAgNFoxPXr1+Hn5wd/f3+0a9cOvXr1wooVK5CZmYk9e/aU53BJAegTRQipNtzd3cEwDMLDw/HNN98Ua10qokYIIaQ6sFgsFMgvY9Xp9R02bBi6detWpGVXr16N69evY+fOnXjmmWcgkRScVDBjxgycO3cO3t7eTzQ2IcUkPT1dvG/y5Mm4evUqDh06hEaNGqFRo0Zo1aoVjEYj7t+//0T7cYZaupYuCmoQQqoNmUyG2rVrIz09HTKZzO4xZ1dNOnbsKP6byg8RQgipbpo3bw6NRlPewyCV1EsvvYQpU6bg3LlzAHLfTwVdJJowYQI6dOiAV199FefPny+wQKhEIkFgYCCio6ORlJTk8HhRLkYJMzQEffv2xYoVK1C7dm3UqFEDq1atwhdffIGAgACYzWZ4enoWuk1SPiioQQipFnbs2IHw8HA8ePAA//77L6Kjox2WyXtF4NixY5BKpQDsgxoU4CCEEFIddO3atdRqCJCiqyqzQ0eNGoWNGzeKQYeLFy/Czc0NjRs3drp8eno6kpKSkJ6eDovFAo1GA7lc7rCcXC6Hm5sb3nnnHZw4ccLphamiHKup1Wq7QMXhw4fh6uqKx48fQyqVolatWqhbty68vb1htVpRo0aNoj71QlFL19JF3U8IIdWC0AHlwIED2Lp1KxISEpCRkVHoeg0aNMDNmzefwggJIYSQCoQHwOTOZBTaavI8T4H9J8QwDOrWrYs33ngD69atwz///FPoOi+88AKmTZuGffv24auvvipxdw9SuI4dOyIuLs7u2E/orNKjRw98//33pbKfpQdLZTNPJKpr+e27rNBMDUJItaBWqxEYGIhatWqhVatWmD17tt3jnTp1srsyIpfL0aNHD9y7d+9pD5UQQggpf0zuibjVaoXVagXP89BqteU9qkrp7bffRs2aNXH79m3MmDEDX3/9NTw8PApd7/Dhwxg/frzT2Qokl6yYrw3HcXZ/t2vXzu7vOnXq4IMPPsDcuXMxZ84cdO/eXZyhQf8fKi5q6UoIqRZ27NiBadOmwWAwwGKxYNOmTXaPu7m52V19MhgM2L9/f7Uq5kUIIYTYEn4XzWYzOI6j38Qn0L17d7i7u+PRo0cAco8vtmzZggEDBmDp0qUOy2s0GphMJuj1egBATEwMUlJS0LZtW5w4ceKpjr00MAxTprN7LAXU3XBGIpGIM144jrOrx8EwDPr06YM9e/age/fu8PLygpeXl3ghzGAwlNq46aNUuij9hBBSLdimn2zbtg3x8fGFpp+U9Q8xIYQQUllwHIfg4GDExMRgypQpWLRoEVJTU8t7WISUmtq1a+O3337Diy++iMePH9s9xjAM2rZti5UrV5bKvhbvL5XNPJE3i9aMplKh9BNCSLUgpJ88fvwYt27dQufOncXHOI6Di4uL3fIqlQpeXl5291WVwl2EEEJIcWm1WsTGxkIul+PkyZMU0CCVHsMwdsd2v/zyCxQKBTp06ICOHTvi+PHjOH78OPbv3w+e50u1aC4VCi1dlH5CCKkWpk+fjnXr1ol/79mzR/y3xWJBVlaW3fJ16tSB1WpFYmKieJ9Wq7XrZU4IIYRUF7ZBjBMnTojFEwkpT8WdVatSqZCdnQ0gtwiu8B6Wy+ViKso///wDrVYLg8GAx48f48cffwTLsvl2bSHlj4IahJBqYezYscjIyMDOnTvBMEyhB2J5C0kBoIAGIYQQgtwaG4KQkBDcuHGDAhykXBQ3TVgIaACwe88aDAb07dvXbtkuXbqI/+Y4jo4DKzBKPyGEVAs7duzAH3/8ASA3Gi9E2/NLKfnnn3/QqFEj8W+GYfDMM8+U+TgJIYSQCo3P/U0MDw8HANy8eRMSCV0nJeVDpSm8i0xRsSyLIUOGoGfPnuA4DlqtFh4eHlCpVAAAmUxWavui9JPSRUENQkiVx/8/9u47rqnr/QP452YDYW9UUIuCKCqKe29xa1t33Vqrba3r29paR2sdba12WG3do26rUqvW1arUvRei4EBUpgiEneT8/uCXW0IGAQPB8Lxfr7wkN/fccxIDyX3uOc/DGDZt2oThw4cDAHJycvj68MYi/Hv37tU6hkKhKNuBEkIIIRUdV/CZePXqVQAFszY0JS8JKW9ZGS9e+RiaC1xqtRrBwcGoUqUKAgICkJ6ejk6dOkEqlUKlUiE2NhaRkZF4/PjxK/dJzIuqnxBCrN6TJ0/QuXNn/PTTT3j//fcRFBSEhQsXYubMmbh//76lh0cIIYS8try9vWFra4uHDx9SyVfy2tMEOIydIjdt2hSbN29+pX5WHCp+n7IyOcxyfZcVmqlBCLF6mmSfAkHBn7zs7GzUqVMHYrFY7/4cx+mdYlinTp2yGyQhhBDyGkpISEBMTAy8vLzg6uoKmUxm6SERUmq2trZaAQ1PT0+MGzcOADBixAhERUW9ckCDmB8tgCOEWJ3w8HDMnTsXSqUSeXl5kEqlAP5LbPbw4UMEBwcjLy9Pb3vGmN7HIiMjy27QhBBCyGtIMzvj2bNnaNy4MZycnHD8+HELj4qQ0tFUwxMIBFCr1UhLS8OePXtgb2+Pa9euma0fyy6W0J9P7nVGQQ1CiNXp2LEjGjRogKysLKSmpiI/Px8TJkzAn3/+ye9jKKBBCCGEkNK5fPmywVmQhLwONMEMTbAuJycHOTk5GDZsGI4ePWrh0RFDKKhBCLE6crkccrmcv88Yg52dHf755x+IxWIolUrUqFEDDx48MHoce3t7ZGRklPVwCSGEkNcfA8AB+fn5lh4JIUYJhUKDJYgZY/D19UVmZiZSUlLQtm1bnDp1Cnv37oW/v385j5SYinJqEEIqFYFAAMaYTkCjcBBEo3BAQzNNkDFm4SmDhBBCSAVUZEa7oZLphFiaoYCGSCQCYwxVq1ZFSkoKBAIBYmJiUK1aNWRlZSEgIMBsY6CSruZFQQ1CiNVbsWIFMjMzkZeXh9zcXL37FFeuVfPljOM4+qJGCCGEFOHh4YHu3bvDzc0NQqGQ/7wUi8V8ou6iZDIZ6tWrp3fJiqE21m7o0KE4fvw49u3bh8aNGxf7Onh7e2PXrl1o2rSpSceXSCTo2rWrOYZqdTS5186cOQOgIF/M8+fPIRAIUKVKFTg7O1tyeMSIyvnXghBSaRw8eBArV64EAD5hKMdxfHZ2gUDAf2GgYAUhhBBScq1bt4a7uzsOHz6MvLw8MMbg6ekJxhhEIhHUajVEov9WvQuFQsyZMweMMdy6dQtubm54//33tY6przysvb19mT8XSwoLC8OsWbOwZMkSDBgwADKZDBs3bjSapyQxMREDBw7EvXv3UL16dfTv39/gvkKhEHl5eThy5EhZDP+1JBQKte5zHIdvv/0WVatWRceOHREZGYm9e/dCoVDA3d3dbP2q1Za7WSMKahBCrE54eDhCQkIQEhKC6dOno3379gCAQYMGAdCublI4GRQtKyGEEEJK7oMPPsCjR48AAOnp6VCr1bC3twfHccjOzoaNjQ2qVq3K7+/s7Iz9+/fzsyefP3+Of//9F4GBgQb7EIvFeOutt8r0eVja6NGjsXPnThw5cgRqtRpnzpyBn5+f0e8nKpUKjDG8fPkS7dq1w71797Qeb9Sokda+5D8uLi5ar4lm+Ul4eDj69euH06dP4+LFi3j//fchEAjQq1cvC46WGMMx+hZPCLEyCoUCKSkpyM/PR+/evfHee+9hxYoV6NSpE19mjuM4MMYgFArBGNN7RYgQQgh53djb26Ndu3Y4dOhQhTuJ9fDwgIeHB27fvs2fqMtkMuTl5dHnMDFZaGgoGjZsiCNHjiA+Ph4cxxlcXvyqPD090bhxY0ydOhW+vr5mO+73f1juFHxKb+ubmUwzNQghVkcul8PPzw/29vZQq9X8dMHTp0/rTF3VlO4ihBBCXmd2dnYQiUTIzc3FoUOHzDpV/lUFBwcDKFgqUatWLX67WCxGTk4OGGMYO3aspYZXoWiWyhLD8vPzsXbtWkgkEixcuLDEAY3ilht37tyZ32fnzp1YtmyZWQMaACUKNTcKahBCrI5m+YkmEVbhK1WaJFCaK0RUeo4QQog1yMzMhFKpRF5eHjiOq1Alye/cucP/fPbsWVSpUgXAf5/BjDGcPn2aEjGi8iZILYnr16+DMYbo6GgcP34crq6uJWpva2vL/ywSiXRylty+fRshISEAgAMHDrz6gEmZo+UnhBCrU3T5ybvvvouVK1carUtOCCGEkOL17NkTL168wKVLl6BUKovNR6VZ7qmPQCCASCQCx3FQKpVwcXFBXl4e0tPTK22eq0aNGsHNza3EyTxFIhF/4aYwiUQCkUiEnJwcmplaChKJBBzHwc/PDwsXLuRnHb2q7/Zb7v09rS8tPyGEkApPs/zE398f9erVw7Fjx3T20VwJkcvl5T08QgghpOyU4blS8+bNERERgeTkZNjb26N///6YNWuW0aokffr0QfXq1bVKowOAq6sratSogby8PKhUKqhUKiQnJyMtLQ3vvvsuatasWXZPpIKSSqXo3Lkz7t69C4lEAoFAgLCwMNjY2OjdX1O5QyAQ8AGNosskVCoVsrKyoFar+de+8EyF15qe93r12iFa94sLQri4uAAw/Jp88MEH+PPPP/Hxxx/D0dGxdOMkZY6CGoQQq1O4+klkZCTu37+vs4/maoVCoSjv4RFCCCFlpwwvwgoEAvj6+uL+/ft48eIF9u7di7CwML66mD5PnjzBo0eP+JkXmn9TUlL4/BFFl4auW7cODx48KLsnUkE5ODjg2rVriI2N5ZOnzpo1C8OHD9e7v2b2aeEZGLNmzdK7D1Dw+rq6uiIrK6sMRm8Bet7rj+5d1br//Plzo4fw8PBAcHCw1mtSODDk6emJatWqoXXr1mbNq0E5NcyLlp8QQqyOZvkJUPBhNnLkSAuPiBBCCCkfVP2EWDtzVD+RyWTIyckpdj+xWAx/f38MHToUAwcOLO2QdSzdZ7lT8On9aPkJIYRUeJrlJ35+fpBIJPz2womgNMtOnJycABRcfdJM4ySEEEJeNxW5+klQUBAAqn5iCpFIZOkhVHjGqp84OHto7Vv4/VaYJqBRXCWUxo0bY8iQIViwYAH27t37iiMnZYWCGoQQqxIeHo7g4GAEBAQgICAAQ4YM4R8rPDFNs+wkMzMTQMHUzYp2RYsQQggxFVU/sQ76kn0Sbcaqn6SnJmrtq28Zk5+fH/+znZ0d+vfvr7OPJtjh7++PQYMGYeDAgdi+fbu5ngKYmlnsZo1o+QkhxKooFAo8efIEqampyM7OxosXLzB79mwAQLNmzXD+/Hmt/QUCAU15JYQQQioYsVhMZddJhfHGG28gIyMDp0+fNsvxvv3dct89ZwywvnkN1veMCCGVmlwuR506ddCyZUt06tQJb731Fr/EJDAwEEDBB5NmWYomrktLTwghhFiFinq5sgTj8vLyooAGKRXfNxpo3TdWmQf4r/qJoWp4CxcuREREBJo0acLPMDIHNbPczRpRUIMQYnUKVz9p1KgRunbtCgD8tMGYmBjk5eVptSlu6QljTOtGCCGEVEgVNQdgCcb11ltvld04iFWLjbmudb+4ZVg+Pj4AtKvhFc5Hk5aWhnPnzmH//v0YOnSoGUdKzImWnxBCrE7h6icAkJubi969e0MikfDBjMLLTjiOo0AFIYQQUkEIBAIMGTIEEydOxNGjR7Fo0SKauUHKjVgs1sq1Zm9vj/fffx+jRo0yWx9f77Hc8pP/vWl98xooqEEIsXqMMbRp0wZjxozB9u3bIZFIMGvWLIwZMwZAwYeXvb09Xrx4odVOKpVqZdSm/BuEEEJIGWOAzKag3OYbb7yBx48fU/JMUqZsbGyQnZ3N3x8zZgz8/f3x6aefokmTJnjx4gVsbW2xY8cOsy1XXrLbct8nP37L+oIa1veMCCGkCI7j0KRJEyxZsgSxsbG4f/8+H9AACrKvd+vWTaedJheHBgU0CCGEkDLG/VduMyYmBj4+PlrVLQh5VYW/3wmFQvTs2ZO/LxaLUaNGDSxduhQA8PHHH+OXX37BzZs3ceHChfIeKjERzdQghFQKGRkZWLZsGfbu3YusrCxLD4cQQggxaOjQoRg7diyOHz+OH374QWu9vz52dnZQKpVaswutiUAggFAoRGhoKKKjo5GUlGSxsdjZ2UEqlUKhUMDBwQEvX740OpNEIBDA3t4eCoXCYP4uTflQOi2rGDiOg4uLC0aPHo0bN27g9u3bePr0Kbp3747vv//eLH0s2mk8l1tZmjXQ+pLj00wNQkilYG9vjzlz5uDtt9+GQCDAhAkTtB53c3PTui+VSrFgwQKqikIIIaRchYWFYdasWZg1axYWLlyIzMxM/qRXn1q1aiEzM9NqAxocx/EzJZ8/f27RgIa/vz+ys7ORlpYGW1tbpKSkQCQSQSwW693f19cXarUaaWlpRhOSUxLyikEgEKBHjx64e/cuzpw5g2bNmqFq1aoYO3YsAMMVUojlUVCDEFIpaCqibNy4EWq1Gr/++qvW48nJyVr3c3NzMWfOnGKrohBCCCHmNHr0aOzcuZOf6s4Yg5OTE2Qymd794+PjdbYJBNpf8Q2ddL8ONCf7+fn5SEhIsOhYUlNT0ahRI6hUKrx8+RKMMcjlcoPLUxMTE1G/fn2tbcX9X2iqcRDzKfr7YIharUbr1q2xZMkSXLt2DS4uLmjbti327NkDoVCImjVrmm1MjFnuZo1Elh4AIYSUh44dOyIoKAi9e/fG5MmTIRaL8d133xmtfEI5NAghhJS3gQMH6mxLTU01uL++kpVFP7+spXJI4WSOlpCSkqJVXQ3QvShSWE5ODm7cuKG1rbj/i2fPnpV+gEQvU7/P2dvbo1u3bjh48CD27duHjIwMeHh4oFWrVkhJSaHZuxUYBTUIIZWCXC6Hvb091Go1WrVqhTVr1vCP1alTB5GRkTptqNoJIYQQUkEwwNHJEWlpaQAKEjzSbEpiTu+88w7kcjnWrl2r81jHjh0tMCJiKlp+QgipFObNm4e2bdsCAAYPHoxjx44BKJjWGhUVpbcNBTQIIYRYgo2NjaWHUPFw4AMaAKBSqUxeVmBJr8MYKysHBwf+Z4FAgJ07d/KVd8oaLT8xL/otI4RYnd9++w0dO3ZEcHAw3n77bdy4cQPvvfceVq9eDQCoXbs2v6+Pjw8FLwghhFQoll5m8ToIDQ3F22+/DS8vL4hEFXfyOX3HqLjS09P5n9VqNZKTk9GgQQMEBATwt0OHDllwhMRUFNQghFiVgwcPYtGiRZg8eTL27t2LwMBAjB07FiKRCG3btoWfn59WSVfN2tXXOYkaIYQQUqkwQKFQYPfu3ZDJZEZLqhJSlKaaUOGLXEDBbI1JkyYhIiICH3zwAWxtbflZvuamZsxiN2tUccOahBBSCuvXr8fAgQPx5ptvAgDmz5+Pw4cPo127dhCLxcjLy9O7Bjc0NBRnz54t7+ESQgghpKQ44O7duwCAR48eQSQSQSgUWm1ZW2I+QqEQrq6uSExMRGxsrNZjAoEAzZs3h7u7O44dO4Zu3brx++Tl5SEhIQGRkZGwtbWFn5+fJYZPDKCZGoQQq5GXl4fbt2+jZcuW/DaBQIA2bdogNDQU+/btwyeffII6derotKWABiGEEPJ6UiqVWgENyklCDFGpVEhMTAQAnfwZSqUSM2fOxK1btxAZGYkOHTqgX79+6NevH5KSkrBu3Tr069cPs2fPtsTQiRE0U4MQYjVSU1OhUqng6uqqtd3LywtPnjyBn58f3N3dUb9+fTx8+FBrzbKNjY3OGmZXV1e8ePHCYMlXQgghhFgYA8D9d9fNzc1omVVCCiv8/e/bb79Fy5Yt8eOPP+KNN95At27dDCaTf1WMUq2YFc3UIIRUKpcuXcKuXbt0Ahj6krIpFAo+oFH4XwpyEEIIIRUEp3130KBBlhkHeS0VnuHj5eWF7OxsHDhwAG+99ZYFR0VKimZqEEKshrOzM4RCIVJSUrS2p6SkwM3NDQBQr149tG3bFn///Xexxyv8QadJKqX5lxBCCCEVz4oVKyCVSiGXy5GRkQGVSqU3lxYhgHZ1muHDh6Nz587IyclBv379yrRfukBmXjRTgxBiNSQSCerWrauVH0OtVuPs2bMICQkBAMhkMgiFQgDQWqairxxcu3btynjEhBBCCDGb/z9PzM3NxYsXLxAcHEwBDWKUs7Oz1v24uDh07NgRLi4uFhoRKQ2aqUEIsSqjR4/Gxx9/jHr16qF+/frYuHEj0tPT8fPPP2PlypVay0wKz+jQ96Xn9u3b5TJmQgghhJhBocmUjDFcvnwZcrkcCoXCcmMi5UoqlSE3N6f4HVFwQSs9PR1isRj5+fkACqrqTJw4sSyHCABQU04Ns+IYzX0hhFiZLVu2YO3atUhKSkKdOnUwffp0XLx4Ebt27UJCQgKEQiFduSGEEEKsnEAggFQqhYuLCxITE/kTV0KMkclkOpVRWrdujbVr15qtj7mbLPdenD9CbLG+ywrN1CCEWJ3hw4dj+PDh/P2DBw/il19+wfz585GRkYFffvkFL1680GojkUiQl5entU0kEkGpVJbLmAkhhBBiRgxo3LgxZDIZTp8+benRkApOIBBArVajVq1akMlkuHnzJpYuXYpmzZoBKPieSCouCmoQQqze+vXr0aRJEyxYsAC5ubl6Z2kUDWgABR9whBBCCHkNccDFixe1NkmlUq0k4KTycnd3R1JSEv+e0Cxe8PDwgIeHBx49eoTo6Gj06tWrTPqnxRLmRd/YCSFWLS8vD7dv30b//v3Rv39/2NnZAQD/b3FtCSGEEGIdHB0dsXr1aoSFhVl6KMTCkpKSAPxX6Y4xBrFYjH79+uHSpUvIyMjAypUrERAQgICAAHTt2tWSwyXFoKAGIcSqpaamQqVS4cqVKwgPD8f48eMBAE5OTlr7SaVSnbZNmzYtjyESQgghpCyxgjwJCoUCs2fPxqFDhyw9IlIBKZVKzJo1C3FxcXB0dMTGjRuxcOFC+Pn5wdbW1qz52NTMcjdrREENQohVO3LkCABg27ZtyMrKwvLlywEAT58+1dpP33TUCxculPn4CCGEEFLGOCAnJwdZWVlISEiAXC7XKutOiMa7776Lli1bIiMjAxzH4c0338TatWsRGRlJ3wsrMKp+QgixaqmpqWjRogUYY+jSpQtOnz6tk9GaEEIIIZWHSCSCSqWivAakRFq0aIENGzaY5VizN1huifOCUdaX9JRmahBCrJqzszNq1qwJADh79ix8fHwM7uvm5oaGDRuW08gIIYQQYglKpRIBAQGWHgapoEaOHAmBQACxWIwBAwbAz88PQEHi2S1btpilD6ZmFrtZIwpqEEKsTnh4OEJCQvhbt27dAABNmjTBw4cPDbazt7dHdHR0eQ2TEEIIIRZy9+5dAEC/fv305tUilVd4eDjUajU+/PBD9OnTBzY2NuA4DiEhIfyyZlKx0PITQojVUSgUSElJ4e/HxsZi3LhxsLe3R0ZGBmQyGdq0aYOjR49acJSEEEIIIeXLzs4OeXl5cHNzQ3Z2NtLS0gwuw3n//fexbds2re9UlQ3HcXB0dIRMJoNcLscbb7yBH3744ZWP++lay5UWXjjW+oJ4NFODEGJ15HI5/Pz8+JutrS0AoE2bNgAKqposXrwYQMGHFQAIBAJIJNa3xpAQQgghhnl5eWndFwqFFhpJ2eM4Dh9//DECAgLw/PlzKBQKjB071uD+P/30E1JSUiASiYo9tqenJwSC1//U0sXFhX8P2NjYAAC6dOmC+Ph4xMTEYODAgZYcHjGAZmoQQqxOeHg45s6dC6VSiby8PEilUuTm5vL/CgQCcBxXotJcRf9UaoIhhBBCCLEOQqEQ7dq1w4kTJyw9lDLRrVs3NG3aFF9++SW/zd3dHe7u7rhz506x7TmOMzirg+M4VKtWDcnJycjKyjLbmMuajY0NsrOztbZxHAdfX188fvwYwcHBiImJQVZWFjw8PHD69Gmz9PvJasslrV88XmaxvssKBTUIIVZHs/wkKysLqampyM/Px4QJE9ClSxd+yUnDhg2hUCgohwYhhBBCeBzHwd7eHjk5ORAKhTonvOZSkmUghWlmQ6jVaqNBBlI6MpkMeXl5UKvVOtsdHBwoqFFBvf5zhAghpAjN8pM6deqgZcuWaNu2Ldzd3RESEgKhUAg3NzesXbsWMTExfBt7e3ud48hk2n/0XVxcynzshBBCCLEcxhjS09Px4YcflllAQ98ykFWrVhlNWMpxHAQCAdRqNdRqNZydnXUCGkKhEO7u7vx9sVhcJuO3FkVfH5FIhJycHHh6evL/FyKRCM7Ozujbty+qVKliiWG+Nl68eIFhw4bBwcEBTk5OGDt2LBQKhdH9P/jgAwQEBMDGxga+vr748MMPkZaWVuK+KahBCLF6HMdhxIgRWLVqFfz8/JCcnIw2bdpofRlo0KCBTrui62xL80eWEEIIIa8PTX6tDRs2lNnFjK5duyI/Px+3bt0CUFBi9vLly3jnnXf07m9rawsXFxet2QOpqala+wiFQjg4OCApKYnflp+fXwajf71oKpcYekwul/P3lUolbGxs4O3tjdzcXH5b69atsX//fvTq1QsvXrwwy7gYYxa7lZVhw4bh9u3bOHr0KA4cOIBTp05hwoQJBvd/9uwZnj17hm+//Ra3bt3Chg0bcPjwYaN5Xgyh5SeEEKvHGMP48eMRERGh94+5pioKIYQQQgghhlSpUsUsOVc+/rVsZgGZYskEG7MfMzIyEkFBQbh48SJCQ0MBAIcPH0aPHj0QFxcHHx8fk46za9cuDB8+HJmZmSYlqNWgmRqEEKs3Y8YMnD59GsOGDcPYsWNha2urFbXPzs7G6NGjddpRMlBCCCGkctJUwNB8F3BycrLYWEpyckdKpujyY6lUitq1a8PDwwM//vgjli5dinr16sHT0xOXL182WxJZprbcLTc3F+np6Vo3zcyU0jp79iycnJz4gAYAdO7cGQKBAOfPnzf5OGlpaXBwcCjxe56CGoQQq8YYw+HDh+Hn54fff/8dW7ZsQVZWltaMDaVSid9++01vW0IIIYRUPpoKaYwxCAQCi34nKEm1NlIyRWfqOjo6wsPDAy4uLujatSt69eqF9evXIzMzE4cOHbLQKM1r0aJFcHR01LotWrTolY4ZHx8PDw8PrW0ikQguLi6Ij4836RjJycn48ssvjS5ZMYTCfoQQq/bgwQMolUq8ePECOTk5er+UBAYGUhUUQgghhOhVs2ZNMMaQkZGhUxWjPNBFlvKTmJiIxMREAEDdunXh5eWFhg0bwsfHB7GxsRYenXnMmjUL06ZN09pmKEntJ598giVLlhg9XmRk5CuPKT09HT179kRQUBDmzZtX4vYU1CCEWLXdu3cDAPz9/XH79m3k5+dDIpGA4zh+qp1UKkXTpk1x5swZrbZisZiSbBFCCCGVnObCR9WqVdGrVy+sWrXKwiMi5iQUCvnZMCKRCAEBAYiJiUFeXh5mzpyJtWvX4v79++jTp4/Z+lRbMFAllUqNVtopbPr06Rg1apTRfWrWrAkvLy8+GKShuahYNPF+URkZGejevTvs7e2xd+/eUlXtoaAGIcSqhIeHY+7cufx9TWmzmJgY2NraIj09HXl5eVptrl+/rvdYFNAghBBCiEZcXBz+/fdfSCQSne8S5PWlCWg4ODhAoVBALpdjxowZWLBgAc6ePQuZTAbGWKUskevu7q5VJtiQFi1a4OXLl7h8+TIaN24MADhx4gTUajWaNWtmsF16ejq6desGqVSK8PBwyGSyUo2Tqp8QQqyKQqFASkoKgIKgRO/evbWmigoEAq0ZGJaYRkoIIYQQQio+sViMLl26IDo6Gu3bt8f06dPNctzpP2ea5TilsXSSXZkcNywsDAkJCVi1ahXy8/MxevRohIaGYuvWrQCAp0+folOnTti0aROaNm2K9PR0dO3aFVlZWdi7dy/s7P4bl7u7O5+s1xSUKJQQYlXkcjn8/Pzg5+cHe3t7qNVqrSomQ4YMgUgkglqt1nlMIND9k+ji4mJShJoQQgghVu7/LwVzHAdfX1+dyhnk9VCSyhpt27bFggULkJCQQN8Hi/Hbb78hMDAQnTp1Qo8ePdC6dWv8+uuv/OP5+fmIiopCVlYWAODKlSs4f/48bt68CX9/f3h7e/O3J0+elKhvmqlBCLE6miUoarUaOTk5EIlEUCqVAICGDRvi2rVrJh+LppgSQgghhFgPgUBgdKau5iKXWq1G69atoVarERkZiYMHD8LFxcUsY7DGmRqWRDM1CCFWp2PHjti3bx/27NkDjuP4gAYArYCGKev2KKBBCCGEEEMEAgHq1KmDXbt2oVOnTpYeDjFBcUuPNbN5ASAiIgJnzpyBXC43W0CjoA9msZs1oqAGIcTqaJag+Pv7o2bNmgAAGxsbcByHOnXq8NMOc3JyABRMI62MyZ8IIYQQUnoSiQRqtRrJyckYO3Ys7t+/b+khkWIY+r7HcRx69+4NoOB7pI2NDQCgQYMGiIiIwM6dO8ttjKTkKKhBCLEq4eHhCAkJ4W/du3cHAGRnZ4MxhsjISK2ZGwDg6+uLtm3bGj0urdQjhBBCSGGa2ZxJSUmQyWSIi4uz8IjIfziDj+gLbDDGcPjwYQAFwars7GwAQOvWreHu7m7WWRoF/VnuZo0opwYhxKoUrn4CFHzh6NWrl9E2HMdR0IIQQgghhOglFArRpUsXfPXVV5DL5a98vI9+VJhhVKWz/INXH39FQzM1CCFWpXD1E80SFCcnJ/6xDh06aFU8AQqi85r8GkUf01cRhRBCCCGExwBPT08ABd8j6LtDxWWsTKhIJELr1q3h6+sLgUDAfyf09vaGra0tbt68iblz55plHEzNLHazRvQbRwixOoWXoDRq1AhdunQBALRp0wZXr17VOytDk1+j6GOUa4MQQgghRnFAQkICgILvEUUvkJCKQ6VSGXzMy8sLK1euBADY2trCzc0NVatWRa1ataBSqdCwYUNcunSpvIZKSoCCGoQQq6OpfqK5de3aFQBw6tQpvHz5ElKp1OS1kbm5uWU5VEIIIUTH0KFDcfz4cdy4cQNjxowxenUZADw8PNC6dWuTqnpVFAKBAIGBgfjtt98wZswYky4iyGQyTJw4EW3btuWTfutj6aBC4RNnTcJJUvHFxcWhRYsWiI2NhUKhQFJSEuLi4nDq1ClkZWXh6NGj8Pf3t/QwiR4U1CCEWJ2iS1Ds7Arqcb/99tsACvJsjBo1SquNWCym6aKEEEIsLiwsDLNmzcKKFSvQpUsXbNiwAYDhafN9+/aFjY0NIiIi+FmH9vb2xfZTXKCkLAUHB+P3339HTk4Ohg8fjg0bNvCVJ/Sxs7ODjY0NBAIBVq1ahfPnz+sk/S6souTJKpxwklRMRX9XXF1dIRKJwHEcHzjTfD8UCAS4fv06PyvnVagZs9jNGtE3eEKI1SlaAUVzxURTjosxhu+++06rTX5+frF1ywkhhJCyNnr0aOzcuRO///47EhISoFar0adPH4OzD+Li4hAbG6u1rWgiQ31tNQF/S/j8889x+fJlPHr0CIwxqNVqREZGIigoSO/+U6dOhVQqRVZWFoCCWZQSiaTY2R21a9c2+9hLIi8vD0Kh0OIzR4hhhWde2NnZ4fHjx1CpVPDw8IBSqUSXLl1Qv359iEQiqNVqZGdn4+zZsxYcMdGHqp8QQqyOoQoo/fv3x969e006BlVEIYQQQsirEgqFRvM4kIpFIBCAMabzHdDX1xdpaWlIS0vD4sWL0b9//1fq5/3v0l6p/av4aZqjxfouKzRTgxBidfRVQHF3d4dC8V/5rBo1ami1KToNt3BFFEIIIYSYl0QisfQQyoVKpeIro5CKx9bWFgD473xqtRqMMUilUgDAokWLEBERgZYtW/JtGjRoUP4DJUZRUIMQYvU4joOPjw+OHj3Kb3v8+LHWPvoCGJQklBBCCCkbeXl5Ju/7ui/f0ORgsLGxee2fi7WpVq0agIJlyBru7u7Izc2FTCYDYwx79uzBrl27kJ6ejsDAQNSsWdNSwyUG0PITQkil8OTJE3Tp0kVnOiFNCyWEEEJIeeE4Dm5ubhAIBEhNTYVarTaa9JRUHP369cNnn30GBweHVz7W5G9fvvqASmnFDCeL9V1WaKYGIaRSkEgkfEDD0fG/tYSGAhqtW7cul3ERQgghpPKoWbMmkpKSkJSUhN69e1NAwww47tVOaR0dHfmErkFBQfjuu+/w888/Izw8HH379gXHcXjjjTewcOFCswQ0iPlRUIMQYvXCw8PRtWtX/n5a2n/JmTSBjqIzOCIiIrTuU515QgghhLyqmJgYAAW5G/78809ajmIGjJW+eh3HcfwFLsYYFAoFevbsiU6dOuHkyZM4ePAgPv/8c8TExODIkSNISkpCZmbmK49ZzSx3s0YU1CCEWL2OHTtiz549fJ3xhg0b8o+Z+mWC8msQQgixZqGhofD09CxxCVKO4/jPV1Iy1atXx88//4xLly4hKioKn376Kdzd3Yt9/W1tbTFnzhz06NHD4L4ULDGNJpChCWw8efKEf2z79u3Iz8/HF198AQD46KOP0Lp1a6xbt84iYyWGiSw9AEIIKWtyuRz+/v6oV68enj59CsYYRCJRiaZ8qtWlvwpACCGEVGR169bF9evXUbVqVZPyTGnyUQkEAr5aBCmB/3+57t+/j9TUVMhkMmzYsAGLFi1Cv3794Ovrix9++EFvU47jwHEczp07hyNHjgAApFKpzsUXxhhsbGyQnZ1dpk/FGohEIrzxxhuIioqCn58fv/3EiRMAgPj4eLRv3x4rVqxAp06dzNIns9YpExZCYVVCSKUxevRopKam4vr16zoBjeKCFpqa5fpqlxNCCCGvs/j4eDRo0AAPHz7kt9na2uqUO9cQCASoX7++1menoX2JHlzBTaVS4datW9ixYwd+/vlnSKVS7N+/H0ePHoW9vb3epjVq1IBMJuMDGoDubFKZTAaO43QCGt7e3mZ/KhWB4BXfe0qlEq1atYJAIIC9vT2WLFmCa9euIS4uDmfPnsWkSZPg5+eHNm3amGnExNyo+gkhpFJZu3YtfvzxR2RlZdHUTEIIIYRUSJpZMKR8aJKByuVyyOVy3LlzBxkZGfDw8ECrVq0wZcoUuLm5ma2/iUtSzXasklr1sbPF+i4rtPyEEFKpjBo1CkeOHMG1a9e0tjPGtIIcIpEIHMfxdcs5joODg4NWklFCCCGEEHOTyWQQCoVmSUhJ/qMvUGRnZ4fMzEzY2dkhOjoaLVq0wNq1a8t8LDSvwLxo+QkhpFKYN28eAgICEBQUhGvXrsHW1lbr8aKzNpRKpdY2xhjS09PLZayEEEKIpRW3nIRmO5YdoVAIT09Pg49LJBKdbVKptCyHZBXatm2rsy03NxeOjo4IDAzk75PXD83UIIRUCu+99x5f1jUxMREff/xxsW3EYjHy8vL4+xRVJ4QQUlkUlzCUPhPLTrVq1TBlyhQcOHAAf/31l04esMLfTTToZLx4//zzj842pVKJtLQ0XLp0CQCQlZVVLmNRU6JQs6KZGoSQSsHT0xMtW7ZEy5Yt4evrq/N4s2bNtO4LhUK4urqWqA+6akUIIYSQVxUdHY01a9bgzz//RN26dS09nNeeoZLDhb+31axZE05OTqhWrVp5DYuYEc3UIIRYvfDwcMydOxeA7rISDR8fH637KpUKsbGxJeqHrloRQggh5FUplUpcvnwZQMF3C7FYzOf4IiWjr9ytSCSCUqnkv7e5uroiKysL6enpGDVqlAVGSV4VzdQghFi9jh07Yt++fdi3bx927tyJH3/8UWefvXv3Gj2GXC4vq+ERQgghZjN06FAcP34cn376qUmfXba2tggLC4NYLC6H0VlOaGgoXyaV47hic4aIRBXj2u+NGze0Aho0K7Rk9C3LKbqcJyUlBfHx8VCr1TqJ5MsKY8xiN2tUMX5bCSGkDGnKc2kEBgbCwcFBK/Gnm5sbkpOTddoKhUKoVCooFIpyGSshhBBSWmFhYZg1axbGjh2LCxcuAChYfpmYmKj3ZIbjOKhUKhw+fNjoyY7ms/B11bBhQ1y9ehVqtRrOzs6ws7NDXFycwf05jtM58bWUojMNrPWktCwVVx5XKpWiZcuW+Pvvv+Hl5VWOIyPmQjM1CCGVQnh4OIKDgxEYGIiAgACdAIahLy+v85c4Qgghlcvo0aOxc+dOPqABAAkJCRgwYIDe/QcOHAiVSlXsibKxShyvA4VCAalUCsYYUlNTERcXB4FAYHDWQ0WZpQHozjSw9hk1ZaFoQKNojg3GGJ48eQJHR0ccO3asXMbE1MxiN2tEQQ1CSKVw9OhRSCQSTJo0CStWrMD//vc/AP9d8Xj58qXedjTNkxBCyOti4MCB+PLLL3W279mzR+/+O3bsMGlGwrNnz155bJYUHR2tU9VCrVYbDOa8av4KzRKgGzduYMyYMcUGIuzt7TFnzhx06tRJb7nWwpRKJWrUqIFdu3ahXr16rzTOyqpokCMvLw/R0dFIS0vDxYsXLTQq8iooqEEIsXrr1q1DZmYmjh49inv37mHixIlYvHgxgP+CFq6urnBwcNBqZ2trq7ONEEIIIcQQzRKgFStWoEuXLti4cSN69+5tcH+hUIj169fj2bNnOH78OIRCIapUqWJwfz8/Pzx+/BgjR47ErVu3yuIpVDocx/GBp+Dg4HLpk2ZqmFfFmVtFCCFlZOvWrZg0aRJatWoFtVoNkUgEqVSqtbQkNTVVJ3JfXrXKCSGEkLKiOWHLy8uz9FAqBc0SoN9//53fFhkZCY7j9M4McXd3h6OjI9asWQMAyM7OxtOnT7X24TgOHMdBrVbj0aNHAPQnwCSGCYVCMMagVqshk8mQk5PDP8YYg62tLdLS0jBu3DgLjpKUFsco2wwhxIq9ePEC8+bNw+eff4569erB19cX2dnZ8PLywpMnTyw9PEIIIeS14uXlhczMTGRkZODrr7/G5s2bcfPmTQwdOhSurq7Ys2cPkpKSAPxX4UEgEIAxBh8fH8TGxsLf3x/Z2dl4/vy51gUFQyf+hrZXZiKRSCsfCr1G5iOXy3USxNeoUQOHDx82Wx9j5iea7VgltW6uh8X6Liu0/IQQYtWUSiWkUim2b98Oe3t7fPrpp9i9ezdsbW35fTiOg4ODg0503snJSet+4TYAIBAaX/dKCCGEWJP69etjwIAB8Pf3BwA8fPgQa9euxdtvv42QkBCsWLEC+fn56NixI1QqFZRKJX/irVQqERsbC47jEB0djcTERD6goSmvauiknE7WdSmVSjDGIJPJYGNjo5P8kpSMQCDAkCFDYGNjwy9BWbp0KSIiIhAREYGtW7eatT81Yxa7WSN69xNCrJq7uztu3LiBNWvWQCgU4pNPPkHfvn3Rs2dPfh/GGHJycrB+/Xp+m0Ag0JmaWLgELACoVSWfyiuRyYvfiRBCCKmAZs+eDVdXV1y9ehUAsHLlSuTk5GDy5MlYtmwZ1Go1kpKS8Ndff6FPnz78ibYmGWm1atX4AIUmGWdQUBCEQiHs7e2L7d9aT9xL+rw0QSAAyMnJgb29Pfz8/Mw9LKtROOm7oXwljo6OuHbtGnr06IHGjRtDKpUiOjoa7u7ucHd3h4uLS3kNl5QCLT8hhFi96dOn48CBA5g8eTI2bdqEO3fuQCQSwdvb22AboVBI5VwJIYQQEwgEAp28VKT8cBwHZ2dncByHjIwMAKAcKqW0detWzJ8/H1FRUVrbq1WrZtZyryPnxJvtWCW18Qsvi/VdVqwz3EkIIYUMGjQIAHDx4kVs3rwZz58/x5w5c7T2kclkWvft7OwAFETuDe1DCCGEEN0SmaT8paamIjU1FRMmTKCAxisYMWIE7t27B0dHR2zYsAFLly5FvXr1kJeXp5Nng1QcFNQghFid8PBwhISE8DeNqlWrokOHDnBzc8PKlSu11ugWDl4A4JeapKWl8dsKL0chhBBCKiN3d/dStTNleQkpHc33GbVajd27dxstCUsKZrboW/LTo0cP7N69Gy1btkRGRgYEAgF69eqF9evXIzMzE4cOHbLAaIkpqKQrIcTqdOzYEQ0aNODva65YjBgxAgsXLsSVK1cwdOhQrTYJCQnlOkZCCCHkdaSpbFJSmmURpGxoAhvJyclgjNEyWiM0VXmKqlWrFurUqYOQkBCcO3cO48aNg4eHBxo2bMhX7jHnGIj50EwNQojVkcvl8PPz42/+/v5wd3fH2bNn+VrvRenbFhgYCKlUWh5DJoQQQgh5NQxQqVT8TSSi69fGaHKRaEgkBVXt6tevj8aNG6N27dqYN28eYmNjcf/+fTg4OFhqqKQYFNQghFi9P/74Ay9fvsSSJUtQt25djBgxQmcfTfmuwpKTk5Gbm1seQySEEEIIeTWc7gwAa60YU1qai1gCgQBBQUFITU3lH4uOjsbZs2exevVqXL58Gd26dYOdnR1kMhkYYxCLxWYbh1rNLHazRlT9hBBi9RQKBZKTk7Fp0yb8+eefSE9Pp6RmhBBCCLFqoaGhUKvVuHr1Ki13MJEmcKEpOaxha2uL4cOHY/r06WbpZ/hnz8xynNLY8pWPxfouKxS6I4RYPblcjurVq2POnDk4f/48tmzZYlK7du3aoVWrVgD0L08hhBBCCKmQGPDkyRNcuXIFjDG88847/PIKokssFmPWrFm4desWevXqhTZt2iAiIgIRERE4cuQIRCJRqZPk6sPUzGI3a0QLrQghVi88PBxz586FUqlEXl4eGGM6QQqZTKZT3eTkyZP8z3SFgxBCCCGvDU47Cfrs2bMRFxeHv//+24KDsjxDCVQLL9O5efMmHBwckJubi8TERPz4448QCoXo1atXeQ6VlAAtPyGEWD2FQoFp06bh8uXLGDJkCEQiEVauXAkAegMchBBCCCHWqHr16vjmm28wY8YMPH782NLDqVA4joOPjw/S09N1qvX4+PiYNSA0bNZTsx2rpH5bZH0lf2mmBiHE6u3cuRNKpRK7du1C/fr1IZFI4O7urhWtd3R0RFpamlY7Nzc3JCcnU1k0QgghhLy+GMAJOFSvXh2PHj3C8OHDrSYROsdxemfTurl7IjkpQU+L/zg7O2slCnV1dcWaNWuwbNky3Lx5E4sXL8bTp0/xyy+/wNbWFiqVCkKh0CzjpnkF5kVBDUKI1Vu9ejWys7PRv39/+Pj4QCqVIi8vD0qlkp+lUTSgARTM8ABAAQ1CCCGEvL64guUVDx8+BFCQBFMgEFhF0nRDwYHiAhpAwevg5eUFpVKJ5ORkJCcnQyaToXbt2oiNjUXz5s0BAE2bNkXnzp1x4cIFtGjRwqzjJ+ZBQQ1CiFV78eIFQkJC8PHHHyMuLg6dOnWCnZ0d3Nzcil12UjTHBiGEEELI66jwBZpGjRpBIpHg3LlzVhHYKC2FQgGFQgF/f38kJycDABwcHAAAjx8/RuvWrSGVStGwYUM4Ojri8ePHZgtqsEr8upcFqn5CCLFqSqUSdnZ28PPzQ5UqVeDm5oZDhw5p7cNxHGxsbHTaBgUFldcwCSGEEELKHgOeP3+OM2fOQK1Wo379+pYeUZkRCDiT8qYlJiYCAHr06AG5XI769etj0aJFWLNmDebNm4eHDx8iLS0N9vb2ZT1kUkoU1CCEWDV3d3fcvHkT4eHh6Nu3L2xtbfHOO+9oZblmjOmdlXHnzh2tffT9TAghhBDy2uCAp0//S1L5+PFjSKVSCw6o7KjVzKTvbOnp6QCAzz77DJmZmTh37hy8vb0hl8shEomgUqnAcZxO8lBScdDyE0KIVeM4Ds2aNcOtW7ewZcsW7NixAz169MDTp08xe/Zsfr/iPvQKR/qpWgohhBBCrEFmZiYAwNPTE2q1GklJSRYekeW8++67+Pbbb3H06FGsW7dO6zGJRKIVDHpVajVdIDMnmqlBCLF6s2fPxj///IPly5dj2LBhaNmyJfz8/PjHBQIB7OzsdNo1aNCgPIdJCCGEEFJ+GKBWqxEaGoqEhAS8fPnS0iMyO6FQaNJMlFq1amHSpElwcHBA3759UatWLURERCAiIgJHjhyBVCqFu7t7OYyYlAbN1CCEWD2xWIz33nsPs2fPRt++fQEUzMzQLEFRq9VwcHDgr1YAgFQqha+vL65fv26RMRNCCCGElCmu4DvQuXPnAPz33ciakoeqVCrY2NjwJWyFQqHeqnYCgQD169eHvb09IiIikJubi9zcXCQmJuLHH3+ESCRCr169zDYuWspsXhyjV5QQUgkoFAqkpKQgMzMTMTExSEpKwpIlSyw9LEIIIYSQCiEwMBAuLi5WWxXF1tYWWVlZRvcZNGgQLl++jOjoaAAFQRBPT0988803CA0NNdtYBk5/ZLZjldTOpdUt1ndZoZkahJBKQS6XQy6XAyioajJ37lwAgEwmQ05ODsRiMfLz8/n9RSIROnXqhL/++ovfxnEcRdYJIYSQSkQgFEOtyi9+RysQFRXFf8955513sGfPnmKDABWJoe9pmtkn+p5L0ZkpTZs2RadOnZCVlYUaNWogKSkJK1aswMyZM/HHH3/w3yVfFaOcGmZFOTUIIZVCeHg4QkJCEBwcjICAAGzfvh0A+OmInp6eWvsrlUqdiigU0CCEEEIql8oS0AC0v+fMnj0bzZs3t+BoSs7Q9zRjs04aNmwIW1tbAICTkxNOnDiBdu3aISwsDIGBgWjTpg1+/fVXpKen49ChQ2UybvLqKKhBCKkUOnbsiH379mHnzp1ay040H4BxcXE6be7fv19u4yOEEEKIeTVp0gTHjx/HjRs3MGbMGK1y7oaIRCKIxWI4Ozvr7C+RSMBxnEnHea0xIDg4GH///belR1Lmrly5ws/gaNiwIZ49e6azj4ODA6pXr47Y2NjyHh4xkZX/RhJCSAG5XA4/Pz/UqVMHvr6+AAoSiAL/lX0tatKkSeU6RkIIIYSYR926dXHlyhV89tln6NKlC9avXw+O42BjY2O0nVKpRH5+PlJTU6FWq+Hj48M/lpeXB6FQaJX5JrRwgL29PRhjkMlkEIlev4wFmu94RWlmZRTm5eUFkUgEjuNQpUoVncczMzPx5MkTs1Y/YWpmsZs1oqAGIcTqaZaeaJafjBo1CgD4HBpubm7o3LmzTruiNcoJIYQQ8nqYO3cu3N3dce7cOSQkJIAxhj59+mD48OEmtec4DhKJBImJiVrblUplpZitkZKSAolEgpycHKhUKgiFQksPqUTy8/NRs2ZNrW329vawt7fX2Tc+Ph5VqlTBqVOnMGTIECxZsgQXLlxAXFwcrly5gvfffx8CgcCs1U+IeVH1E0KI1dNUPgGArKwsJCYmYsKECRYeFSGEEEJIxafJLbF7926kpqZaejhlpnXr1li7di2mTp2Kixcv4uXLl3BxcUHjxo0xdepUfqavOQz4MNpsxyqp33/wt1jfZYWCGoSQSocxhqZNmyI9PR1AwRTFxMREODs7a+3n7+/Pl/QihBBCCKl0GCAQ/lchJCQkBFevXrXwoEzn4eGhM9umKKlUiq5du2LevHlmq25SHApqmJd1z5sihJD/V3gJSqNGjdC2bVv+MaVSiTfeeEOnTXEfgoQQQgghVo3Trh5y69at1ybHBsdxSExMhEQiMbpfbm4uevfuXW4BDWJ+r8c7khBCXlHHjh3RoEED/n50dDQOHDgAoGDmxosXL3TaaGZyEEIIIYSQgkCBSqWCg4MDcnJy4ObmhqysLKSlpRksqVqYJheJWq0Gx3EmtSktzbHz8vKK3ffgwYNo2rRpsYlkzcVaE3ZaCs3UIIRUCprqJ5qbk5OT0f39/f3RrVu38hkcIYQQQkhFxwBXV1dwHIcZM2YgKCgIz549g0KhwKpVqyCVSg021SRXVavVUKvVcHZ21gloCAQCrYSkoaGhpo2L43Q22ckd4OHlo7O9WbNmWklexWIxXFxccObMGcycOdO0/kiFQ0ENQkiloFl+EhwcjICAAL4CikaPHj207tvY2GhNt2SMQalU8j8TQgghhFQqHPD8+XN07twZ+fn5uH79OoRCIZRKJS5fvox33nlHbzNbW1u4uLhofa8qmnC0Xr16sLOzg0ql4rfFxMSgevXqxY9Lz/cyL58qUKSn6SyVOX/+vNY48vPzMXz4cHz99dc4evQoYmNji+/PDKikq3lRolBCSKWgqYCSlZWF1NRUPHv2DJ999pnJ7UUiER/UIIQQQgip7DiOg1AohKurK9RqNVJSUrQCBq8LqVQKjuOQk5ODJUuW4Ny5c9i7d6/WPprKKObSb9I9sx2rpPb9XNtifZcVmqlBCKkUNMtP6tSpg5YtW6JGjRr8YyNHjsSXX36p0yYwMJD/WalUomXLlsX0ojv9kRBCCCHEWoWGhiIhIQEZGRkGvyfJZLJX6oPjhMXv9ApUKhU+/PBDAICXlxcAoE2bNoiIiOBv3333nVn7ZIxZ7GaNKKhBCKkUClc/CQkJ0Zp14e7uDjs7O502RRNLFV/CzDo/KAghhBBCCpNKpWCM4dy5cwAABwcH3Lx5U++++fn5epeRFK1KwunJjQEAjKn0bjeE4/47xS2co0MfW1tbVK1aFStWrECTJk3QvHlzfmzu7u78zdHRsURjIOWLlp8QQioFzfIToCDAsW3bNv4+IYQQQggpJQZIpBLk5+e/tjMBhEIhlixZgt69e6NLly46uTWaN2+OjRs3mq2/vu9Fme1YJbV/ZYDF+i4rNFODEFIpaJaf3L59G7/88gvefPNNrcerVq2q02bXrl1a941l9SaEEEIIqazs7e3BGINMJtNJzmlJxY3F1tYWAoEAYrEYM2fOxIULF+Dp6YmgoCBs3LgRCxcuhJ+fH9LT07WSmL4qTRUYS9ysUcV5xxFCSBkKDw/H3LlzkZ2dDcYYNmzYoPW4i4sL4uLitO7v3r1ba5/8/PzyGCohhBBCyOuDAz/7NScnh08gas4gQGnpS/Iuk8mQk5MDAKhevTrS0tKQnJyM9u3bY/v27ahatSrS09P5pShNmzZF586dceHCBbRo0aJcx09MQ8tPCCGVgkKhQHx8PHr37o3JkyfD1dUV8+bN42umE0IIIYSQVxcYGIgGDRrg0KFDSE9Pt/RwSsTHxwfNmjXDsWPHIBaL4eDggObNm+PQoUOYNm0aBg8ebJZ+eo2/Y5bjlMaB1UEW67us0PITQkilIJfLYW9vD7VajVatWvFJPw3VP3dzc0OHDh3KcYSEEEIIIa85BkRFRWHnzp1IT0/HlClT4OzsbGLj0lWREwjFBh+rW7eu0WShb7/9Ntzc3PhlKgEBAWjTpg2WLFmCDRs2YObMmTh79izS0tLg6upaqvGRskdBDUJIpRAeHo6uXbsCAAYPHoz9+/cDAB4+fAgbGxvI5XKt/ZOTk/HPP/+U9zAJIYQQQl5fHLRKh06aNAkhjRqb2Lh0CwjUKsPLgyMjI/UugxEICk6DT548iRcvXvCzdocPH45bt27B1dUVdnZ2sLOz46u0UG61iotyahBCKoWOHTsiKCgIvXr1wjvvvINNmzYBKPjgzc7O1tuGVucRQgghpDIYOnQoxo4di+PHj+OHH36AQqEoto1QKIStrS0yMjL0Pi4QCBAQUFBpo3DCTn15LsqKoSXGmu2JiYn8tgEDBiA0NBTr16/Hvn37kJGRAQ8PD7Rq1QpJSUl49uyZ2cbFGC19NieaqUEIqRTkcjn8/f0RHByMhIQEAP9F6Q0JDg4uj6ERQgghhFhMWFgYZs2ahVmzZmHhwoXIzMzExIkTIRYbXtYRFFSQl0ET0HBzc9N6nOM4MMZQv359AAWBDI7jyjWgAQB2dnZa9+3t7REUFKQ168LZ2RkCgQBnz56FWq3G2rVrcfbsWdy6dQsnTpzA5MmTkZaWBnd393Id++vmxYsXGDZsGBwcHODk5ISxY8eaFBwDCi4khoWFgeM47Nu3r8R9U1CDEGL1wsPDERISgpCQENy+fRt//fWXzj729vb8zyKRCBKJBMnJyeU5TEIIIYSQcjd69Gjs3LkTFy5cAFBwgjl06FCMHDlS7/61atXCsmXLtJZ1FP3OJJfL0bRpU1SpUoXflp+fD44rXd6M0srMzNS6361bN9y5cwe5ubn8WFJTUxEWFobc3Fz8/vvvWLJkCa5du4a4uDicPXsWkyZNgp+fH9q0aWO2cTE1s9itrAwbNgy3b9/G0aNHceDAAZw6dQoTJkwwqe3y5ctf6b1B1U8IIVZPoVDwpcaysrKwfft2bN++3WgbjuNgY2ODrKys8hgiIYQQQojVk8vlkEqlyMjIgEAg4EurWlpISAiePHmCli1b4sWLF7hz547W8pMpU6bozEZ5FT3G3DTbsUrq4Drzz0SOjIxEUFAQLl68iNDQUADA4cOH0aNHD8TFxcHHx8dg22vXrqFXr164dOkSvL29sXfvXvTr169E/VNODUKI1ZPL5VqJQOfNm4fjx4/D0dER0dHRetswxlCzZk3cunWL31a4rjkhhBBCiLVycHAwWI5Vs7SkuG36KBQKZGZmYvLkyfjpp5/MMtbixieXy6FQKCCTyVC1alWd735OTk5QqVRITk5GUlISNmzYUCbjqihyc3ORm5urtU0qlb5SItSzZ8/CycmJD2gAQOfOnSEQCHD+/Hn0799fb7usrCwMHToUK1asgJeXV6n7p+UnhJBKJTw8HI0aNUJKSorBgIZGZGQk/7MmoWjhjN6EEEIIIa8zjuPg4eGhs91Q8k8AqFGjhs42Jycnk/tkjGH37t1aS1PMqej3tLy8PABATk4Oxo8fr7P/y5cvYW9vD7FYXG5Ljy25/GTRokVwdHTUui1atOiVnk98fLzO+0gkEsHFxQXx8fEG202dOhUtW7ZE3759X6l/mqlBCKkUGGP44YcfsGPHDuTm5kIgEBjMiK1ReK1oea8BJYQQQggpa4wxrQoghbcb8uDBA51tqampJeq3atWqaNiwIY4cOcKf9GqCD+ZW+Lgff/yx3n3+/fdfAMD9+/f5ii0AsGvXLj7ZqbWYNWsWpk2bprXN0CyNTz75BEuWLDF6vMIXAUsiPDwcJ06cwNWrV0vVvjCaqUEIqRRWr16NzZs3o2/fvuA4Dp6enlqPu7m5QSgUam2rWrUq/zMFNQghhBBCzIAVJA1du3YtJBIJpk6dWmYBjaIcHBx0ts2fPx+urq784/v370fv3r3h4+NTZpXw1ExtsZtUKoWDg4PWzVBQY/r06YiMjDR6q1mzJry8vHSCY0qlEi9evDC4rOTEiROIiYmBk5MTRCIRX/b3zTffRPv27Uv0elKiUEKI1WOMoUmTJsjJyYFSqQRjDGKxGPn5+fw+HMehYcOGZokWE0IIIYQQ4zS5L4RCodbs2LJU9PufZhyam1gsxqVLl9C2bVsMHz4ckydPLpNxdBt5rUyOa4q/NjY0+zE1iUIvXbqExo0bAwCOHDmC7t27G0wUGh8fr7PcJzg4GN9//z169+6td5mTITRTgxBi9eLi4pCRkYHvvvsOHMfhgw8+wNKlS/nHXVxcwBijgAYhhBCrpZmNyHGczszEot5++23Y2tqafGyazUhKQ3NtXaVSQSgUQiQSoX79+qhbt26Z9Vk0oKEZh1qthkqlQm5uLjp06IDU1FR07ty5zMZhbSVd69Spg+7du2P8+PG4cOEC/v33X7z//vsYPHgwH9B4+vQpAgMD+dLBXl5eqFevntYNAHx9fUsU0AAoqEEIqQSSkpIAFCwnUavVaNWqFRo0aMA//uLFCwgEAp0lKYQQQoi1aN68Od544w0+4fU333xjcMr5rl27kJWVBYGg+FMFoVDIn5zqSzhJiFH/f47t5eUFxhiqV6+Ou3fvlusQhg8fDm9vbwAFy0/c3d1hY2ODzz77rNxmkFiD3377DYGBgejUqRN69OiB1q1b49dff+Ufz8/PR1RUFLKysszeNwU1CCFWJzw8HCEhIfxNqVRqPT5y5Eh0795da5tQKERCQgJ/vyRXqAghhJCKzNvbGx07dkRMTAwAQK1W4/79+3jnnXeMttMk1DZW2UJz0icQCKBQKMwzYFJ5/P8kn6dPn0KlUsHf35/PrVBenJyckJCQAI7jkJaWhsjISMyYMQM3b97kZxWQ4rm4uGDr1q3IyMhAWloa1q1bB7lczj9evXp1MMaM5stgjKFfv34l7ptyahBCrI5CoUBKSgp/Py8vD7169cKuXbswaNAgfP7552jatCl69uwJxhhNmyWEEEIIqQCEQiF69uyJa9eu4enTp1Cr1UYrsZiTWCyGSqWCjY0Nzp8/jzZt2uCjjz7C4MGDzd5Xl2GXzX5MUx39rbHF+i4rNFODEGJ15HI5/Pz8+Ju/vz/c3d1x6dIl1KtXDzExMXwmZmMBjaJJjQxN0yWEEEIIIa+IAfb29ggPD0d2djY4joOLi4vZuwkKCtK6X6dOHbRp0wb5+flQq9Vo3rw5UlJS8PLlS7i7u5u9f2J+NFODEGLVbty4gaioKERGRuKPP/5ASEgITp48qbOfn58fHj9+rLVNJpMhJyeHv6/J0k0IIYQQQsrWsGHD8OjRI/z7778m7S+TSpCTa7w0rFQq5YMXhbm4uCA1NRWMMXzxxRfYsWMHMjMz8ccff0AikZT6ORjSecglsx/TVMe2hVqs77JCQQ1CiNVSq9WYMGECHj16hFatWsHFxQXbt2/Hy5cv+cdp+QkhhBBCSAXDgLfefguHDx8u91wttra2OsksW7dujbVr15qtDwpqmBcFNQghVm/evHla/wLAsWPHtGqPBwQEICoqir8vEAjg4+ODuLi48homIYQQQgj5f5oZsiWZKSsSiXQSxBfm5eWFhIQEuLm58dXxClu7di0OHDiA5ORkLFq0iN8ukUjg6OhY8idhAAU1zKt8U8sSQoiFPHr0iK+EkpeXB6FQyD/GcRzu37+vtb9araaABiGEEEKIhWgCGYwxeHh4ICUlpdgSq8YCGnK5HAkJCfD19YVAIOCDGlKpFLm5uQCA5ORkAAVBjLLMp8GYuvidiMlopgYhxOr89ttvWLt2LZKSkhAYGAgvLy84ODhgwoQJyMrKQmJiIiZMmMDvr2+aISGEEEIIqVj69++PxYsXo3fv3rh3757ZjquZDVK3bl1kZGQgNjZW6/HmzZtj48aNZuuv02DLlYo9vr2pxfouK1T9hBBiVQ4ePIhFixZh8uTJ2Lt3LwIDA/H3339DpVLBz88PderUwalTpxASEsK3ycrKgkCg++ewbt26WvfFYnGZj58QQgghhGjTzLB9/PgxDh48qDPD1hSGcqgJBAJ+VohYLIanpyeCgoKwceNGLFy4EH5+fkhPTy92lkhJqNXMYjdrRMtPCCFWZf369Rg4cCDefPNNAMC9e/eQn5+P/fv3Y//+/RAKhcjLy9Mpz+rh4YH4+HitbYX3YYwhOzsbIpGIkosSQgghhJQjTUDhypUrUCqVqFKlipFlwhwA3ZN3TeDCycmJTxovk8kglUqRlpYGAOjbty9u3LiB9PR0NG/eHADQtGlTdO7cGRcuXECLFi3M+ryIeVBQgxBiNfLy8nD79m28++67/LYdO3bg448/xosXL1CtWjVs27YNAoFAp5RX0YAGUPDBqcFxHEQiEf8zIYQQUhHZ29ujXbt2OHTokFmvLJuDh4cHPDw8cPv2bf4EUyaTIS8vT+dzmRBDJBIJunfvjiNHjiA+Ph4cx/E5MQoYn42gCWgAQE5ODnJycvj78+fP538OCgpCtWrV0Lx5czg6OuLx48dmC2ower+bFS0/IYRYjdTUVKhUKri6umptd3V1xb1797Bnzx5IJBIIhUL4+/trBSdsbGx0jufk5KR1Xy6Xl8m4CSGEkFdlZ2cHkUiE3NxcHDp0qEyTHJZUUFAQACAxMRG1atXit4vFYuTk5IAxhrFjx1pqeOR1woD8/HysXbsWEokECxcuLBLQ0Fa/fn3Y29sbfFwsFsPZ2Zm/37x5c3zwwQdo3rw5RCIRJkyYgLNnzyItLU3n+yWpOCioQQixeowxJCcnIzMzky/H9fjxY63yYH5+fjrtsrOzte6Xd510QgghxFSZmZl8hS+O45CRkWHpIfHu3LnD/3z27FlUqVIFQMHJKVDwOX369Gmtk0tC9OKA69evgzGG6OhoHD9+3GiwITIyEgqFQm/uNKlUCsYYP3PD0dERT548QWZmJiZOnIjc3FykpqZCIpHw+5OKiYIahBCr4ezsDKFQiJSUFK3tT548gVKpRMuWLZGcnIzPPvsM+/fvh4eHBx/YiIyM1Dmescg/IYQQUt6GDh2K48eP48aNGzh+/DhOnz6NGzduYMyYMVrJrJVKJTIzM2FnZwcXFxdIJBI4OjryJ3aGllFyHAexWMwvtzSr/7+OEB8frzcXwr1795Cammr+folVKPze37lzJ4KDgwEASUlJWLBgAU6fPo2oqCh06tQJIpEIkydPxtGjR3H58mXs27cPrVq10jqeQCDAxIkT8ddff+HatWs4evQohg0bhufPn2Pr1q38zKEtW7YgJCQETk5OePbsmdmeD1Mzi92sEQU1CCFWQyKRoG7dujh79iy/Ta1W49KlSwCAqVOnQqVSoU6dOvDz84NKpeK/2JlS2UQgEPDRekIIIaQ8hYWFYdasWVixYgWWLVsGb29vyOVy9OnTBxs3bsQnn3xSsJTy/89ZateujezsbKSlpUEikSAtLQ0CgQAuLi58QL9OnTr88W1tbeHt7Y38/HwolcqyeRL6zqes8xyLmAknEGm99/v374+7d+9i7dq1cHF2ga2tLaKiovhcGBzHYerUaRg0aBAWL/kGH3/8MbZv346ffvqJf7/LZDJ8/PHHGDJkCBYvXowhQ4Zg/fr1GDduHIYNG4a8vDwAgL+/P44fP47JkycjLS2tQi3pItooqEEIsSqjR4/Gtm3bEBwcjAYNGiA4OJifcaGZNjhs2DA0aNBAa0aHKV/gGGP8Bx0hhBBSnkaPHo2dO3fi999/R1hYGLZv346MjAxkZmZCpVKhS5cuBbmf/n8SRnx8PNq3bw+VSsUvn5TJZAAKAh4CgQCPHj1C06ZNAQC1atXChx9+aJHnRoghTK3Ueu/HxMRg7ty5yMnJwZtvvYlTp05h27ZtOHbsWMH+jKFPn95YtWoVjh87gu7du2Pbtm04efIkxowZA4FAgJycHNSsWRMnTpxARkYG7ty5gz179uDixYuoX78+mjVrhhYtWiA6Oho//fQTJk2aBD8/P7Rp08Z8z4upLXazRhTUIIRYlR49emD69OlwcnKCUqnEG2+8gS+//BLAf4GLevXq8dtKonAODkIIIaQ8DRw4EDExMTh+/DgCAwPRrl07cByH48ePY+fOnZg8eTKSkpL4/dPT0/H3338DKLh6rVmGolAokJaWBhsbG+Tk5ODChQsACvIUfPLJJwAKZiY6ODhAKBSa7wlw4AMuOtsJKaLwchOO43D48GH+McYY2rZti9WrVwMAUlJSMHnyZCQkJODHH3+Es7Mz5s6di06dOmHKlCkACpYUt2/fHkePHsX169dRo0YNJCQk4MaNGxAIBKhevTratm2Ly5cvIzExkc8Ds27dOtStWxe//fYbzdatwCioQQixOmPHjsXp06dx+/ZthIeHo2fPnnB3d8elS5dQv359BAcHa63blUql6Ny5s85xiiaEommHhBBCLMXQ8pNRo0bx0/Ht7Oz4/TXLKzmOg5OTE168eIHMzEx4eXkhISFBJ29U4SpgIpEI6enpVGaVWETR5SaRkZFYsWIFXFxc9O7/0UcfYdCgQdi+fTt27tyJPXv2AChIAi+RSNCyZUuEhYXB3t4eixcvxvz587F161aMHz8eCxcuhFQqxerVq/Hy5Uvs2LED06dPx969ewEAXbt2xZdffgk3N7dye/6k5CioQQixehzHwcfHB0uWLMGNGzewZcsWProPFET827dvr9Ou6Be+wlfACCGEkPKkb/mJQqFA48aN+en4tra2/P5OTk4ICwsDUDBTUSKRgOM4pKWlASjIOSWVSvl9RCIRvzxFs9SSMWYwqSghZaXwe/3Ro0f/LTd5801+H47j+CBe3759sWrVKhw7dgxffPEF5s6dCwAYPHgw8vLyMHHiRCQmJiI7OxtHjx5FdnY2EhISoFQq4enpiezsbHz66acQCAQYNmwYUlJSMGDAAADAiBEjyuQ5UqJQ86KgBiGkUvjhhx/Qp08fODg4gOM4JCcn84+1atUKP/zwg8nHMut0XEIIIaQYYrEYdevWxfnz5/mf//33X/z7778ICQkBYwznzp3TyhWVlpYGZ2dnMMaQkZGB4OBgyGQypKWl8clCc3Jy0KVLF3Tv3h316tVDrVq1dPqmpZekPGne32fOnAEAqFQqMMZw5swZhISEAAAcHBwA/PfeFIvFEAgEiI6OhpeXF38suVwOoCAw8ezZM4jFYlSvXh2HDh3CtGnToFKpsHXrVgBAREQENmzYgGHDhmHOnDkAgG+//ZavskIqNgpqEEIqBS8vL3zzzTe4ePEi7t69y0fxbWxsUKVKFezevVtr/yFDhiAyMpK/auXo6Kj3uELxf0tUHJ09dB4XCISwlTub62kQK+Pg7K31HiKkLNg66v5tqvjoK2phzs7OEIlESExM5H/Oy8tHSkoKPy3+4cOHWstF1Go1WjZrxp/Y5ebm8iVdFyxYwJ8Qnvznbxw+fBhnz57FzZs3+faafU0lLIsysCjfCwkiPX3pm6kiFBVfMa0sCQzMnpEXWn5kDMcBnJH/39K+5kVLAZsyy4fjtMeheX8XDtCJxWL+ve7k5IJ6DULh6enJHz8iIgKDBw9GmzZtIBAI0KlZSwD/BT/s7e0RGBgIsViMw4cP49atW/Dx8cHq1atx7tw57N27F1FRUfjoo49Qs2ZN3L17F2fOnEHv3r1L9TqYgqnVFrtZI/rEIIRUCvPmzUNAQAB/00ytzc7OxtatW7Fs2TKt/QMCAjBv3jzk5OQAAD9dFyi4asD/nP/fEpW01ESdftVqFbIUqTrbCQGA9NTnWu8hQspCVpru36aKzzq/eL8qzZR4AMjISNd6rGgeKAB48PgxevXqBaAgv0B+fj4AYNWqVfw++8P/4H8uHMgoaT4NVRmVgS38mVvWlHr6YozpBDFUyvzyGpJeagOzZxSZmSa1ZwxGT25L+5oXrSRnyiwfU6pxaN63AoEAGRlpOHP6BOLj45H5/8931S+/4smTJ1i5ciX++usvLFi8iO+/cePGWL9+PeRyOVQqFT755BOMHDkSMTEx+OCDDzBlyhRMmDABiYmv499JolE2IVVCCKlg3nvvPXTt2pW/n5WVBQCoWbMmHj58yCeE0vjyyy9Rt25d/r6dnR3/4WkMx3E0VZcQQohZpaam8ieMCoUCSqUSrq6ucHNzQ3JyMmxtbeHm5gaBQKAVjPjxxx/5E8IbN27wj924cUNvP2q1WucYxPJBjMpE8153dXXV2u7q6oq0tDTY2trigw8+wMKFC/nH7OV2eO+99yCRSODk5ITExERERUUhOTkZz549Q2BgIDiOw4kTJ7Bv3z4AwKBBg7B27Vr069cPv/76K/bt24cJEyaU2/OM+KNdufVVGdBMDUJIpeDp6YmWLVvyt44dO0IgEMDPzw93795FVFQUAgMDARR8cA4ZMgQ7duyAp6cnvLy8oFar4eXlBaFQiFq1akEgEPCJ14CCqZoCgQBVq1bl7wuFQtSoUQPNmzfnt7m6ukIsFmsFPgQCgd4pms7Oznr3KXolBABsbW11MtcXx8bGRu/04ipVqujdn+M4nS+6muddmFQq1ft8XiXYU5K27777rtZ9fa9X4S9LYrGYz6hubMpt69atERkZqfcxjuN0Sr0xxiAWF1zd03cFFQDef/993Llzh3+9NOvZGWMQCAQ642nQoIFO9vei+zDGMHr0aJ3tJa3eo3k+hTO+y+VyfkmWpm/NczQ2JlNoZk8VVrt2bf5nzfus6HtbKpUavKpY+HeiMI7jMG7cOL3vaX00U5iLMvS+LPw7Ufi1KPweKTxmY7+vmveOUCiEjY1NsdO5NX/HChs/frzW/aIBWoFAgL59+xo9rlgshp+fH3+f4zh+LIXfI4XfH/pwHKfzt0rfe6hRo0Za94u+1qGhoQb7MLRsQiaTwdvbG9WqVdN5TN/vaHFB6v79+xt8DPhvzN7e3vy2OnXqAIDOCZtIJMK3336rta1fv378z/n5+bhz5w66deuGrKws3L59Gy1btkSLFi1w9epV5Obmok2bNnxgA/jvc0MikcDV1RXx8fHgOA5eXl58fikbGxu0a1dwcvX+++9DJpNBrVZDKBTy/792dnb8353Cr1ONGjW0/u80+TuAgvdr7dq1YW9vzz8uFAr594qtra3Oa65SqeDs7Mz/nhQ+tre3N8Risc7fWY7j+CvwQMEyA1tbW4hEItja2mq9Fwr35+zsDA+PgmVZhf+PNX9zHB0d4evry28/f/48/7usycvg4eGh9fej8O+mQCCATCaDk5MTf0HF3t4eLi4u/JhUKhU4joNIJIKfnx8EAgFEIhGf/JLjOLRr107ndyowMFDrc83JyQlSqRQikQiffPIJ//9uY2MDmUwGoVCIYcOG8cfRBK1q164NoVAIqVSKtm3bws7OTuezrH379vDw8IBcLufzVuTn58PGxkbv36369evzfXt5eSEkJARyuZzflzEGLy8vPu+Fvb09QkJC4OfnB6FQCLlcDhcXF9y/f59P4F6tWjW4urqiRYsWOH/+PNasWcMnDNX8n1SrVg22trZo0KABcnNzUaNGDQBARkYG1q1bx7+XfH19IRAIcOXKFVy5cgUhISH886JA3uuNY3RJkRBSSY0bNw6nT5/GxIkTERQUhM8++wwZGRl48803ER4ejpCQEFy4cAFOTk54+fIlqlWrhri4OP4LkKGs8HK5HAqFwmC/VapUQVxcXKkzyuvrVygUlssU3aJ9G5rBou9k4FWy6JvaViAQQCKR8MuGNG2FQqHRLyyGTl4K9xsYGIjo6Gi9QZLSjtnPzw9xcXH8/53mi5Wmrb5xeXl5IT4+3mi/YrHY5HGWdNyFv/z5+voiNja2VP2UtF9zt9W8vpoTi/Lq1xxtjdH3npFIJFpBo/z8fL2BhMJkMpnW71HR92ZplKRt0edRtK1YLOZnIJSlwv2WdCaeKX97CnN0dNRa6ujj44PExET+dzksLAxLlizBnDlz4OTkhP/973/Izc3F2LFj0bdvXwwYMABz5szB3r170bx5c5w/f54fv7e3N549ewaBQMCXdy2q8PtE87Nm/KY8b02QUPN6ubi46O3H0OuomSWib1+O42Bra2twxmTR/yeg4D2cnZ1d7Lj1vS+L/l8U/R3SbMvNzTX6nnZ2duZLyFevXh2PHj3S6dfGxoYfp729PTIyMgAUBH40s0odHByQnl6w3EgkEiE/Px8cx+mcjGvGWfiYRRX+f3J1dUVGRgby8/PBGIO7uztf6a3w33ehUIhq1arh0aNHev+fih6fMYYqVarg6dOnkEqlfDU5fa914feDRCKBp6cn6tWrx7/Xk5KS0LVrV4SFhaFHjx6wsbHBV199hdu3b2PJkiVwcXFB9erV0a9fP2zevBmhoaGYPn067O3tcfbsWQQEBEAul0MikUCtVmPGjBmwt7fH+PHj4e3tjYsXL2LcuHHYvXu33qAweT1QUIMQUmmp1Wq88847uHz5MhhjcHR0RM+ePfHPP/8gISGBvyJhZ2eHQYMGYcuWLfwHP2D8C7pIJDJ6UlkZy+RVtudc2Z7vq6qIAQJT+hUIBK/dkjN6b76+hg0bhrFjx8Ld3R2JiYmQSqVwdHREZGQkhEIh7t27h1mzZsHV1ZU/mdacwDo6OkKhUPAzMZRKpcnv3ddlaaU1X3EvyXMTi8VQq9Vmvdjh7OwMpVKJ9PT0MgvIAv/NnCn8Xo+MjMSCBQv4ZVObNm3C06dP8dlnnwEAGjdujHnz5sHX11dnNg8AJCUl8bMVNcGpxMREHD58GCdOnMC7777Lz1girycKahBCSCmkp6fzV3IMTU23praW7Jvalk9bS/ZNbcunrSX7prbl09aSfVPbit/Wkn1b8jkT60c5NQghpBSkUinmzp1rMFeCtbW1ZN/UtnzaWrJvals+bS3ZN7Utn7aW7JvaVvy2luzbks+ZWD+aqUEIIYQQQgghhJDXEs3UIIQQQgghhBBCyGuJghqEEEIIIYQQQgh5LVFQgxBCCCGEEEIIIa8lCmoQQgghhBBCCCHktURBDUIIIYQQQgghhLyWRJYeACGEEEJIaSUnJ+P8+fNQqVRo0qQJvL29De577tw5VKtWDVWqVMHz58/x6NEjtGjRotg+5syZg759+6Jx48ZmGzdjDBzHme14xPLGjRuH4cOHo3379uXS35QpU5CUlGTy/m+88Qa+/PLL17atJft+1XGrVCoIhUK9+xp7jBBiGirpSgghhABQKpVYuHAhxowZg6pVq1p6OMQEe/bswdixY1G7dm3k5+cjKioKK1aswOjRo/Xuf/z4caxevRrbt2/HkCFDMH78eHTs2LHYfsaMGYMDBw5AIpGgd+/e6NOnDzp16gSJRFLqsUskEly/fh116tQxut/z58+xcuVKRERE4Pnz5xAIBKhZsyb69euHUaNGvTYnQ5qvm6YGcqZNm6Z3O8dxkMlk8Pf3R9++feHi4mK2MRrrV5/vvvtO637fvn3x119/wd3dHYMHD8bw4cPRoEEDs46vsAYNGiA8PNykfRljGDhwIC5cuPDatn2dxz127Fg4Ojriu+++w71795CXl4d69eph3bp12LhxI06ePGnSscvLnj17EB4ejkGDBmH27NmYPXs2BgwYYJGxJCYm4ptvvkHbtm3Ru3dvAMDIkSPxzTffwMPDwyJjIhUPBTUIIcTKHT9+HMePH0diYiLUarXWY+vWrTPpGHl5eXrb+/r6mm2c5vLs2TNEREToHe+HH35otK29vT1u3ryJ6tWrl6rvzMxM2NnZlaptUSqVCjdv3oSfnx+cnZ2N7vvFF19gxowZsLW11dqenZ2Nb775BnPmzClx/3fv3kWfPn1w7949g/tcuXIFYrEYwcHBAID9+/dj/fr1CAoKwrx5817ppF8fhUIBuVzO369fvz52796N2rVrAwD+/PNPjB8/Hs+ePTN4jMmTJ8PZ2RmpqalYsWKFyX2r1Wr8+++/+OOPP7B//348f/4cXbp0Qd++fdGrVy+DJ9eGTpK///57DB8+HK6urgB0T5AB4NKlS+jcuTP8/f1hY2ODs2fPYujQocjLy8Nff/2FoKAgHD58GPb29iY9B5VKhdu3byMoKAgikeHJuqaevBXWpUsX2NjY6Gxfu3Ytli1bhvv37wMAatWqhY8++gjjxo0zerwOHTrgypUrUKlUCAgIAADcu3cPQqEQgYGBiIqKAsdxiIiIQFBQ0CsFI4r2e/XqVeTn5+v026hRI34/juNw4sQJnfapqanYtWsXtm7ditOnTyMwMBDDhg3D0KFD9f5diY2NRbVq1UwO9sTFxcHHxwcCgQAhISG4evWqSe0AoEmTJrh48SIAvJZtLdn3q4778ePH6NSpE5RKJRITEyGRSODh4YGkpCQcOHAArVq1MvnY5aFLly64evUqtm7dCgCYMWMGbty4YZGxDBo0CH5+frh9+zaaNWuGOXPmwN7eHtevX0fNmjUtMiZS8dDyE0IIMeKHH34wed+iJ8wlOTHo06ePzrZXbQ8A8+fPxxdffIHQ0FB4e3uXeLr7/fv3MWbMGJw5c0Zru2bqvEqlMtr+4sWL+Pvvv/UGGIydWGRmZmLx4sUGgzEPHjzQ227Dhg149913IZFI4OrqqvV8OY4rNqjRsWNHnDx5stRBDU9PTwwcOBBjxoxB69atS9T2o48+QnBwMMaOHQuVSoV27drhzJkzsLW1xYEDB4xOaZ8/fz4mTpyoE9TIysrC/PnzSxXUyM3NRUxMjNF93n33XXzyyScIDg7GgwcPMHjwYPTv3x+7du1CVlYWli9fXuJ+jWncuDG+/vpr9O3bFwAgEomQmJjIBzUSEhIMBlI6dOgAjuOQnp6OK1euoHHjxvw2fSenRQkEArRp0wZt2rTB119/jcjISPzxxx/45ZdfMGHCBDRt2hR9+vTBkCFDUKVKFb7d8uXL0aBBAzg5OWkdjzGGyMhI2NnZGfy9/OijjzB16lTMnTsXALBlyxb89NNPOHfuHFJTU9GxY0fMnj0b33//fbHjB4A//vgDb775JjZt2oRhw4YZ3K9fv34mHU+D4zjcv39f5wRjzpw5+O677/DBBx/wy3zOnj2LqVOnIjY2Fl988YXBY2pmYaxfvx4ODg4AgLS0NIwbNw6tW7fG+PHjMXToUEydOhV//fWXySecxf0N7N27N+zt7bFx40Y+mJiamorRo0ejTZs2mD59utH2zs7OmDBhAiZMmIC4uDhs27YN69atw5w5c6BUKnX29/f3x8OHD7XeM8bUqlULd+/ehZ+fX4n/nhf9e/i6tbVk3686bj8/PzRt2hQqlQobN26ERCLBvHnz8Oeff5oc0Dh58iSWLFkChUIBgaAgLaJmyZO524rFYjRs2BBdu3YFgGID6+YSHR0NFxcXrSBxfHw8duzYAbVajQkTJuD777+npXtEFyOEEGJQ9erVTbrVqFFDpy3HcVo3gUCgc19z06doe0M3Q+0ZY8zLy4tt2rSp1M+/ZcuWrG3btuzgwYPs6tWr7Nq1a1o3Y7766ivGcRwLDAxk7dq1Y+3bt+dvHTp0MNp28ODBzNvbm/3vf/9jy5YtY8uXL9e6GVK1alW2YMECplKpSvV8V65cyby8vNj06dPZ1q1b2f79+7Vuxdm7dy/r27cvE4vFrFatWmzRokXs6dOnJvVdpUoVdvHiRf44Pj4+LCoqis2ePZu1bNnSaFuO41hiYqLO9uPHjzM3NzeT+i/q2rVrRt9bjDHm4ODAoqOjGWOMLV68mHXt2pUxxlhERASrWrVqqfo15uHDh6xHjx6sX79+7OnTp+zUqVPMx8eHeXp6MldXV+bu7s7+/PNPo8eYNGkSmzVrFps0aZLZxpWYmMjWrFnD+vTpw7755hutxxYtWsRq1KjBjh8/rrVdJBKx27dvGz2ujY0Ni4mJ4e+rVComFotZfHw8Y4yxI0eOMB8fH5PH2a9fP+bp6ck6d+5sdD+O41hCQoLJx5XL5Vrj1HBzc2Nbt27V2b5161bm6upq9Jg+Pj56X59bt27xz/ny5cvFHqekfHx82K1bt3S237x5k3l7e5t8nLy8PLZ371725ptvMplMZvD/qWrVqmz27Nns8uXL7Pr16+zOnTssMzOTMcZYfn4+i4qKYtevX2dXr15lP//8MxMKhfzjISEhJXpuTZo04X9+Hdtasu9XHTdjjHl7e7MrV67w9/Pz85lIJDLpd+37779nzZs3Z3fv3uW3JSUlsYEDB7KxY8eave0777zDYmNj+fstWrQodoyloVar2TfffMNCQkLYTz/9xCIiIpivry/79ddf+X0mTZrELl++zBgr+Bs4YMAAJhQK9f7NIZUXBTUIIaQcHD16lDVq1IgdPnyYpaWlsbS0NHb48GEWGhrKjhw5Umb9uri48CedpWFra8siIyNL1dbDw4OtX7++VG0dHR1ZREREidu96vMtbfCoqMTERLZ06VIWHBzMRCIR69mzJ9uzZw/Lz8832EYqlbInT54wxhgbP348mzJlCmOMsQcPHjB7e3u9bZycnJizszMTCAT8z5qbg4MDEwgEpT55NyWoYW9vz+7du8cYY6xz5858wOnx48dMJpOVql9TbN26lfn7+7MffviBZWVlsRs3brCrV6+y7Oxso+2OHTvGBg4cyBgrCJwVDTSUlQsXLrDatWuz6dOns7y8PMaYaUENPz8/rd+DZ8+eMY7jWFZWFmOsIMhj6uuclJTEpFIpO3ToEBOLxfx7TZ9Ro0ax9PR0k47LGGMTJ05kSUlJOtsdHR3590dhUVFRzNHR0egx7ezs2N9//62z/e+//2ZyuZwxxlhMTIzB343Sksvlevs9ceIE368xJ06cYOPGjWPOzs7M0dGRjR49mh07doyp1Wq9+3/77bdMLBZrBb3t7OzYtm3bmI+Pj9Z2gUDApk6dyrd9HU/wK3NQo0WLFmz16tX8/fPnzzMnJyejnwuMFQSJq1evztLS0nQeU6vVrH379mzlypXFtk1NTeW3p6SksFOnThlsqwmcMcZYTk4Ou3DhgtExllZGRgZbs2YNW7lyJfPz82OMMfbkyRP21ltvsaZNm7LLly+zFy9esLNnz/JtsrOz2caNG5lCoSiTMZHXEy0/IYSQEsrLy8PDhw/xxhtvGF2XXthHH32EVatWaS1J6NatG2xtbTFhwgRERkaWyVjHjRuHrVu34vPPPy9V+6CgICQnJ5eqrUAgKPU6YWdn51IlABw7dix27dqFTz75pFT9Fl3mUlru7u6YNm0apk2bhh9//BEzZ87EwYMH4ebmhokTJ+KTTz7RWSri6emJO3fuwNvbG4cPH8bKlSsBFCwhMZQMcvny5WCMYcyYMZg/fz4cHR35xyQSCapXr25SdY/SCg0NxYIFC9C5c2ecPHmSH/PDhw/h6elZZv0OGTIEYWFhmDFjBtq3b49ff/0VDRs2LLadjY0Nli5dCgBYunQpHj16VGZjLKxJkya4fPkyJk+ejNDQUPz2228mTZ/u168fJk6ciG+++QZSqRRffvkl2rVrx+euiIqKMnnZwrZt21CvXj10794dbdq0webNmzFr1iy9+65fv970Jwfw/+9FvfPOO1i5cqXOUrNff/3V6PIXoGD5yZgxY7B06VI0adIEQMFythkzZvDLYy5cuMAvPTKX/v37Y/To0Vi6dCmaNm0KADh//jxmzpxZbKLEKlWq4MWLF+jevTt+/fVX9O7dG1Kp1Gib6dOnY/LkyUhKSoJarUZOTg62bduGUaNGYeDAgfjf//4He3t7CIVCeHh4aC2vys7ONrqEpzBWJIXe69jWkn2/6rhVKhVcXFwwefJknDlzBnK5HJs3b4a3tzeys7ON5sVZunQpPvzwQ3z88cfo0KEDBg4cCACIjIzExIkTsWDBAowcORITJ0402Pbbb7/FV199hWnTpqFZs2Z4//338d1332H+/PkYNWqUTtvCn09SqZT/HTQ3uVyOsWPH4tSpU/wSvapVq2LXrl3466+/MGzYMHTo0AELFy7k28hkMowYMaJMxkNeX5QolBBCTJSVlYUPPvgAGzduBFCQPK5mzZr44IMPUKVKFaMn0jY2Nrh48SLq1auntf3GjRto1qwZsrOzi+0/MzMTJ0+eRGxsLPLy8rQeM5QrYsqUKdi0aRPq16+P+vXrQywWaz1uLK8FAJw4cQKzZ8/GwoULERwcrNNes9Zdn6+//hrPnj0rVV6FLVu2YP/+/di4caPOyb8xKpUKvXr1QnZ2tt7xFvd8zSUhIQEbN27Ehg0b8PjxY/Tv3x9jx45FXFwclixZAh8fHxw5ckSrzbx587B8+XJ4e3sjKysL9+7dg1Qqxbp167B69WqcPXvWYH8nT55Eq1atTA6yAQWBI2Mn1kqlEpmZmUbzpty4cQPDhg1DbGwspk2bxud++OCDD5CSksInmTOngwcPIjIyEg0aNOCDKZMnT0ZYWBi++OILvckqK5Lt27fjo48+QlJSEm7evImgoCCD+yoUCowdOxa///47VCoVWrRogS1btqBGjRoAgCNHjiAtLQ1vv/12sf02btwYI0eOxIcffoj169fzeUHMrXDCTqVSiQ0bNsDX1xfNmzcHUBAgiI2NxYgRI/Djjz8aPI5CocDUqVOxadMmPheFSCTCyJEjsWzZMtjZ2eHatWsAYFJAy1RZWVmYMWMG1q1bh/z8fL7fsWPH4ptvvjGaCHj16tV4++23dfKnlJRarYZMJsOVK1d0PjMKO3XqlEmfHRqOjo78/8Pr2NaSfb/quN977z1cuXIF69ev54/VsWNHLFy4EM+ePcPp06cNHqtq1aoIDw9H//798eeff2q9J6RSKR4/foyqVasiPj4ebm5uetu++eabWLFiBZ90c/369WjSpAlUKhWkUqnethVBXl4elixZgrVr12L+/PkYOXKkpYdEKigKahBCiImmTJmCf//9F8uXL0f37t1x48YN1KxZE/v378e8efOMJqpr27YtZDIZNm/ezF/BTkhIwIgRI5CTk1NsOberV6+iR48eyMrKQmZmJlxcXJCcnAxbW1t4eHgYTJzZoUMHg8c0JUGiJqFY0ZNfZkKiULVajZ49e+LevXsICgrSCTD8/vvvWvdDQkK0+omOjgZjDNWrV9dpe+XKFb19LliwAHPmzEFAQAA8PT11Er2ZkhCyNMGjws9p/fr1fGUKTSK2wic5MTExqFOnjs6xAWD37t148uQJ3n77bb6s7MaNG+Hk5MQnx9SnNFVINMG54pTmS2ROTg6EQqHO/9urmj59OrZs2YIOHTrg4sWLGDVqFD7//HPk5eXhyy+/xK5du7Bs2TKEhYWZtV9zi4uLw+XLl9G5c2eTquXk5ORAqVRqVX4piVu3bqFx48Z4+vQp3NzcoFAo4OnpiRMnTqBZs2alOqYhxv7mFGbq76NCoeD/vtWsWbPUr0FJZWZm8oly33jjDbNVNTJVREQEmjRpUuxMD/J6eP78OeRyuc6MDLVajXv37iEwMNBgWy8vL5w4cQJ9+vTBhg0b+BmfL1++hKurK1JTU+Hm5oYnT57ozJDz9vbGsWPH0LJlS1y9ehUNGjTAP//8g8aNG/P7SCQSvW0rkkePHuGDDz5Aamoqfv75Z9SvX9/SQyIVDAU1CCHERH5+ftixYweaN2+uVU4sOjoajRo1Qnp6usG29+/fx4ABA3Dv3j1Uq1YNAPDkyRPUqlUL+/btg7+/v9G+27dvj9q1a2PVqlVwdHTE9evXIRaLMXz4cEyZMqXM6scXF2xp166dwcfef/99rFmzBh06dNAJMAC6U9znz59v8rg0MwKKcnZ2xrJlyzBq1CiTj1VYaYNHGo6OjhgyZAjGjh1rcLpudnY2vv76a4PPASg4iZXJZCaPu0mTJvjkk0/w5ptv4sGDBwgKCsKAAQNw8eJF9OzZ0+xVSIoqr5K/rq6uOHLkCBo3bowXL16gefPmWiVn79y5g3fffdfoVc/KaObMmbh79y7++OMPftuwYcPg4OBgcOkIIaRi6NatG0aOHImzZ8/i1q1b2LJlC2xtbTFt2jTcu3cP69atQ/v27fH8+XODbd999104Ozvj6dOnqFKlCkQiET766CN07doVHTp00Nu2Ihk0aBB27NiB/fv3Y/r06ejVqxe+/vprs5cNJ6+x8k/jQQghr6fClQgKZ/u/du0ac3BwKLa9Wq1mf/31F/v+++/Z999/z44cOWIweVxRjo6OfOZyR0dHdufOHcYYY+fOnWMBAQHFtr9//z47fPgwn2DQ1H5fhVwuZwcOHCjzfgrz9PTUm5jQVO3atWPjx49nKpWK/z+OjY1lbdu2ZXv27DHaNj8/n61YsYKvTFFSSqWSffHFF8zHx0crs/vs2bPZmjVrjLYtiyokz549Y5MnTza6T1RUFGvdurVWJR9NYsOSJFY1VbVq1diuXbsYYwW/d8HBwWbvw9oolUrm5eXFdu7cqbX94MGDzNnZmeXm5lpoZIQQU4SHh7OmTZuy1NRUvvIHx3GsRYsWLDo6mo0bN459+eWXRts+fPiQPXr0SOv28uVLo20t4caNG2z+/Pk6t8KJWjMzM9lnn32mVZ2FEIGlgyqEEPK6CA0NxZ9//snf18w8WLNmjdFkjPn5+RCJRLh9+za6du2KDz/8EB9++CG6dOlicq11sVjMLwXx8PBAbGwsgIKZAU+ePDHYLiUlBZ06dULt2rXRo0cP/mrM2LFjMX36dJP6Pn36NIYPH46WLVvi6dOnAIDNmzcjIiLCaDsXFxe88cYbJvVRVM2aNZGSkqKz/eXLl6hZs6bBdlOmTDG6Tr84165dw/Tp0yEQCCAUCpGbm4tq1arh66+/xqeffmq0rUgkwowZM5CTk1Oqvr/66its2LBB5+pTvXr1sGbNGqNtGWP8LIljx46hR48eAIBq1aoZTfR6+/Zt/PTTT/j111/x8uVLAEBycjKmTp2KmjVr4u+//zba7+jRoyEQCHDgwAFcvnwZV65cwZUrV3D16lWDS4RexaJFizBixAj4+PigXbt2+PLLL83eh7VJTEzEe++9p7N8qVu3bpg2bRri4+MtNDJCiCl69+6Nli1bYsaMGdi+fTsUCgXS0tJw5swZ7Nu3D7GxsQaT/mraLliwAD4+PvDz8+Nva9asMdrWEqKiohAREQFWUKGTvxVma2uLBQsW8LNeCQEAqn5CCCEmWrhwIcLCwnDnzh0olUp8//33uHPnDs6cOWN0mYZYLIavr6/R/BPFCQkJwcWLF1GrVi20a9cOc+bMQXJyMjZv3mw0kdzUqVMhFosRGxuLOnXq8NsHDRqEadOm8ZUgDNmzZw/eeecdDBs2DFeuXEFubi4AIC0tDQsXLsTBgwcNtp03bx7mzp2L9evXlyjZJ1Cwflbf65Wbm4u4uDiD7S5cuIATJ07gwIEDqFu3brF5PIrSFzyqU6dOscEjjaZNm+Lq1avw8/Mrdt+iNm3ahF9//RWdOnXSykTfoEED3L1712jb0lQhCQ8Px1tvvcUnYfz666+xevVqDBw4EI0bN8bevXvRvXt3o/1eu3YNly9fNroe3JyGDRuG7t2748GDB6hVq9YrJ2SsDLy9vTFnzhyd7QKBALNnz7bAiAghJbVs2TKsX78ePXv2RFBQEKRSKW7evIlmzZrhzz//NFghq3DbHj16oG7dupBIJLh58yaaN29ebNvyFhAQAD8/P53lmcV9BhJCOTUIIaQEYmJisHjxYly/fh0KhQKNGjXCxx9/zCdoNGTt2rX4/fffsXnz5lKVKr106RIyMjLQoUMHJCYmYsSIEThz5gxq1aqFdevWoUGDBnrbeXl54a+//kKDBg208oA8ePAA9evXh0KhMNpvSEgIpk6dihEjRmi1v3r1KsLCwoxe5Q0JCUFMTEyJkn2Gh4cDKChluXHjRq0SpSqVCsePH8fRo0cRFRWlt8/Ro0cbfT7Flars2rUrRo0ahaFDh2L8+PG4ceMGPvzwQ2zevBmpqak4f/680fY7d+7ErFmzMHXqVDRu3FgnuaCx5GY2Nja4e/cu/Pz8tF7rO3fuoGnTpkb/r0pThaRp06Zo1aoVvvzyS6xZswbTpk1D3bp1sW7dOpPL9zVp0gTLli3TKlVMCCGk7KSmpkKpVMLd3b1c25YX9v+JyAkpCQpqEEJIOQgJCUF0dDTy8/Ph5+enc7JbFlP1AcDe3h5XrlxBrVq1tE6UL126hG7duuld4lGYra0t7ty5g+rVq+sERYKCgowutSgu8ae+RJmFq60U/XgSi8WoXr06li5dil69ehk9dmmVNnhUdPyFaZ5LcdViGjdujKlTp2L48OFar/UXX3yBo0ePlir5pbEqJI6Ojrh8+TL8/f35sn6HDx9G586dTT7+q5T8JYQQQggxB1p+QgghJaBSqbB3715ERkYCAIKCgtC3b1+IRMb/nPbr168cRqerTZs22LRpE597gOM4qNVqfP311yaVXvTy8kJ0dDSqV6+utT0iIsJobgvAcIUSYzR5IWrUqIGLFy/Czc2txMd4FaGhofzPHh4eOHz4cInaP3z4sNR9z5kzByNHjsTTp0+hVqvx+++/IyoqCps2bcKBAwdMOsbly5e13puNGjUyuG9GRgYfdBAKhbCxsSn2/7QoTQCkU6dOWttNCeIQQgghhJgDzdQghBAT3b59G3369EF8fDwCAgIAAPfu3YO7uzv++OMPo7ktSqNRo0Y4fvw4nJ2dERISYnQ6pqGZHrdu3UKnTp3QqFEjvs797du38eLFC/z777/FJvJctGgRtmzZgnXr1qFLly44ePAgHj9+jKlTp+Lzzz/HBx988ErP0RzM8TppLFiwAMOGDUONGjXMPUyTnD59Gl988YXW8qY5c+aga9euRtslJiZi0KBBOHnyJJ9n4uXLl+jQoQO2b9+ud6qxQCDQWuIzZMgQLF++XCcHR58+fQz2+yolfwkhhBBCzIGCGoQQYqIWLVrA3d0dGzduhLOzM4CC9amjRo1CUlISzpw5U+wxCl9Jr1u3LkJCQgzuO3/+fMycORO2tralWsqhkZaWhp9++knrRHny5Mnw9vYudryMMSxcuBCLFi1CVlYWAEAqlWLGjBl6K0+4uLjg3r17cHNzg7Ozs9EAw4sXL4z2nZmZiZMnTyI2NhZ5eXlaj3344Yf8z+Z6nYCCpJy3bt1Cs2bNMHz4cAwcOLDEs0U2b96MVatW4eHDhzh79iz8/PywfPly1KhRQ6cChbkMGjQIDx48wKZNm/iEsHfu3MHIkSPh7++Pbdu26bTRt1SmKJptQQghhJCKjoIahBBiIhsbG1y6dAl169bV2n7r1i00adIE2dnZBtsmJiZi8ODB+Oeff0y+km4Of//9t8FlJitWrMDkyZNNOk5eXh6io6OhUCgQFBQEmUyGxMRE+Pj4aO23ceNGDB48GFKpFBs3bjR6zJEjRxp87OrVq+jRoweysrKQmZkJFxcXJCcnw9bWFh4eHnjw4IFJ4y6N27dv47fffsP27dsRFxeHLl26YNiwYejXr1+xVVxWrlyJOXPm4KOPPsJXX32FW7duoWbNmtiwYQM2btxYbInU0nJ0dMSxY8d0EnxeuHABXbt25cu1loXTp0/jl19+wYMHD7Br1y5UqVIFmzdvRo0aNSiBKCGEEELKHiOEEGKS+vXrs+PHj+tsP378OKtXr57RtgMHDmShoaHszp07/Lbbt2+z0NBQNnjw4GL7vnDhAjt37pzO9nPnzrGLFy8abOfk5MQuXbqks3358uXM3t6+2H4NuXbtGhMIBKVuX5x27dqx8ePHM5VKxeRyOYuJiWGxsbGsbdu2bM+ePWXWb1ERERFs0qRJzN3d3aTXq06dOmzv3r2MMcaPmzHGbt68yVxdXY225TiOCQQCgzdj5HI5u3r1qs72K1euvNL/c3F2797NbGxs2Lhx45hUKuWf748//sjCwsLKrF9CCCGEEA1KFEoIIUakp6fzPy9atAgffvgh5s2bh+bNmwMAzp07hy+++AJLliwxepzDhw/j2LFj/NIAoCCR44oVK4rNlwAAkydPxv/+9z80a9ZMa/vTp0+xZMkSg6VGv/nmG4SFheHUqVMIDAwEACxduhRffPEF/vzzz2L7LanCr1dxjFXGuHbtGn755RcIBAIIhULk5uaiZs2a+PrrrzFy5EgMGDCA37e4ZS6FFbfkpSg7OzvY2NhAIpEgIyOj2P0fPnyod0mRVCpFZmam0bZ79+7Vup+fn4+rV69i48aNxS6r6dixI6ZMmYJt27bxs2eePn2KqVOn6iTx1Pjhhx/0bnd0dETt2rXRokULo30CBTlIVq1ahREjRmD79u389latWmHBggXFtieEEEIIeVUU1CCEECOcnJy0TpgZYxg4cCC/jf3/Cr7evXsbzT2gVqv1ltUUi8V8xQ9j7ty5o7eSRUhICO7cuWOw3bhx4/DixQt07twZERER2LFjBxYuXIiDBw+iVatWxfZbUkVfL32YCZUxxGIxn/PBw8MDsbGxqFOnDhwdHfHkyROtfZcvX/7K4y7s4cOH2Lp1K7Zu3YqoqCi0a9cO8+fPx1tvvVVs2xo1auDatWvw8/PT2n748GGtgJY++vJtvPXWW6hbty527NiBsWPHGmz7008/oU+fPqhevTqqVasGAHjy5Anq1auHLVu26G2zbNkyvdtfvnyJtLQ0tGzZEuHh4XBxcTHYb1RUFNq2bauz3dHRsUyXvBBCCCGEaFBQgxBCjDBXDoTSXEkvTCqVIiEhQafk5vPnz4stJ/u///0PKSkpCA0NhUqlwl9//cXPNDE3c71eISEhuHjxImrVqoV27dphzpw5SE5OxubNm3WqzBjLzVFSzZs3x8WLF1G/fn2MHj0aQ4YMQZUqVUxuP23aNEyePBk5OTlgjOHChQvYtm0bFi1ahDVr1pR6TBMmTDC6T7Vq1XDlyhUcO3YMd+/eBQDUqVOHL7mqj7Hysw8ePMDw4cMxe/Zs/Pzzzwb3e5WSv4QQQggh5kCJQgkhpBw8efKEL6da9Ep6eHg4qlatarT9kCFD8Pz5c+zfv58vwfny5Uv069cPHh4e2LlzJ7+voWUF3377Ldq2bYumTZvy2wpXESnsxo0bRsdz9+5dDBkypMwqY1y6dAkZGRno0KEDEhMTMWLECJw5cwa1atXCunXr0KBBA4NtY2JisH79esTExOD777+Hh4cHDh06BF9fX50kr0V99tlnGDZsGIKCgko99t9++w3z5s1DTEwMAMDHxwfz5883OtPCkOzsbMyaNQuHDh1CVFRUqcdUGqdOncKYMWMQHR1tcJ/XoeQvIYQQQqwbBTUIIaSEsrKy9JYZrV+/vtF2jLESXUkv7OnTp2jbti1SUlL4nA3Xrl2Dp6cnjh49ygdKgIIlEKbgOM5gFRGBQACO46DvI0Kz3ZRyn6WpjMEYQ3R0NPLy8hAQEFDsTJTCTp48ibCwMLRq1QqnTp1CZGQkatasicWLF+PSpUvYvXu3yccyxsHBAdeuXTM6GyErKwsKhQIeHh4mHbNobhDGGDIyMmBra4stW7agT58+Om0MBbCKMhS8MubRo0eoV68eFAqFwX1YCUv+EkIIIYSYGwU1CCHERElJSRg9ejQOHTqk93FjJ/g5OTmQyWSv1H9mZiZ+++03XL9+HTY2Nqhfvz6GDBmiN1fHq3r8+LFJ+xXNHVHYnj178M4772DYsGHYvHkz7ty5g5o1a+Knn37CwYMHcfDgQZ02Dx8+RJ8+ffg8IVWrVsWePXsQGhpq0nhatGiBt99+G9OmTYO9vT2uX7+OmjVr4sKFCxgwYADi4uJMOk5xCh/bXDZs2KAV1BAIBHB3d0ezZs3g7Oyst03RANaTJ0/g7e2tFQgyFrwy5o8//sAnn3yC27dvG9wnPz8fYrFYp+SvXC5HcnIy3NzcStwvIYQQQkhJUFCDEEJMNGzYMDx+/BjLly9H+/btsXfvXiQkJGDBggVYunQpevbsabCtTCZD06ZN0a5dO3To0AEtWrSAjY1NOY7+v6SmplYKeVUhISGYOnUqRowYoRUEuHr1KsLCwhAfH6/T5q233sLt27cxZ84cyGQyfPvtt8jJycHly5dN6lMul+PmzZuoUaOGVp+PHj1CYGAgcnJyzPLcDAU1atSoYfT1LU1wwRzj0sdQpZq0tDRcvnwZ06dPx8iRIzFnzhyDx3jzzTexe/duneeckJCATp064datWyV7AoQQQgghJUSJQgkhxEQnTpzA/v37ERoaCoFAAD8/P3Tp0gUODg5YtGiR0aDGsWPHcOrUKfzzzz9YtmwZlEolQkND0a5dO7Rv3x5dunQptv/NmzfzSznOnj0LPz8/LFu2DDVr1tRbOUNj06ZN+Oabb3D//n0AQO3atTFz5ky88847Jj3vly9f4sKFC0hMTNSp1DJixAiD7UpTGSMiIgK7d+/ml6Y0b94cVatWRWZmJuzs7Iodq5OTE54/f64zg+Hq1aslSvhZWh999JHWfU1Z1sOHD2PmzJk6+xeXu6Sw4pY3lZSxSjUcx2HcuHH45JNPjB4jNjYW48aNw9q1a/ltz58/R8eOHYvNX0IIIYQQYg4U1CCEEBNlZmby+RGcnZ2RlJSE2rVrIzg4GFeuXDHatnXr1mjdujU+/fRTKJVKXLx4Eb/88gu+/vprLF68uNjcFCtXrsScOXPw0UcfYcGCBfz+zs7OWL58ucGgxnfffYfPP/8c77//Pl/CNSIiAhMnTkRycjKmTp1qtN8//vgDw4YNg0KhgIODg9ZJMMdxRoMapamMkZiYiFq1avH3vb29YWNjg8TERJNyhQwePBgff/wxdu3aBY7joFar8e+//2LGjBlGx2ouU6ZM0bt9xYoVuHTpks72hg0bGsxdUpgp+UtKylClGgcHB9SqVQtyubzYYxw8eBBt27bFtGnT8N133+HZs2fo0KEDGjRogO3bt5t1vIQQQggh+lBQgxBCTBQQEICoqChUr14dDRo0wC+//ILq1atj1apV8Pb2Lrb9vXv38M8///C33Nxc9OrVC+3bty+27Y8//ojVq1ejX79+WLx4Mb89NDQUM2bMMNpu5cqVWif0ffr0Qd26dTFv3rxigxrTp0/HmDFjsHDhQtja2hY7zsLGjx+PKVOmYN26deA4Ds+ePcPZs2cxY8YMfP7553rbcBwHhUKhtTRHIBAgIyNDa7mEg4OD3vYLFy7E5MmTUa1aNahUKgQFBUGlUmHo0KGYPXt2icZvTEmX8ISFhWHWrFlYv3691nZjZVXLWrt27Uq0/6RJk/DFF19o5clwd3fHkSNH+Jk1Bw4cQKNGjfDbb79BIBCYdbyEEEIIIfpQTg1CCDHRli1boFQqMWrUKFy+fBndu3dHSkoKJBIJNm7ciEGDBhlsW6VKFWRnZ6N9+/Zo37492rVrh/r165t8cmxjY4O7d+/Cz89PK2/C/fv3Ub9+fWRnZ+ttJ5PJcOvWLfj7+2ttv3//PoKDg4vNMWFnZ4ebN2+WKiFmaSpjaKquFD2OZpupVVdiY2Nx69YtKBQKhISEaM3+MIeSJgr9+uuv8fPPP+PRo0dmHUfRvBhVq1ZFRESEzuwYQ0GgkjBW8eXevXto06YNunTpgs2bN5db3hZCCCGEEJqpQQghJho+fDj/c+PGjfH48WPcvXsXvr6+xVZ5cHd3x927dxEfH4/4+HgkJCQgOzvb5NkPNWrUwLVr13SqjRw+fBh16tQx2M7f3x87d+7Ep59+qrV9x44dJp3od+vWDZcuXSpVUIPjOHz22WeYOXOmTmUMQwwtiSgpX19f+Pr6muVY+hw6dEhvjo6QkBCdsqzx8fFISkrCzz//bNKx79y5o7dksL6SrkXzYjDG+JK/mvvmWrqiuQZStPSsRlZWFv744w+4urry2168ePHK/RJCCCGEGENBDUIIMWLatGkm7/vdd98ZfOzatWt4+fIlTp06hZMnT+LTTz/FnTt30LBhQ3To0AFfffVVseOYPHkycnJywBjDhQsXsG3bNixatAhr1qwx2G7+/PkYNGgQTp06xefU+Pfff3H8+HHs3Lmz2OfUs2dPzJw5E3fu3EFwcLBO+Vh9J9pFSSQSBAUFFbsfUPIlEYsXL8aTJ08glUpN2t/Y/xFQUJZ3w4YNOH78uN7EqCdOnAAAfrlFUf369dO6rynL2r59ewQGBhrt+8GDB+jfvz9u3ryplWdDE0DQF5gwVxCoJJYvX17ufRJCCCGEGELLTwghxIgOHTqYtB/HcfwJb3FSUlLwzz//YP/+/di2bRvUarVJV9J/++03zJs3DzExMQAAHx8fzJ8/H2PHjjXa7vLly1i2bBkiIyMBAHXq1MH06dO1rugbYiwvgr4ZAAMGDCj2mBq///67yfsa4uDggKCgIK0cHFeuXIFSqURAQACAgqURQqEQjRs3Lvb/6P3338eGDRvQs2dPeHt768xIWLZs2SuP2ZDevXtDKBRizZo1qFGjBi5cuICUlBRMnz4d3377Ldq0afPKfSxevBgTJ06Ek5NTiduWdMkNIYQQQkh5oKAGIYSUg99//51PEHrnzh24uLigdevWfH6NBg0amHysrKwsKBQKvhJLRTJ69Gj+Z8YY9u7dC0dHR4SGhgIoCLC8fPkSAwYM0EmaWRpFT7S/++47/PPPP9i4cSOcnZ0BAKmpqRg9ejTatGmD6dOnGz2em5sbNm3a9H/t3XdUVFfXBvBnhqKCVAUrAiKiIFYssUYjFoyoaCxYEOxGICC+aBKNvQbFEnvv3dgVRUTFWCliLCiKoAE70iyU+f5wMZ/jNOrMkDy/tbKWc+499+4ZWIvcPefsDRcXlyLF8+zZMxw4cABxcXHQ1dWFnZ0d+vfvL45F2b3PnTuHhg0bwsjICNeuXYOdnR3OnTuHiRMnIioqqkgxfUlRXQxl5CU1cnNz8eeff4qTZg4ODnB1dYWWllax4yUiIiJShttPiIhUYOzYsWjfvj1Gjx6NDh06wNHRsUjXefHiBe7fvw/g80oJMzMzhedraWkhOTlZKgHy+vVrmJubF6rWwocPH1C+fHmF53yZqAgMDET//v2xevVq8QNubm4uxo8fXyKFK2UJCgpCSEiIRBLBxMQEs2fPRpcuXZQmNXR1daWKqhbUypUr4e/vj0+fPonfX1paGvz9/bF+/XoMGjQIIpEI0dHRMlfJ5ObmwsDAAMDnBMc///wDOzs7WFpain/mxVXS32M8fPgQLi4uePbsmXhlzLx582BhYYHjx4/DxsamRO9HRERE9DX2WyMiUoEXL15g//79mDBhQpESGunp6Rg6dCiqV6+ODh06oEOHDqhevTqGDBmCd+/eyZ0n7yH248eP0NXVVXrf3NxczJo1CzVq1EDFihXx6NEjAMDUqVOxYcMGhXM3btyIgIAAiW/stbS04O/vj40bNyq9d1GkpaXh5cuXUuMvX75Eenq60vkTJ07E0qVLC/3wf/z4cfj4+GDChAl49uwZUlNTkZqaimfPnmHMmDHw8PDApUuXMHjwYBw9elTmNRo0aICYmBgAQMuWLbFw4UJERERg5syZGrHlY8iQIVLJKB8fH9jY2CApKQmRkZGIjIxEYmIirK2t4ePjo6ZIiYiI6L+EKzWIiFSgQ4cOGDFiBH744QeJ+g8FNXLkSERFReH48eP45ptvAAB//fUXfH19MWbMGOzevVvi/GXLlgH4vJpj/fr1Eh1HcnNzceHCBaWFKwFgzpw52LJlCxYuXIhRo0aJxxs0aIDg4GCF9TxycnJw79498Tf4+e7duydVgLOk9OnTB56enggKCkKLFi0AAFevXsWkSZMKVO/j0qVLCAsLw8mTJ+Hg4CBVGFVeHZBFixZh8uTJmD17tsR4tWrVsHjxYujp6cHZ2RlVq1bFvHnzZF7j119/RWZmJgBg5syZ+P7779GuXTtUqlQJe/bsURp7caSmpuLatWsyi6MOGzYMALBq1SqpeeHh4bhy5QpMTU3FY5UqVcL8+fPFhWmJiIiIShOTGkREKtCkSRMEBATA29sb/fv3x4gRI9CqVasCzz927BhOnz4t0XWja9euWLduHbp16yZ1fn5BS5FIJLH9A/i8xcLKygqrV69Wet+tW7di7dq1+O677zB27FjxeKNGjXDv3j2Fcz09PTFixAjEx8dLJBjmz58vUXujJK1evRoBAQFwd3dHdnY2AEBbWxsjRozAokWLlM43NjZGnz59Cn3fyMhIrFmzRu7xoUOHYu7cuQgPD5dqNevk5ISRI0fC3d1dvBKiTp06uHfvHt68eSO3hWpJOXr0KAYPHoyMjAwYGhpK3EsgEIiTGrKUK1dO5gqYjIyMAq0EIiIiIio2ERERqUR2drbowIEDIldXV5GOjo6ofv36okWLFolSUlKUzrWwsBDdunVLajwmJkZUo0YNufO+/fZb0Zs3b4occ/ny5UUJCQkikUgkqlixoig+Pl4kEolEf//9t0hfX1/h3NzcXNGCBQtE1atXFwkEApFAIBBVr15dtGDBAlFOTk6RY/pS9+7dRf/884/UeEZGhigmJkYUExMjysjIkDqelJQkys3NLfJ9L126JPrw4YP4tZ6envizkSU+Pl6kp6cn85iXl5fIwMBApKenJxo6dKgoLCysyHEp8+XPMJ+tra3I19dXlJmZWeDrhIeHiz59+iQaOnSoyMHBQXTlyhVRXl6eKC8vT/TXX3+JGjRoIPLw8Cjh6ImIiIiksfsJEZEavHjxAmvXrsWcOXOQm5sLFxcX+Pj4oFOnTjLPX7t2Lfbt24dt27ahatWqAICUlBR4eHjAzc0NY8aMKVY88rpiNGvWDH5+fhgyZIhE94uZM2fizJkzuHjxYoGun5aWJr7P1yIiIuDk5IRy5cpJjOfl5eHhw4cyt0S0b9++MG9PSnG6gMia36JFCwwaNAh+fn4yz1+8eDF2796Na9euyTyelZWFvXv3YvPmzbh48SKsra3h5eUFDw8P1KhRo0gxyuLi4oINGzagWrVq4jF9fX3ExsYW6rPIL0Crq6sLDw8PHD16VLxVJycnB66urti8eTOMjIxKLHYiIiIiWbj9hIhIxa5du4ZNmzZh9+7dMDc3x/Dhw/Hs2TN8//33GD9+PH7//XepOatWrcLDhw9Rq1Yt8faFxMRElCtXDi9fvpTY+hAZGVnomOTlt6dNmwYPDw88e/YMeXl5OHjwIO7fv4+tW7fi2LFjBb6+om4n3bt3l0owXLlyBe7u7njy5IlUbAKBoFBdW2Qpbj7/6/k//vgjxo0bh3LlymH06NHQ1v785zUnJwdr1qzBr7/+ipUrV8q9np6eHoYPH47hw4cjPj4emzZtwpo1a/Dbb7+hS5cuGDFihNKaIAVJAp04cUJqXteuXXHjxo1CJTXy37+xsTEOHz6MBw8eiLcj1a9fv8gdZIiIiIgKiys1iIhU4MWLF9i2bRs2bdqEBw8eoGfPnhg5ciS6du0qrmFw6dIldOvWDRkZGVLzZ8yYUeB7/fbbb4WO78tVGF+7ePEiZs6ciZiYGGRkZKBp06aYNm0aunTpUuj7FPTejRs3Rt26dTFjxgxUq1ZNqqZEcVcAKHq/RZ0fEBCAxYsXw8DAADY2NhCJRHj06BEyMjLg4+MjrnNSUCKRCAcOHMCYMWOQmpqqMJFTnCTQhg0bMHPmTHh6esLR0VGqOKqrq6vUHKFQiOfPnyttKUxERERU2pjUICJSAV1dXdjY2MDLywvDhw+X+TCYlpaGXr16ISwsTOXxyXvIf/r0KWrWrClzzpUrVwpV7LQw99bX10dMTEypfeNfGkkN4PNnsmvXLjx48AAAYGtri0GDBhX6czp//jw2bdqEAwcOQFtbGwMHDlRY2LU4SSChUH53d3kJEaFQiO7du0ttGfqavG4xRERERCWF20+IiFQgNDQU7dq1U3iOoaGh3IRGUlISBAKBOMFw7do17Ny5E/b29hg9enSJx5uvS5cuuHTpkkTLTuBzHYwePXogNTW1VO7bsmVLPHz4sMxtY2jVqlWBEhjjx4/HzJkzUblyZfHY06dPsXnzZmzevBmPHj1Cu3btsHLlygK1AX7w4AH2799fpM+rqO11DQwMitSemIiIiKgkMalBRKQC7dq1Q05ODs6fP4/4+Hi4u7vDwMAA//zzDwwNDVGxYkWF893d3TF69GgMHToUKSkp6Ny5Mxo0aIAdO3YgJSUF06ZNK1Z88lqGtmrVCl26dEFYWBgMDAwAABcuXEDPnj0xffr0Yt1TEW9vb0ycOBEpKSkyt0Q0bNiwWNcvbovU4s7fvn07AgICULlyZezduxcbN25EaGgozM3N4eHhAS8vr0IlKNSRBFq2bBnMzc1Vdj8iIiIiWZjUICJSgSdPnqBbt25ITEzEx48f4ezsDAMDAyxYsAAfP35UuLUAAG7fvo0WLVoAAPbu3QtHR0dEREQgJCQEY8eOLXZSQ95OxPXr16Nfv37o2bMnTp8+jcuXL8PV1RWzZ8+Gr69vse6ZT1aCoG/fvgAALy8vifNEIpFGFgotzvwhQ4agR48eOHToEFxcXBRuB5GnKEmgZcuWFejaPj4+UmPFTeoQERERlRQmNYiIVMDX1xdOTk6IiYlBpUqVxON9+vTBqFGjlM7Pzs4W1y84e/asuHhjvXr1kJycXOz4Tp48KbN1qFAoxO7du9GjRw906tQJt27dwrx58zBhwoRi3zOfrATB48ePS+z6sty5cwfVq1eXGv/tt9/g5eUFS0tLhfPT09NLLJanT58We8VDUZJABSlcKhAIZCY1WI6LiIiINAULhRIRqUClSpVw+fJl2NnZSRSZTEhIgL29PbKyshTOb9myJTp27IgePXqgS5cuuHLlCho1aoQrV66gX79+ePr0qcx5ubm52Lx5M0JDQ2W2+jx37pzUnFu3bkmNpaenY9CgQejRowfGjRsnHle0DeTevXuoV6+ezGOnT59G165d5c4tqszMTMyfP1/u+3306JHC+Y0bN8bt27fRoUMHjBgxAn379lVaDLMo5BUaffDgAcLCwmTGrmg1zpMnTxTeT1mSpjBMTU2xdu1a9OrVC2PGjMHSpUvFW5OIiIiIVI1JDSIiFTAxMUFERATs7e0lHmgvXbqEvn374vnz5wrnnz9/Hn369EFaWho8PDywceNGAMDPP/+Me/fuye0yMWHCBGzevBk9evSQ2RVD1rf1QqFQ/C1/vi9fF3QbiJ6eHhYtWoQff/xRPPbx40dMnDgR69evx4cPH6TmHDlyRMGn8P9ktRkFgEGDBiE8PBxDhw6V+X4LsmUmKioKmzZtwq5du5CTk4OBAwfCy8sLzZs3L1BsBSErqbFu3TqMGzcOlStXRtWqVSViFwgEiIyMLLH7F4WjoyNOnDiB+vXr49atW6hduza0tLSQkpLC1q5ERESkNkxqEBGpwIABA2BkZIS1a9fCwMAAt27dgpmZGXr16oVatWph06ZNSq+Rm5uLtLQ0mJiYiMcSEhKgp6cn3r4QEREBJycn8eqCypUrY+vWrXBxcSlwrMq+9f+SohUAe/fuxbhx49CyZUts2rQJycnJcHd3R15eHrZt2yYzSVCQehKKkinGxsY4fvw42rRpU+D3IE92djaOHj2KTZs24fTp06hXrx5GjBiB4cOHK2yRWhCykhqWlpYYP348AgMDC3yd4iaBCiM/5jFjxuD58+do1qwZtmzZggEDBsjtgpKffCMiIiIqLaypQUSkAkFBQejatSvs7e3x4cMHuLu748GDB6hcuTJ27dpVoGtoaWlJJDQAwMrKSuJ19+7dER0dLX5Y1tXVLXRHjJLaqtC/f3+0bt0anp6ecHBwQGZmJoYPH46goCDo6enJnFPU9qL5TExMpNrPFpVIJEJ2djY+ffoEkUgEExMTrFixAlOnTsW6deswYMCAIl97yJAhMDQ0lBh7+/Ytfvjhh0Jdp3fv3krPKYnCql/avn07lixZgvj4eAgEArx7907mqhsiIiIiVeBKDSIiFcnJycGePXsQExODjIwMNG3aFIMHD5b7LXdRfL0CICgoCI8ePcKKFSuK3LEiPj4ewcHBuHv3LgDA3t4evr6+sLGxUTr36dOnGDx4MG7duoXMzEz8+uuv+PXXX4vU4UOWHj16YP369ahWrRqAzw/chw8fxpYtW+QmTpS5efOmePtJuXLlMGzYMIwcOVKcHFq+fDlmz54td8tQamoqrl27JrMuxrBhw+Ted8SIEWjevDnGjh1bpLhLm6zVJdbW1rhx44ZE8VsiIiIiVWJSg4hIBXbt2oVBgwbJPDZp0iQsWrSoRO7z9YNnnz59EBYWBlNTUzg4OEi1+pRXiyPf6dOn4erqisaNG4u3dERERCAmJgZHjx6Fs7Oz3Lm7d+/GuHHj0K5dO2zYsAHR0dHw9PSEpaUltm3bJlUksyi+fr9NmjRBfHw8RCIRrKyspN6vsroUjo6OuHfvHrp06YJRo0ahZ8+e0NLSkjjn1atXMDc3l7mq5OjRoxg8eDAyMjJgaGgoVRfjzZs3cu89b948LF68GD169JDZllVWF5LC+joJVBjyipsSERERqROTGkREKmBsbIxdu3ahe/fuEuN+fn7YvXt3ibRlBaQfPD09PRWer6yWR5MmTdC1a1fMnz9fYnzy5MkICQlRmCTQ19fH77//LtEt5e3btxgzZgxOnTqFtLQ0ZW9Hqa/f74wZMxSe/9tvvyk8PmvWLHh5eclsb1sQdevWhYuLC+bOnVvolSLW1tZyjwkEAqWdWwqiOImJr+fm5ORgyZIl2LVrF+Li4gB8fv/u7u7w9fWVSsoQERERlQYmNYiIVOD48eMYPHgwjh07hrZt2wIAvL29cfDgQYSGhsptfVpYRX1o/brAaL7y5csjNjYWtra2EuNxcXFo2LChwloK9+/fh52dncxj27Ztw9ChQwsVoyxFfb+7du2Cq6sr9PX1xWPZ2dmoV68ejh07hvr16xcpHn19fcTGxmrsaoaSSmq8f/8ezs7O+Ouvv9C5c2fx53X37l2cPXsWbdq0QUhICMqXL1/Sb4GIiIhIQslsaiYiIoV69OiBlStXwtXVFTdv3sT48eNx8OBBhIWFlVhCA0CR62Z0794dz549kxo3MzNDdHS01Hh0dLS444o88hIaAEokoVEc+R08vqSjo1Psgpddu3bFjRs3inUNTbVmzRpUqVIFADB//nwkJSUhKioKp0+fRnBwMIKDg3H69GlERkbiyZMnUqt7iIiIiEoDu58QEamIu7s7UlNT0aZNG5iZmSE8PLzQnUmUKeriu6/nzZw5EwEBARg1ahRGjx6NR48eoXXr1gA+r+pYsGAB/P39lV736dOnOHLkCBITE/Hp0yeJY4sXLy5SrCVB3uf0448/YsGCBVi/fj20tQv/J7JHjx6YNGkS7ty5I7MuhqzWqgX5HIHS/bxCQ0MRGhoqs7hpfltWd3d38dju3buxePFiNGzYUOpajRo1wu+//45ffvkF06dPL7WYiYiIiABuPyEiKjXyHlb37duHpk2bSnQPKegD64sXL3D//n0An1dCKFstUVBfb0vQ0tJCcnIyzMzMEBwcjKCgIPzzzz8AgOrVq2PSpEnw8fFRuDIkNDQUrq6uqF27Nu7du4cGDRogISEBIpEITZs2xblz50o87uLO69OnD0JDQ1GxYkU4OjpKbE8BlBdWVdTVRV5r1Y4dOyqNVyAQlNrnNWPGDMycORNOTk6oVq2a1M/00KFDUtcpX748Hjx4AAsLC5n3SUpKgq2tLVu9EhERUanjSg0iolISFRUlc7xOnTpIS0sTHy/IlpH09HSMHz8eu3fvFj8Ya2lpYcCAAfjjjz9gZGRUcoHj/1cyCAQC+Pn5wc/PD+np6QA+PxgXxJQpUxAQEIAZM2bAwMAABw4cgLm5OQYPHoxu3bqVSJw///wzTE1NS+RawOeCrn379i3yfFkdUZQJCwsr8v1KwurVq7F58+ZCbQkyNDTEixcv5CY1UlJSCvx7QkRERFQcXKlBRKRBnj59iurVq0t94z9gwABERUVh+fLl+OabbwAAf/31F3x9fdG4cWPs3r27WPf9+ht8oVCI58+fw8zMrFjXjI6Oho2NDUxMTHDp0iU4ODggJiYGvXr1QkJCgsL5Dx48QFhYmMwtEdOmTStyXPmxaXp70tzcXMTGxsLS0hImJiYKz71w4QJat24ttWUmJycHly9fRvv27QF8bhs7btw4GBsbi8+pVKkSrl27JrFySJkBAwYgJycHBw4ckHm8b9++0NLSwt69ewt8TSIiIqKiYFKDiEiDGBoaIjo6WuphW19fH6dPnxZ3Tsl38eJFdOvWDZmZmSV6X6FQCCMjI6WrSN68eSP3WNWqVREWFob69evD3t4e8+fPh6urK2JiYtCmTRtkZGTInbtu3TqMGzcOlStXRtWqVSXiEAgEClvJFoSipEZOTg7Onz+P+Ph4uLu7w8DAAP/88w8MDQ1RsWJFmddbtmxZge7r4+Mj99hPP/0ER0dHjBgxArm5uWjfvj3++usv6Onp4dixY/j222/lzs3fLvT1dqTXr1/D3Nxc5raXfIGBgahYsSKmTp1aoPcAAHfu3EHLli3h4OAAf39/1KtXDyKRCHfv3sWSJUtw584dXLlyBQ4ODgW+JhEREVFRcPsJEZEGkZdnrlSpkswtJkZGRkq/xS/qfWfMmFGsbS2tWrXCpUuXUL9+fbi4uGDixImIjY3FwYMH0apVK4VzZ8+ejTlz5iAwMLDI91fE0tJSqognADx58gTdunVDYmIiPn78CGdnZxgYGGDBggX4+PEjVq9eLfN6S5YsUXpPgUCgMKmxf/9+DBkyBABw9OhRJCQk4N69e9i2bRt++eUXREREyJ0rEolkJqBev34tVRfkax8+fMDatWtx9uxZNGzYUOpzkVXvxd7eHmfOnMGIESMwcOBA8b1FIhHq1auHkJAQJjSIiIhIJbhSg4hIg8hbQbB27Vrs27cP27ZtQ9WqVQF8rlvg4eEBNzc3jBkzpkTjEAqFSElJKVYh0kePHiEjIwMNGzZEZmYmJk6ciMuXL8PW1haLFy+GpaWl3LnyVqwURGpqKvbv34/4+HhMmjQJpqamiIyMRJUqVVCjRg2Fc3v37g0DAwNs2LABlSpVEv8szp8/j1GjRuHBgweFjqegypcvj4cPH6JmzZoYPXo09PT0EBwcjMePH6NRo0ZIS0uTmuPm5gYAOHz4MLp164Zy5cqJj+Xm5uLWrVuws7PDqVOn5N5XUaHSghQojY6ORlxcHACgbt26aNy4scLziYiIiEoSV2oQEZUBq1atwsOHD1GrVi3UqlULAJCYmIhy5crh5cuXWLNmjfjcL7dmPH/+HAEBAeJ2nV/nseVtSyhI8VJlvkxI6Ovry13lIMsPP/yAkJAQjB07tlD3vHXrFjp37gwjIyMkJCRg1KhRMDU1xcGDB5GYmIitW7cqnH/x4kVcvnwZurq6EuNWVlZ49uxZoWJRxNHRESdOnJAotFmlShXcuXMH1apVw6lTp7Bq1SoAQFZWFrS0tGReJ38ljUgkgoGBASpUqCA+pquri1atWmHUqFEKYyluodLGjRszkUFERERqw6QGEVEZ0Lt37yLNGz58OBITEzF16lSZ7TrlKelFfBkZGVLFPg0NDeWeX6dOHUydOhVXrlyBo6Oj1JYIeds4/P39MXz4cCxcuFCi+4aLiwvc3d2VxpmXlycz0fP06dMS7eaRkJCA7OxsiTFPT0/0799f/HPq3LkzAODq1auoV6+ezOts2rQJwOekS0BAgNKtJiVNJBJh//79cgu6KmuBS0RERFRc3H5CRKRBirPtQhYDAwNcvHixyN+ke3l5YenSpVIP9JmZmfD29sbGjRvlzn38+DEmTJiA8+fP48OHD+Lx/PoPiopXWltbyz0mEAjw6NEjmceMjIwQGRkJGxsbia08T548gZ2dnUQcsgwYMABGRkZYu3YtDAwMcOvWLZiZmaFXr16oVauWOIlQXPK2GR04cACJiYn44YcfULNmTQDAli1bYGxsjF69epXIvb/Wp08fmckugUCA8uXLo06dOnB3d4ednZ3UOb6+vlizZg06duyIKlWqSF2npD4vIiIiInmY1CAi0iDKWo3evHkTd+/eBQA4ODigSZMmCq9nb2+PHTt2KD1PHnldNV69eoWqVasiJydH7tw2bdpAJBLB19dX5gNvhw4dihSTIubm5jh9+jSaNGki8VmeOXMGXl5eSEpKUjj/6dOn6Nq1K0QiER48eAAnJyc8ePAAlStXxoULF4pVY+RLX/+cs7Oz0a1bN6xevRq2trYFukbTpk0RGhoKExMTNGnSROEqHEXdYoYPH44///wTxsbGaNasmfj81NRUdOnSBTExMUhISEBoaCjatGkjMdfU1BTbt2+Hi4tLgWImIiIiKmncfkJEpAZpaWk4d+4c7OzsUL9+ffH4nTt3UL16danzX7x4gYEDB+L8+fMwNjYG8LkgZseOHbF7926YmZnJvE9wcDAmT56MNWvWwMrKqlDxiUQiiEQipKeno3z58uJjubm5OHHihNIH/JiYGNy8eVPmN/yFkZ97L8jWGVdXV8ycORN79+4Vz0lMTERgYCD69u2rdH7NmjURExOD3bt349atW8jIyMCIESMwePBgiXoVJU1HRwe3bt0q1JxevXqJC4MWdXsS8Ln1rru7O1asWAGhUAjg8zYcX19fGBgYYPfu3Rg7diwCAwNx6dIliblGRkYltqqIiIiIqCi4UoOISAX69++P9u3bY8KECXj//j0aNWqEhIQEiEQi7N69W+kD94ABA/Do0SNs3bpVnAS5c+cOPDw8UKdOHezatUvmPBMTE2RlZSEnJwd6enpStSnevHkjc55QKFSYRBAIBJgxYwZ++eUXued07NgRv/zyi7g2RGFt3boVixYtEnccqVu3LiZNmoShQ4fKnfPu3Tv069cPN27cQHp6OqpXr46UlBR88803OHHihMprTsgja0WOn58fypUrh/nz56s0FjMzM0RERKBu3boS43FxcWjdujVevXqF2NhYtGvXDqmpqRLnbNmyBadOncLGjRtLNelDREREJA9XahARqcCFCxfECYBDhw5BJBIhNTUVW7ZswezZs5UmNU6dOoWzZ89KrOqwt7fHH3/8gS5dusidFxwcXKR4w8LCIBKJ0KlTJxw4cACmpqbiY7q6urC0tJS5ouRL69evx9ixY/Hs2TM0aNBAKqHSsGFDuXMXL16MqVOnYsKECeItD5cuXcLYsWPx6tUr+Pn5yZxnZGSEM2fO4NKlS+KVFk2bNi1wYkVZd5Rhw4YV6DpFkZOTg40bN+Ls2bNo1qyZVAJm8eLFpXbfe/fuSSU17t27J657Ur58eZlJrv79+2PXrl0wNzeHlZWV1M9Y0bYXIiIiopLApAYRkQq8e/dOnBg4deoU+vbtCz09PfTo0QOTJk1SOj8vL0/qgRH4vG3h644TX/Lw8ChSvPn1Lh4/foxatWoVqcXry5cvER8fD09PT/GYQCAoUKHQ5cuXY9WqVRJJBFdXVzg4OGD69Olykxr52rZti7Zt2xY6Zl9fX4nX2dnZyMrKgq6uLvT09IqU1EhNTRVvGcq3Zs0aVKlSRWLs9u3baNq0KYDPqyS+pOzzNzExUVrsc/jw4RI/i3xDhw7FiBEj8PPPP6N58+YAgOvXr2Pu3Lni9xseHg4HBwepuR4eHrh58yaGDBkis24KERERUWljUoOISAUsLCzw119/wdTUFKdOncLu3bsBAG/fvpWoVyFPp06d4Ovri127dolXSDx79gx+fn747rvvJM5NS0sTt0tNS0tTeF1FbVUB4O7du0hKShInCP744w+sW7dOvErExMRE7lwvLy80adIEu3btKvQDb3JyMlq3bi013rp1ayQnJ0uMLVu2rMDXldcKNt/bt2+lxh48eIBx48YVKPm0YMECWFlZYcCAAQA+r2Q4cOAAqlatihMnTqBRo0YAILO9bFhYWEHegkzTpk3DnDlz0L17d7Ro0QIAcO3aNZw6dQo//vgjHj9+jHHjxiEnJwejRo2SmLtkyRJUqVIFCxcuxPPnzwEAVapUgZ+fHwIDAwEAXbp0Qbdu3aTue/z4cZw+fbpICSQiIiKiksCaGkREKrBy5Ur4+vqiYsWKsLS0RGRkJIRCIZYvX46DBw8qfaBNSkqCq6sr/v77b1hYWIjHGjRogCNHjojbfwKSHUvk1cYoyGoJAHB0dMSCBQvg4uKC2NhYODk5YeLEiQgLC0O9evUUtuzU19dHTEwM6tSpo/AesjRo0ADu7u74+eefJcZnz56NPXv2IDY2VjymqP3rlxS1glXmxo0bGDJkCO7du6fwPGtra+zYsQOtW7fGmTNn0L9/f+zZswd79+5FYmIiQkJClN7r4cOHiI+PR/v27VGhQgXxz0qRvn37wtnZGWPHjpUYX7NmDUJCQnDgwAEsX74ca9eulfjsvpafBFOW7MpXr1497N27V+FWIiIiIqLSxKQGEZGK3LhxA0lJSXB2dkbFihUBfP6m29jYWKpVpiwikQhnz54VP1jXr19fZq2I8PBwtGnTBtra2ggPD1d4TWVtVStWrIjbt2/DysoK06dPx+3bt7F//35ERkbCxcUFKSkpcuf27NkTw4cPL1DXka8dOHAAAwYMQOfOncWfTUREBEJDQ7F371706dOn0NcsjujoaLRv317pypcKFSogLi4OFhYW8PX1xYcPH7BmzRrExcWhZcuWMleC5Hv9+jX69++PsLAwCAQCPHjwALVr14aXlxdMTEwQFBQkd27FihURHR0tlUB6+PAhGjdujIyMDMTHx6Nhw4bIzMws3JtX4Pjx41i+fDlWr15dqO46RERERCWF20+IiFTEyckJTk5OEmM9evRQOi87OxsVKlRAdHQ0nJ2d4ezsrPD8LxMVypIWyujq6iIrKwsAcPbsWXGNBVNTU6UP+D179oSfnx9iY2Ph6OgoVRPE1dVV7ty+ffvi6tWrWLJkCf78808An5M4165dQ5MmTYrxjhQ7cuSIxGuRSITk5GSsWLGiQIknExMTJCUlwcLCAqdOncLs2bPF11G2KsbPzw86OjpITEyUKAg7YMAA+Pv7K0xqmJqa4ujRo1K1Ro4ePSqu5ZKZmQkDAwMAQNOmTREaGgoTExM0adJE4UoQRcU+hwwZgqysLNjY2BSquw4RERFRSWFSg4hIBby8vBQe37hxo9xjOjo6qFWrltKHYkWysrKQmJiIT58+SYwr2zbQtm1b+Pv7o02bNrh27Rr27NkD4HMhyy+3vMiSvxVi5syZUscKsvWlWbNm2L59u8JzAMDf3x+zZs2Cvr4+/P39FZ6rrINI7969peI0MzNDp06dFCYV8rm5ucHd3R22trZ4/fo1unfvDgCIiopSug0nJCQEp0+flvpcbW1t8eTJE4Vzp06dinHjxiEsLExcU+P69es4ceIEVq9eDQA4c+aMOMnVq1cvlCtXTuZ7LoyidtchIiIiKincfkJEpAJfb5fIzs7G7du3kZqaik6dOuHgwYMK52/YsAEHDx7Etm3bJNqrKvPy5Ut4enri5MmTMo8rSywkJiZi/PjxSEpKgo+PD0aMGAHg86qC3NzcQhXpVEbZyo8vfVnzwdTUFHFxcahcuTI6duwod45AIMC5c+eKFaMy2dnZWLp0KZKSkjB8+HDxqpIlS5bAwMAAI0eOlDvXwMAAkZGRsLW1hYGBAWJiYlC7dm3cuHEDXbt2xevXrxXeOyIiAitWrMD9+/cBAHZ2dvD29pZZcJWIiIjo34JJDSIiNcnLy8O4ceNgY2OD//3vfwrPbdKkCR4+fIjs7GxYWlpCX19f4ri8LQKDBw/GkydPEBwcjG+//RaHDh3C8+fPMXv2bAQFBRVo+0tpc3R0xIkTJ2Bpaam0IKasAqdCoRApKSkwNzdH7dq1cf36dVSqVKlIsShb6fElZas+CsvFxQXNmjXDrFmzYGBggFu3bsHS0hIDBw5EXl4e9u/fX6L3k+XDhw/Ys2cPMjMz4ezsDFtbW4XnJyYmKjxeq1atkgyPiIiISAq3nxARqYlQKIS/vz++/fZbpUmNom4ROHfuHA4fPgwnJycIhUJYWlrC2dkZhoaGmDdvXoGSGvHx8di0aRPi4+OxdOlSmJub4+TJk6hVqxYcHByKFNeXEhISkJ2dXeSWpiYmJnj8+DHMzc2RkJCAvLy8IscSFRWFyMhI5OTkwM7ODsDnrTZaWlpo2rSp+Lwvky9f1+FQRFEdkYULF+K7777DjRs38OnTJ/zvf//D33//jTdv3iAiIkLq/OK27vX390d2djaWL18OAPj06RNatWqFO3fuQE9PD//73/8QEhKicKWHlZWVwkRUcbZMERERERUEkxpERGoUHx+PnJwcpef99ttvRbp+ZmYmzM3NAXx++H/58iXq1q0LR0dHhQUg84WHh6N79+5o06YNLly4gDlz5sDc3BwxMTHYsGFDia4eKGpR0759+6JDhw6oVq0aBAIBnJycoKWlJfNcZS1de/bsCQMDA2zZsgUmJiYAgLdv38LT0xPt2rXDxIkTpeYUNOGkrI5IgwYNEBcXhxUrVsDAwAAZGRlwc3PDjz/+iGrVqkmdb2JiIm7da2xsXOjWvSEhIZg7d6749Y4dO5CYmIgHDx6gVq1a8PLywpw5c3D8+HG5MUdFRUm8zs7ORlRUFBYvXow5c+bInUdERERUUpjUICJSga+3NeR31Th+/Dg8PDwKfJ0bN27g7t27AAB7e3s0a9ZM4fl2dna4f/8+rKys0KhRI6xZswZWVlZYvXq1zAflr02ePBmzZ8+Gv7+/uHMGAHTq1AkrVqwocNxFkZqaig0bNojfr4ODA7y8vGBkZCRx3tq1a+Hm5oaHDx/Cx8cHo0aNkoi1MIKCghASEiJOaACfkwezZ89Gly5dZCY1irMy5EuJiYmwsLDAL7/8IvPY11s5zp07J66vUpRVLomJibC3txe/DgkJQb9+/WBpaQkA8PX1hYuLi8JrNGrUSGrMyckJ1atXx6JFi+Dm5lbouIiIiIgKg0kNIiIV+PobbaFQCDMzMwQFBSntjAIAT58+xaBBgxAREQFjY2MAnx/6W7dujd27d8vtROLr64vk5GQAn1d7dOvWDTt27ICuri42b96s9L6xsbHYuXOn1Li5uTlevXqldH5R5RfHrFChgribR/63/yEhIRJbQQCgW7duAICbN2/C19e3yEmNtLQ0vHz5Umr85cuXSE9PL9I1C8ra2lq88uJLr1+/hrW1tdRqi+K27hUKhfiyrNaVK1cwdepU8WtjY2O8ffu20NcFPifTrl+/XqS5RERERIXBpAYRkQoUtV5EvpEjRyI7Oxt3794V13q4f/8+PD09MXLkSJw6dUrmvCFDhoj/3axZMzx58gT37t1DrVq1ULlyZaX3NTY2RnJyMqytrSXGo6KiUKNGjWK8I8X8/Pzg6uqKdevWQVv785+qnJwcjBw5Ej/99BMuXLggc96mTZuKdd8+ffrA09MTQUFB4mTK1atXMWnSpAKvOsjMzER4eLjMFro+Pj5y5+VvFflaRkYGypcvr/CeDx48wOHDh5GQkACBQIDatWujV69eqF27ttw59evXx9GjR+Hv74+///4biYmJEt1jnjx5gipVqii879e1PPJXIE2fPl1pkVEiIiKiksDuJ0REKvTy5UuJlptmZmYFmlehQgVcvnxZ3CI0382bN9GuXTtkZWWVeKwAEBAQgKtXr2Lfvn2oW7cuIiMj8fz5cwwbNgzDhg0rcq2PL33ZvjRfhQoVEBUVhXr16kmce+fOHTg5OZXa+83KykJAQAA2btyI7OxsAIC2tjZGjBiBRYsWSXWd+VpUVBRcXFyQlZWFzMxMmJqa4tWrV9DT04O5ubnMmh75W5OWLl2KUaNGQU9PT3wsNzcXV69ehZaWlsxioQAwb948TJs2DXl5eTA3N4dIJMLLly+hpaWFuXPnIiAgQOa8Q4cOYeDAgWjbti3+/vtvNG/eHEePHhUfDwwMxOPHj7F3716571coFEolYkQiESwsLLB7925888038j8sIiIiohLAlRpERCqQmZkJb29vbN26VVyDQUtLC8OGDcPy5cslHmRlsbCwED9kfyk3NxfVq1eXO08kEmH//v0ICwvDixcvpOo/HDx4UOF9586dix9//BEWFhbIzc2Fvb09cnNz4e7ujl9//VXh3IJas2aN1IoAQ0NDJCYmSiU1kpKSiry1pCD09PSwcuVKLFq0CPHx8QAAGxsbpcmMfH5+fujZsydWr14NIyMjXLlyBTo6OhgyZAh8fX1lzsnfmiQSiRAbGwtdXV3xMV1dXTRq1EhuYiIsLAy//vorpk6dCl9fX3EtkDdv3iA4OBiTJ09GixYt0L59e6m5ffr0wYkTJ3Ds2DF06dIF3t7eUp/F+PHjFb7fr1cg5W+rqlOnjniFDREREVFp4koNIiIVGDNmDM6ePYsVK1agTZs2AIBLly7Bx8cHzs7OWLVqlcL5hw8fxty5c/HHH3/AyckJwOe6E97e3ggMDJTbgcPX1xdr1qxBx44dUaVKFalv1Qu6XSMxMRG3b99GRkYGmjRpUuCtBaGhoQgNDZWZUNm4caPceT4+Pjh06BB+//13cUvRiIgITJo0CX379kVwcHCB7q9qxsbGuHr1Kuzs7GBsbIy//voL9evXx9WrV+Hh4YF79+7Jnevp6YmlS5fKbL8qz4ABA2BsbIw1a9bIPD569Gikp6dj165dcq+RmJiImjVrQigUSoyLRCIkJSVJFSglIiIi0iRMahARqUDlypWxf/9+fPvttxLjYWFh6N+/v8zilF8yMTFBVlYWcnJyJGpMaGtrS60iePPmjfjfpqam2L59u9IuFqVhxowZmDlzJpycnMTtVr906NAhuXM/ffqESZMmYfXq1eKWtzo6Ohg3bhzmz5+PcuXKlWrsRWVmZobLly/D1tYWdevWxfLly9G1a1fcu3cPzZo1Q2ZmZonez9raGtu2bUPbtm1lHr948SKGDRuGx48fy72GlpaW3AKl5ubmMtvByqtp8jVZK0SIiIiIShLXhhIRqUBWVpbMoovm5uYFqg9R1JUJRkZGCotFKvN1K9p8AoEA5cuXR506ddCrVy9xa9EvrV69Gps3b8bQoUMLfV9dXV0sXboU8+bNk9gGomybjro1adIE169fh62tLTp06IBp06bh1atX2LZtGxo0aCB1vpubGzZv3gxDQ0OlhUhlbRV6/vw5rKys5M6xtrZGSkqKwuvK+25DUYHSr5NzX8pPXgkEAnFCioiIiKi0MKlBRKQC33zzDX777Tds3bpV/KD4/v17zJgxo0DFFD08PAp0n/nz5yM1NVXc9nX69OmYMWMGNm7ciAoVKhQ67qioKERGRiI3N1fcdSUuLg5aWlqoV68eVq5ciYkTJ+LSpUuwt7eXmPvp0yfx1pHCevfuHXJzc2FqagpHR0fx+Js3b6CtrV2oLRqqNHfuXHHr1zlz5mDYsGEYN24cbG1tZW63MTIyEicBjIyMCn2/Dx8+SNTg+JqOjo5UB5Z8+QkrgUCAadOmySxQ2rhxY5lz5bV6zcrKwtKlS7Fs2bJiJdOIiIiICorbT4iIVOD27dvo2rUrPn78iEaNGgEAYmJiUL58eZw+fRoODg4lch9DQ0NER0eLHyjfv3+PPn36ICIiAlZWVtDR0ZE4PzIyUuH1goODcfHiRWzatEmcSHj37h1GjhyJtm3bYtSoUXB3d8f79+9x+vRpibmBgYGoWLEipk6dWuj30b17d/Ts2VOqUOXq1atx5MgRnDhxotDX/DcSCoWYPXs2KlasKPN4eno6pk2bJnMLSX771vDwcHzzzTdSBUqtrKwQEBBQoPopeXl52LhxI2bMmAGhUIjp06fDw8NDqk4HERERUUljUoOISEWysrKwY8cOcbHI+vXrY/DgwUVaQSHP1+1R+/fvj7CwMPTr109moVBlLVlr1KiBM2fOSK3C+Pvvv9GlSxc8e/YMkZGR6NKlC169eiWxXSUvLw9btmxBw4YN0bBhQ6mEyuLFi+Xe19TUFBEREahfv77E+L1799CmTRu8fv1aYdz/FVZWVlI/U1kU1dRQVKA0NzcXWlpaCq998OBB/Pzzz3j58iWmTJkCb29vja15QkRERP8+3H5CRKQienp6GDVqlErvefz4cZw+fVpuIUll3r17hxcvXkglNV6+fIm0tDQAnzt+5G9xyG9Pmi9/+8Lt27cLdd+PHz/KrMeQnZ2N9+/fF+paqmRtba0wyfDo0SO5x16/fo1p06bJbb/7ZQHYfAkJCUWONZ+sDjhxcXHYsGEDtm7diuTkZJnzwsPDERgYiNjYWPj6+iIwMLBIW2iIiIiIioNJDSKiUnLkyBF0794dOjo6OHLkiMJzXV1dSyUGCwuLYtWf6NWrF7y8vBAUFITmzZsDAK5fv46AgABxG9lr166hbt26AD53cykJLVq0wNq1a7F8+XKJ8dWrV6NZs2Ylco/S8NNPP0m8zs7ORlRUFE6dOoVJkyYpnDt06FA8fPgQI0aMkLmqpiQ4OjrixIkTsLCwkDqWlZWFPXv2YOPGjfjrr7/g5OQkt1Csi4sLzp49Cy8vL/z555+oWrVqicdKREREVBDcfkJEVEqEQiFSUlJgbm6usLaAQCCQWfOgKL7efnL8+HEsX74cq1evVtglQ56MjAz4+flh69at4pUT2tra8PDwwJIlS6Cvr4/o6GgAkCoq6eXlhaVLl8LAwEBiPDMzE97e3jILZ+aLiIhA586d0bx5c3z33XcAgNDQUFy/fh0hISFo165dod+LOv3xxx+4ceOGzFUR+QwMDHDp0iVxzZXS8PXvBwBcuXIF69evx759+1CrVi3cvXsXYWFhCj9joVAobiesKPkia3UJERERUUliUoOI6F/k64dWExMTZGVlIScnB3p6elJ1LQr60JmRkSHeOlG7dm25hSm/pKWlheTkZJibm0uMv3r1ClWrVlXa7jM6OhqLFi1CdHQ0KlSogIYNG2LKlCkFKlypaR49eoTGjRuLt+zI0rx5cyxfvhytWrUqtTi+/P0ICgrCxo0b8e7dOwwaNAhDhgxBo0aNoKOjg5iYGKktR1/asmVLge5X0K49REREREXF7SdERP8i7dq1kyg8GhwcXCLXrVixIho2bFigc9PS0iASiSASiZCeni5uYQt8Ljx54sQJqUSHLI0bN8aOHTuKHLMm2b9/P0xNTRWes3LlSkyePBnTpk1DgwYNpBJQJd3GNjAwEIGBgZg5c6bSYqBfK2yyYteuXXB1dYW+vn6h5hEREREpw6QGEZEK+Pj4oE6dOvDx8ZEYX7FiBR4+fCgz+aDoW/2v5T/wft3qtLjflGdmZmL+/PkIDQ2VWbxSVuFLY2NjCAQCCAQCca2NLwkEAsyYMUNqPC0tTfw+lL33kn7ALylNmjSR2I4hEomQkpKCly9fYuXKlQrnGhsbIy0tDZ06dZIYF4lEJbpFKd+sWbOwadMmbNu2DYMGDcLQoUPRoEGDEr1HvjFjxqBly5YS216IiIiISgKTGkREKnDgwAGZxUJbt26N+fPny0xq5CcHFCnIA29ubi7+/PNP3L17FwDg4OAAV1fXAn07P3LkSISHh2Po0KGoVq1agYpXhoWFQSQSoVOnTjhw4IDECgVdXV1YWlqievXqUvNMTEzE21XkvffSesAvKfnFU/MJhUKYmZnh22+/Rb169RTOHTx4MHR0dLBz585SKxT6pSlTpmDKlCkIDw/Hxo0b0bJlS9SpUwcikQhv374t0XtxpysRERGVFtbUICJSgfLly+P27duoU6eOxPjDhw/RoEEDfPjwQWpOeHh4ga/foUMHmeMPHz6Ei4sLnj17Bjs7OwDA/fv3YWFhgePHj8PGxkbhdY2NjXH8+HG0adOmwLHke/LkCSwsLBQWSf1SeHg42rRpA21tbaXvXd77Lcv09PQQFRUl/jmVhKdPn2LmzJlYu3YtANmFQvOlp6dj586d2LhxI27evIkWLVqgX79+cjugFIai+xIREREVB5MaREQq0KBBA4wdOxYTJkyQGF++fDlWrVqFO3fuyJ2bk5ODuXPnwsvLCzVr1izUfV1cXCASibBjxw7xionXr19jyJAhEAqFOH78uML51tbWOHHiBOrXr1+o+34pKysLiYmJ+PTpk8R4QWt0lCVF2TKUr3379pg2bRo6d+5cYvHExMSgadOm4pUtO3fuRK9evZTWtoiNjcWGDRuwc+dOvHjxothxMKlBREREpYVJDSIiFdi4cSMmTJiASZMmiWsmhIaGIigoCMHBwRg1apTC+QYGBoiNjS10W1Z9fX1cuXIFjo6OEuMxMTFo06YNMjIyFM7fvn07Dh8+jC1btkBPT69Q93758iU8PT1x8uRJmceVbSH58OEDbt26JbOWh6ura6FiURWhUFjkLUP79u3D9OnTMWnSJDg6OkoVCi1KEujrpEZhZWdni+NwdHTEiRMnYGFhUejrMKlBREREpYU1NYiIVMDLywsfP37EnDlzMGvWLACAlZUVVq1ahWHDhimd36lTJ4SHhxc6qVGuXDmkp6dLjWdkZEBXV1fp/KCgIMTHx6NKlSqwsrKSetCOjIyUO/enn35Camoqrl69im+//RaHDh3C8+fPMXv2bAQFBSm876lTpzBs2DC8evVK6pgm19TYtGkTJk+ejOHDh+Obb74BAPz111/YsmUL5s2bp/DnN2DAAACff1fyCQQCtdYR+fLnnZCQgOzsbJXHQERERKQIkxpERCoybtw4jBs3Di9fvkSFChVQsWLFAs/t3r07Jk+ejNjYWDRr1kxq+4C8lQvff/89Ro8ejQ0bNqBFixYAgKtXr2Ls2LEFWu3wdeHLwjh37hwOHz4MJycnCIVCWFpawtnZGYaGhpg3bx569Oghd663tzd++OEHTJs2DVWqVClyDKq2detWLF68GIMGDRKPubq6wtHREWvXrsX58+flzn38+LEKIlQPS0tLqYQYERERUUng9hMiojJAUbFNRd/ip6amwsPDA0ePHhU/VGZnZ6NXr17YtGkTjI2NSyNcAJ9rRty6dQtWVlawtLTEzp070aZNGzx+/BgODg7IyspSODcqKkppIVNNo6enh5iYGNja2kqMx8XFoXHjxgrfc1G4ubkpPJ6amorw8PASWeUhawtJ7dq1cf36dVSqVEnqvk2bNpXZ8peIiIioJHGlBhFRKWnatClCQ0NhYmKCJk2aKKy1oGgbBwCpmhIFZWxsjMOHD+Phw4filq7169eX6sKizM2bNyVawjZp0kTpHDs7O9y/fx9WVlZo1KgR1qxZAysrK6xevRrVqlVTOLdfv344f/58mUtqWFhYYN26dVi4cKHE+Pr162XWojhy5Ai6d+8OHR0dmS1/vyRrZY2RkZHCOUZGRgXa3lRUCQkJMhMmHz9+xLNnz0rtvkRERET5mNQgIiolvXr1Qrly5QAUbxsHAMycOVPuMYFAgKlTp4pfK2vBGRYWJv734sWLFZ774sULDBw4EOfPnxev6khNTUXHjh2xe/dumJmZyZ3r6+uL5ORkAMBvv/2Gbt26Yfv27dDV1cWWLVsU3nfFihX44YcfcPHiRZlFM318fBTOV5clS5agb9++OHnyJFq2bAkAuHbtGh48eIADBw5Ind+7d2+kpKTA3Nxc4e+IvNU4mzZtKrHYC+PLBMzp06clkiu5ubkIDQ0tdP0XIiIioqLg9hMiojLg65UR2dnZePz4MbS1tWFjYyOx0qNjx44S50ZGRiInJwd2dnYAPm+F0NLSQrNmzXDu3DmF9x0wYAAePXqErVu3itu63rlzBx4eHqhTpw527dpVoPhFIhHev3+Pe/fuoVatWqhcubLC8zds2ICxY8eifPnyqFSpksQqF4FAoNHbGp4+fYqVK1fi3r17AD6vjBk7dmyRuoao09OnTzFz5kysXbsWgOT2k/ztUPmFTL+ko6MDKysrBAUF4fvvv1d53ERERPTfwqQGEZEK3bhxQ7yNw97eHs2aNSvytdLS0jB8+HD06dMHQ4cOlXnO4sWLcf78eWzZsgUmJiYAgLdv38LT0xPt2rXDxIkTFd7DyMgIZ8+eRfPmzSXGr127hi5duiA1NVXh/A0bNmDJkiV48OABAMDW1hY//fQTRo4cqXBe1apV4ePjg8mTJyusJ0Kl5+t2sDt37kSvXr0kitRaW1vj+vXrSpNURERERKWFSQ0iIhV4+vQpBg0ahIiICIltHK1bt8bu3btRs2bNIl03NjYWPXv2REJCgszjNWrUQEhICBwcHCTGb9++jS5duuCff/5ReH0DAwNcvHgRjRs3lhiPiopChw4dkJaWJnfutGnTsHjxYnh7e0u0N12xYgX8/PwUbqkxNTXF9evXy0xNjYULF8Lb2xsVKlQAAERERMDJyUm8/Sg9PR2BgYFYuXKlxLxly5YV+B6q3nLzdVKjoFJTU0u1AC0RERHRl5jUICJSgW7duiE1NRVbtmwRbwO5f/8+PD09YWhoiFOnThXpupcuXULPnj3x9u1bmccNDAxw9OhRfPvttxLjYWFhcHV1RXp6usLr9+rVC6mpqdi1axeqV68OAHj27BkGDx4MExMTHDp0SO5cMzMzLFu2TKK9KQDs2rUL3t7eePXqldy5fn5+MDMzw88//6wwPk2hpaWF5ORkmJubA/jcvSU6OlrcKeT58+eoXr26VILA2tq6QNdXx5abgiQ1FixYACsrKwwYMAAA8MMPP+DAgQOoVq0aTpw4gUaNGqkqXCIiIvqPYqFQIiIVCA8Px+XLl8UJDeBzd5Dly5ejXbt2Sud//Y2+SCRCcnIytm3bhu7du8ud16dPH3h6eiIoKAgtWrQAAFy9ehWTJk1S2g4U+Fyw09XVFVZWVuKaEElJSWjQoAG2bdumcG52djacnJykxps1a4acnByFc3Nzc7Fw4UKcPn0aDRs2lCoUqqzAqap9/f1AQb8vePz4cWmEozKrV6/Gjh07AABnzpzB2bNncerUKezduxeTJk1CSEiImiMkIiKifzsmNYiIVMDCwgLZ2dlS47m5ueIVEIosWbJE4rVQKISZmRk8PDwwZcoUufNWr16NgIAAuLu7i++vra2NESNGYNGiRQWKOzIyEmfPnpUofNm5c2elc4cOHYpVq1ZJJSDWrl2LwYMHK5wbGxsrLo56+/ZtiWOKWuP+G3z69AmPHz+GjY0NtLVL78+0sqSWsnopAJCSkiJOdh07dgz9+/dHly5dYGVlJe7+QkRERFSamNQgIlKBRYsWwdvbG3/88Yd49cKNGzfg6+uL33//Xen8on6jr6enh5UrV2LRokWIj48HANjY2EgUe1RGIBDA2dkZzs7O4rF79+7B1dUVcXFxCudu2LABISEhaNWqFYDPq0QSExMxbNgwidazXyc+vmw7+1+RlZUFb29vcbvbuLg41K5dG97e3qhRowYmT55covf7sg2rvOPDhg1TeI6JiQmSkpJgYWGBU6dOYfbs2QA+r1QpbC0OIiIioqJgUoOISAWGDx+OrKwstGzZUvzte05ODrS1teHl5QUvLy/xuW/evCnx++vr66Nhw4Yldr2PHz+KkyTy3L59G02bNgUA8bmVK1dG5cqVJVZfKFp58fDhQ8THx6N9+/aoUKECRCKRxq7UWL9+PSpWrAjg88928+bN4q4gymqXAMCUKVMQExOD8+fPo1u3buLxzp07Y/r06SWe1Ni0aVOxr+Hm5gZ3d3fY2tri9evX4q1QUVFRqFOnTrGvT0RERKQMkxpERCoQHBys7hBUrjirLV6/fo3+/fsjLCwMAoEADx48QO3atTFixAiYmJggKCioBCMtvlq1amHdunXi11WrVpWqOVKrVi2F1/jzzz+xZ88etGrVSiJx4+DgoDSBpC5LliyBlZUVkpKSsHDhQnFSJzk5GePHj1dzdERERPRfwKQGEZEKeHh4qDuEMsXPzw86OjpITExE/fr1xeMDBgyAv7+/xiU15LXULYyXL1+Ku6d8KTMzU2NXp+jo6CAgIEBq3M/PTw3REBER0X+RUN0BEBH9F0RGRiI2Nlb8+vDhw+jduzd+/vlnfPr0SY2RaaaQkBAsWLAANWvWlBi3tbXFkydP1BRVyXF0dERSUpLEmJOTE44fPy5+nZ/IWL9+Pb755huVxlcY8fHx8Pb2RufOndG5c2f4+PiovP0sERER/XdxpQYRkQqMGTMGkydPhqOjIx49eoQBAwbAzc0N+/btQ1ZWlsZtTzExMVG4OkBZS9biyszMhJ6entT4mzdvUK5cuVK9tyokJCRIdcOZO3cuunfvjjt37iAnJwdLly7FnTt3cPnyZYSHh6spUsVOnz4NV1dXNG7cGG3atAEAREREwN7eHkePHpUoLktERERUGgQikUik7iCIiP7tjIyMEBkZCRsbGyxYsADnzp3D6dOnERERgYEDB0p9a69u+R04lCmtbTUuLi5o1qwZZs2aBQMDA9y6dQuWlpYYOHAg8vLysH///lK5r6oYGBggJiYGtWvXlhiPj4/H/PnzERMTg4yMDDRt2hSBgYFwdHRUU6SKNWnSBF27dsX8+fMlxidPnoyQkBBERkaqKTIiIiL6r2BSg4hIBQwNDXHz5k3Y2trC2dkZ33//PXx9fZGYmAg7Ozu8f/9e3SEWy65du+Dq6lqoVrGK3L59G9999x2aNm2Kc+fOwdXVFX///TfevHmDiIgI2NgWDtujAAAgJklEQVTYlMh91EVeUqOsKV++PGJjY2FraysxHhcXh4YNG+LDhw9qioyIiIj+K7j9hIhIBZycnDB79mx07twZ4eHhWLVqFQDg8ePHqFKlipqjK74xY8agZcuWJfaQ3qBBA8TFxWHFihUwMDBARkYG3Nzc8OOPP6JatWolcg9N8+7dO5w5cwYJCQkQCASoXbs2vvvuOxgaGqo7NLnMzMwQHR0tldSIjo6WWfSUiIiIqKQxqUFEpALBwcEYPHgw/vzzT/zyyy+oU6cOAGD//v1o3bq1mqMrvtJY9GdkZIRffvmlxK+ribZv344JEyYgLS1NYtzIyAirV6/GgAED1BSZYqNGjcLo0aPx6NEj8e9xREQEFixYAH9/fzVHR0RERP8F3H5CRKRGHz58gJaWFnR0dNQdSrGU1HaKV69eITMzE5aWluKxv//+G7///jsyMzPRu3dvuLu7FzdclXv69ClmzpyJtWvXApD8vCIjI9GyZUsMHjwYfn5+qFevHkQiEe7cuYPg4GDs3r0b169fR6NGjdT8LqSJRCIEBwcjKCgI//zzDwCgevXqmDRpEnx8fDS2FS0RERH9ezCpQURExVZSSY1BgwahevXqCAoKAgC8ePEC9erVQ/Xq1WFjY4OTJ09iw4YNGDp0aEmErTIxMTFo2rQpcnNzAQA7d+5Er169oK+vD09PT2RkZGDfvn0y5/br1w+GhobYuHGjKkMutPT0dACffxeIiIiIVEWo7gCIiP4LhEIhtLS05P5Hn125cgWurq7i11u3boWpqSmio6Nx+PBhzJ07F3/88YcaIywZ7u7u4qKqERERGDNmjNxzx44di0uXLqkqtCIzMDBgQoOIiIhUjjU1iIhU4NChQxKvs7OzERUVhS1btmDGjBlqikrzpKSkwMrKSvz63LlzcHNzg7b25z9Xrq6umDdvnpqiKx3//PMP6tatK/d43bp18ezZMxVGpFyTJk0KtLWELV2JiIiotDGpQUSkAr169ZIa69evHxwcHLBnzx6MGDFCDVGVHEtLyxKpC2JoaIjU1FRxTY1r165JfDYCgQAfP34s9n00SVZWFsqXLy/3eLly5TSuNWrv3r3F/xaJRJg3bx7Gjh0LU1NT9QVFRERE/0msqUFEpEaPHj1Cw4YNkZGRoe5QZKpduzauX7+OSpUqSYynpqaiadOmePToUYner1evXqhcuTLWrVuHgwcPYvDgwUhJSYGJiQkA4Pjx4wgICMDdu3dL9L7F5ebmpvB4amoqwsPDxTU1viQUCrFlyxYYGRnJnevp6SlzrqYoqZoqRERERIXFlRpERGry/v17LFu2DDVq1FB3KHIlJCTIfJj++PFjqWyJmDVrFr777jts374dOTk5+Pnnn8UJDQDYvXs3OnToUOL3LS55CYkvjw8bNkzucQ8PD4Xz2UWEiIiISDYmNYiIVMDExETiwVQkEiE9PR16enrYvn27GiOT7ciRI+J/nz59WuKhPTc3F6GhoRK1L0pKw4YNcffuXURERKBq1apo2bKlxPGBAwfC3t6+xO9bXJs2bSry3Ly8vBKMhIiIiOi/hdtPiIhUYPPmzRJJDaFQCDMzM7Rs2VJiJYKmEAo/N8cSCAT4+s+Ejo4OrKysEBQUhO+//14d4Yk5OjrixIkTsLCwUGscxZWdnY0xY8Zg6tSpsLa2Vnc4hcbtJ0RERKQuTGoQEZFc1tbWuH79OipXrqzuUGT6Nz1MGxkZITo6ukwkNZYtWybxOjAwEJMmTZL6PfHx8VFlWERERPQfxKQGEZEKnDp1ChUrVkTbtm0BAH/88QfWrVsHe3t7/PHHHxq5WkOe1NRUGBsbqzsMAP+upIaHhwcaN24MPz8/dYeiVEESLwKBoMQLyRIRERF9jTU1iIhUYNKkSViwYAEAIDY2Fv7+/pg4cSLCwsLg7+9frJoMpWnBggWwsrLCgAEDAAA//PADDhw4gGrVquHEiRNo1KiRmiP897C1tcXMmTMRERGBZs2aQV9fX+K4Jq16ePz4sbpDICIiIgLAlRpERCpRsWJF3L59G1ZWVpg+fTpu376N/fv3IzIyEi4uLkhJSVF3iDJZW1tjx44daN26Nc6cOYP+/ftjz5492Lt3LxITExESEqLW+P5NKzUUrX4o66se/i21T4iIiEjzcKUGEZEK6OrqIisrCwBw9uxZcXtPU1NTpKWlqTM0hVJSUsQPoseOHUP//v3RpUsXWFlZSXUmoeL5N69+SEhIQHZ2trrDICIion8hoboDICL6L2jbti38/f0xa9YsXLt2DT169AAAxMXFoWbNmmqOTj4TExMkJSUB+FwXpHPnzgA+t6TNzc1VeTxPnz7F6NGjVX5fVfr06RPu37+PnJwcdYdCREREpPGY1CAiUoEVK1ZAW1sb+/fvx6pVq1CjRg0AwMmTJ9GtWzc1Ryefm5sb3N3d4ezsjNevX6N79+4AgKioKNSpU0fl8bx+/RobNmwQv16zZg2qVKmi8jhKQ1ZWFkaMGAE9PT04ODggMTERAODt7Y358+erOToiIiIizcSkBhGRCtSqVQvHjh1DTEwMRowYIR5fsmSJRHvM+fPnIzU1VQ0RyrZkyRJMmDAB9vb2OHPmDCpWrAgASE5Oxvjx49UcHeDu7i5VULOsmjJlCmJiYnD+/HmUL19ePN65c2fs2bNHjZERERERaS4WCiUi0iCGhoaIjo7+VxS+LA0xMTFo2rSpWra+lDZLS0vs2bMHrVq1kiiA+vDhQzRt2lSja68o828q6EpERESahSs1iIg0iCbmmePj4+Ht7Y3OnTujc+fO8PHxKdOdODTVy5cvYW5uLjWemZkJgUCghoiK7r9Q+4SIiIg0A7ufEBGRXKdPn4arqysaN26MNm3aAAAiIiJgb2+Po0ePwtnZuUTv5+bmpvC4Jm3NKWlOTk44fvw4vL29AUCcyFi/fj2++eYbdYZWaPm1T9auXQvg31X7hIiIiDQLkxpERCTX5MmT4efnJ1WocvLkyQgMDCzxpIaRkZHS4/ntcP9t5s6di+7du+POnTvIycnB0qVLcefOHVy+fBnh4eHqDq9Y3N3d1R0CERER/UuxpgYRkQbRtNoD5cuXR2xsLGxtbSXG4+Li0LBhQ3z48EFNkf07xcfHY/78+YiJiUFGRgaaNm2KwMBAODo6qju0Qvk31z4hIiIizcKVGkREJJeZmRmio6OlkhrR0dEy6z9Q8djY2GDdunXqDoOIiIiozGBSg4hIg7Rr1w4VKlRQdxhio0aNwujRo/Ho0SO0bt0awOeaGgsWLIC/v7+ao/v3ycvLw8OHD/HixQvk5eVJHGvfvr2aopL2X659QkRERJqF20+IiEpJYVpwGhoalmIkRScSiRAcHIygoCD8888/AIDq1atj0qRJ8PHxKXNdOTTZlStX4O7ujidPnkh1wREIBBq1lcPT07NA523atKmUIyEiIqL/OiY1iIhKiVAoVPrQLxKJNO6BVZ709HQAn+t+UMlr3Lgx6tatixkzZqBatWpSvzvKiqgSERER/RcxqUFEVEoK07GiQ4cOpRgJlQX6+vqIiYlBnTp11B0KERERUZnBmhpERKUkP1GRk5ODuXPnwsvLCzVr1lRzVAXTpEmTAm0tiYyMVEE0/w0tW7bEw4cPmdQgIiIiKgQmNYiISpm2tjYWLVqEYcOGqTuUAuvdu7f43yKRCPPmzcPYsWNhamqqvqD+hW7duiX+t7e3NyZOnIiUlBQ4OjpCR0dH4tyGDRuqOjwiIiIijcftJ0REKtCrVy+4ubnBw8ND3aEUiYGBAWJiYlC7dm11h/Kvkl93Rd6f4vxjZaXuChEREZGqcaUGEZEKdO/eHZMnT0ZsbCyaNWsGfX19ieOurq5qiozU6fHjx+oOgYiIiKhM40oNIiIVEAqFco+VhW/huVKj9F24cAGtW7eGtrbk9w05OTm4fPky2rdvr6bIiIiIiDSX/P/LJiKiEpOXlyf3P01PaJBqdOzYEW/evJEaf/fuHTp27KiGiIiIiIg0H7efEBGpwMyZM+UeEwgEmDp1qgqjUW7ZsmUSr3NycrB582ZUrlxZYtzHx0eVYf2r5dfO+Nrr16+ltisRERER0WfcfkJEpAJNmjSReJ2dnY3Hjx9DW1sbNjY2Gtca1draWuk5AoEAjx49UkE0/25ubm4AgMOHD6Nbt24oV66c+Fhubi5u3boFOzs7nDp1Sl0hEhEREWksrtQgIlKBqKgoqbG0tDQMHz4cffr0UUNEirGApeoYGRkB+LxSw8DAABUqVBAf09XVRatWrTBq1Ch1hUdERESk0bhSg4hIjWJjY9GzZ08kJCSoO5RicXR0xIkTJ2BhYaHuUMqsGTNmICAggFtNiIiIiAqBKzWIiNTo3bt3ePfunbrDKLaEhARkZ2erO4wy7bfffsOtW7cQFxcHALCzs4Ojo6OaoyIiIiLSbExqEBGpwNeFN0UiEZKTk7Ft2zZ0795dTVGRprh27RpGjBiBO3fuIH8BpUAggIODAzZs2IDmzZurOUIiIiIizcTtJ0REKvB14U2hUAgzMzN06tQJU6ZMgYGBgZoiKxkGBgaIiYlB7dq11R1KmXPnzh20bNkS9evXh5+fH+rXry8eX7JkCe7fv48rV67A3t5ezZESERERaR4mNYiIqNiY1Ci6/v37IycnBwcOHJBq6SoSieDm5gYdHR3s3btXTRESERERaS5uPyEiIlKjsLAwnDx5UiqhAXzegvLzzz/DxcVFDZERERERaT6hugMgIqKy5+nTpxg9erS6w/hXSE9PR5UqVeQer1q1KtLT01UYEREREVHZwaQGEREV2uvXr7Fhwwbx6zVr1ih8MCf5LC0tce3aNbnHr169CktLSxVGRERERFR2MKlBRETF5u7uDn19fXWHUSYNHDgQ/v7+uH37ttSx2NhYBAQEYMCAAWqIjIiIiEjzsVAoEREVWkxMDJo2bYrc3Fx1h1LmffjwAd999x2uXr0KZ2dn1K9fHyKRCHfv3sXZs2fRokULnDt3DuXLl1d3qEREREQah0kNIiIqNCY1StanT5+wZMkS7Nq1C3FxcQCAunXrYuDAgfDz80O5cuXUHCERERGRZmJSg4iIpLi5uSk8npqaivDwcCY1imnZsmUYPXo0ypcvj8TERNSsWRNCIXeGEhERERUUkxpERCTF09OzQOdt2rSplCP5d9PW1sY///wDc3NzaGlpITk5Gebm5uoOi4iIiKjM0FZ3AEREpHmYrFCN6tWr48CBA3BxcYFIJMLTp0/x4cMHmefWqlVLxdERERERaT6u1CAiIlKTtWvXwtvbGzk5OXLPEYlEEAgE3OpDREREJAOTGkRERGqUnp6OJ0+eoGHDhjh79iwqVaok87xGjRqpODIiIiIizcekBhERkQbYsmULBg4cyE4nRERERIXApAYREZEGeP/+Pc6cOSPR0tXZ2RkVKlRQc2REREREmouFQomIiNTsyJEjGDlyJF69eiUxXrlyZWzYsAE9e/ZUU2REREREmk2o7gCIiIj+yy5fvox+/fqhffv2iIiIwJs3b/DmzRtcunQJ7dq1Q79+/XDlyhV1h0lERESkkbj9hIiISI1cXFxgYWGBNWvWyDw+ZswYJCUl4cSJEyqOjIiIiEjzMalBRESkRqampggPD4ejo6PM47du3UKHDh3w9u1bFUdGREREpPm4/YSIiEiN3r9/D0NDQ7nHjYyM8OHDBxVGRERERFR2MKlBRESkRra2tjh37pzc46GhobC1tVVhRERERERlB5MaREREauTp6YmAgACZNTOOHz+O//3vfxg+fLjqAyMiIiIqA1hTg4iISI3y8vIwYMAAHDhwAHZ2dqhfvz5EIhHu3r2LBw8eoHfv3ti3bx+EQn4PQURERPQ1JjWIiIg0wJ49e7Br1y7ExcUBAOrWrYuBAwdi4MCBao6MiIiISHMxqUFEREREREREZZK2ugMgIiKi//fixQu8ePECeXl5EuMNGzZUU0REREREmotJDSIiIg1w8+ZNeHh44O7du/h6EaVAIEBubq6aIiMiIiLSXNx+QkREpAEaNWoEGxsbBAYGokqVKhAIBBLHLS0t1RQZERERkeZiUoOIiEgDGBgYICoqCnXq1FF3KERERERlBvvDERERaYDvvvsOMTEx6g6DiIiIqEzhSg0iIiIN8OrVK3h4eKBFixZo0KABdHR0JI67urqqKTIiIiIizcWkBhERkQY4evQohg4dirS0NKljLBRKREREJBu3nxAREWkAb29vDBkyBMnJycjLy5P4jwkNIiIiItm4UoOIiEgDGBgYIDo6GjY2NuoOhYiIiKjM4EoNIiIiDeDm5oawsDB1h0FERERUpmirOwAiIiIC6tatiylTpuDSpUtwdHSUKhTq4+OjpsiIiIiINBe3nxAREWkAa2truccEAgEePXqkwmiIiIiIygYmNYiIiIiIiIioTGJNDSIiIiIiIiIqk1hTg4iISAN4eXkpPL5x40YVRUJERERUdjCpQUREpAHevn0r8To7Oxu3b99GamoqOnXqpKaoiIiIiDQbkxpEREQa4NChQ1JjeXl5GDduHGxsbNQQEREREZHmY6FQIiIiDXb//n18++23SE5OVncoRERERBqHhUKJiIg0WHx8PHJyctQdBhEREZFG4vYTIiIiDeDv7y/xWiQSITk5GcePH4eHh4eaoiIiIiLSbNx+QkREpAE6duwo8VooFMLMzAydOnWCl5cXtLX5PQQRERHR15jUICIiIiIiIqIyiTU1iIiIiIiIiKhM4lpWIiIiNerYsSMEAoHCcwQCAUJDQ1UUEREREVHZwaQGERGRGjVu3FjusfT0dOzcuRMfP35UXUBEREREZQhrahAREWmYnJwc/PHHH5gzZw6MjIwwa9YsDBw4UN1hEREREWkcJjWIiIg0yI4dOzBt2jS8f/8ev/76K0aPHs3OJ0RERERy8P+SiIiINMCpU6cwefJkPH78GAEBAfD394e+vr66wyIiIiLSaExqEBERqdG1a9cQGBiIK1euYOzYsTh79iwqV66s7rCIiIiIygRuPyEiIlIjoVCIChUqYPTo0bC2tpZ7no+PjwqjIiIiIiobmNQgIiJSIysrqwK1dH306JGKIiIiIiIqO5jUICIiIiIiIqIySajuAIiIiKjgHB0dkZSUpO4wiIiIiDQCkxpERERlSEJCArKzs9UdBhEREZFGYFKDiIiIiIiIiMokJjWIiIiIiIiIqExiUoOIiIiIiIiIyiQmNYiIiIiIiIioTGJSg4iIiIiIiIjKJCY1iIiINFRqaqrU2Jo1a1ClShXVB0NERESkgZjUICIi0gALFizAnj17xK/79++PSpUqoUaNGoiJiRGPu7u7Q19fXx0hEhEREWkcJjWIiIg0wOrVq2FhYQEAOHPmDM6cOYOTJ0+ie/fumDRpkpqjIyIiItJM2uoOgIiIiICUlBRxUuPYsWPo378/unTpAisrK7Rs2VLN0RERERFpJq7UICIi0gAmJiZISkoCAJw6dQqdO3cGAIhEIuTm5qozNCIiIiKNxZUaREREGsDNzQ3u7u6wtbXF69ev0b17dwBAVFQU6tSpo+boiIiIiDQTkxpEREQaYMmSJbCyskJSUhIWLlyIihUrAgCSk5Mxfvx4NUdHREREpJkEIpFIpO4giIiI/usuXLiA1q1bQ1tb8vuGnJwcXL58Ge3bt1dTZERERESai0kNIiIiDaClpYXk5GSYm5tLjL9+/Rrm5uasq0FEREQkAwuFEhERaQCRSASBQCA1/vr1a+jr66shIiIiIiLNx5oaREREauTm5gYAEAgEGD58OMqVKyc+lpubi1u3bqF169bqCo+IiIhIozGpQUREpEZGRkYAPq/UMDAwQIUKFcTHdHV10apVK4waNUpd4RERERFpNNbUICIi0gAzZsxAQEAAt5oQERERFQKTGkRERERERERUJrFQKBERkQZ4/vw5hg4diurVq0NbWxtaWloS/xERERGRNNbUICIi0gDDhw9HYmIipk6dimrVqsnshEJEREREkrj9hIiISAMYGBjg4sWLaNy4sbpDISIiIiozuP2EiIhIA1hYWIDfMxAREREVDpMaREREGiA4OBiTJ09GQkKCukMhIiIiKjO4/YSIiEgDmJiYICsrCzk5OdDT04OOjo7E8Tdv3qgpMiIiIiLNxUKhREREGiA4OFjdIRARERGVOVypQURERERERERlEmtqEBERaYj4+Hj8+uuvGDRoEF68eAEAOHnyJP7++281R0ZERESkmZjUICIi0gDh4eFwdHTE1atXcfDgQWRkZAAAYmJi8Ntvv6k5OiIiIiLNxKQGERGRBpg8eTJmz56NM2fOQFdXVzzeqVMnXLlyRY2REREREWkuJjWIiIg0QGxsLPr06SM1bm5ujlevXqkhIiIiIiLNx6QGERGRBjA2NkZycrLUeFRUFGrUqKGGiIiIiIg0H5MaREREGmDgwIEIDAxESkoKBAIB8vLyEBERgYCAAAwbNkzd4RERERFpJLZ0JSIi0gCfPn3Cjz/+iM2bNyM3Nxfa2trIzc2Fu7s7Nm/eDC0tLXWHSERERKRxmNQgIiLSIImJibh9+zYyMjLQpEkT2NraqjskIiIiIo3FpAYRERERERERlUna6g6AiIiIAJFIhP379yMsLAwvXrxAXl6exPGDBw+qKTIiIiIizcWkBhERkQb46aefsGbNGnTs2BFVqlSBQCBQd0hEREREGo/bT4iIiDSAqakptm/fDhcXF3WHQkRERFRmsKUrERGRBjAyMkLt2rXVHQYRERFRmcKkBhERkQaYPn06ZsyYgffv36s7FCIiIqIyg9tPiIiINMD79+/Rp08fREREwMrKCjo6OhLHIyMj1RQZERERkeZioVAiIiIN4OHhgZs3b2LIkCEsFEpERERUQFypQUREpAH09fVx+vRptG3bVt2hEBEREZUZrKlBRESkASwsLGBoaKjuMIiIiIjKFCY1iIiINEBQUBD+97//ISEhQd2hEBEREZUZ3H5CRESkAUxMTJCVlYWcnBzo6elJFQp98+aNmiIjIiIi0lwsFEpERKQBgoOD1R0CERERUZnDlRpEREREREREVCZxpQYREZEGSExMVHi8Vq1aKoqEiIiIqOzgSg0iIiINIBQKIRAI5B7Pzc1VYTREREREZQNXahAREWmAqKgoidfZ2dmIiorC4sWLMWfOHDVFRURERKTZuFKDiIhIgx0/fhyLFi3C+fPn1R0KERERkcYRqjsAIiIiks/Ozg7Xr19XdxhEREREGonbT4iIiDRAWlqaxGuRSITk5GRMnz4dtra2aoqKiIiISLMxqUFERKQBjI2NpQqFikQiWFhYYPfu3WqKioiIiEizsaYGERGRBggPD5d4LRQKYWZmhjp16kBbm99BEBEREcnCpAYRERERERERlUn86oeIiEgDHDlyROa4QCBA+fLlUadOHVhbW6s4KiIiIiLNxpUaREREGkAoFEIgEODrP8v5YwKBAG3btsWff/4JExMTNUVJREREpFnY0pWIiEgDnDlzBs2bN8eZM2fw7t07vHv3DmfOnEHLli1x7NgxXLhwAa9fv0ZAQIC6QyUiIiLSGFypQUREpAEaNGiAtWvXonXr1hLjERERGD16NP7++2+cPXsWXl5eSExMVFOURERERJqFKzWIiIg0QHx8PAwNDaXGDQ0N8ejRIwCAra0tXr16perQiIiIiDQWkxpEREQaoFmzZpg0aRJevnwpHnv58iX+97//oXnz5gCABw8ewMLCQl0hEhEREWkcdj8hIiLSAOvXr0fv3r1Rs2ZNceIiKSkJtWvXxuHDhwEAGRkZ+PXXX9UZJhEREZFGYU0NIiIiDZGXl4eQkBDExcUBAOzs7ODs7AyhkAsriYiIiGRhUoOIiEjNsrOzUaFCBURHR6NBgwbqDoeIiIiozOBXP0RERGqmo6ODWrVqITc3V92hEBEREZUpTGoQERFpgF9++QU///wz3rx5o+5QiIiIiMoMbj8hIiLSAE2aNMHDhw+RnZ0NS0tL6OvrSxyPjIxUU2REREREmovdT4iIiDRA79691R0CERERUZnDlRpEREQaLjc3F1paWuoOg4iIiEjjsKYGERGRhoqLi0NgYCBq1qyp7lCIiIiINBKTGkRERBokKysLmzZtQrt27WBvb4/w8HD4+/urOywiIiIijcSaGkRERBrgypUrWL9+Pfbt24datWrh7t27CAsLQ7t27dQdGhEREZHG4koNIiIiNQoKCoKDgwP69esHExMTXLhwAbGxsRAIBKhUqZK6wyMiIiLSaCwUSkREpEba2toIDAzEzJkzJYqB6ujoICYmBvb29mqMjoiIiEizcaUGERGRGs2aNQv79u2DtbU1AgMDcfv2bXWHRERERFRmMKlBRESkRlOmTEFcXBy2bduGlJQUtGzZEo0aNYJIJMLbt2/VHR4RERGRRuP2EyIiIg2Snp6OnTt3YuPGjbh58yZatGiBfv36sQMKERERkQxMahAREWmo2NhYbNiwATt37sSLFy/UHQ4RERGRxmFSg4iISMNlZ2dDR0cHAODo6IgTJ07AwsJCzVERERERqR9rahAREWm4/IQGACQkJCA7O1uN0RARERFpDiY1iIiIiIiIiKhMYlKDiIiIiIiIiMokJjWIiIiIiIiIqExiUoOIiIiIiIiIyiQmNYiIiDTY06dPMXr0aHWHQURERKSRmNQgIiLSYK9fv8aGDRvEr9esWYMqVaqoMSIiIiIizaGt7gCIiIio4Nzd3dUdAhEREZHG4EoNIiIiIiIiIiqTmNQgIiIiIiIiojKJ20+IiIjUyM3NTeHx1NRU1QRCREREVAYxqUFERKRGRkZGSo8PGzZMRdEQERERlS0CkUgkUncQRERERERERESFxZoaRERERERERFQmMalBRERERERERGUSkxpEREREREREVCYxqUFEREREREREZRKTGkRERERERERUJjGpQURERERERERlEpMaRERERERERFQm/R9H0tuHveoywgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "correlation_matrix = df.corr()\n", + "print(\"Correlation Matrix:\")\n", + "print(correlation_matrix)\n", + "\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(10, 8))\n", + "sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')\n", + "plt.title('Feature Correlation Matrix')\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ml_dataset/random_forest_model.tar.gz b/ml_dataset/random_forest_model.tar.gz new file mode 100644 index 00000000..03159a2b Binary files /dev/null and b/ml_dataset/random_forest_model.tar.gz differ diff --git a/ml_dataset/requirements.txt b/ml_dataset/requirements.txt new file mode 100644 index 00000000..b7d33483 --- /dev/null +++ b/ml_dataset/requirements.txt @@ -0,0 +1,5 @@ +pandas +numpy +scikit-learn +matplotlib +seaborn \ No newline at end of file diff --git a/ml_dataset/tanner_dataset.csv.zip b/ml_dataset/tanner_dataset.csv.zip new file mode 100644 index 00000000..0ecc343c Binary files /dev/null and b/ml_dataset/tanner_dataset.csv.zip differ diff --git a/ml_dataset/test_data.csv.zip b/ml_dataset/test_data.csv.zip new file mode 100644 index 00000000..14e3db38 Binary files /dev/null and b/ml_dataset/test_data.csv.zip differ diff --git a/ml_dataset/train_data.csv.xz b/ml_dataset/train_data.csv.xz new file mode 100644 index 00000000..b1275384 Binary files /dev/null and b/ml_dataset/train_data.csv.xz differ