diff --git a/ElasticNet.py b/ElasticNet.py new file mode 100644 index 0000000..78df1b3 --- /dev/null +++ b/ElasticNet.py @@ -0,0 +1,171 @@ +import numpy as np + +class ElasticNetModel: + + def __init__( + self, + alpha=1.0, + l1_ratio=0.5, + fit_intercept=True, + max_iter=1000, + tolerance=1e-4, + learning_rate=0.01, + optimization='batch', + random_state=None, + early_stopping=False, + patience=10, + learning_rate_schedule=None + ): + self.alpha = alpha + self.l1_ratio = l1_ratio + self.fit_intercept = fit_intercept + self.max_iter = max_iter + self.tolerance = tolerance + self.learning_rate = learning_rate + self.optimization = optimization.lower() + self.random_state = random_state + self.early_stopping = early_stopping + self.patience = patience + self.learning_rate_schedule = learning_rate_schedule + self.coef_ = None + self.intercept_ = 0.0 + self.mean_ = None + self.std_dev_ = None + self.y_mean_ = None + self.y_std_dev_ = None + + def _initialize_weights(self, n_features): + rng = np.random.default_rng(self.random_state) + self.coef_ = rng.normal(loc=0.0, scale=0.01, size=n_features) + if self.fit_intercept: + self.intercept_ = 0.0 + + def _scale_features(self, X): + self.mean_ = np.mean(X, axis=0) + self.std_dev_ = np.std(X, axis=0) + self.std_dev_[self.std_dev_ == 0] = 1 + return (X - self.mean_) / self.std_dev_ + + def _compute_loss(self, X_scaled, y_scaled): + predictions = X_scaled.dot(self.coef_) + (self.intercept_ if self.fit_intercept else 0) + residuals = y_scaled - predictions + mse_loss = np.mean(residuals ** 2) + l1_penalty = self.alpha * self.l1_ratio * np.sum(np.abs(self.coef_)) + l2_penalty = self.alpha * (1 - self.l1_ratio) * np.sum(self.coef_ ** 2) + return mse_loss + l1_penalty + l2_penalty + + def _learning_rate_decay(self, iteration): + if self.learning_rate_schedule == 'time_decay': + return self.learning_rate / (1 + iteration * 0.001) + elif self.learning_rate_schedule == 'step_decay': + return self.learning_rate * (0.5 ** (iteration // 500)) + else: + return self.learning_rate + + def fit(self, X, y): + print(f"Fitting model with X shape {X.shape}, y shape {y.shape}") + + # Input validation + if not isinstance(X, np.ndarray) or not isinstance(y, np.ndarray): + raise ValueError("X and y must be NumPy arrays.") + if X.size == 0 or y.size == 0: + raise ValueError("Input data X and y must not be empty.") + if X.shape[0] != y.shape[0]: + raise ValueError("Number of samples in X and y must be equal.") + if not np.issubdtype(y.dtype, np.number) or not np.issubdtype(X.dtype, np.number): + raise ValueError("X and y must be numeric arrays.") + if self.optimization not in ['batch', 'stochastic']: + raise ValueError(f"Invalid optimization option: {self.optimization}") + + X_scaled = self._scale_features(X) + self.y_mean_ = np.mean(y) + self.y_std_dev_ = np.std(y) + if self.y_std_dev_ == 0: + self.y_std_dev_ = 1 + y_scaled = (y - self.y_mean_) / self.y_std_dev_ + + n_samples, n_features = X.shape + print(f"Number of samples: {n_samples}, Number of features: {n_features}") + self._initialize_weights(n_features) + print(f"Initialized coefficients with shape: {self.coef_.shape}") + + previous_loss = self._compute_loss(X_scaled, y_scaled) + + for iteration in range(1, self.max_iter + 1): + if self.optimization == 'batch': + predictions = X_scaled.dot(self.coef_) + (self.intercept_ if self.fit_intercept else 0) + errors = predictions - y_scaled + gradient_wrt_coef = (2 / n_samples) * X_scaled.T.dot(errors).flatten() + l1_grad = self.alpha * self.l1_ratio * np.sign(self.coef_) + l2_grad = 2 * self.alpha * (1 - self.l1_ratio) * self.coef_ + total_grad_coef = gradient_wrt_coef + l1_grad + l2_grad + lr_adjusted = self._learning_rate_decay(iteration) + + # Update coefficients + if total_grad_coef.shape == gradient_wrt_coef.shape: + self.coef_ -= lr_adjusted * total_grad_coef + else: + raise ValueError(f"Gradient shapes do not match: {gradient_wrt_coef.shape} vs {total_grad_coef.shape}") + + if self.fit_intercept: + intercept_grad = (2 / n_samples) * np.sum(errors) + self.intercept_ -= lr_adjusted * intercept_grad + + elif self.optimization == 'stochastic': + indices = np.random.permutation(n_samples) + for i in indices: + xi_scaled = X_scaled[i].reshape(1, -1) + yi_scaled = y_scaled[i] + prediction_i = xi_scaled.dot(self.coef_) + (self.intercept_ if self.fit_intercept else 0) + error_i = prediction_i - yi_scaled + gradient_wrt_coef_i = 2 * xi_scaled.T.dot(error_i).flatten() + l1_grad_i = self.alpha * self.l1_ratio * np.sign(self.coef_) + l2_grad_i = 2 * self.alpha * (1 - self.l1_ratio) * self.coef_ + total_grad_coef_i = gradient_wrt_coef_i + l1_grad_i + l2_grad_i + lr_adjusted_i = self._learning_rate_decay(iteration) + + # Update coefficients + if total_grad_coef_i.shape == gradient_wrt_coef_i.shape: + self.coef_ -= lr_adjusted_i * total_grad_coef_i + else: + raise ValueError(f"Gradient shapes do not match: {gradient_wrt_coef_i.shape} vs {total_grad_coef_i.shape}") + + if self.fit_intercept: + intercept_grad_i = 2 * error_i + self.intercept_ -= lr_adjusted_i * intercept_grad_i.item() + + loss_value = self._compute_loss(X_scaled, y_scaled) + if iteration % 100 == 0 or iteration == 1: + print(f"Iteration {iteration}: Loss value: {loss_value}") + + if np.isnan(loss_value) or np.isinf(loss_value): + print(f"Numerical issue detected at iteration {iteration}: Loss value: {loss_value}") + break + + if abs(previous_loss - loss_value) < self.tolerance: + print(f"Convergence reached at iteration {iteration}: Loss value: {loss_value}") + break + + previous_loss = loss_value + + def predict(self, X): + # Ensure that the model is fitted before making predictions. + if self.coef_ is None: + raise ValueError("Model has not been fitted yet.") + if not isinstance(X, np.ndarray): + raise ValueError("X must be a NumPy array.") + # Check for empty input data. + if X.size == 0: + raise ValueError("Input data X must not be empty.") + # Ensure that the number of features in the input matches the trained model. + if X.shape[1] != len(self.coef_): + raise ValueError("Number of features in X must match number of coefficients.") + # Scale features using the training data's scaling parameters. + X_scaled = (X - self.mean_) / self.std_dev_ + # Handle zero variance features to prevent division by zero. + X_scaled[:, self.std_dev_ == 0] = 0 + # Calculate predicted target values in scaled space. + y_pred_scaled = X_scaled.dot(self.coef_) + (self.intercept_ if self.fit_intercept else 0) + # Reverse scaling to obtain predictions in original target space. + y_pred = y_pred_scaled * self.y_std_dev_ + self.y_mean_ + return y_pred \ No newline at end of file diff --git a/README.md b/README.md index c1e8359..85d8846 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,109 @@ + # Project 1 -Put your README here. Answer the following questions. +Project Members: + +1.Satwik Sinha +A20547790 +ssinha20@hawk.iit.edu + +2.Aditya Ramchandra Kutre +CWID : #A20544809 +akutre@hawk.iit.edu + +3.Tejaswi Yerra +CWID : #A20545536 +tyerra@hawk.iit.edu + +# ElasticNet Linear Regression Implementation + +## Overview + +This project implements **Linear Regression with ElasticNet Regularization** from first principles. ElasticNet combines both L1 (Lasso) and L2 (Ridge) regularization to enhance model performance, especially in scenarios with high-dimensional data or multicollinearity among features. + +## **What does the model you have implemented do and when should it be used?** + +The implemented **ElasticNet** model performs linear regression while applying a combination of L1 and L2 penalties to the loss function. This approach offers several advantages: + +- **Feature Selection:** L1 regularization encourages sparsity, effectively selecting relevant features. +- **Handling Multicollinearity:** L2 regularization mitigates issues arising from highly correlated predictors. +- **Improving Generalization:** The combined regularization prevents overfitting, enhancing the model’s ability to generalize to unseen data. + +**When to use ElasticNet:** + +- When dealing with datasets that have a large number of predictors. +- When there is multicollinearity among features. +- When feature selection is desired alongside regression. +- When seeking a balance between L1 and L2 regularization benefits. + +## **How did you test your model to determine if it is working reasonably correctly?** + +Testing was conducted through the following approaches: + +- **Synthetic Data Generation:** Utilized the provided `generate_regression_data.py` script to create synthetic datasets with known coefficients and noise levels, validating the model's ability to recover the underlying parameters[3]. +- **Performance Metrics:** Evaluated using Mean Squared Error (MSE) and R-squared metrics to quantify prediction accuracy. +- **Edge Case Analysis:** Tested the model with various data conditions, including: + - High-dimensional data. + - Data with multicollinearity. + - Datasets with varying noise levels. +- **Comparison with Baselines:** Compared the results against standard linear regression without regularization to demonstrate the benefits of ElasticNet. + +## **What parameters have you exposed to users of your implementation in order to tune performance?** + +The ElasticNet implementation exposes the following tunable parameters: + +- **`alpha`**: Controls the overall strength of the regularization. Higher values impose more regularization. +- **`l1_ratio`**: Balances the contribution between L1 and L2 regularization. A value of 0 corresponds to only L2 regularization, while a value of 1 corresponds to only L1. +- **`fit_intercept`**: Boolean indicating whether to calculate the intercept for the model. +- **`max_iter`**: The maximum number of iterations for the optimization algorithm. +- **`tolerance`**: The tolerance for the optimization algorithm's convergence. +- **`learning_rate`**: Step size for gradient descent updates. +- **`random_state`**: Seed used by the random number generator for reproducibility. + +These parameters allow users to fine-tune the model to achieve optimal performance based on their specific dataset characteristics. + +## **Are there specific inputs that your implementation has trouble with? Given more time, could you work around these or is it fundamental to the model?** + +**Challenging Inputs:** + +- **Highly Imbalanced Features:** Datasets where certain features dominate others in scale can affect the regularization effectiveness. Proper feature scaling is essential. +- **Non-linear Relationships:** The current implementation assumes linear relationships between predictors and the target variable. It may underperform on datasets with complex non-linear patterns. +- **Sparse Data with High Dimensionality:** While ElasticNet is suitable for high-dimensional data, extremely sparse datasets might require additional preprocessing or dimensionality reduction techniques. + +**Potential Workarounds:** + +- **Feature Scaling:** Implementing automatic feature scaling can mitigate issues with imbalanced feature scales. +- **Polynomial Features:** Extending the model to include polynomial or interaction terms can help capture non-linear relationships. +- **Dimensionality Reduction:** Techniques like PCA can be integrated to handle extremely high-dimensional sparse data more effectively. + +With additional time, these enhancements can be incorporated to improve the model's robustness and applicability to a wider range of datasets. + +## **Usage Examples** + +Below are examples demonstrating how to use the implemented ElasticNet model: + +### **Training the Model** + +```python +from ElasticNet import ElasticNetModel +import numpy as np + +# Generate synthetic data +from generate_regression_data import linear_data_generator + +# Parameters for synthetic data +m = np.array([1.5, -2.0, 3.0]) +b = 4.0 +rnge = [0, 10] +N = 100 +scale = 1.0 +seed = 42 + +# Generate data +X, y = linear_data_generator(m, b, rnge, N, scale, seed) + +# Initialize the model with desired parameters +model = ElasticNetModel(alpha=1.0, l1_ratio=0.5, fit_intercept=True, max_iter=1000, tolerance=1e-4, learning_rate=0.01, random_state=42) -* What does the model you have implemented do and when should it be used? -* How did you test your model to determine if it is working reasonably correctly? -* What parameters have you exposed to users of your implementation in order to tune performance? (Also perhaps provide some basic usage examples.) -* Are there specific inputs that your implementation has trouble with? Given more time, could you work around these or is it fundamental? +# Fit the model to the training data +model.fit(X, y) diff --git a/extracredit analysis.ipynb b/extracredit analysis.ipynb new file mode 100644 index 0000000..f5be02b --- /dev/null +++ b/extracredit analysis.ipynb @@ -0,0 +1,285 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Test Summary\n", + "- All 5 test cases have passed successfully." + ], + "id": "d2345b34c61d70d5" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## Test Details", + "id": "75de7ca6aee835c8" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### ' test_elasticnet_fit_predict_small_test' ", + "id": "37dfd6e0aa751887" + }, + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2024-10-11T03:40:23.505652Z", + "start_time": "2024-10-11T03:40:22.817560Z" + } + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Loss values for test_elasticnet_fit_predict_small_test\n", + "iterations_small = [1, 79]\n", + "loss_small = [0.8138483865698529, 0.18289415072034765]\n", + "\n", + "plt.figure(figsize=(8, 5))\n", + "plt.plot(iterations_small, loss_small, marker='o', linestyle='-')\n", + "plt.title('Loss Over Iterations: test_elasticnet_fit_predict_small_test')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Loss')\n", + "plt.grid(True)\n", + "plt.show()" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAHWCAYAAABkNgFvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB6XUlEQVR4nO3deVhU5fsG8HtmYIYdRFYRQXFBXEBRERGwBM19yVxzwdLcSsWybFG0zKxE00zL3LLMpdwyUxAFRXDf9xVRQXBjEWSReX9/+GO+IjgsAofl/lwXV82Zd84885wzx5vDWWRCCAEiIiIiokpILnUBREREREQlxTBLRERERJUWwywRERERVVoMs0RERERUaTHMEhEREVGlxTBLRERERJUWwywRERERVVoMs0RERERUaTHMEhEREVGlxTBLRPnExMRAJpNh1apVUpdSLQUFBUEmk1Wb9y1tCQkJ6NevH2rWrAmZTIYFCxYgPDwcMpkM4eHhUpdXakaMGAFHR8c802QyGYKCgiSpR2oFLeOCekRVD8MsAQBWrVoFmUyGo0ePSl1KkRw4cAB9+vSBtbU1VCoVHB0d8d577yE2Nlbq0vLJ3cD+9ddfmmlRUVEICgpCUlKSdIUBWLt2LRYsWCBpDaUlLi4OQUFBOHnyZJm+T2XvWXp6OoKCgip0qHvVGidPnoxdu3Zh2rRpWLNmDd54440Cx1X2ZVlazp8/j6CgIMTExEhdSoVQHutFeW2vqguGWap0Fi1aBG9vb5w5cwbvv/8+fvrpJ/Tr1w/r169H8+bNERUVJXWJhYqKisLMmTMrbJh1cHDAkydPMHTo0PIvqoTi4uIwc+ZMhtlCpKenY+bMmQUGxc8//xxPnjwp/6JeoK3GotizZw969eqFDz/8EG+//TacnZ3h4+ODJ0+ewMfHRzOusi/Lgjx58gSff/55sV5z/vx5zJw5k2H2/5VXmC2P7VV1oSN1AUTFceDAAUyaNAnt27fHzp07YWBgoHlu7Nix8PLyQr9+/XDu3DnUqFGj3OpKS0uDoaFhub3fy6Snp+fpSUnJZDLo6emVQkVUmejo6EBHp/L/s5CYmAgzM7M80+RyeYVZp8tye1FRPiNRuRJEQoiVK1cKAOLIkSNaxx0/fly88cYbwtjYWBgaGorXX39dREdH5xmTlZUlgoKCRP369YVKpRLm5ubCy8tLhISEaMbEx8eLESNGCDs7O6FUKoWNjY3o2bOnuHHjhtb379y5s1AoFOL69esFPr969WoBQMyZM0cIIcR3330nAIiYmJh8Yz/55BOhq6srHj58qJl28OBB0blzZ2FiYiL09fWFj4+PiIyMzPO6GTNmCADi3LlzYtCgQcLMzEy4ubm9tOa9e/cKAGLjxo15Xv/iz/Offc2aNaJly5ZCT09P1KhRQwwYMEDExsbmma+vr69o0qSJOHr0qPD29hb6+vpi4sSJQgghtmzZIrp27SpsbW2FUqkU9erVE7NmzRJPnz7N8/oXa3BwcBBCCHHjxg0BQKxcuTLPe4aFhYn27dsLAwMDYWpqKnr27CnOnz9fYH+uXLkihg8fLkxNTYWJiYkYMWKESEtLyzM2JCREeHl5CVNTU2FoaCgaNmwopk2blmfMzZs3xYULF17a3+d7/OLP8/UXZdmmpKSIiRMnCgcHB6FUKoWlpaXw8/MTx44dK7RnRbVjxw5ND42MjETXrl3F2bNnC+zh81asWCFee+01YWlpKZRKpWjcuLH46aef8s3/yJEjolOnTqJmzZpCT09PODo6ioCAACHE/5briz8zZsx46fsK8Wx9bN26tdDX1xdmZmbC29tb7Nq1S/O8g4OD6Natm9i/f79o3bq1UKlUom7dumL16tX55vXo0SMxceJEUbt2baFUKoWTk5P45ptvRE5OTpFq1CZ3O/bijxD/W0f27t0rhHj1ZZn7mXft2iVcXV2FSqUSjRs3Fn///XeBNYWHh4uxY8cKS0tLYWZmpnm+KOuDEEJs3rxZNGnSRKhUKtGkSROxadMmMXz48Hw1F9Sr27dvi5EjR2q2B46OjmLMmDEiMzPzpT3L7VNhCvvOCPG/bdWpU6eEj4+P0NfXF05OTpptYnh4uGjTpo3Q09MTDRs2FKGhoXneIyYmRowdO1Y0bNhQ6OnpCXNzc9GvX798/168uIyFEAX2SJvC1ouMjAwxffp04eTkJJRKpahdu7b46KOPREZGRp75aNu2FWV7RcVT+X8Fp3Jz7tw5eHt7w8TEBFOnToWuri5+/vlndOjQAREREfDw8ADw7CSSOXPm4N1330WbNm2QkpKCo0eP4vjx4/D39wcAvPnmmzh37hzef/99ODo6IjExEaGhoYiNjX3pwfrp6ekICwuDt7c36tatW+CYAQMGYPTo0di+fTs++eQT9O/fH1OnTsWGDRvw0Ucf5Rm7YcMGdOrUSbMHd8+ePejSpQvc3d0xY8YMyOVyrFy5Eq+//jr279+PNm3a5Hn9W2+9hQYNGuDrr7+GEKLIfezbty8uX76MP//8E/Pnz4eFhQUAwNLSEgAwe/ZsfPHFF+jfvz/effdd3Lt3D4sWLYKPjw9OnDiRZ4/TgwcP0KVLFwwcOBBvv/02rK2tATw7BtrIyAiBgYEwMjLCnj17MH36dKSkpOC7774DAHz22WdITk7G7du3MX/+fACAkZHRS+vevXs3unTpgnr16iEoKAhPnjzBokWL4OXlhePHj+dbbv3790fdunUxZ84cHD9+HL/++iusrKwwd+5cAM/Wp+7du6N58+aYNWsWVCoVrl69igMHDuSZz7BhwxAREaG1x40bN8asWbMwffp0jB49Gt7e3gCAdu3aASj6sh0zZgz++usvTJgwAS4uLnjw4AEiIyNx4cIFtGzZstg9e9GaNWswfPhwdO7cGXPnzkV6ejqWLFmC9u3b48SJE1pPVFmyZAmaNGmCnj17QkdHB//88w/GjRsHtVqN8ePHA3i2R7JTp06wtLTEJ598AjMzM8TExGDTpk0Anq1jS5YswdixY9GnTx/07dsXANC8efOXvu/MmTMRFBSEdu3aYdasWVAqlTh06BD27NmDTp06acZdvXoV/fr1wzvvvIPhw4djxYoVGDFiBNzd3dGkSRMAz77Dvr6+uHPnDt577z3UqVMHUVFRmDZtGuLj47FgwYIS1ZjLx8cHa9aswdChQ+Hv749hw4a9dOyrLksAuHLlCgYMGIAxY8Zg+PDhWLlyJd566y3s3LlTs63LNW7cOFhaWmL69OlIS0sDUPT1ISQkBG+++SZcXFwwZ84cPHjwAAEBAahdu3ahNcbFxaFNmzZISkrC6NGj4ezsjDt37uCvv/5Ceno6fHx88MEHH2DhwoX49NNP0bhxYwDQ/LcwhX1ncj169Ajdu3fHwIED8dZbb2HJkiUYOHAg/vjjD0yaNAljxozB4MGD8d1336Ffv364desWjI2NAQBHjhxBVFQUBg4ciNq1ayMmJgZLlixBhw4dcP78+VL5a1QubeuFWq1Gz549ERkZidGjR6Nx48Y4c+YM5s+fj8uXL2PLli0ACt+2Fba9ohKQOk1TxVCUPbO9e/cWSqVSXLt2TTMtLi5OGBsbCx8fH800V1dX0a1bt5fO59GjRwKA+O6774pV48mTJwUAzd7Hl2nevLkwNzfXPPb09BTu7u55xhw+fFgAEL/99psQQgi1Wi0aNGggOnfuLNRqtWZcenq6qFu3rvD399dMy917NWjQoCLV/eKeWSH+t8f4xT0LMTExQqFQiNmzZ+eZfubMGaGjo5Nneu4ehKVLl+Z7z/T09HzT3nvvPWFgYJBnD0K3bt0K3GtR0J5ZNzc3YWVlJR48eKCZdurUKSGXy8WwYcM003L7M3LkyDzz7NOnj6hZs6bm8fz58wUAce/evXzv/7zcz1mYI0eOFLh3ozjL1tTUVIwfP17r+7ysZ4VJTU0VZmZmYtSoUXmm3717V5iamuaZXtAe0oKWaefOnUW9evU0jzdv3lzo9/jevXsv3dP54vteuXJFyOVy0adPH82e01zP99LBwUEAEPv27dNMS0xMFCqVSkyZMkUz7csvvxSGhobi8uXLeeb1ySefCIVCofnrg7YaiwJAvuVY0F67ki5LIf73mZ/fE5ucnCxsbW1FixYtNNNyt63t27fP85eR4qwPbm5uwtbWViQlJWmmhYSEFLg3+cW+DRs2TMjl8gLXidxluHHjxmLtjX1eUb4zud/htWvXaqZdvHhRABByuVwcPHhQM33Xrl35vscFrfvR0dF5tuFClM6eWSFevl6sWbNGyOVysX///jzTly5dKgCIAwcOCCGKtm172faKSoYngFGR5OTkICQkBL1790a9evU0021tbTF48GBERkYiJSUFAGBmZoZz587hypUrBc5LX18fSqUS4eHhePToUZFrSE1NBQDNb+svY2xsrKkFeLa39tixY7h27Zpm2vr166FSqdCrVy8AwMmTJ3HlyhUMHjwYDx48wP3793H//n2kpaWhY8eO2LdvH9RqdZ73GTNmTJFrL6pNmzZBrVajf//+mhru378PGxsbNGjQAHv37s0zXqVSISAgIN989PX1Nf+fmpqK+/fvw9vbG+np6bh48WKx64qPj8fJkycxYsQImJuba6Y3b94c/v7+2LFjR77XvNgfb29vPHjwIM96AgBbt27N19vnhYeHF2vP94uKs2zNzMxw6NAhxMXFlfj9XiY0NBRJSUkYNGhQnmWrUCjg4eGRb9m+6PllmpycjPv378PX1xfXr19HcnKypn4A2L59O7Kzs1+55i1btkCtVmP69OmQy/P+c/HiJbxcXFw0e5iAZ3uBGzVqhOvXr2umbdy4Ed7e3qhRo0aeHvj5+SEnJwf79u175ZrLU61atdCnTx/NYxMTEwwbNgwnTpzA3bt384wdNWoUFAqF5nFR14fc797w4cNhamqqeb2/vz9cXFy01qdWq7Flyxb06NEDrVq1yvd8aVyGrajfGSMjIwwcOFDzuFGjRjAzM0Pjxo01f9UDoPn/59eb59f97OxsPHjwAPXr14eZmRmOHz/+yp+hqDZu3IjGjRvD2dk5zzJ7/fXXAUCzzIq6baPSwzBLRXLv3j2kp6ejUaNG+Z5r3Lgx1Go1bt26BQCYNWsWkpKS0LBhQzRr1gwfffQRTp8+rRmvUqkwd+5c/Pfff7C2toaPjw++/fbbfBv/F+WG2NxQ+zKpqal5Au9bb70FuVyO9evXAwCEENi4cSO6dOkCExMTANAE7+HDh8PS0jLPz6+//orMzExNYMj1skMdXsWVK1cghECDBg3y1XHhwgUkJibmGW9nZwelUplvPufOnUOfPn1gamoKExMTWFpa4u233waAfJ+jKG7evAkAL13+ueHweXXq1MnzOPdwjtxfYAYMGAAvLy+8++67sLa2xsCBA7Fhw4ZS3/gXZ9l+++23OHv2LOzt7dGmTRsEBQXl+Ue1NOp4/fXX89UREhKSb9m+6MCBA/Dz84OhoSHMzMxgaWmJTz/9FMD/lqmvry/efPNNzJw5ExYWFujVqxdWrlyJzMzMEtV87do1yOXyQkMTkH95A8+W+fO/sF65cgU7d+7M9/n9/PwAoNAeVDT169fPFwgbNmwIAPmuDPDi9qKo60Pud69Bgwb53r+g7+Pz7t27h5SUFDRt2rToH6qYivqdqV27dr5emZqawt7ePt80AHnWmydPnmD69Omwt7eHSqWChYUFLC0tkZSUVKLtWUlduXIF586dy7e8cpd57jIrr20b/Q+PmaVS5+Pjg2vXrmHr1q0ICQnBr7/+ivnz52Pp0qV49913AQCTJk1Cjx49sGXLFuzatQtffPEF5syZgz179qBFixYFzrd+/frQ0dHJE4xflJmZiUuXLuXZC1GrVi14e3tjw4YN+PTTT3Hw4EHExsZqjt0EoNnIfPfdd3Bzcytw3i8eT/f83oLSolarIZPJ8N9//+XZi1OcGpKSkuDr6wsTExPMmjULTk5O0NPTw/Hjx/Hxxx+X2wa1oPoBaPay6uvrY9++fdi7dy/+/fdf7Ny5E+vXr8frr7+OkJCQl76+uIqzbPv37w9vb29s3rwZISEh+O677zB37lxs2rQJXbp0KZU61qxZAxsbm3zPa7uKwLVr19CxY0c4OzsjODgY9vb2UCqV2LFjB+bPn6+Zd+71jA8ePIh//vkHu3btwsiRIzFv3jwcPHiw2MeEFkdhyxt41gN/f39MnTq1wLG5oaAqevG7+irrQ0VS1O/My9aPoqw377//PlauXIlJkybB09MTpqamkMlkGDhwYLkGRLVajWbNmiE4OLjA53ODeXlt2+h/Kse3hSRnaWkJAwMDXLp0Kd9zFy9ehFwuz/Mbtrm5OQICAhAQEIDHjx/Dx8cHQUFBmjALAE5OTpgyZQqmTJmCK1euwM3NDfPmzcPvv/9eYA2GhoZ47bXXsGfPHty8eRMODg75xmzYsAGZmZno3r17nukDBgzAuHHjcOnSJaxfvx4GBgbo0aNHnlqAZ38mzN1LVJZe9uc9JycnCCFQt27dEv/DHh4ejgcPHmDTpk15rql548aNItfxotxev2z5W1hYlOhSQ3K5HB07dkTHjh0RHByMr7/+Gp999hn27t1b7OWgradA0Zetra0txo0bh3HjxiExMREtW7bE7NmzNf8wl/RPs7l1WFlZFfuz/fPPP8jMzMS2bdvy7AF92aEJbdu2Rdu2bTF79mysXbsWQ4YMwbp16/Duu+8Wq34nJyeo1WqcP3/+pb8IFIeTkxMeP35c6Ocvr7uQver7XL16FUKIPPO5fPkyABR616mirg+5372CDtsq6Pv4PEtLS5iYmODs2bNax71qHwr7zryqv/76C8OHD8e8efM00zIyMsrsOt3atiWnTp1Cx44dC+1ZYdu2qnCnvYqEhxlQkSgUCnTq1Albt27N8+ezhIQErF27Fu3bt9f8yf7Bgwd5XmtkZIT69etr/tSZnp6OjIyMPGOcnJxgbGxc6J9DP//8cwghMGLEiHwXd79x4wamTp0KW1tbvPfee3mee/PNN6FQKPDnn39i48aN6N69e57w5e7uDicnJ3z//fd4/Phxvve9d++e1rqKK/e9X9wY9+3bFwqFAjNnzsx3nKgQIl9vC5L7W//zr8/KysJPP/1UYB1F+TOdra0t3NzcsHr16jw1nz17FiEhIejatWuh83jRw4cP803LDUzPrwexsbFFOs73ZT0t6rLNycnJ1wsrKyvUqlUrTz1F7dmLOnfuDBMTE3z99dcFHs+qbR0raJkmJydj5cqVecY9evQo33rzYk9zz/wuShDo3bs35HI5Zs2alW8PWEmOY+7fvz+io6Oxa9eufM8lJSXh6dOnxa7xVZR0WeaKi4vD5s2bNY9TUlLw22+/wc3NrcC9rc8r6vrw/Hfv+VpDQ0Nx/vx5re8hl8vRu3dv/PPPPwXe3TF3Gb7su1OYon5nXpVCoci3vi1atAg5OTml9h7Pe9l60b9/f9y5cwfLli3L99yTJ080h1oVZdtW0p5TwbhnlvJYsWIFdu7cmW/6xIkT8dVXXyE0NBTt27fHuHHjoKOjg59//hmZmZn49ttvNWNdXFzQoUMHuLu7w9zcHEePHtVcugV4tueiY8eO6N+/P1xcXKCjo4PNmzcjISEhzwkCBfHx8cH333+PwMBANG/eHCNGjICtrS0uXryIZcuWQa1WY8eOHflumGBlZYXXXnsNwcHBSE1NxYABA/I8L5fL8euvv6JLly5o0qQJAgICYGdnhzt37mDv3r0wMTHBP//8U9K25uPu7g7g2WVgBg4cCF1dXfTo0QNOTk746quvMG3aNMTExKB3794wNjbGjRs3sHnzZowePRoffvih1nm3a9cONWrUwPDhw/HBBx9AJpNhzZo1BYYPd3d3rF+/HoGBgWjdujWMjIzy7LF+3nfffYcuXbrA09MT77zzjubSXKampiW6F/ysWbOwb98+dOvWDQ4ODkhMTMRPP/2E2rVro3379ppxRbk0F/DsFyIzMzMsXboUxsbGMDQ0hIeHB+rWrVukZZuamoratWujX79+cHV1hZGREXbv3o0jR47k2SNUnJ49z8TEBEuWLMHQoUPRsmVLDBw4EJaWloiNjcW///4LLy8v/PjjjwW+tlOnTlAqlejRowfee+89PH78GMuWLYOVlRXi4+M141avXo2ffvoJffr0gZOTE1JTU7Fs2TKYmJhofuHQ19eHi4sL1q9fj4YNG8Lc3BxNmzYt8LjK+vXr47PPPsOXX34Jb29v9O3bFyqVCkeOHEGtWrUwZ86cQj/38z766CNs27YN3bt311y2Ky0tDWfOnMFff/2FmJgYWFhYFKvGV1HSZZmrYcOGeOedd3DkyBFYW1tjxYoVSEhIyPdLRkGKsz7MmTMH3bp1Q/v27TFy5Eg8fPgQixYtQpMmTQr8Be15X3/9NUJCQuDr66u5nFR8fDw2btyIyMhImJmZwc3NDQqFAnPnzkVycjJUKhVef/11WFlZaZ13Ub8zr6p79+5Ys2YNTE1N4eLigujoaOzevRs1a9Ystfd43svWi6FDh2LDhg0YM2YM9u7dCy8vL+Tk5ODixYvYsGEDdu3ahVatWhVp26Zte0UlUM5XT6AK6mUXzs79uXXrlhDi2U0TOnfuLIyMjISBgYF47bXXRFRUVJ55ffXVV6JNmzbCzMxM6OvrC2dnZzF79myRlZUlhBDi/v37Yvz48cLZ2VkYGhoKU1NT4eHhITZs2FDkevft2yd69eolLCwshK6urqhTp44YNWpUgTdHyLVs2TIBQBgbG4snT54UOObEiROib9++ombNmkKlUgkHBwfRv39/ERYWphmTe/miwi4plaugS3MJ8ewyRXZ2dkIul+e7TNfff/8t2rdvLwwNDYWhoaFwdnYW48ePF5cuXdKMyb0QeUEOHDgg2rZtK/T19UWtWrXE1KlTNZe8ef6yNY8fPxaDBw8WZmZmeS7z87KbJuzevVt4eXkJfX19YWJiInr06PHSmya82J/cdSz3c4aFhYlevXqJWrVqCaVSKWrVqiUGDRqU77JNRb00lxBCbN26Vbi4uAgdHZ189Re2bDMzM8VHH30kXF1dNTcFcXV1zXdjgpf1rKj27t0rOnfuLExNTYWenp5wcnISI0aMEEePHtWMKejSXNu2bRPNmzfX3Ahh7ty5YsWKFXl6evz4cTFo0CBRp04doVKphJWVlejevXueeQshRFRUlHB3dxdKpbJIN01YsWKFaNGihVCpVKJGjRrC19c3z4Xtc28g8CJfX1/h6+ubZ1pqaqqYNm2aqF+/vlAqlcLCwkK0a9dOfP/995pthLYaiwJFvDTXqyzL52+a0Lx5c6FSqYSzs3O+73lhlz0syvogxLNtQuPGjYVKpRIuLi7FumnCzZs3xbBhw4SlpaVQqVSiXr16Yvz48SIzM1MzZtmyZaJevXpCoVAU+TJdRf3OvGxb9bL15sXl9+jRIxEQECAsLCyEkZGR6Ny5s7h48aJwcHAQw4cP14wrrUtzaVsvsrKyxNy5czU3sKhRo4Zwd3cXM2fOFMnJyUKIom/btG2vqHhkQrzCNW+IiIiqIUdHRzRt2hTbt2+XuhSiao/HzBIRERFRpcVjZomIXtG9e/e0noyiVCrz3GyCii8rK6vAE2ueZ2pq+sqXzOOyfObx48eFHo9raWlZqS4z9fDhQ2RlZb30eYVCobmtOFUuDLNERK+odevWmovbF8TX1xfh4eHlV1AVFBUVhddee03rmJUrV2LEiBGv9D5cls98//33mDlzptYxN27cKPQSZBVJ3759ERER8dLnHRwc8t3sgioHHjNLRPSKDhw4kO9Scc+rUaOG5goWVDKPHj3CsWPHtI5p0qQJbG1tX+l9uCyfuX79eqF3v2vfvj309PTKqaJXd+zYMa23UNfX14eXl1c5VkSlhWGWiIiIiCotngBGRERERJVWtTtmVq1WIy4uDsbGxrydHBEREVEFJIRAamoqatWqBblc+77Xahdm4+LiYG9vL3UZRERERFSIW7duoXbt2lrHVLswa2xsDOBZc0xMTEplntnZ2QgJCUGnTp2gq6tbKvOsStifwrFH2rE/2rE/hWOPtGN/tGN/tCuL/qSkpMDe3l6T27SpdmE299ACExOTUg2zBgYGMDEx4UpeAPancOyRduyPduxP4dgj7dgf7dgf7cqyP0U5JJQngBERERFRpcUwS0RERESVFsMsEREREVVaDLNEREREVGkxzBIRERFRpcUwS0RERESVFsMsEREREVVaDLNEREREVGkxzBIRERFRpVXt7gBWnnLUAodvPERiagasjPXQpq45FPLC72RBREREREXDMFtGdp6Nx8x/ziM+OUMzzdZUDzN6uOCNprYSVkZERERUdfAwgzKw82w8xv5+PE+QBYC7yRkY+/tx7DwbL1FlRERERFULw2wpy1ELzPznPEQBz+VOm/nPeeSoCxpBRERERMXBMFvKDt94mG+P7PMEgPjkDBy+8bD8iiIiIiKqohhmS1li6suDbEnGEREREdHLMcyWMitjvSKNq2GgW8aVEBEREVV9DLOlrE1dc9ia6qGwC3DN2HoOUVfvl0tNRERERFUVw2wpU8hlmNHDBQDyBdrcxyZ6OrjxIB2Dfz2EyetP4v7jzHKtkYiIiKiqkDzMLl68GI6OjtDT04OHhwcOHz6sdfyCBQvQqFEj6Ovrw97eHpMnT0ZGRsU6/vSNprZY8nZL2JjmPeTAxlQPS99uif0fv46hbR0gkwGbT9xBx3kRWHc4Fmpe4YCIiIioWCS9acL69esRGBiIpUuXwsPDAwsWLEDnzp1x6dIlWFlZ5Ru/du1afPLJJ1ixYgXatWuHy5cvY8SIEZDJZAgODpbgE7zcG01t4e9i89I7gH3ZuynedK+NTzedwfn4FHyy6Qz+OnYbX/dthobWxhJXT0RERFQ5SLpnNjg4GKNGjUJAQABcXFywdOlSGBgYYMWKFQWOj4qKgpeXFwYPHgxHR0d06tQJgwYNKnRvrlQUchk8nWqil5sdPJ1q5ruVrZu9GbZN8MLn3RrDQKnA0ZuP0PWH/Zi78yKeZOVIVDURERFR5SHZntmsrCwcO3YM06ZN00yTy+Xw8/NDdHR0ga9p164dfv/9dxw+fBht2rTB9evXsWPHDgwdOvSl75OZmYnMzP8dk5qSkgIAyM7ORnZ2dql8ltz5lHR+w9vaw9/ZAl/+exG7L97DkvBr+OfkHczo0RgdGlqWSo1SetX+VAfskXbsj3bsT+HYI+3YH+3YH+3Koj/FmZdMCCHJgZpxcXGws7NDVFQUPD09NdOnTp2KiIgIHDp0qMDXLVy4EB9++CGEEHj69CnGjBmDJUuWvPR9goKCMHPmzHzT165dCwMDg1f/IKXszEMZ/rohR1LWs724buZq9K2rhqlS4sKIiIiIykl6ejoGDx6M5ORkmJiYaB0r6TGzxRUeHo6vv/4aP/30Ezw8PHD16lVMnDgRX375Jb744osCXzNt2jQEBgZqHqekpMDe3h6dOnUqtDlFlZ2djdDQUPj7+0NX99WuH9sVwITMp1i09xpWRcfi5EM5rqTpYopfAwxuY5/vUIXKoDT7U1WxR9qxP9qxP4Vjj7Rjf7Rjf7Qri/7k/iW9KCQLsxYWFlAoFEhISMgzPSEhATY2NgW+5osvvsDQoUPx7rvvAgCaNWuGtLQ0jB49Gp999hnk8vyHAKtUKqhUqnzTdXV1S32FLK15munq4oseTdHX3R6fbj6LU7eSMOvfi9hyKh5f92mGpnampVBt+SuLnlc17JF27I927E/h2CPt2B/t2B/tSrM/xZmPZCeAKZVKuLu7IywsTDNNrVYjLCwsz2EHz0tPT88XWBUKBQBAoqMlylSTWqbYNLYdvuzVBMYqHZy+nYyeP0Zi5j/n8DjzqdTlEREREUlO0qsZBAYGYtmyZVi9ejUuXLiAsWPHIi0tDQEBAQCAYcOG5TlBrEePHliyZAnWrVuHGzduIDQ0FF988QV69OihCbVVjUIuw1BPR4RN8UUP11pQC2DlgRj4zYvAzrPxVTLEExERERWVpMfMDhgwAPfu3cP06dNx9+5duLm5YefOnbC2tgYAxMbG5tkT+/nnn0Mmk+Hzzz/HnTt3YGlpiR49emD27NlSfYRyY2Wih0WDWqCfe218seUsYh+mY8zvx9HR2QozezVB7RoV72Q2IiIiorIm+QlgEyZMwIQJEwp8Ljw8PM9jHR0dzJgxAzNmzCiHyiom34aWCJnsgx/3XMXP+64h7GIioq49wCS/BhjZvi50FZLf1I2IiIio3DD5VEJ6ugp82LkRdnzgjTaO5niSnYM5/11Ej0WROHbzkdTlEREREZUbhtlKrIG1Mda/1xbf9muOGga6uHg3Ff2WRuHTzWeQnM4LOxMREVHVxzBbyclkMvRvZY+wKR3Qz702hADWHopFx+BwbD15hyeIERERUZXGMFtFmBsq8f1brlg3ui2cLA1x/3EWJq47iWErDiPmfprU5RERERGVCYbZKqZtvZrYMdEbU/wbQqkjx/4r99FpwT4sDLuCzKc5UpdHREREVKoYZqsglY4C73dsgJBJPvBuYIGsp2oEh15Glx/2I/raA6nLIyIiIio1DLNVmKOFIX4b2QY/DHSDhZEK1++lYdCyg5iy4RQepmVJXR4RERHRK2OYreJkMhl6udkhbIovhnjUgUwG/H38Nl6fF44NR25BreYJYkRERFR5McxWE6b6upjdpxn+HtsOzjbGSErPxtS/T2PgLwdxJSFV6vKIiIiISoRhtpppWacG/nm/PT7t6gx9XQUOxzxE14X78d2ui8jI5gliREREVLkwzFZDugo5Rvs4ITTQB36NrZCdI7B47zV0mr8P4ZcSpS6PiIiIqMgYZqux2jUMsGxYKyx92x02JnqIfZiOESuPYPza40hMyZC6PCIiIqJCMcxWczKZDG80tcHuKb54p31dyGXAv6fj0XFeBH6LjkEOTxAjIiKiCoxhlgAARiodfNHdBdsmtIdrbVOkZj7F9K3n0HdJFM7FJUtdHhEREVGBGGYpj6Z2ptg0zguzejWBkUoHp24loceiSHy5/TzSMp9KXR4RERFRHgyzlI9CLsMwT0eETfFFt2a2UAtgeeQN+AVHYNe5u1KXR0RERKTBMEsvZW2ih8VDWmJlQGvYm+sjPjkD7605hndXH8WdpCdSl0dERETEMEuFe62RFUIm+WJcByfoyGXYfSEB/sERWLbvOp7mqKUuj4iIiKoxhlkqEn2lAlPfcMaOid5o7VgD6Vk5mL3jAnr8eAAnYh9JXR4RERFVUwyzVCwNrY2xfrQn5r7ZDKb6urgQn4K+S6Lw+ZYzSH6SLXV5REREVM0wzFKxyeUyDGhdB3um+KJvSzsIAfx+MBZ+wRHYdioOQvDatERERFQ+GGapxGoaqRDc3w1rR3mgnoUh7qVm4oM/T2DYisO4+SBN6vKIiIioGmCYpVfWzskC/03yxmS/hlDqyLH/yn10mr8PP+65gqynPEGMiIiIyg7DLJUKlY4CE/0aYNckH3jVr4nMp2p8H3IZXRfux+GYh1KXR0RERFUUwyyVqroWhvj9HQ8sGOAGCyMlriY+xpDlR7H2qhwP07KkLo+IiIiqGIZZKnUymQy9W9ghLLADBrWpAwA4dE+ONxYewMajt3iCGBEREZUahlkqM6YGupjTtxnWj2oDW32BR+nZ+Oiv0xj4y0FcTUyVujwiIiKqAhhmqcy1rGOGj5rn4KNODaCnK8ehGw/R5Yf9mBdyCRnZOVKXR0RERJUYwyyVC4UcGO1dF6GTffG6sxWycwQW7bmKzgv2Yf+Ve1KXR0RERJUUwyyVK3tzAywf3gpLhrSEtYkKNx+kY+jyw/jgzxNITM2QujwiIiKqZBhmqdzJZDJ0aWaL3YG+GNHOEXIZsO1UHDrOi8DvB29CreYJYkRERFQ0DLMkGWM9XQT1bIKt49ujmZ0pUjOe4vMtZ9F3SRTOx6VIXR4RERFVAgyzJLlmtU2xZbwXZvRwgZFKBydvJaHHj5GY/e95pGU+lbo8IiIiqsAYZqlCUMhlCPCqi92BvujazAY5aoFl+2+g0/x9CD2fIHV5REREVEExzFKFYmOqh5+GuGPFiFawM9PHnaQnGPXbUYz+7Sjikp5IXR4RERFVMAyzVCG97myN0EAfjPF1go5chpDzCfAPjsCv+6/jaY5a6vKIiIiogmCYpQrLQKmDT7o4Y/sH7eHuUANpWTn46t8L6LX4AE7dSpK6PCIiIqoAGGapwnO2McHG9zwxp28zmOjp4FxcCnr/dADTt55FSka21OURERGRhBhmqVKQy2UY1KYO9nzYAX1a2EEI4Lfom/CbF4Htp+MgBK9NS0REVB0xzFKlYmGkwvwBbvjjXQ/UtTBEYmomJqw9gRErjyD2QbrU5REREVE5Y5ilSsmrvgX+m+iNiR0bQKmQI+LyPfjPj8DivVeR9ZQniBEREVUXDLNUaenpKjDZvyH+m+QNz3o1kflUje92XUL3RftxJOah1OURERFROWCYpUrPydIIa0d5ILi/K8wNlbic8BhvLY3Gx3+dxqO0LKnLIyIiojLEMEtVgkwmQ9+WtbFnii8GtrYHAKw/egsdgyPw97HbPEGMiIioiqoQYXbx4sVwdHSEnp4ePDw8cPjw4ZeO7dChA2QyWb6fbt26lWPFVFGZGSjxzZvNsXGMJxpaG+FhWhambDyFwcsO4dq9x1KXR0RERKVM8jC7fv16BAYGYsaMGTh+/DhcXV3RuXNnJCYmFjh+06ZNiI+P1/ycPXsWCoUCb731VjlXThVZa0dzbH/fG1PfaAQ9XTmirz9AlwX7ERx6GRnZOVKXR0RERKVE8jAbHByMUaNGISAgAC4uLli6dCkMDAywYsWKAsebm5vDxsZG8xMaGgoDAwOGWcpHqSPHuA71ETrZFx0aWSIrR42FYVfwxoJ9iLxyX+ryiIiIqBToSPnmWVlZOHbsGKZNm6aZJpfL4efnh+jo6CLNY/ny5Rg4cCAMDQ0LfD4zMxOZmZmaxykpKQCA7OxsZGeXzt2jcudTWvOraqTuj42xLn4Z4oad5xLw1Y5LiHmQjreXH0LP5raY1qUhLIxUktT1PKl7VNGxP9qxP4Vjj7Rjf7Rjf7Qri/4UZ14yIeGZMXFxcbCzs0NUVBQ8PT0106dOnYqIiAgcOnRI6+sPHz4MDw8PHDp0CG3atClwTFBQEGbOnJlv+tq1a2FgYPBqH4AqnSdPgX9vyRF5VwYBGfQVAj0d1GhrJSCXSV0dERERAUB6ejoGDx6M5ORkmJiYaB0r6Z7ZV7V8+XI0a9bspUEWAKZNm4bAwEDN45SUFNjb26NTp06FNqeosrOzERoaCn9/f+jq6pbKPKuSitafNwGcvp2ML7adx/n4VKy/rsDlbFN82dMFjWyMJampovWoomF/tGN/Csceacf+aMf+aFcW/cn9S3pRSBpmLSwsoFAokJCQkGd6QkICbGxstL42LS0N69atw6xZs7SOU6lUUKny/xlZV1e31FfIsphnVVKR+uNe1wLbJrTH6uibCA65hBO3ktFryUG8274uJvo1gIFSmq9GRepRRcT+aMf+FI490o790Y790a40+1Oc+Uh6AphSqYS7uzvCwsI009RqNcLCwvIcdlCQjRs3IjMzE2+//XZZl0lVlI5Cjnfa18XuKb54o4kNctQCP++7Dv/gfQi7kFD4DIiIiEhykl/NIDAwEMuWLcPq1atx4cIFjB07FmlpaQgICAAADBs2LM8JYrmWL1+O3r17o2bNmuVdMlUxtqb6WDrUHcuHt4KdmT7uJD3BO6uPYuzvx3A3OUPq8oiIiEgLyY+ZHTBgAO7du4fp06fj7t27cHNzw86dO2FtbQ0AiI2NhVyeN3NfunQJkZGRCAkJkaJkqqI6NraGp1NNLNh9Bcsjb+C/s3ex7/I9TOnUCMPbOULBM8SIiIgqHMnDLABMmDABEyZMKPC58PDwfNMaNWrE25NSmTBQ6uDTro3Rp4UdPt18BidikzBr+3lsOnEbX/dphua1zaQukYiIiJ4j+WEGRBVRY1sT/D2mHWb3aQoTPR2cvZOC3osPIGjbOaRm8DqDREREFQXDLNFLyOUyDPFwQNiUDujlVgtqAayKioFfcAR2nInnXweIiIgqAIZZokJYGqvww8AWWPNOGzjWNEBCSibG/XEcI1cdwa2H6VKXR0REVK0xzBIVkXcDS+yc5IMPXq8PXYUMey/dg//8CCwJv4bsHLXU5REREVVLDLNExaCnq0Bgp0b4b6IPPOqaIyNbjbk7L6L7wkgcu/lQ6vKIiIiqHYZZohKob2WEdaPb4vu3XFHDQBeXElLx5pJoTNt0GknpWVKXR0REVG0wzBKVkEwmQz/32tgzpQP6t6oNAPjz8C10nBeBzSdu8wQxIiKicsAwS/SKahgq8W0/V6wf3Rb1rYzwIC0Lk9efwtvLD+H6vcdSl0dERFSlMcwSlRKPejWx4wNvfNS5EVQ6chy4+gBvLNiPBbsvI/NpjtTlERERVUkMs0SlSKkjx/jX6iNksg98GloiK0eNBbuvoMuC/Yi6el/q8oiIiKochlmiMuBQ0xCrA1pj0aAWsDRW4fr9NAz+9RAmrz+J+48zpS6PiIioymCYJSojMpkMPVxrYXegL4a2dYBMBmw+cQcd50Vg3eFYqNU8QYyIiOhVMcwSlTFTfV182bspNo/zgoutCZKfZOOTTWfQ/+doXE5Ilbo8IiKiSo1hlqicuNmbYdsEL3zerTEMlAocvfkIXX/Yj7k7L+JJFk8QIyIiKgmGWaJypKOQ413veggN9IW/izWeqgWWhF9D10UHcO6RTOryiIiIKh2GWSIJ2JnpY9mwVvhlqDtqmerhdlIGfrmowPvrTiEhJUPq8oiIiCoNhlkiCXVqYoPQQF+84+UAOQR2nktAx3kRWB0VgxyeIEZERFQohlkiiRmqdPDJG40wpXkOmtc2wePMp5ix7Rz6/HQAZ+8kS10eERFRhcYwS1RB1DYENozywJe9msBYpYPTt5PR88dIzPznHB5nPpW6PCIiogqJYZaoAlHIZRjq6YiwKb7o4VoLagGsPBADv3kR2Hk2HkLw0AMiIqLnMcwSVUBWJnpYNKgFVo9sgzrmBribkoExvx/Hu6uP4vajdKnLIyIiqjAYZokqMN+GlgiZ7IMJr9WHrkKGsIuJ8A/eh58jriE7Ry11eURERJJjmCWq4PR0FfiwcyPs+MAbbeqa40l2Dub8dxE9FkXi2M1HUpdHREQkKYZZokqigbUx1o9ui2/7NUcNA11cvJuKfkuj8OnmM0hOz5a6PCIiIkkwzBJVIjKZDP1b2SNsSgf0c68NIYC1h2LRMTgcW0/e4QliRERU7TDMElVC5oZKfP+WK9aNbgsnS0Pcf5yFietOYujyw4i5nyZ1eUREROWGYZaoEmtbryZ2TPTGFP+GUOrIEXn1Pjot2IeFYVeQ+TRH6vKIiIjKHMMsUSWn0lHg/Y4NEDLJB94NLJD1VI3g0Mvo8sN+RF97IHV5REREZYphlqiKcLQwxG8j2+CHgW6wMFLh+r00DFp2EFM2nMKDx5lSl0dERFQmGGaJqhCZTIZebnYIm+KLIR51IJMBfx+/jY7BEVh/JBZqNU8QIyKiqoVhlqgKMtXXxew+zfD32HZwtjFGUno2Pv77DAb+chBXElKlLo+IiKjUMMwSVWEt69TAP++3x6ddnaGvq8DhmIfounA/vtt1ERnZPEGMiIgqP4ZZoipOVyHHaB8nhAb6wK+xFbJzBBbvvYZO8/ch/FKi1OURERG9EoZZomqidg0DLBvWCkvfdoeNiR5iH6ZjxMojGL/2OBJTMqQuj4iIqEQYZomqEZlMhjea2mD3FF+8074u5DLg39Px6DgvAr9FxyCHJ4gREVElwzBLVA0ZqXTwRXcXbJvQHq61TZGa+RTTt55D3yVROBeXLHV5RERERcYwS1SNNbUzxaZxXpjVqwmMVDo4dSsJPRZF4svt55GW+VTq8oiIiArFMEtUzSnkMgzzdETYFF90a2YLtQCWR96AX3AEdp27K3V5REREWjHMEhEAwNpED4uHtMTKgNawN9dHfHIG3ltzDO+uPoo7SU+kLo+IiKhADLNElMdrjawQMskX4zo4QUcuw+4LCfAPjsCyfdfxNEctdXlERER5MMwSUT76SgWmvuGMHRO90dqxBtKzcjB7xwX0+PEATsQ+kro8IiIiDYZZInqphtbGWD/aE3PfbAZTfV1ciE9B3yVR+HzLGSQ/yZa6PCIiIoZZItJOLpdhQOs62DPFF31b2kEI4PeDsfALjsC2U3EQgtemJSIi6TDMElGR1DRSIbi/G9aO8kA9C0PcS83EB3+ewLAVh3HzQZrU5RERUTXFMEtExdLOyQL/TfLGZL+GUOrIsf/KfXSavw8/7rmCrKc8QYyIiMqX5GF28eLFcHR0hJ6eHjw8PHD48GGt45OSkjB+/HjY2tpCpVKhYcOG2LFjRzlVS0QAoNJRYKJfA+ya5AOv+jWR+VSN70Muo+vC/Th0/YHU5RERUTUiaZhdv349AgMDMWPGDBw/fhyurq7o3LkzEhMTCxyflZUFf39/xMTE4K+//sKlS5ewbNky2NnZlXPlRAQAdS0M8fs7HlgwwA0WRkpcTXyMAb8cxEcbT+FhWpbU5RERUTUgaZgNDg7GqFGjEBAQABcXFyxduhQGBgZYsWJFgeNXrFiBhw8fYsuWLfDy8oKjoyN8fX3h6upazpUTUS6ZTIbeLewQFtgBg9rUAQBsPHYbHeeFY+PRWzxBjIiIypSOVG+clZWFY8eOYdq0aZppcrkcfn5+iI6OLvA127Ztg6enJ8aPH4+tW7fC0tISgwcPxscffwyFQlHgazIzM5GZmal5nJKSAgDIzs5GdnbpXFoodz6lNb+qhv0pXFXokYEuMKuHM3q72uCLredxOfExPvrrNDYcvYVZPRqjvpVRieddFfpTltifwrFH2rE/2rE/2pVFf4ozL5mQaLdJXFwc7OzsEBUVBU9PT830qVOnIiIiAocOHcr3GmdnZ8TExGDIkCEYN24crl69inHjxuGDDz7AjBkzCnyfoKAgzJw5M9/0tWvXwsDAoPQ+EBFp5KiB8HgZ/rstR7ZaBoVMoGMtAX87NZQF/95JRESkkZ6ejsGDByM5ORkmJiZax1aqMNuwYUNkZGTgxo0bmj2xwcHB+O677xAfH1/g+xS0Z9be3h73798vtDlFlZ2djdDQUPj7+0NXV7dU5lmVsD+Fq6o9uv3oCWZuv4Dwy/cBAHXM9TGzhwva169ZrPlU1f6UFvancOyRduyPduyPdmXRn5SUFFhYWBQpzEp2mIGFhQUUCgUSEhLyTE9ISICNjU2Br7G1tYWurm6eQwoaN26Mu3fvIisrC0qlMt9rVCoVVCpVvum6urqlvkKWxTyrEvancFWtR3WtdLEyoA12nr2LoH/OIfbhEwSsPoaerrXweffGsDLWK9b8qlp/Shv7Uzj2SDv2Rzv2R7vS7E9x5iPZCWBKpRLu7u4ICwvTTFOr1QgLC8uzp/Z5Xl5euHr1KtTq/13L8vLly7C1tS0wyBKR9GQyGbo0s8XuQF+MaOcIuQzYdioOHedFYM3Bm1CreYIYERGVnKRXMwgMDMSyZcuwevVqXLhwAWPHjkVaWhoCAgIAAMOGDctzgtjYsWPx8OFDTJw4EZcvX8a///6Lr7/+GuPHj5fqIxBRERnr6SKoZxNsHd8ezexMkZrxFF9sOYu+S6JwPi5F6vKIiKiSkuwwAwAYMGAA7t27h+nTp+Pu3btwc3PDzp07YW1tDQCIjY2FXP6/vG1vb49du3Zh8uTJaN68Oezs7DBx4kR8/PHHUn0EIiqmZrVNsWW8F9ZEx+D7kMs4eSsJPX6MxEgvR0zyawhDlaSbJSIiqmQk/1djwoQJmDBhQoHPhYeH55vm6emJgwcPlnFVRFSWFHIZRnjVxRtNbTFr+znsOHMXy/bfwI4zdxHUswn8XaylLpGIiCoJyW9nS0TVl42pHn4a4o4VI1rBzkwfd5KeYNRvRzH6t6OIS3oidXlERFQJMMwSkeRed7ZGaKAPxvg6QUcuQ8j5BPgHR+DX/dfxNEdd+AyIiKjaYpglogrBQKmDT7o4Y/sH7eHuUANpWTn46t8L6LX4AE7fTpa6PCIiqqAYZomoQnG2McHG9zwxp28zmOjp4FxcCvr9cgh/XZcjNYO3kiQiorwYZomowpHLZRjUpg72fNgBfVrYQQhgf4IcbyyMwvbTcZDoxoVERFQBMcwSUYVlYaTC/AFuWD3CHZZ6AompmZiw9gRGrDyC2AfpUpdHREQVAMMsEVV47Zxq4mPXHLz/Wj0oFXJEXL4H//kRWLz3KrKe8gQxIqLqjGGWiCoFXTnwwev18d8kb3jWq4nMp2p8t+sSui/ajyMxD6Uuj4iIJMIwS0SVipOlEdaO8kBwf1eYGypxOeEx3loajY//Oo1HaVlSl0dEROWMYZaIKh2ZTIa+LWtjzxRfDGxtDwBYf/QWOgZH4O9jt3mCGBFRNcIwS0SVlpmBEt+82Rwbx3iiobURHqZlYcrGUxi87BCu3XssdXlERFQOGGaJqNJr7WiO7e97Y+objaCnK0f09QfosmA/gkMuISM7R+ryiIioDDHMElGVoNSRY1yH+gid7IsOjSyRlaPGwj1X8caCfYi8cl/q8oiIqIwwzBJRlWJvboCVI1rjpyEtYWWsQsyDdLy9/BAmrTuBe6mZUpdHRESljGGWiKocmUyGrs1ssXuKL4Z7OkAmA7acjEPHeeFYeygWajVPECMiqioYZomoyjLR08XMXk2xZZwXmtQyQUrGU3y6+Qz6LY3CxbspUpdHRESlgGGWiKo8V3szbB3vhendXWCoVOB4bBK6LYzEnB0XkJ71VOryiIjoFTDMElG1oKOQY2T7utg9xRdvNLFBjlrg533X4R+8D2EXEqQuj4iISohhloiqFVtTfSwd6o7lw1vBzkwfd5Ke4J3VRzFmzTHEJz+RujwiIiomhlkiqpY6NrZGaKAPRvvUg0Iuw85zd+E3LwIrIm8ghyeIERFVGgyzRFRtGSh18GnXxtj+fnu0qGOGtKwczNp+Hr0WR+L07SSpyyMioiJgmCWiaq+xrQn+HtMOs/s0hYmeDs7eSUHvxQcQtO0cUjOypS6PiIi0YJglIgIgl8swxMMBYVM6oJdbLagFsCoqBn7BEdhxJh5C8NADIqKKiGGWiOg5lsYq/DCwBda80waONQ2QkJKJcX8cx8hVR3DrYbrU5RER0QsYZomICuDdwBI7J/ngg9frQ1chw95L9+A/PwJLwq8hO0ctdXlERPT/GGaJiF5CT1eBwE6N8N9EH3jUNUdGthpzd15E94WROHbzodTlERERGGaJiApV38oI60a3xfdvuaKGgS4uJaTizSXRmLbpNJLSs6Quj4ioWmOYJSIqAplMhn7utbFnSgf0b1UbAPDn4VvoOC8Cm0/c5gliREQSYZglIiqGGoZKfNvPFetHt0V9KyM8SMvC5PWn8PbyQ7h+77HU5RERVTsMs0REJeBRryZ2fOCNjzo3gkpHjgNXH+CNBfuxYPdlZD7Nkbo8IqJqg2GWiKiElDpyjH+tPkIm+8CnoSWyctRYsPsKuizYj6ir96Uuj4ioWmCYJSJ6RQ41DbE6oDUWDWoBS2MVrt9Pw+BfD2Hy+pO4/zhT6vKIiKo0hlkiolIgk8nQw7UWwqb4YpinA2QyYPOJO+g4LwLrDsdCreYJYkREZYFhloioFJno6WJWr6bYPM4LLrYmSH6SjU82nUH/n6Nx6W6q1OUREVU5DLNERGXAzd4M2yZ44fNujWGgVODozUfotnA/vvnvIp5k8QQxIqLSwjBLRFRGdBRyvOtdD6GBvujkYo2naoGlEdfgPz8Cey8mSl0eEVGVwDBLRFTG7Mz08cuwVlg2rBVqmerh9qMnCFh1BOP+OIaElAypyyMiqtQYZomIyom/izVCA30xyrsuFHIZdpy5i47zIrDqwA3k8AQxIqISKVGYvXXrFm7fvq15fPjwYUyaNAm//PJLqRVGRFQVGap08Fk3F2yb4AVXezM8znyKoH/Oo89PB3D2TrLU5RERVTolCrODBw/G3r17AQB3796Fv78/Dh8+jM8++wyzZs0q1QKJiKqiJrVMsWlsO3zZuymM9XRw+nYyev4YiZn/nMPjzKdSl0dEVGmUKMyePXsWbdq0AQBs2LABTZs2RVRUFP744w+sWrWqNOsjIqqyFHIZhrZ1QNgUX/RwrQW1AFYeiIHfvAjsPBsPIXjoARFRYUoUZrOzs6FSqQAAu3fvRs+ePQEAzs7OiI+PL73qiIiqAStjPSwa1AKrR7ZBHXMD3E3JwJjfj+Pd1Udx+1G61OUREVVoJQqzTZo0wdKlS7F//36EhobijTfeAADExcWhZs2apVogEVF14dvQEiGTfTDhtfrQVcgQdjER/sH78HPENWTnqKUuj4ioQipRmJ07dy5+/vlndOjQAYMGDYKrqysAYNu2bZrDD4iIqPj0dBX4sHMj7PjAG23qmuNJdg7m/HcRPRZF4tjNR1KXR0RU4ZQozHbo0AH379/H/fv3sWLFCs300aNHY+nSpcWe3+LFi+Ho6Ag9PT14eHjg8OHDLx27atUqyGSyPD96enol+RhERBVWA2tjrB/dFt/2a44aBrq4eDcV/ZZG4dPNZ5Ccni11eUREFUaJwuyTJ0+QmZmJGjVqAABu3ryJBQsW4NKlS7CysirWvNavX4/AwEDMmDEDx48fh6urKzp37ozExJffHcfExATx8fGan5s3b5bkYxARVWgymQz9W9kjbEoH9HOvDSGAtYdi0TE4HFtP3uEJYkREKGGY7dWrF3777TcAQFJSEjw8PDBv3jz07t0bS5YsKda8goODMWrUKAQEBMDFxQVLly6FgYFBnj2+L5LJZLCxsdH8WFtbl+RjEBFVCuaGSnz/livWjW4LJ0tD3H+chYnrTmLo8sOIuZ8mdXlERJLSKcmLjh8/jvnz5wMA/vrrL1hbW+PEiRP4+++/MX36dIwdO7ZI88nKysKxY8cwbdo0zTS5XA4/Pz9ER0e/9HWPHz+Gg4MD1Go1WrZsia+//hpNmjQpcGxmZiYyMzM1j1NSUgA8uyJDdnbp/Kkudz6lNb+qhv0pHHukHfvzjLu9CbaO88SvkTH4KeI6Iq/eR6cF+/Beewc4qtkfbbgOacf+aMf+aFcW/SnOvGSiBH+nMjAwwMWLF1GnTh30798fTZo0wYwZM3Dr1i00atQI6elFu5RMXFwc7OzsEBUVBU9PT830qVOnIiIiAocOHcr3mujoaFy5cgXNmzdHcnIyvv/+e+zbtw/nzp1D7dq1840PCgrCzJkz801fu3YtDAwMivGpiYgqjntPgI035LiU/OwPbFZ6Av3rqdHAlIceEFHll56ejsGDByM5ORkmJiZax5Zoz2z9+vWxZcsW9OnTB7t27cLkyZMBAImJiYW+4avy9PTME3zbtWuHxo0b4+eff8aXX36Zb/y0adMQGBioeZySkgJ7e3t06tSp1GrNzs5GaGgo/P39oaurWyrzrErYn8KxR9qxPwUbJgS2n7mL2TsuITEtCz+eV6BPi1r4uHND1DRUSl1ehcJ1SDv2Rzv2R7uy6E/uX9KLokRhdvr06Rg8eDAmT56M119/XRMuQ0JC0KJFiyLPx8LCAgqFAgkJCXmmJyQkwMbGpkjz0NXVRYsWLXD16tUCn1epVJobPLz4utJeIctinlUJ+1M49kg79ie/vu514NvAAh8sD0NUohybT8Rh76V7mNbFGW+520Mul0ldYoXCdUg79kc79ke70uxPceZTohPA+vXrh9jYWBw9ehS7du3STO/YsaPmWNqiUCqVcHd3R1hYmGaaWq1GWFhYnr2v2uTk5ODMmTOwtbUt+gcgIqpCTPR10b+eGutHtYGzjTGS0rPx8d9nMPCXg7iSkCp1eUREZapEYRYAbGxs0KJFC8TFxeH27dsAgDZt2sDZ2blY8wkMDMSyZcuwevVqXLhwAWPHjkVaWhoCAgIAAMOGDctzgtisWbMQEhKC69ev4/jx43j77bdx8+ZNvPvuuyX9KEREVUILezP88357fNrVGfq6ChyOeYiuC/fju10X8SQrR+ryiIjKRInCrFqtxqxZs2BqagoHBwc4ODjAzMwMX375JdTq4t1yccCAAfj+++8xffp0uLm54eTJk9i5c6fmcluxsbGIj4/XjH/06BFGjRqFxo0bo2vXrkhJSUFUVBRcXFxK8lGIiKoUXYUco32cEBroA7/GVsjOEVi89xo6LYhA+KWXX7+biKiyKtExs5999hmWL1+Ob775Bl5eXgCAyMhIBAUFISMjA7Nnzy7W/CZMmIAJEyYU+Fx4eHiex/Pnzy/WoQxERNVR7RoGWDasFULOJyBo2zncevgEI1YeQbfmtpjR3QVWJrxzIhFVDSUKs6tXr8avv/6Knj17aqY1b94cdnZ2GDduXLHDLBERlT6ZTIbOTWzgVd8C80MvY+WBG/j3dDz2XbqHj95ohCEeDlDwBDEiquRKdJjBw4cPCzw21tnZGQ8fPnzlooiIqPQYqXTwRXcXbJvQHq61TZGa+RTTt55D3yVROHsnWeryiIheSYnCrKurK3788cd803/88Uc0b978lYsiIqLS19TOFJvGeWFWryYwUung1K0k9PwxEl9uP4+0zKdSl0dEVCIlOszg22+/Rbdu3bB7927NJbSio6Nx69Yt7Nixo1QLJCKi0qOQyzDM0xGdm9hg1vbz+Pd0PJZH3sCOM/EI6tkEnZsU7RrfREQVRYn2zPr6+uLy5cvo06cPkpKSkJSUhL59++LcuXNYs2ZNaddIRESlzNpED4sHt8SqgNawN9dHfHIG3ltzDO+uPoo7SU+kLo+IqMhKtGcWAGrVqpXvRK9Tp05h+fLl+OWXX165MCIiKnsdGlkhZJIvFu25gl/2XcfuCwmIunYfk/0aIsDLETqKEl+OnIioXHArRURUzekrFZj6hjN2TPRGa8caSM/KwewdF9DjxwM4EftI6vKIiLRimCUiIgBAQ2tjrB/tiblvNoOZgS4uxKeg75IofL7lDJKfZEtdHhFRgRhmiYhIQy6XYUDrOggL9EXflnYQAvj9YCz8giOw7VQchBBSl0hElEexjpnt27ev1ueTkpJepRYiIqogahqpENzfDf3ca+PzzWdx/X4aPvjzBDYevYWvejeFQ01DqUskIgJQzD2zpqamWn8cHBwwbNiwsqqViIjKWTsnC/w3yRuT/RpCqSPH/iv30Wn+Pvy45wqynqqlLo+IqHh7ZleuXFlWdRARUQWl0lFgol8D9HSrhc+3nMGBqw/wfchlbDkZh9m9m8KjXk2pSySiaozHzBIRUZHUtTDE7+94YMEAN1gYKXE18TEG/HIQH208hYdpWVKXR0TVFMMsEREVmUwmQ+8WdggL7IBBbeoAADYeu42O88Kx8egtniBGROWOYZaIiIrN1EAXc/o2w99jPdHI2hiP0rPx0V+nMeCXg7iamCp1eURUjTDMEhFRibk7mGP7B+3xSRdn6OnKcfjGQ3T5YT/mhVxCRnaO1OURUTXAMEtERK9EVyHHGF8nhE72xevOVsjOEVi05yo6L9iH/VfuSV0eEVVxDLNERFQq7M0NsHx4KywZ0hLWJircfJCOocsP44M/TyAxNUPq8oioimKYJSKiUiOTydClmS12B/piRDtHyGXAtlNx6DgvAmsO3oRazRPEiKh0McwSEVGpM9bTRVDPJtg6vj2a2ZkiNeMpvthyFn2XROF8XIrU5RFRFcIwS0REZaZZbVNsGe+FoB4uMFLp4OStJPT4MRKz/z2PtMynUpdHRFUAwywREZUphVyGEV51sTvQF12b2SBHLbBs/w34B0cg9HyC1OURUSXHMEtEROXCxlQPPw1xx4oRrVC7hj7ikjMw6rejGP3bUcQlPZG6PCKqpBhmiYioXL3ubI3Qyb4Y4+sEHbkMIecT4B8cgV/3X8fTHLXU5RFRJcMwS0RE5U5fqcAnXZyx/YP2cHeogbSsHHz17wX0WnwAJ28lSV0eEVUiDLNERCQZZxsTbHzPE3P6NoOJng7OxaWgz08HMH3rWaRkZEtdHhFVAgyzREQkKblchkFt6mDPhx3Qp4UdhAB+i74Jv3kR2H46DkLw2rRE9HIMs0REVCFYGKkwf4Ab/njXA3UtDJGYmokJa09gxMojiH2QLnV5RFRBMcwSEVGF4lXfAv9N9MbEjg2gVMgRcfke/OdHYPHeq8h6yhPEiCgvhlkiIqpw9HQVmOzfEP9N8oZnvZrIfKrGd7suodvC/TgS81Dq8oioAmGYJSKiCsvJ0ghrR3kguL8rahoqcSXxMd5aGo2P/zqNR2lZUpdHRBUAwywREVVoMpkMfVvWRtgUXwxsbQ8AWH/0FjoGR+DvY7d5ghhRNccwS0RElYKZgRLfvNkcG8d4oqG1ER6mZWHKxlMYvOwQrt17LHV5RCQRhlkiIqpUWjuaY/v73pj6RiPo6coRff0BuizYj+CQS8jIzpG6PCIqZwyzRERU6Sh15BjXoT5CJ/uiQyNLZOWosXDPVbyxYB8ir9yXujwiKkcMs0REVGnZmxtg5YjW+GlIS1gZqxDzIB1vLz+ESetO4F5qptTlEVE5YJglIqJKTSaToWszW+ye4ovhng6QyYAtJ+PQcV441h6KhVrNE8SIqjKGWSIiqhJM9HQxs1dTbBnnhSa1TJCS8RSfbj6DfkujcOluqtTlEVEZYZglIqIqxdXeDFvHe2F6dxcYKhU4HpuEXksOYutNOdKznkpdHhGVMoZZIiKqcnQUcoxsXxe7p/jijSY2yFEL7ImTo+uiKIRdSJC6PCIqRQyzRERUZdma6mPpUHf8/HYL1FAK3EnKwDurj2LMmmOIT34idXlEVAoYZomIqMp7vZElprnl4B0vByjkMuw8dxd+8yKwIvIGcniCGFGlxjBLRETVgkoBfPJGI2x/vz1a1DFDWlYOZm0/j16LI3H6dpLU5RFRCTHMEhFRtdLY1gR/j2mH2X2awkRPB2fvpKD34gMI2nYOqRnZUpdHRMXEMEtERNWOXC7DEA8HhE3pgF5utaAWwKqoGPgFR2DHmXgIwUMPiCqLChFmFy9eDEdHR+jp6cHDwwOHDx8u0uvWrVsHmUyG3r17l22BRERUJVkaq/DDwBZY804bONY0QEJKJsb9cRwjVx3BrYfpUpdHREUgeZhdv349AgMDMWPGDBw/fhyurq7o3LkzEhMTtb4uJiYGH374Iby9vcupUiIiqqq8G1hi5yQffPB6fegqZNh76R7850dgSfg1ZOeopS6PiLSQPMwGBwdj1KhRCAgIgIuLC5YuXQoDAwOsWLHipa/JycnBkCFDMHPmTNSrV68cqyUioqpKT1eBwE6N8N9EH3jUNUdGthpzd15E94WROBrzUOryiOgldKR886ysLBw7dgzTpk3TTJPL5fDz80N0dPRLXzdr1ixYWVnhnXfewf79+7W+R2ZmJjIzMzWPU1JSAADZ2dnIzi6dA/1z51Na86tq2J/CsUfasT/asT+FK06PHGqosCbAHZtPxuGbnZdxKSEV/ZZGY0ArO3zo3xBmBrplXW654zqkHfujXVn0pzjzkgkJj3KPi4uDnZ0doqKi4OnpqZk+depURERE4NChQ/leExkZiYEDB+LkyZOwsLDAiBEjkJSUhC1bthT4HkFBQZg5c2a+6WvXroWBgUGpfRYiIqp60rKBrTflOHTv2R8yjXQEejuq0cpCQCaTuDiiKiw9PR2DBw9GcnIyTExMtI6VdM9scaWmpmLo0KFYtmwZLCwsivSaadOmITAwUPM4JSUF9vb26NSpU6HNKars7GyEhobC398furpV7zf2V8X+FI490o790Y79Kdyr9OgtAEdiHuGLbedx7V4afr+qwHW1OYJ6NEZdC8OyKbiccR3Sjv3Rriz6k/uX9KKQNMxaWFhAoVAgISHvfbITEhJgY2OTb/y1a9cQExODHj16aKap1c8OzNfR0cGlS5fg5OSU5zUqlQoqlSrfvHR1dUt9hSyLeVYl7E/h2CPt2B/t2J/ClbRH7RpY4b+JFli2/zoWhl1B1PWH6P5jNMa95oQxvk7Q01WUQbXlj+uQduyPdqXZn+LMR9ITwJRKJdzd3REWFqaZplarERYWluewg1zOzs44c+YMTp48qfnp2bMnXnvtNZw8eRL29vblWT4REVUjSh05xr9WHyGTfeDT0BJZOWos2H0FXX/Yj6ir96Uuj6jakvwwg8DAQAwfPhytWrVCmzZtsGDBAqSlpSEgIAAAMGzYMNjZ2WHOnDnQ09ND06ZN87zezMwMAPJNJyIiKgsONQ2xOqA1tp+Ox6zt53H9fhoG/3oIfVrY4bNujWFhlP+vgURUdiQPswMGDMC9e/cwffp03L17F25ubti5cyesra0BALGxsZDLJb+CGBERkYZMJkMP11rwbWSJ73ddwpqDN7H5xB3suZiIaV2c0b+VPeRyniFGVB4kD7MAMGHCBEyYMKHA58LDw7W+dtWqVaVfEBERURGY6OliVq+m6NuyNj7ddAbn41PwyaYz+OvYbczu0wyNbIylLpGoyuMuTyIiolfkZm+GbRO88Hm3xjBQKnD05iN0W7gf3/x3EU+ycqQuj6hKY5glIiIqBToKOd71rofQQF90crHGU7XA0ohr8J8fgb0Xtd+inYhKjmGWiIioFNmZ6eOXYa2wbFgr1DLVw+1HTxCw6gjG/XEMCSkZUpdHVOUwzBIREZUBfxdrhAb6YpR3XSjkMuw4cxcd50Vg1YEbyFFLdvNNoiqHYZaIiKiMGKp08Fk3F2yb4AVXezM8znyKoH/Oo89PB3D2TrLU5RFVCQyzREREZaxJLVNsGtsOX/ZuCmM9HZy+nYyeP0Zi5j/n8DjzqdTlEVVqDLNERETlQCGXYWhbB4RN8UUP11pQC2DlgRj4zYvAzrPxEIKHHhCVBMMsERFRObIy1sOiQS2wemQb1DE3wN2UDIz5/TjeXX0Utx+lS10eUaXDMEtERCQB34aWCJnsgwmv1YeuQoawi4nwD96HnyOuITtHLXV5RJUGwywREZFE9HQV+LBzI/w30Rtt6prjSXYO5vx3ET0WReLYzUdSl0dUKTDMEhERSay+lTHWj26Lb/s1Rw0DXVy8m4p+S6Pw6eYzSE7Plro8ogqNYZaIiKgCkMlk6N/KHmFTOqCfe20IAaw9FIuOweHYevIOTxAjegmGWSIiogrE3FCJ799yxbrRbeFkaYj7j7Mwcd1JDF1+GDH306Quj6jCYZglIiKqgNrWq4kdE70xxb8hlDpyRF69j04L9mFh2BVkPs2RujyiCoNhloiIqIJS6SjwfscGCJnkA+8GFsh6qkZw6GV0+WE/oq89kLo8ogqBYZaIiKiCc7QwxG8j2+CHgW6wMFLh+r00DFp2EIEbTuLB40ypyyOSFMMsERFRJSCTydDLzQ5hU3zxdts6kMmATcfvoGNwBNYfiYVazRPEqHpimCUiIqpETPV18VXvZvh7bDs42xgjKT0bH/99BgN/OYgrCalSl0dU7hhmiYiIKqGWdWrgn/fb49OuztDXVeBwzEN0Xbgf3+26iCdZPEGMqg+GWSIiokpKVyHHaB8nhAb6wK+xFbJzBBbvvYZOCyIQfilR6vKIygXDLBERUSVXu4YBlg1rhZ+HusPWVA+3Hj7BiJVHMH7tcSSmZEhdHlGZYpglIiKqAmQyGTo3sUFooC/eaV8Xchnw7+l4dJwXgd+iY5DDE8SoimKYJSIiqkKMVDr4orsLtk1oD9fapkjNfIrpW8+h75IonL2TLHV5RKWOYZaIiKgKampnik3jvDCrVxMYqXRw6lYSev4YiS+3n0da5lOpyyMqNQyzREREVZRCLsMwT0eETfFFt+a2UAtgeeQN+AVHYNe5u1KXR1QqGGaJiIiqOGsTPSwe3BKrAlrD3lwf8ckZeG/NMby7+ijuJD2RujyiV8IwS0REVE10aGSFkEm+GNfBCTpyGXZfSIB/cASWH4hBDs8Po0qKYZaIiKga0VcqMPUNZ+yY6I3WjjWQnpWDb3ZexrzTCpy8lSR1eUTFxjBLRERUDTW0Nsb60Z6Y+2YzmOnr4k66DP2XHcbnW84g+Um21OURFRnDLBERUTUll8swoHUd7JzohdaWaggB/H4wFn7BEdh2Kg5C8NgDqvgYZomIiKq5moZKvF1fjTUBrVDPwhD3UjPxwZ8nMGzFYdx8kCZ1eURaMcwSERERAKBtPXP8N8kbk/0aQqkjx/4r99Fp/j78uOcKsp6qpS6PqEAMs0RERKSh0lFgol8D7JrkA6/6NZH5VI3vQy6j68L9OHT9gdTlEeXDMEtERET51LUwxO/veGDBADdYGClxNfExBvxyEB9tPIWHaVlSl0ekwTBLREREBZLJZOjdwg5hgR0wqE0dAMDGY7fRcV44Nhy9xRPEqEJgmCUiIiKtTA10MadvM/w91hPONsZ4lJ6NqX+dxoBfDuJqYqrU5VE1xzBLREREReLuYI5/3m+PaV2coa+rwOEbD9Hlh/2YF3IJGdk5UpdH1RTDLBERERWZrkKO93ydEDLZB687WyE7R2DRnqvovGAf9l2+J3V5VA0xzBIREVGx2ZsbYPnwVlgypCWsTVS4+SAdw1Ycxvt/nkBiaobU5VE1wjBLREREJSKTydClmS12B/oiwMsRchnwz6k4dJwXgTUHb0Kt5gliVPYYZomIiOiVGOvpYkaPJtg6vj2a2ZkiNeMpvthyFn2XROF8XIrU5VEVxzBLREREpaJZbVNsGe+FoB4uMFLp4OStJPT4MRKz/z2PtMynUpdHVRTDLBEREZUahVyGEV51sTvQF12b2SBHLbBs/w34B0cg9HyC1OVRFcQwS0RERKXOxlQPPw1xx4oRrVC7hj7ikjMw6rejGP3bUcQlPZG6PKpCKkSYXbx4MRwdHaGnpwcPDw8cPnz4pWM3bdqEVq1awczMDIaGhnBzc8OaNWvKsVoiIiIqqtedrRE62RdjfJ2gI5ch5HwC/IMj8Ov+63iao5a6PKoCJA+z69evR2BgIGbMmIHjx4/D1dUVnTt3RmJiYoHjzc3N8dlnnyE6OhqnT59GQEAAAgICsGvXrnKunIiIiIpCX6nAJ12csf2D9nB3qIG0rBx89e8F9Fp8ACdvJUldHlVykofZ4OBgjBo1CgEBAXBxccHSpUthYGCAFStWFDi+Q4cO6NOnDxo3bgwnJydMnDgRzZs3R2RkZDlXTkRERMXhbGOCje95Yk7fZjDR08G5uBT0+ekApm89i5SMbKnLo0pKR8o3z8rKwrFjxzBt2jTNNLlcDj8/P0RHRxf6eiEE9uzZg0uXLmHu3LkFjsnMzERmZqbmcUrKs0uEZGdnIzu7dL44ufMprflVNexP4dgj7dgf7difwrFH2pV3f/q1sMVrDcwxZ+dlbD0Vj9+ib2Ln2bv4rEsjdGlqDZlMVi51FBXXH+3Koj/FmZdMCCHZFY3j4uJgZ2eHqKgoeHp6aqZPnToVEREROHToUIGvS05Ohp2dHTIzM6FQKPDTTz9h5MiRBY4NCgrCzJkz801fu3YtDAwMSueDEBERUYlcSpZh43U57mU8C7CNzdToV1cNCz2JCyNJpaenY/DgwUhOToaJiYnWsZLumS0pY2NjnDx5Eo8fP0ZYWBgCAwNRr149dOjQId/YadOmITAwUPM4JSUF9vb26NSpU6HNKars7GyEhobC398furq6pTLPqoT9KRx7pB37ox37Uzj2SDsp+9MVwLjsHPy8/waW7ruBC0lyfHtGBxM61MNIL0codSQ/IpLrTyHKoj+5f0kvCknDrIWFBRQKBRIS8l53LiEhATY2Ni99nVwuR/369QEAbm5uuHDhAubMmVNgmFWpVFCpVPmm6+rqlvoKWRbzrErYn8KxR9qxP9qxP4Vjj7STqj+6urqY0rkxere0x+ebzyL6+gPM230V207fxdd9m6G1o3m511QQrj/alWZ/ijMfSX/dUSqVcHd3R1hYmGaaWq1GWFhYnsMOCqNWq/McF0tERESVj5OlEdaO8kBwf1fUNFTiSuJjvLU0Gh//dRqP0rKkLo8qKMn33QcGBmLZsmVYvXo1Lly4gLFjxyItLQ0BAQEAgGHDhuU5QWzOnDkIDQ3F9evXceHCBcybNw9r1qzB22+/LdVHICIiolIik8nQt2VthE3xxcDW9gCA9UdvoWNwBP4+dhsSnupDFZTkx8wOGDAA9+7dw/Tp03H37l24ublh586dsLa2BgDExsZCLv9f5k5LS8O4ceNw+/Zt6Ovrw9nZGb///jsGDBgg1UcgIiKiUmZmoMQ3bzbHm+618dnmM7ic8BhTNp7CxmO38FXvZqhvZSR1iVRBSB5mAWDChAmYMGFCgc+Fh4fnefzVV1/hq6++KoeqiIiISGqtHc2x/X1vLI+8gR/CLuPg9Yfo+sN+jPGth3Gv1YeerkLqEklikh9mQERERKSNUkeOsR2cEDrZF681skRWjhoL91zFGwv2IfLKfanLI4kxzBIREVGlYG9ugBUjWuOnIS1hZaxCzIN0vL38ECatO4F7qTwRvLpimCUiIqJKQyaToWszW+ye4ovhng6QyYAtJ+PQcV44/jh0E2o1TxCrbhhmiYiIqNIx0dPFzF5NsXW8F5ramSAl4yk+23wW/ZZG4eLdol9wnyo/hlkiIiKqtJrXNsOWcV6Y3t0FhkoFjscmodvCSMzZcQHpWU+lLo/KAcMsERERVWo6CjlGtq+L3VN88UYTG+SoBX7edx3+wfsQdiGh8BlQpcYwS0RERFWCrak+lg51x/LhrWBnpo87SU/wzuqjGLPmGOKTn0hdHpURhlkiIiKqUjo2tkZooA/e86kHhVyGnefuwm9eBFZE3kAOTxCrchhmiYiIqMoxUOpgWtfG2P5+e7SoY4a0rBzM2n4evRZH4vTtJKnLo1LEMEtERERVVmNbE/w9ph1m92kKEz0dnL2Tgt6LDyBo2zmkZmRLXR6VAoZZIiIiqtLkchmGeDggbEoH9HKrBbUAVkXFwC84AjvOxEMIHnpQmTHMEhERUbVgaazCDwNbYM07beBY0wAJKZkY98dxjFx1BLcepktdHpUQwywRERFVK94NLLFzkg8+eL0+dBUy7L10D/7zI7Ak/Bqyc9RSl0fFxDBLRERE1Y6ergKBnRrhv4k+8KhrjoxsNebuvIjuCyNxNOah1OVRMTDMEhERUbVV38oI60a3xfdvuaKGgS4uJaSi39JoTNt0GknpWVKXR0XAMEtERETVmkwmQz/32tgzpQP6t6oNAPjz8C10nBeBzSdu8wSxCo5hloiIiAhADUMlvu3nig3veaK+lREepGVh8vpTGLHqGBJ5A7EKi2GWiIiI6Dlt6ppjxwfe+KhzI6h05Ii6/hDfnFJg0Z5ryMjOkbo8egHDLBEREdELlDpyjH+tPkIm+8C7fk3kCBkW7r2Grj/sR9TV+1KXR89hmCUiIiJ6CYeahlg+rCWGN8iBpZES1++nYfCvhzB5/Uncf5wpdXkEhlkiIiIirWQyGVpaCOya6IVhng6QyYDNJ+6g47wI/Hk4Fmo1TxCTEsMsERERUREY6+liVq+m2DzOCy62Jkh+ko1pm86g/8/RuHQ3Veryqi2GWSIiIqJicLM3w7YJXvi8W2MYKBU4evMRui3cj2/+u4gnWTxBrLwxzBIREREVk45Cjne962F3oC86uVjjqVpgacQ1+M+PwN6LiVKXV60wzBIRERGVUC0zffwyrBWWDWuFWqZ6uP3oCQJWHcG4P44hISVD6vKqBYZZIiIiolfk72KN0EBfjPKuC4Vchh1n7qLjvAisOnADOTxBrEwxzBIRERGVAkOVDj7r5oJtE7zgZm+Gx5lPEfTPefT56QDO3kmWurwqi2GWiIiIqBQ1qWWKv8e2w5e9m8JYTwenbyej54+RmPnPOTzOfCp1eVUOwywRERFRKVPIZRja1gFhU3zRw7UW1AJYeSAGfvMisPNsPITgoQelhWGWiIiIqIxYGeth0aAWWD2yDeqYG+BuSgbG/H4c764+ituP0qUur0pgmCUiIiIqY74NLREy2QcTXqsPXYUMYRcT4R+8Dz9HXEN2jlrq8io1hlkiIiKicqCnq8CHnRvhv4neaFPXHE+yczDnv4vosSgSx24+krq8SothloiIiKgc1bcyxvrRbfFtv+aoYaCLi3dT0W9pFD7dfAbJ6dlSl1fpMMwSERERlTOZTIb+rewRNqUD+rnXhhDA2kOx6Bgcjq0n7/AEsWJgmCUiIiKSiLmhEt+/5Yp1o9vCydIQ9x9nYeK6kxi6/DBi7qdJXV6lwDBLREREJLG29Wpix0RvTPFvCKWOHJFX76PTgn1YGHYFmU9zpC6vQmOYJSIiIqoAVDoKvN+xAUIm+cC7gQWynqoRHHoZXX7Yj+hrD6Qur8JimCUiIiKqQBwtDPHbyDb4YaAbLIxUuH4vDYOWHUTghpN48DhT6vIqHIZZIiIiogpGJpOhl5sdwqb44u22dSCTAZuO30HH4AisPxILtZoniOVimCUiIiKqoEz1dfFV72b4e2w7ONsYIyk9Gx//fQYDfzmIKwmpUpdXITDMEhEREVVwLevUwD/vt8enXZ2hr6vA4ZiH6LpwP77bdRFPsqr3CWIMs0RERESVgK5CjtE+Ttg9xRd+ja2RnSOweO81dFoQgfBLiVKXJxmGWSIiIqJKxM5MH78Ob4Wfh7rD1lQPtx4+wYiVRzB+7XEkpmRIXV65Y5glIiIiqoQ6N7FBaKAv3mlfF3IZ8O/peHScF4HfomOQU41OEGOYJSIiIqqkjFQ6+KK7C7ZNaA/X2qZIzXyK6VvPoe9PB3D2TrLU5ZWLChFmFy9eDEdHR+jp6cHDwwOHDx9+6dhly5bB29sbNWrUQI0aNeDn56d1PBEREVFV19TOFJvGeWFWryYwVung1O1k9PwxEl9uP4+0zKdSl1emJA+z69evR2BgIGbMmIHjx4/D1dUVnTt3RmJiwQcyh4eHY9CgQdi7dy+io6Nhb2+PTp064c6dO+VcOREREVHFoZDLMMzTEbun+KJbc1uoBbA88gb8giOw69xdqcsrM5KH2eDgYIwaNQoBAQFwcXHB0qVLYWBggBUrVhQ4/o8//sC4cePg5uYGZ2dn/Prrr1Cr1QgLCyvnyomIiIgqHmsTPSwe3BKrAlrD3lwf8ckZeG/NMby7+ijuJD2RurxSpyPlm2dlZeHYsWOYNm2aZppcLoefnx+io6OLNI/09HRkZ2fD3Ny8wOczMzORmfm/W7+lpKQAALKzs5Gdnf0K1f9P7nxKa35VDftTOPZIO/ZHO/ancOyRduyPdpW1P171auDf8e3wU8R1/BoZg90XEhB17T4+eN0Jw9vWgY6idPZplkV/ijMvmRBCstPd4uLiYGdnh6ioKHh6emqmT506FRERETh06FCh8xg3bhx27dqFc+fOQU9PL9/zQUFBmDlzZr7pa9euhYGBwat9ACIiIqJKID4d2HBdgeupMgCAnYFA/3o5cDSWuLCXSE9Px+DBg5GcnAwTExOtYyXdM/uqvvnmG6xbtw7h4eEFBlkAmDZtGgIDAzWPU1JSNMfZFtacosrOzkZoaCj8/f2hq6tbKvOsStifwrFH2rE/2rE/hWOPtGN/tKsq/QlQC/x94g6+3XUFd9KzseCcDga1ro0pfg1gol/yz1UW/cn9S3pRSBpmLSwsoFAokJCQkGd6QkICbGxstL72+++/xzfffIPdu3ejefPmLx2nUqmgUqnyTdfV1S31FbIs5lmVsD+FY4+0Y3+0Y38Kxx5px/5oVxX6M7htXXRuWguzd1zApuN3sPbwbYReuIcvurugR3NbyGSyEs+7NPtTnPlIegKYUqmEu7t7npO3ck/mev6wgxd9++23+PLLL7Fz5060atWqPEolIiIiqhJqGqkQ3N8Na0d5oJ6FIe6lZuKDP09g2IrDuPkgTeryik3yqxkEBgZi2bJlWL16NS5cuICxY8ciLS0NAQEBAIBhw4blOUFs7ty5+OKLL7BixQo4Ojri7t27uHv3Lh4/fizVRyAiIiKqdNo5WeC/Sd6Y7NcQSh059l+5j07z9+HHPVeQ9VStGZejFoi+9gBbT95B9LUHFe7uYpIfMztgwADcu3cP06dPx927d+Hm5oadO3fC2toaABAbGwu5/H+Ze8mSJcjKykK/fv3yzGfGjBkICgoqz9KJiIiIKjWVjgIT/Rqgp1stfL7lDA5cfYDvQy5jy8k4zO7dFI/SszDzn/OIT87QvMbWVA8zerjgjaa2Elb+P5KHWQCYMGECJkyYUOBz4eHheR7HxMSUfUFERERE1UhdC0P8/o4Htp6Mw1f/nsfVxMcY8MvBAsfeTc7A2N+PY8nbLStEoJX8MAMiIiIikp5MJkPvFnYIC+yAAa3tXzou9yCDmf+crxCHHDDMEhEREZGGqYEuervZaR0jAMQnZ+DwjYflU5QWDLNERERElEdiakbhg4oxriwxzBIRERFRHlbGBd+MqqTjyhLDLBERERHl0aauOWxN9fCyWyjI8OyqBm3qmpdnWQVimCUiIiKiPBRyGWb0cAGAfIE29/GMHi5QyEt+x7DSwjBLRERERPm80dQWS95uCRvTvIcS2JjqVZjLcgEV5DqzRERERFTxvNHUFv4uNjh84yESUzNgZfzs0IKKsEc2F8MsEREREb2UQi6Dp1NNqct4KR5mQERERESVFsMsEREREVVaDLNEREREVGkxzBIRERFRpcUwS0RERESVFsMsEREREVVaDLNEREREVGkxzBIRERFRpcUwS0RERESVFsMsEREREVVa1e52tkIIAEBKSkqpzTM7Oxvp6elISUmBrq5uqc23qmB/Csceacf+aMf+FI490o790Y790a4s+pOb03JzmzbVLsympqYCAOzt7SWuhIiIiIi0SU1NhampqdYxMlGUyFuFqNVqxMXFwdjYGDKZrFTmmZKSAnt7e9y6dQsmJialMs+qhP0pHHukHfujHftTOPZIO/ZHO/ZHu7LojxACqampqFWrFuRy7UfFVrs9s3K5HLVr1y6TeZuYmHAl14L9KRx7pB37ox37Uzj2SDv2Rzv2R7vS7k9he2Rz8QQwIiIiIqq0GGaJiIiIqNJimC0FKpUKM2bMgEqlkrqUCon9KRx7pB37ox37Uzj2SDv2Rzv2Rzup+1PtTgAjIiIioqqDe2aJiIiIqNJimCUiIiKiSothloiIiIgqLYZZIiIiIqq0GGZLweLFi+Ho6Ag9PT14eHjg8OHDUpckiX379qFHjx6oVasWZDIZtmzZkud5IQSmT58OW1tb6Ovrw8/PD1euXJGmWAnMmTMHrVu3hrGxMaysrNC7d29cunQpz5iMjAyMHz8eNWvWhJGREd58800kJCRIVHH5WrJkCZo3b6656Lanpyf+++8/zfPVuTcF+eabbyCTyTBp0iTNtOreo6CgIMhksjw/zs7Omuere38A4M6dO3j77bdRs2ZN6Ovro1mzZjh69Kjm+eq8nXZ0dMy3/shkMowfPx4A1x8AyMnJwRdffIG6detCX18fTk5O+PLLL/H8tQQkWYcEvZJ169YJpVIpVqxYIc6dOydGjRolzMzMREJCgtSllbsdO3aIzz77TGzatEkAEJs3b87z/DfffCNMTU3Fli1bxKlTp0TPnj1F3bp1xZMnT6QpuJx17txZrFy5Upw9e1acPHlSdO3aVdSpU0c8fvxYM2bMmDHC3t5ehIWFiaNHj4q2bduKdu3aSVh1+dm2bZv4999/xeXLl8WlS5fEp59+KnR1dcXZs2eFENW7Ny86fPiwcHR0FM2bNxcTJ07UTK/uPZoxY4Zo0qSJiI+P1/zcu3dP83x178/Dhw+Fg4ODGDFihDh06JC4fv262LVrl7h69apmTHXeTicmJuZZd0JDQwUAsXfvXiEE1x8hhJg9e7aoWbOm2L59u7hx44bYuHGjMDIyEj/88INmjBTrEMPsK2rTpo0YP3685nFOTo6oVauWmDNnjoRVSe/FMKtWq4WNjY347rvvNNOSkpKESqUSf/75pwQVSi8xMVEAEBEREUKIZ/3Q1dUVGzdu1Iy5cOGCACCio6OlKlNSNWrUEL/++it785zU1FTRoEEDERoaKnx9fTVhlj16FmZdXV0LfI79EeLjjz8W7du3f+nz3E7nNXHiROHk5CTUajXXn//XrVs3MXLkyDzT+vbtK4YMGSKEkG4d4mEGryArKwvHjh2Dn5+fZppcLoefnx+io6MlrKziuXHjBu7evZunV6ampvDw8Ki2vUpOTgYAmJubAwCOHTuG7OzsPD1ydnZGnTp1ql2PcnJysG7dOqSlpcHT05O9ec748ePRrVu3PL0AuP7kunLlCmrVqoV69ephyJAhiI2NBcD+AMC2bdvQqlUrvPXWW7CyskKLFi2wbNkyzfPcTv9PVlYWfv/9d4wcORIymYzrz/9r164dwsLCcPnyZQDAqVOnEBkZiS5dugCQbh3SKbM5VwP3799HTk4OrK2t80y3trbGxYsXJaqqYrp79y4AFNir3OeqE7VajUmTJsHLywtNmzYF8KxHSqUSZmZmecZWpx6dOXMGnp6eyMjIgJGRETZv3gwXFxecPHmy2vcGANatW4fjx4/jyJEj+Z7j+gN4eHhg1apVaNSoEeLj4zFz5kx4e3vj7Nmz7A+A69evY8mSJQgMDMSnn36KI0eO4IMPPoBSqcTw4cO5nX7Oli1bkJSUhBEjRgDg9yvXJ598gpSUFDg7O0OhUCAnJwezZ8/GkCFDAEj3bz3DLJEExo8fj7NnzyIyMlLqUiqURo0a4eTJk0hOTsZff/2F4cOHIyIiQuqyKoRbt25h4sSJCA0NhZ6entTlVEi5e4cAoHnz5vDw8ICDgwM2bNgAfX19CSurGNRqNVq1aoWvv/4aANCiRQucPXsWS5cuxfDhwyWurmJZvnw5unTpglq1akldSoWyYcMG/PHHH1i7di2aNGmCkydPYtKkSahVq5ak6xAPM3gFFhYWUCgU+c5mTEhIgI2NjURVVUy5/WCvgAkTJmD79u3Yu3cvateurZluY2ODrKwsJCUl5RlfnXqkVCpRv359uLu7Y86cOXB1dcUPP/zA3uDZn8kTExPRsmVL6OjoQEdHBxEREVi4cCF0dHRgbW1d7Xv0IjMzMzRs2BBXr17lOgTA1tYWLi4ueaY1btxYcygGt9PP3Lx5E7t378a7776rmcb155mPPvoIn3zyCQYOHIhmzZph6NChmDx5MubMmQNAunWIYfYVKJVKuLu7IywsTDNNrVYjLCwMnp6eElZW8dStWxc2NjZ5epWSkoJDhw5Vm14JITBhwgRs3rwZe/bsQd26dfM87+7uDl1d3Tw9unTpEmJjY6tNj16kVquRmZnJ3gDo2LEjzpw5g5MnT2p+WrVqhSFDhmj+v7r36EWPHz/GtWvXYGtry3UIgJeXV77LAV6+fBkODg4AuJ3OtXLlSlhZWaFbt26aaVx/nklPT4dcnjc6KhQKqNVqABKuQ2V2alk1sW7dOqFSqcSqVavE+fPnxejRo4WZmZm4e/eu1KWVu9TUVHHixAlx4sQJAUAEBweLEydOiJs3bwohnl2uw8zMTGzdulWcPn1a9OrVq9pc8kUIIcaOHStMTU1FeHh4nsu/pKena8aMGTNG1KlTR+zZs0ccPXpUeHp6Ck9PTwmrLj+ffPKJiIiIEDdu3BCnT58Wn3zyiZDJZCIkJEQIUb178zLPX81ACPZoypQpIjw8XNy4cUMcOHBA+Pn5CQsLC5GYmCiEYH8OHz4sdHR0xOzZs8WVK1fEH3/8IQwMDMTvv/+uGVPdt9M5OTmiTp064uOPP873XHVff4QQYvjw4cLOzk5zaa5NmzYJCwsLMXXqVM0YKdYhhtlSsGjRIlGnTh2hVCpFmzZtxMGDB6UuSRJ79+4VAPL9DB8+XAjx7JIdX3zxhbC2thYqlUp07NhRXLp0Sdqiy1FBvQEgVq5cqRnz5MkTMW7cOFGjRg1hYGAg+vTpI+Lj46UruhyNHDlSODg4CKVSKSwtLUXHjh01QVaI6t2bl3kxzFb3Hg0YMEDY2toKpVIp7OzsxIABA/JcQ7W690cIIf755x/RtGlToVKphLOzs/jll1/yPF/dt9O7du0SAAr8zFx/hEhJSRETJ04UderUEXp6eqJevXris88+E5mZmZoxUqxDMiGeu20DEREREVElwmNmiYiIiKjSYpglIiIiokqLYZaIiIiIKi2GWSIiIiKqtBhmiYiIiKjSYpglIiIiokqLYZaIiIiIKi2GWSIiIiKqtBhmiYiqCUdHRyxYsEDqMoiIShXDLBFRGRgxYgR69+4NAOjQoQMmTZpUbu+9atUqmJmZ5Zt+5MgRjB49utzqICIqDzpSF0BEREWTlZUFpVJZ4tdbWlqWYjVERBUD98wSEZWhESNGICIiAj/88ANkMhlkMhliYmIAAGfPnkWXLl1gZGQEa2trDB06FPfv39e8tkOHDpgwYQImTZoECwsLdO7cGQAQHByMZs2awdDQEPb29hg3bhweP34MAAgPD0dAQACSk5M17xcUFAQg/2EGsbGx6NWrF4yMjGBiYoL+/fsjISFB83xQUBDc3NywZs0aODo6wtTUFAMHDkRqamrZNo2IqBgYZomIytAPP/wAT09PjBo1CvHx8YiPj4e9vT2SkpLw+uuvo0WLFjh69Ch27tyJhIQE9O/fP8/rV69eDaVSiQMHDmDp0qUAALlcjoULF+LcuXNYvXo19uzZg6lTpwIA2rVrhwULFsDExETzfh9++GG+utRqNXr16oWHDx8iIiICoaGhuH79OgYMGJBn3LVr17BlyxZs374d27dvR0REBL755psy6hYRUfHxMAMiojJkamoKpVIJAwMD2NjYaKb/+OOPaNGiBb7++mvNtBUrVsDe3h6XL19Gw4YNAQANGjTAt99+m2eezx9/6+joiK+++gpjxozBTz/9BKVSCVNTU8hksjzv96KwsDCcOXMGN27cgL29PQDgt99+Q5MmTXDkyBG0bt0awLPQu2rVKhgbGwMAhg4dirCwMMyePfvVGkNEVEq4Z5aISAKnTp3C3r17YWRkpPlxdnYG8GxvaC53d/d8r929ezc6duwIOzs7GBsbY+jQoXjw4AHS09OL/P4XLlyAvb29JsgCgIuLC8zMzHDhwgXNNEdHR02QBQBbW1skJiYW67MSEZUl7pklIpLA48eP0aNHD8ydOzffc7a2tpr/NzQ0zPNcTEwMunfvjrFjx2L27NkwNzdHZGQk3nnnHWRlZcHAwKBU69TV1c3zWCaTQa1Wl+p7EBG9CoZZIqIyplQqkZOTk2day5Yt8ffff8PR0RE6OkXfFB87dgxqtRrz5s2DXP7sj2sbNmwo9P1e1LhxY9y6dQu3bt3S7J09f/48kpKS4OLiUuR6iIikxsMMiIjKmKOjIw4dOoSYmBjcv38farUa48ePx8OHDzFo0CAcOXIE165dw65duxAQEKA1iNavXx/Z2dlYtGgRrl+/jjVr1mhODHv+/R4/foywsDDcv3+/wMMP/Pz80KxZMwwZMgTHjx/H4cOHMWzYMPj6+qJVq1al3gMiorLCMEtEVMY+/PBDKBQKuLi4wNLSErGxsahVqxYOHDiAnJwcdOrUCc2aNcOkSZNgZmam2eNaEFdXVwQHB2Pu3Llo2rQp/vjjD8yZMyfPmHbt2mHMmDEYMGAALC0t851ABjw7XGDr1q2oUaMGfHx84Ofnh3r16mH9+vWl/vmJiMqSTAghpC6CiIiIiKgkuGeWiIiIiCothlkiIiIiqrQYZomIiIio0mKYJSIiIqJKi2GWiIiIiCothlkiIiIiqrQYZomIiIio0mKYJSIiIqJKi2GWiIiIiCothlkiIiIiqrQYZomIiIio0vo/IjLU4coSExsAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 1 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### ' test_elasticnet_fit_predict_synthetic '\n", + "id": "70d2dd0270526756" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-11T03:40:34.612965Z", + "start_time": "2024-10-11T03:40:34.527355Z" + } + }, + "cell_type": "code", + "source": [ + "# Loss values for test_elasticnet_fit_predict_synthetic\n", + "iterations_synthetic = [1, 11]\n", + "loss_synthetic = [0.2480363628013885, 0.15761366407585842]\n", + "\n", + "plt.figure(figsize=(8, 5))\n", + "plt.plot(iterations_synthetic, loss_synthetic, marker='o', linestyle='-', color='green')\n", + "plt.title('Loss Over Iterations: test_elasticnet_fit_predict_synthetic')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Loss')\n", + "plt.grid(True)\n", + "plt.show()" + ], + "id": "f45e48d4ad5674fa", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 2 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### 'test_zero_variance_feature_small_test' ", + "id": "e1680295c6c1ac9a" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-11T03:40:43.271085Z", + "start_time": "2024-10-11T03:40:43.141246Z" + } + }, + "cell_type": "code", + "source": [ + "# Loss values for test_zero_variance_feature_small_test\n", + "iterations_zero_var_small = list(range(1, 3844, 100)) + [3843]\n", + "loss_zero_var_small = [\n", + " 0.8094484113101857,\n", + " 0.11348791098790559,\n", + " 0.11348833040128285,\n", + " 0.11348933734133358,\n", + " 0.11349012136059657,\n", + " 0.11349073179829143,\n", + " 0.11349120707945204,\n", + " 0.11349157712542976,\n", + " 0.11349186523489808,\n", + " 0.11349208954913978,\n", + " 0.11349226419335218,\n", + " 0.11349240016551848,\n", + " 0.11349250602862732,\n", + " 0.11349258844971517,\n", + " 0.11349265261960868,\n", + " 0.11349270257975852,\n", + " 0.11349274147672275,\n", + " 0.1134927717603117,\n", + " 0.11349279533786372,\n", + " 0.11349281369436352,\n", + " 0.11349282798596429,\n", + " 0.11349283911280197,\n", + " 0.11349284777568662,\n", + " 0.11349285452024059,\n", + " 0.11349285977126307,\n", + " 0.1134928638594851,\n", + " 0.11349286704240008,\n", + " 0.11349286952048149,\n", + " 0.11349287144980956,\n", + " 0.11349287295190173,\n", + " 0.11349287412136627,\n", + " 0.1134928750318612,\n", + " 0.1134928757407335,\n", + " 0.11349287629263102,\n", + " 0.11349287672231476,\n", + " 0.11349287705684807,\n", + " 0.11349287731730132,\n", + " 0.11349287752007904,\n", + " 0.11349287767795309,\n", + " 0.11349287873143073\n", + "]\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(iterations_zero_var_small, loss_zero_var_small, marker='x', linestyle='-', color='red')\n", + "plt.title('Loss Over Iterations: test_zero_variance_feature_small_test')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Loss')\n", + "plt.grid(True)\n", + "plt.show()" + ], + "id": "a29ab08980af905e", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAIjCAYAAADxz9EgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABkGElEQVR4nO3de1wVdf7H8TcgHEBENAUUSbxUpnkpXA3NS3nLyrK2tGxTabOL+kuXyrKL18rM1mxby26m23bxspVtF5NQrNS0NEutLM1LpeItQUQBOd/fH+w5eQQU9DBnBl/Px4MHnDlz5nzmM8PI25n5niBjjBEAAAAAwC+CA10AAAAAAFQlhCwAAAAA8CNCFgAAAAD4ESELAAAAAPyIkAUAAAAAfkTIAgAAAAA/ImQBAAAAgB8RsgAAAADAjwhZAAAAAOBHhCwAqKCtW7cqKChIs2bNCnQpOEMkJSVp8ODBgS7Dr44ePapRo0YpMTFRwcHB6tu3b6BLwv/MmjVLQUFB2rp1q3da165d1bVr14DVBDgNIQsoB88/OF999VWgSymXZcuW6dprr1VcXJxcLpeSkpJ0xx13aPv27YEurYTMzEwFBQVp/vz53mnLly/XuHHjdODAgcAVJumNN97QtGnTAlqDv+zYsUPjxo3T2rVrK/V9qlLPULlmzpypKVOm6Prrr9fs2bP1t7/9rVLeh30ycJ577rlK/8+o7777TuPGjfMJhIAdELKAKubZZ59Vp06dtG7dOv3f//2fnnvuOV1//fWaM2eOWrVqpeXLlwe6xJNavny5xo8fb9uQ1bBhQx0+fFi33HKL9UWdoh07dmj8+PGELIfauHGjXnrppUCX4VeLFy9WQkKCnn76ad1yyy3q0qVLpbwP+2TgWBWyxo8fT8iC7VQLdAEA/GfZsmUaOXKkLrnkEi1cuFCRkZHe5+666y517NhR119/vTZs2KBatWpZVtehQ4dUvXp1y96vLHl5eT49OVVBQUEKDw/3Q0WwijFGR44cUURERKBLKbdja3a5XIEux+92796tmJiYQJdxyvx1PAFQNXEmC/Cjr7/+Wr1791Z0dLSioqLUrVs3ffHFFz7zFBYWavz48TrnnHMUHh6us846S5dcconS09O98+zatUupqalq0KCBXC6X6tWrp2uuueak/1M3ceJEBQUFafbs2SX+8W/SpImefPJJ7dy5Uy+88IIk6amnnlJQUJC2bdtWYlmjR49WWFiYfv/9d++0lStX6vLLL1fNmjUVGRmpLl26aNmyZT6vGzdunIKCgvTdd99pwIABqlWrli655JJy9c/z+vvuu0+S1KhRIwUFBZW4N+Df//63kpOTFRERodq1a+vGG2/UL7/84rOcrl276oILLtDq1avVuXNnRUZG6sEHH5QkLViwQFdeeaXq168vl8ulJk2aaOLEiSoqKvJ5/QcffKBt27Z5a0hKSpJU9j1ZixcvVqdOnVS9enXFxMTommuu0ffff19qfzZt2qTBgwcrJiZGNWvWVGpqqvLy8nzmTU9P1yWXXKKYmBhFRUXpvPPO866Dx/bt2/XDDz+csKeZmZn605/+JElKTU31rs+x9Zdn2x48eFAjR45UUlKSXC6XYmNj1aNHD61Zs+akPTsZT19K+zr2XiS3261p06apRYsWCg8PV1xcnO644w6f/VQqvofpqquu0scff6y2bdsqIiLCu9///PPPuuGGG1S7dm1FRkbq4osv1gcffFCuOj2uuuoqNW7cuNTnUlJS1LZtW+/jV199VZdddpliY2PlcrnUvHlzPf/88yVed6Kaj78na//+/br33nvVsmVLRUVFKTo6Wr1799Y333zjs0zP5bhz587VY489pgYNGig8PFzdunXTpk2bStSwcuVKXXHFFapVq5aqV6+uVq1a6ZlnnvGZ54cfftD111+v2rVrKzw8XG3bttV7771X7t55fn+WLFmiDRs2eLdzZmampPJv49P9PS7tvqNje+apx7Ocso4n+fn5Gjt2rJo2bSqXy6XExESNGjVK+fn55e6JVL7jvmcfyczM9O4jLVu29Nb69ttvq2XLlgoPD1dycrK+/vprn/f49ttvNXjwYDVu3Fjh4eGKj4/Xrbfeqn379lWo1vJISkrShg0btHTpUm/vj72n68CBAxo5cqQSExPlcrnUtGlTTZ48WW6322c5b731lpKTk1WjRg1FR0erZcuW3n1y1qxZuuGGGyRJl156aYl9CQgkzmQBfrJhwwZ16tRJ0dHRGjVqlEJDQ/XCCy+oa9euWrp0qdq3by+p+I/JSZMm6bbbblO7du2Uk5Ojr776SmvWrFGPHj0kSX/+85+1YcMG/d///Z+SkpK0e/dupaena/v27WX+0ZqXl6eMjAx16tRJjRo1KnWe/v376/bbb9f777+vBx54QP369dOoUaM0d+5cb7DxmDt3rnr27Ok947V48WL17t1bycnJGjt2rIKDg71/PH722Wdq166dz+tvuOEGnXPOOXr88cdljCl3H6+77jr9+OOPevPNN/X000+rTp06kqS6detKkh577DE98sgj6tevn2677Tbt2bNHzz77rDp37qyvv/7a53/G9+3bp969e+vGG2/UX/7yF8XFxUkq/oc5KipKaWlpioqK0uLFizVmzBjl5ORoypQpkqSHHnpI2dnZ+vXXX/X0009LkqKiosqs+5NPPlHv3r3VuHFjjRs3TocPH9azzz6rjh07as2aNSW2W79+/dSoUSNNmjRJa9as0csvv6zY2FhNnjxZUvH+dNVVV6lVq1aaMGGCXC6XNm3aVCL4DBw4UEuXLj1hj88//3xNmDBBY8aM0e23365OnTpJkjp06CCp/Nv2zjvv1Pz58zV8+HA1b95c+/bt0+eff67vv/9eF110UYV7dqzrrrtOTZs29Zm2evVqTZs2TbGxsd5pd9xxh2bNmqXU1FTdfffd2rJli/75z3/q66+/1rJlyxQaGuqdd+PGjbrpppt0xx13aMiQITrvvPOUlZWlDh06KC8vT3fffbfOOusszZ49W1dffbXmz5+va6+9tlz19u/fXwMHDtSXX37pDbCStG3bNn3xxRfe/UiSnn/+ebVo0UJXX321qlWrpv/+978aOnSo3G63hg0b5rPc0mouzc8//6x3331XN9xwgxo1aqSsrCy98MIL6tKli7777jvVr1/fZ/4nnnhCwcHBuvfee5Wdna0nn3xSN998s1auXOmdJz09XVdddZXq1aunESNGKD4+Xt9//73ef/99jRgxQlLxftmxY0clJCTogQceUPXq1TV37lz17dtX//nPf8rVv7p16+q1117TY489ptzcXE2aNElS8X4qlX8bV8bv8YmUdjxxu926+uqr9fnnn+v222/X+eefr3Xr1unpp5/Wjz/+qHfffbfcyy/vcX/Tpk0aMGCA7rjjDv3lL3/RU089pT59+mjGjBl68MEHNXToUEnSpEmT1K9fP23cuFHBwcX/p56enq6ff/5Zqampio+P14YNG/Tiiy9qw4YN+uKLLxQUFHRKvSnNtGnT9H//93+KiorSQw89JEneY3BeXp66dOmi3377TXfccYfOPvtsLV++XKNHj9bOnTu9l3emp6frpptuUrdu3bzHxu+//17Lli3TiBEj1LlzZ9199936xz/+oQcffNC7D3m+AwFlAJzUq6++aiSZL7/8ssx5+vbta8LCwszmzZu903bs2GFq1KhhOnfu7J3WunVrc+WVV5a5nN9//91IMlOmTKlQjWvXrjWSzIgRI044X6tWrUzt2rW9j1NSUkxycrLPPKtWrTKSzL/+9S9jjDFut9ucc845plevXsbtdnvny8vLM40aNTI9evTwThs7dqyRZG666aZy1b1kyRIjycybN887bcqUKUaS2bJli8+8W7duNSEhIeaxxx7zmb5u3TpTrVo1n+ldunQxksyMGTNKvGdeXl6JaXfccYeJjIw0R44c8U678sorTcOGDUvMu2XLFiPJvPrqq95pbdq0MbGxsWbfvn3ead98840JDg42AwcO9E7z9OfWW2/1Wea1115rzjrrLO/jp59+2kgye/bsKfH+x/Ks58l8+eWXJWo2pmLbtmbNmmbYsGEnfJ+yelZRe/bsMWeffbZp2bKlyc3NNcYY89lnnxlJ5vXXX/eZd+HChSWmN2zY0EgyCxcu9Jl35MiRRpL57LPPvNMOHjxoGjVqZJKSkkxRUVG56svOzjYul8vcc889PtOffPJJExQUZLZt2+adVtr+1qtXL9O4cWOfaWXV7Hlu0KBB3sdHjhwpUeuWLVuMy+UyEyZM8E7z/H6df/75Jj8/3zv9mWeeMZLMunXrjDHGHD161DRq1Mg0bNjQ/P777z7LPXa/6Natm2nZsqXP74nb7TYdOnQw55xzTom6T6RLly6mRYsWPtMqso1P9/fYc1w//jjj6dmSJUt8ai3tePLaa6+Z4OBgn/3JGGNmzJhhJJlly5aVuu7HK+9x37OPLF++3Dvt448/NpJMRESEz373wgsvlFiP0nr25ptvGknm008/9U4rrTddunQxXbp0Kdf6eLRo0aLU10ycONFUr17d/Pjjjz7TH3jgARMSEmK2b99ujDFmxIgRJjo62hw9erTM95g3b16J9QTsgMsFAT8oKirSokWL1LdvX59LiOrVq6cBAwbo888/V05OjiQpJiZGGzZs0E8//VTqsiIiIhQWFqbMzMwSl8ecyMGDByVJNWrUOOF8NWrU8NYiFf+P/OrVq7V582bvtDlz5sjlcumaa66RJK1du1Y//fSTBgwYoH379mnv3r3au3evDh06pG7duunTTz8tcYnHnXfeWe7ay+vtt9+W2+1Wv379vDXs3btX8fHxOuecc7RkyRKf+V0ul1JTU0ss59j7cg4ePKi9e/eqU6dOysvLO+mld6XZuXOn1q5dq8GDB6t27dre6a1atVKPHj304YcflnjN8f3p1KmT9u3b57OfSMWXRB3f22NlZmZW6Ezh8SqybWNiYrRy5Urt2LHjlN+vPIqKinTTTTfp4MGDeuedd7z3882bN081a9ZUjx49fLZ/cnKyoqKiSmz/Ro0aqVevXj7TPvzwQ7Vr187nEtaoqCjdfvvt2rp1q7777rty1ei5PG/u3Lk+/Z8zZ44uvvhinX322d5px+5v2dnZ2rt3r7p06aKff/5Z2dnZJ625NC6Xy3t2oqioSPv27fNeUuq5fPNYqampCgsL8z72nM38+eefJRVf6rxlyxaNHDmyxH1SnrMb+/fv1+LFi9WvXz/v783evXu1b98+9erVSz/99JN+++23k9Z+IhXZxv7+PT6Z0o4n8+bN0/nnn69mzZr51HvZZZdJUol9siwVOe43b95cKSkp3seeqyQuu+wyn/3OM92zjT3v43HkyBHt3btXF198sSSVut9Ulnnz5qlTp06qVauWT9+6d++uoqIiffrpp5KKjzmHDh3yuZwecApCFuAHe/bsUV5eXqmX9px//vlyu93ee4YmTJigAwcO6Nxzz1XLli1133336dtvv/XO73K5NHnyZH300UeKi4tT586d9eSTT2rXrl0nrMETrjxhqywHDx70CWI33HCDgoODNWfOHEnFN9vPmzfPe2+ZJG8gHDRokOrWrevz9fLLLys/P7/UPxb97aeffpIxRuecc06JOr7//nvt3r3bZ/6EhASfPyw9NmzYoGuvvVY1a9ZUdHS06tatq7/85S+SVGI9ysNzT1tZ298TWo517B9DkryXZXr+wOrfv786duyo2267TXFxcbrxxhs1d+7cEwauU1GRbfvkk09q/fr1SkxMVLt27TRu3DifP+D85eGHH9bixYv1xhtvqEmTJj61ZmdnKzY2tkStubm5JbZ/afvgtm3bytxOnufLq3///vrll1+0YsUKSdLmzZu1evVq9e/f32e+ZcuWqXv37t579erWreu9n+dUf2/cbreefvppnXPOOXK5XKpTp47q1q2rb7/9ttR9+GT7m+c/WS644IIy33PTpk0yxuiRRx4p0f+xY8dKUoltUFEV2cb+/j0+mdKOJz/99JM2bNhQotZzzz1XUvn7UZHj/vHbsmbNmpKkxMTEUqcfG9r279+vESNGKC4uThEREapbt653n6uMnpXlp59+0sKFC0v0rXv37pL+6NvQoUN17rnnqnfv3mrQoIFuvfVWLVy40LI6gdPBPVmAxTp37qzNmzdrwYIFWrRokV5++WU9/fTTmjFjhm677TZJ0siRI9WnTx+9++67+vjjj/XII49o0qRJWrx4sS688MJSl9u0aVNVq1bNJ7AdLz8/Xxs3bvS5Kb9+/frq1KmT5s6dqwcffFBffPGFtm/f7r3+XZL3D/spU6aoTZs2pS77+PscKmMUN7fbraCgIH300UcKCQk5pRoOHDigLl26KDo6WhMmTFCTJk0UHh6uNWvW6P777/d7iClLafVL8p4ViYiI0KeffqolS5bogw8+0MKFCzVnzhxddtllWrRoUZmvr6iKbNt+/fqpU6dOeuedd7Ro0SJNmTJFkydP1ttvv63evXv7pZ53331XkydP1sSJE3X55ZeXqDU2Nlavv/56qa/13LfnUdkjCfbp00eRkZGaO3euOnTooLlz5yo4ONh7I75UHF66deumZs2aaerUqUpMTFRYWJg+/PBDPf300yX2t/LW/Pjjj+uRRx7RrbfeqokTJ6p27doKDg7WyJEjS92HT7a/lYdnuffee2+ZZ9uOv6+uosq7jf3xe1zW/UfHDpxxrNK2jdvtVsuWLTV16tRSX3N88DmR8h73y9qW5dnG/fr10/Lly3XfffepTZs2ioqKktvt1uWXX27ZsU8q7luPHj00atSoUp/3hNTY2FitXbtWH3/8sT766CN99NFHevXVVzVw4EDNnj3bsnqBU0HIAvygbt26ioyM1MaNG0s898MPPyg4ONjnH9vatWsrNTVVqampys3NVefOnTVu3DhvyJKKRwO85557dM899+inn35SmzZt9Pe//13//ve/S62hevXquvTSS7V48WJt27ZNDRs2LDHP3LlzlZ+fr6uuuspnev/+/TV06FBt3LhRc+bMUWRkpPr06eNTi1R8iZTnfxorU1l//DRp0kTGGDVq1Mj7j3BFZWZmat++fXr77bfVuXNn7/QtW7aUu47jeXpd1vavU6fOKQ1hHxwcrG7duqlbt26aOnWqHn/8cT300ENasmRJhbfDiXoqlX/b1qtXT0OHDtXQoUO1e/duXXTRRXrssce8Iet0bpz/8ccfNWjQIPXt27fEKIqeWj/55BN17NjxlANUw4YNy9xOnufLq3r16rrqqqs0b948TZ06VXPmzFGnTp18Bp3473//q/z8fL333ns+ZyDKexlZWebPn69LL71Ur7zyis/0AwcOeAeLqQjPfrB+/foy9wPPpdChoaGVdhwo7zb2x++x52ze8Z/HV5GzmU2aNNE333yjbt26+WXQiIoe9yvi999/V0ZGhsaPH68xY8Z4p5d16bo/nOi4k5ubW679KCwsTH369FGfPn3kdrs1dOhQvfDCC3rkkUfUtGlTvw7WAfgTlwsCfhASEqKePXtqwYIFPsPtZmVl6Y033tAll1zivfTu+KFyo6Ki1LRpU+9wv3l5eTpy5IjPPE2aNFGNGjVOOiTwww8/LGOMBg8erMOHD/s8t2XLFo0aNUr16tXTHXfc4fPcn//8Z4WEhOjNN9/UvHnzdNVVV/mEguTkZDVp0kRPPfWUcnNzS7zvnj17TlhXRXne+/g/fq677jqFhIRo/PjxJf4H3hhTrmGIPf/be+zrCwoK9Nxzz5VaR3kuoalXr57atGmj2bNn+9S8fv16LVq0SFdcccVJl3G8/fv3l5jmOdN07H5QniHcpbJ7Wt5tW1RUVKIXsbGxql+/vk895e3Z8XJzc3XttdcqISFBs2fPLvUPp379+qmoqEgTJ04s8dzRo0fL9eHVV1xxhVatWuW9xE8q/hy3F198UUlJSWrevHmF6u7fv7927Nihl19+Wd98802JSwVL29+ys7P16quvVuh9jhcSElLid2DevHmnfE/URRddpEaNGmnatGkl+uh5n9jYWHXt2lUvvPCCdu7cWWIZ/jgOlHcb++P32BMsPff/SMX7+Ysvvlihen/77bdSPyj68OHDJS4TLsvpHPfLq7SeSarUD2quXr16qb+X/fr104oVK/Txxx+XeO7AgQM6evSopJL/XgYHB6tVq1aS/jgOlnVsAwKNM1lABcycObPU68FHjBihRx991Pu5RkOHDlW1atX0wgsvKD8/X08++aR33ubNm6tr165KTk5W7dq19dVXX3mHxZaK/ze/W7du6tevn5o3b65q1arpnXfeUVZWlm688cYT1te5c2c99dRTSktLU6tWrTR48GDVq1dPP/zwg1566SW53W59+OGHJT6IODY2VpdeeqmmTp2qgwcPlvhDMTg4WC+//LJ69+6tFi1aKDU1VQkJCfrtt9+0ZMkSRUdH67///e+ptrWE5ORkScXDL994440KDQ1Vnz591KRJEz366KMaPXq0tm7dqr59+6pGjRrasmWL3nnnHd1+++269957T7jsDh06qFatWho0aJDuvvtuBQUF6bXXXiv1sqnk5GTNmTNHaWlp+tOf/qSoqCifM3zHmjJlinr37q2UlBT99a9/9Q7hXrNmTY0bN67CPZgwYYI+/fRTXXnllWrYsKF2796t5557Tg0aNPAZtKE8Q7hLxX+wxcTEaMaMGapRo4aqV6+u9u3bq1GjRuXatgcPHlSDBg10/fXXq3Xr1oqKitInn3yiL7/8Un//+99PqWfHGj9+vL777js9/PDDWrBgQYnaU1JS1KVLF91xxx2aNGmS1q5dq549eyo0NFQ//fST5s2bp2eeeUbXX3/9Cd/ngQce0JtvvqnevXvr7rvvVu3atTV79mxt2bJF//nPf7yDSZTXFVdcoRo1aujee+9VSEiI/vznP/s837NnT+//xN9xxx3Kzc3VSy+9pNjY2FKDSnldddVVmjBhglJTU9WhQwetW7dOr7/+epmf3XUywcHBev7559WnTx+1adNGqamp3mPHhg0bvH8MT58+XZdccolatmypIUOGqHHjxsrKytKKFSv066+/lvicrooq7zb2x+9xixYtdPHFF2v06NHav3+/ateurbfeesv7B3553HLLLZo7d67uvPNOLVmyRB07dlRRUZF++OEHzZ071/uZZydzOsf98oqOjvbe61VYWKiEhAQtWrSo1LN//pKcnKznn39ejz76qJo2barY2Fhddtlluu+++/Tee+/pqquu0uDBg5WcnKxDhw5p3bp1mj9/vrZu3ao6derotttu0/79+3XZZZepQYMG2rZtm5599lm1adPGex9lmzZtFBISosmTJys7O1sul8v7uXRAQFk6liHgUJ7hbMv6+uWXX4wxxqxZs8b06tXLREVFmcjISHPppZf6DLVrjDGPPvqoadeunYmJiTERERGmWbNm5rHHHjMFBQXGGGP27t1rhg0bZpo1a2aqV69uatasadq3b2/mzp1b7no//fRTc80115g6deqY0NBQc/bZZ5shQ4aYrVu3lvmal156yUgyNWrUMIcPHy51nq+//tpcd9115qyzzjIul8s0bNjQ9OvXz2RkZHjn8QxRfrKhxz1KG8LdmOIhfhMSEkxwcHCJoYT/85//mEsuucRUr17dVK9e3TRr1swMGzbMbNy40TtPacNDeyxbtsxcfPHFJiIiwtSvX9+MGjXKOwzyscMA5+bmmgEDBpiYmBgjyTsMdGlDuBtjzCeffGI6duxoIiIiTHR0tOnTp4/57rvvfOYpqz/HD5mckZFhrrnmGlO/fn0TFhZm6tevb2666aYSQx6Xdwh3Y4xZsGCBad68ualWrVqJ+k+2bfPz8819991nWrdubWrUqGGqV69uWrdubZ577jmf9yirZyczaNCgMn+/jh263BhjXnzxRZOcnGwiIiJMjRo1TMuWLc2oUaPMjh07vPM0bNiwzI9K2Lx5s7n++utNTEyMCQ8PN+3atTPvv/9+ueoszc0332wkme7du5f6/HvvvWdatWplwsPDTVJSkpk8ebKZOXNmif36RDWXNoT7PffcY+rVq2ciIiJMx44dzYoVK0oMs13W71dZ+/Dnn39uevTo4d3GrVq1Ms8++6zPPJs3bzYDBw408fHxJjQ01CQkJJirrrrKzJ8//+TNOsaJfkfLs41P9/fYsy7du3c3LpfLxMXFmQcffNCkp6eXOoR7WbUWFBSYyZMnmxYtWhiXy2Vq1aplkpOTzfjx4012dna5elHe435Z+4ikEh+v4NnGxw4L/+uvv5prr73WxMTEmJo1a5obbrjB7Nixw0gyY8eO9c7nryHcd+3aZa688kpTo0YNI8nn9QcPHjSjR482TZs2NWFhYaZOnTqmQ4cO5qmnnvL+ezh//nzTs2dPExsba8LCwszZZ59t7rjjDrNz506f93nppZdM48aNTUhICMO5wzaCjDmNsX8BAAAAAD64JwsAAAAA/Ih7sgAAlWrPnj1lDostFY8eduyHOAea0+q1m5N9pl9ERIT3M5zOBNnZ2SUGIjpefHy8RdX4B78jwMlxuSAAoFIlJSWdcFjsLl26KDMz07qCTsJp9drNyYbUHjRokGbNmmVNMTYwePDgk36mk9P+FON3BDg5zmQBACrV66+/fsL/yT9+tMtAc1q9dpOenn7C54/9HLEzwahRo/SXv/wl0GX4Fb8jwMlxJgsAAAAA/IiBLwAAAADAj864ywXdbrd27NihGjVqnPS6cQAAAABVlzFGBw8eVP369Sv8gfQncsaFrB07digxMTHQZQAAAACwiV9++UUNGjTw2/LOuJBVo0YNScWNjI6ODmgthYWFWrRokXr27KnQ0NCA1nImoN/Wot/WodfWot/Wot/WodfWot/WKqvfOTk5SkxM9GYEfznjQpbnEsHo6GhbhKzIyEhFR0fzy2UB+m0t+m0dem0t+m0t+m0dem0t+m2tk/Xb37cRMfAFAAAAAPgRIQsAAAAA/IiQBQAAAAB+RMgCAAAAAD8iZAEAAACAHxGyAAAAAMCPCFkAAAAA4EeELAAAAADwI0IWAAAAAPgRIQsAAAAA/IiQBQAAAAB+RMgCAAAAAD8iZAEAAACAHxGyAAAAAMCPCFmBMG6cNHFi6c9NnFj8PAAAAABHImQFQkiINGaMgh97zHf6xInSmDHFzwMAAABwpGqBLuCM9MgjkqSQMWOUfMklUoMG0ocfFgesCRO8zwMAAABwHkJWoDzyiNwffaQGn38u0769VFREwAIAAACqAC4XDCBz6aWSpKCiIiksjIAFAAAAVAGErAAKWrlSkmSCg6WCgrIHwwAAAADgGAEPWdOnT1dSUpLCw8PVvn17rVq16oTzT5s2Teedd54iIiKUmJiov/3tbzpy5IhF1frRxIkKzsiQJJm+fYsvFRwzhqAFAAAAOFxA78maM2eO0tLSNGPGDLVv317Tpk1Tr169tHHjRsXGxpaY/4033tADDzygmTNnqkOHDvrxxx81ePBgBQUFaerUqQFYg1P0v1EEi665RiELFkh5eX9cKjhmTPF3Lh0EAAAAHCmgIWvq1KkaMmSIUlNTJUkzZszQBx98oJkzZ+qBBx4oMf/y5cvVsWNHDRgwQJKUlJSkm266SSv/d9ldafLz85Wfn+99nJOTI0kqLCxUYWGhP1en3IILCqSxY3W0aVOFLFggk5tbXMsDDyi4qEgqKJA7QLVVZZ7tHajtfqah39ah19ai39ai39ah19ai39Yqq9+V1f8gY4yplCWfREFBgSIjIzV//nz17dvXO33QoEE6cOCAFixYUOI1b7zxhoYOHapFixapXbt2+vnnn3XllVfqlltu0YMPPljq+4wbN07jx48vdVmRkZF+W59TEfvVV0p59FEdaNxYS510Jg4AAACoAvLy8jRgwABlZ2crOjrab8sN2JmsvXv3qqioSHFxcT7T4+Li9MMPP5T6mgEDBmjv3r265JJLZIzR0aNHdeedd5YZsCRp9OjRSktL8z7OyclRYmKievbs6ddGnoqi8HBJUnS1arriiisCWsuZoLCwUOnp6erRo4dCQ0MDXU6VR7+tQ6+tRb+tRb+tQ6+tRb+tVVa/PVe5+ZujPicrMzNTjz/+uJ577jm1b99emzZt0ogRIzRx4kQ9UsY9TC6XSy6Xq8T00NDQgO/QQTVrFn/Pywt4LWcSO2z7Mwn9tg69thb9thb9tg69thb9ttbx/a6s3gcsZNWpU0chISHKysrymZ6VlaX4+PhSX/PII4/olltu0W233SZJatmypQ4dOqTbb79dDz30kIKDAz5YYoUYz+WKhw4FthAAAAAAfhOwVBIWFqbk5GRl/G8Yc0lyu93KyMhQSkpKqa/Jy8srEaRCQkIkSQG6tez0REUVfydkAQAAAFVGQC8XTEtL06BBg9S2bVu1a9dO06ZN06FDh7yjDQ4cOFAJCQmaNGmSJKlPnz6aOnWqLrzwQu/lgo888oj69OnjDVuOUr26JCmooEAqLJQ4VQwAAAA4XkBDVv/+/bVnzx6NGTNGu3btUps2bbRw4ULvYBjbt2/3OXP18MMPKygoSA8//LB+++031a1bV3369NFjjz0WqFU4Pf8LWZKKz2bFxASsFAAAAAD+EfCBL4YPH67hw4eX+lxmZqbP42rVqmns2LEaO3asBZVZICxM7uBgBbvdhCwAAACginDWSBFVTVCQdxh37ssCAAAAqgZCVoAVeYaXJ2QBAAAAVQIhK8CORkQU/0DIAgAAAKoEQlaAHfWcycrNDWwhAAAAAPyCkBVg3JMFAAAAVC2ErADjniwAAACgaiFkBdhRzmQBAAAAVQohK8A4kwUAAABULYSsAGN0QQAAAKBqIWQFWBGjCwIAAABVCiErwLgnCwAAAKhaCFkBxj1ZAAAAQNVCyAowPicLAAAAqFoIWQHG5YIAAABA1ULICjBvyGLgCwAAAKBKIGQFGPdkAQAAAFULISvAuCcLAAAAqFoIWQF2lDNZAAAAQJVCyAowzmQBAAAAVQshK8AYXRAAAACoWghZAeY9k1VYKBUUBLYYAAAAAKeNkBVg3nuyJM5mAQAAAFUAISvATGioTLVqxQ8IWQAAAIDjEbLsoHr14u+ELAAAAMDxCFl2QMgCAAAAqgxClh0QsgAAAIAqg5BlB56QlZsb2DoAAAAAnDZClg0YzmQBAAAAVQYhyw4IWQAAAECVQciyg8jI4u+ELAAAAMDxCFl2EBVV/J2QBQAAADgeIcsGDANfAAAAAFUGIcsOuCcLAAAAqDIIWXbAPVkAAABAlUHIsgPOZAEAAABVBiHLDghZAAAAQJVByLIBPowYAAAAqDoIWXbA6IIAAABAlUHIsgPOZAEAAABVBiHLDghZAAAAQJVByLIB7skCAAAAqg5Clh3wOVkAAABAlUHIsoOoqOLvhw5JxgS2FgAAAACnhZBlB57LBY8elQoKAlsLAAAAgNNCyLIDT8iSuGQQAAAAcDhClh2EhhZ/SYQsAAAAwOEIWXbBCIMAAABAlUDIsotjB78AAAAA4FiELLvwnMnKzQ1sHQAAAABOiy1C1vTp05WUlKTw8HC1b99eq1atKnPerl27KigoqMTXlVdeaWHFlYDLBQEAAIAqIeAha86cOUpLS9PYsWO1Zs0atW7dWr169dLu3btLnf/tt9/Wzp07vV/r169XSEiIbrjhBosr9zNCFgAAAFAlBDxkTZ06VUOGDFFqaqqaN2+uGTNmKDIyUjNnzix1/tq1ays+Pt77lZ6ersjISEIWAAAAAFuoFsg3Lygo0OrVqzV69GjvtODgYHXv3l0rVqwo1zJeeeUV3Xjjjap+7GdNHSM/P1/5+fnexzk5OZKkwsJCFRYWnkb1p8/z/oWFhQqJiFCwpKKcHLkDXFdVdWy/Ufnot3XotbXot7Xot3XotbXot7XK6ndl9T/IGGMqZcnlsGPHDiUkJGj58uVKSUnxTh81apSWLl2qlStXnvD1q1atUvv27bVy5Uq1a9eu1HnGjRun8ePHl5j+xhtvKDIy8vRWwI8ufOYZnb1kiTYMHKhN110X6HIAAACAKi8vL08DBgxQdna2oqOj/bbcgJ7JOl2vvPKKWrZsWWbAkqTRo0crLS3N+zgnJ0eJiYnq2bOnXxt5KgoLC5Wenq4ePXrItXChtGSJmjVooHOvuCKgdVVVx/Y71PPhz6g09Ns69Npa9Nta9Ns69Npa9NtaZfXbc5WbvwU0ZNWpU0chISHKysrymZ6VlaX4+PgTvvbQoUN66623NGHChBPO53K55HK5SkwPDQ21zQ4dGhqqkBo1JEkhR44oxCZ1VVV22vZnAvptHXptLfptLfptHXptLfptreP7XVm9D+jAF2FhYUpOTlZGRoZ3mtvtVkZGhs/lg6WZN2+e8vPz9Ze//KWyy7QGA18AAAAAVULALxdMS0vToEGD1LZtW7Vr107Tpk3ToUOHlJqaKkkaOHCgEhISNGnSJJ/XvfLKK+rbt6/OOuusQJTtf4QsAAAAoEoIeMjq37+/9uzZozFjxmjXrl1q06aNFi5cqLi4OEnS9u3bFRzse8Jt48aN+vzzz7Vo0aJAlFw5CFkAAABAlRDwkCVJw4cP1/Dhw0t9LjMzs8S08847TwEcFLFyREUVf8/NDWwdAAAAAE5LwD+MGP/DmSwAAACgSiBk2QUhCwAAAKgSCFl2QcgCAAAAqgRCll0QsgAAAIAqgZBlF56BLwhZAAAAgKMRsuzCcyYrN1eqaiMnAgAAAGcQQpZdeEKW2y3l5we2FgAAAACnjJBlF56QJXHJIAAAAOBghCy7qFZNCgsr/pmQBQAAADgWIctOGGEQAAAAcDxClp0wwiAAAADgeIQsOzl2hEEAAAAAjkTIshMuFwQAAAAcj5BlJ4QsAAAAwPEIWXZCyAIAAAAcj5BlJ4QsAAAAwPEIWXbiGV2QgS8AAAAAxyJk2QlnsgAAAADHI2TZCSELAAAAcDxClp0QsgAAAADHI2TZCSELAAAAcDxClp14Br4gZAEAAACORciyE8+ZLEYXBAAAAByLkGUnXC4IAAAAOB4hy04IWQAAAIDjEbLshJAFAAAAOB4hy04IWQAAAIDjEbLshNEFAQAAAMcjZNnJsaMLGhPYWgAAAACcEkKWnXhCljHSkSOBrQUAAADAKSFk2YknZElcMggAAAA4FCHLTkJCJJer+GdCFgAAAOBIhCy7YYRBAAAAwNEIWXbjGWEwNzewdQAAAAA4JYQsu+FMFgAAAOBohCy7IWQBAAAAjkbIshtCFgAAAOBohCy7IWQBAAAAjkbIshvPwBeELAAAAMCRCFl24zmTxeiCAAAAgCMRsuyGywUBAAAARyNk2Q0hCwAAAHA0QpbdELIAAAAARyNk2Q0hCwAAAHA0QpbdMLogAAAA4GiELLthdEEAAADA0QhZdsPlggAAAICjEbLshpAFAAAAOBohy24IWQAAAICjBTxkTZ8+XUlJSQoPD1f79u21atWqE85/4MABDRs2TPXq1ZPL5dK5556rDz/80KJqLcDAFwAAAICjVQvkm8+ZM0dpaWmaMWOG2rdvr2nTpqlXr17auHGjYmNjS8xfUFCgHj16KDY2VvPnz1dCQoK2bdummJgY64uvLAx8AQAAADhaQEPW1KlTNWTIEKWmpkqSZsyYoQ8++EAzZ87UAw88UGL+mTNnav/+/Vq+fLlCQ0MlSUlJSVaWXPk8ISsvTzJGCgoKbD0AAAAAKiRgIaugoECrV6/W6NGjvdOCg4PVvXt3rVixotTXvPfee0pJSdGwYcO0YMEC1a1bVwMGDND999+vkJCQUl+Tn5+v/Px87+OcnBxJUmFhoQoLC/24RhXneX+fOsLCFCpJxqgwJ0eKjAxIbVVRqf1GpaHf1qHX1qLf1qLf1qHX1qLf1iqr35XV/yBjjKmUJZ/Ejh07lJCQoOXLlyslJcU7fdSoUVq6dKlWrlxZ4jXNmjXT1q1bdfPNN2vo0KHatGmThg4dqrvvvltjx44t9X3GjRun8ePHl5j+xhtvKNKOAaaoSNf8+c+SpI9mz1ZBzZoBLggAAAComvLy8jRgwABlZ2crOjrab8sN6OWCFeV2uxUbG6sXX3xRISEhSk5O1m+//aYpU6aUGbJGjx6ttLQ07+OcnBwlJiaqZ8+efm3kqSgsLFR6erp69OjhvfxRkkx4uIKOHFH3lBSpql0OGUBl9RuVg35bh15bi35bi35bh15bi35bq6x+e65y87eAhaw6deooJCREWVlZPtOzsrIUHx9f6mvq1aun0NBQn0sDzz//fO3atUsFBQUKCwsr8RqXyyWXy1ViemhoqG126BK1REVJR44otKBAskmNVYmdtv2ZgH5bh15bi35bi35bh15bi35b6/h+V1bvAzaEe1hYmJKTk5WRkeGd5na7lZGR4XP54LE6duyoTZs2ye12e6f9+OOPqlevXqkBy7EYYRAAAABwrIB+TlZaWppeeuklzZ49W99//73uuusuHTp0yDva4MCBA30Gxrjrrru0f/9+jRgxQj/++KM++OADPf744xo2bFigVqFy8IHEAAAAgGMF9J6s/v37a8+ePRozZox27dqlNm3aaOHChYqLi5Mkbd++XcHBf+TAxMREffzxx/rb3/6mVq1aKSEhQSNGjND9998fqFWoHIQsAAAAwLECPvDF8OHDNXz48FKfy8zMLDEtJSVFX3zxRSVXFWCELAAAAMCxAnq5IMpAyAIAAAAci5BlR1FRxd8Z+AIAAABwHEKWHXEmCwAAAHAsQpYdEbIAAAAAxyJk2REhCwAAAHAsQpYdEbIAAAAAxyJk2ZFn4AtCFgAAAOA4hCw78pzJYnRBAAAAwHEIWXbE5YIAAACAYxGy7IiQBQAAADgWIcuOCFkAAACAYxGy7IiQBQAAADgWIcuOGF0QAAAAcCxClh0xuiAAAADgWIQsO/KErLw8ye0ObC0AAAAAKoSQZUeekCVJhw8Hrg4AAAAAFUbIsqPIyD9+5r4sAAAAwFEIWXYUHCxFRBT/TMgCAAAAHIWQZVeeEQYZ/AIAAABwFEKWXfFZWQAAAIAjEbLsipAFAAAAOBIhy64IWQAAAIAjEbLsipAFAAAAOBIhy648A18QsgAAAABHIWTZledMFqMLAgAAAI5CyLIrLhcEAAAAHImQZVeELAAAAMCRCFl2RcgCAAAAHImQZVeELAAAAMCRCFl2xeiCAAAAgCMRsuyK0QUBAAAARyJk2RWXCwIAAACORMiyK0IWAAAA4EiELLsiZAEAAACORMiyK0IWAAAA4EiELLvyjC7IwBcAAACAoxCy7IozWQAAAIAjEbLsyhOyDh+W3O7A1gIAAACg3AhZduUJWZKUlxe4OgAAAABUCCHLriIi/viZSwYBAAAAxyBk2VVwMPdlAQAAAA5EyLIzT8hihEEAAADAMQhZdsaZLAAAAMBxCFl2RsgCAAAAHIeQZWeELAAAAMBxCFl2RsgCAAAAHIeQZWdRUcXfCVkAAACAYxCy7IzRBQEAAADHIWTZGZcLAgAAAI5DyLIzQhYAAADgOLYIWdOnT1dSUpLCw8PVvn17rVq1qsx5Z82apaCgIJ+v8PBwC6u1ECELAAAAcJyAh6w5c+YoLS1NY8eO1Zo1a9S6dWv16tVLu3fvLvM10dHR2rlzp/dr27ZtFlZsIUIWAAAA4DjVAl3A1KlTNWTIEKWmpkqSZsyYoQ8++EAzZ87UAw88UOprgoKCFB8fX67l5+fnKz8/3/s4JydHklRYWKjCwsLTrP70eN6/rDqCIyIUIsmdk6OiANdaFZys3/Av+m0dem0t+m0t+m0dem0t+m2tsvpdWf0PMsaYSllyORQUFCgyMlLz589X3759vdMHDRqkAwcOaMGCBSVeM2vWLN12221KSEiQ2+3WRRddpMcff1wtWrQo9T3GjRun8ePHl5j+xhtvKDIy0m/rUhnOTk/XhdOna1fbtlr58MOBLgcAAACoUvLy8jRgwABlZ2crOjrab8sN6JmsvXv3qqioSHFxcT7T4+Li9MMPP5T6mvPOO08zZ85Uq1atlJ2draeeekodOnTQhg0b1KBBgxLzjx49Wmlpad7HOTk5SkxMVM+ePf3ayFNRWFio9PR09ejRQ6GhoSWeDzp4UJo+XbHVq+uKK64IQIVVy8n6Df+i39ah19ai39ai39ah19ai39Yqq9+eq9z8LeCXC1ZUSkqKUlJSvI87dOig888/Xy+88IImTpxYYn6XyyWXy1ViemhoqG126DJrqVlTkhScl6dgm9RaFdhp258J6Ld16LW16Le16Ld16LW16Le1ju93ZfU+oANf1KlTRyEhIcrKyvKZnpWVVe57rkJDQ3XhhRdq06ZNlVFiYDHwBQAAAOA4AQ1ZYWFhSk5OVkZGhnea2+1WRkaGz9mqEykqKtK6detUr169yiozcKKiir8TsgAAAADHCPjlgmlpaRo0aJDatm2rdu3aadq0aTp06JB3tMGBAwcqISFBkyZNkiRNmDBBF198sZo2baoDBw5oypQp2rZtm2677bZArkbl8JzJys0NbB0AAAAAyi3gIat///7as2ePxowZo127dqlNmzZauHChdzCM7du3Kzj4jxNuv//+u4YMGaJdu3apVq1aSk5O1vLly9W8efNArULl4XJBAAAAwHECHrIkafjw4Ro+fHipz2VmZvo8fvrpp/X0009bUJUNeELWkSNSUZEUEhLYegAAAACcVEDvycJJeEKWJOXlBa4OAAAAAOVGyLKziAgpKKj4Zy4ZBAAAAByBkGVnQUEMfgEAAAA4DCHL7hj8AgAAAHCUUwpZv/zyi3799Vfv41WrVmnkyJF68cUX/VYY/oeQBQAAADjKKYWsAQMGaMmSJZKkXbt2qUePHlq1apUeeughTZgwwa8FnvEIWQAAAICjnFLIWr9+vdq1aydJmjt3ri644AItX75cr7/+umbNmuXP+kDIAgAAABzllEJWYWGhXC6XJOmTTz7R1VdfLUlq1qyZdu7c6b/qQMgCAAAAHOaUQlaLFi00Y8YMffbZZ0pPT9fll18uSdqxY4fOOussvxZ4xouKKv7O6IIAAACAI5xSyJo8ebJeeOEFde3aVTfddJNat24tSXrvvfe8lxHCTziTBQAAADhKtVN5UdeuXbV3717l5OSoVq1a3um33367IiMj/VYcRMgCAAAAHOaUzmQdPnxY+fn53oC1bds2TZs2TRs3blRsbKxfCzzjEbIAAAAARzmlkHXNNdfoX//6lyTpwIEDat++vf7+97+rb9++ev755/1a4BmPkAUAAAA4yimFrDVr1qhTp06SpPnz5ysuLk7btm3Tv/71L/3jH//wa4FnPM/AF4QsAAAAwBFOKWTl5eWpRo0akqRFixbpuuuuU3BwsC6++GJt27bNrwWe8TxnshhdEAAAAHCEUwpZTZs21bvvvqtffvlFH3/8sXr27ClJ2r17t6Kjo/1a4BmPywUBAAAARzmlkDVmzBjde++9SkpKUrt27ZSSkiKp+KzWhRde6NcCz3iELAAAAMBRTmkI9+uvv16XXHKJdu7c6f2MLEnq1q2brr32Wr8VBxGyAAAAAIc5pZAlSfHx8YqPj9evv/4qSWrQoAEfRFwZCFkAAACAo5zS5YJut1sTJkxQzZo11bBhQzVs2FAxMTGaOHGi3G63v2s8s3lGF2TgCwAAAMARTulM1kMPPaRXXnlFTzzxhDp27ChJ+vzzzzVu3DgdOXJEjz32mF+LPKNxJgsAAABwlFMKWbNnz9bLL7+sq6++2jutVatWSkhI0NChQwlZ/kTIAgAAABzllC4X3L9/v5o1a1ZierNmzbR///7TLgrH8ISs/HypqCiwtQAAAAA4qVMKWa1bt9Y///nPEtP/+c9/qlWrVqddFI7hCVkSZ7MAAAAABzilywWffPJJXXnllfrkk0+8n5G1YsUK/fLLL/rwww/9WuAZLzxcCgqSjCkOWXzYMwAAAGBrp3Qmq0uXLvrxxx917bXX6sCBAzpw4ICuu+46bdiwQa+99pq/azyzBQUxwiAAAADgIKf8OVn169cvMcDFN998o1deeUUvvvjiaReGY1SvLh08yOWCAAAAgAOc0pksWIwRBgEAAADHIGQ5ASELAAAAcAxClhMQsgAAAADHqNA9Wdddd90Jnz9w4MDp1IKyeAa+IGQBAAAAtlehkFWzZs2TPj9w4MDTKgil8JzJYnRBAAAAwPYqFLJeffXVyqoDJ8LlggAAAIBjcE+WExCyAAAAAMcgZDkBIQsAAABwDEKWExCyAAAAAMcgZDmBZ3RBBr4AAAAAbI+Q5QScyQIAAAAcg5DlBIQsAAAAwDEIWU5AyAIAAAAcg5DlBIQsAAAAwDEIWU7gGfiCkAUAAADYHiHLCTxnshhdEAAAALA9QpYTcLkgAAAA4BiELCcgZAEAAACOQchyAk/IKiiQjh4NbC0AAAAAToiQ5QSekCVxNgsAAACwOUKWE7hcUkhI8c+ELAAAAMDWCFlOEBTECIMAAACAQ9giZE2fPl1JSUkKDw9X+/bttWrVqnK97q233lJQUJD69u1buQXaAYNfAAAAAI4Q8JA1Z84cpaWlaezYsVqzZo1at26tXr16affu3Sd83datW3XvvfeqU6dOFlUaYIQsAAAAwBECHrKmTp2qIUOGKDU1Vc2bN9eMGTMUGRmpmTNnlvmaoqIi3XzzzRo/frwaN25sYbUBRMgCAAAAHKFaIN+8oKBAq1ev1ujRo73TgoOD1b17d61YsaLM102YMEGxsbH661//qs8+++yE75Gfn6/8/Hzv45ycHElSYWGhCgsLT3MNTo/n/ctTR0hkpIIlHc3Olglw3U5VkX7j9NFv69Bra9Fva9Fv69Bra9Fva5XV78rqf0BD1t69e1VUVKS4uDif6XFxcfrhhx9Kfc3nn3+uV155RWvXri3Xe0yaNEnjx48vMX3RokWKjIyscM2VIT09/aTzpBw+rFhJ3y5frl9crsovqgorT7/hP/TbOvTaWvTbWvTbOvTaWvTbWsf3Oy8vr1LeJ6Ahq6IOHjyoW265RS+99JLq1KlTrteMHj1aaWlp3sc5OTlKTExUz549FR0dXVmllkthYaHS09PVo0cPhYaGnnDekFdfldauVeumTdXyiissqrBqqUi/cfrot3XotbXot7Xot3XotbXot7XK6rfnKjd/C2jIqlOnjkJCQpSVleUzPSsrS/Hx8SXm37x5s7Zu3ao+ffp4p7ndbklStWrVtHHjRjVp0sTnNS6XS65SzvyEhobaZocuVy01akiSQo4cUYhN6nYqO237MwH9tg69thb9thb9tg69thb9ttbx/a6s3gd04IuwsDAlJycrIyPDO83tdisjI0MpKSkl5m/WrJnWrVuntWvXer+uvvpqXXrppVq7dq0SExOtLN9aDHwBAAAAOELALxdMS0vToEGD1LZtW7Vr107Tpk3ToUOHlJqaKkkaOHCgEhISNGnSJIWHh+uCCy7weX1MTIwklZhe5RCyAAAAAEcIeMjq37+/9uzZozFjxmjXrl1q06aNFi5c6B0MY/v27QoODvhI84EXFVX8nZAFAAAA2FrAQ5YkDR8+XMOHDy/1uczMzBO+dtasWf4vyI48Z7JycwNbBwAAAIAT4hSRU3C5IAAAAOAIhCynIGQBAAAAjkDIcgpCFgAAAOAIhCynIGQBAAAAjkDIcgrP6IIMfAEAAADYGiHLKTiTBQAAADgCIcspCFkAAACAIxCynIKQBQAAADgCIcspPCGrsLD4CwAAAIAtEbKcwhOyJM5mAQAAADZGyHKKsDCpWrXinxlhEAAAALAtQpZTBAVxXxYAAADgAIQsJyFkAQAAALZHyHISQhYAAABge4QsJyFkAQAAALZHyHKSqKji74QsAAAAwLYIWU7iOZPF6IIAAACAbRGynITLBQEAAADbI2Q5CSELAAAAsD1ClpMQsgAAAADbI2Q5CSELAAAAsD1ClpN4Rhdk4AsAAADAtghZTsKZLAAAAMD2CFlOQsgCAAAAbI+Q5SSELAAAAMD2CFlOQsgCAAAAbI+Q5SSELAAAAMD2CFlOwuiCAAAAgO0RspyEM1kAAACA7RGynISQBQAAANgeIctJCFkAAACA7RGynMQTso4elQoKAlsLAAAAgFIRspzEE7IkzmYBAAAANkXIcpKwMCk0tPhnRhgEAAAAbImQ5TTclwUAAADYGiHLaQhZAAAAgK0RspyGkAUAAADYGiHLaQhZAAAAgK0RspwmKqr4OwNfAAAAALZEyHIazmQBAAAAtkbIchpCFgAAAGBrhCynIWQBAAAAtkbIchpCFgAAAGBrhCynIWQBAAAAtkbIchpGFwQAAABsjZDlNJzJAgAAAGyNkOU0hCwAAADA1ghZTkPIAgAAAGyNkOU0hCwAAADA1mwRsqZPn66kpCSFh4erffv2WrVqVZnzvv3222rbtq1iYmJUvXp1tWnTRq+99pqF1QaYZ+ALQhYAAABgSwEPWXPmzFFaWprGjh2rNWvWqHXr1urVq5d2795d6vy1a9fWQw89pBUrVujbb79VamqqUlNT9fHHH1tceYB4zmQxuiAAAABgSwEPWVOnTtWQIUOUmpqq5s2ba8aMGYqMjNTMmTNLnb9r16669tprdf7556tJkyYaMWKEWrVqpc8//9ziygOEywUBAAAAW6sWyDcvKCjQ6tWrNXr0aO+04OBgde/eXStWrDjp640xWrx4sTZu3KjJkyeXOk9+fr7y8/O9j3NyciRJhYWFKiwsPM01OD2e969QHWFhCpVkDh3S0QDX7zSn1G+cMvptHXptLfptLfptHXptLfptrbL6XVn9DzLGmEpZcjns2LFDCQkJWr58uVJSUrzTR40apaVLl2rlypWlvi47O1sJCQnKz89XSEiInnvuOd16662lzjtu3DiNHz++xPQ33nhDkZGR/lkRC4Xv26def/2r3MHB+u9//iMFBQW6JAAAAMCR8vLyNGDAAGVnZys6Otpvyw3omaxTVaNGDa1du1a5ubnKyMhQWlqaGjdurK5du5aYd/To0UpLS/M+zsnJUWJionr27OnXRp6KwsJCpaenq0ePHgoNDS3fiw4ckCQFu926ont3yeWqvAKrmFPqN04Z/bYOvbYW/bYW/bYOvbYW/bZWWf32XOXmbwENWXXq1FFISIiysrJ8pmdlZSk+Pr7M1wUHB6tp06aSpDZt2uj777/XpEmTSg1ZLpdLrlKCSGhoqG126ArVEhPzx+vy8/8YbRDlZqdtfyag39ah19ai39ai39ah19ai39Y6vt+V1fuADnwRFham5ORkZWRkeKe53W5lZGT4XD54Mm632+e+qyotNFQKCyv+mcEvAAAAANsJ+OWCaWlpGjRokNq2bat27dpp2rRpOnTokFJTUyVJAwcOVEJCgiZNmiRJmjRpktq2basmTZooPz9fH374oV577TU9//zzgVwNa1WvLhUUELIAAAAAGwp4yOrfv7/27NmjMWPGaNeuXWrTpo0WLlyouLg4SdL27dsVHPzHCbdDhw5p6NCh+vXXXxUREaFmzZrp3//+t/r37x+oVbBe9erS778TsgAAAAAbCnjIkqThw4dr+PDhpT6XmZnp8/jRRx/Vo48+akFVNsZnZQEAAAC2FfAPI8YpIGQBAAAAtkXIciLPiIK5uYGtAwAAAEAJhCwn4kwWAAAAYFuELCciZAEAAAC2RchyIkIWAAAAYFuELCciZAEAAAC2RchyIga+AAAAAGyLkOVEnMkCAAAAbIuQ5USELAAAAMC2CFlORMgCAAAAbIuQ5USELAAAAMC2CFlORMgCAAAAbIuQ5USMLggAAADYFiHLiTiTBQAAANgWIcuJCFkAAACAbRGynIiQBQAAANgWIcuJjg1ZxgS2FgAAAAA+CFlO5AlZbreUnx/YWgAAAAD4IGQ5kSdkSYwwCAAAANgMIcuJqlWTXK7in7kvCwAAALAVQpZTMfgFAAAAYEuELKciZAEAAAC2RMhyKkIWAAAAYEuELKeKiir+zsAXAAAAgK0QspyKM1kAAACALRGynIqQBQAAANgSIcupCFkAAACALRGynIqQBQAAANgSIcupCFkAAACALRGynIrRBQEAAABbImQ5FWeyAAAAAFsiZDkVIQsAAACwJUKWUxGyAAAAAFsiZDkVIQsAAACwJUKWU3kGviBkAQAAALZCyHIqz5ksRhcEAAAAbIWQ5VRcLggAAADYEiHLqQhZAAAAgC0RspyKkAUAAADYEiHLqY4NWcYEthYAAAAAXoQsp/KMLmiMdPhwYGsBAAAA4EXIcqrIyD9+5pJBAAAAwDYIWU4VEiKFhxf/TMgCAAAAbIOQ5WQMfgEAAADYDiHLyQhZAAAAgO0QspyMkAUAAADYDiHLyTwjDObmBrYOAAAAAF6ELCfjTBYAAABgO4QsJyNkAQAAALZDyHIyQhYAAABgO7YIWdOnT1dSUpLCw8PVvn17rVq1qsx5X3rpJXXq1Em1atVSrVq11L179xPOX6URsgAAAADbCXjImjNnjtLS0jR27FitWbNGrVu3Vq9evbR79+5S58/MzNRNN92kJUuWaMWKFUpMTFTPnj3122+/WVy5DXgGviBkAQAAALYR8JA1depUDRkyRKmpqWrevLlmzJihyMhIzZw5s9T5X3/9dQ0dOlRt2rRRs2bN9PLLL8vtdisjI8Piym3AcyaL0QUBAAAA26gWyDcvKCjQ6tWrNXr0aO+04OBgde/eXStWrCjXMvLy8lRYWKjatWuX+nx+fr7y8/O9j3NyciRJhYWFKiwsPI3qT5/n/U+1juDwcIVIch88qKIAr4sTnG6/UTH02zr02lr021r02zr02lr021pl9buy+h9kjDGVsuRy2LFjhxISErR8+XKlpKR4p48aNUpLly7VypUrT7qMoUOH6uOPP9aGDRsUHh5e4vlx48Zp/PjxJaa/8cYbioyMPL0VCLDG772nljNn6tdOnbT6nnsCXQ4AAADgKHl5eRowYICys7MVHR3tt+UG9EzW6XriiSf01ltvKTMzs9SAJUmjR49WWlqa93FOTo73Pi5/NvJUFBYWKj09XT169FBoaGiFXx+0Y4c0c6bq16ypuCuuqIQKq5bT7Tcqhn5bh15bi35bi35bh15bi35bq6x+e65y87eAhqw6deooJCREWVlZPtOzsrIUHx9/wtc+9dRTeuKJJ/TJJ5+oVatWZc7ncrnkcrlKTA8NDbXNDn3KtfwvJAYfPqxgm6yLE9hp258J6Ld16LW16Le16Ld16LW16Le1ju93ZfU+oANfhIWFKTk52WfQCs8gFsdePni8J598UhMnTtTChQvVtm1bK0q1J8/oggx8AQAAANhGwC8XTEtL06BBg9S2bVu1a9dO06ZN06FDh5SamipJGjhwoBISEjRp0iRJ0uTJkzVmzBi98cYbSkpK0q5duyRJUVFRivKEjjMFn5MFAAAA2E7AQ1b//v21Z88ejRkzRrt27VKbNm20cOFCxcXFSZK2b9+u4OA/Trg9//zzKigo0PXXX++znLFjx2rcuHFWlh54hCwAAADAdgIesiRp+PDhGj58eKnPZWZm+jzeunVr5RfkFIQsAAAAwHYC/mHEOA2ELAAAAMB2CFlO5glZeXmS2x3YWgAAAABIImQ5m2egD2Okw4cDWwsAAAAASYQsZ4uM/ONnLhkEAAAAbIGQ5WTBwVJERPHPhCwAAADAFghZTsfgFwAAAICtELKcjpAFAAAA2Aohy+k8g1/k5ga2DgAAAACSCFnOx5ksAAAAwFYIWU5HyAIAAABshZDldIQsAAAAwFYIWU5HyAIAAABshZDldIQsAAAAwFYIWU7H6IIAAACArRCynI4zWQAAAICtELKcjpAFAAAA2Aohy+kIWQAAAICtELKcjpAFAAAA2Aohy+kIWQAAAICtELKcjtEFAQAAAFshZDkdZ7IAAAAAWyFkOR0hCwAAALAVQpbTEbIAAAAAWyFkOR0hCwAAALAVQpbTeQa+yMuT3O7A1gIAAACAkOV4njNZUnHQAgAAABBQhCyni4j442cuGQQAAAACjpDldMHBUmRk8c+ELAAAACDgCFlVAYNfAAAAALZByKoKCFkAAACAbRCyqgLPCIO5uYGtAwAAAAAhq0rgTBYAAABgG4SsqoCQBQAAANgGIasqIGQBAAAAtkHIqgoIWQAAAIBtELKqAkIWAAAAYBuErKqA0QUBAAAA2yBkVQWcyQIAAABsg5BVFRCyAAAAANsgZFUFhCwAAADANghZVQEhCwAAALANQpaTjRsnTZxY+sAXEycWP1+R5ZSmIsvx57Lsthw71sS6ObMm1s2ZNbFuzqyJdXNmTaybM2s62XK6dvXfujsAIcvJQkKkMWOk//63+LHnTNbEicXTQ0Iqtpzjd/yKLsefy7LbcuxYE+vmzJoqYd2CH3vMHjWx3ZxZE+vmzJo4ljizpjN93fy17g4QZIwxgS7CSjk5OapZs6ays7MVHR0d0FoKCwv14Ycf6oorrlBoaOipLcSzY0pSYqLUsaP01lvSjTdKN9xQ/uXMm+f7uuMfV4S/luXn5RT166fVjRopecsWhcydW6XWzY7b7bT7XRnr1r//H8uaM+ePxxVZzrGvC/RyjlnWr5dcovjhw1XtnXeq3LrZpqb/va7ohhv+2LfnzatS62bH7Xba/bbxutlmOccsi2OJdcs5I48lxz/+9ltpwoTir0ceqdi6V1BZf3dXVjYgZAWQX0KWJN15p/TCC/4rDAAAALCCBQFLsj5kVfPbkhA406dLL70kud1SUFDx2axTtWyZZMzpL8efy/LTcsyyZQoyRiYoSEFVbN3suN381m8brpvdluM2RkHLlyvIRjVV5e3GscTaZXEssW45HEusXc4ZfSzxPB8WZknACghzhsnOzjaSTHZ2dqBLMQUFBebdd981BQUFp7egCROMkYwJCyv+PmFCYJdjx5r+t5yj1apV2XWz43Y77X7beN1ssxxjzNGxY42RjNsuNZ0B241jibU1cSyxYDmGY0kglnNGHkv8uV0roKy/uysrGxCyAsgvIcuzo3p20OMfW70cO9bkOZCNHWveffdd7z8iVWnd7LjdTrvfNl432yznmNd+d9NNxceSQNd0Bmw3jiXW1sSxxILlHPNajiXWLeeMPJb4c7tWECGrklWpkFXWjlnRHdZfy7FjTcfM79PvKrZup7WcSqrptPpt83WzxXKOeY3nH2rvsaQKrZttauJYErCaOJZU8nKOeQ3HEmuXc8YdSy67zH/b9RRYHbICfk/W9OnTNWXKFO3atUutW7fWs88+q3bt2pU674YNGzRmzBitXr1a27Zt09NPP62RI0daW7CdFBWVfrOg53FRkbXLsWNNxy6nsPDUl1NZNdlhOZVV0+n02+7rZoflHLMs9wMPSB9+GPiazpTtxrHE2po4llTuco5ZFscSi5dzph1LMjL8t10dIKCjC86ZM0cDBw7UjBkz1L59e02bNk3z5s3Txo0bFRsbW2L+L7/8UnPnzlVycrL+9re/6f77769wyKqSowuiXOi3tei3dei1tei3tei3dei1tei3taweXTCgH0Y8depUDRkyRKmpqWrevLlmzJihyMhIzZw5s9T5//SnP2nKlCm68cYb5XK5LK4WAAAAAE4uYJcLFhQUaPXq1Ro9erR3WnBwsLp3764VK1b47X3y8/OVn5/vfZyTkyOpOM0WHnuaNgA87x/oOs4U9Nta9Ns69Npa9Nta9Ns69Npa9NtaZfW7svofsJC1d+9eFRUVKS4uzmd6XFycfvjhB7+9z6RJkzR+/PgS0xctWqTIyEi/vc/pSE9PD3QJZxT6bS36bR16bS36bS36bR16bS36ba3j+52Xl1cp7xPwgS8q2+jRo5WWluZ9nJOTo8TERPXs2dMW92Slp6erR48eXItrAfptLfptHXptLfptLfptHXptLfptrbL67bnKzd8CFrLq1KmjkJAQZWVl+UzPyspSfHy8397H5XKVev9WaGiobXZoO9VyJqDf1qLf1qHX1qLf1qLf1qHX1qLf1jq+35XV+4ANfBEWFqbk5GRlZGR4p7ndbmVkZCglJSVQZQEAAADAaQno5YJpaWkaNGiQ2rZtq3bt2mnatGk6dOiQUlNTJUkDBw5UQkKCJk2aJKl4sIzvvvvO+/Nvv/2mtWvXKioqSk2bNg3YegAAAACAR0BDVv/+/bVnzx6NGTNGu3btUps2bbRw4ULvYBjbt29XcPAfJ9t27NihCy+80Pv4qaee0lNPPaUuXbooMzPT6vIBAAAAoISAD3wxfPhwDR8+vNTnjg9OSUlJCuBnJwMAAADASQX0w4gBAAAAoKohZAEAAACAHxGyAAAAAMCPCFkAAAAA4EeELAAAAADwo4CPLmg1z+iEOTk5Aa5EKiwsVF5ennJycvikbwvQb2vRb+vQa2vRb2vRb+vQa2vRb2uV1W9PJvD3COZnXMg6ePCgJCkxMTHAlQAAAACwg4MHD6pmzZp+W16QOcM+eMrtdmvHjh2qUaOGgoKCAlpLTk6OEhMT9csvvyg6OjqgtZwJ6Le16Ld16LW16Le16Ld16LW16Le1yuq3MUYHDx5U/fr1FRzsvzupzrgzWcHBwWrQoEGgy/ARHR3NL5eF6Le16Ld16LW16Le16Ld16LW16Le1Suu3P89geTDwBQAAAAD4ESELAAAAAPyIkBVALpdLY8eOlcvlCnQpZwT6bS36bR16bS36bS36bR16bS36bS2r+33GDXwBAAAAAJWJM1kAAAAA4EeELAAAAADwI0IWAAAAAPgRIQsAAAAA/IiQFUDTp09XUlKSwsPD1b59e61atSrQJTnOuHHjFBQU5PPVrFkz7/NHjhzRsGHDdNZZZykqKkp//vOflZWV5bOM7du368orr1RkZKRiY2N133336ejRo1avii19+umn6tOnj+rXr6+goCC9++67Ps8bYzRmzBjVq1dPERER6t69u3766Sefefbv36+bb75Z0dHRiomJ0V//+lfl5ub6zPPtt9+qU6dOCg8PV2Jiop588snKXjXbOVmvBw8eXGJfv/zyy33modflN2nSJP3pT39SjRo1FBsbq759+2rjxo0+8/jr+JGZmamLLrpILpdLTZs21axZsyp79WylPL3u2rVrif37zjvv9JmHXpfP888/r1atWnk/cDUlJUUfffSR93n2a/86Wb/ZtyvPE088oaCgII0cOdI7zVb7t0FAvPXWWyYsLMzMnDnTbNiwwQwZMsTExMSYrKysQJfmKGPHjjUtWrQwO3fu9H7t2bPH+/ydd95pEhMTTUZGhvnqq6/MxRdfbDp06OB9/ujRo+aCCy4w3bt3N19//bX58MMPTZ06dczo0aMDsTq28+GHH5qHHnrIvP3220aSeeedd3yef+KJJ0zNmjXNu+++a7755htz9dVXm0aNGpnDhw9757n88stN69atzRdffGE+++wz07RpU3PTTTd5n8/OzjZxcXHm5ptvNuvXrzdvvvmmiYiIMC+88IJVq2kLJ+v1oEGDzOWXX+6zr+/fv99nHnpdfr169TKvvvqqWb9+vVm7dq254oorzNlnn21yc3O98/jj+PHzzz+byMhIk5aWZr777jvz7LPPmpCQELNw4UJL1zeQytPrLl26mCFDhvjs39nZ2d7n6XX5vffee+aDDz4wP/74o9m4caN58MEHTWhoqFm/fr0xhv3a307Wb/btyrFq1SqTlJRkWrVqZUaMGOGdbqf9m5AVIO3atTPDhg3zPi4qKjL169c3kyZNCmBVzjN27FjTunXrUp87cOCACQ0NNfPmzfNO+/77740ks2LFCmNM8R+2wcHBZteuXd55nn/+eRMdHW3y8/MrtXanOf4Pf7fbbeLj482UKVO80w4cOGBcLpd58803jTHGfPfdd0aS+fLLL73zfPTRRyYoKMj89ttvxhhjnnvuOVOrVi2fft9///3mvPPOq+Q1sq+yQtY111xT5mvo9enZvXu3kWSWLl1qjPHf8WPUqFGmRYsWPu/Vv39/06tXr8peJds6vtfGFP8heuwfSsej16enVq1a5uWXX2a/toin38awb1eGgwcPmnPOOcekp6f79Ndu+zeXCwZAQUGBVq9ere7du3unBQcHq3v37lqxYkUAK3Omn376SfXr11fjxo118803a/v27ZKk1atXq7Cw0KfPzZo109lnn+3t84oVK9SyZUvFxcV55+nVq5dycnK0YcMGa1fEYbZs2aJdu3b59LdmzZpq3769T39jYmLUtm1b7zzdu3dXcHCwVq5c6Z2nc+fOCgsL887Tq1cvbdy4Ub///rtFa+MMmZmZio2N1Xnnnae77rpL+/bt8z5Hr09Pdna2JKl27dqS/Hf8WLFihc8yPPOcycf643vt8frrr6tOnTq64IILNHr0aOXl5Xmfo9enpqioSG+99ZYOHTqklJQU9utKdny/Pdi3/WvYsGG68sorS/TEbvt3tQrNDb/Yu3evioqKfDawJMXFxemHH34IUFXO1L59e82aNUvnnXeedu7cqfHjx6tTp05av369du3apbCwMMXExPi8Ji4uTrt27ZIk7dq1q9Tt4HkOZfP0p7T+Hdvf2NhYn+erVaum2rVr+8zTqFGjEsvwPFerVq1Kqd9pLr/8cl133XVq1KiRNm/erAcffFC9e/fWihUrFBISQq9Pg9vt1siRI9WxY0ddcMEFkuS340dZ8+Tk5Ojw4cOKiIiojFWyrdJ6LUkDBgxQw4YNVb9+fX377be6//77tXHjRr399tuS6HVFrVu3TikpKTpy5IiioqL0zjvvqHnz5lq7di37dSUoq98S+7a/vfXWW1qzZo2+/PLLEs/Z7bhNyIKj9e7d2/tzq1at1L59ezVs2FBz5849ow46qPpuvPFG788tW7ZUq1at1KRJE2VmZqpbt24BrMz5hg0bpvXr1+vzzz8PdClVXlm9vv32270/t2zZUvXq1VO3bt20efNmNWnSxOoyHe+8887T2rVrlZ2drfnz52vQoEFaunRpoMuqssrqd/Pmzdm3/eiXX37RiBEjlJ6ervDw8ECXc1JcLhgAderUUUhISInRTrKyshQfHx+gqqqGmJgYnXvuudq0aZPi4+NVUFCgAwcO+MxzbJ/j4+NL3Q6e51A2T39OtB/Hx8dr9+7dPs8fPXpU+/fvZxucpsaNG6tOnTratGmTJHp9qoYPH673339fS5YsUYMGDbzT/XX8KGue6OjoM+4/gsrqdWnat28vST77N70uv7CwMDVt2lTJycmaNGmSWrdurWeeeYb9upKU1e/SsG+futWrV2v37t266KKLVK1aNVWrVk1Lly7VP/7xD1WrVk1xcXG22r8JWQEQFham5ORkZWRkeKe53W5lZGT4XMOLisvNzdXmzZtVr149JScnKzQ01KfPGzdu1Pbt2719TklJ0bp163z+OE1PT1d0dLT3VD9K16hRI8XHx/v0NycnRytXrvTp74EDB7R69WrvPIsXL5bb7fb+Q5OSkqJPP/1UhYWF3nnS09N13nnnnbGXr5XHr7/+qn379qlevXqS6HVFGWM0fPhwvfPOO1q8eHGJyyj9dfxISUnxWYZnnjPpWH+yXpdm7dq1kuSzf9PrU+d2u5Wfn89+bRFPv0vDvn3qunXrpnXr1mnt2rXer7Zt2+rmm2/2/myr/bviY3rAH9566y3jcrnMrFmzzHfffWduv/12ExMT4zPaCU7unnvuMZmZmWbLli1m2bJlpnv37qZOnTpm9+7dxpjioTzPPvtss3jxYvPVV1+ZlJQUk5KS4n29ZyjPnj17mrVr15qFCxeaunXrMoT7/xw8eNB8/fXX5uuvvzaSzNSpU83XX39ttm3bZowpHsI9JibGLFiwwHz77bfmmmuuKXUI9wsvvNCsXLnSfP755+acc87xGVb8wIEDJi4uztxyyy1m/fr15q233jKRkZFn3LDiJ+r1wYMHzb333mtWrFhhtmzZYj755BNz0UUXmXPOOcccOXLEuwx6XX533XWXqVmzpsnMzPQZWjkvL887jz+OH56hgO+77z7z/fffm+nTp59xQy+frNebNm0yEyZMMF999ZXZsmWLWbBggWncuLHp3Lmzdxn0uvweeOABs3TpUrNlyxbz7bffmgceeMAEBQWZRYsWGWPYr/3tRP1m3658x4/eaKf9m5AVQM8++6w5++yzTVhYmGnXrp354osvAl2S4/Tv39/Uq1fPhIWFmYSEBNO/f3+zadMm7/OHDx82Q4cONbVq1TKRkZHm2muvNTt37vRZxtatW03v3r1NRESEqVOnjrnnnntMYWGh1atiS0uWLDGSSnwNGjTIGFM8jPsjjzxi4uLijMvlMt26dTMbN270Wca+ffvMTTfdZKKiokx0dLRJTU01Bw8e9Jnnm2++MZdccolxuVwmISHBPPHEE1atom2cqNd5eXmmZ8+epm7duiY0NNQ0bNjQDBkypMR/ytDr8iut15LMq6++6p3HX8ePJUuWmDZt2piwsDDTuHFjn/c4E5ys19u3bzedO3c2tWvXNi6XyzRt2tTcd999Pp8lZAy9Lq9bb73VNGzY0ISFhZm6deuabt26eQOWMezX/naifrNvV77jQ5ad9u8gY4yp2LkvAAAAAEBZuCcLAAAAAPyIkAUAAAAAfkTIAgAAAAA/ImQBAAAAgB8RsgAAAADAjwhZAAAAAOBHhCwAAAAA8CNCFgAAAAD4ESELAIATSEpK0rRp0wJdBgDAQQhZAADbGDx4sPr27StJ6tq1q0aOHGnZe8+aNUsxMTElpn/55Ze6/fbbLasDAOB81QJdAAAAlamgoEBhYWGn/Pq6dev6sRoAwJmAM1kAANsZPHiwli5dqmeeeUZBQUEKCgrS1q1bJUnr169X7969FRUVpbi4ON1yyy3au3ev97Vdu3bV8OHDNXLkSNWpU0e9evWSJE2dOlUtW7ZU9erVlZiYqKFDhyo3N1eSlJmZqdTUVGVnZ3vfb9y4cZJKXi64fft2XXPNNYqKilJ0dLT69eunrKws7/Pjxo1TmzZt9NprrykpKUk1a9bUjTfeqIMHD1Zu0wAAtkHIAgDYzjPPPKOUlBQNGTJEO3fu1M6dO5WYmKgDBw7osssu04UXXqivvvpKCxcuVFZWlvr16+fz+tmzZyssLEzLli3TjBkzJEnBwcH6xz/+oQ0bNmj27NlavHixRo0aJUnq0KGDpk2bpujoaO/73XvvvSXqcrvduuaaa7R//34tXbpU6enp+vnnn9W/f3+f+TZv3qx3331X77//vt5//30tXbpUTzzxRCV1CwBgN1wuCACwnZo1ayosLEyRkZGKj4/3Tv/nP/+pCy+8UI8//rh32syZM5WYmKgff/xR5557riTpnHPO0ZNPPumzzGPv70pKStKjjz6qO++8U88995zCwsJUs2ZNBQUF+bzf8TIyMrRu3Tpt2bJFiYmJkqR//etfatGihb788kv96U9/klQcxmbNmqUaNWpIkm655RZlZGToscceO73GAAAcgTNZAADH+Oabb7RkyRJFRUV5v5o1ayap+OyRR3JyconXfvLJJ+rWrZsSEhJUo0YN3XLLLdq3b5/y8vLK/f7ff/+9EhMTvQFLkpo3b66YmBh9//333mlJSUnegCVJ9erV0+7duyu0rgAA5+JMFgDAMXJzc9WnTx9Nnjy5xHP16tXz/ly9enWf57Zu3aqrrrpKd911lx577DHVrl1bn3/+uf7617+qoKBAkZGRfq0zNDTU53FQUJDcbrdf3wMAYF+ELACALYWFhamoqMhn2kUXXaT//Oc/SkpKUrVq5f8nbPXq1XK73fr73/+u4ODiizjmzp170vc73vnnn69ffvlFv/zyi/ds1nfffacDBw6oefPm5a4HAFC1cbkgAMCWkpKStHLlSm3dulV79+6V2+3WsGHDtH//ft1000368ssvtXnzZn388cdKTU09YUBq2rSpCgsL9eyzz+rnn3/Wa6+95h0Q49j3y83NVUZGhvbu3VvqZYTdu3dXy5YtdfPNN2vNmjVatWqVBg4cqC5duqht27Z+7wEAwJkIWQAAW7r33nsVEhKi5s2bq27dutq+fbvq16+vZcuWqaioSD179lTLli01cuRIxcTEeM9QlaZ169aaOnWqJk+erAsuuECvv/66Jk2a5DNPhw4ddOedd6p///6qW7duiYEzpOLL/hYsWKBatWqpc+fO6t69uxo3bqw5c+b4ff0BAM4VZIwxgS4CAAAAAKoKzmQBAAAAgB8RsgAAAADAjwhZAAAAAOBHhCwAAAAA8CNCFgAAAAD4ESELAAAAAPyIkAUAAAAAfkTIAgAAAAA/ImQBAAAAgB8RsgAAAADAjwhZAAAAAOBH/w8MjJWKnDw7nQAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### ' test_zero_variance_feature_synthetic'", + "id": "4a62b5cc6bb79e0f" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-11T03:40:54.270452Z", + "start_time": "2024-10-11T03:40:54.170140Z" + } + }, + "cell_type": "code", + "source": [ + "# Loss values for test_zero_variance_feature_synthetic\n", + "iterations_zero_var_synthetic = list(range(1, 956, 100)) + [955]\n", + "loss_zero_var_synthetic = [\n", + " 0.7808703942509939,\n", + " 0.15893821461720334,\n", + " 0.15895228493760796,\n", + " 0.15896093020411556,\n", + " 0.15896616870017413,\n", + " 0.15896934255787273,\n", + " 0.15897126538213102,\n", + " 0.15897243024381283,\n", + " 0.15897313590885337,\n", + " 0.15897356338951335,\n", + " 0.1589747188811727\n", + "]\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(iterations_zero_var_synthetic, loss_zero_var_synthetic, marker='s', linestyle='-', color='purple')\n", + "plt.title('Loss Over Iterations: test_zero_variance_feature_synthetic')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Loss')\n", + "plt.grid(True)\n", + "plt.show()" + ], + "id": "22ad5284c0a14719", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 4 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### 'test_invalid_optimization_option_small_test'", + "id": "7f571ca332c6f518" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "- No iterative loss data available as this test checks for exception handling.\n", + "id": "5be2502c7c57633c" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Conclusion\n", + "- All test cases have passed without any issues, ensuring the robustness and reliability of the ElasticNetModel implementation.\n" + ], + "id": "8d118b601c7aa0a2" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/generate_regression_data.py b/generate_regression_data.py index bca2108..5a37a98 100644 --- a/generate_regression_data.py +++ b/generate_regression_data.py @@ -6,18 +6,18 @@ def linear_data_generator(m, b, rnge, N, scale, seed): rng = numpy.random.default_rng(seed=seed) sample = rng.uniform(low=rnge[0], high=rnge[1], size=(N, m.shape[0])) - ys = numpy.dot(sample, numpy.reshape(m, (-1,1))) + b + ys = numpy.dot(sample, m) + b noise = rng.normal(loc=0., scale=scale, size=ys.shape) return (sample, ys+noise) def write_data(filename, X, y): - with open(filename, "w") as file: + with open(filename, "w",newline='') as file: # X column for every x xs = [f"x_{n}" for n in range(X.shape[1])] header = xs + ["y"] writer = csv.writer(file) writer.writerow(header) - for row in numpy.hstack((X,y)): + for row in numpy.hstack((X,y.reshape(-1,1))): writer.writerow(row) def main(): diff --git a/small_test.csv b/small_test.csv new file mode 100644 index 0000000..62d6cfe --- /dev/null +++ b/small_test.csv @@ -0,0 +1,101 @@ +x_0,x_1,x_2,x_3,x_4,x_5,x_6,x_7,x_8,x_9,y +5.479120971119267,-1.2224312049589532,7.171958398227648,3.9473605811872776,-8.11645304224701,9.512447032735118,5.222794039807059,5.721286105539075,-7.4377273464890825,-0.9922812420886569,21.6922510572167 +-2.5840395153483753,8.535299776972035,2.8773024016132904,6.455232265416598,-1.131716023453377,-5.455225564304462,1.0916957403166965,-8.723654877916493,6.55262343985164,2.6332879824412974,1.2474334465888388 +5.1617548017074775,-2.9094806374026323,9.413960487898066,7.862422426443953,5.567669941475238,-6.1072258429606485,-0.6655799254593155,-9.123924684255424,-6.914210158649043,3.6609790648490925,-3.0838514701892974 +4.895243118156342,9.350194648684202,-3.4834928372369607,-2.5908058793026223,-0.6088837744838411,-6.2105728183142865,-7.401569893290567,-0.48590147548132556,-5.461813018982317,3.396279893650206,-5.518973575291431 +-1.2569616225533853,6.653563921156749,4.005302040044983,-3.7526671723591782,6.645196027904021,6.095287149936038,-2.2504324193965104,-4.233437921395118,3.6499100794995094,-7.204950327813804,15.489627348789693 +-6.001835950497833,-9.85275460497989,5.738487550042768,3.2970171318406436,4.1033075725267025,5.614580620439359,-0.8216844892332009,1.3748239190578744,-7.204060037446851,-7.709398529280531,-3.519382274803764 +3.368059235809433,-0.5780758771373495,1.3047221296237765,5.299977148320512,2.694366400011816,1.071588013159916,1.1841432149082713,-3.920998038747756,-9.383643308641211,-1.2656522153527519,4.691972101737773 +-5.708306543609416,-1.8294271255072765,7.068061465363321,-5.321210282693185,-8.83394516621868,-4.372322159560069,-4.128124844666328,3.238330294537901,1.1406430468255664,5.677964182128271,-19.064966252715788 +3.2862708065477513,-1.8722627711985886,6.280407693320694,-6.660541601845922,-9.54575853732279,-8.199042784487165,4.447187011929007,-0.7624553949722532,-6.774564419327964,0.020895502067270755,-31.721613112458115 +-6.953757945736632,3.9264075015547206,-1.0768744885193868,-2.3795754780703504,-3.96975821704247,2.605651862377769,-2.763747788932191,-8.24700161367798,-7.639881957589694,9.23795329099029,-1.9925091213088766 +8.171613814152142,3.9941426762149916,-4.682600770809609,9.383527546954479,5.5750180793158925,4.337803783179911,-1.0127699571242275,-4.55516876309682,-8.072180756930013,8.052047930876832,34.355979574822065 +-0.8844742033277786,-5.952732704095394,-3.8808675169869495,1.5843913788379194,-6.464544341215365,7.1322856818475096,5.170390596704202,4.389259119018735,-1.3581392044979257,2.546176814048863,11.033678750543125 +1.681959378254712,2.9969320310963994,-8.311113577202217,-1.683851956587807,-9.16771652276215,-0.12018361510962094,-3.4027757533442937,-7.109516222679062,-7.931940645548967,1.7528914435542404,-22.95927646430916 +-6.588140629262278,8.502402367535943,1.621222794007899,-3.0626039093032587,1.818309829628335,-9.54392257940605,9.171184264828906,-0.35393126114199447,5.654704545005725,-8.345400001551228,-9.785083538588736 +-0.2668333832367935,-0.18586011290958204,8.756529099499659,1.4345610475215071,-0.5302119788609243,-4.660486738162128,-3.3686200531489563,0.4134480494307553,-1.2217707938990667,-9.567758402393391,-20.498419768467524 +6.525838483887156,7.923215436795335,-7.195018220027785,1.0807228707809884,-7.828485177291129,3.4448018607962343,-4.375324323219834,3.1884526938380358,4.539892285737652,5.37294983835314,16.908900213316606 +-7.845181080882069,8.320236902752157,-5.395720182102384,-9.251748876476405,1.0970493878296672,-2.5815543227512254,6.595794862648262,6.165029441286038,-3.6572221435456935,9.057987901394899,19.553020396375413 +-4.181643237197628,0.30114258463429167,-4.880698188647945,8.720871400979266,-6.707843648359637,-9.10178761215342,-1.2980587999392412,9.847511281116741,7.833545325098278,4.972160389138985,-4.055715919419139 +7.8158498175704985,7.8689327939572635,0.3771672077289807,-3.6814189633841394,5.4402486422197605,3.233225263355221,-2.526845422525799,-8.110666638769695,4.935792226980521,-4.750789681542706,12.17921890976679 +8.736263010675586,-5.180588499886305,-7.5448413517702795,6.622253442498124,-6.93431366751012,-6.414633836845218,1.9876558304168697,7.49124081674929,-6.071306685708535,-3.793526541998105,-18.178466808154415 +5.548096764823551,9.436528521219348,0.014823724046845399,-7.1220499489749844,-9.72127424583597,-5.406879400022895,-7.36355564426958,3.55317347225715,-7.5633499074293775,0.12659863241266045,-19.825142393688616 +3.885248712857729,1.6223321844180472,-6.004486966798847,6.082490523645255,4.308142592316033,4.779680078310836,-7.378844968853735,-7.524923926993107,8.551251020130152,-2.0484361235011868,10.176288979230959 +-3.9810261643812055,-0.22831909296933262,3.2572842552716494,9.112465140939399,-4.271075462358899,8.496168586240543,-9.502810172274874,1.1039608465364932,2.6795022336217027,-7.882051924984934,1.115821011666571 +-7.193208058721748,-1.6177136136739243,9.324638242863635,1.9208510646874561,8.660464432004225,6.087218312259417,-0.6523679688941701,5.695268985043748,-9.643264320460245,-7.817120064685302,17.51441858510625 +6.5885722976547285,5.936341766503235,-5.3471851606713265,0.6153918119810697,2.120316414000218,7.354779075520224,2.0621431467745133,-1.748568614526393,-2.5163191318563456,-1.4823582725298028,26.281385161011542 +3.0386205115994827,7.349812635046497,-0.9220623584740046,-5.043208740972838,-5.266752740048377,4.920285604868928,6.331375268478208,-7.894438402917501,-8.668822860896437,1.8886732751290367,6.654201308487984 +-7.076535116146035,6.493283809126826,-3.7933065215185113,-7.122561340577147,8.419409449749004,-6.689365545294437,-4.3055983532412885,-6.927732096158827,-7.6901987266929,-9.5770396732712,-27.510022900416747 +-8.892091816714798,-6.507170581282946,-8.932361347456492,1.8228763222194253,3.6142905359901274,-2.1273908633594356,-3.6401780609590118,0.0905247404446019,7.500098844692172,7.022632536444121,-1.5497861305968033 +-9.13049875974416,-6.370031808069518,-5.26510257791208,-5.012248483355764,1.4246530348554547,-1.674751485936154,-9.01491760144812,-2.527717230808568,0.4750589743527449,-7.966561941925681,-37.53506539451967 +6.669171075771196,-8.960762670697914,8.496837380361242,-8.01773716840249,6.871499031955054,8.053062878552343,9.591413611731852,6.0405176054718694,5.589550815426579,2.8496655199109533,39.225589240123014 +5.579927091562579,-7.308955831737059,0.7213607189527451,0.28445740380828965,7.15144288245115,-0.7440126881296827,-2.2982100779929304,2.7912654247422015,-4.670733649983079,-7.204631780920863,-4.546310189771818 +-0.44245451952508397,-1.6622126281022993,-5.348601189422526,-2.6497637976974397,-2.6721510034750517,-3.450088711749091,-2.41071840546142,3.714866909118907,-4.062470508574294,8.97715853430681,-2.6086000123352147 +8.32696039076356,-0.3817914339984281,-3.4327758999062237,0.7086957966000629,6.9712097754724915,3.0517468112020403,6.087836558941547,0.6544455213148037,2.6583525853524144,-4.236887716350766,23.56859834041093 +4.6978632462058165,-5.951908137485633,3.895962576369964,7.21438136651788,-7.357943253969122,2.287594810838396,-8.098085035401308,4.514312565428538,-8.310135623529595,8.71879645401252,2.64569249462882 +-7.251841399243957,9.177604918181608,6.017683521701933,1.8736400893270826,5.6524820925909385,5.902296779661718,8.920541256346606,-4.932332923216256,1.8015179071661827,-8.099016048711976,25.509253540522934 +2.3233140004824264,-6.574173918144224,1.299012229448838,1.448610280676995,-0.6802969403754524,0.4526355102624553,5.278467800131759,5.984894330241332,-0.15693568849141748,1.9918688304522458,10.38041745473024 +8.624724713802038,-7.605328229977544,-7.65792868199779,-8.245819761784631,3.157265700810557,-1.62783398419241,5.486428322836865,3.424628266171851,-3.3272448334352367,7.967330947230714,8.391646545051827 +5.250642941413046,-4.589301181796486,-2.7161596445589193,-3.7112003959147426,-6.847767027500007,-7.044332549156167,8.722549267514882,-1.2419192560249357,-2.333603544451803,4.593714173547559,-17.131974261432532 +1.0598613050579981,8.722799736769243,5.606029878187844,-0.4126087175091939,-2.4728105303834758,9.732630898486441,4.355204720072869,9.023893200076824,-7.630428455659173,7.010673583815652,50.08801124178327 +2.7414776798241505,-7.561566433297749,1.765159999384414,3.721927302108977,-9.753946282227943,-0.9136407631650698,6.507990223926424,-4.092819493118203,-0.8290383640289782,-1.1537174586421362,-19.43579507694806 +-3.9614521711501682,8.368837910311086,5.6258807086303175,-7.7882317800777905,9.940693156751461,7.584000486154906,-4.32183124271922,6.7379315932187644,-7.871609362572343,9.982094609484772,49.689593815874716 +3.3136947221307373,3.0025003111759396,-8.191185460317346,7.940667977932506,-9.420009935910612,-5.183438839177059,-7.1395624966673,5.535358813844372,-6.0359154557420425,8.212764542617705,-6.13479191358857 +3.125380786549803,-9.276745790106077,-9.89140331742599,-8.96684165971202,2.1185035529545537,6.029636217188305,-5.22894358745223,6.988176858461458,-8.855361196934792,6.019277072833525,5.7251583437859415 +8.555908603445609,5.442167982087611,3.962415679572743,6.759604373107663,-9.196974009058671,-5.964357785618892,-7.501526413887138,0.09061980385973101,4.903762566576891,2.600236891527974,-8.428533250877415 +7.022621995238701,-6.895740151178183,4.692421838703231,-6.139170182621918,-4.584824973643995,4.198093945626077,9.604095697973637,2.2308721195413916,-8.909993700174088,2.326179398550657,6.567592347603967 +-9.152988968396658,7.682914227336344,4.191565702012415,-6.537443071549935,-8.165579883516038,-6.329335422393621,9.600543591083849,-0.8287871508302036,5.681618966828159,2.728166842155538,-8.084765147717231 +1.4482629991727478,-7.097394906699006,8.920489071161903,-3.9731473497056413,1.560344316150843,3.995518891781323,2.9846631049061774,8.81188819391037,-7.03122020159884,0.16705476893884175,14.052202838270505 +-1.9193121851846797,-0.516625410347638,-7.615649476045108,-7.318107802544693,-4.438489084374853,-3.9059079247833743,-1.441935726373,2.219750940732565,2.69258234836526,-1.7637820682885952,-21.63293060505093 +-1.8243378114260587,-5.6474294660607605,1.766124968180165,-3.6591817736552423,-9.278803314452727,-1.6319991168627919,-0.5173464981965932,-5.48814263591578,1.4491586624423132,1.3154380086384183,-29.21781760924049 +4.040043622207428,2.958969644024201,3.0486611304206317,-3.675716963519138,5.748644439719078,0.9828876719935877,-1.3716360964021987,2.5202496188211416,-2.786853310994914,0.25478489213516475,17.26062231334612 +4.734113769644406,7.728057734474156,8.421143945903832,0.07265850366198379,0.4055022948113809,5.99740821527673,-3.7109861651159743,6.747647246901373,-0.11716706965153101,-7.682865513294632,22.84154755258513 +-8.558817058541127,6.839864220789263,-8.888641661862442,-4.387771277326882,-3.317399189969084,-6.540111096168124,-3.7221326039602154,4.853851334501712,-9.706343128798585,6.54346849041373,-11.286319120658824 +7.130960471491164,-2.5547685361690364,-6.9277420187873044,2.0168081589016182,-7.606548882702113,-2.7016127784349493,9.168583618019447,9.909289451672741,5.442097827091711,-3.7807698015846753,1.4959044553969845 +3.75330098332185,4.108127309680254,-2.2431660967270055,2.8177726917231887,-9.785447100486476,-5.818846827955171,0.5017660593452238,-6.724973914834083,-6.681862642469327,6.726085811004758,-17.05069780764376 +9.78266005367211,1.119388560568968,6.78139461763427,9.80643328652545,-7.168082228624506,-1.0350877349129775,-2.1485456831616023,-8.3990143270763,5.10660345589489,-1.3244194535481402,-6.5088868222053735 +-0.6134613161919749,-6.986540523735196,-6.3814669553826375,8.142072443124299,-9.107018220514423,-5.342954301125875,-4.158813393709433,-0.19604915196827122,1.7289034602959177,-0.13420048298666742,-30.65250711556441 +-8.31769330886236,-5.126650918885729,6.871767695250824,2.751774009569182,2.982981002685488,3.4040651070270993,5.258060380790582,-8.837830365571053,-2.6678323013477527,0.790548705233574,1.9923808799101839 +-3.2308703340534795,6.889577465743731,-0.3485498282541215,5.3725517891875825,7.0403103376233815,0.09582965806996135,8.191044877426997,1.7424788107396125,7.005485976674436,-3.188184088169514,30.795830741765336 +-0.023660829370296454,0.6282208200915544,-7.900405682078588,-2.028949865969187,8.346753451033521,2.616644807294847,-6.44986835126065,-3.2228872878079002,-6.167939806746004,-9.50353736402855,-7.503208104122554 +8.549209170080534,-1.0358534348625703,-3.849298551584277,1.9695438311547324,-9.853710874139686,-4.439557867983723,4.060669313977851,2.675395461385259,9.636118950850708,2.4071541931608813,-5.040946052534432 +-0.44988252744534485,5.2286512636801525,8.066557439281063,4.413918934367032,9.264224470987592,5.640103414763544,7.336028765238531,-7.717918576327256,4.648270059875754,-1.1982260094526271,37.15362993363959 +1.0620760482255047,3.0820481896471357,9.39630233411139,9.691561628632492,-4.235435090241895,4.675069948758324,4.999670758705372,-3.0701427737390237,-7.52260450271558,-9.181060794285605,5.007129454961237 +5.546862550583571,-0.2060051636618816,9.710803389898523,-0.7005308761269387,9.558339581476805,-1.768479956118803,5.8736430111994515,-8.303614553763358,1.1092342027552782,6.041195739714485,22.30374801370555 +8.494033344397774,6.4516618123486325,-9.260585455976516,-2.545953173865316,-9.026030553722975,-7.814354177708839,3.5061125733496823,4.265163926233964,5.474413655032526,7.309130961113258,-0.08150541187913818 +4.788629369530197,6.017431842132641,-9.020725803534415,-5.309296991174028,2.4379554675049153,7.162506092496464,-9.909997501206817,0.2925868423269957,3.5457479872879443,-9.407854217427737,3.7856666392503415 +-1.9728888489322411,7.912697627673936,3.432256177117175,-5.246832732788054,7.0556225926382545,-3.0393715318097136,7.06689342288119,-4.02112697762189,1.8064050176629802,-2.0611986450433184,12.300309560242255 +-4.503498984898659,7.731151243437385,-6.248126361210174,-8.303768175284738,-3.161461229086793,4.352782952831351,6.148632119525633,9.974867401335295,-4.072758859776702,-1.841160977374356,17.8339567764448 +-7.263574439407474,1.4974385924606715,9.951600745258343,4.01762020241317,1.9042568082674354,-2.15261814156412,8.305975205711096,-0.061668077393012055,-7.31266173373877,-2.6924307360173305,5.443628771745907 +-8.656666623044663,-5.960419246224369,-9.646624380001755,-0.9344016699967312,2.6908052990359437,-3.134150752421845,-1.5923645698944568,9.18418545689152,5.03926243149831,0.8171327388990246,-3.5136842885802055 +-4.309182497763495,7.939935975459903,-5.29805766238681,-3.4931453896664593,8.18129628845897,0.5908411057014469,4.846358988359533,1.814895883275323,3.068784180189903,-4.012334169703489,21.260540938562855 +-5.172558767466741,-3.5501530566266943,-6.891168718331551,7.486287305816148,-4.335061334997718,1.2297878882876923,5.839488502827482,5.676482187514271,-1.232274828316143,-0.4748538282654877,4.617244237105142 +9.894034978700496,3.4919495395804816,6.292768862357654,8.05107938438464,5.751796724586784,-6.296413100928648,1.2434146747514436,-7.9621168537091025,3.058442531279969,9.106988563756218,20.199586727161858 +0.2546412860022258,-1.3405501426446556,-9.283144971636737,9.195490446584408,-7.939946317396824,-9.178418133903062,-5.07866776990123,-8.689391321632352,-0.8976431517647541,0.321756025142248,-40.09836118881421 +-3.748601019428321,-8.980790348502278,-7.7679926350154656,-2.3099124402014386,-8.789430983469277,3.9637945121982696,-5.85958916950376,-3.9585686243272296,-2.11748445643805,-1.6678073386170418,-32.59382112117371 +-9.966785846503988,-7.758592580026049,7.255291274817562,-9.975338749761837,0.1633471162575013,-0.20995986985583848,-3.338116779787244,-1.3734595970710082,5.611622750531687,6.8240741242991305,-10.57652861096004 +-4.793029131694999,-3.5501911806454034,-5.1503429394333455,-0.40273198897869733,3.6651671531762595,-5.434942490731589,-3.3852851589026667,8.607692351783008,-9.028614203060839,-0.7846078952086764,-9.99576787494542 +4.231160831935556,-6.990919768850519,-9.052519599890363,-7.235892567229385,8.376463870613659,-9.814804363577531,-6.233560503772964,-9.37432974196711,-7.787410648755935,2.4029857325659254,-35.02217429290398 +-5.167221825218284,1.384241008613536,1.8039076553225222,6.988706661795582,-9.905172141762522,7.067389186847336,2.38238172853948,-6.745130277900849,5.458747762705681,7.109830835811714,11.862312514460987 +-4.914730324916854,8.375873618053618,-0.9108513940268441,2.06848908666643,9.692990672352874,-2.7692784272160136,6.263186916402258,-3.6320176434308067,5.98427044482982,2.0146783772528494,26.337817559252866 +-5.672886095491972,-1.7194781242152715,-3.647287312728766,-8.437832138392722,-9.40330459800605,-3.070426891856382,-9.619317043650268,-6.690244848364499,4.503666417017376,4.161824713671757,-39.00487840381594 +4.771607729147654,-3.6569365774004243,7.800389142353911,1.8766109605689518,-7.4794731650674695,-7.125626770889317,3.8619085385940295,-6.541121271158438,0.14585403164086586,9.835489518574214,-12.640017182989723 +-9.91984790533321,-9.668403962048862,9.861691638610132,1.6927766826833093,-7.461800489629738,7.946043995081872,7.607606002553844,0.724008262227505,2.4358405972151314,-4.536256169982473,-3.0942750900273346 +-8.989606072559898,1.8913521778172875,-4.10489613594474,3.272420933207039,6.724903536852025,-9.636789121712718,1.9142754937145483,-5.374389206262955,7.477769958076028,-4.92670986876343,-15.911021352431318 +2.2154026647083658,1.0708168017922297,-2.0766699988150217,3.5524152719958817,4.515392694308677,1.3387559063877355,5.1684447436950816,9.668341519858753,-1.6145522419838976,0.29166103771061813,30.602910880008565 +-9.750602441175735,5.920571126207568,0.40460134091987676,-1.840771392788696,-8.118560738212084,7.793128433507945,-2.0998551991888714,3.651631964184407,-7.012516872636985,9.230992590820652,17.772442559783883 +-6.431164763563382,-6.0091601420101926,7.179657211154275,8.251654882838622,-5.757051849533972,-0.6039822365034411,4.669898091256597,7.567314676216032,-2.418946099253896,0.340389736988584,1.6727862016411295 +4.834328210394698,4.622719533055907,5.659202600521699,1.3986763728305274,-7.907698063904496,8.079465817560802,7.311450786420565,5.96194871636666,-8.00275045678541,-5.912052658371416,19.434839996957898 +4.872007302153039,-9.537198108361071,9.584492674145594,-2.457106392886386,4.3862506738164715,7.751421769760867,-2.1074022369983547,-3.6173502280066794,2.1748225779649353,1.619787474961015,13.191132717490275 +-1.8172004475040566,2.03549511735417,8.707627391329893,-0.6471948674680696,-6.0651563849873735,-2.4558803423399223,-2.1178603481376275,-7.377826139475603,-6.742569988908902,3.691241467873546,-16.089145232342574 +-3.210444915821946,9.097967837116151,-5.1280650928278515,-8.021509897903554,5.070091260005158,7.620721038357402,-4.437732862570243,-5.95823796709044,-6.284677302578256,0.44024602733024665,14.53085327275415 +-0.6316671750645817,-4.811203202909315,-9.096537660211473,-0.37017319347438615,9.186646952712167,3.0503840150532646,-0.08986886742763112,-7.786158519407678,-4.951274189008254,-4.1045210085091455,-3.1175476522411123 +5.296071052144686,7.534215945292388,8.032837071328768,9.691372165015082,9.647333662090649,9.05998265535963,-8.563557189942312,-7.244129281443897,-3.910669470479342,1.057965081289229,39.62105002947435 +-8.060442225890414,6.91593915604285,2.3351235815461813,0.847288046044099,-6.693773532654177,-4.934890511996053,-6.793759500354839,7.038663155895971,1.6845572012243633,4.702588550392669,-3.8880901429864805 +-4.079342741799485,-2.574947258234457,-1.902900711469325,5.200299434880698,5.447059753491361,-5.863729449719366,8.83077713476198,-7.586893251126272,7.922441648472606,-7.992087087003814,-11.251126178112324 +-4.709203776973778,6.929570721359141,-6.410158553078251,-1.7286413738006026,-1.0028140011174749,-5.094820539535807,4.204904026719731,7.026692988044076,7.491502797111437,-3.213557085268781,3.612082205849504 +0.6170078857562888,-5.03187192268697,-5.104069968997091,-6.774918742961518,8.800380216150295,7.759776572111598,5.547174266553846,0.35323042575457997,-0.18784168976256232,0.5949133236499584,24.750330831976175 +0.7313602715417851,-1.3087383060461928,-7.364903342158651,-7.48672294262928,9.044994316913666,-0.35938480827298847,9.06411049810378,-6.728462445797801,1.0883310407986713,-5.845654932969215,-0.10066581655487254 +-4.93630787746797,-9.398908424776424,-7.620933785195774,8.336968152583914,-3.5693401703533656,2.1625842382918314,-0.6997173602145406,-1.9909750950944343,0.6377218269213625,-6.25522110769317,-19.987041906212912 +9.772077970391532,6.366157374077261,4.832292654630306,-0.6248140597209506,-6.942457557473281,8.413317165471355,-3.1722586523654472,-8.997866206061325,-3.1519264637874267,5.889140609917687,15.587095192347231 +2.4541748997641637,5.0167716948971925,5.872707677247549,-5.760907778389148,8.475666321863603,-1.2402079415925478,2.7802729852832915,-9.95382454826516,9.86736996822356,-4.382072280716898,6.905570392462605 diff --git a/test_ElasticNetModel.py b/test_ElasticNetModel.py new file mode 100644 index 0000000..92d4e7b --- /dev/null +++ b/test_ElasticNetModel.py @@ -0,0 +1,234 @@ +import os +import csv +import numpy as np +import pytest +from ElasticNet import ElasticNetModel +from generate_regression_data import linear_data_generator + +def load_small_test_data(filename="small_test.csv"): + """ + Load data from small_test.csv and return feature matrix X and target vector y. + """ + current_dir = os.path.dirname(__file__) + data_path = os.path.join(current_dir, filename) + + data = [] + try: + with open(data_path, "r") as file: + reader = csv.DictReader(file) + for row in reader: + data.append(row) + except FileNotFoundError: + pytest.fail(f"Test data file not found at {data_path}") + + X = np.array([[float(v) for k, v in datum.items() if k.startswith('x')] for datum in data]) + y = np.array([float(datum['y']) for datum in data]) + + return X, y + + +def generate_synthetic_data(n_samples=100,n_features=10,noise=0.1,seed=42): + """ + Generate synthetic regression data using the linear_data_generator function. + """ + np.random.seed(seed) + m=np.random.randn(n_features) + b=np.random.randn() + + rnge=(-10,10) + + scale=noise + + X,y=linear_data_generator(m,b,rnge,n_samples,scale,seed) + + return X,y + + +@pytest.fixture(scope="module") +def small_test_dataset(): + + """ + Fixture to provide small_test.csv data. + """ + + return load_small_test_data() + + +@pytest.fixture(scope="module") +def synthetic_test_dataset(): + + """ + Fixture to provide synthetic regression data. + """ + + return generate_synthetic_data() + + +def test_elasticnet_fit_predict_small_test(small_test_dataset): + + """ + Test the fit and predict methods of ElasticNetModel using small_test.csv. + """ + + X,y=small_test_dataset + print(f"Small Test Data: X shape {X.shape}, y shape {y.shape}") + + + model=ElasticNetModel(alpha=0.1,l1_ratio=0.5,fit_intercept=True,max_iter=10000,tolerance=1e-6, + learning_rate=0.05, + optimization='batch',random_state=101) + + + model.fit(X,y) + + + y_pred=model.predict(X) + + + mse=np.mean((y-y_pred)**2) + + + r2=1-mse/np.var(y) + + + assert mse<10,f"MSE is too high: {mse}" + + + assert r2>0.8,f"R-squared is too low: {r2}" + + +def test_elasticnet_fit_predict_synthetic(synthetic_test_dataset): + + """ + Test the fit and predict methods of ElasticNetModel using synthetic regression data. + """ + + X,y=synthetic_test_dataset + print(f"Synthetic Test Data: X shape {X.shape}, y shape {y.shape}") + + + model=ElasticNetModel(alpha=0.1,l1_ratio=0.5,fit_intercept=True,max_iter=10000,tolerance=1e-6, + learning_rate=0.5, + optimization='batch',random_state=101) + + + model.fit(X,y) + + + y_pred=model.predict(X) + + + mse=np.mean((y-y_pred)**2) + + + r2=1-mse/np.var(y) + + + assert mse<10,f"MSE is too high: {mse}" + + + assert r2>0.8,f"R-squared is too low: {r2}" + + +def test_zero_variance_feature_small_test(small_test_dataset): + + """ + Test the model's ability to handle a zero variance feature using small_test.csv. + """ + + X,y=[array.copy()for array in small_test_dataset] + + + # Introduce a zero variance feature by setting the first feature to a constant + + + X[:,0]=5.0 + + + model=ElasticNetModel(alpha=0.05,l1_ratio=0.5,fit_intercept=True,max_iter=10000,tolerance=1e-9, + learning_rate=0.05, + optimization='batch',random_state=101) + + + model.fit(X,y) + + + y_pred=model.predict(X) + + + mse=np.mean((y-y_pred)**2) + + + r2=1-mse/np.var(y) + + + assert mse<10,f"MSE is too high with zero variance feature: {mse}" + + + assert r2>0.8,f"R-squared is too low with zero variance feature: {r2}" + + +def test_zero_variance_feature_synthetic(synthetic_test_dataset): + + + """ + Test the model's ability to handle a zero variance feature using synthetic data. + """ + + + X,y=[array.copy()for array in synthetic_test_dataset] + + + # Introduce a zero variance feature by setting the second feature to a constant + + + X[:,1]=10.0 + + + model=ElasticNetModel(alpha=0.1,l1_ratio=0.5,fit_intercept=True,max_iter=10000,tolerance=1e-6, + learning_rate=0.05, + optimization='batch',random_state=101) + + + model.fit(X,y) + + + y_pred=model.predict(X) + + + mse=np.mean((y-y_pred)**2) + + + r2=1-mse/np.var(y) + + + assert mse<10,f"MSE is too high with zero variance feature: {mse}" + + + assert r2>0.8,f"R-squared is too low with zero variance feature: {r2}" + + +def test_invalid_optimization_option_small_test(small_test_dataset): + + + """ + Test that providing an invalid optimization algorithm raises a ValueError using small_test.csv. + """ + + + X,y=[array.copy()for array in small_test_dataset] + + + with pytest.raises(ValueError): + + model=ElasticNetModel(alpha=0.1,l1_ratio=0.5,fit_intercept=True,max_iter= + 10000,tolerance= + 1e-6, + learning_rate= + 0.01, + optimization= + 'invalid_option',random_state= + 10) + model.fit(X,y) + +