{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":8616088,"sourceType":"datasetVersion","datasetId":4906925}],"dockerImageVersionId":30732,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"**Ensemble learning in classification** involves combining **multiple models** to improve **overall performance**. This technique helps **balance bias and variance**, two critical sources of error in machine learning models. *Bias refers to errors due to overly simplistic models*, while *variance refers to errors due to overly complex models*. By aggregating the predictions of diverse models, ensemble learning can **reduce both bias and variance**. \n* **bagging** (e.g., Random Forests) **reduce variance** by voting predictions of different models trained on varied subsets of data.  \n* **boosting** (e.g., AdaBoost) **reduces bias** by focusing on correcting the errors of weak models sequentially.   \n* **stacking** involves training a meta-model to combine the predictions of several base models, further **enhancing the robustness and accuracy** of classification tasks.  \n\nThus, ensemble learning effectively improves classification performance by mitigating both bias and variance.","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19"}},{"cell_type":"markdown","source":"### Read the Datasets","metadata":{}},{"cell_type":"code","source":"import pandas as pd\n\n# Read the training datasets\nX_train_original = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_train_original.csv')\nX_train_original = X_train_original.set_index('Unnamed: 0')\n\nX_train_transformed = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_train_transformed.csv')\nX_train_transformed = X_train_transformed.set_index('Unnamed: 0')\n\nX_train_discretized = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_train_discretized.csv')\nX_train_discretized = X_train_discretized.set_index('Unnamed: 0')\n\n# Read the test datasets\nX_test_original = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_test_original.csv')\nX_test_original = X_test_original.set_index('Unnamed: 0')\n\nX_test_transformed = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_test_transformed.csv')\nX_test_transformed = X_test_transformed.set_index('Unnamed: 0')\n\nX_test_discretized = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/X_test_discretized.csv')\nX_test_discretized = X_test_discretized.set_index('Unnamed: 0')\n\n# Read the target variable for training and testing\ny_train = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/y_train.csv')\ny_train = y_train.set_index('Unnamed: 0').squeeze()\n\ny_test = pd.read_csv('/kaggle/input/bankloan-ready-to-modeling/y_test.csv')\ny_test = y_test.set_index('Unnamed: 0').squeeze()","metadata":{"execution":{"iopub.status.busy":"2024-07-06T17:55:21.470613Z","iopub.execute_input":"2024-07-06T17:55:21.471024Z","iopub.status.idle":"2024-07-06T17:55:21.530984Z","shell.execute_reply.started":"2024-07-06T17:55:21.470988Z","shell.execute_reply":"2024-07-06T17:55:21.529688Z"},"trusted":true},"execution_count":25,"outputs":[]},{"cell_type":"markdown","source":"### Bagging  \nBagging, short for **bootstrap aggregating**, is an ensemble learning technique used to improve the accuracy and robustness of classification models. It works by generating **multiple versions of a training dataset** through random sampling with replacement. Each version is then used to train a separate model. The predictions from these individual models are combined, typically by **majority voting** for classification tasks. Bagging helps to **reduce variance** by averaging out the errors of the individual models, making it *particularly effective for high-variance algorithms like decision trees*. A prominent example of bagging in classification is the **Random Forest algorithm**, which builds a multitude of decision trees and merges their predictions to achieve more accurate and stable results.","metadata":{}},{"cell_type":"markdown","source":"### Fit the Logistic Regression Model","metadata":{}},{"cell_type":"code","source":"from sklearn.linear_model import LogisticRegression\nfrom sklearn.metrics import confusion_matrix, classification_report\n\nlogistic = LogisticRegression(penalty=None, C=1.0, fit_intercept=True, class_weight='balanced', l1_ratio=None)\nlogistic.fit(X_train_transformed, y_train)\n\ny_pred_train = logistic.predict(X_train_transformed)\ny_pred_test = logistic.predict(X_test_transformed)\ny_prob_test = logistic.predict_proba (X_test_transformed)\n\ncm_train = confusion_matrix(y_train, y_pred_train)\nreport_train = classification_report(y_train, y_pred_train)\n\ncm_test = confusion_matrix(y_test, y_pred_test)\nreport_test = classification_report(y_test, y_pred_test)\n\nprint(\"Evaluation the Model on Training Set\")\nprint(f\"Confusion Matrix:\\n{cm_train}\")\nprint(f\"Classification Report:\\n{report_train}\")\nprint(\"-\"*80)\nprint(\"Evaluation the Model on Testing Set\")\nprint(f\"Confusion Matrix:\\n{cm_test}\")\nprint(f\"Classification Report:\\n{report_test}\")","metadata":{"execution":{"iopub.status.busy":"2024-07-06T17:56:54.016152Z","iopub.execute_input":"2024-07-06T17:56:54.016580Z","iopub.status.idle":"2024-07-06T17:56:54.062352Z","shell.execute_reply.started":"2024-07-06T17:56:54.016550Z","shell.execute_reply":"2024-07-06T17:56:54.061217Z"},"trusted":true},"execution_count":26,"outputs":[{"name":"stdout","text":"Evaluation the Model on Training Set\nConfusion Matrix:\n[[274  90]\n [ 25  96]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.92      0.75      0.83       364\n           1       0.52      0.79      0.63       121\n\n    accuracy                           0.76       485\n   macro avg       0.72      0.77      0.73       485\nweighted avg       0.82      0.76      0.78       485\n\n--------------------------------------------------------------------------------\nEvaluation the Model on Testing Set\nConfusion Matrix:\n[[119  34]\n [ 16  41]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.88      0.78      0.83       153\n           1       0.55      0.72      0.62        57\n\n    accuracy                           0.76       210\n   macro avg       0.71      0.75      0.72       210\nweighted avg       0.79      0.76      0.77       210\n\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Fit the Bagging Logistic Regression Model","metadata":{}},{"cell_type":"markdown","source":"### Parameters\n\n#### `estimator` object, default=None\nThe base estimator to fit on random subsets of the dataset. If None, then the base estimator is a `DecisionTreeClassifier`.\n\n#### `n_estimators` int, default=10\nThe number of base estimators in the ensemble.\n\n#### `max_samples` int or float, default=1.0\nThe number of samples to draw from `X` to train each base estimator (with replacement by default, see `bootstrap` for more details).\n\n- If int, then draw `max_samples` samples.\n- If float, then draw `max_samples * X.shape[0]` samples.\n\n#### `max_features` int or float, default=1.0\nThe number of features to draw from `X` to train each base estimator (without replacement by default, see `bootstrap_features` for more details).\n\n- If int, then draw `max_features` features.\n- If float, then draw `max(1, int(max_features * n_features_in_))` features.\n\n#### `bootstrap` bool, default=True\nWhether samples are drawn with replacement. If False, sampling without replacement is performed.\n\n#### `bootstrap_features` bool, default=False\nWhether features are drawn with replacement.\n\n#### `n_jobs` int, default=None\nThe number of jobs to run in parallel for both `fit` and `predict`. None means 1 unless in a `joblib.parallel_backend` context. -1 means using all processors. See Glossary for more details.\n\n#### `random_state` int, RandomState instance, or None, default=None\nControls the random resampling of the original dataset (sample wise and feature wise). If the base estimator accepts a `random_state` attribute, a different seed is generated for each instance in the ensemble. Pass an int for reproducible output across multiple function calls. See Glossary.","metadata":{}},{"cell_type":"code","source":"from sklearn.ensemble import BaggingClassifier\nfrom sklearn.metrics import confusion_matrix, classification_report\n\nbag_clf = BaggingClassifier(estimator=logistic, n_estimators=100, max_samples=1.0, max_features=1.0,\n                            bootstrap=True, bootstrap_features=False, n_jobs=-1, random_state=111)\n\nbag_clf.fit(X_train_transformed, y_train)\n\ny_pred_train = bag_clf.predict(X_train_transformed)\ny_pred_test = bag_clf.predict(X_test_transformed)\ny_prob_test = bag_clf.predict_proba (X_test_transformed)\n\ncm_train = confusion_matrix(y_train, y_pred_train)\nreport_train = classification_report(y_train, y_pred_train)\n\ncm_test = confusion_matrix(y_test, y_pred_test)\nreport_test = classification_report(y_test, y_pred_test)\n\nprint(\"Evaluation the Model on Training Set\")\nprint(f\"Confusion Matrix:\\n{cm_train}\")\nprint(f\"Classification Report:\\n{report_train}\")\nprint(\"-\"*80)\nprint(\"Evaluation the Model on Testing Set\")\nprint(f\"Confusion Matrix:\\n{cm_test}\")\nprint(f\"Classification Report:\\n{report_test}\")","metadata":{"execution":{"iopub.status.busy":"2024-07-06T18:01:39.644338Z","iopub.execute_input":"2024-07-06T18:01:39.645373Z","iopub.status.idle":"2024-07-06T18:01:41.344290Z","shell.execute_reply.started":"2024-07-06T18:01:39.645335Z","shell.execute_reply":"2024-07-06T18:01:41.343013Z"},"trusted":true},"execution_count":27,"outputs":[{"name":"stdout","text":"Evaluation the Model on Training Set\nConfusion Matrix:\n[[276  88]\n [ 25  96]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.92      0.76      0.83       364\n           1       0.52      0.79      0.63       121\n\n    accuracy                           0.77       485\n   macro avg       0.72      0.78      0.73       485\nweighted avg       0.82      0.77      0.78       485\n\n--------------------------------------------------------------------------------\nEvaluation the Model on Testing Set\nConfusion Matrix:\n[[119  34]\n [ 16  41]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.88      0.78      0.83       153\n           1       0.55      0.72      0.62        57\n\n    accuracy                           0.76       210\n   macro avg       0.71      0.75      0.72       210\nweighted avg       0.79      0.76      0.77       210\n\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Fit the Random Forest Classifier","metadata":{}},{"cell_type":"markdown","source":"### Parameters\n\n#### `n_estimators` int, default=100\nThe number of trees in the forest.\n\n#### `criterion` {\"gini\", \"entropy\", \"log_loss\"}, default=\"gini\"\nThe function to measure the quality of a split. Supported criteria are “gini” for the Gini impurity and “log_loss” and “entropy” both for the Shannon information gain. Note: This parameter is tree-specific.\n\n#### `max_depth` int, default=None\nThe maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than `min_samples_split` samples.\n\n#### `min_samples_split` int or float, default=2\nThe minimum number of samples required to split an internal node:\n\n- If int, then consider `min_samples_split` as the minimum number.\n- If float, then `min_samples_split` is a fraction and `ceil(min_samples_split * n_samples)` are the minimum number of samples for each split.\n\n#### `min_samples_leaf` int or float, default=1\nThe minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least `min_samples_leaf` training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression.\n\n- If int, then consider `min_samples_leaf` as the minimum number.\n- If float, then `min_samples_leaf` is a fraction and `ceil(min_samples_leaf * n_samples)` are the minimum number of samples for each node.\n\n#### `max_features` {\"sqrt\", \"log2\", None}, int or float, default=\"sqrt\"\nThe number of features to consider when looking for the best split:\n\n- If int, then consider `max_features` features at each split.\n- If float, then `max_features` is a fraction and `max(1, int(max_features * n_features_in_))` features are considered at each split.\n- If “sqrt”, then `max_features=sqrt(n_features)`.\n- If “log2”, then `max_features=log2(n_features)`.\n- If None, then `max_features=n_features`.\n\n\n#### `bootstrap` bool, default=True\nWhether bootstrap samples are used when building trees. If False, the whole dataset is used to build each tree.\n\n#### `n_jobs` int, default=None\nThe number of jobs to run in parallel. `fit`, `predict`, `decision_path`, and `apply` are all parallelized over the trees. None means 1. -1 means using all processors.\n\n#### `random_state` int, RandomState instance, or None, default=None\nControls both the randomness of the bootstrapping of the samples used when building trees (if `bootstrap=True`) and the sampling of the features to consider when looking for the best split at each node (if `max_features < n_features`). \n\n#### `class_weight` {\"balanced\", \"balanced_subsample\"}, dict, or list of dicts, default=None\nWeights associated with classes in the form `{class_label: weight}`. If not given, all classes are supposed to have weight one. For multi-output problems, a list of dicts can be provided in the same order as the columns of `y`.\n\nNote that for multioutput (including multilabel) weights should be defined for each class of every column in its own dict. For example, for four-class multilabel classification weights should be `[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}]` instead of `[{1:1}, {2:5}, {3:1}, {4:1}]`.\n\nThe “balanced” mode uses the values of `y` to automatically adjust weights inversely proportional to class frequencies in the input data as `n_samples / (n_classes * np.bincount(y))`.\n\nThe “balanced_subsample” mode is the same as “balanced” except that weights are computed based on the bootstrap sample for every tree grown.\n\nFor multi-output, the weights of each column of `y` will be multiplied.\n\nNote that these weights will be multiplied with `sample_weight` (passed through the `fit` method) if `sample_weight` is specified.\n\n\n#### `max_samples` int or float, default=None\nIf `bootstrap` is True, the number of samples to draw from `X` to train each base estimator.\n\n- If None (default), then draw `X.shape[0]` samples.\n- If int, then draw `max_samples` samples.\n- If float, then draw `max(round(n_samples * max_samples), 1)` samples. Thus, `max_samples` should be in the interval (0.0, 1.0].","metadata":{}},{"cell_type":"code","source":"from sklearn.ensemble import RandomForestClassifier\nfrom sklearn.metrics import confusion_matrix, classification_report\n\nrf_clf = RandomForestClassifier(n_estimators=100, criterion='gini', max_depth=4, min_samples_split=2,\n                                min_samples_leaf=1, max_features='sqrt', bootstrap=True, n_jobs=-1,\n                                random_state=111, class_weight='balanced', max_samples=None)\n\nrf_clf.fit(X_train_transformed, y_train)\n\ny_pred_train = rf_clf.predict(X_train_transformed)\ny_pred_test = rf_clf.predict(X_test_transformed)\ny_prob_test = rf_clf.predict_proba (X_test_transformed)\n\ncm_train = confusion_matrix(y_train, y_pred_train)\nreport_train = classification_report(y_train, y_pred_train)\n\ncm_test = confusion_matrix(y_test, y_pred_test)\nreport_test = classification_report(y_test, y_pred_test)\n\nprint(\"Evaluation the Model on Training Set\")\nprint(f\"Confusion Matrix:\\n{cm_train}\")\nprint(f\"Classification Report:\\n{report_train}\")\nprint(\"-\"*80)\nprint(\"Evaluation the Model on Testing Set\")\nprint(f\"Confusion Matrix:\\n{cm_test}\")\nprint(f\"Classification Report:\\n{report_test}\")","metadata":{"execution":{"iopub.status.busy":"2024-07-06T18:06:11.589713Z","iopub.execute_input":"2024-07-06T18:06:11.590185Z","iopub.status.idle":"2024-07-06T18:06:12.104791Z","shell.execute_reply.started":"2024-07-06T18:06:11.590131Z","shell.execute_reply":"2024-07-06T18:06:12.103646Z"},"trusted":true},"execution_count":28,"outputs":[{"name":"stdout","text":"Evaluation the Model on Training Set\nConfusion Matrix:\n[[303  61]\n [ 17 104]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.95      0.83      0.89       364\n           1       0.63      0.86      0.73       121\n\n    accuracy                           0.84       485\n   macro avg       0.79      0.85      0.81       485\nweighted avg       0.87      0.84      0.85       485\n\n--------------------------------------------------------------------------------\nEvaluation the Model on Testing Set\nConfusion Matrix:\n[[121  32]\n [ 18  39]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.87      0.79      0.83       153\n           1       0.55      0.68      0.61        57\n\n    accuracy                           0.76       210\n   macro avg       0.71      0.74      0.72       210\nweighted avg       0.78      0.76      0.77       210\n\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Boosting  \nBoosting is an ensemble learning technique used in classification to improve the predictive performance by **combining multiple weak learners**, typically decision trees, to form a strong learner. Unlike bagging, which builds models independently, boosting builds models **sequentially**, with *each new model focusing on correcting the errors made by the previous ones*. The process gives more weight to incorrectly classified instances, ensuring that subsequent models address these errors more effectively. Popular boosting algorithms include **AdaBoost**, Gradient Boosting, and XGBoost. By iteratively refining the model, boosting **reduces bias**, leading to higher accuracy in classification tasks.","metadata":{}},{"cell_type":"markdown","source":"### Fit the AdaBoost Classifier","metadata":{}},{"cell_type":"markdown","source":"### Parameters\n\n#### `estimator` object, default=None\nThe base estimator from which the boosted ensemble is built. Support for sample weighting is required, as well as proper `classes_` and `n_classes_` attributes. If None, then the base estimator is `DecisionTreeClassifier` initialized with `max_depth=1`.\n\n#### `n_estimators` int, default=50\nThe maximum number of estimators at which boosting is terminated. In case of perfect fit, the learning procedure is stopped early. Values must be in the range [1, inf).\n\n#### `learning_rate` float, default=1.0\nWeight applied to each classifier at each boosting iteration. A higher learning rate increases the contribution of each classifier. There is a trade-off between the `learning_rate` and `n_estimators` parameters. Values must be in the range (0.0, inf).\n\n#### `algorithm` {‘SAMME’, ‘SAMME.R’}, default=’SAMME.R’\nIf ‘SAMME.R’ then use the SAMME.R real boosting algorithm. `estimator` must support calculation of class probabilities. If ‘SAMME’ then use the SAMME discrete boosting algorithm. The SAMME.R algorithm typically converges faster than SAMME, achieving a lower test error with fewer boosting iterations.\n\n#### `random_state` int, RandomState instance or None, default=None\nControls the random seed given at each estimator at each boosting iteration. Thus, it is only used when `estimator` exposes a `random_state`. Pass an int for reproducible output across multiple function calls. See Glossary.\n","metadata":{}},{"cell_type":"code","source":"from sklearn.ensemble import AdaBoostClassifier\nfrom sklearn.metrics import confusion_matrix, classification_report\n\nadabo_clf = AdaBoostClassifier(estimator=logistic, n_estimators=10, learning_rate=0.01, algorithm='SAMME', random_state=111)\nadabo_clf.fit(X_train_transformed, y_train)\n\ny_pred_train = adabo_clf.predict(X_train_transformed)\ny_pred_test = adabo_clf.predict(X_test_transformed)\ny_prob_test = adabo_clf.predict_proba (X_test_transformed)\n\ncm_train = confusion_matrix(y_train, y_pred_train)\nreport_train = classification_report(y_train, y_pred_train)\n\ncm_test = confusion_matrix(y_test, y_pred_test)\nreport_test = classification_report(y_test, y_pred_test)\n\nprint(\"Evaluation the Model on Training Set\")\nprint(f\"Confusion Matrix:\\n{cm_train}\")\nprint(f\"Classification Report:\\n{report_train}\")\nprint(\"-\"*80)\nprint(\"Evaluation the Model on Testing Set\")\nprint(f\"Confusion Matrix:\\n{cm_test}\")\nprint(f\"Classification Report:\\n{report_test}\")","metadata":{"execution":{"iopub.status.busy":"2024-07-06T18:23:40.149712Z","iopub.execute_input":"2024-07-06T18:23:40.150172Z","iopub.status.idle":"2024-07-06T18:23:40.260625Z","shell.execute_reply.started":"2024-07-06T18:23:40.150115Z","shell.execute_reply":"2024-07-06T18:23:40.259399Z"},"trusted":true},"execution_count":29,"outputs":[{"name":"stdout","text":"Evaluation the Model on Training Set\nConfusion Matrix:\n[[274  90]\n [ 25  96]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.92      0.75      0.83       364\n           1       0.52      0.79      0.63       121\n\n    accuracy                           0.76       485\n   macro avg       0.72      0.77      0.73       485\nweighted avg       0.82      0.76      0.78       485\n\n--------------------------------------------------------------------------------\nEvaluation the Model on Testing Set\nConfusion Matrix:\n[[120  33]\n [ 16  41]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.88      0.78      0.83       153\n           1       0.55      0.72      0.63        57\n\n    accuracy                           0.77       210\n   macro avg       0.72      0.75      0.73       210\nweighted avg       0.79      0.77      0.77       210\n\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Stacking  \nStacking in classification is an ensemble learning technique that **combines multiple base classifiers** to improve **classification accuracy**. Unlike traditional ensemble methods like bagging and boosting, *stacking involves training a meta-model that learns how to best combine the predictions of the base classifiers*. The process typically follows a two-stage approach: in the first stage, diverse base classifiers are trained on the dataset; in the second stage, a meta-model is trained using the predictions from these base classifiers as inputs. This **meta-model** then makes the final prediction. Stacking helps in **reducing bias and variance** by leveraging the strengths of different models and can lead to improved performance over individual classifiers. However, it requires careful tuning and validation to avoid overfitting and maximize its benefits in classification tasks.","metadata":{}},{"cell_type":"markdown","source":"### Fit the Base Classifiers","metadata":{}},{"cell_type":"code","source":"from sklearn.tree import DecisionTreeClassifier\n\ntree = DecisionTreeClassifier(criterion='gini', max_depth=2, min_samples_split=10, \n                             min_samples_leaf=5, random_state=111, class_weight=\"balanced\") ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.linear_model import LogisticRegression\n\nlogistic = LogisticRegression(penalty=None, C=1.0, fit_intercept=True, class_weight='balanced', l1_ratio=None)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.svm import LinearSVC\n\nlsvm = LinearSVC(penalty='l1', loss='squared_hinge', C=0.5, multi_class='ovr',\n                 fit_intercept=True, class_weight='balanced', dual=False, random_state=111, max_iter=1000000)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.naive_bayes import GaussianNB\n\nnb = GaussianNB(priors=None)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.neural_network import MLPClassifier\n\nann = MLPClassifier(hidden_layer_sizes=(20, 10), activation='tanh', solver='adam', alpha=0, batch_size=20,\n                learning_rate='constant', learning_rate_init=0.01, max_iter=100000, random_state=111, n_iter_no_change=20)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Fit the Stacking Classifier","metadata":{}},{"cell_type":"markdown","source":"### Parameters\n\n#### `estimators` list of (str, estimator)\nBase estimators which will be stacked together. Each element of the list is defined as a tuple of string (i.e., name) and an estimator instance. An estimator can be set to ‘drop’ using `set_params`.\n\n#### `final_estimator` estimator, default=None\nA classifier which will be used to combine the base estimators. The default classifier is a `LogisticRegression`.\n\n#### `cv` int, cross-validation generator, iterable, or “prefit”, default=None\nDetermines the cross-validation splitting strategy used in `cross_val_predict` to train `final_estimator`. Possible inputs for `cv` are:\n\n- None, to use the default 5-fold cross-validation,\n- integer, to specify the number of folds in a (Stratified) KFold,\n- An object to be used as a cross-validation generator,\n- An iterable yielding train, test splits,\n- \"prefit\" to assume the estimators are prefit. In this case, the estimators will not be refitted.\n\n#### `stack_method` {'auto', 'predict_proba', 'decision_function', 'predict'}, default='auto'\nMethods called for each base estimator. It can be:\n\n- if 'auto', it will try to invoke, for each estimator, 'predict_proba', 'decision_function' or 'predict' in that order.\n- otherwise, one of 'predict_proba', 'decision_function' or 'predict'. If the method is not implemented by the estimator, it will raise an error.\n\n#### `n_jobs` int, default=None\nThe number of jobs to run in parallel for all estimators fit. None means 1 unless in a `joblib.parallel_backend` context. -1 means using all processors. See Glossary for more details.\n\n#### `passthrough` bool, default=False\nWhen False, only the predictions of estimators will be used as training data for `final_estimator`. When True, the `final_estimator` is trained on the predictions as well as the original training data.\n\n#### `verbose` int, default=0\nVerbosity level.\n","metadata":{}},{"cell_type":"code","source":"from sklearn.ensemble import StackingClassifier\nfrom sklearn.metrics import confusion_matrix, classification_report\n\nstack_clf = StackingClassifier([(\"tree\",tree), (\"logistic\",logistic), (\"lsvm\",lsvm), (\"nb\",nb)], \n                               final_estimator=nb, cv=5, stack_method='auto', n_jobs=-1, passthrough=True, verbose=0)\n\n# Fit the model\nstack_clf.fit(X_train_transformed, y_train)\n\n# Make predictions\ny_pred_train = stack_clf.predict(X_train_transformed)\ny_pred_test = stack_clf.predict(X_test_transformed)\n#y_prob_test = stack_clf.predict_proba(X_test_discretized)\n\n# Evaluate the model on the training set\ncm_train = confusion_matrix(y_train, y_pred_train)\nreport_train = classification_report(y_train, y_pred_train)\n\n# Evaluate the model on the testing set\ncm_test = confusion_matrix(y_test, y_pred_test)\nreport_test = classification_report(y_test, y_pred_test)\n\n# Print the evaluation results\nprint(\"Evaluation of the Model on Training Set\")\nprint(f\"Confusion Matrix:\\n{cm_train}\")\nprint(f\"Classification Report:\\n{report_train}\")\nprint(\"-\"*80)\nprint(\"Evaluation of the Model on Testing Set\")\nprint(f\"Confusion Matrix:\\n{cm_test}\")\nprint(f\"Classification Report:\\n{report_test}\")\n","metadata":{"execution":{"iopub.status.busy":"2024-07-06T18:31:04.551190Z","iopub.execute_input":"2024-07-06T18:31:04.551606Z","iopub.status.idle":"2024-07-06T18:31:06.591581Z","shell.execute_reply.started":"2024-07-06T18:31:04.551576Z","shell.execute_reply":"2024-07-06T18:31:06.590107Z"},"trusted":true},"execution_count":30,"outputs":[{"name":"stdout","text":"Evaluation of the Model on Training Set\nConfusion Matrix:\n[[286  78]\n [ 32  89]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.90      0.79      0.84       364\n           1       0.53      0.74      0.62       121\n\n    accuracy                           0.77       485\n   macro avg       0.72      0.76      0.73       485\nweighted avg       0.81      0.77      0.78       485\n\n--------------------------------------------------------------------------------\nEvaluation of the Model on Testing Set\nConfusion Matrix:\n[[125  28]\n [ 17  40]]\nClassification Report:\n              precision    recall  f1-score   support\n\n           0       0.88      0.82      0.85       153\n           1       0.59      0.70      0.64        57\n\n    accuracy                           0.79       210\n   macro avg       0.73      0.76      0.74       210\nweighted avg       0.80      0.79      0.79       210\n\n","output_type":"stream"}]},{"cell_type":"code","source":"stack_clf","metadata":{"trusted":true},"execution_count":31,"outputs":[{"execution_count":31,"output_type":"execute_result","data":{"text/plain":"StackingClassifier(cv=5,\n                   estimators=[('tree',\n                                DecisionTreeClassifier(class_weight='balanced',\n                                                       max_depth=2,\n                                                       min_samples_leaf=5,\n                                                       min_samples_split=10,\n                                                       random_state=111)),\n                               ('logistic',\n                                LogisticRegression(class_weight='balanced',\n                                                   penalty=None)),\n                               ('lsvm',\n                                LinearSVC(C=0.5, class_weight='balanced',\n                                          dual=False, max_iter=1000000,\n                                          penalty='l1', random_state=111)),\n                               ('nb', GaussianNB())],\n                   final_estimator=GaussianNB(), n_jobs=-1, passthrough=True)","text/html":"<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>StackingClassifier(cv=5,\n                   estimators=[(&#x27;tree&#x27;,\n                                DecisionTreeClassifier(class_weight=&#x27;balanced&#x27;,\n                                                       max_depth=2,\n                                                       min_samples_leaf=5,\n                                                       min_samples_split=10,\n                                                       random_state=111)),\n                               (&#x27;logistic&#x27;,\n                                LogisticRegression(class_weight=&#x27;balanced&#x27;,\n                                                   penalty=None)),\n                               (&#x27;lsvm&#x27;,\n                                LinearSVC(C=0.5, class_weight=&#x27;balanced&#x27;,\n                                          dual=False, max_iter=1000000,\n                                          penalty=&#x27;l1&#x27;, random_state=111)),\n                               (&#x27;nb&#x27;, GaussianNB())],\n                   final_estimator=GaussianNB(), n_jobs=-1, passthrough=True)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">StackingClassifier</label><div class=\"sk-toggleable__content\"><pre>StackingClassifier(cv=5,\n                   estimators=[(&#x27;tree&#x27;,\n                                DecisionTreeClassifier(class_weight=&#x27;balanced&#x27;,\n                                                       max_depth=2,\n                                                       min_samples_leaf=5,\n                                                       min_samples_split=10,\n                                                       random_state=111)),\n                               (&#x27;logistic&#x27;,\n                                LogisticRegression(class_weight=&#x27;balanced&#x27;,\n                                                   penalty=None)),\n                               (&#x27;lsvm&#x27;,\n                                LinearSVC(C=0.5, class_weight=&#x27;balanced&#x27;,\n                                          dual=False, max_iter=1000000,\n                                          penalty=&#x27;l1&#x27;, random_state=111)),\n                               (&#x27;nb&#x27;, GaussianNB())],\n                   final_estimator=GaussianNB(), n_jobs=-1, passthrough=True)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>tree</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">DecisionTreeClassifier</label><div class=\"sk-toggleable__content\"><pre>DecisionTreeClassifier(class_weight=&#x27;balanced&#x27;, max_depth=2, min_samples_leaf=5,\n                       min_samples_split=10, random_state=111)</pre></div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>logistic</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(class_weight=&#x27;balanced&#x27;, penalty=None)</pre></div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>lsvm</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearSVC</label><div class=\"sk-toggleable__content\"><pre>LinearSVC(C=0.5, class_weight=&#x27;balanced&#x27;, dual=False, max_iter=1000000,\n          penalty=&#x27;l1&#x27;, random_state=111)</pre></div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>nb</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" ><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GaussianNB</label><div class=\"sk-toggleable__content\"><pre>GaussianNB()</pre></div></div></div></div></div></div></div></div><div class=\"sk-item\"><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>final_estimator</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-6\" type=\"checkbox\" ><label for=\"sk-estimator-id-6\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GaussianNB</label><div class=\"sk-toggleable__content\"><pre>GaussianNB()</pre></div></div></div></div></div></div></div></div></div></div></div></div>"},"metadata":{}}]},{"cell_type":"code","source":"from sklearn.tree import DecisionTreeClassifier\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.svm import LinearSVC\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.neural_network import MLPClassifier\nfrom sklearn.ensemble import StackingClassifier\nfrom sklearn.metrics import roc_curve, roc_auc_score\nimport matplotlib.pyplot as plt\n\n# Define individual classifiers\ntree = DecisionTreeClassifier(criterion='gini', max_depth=2, min_samples_split=10, \n                              min_samples_leaf=5, random_state=111, class_weight=\"balanced\")\nlogistic = LogisticRegression(penalty=None, C=1.0, fit_intercept=True, class_weight='balanced', l1_ratio=None)\nlsvm = LinearSVC(penalty='l1', loss='squared_hinge', C=0.5, multi_class='ovr',\n                 fit_intercept=True, class_weight='balanced', dual=False, random_state=111, max_iter=1000000)\nnb = GaussianNB(priors=None)\nann = MLPClassifier(hidden_layer_sizes=(20, 10), activation='tanh', solver='adam', alpha=0, batch_size=20,\n                    learning_rate='constant', learning_rate_init=0.01, max_iter=100000, random_state=111, n_iter_no_change=20)\n\n# Fit each individual model\ntree.fit(X_train_transformed, y_train)\nlogistic.fit(X_train_transformed, y_train)\nlsvm.fit(X_train_transformed, y_train)\nnb.fit(X_train_transformed, y_train)\nann.fit(X_train_transformed, y_train)\n\n# Create a stacked classifier\nstack_clf = StackingClassifier(estimators=[(\"tree\", tree), (\"logistic\", logistic), \n                                           (\"lsvm\", lsvm), (\"nb\", nb)], \n                               final_estimator=nb, cv=5, stack_method='auto', n_jobs=-1, passthrough=True, verbose=0)\n\n# Fit the stacked classifier\nstack_clf.fit(X_train_transformed, y_train)\n\n# Compute ROC curves and ROC area for each classifier\nclassifiers = {\n    \"Decision Tree\": tree,\n    \"Logistic Regression\": logistic,\n    \"Linear SVM\": lsvm,\n    \"Gaussian Naive Bayes\": nb,\n    \"MLP Classifier\": ann,\n    \"Stacked Classifier\": stack_clf\n}\n\n# Initialize lists to store fpr, tpr, and roc_auc for each classifier\nfpr = {}\ntpr = {}\nroc_auc = {}\n\n# Compute ROC curves and ROC area for each classifier\nfor name, clf in classifiers.items():\n    if name == \"Linear SVM\":\n        y_pred_decision = clf.decision_function(X_test_transformed)\n        fpr[name], tpr[name], _ = roc_curve(y_test, y_pred_decision)\n    elif name == \"Stacked Classifier\":\n        y_pred_proba = stack_clf.predict_proba(X_test_transformed)[:, 1]\n        fpr[name], tpr[name], _ = roc_curve(y_test, y_pred_proba)\n    else:\n        y_pred_proba = clf.predict_proba(X_test_transformed)[:, 1]\n        fpr[name], tpr[name], _ = roc_curve(y_test, y_pred_proba)\n        \n    roc_auc[name] = roc_auc_score(y_test, y_pred_proba)\n\n# Plot ROC curves\nplt.figure(figsize=(6, 4))\nfor name in classifiers:\n    plt.plot(fpr[name], tpr[name], lw=2, label=f'{name} (AUC = {roc_auc[name]:.2f})')\n\nplt.plot([0, 1], [0, 1], color='gray', lw=1, linestyle='--')\nplt.xlim([0.0, 1.0])\nplt.ylim([0.0, 1.05])\nplt.xlabel('False Positive Rate')\nplt.ylabel('True Positive Rate')\nplt.title('ROC Curves on Test Data')\nplt.legend(loc='lower right')\nplt.grid(True)\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-07-06T18:33:25.511095Z","iopub.execute_input":"2024-07-06T18:33:25.511508Z","iopub.status.idle":"2024-07-06T18:33:28.734875Z","shell.execute_reply.started":"2024-07-06T18:33:25.511478Z","shell.execute_reply":"2024-07-06T18:33:28.733733Z"},"trusted":true},"execution_count":32,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 600x400 with 1 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAAiMAAAGJCAYAAABYRTOkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADnNklEQVR4nOzdd3xT1fvA8c9N2qR70QkUyt57yV5FCogDlSHbraAgLvz5FcStOBBF8ftlyVBElL0sZe+9N5Qho4PumXV+f6QNDU1LW9qmLef9elXbm5ubJ7cleXLuc56jCCEEkiRJkiRJdqKydwCSJEmSJD3YZDIiSZIkSZJdyWREkiRJkiS7ksmIJEmSJEl2JZMRSZIkSZLsSiYjkiRJkiTZlUxGJEmSJEmyK5mMSJIkSZJkVzIZkSRJkiTJrmQyIkmSJEmSXclkRHpgzZs3D0VRLF8ODg5UqVKFUaNGcf36dZv3EUKwYMECunTpgpeXFy4uLjRp0oSPPvqI1NTUPB9r2bJl9OnTB19fXzQaDZUrV2bgwIFs2rSpQLFmZGTw3Xff0a5dOzw9PXFycqJu3bqMHTuWc+fOFen5S9CtWzerv4G8vj788MNiebyffvqJefPmFXj/u/8+fXx8aNWqFePGjePUqVNFjiMtLY0PP/yQLVu2FPkYklScFLk2jfSgmjdvHqNHj+ajjz6iRo0aZGRksGfPHubNm0dISAgnTpzAycnJsr/RaOSZZ55hyZIldO7cmQEDBuDi4sL27dv57bffaNiwIRs3biQgIMByHyEEzz77LPPmzaNFixY89dRTBAYGcvPmTZYtW8bBgwfZuXMnHTp0yDPO2NhYwsLCOHjwII888gihoaG4ublx9uxZFi9ezK1bt9DpdCV6riqq8PBwoqKiLD/v37+f6dOn83//9380aNDAsr1p06Y0bdr0vh+vcePG+Pr6FjgJUBSFXr16MWLECIQQJCYmcvToUf78809SU1P58ssvmTBhQqHjiI2Nxc/Pj8mTJxdboiVJ90VI0gNq7ty5AhD79++32v7uu+8KQPzxxx9W2z/77DMBiLfeeivXsVauXClUKpUICwuz2j516lQBiPHjxwuTyZTrfvPnzxd79+7NN85+/foJlUolli5dmuu2jIwM8eabb+Z7/4LS6/UiMzOzWI5VXv35558CEJs3by6R4zdq1Eh07dq1wPsDYsyYMbm2x8bGivbt2wtArFmzptBxxMTECEBMnjy50PeVpJIgkxHpgZVXMrJ69WoBiM8++8yyLS0tTXh7e4u6desKvV5v83ijR48WgNi9e7flPj4+PqJ+/frCYDAUKcY9e/YIQLzwwgsF2r9r16423+xGjhwpqlevbvk5MjJSAGLq1Kniu+++EzVr1hQqlUrs2bNHqNVq8eGHH+Y6xpkzZwQgfvjhB8u2+Ph4MW7cOFG1alWh0WhErVq1xBdffCGMRqPVfX///XfRsmVL4ebmJtzd3UXjxo3FtGnT7vl8UlJSxIQJEyzHr1u3rpg6dWquxC77TXvZsmWiUaNGQqPRiIYNG4p169bd8zFyyisZWbt2rejUqZNwcXERbm5uom/fvuLEiRNW+9y8eVOMGjVKVKlSRWg0GhEYGCgeffRRERkZKYQQonr16gKw+rpXYpJXMiKEEFeuXBEODg6iQ4cOlm2ZmZnigw8+EC1bthQeHh7CxcVFdOrUSWzatMmyT/bv/u6v7MTk6NGjYuTIkaJGjRpCq9WKgIAAMXr0aBEbG1uwkyhJReBQWiMwklReXL58GQBvb2/Lth07dhAfH8+4ceNwcLD9z2bEiBHMnTuX1atX89BDD7Fjxw7i4uIYP348arW6SLGsXLkSgOHDhxfp/vcyd+5cMjIyePHFF9FqtQQFBdG1a1eWLFnC5MmTrfb9448/UKvVPP3004C57qBr165cv36dl156iWrVqrFr1y7ee+89bt68ybRp0wDzpZAhQ4bQs2dPvvzySwBOnz7Nzp07GTduXJ6xCSF49NFH2bx5M8899xzNmzdnw4YNvP3221y/fp3vvvvOav8dO3bw999/8+qrr+Lu7s706dN58sknuXr1KpUqVSryOVqwYAEjR46kd+/efPnll6SlpfHzzz/TqVMnDh8+TEhICABPPvkkJ0+e5LXXXiMkJITo6GjCw8O5evUqISEhTJs2jddeew03Nzfef/99AKtLeoVVrVo1unbtyubNm0lKSsLDw4OkpCRmzZrFkCFDeOGFF0hOTmb27Nn07t2bffv20bx5c/z8/Pj555955ZVXeOKJJxgwYACA5TJUeHg4ly5dYvTo0QQGBnLy5En++9//cvLkSfbs2YOiKEWOWZLyZO9sSJLsJXtkZOPGjSImJkZcu3ZNLF26VPj5+QmtViuuXbtm2XfatGkCEMuWLcvzeHFxcQIQAwYMEEII8f3339/zPvfyxBNPCEDEx8cXaP/Cjox4eHiI6Ohoq31/+eUXAYjjx49bbW/YsKHo0aOH5eePP/5YuLq6inPnzlntN3HiRKFWq8XVq1eFEEKMGzdOeHh4FHp0aPny5QIQn3zyidX2p556SiiKIi5cuGDZBgiNRmO17ejRo7lGcu7l7pGR5ORk4eXllWtk6tatW8LT09OyPT4+3jLSlJ/iukyTbdy4cQIQR48eFUIIYTAYcl1qi4+PFwEBAeLZZ5+1bMvvMk1aWlqubb///rsAxLZt2wocuyQVhpxNIz3wQkND8fPzIzg4mKeeegpXV1dWrlxJ1apVLfskJycD4O7unudxsm9LSkqy+n9+97mX4jhGfp588kn8/Pystg0YMAAHBwf++OMPy7YTJ05w6tQpBg0aZNn2559/0rlzZ7y9vYmNjbV8hYaGYjQa2bZtGwBeXl6kpqYSHh5eqNjWrl2LWq3m9ddft9r+5ptvIoRg3bp1VttDQ0OpVauW5eemTZvi4eHBpUuXCvW4OYWHh5OQkMCQIUOsnqNaraZdu3Zs3rwZAGdnZzQaDVu2bCE+Pr7Ij1dYbm5uwJ2/T7VajUajAcBkMhEXF4fBYKB169YcOnSoQMd0dna2fJ+RkUFsbCwPPfQQQIGPIUmFJZMR6YE3Y8YMwsPDWbp0KX379iU2NhatVmu1T3YykP2ib8vdCYuHh8c973MvxXGM/NSoUSPXNl9fX3r27MmSJUss2/744w8cHBwsQ/oA58+fZ/369fj5+Vl9hYaGAhAdHQ3Aq6++St26denTpw9Vq1bl2WefZf369feM7cqVK1SuXDlXIpY9y+XKlStW26tVq5brGN7e3veVHJw/fx6AHj165Hqe//zzj+U5arVavvzyS9atW0dAQABdunThq6++4tatW0V+7IJISUkBrJPVX3/9laZNm+Lk5ESlSpXw8/NjzZo1JCYmFuiYcXFxjBs3joCAAJydnfHz87P8nRT0GJJUWLJmRHrgtW3bltatWwPw+OOP06lTJ5555hnOnj1r+eSZ/QZ47NgxHn/8cZvHOXbsGAANGzYEoH79+gAcP348z/vcS85jdO7c+Z77K4qCsDFb32g02tw/56fgnAYPHszo0aM5cuQIzZs3Z8mSJfTs2RNfX1/LPiaTiV69evHOO+/YPEbdunUB8Pf358iRI2zYsIF169axbt065s6dy4gRI/j111/v+ZwKKq+6HFvno6BMJhNgrhsJDAzMdXvO+qHx48fTv39/li9fzoYNG/jggw/4/PPP2bRpEy1atChyDPk5ceIEarXakiwsXLiQUaNG8fjjj/P222/j7++PWq3m888/5+LFiwU65sCBA9m1axdvv/02zZs3x83NDZPJRFhYmOV8SFKxs/NlIkmym7xm02zevFkA4vPPP7dsS01NFV5eXqJevXp51j48++yzVrNpUlNThbe3t2jQoEGRZ9Ps2rVLAOLFF18s0P5PPPGEaNasWa7tnTt3znM2jS3x8fFCo9GIiRMnisOHDwtAzJ0712qfhg0bivbt2xf0qVgYjUbx0ksvCUCcP38+z/1efPFFoVarRVJSktX27BlGOWtByKO2onr16mLkyJEFju3umpElS5YIQGzYsKHAx8h27tw54eLiIoYOHWrZ1rhx42KrGcmeTdOpUyfLtscee0zUrFkz12yjDh06WP3+Y2NjbdaMZNc9TZkyJddzsbW/JBUXeZlGku7SrVs32rZty7Rp08jIyADAxcWFt956i7Nnz1pmQuS0Zs0a5s2bR+/evS3X111cXHj33Xc5ffo07777rs1P6AsXLmTfvn15xtK+fXvCwsKYNWsWy5cvz3W7Tqfjrbfesvxcq1Ytzpw5Q0xMjGXb0aNH2blzZ4GfP5jrPHr37s2SJUtYvHgxGo0m1+jOwIED2b17Nxs2bMh1/4SEBAwGAwC3b9+2uk2lUllmbmRmZuYZQ9++fTEajfz4449W27/77jsURaFPnz6Fek5F0bt3bzw8PPjss8/Q6/W5bs8+z2lpaZa/lWy1atXC3d3d6jm6urqSkJBw33HFxcUxZMgQjEaj1d9j9uhQzr+1vXv3snv3bqv7u7i4AOSKxdb9AcvMKEkqKfIyjSTZ8Pbbb/P0008zb948Xn75ZQAmTpzI4cOH+fLLL9m9ezdPPvkkzs7O7Nixg4ULF9KgQYNclx3efvttTp48yTfffMPmzZstHVhv3brF8uXL2bdvH7t27co3lvnz5/Pwww8zYMAA+vfvT8+ePXF1deX8+fMsXryYmzdv8vXXXwPw7LPP8u2339K7d2+ee+45oqOjmTlzJo0aNbIUwxbUoEGDGDZsGD/99BO9e/fGy8sr13NbuXIljzzyCKNGjaJVq1akpqZy/Phxli5dyuXLl/H19eX5558nLi6OHj16ULVqVa5cucIPP/xA8+bNrbqc3q1///50796d999/n8uXL9OsWTP++ecfVqxYwfjx462KVUuKh4cHP//8M8OHD6dly5YMHjwYPz8/rl69ypo1a+jYsSM//vgj586do2fPngwcOJCGDRvi4ODAsmXLiIqKYvDgwZbjtWrVip9//plPPvmE2rVr4+/vT48ePfKN4dy5cyxcuBAhBElJSZYOrCkpKXz77beEhYVZ9n3kkUf4+++/eeKJJ+jXrx+RkZHMnDmThg0bWupLwHx5rmHDhvzxxx/UrVsXHx8fGjduTOPGjS31Lnq9nipVqvDPP/8QGRlZ/CdXknKy78CMJNlPXpdphDBfSqhVq5aoVauW1SUWo9Eo5s6dKzp27Cg8PDyEk5OTaNSokZgyZYpISUnJ87GWLl0qHn74YeHj4yMcHBxEUFCQGDRokNiyZUuBYk1LSxNff/21aNOmjXBzcxMajUbUqVNHvPbaa1bTWYUQYuHChaJmzZpCo9GI5s2biw0bNuTb9CwvSUlJwtnZWQBi4cKFNvdJTk4W7733nqhdu7bQaDTC19dXdOjQQXz99ddCp9NZPXd/f3+h0WhEtWrVxEsvvSRu3rx5z+ednJws3njjDVG5cmXh6Ogo6tSpk2/Ts7vd72WabJs3bxa9e/cWnp6ewsnJSdSqVUuMGjVKHDhwQAhhvuwxZswYUb9+feHq6io8PT1Fu3btxJIlS6yOc+vWLdGvXz/h7u5e4KZn2V8qlUp4eXmJFi1aiHHjxomTJ0/m2t9kMonPPvtMVK9eXWi1WtGiRQuxevXqXL9/IcyXAFu1aiU0Go3VJZh///1XPPHEE8LLy0t4enqKp59+Wty4cUNeppFKlFybRpIkSZIku5I1I5IkSZIk2ZVMRiRJkiRJsiuZjEiSJEmSZFcyGZEkSZIkya5kMiJJkiRJkl3JZESSJEmSJLt64JqemUwmbty4gbu7O4qi2DscSZIkSSo3hBAkJydTuXJlVKriG8944JKRGzduEBwcbO8wJEmSJKncunbtGlWrVi224z1wyUj2UtuRkZH4+PjYOZoHg16v559//uHhhx/G0dHR3uE8EOQ5L33ynJc+ec5LX1xcHDVq1LC8lxaXBy4Zyb404+7ujoeHh52jeTDo9XpcXFzw8PCQLxilRJ7z0ifPeemT57z0ZS8YWdxlDrKAVZIkSZIku5LJiCRJkiRJdiWTEUmSJEmS7EomI5IkSZIk2ZVMRiRJkiRJsiuZjEiSJEmSZFcyGZEkSZIkya7smoxs27aN/v37U7lyZRRFYfny5fe8z5YtW2jZsiVarZbatWszb968Eo9TkiRJkqSSY9dkJDU1lWbNmjFjxowC7R8ZGUm/fv3o3r07R44cYfz48Tz//PNs2LChhCOVJEmSJKmk2LUDa58+fejTp0+B9585cyY1atTgm2++AaBBgwbs2LGD7777jt69e5dUmJIkSZIklaBy1Q5+9+7dhIaGWm3r3bs348ePz/M+mZmZZGZmWn5OSkoCzC1ts9vaSiUr+zzL81165DkvfQ/SOQ+/Gs7Px34mTZ9mfYMhHTKTQYjSC0YIpi94/567Bd5yoe4FL9QG6wsCapMjjkYnoHRWcVdEaT1SyUg3GEvkuOUqGbl16xYBAQFW2wICAkhKSiI9PR1nZ+dc9/n888+ZMmVKru2bN2/GxcWlxGKVcgsPD7d3CA8cec5L34Nwzr9P+p4YU4ztG1VQum+3BXusDhe8cUu1tX6NANKLNaJ7KcVUrVgZ3L1I9Q4skWOXq2SkKN577z0mTJhg+TkpKYng4GC6d+9OpUqV7BjZg0Ov1xMeHk6vXr3kYlalRJ7z0vcgnfPpy6ZDOqgUFb5OvnduSIkCkfXJWVGXTjBCQAEWbdMazPsIBBnaO5/unfQeKMI8WiIUU8nEmIOqHGYiJgcHMgODMLh7oIqNLZHHKFfJSGBgIFFRUVbboqKi8PDwsDkqAqDVatFqtbm2Ozo6VvgXjLJGnvPSJ8956XsgznnWe7+vsy8RT0fc2f5NA0i+Ae6V4c0TJR6GXq9n7dq19O3b957n/Jf9I0nJvI27jy9v/fyrZfu8iTtJTcjE1UvLqC86lnTInO/aDUNUFA4BAdTZuqVEH0sIwY3EDE7dSOLUjSRO3kjk1M0k/o0v2EhQkKcTTX1VVI7ahaODI926h9KgRjCf/vhjscdarpKR9u3bs3btWqtt4eHhtG/f3k4RSZIkSZL96Y0mLsakZCUd5uTj1M0kEtPvXcOkVinU8nOlYZAHDSt70DDIk2ruUC3QFyEEu3dradmyJU5OTty+fbtE4rdrMpKSksKFCxcsP0dGRnLkyBF8fHyoVq0a7733HtevX2f+/PkAvPzyy/z444+88847PPvss2zatIklS5awZs0aez0FSZIkSSo1BqOJK3FpnI9K4WJMCuejkjkfncL5qBR0xntfZnLRqGkQ5EHDIA8aVTYnH3UD3HFyNF9W0+v1bN26lV9372bkyJFUq1aNDh06lPTTsm8ycuDAAbp37275Obu2Y+TIkcybN4+bN29y9epVy+01atRgzZo1vPHGG3z//fdUrVqVWbNmyWm9kiRJRXVyGWz+DDJTct10Ns6VXf/6oDNaz0DprnLEpFRBJeCXFWF3bhBVgarmepFXRpZw4OZykYyMDGav+/ueZSMp8XEApCXqmDdxp2V7WmKmzf2T1q8nZvoPmFJTiy1eAENMHoW/d8k0GLkcm8b56GTOR6VwIdr8dSk2Bb2xYIUn/u5aS8LRMMiThpU9qO7jgkpl+2RdvHiRNWvWkJSURNeuXalSpUqBn9f9smsy0q1bN0Q+U8BsdVft1q0bhw8fLsGoJEmSHiCbP4PYczZv2nW1FXE6Ta7tOSv0rFOYHG8pcSUznG9LanrBEwYhHElNyJ2AaJysC25jpv+A7tKl+44tLypXVwDSdUYuxpgTjZyJx5W4NIymgiUdapVCSCUXGlX2zEo8PGgQ5IGfe+56ybwcO3aMZcuWERISwtChQ0t9gke5qhmRJEmSiln2iIiiAjfraZs6YU5EFASujndmoMSowKSYZ4b43X1lQFFA6w6OticVFKfskREnJ6d7joykJeoQwhFHlw64elm/SWuc1LTtX9Nqm2VERKXCwc+vGGIVGEwCg1GQ4ahlU9O+rPlqE//Gpxe4LYujWqGmrxu1A9yo7edGnQA36vi7E+Lrgtah8LOXhBDExsbi5+dHvXr1eOKJJ2jSpAlKAWYnFTeZjEiSJEnmROTN09bbXhkJcbdx9fHlpRwzUHr+2ZPotGj8XfytZ9OUssLMpinqrBkHP79CzXqJT9VxIcZcw3E+OtlyeeVmYkbuneNsz2pxclRRy8+NOv5u1AlwN38f4EZ1Hxcc1MWzisvt27dZvXo1169fZ/z48bi4uNC0adNiOXZRyGREkiRJkgpBCEFMSiYXolJyJR6xKboCH8dN60At/6ykw//OSEcVL+c86zrul9FoZOfOnWzbtg0PDw8GDRpUJhqAymREkiSprMlRVLpBozDDRUVqMb43tT/oTOBNb4SiAqpnfQG7wqz206nVoCjooqPY1baRZfsUYb42o1Jucf7HbsUXWCEJIaiRkUHkN9/e89KCofZ4cPTAEBPD+a7d7nns7EJTo0mw9VwM56OSs2avpHA+OqVAU2azeTo7UjfAjdr+7tTOkXgEejiV+iWRtWvXcvjwYTp06EDXrl3LTE8cmYxIkiSVNTmKSmdUCSKyCPUA+Qm86U2mY+7C1Lw4Gkx4J9maNmrCkBRlY3vpcQSMWWuO5atmVs2LyYghquAxX0mHl+bsK9C+vm7aHCMcblmjHu74umnsUoeRLSMjg6SkJPz9/enYsSNt2rQhMLBk2roXlUxGJEmSypocRaWpavPLtEoIfIupW7l5RAQQAo0x/4XP1CYTVRLjifewrlVQocJV44qT2ql4gioCIUSOAtZ7vNmr1Jb/G3x8LcWkBpMJg0nYXDAmzUHLgga5W0dU9nSyJBrZiUdtfze8XAqe4JUGIQSnT59m3bp1uLm58eKLL+Lj42PvsGySyYgkSVJZ5RYI7gGQFo2va0CxFYvOWNsXACeTYMxf64vlmPaQVwFrpsFIZGyq5ZLKxegUauxOwNkAsRp3+neZeM9jKwoEe7tQx9+Nl7KSDXMxqSvuTmXj0kZ+EhMTWbt2LefOnaN+/fr06dPHrqMz9yKTEUmSJKlcStMZuJYCK47c4NLtdM5nzVy5cjuVu1t0vGx0wtYKv2qVQvVKLllFpOaRjlp+5i9nTSkt9lfMhBAsWrSIjIwMBg4cSIMGDewd0j3JZESSJKkg8ulUCuCA4OGMDBwuvEtBl7XPqzi1iqkFDRI+wPG2Ew9fMW9TKyrmHdyZ+yB3yUw9TXr8doTJelaHEMLcmAOBUKsBQaaDm1U30rIqZ48Og8mU9X+R1RTMjQs7zMuK1Mr6gtyXjlyzkhMnRxXjQ+tYEo/qlYrWo6MsunnzJs7Oznh5eTFgwAC8vb1tLhRbFslkRJIkqSDy6VQK5vTDGaDgkyzyLE7tfuMRPDJyFximZtpuXZ5TZuI2hCmuYAEoTja7kZZlKkCT9VXQpC8nfx9nngmtW7xB2ZlOp2PLli3s2bOH1q1b07dv3zJXoHovMhmRJEkqiHw6lQIIchRTFvBNMlVtTkTuLk51MjhlHdNEhjYFBQU3jRvaAhSL6pL0WbWYCiq12534TNaFqoqiwcWjPVqv0v/kbBJ3j3KY/1/A7ueAuabDQaWgYELr6IiDWsFBpUKdT38OW51Wy7vz58+zZs0aUlNT6dGjR7ldxV4mI5IkSYVhq1MpYNDr+aeA3UAt/uxpszg1u1uom5czY78ILVR4v7zyX1LiwM3Hx6pr6vmu3TBEReEQEFCojqJFJYTgRmIG56PudCE1ry6bTFKGocDvPl4ujlmzVdwt02Zr+5t7dBgMhgJ3YK2IUlJSWLJkCdWqVWPEiBFldqZMQchkRJIkSSoyo0nwb3yaZebK+ehkLmYlH6m6/KcN5+TnrrV0Iq2dnXwEuFHJ1b49OsoaIQTHjx+nQYMGuLm58cILL+Dn51fuz5FMRiRJkvIoTrUqMPUCvCqDojaPaGQJ/FdF3ZOOqA0KCMHxZf8t8MP2NLigMdYHFL5bNsSy3ZR1vUKXpPDLK/c+nsjIwJiSAkKQoVJAUXJ1Gi3o0vV50RtNXLmdah7hsCQeKVyKSSHTUPAGKJU9nagd4H5X4lH2enSURbGxsaxevZorV66gVqtp1KgR/v7+9g6rWMhkRJIkKY/iVOsC0xwvl2nRlm87HK+MW2p2Q7DCfjoVgHmxNJv9TY2QUsBaVFSK1eOr9QabnUazl67PS4Y+q0dHdAoXopIta69Exqaam4MVgKJANR8XavuZV5itk3WJpZa/G25a+bZTWAaDgR07drBjxw48PT0ZMWIENWrUsHdYxUr+VUiSJOVRnJqrwFRRQOsBjncKSbUm88uoQJDhJLjnWvY5OGW6oghzIpNrYTQFNE4OOGjuvUqrISYGjCZzLqJS4SCgfroRh4AAq/1Urq74vf46YO7RcTE6lfPRyVm1HClcjLHdoyMvapVCSCUX6mSvuZJVz1HLzw0nx4oxXbYsuHr1Ktu3b6djx4507ty5QtbHyGREkiQp293FqXkUmOb0y6aRpKTfxs3blzp9BhSqmLKoy9rfLb/i1MR0PReyupCej07m/M0Uzn+xiesJtpevt0WjVlHTzzVrkTd3S9IRUskVjUPxLGkvWUtPT+fo0aO0a9eOmjVr8vrrr+Pp6WnvsEqMTEYkSZIqCJ3BxMI9V3LMXkkmKqngfUScHdXU8ne9M9KR1QI92NsZB7VMOkqDEIKTJ0+yfv16DAYDdevWxcfHp0InIiCTEUmSKoCzu3ewa8lCdBk2Pu3r0yEzOav76B0ZCqQq2bUa1bO+gFH9LPt0FY5AFVSKml82jbT52Knx8YWK9cLBaPatuoQuw0haYuEajgkhiE7OzCoiTbYUkY5LysAHiEvV8Z/lJ+55HHetQ1Yth5tltKO2vxtVvJxzXy6SSk1CQgJr1qzhwoULNGjQgD59+uDu7m7vsEqFTEYkSSr3di1ZSNyNf/PZw3b9wr3bfd15iUxJv53vnhrngq1eu2/VJeJvpVnf18k6PpNJcCMxa62VqDujHOejU0jOMOQ6Zl41Ht4ujuZE467EI8BDW+6nglZEJ0+eJDo6msGDB1OvXj17h1OqZDIiSVK5lz0ioigqXL29rW9MjgKR1e9CufOmH6MCkwIIc4tx8+2qXAWoKhRcHV1xcsg72dA4OdPuqSGcj00oQKzGrFjBxVMLjgpOLXz4acsFc+IRY04+0grRoyN7NMNFo+bjxxtbps1Wcisf65I8yG7cuMG///5L27Zteeihh2jdunW5WU+mOMlkRJKkCsPV29uq6ygA3zSA5BvgXtmqOLXnnz2JTovG38U/z+LUwtDr9Zxfu9bmbTrDnR4dKZkGFCBNDdMcktDpTbC7YJd6qng5W2o5LLNX/NyJ3j0VQxp4ODsy/KHq9/1cpJKn0+nYtGkT+/btIygoiFatWqFWq1GrH8xZSDIZkSRJKiZ6E5y+mUxkXHrW7BXz1+UcPTpeznDCHQWDUaCz0Swsu0dHzhbote/RoyPa5laprDp37hxr1qwhLS2N0NBQHnroIVSqB7tAWCYjkiQVTEG6lOYh8JYLdS94oTaUzAuuU6YaBYWY1Ch6zmlsfaMXNjunxqbHWr5PWr+emOk/YEpNLdDjWS9pf2ehN61XI/YFp2NSaXEDWmR95aTXaEFR8MlI4rd9X+GgMi/wZl7ozfy9rXKOm/nEc7/dVaXSdeLECfz9/enbty/ed19WfEDJZESSpIIpUJdS2zpc8MYtteQbNWU6CKLVd7+T2+6cms3V0ZWY6T+gu3SpUI+lAI5ZX9nONupBpnPB2nM7GtLxTk3Itb3glSK53au7qmQfQggOHjyIs7MzjRo1on///jg4OMgi4hxkMiJJUsEUtEupDVqD+UVXIMjQ3s/bbd6MDiYu1U7A32hjaomNzqlgTkTGNh+LIeVTc3yKinQPL8uIh6kQa9orCugdnc0/CBMafXKebzYOpkxqxW/P1SH1fuTsriqVHdHR0axevZpr167RoUMHGjVqVCE7qN4vmYxIklQ4RelSun8kKZm3cffx5a27C0xLSXaPDvMib+ZpshdupTBxQQrfJ2XiC9zWujO8+//lexx3J4c7DcFyTJv1c3HgxDvbIBNcvZ0Z9UXoPSIaVGzPTSp7DAYD27ZtY+fOnXh7ezNy5EhCQkLsHVaZJZMRSZIqFJNJcD0h3aoLaXa/juTM3D068uLt4kidAHer/hx1Atzwd7fdo0Ov1xfn05DKOUVRuHTpEp06daJz5844OMi32/zIsyNJFdyGyxuYcWQGqfq7ijP1GZCZlKszaZ68uGchaHEpaEGpuYjUlFVEav7eaBIIYX5xq5/1lR+VSsErMwkwT41d/OJDherRcaejqgFjpqwBeJClpaURHh5O27ZtCQoK4tlnn33gZ8kUlExGJKmCm3FkBpGJkbZvVEHBl72/dyFocSlMQakDxfdC5ubtQbOalQp1H+uOquZzeXdHValiE0Jw/PhxNmzYgMlkol69egQFBclEpBBkMiJJFVz2iIhKUeHr7Hvnhjw6k+brHoWg9yNDb+RiVvfR4NuJOAMmRSFO61Go46hVStY0WZV5qmzWlNl7zVwoagFozo6qKo0Jdy9X2vavWejjSOVTUlISK1as4NKlSzRq1IiwsDDc3NzsHVa5I5MRSXpA+Dr7WheYWnUmvffiasUlJdOQoyFYsuX7q3FplitGCzINOANxWg+Gh32Q6xgOKoUQX1dL2/PaAe7U9nOjpp8rTo72GZVw8dTg3f42fft2lbMlHiBqtZr09HSeeeYZ6tSpY+9wyi2ZjEiSVCIS0/RciEnmfFQKSRkGVEB0ciaNJ28o+EEUaBDkkWP2irkFevVKrjjKJe0lO7l+/ToRERE89dRTuLq68sILL8ieIfdJJiOSJBWZEILbqTrOR6VwITo5a/aK+SsmOdOy3+hMA26QZ98OF42a2lmzVmr7u+G1zREyINDDiXXjOpfSs5Gk/GVmZlqtJ5Oeno6Li4tMRIqBTEYkqaLTZ5j/nxxlvjSTLeWW5duCzF4xmu60Pr+pdSDS2xnDXa/BlbK+Hro7BAfzarjeGUksDv/0TutztbmuQ62yPpAhIa7wz1OSSlBkZCTLli0jIyOD3r1707ZtW1mgWoxkMiJJFV1mknnWjDCaa0TupnUr8OwVddbXlXrBpGsKX5uhMRrxTLVeoVYAeXX/kO3NJXsTQqAoClqtlsqVK9OnTx88PT3tHVaFI5MRSarohMAyfde9snkTYDSZyFC5sMP/OSrFLsANMKIQ73Tv2Su67GXOhUCT1X49e2wjrxFrBwH1040FboEu25tL9mQymThw4ACnTp1ixIgRVK5cmcGDB9s7rApLJiOSVIHlXKJeKGrGBM3nYnQKl2JS0RmzbouBBTojbkC8k+3ZK1W8nKkTcKcFuvK//4PEeNwq+fKSndq7S1JJiYqKYtWqVVy/fp1WrVphMBjQaDT2DqtCk8mIJFUwF6KTmRZ+jn3n1UzYG0G1WuaRESEEa47ltxC9uUdHaIMAq8Sjpp8rrlrrl4pf5qjQleBzkCR72bFjB5s3b8bHx4fRo0dTrVo1e4f0QJDJiFThFaQ484ZWzRl3ba6CzFIlBOYLKOb/Fny92NzqZX0BiLPBgPkyihA/mr9XzFuyn+6xml4gvECtos2eHwCIyfraZeP4qfHxNrY+OO60gDeSlph57ztIZZ7JZEKlUuHp6UmXLl3o2LGjXE+mFMkzLVV4BSnOPF0vmFSHB7kyPsdzj7td4HtpnJxLIJayz7oFvJmjVraAL49SU1P5559/AHjiiSdo0qSJnSN6MMlkRKrwLCMiKhUOfn429zE6Zv1TEAKnPHphlDhhsixaZ1IUy8hIcQ3WKNyjJbqioHZzQ3FyynufHDROznQcNKyYoitfcraAd/HUonFS06pvNc7czL1mj1Q2CSE4evSoJRHp1auXnSN6sMlkRHpgOPj5UWfrFpu3bXplJMTdtm9BZo727D2rVSY6LRp/F3/rFu42/HngGu/+dYzsHOrhhgF8+1RjIsI30LdvX9mavAS5eGoZ9UVHAPR6PWfyL8mRygiTycRvv/3GxYsXadKkCb1798ZVTiO3K5mMSFI5NmdHJB+tPmX5eUDLKnz1ZFOEyWjHqCSpbDIajSiKgkqlombNmrRv355atWrZOywJmYxID7Czu3ewa8lCdBnp91WQuWH7x8w4/yepmO69c368AK/KoKiJTY/Nd1chBNM2nuf7iPOWbaM6hDDpkYaoVAp6mYxY5Cw2LS6yaLX8uXbtGqtWraJZs2Z07NiRDh062DskKQeZjEgPrF1LFhJ341+rbUUpyJxx/k8i1TkaixVZjn+OwpzYuDrmHjo2mQQfrT7FvF2XLdvGh9ZhXM86co0MG2wVmxYXjZMsWi3rMjIyiIiI4MCBA1SuXFmOhJRRMhmRHli6jHQAFEWFq7d3kQsyzSMiCioh8L3PwREUBbQe4OiEq6MrY5uPtbrZYDTx7l/H+evQnSRq0iMNebZTjft84Irr7mLT4qJxUtO2f81iO55U/BITE5k1axY6nY6wsDDatGkj15Mpo2QyIj3wXL29i6Vo1dcEEc+eKIaIbMvQG3n998P8cyoKAJUCXz3VjKdaVS2xx6xIchabShVbWloaLi4ueHh40Lp1a5o3by7Xkynj7J4izpgxg5CQEJycnGjXrh379u3Ld/9p06ZRr149nJ2dCQ4O5o033iAjI6OUopUk+0jNNPDcr/stiYhGreKnoa1kIiJJOZhMJvbs2cO0adO4cOECiqLQtWtXmYiUA3YdGfnjjz+YMGECM2fOpF27dkybNo3evXtz9uxZ/P39c+3/22+/MXHiRObMmUOHDh04d+4co0aNQlEUvv32Wzs8A8neCtJd1RATY/m+JIpWY0s4pU9I0zFq7n6OXEsAwEWj5r/DW9Opjm+xPUZJFHmWFbLY9MFw8+ZNVq9ezY0bN2jdujVVq8pEvTyxazLy7bff8sILLzB69GgAZs6cyZo1a5gzZw4TJ07Mtf+uXbvo2LEjzzzzDAAhISEMGTKEvXv3lmrcUtlRkO6q2VSuruwowaJV1xIYaIxOymD47H2cjUoGwNPZkbmj29CymnexPk5JFnmWFbLYtOK6cOECf/75J35+fjz77LMEBwfbOySpkOyWjOh0Og4ePMh7771n2aZSqQgNDWX37t0279OhQwcWLlzIvn37aNu2LZcuXWLt2rUMHz48z8fJzMwkM/POJ6OkpCTA3KBIr9cX07OR8pN9nkvifBtTUszfqFSoffMeKVC5uuIz5lUyVy0BzEWrLl7eaJydaPfUkELHdnfRqisqXqn1VLE+x6txaYyad5Br8eZCWz83DXNHtqJeoNs9H6ew51yXYQCyizwr3uqkjlpzh9SS/Ddfkn/nkm23b5uXLqhcuTKhoaG0bNkStVotfwclqKTOrd2SkdjYWIxGIwEBAVbbAwICOHPmjM37PPPMM8TGxtKpUyeEEBgMBl5++WX+7//+L8/H+fzzz5kyZUqu7Zs3b8bFxeX+noRUKOHh4cV+zBoZGTgCejc3zr05If+dDQZLfZHKyZmgPgMAOB+bwPm1awv3wMI8KuJrFLzu+xkAugRYW9jj5OFmGvx0Sk2S3jzyUkkreLlOGhcPbediIY5T0HOeke4KqFBpTHi3L/jaNOXJmZvRpdIhtST+ziVrer2e69evk5iYSIMGDdiyZQsAGzZssG9gD4C0tJIZQS1Xs2m2bNnCZ599xk8//US7du24cOEC48aN4+OPP+aDDz6weZ/33nuPCRPuvEklJSURHBxM9+7dqVSpUmmF/kDT6/WEh4fTq1evYm9NHvnNtxiTknBycqJv37733H/2ur9JTU8t8P55mb7gffM3inJfx7Hl6L+JTJ5/iKSsTyC1/VyZO6oVgR4FWzMGCn/OF+3eS2qmDidnJ/r27Vrk2B9kJfl3LpllryezadMmFEUhLCyMGzduyHNeirJHo4qb3ZIRX19f1Go1UVFRVtujoqIIDAy0eZ8PPviA4cOH8/zzzwPQpEkTUlNTefHFF3n//fdtzh/XarVotbl7Czg6Oso/3lJWEuc8u8mXoihWx85ZqJpTWkJ81v7kGcuGyxuYcWQGqfq7imL1GZCZBEJYFa0W53PadSGWF+YfIFVnLiRtVtWTeaPb4u1atEsnd5/zvApV0xJ1Wd8p8t/FfZKvLSUnIiKCHTt20KxZMx5++GEcHR25efOmPOelqKTOs92SEY1GQ6tWrYiIiODxxx8HzNOyIiIiGDt2rM37pKWl5Uo41GpzUZoQdlppVSqTbHVXzSm/otUZR2YQmRhp+0YVlFTR6j8nbzH298PoDObOae1rVuJ/I1vjpi2+f6b3KlSVRZ5SWWMwGEhISMDX15eWLVtSo0YNatY0N5uTtSEVh10v00yYMIGRI0fSunVr2rZty7Rp00hNTbXMrhkxYgRVqlTh888/B6B///58++23tGjRwnKZ5oMPPqB///6WpESSIHd31Zzu1Wk1e0REpajwdc5RFJscBSJrREFR44qKsXUGFku8fx/6l7eXHsOYtfRuaIMAfnymBU6Oxft3nV83UtlRVCprrly5wurVqzGZTIwZMwZvb2+8vYt3JplUNtg1GRk0aBAxMTFMmjSJW7du0bx5c9avX28par169arVSMh//vMfFEXhP//5D9evX8fPz4/+/fvz6aef2uspSGXc/XRX9XX2JeLpiDsbvmkAyTfAvTK8WXydVuftjOTDVXdW3n2iRRW+eqopjuqSa2Aiu5FKZVl6ejobN27k0KFDVK1alf79+8s27hWc3QtYx44dm+dlmewK6WwODg5MnjyZyZMnl0JkklSyhBD8sOkC34afs2wb0b46H/ZvhEolF7yTHly///470dHR9O3bl9atW8sFIB8Adk9GJCkvR37+kb0R6zCQTz1QJSfwqQ5qFZteGWnZnLO7ap4FqXmITY+988PJZbD5M8hMgZRbhX4OeRFC8Mma08zecac25bUetZnQq26xvPBeOhzDrW0uLNq9l5w1LrIbqVRWJSQkAODl5UVYWBju7u64u7vbNyip1MhkRCqz9kasI0WtkPPNNJeclzLick850zg551+Qmg9XR1dzIhJ7zvoGrVuhj5WTwWjivb+P8+fBOwW2/+nXgOc7F1+9xoE1VzCkqjGgs3m7LFSVygqTycTevXvZvHkz9evXZ8CAAVSuXNneYUmlTCYjUpllHhFRQAicTPmMjigKajc3FCfrPhzZhaoLr5kv6+UqSM2Hq6MrY5uPhYvjsh5DBW6B5kSk+/tFeToAZBqMjPv9COtP3sqKCb4Y0JSBbYq3fbU+UxaqSmXfjRs3WL16NTdv3qRdu3Z0797d3iFJdiKTEanMczIJxiy9j86m18z/y1WQWhhugfDm6aLHAKTpDLy04CDbz5svAzmqFb4f3IK+TYLu67j5cfHUyEJVqUzKzMxk/vz5eHl58fzzz1OlShV7hyTZkUxGJKkUJKbpGT1vH4euJgDg7Khm5vBWdK3rZ9/AJKmUXbhwgeDgYLRaLSNGjCAgIEC2ZpBkMiLZR84OqSIjw7zg3V2N6zIqyIyS6OQMRszex5lb5pV33Z0cmDe6Da2q+xTpeHl1Uc3pTkdVSSobkpOTWb9+PadOnaJv3760adNG1oZIFjIZkewiV4dUVd6Fqg75FbCWcdfi0hg+ey+Xb5u7nvq6aZj/bDsaVvYo8jHv1UU1J0et/MQp2ZcQgoMHD7Jx40bUajUDBgygcePG9g5LKmNkMiLZRc4OqVqDAYwmcy5yV2MjBxTahRbvQnSl5UJ0MsNm7eNWknml4Cpezix8vh01fF3v67j5dVG9Q5CpT6d1v+r39ViSdL+uX7/OmjVraN68Ob169ZKrpUs2yWREsitXb296nLqCISoKh4AA6mzdYu+QisWxfxMYOWcf8WnmtTNq+bmy8Pl2BHnmvSZOYeXXRVWv17N27VpqtpA1KVLpMxgMHDt2jBYtWlC1alXGjBmDr2/BZrJJDyaZjEhSMdtz6TbP/3qAlEwDAI2rePDr6LZUcstrFEOSKo7Lly+zevVq4uPjCQoKIigoSCYi0j3JZESSilHE6SheXXSIzKyVd9vW8GHWyNZ4OMnlzaWKLS0tjfDwcI4cOUK1atUYNGgQfn5yZE4qGJmMSKUi5eolFrwzFn2GuX4iZ7v2QsvRon2DRmGGi4rUfGpcY1WYCyySo8yL3RUq8IK3gF9x5DpvLjmKIatBW4/6/vw0tGWBV94tyCwZkC3dpbLpxIkTnD59mkceeYSWLVvK9WSkQpHJiFQqbh87iD4pIdd2jVMRaihytGifUSWISIeCvdm7Gg2QfLPwjwf3bAG/YM8VJq04YZmd/GizynwzsFmhVt4tzCwZkC3dJfuLj4/n0qVLtGrVitatW9OwYUPc3O5vuQTpwXRfyUhGRgZOd7XgliRbTHpzIaeiqHD19gbutGvn0H8Kd7DMFPP/FRWpavOfsEoIfE1538VVwNgMFbgXoa9BPi3ghRD8tOUiUzectWwb2q4aHz3WGHUh+6QUbJaMmWzpLtmT0Whkz549bNmyBTc3N5o0aYJGo5GJiFRkhU5GTCYTn376KTNnziQqKopz585Rs2ZNPvjgA0JCQnjuuedKIk6pgnD19ualn3+12na+qAdzCwT3AEiLxtc1oOit3otICMEX687wy7ZLlm2vdqvF273r3dcQdX6zZCTJ3q5fv86qVauIjo62rCej0WjsHZZUzhV8DDnLJ598wrx58/jqq6+s/gAbN27MrFmzijU4SSqrjCbB/y07bpWITOxTn3fC6str5VKFduDAARRF4fnnn6d3794yEZGKRaFHRubPn89///tfevbsycsvv2zZ3qxZM86cOVOswUnlT15t3o0qBRQFQ0wM57t2I8OYQaouFRMmPJNNqICY1ChenlOAzoxegFdlUNTEpseW8DPKTWcw8caSI6w5Zq4/URT49PEmPNOuWqGPlbNoVRamSmXVmTNnMBgMNG7cmD59+uDg4IBKVejPspKUp0InI9evX6d27dq5tptMJvRZdQHSg+tebd7VeoO5wRngedd9U7UQrS7IqEKOP1thLhRxdby/rqYFla4z8vLCg2w9F2OORKXw3aDm9G9WtDU2bBWtysJUqaxISkpi3bp1nDlzhiZNmtC4cWM5EiKViEInIw0bNmT79u1Ur27dZnrp0qW0aNGi2AKTyqe82rwLRcERqJ9uxCEggJj0GExZiYRKQKYG1ncEf6PI5+g5KApoPcDRCVdHV8Y2H1tCz+iOxHQ9z83bz4Er5mnJTo4qfh7Wiu71/It8zLuLVmVhqlQWCCE4cOAAGzduxNHRkaeeeoqGDRvaOyypAit0MjJp0iRGjhzJ9evXMZlM/P3335w9e5b58+ezevXqkohRKodytnlX+/tz+s0J9O3bF0dHc/Ovl//sSXRaNP4u/kRcvQHJN+juXhmePWHnyG2LSc5k5Jx9nLqZBIC71oE5o9vQJqRoK+/eTRatSmWJEIKjR4/SuHFjQkNDcXYuvmUMJMmWQl/0e+yxx1i1ahUbN27E1dWVSZMmcfr0aVatWkWvXr1KIkZJsqvrCekM/GW3JRGp5Krh9xcfKrZERJLKAr1eT0REBP/++y8qlYpRo0bRv39/mYhIpaJIfUY6d+5MeHh4cccilSNJ69cTM/0HTKmp3NCqOeOuxaBARo5CVUNMjGX/E7oTzFo9izSDuT4iNi3rtuSoQnU5LW0XolMYPnsvNxPNnWMrezqx4Pl21PK700+hoJ1TbZFFq1JZcOnSJdasWUNiYiLe3t5UrVoVBwfZE1MqPYX+a6tZsyb79++nUqVKVtsTEhJo2bIlly5dyuOeUkUSM/0HdFm/69P1gkl1sB5kU+sNYMqqCXF1JSIjghhTTK7juBoNliLUe3U5LW0nricyYs4+4lJ1ANT0dWXB8+2o4mX9SbGwnVNtkUWrkj2kp6ezYcMGjh49SvXq1RkyZIhc1E6yi0InI5cvX8ZozP0JMDMzk+vXrxdLUFLZZ0pNNX+jUmF0zPozEgInk8BB3ClUVbm64jPmVTJvf2beXVHh6+wLyVG4Gg2MTUgyd0XNp8upPeyLjOO5eftJzlp5t2GQB/Ofa4uvjZV3C9M51RZZtCrZ0/Xr13n00Udp3ry57JEj2U2Bk5GVK1davt+wYQOenncmZhqNRiIiIggJCSnW4KSyz8HPDwc/P4i7jVsl31zdVcF8LZrfzcmIr7OvuVPqNw3M68S4V4Y3T5d22PnafCaalxcetKy82ybEm1kj2+DpnP/Ku7IIVSoP4uLiCA8Pp1+/fri5ufHqq6/KJESyuwInI48//jgAiqIwcuRIq9scHR0JCQnhm2++KdbgJKm0rTp6gzf+OGJZebdrXT9mDmuFs0ZeRpHKN6PRyK5du9i2bRtubm4kJSXh5uYmExGpTChwMmLKuv5fo0YN9u/fL68rSoWiNunMvc+So8yjImWwaPW3vVd5f/lxy8q7/ZoG8d3A5mgcZKdJqXy7efMmy5cvJyYmhvbt29OtWzfLNHtJKgsKXTMSGRlZEnFIFZyDKR3UCggjJN+4c0MZKVr9ectFvlx/ZzmDIW2D+eTxJoVeeVeSyiKVSoVWq+XFF18kMDDQ3uFIUi5FmruVmprK1q1buXr1Kjqdzuq2119/vVgCkyoWRQgsbeHds1qnl4GiVSEEX204y89bLlq2vdS1JhPlgndSOSaE4MyZMxw8eJAhQ4YQEBDA6NGj5d+0VGYVOhk5fPgwffv2JS0tjdTUVHx8fIiNjcXFxQV/f3+ZjEj5U9TwZtnosmo0CSatOMGivVct294Jq8er3XKvvSRJ5UViYiLr1q3j7Nmz1KtXD51Oh7Ozs0xEpDKt0MnIG2+8Qf/+/Zk5cyaenp7s2bMHR0dHhg0bxrhx40oiRkkqdnqjiQlLjrLqqPmSkaLAR481ZvhD1e9xT0kqu44cOcK6devQaDQMHDiQ+vXlCJ9UPhQ6GTly5Ai//PILKpUKtVpNZmYmNWvW5KuvvmLkyJEMGDCgJOKU7CSvTqtUcgKf6qBWkRkfb+8wCyVdZ+TVRQfZfPbOyrvfDGzGY82rFPgYObuuyi6qkr0JIVAUBUdHR5o2bUrPnj1xcnKyd1iSVGCFTkYcHR1RqcyzC/z9/bl69SoNGjTA09OTa9euFXuAkn3l2WlVnWOGSVYHVY1T2V/DIilDz/PzDrDvchwAWgcVPw9rSY/6AYU6jq2uq7KLqlTa9Ho9W7ZsISkpiSeffJJGjRrRqFEje4clSYVW6GSkRYsW7N+/nzp16tC1a1cmTZpEbGwsCxYsoHHjxiURo2RH+XVaRVFQu7mhODmhcXKm46Bh9gu0AG6nZDJy7j5OXDcveOemdWDWyNY8VLPSPe6Z291dV2UXVam0XbhwgTVr1pCcnEyXLl0soyOSVB4VOhn57LPPSE5OBuDTTz9lxIgRvPLKK9SpU4fZs2cXe4BS2VCQTqtl2Y2EdIbP3svFGHNy5e3iyPxn29Gkquc97pk/2XVVKm1CCFasWMHRo0epUaMGw4YNy7VWmCSVN4VORlq3bm353t/fn/Xr1xdrQJJU3CJjUxk2ay/XE9IBCPRwYuHzbant727nyCSp4IQQCCFQqVT4+fnx+OOP07RpUzkaIlUIxbZG9KFDh5g0aRKrV68urkNKpShnoWpOhpgcK+3qzW/mli6qNmzQKMxwUZF61+tjrNo+L5inbiQxYs5eYlPM/XA6aZ3ple7Ejm+PseM+jiuLVqXSFBsby+rVq6lRowZdu3alY0c5GidVLIVKRjZs2EB4eDgajYbnn3+emjVrcubMGSZOnMiqVavo3bt3ScUplbCchaq2qFxdITMZUOfuoprDjCpBRDrkXcjpSum1Vj9wOY7R8/aTnGFeebd+oDsPxzmSHJNebI8hi1alkmQwGNi5cyfbt2/Hw8OD4OBge4ckSSWiwMnI7NmzeeGFF/Dx8SE+Pp5Zs2bx7bff8tprrzFo0CBOnDhBgwa2Py1LZV/OQlUHPz+r21Survi9/jos/O7OxuwuqndJVZvfnFVC4GvKcYMQuCpqxtYZWJxh52nruRheWnCADL05iJbVvJg7qi3LPtoH3Ck8vR+yaFUqSenp6cyZM4e4uDg6dOhAly5d5HoyUoVV4GTk+++/58svv+Ttt9/mr7/+4umnn+ann37i+PHjVK1atSRjlEqRg58fdbZusX1jdjKiqOHN07b3+bMnpEXj6xpAxNMRgHn64dq1a+nbt2+pvJiuPX6TcYsPozeaV7zrXMeXX4a3wkVz589dFp5KZZVOp0Oj0eDk5ET9+vVp3LgxAQGFm3ouSeVNgcfML168yNNPPw3AgAEDcHBwYOrUqTIRkcqUP/ZfZexvhyyJSJ/Ggcwa2doqEZGkskgIwcmTJ5k+fTpnzpxBURR69uwpExHpgVDgV+j09HRcXFwAUBQFrVZLUFBQiQUmla4bWjWn6wVjdHRg0ysjbe6Tqi/b9RH/23aJT9feGbEZ2Loqnz3RhMtHYmW3VKlMS0hIYO3atZw/f5769etTubLty6CSVFEV6uPirFmzcHMzL/luMBiYN28evr6+VvvIhfLKpzPu2jvdVeNu57GXeUaMRm3K43b7EELwzT/n+HHzBcu25zvV4P1+DVAURXZLlcq0a9eusWDBApycnBg0aBD169e3d0iSVOoKnIxUq1aN//3vf5afAwMDWbBggdU+iqLIZKScMmTPvBUCt0q+tndKjkKj6OhYNanU4roXk0nw4aqTzN99xbLtzV51GdujtqX/guyWKpVFqampuLq6EhQURMeOHXnooYfQau+vqFqSyqsCJyOXL18uwTCkssLJJPLurvpNA/OU3jxm0pQ2vdHEO0uPsezwdcu2KY82YmSHEJv7y6JVqSzQ6XRs3ryZAwcO8PLLL1OpUiW6du1q77Akya5kVZ9ULmXojYz97RAbT0cDoFYpTH2qKQNayoJqqew6d+4ca9euJTU1lW7duuHl5WXvkCSpTJDJiFTupGQaeP7X/ey5ZF55V+Og4schLXi4UaCdI5OkvO3evZt//vmHWrVqMXLkSLy9ve0dkiSVGTIZkXI7uQw2fwaZKdbbU25Zvt1weQMzjswgVW/dPj42PbZEQ4tL1TFq7j6O/ZsIgKtGzf9GtqZDrTzqXCTJjoQQJCYm4uXlRaNGjXB1daVJkyZyPRlJukvp9ebOw4wZMwgJCcHJyYl27dqxb9++fPdPSEhgzJgxBAUFodVqqVu3LmvXri2laB8Qmz+D2HPm+pCcXyJrFo3WjRlHZhCZGEl0WrTVlylrH1dH12IP61ZiBgN/2W1JRLxcHFn0wkMyEZHKpJiYGObNm8ecOXMwGAx4eHjIhe0kKQ92HRn5448/mDBhAjNnzqRdu3ZMmzaN3r17c/bsWfz9/XPtr9Pp6NWrF/7+/ixdupQqVapw5coVed21uGWPiCgqcLvr0ofWDbq/T+qpHwBQKSp8na2TAVdHV8Y2H1usIV2OTWXY7L38G29eV8bfXcvC59tRN0CuvCuVLQaDgR07drBjxw68vb0tTSIlScpbkf6FXLx4kblz53Lx4kW+//57/P39WbduHdWqVaNRo0YFPs63337LCy+8wOjRowGYOXMma9asYc6cOUycODHX/tnrNOzatcvSVjwkJKQoT0EqCLfAvNu+ZyUjvs6+lrbvJeX0zSSGz95HbIq5YVk1HxcWPd+OYB+XEn1cSSqKZcuWcfHiRTp16kTnzp1lIiJJBVDofyVbt26lT58+dOzYkW3btvHpp5/i7+/P0aNHmT17NkuXLi3QcXQ6HQcPHuS9996zbFOpVISGhrJ7926b91m5ciXt27dnzJgxrFixAj8/P5555hneffdd1GrbTawyMzPJzLzTdTMpydwjQ6/Xo9frC/q0HygCgZL1f0Ne50jc+f+9zmP27UU534evJvD8gkMkZa28W9ffjbmjWuHv7liI490J9kH5nd/POZcKLz09ndSsxSYfeughunXrhp+fH0I8OH9z9iD/zktfSZ3rQicjEydO5JNPPmHChAm4u98ZIu/Rowc//vhjgY8TGxuL0WjMte5CQEAAZ86csXmfS5cusWnTJoYOHcratWu5cOECr776Knq9nsmTJ9u8z+eff86UKVNybd+8ebOlvX1Fd0J3goiMCDJFJmqTDgdTOooQtD/kQuBNb4SiQpeVzJmEiVAvBbwqAyoyfu9m85jJIhmAjIyMAtfshIeHFyruMwkKs8+q0JnM19iruwlGVUvgwPbCjcRkpLsCKjLSCx5rRVHYcy4VjhCChIQErl+/jouLCzVr1uT48eP2DuuBI//OS09aWtq9dyqCQicjx48f57fffsu13d/fn9jYkp1JYTKZ8Pf357///S9qtZpWrVpx/fp1pk6dmmcy8t577zFhwgTLz0lJSQQHB9O9e3cqVapUovGWFbNWzyLGFGP+QQHUCqAQeNObTEeN1b6KMBGdc1hZ5N9t1cfdh759++a7j16vJzw8nF69ehV41d4NJ6OYte8YepN5VKNDTR9+eqY5rtrCD3kv2r2X1EwdTs5O9O37YDSXKso5lwonISGB9evXc+XKFerXr0/37t3ZvXu3POelSP6dl77bt/NaLuT+FPqV3cvLi5s3b1KjRg2r7YcPH6ZKlSoFPo6vry9qtZqoqCir7VFRUQQG2u4XERQUhKOjo9UlmQYNGnDr1i3Lstt302q1NlssOzo6PjB/vGkGcyarUlT4GowgzO3RhZI1mUoINEYjijBxs3I8/kZh7p2u9QBHpzyPm12oWtDzWNBz/ueBa7z71zGy8hB6Nwpg+pAWaB2Kup6MYvn/g/I7z/Yg/Z2XJoPBwPz581GpVAwZMoS6detahq/lOS998pyXnpI6z4VORgYPHsy7777Ln3/+iaIomEwmdu7cyVtvvcWIESMKfByNRkOrVq2IiIjg8ccfB8wjHxEREYwda3smRseOHfntt98wmUyoVOY30nPnzhEUFGQzEZGs+Tr7EnH1hqWl+4ysZMTJJBjz13o7R2c2e0ckH68+Zfn5yZZV+fLJJjio7T4LXZK4ceMGPj4+ODk58fTTTxMYGChfeySpGBT6Ff6zzz6jfv36BAcHk5KSQsOGDenSpQsdOnTgP//5T6GONWHCBP73v//x66+/cvr0aV555RVSU1Mts2tGjBhhVeD6yiuvEBcXx7hx4zh37hxr1qzhs88+Y8yYMYV9GlIZI4Tg2/BzVonI6I4hTH2qqUxEJLvLzMxk3bp1zJo1y9ILqVq1ajIRkaRiUuiREY1Gw//+9z8++OADTpw4QUpKCi1atKBOnTqFfvBBgwYRExPDpEmTuHXrFs2bN2f9+vWWotarV69aRkAAgoOD2bBhA2+88QZNmzalSpUqjBs3jnfffbfQj10Rbdj+MTPO/0kqJqvttc4JJm434Zp5g/NGIxBgTkOrm6AMvNGbTIKPVp9i3q7Llm3jQ+swrmedIjeIunAwmn2rLqHLMJKWmHnvO0hSHs6ePcvatWtJT08nNDSUhx56yN4hSVKFU+hkZMeOHXTq1Ilq1apRrVq1+w5g7NixeV6W2bJlS65t7du3Z8+ePff9uBXRjPN/EqkW3KmRMJu43UjVrJojAznqLrJnvNqxI6TBaOKdv47x96E7K+9OeqQhz3aqkc+97m3fqkvE37Ku+tY4FbXmRHpQxcTEsHjxYmrXrk2/fv1kg0VJKiGFTkZ69OhBlSpVGDJkCMOGDaNhw4YlEZdUBOYREQWVEPjmGBxxzRoYEAo4ugAooHW3jIqo3dxKO1TAvPLu678f5p9T5iJmlQJfPdWMp1rd/8q7ugxzka6igIunFo2Tmrb9a973caWKTwjBqVOnaNiwIX5+fjz//PNUrlxZtnGXpBJU6GTkxo0bLF68mN9//50vvviCpk2bMnToUIYMGULVqnL59rLA1wQRz56w/Hz+124YUqJw9A+gztYtlu2bXhkJcbdRnPKeMVNSUjINvDj/ALsumodsNGoV04e0IKxx8a686+KpZdQXHYv1mFLFFR0dzapVq/j3338ZOXIkISEhhZolKElS0RS6YMDX15exY8eyc+dOLl68yNNPP82vv/5KSEgIPXr0KIkYpQomIU3H0Fl7LYmIi0bNnFFtij0RkaSC0uv1RERE8Msvv5CRkcGoUaPkUhOSVIrua9GEGjVqMHHiRJo1a8YHH3zA1q1biysuKR8bLm9gxpEZpOpTQZ8BmUkgRFahqhHXTNi6uCdn3LUYFKCSE/hUB7XKPBqSJTU+vtRjF0Lw0oKDHL2WAICnsyNzR7ehZTVvwLrw9H7IolWpME6ePMnu3bvp3LkznTp1kuvJSFIpK/K/uJ07d7Jo0SKWLl1KRkYGjz32GJ9//nlxxiblYcaRGUQmRt7ZoAJQrApVt1ZRk+qQNfCVc8ZMXO7ueRon5xKL9W4rjtxgb2QcAL5uWhY+35b6gR6W220Vnt4PWbQq5SUtLY1z587RvHlzmjVrRrVq1fDx8bF3WJL0QCp0MvLee++xePFibty4Qa9evfj+++957LHHHph1XsqCVL15Qa67O6reKVRVMDpm/WqFwMlk7qiqdnPLVR+icXKm46BhpRJ3SqaBz9beWQV46tNNrRIRyF14ej9k0apkixCCY8eOsWHDBgDq1q2Li4uLTEQkyY4KnYxs27aNt99+m4EDB+Lr61sSMUkFdHdH1fOuAVmFqv44+PlB3G3cKvny0s+/2jtUAH7aconoZHPGFNoggO71/PPcVxaeSiUhLi6O1atXExkZSePGjendu7f8ICVJZUChk5GdO3eWRBxSBReVDvOOXwFA46Bi0iNySrhU+vbs2UN8fDxDhw6ldu3a9g5HkqQsBUpGVq5cSZ8+fXB0dGTlypX57vvoo48WS2APKqvi1JxyFKrGqjBfx0iOgpRbll1uaNWcrheM0dGBTDsUp+ZFCMHuE44Mj9egEQpuWjWbph62ua8sPJWK27///ktiYiKNGjWiZ8+ehIaGyjbuklTGFCgZefzxx7l16xb+/v6WRe1sURQFo/H+ZkE86HIVp+aUVaiazdVoAJHV3Uzrxhl37Z2i1aztpVmcmpeIMzHUiNNQyZQVW4aJ1Iz8kw5ZeCrdr8zMTCIiIti/fz81atSgYcOGNlfwliTJ/gqUjJhMJpvfS8XPqjjVOUdNTnKUpVAVRY2rgLEZKnCvDFo36P4+hi3/Nd8uBG6VfEu1ODUvGXojn647yyMiK4lSwPUehamy8FS6X6dPn2bdunVkZGTQu3dv2rZtKzuoSlIZVuiakfnz5zNo0KBcnzB0Oh2LFy9mxIgRxRbcg8zX2ZeIpyPubPimgaVQlTdP5HEvczLiZBJlpmj1v9su8W98OmCexeMqC1OlEiaEYPfu3QQFBdG3b188PT3tHZIkSfdQ6A6so0ePJjExMdf25ORkRo8eXSxBSRXDv/Fp/LTlQtZPIt99Jel+mEwm9u7dy5UrV1AUhaFDhzJ48GCZiEhSOVHokREhhM3hzn///Vf+wy+inEWrsemxlu1nd+9g15KF6DLSIbk6iKqgqCFHF9WcMlRlaxj6h1+P8cxtR3PRqsxFpBJy69YtVq9ezfXr1+nRowfVq1eXtSGSVM4UOBlp0aIFiqKgKAo9e/a0apdsNBqJjIwkLCysRIKs6GwVrbo6urJryULibvybtcUBy6/LRhdVwDzDBnAoA2/8Oy/E4nou5U7RahZZmCoVF71ez5YtW9i9eze+vr48++yzBAcH2zssSZKKoMDJSPYsmiNHjtC7d2/cciw7r9FoCAkJ4cknnyz2AB8Edxetujq6Mrb5WCI3LAJAUVS4OujMBayKGtwDbB7HEBODWm+gfrp9ZzTpjSYmrzxJaI6iVbXGhLuXqyxMlYqN0Wjk9OnTdOvWjY4dO6JWy0RXksqrAicjkydPBiAkJIRBgwbhZIdl5yu6u4tWf8GcjLh6e/NS7X05CljX27z/+a7dMERF4RBgO1kpLb/uusyF6BRCs4pWXTw0+HS4Td++XXF0dLRrbFL5lpqaSkREBF27dsXT05MxY8bIJESSKoBC14yMHGm7XkGSAGKSM/l+43mrbXJGpXS/hBAcOXKE8PBwABo3boynp6dMRCSpgihQMuLj48O5c+fw9fXF29s73/n6cXFxxRbcA0+fbv7/XZ1Wy4ILB6PZt+qSZWG7bInpeobqzPUtbkJmIdL9i4uLY9WqVVy+fJmmTZvy8MMP4+rqau+wJEkqRgVKRr777jvc3d0t38vmQaUkMxlQm2tFcnRaLQv2rbpE/K20XNsdAHes/z4ctfLTq1R0RqOR1NRUhg8fTs2asuZIkiqiAiUjOS/NjBo1qqRike4mckyLydFptSzIHhFRFPMKuwC3UzLRG80xezg74KJxQOOkplXfapy5GW23WKXy5+rVq+zatYunnnoKPz8/XnnlFfkhSJIqsELXjBw6dAhHR0eaNGkCwIoVK5g7dy4NGzbkww8/lAtQlQRFDW+etncUNrlkdVT9fd9Vfvj7OAD1A91Z/VonHNTmab16vZ4zN+0ZpVReZGRksHHjRg4ePEiVKlVIS0vDw8NDJiKSVMEVugPrSy+9xLlz5wC4dOkSgwYNwsXFhT///JN33nmn2AOUyr7END1TN5y1/Pzho40siYgkFdS5c+eYMWMGx48fp0+fPjz77LN4eHjYOyxJkkpBod8xzp07R/PmzQH4888/6dq1K7/99hvz5s3jr7/+Ku74pHLg2/CzxKXqAOjfrDIP1axk54ik8shkMlG1alXGjBlD27ZtUalkQitJD4oitYPPXrl348aNPPLIIwAEBwcTGxub312lHArSAj5Vf6fwM2n9emKm/4ApNTXPYxpiYoocT16zY/KSlphpfkyjiQV7rgDg7Kjm//rWL3IM0oPFZDKxb98+rl+/zoABA6hfvz7168u/H0l6EBU6GWndujWffPIJoaGhbN26lZ9//hmAyMhIAuzcbKs8KVgLePN1co3aRMz0H9BdulSgY6uKMO0xr9kx9xKnM2DKypnG9qhNkKdzoY8hPXhu3rzJqlWruHnzJm3atMFkMsmeIZL0ACt0MjJt2jSGDh3K8uXLef/996lduzYAS5cupUOHDsUeYEVV0BbwGkVHx6pJmC5nTelVqXDw88vzuCpXV/xef73Q8diaHXMvmQg26pIBCKnkwvOdaxT6caUHT0REBDt37sTPz4/nnnuOqlWr2jskSZLsrNDJSNOmTTl+/Hiu7VOnTpWfbIqgoC3gz2NORhz8/KizdUuJxZM9O+ZeUjMN9PhmC1FJ5kt2k/s3Qusgf/9S3rJX/HZycqJHjx60b99evmZIkgQUIRnJdvDgQU6fNk83bdiwIS1btiy2oKSy78fNF4hKMteN9KzvT/f6/naOSCqrUlJS2LBhA97e3vTo0YOOHe+d7EqS9GApdDISHR3NoEGD2Lp1K15eXgAkJCTQvXt3Fi9ejF8+lxAedAUqWo2Pt2xPugQx+/0wGcGQXvTi1JzyKlTNLkgtiEsxKczabq5f0ahVfPBIw2KJTapYhBAcPnyY8PBwVCoVYWFh9g5JkqQyqtDJyGuvvUZKSgonT56kQYMGAJw6dYqRI0fy+uuv8/vvvxd7kBVFwYpWzTROzsTsBl1S9iq35sshRSlOzelehaoap/yHzYUQfLT6lKXT6gtdahDiK9cJkazpdDoWLVrE1atXad68Ob169cLFxcXeYUmSVEYVOhlZv349GzdutCQiYL5MM2PGDB5++OFiDa6iKVDRqrc3GidnOg4ahmnbVvMdFXDwDyhycWpO+RWqapzUtO2f/9ofEaej2XLWPEoT5OnEmO617yueB5HRaESv15foY+j1ehwcHMjIyMBoLNh07eJgNBpRqVQoikJwcDCdO3e2FKhmZGSUWhz2YK9z/iCT57xkaDSaUu/zU+hkxGQy4ejomGu7o6Ojpf+IlL98i1Z//tWy/XzW/x1cKPai1YIWquaUoTfy0epTlp//r28DXDRFLjt64AghuHXrFgkJCaXyWIGBgVy7dq3UWqkbDAbS09NxcnLC0dGRKlWqoNfriYyMvPedKwB7nPMHnTznJUOlUlGjRo1SXd6l0O8kPXr0YNy4cfz+++9UrlwZgOvXr/PGG2/Qs2fPYg9QKjtmbb/E1TjzJZ6HavrwSNMgO0dUvmQnIv7+/ri4uJToi6fJZCIlJQU3N7cS/4ST/VgZGRn4+vri5uZm8wNLRVea51wyk+e8+JlMJm7cuMHNmzepVq1aqSV5hU5GfvzxRx599FFCQkIIDg4G4Nq1azRu3JiFCxcWe4DlnVXRalpWEWpyFGffb82uf33QGVVZnVYVSI4iaUwDYg6CSQ+GNEF24zN7u56Qzo+bLwCgVilMebSx/CRSCEaj0ZKIVKpU8u3yTSYTOp0OJyenEn2R1uv1JCQkIISgUqVKJZ5klWWldc6lO+Q5Lxl+fn7cuHEDg8FQah8sCp2MBAcHc+jQISIiIixTexs0aEBoaGixB1cR2CxaNRrYddWDOJ31EJhG0RGzX5+jaNX8oq7S2P/F/bM1p8nQmy/DDX+oOvUC3e0cUfmSXSNSUYo4TSYTKpUKBwcHnJ2dcXNzkz1DJKmCyL48YzQay2Yy8scff7By5Up0Oh09e/bktddeK6m4KgyrolWDEVejgbEJSUSKEAAUBK6ORjRqk7nT6qmsX7xirhVRaRT8nhtip+jNdl2IZc3xmwBUctXwRq+6do2nPCvvowZCCFJTU0lOTsbX1xdHR0c8PT3tHZYkScXIHq9TBU5Gfv75Z8aMGUOdOnVwdnbm77//5uLFi0ydOrUk46swfJ19ibh6A5JvgntlfnEPgLjbuPr4Whet7ugGqVE4+AeUaKfVgtIbTXy46qTl53fC6uHp/ODVA0jm6bqJiYno9XpcXV3lSIgkScWmwBfZfvzxRyZPnszZs2c5cuQIv/76Kz/99FNJxiaVAQt2X+FcVAoAzap68nSrYDtHJNlDWlqaZVVuX19fPD095TV6SZKKTYFHRi5dusTIkSMtPz/zzDM899xz3Lx5k6AgOasiZ6Eq+gzITAIhcI1y4fHzldEaFGbqgjHqqwEKGepYUBQMMTGc79rNchxDTPF0Ws0pZ9fVwnRajUnO5Lvwc5afpzzWGJWqfF9mkArHaDSiVqvRarV4eHjg6upaokO4ISEhjB8/nvHjxxfrvhVBREQEY8eO5cSJE3JUqhjExsbSsGFDDh06JBdrLAMK/NEmMzMT1xzdP1UqFRqNhvT09BIJrLzJLlSNTosmWp9EtAqi1QrNznvjleqIc6YDqUJDhoMjGQ4O5q5jgFpvwBAVZfnCVDydVnPK7rqampCJMDdOvWenVYCv1p8hOdMAwMDWVWke7FVsMUllm9FoJC4ujpiYGEaOHImDgwPu7u5oNBoCAgLo1asXc+bMKfbeQvv37+fFF18s9n2LYtSoUSiKkudXSEhIiT22Le+88w7/+c9/ciUi6enp+Pj44OvrS2Zm7g8biqKwfPnyXNtHjRrF448/brXtwoULjB49mqpVq6LVaqlRowZDhgzhwIEDxflUcpkxYwYhISE4OTnRrl079u3bl+/+3bp1Q1EU1Go13t7eqNVqFEWhX79+Nvd/+eWXURSFadOmWbb5+voyYsQIJk+eXJxPRSqiQhWwfvDBB1azAXQ6HZ9++qlVAdu3335bfNGVI3cXqiLM3QC1huxPkQIng9Hc1V0BVCocBNRPN+IQEGB1rOLotJrT3V1XC9Jp9fDVeP48aG5R7+7kwDth9YstHqnsEkKQlpZGUlISiqLg6emJoiiEhYUxd+5cjEYjUVFRrF+/nnHjxrF06VJWrlyJg0PxNL8rzNpWJb0O1vfff88XX3xh+TkoKIi5c+da1ti5OynQ6XQlFsuOHTu4ePEiTz75ZK7b/vrrLxo1aoQQguXLlzNo0KAiPcaBAwfo2bMnjRs35pdffqF+/fokJyezYsUK3nzzTbZu3Xq/T8OmP/74gwkTJjBz5kzatWvHtGnT6N27N2fPnsXf3/YCnH///Tc6nQ6TyURycjI6nY4WLVrw9NNP59p32bJl7Nmzx9IXK6fRo0fTqlUrpk6dio+PT7E/N6ngCjwy0qVLF86ePcvhw4ctXx06dODSpUuWn48cOVKCoZYPvs6+RMQbibh2g4gE8HM1JxpuPr48HJtBj9NXePh2BmOWruWlv9bS9Z8I6mzdYvVVa+0aPMJ6F3ts2V1Xn/nwIWq3ynuVXZNJ8OHKO0Wrb4TWxddNm+f+UsWRmJhIYmIizs7O+Pv74+zsDIBWqyUwMJAqVarQsmVL/u///o8VK1awbt065s2bZ7l/QkICzz//PH5+fnh4eNCjRw+OHj1q9RirVq2iTZs2ODk54evryxNPPGG5LSQkxPLpVQjBhx9+SLVq1dBqtVSuXJnXcyTpOfcFuHr1Ko899hhubm54eHgwcOBAoqKiLLd/+OGHNG/enAULFhASEoKnpyeDBw8mOTnZ5rnw9PQkMDDQ8gXg5eVl+blNmzZ8/PHHjBgxAg8PD1566SXAnDh07twZZ2dngoODef3110lNTbUcNzMzk7feeosqVarg6upKu3bt2LJlS76/l8WLF9OrVy+cnJxy3TZ79myGDRvGsGHDmD17dr7HyYsQglGjRlGnTh22b99Ov379qFWrFs2bN2fy5MmsWLGiSMctiG+//ZYXXniB0aNH07BhQ2bOnImLiwtz5szJ8z4+Pj6W30NAQAAbN27ExcUlVzJy/fp1XnvtNRYtWmRzimqjRo2oXLkyy5YtK/bnJRVOgT/O3Osfi1Rx/HnwGkf/TQSgboAbw9tXt3NEFVf/H3YQk1zwOp6CE5iEQKUo2Gqc5+euZdVrncx7CoHRaMTBwQEXFxecnZ3Rau+dfPbo0YNmzZrx999/8/zzzwPw9NNP4+zszLp16/D09OSXX36hZ8+enDt3Dh8fH9asWcMTTzzB+++/z/z589HpdKxdu9bm8f/66y++++47Fi9eTKNGjbh161auxCabyWSyJCJbt27FYDAwZswYBg0aZPXadfHiRZYvX87q1auJj49n4MCBfPHFF3z66af3fL62fP3110yaNInJkydjMpmIjIykb9++fPLJJ8yZM4eYmBjGjh3L2LFjmTt3LgBjx47l1KlTLF682PJGGBYWxvHjx6lTp47Nx9m+fTvPPPNMru0XL15k9+7d/P333wgheOONN7hy5QrVqxfu3+yRI0c4efIkv/32m83C5OwV2m357LPP+Oyzz/I9/qlTp6hWrVqu7TqdjoMHD/Lee+9ZtqlUKkJDQ9m9e3eB458zZw6DBw+2KiUwmUwMHz6ct99+m0aNGuV537Zt27J9+3aee+65Aj+eVPzkwiKSlcR0PV+tP2v5+cNHG+GolrMmSkpMcia3kuy3gFxmZiYJCQmo1Wp8fX0LvRZF/fr1OXbsGGAeEdi3bx/R0dGWZObrr79m+fLlLF26lBdffJFPP/2UwYMHM2XKFMsxmjVrZvPYV69eJTAwkNDQUBwdHalWrRpt27a1uW9ERATHjx8nMjLS0hl6/vz5NGrUiP3799OmTRvA/AY1b9483N3NTfuGDx9OREREkZORHj168Oabb1qOPWrUKJ555hlLUW2dOnWYPn06Xbt25eeffyY6Opq5c+dy9epVy2WDt956i/Xr1zN37tw839SvXLli8zLDnDlz6NOnD97e3gD07t2buXPn8uGHHxbqeZw/b14Jq379wl+Offnllxk4cGC++9iKHcxFpEajkYC7LlUHBARw5syZAj3+wYMHOXHiRK5RoS+//BIHBwer0bS8Yjt8+HCBHksqOTIZkax8F36O26nma9/9mgbRoZavnSOq2PzcS+ryV/4jI75uGhISEkhLS0Oj0RS5cZkQwjK75ujRo6SkpORqd5+ens7FixcB8yfwF154oUDHfvrpp5k2bRo1a9YkLCyMvn370r9/f5v1KadPnyY4ONiSiIB5NXEvLy9Onz5tSUZCQkIsiQiY60Cio6ML96RzaN26tdXPJ06csIwwZBNCWEZNLl26hNFopG5d68aBmZmZ+S4TkL0AYU5Go5Fff/2V77//3rJt2LBhvPXWW0yaNKlQU69FdmV7Efj4+Ni13mLBggU0adLEKlE9ePAg33//PYcOHbrn7C9nZ2fS0tJKOkzpHmQyIlmcuZXEgj1XAHB2VPN+3wZ2jqjiy75UUtxMJhNJSUl4eHjkelMSQhATE0N6ejqenp73tZ7M6dOnqVGjBgApKSkEBQXZvKSbPcyfXYNSEMHBwZw9e5aNGzcSHh7Oq6++ytSpU9m6dWuRW1TffT9FUe5rRpDrXbPeUlNTefHFFxk3blyufatVq8axY8dQq9UcPHgwVwGsm5tbno/j6+tLfHy81bYNGzZw/fr1XAWrRqORiIgIevXqBYC7uzuJiYm5jpmQkGBJQrOTozNnztCiRYs847Dlfi7T+Pr6olarrWp7AKKioix1OvlJTU3l77//5qOPPrLavn37dqKjo60e02g08uabbzJt2jQuX75s2R4XF1fixdDSvZWJ8ffCTuvKtnjxYhRFyTU9TSo8IQSTV5zEaDJ/QhrTvRaVvQr+xiGVfQaDAaPRaJkl4+/vf199QzZt2sTx48ctMzxatmzJrVu3cHBwoHbt2lZfvr7mEbamTZsSERFR4Mdwdnamf//+TJ8+nS1btrB7926OHz+ea78GDRpw7do1rl27Ztl26tQpEhISaNiwYZGeX1E0bdqU06dP53r+tWvXRqPR0KJFC4xGI9HR0bluz+/Nt0WLFpw6dcpq2+zZsxk8eDBHjhyx+ho8eLDVJYt69epx8OBBq/sajUaOHj1qSUKaN29Ow4YN+eabb2wmZwkJCXnG9vLLL+eK4e6vvC7TaDQaWrVqZfU3YTKZiIiIoH379nk+ZrY///wTnU7H0KFDrbYPHz6cY8eO5Yrh7bffZsOGDVb7njhxotAJmFT87D4yUpRpXQCXL1/mrbfeonPnzqUYbcW1+thN9kbGAVDNx4XnO+c/9VcqP4QQpKSkkJKSgouLC56engUqUM0pMzOTW7duWU3t/fzzz3nkkUcYMWIEAKGhobRv357HH3+cr776irp163Ljxg1L0Wrr1q2ZPHkyPXv2pFatWgwePBiDwcDatWt59913cz3mvHnzMBqNtGvXDhcXFxYuXIizs7PN4szQ0FCaNGnC0KFDmTZtGgaDgVdffZWuXbvmupRSksaNG8fDDz/M2LFjef7553F1deXUqVOEh4fz448/UrduXYYOHcqIESP45ptvaNGiBTExMURERNC0adM8+2T07t2bX3+9s2xETEwMq1atYuXKlTRu3Nhq3xEjRvDEE08QFxeHj48PEyZM4LnnnqN+/fr06tWL1NRUfvjhB+Lj4y2Fx4qiMHfuXEJDQ+ncuTPvv/8+9evXJyUlhVWrVvHPP//kObX3fi/TTJgwgZEjR9K6dWvatm3LtGnTSE1NZfTo0VbPqUqVKnz++edW9507dy59+/bNdYmrUqVKubY5OjoSGBhIvXr1LNvS0tI4ePDgPUd2pJJXpJGR7du3M2zYMNq3b8/169cB83W7HTt2FPpYRZnWZTQaGTp0KFOmTKFmzbL3pnnktCu/HG3LjF3VSbltbqFtiIkpke6qxSFNZ+CztactP0/u3xAnR9nhsSLQ6/XExMSQnJyMi4uLVb1EYaxfv56goCBCQkIICwtj8+bNTJ8+nRUrVlguNyiKwtq1a+nSpQujR4+mbt26DB48mCtXrlgKFLt168aff/7JypUrad68OT169MhzJNTLy4v//e9/dOzYkaZNm7Jx40ZWrVpls7ZCURRWrFiBt7c3Xbp0ITQ0lJo1a/LHH38U6fkWVePGjdm8eTPnzp2jc+fOtGjRgkmTJlmNDMydO5cRI0bw5ptvUq9ePR5//HH2799v8zJGtqFDh3Ly5EnOnjUXl8+fPx9XV1d69uyZa9+ePXvi7OzMwoULARgyZAizZs1izpw5tGrVirCwMG7dusW2bdusCkfbtm3LgQMHqF27Ni+88AINGjTg0Ucf5eTJk1ZTqIvboEGDLLOSmjdvzpEjR1i/fr1VbFevXuXmzZtW9zt79iw7duxg+PDhRX7sFStWUK1aNfmhtgxQRCErl/766y+GDx/O0KFDWbBgAadOnaJmzZr8+OOPrF27Ns9perbodDpcXFxYunSp1aWWkSNHkpCQkOfc9smTJ3Ps2DGWLVvGqFGjSEhIsNlhEMyf6HJ2JUxKSiI4OJibN2/mWzBWWGHLwohOj8bf2Z+Bi9WkOFrPSnDN0NH1rHkI2bFGDaqvLLl5+3db9MFeUhN0uHppGPpxu1y3fxt+np+3RQLQta4vs4a3LNbH1+v1hIeH06tXr1JbjrqsycjI4Nq1a5bLkSVNCEFiYiIZGRmWlXWLqzGZZJsQguTkZNzd3UukZf4777xDUlISM2fOLPZjl1f3e847dOjA2LFjbU6bfpBlZGRw+fJlgoODc71e3b59m6CgIBITE/Hw8Ci2xyz0q9Mnn3zCzJkzGTFiBIsXL7Zs79ixI5988kmhjlWUaV07duxg9uzZBW6w9vnnn1tNI8y2efNmq26y9ysjI8PyfwNZnz6FQGs04WAS1EpMR+/hgUmr5UaHDpwsRNJ237GluwIqMtIzciWLMenw36NqQEGtCDq53CpUQlkY4eHhJXLc8sDBwYHAwEBSUlJKtFMnmEcOVSoVKpUKrVaLSqWSswVKUV5N1O7Xa6+9xqxZs0hISJCLFN6lKOf89u3b9OnTh379+pGUlFQCUZVfOp2O9PR0tm3bhsFgsLqtpF5LCp2MnD17li5duuTa7unpmW+RU3FITk5m+PDh/O9//7MUxN3Le++9x4QJEyw/Z4+MdO/evVhHRqYvm05SepI5i8xK0J2MRl5cvKrYHqOoFu3eS2qmDidnJ/r27Wp12wsLDmEU5ktJz3eqyaiHbTdduh9yZOTOyIibm1uJjYyYTCYSExPJzMzEy8sLnU6Hl5dXiS5sJ91R0iMjHh4eNj9YPcju55x7eHjwwQcflFBk5VtGRgbOzs506dLF5shISSh0MhIYGMiFCxdyLRK1Y8eOQtdvFHZa18WLF7l8+TL9+/e3bMuu/HZwcODs2bPUqlXL6j5ardZmsZ6jo2PxvjEqd/0/x+PY353gcsaz6UwUW86ZE5FADydeD62Lo2PJDeUX+zkvR7JnsWSPWBQnIQSpqakkJyejKAre3t5otVp0Op3lMaWSl/1aJM956ZHnvGSoVCoURbH5ml1Sr+GF/u298MILjBs3jr1796IoCjdu3GDRokW89dZbvPLKK4U6VmGnddWvX5/jx49bTdd69NFH6d69O0eOHLFqeCTlL9Ng5KNVd6YK/l+/BrhqZU1BeZSRkUFSUlKu9WQkSZLKi0K/+0ycOBGTyUTPnj1JS0ujS5cuaLVa3nrrLV577bVCB3CvaV05p3Q5OTnlmsaW3Uzp7u2lLfBfFR2OV0ZrciDDThNRLhyMZt+qS5ZVerOlJeZe+2TW9kgu3zZf+2tXw4f+TYNKJUapeJhMJjIzM3F2dsbJyQk/P78HdtRJkqTyr9DJiKIovP/++7z99ttcuHCBlJQUGjZsmG/3wPwMGjSImJgYJk2axK1bt2jevLnVtK6rV6+Wi+G3uicdcUvNijPrqojDfXR2LIp9qy4Rfyvv4iKNkzlLupmYzo+bLgCgUszrz8i6gvIjIyODxMREjEYjjo6OODg4yEREkqRyrcjj8hqNptg6G2avamnLvVYLzrl8uT2pDeY3c4HA2WBEbTBRPz6uVGPIHhFRFHDxtK6T0TipadvfXNPz6ZrTpOvN+w5/qDoNgopvepZUcoxGI0lJSaSnp6PRaKhUqZKcritJUoVQ6Fey7t275/spetOmTfcVUHmX4QyPHb+CIRUcXO+9f0lw8dQy6ouONm/bffE2q4+Zmwf5uGqY0Kuezf2ksic1NdUyU8bZ2VmOZkmSVGEU+vpH8+bNadasmeWrYcOG6HQ6Dh06RJMmTUoiRqmYGIwmpqw6afn57d718HSRw/tlmcFgID09HTAvpObn53dfC9uVVSEhIffV5XPevHmW+jHJ2v2e28IYPny4bK1ejNavX0/z5s3vazHH8qLQIyPfffedze0ffvghKSkp9x1QWbDh8gZmHJlBqj413/0C/1VR96QjaoOCNr2UgrtLzqJVW4WqOS3cc4Uzt8zNgZpW9WRgazn7qKzKXk8mOTkZBwcHnJyc7FY7da8ux8Vh//79uVbAzUtISAjjx49n/Pjxlm2DBg2ib9++RX78efPmWYrmFUUhICCALl26MHXq1HzbtJcHhTm39+Po0aOsXbuWn3/+Oddtv//+O8OGDePll19mxowZVrfNmzeP8ePH2+xTpSgKy5Yts+rQ/ddff/HDDz9w+PBhjEYj1atXZ+DAgbz22mv3tUZOfuLi4njttddYtWoVKpWKJ598ku+//z7fWslbt27x9ttvEx4eTnJyMvXq1eP999+3LCwJ8Oijj3LkyBGio6Px9vYmNDSUL7/80rJ8QFhYGB988AGLFi26r7b35UGxvboNGzYs3/VkypMZR2YQmRhJdFp0vl81j6twS1bhnK6gyqpaNTmW7ifW7KLV1IRMshv7Zxeq5hSbksm34ecsP095tBFqVcX6dF1RZGZmWtaTcXNzw9fXt8KNhNwte8SnqLKnNd8PDw8Pbt68yfXr1/nrr784e/YsTz/99H0dsyD0en2JHv9+z21B/fDDDzz99NM236Bnz57NO++8w++//27pVl0U77//PoMGDaJNmzasW7eOY8eO8cknn3D06FEWLFhwP+HnK3ttoPDwcFavXs22bdt48cUX873PiBEjOHv2LCtXruT48eMMGDCAgQMHcvjwYcs+3bt3Z8mSJZw9e5a//vqLixcv8tRTT1kdZ9SoUUyfPr1EnldZUmzJyO7du0tlzY3SkD0iolJU+Lv45/mlNZkHlgSCdGdBqgc06N+nVGPNWbTq6qXFO9DFUqia09T1Z0nKMLf1fapVVVpU8y7VOKWCy25e5ufnh4eHR5mfTbZ161batm2LVqslKCiIiRMnWrWQTk5OZujQobi6uhIUFMR3331Ht27drEY2cl5KEELw4YcfUq1aNbRaLZUrV+b1118HzAvtXblyhTfeeANFUSxJmq3LNKtWraJNmzY4OTnh6+vLE088ke/zUBSFwMBAgoKC6NChA8899xz79u2zahW+YsUKWrZsiZOTEzVr1mTKlClWz/XcuXOWrpUNGzZk48aNKIpiGVW6fPkyiqLwxx9/0LVrV5ycnFi0aBEAs2bNokGDBjg5OVG/fn1++ukny3F1Oh1jx44lKCgIJycnqlevblnBNr/zdfe5BfMMxcceeww3Nzc8PDwYOHCgVePJDz/8kObNm7NgwQJCQkLw9PRk8ODB+bZcNxqNLF261KohZbbIyEh27drFxIkTqVu3Ln///Xe+v4e87Nu3j88++4xvvvmGqVOn0qFDB0JCQujevTtLly5l5MiRRTruvZw+fZr169cza9Ys2rVrR6dOnfjhhx9YvHgxN27cyPN+u3bt4rXXXqNt27bUrFmT//znP3h5eXHw4EHLPm+88QYPPfQQ1atXp0OHDkycOJE9e/ZYJaj9+/fnwIEDXLx4sUSeX1lR6Ms0AwYMsPpZCMHNmzc5cOBAhWut6+vsS8TTEXne/sumkaSk38bdx5e3fr6zvPf5KT+WRnhW8itaPXotgSUHzYv0uWsdeDesfmmGJt2DEIKMjAzLWjLe3t6WDohl3fXr1+nbty+jRo1i/vz5nDlzhhdeeAEnJyc+/PBDwNxLaOfOnaxcuZKAgAAmTZrEoUOHaN68uc1j/vXXX3z33XcsXryYRo0acevWLY4ePQrA33//TbNmzXjxxRd54YUX8oxrzZo1PPHEE7z//vvMnz8fnU5XqDWXoqOjWbZsGWq12rIq8fbt2xkxYgTTp0+nc+fOXLx40fLpePLkyRiNRoYNG0b16tXZu3cvycnJvPnmmzaPP3HiRL755htatGhhSUgmTZrEjz/+SIsWLTh8+DAvvPACrq6ujBw5kunTp7Ny5UqWLFlCtWrVuHbtGteuXbvn+bqbyWSyJCJbt27FYDAwZswYBg0aZDVz8eLFiyxfvpzVq1cTHx/PwIED+eKLL/j0009tHvfYsWMkJibSunXrXLfNnTuXfv364enpybBhw5g9e3aRFqZbtGgRbm5uvPrqqzZvz69mqFGjRly5ciXP2zt37sy6dets3rZ79268vLysnltoaCgqlYq9e/fmmeR26NCBP/74g379+uHl5cWSJUvIyMigW7duNvePi4tj0aJFdOjQwWqqfrVq1QgICGD79u25OoxXJIVORjw9Pa1+VqlU1KtXj48++oiHH3642AKTiofJJJi08qTlEs640Dr4uedujy/Zh/ilC6akKDQIc/KhqCiOnnkK4CFMKEoeoypu/vDS1vt+nJ9++ong4GB+/PFHFEWhfv363Lhxg3fffZdJkyaRmprKr7/+ym+//WZZ7n7u3LmWa+K2XL16lcDAQEJDQ3F0dKRatWq0bdsWAB8fH9RqNe7u7jaXjMj26aefMnjwYKu1XJo1a5bvc0lMTMTNzQ0hhGUxsNdff91SbzFlyhQmTpxo+QRes2ZNPv74Y9555x0mT55MeHg4kZGRbNmyxfL8Pv30U3r16pXrscaPH2/1wW7y5Ml88803lm01atTg1KlT/PLLL4wcOZKrV69Sp04dOnXqhKIoVK9evUDn624REREcP36cyMhIS8fq+fPn06hRI/bv30+bNm0Ac9Iyb9483N3Ni34OHz6ciIiIPJORK1euoFarc10qyz7ODz/8AMDgwYN58803iYyMpEaNGnn+Lmw5f/48NWvWLFJPnbVr1+Z7OSy/rsW3bt3K9bwcHBzw8fHh1q1bed5vyZIlDBo0yDIF38XFhWXLllG7dm2r/d59911+/PFH0tLSeOihh1i9enWuY1WuXDnfZKoiKFQyYjQaGT16NE2aNMHbu2IN85/dvYNdSxaiy0ine5oWE1VQCfhlRZhlH2EEY44FVzPUalAUDNFRnG/VwLLdkCbItUhNMSpM0erSQ/9y9FoCAHX83RjZIaTE4pIKLns9GeekW6hTo+59h0JSKMm/wDtOnz5N+/btrUZxOnbsSEpKCv/++y/x8fHo9XqrN0dPT0/q1ct7SvnTTz/NtGnTqFmzJmFhYfTt25f+/fsXqqfKkSNH8h05scXd3Z1Dhw6h1+tZt24dixYtsnrzPXr0KDt37rTaZjQaycjIIC0tjXPnzlGlShWrJCmvpCDnp+zU1FQuXrzIc889ZxWzwWCwfPgbNWoUvXr1ol69eoSFhfHII49YPvwV5nydPn2a4OBgq6UzGjZsiJeXF6dPn7YkIyEhIZZEBCAoKIjo6Og8z116ejparTbXaF54eDipqamW4mJfX1969erFnDlz+Pjjj/M8ni0i+xNVEeRM3krLBx98QEJCAhs3bsTX15fly5czcOBAtm/fbjXz9O233+a5557jypUrTJkyhREjRrB69Wqrc+ns7FzhV94uVDKiVqt5+OGHOX36dIVLRnYtWUjcjX8BcEZFdjlNrvlBNs6Y2mDCYDXxxvxHpNKUzNuBrU6rtopWE9P1fLX+jOXnKY82wlFdtusPHhTZyYiTqz9CpS72xEEAImtkxOax3e6v2LMkBQcHc/bsWTZu3Eh4eDivvvoqU6dOZevWrQX+VFyU9XlUKpXlU2uDBg24ePEir7zyiqUwMiUlhSlTpuS6VA0Uul4u5+yW7FmI//vf/2jXrp3VftmXiFq2bElkZCTr1q1j48aNDBw4kNDQUJYuXVos5+tud99PUZR8p5f6+vqSlpaGTqdDo9FYts+ePZu4uDir34fJZOLYsWNMmTIFlUqFh4cHqampmEwmq/qo7Nk12QlZ3bp12bFjB3q9vtDP634u0wQGBuZKxAwGA3FxcXmOzl28eJEff/yREydO0KhRI8A8Mrd9+3ZmzJjBzJkzLfv6+vri6+tL3bp1adCgAcHBwezZs8dqfba4uDj8/PwK/HzLo0JfpmncuDGXLl0q9BBbWafLMM/NVRQVaRodJgVUAvxy/PszpAPZP2f9m3EwmTut3t3gTKVR8HtuSAnFat1pNWd31ZymbTxHbIp5KKdvk0A61PYtkXikgsmeruvg4ICDgwN+fn6oXt1RMo9lMpGUlISHhwdKCRbANmjQgL/++gshhOWT3M6dO3F3d6dq1ap4e3vj6OjI/v37LVNkExMTLYWeeXF2dqZ///7079+fMWPGWBbJbNmyJRqNBqPRmOd9AZo2bUpERIRlum5RTJw4kVq1avHGG2/QsmVLWrZsydmzZ3MNs2erW7cu169fJyoqiqAg81pP+/fvv+fjBAQEULlyZS5dusTQoUPz3M/Dw4NBgwYxaNAgnnrqKcLCwoiLi8PHxyff85VTgwYNLPUm2aMjp06dIiEh4b46amfX/5w6dcry/e3bt1mxYoWlliWb0WikU6dO/PPPP4SFhVGvXj0MBgNHjhyxivfQoUOA+bwCPPPMM0yfPp2ffvqJcePG5YohISEhz7qR+7lM0759exISEjh48CCtWrUCzM09TSZTruQxW/Yoxt3F52q1Ot+kLvu2zMw7I94ZGRlcvHiRFi1a5Hm/iqDQycgnn3zCW2+9xccff0yrVq1yzV/38CjfrcVdvb1Z0+Yg0WoFf6Mg4tkTltvOd+2GISoKh4AA6mzdYr8gs+RXtHr2VjLzd5s/CTg5qni/X/G07peK5vLly5apuq6urjg4OJT5WTI5JSYmcuTIEattlSpV4tVXX2XatGm89tprjB07lrNnzzJ58mQmTJiASqXC3d2dkSNH8vbbb+Pj44O/vz+TJ0/Ot0B33rx5GI1G2rVrh4uLCwsXLsTZ2dky1B4SEsK2bdsYPHgwWq0WX9/cSfbkyZPp2bMntWrVYvDgwRgMBtauXcu7775b4OccHBzME088waRJk1i9ejWTJk3ikUceoVq1ajz11FOoVCqOHj3KiRMn+OSTT+jVqxc1atRg1KhRTJ06leTkZP7zn/8A3LMYecqUKbz++ut4enoSFhZGZmYmBw4cID4+ngkTJvDtt98SFBREixYtUKlU/PnnnwQGBuLl5XXP85VTaGgoTZo0YejQoUybNg2DwcCrr75K165dbRafFpSfnx8tW7Zkx44dlmRkwYIFVKpUiYEDB+Z6/n379mX27NmEhYXRqFEjHn74YZ599lm++eYbatasydmzZxk/fjyDBg2iSpUqALRr14533nmHN998k+vXr/PEE08QGBjIsWPHWLBgAZ07d7aZpMD9XaZp0KABYWFhvPDCC8ycORO9Xs/YsWMZPHiwpTbo+vXr9OzZk/nz59O2bVvq169P7dq1eemll/j666+pVKkSy5cvt0wNBti7dy/79++nU6dOeHt7c/HiRT744ANq1aplNSqyZ88etFqtzZXsKxRRQFOmTBEpKSlCURTLl0qlsnxl/1zWJSYmCkDExsZabZ/58gjx9cB+YubLI0SP2Y1E43mNRY/Zjaz2OdelqzhVr74416VrKUac29x3d4gfX4oQc9/dYfN2k8kkBv+yW1R/d7Wo/u5q8f3Gc6UcoTWdTieWL18udDqdXeOwh5SUFLF06VIxdepUsW/fPpGcnFwqj2s0GkV8fLwwGo33fayRI0cKsq785Px67rnnhBBCbNmyRbRp00ZoNBoRGBgo3n33XaHX6y33T0pKEs8884xwcXERgYGB4ttvvxVt27YVEydOtOxTvXp18d133wkhhFi2bJlo166d8PDwEK6uruKhhx4SGzdutOy7e/du0bRpU6HVakX2S9jcuXOFp6enVdx//fWXaN68udBoNMLX11cMGDAgz+do6/7ZjwWIvXv3CiGEWL9+vejQoYNwdnYWHh4eom3btuK///2vEMJ8zvfu3Ss6duwoNBqNqF+/vli1apUAxPr164UQQkRGRgpAHD58ONdjLVq0yBKvt7e36NKli/j777+FEEL897//Fc2bNxeurq7Cw8ND9OzZUxw6dKhA5yvnuRVCiCtXrohHH31UuLq6Cnd3d/H000+LW7duWW6fPHmyaNasmVVs3333nahevXqe508IIX766Sfx0EMPWX5u0qSJePXVV23u+8cffwiNRiNiYmKEEELEx8eL119/XdSqVUs4OzuLOnXqiHfeecfmv5c//vhDdOnSRbi7uwtXV1fRqFEjMWXKFBEfH59vfPfj9u3bYsiQIcLNzU14eHiI0aNHW8WW/XvdvHmzZdu5c+fEgAEDhL+/v3BxcRFNmzYV8+fPt9x+7Ngx0b17d+Hj4yO0Wq0ICQkRL7/8svj333+tHvvFF18UL730Uok9N1vS09PFqVOnRHp6eq7bYmNjBSASExOL9TEVIQpWFaRWq7l58yanT5/Od7+uXbsWOTEqDUlJSXh6ehIbG0ulSpUs2395ZSQpcbdx86nEefcD9N5pwjUT/FwDLPsYYmLAZLL7yMi8iTtJTcjE1cv2yMiaYzcZ85t5iDPYx5nwN7ri5FgcczSKRq/Xs3btWvr27fvArS4bFxfHr7/+So8ePdBoNNSoUaNU+vGYclymKWsjMKmpqVSpUoVvvvmG5557zt7hFBtb53znzp106tSJCxcuVOhpmWAuYq1Xrx5//PFHqX2KL8t/58UhNjaWevXqceDAgVItjcjIyLDMeLr79er27dv4+vqSmJhYrFdCCnyZJjtnKevJRnHot8NEYNaCu4aU3DMdVKXQWrmo0nQGPl1zyvLzpEca2TUReRDFxsaybds2+vfvj4+PD6+//jp6vZ7IyEh7h2YXhw8f5syZM7Rt25bExEQ++ugjAB577DE7R1b8Vq9ejZ+fH/Xq1ePChQuMGzeOjh07VvhEBMx1F/Pnzyc2NtbeoVQYly9f5qeffqpwNZq2FKpmpDw0YSoO2qzpuyYFNP4BVrepXF3xy9HdsKz5ectFbiSa2y13retHaIOyO2uiojEYDOzYsYMdO3bg6elJYmIivr6+qNXqEm/5XdZ9/fXXnD17Fo1GQ6tWrdi+fbvNWo/yLiUlhY8++oirV6/i6+tLaGgo33zzjb3DKjV5NfSSiqZ169b3VctTnhQqGalbt+49E5K4uLj7CqgsSXSFDmWgULWgrtxO5ZetlwBwVCtM7t/wgUkg7e3atWusXLmSuLg4OnbsSOfOnR+4S1J5adGihVUL7Ips8ODBvPjiixXykoEklaRCJSNTpkzJ1YFVKjs+Xn0KndE8NezZTjWo6Zf3ipJS8crMzMTZ2ZmXXnrpvhdskyRJetAUKhkZPHhwhXqh3XB5AzOOzCBVn0r3dCecUYhJj8VUDgcTNp+NZuNpc2Mef3ctr/WoY+eIKjYhBCdPnuT8+fM8/vjj1K5dm1q1asmRKEmSpCIocDJSEV9kZxyZQWSiuajQJKoADpjEnWZK5WWgNdNg5KNVd4pW3+/XADdtoVvISAWUkJDAmjVruHDhAg0aNMBgMODo6Fgh/41IkiSVhkLPpqlIUvXmHu4qRYVKUWd9r0aV9VRdy8lTnrPjMpGx5ufSNsSHR5vlvQiZdH/27dvHxo0bcXZ2ZvDgwfmusSJJkiQVTIGTkfxa2JZ3vs6++Dn7kpJ+Gz9nX/zEJQxAyXeDuH+3EjP4YdN5AFQKfPhoI/kJvQSIrHbnBoOBli1b0r17d7RaufqxJElScZBj+eXcZ2tPk6YzX1oa2q46DSuX73b8ZY1Op2PTpk04ODgQGhpKhw4d7B2SJElShfNAJyOB/6rocLwyWpMDqRnx9g6n0HQGEyuP3gDA28WRNx+ua+eIKpazZ8+ydu1a0tLS6NGjh73DkSRJqrDKS41miah70hGvVEec0xWEMF+G0jgVfulxe0nKuNNI663e9fBy0eSzt1RQRqORP//8k8WLF+Pv78+rr75a8Repug+KorB8+XJ7h1FudOnShd9++83eYVQYc+bM4dFHH7V3GNJ9eqCTEbXBXFshELj5VMKnclU6Dhpm56gKzmA0V9g2ruLB4DbV7BxN+SeEQAiBWq3G3d2dAQMG8Mwzz+Dt7W3v0Oxq1KhRPP7443nefvPmTfr06VN6ARXS1q1b6dGjBz4+Pri4uFCnTh1GjhyJTqfjr7/+Qq1Wc/36dZv3rVOnDhMmTADM3UUVReGLL77ItV+/fv1Qq9U2b8tp5cqVREVFMXjw4Fy3ff7556jVaqZOnZrrtg8//NCyGm5Oly9fRlEUqxWVhRD897//pV27dri5ueHl5UXr1q2ZNm2aZWn7knD16lX69euHi4sL/v7+vP322xgMhnzvc+7cOR577DF8fX3x8PCgU6dObN682XL77du3CQsLo3Llymi1WoKDgxk7dixJSUmWfYYNG8bhw4fZvn17iT03qeQ90MlItgxneOnnXxn93UzqPtTJ3uHck+mumU1THm2MWiWLVu9HdHQ0c+fO5dixYwCEhYXRpEkTWQxcAIGBgXYv5hVC2HzjO3XqFGFhYbRu3Zpt27Zx/PhxfvjhBzQaDUajkUcffZRKlSrx66+/5rrvtm3buHDhgtVifsHBwcybN89qv+vXrxMREUFQUNA945w+fTqjR4+22aF1zpw5vPPOO8yZM6cAzzhvw4cPZ/z48Tz22GNs3ryZI0eO8MEHH7BixQr++eef+zp2XoxGI/369UOn07Fr1y5+/fVX5s2bx6RJk/K93yOPPILBYGDTpk0cPHiQZs2a8cgjj3Dr1i0AVCoVjz32GCtXruTcuXPMmzePjRs38vLLL1uOodFoGDJkCNOnTy+R5yaVDpmMlEPJGXdedAe0rEKr6g/2J/f7kf1C+Msvv5CWloaXl5e9Qyp3cl6myf6k/vfff9O9e3dcXFxo1qwZu3fvtrrPjh076Ny5M87OzgQHB/P666+TmppquX3BggW0bt0ad3d3AgMDeeaZZ4iOjrbcvmXLFhRFYd26dbRq1QqtVsuOHTtyxfbPP/8QGBjIV199RePGjalVqxZhYWH873//w9nZGUdHR4YPH54rwQBzctCuXTsaNWpk2fbII48QGxvLzp07Ldt+/fVXHn744Xs2hIyJiWHTpk30798/121bt24lPT2djz76iKSkJHbt2pXvsfKyZMkSFi1axO+//87//d//0aZNG0JCQnjsscfYtGkT3bt3L9Jx7+Wff/7h1KlTLFy4kObNm9OnTx8+/vhjZsyYgU6ns3mf2NhYzp8/z8SJE2natCl16tThiy++IC0tjRMnTgDg7e3NK6+8QuvWralevTo9e/bk1VdfzTUK8sgjj7By5UrS09NL5PlJJe+BLmBFCEABk5GkMQ2IOQgmPRjSsrbbwYWD0exbdQldhtHm7XqjCVWmEVBQFJjYp37pBliBJCQksGDBAhISEujcuTOdOnXCwaF0/0kMWj2I2PSSWeVUmARKHiNmvs6+/PHIHyXyuADvv/8+X3/9NXXq1OH9999nyJAhXLhwAQcHBy5evEhYWBiffPIJc+bMISYmhrFjxzJ27Fjmzp0LgF6v5+OPP6ZevXpER0czYcIERo0axdq1a60eZ+LEiXz99dfUrFnT5uW0wMBAbt68ybZt2+jSpYvNWJ977jm+/fZbq31SUlJYunQp3333ndW+Go2GoUOHMnfuXDp27AjAvHnz+Oqrr/jwww/zPSc7duzAxcWFBg0a5Lpt9uzZDBkyBEdHR4YMGcLs2bOLNHNr0aJF1KtXz+aKyIqi5Luch5tb/stHDBs2jJkzZ9q8bffu3TRp0oSAgDsLi/bu3ZtXXnmFkydP0qJFi1z3qVSpEvXq1WP+/Pm0bNkSrVbLL7/8gr+/P61atbL5ODdu3ODvv//OtXp869atMRgM7N27Vy7WV0494MmIiezBoZj9enRJ2QubmV/AVZrST0j2rbpE/K38r+uqsuJzc9Pg714euqGULQaDAQcHBzw8PKhRowbt2rXDz8/PLrHEpscSnRZ97x3Lmbfeeot+/foB5jWtGjVqxIULF6hfvz6ff/45Q4cOZfz48YC5LmP69Ol07dqVn3/+GScnJ5599lnLsWrWrMn06f/f3l2HRZX9fwB/D+DA0CBISCopqwgqiB0gGIiJwSKKsau4urJ2gWuvsXYTNnasIIqBIgYWBigoohhggIDEMHV+f/Dl/hxnSEk9r+eZZ733nnvvuWeHmc+c3IB27dohLy9P7Evz77//houLS6n5GDp0KM6dO4euXbtCV1cX7du3R8+ePTFq1CioqhYPg2/RogXat2+P4OBgJhg5fPgwCCFS+3b4+vqic+fOWL9+Pe7evYucnBz069ev3GDk1atX0NHRkWiiyc3NxdGjR5nao19//ZW5fnkBwreePXtW5Yn4vu53Ik1JeUmTkZEhFogAYLZLmly+xWKxcOHCBQwYMAAqKiqQkZFBkyZNEBkZKRFYjhgxAqdOnUJhYSHc3d2xa9cuseOKiopQU1PDq1evynwGqv76uYORr4iE/wtEWICcYnEgoj12RK3no6RGhMUCFNXE2+EL+ULkFPxvBE0jFgYOpevPVAYhBI8ePUJUVBRGjBgBfX199OvXr07zpMXRqrFrl1czUpNatWrF/LukL8WHDx9gZWWFBw8e4OHDh9i/f///55UQiEQipKamwtraGnfv3kVgYCAePHiAz58/M5MupqWloUWLFsx55S2vLisri5CQECxZsgSXLl3CrVu3sGzZMqxcuRJxcXFM3nx9fTFt2jRs3LgRKioqCA4OxtChQ6GioiJxTVtbW5ibm+Po0aO4fPkyvL29K1SjVlhYCAUFyR8PBw8eRPPmzWFrawsAaN26NYyNjXHo0CGx/ioV8T0zZZuZmVX53KoghMDPzw9NmjRBTEwMOBwOdu3aBXd3d9y+fVusD86///6LgIAAJCcnY86cOfD398eWLVvErsfhcGq0gy5Vs2gwUkJZB8h/D7kmOjC/El3XuYGimjxGr+jIbOdy+eix+go+NSoCAOwb6whL85r9QvmRZGVlITw8HC9evICNjU2Zv/JqU001lYhEIuTm5kJVVbVOlrNv1KgR8++STsAlAUVeXh5+++03TJkyReI8IyMj5Ofnw9XVFa6urti/fz+0tbWRlpYGV1dXif4HSkpKFcpP06ZN4e3tDW9vbyxevBgWFhbYtm0bFi1aBKB4EdBp06bh8OHD6NKlC2JjY7F8+fJSr+fr64vNmzcjMTERcXFxFcqDlpYWPn+WnM8oKCgICQkJYgGNSCRCcHAwE4yoqqoiJydH4tzs7GwAYJpfLCws8PTp0wrl51vf00yjq6srUQ7v379njklz6dIlnDlzBp8/f2b+Hrds2YKoqCjs3r0bs2fPFru+rq4urKysoKmpic6dO2PBggVitTFZWVl1VsNJfT8ajDQQ6y88w6e84kDEzUYXnWggUmHJyck4cuQIlJSUMHLkSJib0xqlumRvb4/ExMRSf4k/evQImZmZWLFiBQwNDQEAd+7cqbb7a2hoQE9PT6zDrIqKCoYOHYrg4GCkpKTAwsICnTt3LvUaI0eOxPTp02FraytWU1MWOzs7ZGRk4PPnz0wzxKNHj3Dnzh1ER0dDU1OTSZuVlYVu3brh6dOnsLKygqWlJd68eYP379+LfQHfu3cPCgoKMDIyYvI1fPhwnDp1SqLfCCEEubm5pfYb+Z5mGicnJyxduhQfPnxgOvJGRUVBVVW11PIpqcX4NliWkZEpc/mRkmNFRUXMvpSUFHC5XKl9U6iGgQYjDcCz91+w+/pLAIC8nAzm9ZXsAEdJ4nK5UFBQQNOmTdG+fXt07twZbDadGK4qcnJyJL6sGjduzAQLlTFr1iy0b98ekydPxrhx46CkpITExERERUVh06ZNMDIyApvNxsaNG/H777/j8ePHWLx4cZXyvX37dsTHx2PgwIFo3rw5uFwu9uzZg4SEBGzcuFEs7dixY9G5c2c8efIEs2bNKvO6GhoaSE9PF6sBKo+dnR20tLQQGxvLNA8GBQXBwcFBaufadu3aISgoCKtWrYKrqyssLS0xYsQILFmyBLq6urh37x7mz5+PqVOnQla2eKFPT09PnDhxAiNGjMD8+fPRq1cvaGtr49GjR/j333/xxx9/lDpnzPc00/Tq1QstWrSAt7c3/vnnH2RkZGD+/Pnw8/Njhn3HxcVh1KhRuHjxIpo2bQonJydoaGjAx8cHCxcuBIfDwc6dO5Gamsr0N4qIiMD79+/Rrl07KCsrIyEhATNmzEDHjh1hYmLCBCYxMTFo1qwZmjdvXuVnoOoWHdpbzxFCEPhfAgSi4rbgid2aw1BTsY5zVb8VFRXh7Nmz2LhxIwoKCqCkpISePXvSQOQ7REdHw87OTuxV0sRRWa1atcKVK1eQnJyMzp07w87ODgsXLoS+fvFq09ra2ggNDcWRI0fQokULrFixAqtXr67SvRwcHJCXl4fff/8dNjY26Nq1K27evImTJ09KjMjo1KkTLC0tkZubi1GjRpV7bXV19Qo3EwHF/VfGjBnD9JXh8XjYt28fBg8eLDX94MGDsWfPHvD5fMjJyeH8+fMwMjLCiBEj8MsvvyAgIABTp04VC9RYLBYOHDiAtWvXMs/YqlUrBAYGwsPDA66urhXOb2XIysrizJkzkJWVhZOTE3799VeMGjUKf//9N5OmoKAASUlJ4POL+71paWkhMjISeXl56NGjB9q2bYtr167h1KlTTP+ZkgClU6dOsLa2xrRp09C/f3+cOXNG7P5hYWEYP358jTwbVTtY5Ht6PDVAJdWUnz59wtZpXuAUyaFQXoBhr7gQvH8POZ267TMSOjsW+dlFUFIv7jNy9lE6Ju6/BwAw0ODggn9XKDSSrbP8VQWfz0dERAT69OlTqV+SVfH06VNERESAy+WiR48ecHBwqJM+E9/icrlITU2Fqamp1E6M1a2u+4z8jCpS5hkZGbCxscG9e/dgbGxcyzn88YhEIty6dQsDBgxAcnJymUOXqYor6/MqMzMTWlpayMnJqda+d7SZph4r5AmxJPwJs72gX4sGF4jUposXL+LatWswNzdHnz596ARmVL2jq6uLoKAgpKWl0WCkmrx//x6hoaE0EGngaDBSj22Nfo632cUzCnY210KvFjrlnPHzEYlEKCgogLKyMlq0aAFdXV20aNGCTuNO1VtlrfNDVV63bt3qzeg4qupoMFJPCUUE266+AADIybAQ4G5Dv2C/8f79e/z3338QCoWYMGEC9PT0KrQ+CEVRFFW/0GCkhpU3vfu3CnKKh6vlcvngyRT3FPftZAqzJpWbifFHxufzcfXqVVy/fh2amppwd3engRpFUVQDRoORGlaR6d2l+SIoDl60VeTxR4/anRmxPiOEYM+ePUhPT0eXLl3QsWPHWl9PhqIoiqpe9FO8hpU1vbt0BOn5PFxrVDz8bW4fK6go1OwIlIYgPz8fLBYLioqK6NatG9TU1KClRSd+oyiK+hHQYKSWfDu9e2m2X0nB9rPF0zm3NdbAgNZNazpr9RohBA8ePMD58+dhbW0Nd3d3OrERRVHUD4YGI/XI+1wuNlx8BqC4JiWw/8/daTUzMxNnzpzBy5cv0bJlS/To0aOus0RRFEXVADobUj2yPOIJ8nnFzTojHYzwS9Ofd9x8QUEBtm/fjuzsbHh5eWHQoEGVmu2S+vmEhoY2uLllunXrhj///LOus1GvLViwABMmTKjrbPwwEhMTYWBgILY2U31Ag5F64vbLLJyMfwcAUFdshOm9LOs4R3Xj3bt3EAqFUFRUxNChQzFp0qRaX9qckpSRkYGpU6fCzMwMCgoK0NHRQceOHbF169Z6s2z7sGHDkJycXOP3GT16NFgsFlasWCG2/+TJk8wCeBV1/PjxKq+7U1El+S15NW7cGG5ubnj48GGN3rc6ZGRkYP369Zg3b57EsRs3bqBRo0bw9PSUOBYdHQ0Wi8Wsavw1ExMTrFu3Tmzf5cuX0adPHzRu3BiKiopo0aIF/vrrL7x9+7a6HkUCl8uFn58fGjduDGVlZQwePJhZ6bg0eXl5mDx5MgwMDMDhcNCiRQuxlZSzsrLwxx9/wNLSEhwOB0ZGRpgyZYrYis8tWrRA+/btsXbt2hp7tqqgwUg9IBQRBJxKYLan97KEhtLPtY4Kl8tFeHg4du7cyXxImpub1/j08VT5Xrx4ATs7O5w/fx7Lli3D/fv3cePGDcycORNnzpzBhQsX6jqLAIrXMSlZMbamKSgoYOXKlfj8+fN3XUdTUxMqKirVlKvSubm5IT09Henp6bh48SLk5OSYxfrqs127dqFDhw5SZ6sNCgrC5MmTcePGDbx7967K99i+fTucnZ2hq6uLY8eOITExEdu2bUNOTg7WrFnzPdkv07Rp0/Dff//hyJEjuHLlCt69e4dBgwaVeY6/vz8iIyOxb98+PHnyBH/++ScmT56M06dPAyj+Mffu3TusXr0ajx8/RmhoKCIjIzF27Fix64wZMwZbt26FQCCoseerLBqM1AMH4tKQmJ4LALDRV8UIB6M6zlHtIYQgMTERmzdvxsOHD+Hm5sYskkXVD5MmTYKcnBzu3LkDT09PWFtbo1mzZvDw8EB4eDjc3d2ZtGvXrkXLli2hpKQEQ0NDTJo0CXl5eczxwMBAtG7dWuz669atg4mJCbMdHR0NBwcHKCkpQV1dHR07dsSrV68AAA8ePED37t2hoqICVVVVtGnTBnfu3AEg2UyTkpICDw8P6OjoQFlZGe3atZMInExMTLBs2TL4+vpCRUUFRkZG2LFjR7llUvLltXz58lLTZGZmYsSIEWjatCkUFRXRsmVLHDx4UCzN1800c+fOhaOjo8R1bG1txRac27VrF6ytraGgoAArKyts2bKl3PzKy8tDV1cXurq6aN26NWbPno3Xr1/j48ePTJpZs2bBwsICioqKaNasGRYsWMAsavfy5UvIyMgwZV1i3bp1MDY2ZlbPffz4MXr37g1lZWXo6OjA29sbnz59YtIfPXoULVu2BIfDQePGjeHs7Fxmc0FYWJjY+6tEXl4eDh06hN9//x0uLi7YvXt3uWUgzZs3bzBlyhRMmTIFwcHB6NatG0xMTNClSxfs2rULCxcurNJ1y5OTk4OgoCCsXbsWPXr0QJs2bRASEoLr16/j5s2bpZ53/fp1+Pj4MPmcMGECbG1tERcXBwD45ZdfcOzYMaajf48ePbB06VL8999/YoGHi4sLsrKycOXKlRp5vqqgHVjrWFY+D6vPJTHbi/rbQFbm5+m0+vLlSxw5cgSWlpbo3bv3T7e+ROrgIRB89WFdnUQiET6WsmCbnJYWTI8dLfcamZmZTI1IaX12vu5kLSMjgw0bNsDU1BQvXrzApEmTMHPmzAp9YQKAQCDAgAEDMH78eBw8eBA8Hg9xcXHMPby8vGBnZ4etW7dCVlYW8fHxpdae5eXloU+fPli6dCnk5eWxZ88euLu7IykpCUZG/x/wr1mzBosXL8bcuXNx9OhRTJw4EV27doWlZelNpbKysli2bBlGjhyJKVOmwMDAQCINl8tFmzZtMGvWLKiqqiI8PBze3t5o3rw5HBwcJNJ7eXlh+fLlSElJYUaMJSQk4OHDhzh27BgAYP/+/Vi4cCE2bdoEOzs73L9/H+PHj4eSkhJ8fHwqVMZ5eXnYt28fzMzM0LhxY2a/iooKQkNDoa+vj0ePHmH8+PFQUVHBzJkzYWJiAmdnZ4SEhKBt27bMOSEhIRg9ejRkZGSQnZ2NHj16YNy4cfj3339RWFiIWbNmwdPTE5cuXUJ6ejpGjBiBf/75BwMHDsSXL18QExOD0tZqzcrKQmJiotj9Shw+fBhWVlawtLSEp6cn5s+fj7lz51a6w/+RI0fA4/Ewc+ZMqcfL6oPUu3dvxMTElHrc2NgYCQkJUo/dvXsXfD4fzs7OzD4rKysYGRnhxo0baN++vdTzOnTogNOnT8PX1xf6+vqIjo5GcnIy/v3331LzUbKg3dfzMbHZbLRu3RoxMTHo2bNnqefWpnoRjGzevBmrVq1CRkYGbG1tsXHjRql/rACwc+dO7NmzB48fPwYAtGnTBsuWLSs1fVnY/wsU1fIBwVe/ECqqIrOrlsyoWprV55OQU1j862OgXVO0NdGsdD4aGpFIhJSUFJibm8PExAQ+Pj4wNjb+KUcOCT59gqCcduLvIfrO858/fw5CiMQXs5aWFrhcLgDAz88PK1euBACxzpgmJiZYsmQJfv/99woHI7m5ucjJyUG/fv2YL2Rra2vmeFpaGmbMmAErKysAxU15pbG1tRWrZVu8eDFOnDiB06dPY/Lkycz+Pn36YNKkSQCKawf+/fdfXL58ucxgBAAGDhyI1q1bIyAgAEFBQRLHmzZtiunTpzPbf/zxB86dO4fDhw9L/byysbGBra0tDhw4gAULFgAoDj4cHR2ZflMBAQFYs2YNU51vamqKxMREbN++vcxg5MyZM1BWLp7FOT8/H3p6ejhz5ozY6sLz589n/m1iYoLp06cjLCyM+aIeN24cfv/9d6xduxby8vK4d+8eHj16hFOnTgEAEyAtW7aMuU5wcDAMDQ2RnJyMvLw8CAQCDBo0iGl2admyZal5TktLAyEE+vr6EseCgoLw66+/Aiiupfrjjz9w5coVdOvWrdTrSfPs2TOoqqpWaRmJXbt2obCwsNTjZTUxZ2RkgM1mSwQ7Ojo6yMjIKPW8jRs3YsKECTAwMICcnBxkZGSwc+dOdOnSRWr6T58+YfHixVI7AOvr6zM1jvVBnQcjhw4dgr+/P7Zt2wZHR0esW7cOrq6uSEpKktr+Gx0djREjRqBDhw5Mu22vXr2QkJCApk0rNyeHQhHAlwNkRAD+V80oU4kRG5WZXZWtILna7uO3OTgYlwYAUGLLYk5vqwrfu6FKT0/HmTNn8O7dO0yaNAna2tpiVfQ/G7kanLhNJBKVupT99943Li4OIpEIXl5eKCr6/4D7woULWL58OZ4+fYrc3FwIBAJwuVwUFBRAUVGx3Otqampi9OjRcHV1hYuLC5ydneHp6cl8Wfj7+2PcuHHYu3cvnJ2dMXTo0FLnncnLy0NgYCDCw8ORnp4OgUCAwsJCpKWliaVr1aoV828WiwVdXV18+PChQuWwcuVK9OjRQyzoKCEUCrFs2TIcPnwYb9++BY/HQ1FRUZnl4OXlheDgYCxYsACEEBw8eBD+/v4AioOIlJQUjB07FuPHj2fOEQgE5dYodu/eHVu3bgUAfP78GVu2bEHv3r0RFxfHBAaHDh3Chg0bkJKSwgQOXy9AN2DAAPj5+eHEiRMYPnw4QkND0b17d+bv98GDB7h8+TIT9HwtJSUFvXr1Qs+ePdGyZUu4urqiV69eGDJkSKmdfku+6L9dwj4pKQlxcXE4ceIEAEBOTg6enp4ICgqqdDBCCKnyj6DKft9Uh40bN+LmzZs4ffo0jI2NcfXqVfj5+UFfX1+slgUoDuz79u2LFi1aIDAwUOJaHA6n3nQ+B+pBMLJ27VqMHz8eY8aMAQBs27YN4eHhCA4OxuzZsyXS79+/X2x7165dOHbsGC5evIhRo0ZV6t4lb0ECQE5HBzJKStCeMqXC51d0dlW2giwc3JuJ7SOEIOB0AkpqKKf0NEcTVQUpZ/8YhEIhLl26hFu3bkFbWxu+vr7Q1tau62zVuYo0lVSFSCRCbm4uVFVVSw1IKsLMzAwsFgtJSUli+5s1K34/czgcZt/Lly/Rr18/TJw4EUuXLoWmpiauXbuGsWPHgsfjQVFRETIyMhLV8iX9EkqEhIRgypQpiIyMxKFDhzB//nxERUWhffv2CAwMxMiRIxEeHo6zZ88iICAAYWFhGDhwoETep0+fjqioKKxevRpmZmbgcDgYMmQIeDyeWLpvf8GyWCymD0R5unTpAldXV8yZM0fi82fVqlVYv3491q1bx/Sj+fPPPyXu/7URI0Zg1qxZuHfvHgoLC/H69WsMGzYMAJi+Nzt37pToWyIrK/lj52tKSkpio9J27doFNTU17Ny5E0uWLMGNGzfg5eWFRYsWwdXVFWpqaggLCxPrwMlmszFq1CiEhIRg0KBBOHDgANavX88cz8vLg7u7O1NL9jU9PT3IysoiKioK169fx/nz57Fx40bMmzcPt27dgqmpqcQ5JTMsf/78WeyzIigoCAKBQKzGhBACeXl5bNq0CWpqakwQlZOTI1H7kJ2dzQRvFhYWyMnJQXp6eqVrR76nmUZXVxc8Hg/Z2dli+Xv//j10dXWlnlNYWIi5c+fixIkT6Nu3L4DiQDo+Ph6rV68WC0a+fPkCNzc3qKio4MSJE1JrabKysurVBJJ1GozweDzcvXsXc+bMYfbJyMjA2dkZN27cqNA1CgoKwOfzoakpvXmjqKhI7Jdbbm5xR9GvPwCJDGByIYrZ/vbDsXTFH6qKamx4LS6/mejr656Mf4e7r4p74jfTUsSvDgaVuG/Dwufz8enTJzx58gRdu3aFo6MjZGVlf9jnlYbP54MQApFIVOEvuu9R8oVfcs+q0tDQgLOzMzZt2gQ/Pz+p/UZK7nH79m2IRCKsWrWKCYAOHToEAMxzN27cGBkZGRAKhcwv0vv37zNpSpQ0scyaNQsdO3bE/v37maYNMzMzTJ06FVOnTsXIkSMRHBwMDw8P5vyS/8bGxsLHxwceHh4Air8sX758KVEm0sqorHIjhIgdX7ZsGezt7Zkmo5Jj165dQ//+/TFy5EgmX8nJybC2ti71/vr6+ujatSv27duHwsJCODs7Q0tLCyKRCNra2tDX10dKSgpGjBghka+K5rdkn4yMDAoKCiASiRAbGwtjY2Oxz+KXL19KXNfX1xetWrXC5s2bmf49Jcft7Oxw/PhxGBkZSV0vqiSdk5MTnJycMH/+fJiamuL48eOYNm2aRHpTU1Ooqqri8ePHTCAlEAiwZ88erF69Gi4uLiCEID8/H0pKShg8eDD279+P33//Hc2bN4eMjAxu374NQ0ND5povXrxATk4OzMzMIBKJMGjQIMyePRsrV66UOtT122Dhazt27Ci3maa0/yd2dnZo1KgRoqKiMHjwYADFNT5paWlwdHSUel5RURHzmfn1cRkZGQiFQmZfbm4uevfuDXl5eZw8eRJsNlvq9R4/foxBgwZJPSYSiUAIAZ/Plwh0a+pzu06DkU+fPkEoFEJHR0dsv46ODp4+fVqha8yaNUtqFVWJ5cuXY9GiRRL7L1++LLYdERFRwVz/P26hEgAZcAu5lTqfKwCWxsuipG7GVfsLLpyPrPT96zs+n4+CggKoqalBW1sb6urqyM7Oxrlz5+o6a7VOTk4Ourq6yMvLK/OXcXX78uXLd19j5cqVcHNzQ9u2bTFr1izY2NhARkYG9+7dw5MnT/DLL78gNzcXurq64PP5WL16Ndzc3HDz5k1mDoQvX75ARkYGbdu2xcePH7F48WJ4eHjgwoULOHv2LFRUVJCbm4tXr14hNDQUvXv3hq6uLp4/f47k5GQMGTIE79+/x8KFC+Hh4QEjIyO8e/cOcXFxcHd3R25uLrhcLgghzA8OExMTHD16FN27dwdQHDSIRCLweDwmjUgkApfLZbaB4lq8oqIisX1f4/P5EAgEzHFjY2MMHToUmzZtEitzY2NjnDp1ClFRUVBXV8eWLVuQkZEBc3Nz5lyBQCCWH6C4L8qKFSvA4/GwdOlSsWOzZs3C7NmzIS8vj549e6KoqAjx8fHIzs6Gn59fqfnNz8/Hs2fFsztnZ2dj586dyMvLQ48ePZCbmwt9fX2kpaUhJCQE9vb2OH/+PE6cOCFWnkBx00Tbtm0xe/ZseHl5gc/nM19O3t7e2LlzJzw9PTFlyhRoaGjgxYsXOH78ODZs2ID79+/jypUr6NGjB7S0tHD37l18/PgRRkZGpZZ1165dcfnyZWb25fDwcHz+/BlDhgyRaJrq27cvdu3axQR/3t7e+Ouvv8Dj8WBjY4M3b95g0aJFaNeuHfOeVVNTw9KlSzFz5kxkZmZi+PDhMDQ0xLt37xAWFgZlZWUsWbJEat5UVFTKHZZd2nOxWCz8+uuv8Pf3h4KCAtNRuF27dmjRogVznoODAxYuXMgMw+7YsSOmT58OQggMDQ0RGxuLvXv3YsmSJcjNzUVubi4GDx6MgoIC7Nu3T2yeFC0tLSawSEtLw9u3b+Ho6Cg1jzweD4WFhbh69arE8N8aa9ohdejt27cEALl+/brY/hkzZhAHB4dyz1++fDnR0NAgDx48KDUNl8slOTk5zOv169cEAElPTycbBrmS1Z59yYZBroTH41X6FTIrhmz67SIJmRVTqfP+Pv2IGM86Q4xnnSHjQuOqdO/6/CoqKiJxcXFkxYoVZO3atSQnJ4ecPHmS5Ofn13ne6uqVm5tLEhISSH5+PhEKhTX+EggE5PPnz0QgEFTL9d68eUP8/PyIqakpadSoEVFWViYODg7kn3/+IV++fGHSrVmzhujp6REOh0N69epFQkNDCQCSmZnJpNm8eTMxNDQkSkpKxNvbmyxZsoQYGxsToVBI3r17Rzw8PIienh5hs9nE2NiYLFiwgPD5fFJYWEiGDRtGDA0NCZvNJvr6+sTPz48p06CgIKKmpsbcJyUlhXTv3p1wOBxiaGhINm7cSLp27UqmTJnCpDE2NiZr164Ve1ZbW1uycOHCUsti1KhRpH///mL7UlJSCJvNJgCYMv/48SPp378/UVZWJk2aNCHz5s0j3t7eYud+mx+hUEgyMzOJvLw8UVRUJDk5ORL337t3L2ndujVhs9lEQ0ODdOnShRw9erTM/KK4GpcAICoqKqRdu3bk8OHDYummT59OGjduTJSVlYmnpydZu3atWHmWvHbu3EkAkJs3b0oce/r0KRkwYABRV1cnHA6HWFlZkalTpxKBQEAeP35MevXqRbS1tYm8vDyxsLAgGzZsKPN9d+bMGdK0aVPC5/OJUCgkffv2Jb1795b6Pr9x4wYBQO7fv0+EQiHJz88nCxcuJFZWVoTD4RBTU1Myfvx48v79e4n7nDt3jvTq1YtoaGgQBQUFYmVlRf766y/y5s2bGvsbzc/PJxMnTiQaGhpEUVGRDBgwgLx9+1YsDQASFBTEbL99+5b4+PgQfX19oqCgQCwtLcnq1auZ99zFixfF/l9//UpJSWGus3TpUtKrV68y85aQkEByc3MlPsvS09MJAJKTk/PdMcDXWISUMq6qFvD+14589OhRDBgwgNnv4+OD7Oxsppe2NKtXr8aSJUtw4cIFqUO/SlMSDX/69AkHJniBJycHtkCAP45VvmYidHYs8rOLoKResUXwAOD5hy9wWxcDgYhAXk4GF/y7wlCz/I59DcWnT59w5swZvHr1Cra2tujVqxcaNWqEiIgI9OnT56edxIzL5SI1NRWmpqYSHfJqQnX1GaEq7mcp88WLF+PIkSO1MoMrIQSOjo6YNm1aqU1TP0OZVycejwdzc3McOHAAHTtK/94q6/MqMzMTWlpazJDh6lKn//fYbDbatGmDixcvMvtEIhEuXrwIJyenUs/7559/sHjxYkRGRlYqEKlrhBAs+i8RAlFx/Pdb1+Y/VCACFI+m+PLlC7y9vTFgwIAKjaCgKKr+y8vLw+PHj7Fp0yb88ccftXJPFouFHTt21KuZQhu6tLQ0zJ07t9RApK7U+Wgaf39/+Pj4oG3btnBwcMC6deuQn5/PjK4ZNWoUmjZtysx0uHLlSixcuBAHDhyAiYkJMyZbWVlZ6pCy+uRcwnvEPCue4KqpOgcTu9afnszf49WrVxCJRDA1NYW7uzvYbPZPWwNCUT+qyZMn4+DBgxgwYAB8fX1r7b6tW7eWmLWXqjozM7N6ud5XnQcjw4YNw8ePH7Fw4UJkZGSgdevWiIyMZDq1pqWliVW/bd26FTweD0OGDBG7TkBAgNSx1PUFly/E4jOJzPaCftbgsMsejlffFRYW4sKFC7h37x5sbGxgampKV9alqB9UaGgoQkND6zob1A+qzoMRoDji/npGxK9FR0eLbZcMN6stZc2yWt7sql/bGp2Ct9nFw8A6mWnB1Ub6WPKGgBCChIQEREZGQiAQoE+fPg2quYyiKIqqX+pFMFKfVWSWVWmzq37tdVYBtl1JAQDIybAQ2L9Fg576XPi/CcyMjIzg5uZWrZ2YKIqiqJ8PDUbKUd4sq9JmV/3WkvBEFAmKJ5YZ3cEEZk1qfsnw6iYSiXDr1i1YWFigcePGGDduHO2cSlEURVULGoxUkKJaxYfvfi3m2UecSyheCE1LWR5TnUtf2Ku+evfuHc6cOYP09HQ0atQIjRs3poEIRVEUVW1oMFKDeAIRAk///9oEc3pbQUWh4Ywy4fF4uHTpEuLi4tCkSROMGzeuThaHoiiKon5sNBipQaHXU5HyMR8AYG+kjoF2DeuLvKCgAI8ePULPnj3Rvn37chfjoiiKoqiqoFPW1ZAPuVysv1C8FgSLBfzt8QtkZOp/p9UvX74gPDwcRUVFUFdXx59//omOHTvSQISq9wIDA2ttPopu3brhzz//ZLYLCgowZMgQGBkZQVZWFtnZ2TAxMcG6detqLA/e3t5YtmxZjV3/Z7Nt2za4u7vXdTZ+WjQYqSErzj5FPq+48+vwdkb4palaOWfULUII7ty5g82bNyMxMRGfPhVPzkYnL6NGjx4NFouF33//XeKYn58fWCwWRo8eLZb+6+UdvmViYgIWiwUWiwUlJSXY29vjyJEj5ebj2LFj6NatG9TU1KCsrIxWrVrh77//RlZWVlUe67scP34cixcvZrZ3796Na9euITIyEm/fvoWamhpu376NCRMm1Mj9Hzx4gIiICEyZMkXi2MGDByErKyt14bzQ0NBSV6FlsVg4efKk2L66KPOsrCx4eXlBVVUV6urqGDt2LPLy8kpNn5aWBllZWeY99fVL2vsqMzMTBgYGYLFYyM7OZvb7+vri3r17iImJqYnHospBg5EacPdVFo7fL14tUY3TCDNcLes4R2X7+PEjQkJCEB4eDmtra/j5+dG+IZQYQ0NDhIWFiS2ZzuVyceDAARgZGVX6en///TfS09Nx//59tGvXDsOGDcP169dLTT9v3jwMGzYM7dq1w9mzZ/H48WOsWbMGDx48wN69e6v0TN9DU1NTbMXWlJQUWFtbo0WLFtDV1QWLxYK2tvZ3dfTmlbG688aNGzF06FCps04HBQVh5syZOHjwILhcbpXvX1dl7uXlhYSEBERFReHMmTO4evVqmUFd06ZN8fbtW6SnpzOvRYsWQVlZGb1795ZIP3bsWLRq1UpiP5vNxsiRI7Fhw4ZqfR6qYmgwUs2EIoKFp/6/0+r0XhbQVGLXYY7Kl5eXh4KCAvj4+MDDw4OOlKEk2Nvbw9DQEMePH2f2HT9+HEZGRrCzs6v09VRUVKCrqwsLCwts3rwZHA4H//33n9S0cXFxWLZsGdasWYNVq1ahQ4cOMDExgYuLC44dOwYfHx+p592+fRsuLi7Q0tKCmpoaunbtinv37jHHCSEIDAyEkZER5OXloa+vL1bTsGXLFpibm0NBQQE6Ojpisz5/3UzTrVs3rFmzBlevXoWGhgaz3P23zTTZ2dkYN24ctLW1oaqqih49euDBgwfM8ZJmpl27dpW5oKJQKMTRo0elNimkpqbi+vXrmD17NiwsLMT+f1VGVcv8ez158gSRkZHYtWsXHB0d0alTJ2zcuBFhYWF49+6d1HNkZWWhq6sr9jpx4gQ8PT0lgrWtW7ciOzsb06dPl3otd3d3nD59WizopmoH7cBazcJupyHhXS4AwFpPFSMdjes4R9Klpqbi4cOH6N+/P0xNTTFp0iS66mUdOLzsNgpyS/8FXHUEIhH5Xz8lyb5KiqpseM5tV6kr+vr6IiQkBF5eXgCA4OBgjBkzRmKW5MqSk5NDo0aNSq0J2L9/P5SVlTFp0iSpx0trdvjy5Qt8fHywceNGEEKwZs0a9OnTB8+ePYOKigqOHTuGf//9F2FhYbCxsUFGRgYTHNy5cwdTpkzB3r170aFDB2RlZZVafX/8+HHMnj0bjx8/RkhICBo3biw13dChQ8HhcHD27Fmoqalh+/bt6NmzJ5KTk6GpqQkAeP78OY4dO4bjx4+X2k/r4cOHyMnJkTrrcUhICPr27Qs1NTX8+uuvCAoKwsiRI6VepyxVLXMAsLGxwatXr0o93rlzZ5w9e1bqsRs3bkBdXV3s2ZydnSEjI4Nbt25h4MCB5eb97t27iI+Px+bNm8X2JyYm4u+//8atW7fw4sULqee2bdsWAoEAt27dQrdu3cq9F1V9ftpgJGjMMMgqSE5iBohPAV+ZKd8/5/Ow6lwSs72ovw1k61mn1YKCAkRFRSE+Ph5GRkbgcrngcDg0EKkjBbk85GdX/D1Wl3799VfMmTOH+aKJjY1FWFjYdwUjPB4Pa9asQU5ODlOj8K1nz56hWbNmle6/9O31duzYAXV1dVy5cgX9+vVDWloadHV14ezsjEaNGsHIyAgODg4AivshKCkpoV+/flBRUYGxsXGpNUCamppQVFQEm82Gjo6O1BmJr127hri4OHz48AHy8sWfO6tXr8bJkydx9OhRphmCx+Nhz5490NbWLvW5Xr16BVlZWTRp0kRsv0gkQmhoKDZu3AgAGD58OP766y9mKfjKqGqZA0BERAT4fH6pxzkcTqnHMjIyJJ5LTk4OmpqazKKo5QkKCoK1tTU6dOjA7CsqKsKIESOwatUqGBkZlRqMKCoqQk1NrcxgiqoZP20wwpeThez/pmSXISKxY9KmgC9vyncAWBOVhOyC4j9Cj9b6cDDVrKbcVo+EhARERERAKBSiX79+sLe3b9DT0v8IFFVrqgmv/JqRytLW1kbfvn0RGhoKQgj69u0LLS2tKuVu1qxZmD9/PrhcLpSVlbFixQr07dtXalpCSJXu8f79e8yfPx/R0dH48OEDhEIhCgoKkJaWBqC4pmLdunVo1qwZ3Nzc0KdPH7i7u0NOTg4uLi4wNjZmjrm5uWHgwIFVbsJ88OAB8vLyJGpNCgsLkZKSwmwbGxuXGYiUnCMvLy/xtxsVFYX8/Hz06dMHAKClpQUXFxcEBweLdbatiKqWOVD8DHWlsLAQBw4cwIIFC8T2z5kzB9bW1vj111/LvQaHw0FBQdlLgFDV76cNRkAI2AIBZIgIBjY6Yoe+nQK+IlO+J7zLwYFbxR9yimxZzOltXTP5/g5fvnyBqakpXF1dxTrfUXWnsk0lFSUSiZCbmwtVVdVqrfXy9fVlFrX8thq8MmbMmIHRo0dDWVkZOjo6ZQbFFhYWuHbtGvh8fqV+qfv4+CAzMxPr16+HsbEx5OXl4eTkxDQHGRoaIikpCRcuXEBUVBQmTZqEVatW4cqVK1BRUcG9e/cQHR2N8+fPY+HChQgMDMTt27fLbKIoTV5eHvT09KTWIn19vYqseq2lpYWCggLweDyw2f8fVAYFBSErK0us5kEkEuHhw4dYtGgRZGRkoKqqivz8fIhEIrH3RcmoEjW14lF/VS1z4PuaaXR1dfHhwwexfQKBAFlZWdDVLX9x0aNHj6KgoACjRo0S23/p0iU8evQIR48eBfD/wZaWlhbmzZuHRYsWMWmzsrLKDQip6vfTBiONhCL8ceJ8mWkqOgU8IQSBpxMg+t+PiSk9zaGrJr3zWW0SCoW4efMmCgoK4OLiAkdHR7Rv376us0U1YG5ubuDxeGCxWHB1da3ydbS0tGBmZlahtCUjHLZs2YKpU6dKHM/OzpYaIMTGxmLLli1MTcHr16+ZIeslOBwO3N3d4e7uDj8/P1hZWeHRo0ewt7eHnJwcnJ2d4ezsjICAAKirq+PSpUsYNGhQpZ/X3t4eGRkZkJOTg4mJSaXP/1rJXCqJiYnMvzMzM3Hq1Cmm/0sJoVCITp064fz583Bzc4OlpSUEAgHi4+Nhb2/PpCvp2GthYQGg6mUOfF8zjZOTE7Kzs3H37l20adMGQHEgIRKJ4OjoWOp5JYKCgtC/f3+JYOLYsWNinVJv374NX19fxMTEoHnz5sz+lJQUcLncKnXKpr7PTxuMVKdT8e9w++VnAEAzLSX4dqxc+2xNePv2Lf777z98+PAB7du3ByGENslQ301WVhZPnjxh/l2anJwcxMfHi+1r3LgxDA0NK31PR0dHzJw5E3/99Rfevn2LgQMHQl9fH8+fP8e2bdvQqVMnqV+Y5ubm2Lt3L9q2bYvc3FzMmDFD7IswNDQUQqEQjo6OUFRUxL59+8DhcGBsbIwzZ87gxYsX6NKlCzQ0NBAREQGRSARLy6oN03d2doaTkxMGDBiAf/75BxYWFnj37h3Cw8MxcOBAqZ1RS6OtrQ17e3tcu3aNCUb27t2Lxo0bw9PTU+LvvE+fPggKCoKbmxtsbGzQq1cv+Pr6Ys2aNWjWrBmSkpLw559/YtiwYcyQ/qqWOfB9zTTW1tZwc3PD+PHjsW3bNvD5fEyePBnDhw+Hvr4+gOLPtp49e2LPnj1i5fb8+XNcvXoVEREREtf9OuAAwASl1tbWYkFVTEwMmjVrJpGeqnk0GPmfqnZazSsSYFnEE2Z7oXsLsOXqrjMoIQTnzp3DrVu3oKenh3HjxjF/xBRVHaR10PxWdHS0xK/LsWPHYteuXVW658qVK9GmTRts3rwZ27Ztg0gkQvPmzTFkyJBSh5kGBQVhwoQJzLDkZcuWiQ3pVFdXx4oVK+Dv7w+hUIiWLVviv//+Q+PGjaGuro7jx48jMDAQXC4X5ubmOHjwoFitQ2WwWCxERERg3rx5GDNmDD5+/AhdXV106dIFOjo65V/gG+PGjcOePXuYJrPg4GAMHDhQ6g+OwYMHw9vbG58+fYKWlhYOHTqEgIAA/Pbbb3j37h0MDAwwcOBAiX4WVSnz6rB//35MnjwZPXv2hIyMDAYPHiw29wefz0dSUpJEv47g4GAYGBigV69eVb73wYMHMX78+CqfT1Udi3xPT6UGKDc3F2pqaljp3hMzT19g9h8IvCnRaVVDVxEjA8tu1lge8QTbrxb3zHa21sEun4r/wqluJbUfZ8+ehbq6OhwdHevFKBk+n4+IiAj06dPnp53RlcvlMqMaSps/ojrVVJ8RqnS1WeaFhYWwtLTEoUOH4OTkVKP3qs+qs8wTEhLQo0cPJCcnM31nflZlfV5lZmZCS0sLOTk5FfphUlG0ZuR/qtJpNeVjHoJjUwEAbDkZLOzXosbzKU1ubi7Onj0Lc3Nz2NvbS511kKKoHweHw8GePXsk+sBQVZeeno49e/b89IFIXaHByDcq02l10X+J4AuLK5Z+69IMRo1rd+ZSkUiEO3fu4OLFi2jUqJHUKY4pivox0Um5qpezs3NdZ+GnRoORKopKfI+ryR8BAE3VOZjUrWIjA6pLfn4+wsLC8ObNG9jb28PZ2bnMXuoURVEUVV/RYKQKuHwhFocnMtvz+lqDwy5/UrTqUDI/AIfDgaamJpydnet0kiGKoiiK+l60Z1sVbL/yAq+zisesd2jeGL1/KX8ynurw4sULbNmyBa9fv4aMjAwGDhxIAxGKoiiqwaM1I5X05nMBtkQ/BwDIyrAQ2N+mxufvKCgowPnz5/HgwQMYGxvTVXUpiqKoHwoNRippafgTFAmK17LxcTKBhU7NTqv++vVrHDx4EIQQ9O/fH61bt6aTl1EURVE/FBqMVELs8084+7h45UgtZTb+dDGvsXuVrAmhpaWFFi1aoHv37hVat4KiKIqiGhraZ6SC+EIRAk4nMNuz3KygqlD9E3gJhULExMRgw4YN+PLlCzgcDvr160cDEYqiKOqHRYORCtp9/SWef8gDANgZqWOwvUG13+P169fYsWMHLl++jFatWkFeXr7a70FRDUV0dDRYLBazomx1ePnyJVgslsS6OXV1nYoIDQ2VWJRux44dMDQ0hIyMDNatW4fAwEBmnZqacPHiRVhbW0MoFNbYPX4mPB4PJiYmuHPnTl1npd6gwUgFfPjCxboLzwAUz9C6qL8NZGSqt9/GzZs3ERwcDDk5OUyYMAEuLi5iy4NTVF35+PEjJk6cCCMjI8jLy0NXVxeurq6IjY1l0rBYLJw8ebLuMlnNnj9/jjFjxsDAwADy8vIwNTXFiBEj6uTLY9iwYUhOTma2c3NzMXnyZMyaNQtv377FhAkTMH36dFy8eLHG8jBz5kzMnz9fYnHEwsJCaGpqQktLC0VFkmt6lfa+GD16NAYMGCC2r67KfPPmzTAxMYGCggIcHR0RFxdX7jnr1q2DpaUlOBwODA0NMW3aNHC5XOb41q1b0apVK6iqqkJVVRVOTk44e/Ysc5zNZmP69OmYNWtWjTxTQ0SDkQpYeTYJeUUCAMCwtoZoZaBeLdclhDDLWpuamsLV1RVjx46Frm7tDBWmqIoYPHgw7t+/j927dyM5ORmnT59Gt27dkJmZWddZqxF37txBmzZtkJycjO3btyMxMREnTpyAlZUV/vrrr1rPD4fDQZMmTZjttLQ08Pl89O3bF3p6elBUVISysjIaN278Xffh8/lS91+7dg0pKSkYPHiwxLFjx47BxsYGVlZW3xWM1lWZHzp0CP7+/ggICMC9e/dga2sLV1dXfPjwodRzDhw4gNmzZyMgIABPnjxBUFAQDh06hLlz5zJpDAwMsGLFCty9exd37txBjx494OHhgYSE/2/q9/LywrVr18T2/dTITyYnJ4cAICvde4rtD5l1jWz67SIJmXVNbP+dl1nEeNYZYjzrDGkZEEk+feFWSz6ys7PJwYMHyebNm4lAIKiWa9ZXPB6PnDx5kvB4vLrOSp0pLCwkiYmJpLCwsFbuJxQKyefPn4lQKPyu63z+/JkAINHR0aWmMTY2JgCYl7GxMSGEkOfPn5P+/fuTJk2aECUlJdK2bVsSFRUldi6XyyUzZ84kBgYGhM1mk+bNm5Ndu3YRQgi5fPkyAUA+f/5MCCEkPz+fuLm5kQ4dOjD7du7cSaysrIi8vDyxtLQkmzdvFrv+rVu3SOvWrYm8vDxp06YNOX78OAFA7t+/L/VZRCIRsbGxIW3atJFadiX3TU1NFbuOQCAgY8aMIUZGRkRBQYFYWFiQdevWiZ17+fJl0q5dO6KoqEjU1NRIhw4dyMuXLwkhhMTHx5Nu3boRZWVloqKiQuzt7cnt27cJIYSEhIQQNTU15t9flzUAkpqaSgICAoitra3Y/coqm5L8h4WFkS5duhB5eXkSEhIitUz8/PzIkCFDpB7r1q0b2bZtG9m6dStxcXGROA6AnDhxQmK/j48P8fDwIIRUvMyl+d73uYODA/Hz8xO7nr6+Plm+fHmp5/j5+ZEePXqI7fP39ycdO3Ys814aGhrMe7tE9+7dyfz586uQ85pV1ufVp0+fCACSk5NTrfeko2nKIBQRBH7VafWvXpZorPx9/ThEIhFu376NS5cugc1mo0+fPnRV1Z/Yvjl/Ij/7c41cu2S2XmmU1DXw6/J15V5DWVkZysrKOHnyJNq3by+1H9Pt27fRpEkThISEwM3NjanKz8vLQ58+fbB06VLIy8tjz549cHd3R1JSEoyMjAAAo0aNwo0bN7BhwwbY2toiNTVV6uJv2dnZ6Nu3L5SVlREVFQVFRUXs378fCxcuxKZNm2BnZ4f79+9j/PjxUFJSgo+PD/Ly8tCvXz+4uLhg3759SE1NxdSpU8t83vj4eCQkJODAgQNSy+7bvhslRCIRDAwMEBoaCiMjI9y8eRMTJkyAnp4ePD09IRAIMGDAAIwfPx4HDx4Ej8dDXFwcM0zfy8sLdnZ22Lp1K2RlZREfHy91hethw4bB0NAQzs7OiIuLg6GhIbS1tSXSlVc2JWbPno01a9bAzs6u1NWkY2JiMHLkSIn9KSkpuHHjBo4fPw5CCKZNm4ZXr15VeiLGqpY5ACxfvhzLly8v8/qJiYnM++1rPB4Pd+/exZw5c5h9MjIycHZ2xo0bN0q9XocOHbBv3z7ExcXBwcEBL168QEREBLy9vaWmFwqFOHLkCPLz8yVWWHZwcEBMTEyZ+f9Z0GCkDIfvvMajtzkAACtdFXg5Sr6hK33Nw4eRlJSEtm3bomfPnrWynDxVf+Vnf0ZeVv1t7pCTk0NoaCjGjx+Pbdu2wd7eHl27dsXw4cOZhRlLvgzV1dXFmhhtbW1ha2vLbC9evBgnTpzA6dOnMXnyZCQnJ+Pw4cOIiopiFilr1kxypeyMjAwMGzYM5ubmOHDgANOXKiAgAGvWrMGgQYMAFDd1JiYmYvv27fDx8cGBAwcgEokQFBQEBQUF2NjY4M2bN5g4cWKpz/vsWXHfMCsrq0qVU6NGjRAYGMgsZ9+8eXPcuHEDhw8fhqenJ3Jzc5GTk4N+/fqhefPmAABra2vm/LS0NMyYMYO5r7m59GkDOBwO0xyjra1dapNueWVT4s8//2TSlObVq1fQ19eX2B8cHIzevXtDQ0MDAODq6oqQkBAEBgaWeb1vVbXMAeC3335D7969oaysXGrgLS3vAPDp0ycIhULo6OiI7dfR0cHTp09LvefIkSPx6dMndOrUCYQQCAQC/P7772LNNADw6NEjODk5gcvlQllZGSdOnECLFuIru+vr6+PVq1cVedQfHg1GSpFdwMM/kf//hgzsbwM52arVYPD5fPD5fCgqKqJt27bo2LEjDA0NqyurVAOmpK5RY9cur2akogYPHoy+ffsiJiYGN2/exNmzZ/HPP/9g165dGD16dKnn5eXlITAwEOHh4UhPT4dAIEBhYSHS0tIAFP8ilpWVRdeuXcu8v4uLCxwcHHDo0CGm1iU/Px8pKSkYO3Ysxo8fz6QVCATMEvBPnjxBq1atxAL+b3+ZfosQUubxsmzZsgW7du3C27dvUVhYCB6Px4xw0dTUxOjRo+Hq6goXFxc4OzvD09MTenp6AAB/f3+MGzcOe/fuhbOzM4YOHcoELZVVkbIp0bZt23KvV1hYKPGjSSgUYvfu3Vi/fj2z79dff8X06dOxcOHCStX2fk+Za2pqQk5ODqqqqrVWwxwdHY1ly5Zhy5YtcHR0xPPnzzF16lQsXrwYCxYsYNJZWloiPj4eOTk5OHr0KHx8fHDlyhWxgITD4aCgoKBW8l3f0WCkFGujkvG5oLhDl7utPto3q1rnsOfPnyM8PBwGBgYYPHgwzMxqd3Vfqn6rSFNJVYhEIuZXenV8SCsoKMDFxQUuLi5YsGABxo0bh4CAgDKDkenTpyMqKgqrV6+GmZkZOBwOhgwZAh6PBwAVXmW6b9++OHbsGBITE9GyZUsAxYEOAOzcuROOjo5i6b8d8VEZFhYWAICnT5/Czs6uwueFhYVhxowZWLx4Mbp37w41NTWsWrUKt27dYtKEhIRgypQpiIyMxKFDhzB//nxERUWhffv2CAwMxMiRIxEeHo6zZ88iICAAYWFhGDhwYKWfoTJlU5H5i7S0tPD5s3hT4rlz5/D27VsMGzZMbL9QKMTFixfh4uICAFBRUUFOTo7ENbOzs5nAqKplDnxfM42WlhZkZWXx/v17sf3v378vcxDBggUL4O3tjXHjxgEAWrZsifz8fEyYMAHz5s1j/t7YbDbzed+mTRvcvn0b69evx/bt25lrZWVlSW1m+xnRzgpSJL7Lxb6bxVVnnEaymNun8tWH+fn5OH78OPbv3w8NDQ1069atmnNJUXWnRYsWyM/PZ7YbNWokMQdFbGwsRo8ejYEDB6Jly5bQ1dXFy5cvmeMtW7aESCTClStXyrzXihUr4OPjg549eyIxsXi1bB0dHejr6+PFixcwMzMTe5mamgIobgZ5+PCh2JDLmzdvlnmv1q1bo0WLFlizZg1EIpHE8dLmPImNjUWHDh0wbtw42NnZwczMDCkpKRLp7OzsMGfOHFy/fh2//PILDhw4wByzsLDAtGnTcP78eQwaNAghISFl5rU0FSmbyrCzs2PKvURQUBCGDx+O+Ph4sdfw4cMRFBTEpLO0tMTdu3fFzhUKhXjw4AEThFS1zIHiZpqrV6/i3r17EnkpeZXWTMNms9GmTRuxIdEikQgXL14sswatoKBAIsAvCfLKquURiUQSw58fP35c6QDsR0VrRqQIPJ0A0f/eU3/0NIOeWsV+wZXg8XjYunUrRCIRPDw8YGtrS9eToRqkzMxMDB06FL6+vmjVqhVUVFRw584d/PPPP/Dw8GDSmZiY4OLFi+jYsSPk5eWhoaEBc3NzHD9+HO7u7mCxWFiwYIHYl42JiQl8fHzg6+vLdGB99eoVPnz4AE9PT7F8rF69GkKhED169EB0dDSsrKywaNEiTJkyBWpqanBzc0NRURHu3LmDz58/w9/fHyNHjsS8efMwfvx4zJkzBy9fvsTq1avLfF4Wi4WQkBA4Ozujc+fOmDdvHqysrJCXl4f//vsP58+flxo8mZubY8+ePbh48SJsbGywf/9+3L59m/nyT01NxY4dO9C/f3/o6+sjKSkJz549w6hRo1BYWIgZM2ZgyJAhMDU1xZs3b3D79m2pQ2krqryyqQxXV1fs3r2b2f748SP+++8/nD59Gr/88otY2lGjRmHgwIHIysqCpqYm/P39MXbsWFhZWcHFxQX5+fnYuHEjPn/+zNQsVLXMge9vpvH394ePjw/atm0LBwcHrFu3Dvn5+RgzZozYMzVt2pSpgXF3d8fatWthZ2fHNNMsWLAA7u7uTFAyZ84c9O7dG0ZGRvjy5QsOHDiA6OhonDt3Tuz+MTExWLx4caXz/UOq1rE5DUB5Q3u3+l9hhvJ2W3WZcPkVH3b76dMnwufzCSGEJCYmkry8vGrNe0NFh/Y23KG9XC6XzJ49m9jb2xM1NTWiqKhILC0tyfz580lBQQGT7vTp08TMzIzIyckxQ3tTU1NJ9+7dCYfDIYaGhmTTpk2ka9euZOrUqcx5hYWFZNq0aURPT4+w2WxiZmZGgoODCSGSQ3sJIeSPP/4genp6JCkpiRBCyP79+0nr1q0Jm80mGhoapEuXLuT48eNM+hs3bhBbW1vCZrNJ69atybFjx8oc2lsiKSmJjBo1iujr6xM2m02MjY3JiBEjyL1795hn+/o6XC6X+Pj4EFVVVaKurk4mTpxIZs+ezQy3zcjIIAMGDGCe09jYmCxcuJAIhUJSVFREhg8fTgwNDQmbzSb6+vpk8uTJzHvl66G9hBBy//59ZkhvCWlDe8sqm2/zX5bMzEyioKBAnj59SgghZPXq1URdXV3q33NRURFRV1cn69evF8tHmzZtiIqKCtHR0SF9+vQhDx48qHSZS1Md7/ONGzcSIyMjwmaziYODA7l586bY8a5duxIfHx9mm8/nk8DAQNK8eXOioKBADA0NyaRJk8Tep76+vsTY2Jiw2Wyira1NevbsSc6fPy923evXrxN1dXWxv6P6oi6G9rII+Y7eQw1Qbm4u1NTUsNK9J2aevsDsD50di/zsIuTLEmxRKa7WDRndDt2tmpR2KYZAIEBsbCxiYmLQs2fPcjvJ/Wz4fD4iIiLQp08fqcMVfwZcLhepqakwNTWtlRFU1d1nhCrfj1zmM2bMQG5urlh/h/qgIZf5sGHDYGtrKzEKpz4o6/MqMzMTWlpayMnJgaqqarXds2H936sFJbXIPa2aVCgQSUtLw/bt23H16lU4OTlVqHc6RVFUQzJv3jwYGxtL7dNBVR6Px0PLli0xbdq0us5KvUH7jPyP4Ks/MrasDBb0a1FG6mLp6ekICQmBgYEBJkyYIDFenaIo6kegrq5eL3/BN1RsNhvz58+v62zUKz9tMCJopILQ2f+/0Bc3l4+SLqbju5jCREv6kDdCCNLS0mBsbAxdXV0MHz4c5ubmDa6KkKIoiqLqi582GCGQQX72/w+zKglERLLAlO7S5wLJzs5GREQEnj17Bl9fXxgaGsLS0rIWcktRFEVRP66fNhgBACV1eRAQfPrCg1BEwGMRWPY0gCJbvFhEIhFu3bqFy5cvQ0FBgVkfgqIq6yfrL05RVANUF59TP20wwoIIo1d0xMaLz7A5KhkA4NSsMRYMkKzpuHPnDs6fPw8HBwf06NFD6mJhFFWWklFEBQUFFZ55lKIoqi6UzJL8PbMZV9ZPG4wAwNvsQmyOfg4AkJVhIbC/DTM5GY/HQ1paGszMzGBvbw8DA4NSZ/KjqPLIyspCXV0dHz58AAAoKirW6ER4IpEIPB4PXC6X9meqJbTMax8t8+onEonw8eNHKCoqQk6u9kKEnzoYWRb+BFx+8Sga7/bGsNRVAQAkJycjIiICXC4X06ZNg7y8PA1EqO9Wst5FSUBSkwghKCwsBIfDobP/1hJa5rWPlnnNkJGRgZGRUa2W6U8djIQ/SgcANFZiY5qLBfLy8hAZGYmEhAQ0b94cffv2pU0yVLVhsVjQ09NDkyZNwOfza/RefD4fV69eRZcuXX7aieZqGy3z2kfLvGaw2exar2n6qYORErPcrKDGaYQTJ84gNTWVWdiLRtpUTZCVla3xtlhZWVkIBAIoKCjQD+laQsu89tEy/3HUi0a2zZs3w8TEBAoKCnB0dERcXFyZ6Y8cOQIrKysoKCigZcuWiIiIqPK9HfUaoW1jAQDAxcUFfn5+aNWqFQ1EKIqiKKqW1HkwcujQIfj7+yMgIAD37t2Dra0tXF1dS21Xv379OkaMGIGxY8fi/v37GDBgAAYMGIDHjx9X6r6ExUJrubewyb2FmJirAABlZWUoKip+9zNRFEVRFFVxdR6MrF27FuPHj8eYMWPQokULbNu2DYqKiggODpaafv369XBzc8OMGTNgbW2NxYsXw97eHps2barUfQuMTdGanYHOnTrBy8urOh6FoiiKoqgqqNM+IzweD3fv3sWcOXOYfTIyMnB2dsaNGzeknnPjxg34+/uL7XN1dcXJkyelpi8qKkJR0f/PtJqTk1N874J8DPh1DJoZ6TH7qJrB5/NRUFCAzMxM2q5bS2iZ1z5a5rWPlnnty8rKAlD9E6PVaTDy6dMnCIVCiQXmdHR08PTpU6nnZGRkSE2fkZEhNf3y5cuxaNEiif2rt23H6m31azlsiqIoimoIMjMzoaamVm3X++FH08yZM0esJiU7OxvGxsZIS0ur1oKkSpebmwtDQ0O8fv0aqqqqdZ2dnwIt89pHy7z20TKvfTk5OTAyMoKmpma1XrdOgxEtLS3Iysri/fv3Yvvfv3/PTBD1LV1d3Uqll5eXlzpXiJqaGn3z1jJVVVVa5rWMlnnto2Ve+2iZ177qnoekTjuwstlstGnTBhcvXmT2iUQiXLx4EU5OTlLPcXJyEksPAFFRUaWmpyiKoiiqfqvzZhp/f3/4+Pigbdu2cHBwwLp165Cfn48xY8YAAEaNGoWmTZti+fLlAICpU6eia9euWLNmDfr27YuwsDDcuXMHO3bsqMvHoCiKoiiqiuo8GBk2bBg+fvyIhQsXIiMjA61bt0ZkZCTTSTUtLU2sOqhDhw44cOAA5s+fj7lz58Lc3BwnT57EL7/8UqH7ycvLIyAggE7zXotomdc+Wua1j5Z57aNlXvtqqsxZpLrH51AURVEURVVCnU96RlEURVHUz40GIxRFURRF1SkajFAURVEUVadoMEJRFEVRVJ36IYORzZs3w8TEBAoKCnB0dERcXFyZ6Y8cOQIrKysoKCigZcuWiIiIqKWc/jgqU+Y7d+5E586doaGhAQ0NDTg7O5f7/4iSVNn3eYmwsDCwWCwMGDCgZjP4A6psmWdnZ8PPzw96enqQl5eHhYUF/XyppMqW+bp162BpaQkOhwNDQ0NMmzYNXC63lnLb8F29ehXu7u7Q19cHi8Uqdd23r0VHR8Pe3h7y8vIwMzNDaGho5W9MfjBhYWGEzWaT4OBgkpCQQMaPH0/U1dXJ+/fvpaaPjY0lsrKy5J9//iGJiYlk/vz5pFGjRuTRo0e1nPOGq7JlPnLkSLJ582Zy//598uTJEzJ69GiipqZG3rx5U8s5b7gqW+YlUlNTSdOmTUnnzp2Jh4dH7WT2B1HZMi8qKiJt27Ylffr0IdeuXSOpqakkOjqaxMfH13LOG67Klvn+/fuJvLw82b9/P0lNTSXnzp0jenp6ZNq0abWc84YrIiKCzJs3jxw/fpwAICdOnCgz/YsXL4iioiLx9/cniYmJZOPGjURWVpZERkZW6r4/XDDi4OBA/Pz8mG2hUEj09fXJ8uXLpab39PQkffv2Fdvn6OhIfvvttxrN54+ksmX+LYFAQFRUVMju3btrKos/nKqUuUAgIB06dCC7du0iPj4+NBippMqW+datW0mzZs0Ij8errSz+cCpb5n5+fqRHjx5i+/z9/UnHjh1rNJ8/qooEIzNnziQ2NjZi+4YNG0ZcXV0rda8fqpmGx+Ph7t27cHZ2ZvbJyMjA2dkZN27ckHrOjRs3xNIDgKura6npKXFVKfNvFRQUgM/nV/vCSz+qqpb533//jSZNmmDs2LG1kc0fSlXK/PTp03BycoKfnx90dHTwyy+/YNmyZRAKhbWV7QatKmXeoUMH3L17l2nKefHiBSIiItCnT59ayfPPqLq+Q+t8Btbq9OnTJwiFQmb21hI6Ojp4+vSp1HMyMjKkps/IyKixfP5IqlLm35o1axb09fUl3tCUdFUp82vXriEoKAjx8fG1kMMfT1XK/MWLF7h06RK8vLwQERGB58+fY9KkSeDz+QgICKiNbDdoVSnzkSNH4tOnT+jUqRMIIRAIBPj9998xd+7c2sjyT6m079Dc3FwUFhaCw+FU6Do/VM0I1fCsWLECYWFhOHHiBBQUFOo6Oz+kL1++wNvbGzt37oSWllZdZ+enIRKJ0KRJE+zYsQNt2rTBsGHDMG/ePGzbtq2us/bDio6OxrJly7Blyxbcu3cPx48fR3h4OBYvXlzXWaPK8UPVjGhpaUFWVhbv378X2//+/Xvo6upKPUdXV7dS6SlxVSnzEqtXr8aKFStw4cIFtGrVqiaz+UOpbJmnpKTg5cuXcHd3Z/aJRCIAgJycHJKSktC8efOazXQDV5X3uZ6eHho1agRZWVlmn7W1NTIyMsDj8cBms2s0zw1dVcp8wYIF8Pb2xrhx4wAALVu2RH5+PiZMmIB58+ZV+7L3VOnfoaqqqhWuFQF+sJoRNpuNNm3a4OLFi8w+kUiEixcvwsnJSeo5Tk5OYukBICoqqtT0lLiqlDkA/PPPP1i8eDEiIyPRtm3b2sjqD6OyZW5lZYVHjx4hPj6eefXv3x/du3dHfHw8DA0NazP7DVJV3ucdO3bE8+fPmcAPAJKTk6Gnp0cDkQqoSpkXFBRIBBwlwSChy7DViGr7Dq1c39r6LywsjMjLy5PQ0FCSmJhIJkyYQNTV1UlGRgYhhBBvb28ye/ZsJn1sbCyRk5Mjq1evJk+ePCEBAQF0aG8lVbbMV6xYQdhsNjl69ChJT09nXl++fKmrR2hwKlvm36KjaSqvsmWelpZGVFRUyOTJk0lSUhI5c+YMadKkCVmyZEldPUKDU9kyDwgIICoqKuTgwYPkxYsX5Pz586R58+bE09Ozrh6hwfny5Qu5f/8+uX//PgFA1q5dS+7fv09evXpFCCFk9uzZxNvbm0lfMrR3xowZ5MmTJ2Tz5s10aG+JjRs3EiMjI8Jms4mDgwO5efMmc6xr167Ex8dHLP3hw4eJhYUFYbPZxMbGhoSHh9dyjhu+ypS5sbExASDxCggIqP2MN2CVfZ9/jQYjVVPZMr9+/TpxdHQk8vLypFmzZmTp0qVEIBDUcq4btsqUOZ/PJ4GBgaR58+ZEQUGBGBoakkmTJpHPnz/XfsYbqMuXL0v9fC4pZx8fH9K1a1eJc1q3bk3YbDZp1qwZCQkJqfR9WYTQuiuKoiiKourOD9VnhKIoiqKohocGIxRFURRF1SkajFAURVEUVadoMEJRFEVRVJ2iwQhFURRFUXWKBiMURVEURdUpGoxQFEVRFFWnaDBCURRFUVSdosEIRf1gQkNDoa6uXtfZqDIWi4WTJ0+WmWb06NEYMGBAreSHoqiaR4MRiqqHRo8eDRaLJfF6/vx5XWcNoaGhTH5kZGRgYGCAMWPG4MOHD9Vy/fT0dPTu3RsA8PLlS7BYLMTHx4ulWb9+PUJDQ6vlfqUJDAxknlNWVhaGhoaYMGECsrKyKnUdGjhRVPnk6joDFEVJ5+bmhpCQELF92tradZQbcaqqqkhKSoJIJMKDBw8wZswYvHv3DufOnfvua5e2PPzX1NTUvvs+FWFjY4MLFy5AKBTiyZMn8PX1RU5ODg4dOlQr96eonwWtGaGoekpeXh66urpiL1lZWaxduxYtW7aEkpISDA0NMWnSJOTl5ZV6nQcPHqB79+5QUVGBqqoq2rRpgzt37jDHr127hs6dO4PD4cDQ0BBTpkxBfn5+mXljsVjQ1dWFvr4+evfujSlTpuDChQsoLCyESCTC33//DQMDA8jLy6N169aIjIxkzuXxeJg8eTL09PSgoKAAY2NjLF++XOzaJc00pqamAAA7OzuwWCx069YNgHhtw44dO6Cvrw+RSCSWRw8PD/j6+jLbp06dgr29PRQUFNCsWTMsWrQIAoGgzOeUk5ODrq4umjZtCmdnZwwdOhRRUVHMcaFQiLFjx8LU1BQcDgeWlpZYv349czwwMBC7d+/GqVOnmFqW6OhoAMDr16/h6ekJdXV1aGpqwsPDAy9fviwzPxT1o6LBCEU1MDIyMtiwYQMSEhKwe/duXLp0CTNnziw1vZeXFwwMDHD79m3cvXsXs2fPRqNGjQAAKSkpcHNzw+DBg/Hw4UMcOnQI165dw+TJkyuVJw6HA5FIBIFAgPXr12PNmjVYvXo1Hj58CFdXV/Tv3x/Pnj0DAGzYsAGnT5/G4cOHkZSUhP3798PExETqdePi4gAAFy5cQHp6Oo4fPy6RZujQocjMzMTly5eZfVlZWYiMjISXlxcAICYmBqNGjcLUqVORmJiI7du3IzQ0FEuXLq3wM758+RLnzp0Dm81m9olEIhgYGODIkSNITEzEwoULMXfuXBw+fBgAMH36dHh6esLNzQ3p6elIT09Hhw4dwOfz4erqChUVFcTExCA2NhbKyspwc3MDj8ercJ4o6ofxvcsNUxRV/Xx8fIisrCxRUlJiXkOGDJGa9siRI6Rx48bMdkhICFFTU2O2VVRUSGhoqNRzx44dSyZMmCC2LyYmhsjIyJDCwkKp53x7/eTkZGJhYUHatm1LCCFEX1+fLF26VOycdu3akUmTJhFCCPnjjz9Ijx49iEgkknp9AOTEiROEEEJSU1MJAHL//n2xND4+PsTDw4PZ9vDwIL6+vsz29u3bib6+PhEKhYQQQnr27EmWLVsmdo29e/cSPT09qXkghJCAgAAiIyNDlJSUiIKCArOU+tq1a0s9hxBC/Pz8yODBg0vNa8m9LS0txcqgqKiIcDgccu7cuTKvT1E/ItpnhKLqqe7du2Pr1q3MtpKSEoDiWoLly5fj6dOnyM3NhUAgAJfLRUFBARQVFSWu4+/vj3HjxmHv3r1MU0Pz5s0BFDfhPHz4EPv372fSE0IgEomQmpoKa2trqXnLycmBsrIyRCIRuFwuOnXqhF27diE3Nxfv3r1Dx44dxdJ37NgRDx48AFDcxOLi4gJLS0u4ubmhX79+6NWr13eVlZeXF8aPH48tW7ZAXl4e+/fvx/DhwyEjI8M8Z2xsrFhNiFAoLLPcAMDS0hKnT58Gl8vFvn37EB8fjz/++EMszebNmxEcHIy0tDQUFhaCx+OhdevWZeb3wYMHeP78OVRUVMT2c7lcpKSkVKEEKKpho8EIRdVTSkpKMDMzE9v38uVL9OvXDxMnTsTSpUuhqamJa9euYezYseDxeFK/VAMDAzFy5EiEh4fj7NmzCAgIQFhYGAYOHIi8vDz89ttvmDJlisR5RkZGpeZNRUUF9+7dg4yMDPT09MDhcAAAubm55T6Xvb09UlNTcfbsWVy4cAGenp5wdnbG0aNHyz23NO7u7iCEIDw8HO3atUNMTAz+/fdf5nheXh4WLVqEQYMGSZyroKBQ6nXZbDbz/2DFihXo27cvFi1ahMWLFwMAwsLCMH36dKxZswZOTk5QUVHBqlWrcOvWrTLzm5eXhzZt2ogFgSXqSydliqpNNBihqAbk7t27EIlEWLNmDfOrv6R/QlksLCxgYWGBadOmYcSIEQgJCcHAgQNhb2+PxMREiaCnPDIyMlLPUVVVhb6+PmJjY9G1a1dmf2xsLBwcHMTSDRs2DMOGDcOQIUPg5uaGrKwsaGpqil2vpH+GUCgsMz8KCgoYNGgQ9u/fj+fPn8PS0hL29vbMcXt7eyQlJVX6Ob81f/589OjRAxMnTmSes0OHDpg0aRKT5tuaDTabLZF/e3t7HDp0CE2aNIGqqup35YmifgS0AytFNSBmZmbg8/nYuHEjXrx4gb1792Lbtm2lpi8sLMTkyZMRHR2NV69eITY2Frdv32aaX2bNmoXr169j8uTJiI+Px7Nnz3Dq1KlKd2D92owZM7By5UocOnQISUlJmD17NuLj4zF16lQAwNq1a3Hw4EE8ffoUycnJOHLkCHR1daVO1NakSRNwOBxERkbi/fv3yMnJKfW+Xl5eCA8PR3BwMNNxtcTChQuxZ88eLFq0CAkJCXjy5AnCwsIwf/78Sj2bk5MTWrVqhWXLlgEAzM3NcefOHZw7dw7JyclYsGABbt++LXaOiYkJHj58iKSkJHz69Al8Ph9eXl7Q0tKCh4cHYmJikJqaiujoaEyZMgVv3rypVJ4o6odQ151WKIqSJK3TY4m1a9cSPT09wuFwiKurK9mzZw8BQD5//kwIEe9gWlRURIYPH04MDQ0Jm80m+vr6ZPLkyWKdU+Pi4oiLiwtRVlYmSkpKpFWrVhIdUL/2bQfWbwmFQhIYGEiaNm1KGjVqRGxtbcnZs2eZ4zt27CCtW7cmSkpKRFVVlfTs2ZPcu3ePOY6vOrASQsjOnTuJoaEhkZGRIV27di21fIRCIdHT0yMASEpKikS+IiMjSYcOHQiHwyGqqqrEwcGB7Nixo9TnCAgIILa2thL7Dx48SOTl5UlaWhrhcrlk9OjRRE1Njairq5OJEyeS2bNni5334cMHpnwBkMuXLxNCCElPTyejRo0iWlpaRF5enjRr1oyMHz+e5OTklJonivpRsQghpG7DIYqiKIqifma0mYaiKIqiqDpFgxGKoiiKouoUDUYoiqIoiqpTNBihKIqiKKpO0WCEoiiKoqg6RYMRiqIoiqLqFA1GKIqiKIqqUzQYoSiKoiiqTtFghKIoiqKoOkWDEYqiKIqi6hQNRiiKoiiKqlP/B9rJH5ETLaHXAAAAAElFTkSuQmCC"},"metadata":{}}]}]}