diff --git "a/A2/.ipynb_checkpoints/ml_experiments-checkpoint.ipynb" "b/A2/.ipynb_checkpoints/ml_experiments-checkpoint.ipynb"
new file mode 100644--- /dev/null
+++ "b/A2/.ipynb_checkpoints/ml_experiments-checkpoint.ipynb"
@@ -0,0 +1,1733 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ML Baseline & Feature Engineering: Automated Movement Assessment\n",
+    "## 4DV652 - Data Intensive Systems\n",
+    "\n",
+    "**Project:** Automated Movement Assessment (AIMO)  \n",
+    "**Task:** Develop baseline linear regression model and explore feature engineering techniques\n",
+    "\n",
+    "### Context\n",
+    "This project develops a data-driven system to automatically assess human movement quality (Deep Squat exercise) based on:\n",
+    "- **Input:** 3D skeleton sequences from Kinect camera (40 features after preprocessing)\n",
+    "- **Output:** AimoScore (expert quality score 0-100)\n",
+    "- **Goal:** Train ML models to predict expert scores from movement features\n",
+    "\n",
+    "### Key Insights from Domain Knowledge\n",
+    "- Features include **38 movement features** (angle deviations) + **2 time features**\n",
+    "- Some features may be **identical or highly correlated** (to be removed)\n",
+    "- **Left-right symmetry constraints** should be enforced (e.g., left vs right knee)\n",
+    "- Feature deviations are weighted by domain experts (larger deviation = worse movement)\n",
+    "\n",
+    "### Dataset\n",
+    "- **Records:** 2095 deep squat assessments\n",
+    "- **Features:** 40 (38 movement angles + 2 timing)\n",
+    "- **Target:** AimoScore (continuous, 0-100)\n",
+    "- **Ground Truth:** Expert assessments from AIMO methodology"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 0: Setup & Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ All imports successful\n",
+      "✓ Numpy version: 2.2.6\n",
+      "✓ Pandas version: 2.3.3\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from sklearn.model_selection import train_test_split, cross_val_score\n",
+    "from sklearn.linear_model import LinearRegression, Lasso, LassoCV\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.feature_selection import RFE, mutual_info_regression\n",
+    "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error, mean_absolute_percentage_error\n",
+    "from scipy import stats\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "# Set style\n",
+    "sns.set_style('whitegrid')\n",
+    "plt.rcParams['figure.figsize'] = (14, 7)\n",
+    "\n",
+    "print(\"✓ All imports successful\")\n",
+    "print(f\"✓ Numpy version: {np.__version__}\")\n",
+    "print(f\"✓ Pandas version: {pd.__version__}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 1: Load and Explore Data\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- Loading the A2_dataset.csv with movement assessment data\n",
+    "- Exploring structure: 2095 records with 42 features\n",
+    "- Identifying AimoScore as target variable\n",
+    "- Checking for missing values and data quality\n",
+    "\n",
+    "**What to expect:**\n",
+    "- Dataset shape: (2095, 42) or (2095, 43) depending on if target is included\n",
+    "- Target: AimoScore column (continuous values 0-100)\n",
+    "- 38 FMS/NASM angle features (large values = bad movement)\n",
+    "- 2 time-based features (timing deviations)\n",
+    "- Potentially some identical or highly correlated features\n",
+    "- No missing values expected\n",
+    "\n",
+    "**Data-driven insights:**\n",
+    "- Understand feature distributions\n",
+    "- Identify potential outliers\n",
+    "- See which features correlate with quality assessment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================================================================\n",
+      "DATASET EXPLORATION\n",
+      "================================================================================\n",
+      "\n",
+      "Dataset Shape: (1675, 42)\n",
+      "Records: 1675, Features: 42\n",
+      "\n",
+      "First 5 rows:\n",
+      "   AimoScore  No_1_Angle_Deviation  No_2_Angle_Deviation  \\\n",
+      "0   0.653711              0.361071              0.561932   \n",
+      "1   0.866667              0.279770              0.868006   \n",
+      "2   0.900765              0.279770              0.103778   \n",
+      "3   0.972904              0.279770              0.626016   \n",
+      "4   0.721837              0.279770              0.092300   \n",
+      "\n",
+      "   No_3_Angle_Deviation  No_4_Angle_Deviation  No_5_Angle_Deviation  \\\n",
+      "0              0.346724              0.337159              0.259684   \n",
+      "1              0.346724              0.188905              0.331899   \n",
+      "2              0.346724              0.225729              0.523673   \n",
+      "3              0.512195              0.188905              0.163080   \n",
+      "4              0.346724              0.634146              0.698231   \n",
+      "\n",
+      "   No_6_Angle_Deviation  No_7_Angle_Deviation  No_8_Angle_Deviation  \\\n",
+      "0              0.204687              0.194165              0.528455   \n",
+      "1              0.142516              0.456241              0.521760   \n",
+      "2              0.842659              0.838355              0.521760   \n",
+      "3              0.140124              0.194165              0.521760   \n",
+      "4              0.585366              0.797226              0.521760   \n",
+      "\n",
+      "   No_9_Angle_Deviation  ...  No_19_NASM_Deviation  No_20_NASM_Deviation  \\\n",
+      "0              0.616451  ...              0.670971              0.656624   \n",
+      "1              0.511239  ...              0.670971              0.912004   \n",
+      "2              0.746055  ...              0.681492              0.656624   \n",
+      "3              0.156385  ...              0.670971              0.656624   \n",
+      "4              0.156385  ...              0.714491              0.656624   \n",
+      "\n",
+      "   No_21_NASM_Deviation  No_22_NASM_Deviation  No_23_NASM_Deviation  \\\n",
+      "0              0.642276              0.552846              0.648972   \n",
+      "1              0.733142              0.598757              0.648972   \n",
+      "2              0.642276              0.572453              0.648972   \n",
+      "3              0.642276              0.552846              0.648972   \n",
+      "4              0.839790              0.772836              0.648972   \n",
+      "\n",
+      "   No_24_NASM_Deviation  No_25_NASM_Deviation  No_1_Time_Deviation  \\\n",
+      "0              0.578192              0.380679             0.256337   \n",
+      "1              0.578192              0.794357             0.148733   \n",
+      "2              0.578192              0.308943             0.148733   \n",
+      "3              0.578192              0.308943             0.352463   \n",
+      "4              0.578192              0.308943             0.148733   \n",
+      "\n",
+      "   No_2_Time_Deviation  EstimatedScore  \n",
+      "0             0.264467        0.110952  \n",
+      "1             0.151124        0.176949  \n",
+      "2             0.151124        0.312291  \n",
+      "3             0.197513        0.008608  \n",
+      "4             0.151124        0.498326  \n",
+      "\n",
+      "[5 rows x 42 columns]\n",
+      "\n",
+      "Column names:\n",
+      "['AimoScore', 'No_1_Angle_Deviation', 'No_2_Angle_Deviation', 'No_3_Angle_Deviation', 'No_4_Angle_Deviation', 'No_5_Angle_Deviation', 'No_6_Angle_Deviation', 'No_7_Angle_Deviation', 'No_8_Angle_Deviation', 'No_9_Angle_Deviation', 'No_10_Angle_Deviation', 'No_11_Angle_Deviation', 'No_12_Angle_Deviation', 'No_13_Angle_Deviation', 'No_1_NASM_Deviation', 'No_2_NASM_Deviation', 'No_3_NASM_Deviation', 'No_4_NASM_Deviation', 'No_5_NASM_Deviation', 'No_6_NASM_Deviation', 'No_7_NASM_Deviation', 'No_8_NASM_Deviation', 'No_9_NASM_Deviation', 'No_10_NASM_Deviation', 'No_11_NASM_Deviation', 'No_12_NASM_Deviation', 'No_13_NASM_Deviation', 'No_14_NASM_Deviation', 'No_15_NASM_Deviation', 'No_16_NASM_Deviation', 'No_17_NASM_Deviation', 'No_18_NASM_Deviation', 'No_19_NASM_Deviation', 'No_20_NASM_Deviation', 'No_21_NASM_Deviation', 'No_22_NASM_Deviation', 'No_23_NASM_Deviation', 'No_24_NASM_Deviation', 'No_25_NASM_Deviation', 'No_1_Time_Deviation', 'No_2_Time_Deviation', 'EstimatedScore']\n",
+      "\n",
+      "Data types:\n",
+      "AimoScore                float64\n",
+      "No_1_Angle_Deviation     float64\n",
+      "No_2_Angle_Deviation     float64\n",
+      "No_3_Angle_Deviation     float64\n",
+      "No_4_Angle_Deviation     float64\n",
+      "No_5_Angle_Deviation     float64\n",
+      "No_6_Angle_Deviation     float64\n",
+      "No_7_Angle_Deviation     float64\n",
+      "No_8_Angle_Deviation     float64\n",
+      "No_9_Angle_Deviation     float64\n",
+      "No_10_Angle_Deviation    float64\n",
+      "No_11_Angle_Deviation    float64\n",
+      "No_12_Angle_Deviation    float64\n",
+      "No_13_Angle_Deviation    float64\n",
+      "No_1_NASM_Deviation      float64\n",
+      "No_2_NASM_Deviation      float64\n",
+      "No_3_NASM_Deviation      float64\n",
+      "No_4_NASM_Deviation      float64\n",
+      "No_5_NASM_Deviation      float64\n",
+      "No_6_NASM_Deviation      float64\n",
+      "No_7_NASM_Deviation      float64\n",
+      "No_8_NASM_Deviation      float64\n",
+      "No_9_NASM_Deviation      float64\n",
+      "No_10_NASM_Deviation     float64\n",
+      "No_11_NASM_Deviation     float64\n",
+      "No_12_NASM_Deviation     float64\n",
+      "No_13_NASM_Deviation     float64\n",
+      "No_14_NASM_Deviation     float64\n",
+      "No_15_NASM_Deviation     float64\n",
+      "No_16_NASM_Deviation     float64\n",
+      "No_17_NASM_Deviation     float64\n",
+      "No_18_NASM_Deviation     float64\n",
+      "No_19_NASM_Deviation     float64\n",
+      "No_20_NASM_Deviation     float64\n",
+      "No_21_NASM_Deviation     float64\n",
+      "No_22_NASM_Deviation     float64\n",
+      "No_23_NASM_Deviation     float64\n",
+      "No_24_NASM_Deviation     float64\n",
+      "No_25_NASM_Deviation     float64\n",
+      "No_1_Time_Deviation      float64\n",
+      "No_2_Time_Deviation      float64\n",
+      "EstimatedScore           float64\n",
+      "dtype: object\n",
+      "\n",
+      "Missing values:\n",
+      "✓ No missing values found\n",
+      "\n",
+      "Basic Statistics:\n",
+      "         AimoScore  No_1_Angle_Deviation  No_2_Angle_Deviation  \\\n",
+      "count  1675.000000           1675.000000           1675.000000   \n",
+      "mean      0.575319              0.539129              0.502094   \n",
+      "std       0.237320              0.238810              0.281690   \n",
+      "min       0.010000              0.279770              0.092300   \n",
+      "25%       0.409259              0.279770              0.246055   \n",
+      "50%       0.623084              0.501196              0.494500   \n",
+      "75%       0.761946              0.749641              0.745815   \n",
+      "max       0.993987              1.000000              1.000000   \n",
+      "\n",
+      "       No_3_Angle_Deviation  No_4_Angle_Deviation  No_5_Angle_Deviation  \\\n",
+      "count           1675.000000           1675.000000           1675.000000   \n",
+      "mean               0.559657              0.516177              0.511224   \n",
+      "std                0.219129              0.262952              0.272035   \n",
+      "min                0.346724              0.188905              0.163080   \n",
+      "25%                0.346724              0.247728              0.242229   \n",
+      "50%                0.497370              0.496413              0.497848   \n",
+      "75%                0.753945              0.747250              0.748207   \n",
+      "max                1.000000              1.000000              1.000000   \n",
+      "\n",
+      "       No_6_Angle_Deviation  No_7_Angle_Deviation  No_8_Angle_Deviation  \\\n",
+      "count           1675.000000           1675.000000           1675.000000   \n",
+      "mean               0.504162              0.516320              0.635480   \n",
+      "std                0.273288              0.264328              0.152102   \n",
+      "min                0.140124              0.194165              0.303247   \n",
+      "25%                0.242229              0.243424              0.521760   \n",
+      "50%                0.493066              0.493066              0.521760   \n",
+      "75%                0.737685              0.749163              0.749880   \n",
+      "max                1.000000              1.000000              1.000000   \n",
+      "\n",
+      "       No_9_Angle_Deviation  ...  No_19_NASM_Deviation  No_20_NASM_Deviation  \\\n",
+      "count           1675.000000  ...           1675.000000           1675.000000   \n",
+      "mean               0.515840  ...              0.723809              0.715658   \n",
+      "std                0.271632  ...              0.094203              0.100324   \n",
+      "min                0.156385  ...              0.670971              0.656624   \n",
+      "25%                0.253706  ...              0.670971              0.656624   \n",
+      "50%                0.506456  ...              0.670971              0.656624   \n",
+      "75%                0.756337  ...              0.741511              0.750598   \n",
+      "max                1.000000  ...              1.000000              1.000000   \n",
+      "\n",
+      "       No_21_NASM_Deviation  No_22_NASM_Deviation  No_23_NASM_Deviation  \\\n",
+      "count           1675.000000           1675.000000           1675.000000   \n",
+      "mean               0.706262              0.652765              0.709920   \n",
+      "std                0.106136              0.140646              0.102617   \n",
+      "min                0.640401              0.525310              0.648972   \n",
+      "25%                0.642276              0.552846              0.648972   \n",
+      "50%                0.642276              0.552846              0.648972   \n",
+      "75%                0.747967              0.749880              0.747489   \n",
+      "max                1.000000              1.000000              1.000000   \n",
+      "\n",
+      "       No_24_NASM_Deviation  No_25_NASM_Deviation  No_1_Time_Deviation  \\\n",
+      "count           1675.000000           1675.000000          1675.000000   \n",
+      "mean               0.668300              0.549950             0.513675   \n",
+      "std                0.130992              0.228300             0.273739   \n",
+      "min                0.578192              0.308943             0.148733   \n",
+      "25%                0.578192              0.308943             0.250598   \n",
+      "50%                0.578192              0.506456             0.502152   \n",
+      "75%                0.750598              0.747250             0.750598   \n",
+      "max                1.000000              1.000000             1.000000   \n",
+      "\n",
+      "       No_2_Time_Deviation  EstimatedScore  \n",
+      "count          1675.000000     1675.000000  \n",
+      "mean              0.513174        0.496979  \n",
+      "std               0.273313        0.289519  \n",
+      "min               0.151124        0.000478  \n",
+      "25%               0.248207        0.246055  \n",
+      "50%               0.505500        0.496413  \n",
+      "75%               0.749641        0.744859  \n",
+      "max               1.000000        1.000000  \n",
+      "\n",
+      "[8 rows x 42 columns]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load dataset\n",
+    "df = pd.read_csv('/Users/reemothman/Downloads/Data-intensive-systems/Datasets_all/A2_dataset_80.csv')  # Update path as needed\n",
+    "\n",
+    "print(\"=\"*80)\n",
+    "print(\"DATASET EXPLORATION\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nDataset Shape: {df.shape}\")\n",
+    "print(f\"Records: {df.shape[0]}, Features: {df.shape[1]}\")\n",
+    "\n",
+    "print(f\"\\n{'First 5 rows:'}\")\n",
+    "print(df.head())\n",
+    "\n",
+    "print(f\"\\n{'Column names:'}\")\n",
+    "print(df.columns.tolist())\n",
+    "\n",
+    "print(f\"\\n{'Data types:'}\")\n",
+    "print(df.dtypes)\n",
+    "\n",
+    "print(f\"\\n{'Missing values:'}\")\n",
+    "missing = df.isnull().sum()\n",
+    "if missing.sum() > 0:\n",
+    "    print(missing[missing > 0])\n",
+    "else:\n",
+    "    print(\"✓ No missing values found\")\n",
+    "\n",
+    "print(f\"\\n{'Basic Statistics:'}\")\n",
+    "print(df.describe())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Target Variable:\n",
+      "Column: AimoScore\n",
+      "\n",
+      "Statistics:\n",
+      "count    1675.000000\n",
+      "mean        0.575319\n",
+      "std         0.237320\n",
+      "min         0.010000\n",
+      "25%         0.409259\n",
+      "50%         0.623084\n",
+      "75%         0.761946\n",
+      "max         0.993987\n",
+      "Name: AimoScore, dtype: float64\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Target statistics:\n",
+      "  Min: 0.01\n",
+      "  Max: 0.99\n",
+      "  Mean: 0.58\n",
+      "  Std: 0.24\n",
+      "  Skewness: -0.6940\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Identify target variable and prepare data\n",
+    "# Check for AimoScore column\n",
+    "if 'AimoScore' in df.columns:\n",
+    "    target_col = 'AimoScore'\n",
+    "else:\n",
+    "    # If not found, it's likely the last column\n",
+    "    target_col = df.columns[-1]\n",
+    "    print(f\"⚠ AimoScore not found, using last column: {target_col}\")\n",
+    "\n",
+    "print(f\"\\n{'Target Variable:'}\")\n",
+    "print(f\"Column: {target_col}\")\n",
+    "print(f\"\\nStatistics:\")\n",
+    "print(df[target_col].describe())\n",
+    "\n",
+    "# Visualize target distribution\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
+    "\n",
+    "axes[0].hist(df[target_col], bins=30, edgecolor='black', alpha=0.7)\n",
+    "axes[0].set_xlabel('AimoScore')\n",
+    "axes[0].set_ylabel('Frequency')\n",
+    "axes[0].set_title('Distribution of Target Variable (AimoScore)')\n",
+    "axes[0].grid(True, alpha=0.3)\n",
+    "\n",
+    "axes[1].boxplot(df[target_col])\n",
+    "axes[1].set_ylabel('AimoScore')\n",
+    "axes[1].set_title('Boxplot of Target Variable')\n",
+    "axes[1].grid(True, alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"\\nTarget statistics:\")\n",
+    "print(f\"  Min: {df[target_col].min():.2f}\")\n",
+    "print(f\"  Max: {df[target_col].max():.2f}\")\n",
+    "print(f\"  Mean: {df[target_col].mean():.2f}\")\n",
+    "print(f\"  Std: {df[target_col].std():.2f}\")\n",
+    "print(f\"  Skewness: {stats.skew(df[target_col]):.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 2: Identify and Remove Duplicate/Identical Features\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- Finding features that are identical (same values across all rows)\n",
+    "- Finding features with extremely high correlation (>0.99)\n",
+    "- Removing duplicates to clean the feature space\n",
+    "\n",
+    "**What to expect:**\n",
+    "- Discover 1-3 pairs of identical/nearly-identical features\n",
+    "- Feature count reduction (42 → 39-41)\n",
+    "- Clean dataset without redundant information\n",
+    "- Improved feature stability\n",
+    "\n",
+    "**Domain context:**\n",
+    "- Some FMS features may duplicate NASM features (e.g., feature 5 = feature 14)\n",
+    "- Identical features provide no new information\n",
+    "- Highly correlated features increase multicollinearity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original feature set: 41 features\n",
+      "\n",
+      "================================================================================\n",
+      "DUPLICATE FEATURE DETECTION\n",
+      "================================================================================\n",
+      "\n",
+      "Identical features (correlation = 1.0): 5\n",
+      "  ✗ No_1_Angle_Deviation == No_3_NASM_Deviation (r=1.0000)\n",
+      "  ✗ No_5_Angle_Deviation == No_1_NASM_Deviation (r=1.0000)\n",
+      "  ✗ No_7_Angle_Deviation == No_2_NASM_Deviation (r=1.0000)\n",
+      "  ✗ No_10_Angle_Deviation == No_4_NASM_Deviation (r=1.0000)\n",
+      "  ✗ No_13_Angle_Deviation == No_5_NASM_Deviation (r=1.0000)\n",
+      "\n",
+      "Highly correlated features (correlation > 0.99): 0\n",
+      "  ✓ None found\n",
+      "\n",
+      "Features to remove: 5\n",
+      "  - No_3_NASM_Deviation\n",
+      "  - No_5_NASM_Deviation\n",
+      "  - No_4_NASM_Deviation\n",
+      "  - No_1_NASM_Deviation\n",
+      "  - No_2_NASM_Deviation\n",
+      "\n",
+      "Cleaned feature set: 36 features (removed 5)\n",
+      "✓ Clean dataset shape: (1675, 37)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Separate features from target\n",
+    "X = df.drop(target_col, axis=1)\n",
+    "y = df[target_col]\n",
+    "\n",
+    "print(f\"Original feature set: {X.shape[1]} features\")\n",
+    "\n",
+    "# Function to find duplicate features\n",
+    "def find_duplicate_features(X, threshold=0.99):\n",
+    "    \"\"\"\n",
+    "    Find identical features (correlation = 1.0) and highly correlated features\n",
+    "    \"\"\"\n",
+    "    correlation_matrix = X.corr().abs()\n",
+    "    duplicates = []\n",
+    "    identical = []\n",
+    "    \n",
+    "    for i in range(len(correlation_matrix.columns)):\n",
+    "        for j in range(i+1, len(correlation_matrix.columns)):\n",
+    "            corr_val = correlation_matrix.iloc[i, j]\n",
+    "            col_i = correlation_matrix.columns[i]\n",
+    "            col_j = correlation_matrix.columns[j]\n",
+    "            \n",
+    "            if corr_val == 1.0:\n",
+    "                identical.append((col_i, col_j, corr_val))\n",
+    "            elif corr_val >= threshold:\n",
+    "                duplicates.append((col_i, col_j, corr_val))\n",
+    "    \n",
+    "    return identical, duplicates\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"DUPLICATE FEATURE DETECTION\")\n",
+    "print(\"=\"*80)\n",
+    "\n",
+    "identical, highly_corr = find_duplicate_features(X, threshold=0.99)\n",
+    "\n",
+    "print(f\"\\nIdentical features (correlation = 1.0): {len(identical)}\")\n",
+    "if identical:\n",
+    "    for col1, col2, corr in identical:\n",
+    "        print(f\"  ✗ {col1} == {col2} (r={corr:.4f})\")\n",
+    "else:\n",
+    "    print(\"  ✓ None found\")\n",
+    "\n",
+    "print(f\"\\nHighly correlated features (correlation > 0.99): {len(highly_corr)}\")\n",
+    "if highly_corr:\n",
+    "    for col1, col2, corr in highly_corr:\n",
+    "        print(f\"  ✗ {col1} <-> {col2} (r={corr:.4f})\")\n",
+    "else:\n",
+    "    print(\"  ✓ None found\")\n",
+    "\n",
+    "# Identify columns to drop\n",
+    "cols_to_drop = set()\n",
+    "for col1, col2, _ in identical:\n",
+    "    cols_to_drop.add(col2)  # Keep first, drop second\n",
+    "for col1, col2, _ in highly_corr:\n",
+    "    cols_to_drop.add(col2)  # Keep first, drop second\n",
+    "\n",
+    "print(f\"\\nFeatures to remove: {len(cols_to_drop)}\")\n",
+    "if cols_to_drop:\n",
+    "    for col in cols_to_drop:\n",
+    "        print(f\"  - {col}\")\n",
+    "\n",
+    "# Create clean dataset\n",
+    "X_clean = X.drop(columns=list(cols_to_drop))\n",
+    "print(f\"\\nCleaned feature set: {X_clean.shape[1]} features (removed {len(cols_to_drop)})\")\n",
+    "\n",
+    "df_clean = df.drop(columns=list(cols_to_drop))\n",
+    "print(f\"✓ Clean dataset shape: {df_clean.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 3: Train Baseline Linear Regression Model\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- Split data into train (80%) and test (20%) sets\n",
+    "- Standardize all features (important for linear regression)\n",
+    "- Train linear regression using ALL clean features\n",
+    "- Evaluate on both train and test sets\n",
+    "\n",
+    "**What to expect:**\n",
+    "- **Baseline R² score:** ~0.35-0.55 (typical for movement assessment)\n",
+    "- **Overfitting gap:** Train R² > Test R² (shows some overfitting with all features)\n",
+    "- RMSE & MAE metrics showing prediction error magnitude\n",
+    "- This becomes your **reference point** - all other models compared against this\n",
+    "\n",
+    "**Why it matters:**\n",
+    "- Establishes the floor - \"what's the simplest possible model?\"\n",
+    "- If R² is low, feature engineering is critical\n",
+    "- If overfitting gap is large (>0.15), feature selection will help"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================================================================\n",
+      "DATA SPLIT\n",
+      "================================================================================\n",
+      "Training set: 1340 samples (80.0%)\n",
+      "Test set: 335 samples (20.0%)\n",
+      "Features: 36\n",
+      "\n",
+      "✓ Features scaled using StandardScaler\n",
+      "  Train mean: 0.0000, std: 1.0000\n",
+      "  Test mean: 0.0072, std: 1.0111\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Prepare data for modeling\n",
+    "X_final = X_clean\n",
+    "y_final = y\n",
+    "\n",
+    "# Train-test split\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X_final, y_final, test_size=0.2, random_state=42\n",
+    ")\n",
+    "\n",
+    "print(\"=\"*80)\n",
+    "print(\"DATA SPLIT\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"Training set: {X_train.shape[0]} samples ({X_train.shape[0]/len(X_final)*100:.1f}%)\")\n",
+    "print(f\"Test set: {X_test.shape[0]} samples ({X_test.shape[0]/len(X_final)*100:.1f}%)\")\n",
+    "print(f\"Features: {X_train.shape[1]}\")\n",
+    "\n",
+    "# Scale features\n",
+    "scaler = StandardScaler()\n",
+    "X_train_scaled = scaler.fit_transform(X_train)\n",
+    "X_test_scaled = scaler.transform(X_test)\n",
+    "\n",
+    "print(f\"\\n✓ Features scaled using StandardScaler\")\n",
+    "print(f\"  Train mean: {X_train_scaled.mean():.4f}, std: {X_train_scaled.std():.4f}\")\n",
+    "print(f\"  Test mean: {X_test_scaled.mean():.4f}, std: {X_test_scaled.std():.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "================================================================================\n",
+      "BASELINE MODEL - ALL FEATURES\n",
+      "================================================================================\n",
+      "\n",
+      "Training Performance:\n",
+      "  R² Score:  0.6156\n",
+      "  RMSE:      0.1491 (score points)\n",
+      "  MAE:       0.1143\n",
+      "\n",
+      "Test Performance (EVALUATION METRIC):\n",
+      "  R² Score:  0.4864  ← YOUR BENCHMARK\n",
+      "  RMSE:      0.1601 (score points)\n",
+      "  MAE:       0.1222\n",
+      "  MAPE:      0.7753\n",
+      "\n",
+      "Overfitting Analysis:\n",
+      "  Train R² - Test R² = 0.1293\n",
+      "  ⚠ Moderate overfitting (feature selection may help)\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Train baseline model (all features)\n",
+    "baseline_model = LinearRegression()\n",
+    "baseline_model.fit(X_train_scaled, y_train)\n",
+    "\n",
+    "# Predictions\n",
+    "y_train_pred_baseline = baseline_model.predict(X_train_scaled)\n",
+    "y_test_pred_baseline = baseline_model.predict(X_test_scaled)\n",
+    "\n",
+    "# Metrics\n",
+    "baseline_train_r2 = r2_score(y_train, y_train_pred_baseline)\n",
+    "baseline_test_r2 = r2_score(y_test, y_test_pred_baseline)\n",
+    "baseline_train_rmse = np.sqrt(mean_squared_error(y_train, y_train_pred_baseline))\n",
+    "baseline_test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred_baseline))\n",
+    "baseline_train_mae = mean_absolute_error(y_train, y_train_pred_baseline)\n",
+    "baseline_test_mae = mean_absolute_error(y_test, y_test_pred_baseline)\n",
+    "baseline_test_mape = mean_absolute_percentage_error(y_test, y_test_pred_baseline)\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"BASELINE MODEL - ALL FEATURES\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nTraining Performance:\")\n",
+    "print(f\"  R² Score:  {baseline_train_r2:.4f}\")\n",
+    "print(f\"  RMSE:      {baseline_train_rmse:.4f} (score points)\")\n",
+    "print(f\"  MAE:       {baseline_train_mae:.4f}\")\n",
+    "\n",
+    "print(f\"\\nTest Performance (EVALUATION METRIC):\")\n",
+    "print(f\"  R² Score:  {baseline_test_r2:.4f}  ← YOUR BENCHMARK\")\n",
+    "print(f\"  RMSE:      {baseline_test_rmse:.4f} (score points)\")\n",
+    "print(f\"  MAE:       {baseline_test_mae:.4f}\")\n",
+    "print(f\"  MAPE:      {baseline_test_mape:.4f}\")\n",
+    "\n",
+    "print(f\"\\nOverfitting Analysis:\")\n",
+    "baseline_gap = baseline_train_r2 - baseline_test_r2\n",
+    "print(f\"  Train R² - Test R² = {baseline_gap:.4f}\")\n",
+    "if baseline_gap < 0.05:\n",
+    "    print(f\"  ✓ Excellent generalization\")\n",
+    "elif baseline_gap < 0.10:\n",
+    "    print(f\"  ✓ Good generalization\")\n",
+    "elif baseline_gap < 0.15:\n",
+    "    print(f\"  ⚠ Moderate overfitting (feature selection may help)\")\n",
+    "else:\n",
+    "    print(f\"  ✗ Significant overfitting (feature selection recommended)\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1800x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualize baseline predictions\n",
+    "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n",
+    "\n",
+    "# Actual vs Predicted\n",
+    "axes[0].scatter(y_test, y_test_pred_baseline, alpha=0.5)\n",
+    "axes[0].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)\n",
+    "axes[0].set_xlabel('Actual AimoScore')\n",
+    "axes[0].set_ylabel('Predicted AimoScore')\n",
+    "axes[0].set_title(f'Baseline: Actual vs Predicted (R²={baseline_test_r2:.4f})')\n",
+    "axes[0].grid(True, alpha=0.3)\n",
+    "\n",
+    "# Residuals\n",
+    "residuals = y_test - y_test_pred_baseline\n",
+    "axes[1].scatter(y_test_pred_baseline, residuals, alpha=0.5)\n",
+    "axes[1].axhline(y=0, color='r', linestyle='--', lw=2)\n",
+    "axes[1].set_xlabel('Predicted AimoScore')\n",
+    "axes[1].set_ylabel('Residuals')\n",
+    "axes[1].set_title('Residual Plot')\n",
+    "axes[1].grid(True, alpha=0.3)\n",
+    "\n",
+    "# Residual distribution\n",
+    "axes[2].hist(residuals, bins=20, edgecolor='black', alpha=0.7)\n",
+    "axes[2].set_xlabel('Residuals')\n",
+    "axes[2].set_ylabel('Frequency')\n",
+    "axes[2].set_title(f'Residual Distribution (RMSE={baseline_test_rmse:.2f})')\n",
+    "axes[2].grid(True, alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 4: Feature Selection - Correlation-Based\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- Computing correlation of each feature with target (AimoScore)\n",
+    "- Removing weak predictors (correlation < 0.05)\n",
+    "- Keeping only features with meaningful relationship to target\n",
+    "\n",
+    "**What to expect:**\n",
+    "- Visualize top 15-20 features by correlation\n",
+    "- Remove 5-10 low-correlation features\n",
+    "- Test R² similar or slightly lower, but **better generalization** (smaller overfitting gap)\n",
+    "- Much simpler model, easier to interpret\n",
+    "\n",
+    "**Domain insights:**\n",
+    "- High-weight FMS/NASM features should have high correlation\n",
+    "- Time features may have lower correlation\n",
+    "- Identifies which movement angles actually matter for scoring"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================================================================\n",
+      "CORRELATION-BASED FEATURE SELECTION\n",
+      "================================================================================\n",
+      "\n",
+      "Top 20 features by absolute correlation with AimoScore:\n",
+      "EstimatedScore           0.571022\n",
+      "No_12_NASM_Deviation     0.489057\n",
+      "No_11_NASM_Deviation     0.473923\n",
+      "No_13_Angle_Deviation    0.418670\n",
+      "No_10_NASM_Deviation     0.408648\n",
+      "No_10_Angle_Deviation    0.379893\n",
+      "No_12_Angle_Deviation    0.332944\n",
+      "No_6_Angle_Deviation     0.318481\n",
+      "No_8_Angle_Deviation     0.302376\n",
+      "No_2_Time_Deviation      0.296228\n",
+      "No_5_Angle_Deviation     0.292375\n",
+      "No_11_Angle_Deviation    0.288521\n",
+      "No_9_NASM_Deviation      0.273587\n",
+      "No_1_Time_Deviation      0.267340\n",
+      "No_17_NASM_Deviation     0.262281\n",
+      "No_22_NASM_Deviation     0.248195\n",
+      "No_16_NASM_Deviation     0.242770\n",
+      "No_18_NASM_Deviation     0.238921\n",
+      "No_7_Angle_Deviation     0.238315\n",
+      "No_25_NASM_Deviation     0.228025\n",
+      "dtype: float64\n",
+      "\n",
+      "Bottom 10 features (lowest correlation):\n",
+      "No_3_Angle_Deviation    0.151341\n",
+      "No_8_NASM_Deviation     0.148498\n",
+      "No_4_Angle_Deviation    0.143498\n",
+      "No_1_Angle_Deviation    0.133244\n",
+      "No_7_NASM_Deviation     0.131405\n",
+      "No_23_NASM_Deviation    0.110539\n",
+      "No_19_NASM_Deviation    0.108068\n",
+      "No_13_NASM_Deviation    0.076349\n",
+      "No_2_Angle_Deviation    0.065751\n",
+      "No_15_NASM_Deviation    0.001390\n",
+      "dtype: float64\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABjYAAAJOCAYAAAAUHj4bAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd0FOXXx/FLR3qvho4U6VWaBUWRJl1RFLEhCmKnWBAURRH0rygWrIBYUFCaFRXpKKAUUWnSe+8lec/v4Z11s0nIhpTNJt/POXtIdmd3Zp5ZYGbuc+/NEBUVFWUAAAAAAAAAAABhIGOoNwAAAAAAAAAAACBYBDYAAAAAAAAAAEDYILABAAAAAAAAAADCBoENAAAAAAAAAAAQNghsAAAAAAAAAACAsEFgAwAAAAAAAAAAhA0CGwAAAAAAAAAAIGwQ2AAAAAAAAAAAAGGDwAYAACESFRXF2KdRHFsAABCOOIdhfPlu8HcBCBcENgAAQRkwYIBVqlTpnI+bb745WUdz5cqVduedd9oll1xiDRs2tNtuu8095+/06dP28ssv22WXXWY1a9a0G2+80X7//fdzfu7mzZvPuV9t2rRJ8n357bff7K677rLUzBuXL774ItnWsXz5cnvkkUfs8ssvtxo1athVV11lTzzxhG3atMlCbeHChW7/9WewTp48ac8++6xNnTo12t+d5s2bJ9NWAgCA9Hju/fXXXyfp+mI7hwklzhFDS9d1/td2n332mT3//PO+33V9oO+hrheC9eqrr8Z7PZlazplff/11e+edd0K9GQDikTm+BQAAkHvuucduuOGGaCd7q1atstGjR/uey5UrV7IN1r///mvdu3e3atWq2bBhwyxDhgz27rvvusDF5MmTrVy5cm654cOH26RJk+yhhx6ykiVL2nvvvWe33nqrTZkyxUqXLn3OdfTu3dvdYA+UPXv2JN8fXRysXbvW0rMJEya4C2gFqXS8ihQp4o6zLiK+/fZb++CDD6xy5coWTnbu3Om2+7nnnov2d+eWW24J6XYBAIDwU7hw4Wjn2v7KlCmT7OcwocI5YugNHjw42u9jxoyxBg0aJOozu3TpYs2aNYt2PaTrtk8++cT3XNasWS01+N///md9+vQJ9WYAiAeBDQBAUEqVKuUengIFCrgTz1q1aqXICI4bN84uuOACe/PNNy1HjhzuOWVuaFbP+PHj7cknn7Rt27bZxIkT7bHHHnMBD2natKldc8019vbbb9szzzxzznVo/1Jqf9I7ZawoQHXTTTe54+VRkENZG+3bt7dBgwYla7ZISvH/ewMAABCslDzXTi04R0wdKlSokOSfWaxYMffw/PLLL+7P9PYdB5B0KEUFAEhSc+fOdUGFunXr+mbiK+AQmLas8lAdOnRw5Yfatm0bbzq9MjJUesoLaoh+1snxxo0b3e/z5893pahatGgR7YJQWRg///xzkuzf/v37XRClcePGVr16devatatbr7+9e/fakCFD7IorrnAZJprddO+99/pStVVaQFkmW7Zs8ZV6iqvsUWAauAI5ynLo0aOHGzsvKBDMdunY6PnatWtb/fr1XYZKMFkjO3bssF69ern1qcTXK6+8YmfOnHGvKSVdzx86dCjae5TRo+/AsWPHYv1MZWXkzp3bHnzwwRivKWimMbryyivt6NGj7jmtT7P39F3R+nRMX3zxRTtx4oTvfXqPxkUzzOrUqWOtWrVy79O4arZjx44d3Xu9mY9bt25169fxUdkyvVdZSOfy/fffu++3xlDHtmXLlm67RMdX2ywDBw70pdIHlqIKdl+UafT555+7wJzWdd1119ns2bPjPV4AACB90fmJznN0DtikSRM3mcc7h0rMOUzgeagEnrPqPLZq1apu9r3WrfOqNWvWBL1dgThHTPpzRGUetGvXLtpzOu/Ve48fP+57TpOO9JmBx17fB1236PolsPyUrumU1a9jrO0dO3asJda5vqv+38GPP/7YXW/pvF/XOaJt1DWAtkf7rOshfT/9J0vFdw2gzxZdM3g/A0idCGwAAJKMyj0p+FC8eHEbNWqUuzBaunSpXX/99bZnz55oy+pGuS6gdMJYtmxZu//++88ZfNDJ7R133BHtOZUt+ueff6xixYrud92kz5kzp0vb96cSVEqvP3LkyDm3PzIy0gVG/B/eDXzRRYVOfH/44Qd74IEH3LYrsKLt8oIIariofdPJ9cMPP+wuznQxode9lG6VJlKAQNup1OvYyl+di07sdbKu4EHnzp2D2i71rNB6dXGgVHJduKxfv971+dB+x1cPt2DBgvbaa69Zp06d7I033vDV2PXWHxiY+vLLL91FhbJsAmmM5syZY40aNYr1ddF7FQzyAlkK2qg0grI5tP3K9FCmjvbJv8nlr7/+6gJp2lYF1TJlyuSe1zbrIlFBGV2wKfikizD1aFFPj5EjR7px0OfGFez56aef3DZdfPHFbuw1LhERETZ06FB3UadSWl7QREGjuEpHBLsvK1ascN+f++67z+2P9qVv37524MCBcx4vAACQdgSem+rhf76gnhg6P9EkIJ0v6Lzzq6++inZekVTnMHHR+bJKxOr8Uuf/5cuXD2q7AnGOmDzniLru+Pvvv33XYzp31zXaqVOnbNmyZb7lFBxRoCCQvg+6btHn6NpF3xfPU089Za1bt7a33nrLBSJGjBhhP/74o52v+L6rgdvVv39/d26tdetaVIEfBTr0Xp3za+z8r+eCuQbwSmPpOse/TBaA1IdSVACAJKETQs0oUuknnSB6vJnzOvl+9NFHfc9rBpBOWkW1VpW9oRNznTAHQ7OLdCKrjAz13hBlDcTW50PBDjl8+LDv59go+8G/LJLo89W80LtZv3r1avv000/d7B659NJL3b5o3zVzSgEU3azXttWrV88to8wVZZV4J8YqTZSYUl4lSpRwQROPtie+7frjjz/cmCnoUrRoUbeMgh8Khmjm3Ln6o+j4KEvE+1nj+NFHH7kLBV246kJCY6O6ubJkyRLbsGGD63cSm3379rkLqgsvvDCo/dWsP69vitdwXbP+dFGl75QuwrzvjS72deHjn+YuOhY9e/b0/f7SSy+5LBeVLlMvFm/M9F1VTV0FQGLbDn1P/b8j2ncdX80c09hXqVLFd4w1Oywx+6Lvs2aXeaWsFOTRd33BggW+2XQAACDt0ix53eAN5J1H6Ga3zvV0fqY//ftvaFa/Jg1pAk1SnMPE5+677/ZN1gl2uwJxjpg854je+zThqU2bNu5cXcEQTS5bvHixK++rSVA6f48tsKHvg65bdP0SeO2izIdu3bq5n/Xad99957Yjts8JRjDfVf+Jb8rm8OgcXuv1yg/r+5clS5Zo16bqIxPfNYC3j7qeoEwWkLoR2AAAJAnN/t+1a5c7GfenE26djC5atCja8zph9agRuMpHaUaObr7H16xbN9YVFFHAQSeg3klpXLO/PBkznjtRUTPJAi+y/N+jiwHNVtIFpm6ge3QC/cILL7hZUgoafPjhh25blKatrJJ169a5C4iTJ09aUvAuPBOyXboIyJYtm5t5pAsAncDrAkFp7vG59tpro/1+9dVXu4sCzZrShZKyODTjSRffOhZKAdeFko57bLwsCv/ZU+fifXc0G8yfftesQF3keBds+fLlixHUiGvM9JyOlzdmOtYaF80mjI2XMaTMH33fFazygl7BHtuE7IsuHv37c3j7FVd5LwAAkLbo/E4z9wN55wQ6x9y+fbubuOJ/DqiSo5q0ogxindsmxTlMfPzPtYLdrkCcIybPOaKCIwpOzJs3zwU2dB6syWeaLOWdmypwkidPHldKNiG8iVyiyV2FChWygwcP2vlKyHfV/zunay6VmOrXr1+M8fMPbJzPNQCA1IvABgAgSWjmi+hkNpCeC+xd4J/CLCp1pGCAToTPFdhQmSFdJOlEV7Pulart0YVSbOWmFAgR9XQ4F92UV4mnc+2jgjexzZwTvZY3b153UqxSXNpW3WjXyXN8wZqE8O8zEux2qQGgUtmVJq6MAQVfdPGimU4qA6bgUlwCS3vpYkq8dHfNcFJGh7I2br/9dps5c6ZvpllsNEbKnNHFR1yURaL0eC3rrSdwOzJnzmz58+eP1t8jroyc2MZMF0BxjVlsF4ZKXVc5MdX91XipxJl3MRdfUM2TkH0JLNPlHaP4SocBAIC0QbPk4zs3FfV20yOQMomT6hwmPv7nWsFuVyDOEZPvHFFBEZ2rezf3NalM5YP1nAIGauStDAetLyECt0VBgsR8pxLyXfX/zul93jWlv8Br02CuAeIqlQsg9SGwAQBIErqBL7t37471xrpOyANPKv1PNPU+zdLyPic2f/31l7txrjJGquOrWV/+VMNXQQyd2Ho330UnrwpaJDa4oMCIUuj9U+r9qbSSejyoDJXKQGlbvbJPypz47bff4vzsuC5IFKg5V/msYLdLvMbZunjRtqg0lnpPVK5cOUZWhr/Aer3eMfYuHLR9ygJRQOOiiy5yQQk1MTwXlSzTzDMdS2WSBFJZLfXxUBBGF7ne98jLzhEFPlSyIPC7FQyNmRoG+pdHC7yREEjlvzQD8f3333fZKFpGFz/a1mAlx74AAID0SZNUROczOq+J67wjMecwgRm28TX/Tsh2xYZzxOQ5R1SGjPpOqLeEHir1pIwNnYvr+kXn5bEFoVLa+X5XvayVwL6Ogb+fzzUAgNSL5uEAgCSh0kOaYTRt2rRoz6teq5rSKd3Zn2bheDT75ttvv3Wpz3GdTCr7QT0SFABQTdTAoIY0btzY/enfyFo38dWETjVqE0snwdoO3dDX7DnvoXT6sWPHusCMGvEpOKEGfl5QQxeESv32D1wElsXyelwobd8/oBBXI+uEbpcuDlSaSuOhMVbj7qefftq9/1yZE6Lx8zd9+nQ3k8m/xq1KXKkpoUpU6Th4+x4XNZlXcOvll1+O8Zpu+itwpSwTzabyLoi13sDt0NgmNGVe9JnK+tH31n/MNGtNwRSvFII/BYNUhkslvLzvqdL2/Y9rbO8LXG9S7wsAAEifNKlH538qf+p/PqPzMJXf8TKmz/ccRuen/uem3mcl1XbFhnPE5DlH1Phr4peCG5pUVK1aNZdBr2OliU8KcKgc0/mW9E0qwXxX4wpsqDyXenz40zXm+VwDpNT+AkgcMjYAAElCJ39qHqcasOqz0a5dOze7SCfKmpXl37jZy2DQCbROKj/77DN3A183xeOiJnCacaOZRMrKULDE/6JLN8E1u0m9O5577jn32cpieO+991x5K69ea2J07NjRlXPSvqhBotK3FbB4++23XcM+NafzelaogbV6Tyg4MWHCBNfcW7xG3ZrJpswHNU9UqapKlSq5z1MDdb2uAM6bb74ZVCp0MNulpoDK6FBvEj2nk/aPP/7YXTDE19xPFwS6EFXAYs6cOS7TQ/Vr/RuO62JLx1J1elUiLD5qxKfPUGBDx759+/ZuJto///zjGs3r+HlBDx1bHVc189OMLQW1/vzzT/fd0kWP0uYTSo0rdQGjP3UBrXXPmDHDzQbTdzg2OrZTp051wRZdPKlvikp76Vh5pau8cmdK8Vdjdf/gT3LtCwAASJ90PvfAAw/Yk08+6X7WOZ3Oe3XzeseOHb5yO+d7DqPPmzVrlju3bt68uZvZP2XKlCTbrthwjpg854heHwkdP2XFeCWn9NmaNKZyT+fKnNe1iwJSOtcPpkff+QrmuxobvX7fffe5jA+VslKpLV1/6drKP1AR7DWA9lfrVnN1jc25yvYCCB0CGwCAJKMb7CpLpBvyuoGuG986CVfAI7Be7FNPPeWWU0aHmtlphr5/8zl/XtaF6EQ1kGbejBs3zhdQ0ImobuoriKCTYgU3VJ81sVTHVUEKzTQbMWKEq3WrYIoCOTox9i4OdBGndSpzROW29JwuSjQmmoWkGrcaKwU19JxOwtWTQje71atC46X39ejRw6Via1ZRYrdL5aZUdkon9/p8zfzSTC2Nu2ZqnYtS1TVbTFkfOo6DBg2yW265JdYUd5UB8+97ci69e/d2x17brv1WEEhBGX2OF6DxDBs2zB3Dzz//3B1bzTDTNtxzzz3nNaNKgRoFdjRm+i56gTCtR9knsRk+fLjLcvEyXbS8Am3qqaILfdF3XgEmBX90fJU1Eyip9wUAAKRfXbp0ceffytLV+YfOC5UprQktERERiTqH0SQdNW+ePHmyO2/SzXadr3br1i1JtisunCMmzzmirkEU2NC1iccLbMTWzN2fril0vq5Su7rOSS7BfFfj0rZtW3f9p0lSOs+uWLGiu47Rw+vHEew1gK5FFIi78847XeBDZbsApD4ZopKqUxQAAEH44osv3GyYH374wdf7AeFPpxOtW7d2M8AU+AAAAACAlKKSyJo05T9pS5PjevXq5bI0NNELQNpCxgYAADhvKgumTI7ly5e77Bs1TQcAAACAlKSsDpXEvf/++13m97///usyjJTdT1ADSJsIbAAAgPOWPXt2l86tZn5KT4+vtAAAAAAAJLXnn3/eV5pX5XFV2rdly5au7C+AtIlSVAAAAAAAAAAAIGzQoRIAAAAAAAAAAIQNAhsAAAAAAAAAACBsENgAAAAAAAAAAABhg+bhCDtqUHv69GnLmDGjZciQIdSbAwAAgDQsKirKnX9mzpzZnX+mN5x7AwAAIDWeexPYQNhRUGP58uWh3gwAAACkI9WrV7esWbNaesO5NwAAAFLjuTeBDYQdL1pXrVo1F71D+EVeDx48aHny5CHjJgxx/MIbxy+8cfzCG8cvfJ05c8ZNqkmP2Rri7bcuLjNlypSi6+bvDWMbjvjeMrbhiO8tYxuO+N6mzfFNyLk3d4URdry/TLqwSumLKyTNP4z6x0nHjlJi4YfjF944fuGN4xfeOH7hL72et4Ty3Ju/N4xtOOJ7y9iGI763jG044nubtsc3mHWmz2lHAAAAAAAAAAAgLBHYAAAAAAAAAAAAYYPABgAAAAAAAAAACBv02ACQ4uiNEt44fgAAAAAApA9q5nzq1ClLjT0gTp48acePH0+3vdDCcXyzZMmSZPeVCGwgbPGPVvget9y5c4d6MxDGx+9MZJRlyshJCwAAAAAAyXlje/v27bZ///5UO8iRkZG2Z8+eUG9GmhWZTOObL18+K1asWKLv7SYosFGpUiVr06aNjRw5MtrzX3zxhY0ePdpmzZplSeHzzz+3t99+23bs2GEVKlSwAQMGWN26dd1rBw4csAYNGsQYjIULF8b7udrOgQMH2rvvvmtNmjSJ9trNN9/sPrdv374xnl++fLnNmTPHcuXKFe21w4cP2//+9z/75ptvbO/evVaiRAlr166d3XXXXZY1a1a3TPPmzW3Lli02fvx4q1+/frT3z5492+68807r0KGDDR8+PN7tf/XVV904+0e4ihYt6tZ5zz33uN8TS9vbp08f69ixY7zLbtq0ydatW2eXXXaZbd682a688kr74Ycf7MILL7SUMGrq77Zh15EUWReA1CGiUC4b0KF2qDcDAAAAAIA0zQtqFClSxHLkyJHqJhgr8KJsEs3+T23blhZEJcP46jOPHj1qO3fudL8XL148ZTM2pk2bZp07d7ZGjRpZctDN/qFDh9rTTz9tNWvWtMmTJ7tAwYwZM9xN/DVr1rhAhrbDkzFjwlqF6POnTp3qCz7ERYGVpUuXur/ACl506tQp2usKuOgv+Msvv+yWWb16tfvsffv22RNPPOFbTgEHBX0CAxvff/99gr8YtWvXdgEOUSqQgi7Dhg2zbdu2BRUcic+kSZPcP1bBGDRokAsGKbChL6KCPwUKFLCUsmXPEVuz/WCKrQ8AAAAAAABI63RD2wtqFCxY0FIjAhvhOb4XXHCB+1PBDX2/ElOWKsHNw0uWLOlu3qvGVnJQIKN9+/YuC6F06dJ2//33W6FCheznn392rytDoGzZsla4cGHfIyF/wfLmzWu7d++2t956K95lFUy56KKLXBbDlClTor126NAhF5h47LHHrE6dOi5L4aqrrrKHHnrIBQeUquOpV69ejGwWfTn0XK1atSwhFCTx9jsiIsJatWplL774ohu3FStWWGIpMJE9e/YEv09fQm0TtfcBAAAAAACA8OX11Ah28jOQEN73KrG9WxIc2FCgQZkM77zzzjlTlfr16+dm8zds2NCeeeaZoAMhd9xxh/Xs2TPG8wokiDI2ypQpY+dL5aS0bQpsbNy48ZzLKitEWRZXXHGFLV682JVb8ihSpce8efOivefqq692QQb/SNbll1/u3rt27Vrfc8uWLXNBlsTsi0fZM6VKlbLvvvvO99zHH3/sAjLK8FA5rb/++ss9P3HiRPe8v08++cRtt+g1lezySm2pdJc+v1q1atayZUsXzPGyVRYtWuRKY+nztX8qVeaNkUqGKWulcePGrozYI4884p4TlQ3Tej766CNr1qyZC+7o9eQKlgEAAAAAAABIGEo8ITV/rxJcikrloO677z576aWXXL8NZQ34083pHj16uGyLcePGud4TXlmmxx9/PN7Pv/jii2OUptqwYYNdcskl7ncFB06fPu3KYSnAomwI3XxX6kqwbrrpJhd8UObJ2LFjY11GQQ9lQOiGu27MKyCirA31nxD9rt4YL7zwgn322WeuHJNu4isIUK5cuWiflSdPHvcZytAoX768e05BCGV4aB+Sgj7XC5xoPQo4qJyXslu03bfccot9++23ds0117hAk/ZNwQrR89dee22Mz1SJq/Xr17ueJEoT0lgpQ+XSSy91f+q4KHDSq1cvFwTxp3E6duyYvfHGG+73p556ygVDxowZ40s3UnkvfaZ+1vIKInXt2jVJxgNA2qZ0SCScsgWVUajx4wQ1/HD8whvHL3zxfw4AAACQ+iQ4sCGaoa9Z/brx7d249vzyyy/uZv2nn37qMhLkySeftN69e9sDDzxgOXPmDHo9Ci4oaNG2bVtfwEOlqFQuSc/rAlEBlrvvvtsFF4Itg6TldKP9hhtusK+//tplIsSWraFeHrrZruWVdfHll1/6AhuiAEGVKlVcs/P333/fPVQ2S+Oi5f2psbbWpWbhoibbKiE1YcIESwoKtHhd6hUsULBBmSZelo0CRF999ZU7dgoSKZihwIayKJRB8eijj8b4TO27smdUjktuu+02N85aj3pqqCyWUoc0Tv6BDfUaUTaH9leBFRkxYoQrm6Xj56UaKdBVsWJFl+mhzA31CyGwASAYykJT8BQAAAAAAEA0qVqT2ePy4Ycf+l5Pil7FwWzP+a5LVXF0P1n3kNUCIdAXX3zhJrYHtj/wN3fuXLe/ugft3e9Wr+hdu3ZZ06ZN3aT4uPolnzhxwoYMGeIm56ttge4L6+F/X1xJDf6U3NC9e3d3v17tLJL7Pu95BTa8wMCNN97oK03kUdaAyit5QQ1RDwplWShQoUBAMJQpoJvqygjRQHmmT5/uZpl6fSBeeeUVdyB+//13t55gqTF5ly5d7LnnnnM31QNpPQpOeMESlWpSw/Fff/3VZYl4TcsVKNBDwRwFD9577z2X0aKDruwWj76Izz//vMtg0UNfjurVq1tSUWBBwQ3vGCiQMGrUKN/rWp8yLKR169auFNeDDz7o/nIou0bBhUDqdaLjqyCVAhIrV64MataallWWihfU8DJK9J3Qa7lz53bPab0ebbu+IwAQjNj+zUL8NCHg4MGD7t9oMjbCD8cvvHH8wpfOfTUBBwAAAKmbKsyo/7HXO1lVaNQL2aN7k+cKfKQlJ0+edPfUvaSEP/74w42PghWVK1d2E/OVOPDmm2/G+n5VKVLFH03k37Ztm/Xv399KlCjhSxDQ/WeNtSoaebx707fffrt7vkWLFpY/f/7UFdgQBRE6derkBkF9MTzZsmWLsax3IzzYNO5//vnHbr31VhfUUPaBfzNrr3O6R43DlTFwPiWdNPgKQLz66qvRnlfGgXp56Ca8ghn+VNZJgQ1lOSxZssRlooiCGAqU6ICpLJVe8y/vpMhahQoV7KeffnKll1SGKin9/fffLhDhjfOgQYNcWSx/3pdL2zh48GA3znGVoRJlcSxdutSuu+4669atm2sOfv3118e7LVmzZo31eW2X/3cgcDld8ANAMILN0IPF+HdWQXmNH4GN8MPxC28cPwAAACB5aTK1N6Faf+raV/cz06MZM2a4QIQ3sXz8+PHuHrB3/1iBC1X72bRpU4xWE0ePHnUBIQVFVEVJVX90H1mVh/wDGwpgxDa+mkypRAT1V7733nuTbR8T3Dzc38MPP+x21L+RuGbpKzNg//790RplZ86c2TW4jo9u+iutRYOuz/VuxntZCSqPtGDBAt9zCmjs27cvRl+LYChKp5v3SpvxbySuA68DoAieAhneQ5kOM2fOtOPHj7sSTq+//rpL3fGn0kz6SxNbGo+yNhTYUJZEUgY25s+fb1u2bHH9M7xjoAbuGkPvoS+ijoP3F1tZKtoXNT/XfgXSWCs9SalDykBRMMRr/h1fAELr14xgr+yUKFCkz/TP4gAAAAAAAACAlKR7lGqZoIo+qtjjP7G9efPmrhKObswrCKD7oJpQroo9NWrUcPdf/VsL6B5o37593UR43bfW/XL/kv3nWpcq7GhdmiRfq1Yt125B2RGx0T1wJRdoOWVDbPS7lx2biRMnRrv/rGpHXhUiUZsBBT70fCBN+ldlHa3Lo/7RWlZ9O7VP2h5VbYqLxvGTTz5xy6fKwIZSSXSwdFPd06RJExflUcBANdAVhFC9LjUaV7AgPirXpB1WJoiCJgoc6HHkyBEX5NAgqnyU0mdUGklfDN2kP9+yJPoi6CApEOBfhkp9PZSWo/4S3kNZJDpwKs+kiJbKK6lclmqZqe6ZylQpC0Q37/VFji2woR4kioTF9now1JvCGxN9jgIuOgbKFvHGQNv0wQcfuNf0JddfEAUxvMblomCGymYpIBRbsEHZFMqOUUaH9k3brWbrXiqTF8RREMvr7eHRetRgXClKOk566Gfts9evAwAAAAAAAECYOXIk7sfx48EvG9g3M7Zlkokq+CgTQZO6lcWgyjeHDh3yva7ggybcqzeGgg/qmax70upfrHucmuyu+65emwTdp1UgQT08FBTQ68GsSxV19Lruh3/88ccumHDPPffEGgzo16+fe179j7U9H3zwQZz7p8npCkLoPr1/MkGRIkViVELyvyfu0f7ovr9/tR31ldZYKJlB2RqqAqGJ9LoH3K5duxglvtTjeffu3S4olOpKUXk6d+7smmdrcETZCjp4CmaoQYiahStIoH4O8VEETEEDZUQENvRW025Fv3Sg9aW666673A12BQvUhDox1C/EqwemrAbdyNd+BVJUTl9EHSgFalRjTF9e7asOuDJAFAnT7yr1EUhpOwruqETU+ZZRUWkoRQy9wIJKXOnLrKihR0269cXRtulPlcAaM2ZMtCiaAjMaby0bG31xFRDReCujRetR2S01mPnzzz9d8ELBFP1lVLQwsJyX3qc6bgoGaV91nFS3LSmVLJjTTiVf0A9AKhRR6L8sPgAAkHadiYyyRev32IYd+6xM0dPWoGxBy5QxQ6g3CwAA+FXXiUH3GadP/+933Ug/ejT2ZS+7zOynn/77Xfctd++Ovkwyla2vXbu2r7WCAgnqxaHKM8qqEN2o9yaQK5CgAMD999///5tZxk3yVxBDGR36Wfe/de9Uk8T/97//BbUufc6XX35pb7/9tgsCiJp8K6tDTb/9J6KrDJTuCf/4448uy6JixYqu/8XXX38d6/7p3m2WLFmiNR3X/fbAtgD63ZvA7u/YsWOxLitaXtuvwIYmzKtZ+OLFi13jcCUlqOqP165CyQ+rVq1yyQMhD2woAyOQdkIRJX/aaDWnTih9VmzpL/4UPFDGxvno2LGjewTyvgzn2k//jvMe9fZ48skn3SMugZ3pf/7552i/K0gTLAV29AjGLbfc4h5xUVDEK00V1/YqSBNYMss/4BP4uv+4qRSXf/Nyfw0bNowxxgkZB8+DbWtSZx9Ipzc6uLEBAEDa9fWKbTZk6irbduC/WZ/F82a3wW2rWstqxUO6bQAAIPz595TwenIoG8FTsmRJ38+6ia8sDAUoPOoh7E1a1/1XBSw0kV0PlarSJP/41qUqOMrA8IIp3r1mBTSUEeEf2FCJf72moIanevXqcQY29u7d6+6h+0+8V6AhMIih3wP7WZ9rWVEvbAV0NGle2yQKXGh/lLXiBTa8/Qms9JOqMjaAUKHZePgeN5V0UxSX5sXhJzUcP4IaAACk7aBG7/FLLHB+5vYDx93zY7rXIbgBAEAo+fWPiCGwQs3/V/iJVWC1mw0bLKXEVknH/z6jbux7VB5KAYu4JrbrNU1kV09l9VbWcnPmzHHZF+dal/86/CloElspqsD7oFmyZIlz/3S/JvAzihYt6ir7+NPvsTX/1rLqaa1997Zf1YoU1FA1In2+F9TwKHvDvy+2aBtiq2oUloEN9XRQeaS4KJrl9XFIqG+++cYGDBgQ5+uqgzZ27FhLrdRTRN3m49KrVy/XQAZIC/SPNMIXxw8AACTLOUZklMvUiK3ohJ7TlAq93qJqMSY6AAAQKjlzhn7ZFKTMCQUtVNbJu8mvElLLly937RHUqkBlq9TmQA/1bg6mHL8yOTJnzuwq6qh/tCiY8O+//8boh6yexeqboddKly7tKzcVF/XDUFNzBUO8SanKDPntt9981YzUpFwP/4wRT5UqVdy2qbJSgwYN3HN6r7JEFKhQuS2VxtK+e5TVouCGP+2PtiVNBDY6derkOqLHRTOAz5f6TnhNW2KjiFJqpv4VqkkWF6UPAQAAAEBatWj93mjlp2ILbuh1LdeofMEU3TYAAJA+qd/G6NGjXSbGbbfd5noza4J6z5493etqvv3JJ5+41gnKYtDk+6pVq8b7uerLof7F6tWsh+79KsujWLFirum3189a1OtYmSHqdaxeFtqG8ePHu8+IjQItypZQSSv1XpZu3bq5Hs21atVyAQrtg/p5eKWy1NBcE1m1DypPpXJTSkDQfmlb1BvEaw+hMlRqQ6EG6yo9pQwV3ZdX3xGPqn2o/4j6VaeJwIZSVfRIDjqQcR3McKCeFHoAAAAAQHq089DxJF0OAAAgsTQRXw2+n332WXezXzf+b7rpJlddR/r16+eCApq0fvToUatfv76NGDEiqM/u37+/Pf/883bfffe5HhaNGzd2WRCBjbvlpZdeckGNG264wfXauPnmm6P1gvan++81atRwWRZeYEM9QhSoUDUlZX8oeKKAikeBDgUixo0b535XZaTBgwdbjx493Bio7/PVV1/tXtNnK2tDn6U/1ZNk5MiR0fqQKKNDQRpv/ckhQxSNChBmFD1UmpZSpZQWhfCif3L0D6gi0fTYCD8cv/DG8QtvHL/wxvEL/3NPzW6LrUZyWpeS+z9/7R7r9nb02syxmXjnJWRsJBL/JiUfxpaxDUd8bxnbQMePH7f169e7kkiptQqOvrdeE2/uL8WkoEdgFkVKjq/KcSkbRI3VE/L9Ssi5Z/J17wAAAAAAIEgNyhaw4nmzu14asdHzel3LAQAAIG5t2rSxrVu32rp16yylqbfG3LlzXfmr5ERgAwAAAAAQcpkyZrDBbc/WpA4Mbni/63UtBwAAgLipnJVKV7322muW0tSPQ6W58ufPn6zroY4PAAAAACBVaFmtuI3pXseGTF0VrZF4kTzZbEi7i93rAAAAiN9ll13mHintoYceSpH1kLEBAAAAAEg1FLyY07+5tapezPfc462qEtQAAACAD4ENAAAAAECqonJTXetG+H6fv35PSLcHAAAAqQuBDQAAAABAqlO/bH7L/P/9NOat2R3qzQEAIN2JjIwM9SYgDYpMou8VPTYApLhMmTIx6mGM4wcAAFJCjqyZrUaJ3LZk80HbsOeobd531C7Mn4PBBwAgBRpPZ8yY0bZu3WqFCxd2v2fIcHayQWoRFRVlZ86ccfcoUtu2pQVRyTC++syTJ0/arl273PdL36vEILCBsMU/WuF73HLnzh3qzUA6OX5nIqNcKQsAABCeGpbJ6wIbMm/NHutan8AGAADJTTedy5Yta9u2bXPBjdQ881/bivAa3xw5clipUqUS/dnJGtioVKmStWnTxkaOHBnt+S+++MJGjx5ts2bNSvQ6mjdvblu2bInxfN++fa1Pnz5Bf86rr77qtun999+3Ro0aJXq7/D930aJFNm7cuER/1oABA2zy5Mm+3xXVioiIsOuvv95uueWWJLnRr2P24YcfWsOGDeNd9s8//7Rjx45ZnTp1bOHChW4b/vrrL0spo6b+bht2HUmx9QEILxGFctmADrVDvRkAACARGpTJZ2PmbHI/z12727rW/6/vBgAASD6676ibz6dPn3Yz91Mbzf4/dOiQm3zJ5OfwGV9lgGTOnDlJPjPZMzamTZtmnTt3TtJggb9JkyZF+8v1zTff2Msvv2wdOnRI8HbqL+uUKVOSbVuTwrXXXmuPPfaY+/no0aO2YMECGz58uB08eNAFcxJrzpw5ljdv3qCWvffee13wSIGN2rVru/empC17jtia7WdnbwEAAABIe6oVz2U5s2ayIyfP2Nw1e9xFNjcvAABIGfo/N0uWLO6R2uic4MSJE5Y9e3bODdLp+CZ7rk7JkiVt6NChrn5WcihQoICr9aaHBvq1116z/v37u/UGa+XKlbZx40br3bu3ffvtt3bkSOrNAtA+evtbunRpl60xaNAge/PNN23Hjh2J/nyvbl5C6T16LwAAAAAklSyZMlrDsgXcz7sPn7C/dxxmcAEAAJD8gY3777/f3XB/55134lxm+/bt1q9fP2vQoIErgfTMM8+cVyBE69DN9U6dOiU4W6Ny5cp2zTXX2KlTp1xwI7A805dffunKalWrVs1uvPFG27TpbDq0rFixwrp27Wo1atSwG264wf73v//ZzTffHOu6fv31V+vYsaNbtm3bti7DJLHatWvnIqezZ8/2RdQU4GnatKnVq1fP7r77bl89vBdffNG6d+8e7f2jRo2yW2+91bevKislOm733Xef1a9f3+23smB+++0395r2TyXABg4c6Epk6T16bzDHVKXI9P5XXnnFvaZtfO6559x2AwAAAIC/xhUK+X6eu2Y3gwMAAIDkL0VVtGhRd3P8pZdecoEB9YTwp5vdPXr0cNkH6kOxd+9ee+KJJ9xrjz/+eNDrUa+H8ePHu+yQhDQe0c30mTNnumBDzpw5XRkq9bEILGWlXhlPP/20FSxY0N2wV7kr9Q5RrbE77rjDlYhSSah58+a5m/QqzxRIHd979eplDzzwgDVr1syWLVvmggL6TN3cP1/ZsmWzCy+80NasWeN+1zhMnTrVbV+hQoXs3Xfftdtuu80917p1axcA2rNnj1uvKLiifQj08MMPW548eezjjz9246SgyFNPPeU+R+Nx3XXXuc/V2K1atSpBx3Tp0qVu2yZOnGjLly9343DppZdakyZNznscACA2qbEWaKjo33I1/9KYpNZUUsSN4xfeOH7hi/9HQq9JhbPXLV5g47amZUO6PQAAAEgHgQ3R7HzN0h82bJi98cYb0V775ZdfXGbAp59+6uvt8OSTT7qyUAoAKNgQjBkzZriO6ldffXWCtk0ZCNu2bbOrrrrK/a736ya8shH8y1n17NnT13ujW7duNmHChGjr1Q17NT8pV66cLVmyxAUxAuk9jRs39mVM6Ma/GnB/8MEHiQpsSK5cuXwltMaOHWuDBw/2NQBXsEfZGxprNVsvU6aMff/9966MlZp9a19btGgR4+JbY6IslmLFirnnbrrpJrvrrrvcz/ny5XP7qwYyeiTkmHoXiAoUabs1ZmrargAHgQ0ASU3/zin4DQAAwlOlormtUK6stvvwSVu4fq+dPhNpmTMle/EBAAAApPfAhm6Aa6a/Sjjphrq/tWvXuhvt/g2rle1w+vRp1/eiSpUqQa1DWQetWrVyXdUTYvr06S6AUbVqVff7lVde6W7Cq/TUPffc41tOQQiPbsarZJV3w+ziiy92++ipVauWfffddzHWtW7dOvvxxx9do22PPqds2cTPODp8+LAvuKEyUAog+GeuHD9+3DZs2OB+1jip3JYCG/pTwRYFKvxpJq8COArcKFCzfv16V3JLM33jE98xFWWLaHs9+lmvA0BS8y+Tl94paH3w4EGXjUfGRvjh+IU3jl/40oQcTcBB6Oj/rEblC9nU37fa4ROn7ffNB6xu6fwcEgAAgHQsRQIb3o1t9b5Q1oZ/2SOVUYor3TvYtG+VPlq0aJEvmyBY+vyvv/7a9u3b5wtsiG7eBwY21MMiNgpoBPaGiKtXhG7cq6+Gel74S2gwJpA61CtooT4Z3pipz0dgwMQLNCiwoWbjurmlwMbtt98e4zM1BiozpWW0vDI9FITp06dPvNsTzDGNrUE5PTYAJAf/wHN6p39nFfTWmBDYCD8cv/DG8QMSp2mFgi6w4ZWjIrABAACQvqVo/q56Nhw9ejRaI3HdfNdN+f379/ueU+8J3ewvVapUUJ+rrAkFDdSQOyHmz5/v+j+oifWUKVN8D/V70DYpUyE+FStWdOWk/DMZVq5cGeuy2td///3XZX94jx9++MH1rEgMvV83qK644go3C1fZECqF5a2jePHiNmLECJd1IeXLl3cP9c7QfnpluPypX8fixYtdiSgFYi6//HLbuXNnUAGIpDimAAAAAOBpXJ4G4gAAAAhRYCN//vwuuKGeDh71VFBD8UcffdQFKBYsWOB6L6jRuG7SB+Off/5xzbNjywKIrwyVAhPqq3HRRRf5HiqZpdJMCnLER824VQZKDcMVOFBfCZVvio0+V+Wc1EhdN/4VkBg1apSVKFEi6G1WSSkFLfRQkESNwp999lnXv6JAgQJuGWVuqLn5rFmz3HrU/0NBGvWy8N/uMWPGuIbd/iWhPBp7zerVGOl4KbNFDcO9DBlRbxGV1/IPYCTVMQUAAAAAT0SBHFa6YA7389KN++3oScrYAgAApGcp3nGtc+fO0XpMqBzG66+/7n7u2rWrPfjgg67PhRpeB2v37t3R+jkEQzfn1QdD2xNbKaWOHTvazJkzXZmnc1FzczVEV3aDykxNnjzZ/RlbkEW9PLSsmmvrJr+CD8oOadeuXdDbrW1SI3A9tI0KvihwocCGR6WltF/qFdK+fXvbunWry5LxHyOVl1L2jAIcsVHDcPVFefvtt922vvXWW249yrpYtWpVtCbqet5fUhxTAAAAAIgta+PkmUhbvGEfgwMAAJCOZYiisUGibNq0yXbs2GH16tXzPTdkyBA7duyYDR8+PPFHCDGoT4dKW83alME27DrCCAGIVUShXDagw3+BdJwtJXjgwAEX6KbHRvjh+IU3jl/4n3vWqlUrXfZtCuX+B/69mfbHVuvz0VL3Wq9Ly9nAVlVSdHvSEv5NYmzDEd9bxjYc8b1lbMNVVIjuHyTk3DPFmoenVSpD1bNnT9fDonr16q6/hhqPq8QUkteDbWumy4tLAME7ExllmTKm3H/AAAAgZfpszFmzm6EGAABIx1J1YOO9995zjb3jopJPcZU32rNnT6xNsf0tXXp2tk9iVKlSxZV8UiBj27Ztrl/GwIEDXbPthLj33ntt3rx5cb6uLJCElKxKD0g2Ct/jpoCgerswYzz8hNvxI6gBAEDaUSBnVqtaPI+t2nbQPfYdOWn5cyaszyIAAADShlQd2OjUqZM1b948ztdja3rtCbb5d1Lo0qWLeyTG4MGDXfmquBQsWDBRnw+kJkorQ/ji+AEAgFBpUqGgC2pERZnNX7fHWlUvzsEAAABIh1J1YCNPnjzucT5Uoqh06dIWLooUKRLqTQAAAACAVK1JhUL29i/rfeWoCGwAAACkTxlDvQEAAAAAAASjQdkCliXT2XKY8+izAQAAkG4R2AAAAAAAhIUcWTNb7VL53c8b9hy1zfuOhnqTAAAAEAIENgAAAAAAYaNJ+UK+n+et2RPSbQEAAEBoENgAAAAAAIRVA3HP3LW7Q7otAAAACA0CGwAAAACAsFEzIp/lzJrJ/Tx3zR6LiooK9SYBAAAghRHYAAAAAACEjSyZMlrDcmezNnYfPmF/7zgc6k0CAABACiOwAQAAAAAIK43L+5WjWkM5KgAAgPSGwAaAFJcp09nSAQhPHD8AABBqTSv6NRCnzwYAAEC6Q2ADYStDhgyh3gSc53HLnTs3xy9MhePxOxNJ3W0AANKaSkVzW6FcWd3PC9bttdNnIkO9SQAAAEhBmROycKVKlaxNmzY2cuTIaM9/8cUXNnr0aJs1a1aSbtxXX31ln332mY0bN8733IkTJ+yFF16wGTNmuN9btGhhAwYMsBw5csT7edrOgQMH2rvvvmtNmjSJ9trNN99sDRo0sL59+8Z4fvny5TZnzhzLlStXtNcOHz5s//vf/+ybb76xvXv3WokSJaxdu3Z21113WdasZ0+ymzdvblu2bLHx48db/fr1o71/9uzZduedd1qHDh1s+PDh8W7/q6++6sbZkyVLFitatKhb5z333ON+Tyxtb58+faxjx47xLrtp0yZbt26dXXbZZbZ582a78sor7YcffrALL7zQUsKoqb/bhl1HUmRdAMJTRKFcNqBD7VBvBgAASGKaZNGofCGb+vtWO3zitP2++YDVLZ2fcQYAAEgnEhTYkGnTplnnzp2tUaNGlpwWLFhgTz75pFWvXj3a87qxv2jRInvrrbcsKirKBTVGjRpljz/+eNCfPXToUJs6daov+BCXHTt22NKlS61IkSIueNGpU6dor2vd+/fvt5dfftkts3r1avfZ+/btsyeeeMK3nAIOCvoEBja+//77BM96rl27tgtwyPHjx13QZdiwYbZt27aggiPxmTRpUlBBIhk0aJALBimwUbx4cRf8KVCggKWULXuO2JrtB1NsfQAAAABSj6YVCrrAhtdng8AGAABA+pHgUlQlS5Z0N+9PnjyZPFv0/8ELZTJERETEeO3nn3+266+/3gU8atSoYd26dXNBkGDlzZvXdu/e7QIj8VFWyEUXXeSyGKZMmRLttUOHDrnAxGOPPWZ16tRxWQpXXXWVPfTQQy44EBn5Xyp0vXr1YmSzKCij52rVqmUJoSBJ4cKF3UPj06pVK3vxxRdt8uTJtmLFCkssBSayZ89+XjX3tU3U3gcAAACQEhqX/6/PBg3EAQAA0pcEBzbuv/9+l8nwzjvvxLnM9u3brV+/fm42f8OGDe2ZZ55JUCBk7ty57vOvvvrqGK/ly5fPZU8cOHDAPb799lurUqVK0J+tclLaNgU2Nm7cGG92irIsrrjiClu8eLErt+RRpoUe8+bNi/YebbOCDP6ZGJdffrl779q1a33PLVu2zAVZypQpY4ml7JlSpUrZd99953vu448/dgEZZXionNZff/3lnp84caJ73t8nn3ziG2u9ppJdXqktle7S51erVs1atmzpgjletooyZxSE0udr/1SqzBsjHRtlrTRu3Njq1q1rjzzyiHtOFi5c6Nbz0UcfWbNmzVxwR68nZ7AMAAAAQNoSUSCHlS54Ntt86cb9dvTk6VBvEgAAAFJrYEM9He677z574403XI+FQLo53aNHDzt27JjrjaEyTT/99JPrixEs3XxXUCQ2jz76qLt5roCJHrpZPnjw4ATtw0033WTly5d3mSdxUdBDGRAKamhbFBDxz9rQ7+qNof3SDf/nnnvOZZMoY6FcuXLRAht58uRxN/f9szYUhFCGR1LR/niBE61HAQcFFhRk0bpvueUWN1bXXHONC0z5Z3coOHTttdfG+EyVuFq/fr3rSaIgjzJPlKGiY6w/FTS57bbbfKWx/KlPx59//um+J++9957bNgVDPDt37nQBqrFjx7r3axsCs2IAAAAAIJisjZNnIm3xhn0MFgAAQDqR4B4bohn6mtWvG9+6ce3vl19+cTfOP/30U5eRIOqV0bt3b3vggQcsZ86cidpgBRzUz0H9JE6fPu2CE/pZWSHBUvDhqaeeshtuuMG+/vprF5gIpBv5yg5RxoaWV9bFl19+6W7Ye7ROZYt8/vnn9v7777tHoUKF3LhoeX9qrK11qcSWqMm2SkhNmDDBkoICLXv27HE/K1jQq1cvF5TxsmzUqFzN2HXsLrnkEhdIUBaGgh3KoFDAKJD2vWfPnq4clyiIoWbuWo+OgcpiqR+HxknZHR71GlE2h/a3bNmy7rkRI0a4sllqNi6nTp1yfVEqVqzoMj2UuaF+IV27dk2S8QAAf2fOnGFA/r8MokolajwS2uMJocfxC28cv/DF/yGpW5MKBW3iorOZ+PPW7LbLLioc6k0CAABAag1seIGBG2+80VeayKOZ+Sqv5AU1RD0oFIRQUCIhZaMC6ea5MgUUQKhZs6Z77tlnn7Xu3bu7LBI18A6W3t+lSxeXaaGb6oGmT5/ughNezwiValLD8V9//dVlLkjGjBldoEAPBXMUPFB2grZFGRnKbvEPbDz//PO2d+9e9zhx4kSMxuiJobFRcMM7BgokqKm6R+vbsGGD+7l169auFNeDDz7oAiylS5d2wYVA7du3d8dXQSoFJFauXBnUxZ2WVZaKF9TwMkr0ndBruXPnds9pvR5tu74jAJAcVI5PmYQAACAN99lYuzuk2wIAAIBUHtjwghWdOnVy2Ql33HGH7/ls2bLFWNa7EZ7Y2U66KX706FGrXLmy77mqVau62afq65GQwIao0bcCEIGllJRxsGbNGrc+BTP8qVySAhvKcliyZInLRBEFMRQoadGihV122WXuNf/yTmouXqFCBVeWS2WYkrIMlfz9998uEOGN86BBg1xvDH9e4EPbqPJd//zzT5xlqERZHEuXLrXrrrvONWlXc3A1bo9P1qxZY31e2+X/HQhcTjMZASA5xBa8TY/07+zBgwdd8JmMjfDD8QtvHL/wpfNXZRYjdSqQM6tVLZ7HVm07aCu3HrR9R05a/pyxX48AAAAg7TjvwIY8/PDDroyTfyNxzdJXZsD+/ftdiSKvUXbmzJldg+vE8AIXCjpcfPHF7mevtJECBwmlDALdvFdJJJWQ8vp6zJgxw930UY8QZWV4VHZr5syZbnmVcHr99detc+fO7oa/R6WZlOVRoECBGOtT1oYCG9u2bXNBlaQyf/5827Jli+uf4R0DBXr8MyLUBFzBFG2DMiaUpaJ9UfPz/v37x5oBonJcytaoUaOGe049RIIJQGj9unGmY6N+I94x02fqtX37qH0LIGV52Xfpnf791v9rGg8CG+GH4xfeOH5A8pajUmBDlynz1+2xVtWLM9wAAABpXIKbh/vLnz+/C27oprqnSZMmFhER4QIGKv2xYMECe/rpp61NmzYuWJAYxYoVczfk1RRbza81c0o/q7RSbIGEYKgBeK1atVwgwL8MVdu2bV1miPpLeI9bb73V3ZxXeSb1r1B5JfWgULNuNTRXmSoFLHTzXv0pAimooB4karoe2+vBUG+KXbt2uYc+RxkkOgbKFvFmJGubPvjgA/eayn+pLJWCGNpej8ZMZbMUePAvGeWfTXHBBRe4jA7tm7bba7au5uFeEEdBLK+3h0frufTSS13A5I8//nAP/ax99vp1AAAAAEBSaFLBrxzVGspRAQAApAeJCmyIMhZq167t+12zQJXJIGoErT4OuqHv3RRPrJEjR7ob+HfddZfdfffdrgG2AieJoX4haoTtZZfoRr72K5AyF5QpMnnyZLe8en0oy0PrV+ZKv379XIBFGSz+mR4ebauCO/69OxJKpaGaNm3qHu3atXPrUkPyIUOG+JZRk241an/llVdcQEkZHWPGjHG9TzwKzGjmoJaNjQIbCoh88803LgiiBu0qu6XslD///NMto2CKAh7+pcg86ieiAJeCQbfffrtrEv7aa6+d1z4DAAAAQFwalC1gWTJlcD8T2AAAAEgfMkTR2ABhWOdYAahZmzLYhl1HQr05AFKxiEK5bECH/4Lv6Z3+y1cpRZVipBRV+OH4hTeOX/ifeyrLOz2WNgzl/ifk703XN+fbovV73c9zBzS3kvkuSKGtDE/8m8TYhiO+t4xtOOJ7y9iGq6gQ3T9IyLlnonpsAKH0YNua6fLiEkDCnImMskwZU+4/YQAAkPKalC/0X2BjzW7rWi+CwwAAAJCGpWhgQz0dVB4pLuprcb4lq1QyacCAAXG+XrduXRs7dqylVsOGDbNJkybF+XqvXr1c6S38h2Sj8D1u6lWTK1cuZoyHoXA8fgQ1AABIHw3EX/r+7M8ENgAAANK+FA1sdOrUyZo3bx7n67pRdr7Uc0LNsuOSPXt2S83Uv6J79+5xvq60HyCtUFoZwhfHDwAApDY1I/JZzqyZ7MjJMzZv7R43GSNcJmEAAAAglQc21Dhbj+SQM2dO9whXajquBwAAAAAgYbJkymgNyxW0Wat32q5DJ+yfnYftoqK5GUYAAIA0KmOoNwAAAAAAgMRqXL6g7+c5/+xmQAEAANIwAhsAAAAAEGZOnDhhgwYNsnr16rmyvO++++45y95WqlQp2uPHH3+0tKZpxUK+n+etJbABAACQlqVoKSoAAAAAQOK98MILtmLFCvvggw9s69at1r9/fytRooS1bNkyxrJr1661ESNGWKNGjdJ0D79KRXNboVxZbffhk7Zg3V47fSbSMmdiLh8AAEBaRGADAAAAAMLI0aNH7bPPPrO3337bLr74Yvf4559/bMKECTECGydPnrTNmzdb9erVrXDhwpaWqVl44/KF7Kvft9rhE6ft980HrG7p/KHeLAAAACQDpq8AAAAAQBhZvXq1nT592mrXru17rm7duvb7779bZGRktGXXrVvnbvhHRERYetCkwn99NuatoRwVAABAWkVgAwAAAADCyK5duyx//vyWNWtW33OFChVyfTf2798fI7CRK1cue/TRR10vjs6dO9vPP/9saZUyNjxzCGwAAACkWZSiAgAAAIAwcuzYsWhBDfF+V+mpwMDG8ePHXVDjrrvusu+++841E//kk09ceapgRUVFuUdK8taZkPVemP8CK10gh/2796gt3bjfjp44bRdkzZSs2xmOzmdswdiGGt9bxjYc8b1lbMNVVIjOFRKyPgIbAAAAABBGsmXLFiOA4f2ePXv2aM/fc889dvPNN/uahVeuXNlWrlxpn376aYICGwcPHrSMGTOm+IWt+omIymkFq16p3C6wcfJMpP20apM1LkufjaQaW8SPsU0+jC1jG4743jK24SoqROcKgWVVz4XABoAUlykTs+bCGccPAIDQKlq0qO3bt8/12cicObOvPJWCGnny5Im2rIIRXlDDU65cOVuzZk2C1qnPTelzAG/GnrY/IRfUl1cpYZ8v2+F+XrbtuF1bK/r+4/zHFvFjbJMPY8vYhiO+t4xtuIoK0bnCmTNngl6WwAbCFifg4XvccufOHerNQDo+fmcioyxTRi7gAQDhq0qVKi6gsWzZMqtXr5577rfffnMZGIFZFQMGDHD/fz/33HPRmo9fdNFFCVqnPiMU59/eehOy7iYV/uuzMW/tbq4bknBsERzGNvkwtoxtOOJ7y9iGqwwhOFdIyLoSFNioVKmStWnTxkaOHBnt+S+++MJGjx5ts2bNsqT01Vdf2WeffWbjxo2L9vyECRPs7bffdunQqhU7dOhQy5cvX7yfp+0cOHCgvfvuu9akSZNoryk9u0GDBta3b98Yzy9fvtzmzJnjmu75O3z4sP3vf/+zb775xvbu3WslSpSwdu3audq1Xo3b5s2b25YtW2z8+PFWv379aO+fPXu23XnnndahQwcbPnx4vNv/6quvunH2ZMmSxc3W0jqVYq7fE0vb26dPH+vYsWO8y27atMnV7L3sssts8+bNduWVV9oPP/xgF154oaWEUVN/tw27jqTIugCkDRGFctmADrVDvRkAACTKBRdcYO3bt7ennnrKnn32Wdu5c6e7xvGCF8re0EQEZXDo/P7BBx+0hg0bWu3atW3q1KkuCKJrqLSqQM6sVrV4Hlu17aCt3HrQ9h05aflzRu9JAgAAgPCW4IyNadOmWefOna1Ro0aWnBYsWGBPPvlkjLqvM2bMsBdeeME9ypYta4899pg7KR81alTQn63ldUIf2HAv0I4dO2zp0qVWpEgRF7zo1KlTjNlP+/fvt5dfftkto5lP+mylhT/xxBO+5RRwUNAnMLDx/fffJzjipYsRBThETQAVdBk2bJht27YtqOBIfCZNmmQ5cuQIatlBgwa5YJACG8WLF3fBnwIFClhK2bLniK3ZfjDF1gcAAACkFpqwpcBGjx493AQsTdC6+uqr3Wua/KUghyYr6bnBgwfbmDFjbOvWrVaxYkUbO3Zsik1GCpUmFQq6wIaqKLwy6x+7umoxa1C2AFmbAAAA6TWwUbJkSXfz/ssvv4w3MHC+lJXw5ptvWpkyZWK8pkwNZTlcc8017vdHH33UhgwZ4upvBVPzVXXBdu/ebW+99ZbLTDgXBVGUol2nTh2bMmVKtMDGoUOHXGBi8uTJLhVcdHFw5MgRF5BRwMVLA1d6uAIb/fv3j1anTM/VqlUrASNzNkhSuHBh3+8RERGWP39+u/XWW6179+5WrVo1S4zzDUxo7P23CwAAAEDyZm08//zz7hHor7/+ivZ7ly5d3CM9yZb5v5Jc783d4B7F82a3wW2rWstqxUO6bQAAAEi86AVYg3D//fe7TIZ33nknzmW2b99u/fr1c7P5lfL8zDPP2MmTJ4Nex9y5c93nezOO/Es/rVq1ylq0aOF7TlkQyiIJtpGdZjNp2xTY2Lhx4zmX1efq86+44gpbvHixK7fk8eqLzZs3L9p7tM0KdvhnYlx++eXuvWvXrvU9p3q4CrLEFrxJKGXPlCpVyr777jvfcx9//LFLO1eGh8ppeRc3EydOdM/7++STT3xjrddUsssbb80E0+crYNKyZUsXzPGyVRYtWuSCUPp87Z9KlXljdODAAZe10rhxY6tbt6498sgj7jlZuHChW89HH31kzZo1c8EdvZ6Q7wgAAAAAxObrFdvstR//u/bybD9w3HqPX+JeBwAAQDrL2FBPh/vuu89eeukl129DGQP+dHNa6dClS5d2vTHUe8Iry/T4448HtQ7dfPdugAf2dBB95g033OBuoqtXhrIj8uTJE/Q+3HTTTS74oMwTpWHHRkGPFStWuBvuujGvgIiyNrwsD/2u3hgqiaU+ICrHpJv4CgKUK1cu2mdp2/QZytAoX768e05BiKuuusoFiZKCPtcLnGg9Cjg8/fTTrlyXtvuWW26xb7/91mW6KNCkffOyO/T8tddeG+MzVeJq/fr1rl6vZoRprDTWl156qftzw4YNLnDSq1cvFwTxp3E6duyYvfHGG+53pckrGKIUeFEdYJX30mfqZy2vIFLXrl2TZDwA4FyU5ZceKVswMjLS7T+NQsMPxy+8cfzCV3r9PyNcnYmMsiFTV1lULK/pOU0/0+stqhajLBUAAEB6CmyIZuhrVr9ufHs3rj2//PKLu1n/6aefuowEUWmm3r172wMPPGA5c+Y8741VmSdRQOLhhx92DcO1DSpHFbgd56LsDt1oV3Dk66+/dpkIsWVr6PN1s13LK+tC5bf8y1cpQKAyVJ9//rm9//777lGoUCG3TVrenxpra10qoyVqsv3iiy+6RuhJQYGWPXv2uJ8VLFCwQZkmXpaNGpWrGbuO3SWXXOKCGQpsKItCASSNYSDte8+ePV05LrnttttcEEfrUU8NlcVSPw6Nk39gQ71GlM2h/VVgRUaMGGGtWrVyzcbl1KlTLtClGr/K9FDmhvqFENgAkBKUxabgKwAASFsWrd9r2w4cj/N1BTf0upZrVL5gim4bAAAAQhzY8AIDN954o680kUdZAyqv5AU1RD0qTp8+7bIgvH4U57Wxmc9u7l133eUCBaIgQvv27V0wRdkkwapZs6arM6umerqpHmj69OkuOOGVuFKpJjUc//XXX13PDFEPDQUK9ND6FTx47733XEaLMjL8t0fbq/q3yjbR48SJEzEaoyeGAgsKbnjHQIEE/4bqWp8yLKR169auFNeDDz7oAizKrlFwIZDGVcdXQSoFJFauXBnUrDUtqywVL6jhZZToO6HXcufO7Z7Tej3adn1HACAlxPZvXnqZMX7w4EH3bzQZG+GH4xfeOH7hS+e+moCD8LDz0PEkXQ4AAABpKLDhBSvUTFuBhTvuuMP3fLZs2WIs690IT2wat9ec2r/Uk3fzXH09EhLYkIceesgFIF599dVozyvjYM2aNe4mvIIZ/lTWSYENZTksWbLEZaKI1q1Aifp/qCyVXvMv76TG4hUqVLCffvrJlV5SGaqk9Pfff7tAhDfOgwYNcmWx/HmBD23j4MGD7Z9//omzDJUoi2Pp0qV23XXXWbdu3dz4X3/99fFuS1xN5bVd/t+BwOV0wQ8AKSHYvkxpjf6dVVBe+09gI/xw/MIbxw9IGUVyZw9quSMnmFQFAACQrpqH+1M5qKNHj0ZrJK5AgzID9u/fH61RtrIt1OA6MUqUKGFFihRxgQePshN0c0avJZQyCHTzXr1A/BuJz5gxw81mVR8OBTK8hzIdZs6cacePH3clnF5//XXbtWtXtM9UaSbdMCpQoECM9SlrQ4ENZUkkZWBj/vz5tmXLFtc/wzsGCvQoI8J7qFSXjoMoY0JZKtoXNT/XfsWWAaJyXOqlogwUBUO85t/xBSC0fs0I9spOiQJF+kz/LA4AAAAASEoNyhaw4nmzu14a5/Lklyvs9Z/WuJ4cAAAASGeBjfz587vghm6qe9TMWw3FFTBQDfMFCxa4JtZqNJ6QBt+xUQDj1ltvtVdeecXmzp3rAhwqiaUggZfNkVBqAF6rVi0XCPAvQ9W2bVurXLmy6y/hPbRu3ZxXeSb1r1B5JfWgULNuNTJXmSplgejmvfpTxBbYUA8SNUGP7fVgqDeFgil66HMUcNExULaIV1pF2/TBBx+41xSwUVkqBTG8xuWiYIbKZin7JbZgg7Ip1DBcGR3aN223ept4DeK9II6CWF5vD4/Wowbj/fv3tz/++MM99LP22evXAQAAAABJLVPGDDa4bVX387mCG6cjzV74+i/r9tYC27T3KAcCAAAgvZSi8nTu3Nk1z1Z5JVG2gjIZFMxQI2g1C1eQQP0ckoIaWKtfhAInyhZp3ry5C24kht6vAIcoq0E38rVfgWrUqGEXX3yxy+RQoEbNwhVk0b4q0KAMEAVZ9LtKfQRSs24Fd1Qi6nzLoKg0VNOmTX2BBZW4UkNy9fnwqEn37t273bbpT5XAGjNmjOt94lFgRpkXWjY2CmwoIKK+IMpo0XpUduvll1+2P//80wUvFExRySuVIgss56X3qbm6gkHaVwV1Bg4caEmpZMGcdioyST8SQBoXUehsST4AAJB2taxW3MZ0r2NDpq6K1khcmRyDWlWx1dsP2us/rTUloi/asNeu/d8vNvS6i61D7ZKUagQAAAgTGaJobIAwoz4dCkAp0ya91skHcP5UckKzOdMj/ZevsoIKxNNjI/xw/MIbxy98pfdzz1Duf2L/3uj//EXr97pG4eq9oTJV3jmAnn/gk2W2Zf8x3/Ktqxe3YR2qWb4csfcMTEv4N4mxDUd8bxnbcMT3lrENV1Ehun+QkHPPRJWiAkKJmFz4HrdDhw5x/MJUWjh+6TWoAQBAeqP/8xuVL2jX1Srp/vQ/B1CQ4+v7m1mnOhf6npu+fJtd8/Jsm/PP7hBtMQAAAFKsFFVCqKeDyiPFRSWrvD4OCfXNN9/YgAED4ny9bt26NnbsWEuthg0bZpMmTYrz9V69etndd9+dotsEJGf0FeGL4wcAANKC3Nmz2MiuNe3KKkVs4BfL7cCxU7bj4Anr/s5Cu71pWXvkmkqWJVPGOLM+AAAAkE4CG506dXI9MeKSK9f51z5X3wk1y45L9uzZLTVT/4ru3bvH+brSfgAAAAAASatV9eJWp1R+e2TS7/bL/2drvDNnvc1cvs1Onom03YdPRuvToebk6uMBAACAdBLYUONsPZKDmpTrEa4KFCjgHgAAAACAlFUsb3b7oGcDe3/eBhv+9Wo7eTrStvo1HvdsP3Dceo9f4pqTE9wAAAAIHXpsAAAAAADSvYwZM9htTcval/c2scxxlJvyuowNmbrKNScHAABAaBDYAAAAAADg/+0/espOnyNooVe2HTjuem8AAAAgNAhsAAAAAADw/9QoPCmXAwAAQNIjsAEAAAAAwP8rkjt7ki4HAACApEdgAwAAAACA/9egbAErnje7xd5lw9zzel3LAQAAIDQIbAAAAAAA8P8yZcxgg9tWdT9niKPHhl7XcgAAAAgNAhsAAAAAAPhpWa24jelex4rljVluqlrJPO51AAAAhE7mEK4bQDqVKVOmUG8CEoHjBwAA0gMFL1pULWaL1u+17QeP27Bpq2z3kZO2autB23bgmBXPe0GoNxEAACDdImMDYStDBlK/w/W45c6dm+MXptLy8TsTqcISAAAA/1G5qUblC1qH2iWte6PS7jmdMkz6dTPDBAAAEC4ZG5UqVbI2bdrYyJEjoz3/xRdf2OjRo23WrFlJslGff/65vf3227Zjxw6rUKGCDRgwwOrWreteO3nypL300ks2ffp0O3bsmDVo0MCeeOIJK1asWLyfu3DhQrvlllts6NChdv3110d7TeuQ4cOHx3h+8uTJ9t1331mpUqWivXbq1Cl74403bMqUKW5bCxUqZNdcc4317dvXcuXK5Za5+eabbdGiRfb8889b+/bto71/7dq11qpVK7cP48aNi3f7Nc4DBw70/Z45c2YrWLCgXX311Xb//ff71pkY2l5tj/YhPnv27HH7du211/q+Hx9++KE1bNjQUsKoqb/bhl1HUmRdANK2iEK5bECH2qHeDAAAkIp1qRdh//vhH4uKMvvk10127xUVLCN9NgAAAMKjFNW0adOsc+fO1qhRo2TZoNmzZ7vAw9NPP201a9Z0QYW77rrLZsyYYUWLFrVXXnnFvv/+e3vxxRetQIECNmLECOvTp4999tlnQc8gHjVqlLVo0cK9/1xOnDjhC2goeHHfffdFe13bMG/ePHvmmWcsIiLCNm3aZMOGDbN///3XBTw8WbJkcUGfwMCG9iOhs54VwJk0aZIvyLNmzRq3zr///tvef/99y5gxcUk4r776qtveYGj/o6KifIGNOXPmWN68eS2lbNlzxNZsP5hi6wMAAACQfpXMd4FdWrGw/fz3Ltu875jNW7vHmlYsFOrNAgAASJcSfBe8ZMmSLvCgm+rJQYEMBQDatWtnpUuXdpkIyoT4+eeffa8/8MADLqtA2RwKgCxfvtwFE4KVM2dOFxCJj9apm/w33nijC2zoJn7gtvbr188FeS688EL351NPPWU//vij7dy507dcvXr13E3/wDFTYKNWrVqW0Nr2hQsXdg8di8suu8wFUX777TcXhEmsfPnyufEJRuB4aJuyZs2a6G0AAAAAgNTohvoRvp8/XrwxpNsCAACQniU4sKFAg8ouvfPOO3Eus337dnfDX8EHlSVSRkOwgZA77rjDevbsGeP5Q4cOWWRkpAtING7cONbXg/XYY4+5oISCAfFlpygoccUVV9iWLVts8eLF0V5XtsWCBQvcdnlq167tymTlz58/2nPZsmVzy3o0hgrGJEXZpnLlyrnt9A9s6GeVuVLWizJsVDLKy4jRcyrj5VHQpU6dOnb8+HFXikpZG6Jj9txzz1mzZs3s4osvtubNm9snn3ziXtMyGkM99LxXikrlvrxsFx0rBV4UvLn77rtt27Zt7rXNmze7Zb/99lu76qqrrHr16tarVy/bv39/oscCAAAAAJLLlVWKWsGcZydzfbtyh+09kjwT/gAAAJDEpahUDkolmdTnQv02VILJn26G9+jRw2VbqG/E3r17XQ8Mefzxx+P9fN1A96cb8Rs2bLBLLrnElVkKDGqop4OCCLpRHqwrr7zSBSuUXaEb8+pVEejIkSMuY+PJJ5+0MmXKWPny5d2yCtZ41K/DK42lG/jatqZNm7pMEn/a7ssvv9yVo7r00kvdc3qPAgaxrft8aJ1LlixxP69evdr69+9vQ4YMsRo1arj9uPPOO+2rr75y23jBBRe4cVU/EFGAQcGJ7NmzR/vMt956y3766ScXxFAvD+2/MmQ0frfddpvrESIao0CDBw9226PeIsoCUdmqe+65x/VP8SjTRGXBlPnRu3dve++991w2DgCEypkzZ9L04OvfWwXjtZ9psQF8WsfxC28cv/CV1v9vQMJkzZzROtW90N6avc5Onom0yUu32O1NyzKMAAAAKey87qprVr8aWau3g38vCfnll19cNsKnn37q67egG9+6ca2b1sGWOZKNGze6Ztlt27aNEfDwggPvvvuuu4Gf0BJICrK0bt3aPvjgA7v99ttj/Ww1B1cARNSTQ4Ea7YsCA3Lvvfe6wM5HH33k9vfjjz92+6eMkE6dOkX7PAUDFBRQMEV++OEH69q1q/3zzz+WFNQ4XMEYUTaNPlvj5gVglG0yceJE1wxdzcYVzFBgQxdq2ldl1QSqXLmyCyh55bKUdfHaa6+5QJMyRLxASGCvkgMHDtiXX37pGsDr/aLAhoI7c+fOtbJlz574K0CmwItoW1VSDABC6a+//oqW0QYAABCoa70IF9iQTxdvstualGHCAAAAQDgENtTnQTfo1XtCN8X9aRa/Mhz8m0irzNHp06ddoKJKlSpBrWP9+vWuJJUCB7HddNd6VRare/fu1qVLlwTvg/pTKINg9OjRLsARSOWktN3eTXsFAxTEUUDguuuu8y2nXiB67Nu3z5V0Gj9+vAtsKIOkWrVqvuWaNGniSi2tXLnS7dOyZctcJkRSBTYU1FBwwzsGM2fO9JWNEgVplE0i2l/tu7Jrli5dGu01fyoTpUDE8OHDbd26dbZq1aqgZq0p8KEZwSp55VHWhgIa2jYvsKGsHo+2XdsBAKGUkOy/cJ0xfvDgQcuTJw83YMIQxy+8cfzCl859mYADfxWK5LJ6pfPbr//us792HLJlm/Zb7VL/lSIGAABA8jvvOki66a+sBGVtqC+GR70kAnk3woNN49bN/ltvvdUFAMaOHRujRJKCDo8++qjdcMMNNmjQoPPdBRc4UVNw7YN/JomCFPPmzXPBmKpVq0Z7j5ZXYEPlnvSzMiBE5bCUdaAsCAVB1E/DP7ChLA+VgVI5KgV+VNIqIdkrwcwyrlixom+cVXpKTdj9eeNYv359y5Ejh9tHZdgogBFbxovKjX322WfWsWNH91kqL+X10ziX2L4D3nb59yNRY3YASE0UuE/rN1ZVHlH7SSmq8MPxC28cPyBtub5+hAtsyCeLNxHYAAAASO3Nw/09/PDDdvTo0WiNxDUbXzP2/RtBKztBvSRKlSoV72fu3LnT9W/QbH59rpeF4Jk/f74Latx0002+3h3nSzfWdbNeWRhec23R77oBP2HCBBe88B7aLgUs1BxdN+nVE8LLYvAoQKAAQmB5Jq8c1Y8//ujKUKm0VVLReP/666/WsmVL3zFQg26NofdQ9ob6aohuamlZ9c/QtsSWsSIqraUx1nFWI3KvPIsuzCWum2IKSOl467j7B4vULN3L1gAAAACAcNW6RnHLle3sPMGvft9qh0+cDvUmAQAApCuJCmwoS0E3vbds2RKt5JJubCv4oCwCBQLUW0KNxlX6Ij5qNq2ggrIoFDTZtWuXe6jUkjIolKGhjANlJHiv6aGySuejYcOGrpSU/z5MmzbNNfauW7euXXTRRb6HskgUFFD/CPX8UM8IlXSaOnWqCyToRr4CJdoWZW0EUr8OjYlKVnm9OxJKARVvn7du3epKcmksGjVq5PtMbeeMGTNcY3WV/3r//ffdQ5kiHgUztB8nTpzw9cEIpPJRCsRs2rTJBU50TMUba2WhaNzUU8WfMlFUHkzHfeHChS675ZFHHrFixYq57wcAAAAAhLMcWTNbu1ol3M9HT56x6X9sDfUmAQAApCvnXYrK07lzZ/v8889dpoWovMXrr7/ubmqrgbVucqtE04MPPhjvZykTQDfqjx8/7ss+8PTp08cFG3QzX4/AnhC6ia8gxfno37+/y14Q3aTXTfxXXnklxnJFixZ1WReTJ0+2Xr162csvv+z6bqhPh7ZJ5Z20XeqzEZhpIgULFnTNspXNEFtGRzCULeLtu0o+lShRwo2vfzkwNft+4YUXXA8P/alMmZEjR7qAkP8yCkxpTLU9sXn22WddLxUFQbTvClbo+P7555926aWXupJcaqCuwJACWIFjqiCVGoQrEKIyXAquJLTJOwAAAACkRjfUj7CPFm50P3+8eJNdXz/+CgUAAABIGhmivLpCQJhQ1oqyY2ZtymAbdh0J9eYASAMiCuWyAR1qW1qn//IPHDhgefPmpcdGGOL4hTeOX/ife2piUFrvxZTa9j+1/73R9rV6ZY79ue2g+/2b+y+1SsVyWzhI7WMbzhhbxjYc8b1lbMMR39u0Ob4JOfdMdMYGECoPtq2ZLi8uASSPM5FRlikjF/YAACA4ushX1sbgr1b6mog/2bYqwwcAAJACUjSwoWbbsZV48qik0tChQ8/rs//44w/r0aNHnK+rZNP06dMttUrOsUmrSDYK3+N2+PBhV66N2WHhJy0fP4IaAAAgodrXKmnDZvxpJ09H2hdLN1v/aytZtsxMvgIAAEhTgY1OnTpZ8+bN43w9tr4UwapcubJNmTIlztfj6iORWiTn2ACpjdLKEL44fgAAAGflzZHFWlUrZlOWbbX9R0/Ztyt3WNuaZ5uKAwAAIPmk6N3+PHnyuEdyUFPq0qVLW7hKzrEBAAAAACQPNQ1XYMMrR0VgAwAAIPllTIF1AAAAAACQJl1SroCVKZjD/TxnzW7btPdoqDcJAAAgzSOwAQAAAADAeVLfsa71I3y/f/brJsYSAAAgmRHYAAAAAAAgETrXudAyZczgfv701812JjKK8QQAAEhGBDYAAAAAAEiEInmy2xWViriftx88brP/3sV4AgAAJCMCGwAAAAAAJNINfuWoPl68kfEEAABIRgQ2AAAAAABIpMsrFbYiubO5n3/4c6ftPHScMQUAAEgmBDYAAAAAAEikzJkyWpd6F7qfT0dG2RdLtjCmAAAAyYTABoAUlylTJkY9jHH8AAAAYte13n/lqD5ZvMmiomgiDgAAkBwIbCBsZciQIdSbgPM8brlz5+b4hSmOX9zORHLjAgCA9K50wZzWuHxB9/P63Uds0fq9od4kAACANClzQhauVKmStWnTxkaOHBnt+S+++MJGjx5ts2bNStKN++qrr+yzzz6zcePGud83b95sV155ZazLjh8/3urXr3/Oz9N2Dhw40N59911r0qRJtNduvvlma9CggfXt2zfG88uXL7c5c+ZYrly5or12+PBh+9///mfffPON7d2710qUKGHt2rWzu+66y7JmzeqWad68uW3ZsiXW7Zs9e7bdeeed1qFDBxs+fHi84/Hqq6+6cfZkyZLFihYt6tZ5zz33uN8TS9vbp08f69ixY7zLbtq0ydatW2eXXXaZ79j88MMPduGFZ9Ovk9uoqb/bhl1HUmRdAHAuEYVy2YAOtRkkAABg19ePsHlr9/iyNhqWOxvoAAAAQIgCGzJt2jTr3LmzNWrUyJLTggUL7Mknn7Tq1av7nitevLgLMPhTQODff/+1WrVqBf3ZQ4cOtalTp/qCD3HZsWOHLV261IoUKeKCF506dYr2+oABA2z//v328ssvu2VWr17tPnvfvn32xBNP+JZTwEFBn8DAxvfff5/gWeu1a9d2AQ45fvy4C7oMGzbMtm3bFlRwJD6TJk2yHDlyBLXsoEGDXDBIgQ3v2BQoUMBSypY9R2zN9oMptj4AAAAAiM81FxezvBdksQPHTtn05dtscLuL3e8AAAAIYSmqkiVLupv3J0+etOSirARlMkRE/Fef1KvrXrhwYd9DGQMKODz//PNBZyvkzZvXdu/ebW+99Va8y86YMcMuuugil8UwZcqUaK8dOnTIBSYee+wxq1OnjstSuOqqq+yhhx5ywYHIyEjfsvXq1YuRzaJaq3ouIQEZ0X56+6/xadWqlb344os2efJkW7FihSWWAhPZs2dP8Pu8Y0PtfQAAAADpWfYsmaxD7ZLu5xOnI+2rZTQRBwAACHlg4/7773eZDO+8806cy2zfvt369evnZvM3bNjQnnnmmQQFQubOnes+/+qrrz7nciqJ1bVrVytfvnzQn61yUto2BTY2btwYb3aKsiyuuOIKW7x4sSu35FGmhR7z5s2L9h5ts4IM/pkYl19+uXvv2rVrfc8tW7bMBVnKlCljiaXsmVKlStl3333ne+7jjz92ARlleKic1l9//eWenzhxonve3yeffOIba72mkl1eqS2V7tLnV6tWzVq2bOmCOV62yqJFi1wQSp+v/VOpMm+MDhw44LJWGjdubHXr1rVHHnnEPScLFy506/noo4+sWbNmLrij15MzWAYAAAAAKVmOyvPJr5sYeAAAgFAHNtTT4b777rM33njDZUwE0s3pHj162LFjx1xvDJVp+umnn+yFF14Ieh26+a6gyLn89ttvLjjQq1evhO6C3XTTTS4YosyTuCjooQwIBTW0LQqI+Gdt6Hf1xtB+6Yb/c889Zz///LPLWChXrly0wEaePHnczX3/rA0FIZThkVS0P17gROtRwEGBBQVZtO5bbrnFBRauueYaF5jyz+749ttv7dprr43xmSpxtX79eteTREEeZZ4oQ0XHWH8qaHLbbbf5SmP5U5+OP//8031P3nvvPbdtCoZ4du7c6bJtxo4d696vbQjMigEAAACAcFSleB6rGZHP/bxiy0FbseXsJC8AAACEqMeGaIa+ZvXrxrduXPv75Zdf3I3zTz/91GUkiHpl9O7d2x544AHLmTNnkmy4Pr9FixYu0JJQCj489dRTdsMNN9jXX3/tAhOBdCM/X758LmNDyyvr4ssvv3Q37D3KRKlSpYp9/vnn9v7777tHoUKF3LhoeX9qrK11qcSWqMm2SkhNmDDBkoICLXv2nG1Qp2CBAj4KynhZNmpUrmbsOnaXXHKJCyQoC0PBDmVQPProozE+U/ves2dPV45LFMRQM3etRz01VBZL/Tg0Tsru8KjXiLI5tL9ly5Z1z40YMcKVzVKzcTl16pQ9/vjjVrFiRZfpocwN9QtRBg4AhKszZ85YaqYyiCqVqO1MaI8nhB7HL7xx/MJXav+3HanXDfUj7PdN+31NxKuVPHt9DAAAgBAFNrzAwI033ugrTeTRzHyVV/KCGqIeFKdPn3ZZEAoEJJY+S4GBhGSBBKpZs6Z16dLFZVropnqg6dOnu+CE1zNCpZrUcPzXX391mQuSMWNGFyjQQ8EcBQ+UnaCMFmVk+AddFNhQL5C9e/e6x4kTJ6I1Rk8sBRYU3PCOgQIJo0aN8r2u9W3YsMH93Lp1a1eK68EHH3TjWLp0aRdcCNS+fXt3fBVEUkBi5cqVQV3caVllqXhBDS+jRN8JvZY7d273nNbr0bbruAJAOFPZP2UsAgAAtKlR3IZOXWXHTp2xKcu22KBWVeyCrGevLwEAABCCwIYXrOjUqZPLTrjjjjt8z2fLli3Gst6N8KSa7aQSVLoJ3qRJk0R9jhp9KwARWEpJGQdr1qxxN+EVzPCnckkKbCjLYcmSJS4TRRTEUKBEWSSXXXaZe82/vJOai1eoUMGV5VIZpqQsQyV///23C0R44zxo0CDXG8OfF/jQNg4ePNj++eefOMtQibI4li5datddd51169bNNQe//vrr492WrFmzxvq8tsv/OxC4nGYyAkA4iy1InJro39mDBw+64DMZG+GH4xfeOH7hS+evyiwGEip39iwuuPHZb5vt0PHTNnPFNutY50IGEgAAIJSBDXn44YddGSf/RuKapa/MgP3797sSRV4gInPmzK7BdVL4/fff7eKLL441iJIQyiDQzXuVRFIJKa+vx4wZM9xNH/UIUVaGR2W3Zs6c6ZZXCafXX3/dOnfu7G74e1SaSVkeBQoUiLE+ZW0osLFt2zYXVEkq8+fPty1btrj+Gd4xUAN3/4wINQFXMEXboIwJZaloX9T8vH///rFmgKgcl7I1atSo4Z5TD5FgAhBav26cKTCkfiOiQJE+U6/t27cvyfYdAFITL8svtdK/3/p/TdtJYCP8cPzCG8cPSJ9uaBDhAhvy1ux1liljBiuSO7s1KFvA/QwAAIAUah7uL3/+/C64oZvqHmVRREREuICBSnIsWLDAnn76aWvTpo0LFiQFZRqotFFSUAPwWrVquUCAfxmqtm3bWuXKlV1/Ce9x6623upvzKs+k/hXaBvWgULPuzZs3uzJVCljo5r36UwRSUEE9SNR0PbbXg6HeFLt27XIPfY4ySHQMlC3izRTWNn3wwQfuNZX/UlkqBTH8x0zlqFQ2S4EH/5JR/tkUF1xwgcvo0L5pu71m62oe7gVxFMTyent4tJ5LL73UBUz++OMP99DP2mevXwcAAAAApHV1SuW3Ynmyu59Xbz9k/T5eZt3eXmBNn59lX6/YFurNAwAASJ+BDVHGQu3atX2/axaoMhlEjaDVx0E39L2b4klh9+7d0Xp4JJb6hagRtpddohv52q9AylxQpsjkyZPd8moWriwPBW6UudKvXz+XqaEMFv9MD4+adSu449+7I6FUGqpp06bu0a5dO7cuNSQfMmSIbxk16Vaj9ldeecUFlJTRMWbMGNf7xKPAjGYOatnYKLChgMg333zjgiDDhw93ZbeUnfLnn3+6ZRRMUcDDvxSZR/1EFOBSMOj22293TcJfe+2189pnAAAAAAhH36zcbtsPHo/x/PYDx633+CUENwAAAM5ThigaGyDMqM6xAlCzNmWwDbuOhHpzAMAiCuWyAR3+C/KnVvovX6UUNTmAUlThh+MX3jh+4X/uqSzv1F5yMK3tf7j/vTkTGeUyM7YdiBnYEO1RsbzZbU7/5ilelircxzY1Y2wZ23DE95axDUd8b9Pm+Cbk3DNRPTaAUHqwbc10eXEJIPXevKBWNgAA8CxavzfOoIaoc6Fe13KNyhdk4AAAABIgRQMb6umg8khxUV+L8y1ZpZJJAwYMiPP1unXr2tixYy21GjZsmE2aNCnO13v16mV33313im5TakeyUfgeN/WqyZUrF7PDwhDHL24ENQAAgL+dh+IOavib9sdWq1s6v2XNnOhK0QAAAOlGigY2OnXqZM2bN4/zdd3oPF/qOaFm2XHJnv1sw7bUSv0runfvHufrSdlTBAg1pZUhfHH8AAAA4lckd3DXoBMWbrRZq3fa7U3LWrcGpSxnNgorAAAAxCdFz5jUOFuP5JAzZ073CFdqOq4HAAAAACD8NShbwIrnze4ahavs1LmoJNUz0/+0V2etsVsalbYejctYoVzZUmhLAQAAwg+5rgAAAAAAJEOZysFtq7qfA1tuZvj/x8NXX2RXVSnie/7AsVMuuNFk+Cx7YsoK27jnaLR+XvPX7rEvl21xf+p3AACA9IocVwAAAAAAkkHLasVtTPc6NmTqqmiNxIvlze6CHnpd/t5xyN78eZ0LWpyOjLITpyNt3IJ/bcLCf611jRJWvUQee2/ehmifUTzgMwAAANITAhsAAAAAACQTBR5aVC1mi9bvdQ3F1XtDZaqU0eG5qGhuG9m1pj109UX2zpz1NnHRRjt68owpKWPq71vdI5BKXPUev8QFTghuAACA9IbABgAAAAAAyUhBjEblC8a7XIl8F9gTbapa3+YVbNz8f+29uett79FTsS6rQlQKjSgbRIET/0AJAABAWkePDQAAAAAAUpF8ObJa3ysr2ks31DrncgpuqDyVskEAAADSEwIbAAAAAACkQvvjyNYIpBJXAAAA6QmBDQAAAAAIMydOnLBBgwZZvXr1rGnTpvbuu+/G+57Nmzdb7dq1beHChSmyjUg89eNIyuUAAADSCnpsAAAAAECYeeGFF2zFihX2wQcf2NatW61///5WokQJa9myZZzveeqpp+zo0aMpup1IHDUZL543u2sUrrJTsSmUK6tbDgAAID0hYwNAisuUKROjHsY4fgAAhJaCE5999pk99thjdvHFF1uLFi3sjjvusAkTJsT5nq+++sqOHDmSotuJxFND8MFtq7qf42oNruePnjzNcAMAgHSFwAbCVoYMcZ3aI7Uft9y5c3P8whTHL+HORMY1vxIAgPOzevVqO336tCsr5albt679/vvvFhkZGWP5ffv22YgRI2zo0KEMeRhqWa24jelex4rljV5uKkums9dDuw6ftIFfLLeoKM45AABA+pHipagqVapkbdq0sZEjR0Z7/osvvrDRo0fbrFmzknR9mpmk2Uzjxo0LavkBAwbY5MmT43z9ueees4EDB9oPP/xgF154oaWkm2++2RYtWuT7PXv27FauXDnr2bOntWvXLtGfr5q7V155ZdD7Nn/+fCtSpIiVL18+2Y7fuYya+rtt2MWsMwCpV0ShXDagw383nQAASAq7du2y/PnzW9asWX3PFSpUyPXd2L9/vxUoEL0s0fDhw61Dhw5WsWJFDkAYBzdaVC1mi9bvdY3C1VOjWJ7s1u61OXbo+Gmb9sc2u6RcQet+SelQbyoAAEDa7bExbdo069y5szVq1ChZ17NgwQJ78sknrXr16kG/R+ncDz30kPt5xowZrgnfpEmTfK/nzZvXmjVrFuNiIaXcdttt7qHZOIcOHXJBCAVaNGOrY8eOifrs4sWL25w5c4Let1tvvdU+/PBDF9ho1aqVXX755ZaStuw5Ymu2H0zRdQIAAAChduzYsWhBDfF+P3nyZLTn582bZ7/99pu7BksMXX+kdEaAt04yEc7KmMHsknLRr9Ve6FTDek9Y4n4eOm2V1YrIaxeXyMvYhhDfW8Y2HPG9ZWzDEd/btDm+CVlfSAIbJUuWdGnQX375ZYwT8qSi7IE333zTypQpk6D3qUSOHt7PqiVfuHDhaMsE/p6ScuTI4Vu/ly2hGrtKLW/durVly5btvD87tn0NlrJH9AAAAACQvHTOHxjA8H73Pyc/fvy4m+g1ePDgRJ+rHzx40DJmzJjiF7Zes3PK0MauUcQF1q1ucZv42zY7eTrSeo//zSbeWtNyZTv3pT5jm3wYW8Y2HPG9ZWzDEd/btDm+sZVVTVWBjfvvv9+eeuope+edd6x3796xLrN9+3ZX9knljjR4bdu2tUcffTToQMjcuXPd5y9cuDBa+aakLtek0lovv/yyvfLKK7Z161b32gMPPOAyP1TjVs38XnrpJStatKh7/3fffed+37Jli0sF1z41aNAgUdt0/fXX25gxY9xMrMaNG7uLmhdeeMGmTp3qXleGyeOPP2758uVz26YxfP75533vV4aKLnR0LPz3bc2aNe4YLFmyxGWEKPPl6aefdsGU5s2bu/fecsst1qdPHxes8i9FtXbtWnv22Wdt6dKlljNnTreN99xzj7sYevXVV23Dhg2WK1cut426MFMWyp133pmocQAAAADSA11bqG+GztEzZ87sK0+lc/o8efL4lvvjjz9s06ZNdt9990V7v86727dvn6CeG/pcTYQKxYw9Zc0T2Ijb4PY1bOX2o/bHlgO2ad9xG/7DRnvlhlrnHDPGNvkwtoxtOOJ7y9iGI763aXN8z5w5k7oDGzoR18m1bvCr30ZERES013VjvkePHla6dGnXG2Pv3r32xBNPuNd0gz4YEydOdH8qsJHcFNRQ3VqlhN9xxx0ukKLAhkpEaT/ffvttt91q8te/f38bMmSI1ahRw37++Wd3UaE+INrXxJSQUiaHAhEKbIwaNcpWrFjh1quggca5X79+9sEHH7isjkGDBtmpU6csS5Ysbqx//PFHF5QIjI7dfffd7vM0w0tlr3Tho8yQN954w5XnUikxBSmaNGli33zzje+9Ol433nijC36ov8n69evd/iuQofJVouW1jPqZKNijz73qqqusbNmyiTgSAJA6JeQ/5uQ+MdG/79oebhCFH45feOP4ha/U8m+4vypVqriAxrJly6xevXruOU1y0kQk/6wKXXN8++230d579dVX2zPPPOPO4RNC/2+E4v8Ob738vxW37Fky2+gb61jrV39JUL8Nxjb5MLaMbTjie8vYhiO+t2lvfBOyrpAENrxG2Go4PWzYMHej3N8vv/xiO3bssE8//dRFhUQp1MooUMaBMgBSE92sr1mzpu8iQzfnr732Wt+FgwIaogySrl27uuwTL9th8eLFLgijpuWJobJZR44cccGV8ePH2+eff+6ySUTZGw0bNrS//vrLLr30UndTSwGfpk2bup4amtml17dt2xYtbf2GG25wwQcFTUQNB8eOHet+9vpw6PgEHg/V773gggtcdocuuJThoRlkr732mi+woewRBXk060vBIAVhFIwhsAEgLdK/v/r3GQCApKBzbWVcKAteWdI7d+50vQGVbS0699b1gc7zY5tApYlmBQsW5GCkIaUK5rARnWvY3eP9+23ks2ol4++3AQAAEI5CFtjQDW2diOvG+ffffx/tNZUxUm8ML6ghderUcanWGzdudMGD1MQ/40QXDyrL5P+7V+9W+zVz5kz75JNPfK8rc0IBhsRSUEMZEUo112cqKOFPwQyVf1KwQ5kRmrml9erPa665JkZauYIZ3bp1sylTpriAw7p162zVqlVWqFCheLdF+6kSXF5avNSuXdtdYKk2r6jUlf86FRzR8QWAtMgLNKeGGeP6d1jlRJj5Gn44fuGN4xfeGRvLly+31EbZ4bqeUqa7rgP69u3rJlWJzvMV5OjYsWOoNxMpqGW14nZr4zL2/rwNrt9Gn4+W2NS+TS139iwcBwAAkOaELLDhBSs6derksjY0a98TWwNsLwU8NaaCBwYF4mqqp2336tn6S2wjP/X9OHz4sOvZ4Y3PRx995Mu08Hizslq1auUuhFQeSj0xlEkRW6Ckc+fOlj9/fldSSiXDFNzQTLD4xHb8vMYv3vapDFZiut4DQDhJ6ZrkcdG/s/o/SttDYCP8cPzCG8cPyZG1ob55/r3z/DMF43Ku1xD+BraqbEs27rM/Nh+wDXuO2sAvltur3Wrz/z4AAEhzYr8Dn4Iefvhh12FdZZo8Kkek7IL9+/f7nlP9WGUAlCpVysKV9ktBCKWDew9lb8yePTtRn6uyU4ULF3b1dZU9ohtWGjtvHZrBpRlbe/bsccurb4YCDO+9954Lqnh1ef2pT4hS2j/88EMXdNJ71Bw9mOCD9nPlypUuc8SjJuIqX6USVAAAAACApJctcyYb3a2O5c5+dg6j+m1MWLiRoQYAAGlOyAMbyghQcGPLli2+59TITjfoH330UTejaMGCBa5fg7IGVD4jXKm/xIwZM1ywQCW13n//ffdQ2a1gKQikkk56qOSTsi3Un+KRRx5xgR8FMbp06eLS0tVHQw3FNY7//vuvK/8kWk5p6upt0rJly1hn7ygAoXWpTJiCMWoCPmHCBF9ZLVFGyD///OMai/tTDxEtp74o2kZ9hpqMq7QVM4QBAAAAIPn7bXjUb2PFlgMMOQAASFNCWorKo5JHyjpQhoAo4+D11193wQw121b/Bd0sf/DBBy2c1apVyzXy1k1+/ansk5EjR1r9+vWD/gyVgvLKQSn4oPJTr7zyiisX5VEjcqWk33fffS5rQp//1ltvRSuF0rp1a5ctoj9jo54Y9957rw0ZMsROnDjh6sMrUPHYY4+5xu5qOKgG8NoPBWkqV67se6+CK2oyrhJjKrulTA3V/u3Vq5clpZIFc9qpsxWuACBViiiUK9SbAAAA0iH6bQAAgLQuQxSNDRBmVEZLpckUKEotdesBIC5nIqMsU8aYmXGhoP/yDxw4YHnz5iWDLgxx/MIbxy98pfdzz1DuP39vEufE6TPW5Y35rt+GtKlR3Ndvg7FNPowtYxuO+N4ytuGI723aHN+EnHuGvBQVcL6IyYXvcVP5Mo5feOL4JVxqCWoAAID0hX4bAAAgLUsVpagSQg2vVXopLipZNXTo0Dhfb9iwYbQ+EYGmT59uJUqUsJTWsWNHW79+fZyvq49GbE2+gXCk6CvCF8cPAAAgvPpt3D1+ia/fRvWSee3oydO2Ycc+K1P0tDUoW5CJGAAAIOyEXWCjU6dO0fpJBFJ/h3OZNGmSRUbG3ZihSJEiFgqjR492/TDiop4WAAAAAAAkpt9GxzHzXKlMT/G82W1w26puOQAAgHARdoGNPHnyuMf5ioiIsNQoFFkiAAAAAIC0b2CryvbjXzvt3z1HowU1ZPuB49Z7/BIb070OwQ0AABA26LEBAAAAAEAaljljRjt6IvZysF6YY8jUVTGCHgAAAKkVgQ0AAAAAANKwRev32q7DJ+J8XeGMbQeOu+UAAADCAYENAAAAAADSsJ2HjifpcgAAAKFGYAMAAAAAgDSsSO7sSbocAABAqBHYAAAAAAAgDWtQtoAVz5vdMsTxup7X61oOAAAgHBDYAAAAAAAgDcuUMYMNblvV/RxXcEOvazkAAIBwQGADAAAAAIA0rmW14jamex0rljdmuameTcq41wEAAMJF5lBvAID0J1OmTKHeBCQCxw8AACA8KXjRomoxW7R+j81aucXenrfZPb9g3V6LioqyDBnI2AAAAOGBjA2ELU66w/e45c6dm+MXpjh+SetMZFQSfyIAAMC5qdzUJeUK2j3NSlnNC/O651ZtO2hz1uxm6AAAQPrM2KhUqZK1adPGRo4cGe35L774wkaPHm2zZs1KkvVMmTLFxowZY7t27bJGjRrZU089ZYULF06WbdTzAwcOtGeeeca6dOkS4/OmTZtm77zzjq1Zs8Zy5Mhhl1xyiT344INWunRp9/qrr77qPrdjx4723HPPRXuvZsQ0a9bM7cdff/0V77Zv3rzZrrzySt/vGTNmtDx58ljdunXt0UcftTJlylhiaXsXLVpk48aNi3fZkydPumPRtWtX9/vNN99sDRo0sL59+1pKGDX1d9uw60iKrAsAklpEoVw2oENtBhYAAIRswspdl5azez9a6n5/8+d11qxicNfVAAAAaa4UlW70d+7c2QUcksMvv/xigwYNcg+t44033rA777zTBSB0oz+pt3H69OlWqlQp+/LLL2MENr7//nsbPHiwDRkyxGrWrGkHDx50AZfu3bvbzJkzLVeuXG65LFmy2M8//2yRkZHRtnHZsmW2e3fCZ8V89tlnVrx4cTtz5ozt2LHDBSO0To1BkSJFLDFuu+02F6AIhsZG4+8FNrQd2teUsmXPEVuz/WCKrQ8AAAAA0pJrLi5mpQvmsH/3HHUZGyu2HLBqJc9mcQAAAKSrUlQlS5a0oUOHutn8yWH8+PHWtm1bdyO/fPny9vTTT9u2bdts7ty5Sb6Ne/bssfnz59u9995rv/76q23atCna68pWUCaGMkAiIiLs4osvdpkghw8fdoEMT9WqVe3YsWMukBEYGKlVq5YlVIECBVyGSrFixVxA5bXXXnPZIm+++aYlVs6cOS1fvnxBLauME396n94PAAAAAAiPslR3NCvn+/2t2etCuj0AAAAhC2zcf//9LotA5Znisn37duvXr58rW9SwYUNX5inYQIiCCzVq1PD9nj17dpdRERg0SOw2ytdff+16AbRr185lQihrw5+yL37//Xc7cuS/ckjZsmVzAY/LLrss2nNNmzaNUeZKgY2rrrrKEkuff91119l3333ne+7vv/92mRcaq2uuucYmTJjgnj906JBVr17dFixY4FtWgRg9p+CNsi78MzaUHdKyZUurVq2aO1bKTlGmyMKFC12Jri1btrjyXiqTpffp/R5lkFx77bVuGxQAWrx4se+15s2bu21StofWre1fsWJFoscCAAAAABC8LnUvtII5s7qfpy/fZpv2HmX4AABA+itFVbRoUbvvvvvspZde8mUy+FMAo0ePHq4Hhfo47N2715544gn32uOPPx7v5xcsWNB27tzp+13lnRSk2LdvX5Jto3+ppcsvv9wFMHQjXgELZW94TatvvPFGV7rp0ksvdY/GjRu7P73+Gv7UG+Ott96yhx9+2P2unhzHjx93AYOkUKFCBTcOClJkzpzZlefq0KGDy2hZt26dG2NlU7Rv39719VAQRP1A5KeffnJZIOrVoQwVj3ptKOg0YsQIl3WiwMMjjzziSnhpXFQO7N1337VJkya59/tTUEPrVqkuBTb0+1133eWCRRp/URBEn6/MG22ffv7444+TZDwAIFwoWJxSlGmn/ze1Tu//MoQPjl944/iFr5T8dxoIhexZMtktjcrYS9//bWcio+ydOevtqXYXczAAAED6CmyIZu7rRvawYcNcD4bAHhm6Af/pp59a3rxna3c++eST1rt3b3vggQfiLWXUqlUrF5DQjXUFBd5++21XMurUqVNJto2i8lZLliyxnj17ut+vvvpqmzhxov32229Wr14995wCA8o6GDt2rMvGmDFjhmXKlMluuOEGF6Tx76ehDA4FAv79918X+FC2hoIdSXVjSZklouyR2bNnuwCQMlNETcWVWfHhhx+6wEbr1q3t+eefd9uo9X/zzTcusyJwW1TeSuOjfZcLL7zQ3nvvPfvnn3/cc1qn9je2xu0KWmmMtT5RQEcZGyol9tBDD7nnFHjxMlY0zsriAYD05q+//nLlCgEAAELllkal7Y2f19qxU2fsk8WbrN+VFS3//2dxAAAApJvAhm52P/XUUy6jQTfw/a1du9bdaPeCGlKnTh07ffq0bdy40apUqXLOz1bpIpVZuummm9zvKrOkLAmvUXdSbKOXreGVkBKVzdI2T5482RfYkNq1a7seFydOnHAZDsrqULBD5bFuvfVW33L58+d3GREKgOgmvtbp3eBPCsrUEAWGlKGxevVqt23+M820z3LFFVfYY4895spoqYyUgk0KegRS4Eilvl555RWXYaKbbwrMeGNyLjrOym7xp34iet6j74FHxy+hwSkASAv073BKzhg/ePCg5cmTh4yNMMTxC28cv/Cl8+jly5eHejOAZKUgxvX1I+z9eRtccGP8gn+t75UVGXUAAJC+AhtesKJTp05uxv8dd9zhe17BgrjSu4NJ89bNeZU3evTRR10wQQ2rO3fubE2aNEmybfQCGyoVpWCE/3aqlJLKJulnNQpXeSU18dZ+qcSTHirzMW/evGiBDVGGxg8//OCyTtQrpH79+i4DJCko6FCiRAkXIFCQSOWilAkTG2ViKLihTA1lzxQqVCha3xKPAh4KTnjlq/SzemwEI67jrLHxZMmSJUH7CABpkRd0Tqkbq8om1DopRRV+OH7hjeMHbzKSJgzpfF3fCX+6NgBC6famZe3D+RssMspcgOPOS8u5MlUAAADpKrDhlR9S42n/Jt1ly5a1DRs22P79+11QQtT4W30hlOUQn/fff9/16VBA4YILLnD9Nv7880979tlnk2wb169fb6tWrXKlmtQw26OLEJXLUn8KBSemTp0aIzNDVKIpthv7CmyoX4WyPlRKS/ucFDQeX331ldsPb4wVQFHpKO+GmRqfa6aZ18dE5ahGjRplu3fvdvsSGzUOV+BHgSTxsmq83hznuimmbVBGiH9zdP3un+0CAAAApBc6H1fGeGzlB3VerWsaIJQiCuSw1jVK2NTft9qeIyft8yWb7aaGMftHAgAApAb/NYFIBiq/pMCB+jt4lFmhZt3KuFCWwYIFC1yTaTXxVmmM+Ohmvfpq6H3q9aAm4OpfcdFFFyXZNipbQ0GX66+/3n2u91AAQE26VW5KAYO7777bBQfUFFzln1QiS4EXBTy6d+8eY13a73LlyrnlW7RoYedLDdd37drlsi2WLl3qtkMXSGoYLu3atXPZJsrYUOmnn3/+2WWlqO+GR+W7FBRSSay4AhsaA32+jpPGesCAAW69CqSIAksHDhxwgSoFPfwp2KN+GhorBYpefPFFVx5L2TUAAABAeqM+gV26dLFff/3VnRf7PwhqILXodWk5389vz17nmokDAACku4wN0Y3szz//3N1EFwUEXn/9dRfMUL8M9YRo27atPfjgg0F9njIAdLNewQiVotLv6heRlNuowIa2KWvWmM3SunXr5oIECircfvvtru+GmoqPGTPGve41NNefsWnevLkLfpxP6SyPLoi8sSxSpIgrOzV06FArUKCAe17lqLQNymJRGSkFKNSTpFevXr7P0L5p7JRFUbly5VjX06dPHxs4cKAL8OgzFUDS/nsXXsrcUCN0jdVHH30U7b0KligbRP05FAxR75R3333Xypcvf977DQAAAIQrZazfcsstCe4NCKSkaiXzWpMKBW3umj22Yc9R+27VdmtZrTgHAQAApDoZogKLuwKpnHp1qHzZrE0ZbMOuI6HeHAA4LxGFctmADrVTdPT0X74y7RSUp8dG+OH4hTeOX/ife9aqVStRfZFU0rZ69ep22223WXrc//PB35vQjO3sv3fZLe8ucj/XjMhnU+5pzHlDEo0tku97C8Y2teJ7y9iGq6gQ/ZubkHPPZM/YAJLLg21rpvjFFQAkJZV3yJSRizIASA+KFi3qylHNnDnTZT1nyZIl2uvPPfdcyLYN8NesYiGrUjyP/bntoP2+ab8tWr/XGpb7r6wxAABAapCqAhvvvfeeK10UF5U8UsmluKjRt9f/ITYqMVWiRAlLjf744w/r0aNHnK9ru7X9+A/JRuF73A4fPuzKMDDLJvxw/JIWQQ0ASD804019BYHUTufo6rVx/yfL3O9vzV5HYAMAAKQ6qSqw0alTJ9eDIi7x1aOdNGmSRUZGxvm6+lGkVupzoUbbccmcOVUdKiDRaWUIXxw/AAASjowMhJPWNYrbC1+vtq0HjtsPq3faPzsOWcWiuUO9WQAAAD6p6m55njx53ON8RUREWLhSM2+lpAMAAABIm77//nsbO3asrVu3zk0UKFu2rHXv3t3at28f6k0DosmSKaPd3qycPT1tlS9rY0SXmowSAABINTKGegMAAAAAIK37+OOP7ZFHHrH69evb8OHD7fnnn7cGDRrYkCFD7LPPPgv15gEx3FA/wvJkPzsXcsqyLbb9wHFGCQAApBqpKmMDAAAAANIiZWoMHjw4WnbGVVddZRUrVrQ33njDunTpEtLtAwLlzJbZbm5U2l77ca2dOhNl781dbwNbVWGgAABAqkDGBgAAAAAksz179litWrViPF+7dm3btm0b449UqUfjMpY189nbBh8t3GgHj58K9SYBAAA4BDYAAAAAIJlVqVLFpkyZEuP5yZMnW4UKFRh/pEpFcme3TnVKup8PnThtExduDPUmAQAAOJSiAgAAAIBkpv4at956qy1cuNBq1jzbhHnZsmW2evVqV4oKSK3uaFbOPl68yaKizN6du956Ninry+IAAAAIFc5GAAAAACCZqeTUF198YTVq1LC1a9fa5s2bXSPxmTNn2iWXXML4I9UqXziXtahS1P284+AJ+3LZllBvEgAAABkbAAAAAJASypcvbwMHDmSwEXZ6XVbevl21w/389i/rrFOdCy1jxgyh3iwAAJCOUYoKQIrLlCkTox7GOH4AAATnlltusdGjR1uePHns5ptvtgwZ4r4R/OGHHzKsSLXqls5v9Urnt1//3Wd/7zhsP/2905pXPpvFAQAAEAoENhC2znVhiNR93HLnzh3qzcB54vilLmcioywTsyUBINVq0KCBZcmSxf3csGHDUG8OkOisjV8//NX9/MbP6whsAACA8A5sVKpUydq0aWMjR46M9rzqx2p20qxZsywpffXVV/bZZ5/ZuHHjYrz2+OOPW9GiRa1v374J/twBAwbY5MmT7bvvvrNSpUol0dae/VwZPnx4oj9Ls7wWLVrk+z179uxWrlw569mzp7Vr1y7Rn686v1deeaX98MMPduGFF8a7/Pz5861IkSIupT65jve5jJr6u23YdSTF1gcAqUlEoVw2oEPtUG8GAOAc+vTp4/tZ59etWrWyrFmzRlvm6NGjNmnSJMYRqd6VlYtY+cI5be2uI7Zo/V5bunGf1S6VP9SbBQAA0qkkydiYNm2ade7c2Ro1amTJacGCBfbkk09a9erVY7z29ttvu4CH/8VDsE6cOOELaEyZMsXuu+8+S61uu+0294iKirJDhw65IITq9J4+fdo6duyYqM8uXry4zZkzxwoUKBDU8rfeeqtLmVdgQxdpl19+uaWkLXuO2JrtB1N0nQAAAECw9u7da8ePH3c/65y9YsWKlj9/9BvBq1evthdffNGVrQJSM/XUuOvSctb/8+Xu9+dm/Gk3XVLaiuTObg3KFiCLFAAAhF9go2TJkjZ06FD78ssvY8xASirKBnjzzTetTJky0Z4/fPiwDRo0yAU9dGP+fPz8888uRfzGG290mSDK+EitZY5y5MhhhQsXdj972RKa5TVixAhr3bq1ZcuW7bw/W3Xzvc9OKGWP6AEAAADgLGVb33///b5rC00G86fJSpIU2ddASmhfu6QNm/6nHTx+2hZt2OceUjxvdhvctqq1rHZ+1+QAAAAJldGSgE7Wd+zYYe+8806cy2zfvt369evn6syqvuwzzzxjJ0+eDHodc+fOdZ9/9dVXxyifpIwLlUKKiIg474yTevXq2RVXXGFbtmyxxYsXR/t8ldv69ttv7aqrrnLZIr169bL9+/f7llGWQ9u2ba1GjRp2xx132NNPP+0rQRVImSHKbqhZs6a7sPEvLXW+rr/+ejcb7LfffnO/a1w1vhpnPR5++GHf9j7wwAPWv3//aO9/6KGH7LHHHvPtq/6UNWvW2O233261a9d2+63Az9q1a91rzZs3d39qZtmrr77qxt97TrSc3lunTh1r1qyZC0xFRka617S81jl48GD3ujJ9lHEDAAAApCUtW7Z0pVp1DaAgxqeffmrff/+976HXVN71hRdeCPWmAkH5cfVOF9QItP3Aces9fol9vWIbIwkAAMInsKG+Firf9MYbb9imTZtivK4b7T169LBjx465jIiXX37ZfvrppwSdwE+cONEFRQJVrlzZZXIE0xMiNkeOHHEZGwpqKBtEGRDqtRFI+zZq1CgbP368LV++3N577z33vPa3d+/edu2117oyVgoATJgwIdZ1Kc1cQQUtr14hmpl155132r///muJoUwVZXIoECHazhUrVrhggUpFKatFQSVRVsePP/5op06d8h0b/a7n/SkIcffdd7tsHGXifPzxx3bmzBmXGSJeHWAFKVQay5+CLAqCKKNE5cEUwNC4aVs833zzjcsu0VgrAKL0+/Xr1ydqHAAAAIDUpkSJEu5aRdcCulbQ+bX30GsqTeWdmwOp2ZnIKBsydVWsr53NPTL3upYDAAAIi1JUXmNrzdofNmyYCwL4++WXX1xGh2Yo5c2b1z2nXhm6wa8Mgpw5c1qoaKaULiQU2JAWLVq44Iu274ILLvAtp8CNMjJE2RkKbohu3Ov5e+65x/2uAMK8efNiXZcyTrp27ere72U7KDtEQZu4MjyClTt3bhekUfBIQYTPP//cZV+IAkjK3Pjrr7/s0ksvdUGLhQsXWtOmTV22iUpI6fVt2/6bXaNawDfccIMLUChoIh06dLCxY8e6n70+HDqegcdPGTAaO2WuZM6c2QWLdu3aZa+99prryyH58uVzQR6Vv1KWi4IwCsaULVs2UeMAAOmNgs7B0mxh/R+g96TWkouIG8cvvHH80se/s+eye/duNyFLk5G8z9T3Qtciynb2zxoHUiM1DN924GzPmNgonKHXtVyj8gVTdNsAAED6k2SBDd2gfuqpp9yNcAUL/OlEXdkQXlBDVIJIDa83btxoVapUsVCZPn262xbvRr1KXSkwo9JT1113nW+50qVL+37OlSuXb1aVggWBzcxr1aplBw4ciLEujcPMmTPtk08+8T2nz1GAIbEU1NB2KYNEn6mghD/dyNqwYYMLdqiklvZP69Wf11xzjTt+/hTM6Natm8tCUcBh3bp1tmrVKitUqFC826L9vPjii11Qw6NyVgpuHDx4ttm3Zq35r1PBEX0fAAAJo/+HFNQGAKRu6guoax9db7z77rvWs2dP97vKVCV2khOQEnYeOp6kywEAAKSKwIYoQNCpUyeXtaFZ+J7YGlp7s5SSagbU+di3b5/LrtAN9apVq0Z7TTf0/QMbai4eG92c95r+eQJ/92hfVXqqffv20Z5PbNNt9cRQuamKFSv6xvOjjz7yZVp4ChY8O2tGPT4GDhxojz/+uKvrq0yK2AIl6gGi1Hj1zmjTpo0LbugiLD6xHW+vv4a3fbGNZ1zjBgCIm5edFwz9O6sAc548ecjYCEMcv/DG8QtfOn/1srUTQxkZOpfWhB/1D7z88sutbt269tZbb9ns2bNdNjeQmhXJHdx1646DBDYAAECYBTZEjarVJM+/kbjKCylbQA2sVYJIli1b5mb0lypVykJF2Qq64a6eGCrl5FHfh/fff981PI+Pggle027PypUrY21krnFQEMI/+0NlovR8ly5dzns/VHaqcOHCrgG6Skgp2KKx9jJh9uzZ45qDK5ihrI7GjRu7CzT1CVFQRe8LpKbmO3futKlTp/oyL1S2Kpjgg/ZHY6vMES+AsXTpUpcV4x1/AEDSCMy4Oxf9G54xY0b3HkpRhR+OX3jj+EHfAfUmlAoVKrhsaAU21KvP/9oJSK0alC1gxfNmd43Cz3VV+OyM1bZhz1Eb1KqK5cqW5LccAAAAkq55uD/N8FdwY8uWLb7nmjRp4m70P/roo65kxoIFC1z/BWUBaNZoqKgXRLNmzdwFxUUXXeR7qA+EbvyoaXZ81DNDQRrNtFLza5Wx+vXXX2O9YaTPnTFjhmuirbRzBU/0UJmuYB09etSVdNJDJZ+UbaH+FI888ogLQChwoSCJyoKpj4Zq+Grc1aDca7Cu5bySWwpCxbatCkBoXSorpmCMeokoAKRm4x5lhPzzzz926NChaO9VDxEtpz4l2kZ9hpqMq7QVN9IAAACQHilD3Lu+0AQkZW2IzrWBcJApYwYb3PZspYP4OnV9tHCjXfPSbJu3ZneKbBsAAEh/kjywISphpBRrj2aGvv76675AwIMPPmhXXnmlDR061EJFzcwVgNC2BtJMKm2fMjfiU7JkSXvllVdc1oRu6CszQe+NrdSSem8oQ0NlolQOSs3UR44cafXr1w96u5W+rt4Yeqifyfz58936/ctmqUZvo0aNXMNzjbcCGQq8+M/qbd26tQtc6M/Y6Pjde++9NmTIEGvXrp1rDK9AhbI/NHZew3jtj4IW/hRcUZNxBW9UdktBrB49elifPn2C3k8AAAAgLXnooYfcubwmNuncXX3sdP2gc2RdGwDhoGW14jamex0rljd6WSplcoy5qY49076a5ch69rpzy/5jduPYhfbElBV25AT9FAEAQNLKEEVjg0T5+++/Y/TouOuuu1xD8b59+yb+CCEGldFSlsysTRlsw64jjBCAdCmiUC4b0OG/SQTB0H/5Bw4csLx585JBF4Y4fuGN4xf+556apJSQ8n+xUV88lY4tVKiQmyykzGZlSqsclTLG0/r+JxR/b1Lv2J6JjLJF6/e6RuHqvaEyVcrokE17j9ojk363Bev2+paPKHCBjehc0y4pd7bvY1rG95axDUd8bxnbcMT3Nm2Ob0LOPSl4mUjKSlD/ilGjRrmSUmpGriwKZaUgeT3YtmaKX1wBQGqimwreTQQAQOqnzGY9vCzxm266KdSbBJwXnX80Kh97kCKiQA776I5LbNyCf234zNV27NQZ27T3mN3w1gK7tXEZe7RlJcuRNXO8ARIAAIBUHdhQA2uVUoqL0rPPp2TVH3/84cofxaVEiRI2ffp0S6yrrrrK9ZlQcENlmtQ4+6WXXrLKlSsn6HM6duzoenTERX00YmvynZ6RbBS+x02zFXVRT8+V8MPxS1248AeA1E3XBMGe7/z555/Jvj1ASsmYMYP1aFzGLq9U2B757A9btOFs9sb78zbYj3/tdNkbe4+csCFTV9m2A8ejlbRSHw+VvAIAAEjVgY1OnTpZ8+bN43zdm9F0PhcRU6ZMifN19Z1IKr1793aPxBg9erSdOnUqztc1owtIK5RWhvDF8QMAIDgffvghQ4V0rXTBnPbxXZe4gMYL36y246ci7d89R63rm/NjXX77gePWe/wS18eD4AYAAEjVgY08efK4R1LLmjWrlS5d2sKFMkgAAAAApB0NGjSI8ZwyV1XOtkKFCnby5MnznsgFhFP2xm1Ny9oVlYvYI5/9br/+uy/OZaPUCNTMZXK0qFqM7FQAABCn1NmhDgAAAADSEAUxHn/8cRfs6Ny5s2sePmDAALv99ttdY0YgrStbKKd90quRdb+k1DmXU3BD5anUewMAACAuBDYAAAAAIJm98MILtmbNGps8ebJly5bNPde3b1/bt2+fPfPMM4w/0k1/sPplCgS1rBqKAwAAxIXABgAAAAAks2+//dYee+wxq1Spku85/fz000/b7NmzGX+kG0VyZ0/S5QAAQPpEYAMAAAAAktmRI0fsggsuiPF8ZGSknTlzhvFHutGgbAErnje766URl5xZM1mtiHwpuFUAACDcENgAAAAAgGTWvHlze+mll1zzcM+mTZtcGarLLruM8Ue6Kkc1uG1V93NcwY0jJ89Yt7cX2Ka9R1N02wAAQPggsAEAAAAAyezJJ5+0jBkzuubhx44ds06dOtnVV19tefLksSeeeILxR7rSslpxG9O9jhXLG73cVJ7smS1zxrPhjmWb9lvrV36xb1ZuD9FWAgCA1CxzqDcAAAAAANI6NQl/9dVXXZbG2rVr7fTp01a2bFkrX758qDcNCFlwo0XVYrZo/V7XKFw9NVSmatXWg3bvR0ts496jdvD4aes17jfr2aSMDby2imXNzNxMAABwFoENAAAAAEhm3bp1szfffNOqVatmERERjDfw/2WpGpUvGG0sql+Y16bd19QGfr7cpi/f5p57b+4G++3ffTa6Wx0rVTAHYwcAAChFBSDlZcqUiWEPYxw/AAASrlChQrZnzx6GDghCnuxZbPSNte3p9tUsa6azWRp/bD7gSlPN/P9gBwAASN/I2EDYypAhrlZzSO3HLXfu3KHeDJwnjl/qdyYyys1+BACkLlWrVrV77rnHqlevbiVLlrSsWbNGe/25554L2bYBqfW88+ZLSlvtiHzW56MltmHPUTt04rT1nrDEejQqbYNaV7FsmZkwBQBAepWsgY1KlSpZmzZtbOTIkdGe/+KLL2z06NE2a9asJFlPu3bt7K+//or23NSpU+2iiy4K+jNU71bb9P7771ujRo2SZLu8z120aJGNGzcu0Z81YMAAmzx5su93XQwpjf3666+3W265JUlu9OuYffjhh9awYcN4l/3zzz9d48M6derYwoUL3TYEHofkNGrq77Zh15EUWx8ApHYRhXLZgA61Q70ZAIBzXLcASJhqJfPa1L5NbdDkFTb1963uuQ/m/2u/bTxbmiqiQI4YfTqY5AEAQNqX7Bkb06ZNs86dOydpsMDfmTNnbMOGDTZ+/HgrU6aM7/n8+fMneDtLlSplU6ZMSbZtTQrXXnutPfbYY+7no0eP2oIFC2z48OF28OBB69u3b6I/f86cOZY3b96glr333nutT58+LrBRu3Zt996UtGXPEVuz/WCKrhMAAAA4H2oSrklfxYoVS5IBPHHihA0ZMsS+/fZby549u912223uEZuvvvrKXnvtNdu2bZvLHBk0aJDVqFEjSbYDSAm5s2exV26oZY3KFbSnpq60k6cjbcWWg9by5dmWPWsm23/0lG/Z4nmz2+C2VV1zcgAAkHadLVaZjJRmPXToUDt58mSyfP7mzZvt1KlT7sS8cOHCvkfmzMHHbFauXGkbN2603r17uwuDI0dSbxaALlq8fSxdurTL1tCFiRoR7tixI9Gfr88NTIsPht6j9wIAAACI6Y033nDXLUnlhRdesBUrVtgHH3xggwcPdtnnX3/9dYzlfv31VzcxSmWwpk+f7iYk3Xnnnan6mgeIjSoU3NiwlH15bxMrVyine+746choQQ3ZfuC49R6/xL5eQS8OAADSsmQPbNx///3uhvs777wT5zLbt2+3fv36WYMGDVwJpGeeeSboQMiaNWusePHili1btvPeRmVrVK5c2a655hp3saHgRmB5pi+//NLNsKpWrZrdeOONtmnTJt/ruqDo2rWrC67ccMMN9r///c9uvvnmWNelC4uOHTu6Zdu2bWvffPONJUVKe5YsWWz27Nnu96ioKDcjq2nTplavXj27++67bevWsym7L774onXv3j3a+0eNGmW33nqrb19VVkp03O677z6rX7++2+8OHTrYb7/95l7T/m3ZssUGDhzoSmTpPXpvMMdUpcj0/ldeecW9pm1UTWFtNwAAAJAW6VpizJgxLts8sZO+lLn92WefuYDFxRdfbC1atLA77rjDJkyYEGPZXbt2uaDGdddd58rYKut6//79tnbt2kRtAxAqVYrnscn3NrHsWWK/neFdVQ6Zusr1HgMAAGlTspeiKlq0qLs5/tJLL7mTeZ1M+9NJfY8ePVz2gfpQ7N2715544gn32uOPPx7v5+uEXDf1e/Xq5QIMZcuWtUcffTTo1GrdTJ85c6YLNuTMmdOVoVIfC93ED+yV8fTTT1vBggXdDfuXX37Z9Q45dOiQu4hQiSiVhJo3b567Sa/yTLFdVGg7H3jgAWvWrJktW7bMBQX0mbq5f74U1LnwwgtdkEdUlks9RrR9hQoVsnfffdelpeu51q1buyDTnj173HpFwRXtQ6CHH37Y8uTJYx9//LEbJwVFnnrqKfc5Gg9dHOlzNXarVq1K0DFdunSp27aJEyfa8uXL3Thceuml1qRJk/MeBwDAf2UaY6N/yyMjI93rSdGXCSmL4xfeOH5p79/UhNIkJE028u+ZF9i/LlirV6+206dPu+wLT926dV1WiP6dz5jxvxu+uk7xHD9+3PUU1HWASmMB4WrV1oN2/FRknK8rnLHtwHEb8c1fdnvTslY497knQioAQp8OAADCS7IHNkSz8zVLf9iwYe5k298vv/ziMgM+/fRTX2+HJ5980pWFUgBAwYZzWb9+vR04cMC6dOniAij6HN1UnzFjhsvkiI8yEFRr9qqrrnK/X3311e4mvLIRVEbL07NnT1/vjW7duvlmQ2k9OXLkcDfsM2XKZOXKlbMlS5a4IEYgvadx48a+jAnd+NcFjNLHExPYkFy5cvnSyceOHevS0b0G4CoFpuwNjXXz5s1dL5Lvv//elbFSs2/tq2Z5BV58a0yUxeLVAb7pppvsrrvucj/ny5fP7W/u3LndIyHH1LtAVKBI260x0wWWAhwENgAg8fRv+7FjxxhKAEhFNAkqqehaQz0F/UvIatKQ+m4oG6NAgQIx3jN//nw3KcmbsBTfdVYgvS+lM6y9dZLZzdgG2nnweFCD8sbPa92jWok8dlmlwnb5RYWtVkQ+y5zpv+Df1yu225Bpq1wJK08x9elooz4dCe+Jw/c2+TC2jG044nvL2IarqBCdhyVkfSkS2NANcM30Vwkn3VAPzLjQjXb/htXKdtAMJPW9qFKlyjk/WzfHNfNIN8hF61FgQaWjVIIpPqozqwCGmujJlVde6W7C6/1K2fYoCOHRurz6uLp5pPRv7aOnVq1a9t1338VY17p16+zHH3+MNrNKn6Msk8Q6fPiwL7ihMlAKIPjP1NIYKe1dWrVq5cptKbChPxVsUaDCn2byKoCjwI3GUwEkZcRoBlh84jumolli3jET/azXAQCJ518aMPAE4eDBgy4bj4yN8MPxC28cv/ClCTmagJNYKtEqOifX+bLOq3UdUKFChQR/loLXgX3xvN/jKnNVsWJFN9lM1yPKllbGt65bgqX/P/yvL1Lq743Kbgn/bzG2/nJkTNi144qtB93jtR/XWu5smaxR2XzWpFx+OxMVZU/PXOsrX+XZceC43TNhib3YobJdWelspQO+t6HHvwmMbTjie8vYhquoEJ2HBXPvOUUDG96N7U6dOrmsDf+yR7H1xvDSvYNJ+1aTcP8b5BpoZQAE00hbn68Ge/v27fMFNrwBDAxsqNxVbBTQCIwkxRVZ0o179dUIDLgkpNF5bDQzSxdI6pPhjZn6fAQGTLxAgwIbajauixMFNm6//fYYn6kx0IwuLaPllemhIEyfPn3i3Z5gjmlsDcqZiQUAScM/2B7476xuSul1bhCFH45feOP4QefV6k/3ww8/uPNynRdrUpL62ak/XmAWdHzn24EBDO/37Nmzx/oeZXTooYljv//+uys3m5DAhoLicf3/kly86wONF/9vMbb+rqiWx4rlXeMCELFdfev2S4GcWa1LvQvtl39228qtB32vHTpxxr5dvcc94vzu/f9nvDhrg11Xr6xlyhj8DR2+t8mHsWVswxHfW8Y2XEWF6DwsIWVgUyyw4fVsaNmyZbRG4rr5rpvySpn2sgbUe0I3+0uVKhVUmSuVXPJuuOuGvLIoVDYpPkrHVv8H9YtQhoFn7ty5LlVcmQqx9coInPk0a9asaLVsV65cGeuy2lf1lvDP/lD/C12EBJNdEhf1vNAX7IorrnAXHMqGUHr65Zdf7l7X5z/44IMugKFsEdXT1UMXMxp7rwyXP/XrWLx4sRsjL5XdK7+lL/a5vtDxHdO///77vPcVAAAACEfPPPOMy6xWRrQmYnnn3MqeUI++Z599NkF9DDU5SxOnvElSOv9XUEPXA/7++OMPF5BQlrlH1wIJbR6u8/9QBBe89RLYYGz9Zc6UwZ5qW9V6j1/iAhD+wQ3vWzqsQzVrWa24Dbj2bOmqn//eZT/9vct++XuXHTwef8aH16djzprddnmlIkEdAK9Xx4Yd+6xM0TPWoGzBBAVFED/+TUg+jC1jG4743qa98U3IulI0l1h1YBXcUE8Hj3oqqKG4Gn4rILFgwQJXXkqNxgNPymOjTAL1Z9DMJ5V6Uj8JNfQObP4dVxkqBSbUV+Oiiy7yPVQySzfkp0yZEu9nqBm3ykDpYkTlmtRXQhcrsdHnqpyTGqnrxr8CEqNGjbISJUpYsFRSShctevz777+uUbgugtS/wgtAKHNDzc0VcNF61P9DQRrvAsrb7jFjxriG3f4ZLx6NvQI1GiMdL2W2KADkPxtMvUU05gpg+EvsMQUAAADSGp2bq2yu/zm5ylCpDK6uZRJCWRcKaGjykH/vwOrVq8coFzVp0iR3zeFPE7H8twMIRwpajOlex/XD8Kff9bxe9xTJk9261Iuw126sY0ueaGGT7m5kV1ctGtR6bn1vsV0+4ke7e9xv9vL3f9vXK7bZht1HLDIyeq6Inm/6/Czr9vZCG/jV3+5P/a7nAQBA0kvRjA3p3Lmzff7557Zz5073u2YPvf766+7Gd9euXV0TO5VrUoZBMHQTX6WYNANq9+7dVrNmTXvvvfdivVnvTzfn1QcjttJKSu3u2LGjuwh47LHHzvk52l41RB8yZIhNnDjRXUxo+73986deHlpWzfqUtaKZVpqh1a5dOwvWzJkz3UO0j8qOUOBC2+tRZobS2nWRpKBLtWrV3Pr8e16ovNTIkSNdgCM2ahiuCy+lxetCyFtP//79bdWqVS7zQz04tC8KnihzxpPYYxqskgVz2qngy64BQJoXUejc//cBAEJH1xix9ajQrLSEpNzLBRdcYO3bt3fn65rkpGsPZYJrspVoEpRKWymDQ331dE7+wQcf2GWXXWZfffWVy+J44YUXkmzfgFBR8KJF1WIuS2LnoeNWJHd2a1C2wDmzJNQ4vF6ZAnbqTJR9uyr+EtayYc9R9/h65XbfcxdkyWQXFcttVYrltsioKPv0180x3qeG5MoqCQy0AACAxMsQRWODRNm0aZPr51GvXj3fcwpyqKGfylkh6enCT7PTVBM4pev8AkBqpxIIcV3M67/8AwcOUKs8THH8whvHL3wl1bnnE0884bKZNTHIK7mrCUKaOKRG3pp0lBC63lBgQz3zNOFJk5s06UsqVarkghze5Cc1DNdkJWV8K2Ndk7fiK7mbGs69+XvD2Cb3OZMyKhR8iL1L5tngRcUiOe3vnYfteCJm1RXPm93m9G8eVFkqr5xVsIGa9IR/ExjbcMT3lrENV1Ehun+QkHPPFM/YSGuUEdGzZ08bMWKEy9ZQWrcajwemeyPpEZML3+Omvze6AKdWcvjh+KV+XPgCQOr0yCOP2L333mvXXHONrzyrGoo3a9bMBT0SSlkbzz//vHsEUgDFn3rx6QEg+jnT4Hj6dLx0fU2XaaFgw797jthf2w/Zn9sP2eptB+2vHYfs3z1HgxpS9epQOau6pfNb5eJ5rLIyPYrnsSK5s0W7JlLZqiFTV7nl/YMi2k4yPgAACKPAhkpKvfLKK3G+rvJG6qkRmz179sTaFNufGnknlurbquSTAhnbtm1z/TIGDhzoa9wdLF3kzJs3L87XlQWSkJJVQGqW0HILSF04fgAAJJyCGePGjXNBBzXuVmkqlXul1wUQ+j4dgcGEYgHBBAVByhXO5R7XVv+vpNThE6ftnTnr7KXv/ol3XZv2HXMPW7bV91y+HFlckKNysTx2JjLSxi3YGON9lLMCACAMAxudOnVyzcHjcq4+GsE2/04KXbp0cY/EGDx4sEsnj0vBggUT9fkAAAAAQkMloDQBKkuWLK5MlB7z588nAxkI0z4dnlzZMluDMrpWjz+woY8L6Ddu+4+esgXr9rpHXPQWbYmCL9pOsnMBAAiDwIZmNXlp2gmlGlylS5e2cFGkSJFQbwIAAACAJC7hOGzYMPvoo4/s/ffftwYNGvheU/aGel/06NHD9dmgRCcQOgoWNCp/fpMJFQRRuai4enVk+P8MkB8eusw27D5qq7cftNUqZ/X/Ja12HjoR7zr0ucooUfDlfLcTAIC0JlUHNgAAAAAgXH344Yc2Y8YMe+2116IFNeT111+3WbNmuTK2aiZ+4403hmw7ASRvrw69niNrZqtaIo97+Ntz+IS9N3e9jf5xbbzrUkYJAAA4K+P//wkAAAAASEKffvqpawweV+Nuld19+OGHbeLEiYw7kAZ6dSgzw59+1/PnavxdMFc2a1KhcFDrUfNyZYIBAAAyNgAAAAAgWWzZssVq1KhxzmUuueQSV64KQFrp1bHHNuzYZ2WK5rcGZQsG1RMjvnJWntd/Wmvrdx+xYR2qW4GcWZN0+wEACDdkbAAAAABAMihYsKALbpzL9u3bLV++fIw/kAYoiHFJuYJ2bdXC7s9gG3175awk8B2Bv89csd2ueXm2/bh6ZxJtNQAA4YnABgAAAAAkgxYtWtirr75qp06divX106dP2+jRo61p06aMP5DOnauc1Rvd69jrN9WxfDmyuOd2HTphPd9fbIMmL7cjJ06HaIsBAAgtmocDAAAAQDK45557rHPnztaxY0e7+eabrVq1apY7d247cOCArVy50saPH29HjhyxF154gfEH4FfOaq9rFF4kd3ZXpsrL/KhXOr89+vkf9tNfu9zvHy3caHPX7LZRXWtZ3dL5GUEAQLpCYAMAAAAAkkGePHlcA/EXX3zRhg8fbseOHXPPq/mvAhytWrWyvn37WqFChRh/AI6CGI3KF4x1NIrkyW7v3VrfJizcaMOm/2nHTp2xf/cctS5vzLN7Lq9g911Z0bJmpjAHACB9ILABIMVlypSJUQ9jHD8AAIKn/hnPPPOMPfnkk7Zp0yY7ePCge65UqVL8nwogwTJkyGDdLyltTSoUsgc/XWZLN+63yCiz0T+usR//2mkvX1/LKhbNbWcio+LM/AAAIC0gsIGwPqFDeB43zVBEeOL4hR9d1HIRCwChlzVrVitfvnyoNwNAGlG2UE77rFcje+Pntfby9//Y6cgoW7n1oLV+dY61q1Hc5qzZY9sPHvctXzxvdtegXOWuAABIC1I8sFGpUiVr06aNjRw5MtrzX3zxhWucN2vWrCRZz+eff25vv/227dixwypUqGADBgywunXrxvs+LTd58uQ4X3/uueds4MCB9sMPP9iFF15oKUl1eRctWuT7PXv27FauXDnr2bOntWvXLtGfv3nzZrvyyiuD3rf58+dbkSJF3AVaUh+/YIya+rtt2HUkxdYHAOEmolAuG9Chdqg3AwAAAMkgc6aM1qd5RbvsoiL2wKfLbM3Ow3bydKRNWrIlxrLbDxy33uOXuAblBDcAAGlBSDI2pk2b5proNWrUKFk+f/bs2TZ06FB7+umnrWbNmi5Qcdddd9mMGTOsaNGi53zvY489Zg899JD7Wcu/++67NmnSJN/refPmtWbNmlmBAgUsFG677Tb3UF3eQ4cOuSCEAi2nT592TQkTo3jx4jZnzpyg9+3WW2+1Dz/80AU2VB/48ssvt5S0Zc8RW7P9YIquEwAAAACA1KT6hXltWt+mNnzmant/3oZYl4lS9rWZDZm6yjUoJ6MXABDuQtJVqmTJki7wcPLkyWT5fAUy2rdv77IYSpcubffff79ryPfzzz/H+16VyClcuLB76GfVkvd+10Mp5PozVDXmc+TI4dbvZUooYHPnnXfaiBEj7MSJE4n6bG9fz2fflD0SqmAPAAAAAADpWfYsmeyai4udcxkFN7YdOG5z/tmVYtsFAECaCmwo0KASUe+8806cy2zfvt369etnDRo0sIYNG7qGe8EGQu644w5XnimQMhySolyTymnpT9HPM2f+H3v3AR1F2YUB+JJQQg0QILRQpfcOCkrvvWOhiSAiooh0pSgKKEVERFBAelFA6dKlN+m99xoghBJa8p/38s+62WzIJptNdpL3OWdJsjs7O/vNksx8d+69K6ROnTqaHdKzZ09tCti2bVv9+c0339T3ali9erVmN+AxZK1Yl5aKqlatWsnt27dlz549+jPGCeOFccOtV69ecvfuXX3sk08+kT59+oR6PjJUkKli+95OnTol7777rpQoUUKKFCmi7+X06dP6WNWqVfUr3ucPP/ygpaiM+wDL4bklS5bUDBeUqQoODtbHsDxec9CgQfo4MndQNoyIiIiIKC57/vy5bNiwQaZNm6ZNxPfv3x8t5yhERIBG4Y5497fd0n7qTpm+7ZxcvP3wpb3atp32lz/3Xdav+JmIiChel6JCOaiPPvpIxowZo/02/Pz8Qj2Oifl27dpptsWMGTN00v7zzz/XxwYOHBjh+gsVKhSmNNW5c+ekfPny4grjxo2T4cOHy6NHjzSogmAFAgUoEYX3iUl7bPexY8c0qDBkyBApWrSoZpAg2+Kvv/7S9+pMCSlkciAQ8eqrr8ro0aPl0KFD+rpJkiTRcUaQ6LfffpN69epJ//795enTp5IoUSId6/Xr12vgwRqCEO+//76uDwEInHAhywaZIRMnTtTyXAhIIEjx2muvyapVqyzPxf5CEASBjgULFsjZs2f1/adIkULLVwGWxzLIrkGwB+utXr265MyZ04k9QURE4U2kAcoY4vc7fkYjeDIX7j9z4/4z/+9QZ129elUv/MEFRwEBAdrb7pdffpG9e/fqBV+4wIiIyBkZUno5tBwajW84flNvIocld/rkUiVfBqmSP4OUyZFWEif0kJWHrmrZKmR4GNiAnIiIJL4HNoxG2LjKf9iwYTpRbm3Tpk2a5TB//nztaQFffPGFdO3aVTMOkidP7vDrXLhwQQMMDRo0CBPwiC6YrEcGBhQoUEAn55HBATVr1tSABuCEpWXLlrotRrbDrl27ZM6cOdq03Bkom/XgwQMNrsycOVObpxsnRyNHjtTMjePHj8vrr7+uk1o7duyQihUrak8NlJHC4zjZMgQFBUnr1q01+ICgCTRp0kRPvsAoO4X9Y7s/0EMladKk2uMkYcKEWjLr5s2b8uOPP1oCG6lTp9YgD8peIRiEIAyCMQxsEBFFP/z+x98HIiKKPbhIqFSpUjJ48GApXbq03ocLknBBFLKtcUEXEZEzyuZMq8EHNAoPL7ciWWJPSZHEU24E/lcR4/TNB3L65ln5ZfNZSZ7YU/L4ppB9FwPCPJcNyImIyJ3EWmADE9o4qMfE+Zo1a0I9hjJGOXLksAQ1ACWL0CAbgQoEDxyBTAGUpEJGCE4WXMU64wRBAvQQsf7ZKKGF94WyVfPmzbM8jswJBBichaAGMiJQBgvrRFDCGoIZyFpBsAOZEX///be+Lr7WqlUrTF8NBDPatGkjixcv1oDDmTNn5MiRI9qrJCJ4nwgiIahhQDkrBDeQcg9Zs2YN9ZoIjmD/EhFR9DMC3bhiHL+HU6VKxYwNE+L+MzfuP3NnbBw8eNDp9ezevVsv3LI+BkYG9QcffKAXEBEROQsNwQc1KChdZ/6rjcKtgxtGru7olsW0F8fRq4Gy/vgN2XD8huw5f0eMKlMPnjy3G9QANiAnIiJ3EmuBDSNY0axZM83awFX7BpRPCi8F3NFU8JMnT2p2AIIOyDJAgMFVbIMCHh72W5dg21F6Co3NrTm7beiJcf/+fcmTJ49lfGbPnm3JtDD4+PjoV/T4QBYLykOtW7dOMynsBUrQAyRNmjRaUgolwxDcmDJlSoTbY2//Gf01jO3DSZy9E34iInLd3yn8nsXfKPzMUlTmw/1nbtx/hGN+f3//MBnKuBgLFygREUWH2oUzyU9vlwxTRiqjt5cGPfA4FMycSm/dqrwidx8+kX9O3pINx27I6qPXJTDoWYQNyMesPi5tymWXLKmTRrhN6M2x8+xt7QGCclnILEEQhoiIyLSBDUBj69q1a4dqJI6DfWQXoP4sShbBvn37NAMgW7ZsEa7zxo0b0rFjR+1bgRJHkSld5Up4XwhCWPfTQJko3N+iRYsorxdlp9KnT68p7SghhQkrjJ2R2YITKKPnB06a0DcDAYapU6fqCZaRCm8NfUIwjkuWLLFkXqBslSPBB7wfZIIYfTwAtYNRvsrYn0RERERE8QkyqlFet3fv3paABo650Q/PmXMBIiJbCF7UKJjR4WBC6mSJpWGxzHpbvPeyfDxvX4SDOn79ab1l9vaS0jnSSpkcafRrXt+UoV6HvTqIiCjOBjaQEYDgBrIHjBJOaEaNTAsc9H/66ady584d7deArAGUz4jIiBEjNEMAmSAPHz7UGyCDITaDHMggeeutt6RIkSJSuXJlzZaYNm2aNvV2FN4LSjoByomsXLlSgzd4rwhAIHCBEyOU+UIdX2RpfPPNN3LlyhUt/wRYDr0/0NsEy9q7ahcBCLwWyoQVLlxYtm3bJrNmzQp1NRnGE5kxBQsWDPVc9BBBU3GcuCETBydt+Bllx3iFMBERERHFR926ddNzGRyno+9R586d9Vgd5whoKk5EFJ0QXKiQ+0XVhsjwTRW5ihJXAoLkr/1X9AYpvRJKqexptAk5MjXGrD4Rpt8He3UQEVGcCGwASh4h6wAZAoCMgwkTJmgwA822EYzAZHnPnj0jXBcyCjAZj8wFZIJY+/DDD6V79+4SW4oXL64ZGpjkx1dkn4waNUrKlCnj8DpQCsooB4XgA8pPjRs3TstFGdCIHMGdjz76SLMmsP5JkyaFKplVr1497fWBr/agJwZOvoYMGSKPHz/W+uwIVCDzA43dfX19tQE83gf6nuTPn9/yXAQ/UP4LwRaU3UKmRrt27aRLly5RHDkiIiIiInPDhUa4yAnH0LiACBnUKVOm1K9Hjx7VHnVERO7egByXRaZJnljeKpdN/r1wR/49f1cePf2vZDjKWG04flNv4WGvDiIiig4JQtjYgEwGJ38oTbbuYgI5d/NBbG8OEZHb8kuXQvo2KWH5GX/yAwICxNvbmxl0JsT9Z27cf+Y/9sRFSra99SIDZWK3bNmiF/1YO3/+vDRs2FD2798vcfn9RwX/33BszSgufG5RPgoNyCWcBuTo4WH06nj6PFiOXr2nZa92n7sju8/fllv3nzj8WnPeK+9wZklcGFt3xbHl2JoRP7dxc3wjc+zpFhkbRFHRs0GxGD+5IiIyG5QAYHNGIqLYsWDBAi3/apwcNmvWTDw8PEItg/KyuXPnjqUtJCKKegNySOTpIUWzptZbp0ovfted838ok/45LXN2XoxweNEDhIiIKCpMF9hAw2uUXgoPSlaht0R4ypUrJ0+ehH/1wLJlyyRz5swS05o2baq9KMKDPhr2mnzHZ0w2Mu9+u3//vpYs41U25sP9Zz4MahARxR6UZU2UKJH2/+vfv7906NBBy08ZcCyUNGlSKV++PHcTEZm6Abn177Wc6ZJLw2JZHApspE6WKBq3moiI4hPTBTZwlZN1Pwlb1s2t7fn999/1xCI8GTJkkNgwfvx47YcRHvS0IIorkFZG5sX9R0RE5BgENRDcgKxZs0rJkiUlYULTnYIRUTwV1QbkjvTqMAz567B82yKRNhwnIiKKDNMdVadKlUpvUeXn5yfuKDayRIiIiIiIKGbs3LlTb+H58MMPuSuIKE4FRVC2Cr06kOMRXnDjzK2H0nziVunwak7pVSuvJEtsumkqIiKKJfyLQURERERE5GI7duwIkwF56dIl7bFRq1Ytjj8RxZteHcjk6FQpl/y177LsvxQgISEiU7aclTVHr8vwpkXk1VfSxep2ExGROTCwQURERERE5GIzZsywe//XX3/NvmNEFC97dbSrkF0DGqP+PiGPnwXLhdsP5c1fdkibsn7Sr24BSeXF/htERBQ+j5c8RkRERERERC70zjvvyMKFCznGRBTne3U0Kp5FvxoNyBN6ekjn13PLyo9fl7I50lqWR9PxmqP/kbVHr1vuex4cItvP+MuKIzf1K34mIqL4jRkbREREREREsWTjxo2SJEkSjj8RxVs50yWXuZ3Ly6wd52X4imPy4MlzuXYvSN79bbc0Lp5ZXnslnYxefSJMOSv08EBGCBERxU8MbBAREREREblY1apVw5ScevDggQQEBEifPn04/kQUr3l4JJB3KuSQKvkzSL+FB2XTyVt6/+J9V/Rm61pAkDYmRw8PBjeIiOInBjaIiIiIiIhc7MMPPwwV2MD3iRIlksKFC0v27Nk5/kREIpI1TTKZ3rGs/L7nkgxdclgCHz+3Oy4oRIXfqGhMjh4eRnkrIiKKPxjYICIiIiIicrGmTZtyjImIHIDAb4vSfpIiSULpOuvfcJdDcAPlqdCYHL07iIgofmFgg4hinKenJ0fdxLj/zI37j4goZhuD25afCs/06dNdvj1ERGby5HmwQ8sNWHRQ6hfNJOVz+UjJ7GnEK5H98000HEcQ5EZgkGRI6SVlc6ZlpgcRkYkxsEGm5ehJIrnffkuZMmVsbwZFEfdf3Np/OLlj2j4RkeuUK1eOw0tEFEUIPjjizK0HMm7dKb0l9vSQ4tlSa5CjQi4fKZEttQY6Vh66qmWr2ICciCjucGlgI1++fFK/fn0ZNWpUqPsXLlwo48ePl3Xr1kXL68yZM0d++eUXuXPnjpQoUUIGDx4sfn5+kVrHDz/8oNs0bdo0qVChQrRsl7HenTt3yowZM5xeV9++fWXRokWWnxMnTqzvs1WrVtK2bdtomejHPsPVYo6chB09elQePXokJUuWlB07dug2HD9+XGLK6CX75dzNBzH2ekREcYlfuhTSt0mJ2N4MIqI431fDnvv378vz58/F29s7xreJiMgskFGRydtLG4Wj7JQ9uEgHF+tYZ3kgKwO3cWtPSuKEHpI9bTI5eeN+mOeyATkRkbm5PGNj6dKl0rx582gNFljbtGmTfPvttxo8yZEjh4wePVq6desmf/31V6S3M1u2bLJ48WKXbWt0qFOnjgwYMEC/f/jwoWzfvl2GDx8u9+7dk+7duzu9/s2bNzt8goVxxskaAhsIKOG5Memy/wM5de1ejL4mEREREVFU/fbbb3pB1q1bt/TntGnTSps2bcINgBARxWcIWgxqUFC6zvxXG4VbBzeMyzp/fLOEFPNLLTvO3JZtp/1l+1l/Oe//0LLck2fBdoMaYrW+wZFsQB4dJa1YFouIyASBjSxZssjQoUPlzz//1AyD6LZx40apWLGiVKlSRX/GSUHDhg3l9u3beqLgiMOHD8uFCxdk2LBh8uWXX8oXX3whyZMnF3fk5eUl6dOnt/ycPXt28fDwkCFDhkjLli3F19fXqfVbrzsysG+j+lwiIiIiorjuxx9/lJkzZ0qPHj30oqDg4GD5999/NWscx9KdO3eO7U0kInI7tQtnkp/eLhmmjFRGby8NeuBxaFwii97gyt1Hsv2Mv97WH78hNwOfvPQ1kLlRaeQ6KZEtjRTImFLyZ0wl+TOllCypk4apjBEdJa1YFouIKHp4iIt9/PHHcv36dfn111/DXebatWt6gF+2bFktgfTVV1/Jkycv/8NjSJ06tezatUtOnz4tz54904wLBFMik9aNbI38+fNLrVq15OnTp/L333+HKc+EwAzKahUuXFjefPNNuXjxouXxQ4cOaVChaNGi0rp1a/n++++1UaA9u3fvlqZNm+qyDRo0kFWrVomzEMhJlCiR/PPPP/pzSEiInjgh4FO6dGl5//335cqVK/rYd999J2+//Xao5yPLpX379pb3irJSgP320UcfSZkyZfR9N2nSRPbs2aOP4f1dvnxZ+vXrpyWy8Bw815F9ilJkeP64ceP0MWzjN998o9tNRERERBQXzZ8/Xy+kwvkCjpsLFCggb731ll5YhdK6RERkHwIGm/tUlTnvlZNvGubVr/g5vEBC5tRJpWnJrDKyeTEZWK+gQ8N65W6QLDtwVb77+4R0mr5bKo5YL0UH/y3Nf9oqAxcflBnbz8v4dSc1e8Q6qGFd0goBi4hgGWfXQUREMRTYQAYBJscnTpwYKhhgwGR3u3bttFcD+lCMHTtWNmzYICNHjnRo/Zggz5Url9StW1eDBThhmDBhgnh6ejr0fEymr1ixQjM+kKWBMlTWfSyse2WgBBQm5dHLA9sJgYGB0qlTJylUqJAGVRD8mDRpkt3XunnzpnTp0kUDG0uWLNHnISiAYIczkiRJIlmzZpVTp07pz7gSDOtHea558+aJj4+PdOzYUYM29erV0+CEv7+/5fkIruB+W7169dLav3PnztX3hn2J/iXGeGTMmFH69+9vKY0VmX26d+9eOXv2rJ7Eff7559rXY+vWrU6NAxERERGRu0JfDZTOtZUzZ07NNiciovCh1BMagtcpmF6/Olr6ydEG5AntrC/w8TPZff6OzNx+QT5ffEiDHvYuxwz5/+2zBQfkpw2nZOqWszJrx3lZsPui/Lnvsqw8dE3WH7shm07clAGLDoW7DkA2iHXPECIiisVSVEbwAQEBXKGEAIdtjwxkBiAgYWRZoBRU165d5ZNPPomwJNSNGzfk8ePHmomAskwIanz22Wfy+++/64R/RDDJf/XqValevbr+XLNmTZ1oRzYCMj8MHTp0sPTeQB3cWbNm6ffLly+XZMmSycCBAzWYgiALUsoRxLCF57z66quWjAlsLxpwo9YushackSJFCnnw4EUjbdTtHTRokKUBOEqBIXsDY121alU9oVqzZo02HUezb7zXGjVqhAn4YEyQxYIABuCKMiNFHpkyeL8pU6bUW2T2KSBggqvTsN0YMzRtP3jwoLz22mtOjQMREUUOfh+TOeBvM0rXYJ/ZlkUg98f9Z17R9XsS5aemTJmix+YoJWusG/fhAi0iIor5BuQJ/l/Wan2vynLx9kM5ei1Qjl+7J8euBsqxa4Fy+e4jh18LgZARK49HeVuxfcjkQP+OCrl9orweIqL4IkYCG5gAx5X+KOGECXVrKCGFiXbr0lFoRo2yUuh7gRTtl8EEPoIRKOsEyFKoXLmyrF27VrM4IrJs2TINYBQs+CI9sVq1ajoJj9JTH3zwgWU5BCEMmIxH9gMgMIBsDesMkeLFi8vq1avDvNaZM2dk/fr1elJjwHpwlVZ0XAFmBDdQBgoBBOOECYKCguTcuXP6PcYF5bYQ2MBXBFsQqLCGCRMEcBC4QaAG2RUouYUJlYhEtE8BWSTYXgO+x+NERBSz8HcMGXZERORaKOGKC4WQpYzzB6PXH7KdcWESERHFTgNyPO6VyFPy+KbUmxTLbFkm4NFTOXE9UObvuigL9lyKkV10417oMlVERBSLgQ1jYrtZs2aatYESTAZ7WRXGVVGOXB2FkwH0kDAgwwNBCGQhRATrX7lypZaWMgIbgMl728AGeljYg4CGbW+I8HpFYOIeARjr7YWECZ3bDchYQdACfTKMMUOfD9uAiRFoQGDj559/lnv37mlg49133w2zTowByldhGSyPTA8EYdCcPSKO7FN7jeTZY4OIKOZZ90ci94a/k/i7nCpVKmZsmBD3n3nh+BWZxc7KnTu3lsBFyVhc8IRjZmQr4/wgoix1IiJyfQNye7yTJpIyOdLKs+chDgU2PqmeR3KkSy6PnwXr7YnV7eyt+7J434v+py/z44ZTkippIqmcLz2P+YiI3CGwYfRsqF27dqhG4ph8x6T83bt3LVkD+/bt08n+bNmyRbjODBkyaIbA66+/rj/jiqdLly5pz4mIbNu2TevZol+Edb3bLVu2yPDhwzVTAQGZl8mTJ4+sW7dOAwFGhgSCLfbgvaK3hHX2B1LPsc22wY7IwMkRMizQJwSTHciGQCksZK4A1t+zZ08NYCBbBCdVuKF3BsbeKMNlDf060JQdY5Q2bVq9zyi/hRPzl5XAiGifnjhxIsrvlYiIopejPako9uHvL441sM9Yisp8uP8I0qRJo2Vp8X8ZJXVRFhdfoyODm4iIwofgRY2CGbXM043AIO29gTJVjvbqcLSk1YdV84S7TvTO2HH2drjrMJy4fl86TNslBTKlkm5Vckudwpkc3k4iovjE5c3DbQ/kEdywzqbAVUp+fn7Su3dvLYexfft27b2AJtyYpI9IixYttG8HSjzhyif0x8AVT8gwcKQMFQITKGWVN29eyw0lszAhj4bZEUHTbZSB+uabb7RcE/pKoHyTPVgvyjmNGTNGJ/4RkBg9erRkzvxfmmNEUFIKQQvczp8/r43Cv/76a+1fYQQgkLmBht0IuOB10P8DQRr0srDe7p9++kkDQtYloQwYe5xwYYywv5DZggCQESgB9BbBmCOAYc3ZfUpEREREFNcgiFGpUiXZuXOnBjOaNm2qJXCRsYFMDiIici0EB9C7olHxLPo1MsECo6QV2D7LuqTVy9bpyDoQPDEcvXpPPpy9V6qP3qilsJD1QUREsRTYgObNm4fqMYGrDtHwG1q2bKmZBehzgaZ6jkAWAm5fffWVBjn8/f21EXVEjcMxOY8+GNgeW3guTjRwgoEyTy+DIAoCK8huwEnJokWL9Ku9Ukvo5YFl0Vwbk/wIPvTt21caNmwojsI2oRE4bthGBF8QuEBgw3pM8L5wotS4cWO5cuWKZslY97xAeamHDx9qgMMeNAxHX5TJkyfrtk6aNElfB1kXR44cCdVEHfdbc3afEhERERHFNbgQCsfgxYoV04uhcM6BTHFcADRu3LjY3jwiInKwpBUyM6zhZ9z/spJWjqxj4tslZUufqjLpnVJSLOt/8zdnbz2Q3n8ckDe+XS9Tt5yVR0+eh8oC2XbaX/7cd1m/4mciovgiQQgbGzjl4sWLcv36dSldurTlviFDhmgjVpSzItfUOUZpq3UXE8i5mw84xEREUeCXLoX0bfLfhQbk/nDIFhAQoBcqsBSV+XD/mf/Ys3jx4k6V7ytatKhmQSNbGxcolStXTvr06aPZ0Qh47N+/X+Ly+48K/r/h2JoRP7dxf2wRPIhqSStH14H3uuWUv/y4/pRsO+Mf6rk+yRNLx4o5Nbvj21XHQ/UNyeRA3xB3Htu4iGPLsTWrkFj6vRCZY88Y7bERF6EMVYcOHeTbb7+VIkWKaH8NNB5HiSlyrZ4NirE2PBGRE3BCxXq9REQxI126dNrHDlnTyIBG5jZs3bpVMmWK3AQUERHFfkkrV64Dk4gV86TT257zd+SnDadkzdEb+pj/gyca0LAH/Tu6zvzX4QwSIiIzc+vAxtSpU1+alo2ST+GVN0JJKntNsa2hkbezChQooCWfEMi4evWqXoHVr18/S+NuR3Xr1k1PasKDLJDIlKyKD5hsZN79hoAgervwShDz4f6LW/uPQQ0iopiDPng45kcfO1wQVbZsWS1TO378eC1TRUREZE+p7Gnkl3ZltOfGTxtOy5L9V8JtPo77cV31kCVHtFk6j/eJKC5z68BGs2bNXtoE3F7Ta4Ojzb+jA3p74OaMQYMGafmq8Pj4OHc1AJE7QVoZmRf3n7lx/xERxY62bdtq+Vr0v0O/PChfvrxeEJU/f37uFiIieqkCmVLJuDYlpEq+9PLJ/PDLFyK4gfJUXy07Iq3LZJM8GVKIx0tKZb0oi+Uv567fkRy+z6Rszsg1Viciii1uHdhIlSqV3qICNbiyZ88uZpEhQ4bY3gQiIiIiInKhggULStKkSWXz5s2SKFEiyZUrl/j5+XHMiYjIYS8LUlibuuWc3tIkS6Q9PMrl9JFyudJK/oypLIGLlYeuanZHdPTpICKKaW4d2CAiIiIiIooLULYWzcJ37dqlF2+hPGBgYKBmqA8bNkwzzomIiCKCZuORcefhU1l1+LreIJVXQimTI614J0skC/+9HGZ59ukgIrPwiO0NICIiIiIiiusGDhyo/TXWrFkjO3bskJ07d8qKFSvkzp072rOPiIjIEci+QFZFeHkbuD9disTSv25+qV7AVwMZ1u4FPZO1x27YDWqA0b8DmRwoU0VE5K6YsUFERERERORiyNRYuHChZMmSxXJfjhw5NKjRunVrjj8RETkEZaRQKqrrzH81iGEdejCCHV81LqylpDq//qKHxrFr92THmduy46y/7Dx7W7M4Xsbo0zFu7UlpUzabZPSOOEvkRa+O23IjMEizShCAYa8OInIlBjaIiIiIiIhcLHfu3HLixAl55ZVXQt1/8eLFUMEOIiKiiCBo8dPbJcP0x8hopz8GgguFMnvrrWPFnBIcHCKT/jkjw1cei/B1vl97Um9ZUieVUtnTWG75M6aUhJ7/FYGJrl4dDI4QUWQwsEFEREREROQCixcvtnxfvnx5GTBggBw5ckSKFCkinp6ecvz4cZk2bZp06NCB409ERJGCgEGNghkjnSWB5uPF/CLX1+ny3Ud6+2v/Ff05aSJPKe6XWoMcIRIiE9afDpU5EpVeHWxkTkSRxcAGERERERGRC4wbNy7Uz2nSpJHly5frzZAyZUr56aef5IMPPuA+ICKiSEEQo0Junyj36UDwwV4XDYRG0iRLJK3K+sneC3dl38W7EvQ02PL4o6fPZdsZf72Fx1jvwMWHJH/GVOKTIrGkSJJQEiRIYDeogSCIs8ERIopfGNggIiIiIiJygXXr1oX72OPHj2X16tWyaNEiuX79OsefiIjcqk/H102LWIIJT58Hy7GrgbLn/G3Zc+Gu7Dl3W65YlZ16mVv3n0jl7zbo94k8E4h30sQaNEmTLLGkTpZIvJMmkuUHr9oNsIT8f3tQ5grZKezZQUTWGNggIiIiIiKKIXv27NESVStXrpT79+9r743+/ftz/ImIyG37dCTy9JAiWb311v61F/dduftIJv1zWqZtPe/waz59HiK37j/Wm6OMRuYouRWV7BQiirsY2CCiGIea0mRe3H/mxv1HRBTzLl++rMGMP//8U5uFp0qVSoMao0aNkrp163KXEBFRLPfp8Jdz1+9IDt80Ujanj0OZEZlTJ5VahTI5FNgon+tF7487D57K3YdP5M7Dp1rOKjLQR4SIyJqHuFC+fPnk008/DXP/woULpWrVqtH2Ojt37pRGjRpJsWLFpGXLlnLs2LFIr+OHH37Q7d22bVu0bZex3nfeeSda1tW3b1/dRuOGpoM4Efrtt98kJMRe0l7kYb07duxwaNmjR4/Kv//+q9/jOXhuTLJXl5HcH/Ybaklz/5kT95+5uWr/PQ+Onr9BRERxzR9//KHnAtWrV5f58+fLa6+9JlOmTJEtW7aIh4eH5M2bN7Y3kYiI4jkEHMrn8pE6BdPr18iUezJ6dYT3DNyPx2d1Kq+35T0qydZ+1eTol7Xl2Je1ZXu/ajKiWRGHXgvN0YmIYjRjY+nSpdK8eXOpUKGCS9aPK57ee+89vdWvX19+/fVXbbyH1O7EiRNHajuzZcumV1K5alujQ506dWTAgAH6/cOHD2X79u0yfPhwuXfvnnTv3t3p9W/evFm8vb0dWrZbt27y4YcfSsmSJaVEiRL63Jg0esl+OXfzQYy+JhERheaXLoX0bVKCw0JEZAeO27Nnzy4jRoyQhg0bcoyIiCje9erA4/aCJV6JPCWjt6c0L+UnY9ecDLeROaAnB4IoREQxGtjIkiWLDB06VNOuIxNocNTMmTOlaNGiOsEOqE/boEEDOXPmjOTPn9+hdRw+fFguXLggw4YNky+//FK++OILSZ48ubgjLy8vSZ8+veVnnCjhaq8hQ4Zotoqvr69T67ded2Rg30b1uVF12f+BnLp2L0Zfk4iIiIjIUV9//bUsW7ZM+vXrJ998841UrlxZszcqVqzIQSQionjXqyOywRHDvaCnsuH4DalWwLk5LyKKW1xaigo+/vhjuX79umZShOfatWvSo0cPKVu2rJQrV06++uorefLkicNlqGrWrGn5OWnSpLJmzRqHgxpGtgaWr1Wrljx9+lT+/vvvUI+jxBICM8gIKVy4sLz55puaKWI4dOiQBhUQYGndurV8//334Zaf2r17tzRt2lSXRQBm1apV4ixc/ZUoUSL5559/9GeUpfrxxx/1hKl06dLy/vvvy5UrV/Sx7777Tt5+++1Qzx89erS0b98+TCkq7LePPvpIypQpo++7SZMm2uwQ8P5QKxgnaSiRZVuK6mX7FKXI8Pxx48bpY9hGnOhFVzktIiIiIiJ3gON+nAdt2rRJL8TCxVT4Wr58eQkODtZjaJx/EBERmRmCF5v7VJU575WX71sX16/4OaKghm1wBMEQa0kTvZi2fB4sGvhYd+y6S7afiMzJ5YENZBBgcnzixImhggEGTHa3a9dOHj16JDNmzJCxY8fKhg0bZOTIkQ6tH+tEFgNe49VXX5W2bdvKqVOnHN4+TKavWLFCqlSpolkaKEO1aNEiu70ykEqOSfk7d+7odkJgYKB06tRJChUqpGWsEPyYNGmS3de6efOmdOnSRU9wlixZos9DUADBDmckSZJEsmbNannfyGLB+tGMcN68eeLj4yMdO3bUk6Z69eppcMLf39/yfARXcL+tXr16yfPnz2Xu3Ln63rAvBw8ebBmPjBkzaoaMURorMvt07969cvbsWZkzZ458/vnnMn36dNm6datT40BERERE5I7Spk0rb731lsyaNUvWr1+vJV0LFCig2eKVKlXSi3yIiIjMDJkXFXL7SKPiWfRrZHp1hBcc2T+oljQqnlkff/I8WN6f8a+sP3bDRe+AiMzG5aWoAFfnIyCAUk8IcFjD1UvIDEAzPaO3A0pBde3aVT755JMIS0KhzwSyEHDlE4IGmCBH9gEm6x0pJ4VJ/qtXr2pKOCD7AxPtyEZAGS1Dhw4dLL032rRpoyclsHz5ckmWLJkMHDhQPD09JVeuXNpQG0EMW3gOgi9GxgTKSKEBN5p/I2vBGSlSpJAHD170m/jll19k0KBBmg0BKAWG7A2MNZq258iRQ7NaWrVqJcePH9f3WqNGjTABH4wJslgQwACcjHXu3Fm/T506tb5fNKHFLTL7FBAwwYkcthtjNm3aNDl48KA2VCQiIvPB73VyLfxtxhXeGOvobgBPrsf9Z17R/fsNx9a4wAm3c+fOafY4zimQCU1ERBSfGcERa6NaFJPgEJEl+69ocKPLjD3yc9tSUiVfhljbTiKKR4ENTIDjSn+UcMKEurXTp0/rRLt1w2o0o3727JmmauNKpojWjcl6o/QTJstRu3bdunVa6ikiqHmLAEbBggX152rVqukkPEpPoQm5AUEIAybjjZRxBAaQrYHtMBQvXlxWr14d5rXQ9wNXaKHRtgHryZkzpzjr/v37luAGykAhgIDeG4agoCA9cYK6detquS0ENvAVwRYEKqxhwgQBHJxkIVCD7AqU3MKESkQi2qeALBJsrwHf43EiIjIn/D1Eph4RETkOx8y4QMvoF0hEREShJfT0kDEti+lFIksPXLUENya9U0oqM7hBFK/FSGDDmNhu1qyZZm3g6iTrMkrhXRXlyNVRaFhtHRhAE2sEKpCFERGsf+XKlVpayghsACbvbQMb6GFhDwIatr0hwusVgYl7BFvQ88JawoTO7YbHjx9r0AKZKsaYoc+HbcDECDQgsPHzzz/LvXv3NLDx7rvvhlknxgDlq7AMlkfwCEEYR066HNmn9hrJs8cGEZF5WfdZItfA30n8XU6VKhUzNkyI+8+8cPyKzGJ3g3OAIUOG6PE8SvPi2B03e1AWdsyYMXqREUrYog8iLugiIiIyS3BjbKvigum2ZQevypNnwdJ5xh75pW1peT1v+tjePCKK64ENo2dD7dq1QzUSx+Q7JuXv3r1ryRrYt2+fTvZny5YtwnUiOwJXiVr3d0DfDRywR2Tbtm1y+/Zt7ReBq6UMW7ZskeHDh2umAgIyL5MnTx7NDkEgwMiQOHz4sN1l8V7RW8I6+2PKlCm6zbbBjshAPw1kWKBPCCY7kA2BUljIXAGsv2fPnhrAQLZI7ty59YbeGRh7owyXNfTr2LVrl44RagKDUX4LJ+YvK4ER0T49ceJElN8rERG5J+vMRXIN/P3FsQbGmqWozIf7j6Ib+tchoxplba9cuSJ9+vSRzJkz6/mWtWPHjunFSb1795Y33nhDNm/eLD169JDff/9d8ufPzx1DRETmCW60Li4hEiLLD17T4MZ703fLL+1KS6U8DG4QxUcubx5uLU2aNBrcQE8HA3oq+Pn56YE2AhTbt2/XclJowo1J+oigSTX6acyePVsn09FPAhkDxqR+RGWoEJhAX428efNabiiZhQl5NMyOCJpuowwUGv6hXBP6SqB8kz1YL04+cLUUthUBidGjR+sJiKNQUgpBC9zOnz+vjcK//vpr7V9hBCCQuYGG3Qi44HXQ/wNBGvSysN7un376SV5//fVQJaEMGHtMnmCMsL+Q2YIAkBEoAfQWQXktBDCsObtPiYiIiIjo5X0GFyxYIAMGDNCyuOiXh6x440Ika+jhUb58eWnbtq1eYIW+eejFt2LFCg4xERGZSiJPD/m+dQmpU/hFL9jHz4Kl02+7ZfPJW7G9aUQU1wMb0Lx581A9JnDV4YQJE/T7li1bamYB0qIRoHBEsWLFdBIfTcNR5gn9HdA8G5PuL4PJefTBwPbYQmCkadOmerCPFO+XQYNyNERHdgNef9GiRfrVXqkllMjCsmiujUl+bHffvn2lYcOG4ihsExqB44ZtRPAFgQsENgzIzMD7Qq+Qxo0b6xVcyJKx7nmB8lI4IUKAI7ymhuiLMnnyZN3WSZMm6esg6+LIkSOhmqjjfmvO7lMiIiIiIgofsjBQ5tb6vKpUqVKyf//+MD3xmjRpoheX2QoMDOQQExGRKYMb49qUkFqFfC3BjXd/2yVbTjG4QRTfJAhhYwOnoOzV9evXpXTp0pb7UOsWDVRRzopcU+cYpa3WXUwg524+4BATEcUiv3QppG+T/ybWyHVwyBYQEKAXKrAUlflw/5n/2BMlcN2l7B4y1nHREEroGnCBFy5esi4la8/JkyelUaNG2pMPmR6Ovn9cUBbT75//bzi2ZsTPLcfWjMz4uUUpqu5z9srfR67rz16JPOTXdqXl1dzpxJ2YcWzNgmMbN8cXx564WMeRY+8Y7bERF6EMVYcOHeTbb7+VIkWKaH8NNB5HiSlyrZ4NYv7kioiIwnoeHCKeHjxIJyKKKbiIyjZD3PjZKBtrD/oLdu/eXfsIRrZ5+L179yw9BWPyhBpZ5sDJII6tWfBzy7E1I7N+bofVyyVPnj6VDSdvS9DTYHl32m75vlkB8fBIILcePJF0yRNLSb9UsXquYtaxNQOObdwcX9vsY9MGNqZOnSrjxo0L93GUfAqvvJG/v7/dptjW0MjbWQUKFNCSTwhkXL16Vftl9OvXz6EeH9a6desmW7duDfdxZIFEpmRVfMBkI/PuNwQE0duFf9TNh/vP3Fy1/xjUICKKWSidaxvAMH728vKy+5xbt27pBVn4W4BzrMgGKdArLzYyNoBXuXJszYSfW46tGZn5c/tz27Lywex/Ze3RGxL0LFi6zDsc6vGM3l4yqH5Bqf3/vhwxzcxj6+44tnFzfJGxEScCG82aNZOqVauG+7i9ptcGR5t/R4cWLVrozRmDBg3SK6/C4+Pj49T6idxJZH5Jkfvh/jM37j8iIvPz9fWVO3fuaJ8N9MCDmzdvalADAQhbKJ2L5uGA3oQvK1UVHpzQxsaEjPG6nAzi2JoJP7ccWzMy6+c2SSJPmfBWSWn+01Y5ePlemMevBwTJB7P+lZ/eLim1C2eKlW0069iaAcc27o1vZF7LrQMbOCi3d2DuCFxNlD17djGLDBkyxPYmEBERERGRCSBrHAEN9L4wev3t2bNHS+PaZmKghECnTp30fgQ10qdPH0tbTURE5BoJPTzkZuBju4/hmnNMkw5ZckRqFMzIbHOiOCRmi6QSERERERGRU5ImTSqNGzeWwYMHy4EDB2TNmjUyZcoUS1YGsjeCgoL0+59//lkuXLggI0aMsDyGW2BgIPcCERHFCTvP3pZr9+wHNozgxtWAIF2OiOIOt87YICIiIiIiorDQ1w+BjXbt2mmJXjQFr1mzpj5WsWJF+eabb6Rp06ayatUqDXLYls5t0qSJDB8+nENLRESmdyMwKFqXIyJzYGCDiIiIiIjIhFkbyMIwMjGsHT9+3PL9ypUrY3jLiIiIYlaGlF7RuhwRmQNLUREREREREREREZEplc2ZVjJ5e2kvjfCgH3FKL17fTRSXMLBBREREREREREREpuTpkUAGNSio34cX3AgJEWk3ZaecvM4eU0RxBQMbREREREREREREZFq1C2eSn94uKRm9Q5ebypjKS3KmS6bf+z94Im0m75DTN+/H0lYSUXRiDhYRERERERERERGZPrhRo2BG2Xn2tjYKR08NlKm6//iZvPPrDjlwKUBu3X8sb07eLvM6V5Ac6ZLH9iYTkROYsUFERERERERERERxoixVhdw+0qh4Fv2Kn72TJpLpHctKwUypdJnr914ENy7efhjbm0tETmBgg4hinKenJ0fdxLj/zI37j4iIiIiI4pvUyRLLzE7lJH/GlPrzlYAgaTN5u1y++yi2N42IooiBDTKtBAnCawlF7r7fUqZMyf1nUtx/5uau++95cEhsbwIREREREcVxaZO/CG68kiGF/nzpziPN3LgWEBTbm0ZEMd1jI1++fFK/fn0ZNWpUqPsXLlwo48ePl3Xr1kl0+uuvv2TBggUyY8YMy31PnjyRMWPGyLJly+TRo0dStmxZ+fzzzyVjxoyRWnffvn1l0aJFsnr1asmWLVu0bTPWC8OHD3d6Xe+8847s3LnT8rOXl5fkypVLOnToIA0bNnR6/ZcuXZJq1arJ2rVrJWvWrBEuv23bNsmQIYPkzp3bZfv8ZUYv2S/nbj6IsdcjIqLo55cuhfRtUoJDS0RERERELpcuRRKZ3amctJ60Xc7ceiDn/R9qcGNu5/KSIVXoxuNEFMebhy9dulSaN28uFSpUEFfavn27fPHFF1KkSJFQ948bN07WrFkj3333naRNm1a+/fZb+fDDDzUA4ugVqY8fP7YENBYvXiwfffSRuKuOHTvqLSQkRAIDAzUI0a9fP3n27Jk0bdrUqXVnypRJNm/erOPoiPbt28v06dM1sFG3bl2pXLmyxKTL/g/k1LV7MfqaRERERERERERkXghgzH6vvLSatE0DGwhwvPnLDg1uIPBBRPGkFFWWLFlk6NChmjnhKsgEeO+998TPzy/MY8iy+OSTTzRT45VXXpEvv/xSDh48KOfPn3d4/Rs3bpREiRLJm2++qYENBA3cVbJkySR9+vSWTInOnTvr2CCggwCNs3XXse6o1F9H9oijAREiIiIiIiIiIqLYktH7RXAja5qk+vOpG/fl7V92yO0HrpvfJCI3C2x8/PHHcv36dfn111/DXebatWvSo0cPDT6UK1dOvvrqq0gFQrZs2aLrr1mzZqj7g4ODdUL/1VdfDfMcZDNEJuukdOnSUqVKFbl8+bLs2rUrVHkmlNz6+++/pXr16pox0qVLF7l7965lGWQ5NGjQQIoWLSqdOnXS4IpRgsoWMkOQ3VCsWDHNdLEuLRVVrVq1ktu3b8uePXv0Z4wtxhhjjVuvXr0s24sgUJ8+fUI9/9NPP5UBAwZY3iu+wqlTp+Tdd9+VEiVK6PtG4Of06dP6WNWqVfVr27Zt5YcfftBSVMZ9gOXw3JIlS0qlSpU0OIX9BVgerzlo0CB9HNk+kydPdnociIiIiIiIiIiIHJEldVKZ8155yeT9ogTVsWuBGty4+/CJ9gHcdtpf/tx3Wb+yLyBRHAxs+Pr6aummiRMnysWLF8M8jkn2du3aaf8L9MYYO3asbNiwQUaOHOnwa8yZM0eDImE23sNDgxqpU6e23IfSSGnSpNEJekc8ePBAMzYQ1MiRI4dmQSALxBbe3+jRo2XmzJmaETJ16lS9H++5a9euUqdOHc32QABg1qxZdl/r2LFjGlTA8ugXgr4YyLaITHZJeCWkkMmBQARgOw8dOqTBAozH/fv3NbAE9erVk/Xr18vTp08t+wc/435rCEK8//77mpHz559/yty5c+X58+caSILff//dEqRAaSxrCLIgCIKsEpQEQwAD44ZtMaxatUqSJEmiY40ACEqJnT171qlxICIi88LfGN4iHgP8feY4mfezwv1n3hsRERHFTX5pk2lwwzfVixJUR67ek0Y/bpFXh6+VNpO3S4+5+/RrxRHrZOWhq7G9uUQUnT02jKbWuGJ/2LBhGgCwtmnTJs3omD9/vnh7e+t96JWByX1kDyRPnlyiC3ptTJkyRYYMGSKJEyd2+DmY5EdgA2rUqKEBGGxj0qQv0tEAwRtkZACyMxDcAEzc4/4PPvhAf0YAYevWrXZfC1knLVu21Ocb2Q7IDkHgJrwMD0elTJlSgzQIICGI8Mcff1iCOwgiIXPj+PHj8vrrr+tJ9Y4dO6RixYqabYIyUnj86tX/fkEHBQVJ69atNUCBoAk0adJEfvnlF/3eKDuFfWq7D5EBg7FD5krChAk1WHTz5k358ccftS8HIBiFIA/KXiHLBUEYBGNy5szp1DgQEZE54W8U/oYRERERERHFpBzpkr/oufHzdrl1/7H23bB1LSBIus78V356u6TULpyJO4gorgQ2MDk9ePBgnQRHoMAaShIhE8IIagDKD6HZ9YULF6RAgQLRsQn6uiiL9fbbb0uLFi0cft6yZct0e4yJepS7QnAGpacaNWpkWS579uyW71OkSGHJeMBEjG1D8+LFi0tAQECY18JYrFixQubNm2e5D+tBgMFZCGpgu5BBgnUiKGENwYxz585psAMltfD+8Lr4WqtWrTB9NRDMaNOmjWahIOBw5swZOXLkiKRLly7CbcH7LFSokAY1DChnheDGvXsvmn1nzZo11GsiOILPBBERxU+OZlrGZ+gBhr+jqVKlkgQJEsT25lAkcf+ZFzI2jIuaiIiIKG7KnT6FzHy3rNQdt0mC7bTexV04Ah+y5IjUKJhRPD14PE4UJwIbgOBAs2bNNGsDV+AbUG7IlpHOHV1p3QhO9O7dWyfz+/fv7/Dz7ty5o9kVmFAvWLBgqMcwoW8d2EBzcXswOW/bbDy85uN4vyg91bhx41D3I2PCGeiJgXJTefLksYzp7NmzLZkWBh8fH/2KHh/9+vWTgQMHyrp16zSTwl6gBD1AUNYLvTPq16+vwQ1kxETE3j43+msY22dvPN25aTsREbmWbYCdxO7fSZThxFgxsGE+3H9ERERE7u3Ow6d2gxoGPHQ1IEh2nr0tFXK/mGMjojgQ2AA0qa5du3aoRuIoLYRMATSvNnph7Nu3T6/mz5Ytm9OvuW3bNg1qvPXWW5EKagCyFTDhjp4YKOVkQN+HadOmadPziCCYYDTtNhw+fFj8/PzCLIuxQBDCOvsDZaJwf2SyTGyh7FT69Om1ATpKSGHCA+NtZMP4+/trc3AEM5DVgb4kCDCgTwiCKnieLTQ1v3HjhixZssSSeYGyVY4EH/B+MLbIHDECGHv37tWsGOt+KERERERERERERO7gRmCQQ8vN3H5OEif0kKJZvSWRZ/jti9FwfOdZfzl3/Y7k8H0mZXP6MNODyJ2ah1vD1f0Ibly+fNly32uvvaaT/Ag+oGzT9u3btfcCMgBQSsEZyLRAMKNMmTKaCYFSR8YNTbEjgl4QlSpVklKlSknevHktN/SBwBWRaJodEfTMQKBm0qRJ2vwaZax2795t90pKrHf58uXaRBtluBA8wQ2luhz18OFDy3tEySdkW6A/xWeffaYBCAQuECRBaTD00UBDcYw9GpSj/BNgOaPkFgJR9rYVAQi8Fkp8IRiDXiIIAFmPKzJCTp48KYGBgaGeix4iWA59SrCNWAeajKO0Fa8wJSIiIiIiIiIid5MhpWMVVZYdvCbNftoqxYf8LR2m7pTJ/5yRQ5cDJNgq3QONxtFwvM3kHdLvrxP6lQ3Iidw4YwNQvggZBLjaH5A9MGHCBA1mIAiAXgqY+O7Zs6fTr4XeD1euXNGbbZ8KBA/QEDs8aGiOAMS4cePCPObr6yvVqlXTzI169eq9dBuyZMmi6xgxYoR+RSAHz7VXagm9N5ChgUl+fEXGyqhRozQw4yiUgjLKQSH4gIwRvC7KRRnQiBzbg4bnyJrA+hF4sS7zgfeFXh/hvT/0xOjWrZs2Yn/8+LHWPkegApkfGDuMEZrG430gSJM/f37LcxFcQZNxlCVD2S1karRr1066dOni8PskIiIiIiIiIiKKKWVzppVM3l7aKNyRYukPnjyX9cdv6g1SJ0sk5XP66Ne5uy6GWZ4NyImiV4IQNjZwyokTJ8L06OjcubM2FO/evbvze4jCQBktZMmsu5hAzt18wBEiIjIxv3QppG+TErG9GaaAQ7aAgADx9vZmBqQJcf+Z/9gTFynFx35Asfn++f+GY2tG/NxybM2In1sJlWnRdea/L8bF6n6j1smXjQtLIs8EsvW0v95uBj6O1FhjPRm9vWRzn6osS8XPrVsLiaXzz8gce0Z7xkZ8g2wFZDGMHj1aS0qhGTn6fkRHRgq9XM8GxeLlySURUVyD2rOeHjF3oERERERERGRP7cKZ5Ke3S8qQJUe0UbgBwYhBDQrq49CqTDad+D198/6LIMcpf9l2xl8CHj196cCyATlR9InVwAaaV9srBWVAyaqhQ4dGad0HDhzQ8kfhyZw5syxbtkycVb16de0zgeAGmnSjcfaYMWNClWZyRNOmTbVHR3jQR8Nek+/4jMlG5t1v9+/f15Jl7LliPtx/5uau+49BDSIiIiIichcIXtQomFF2nr2tDcXRewNlqmzPW3BO9UqGlHprWyGHXrA1ceNp+XbV8WhrVE5EbhrYaNasWajeELYw8RJVCCwsXrw43MfRQDu6dO3aVW/OGD9+vPbDCA96WhDFFUgrI/Pi/jM37j8iIiIiIqKXQxCjQm6fSD+nZLY0Di2bPAmL6BA5K1b/F6VKlUpvrpA4cWLJnj27mAUySIiIiIiIiIiIiChuNyD/YvEhSZ00kZTOkTYGt44obvGI7Q0gIiIiIiIiIiIiMjtkbaAXB7ys+O+VgCBp+fM2+X7NSXn2PDjGto8oLmFgg4iIiIiIiIiIiCgaG5Cj4bg1ZHIMa1JYyuR4Ua4qOERkzJoT0mbydrl05yHHniiSWNCNiIiIiIiIiIiIKNobkPvLuet3JIdvGimb00czOlqV9pMJG07L92tPasPxXefuSJ3vN8nwpkWlXtFM3AdEDmLGBhEREREREREREVE0QhCjfC4fqVMwvX7Fz5DQ00M+qpZH5ncpL1lSJ9X7AoOeSbfZ/0rv3/fLwyfPuB+IHMDABhEREREREREREVEMKpU9rSzvUUkaFMtsuW/+7ktSf9xmOXQ5gPuCKAIMbBARERERERERERHFMO+kiWRc6+LybfOikiyxp9535tYDaTJhi0z+54wEB4douaptp/3lz32X9St+JiL22CAiIiIiIiIiIiKKFQkSJJAWpf2kdI600mPuXjlwKUCePg+RYcuPysK9l8T//hO5Efg4VBPyQQ0Kah8PoviMGRtEFOM8PV9chUDmxP1nbtx/RERERERE7idnuuTy+/uvSpc3clnuO3o1MFRQA64FBEnXmf/KykNXHV43sz4oLkoY2xtA5ExEm8y531KmTBnbm0FRxP1nbtx/MQcnDkZzQCIiIiIiIkckTugh/eoUkNdypZP203aKvapTxl0DFh+S4n5pxDdVkpfOkSEAMmTJEbkaEGS5j1kfJPE9sJEvXz6pX7++jBo1KtT9CxculPHjx8u6deskOv3111+yYMECmTFjRqj7p02bJr/++qvcv39f6tSpI59//rkkTZo0Uuvu27evLFq0SFavXi3ZsmWLtm3GemH48OFOr+udd96RnTt3Wn728vKSXLlySYcOHaRhw4ZOr//SpUtSrVo1Wbt2rWTNmjXC5bdt2yYZMmSQ3Llzu2yfv8zoJfvl3M0HMfZ6REREjvBLl0L6NinBwSIiIiIioihJlNDDblDDGkpUlf9mrSRN5Cl+aZNKtrTJxC9tMv1qfH/06j35eO4+SzDENuvjp7dLsqQVxd+MjaVLl0rz5s2lQoUK4krbt2+XL774QooUKRLq/lWrVumE+rfffis+Pj7Sr18//R7LOurx48eWgMbixYvlo48+EnfVsWNHvYWEhEhgYKAGIfCenz17Jk2bNnVq3ZkyZZLNmzdL2rRpHVq+ffv2Mn36dA1s1K1bVypXriwx6bL/Azl17V6MviYREREREREREZEr3Qj8L7siIo+ePpcT1+/rzVEIdCDHA5kcNQpmZLY5xc8eG1myZJGhQ4fKkydPxFUQuHjvvffEz88vzGOYWG/Xrp1UqVJFihYtKkOGDJE//vhDHj165PD6N27cKIkSJZI333xTAxsIGrirZMmSSfr06S2ZEp07d9axQTAHARpn665j3VGpv47sEUcDIkRERERERERERGRfhpReDg1NMT9vyZU+uZawiizMfqI81bi1J+X6PccCKezVQXEqsPHxxx/L9evXtRRUeK5duyY9evSQsmXLSrly5eSrr76KVCBky5Ytuv6aNWuGuv/58+dy8OBBKV26tOW+4sWLy9OnT+XYsWORyjrBOhAcuXz5suzatStUeSaU3Pr777+levXqmjHSpUsXuXv3rmUZZDk0aNBAAyudOnWSL7/80lKCyhYyQ5DdUKxYMc10sS4tFVWtWrWS27dvy549e/RnjC3GGGONW69evSzb+8knn0ifPn1CPf/TTz+VAQMGWN4rvsKpU6fk3XfflRIlSuj7RuDn9OnT+ljVqlX1a9u2beWHH37QUlTGfYDl8NySJUtKpUqVNDgVHBysj2F5vOagQYP0cWT7TJ482elxICIiIiIiIiIiMruyOdNqH4zwOmfgfjy+sOtrsu7TynJsaG3Z3q+azO9SQb5rUUx6VMsjZbKncei1vl97Usp9vVYqjlgnn8zbJzO3n5dj1+5JsE0tLPTqwDJtJm+XHnP36Vf8HJkm5kRuFdjw9fXV0k0TJ06Uixcvhnkck+zIqEAGBXpjjB07VjZs2CAjR450+DXmzJmjQRFb9+7d0ywFZC8YEiZMKKlTp9ZgiiMePHigGRsIauTIkUOzINBrwxbe3+jRo2XmzJkaTJk6darej/fctWtX7e2BbA8EAGbNmmX3tRBsQVABy6NfCPpiINvi/Pnz4mwJKWRyIBAB2M5Dhw5psAAZLeg9gsAS1KtXT9avX6/BH2P/4Gfcbw1BiPfff18zcv7880+ZO3euBpKQGQK///67JUiB0ljWEGRBEAT7BT1REMDAuGFbrEuIJUmSRMcaAZDvvvtOzp4969Q4EBERuRP83YzuG/4+u2K9vMXMGHD/mfezRkRERBSTPD0SyKAGBfV72+CG8TMex3Lg4ZFAMnp7aUCkeams8kmNvNKzZr5IvealO49k0d7LMnDxIak9dpMUH/q3tJ+6U8avO6lZHejJYd2A3LpXB4MbZMoeG0ZTa1yxP2zYMA0AWNu0aZNmdMyfP1+8vb31PvS/wOQ+sgeSJ08e5dcNCnrxnylx4sSh7sfPjmaErFmzRif5EdiAGjVqaAAG22jdgBzBG2RkALIzENwATNzj/g8++EB/RgBh69atdl8LWSctW7bU5xvZDsgOQeAmvAwPR6VMmVKDNAggIYiAclzIvgAEkZC5cfz4cXn99df1pHrHjh1SsWJFzTZBGSk8fvXq1VBj27p1aw1QIGgCTZo0kV9++UW/N8pOYZ/a7kNkwGDskLmCQBOCRTdv3pQff/xR+3IAgk8I8qDsFbJcEIRBMCZnzpxOjQMREZG7wN/dyJTGJCIiIiIiMtQunEmbe6MPhnVAAQEMBDXwuCNZHwg+2Cu6j5BImmSJpVXZrPLv+buy7+JdefzsRbUVuBf0TDYcv6m38LBXB5k+sIHJ6cGDB+skOAIF1lCSCJkQRlADUH4Iza4vXLggBQoUiPLr4op/sA1i4GfroMTLLFu2TLfHmKhHuSsEZ1B6qlGjRpblsmfPbvk+RYoUlowHTFrYNjRHOayAgIAwr4WxWLFihcybN89yH9aDAIOzENTAdiGDBOtEUMIaghnnzp3TYAdKauH94XXxtVatWmH6aiCY0aZNG81CQcDhzJkzcuTIEUmXLl2E24L3WahQIQ1qGFDOCsENZNlA1qxZQ70mgiP4TBAREcUVxgUG0QU9wPB3NFWqVJIgQXhJ6eSuuP/Myyh/S0RERBTTELxAc++dZ29rQ3H03kDAwsjUcCTrAxkVWNo6uGE8++umhS0BkifPguXwlQDZc/6O7Dp3W7/euv/E4V4d2MYKuX2i/F6JYiWwAQgONGvWTLM2cAW+bfDBmpHO7WxaN676x/pv3bqlWQGAyXH0k0AT7IjcuXNHsyvwnIIFX6R3GTChbx3YQHNxezA5b9tsPLzm43i/KD3VuHHjUPcjY8IZ6ImBclN58uSxjOns2bMtmRYGH58Xv1zQ46Nfv34ycOBAWbdunWZS2AuUoAdImjRptHdG/fr1NbgxZcqUCLfH3j43+msY22dvPN25aTsREVFk2V404Cz8nfTw8ND1MrBhPtx/RERERBQVCFBENWAQmawPNCAvkS2N3jpVyqXHr+f9H8qkf07L7J1h2w/YuuFgA3IitwtsAJpU165dO1QjcZQWQqYAgg0IRMC+ffv0av5s2bI59Xo4uUe2BJpmo5SS9brz588f4fORrYAJd/TEQCknA/o+TJs2zaE+HQgmGE27DYcPHxY/P78wy2IsEISwzv5AmSjc36JFC4kqlJ1CIAcN0FFCChMeGG8jG8bf31+bgyOYgayOV199VQMM6BOCoIp183UDmprfuHFDlixZYsm8QNkqR4IPeD8YW2SOGAGMvXv3alaM8RkgIiIiIiIiIiIi98z6wMVUOdIllwbFsjgU2Bi1+oR4eiaQOoUzOZRRQhTrzcOt4ep+BDcuX75sue+1117TSf7evXtr2abt27dr7wVkAKCUgrNQ/gqBFJTAOnDggJbEQh8LR0pRoRdEpUqVpFSpUpI3b17LDX0gEDRB0+yI4LUQTJk0aZI2v0YZq927d9u9khLrXb58uTbRRhkuBE9wQ6kuRz18+FBLOuGGkk/ItkB/is8++0wDEAhcIEiCcUAfDTQUx9ijQTnKPwGWM0puIRBlb1sRgMBrYVwRjEEvEQSArMt+ISPk5MmTEhgYGOq56CGC5dCnBNuIdaDJOEpb8QpTIiIiIiIiIiKimM/6aFQ8i36NTODB6NUR0TMu3H4oH87eK9VHb5R5uy5oaSsi0wQ2AOWL0E/BgOyBCRMmWIIAPXv2lGrVqsnQoUOj5fXq1asnXbp00Un0jh07aiNvTPJHBA3NEYDA9try9fXVbUTmRkSyZMki48aN06wJTOgjMwHPtVdqCb03kKGBMlEoB4WG6qNGjZIyZco4/H5RCgq9MXBDUGfbtm36+tZls9CIvEKFCtrwHGOOQAYCL9YlMTBuCFzgqz3Yh926dZMhQ4ZIw4YNtTk8xhjZHxg7o2k83g+CFtYQXEGTcQRvUHYLgax27drJhx9+6PD7JCIiIiIiIiIiothl9OoA2+CG8XN2n//K4Z+99UD6/HFQ3vh2vUzZfFYePgndU/d5cIhsO+0vf+67rF/xM1FUJAhhYwOnnDhxIkyPjs6dO2uJrO7duzu3crILZbSQJbPuYgI5d/MBR4mIiNyKX7oU0rfJfxd5RBccsgUEBIi3tzczIE2I+8/8x564SCm6e+eYQWy+f/6/4diaET+3HFsz4ueWY+uIlYeuhunVgUwOBD1qFcooW0/7y4/rT+lXa2mSJZKOr+WUthVyyLYzt8Jdh3W/D35u4+/vheeROPaM1h4b8RGyEtC/YvTo0VpSCs3IkUWBzBRyrZ4NisXLk0siInJ/uOqIdWWJiIiIiCi+9Op47ZV0ett74Y5M2HBaVh95UfHlzsOn2n8DQY8gO+WprgUESdeZ/2qTc0eDGzjf2nnWX85dvyM5fJ9J2ZyRK69FcUOsBjbQvBpllMKD0k5RLVmFfhsofxSezJkzy7Jly8RZ1atX1z4TCG6gTBMaZ48ZM8ah5uXWmjZtqj06woM+GvaafMdnTDYy7367f/++lixjzxXz4f4zN+6/mMODaiIiIiIiiqu9Ol6mRLY0MrltaTl+LVB+2nBK/tp/RVBtyl5QA1CICiEJZHIgcBLRudTLMkcim/VB5hargY1mzZpJ1apVw30cE59RhcDC4sWLw30cfSeiS9euXfXmjPHjx8vTp0/DfRx9P4jiCqSVkXlx/5kb9x8RERERERG5Wr6MKWVs6xLSs0Y+Gbr0sKw5eiPcZRHcQKCi3vebJGf65OKTIrH4JE8i6VIklrTJk+jP+H7fhbvy2e8HdHlnsz7I/GI1sJEqVSq9uULixIkle/bsYhbIICEiIiIiIiIiIiKKK7L5JJMGxTK/NLBhOHY9UG+RFdmsD4obPGJ7A4iIiIiIiIiIiIgobkI/Dlczsj7QA4TiBzYPJyIiIiIiIiIiIiKXQJNx9MFAySjbMlKA/IqM3l6ypucbcvfRU/G//1j87z8R/wdPXnz/4Ik2Jd917k6Er4XG5hQ/MLBBRERERERERERERC6B0lBo7o0+GAhiWAc3jKJReDx5koR6y5I6aZh1bDvtL20mb3eL7BByDyxFRUREREREREREREQug6beaO6NzAxr+NmRpt9G1kdE3TNuBT6Ohq0lM2DGBhERERERERERERG5FIIXaO6NPhgoGYXsCgQsHGn2/bKsD2s95u2VZyHB0qRE1mjffnIvzNggIiIiIiIiIiIiIpdDgKJCbh9pVDyLfnUkqBFR1gcyOV7L7aPfB4eI9Jy/X+btuhDt207uhRkbRERERERERERERGSirA9/OXf9juTwTSNlc/poFsegvw7LjO3nJSREpM8fB+Xxs2BpWyFHbG8yuQgDG0QU4zw9PTnqJsb9Z27cf+bG/UdERERERPEdsjzK5/KRAj4JxdvbWxIkeJH1MbRRIUmS0EN+2XxWf/7iz8Py5FmwdKqUK5a3mFyBpajItIxfWmS+/ZYyZUruP5Pi/jM37r/4s/+eI/+aiIiIiIgoHsG50oB6BaRbldyW+75adlTGrzsZq9tFbpCxkS9fPqlfv76MGjUq1P0LFy6U8ePHy7p166J14/766y9ZsGCBzJgxI9T906ZNk19//VXu378vderUkc8//1ySJk0a4fp27Nghbdu2laFDh2Cfm18AAGPMSURBVEqrVq1CPda3b1/9Onz48DD3L1q0SFavXi3ZsmUL9djTp09l4sSJsnjxYrl+/bqkS5dOatWqJd27d5cUKVLoMu+8847s3LlTRowYIY0bNw71/NOnT0vdunWlbNmyYd6jPRjnfv36WX5OmDCh+Pj4SM2aNeXjjz+2vKYzsL3YHryHiPj7++t7wz4wPh/Tp0+XcuXKSUwYvWS/nLv5IEZei4iIyCz80qWQvk1KxPZmEBERERERxUpw47Na+cUroaeMWn1C7/vu7xNalqpnjby80DY+l6JaunSpNG/eXCpUqCCutH37dvniiy+kSJEioe5ftWqVBlG+/fZbndTHRD++x7KOGj16tNSoUUPSpk370uUeP35sCWggePHRRx+Fevy7776TrVu3yldffSV+fn5y8eJFGTZsmJw/f14DHoZEiRJp0Mc2sLFmzZpI/2fKmDGj/P777/r9kydP5NSpU/qaJ06c0ICPh4dzSTg//PCDbq8j8P5DQkIsgY3Nmzdr+ldMuez/QE5duxdjr0dERERERERERETur3u1PJI4oYd8s+KY/vzDulMa3OhXJz+DG3FEpGfBs2TJohkPmFR3FQQu3nvvPQ0W2EJGQLt27aRKlSpStGhRGTJkiPzxxx/y6NEjh9efPHlyDYZEZOPGjTrJ/+abb2pgA5P41pDJ0aNHDw3yZM2aVb8OHjxY1q9fLzdu3LAsV7p0aZ30tx0zBDaKFy8uka2tnT59er1hX7zxxhsaRNmzZ48GYZyVOnVqHR9H2I4Htilx4sRObwMRERERERERERGRM7q8kVsGNyho+XnSP2dk8F+HJZile+NnYAMlj1B2CaWgwnPt2jWd8EdJI5QlQkZDZAIhW7Zs0fWjxJK158+fy8GDBzVQYEBgACWhjh17EX1zxIABAzQogWBARNkpeC0EUS5fviy7du0K9TiyLZBZEhwcbLmvRIkSsmzZMkmTJk2o+5IkSaLLGjCGyOyIjrJNuXLl0u20Dmzge5S5KlasmGbYoGQU/PPPP3qfdSAIQZeSJUtKUFCQlqJC1gZgn33zzTdSqVIlKVSokFStWlXmzZunj2EZjCFuuN8oRYVyX0a2C4JHCLxgH73//vty9epVfezSpUu67N9//y3Vq1fXrJwuXbrI3bt3nR4LIiIiIiIiIiIiImj/Wk75ukkRMYrm/LbtvPRfdJDBjfgY2PD19dWSTMgSQOklW5gMR0YFJs7RN2Ls2LGyYcMGGTlypMOvMWfOHA2K2Lp3755OmGfIkCFUnwlkGSCY4qhq1appsALZFc+ePbO7zIMHDzRjA8vlyJFDcufOrZP41tCvA+8RE/uDBg3SMlkIDrzyyiuhyjmhPFTlypVD9SBBtgYCBtj+6IDXRM8OQJCnT58+0rVrV+1T0rBhQ82AQSDl1Vdf1X4kCHAYEGDAe/Dy8gq1zkmTJum+QxBj5cqVWkrryy+/lFu3bknHjh21BBVuRmksaxgPBFfQW2Tu3Lk6zh988EGoIBA+QygLNnPmTA1YTZ06NVrGgoiIiIiIiIiIiAjeLJdNvmteTDz+H9yYu+ui9FqwXx4/fS7bTvvLn/su69fnzOQwlSg1ZMBV/dmzZ9feDrY2bdqk2Qi4Wh9X5aM8E/pfIFiBYIEzEDQA23JH+DmypbEGDhyogZnffvvN7uMIPCATBIENQE8OBC6sMx26deum7xN9L+bPn68BHwQrUBrLXjAFJaoMa9eu1XVGFzQON8YX2S4tW7aUBg0a6H5CAOb111/XfYBACjJhEMwwsmDwXpHdYSt//vy6j5FxgbJgyLrAmJw7d07LVSEQgpttr5KAgAD5888/db+XL19e14N+HGfPntVsHAPGC+XEkEGCbUVwg4iIiKIH/sbz5l5jgAs8YnsbeIvaGBARERGRuTUrlVW+b11CPP8f3Vi497IUG/q3tJm8XXrM3adfK45YJysPvag4Q+4vSukC6POAbAf0nsCkuDVkDSDDwbqJNMoc4Yr9CxcuSIECBaK8sSjnBLZBDPyMLITIQH8KZBCgn0e9evXCPI5yUthuY9IewQBkGCAg0KhRI8tyyIbA7c6dO1rSCdkHKHWFoE7hwoUty7322mtaaunw4cMaJNi3b59mQpw8eVKiA4IaCG4Y+2DFihWWslGAgETFihX1e7xfvHeM2969e0M9Zg1lohCIGD58uJw5c0aOHDmi90d0cofAB07cEbAwIKsmZ86cum34Cgi6GLDt2A4iIiKKHsePH49UDzIiIiIiIqK4rEGxzNpQ/INZe+R5sEjQ0/8qy8C1gCDpOvNf+entklK7cCaH1oksj51nb8uNwCDJkNJLyuZMawmekGtFuQ4SJv2bNWumV/R36tQpTPDBmjER7uzVTpgcx/pRCgmloQABEwQM0Lg6sjp06KBNwfEerBtmI0ixdetWXXfBgv81mAEsj8AGyj3h+759++r96KmBrINatWppEAT9NKwDGwi8oAwUylEh8INSW4426XZ08iJPnjyWcUbpKZSOsmaUmipTpowkS5ZM3yMybBDAsNf0e8yYMbJgwQJp2rSprgvlpYx+Gi9j7zNgbJd1KSrrcl1EREQUvXCRBbmPkJAQLauaKlUq7dNG5mH0+SMiIiIi86tewFdSeSWSOw/DXmAd8v+vfRcelNTJEkvWNEnFN5WXJPK0X/QI2R1DlhyRqwEvqgxBJm8vGdSgoMOBEYo6pxo89OrVS2rXrh2qkTiuxscV+wg2IBAByE5ACaRs2bI583LaqwKNptH022i6bawb5Y4iCxPrmKxHqSZkcBh9PZCVgQn4WbNmScqUKS3Lo8fGtGnTtJ8HTnDQEwLZGtbBDwQI7JVnMspRzZ49W8chOstQYbx3794tEyZMsOwDNOi2zohAjxPc36JFCx1H7Df0z8ANzd3tQW8MZOagjwacOnXKcmIOOCk3vreGjBTsE+wblOYygkXo8WFkaxAREZFrIcOW3AeOmXAMhv3CwAYRERERUexAdoW9oIa1uw+fSutJ2/V7JF8gEyNTai/JnDqpZPb2kkzeSeX6vSD5+Z8zYZ4blawPisEeGwZkKSC4cfny5VAllzCx3bt3b80iQOYCGk7Xr19fr1BzFspfIZCCElgHDhzQiXf0k4hsKSoDAiQITli/h6VLl+qEfKlSpSRv3ryWW/v27fWEFP0jChUqpA3BUdJpyZIlGkjARD4CJSjxhKwNW+jXgTFBySqjd0dkIaBy8+ZNvV25ckXHAdkZ6GVirBPbuXz5cpk+fbqW/0IwBjdkihhQjgrvA83Y0QfDHgSm0BcEvUgQOME+tS4FhjHHuKGnijVkoiCAgv2+Y8cOzW757LPPtBcJPh9EREREREREREREMQ0loyID/cSv3QuSvRfuyrIDV2XyprMydOkRu0ENMC4BRyYHm5G7ccYGNG/eXJtl37hxQ3/GVWjIHMCkNgIOmORGiaaePXtGx/bqhDwm09GY2gggYNLcGX369NHMBcAkPSbxx40bF2Y5X19fzbpA5kaXLl1k7Nix2ncDfToQZEB5J/SqQJ8No9+FNR8fH22WjWwGexkdjkC2iNEPAyWfMmfOrONrXQ4Mzb6RoYEeHviKDJFRo0ZpCSrrZRCYQgAH22PP119/rYEjjDneO4IV2L9Hjx7VZuQoyYUG6ggMIYBlO6YjRozQBuHYTyjDheCKvZJXRERERERERERERK6G7AtH1C7sKxKSQK4EPJIrd4Pk1v3HDr8GghsoT4XskAq5fZzYWnqZBCH2agkRuTFkrSA7Zt3FBHLu5oPY3hwiIiK34pcuhfRtUiK2N4Ns4JA7ICBAvL29WYrKpMeeuDAoPpZ4i833z/83HFsz4ueWY2tG/NxybOPT5xZZFBVHrNOSUfYmxbGmjN5esrlP1VBNwB8/e67PQZBj2cErMnP7hQhf6/vWxaVR8SxiRiGxdP4SmWNPpzM2iGJLzwbF4uXJJRERkSMH69YH4UQU96Ck7JAhQ7Q/IHr8dezYUW8vg8x0ZFavXbs2xraTiIiIyJ3gPAnNvdEHA2dM1sEN4wwKj9ueTyVJ6CnZfZLrDRwJbDiaHUJRE6OBDTTbtlfiyYCSSkOHDo3SutFvo127duE+jpJNy5YtE3flyrGJq5hsZN79dv/+fS3Xxuap5sP9Z27cf/Fn/zGoQRT3oeTsoUOH5LffftOyuAhY4Jyndu3adpdHr78ePXpoOVsiIiKi+AxNvdHcG30wUDLKgEwNBDUiavpdNmdayeTtFW7Wh64rVRJdjuJIYKNZs2ZStWrVcB+315fCUfnz55fFixeH+3h4fSTchSvHhsjdIK2MzIv7z9y4/8yN+4+I4OHDh7JgwQKZPHmyFCpUSG8nT56UWbNm2Q1szJ07V/vf+fn5aYCUiIiIKL5D8KJGwYzaBwMNxZFdgUCEIxeJvSzrw5ArfQpecOZiMTrbnypVKr25AppSZ8+eXczKlWNDRERERERxx7Fjx+TZs2dSosR//XRKlSolEydOlODgYPHw8Ai1/D///KOBDQQ1xo8fHwtbTEREROR+EKCIanPv8LI+jEDH1tP+svbodalWwDcat5isuXcaAxEREREREYVy8+ZNSZMmjV7cZUiXLp323bh7966kTRu67MGECRP068KFC50qhxfTpWCN12QJWo6tmfBzy7E1I35uObZm5A6f21qFMkr1Ar6y69xtuXHvsWRIlUTO3nog/Rcd0sf7Ljwoq3qkljTJ/ztmM4uQWBrfyLweAxtEREREREQm8ujRo1BBDTB+fvLkiUte8969e2EyQWLixBZlt4C92Ti2ZsHPLcfWjPi55diakTt9bgv4JNQb5E+bSpbnTiObT9+Rm4GPpf8f+2R4o3xiNiGxNL7IPnYUAxtEREREREQmggbgtgEM42cvLy+XvCbK5np6ekpsXLHn7e0d6xMWcQ3HlmNrRvzccmzNiJ/b+Dm237UsIbXGbpKAR09l5dFbUq+4n9Qv+vKG5O4mJJbGNzJ9JRnYICIiIiIiMhFfX1+5c+eO9tlImDChpTwVghqu6tuHE9rYmDQwXtfdJiziAo4tx9aM+Lnl2JoRP7fxb2wzeieVoY0KSY+5+/TnL/48JOVypdUG5WaSIBbGNzKvFbO5xEREREREROSUAgUKaEBj374XJ8uwZ88eKVKkSIyXiyIiIiKisBoWyyx1i2TU7+88fCr9Fx5i37BoxqNeIiIiIiIiE0maNKk0btxYBg8eLAcOHJA1a9bIlClTpG3btpbsjaCgoNjeTCIiIqJ4C5kHXzYqLOlSvOiDtubodfl9z6XY3qw4hYENIiIiIiIik+nXr58UKlRI2rVrJ0OGDJHu3btLzZo19bGKFSvK8uXLY3sTiYiIiOI1nxRJZFiTIpafhy45IpfvPorVbYpL2GODiIiIiIjIhFkbI0aM0Jut48eP231O06ZN9UZEREREMaNWoYzStGQWWfjvZQl8/Ez6/H5ApncsKx4e7tUXxIyYsUFEMc7T05OjbmLcf+bG/Wdu3H9ERERERETmMqhBIcnk/aJx+OZTt2TWjvOxvUlxAgMbZOpadWTO/ZYyZUruP5Pi/jM37j9zc9X+ex4cEq3rIyIiIiIiov94J00kI5oVtfz89fJjcu7WAw5RbJaiypcvn9SvX19GjRoV6v6FCxfK+PHjZd26dRKd/vrrL1mwYIHMmDHDct/Dhw/l66+/ltWrV0twcLDUrl1b+vbtK8mTJ4/UuvGcRYsW6XqyZcsWbduM9cLw4cOdXtc777wjO3futPzs5eUluXLlkg4dOkjDhg2dXv+lS5ekWrVqsnbtWsmaNWuEy2/btk0yZMgguXPndtk+f5nRS/bLuZv8JUBERBRVfulSSN8mJTiARERERERELvR63vTydvlsMnP7BXn09Ln0WrBf5nWpIJ4sSRV7PTaWLl0qzZs3lwoVKogrbd++Xb744gspUuS/hiuAoMahQ4fk119/1SsY+/fvr0GEL7/80uF1P3782BLQWLx4sXz00Ufirjp27Ki3kJAQCQwM1CAEGgc+e/bM6Xq5mTJlks2bN0vatGkdWr59+/Yyffp0DWzUrVtXKleuLDHpsv8DOXXtXoy+JhEREREREREREVFk9atTQP45cUsu3H4ou8/fkV83n5HOr+fmQMZWKaosWbLI0KFD5cmTJ+IqyAR47733xM/PL8xjiRIlks8//1wKFy4shQoVkmbNmsmePXsitf6NGzfqet58800NbCBo4K6SJUsm6dOnt2RKdO7cWcfm22+/1QCNs3W7se6o1O9G9oijAREiIiIiIiIiIiKi+CR5koTyXYtiYlQX/m7VCTlxPTC2Nyv+BjY+/vhjuX79umZMhOfatWvSo0cPKVu2rJQrV06++uqrSAVCtmzZouuvWbNmmMcGDRokpUqVspRSQgYJXicy8JzSpUtLlSpV5PLly7Jr1y7LY1gnSm79/fffUr16dc0Y6dKli9y9e9eyDLIcGjRoIEWLFpVOnTpptohRgsoWMkOQ3VCsWDHNdLEuLRVVrVq1ktu3b1sCOhhbjDHGGrdevXpZtveTTz6RPn36hHr+p59+KgMGDLC8V3yFU6dOybvvvislSpTQ943Az+nTp/WxqlWr6te2bdvKDz/8oKWojPsAy+G5JUuWlEqVKmlwCqXCAMvjNbHv8DiyfSZPnuz0OBARERERERERERG5q7I500qnijn1+yfPg+XT+fvl6fMXc6YUw4ENX19fLd00ceJEuXjxYpjHMcnerl07efTokfbGGDt2rGzYsEFGjhzp8GvMmTMnwmAFJuvRH+LWrVvSrVs3h9f94MEDzdhAUCNHjhyaBYFeG7bw/kaPHi0zZ86UgwcPytSpU/V+vOeuXbtKnTp1NNsDAYBZs2bZfa1jx47pdmJ59AtBXwxkW5w/f16cLSGFTA4EIgDbifJcCBagVNT9+/c1sAT16tWT9evXy9OnTy37Bz/jfmsIQrz//vuakfPnn3/K3Llz5fnz55oZAr///rslSIHSWNYQZEEQBFkl6ImCAAbGDdtiWLVqlSRJkkTHGgGQ7777Ts6ePevUOBAREVHU4G88b64fAxxfcZzN+VkjIiIiIooun9bMJ69kSKHfH7wcIBPWv7iQnGK4x4bR1BpX7A8bNkwDANY2bdqkGR3z588Xb29vvQ+9MjC5j+yByDb5Dg8CBG3atNFG5vge2+PhEXHcZs2aNTrJj8AG1KhRQwMw2MakSZNalkPwBhkZgOwMBDcAE/e4/4MPPtCfEUDYunWr3ddC1knLli31+Ua2A7JDELgJL8PDUSlTptQgDQJICCL88ccfmn0BCCIhc+P48ePy+uuv60n1jh07pGLFipptgjJSePzq1auW9QUFBUnr1q01QIGgCTRp0kR++eUX/d4oO4V9arsPkQGDsUPmSsKECTVYdPPmTfnxxx+1LwekTp1agzwoe4UsFwRhEIzJmfNFxJKIiIhiDo4RcAxBREREREREruWVyFNGtSgmTX/aKs+DQ+SHdSelcr708vDJc7kRGCQZUnppZgcbi8dAYAOT04MHD9ZJcAQKrKEkETIhjKAGoPwQml1fuHBBChQoEB2bIK+88op+HTNmjJY+QsAAk/URWbZsmW6PMVGPclcIzqD0VKNGjSzLZc+e3fJ9ihQpLBkPmAiwbWhevHhxCQgICPNaGIsVK1bIvHnzLPdhPQgwOAtBDWwXMkiwTgQlrCGYce7cOQ12oKQW3h9eF19r1aoVpq8GghkIFCELBQGHM2fOyJEjRyRdunQRbgveJ/qdIKhhQDkrBDfu3XvR7Dtr1qyhXhPBEXwmiIiIKOYZF0OQ66CHG46DUqVKJQmMorpkCsjYMC5qIiIiIiKKDsX8Uku3yrll3LpT8iw4RJr9tFW/GjJ5e8mgBgWlduFMHHBXBjYAwQE07kbWBq7AN6DckC0jndvZtG6jjNJrr72mk/qAiXdkA9y5cyfC52MZZFdgQr1gwYKhHsOEvnVgA83F7cHkvG2z8fCaj+P9IpukcePGoe5HxoQz0BMD5aby5MljGdPZs2dbMi0MPj4++hU9Pvr16ycDBw6UdevWaSaFvUAJeoCkSZNGe2fUr19fgxtTpkyJcHvs7XOjv4axffbG052bthMREcVlthc4UPTDcQ6yiTHWDGwQEREREdGHVfPIor2X5eKdR6GCGnAtIEi6zvxXfnq7JIMbruqxYQ1Nqh8+fBiqkThKCyFTwLrZ9r59+/Rq/mzZsjn1ejg5RAkn9OwwXLlyRQMWKH8UEWQrYMIdPTEQyDBu6Bmxfft2bXoeEQQTDh8+HOo+25+txwJBCGR/GDdkb/zzzz/iDJSdSp8+vTZA9/Pz0xNmjLfxGgj6fPPNN+Lv76/Lv/rqqxpgQJ8QBFXwPFtoan7jxg3ti4FAFZ6DsXUk+ID3iTEwslpg7969mhWDoBMRERERERERERFRfIZSU4+e2r/w35iBHbLkiJarIhcHNnB1P4Ibly9fttyHbApMtvfu3VvLNiFggN4LyABAKr4zEBxp1aqVNsvevXu3lkxC3w40EUfAISLoBYGyVaVKlZK8efNabugDgaAJmmZHBD0zEKiZNGmSNr9GGStsi70r8bDe5cuXa7AAZbimTZumN5TqchQCRyjphBtKPiHbAv0pPvvsMx0PBDFatGihpcHQRwMNxTH2aFCO8k/GuBklt2rXrm13WxGAwGuhtBiCMeglggAQsmQMyAg5efKkBAYGhnoueohgOfQpwTZiHWgyjtJWvEKRiIiIiIiIiIiI4rudZ2/Lrfv/zbXaQjjjakCQLkcuLEVlQPkiZBDgan9A9sCECRM0mIEgAHopYOK7Z8+e0fJ6WA8myz/++GOdiMeEPUosRQQNzRGAGDduXJjHfH19NTiyaNEiqVev3kvXkyVLFl3HiBEj9CsCOXiuvVJL6L2BRt6Y5MdXZKyg2XmZMmUcfr8oBWWUg0LwAQEcvC7KRRmQxYLtQcNzZE1g/Qi8WJeZwPtCtkh47w89Mbp16yZDhgyRx48fa+1tBCoGDBigY4cxQtN4vA8EafLnz295LoIraDKOsmQou4VMjXbt2kmXLl0kOmXxSS5PX1S4IiIioijwS/eilCcRERERERHFLDQKj87l4psEIWxs4JQTJ06E6dHRuXNnbSjevXt35/cQhYEyWsiSQaCINcGJiIicg7RmpECTa+GQOyAgQLy9vZnBajLx/dgzNt8//99wbM2In1uOrRnxc8uxNaO48Lnddtpf2kzeHuFyDYplkkENCkm6FGH7Gse18Y3MsWe0lqKKj5Ct0KFDB9myZYuW4ELJpm3btkmNGjVie9PiPMbkzLvfUL6M+8+cuP/MjfvP3Fy1/xjUICIiIiIiinllc6aVTN5eElHYYMn+q1JxxDr5aukRuXGP2RsuK0UVGWheba8UlAElq4YOHRqldR84cEDLH4Unc+bMsmzZMnFW9erVtc8ESjShOTcaZ48ZMyZUaSZHNG3aVHt0hAd9NOw1+SYyI0Rfyby4/8yN+8/cuP+IiIiIiIjiBlxkNqhBQek6818Nbti7hC2hRwJ5FhwiQU+D5ZfNZ2XG9vPSpmw26fJGLsnknVTis1gNbDRr1ixUbwhb6NUQVQgsLF68ONzH0UA7unTt2lVvzhg/frz2wwgPeloQERERERERERERUdxQu3Am+entkjJkyRFtFG5AJgeCHsX90sjP/5yW2TsuyONnwXqbtvWc/tyyTFbpWvkVyZI6qaXMMBqNoydHhpRemhESlzP0YzWwkSpVKr25QuLEiSV79uxiFsggISIiIiIiIiIiIqL4FdyoUTBjuEEJ9NfoWjm3TP7njMzcfkEePX0uT54H6/fzdl2U5qWySqHM3vLj+lN2gyNYf1wUq4ENIiIiIiIiIiIiIqL4DEGMCrl9wn0cwY4B9QrK+2/k1pJU07eekwdPnsvT5yEyZ+dFEcEttGsBQVrmChkhcTG4webhRERERERERERERERuzidFEulTO79s7lNVuld9RVIk9gx3WaNnB8pcoUxVXMPABhERERERERERERGRSaRJnlg+rZlPxrYu8dLlEM5AeSqUuYprGNggIiIiIiIiIiIiIjKZB0+eObQcenfENQxsEBERERERERERERGZTIaUXtG6nJkwsEFEREREREREREREZDJlc6aVTN5ekiCcx3E/HsdycQ0DG0REREREREREREREJuPpkUAGNSio34cX3MDjWC6uYWCDiGKcp6cnR93EuP/MjfvP3Lj/iIiIiIiIyFrtwpnkp7dLSkbvsOWmBjUsqI/HRQljewOIoipBgrgXaYwv+y1lypSxvRkURdx/5sb9Z27cf9HreXBInLxqiYiIiIiI4p/ahTNJjYIZZefZ2zJv1wVZvO+K3h/4yLHm4vEisJEvXz6pX7++jBo1KtT9CxculPHjx8u6deuic/vkr7/+kgULFsiMGTPCPDZw4EDx9fWV7t27O7SuHTt2SNu2bWXo0KHSqlWrUI/17dtXvw4fPjzM/YsWLZLVq1dLtmzZQj329OlTmThxoixevFiuX78u6dKlk1q1aun2pEiRQpd55513ZOfOnTJixAhp3LhxqOefPn1a6tatK2XLlrX7/mxhjPv162f5OWHChOLj4yM1a9aUjz/+2PKazsD2YnscGVN/f399b3Xq1LF8NqZPny7lypWTmDB6yX45d/NBjLwWERERxR1+6VJI3yYlYnsziIiIiIiIoo2nRwKpkNtH/NImtQQ2lh28Kt2r5YmToxyljI2lS5dK8+bNpUKFCuJK27dvly+++EKKFCkS5rHJkydrwOPDDz+M9HpHjx4tNWrUkLRpX9405fHjx5aABoIXH330UajHv/vuO9m6dat89dVX4ufnJxcvXpRhw4bJ+fPnNeBhSJQokQZ8bAMba9asiXTWQcaMGeX333/X7588eSKnTp3S1zxx4oRMmzZNPDycqy72ww8/6PY6Au8/JCTEEtjYvHmzeHt7S0y57P9ATl27F2OvR0REREREREREROTOsqZJJsX9Usu+i3fl2LVAOXXjvrySwfkL4t1NlGbBs2TJolkPmFh3FWR/vPfeexowsHb//n0NMCCwkSlT1OqDJU+eXL799tsIl9u4caNO8r/55psa2MAkvjVkcvTo0UMDPFmzZtWvgwcPlvXr18uNGzcsy5UuXVon/W3HC4GN4sWLR7q2dvr06fWG/fDGG29oEGXPnj0ahHFW6tSpdXwcYTse2KbEiRM7vQ1EREREREREREREFDX1i/43b7784NU4OYxRCmyg7BFKL/3666/hLnPt2jWd9EdZI5QmQlZDZAIhW7Zs0fWjzJK1S5cuaSYFyjLZBj0cNWDAAA1KIBgQUWYKghJVqlSRy5cvy65du0I9jmwLZJUEBwdb7itRooQsW7ZM0qRJE+q+JEmS6LIGjB8yO6KjbFOuXLl0O60DG/geZa6KFSum2TUoGQX//POP3vfo0SPLsgi6lCxZUoKCgrQUFbI2APvrm2++kUqVKkmhQoWkatWqMm/ePH0My2AMccP9RikqlPsC7CMEjxB4QfDm/fffl6tXr1r2IZb9+++/pXr16pqR06VLF7l7967TY0FEREREREREREQUn9Up8l9gY9mBuBnYiFIpKvS1QNbEmDFjtN+GbYABE+Lt2rWT7Nmza++I27dvy+eff27pi+GIOXPm6FdjotyQP39++fnnn8UZ1apV02AFsiswMY9eFbYePHigGRsohZUjRw7JnTu3LotAjQH9OsaNG6eZF5jAf/XVV6VixYryyiuvhFoXykNVrlxZy1G9/vrreh+eg4CBvdeOCrzmv//+q98fO3ZM+vTpI0OGDJGiRYvq+0D2C/qVYBuTJk2qAQ70AwEEGBCc8PLyCrXOSZMmyYYNGzSIgV4eeP9ffvmljl/Hjh21RwhgjGwNGjRItwe9RZAFgrJVH3zwgfzxxx+WZZBpgrJgyPzo2rWrTJ06VT755JNoGQ8iIiKiiDx//jzGBgnHO7gYBq8Z2VKkFH8+J27twQOkj4e9H/dZn0dgufCgbG7SpI4va73ehw/xH8n+svg/lSxZ1JbFBV9WF6qFYZ3NHpllg4Lw4YmeZbG9xu+Nx49Fnj1zflmMj/V7wUWIT5+Gv17sN6PscUTLYr8Zn5XILIvlXnYxZJIkaDQZ+WUxBhiL8KDqgFGOOTLLYp9h39kbW3y2MWbYjpcta8A6jeoH2C9WFyI6tSzGwNgGbBf+b0THspH5fx+dvyOMscW2Yr3Wy/J3hHO/I6zH1ng8Mv/v+Tsi/N8R9sbW9v8yf0eE//8+ot8R9sbW3rLx8HdElkQiFXyTyLZrQXL8OspRBcor3okj9zsivPF15e8IB1skQJRn1XFlP7Im0N/Bup8EbNq0STMS5s+fb+m5gMlvTF5j4trRUkeuhABLvXr15LfffpN33303zOMIPKA5OAIggJ4cCNLgfSAwAN26ddOgzuzZs/W9zp07V98bMkKaNWsWan0IBiAogGAKrF27Vlq2bCknT56MlveDxuEIxgAyXbDuBg0aWAIwyDZBsAjN0JEFg2AGAhs4UcN7RUaNLQSRypcvbymXhayLH3/8Uc6dO6cZIkYgxLZXSUBAgPz5559aLgzPBwQ2ENxBJk7OnDn1PgTHEHgBbOvBgwejZSyIiIiIHHH8+PFQWaxE9BKZM9ufbKhbV2TZsv9+zpAh/AnRN94Q2bDhv59z5BC5dcv+sqVLi/w/61wVLChy/rz9ZfHY4cP//VymjMiRI/aXzZ5d5Ny5/37GhWe7d9tfNl06kZs3//sZvQU3bgx/IsB6fHA+uHy5hMt6wuSdd0T+30fRrvv3/5vA6NJF5Lffwl8WJZHTp3/xfc+eIhMm2F0M0xMe+/eLGJUGBgzASVv46z10SKRQoRfff/21yJAh4S+L/YZ9AN9/L9K7d/jLrl8vUrnyi+8nTRJ5WQ/NpUtF6tV78f2sWSIdOoS/7Pz5Ii1avPh+0SKRli3DX3bqVJH27V98v2qVSP364S87fjwmAl58v2mTyP/nC2zHNjV28YgR/713XIRodZFkGIMGifx/rkCOHhUpXDj8ZXv1EjFKa1+4IPL/82u7PvhA5McfX3yP/2v4/xmedu1Epk178T3+D6d4SS325s1FFiz47+eXLRuNvyOMsbX8jrCuqsHfEU79jgg1toazZ1/sA+DviCj/jrA7tjBypMhnn734nr8jovY7ImdOSf2y4wj+jhCkDRT45Hd5lNhLlh24Jj1mDovU74jUP/0U/rKu/B3hYA/pKAc20OsBk/ToP4GJcWu4kh9ZDtaNpFHq6NmzZ3LhwgUpUKCAxDb0p0AGAXp5IMBhC+WksM3GpD2CAQjgICDQqFEjy3INGzbU2507d7Sk08yZMzWwgVJLha0ORl577TUttXT48GENhuzbt08zIaIrsIGgBoIbxvivWLHCUjYKEKRBNgng/eK9I7Nm7969oR6zhjJRCEQMHz5czpw5I0f+f3IQ0VVrCHzgikSUvDIgawMBDWybEdhARo8B247tICIiIoopOF6LyYyNe/fuSapUqZixYTI49uUFOERERERkZssOXpEeErc4VQcJE//ITEDWRqdOnSz3o5+ELWMy3J1SuTt06KBNwbH91lkkCFJs3bpVAzEFEfW3guUR2EC5J3yPDAhATw1kHSALAkEQ9NOwDmwgywNloFCOCkEflLSKzswVXHGYJ08eyxij9FTjxo1DLWNkWJQpU0aSJUum7xHZNQhg2Gv6jVJjCxYskKZNm+q6UF7K6KfxMvb2v7Fd1v1I0JidiIiIKLbgQp2YDGygPClek6WoyJSuXAm/FJXtlX7hsb36zjpzIqJlcZHVy8pCWMMVmo4u+88/Ly8LYW3FCseXRQleR899Z8z470p5e6xLXqAss3EFfkTLjh794org8MrjWZdyGjbsv4wBe6zLefTv/99VxvZYlx3q0eNF1oAjy3bu/F/mhD3W55lvvfVfRkZEyzZp8iLrJTzW58Io1+zospUq2V0WY4sqBt7I+DGULPny9VqfG+NCUEeXzZbt5ctal77G9ji6LD5HL1vW9v99ZJZ14neEZWy9vSWB7Xr5O8Kp3xGhxta6FJWBvyOi/DvC7tja/l/m74io/Y44e1bu2htbe8vG498RBX/bJ3su3JUT1+/LyaHfSZ5I/I64O2CA/fF15e8I/N9wsKqP0w0eevXqJbVr1w7VSBxX5OOqfWQo4Ep9QIYC+klkwx9eN4GJdUzWo1QTMjiM/hnIysAE/KxZsyRlypSW5dFjYtq0adoYHZP06AmBbA3r4AcCBAgg2JZnMspRoWwVxgClraILxnr37t0y4f8phBh/NOi2zogYOXKk3t+iRQs9qcY+Q/8M3OyVoQKU1kJWTh2kXIvIqVOn9Ct+KQM+1Mb31pCRgn2NfY4+IkawCM3SjWwNIiIiIiIyEVyU5UgwMDIXb0W0rPW5hvWJdkQis6z1iXZ0LmvTvzDalsWEfTgXkkVqWYytdY1tTMbZudjNLlcti4kMRy9+i8yymLB3tLdlZJbF/wd7n2FjbK3fd3jL2oPJOFcsi0kpVywLMbWsMba433aSjb8jnPsd8bKxBf6OiPrviIjG1npZR/B3xH8wZhGNrSEe/46oVzSzBjZg6fHb8kmNvI6tF78fMLaOjG90/o6IRFKEYwWrXgKZCghuXL58OVTZJUxu9+7dWzMJkL2A/hJoNI70e3dSrlw5DU5Yb//SpUt1Qr5UqVKSN29ey619+/YaFED/iEKFCmnPCJR0WrJkiQYSMJGPQAlKPCFrwxb6dWA8ULLK6N0RWQio3Lx5U29XrlzRMmDIzqhQoYJlndjO5cuXy/Tp07X0F4IxuCFTxIByVHgfjx8/tvTBsIWg1Pr16+XixYsaOMH+BLw/IwsF44Z+KtaQiYIACvY5mr8ju+Wzzz6TjBkz6meDiIiIiIiIiIiIiFyrbpFMlu+XHbwap4bb6cAGNG/eXEqUKGH5GSn2RvYAmlj37NlTsxWGDh0q7qhPnz6WgAsm6TGJj/dky9fXV98HMjdg7NixWpYKfTqQ1dClSxe5f/++9tkw+l1Y8/Hx0WbZ6DFiL6PDEcgWQT8M3JB1gabcKIGFbTCg2TcyNJAdUrduXW1sPmrUKC1BZb0MglIIwCC7wp6vv/5ajh49qkGQfv366eth+3Ef4L2fPXtWA0O2mRsYU5TeQoPwNm3aaHkqBFfslbwiIiIiIiIiIiIiouiV0dtLyuRIo9+funFfTlwPjDNDnCDEXi0hIjeGrBVkx6y7mEDO3XwQ25tDREREJuOXLoX0bfLfRTkxIdz6ymSaY09cGBSTfVncRWy+f/6/4diaET+3HFsz4ueWY2tG/Nw6buqWszJkyRH9/qNqeaSnA+WoYmt8I3Ps6XSPDaLY0rNBsXh5cklERETOex4cIp4eDDAQEREREVHcVqdwJhm69Ii2fFl24Ip8Uj1PnLjYKsYDG2i4PW7cuHAfR1mlqJSsOnDggLRr1y7cxzNnzizLli0Td+WqcYnLmGxk3v2Gkm0o1xYXfonGN9x/5sb9Z27cf9GLQQ0iIiIiIoo35aiyp5Wd527L6ZsP5Pj1QMmf0b36YJsisNGsWTOpWrVquI/b603hiPz588vixYvDfTy8PhLuwlXjQuSOkFZG5sX9Z27cf+bG/UdERERERESRVa9oJg1swPIDVxnYiAo06TYadUcnNKXOnj27mJWrxoWIiIiIiIiIiIiI4q86hTPK4CWHtRzV0oNX5ZMaeU1fScUjtjeAiIiIiIiIiIiIiIhcI0MqLymTI61+f+bmAzl2LdD0Q83ABhERERERERERERFRHFa/aCbL98sOXBWzY2CDiIiIiIiIiIiIiCgOq104oxjVp5YdvCohqEtlYgxsEBERERERERERERHFYRlSekm5nC/KUZ299UCOXjV3OSoGNoiIiIiIiIiIiIiI4rh6RTNbvl928IqYGQMbRERERERERERERERxXO1CGcXDKEd1wNzlqBjYICIiIiIiIiIiIiKK49KnTCLlcvro9+f8H8rhK/fErBjYIKIY5+npyVE3Me4/c+P+MzfuPyIiIiIiInJGvaKZLN+jibhZMbBBppUgwf/zpsh0+y1lypTcfybF/Wdu3H/mxv3nfp4Hmzdtm4iIiIiI4qfahf8rR7X8oHnLUSWMzML58uWT+vXry6hRo0Ldv3DhQhk/frysW7cuWjfur7/+kgULFsiMGTMs9z158kTGjBkjy5Ytk0ePHknZsmXl888/l4wZM0a4vh07dkjbtm1l6NCh0qpVq1CP9e3bV78OHz48zP2LFi2S1atXS7Zs2UI99vTpU5k4caIsXrxYrl+/LunSpZNatWpJ9+7dJUWKFLrMO++8Izt37pQRI0ZI48aNQz3/9OnTUrduXX0P1u8xPBjnfv36WX5OmDCh+Pj4SM2aNeXjjz+2vKYzsL3YHryHiPj7++t7q1OnjuXzMX36dClXrpzEhNFL9su5mw9i5LWIiIiIrPmlSyF9m5TgoBARERERkamkS5FEKuT2kS2n/OX8/8tRFc7iLXE6sAFLly6V5s2bS4UKFcSVtm/fLl988YUUKVIk1P3jxo2TNWvWyHfffSdp06aVb7/9Vj788EMNgDh6Bf/o0aOlRo0a+vyXefz4sSWggeDFRx99FOpxbMPWrVvlq6++Ej8/P7l48aIMGzZMzp8/rwEPQ6JEiTToYxvYwPuIbNYBAji///67Jchz6tQpfc0TJ07ItGnTxMPDuSScH374QbfXEXj/iOgZgY3NmzeLt3fM/Se47P9ATl0zbx04IiIiIiIiIiIiophWt0gmDWzA0gNXTRnYiPQseJYsWTTjAZPqroLsj/fee0+DBbaQPfHJJ59oVsErr7wiX375pRw8eFCDCY5Knjy5BkQisnHjRp3kf/PNNzWwYZuWg23p0aOHBnmyZs2qXwcPHizr16+XGzduWJYrXbq0TvrbjhkCG8WLF5fI1tZOnz693rAv3njjDQ2i7NmzR4MwzkqdOrWOjyNsxwPblDhxYqe3gYiIiIiIiIiIiIhco3ah/8pRLTt4xZTlqCId2EDJI5Rd+vXXX8Nd5tq1azrhj+ADyhIhoyEygZAtW7bo+lFiyVpwcLAGJF599dUwzwkMDHR4/QMGDNCgBIIBEWWnIChRpUoVuXz5suzatSvU48i2QGYJtstQokQJLZOVJk2aUPclSZJElzVgDBGMiY6yTbly5dLttA5s4HuUuSpWrJhm2KBkFPzzzz96H8p4GRB0KVmypAQFBWkpKmRtAPbZN998I5UqVZJChQpJ1apVZd68efoYlsEY4ob7jVJUKPdlZLtgXyHwguDN+++/L1evvmhGc+nSJV3277//lurVq2tWTpcuXeTu3btOjwURERERERERERERhc8nRRJ5NXc6/f7i7Udy6PK9uB/Y8PX11ZJMyBJA6SVbmAxv166dTpyjb8TYsWNlw4YNMnLkSIdfY86cORoUCbOxHh4a1EBWgQE9HRBEwES5o6pVq6bBCmRXPHv2zO4yDx480IwNLJcjRw7JnTu3TuJbQ78OvEdM7A8aNEhWrVqlwQFkkliXc8J2V65cOVQPEmRrIGCAPhnRAa+Jnh1w7Ngx6dOnj3Tt2lX7lDRs2FAzYBBIwfglTZpUAxwGBBjwHry8vEKtc9KkSbrvEMRYuXKlltJChsytW7ekY8eOWoIKN6M0ljWMB4Ir6C0yd+5cHecPPvggVBAInyGUBZs5c6Zm3UydOjVaxoKIiIiIiIiIiIiIwlevaCbL90sPXhGziVJDBlzVnz17du3tYGvTpk2ajYCr9RFsQHkm9MpAsALBguiE4MCUKVPk008/jXQJpIEDB2pg5rfffgt33WgOjsAGoCcHAhfWmQ7dunXT94m+F/Pnz9eAD4IVf/zxh91gCkpUGdauXavrjC5oHG6ML7JdWrZsKQ0aNND9hADM66+/rvsAgRRkwiCYAc+fP9f3iuwOW/nz59d9jIwLlAVD1gXG5Ny5c1quCoEQ3Gx7lQQEBMiff/6p+718+fK6HvTjOHv2rGbjGDBeRYsW1QwSbCuCG0RERERmgmMpR2+4wCMyy/PmPmNARERERBTX1CqUUTz/X49q2YGrpitHFaV0AfR5QLYDek9gUtwasgaQ4WDdRBpljnDF/oULF6RAgQLOb/X/Aw8oi/X2229LixYtIv189KdABgH6edSrVy/M4ygnhe02Ju0RDECGAQICjRo1siyHbAjc7ty5oyWdkH2AUlcI6hQuXNiy3Guvvaallg4fPqxBgn379mkmxMmTJyU6IKiB4IaxD1asWGEpGwUISFSsWFG/x/vFe0d2zd69e0M9Zg1lohCIGD58uJw5c0aOHDmi90d0cofAB07cEbAwIMsmZ86cum34Cgi6GLDt2A4iIiIiMzl+/HioC1+IiIiIiIjMIG3yxPJqbh/ZdPKWXLrzSA5cCpBifv9VSnJ3Ua6DhEn/Zs2a6RX9nTp1styPXhK2jInw6LraCUGH3r17S+vWraV///5RXk+HDh20KTjeg3XDbAQptm7dqsGYggULhnoOlkdgA+We8H3fvn31fpTDQtZBrVq1NAiCfhrWgQ2Uf0IZKJSjQuAHpbYcbdLt6El1njx5LOOM0lMoHWXNKDVVpkwZSZYsmb5HZNgggGEv42XMmDGyYMECadq0qa4L5aWMfhovY+8zYGyXdSkq63JdRERERGbkaDlUXP107949SZUqlfZpI/PAMSwzi4mIiIgoLqpXJJMGNmDZwavxI7ABvXr1ktq1a4dqJI6r8XHFPrITjF4YyE5ACaRs2bI5vcHbtm3ToMZbb73lVFDDmFjHZD1KNSGDw+jrgawMTMDPmjVLUqZMaVkePTamTZumzdFxgoOeEMjWsA5+IEBgrzyTUY5q9uzZOg7RWYYK4717926ZMGGCZR+gQbd1RgR6nOB+ZLeg5wf2G/pn4Ibm7vagNwYyc9BHA06dOqVfjbQknJTbS1FCRgr2N/Y7SnMZwSL0+DCyNYiIiIjiAmQyOwLHTDgGw/IMbBARERERkbuUoxqw+JA8Dw7RclT96uQ3zflKlHpsGJClgODG5cuXQ5VcwsQ2gg/IIkDmAhpO169fX69QcwYyKBDMQMYBMhJu3rxpuaGsUlSUK1dOgxPW72Hp0qU6IV+qVCnJmzev5da+fXs9IUX/iEKFCmlDcJR0WrJkiQYSMJGPQAm2BVkbttCvA2OCklVG747IQkDFeM9XrlzRklwYC/QyMdaJ7Vy+fLk2Vkf5LwRjcEOmiAHlqPA+Hj9+rH0w7EFgCn1B0IsEgRPsUzDGGlkoGDf0VLGGTBQEULDfd+zYodktn332mfYiweeDiIiIiIiIiIiIiGJXmuSJ5bVX0un3l+8+kv2XAkyzS5wKbEDz5s2lRIkSlp9xFZqROYAG1j179tRMhaFDhzr7UnLo0CGdzEfWBnpCWN/QKyKq+vTpYwm6YJIek/h4X7Z8fX31vSBzA8aOHatlqdCnA1kNXbp0kfv372ufDaPfhTUfHx9tlo0+I/YyOhyBbBHjPSPrAk25UQIL22BAs29kaCA7BE3B0dh81KhRGhCyXgaBKQRgkF1hz9dffy1Hjx7VIEi/fv309bD9uA/w3tEQHIEh28wNjClKb6FBeJs2bbQ8FYIrkW3yTkRERERERERERESuUb9IJsv3yw5cMc0wJwgxW7tziveQtYLsmHUXE8i5mw/i/XgQERFRzPNLl0L6Nvnv4p6I4JA7ICBAvL29TZPaTaGPPXFhkKOlx+KS2Hz//H/DsTUjfm45tmbEzy3H1oz4uY0+dx8+kdJfrZFnwSGSJXVS2dznRVWg2Dh/icyxp1M9NohiU88GxeLlySURERG5B9Sh9fRgkIKIiIiIiMwrdbIX5ag2nrip5aj2XbwrxU3QRDxGAxtotj1u3LhwH0dJpaiWrDpw4IC0a9cu3MczZ84sy5YtE3flyrGJq5hsZN79hpJtKNfGK1bNh/vP3Lj/zI37z/0wqEFERERERHFBvaKZNLABaCLOwIaNZs2aSdWqVcMdQHt9KRyVP39+Wbx4cbiPh9dHwl24cmyI3A3Sysi8uP/MjfvP3Lj/iIiIiIiIKLrVKphRBngelKfPQ2T5wavSr05+cXcxOtuPBt1Gk+7ohqbU2bNnF7Ny5dgQEREREREREREREdnjnSyRVHwlnaw/flOuBARpOarcqT3Enbn31hEREREREVEYjx8/lv79+0vp0qWlYsWKMmXKlHBH6ciRI9KiRQspVqyYZoofOnSII0pEREREodQrmtny/S+bz8iKIzdl+xl/7S3ojhjYICIiIiIiMpmRI0dqgOK3336TQYMGyfjx42XlypVhlnv48KF07txZAyALFy6UEiVKSJcuXfR+IiIiIiJDjYK+4vn/aMGKQ9el318npM3kHVJxxDpZeeiquBsGNoiIiIiIiEwEQYkFCxbIgAEDpFChQlKjRg3p1KmTzJo1K8yyy5cvlyRJkkjv3r0ld+7c+pzkyZPbDYIQERERUfy17fQteR4c9v5rAUHSdea/bhfcYGCDiIiIiIjIRI4dOybPnj3T7AtDqVKlZP/+/RIcHPpsFPfhsQQJEujP+FqyZEnZt29fjG83EREREbmn58EhMmTJEbuPGYWo8Lg7laViYIOIiIiIiMhEbt68KWnSpJHEiRNb7kuXLp323bh7926YZTNkyBDqPh8fH7l27VqMbS8RERERubedZ2/L1YCgcB9HOAOPYzl3kTC2N4CIiIiIiIgc9+jRo1BBDTB+fvLkiUPL2i4XkZCQEL3FJOM1Y/p14wOOLcfWjPi55diaET+3HFuzuHEvyOHlXHlsFpl1M7BBRERERERkIuiZYRuYMH728vJyaFnb5SJy79498fCI2YR/nNgaTc6NUlrEsXV3/NxybM2In1uOrRnxcxu9knk8c3i5gIAAcRXbsqovw8AGERERERGRifj6+sqdO3e0z0bChAktJacQrEiVKlWYZW/duhXqPvxsW54qIlivp6enxCTjij1vb28GNji2psHPLcfWjPi55diaET+30atK4VSS0fuUXA8IsvTUsIZLTDJ6e0mVwn7i6eG6C06eP3/u8LIMbBBRjIvpk2KKXtx/5sb9Z27cf+bG/UfRpUCBAhrQQAPw0qVL63179uyRIkWKhMmqKFasmEyePFlP/pH1gK///vuvvP/++5F6TTw3NrImjNdlxgbH1kz4ueXYmhE/txxbM+LnNvok9EwggxsUlK4z/9UghnVwwzgCHNSgoCT0dG0Gb2SO+dg8nEyLJzfm3W8pU6bk/jMp7j9z4/4zN+4/c+P+c87zYPZYsJY0aVJp3LixDB48WA4cOCBr1qyRKVOmSNu2bS3ZG0FBL+ok165dW8tIDRs2TE6dOqVf0XejTp06Tu4VIiIiIopLahfOJD+9XVIzM6zhZ9yPx90JMzZsVK1aVS5fvmx3sKZPny7lypULdzAvXrwoZ86ckTfeeEMuXbok1apVk7Vr10rWrFmjdafdv39fT15wMhMVP/zwg+zcuVNmzJhhSUUfNWqUbNiwQdedPXt2adWqlbzzzjvizkYv2S/nbj6I7c0gIiIiIhfyS5dC+jYpwTG20a9fPw1stGvXTlKkSCHdu3eXmjVr6mMVK1aUb775Rpo2baqP/fzzzzJo0CCZP3++5MuXTyZNmiTJkiXjmBIRERFRKAhe1CiYUXae9Zdz1+9IDt80Ujanj0vLT0UVAxt29O/fX+rWrRvmftR2jeh5ZcuW1cBGpkyZZPPmzZI2bVqJbtOmTZMdO3ZEObBhDanonTt31uDLL7/8orVz9+7dK0OGDJGnT59Kx44dxV1d9n8gp67di+3NICIiIiKKlayNESNG6M3W8ePHQ/1ctGhRWbRoUQxuHRERERGZladHAimfy0cK+CR0615nDGzYgTI56dOnd7qGsrPriKg5TnTASc/hw4c1WGI0GvTz89OME1zR5c6BDSIiIiIiIiIiIiKKf9hjI5K2bdsmjRo10sZ8KDU1d+5cvb9v375a3mn8+PFawgmBAaR54yvg+xUrVmgtWzTw69mzp5auQh1c/Pzmm2/K9evXLYGLiRMnalmswoULayo51gsLFy7U7/FaWCc8efJEvvrqKy2ThVuvXr3k7t27lm1GLd02bdro6+D17ty5898H4P/NBbds2RLqfb799tvaZNBw/vx5effdd6VEiRJSuXJlLctlOH36tD5WsmRJqVSpkm5fcHCwpezVBx98IG+99ZZms2C7I9peIiIiIiIiIiIiIqLwMLARCc+fP5ePP/5YG/AhSNGjRw8t2YTAwYABA3TSHxkOmMy3Z9y4cTJ8+HCtcfv3339rsAE3BEfQ4M8IJCxevFh+++03bey3cuVK6datm64TmRUokYXXwGuh1BWMHj1aDh06pM9HwAF9MrBtgCACSk0hCwNBkVq1asm8efMs25Q3b14pX768vq8mTZroulDmKnny5PocePz4sb4m7kMWxxdffCFjxoyR9evXy+3btzUokyFDBlmwYIHW7p05c2aowAf6jNSvX1/fE9LgX7a9REREREThHYvH1o2IiIiIiNwLS1HZgcn5L7/8MtR9mTNnllmzZmlmQbp06bQnBW6Y0EfJKZSvSpQokTbhS506tU7W22rfvr1mTUCBAgUkZ86cmsEBaPR37Ngx/R79OdDsr0KFCvozgh8//vijnDx5UgoVKqSvgdfC6z569EgDCX/88Yclg2PkyJGaCYEyU1evXtVtRmNBPC937tyaNYGAhAHNA3/99Vf5888/NeiCG4IaaCiO7UUABct//fXX2nwwT548MnDgQM32WLp0qdb3xXglTJhQ148gDbYX7xcwXngPENH2GvcREREREVnDsSKOJYmIiIiIiBjYsOOjjz7SQIM1TNojYIEJekzqT5gwQapUqSLNmjWLsKm4wciAAC8vL8mSJUuon5FdAcig2L9/vwYWUObp6NGjGiwwyjtZQzkrNPlu3bp1qPux7Llz5/TxHDlyaFDDgDJaGzdutPycJEkSLReF24ULFzQTY8qUKdK1a1f9/uzZsxqEQVDDgPdtBIEQbMH4GJBNgu29d+9FY2/r9xnR9jKwQURERET2xNZxIjI2Dh48GCuvTURERERE9jGwYYePj49kz57d7oAh8wH9ItasWaM3lHVCkOONN94QRxqKWzP6W9hCSSdkR7Ro0UIDLH369NHeGPYYqfGzZ88OFbww3gfKXNk2G0e2h2HVqlXi7++v5aQgW7Zs0q5dO+3rgbJXuDLOOmhhC0ERW0YAxtg262Ui2l4iIiIiIkeOpYmIiIiIKP5ij41IQBYCemog6IFsBpRTQnbFunXronWnzJkzR/tq9O/fXxo3bixp0qTR4IMRoEiQIEGoLBCc5KHcFLYLN2RWoJQVnoOyUciECAwMtDwHGSCGK1euaGAmKCgo1DakSpVKv6ZNm1YzPtA83Dr1f8SIEdoAHJkc6P2BLAzD3r179XnIcLEV0fYSEREREREREREREb0MAxt2IAiAIIbtDeWiVq9erdkUKNm0a9cu7YtRsGBBfR4yEBBEcHaCHoGMbdu2aQkoNNn+5JNPNHBglKpCT4sbN27IpUuXNCiAzA5kkqDpNxqZ9+7dWwMR6AHy6quvas8ONDdHWSs0EF++fLnltdAwHBkZaA6O18Q6t27dqq+JbBGsA9kb6JOBpuFYB5qBIxME9zdo0EC3y3gMWSxodI6SXdYBGENE20tERERERERERERE9DIsRWUHAhe42erRo4dmN+Cxhg0bSvLkyaV58+Y6UQ/4iiyLTp066eR+VGEduDVq1EjLM6HBOIIZRqZFjRo1NLBQr149zRbp27evZlCgNwgCIGXKlNGG4MiMwA3NwNEXBEEM1CZGKS0ETABZFSgLNXbsWPnss88szdERsEDWiH5IEibU9z106FBdBx5HMKJy5cr6+C+//CLDhg3T7BJkaqCUVZcuXcJ9fy/b3sjI4pNcnoZtO0JEREREcYhfuv/6vBEREREREUGCENsGDERuDn069u3bJ8WLF2etZSIiIqJ44HlwiHh6JIid147nx56x+f5xqhoQECDe3t52s8GJY+uO+Lnl2JoRP7ccWzPi5zZujm9kjj1ZiopMizE58+43lHvj/jMn7j9z4/4zN+4/c+P+c05sBTWIiIiIiMg9MbBBRDEO0VcyL+4/c+P+MzfuP3Pj/iMiIiIiIooeDGwQEREREREREREREZFpMLBBRERERERERERERESmwcAGERERERERERERERGZRsLY3gCiyDKaTqNOdYIEbCRpxv0XHBzM/WdS3H/mxv1nbtx/5sb9Z/7eKMYxaHw+9o6N1+ZxI8fWbPi55diaET+3HFsz4uc2bo5vZI69Gdgg08F/Kjh06FBsbwoRERERxbNj0Pj6vg8ePBjbm0JERERE8USwA8feCULi66VHZOoP9rNnz8TDw4MZG0REREQUI1erJUyYUI8/4xseexMRERGROx57M7BBRERERERERERERESmEf8uOSIiIiIiIiIiIiIiItNiYIOIiIiIiIiIiIiIiEyDgQ0iIiIiIiIiIiIiIjINBjaIiIiIiIiIiIiIiMg0GNggIiIiIiIiIiIiIiLTYGCDiIiIiIiIiIiIiIhMg4ENckuPHz+W/v37S+nSpaVixYoyZcqUcJc9cuSItGjRQooVKybNmjWTQ4cOxei2knP7z7B7926pVq0ah9Nk+2/Dhg3SqFEjKVGihDRo0EDWrl0bo9tKzu2/v/76S2rVqiVFixaV1q1by4EDBzikJvz9eenSJf0/uGPHjhjZRoqe/de1a1fJly9fqNv69es5vERR/F1Ijlm9enWY3z0fffQRh89JT548kfr164f6W3zx4kVp3769FC9eXOrWrSubN2/mOEfT2H711VdhPsczZ87k+Dro+vXr+v++bNmyUqlSJfnmm2/09y4/t64dW35unXP+/Hl599139byncuXK8ssvv1ge4+9b142tu39uE8b2BhDZM3LkSA1Q/Pbbb3LlyhXp06ePZM6cWWrXrh1quYcPH0rnzp11QnX48OEyZ84c6dKlix6wJ0uWjIPr5vvPcPz4cenRo4ckSZIkxreVor7/jh07Jh9++KH07t1b3njjDT1Zw378/fffJX/+/BxaN99/CCYOGDBAD1RKliwps2fPlvfee0/WrVsnyZMn5/5z8/1nbfDgwfr3kMy1/06fPi3ffvutVKhQwXKft7d3DG8xUdz5XUiOOXXqlFSpUkW+/PJLy308BncOJi0//fRTOXnypOW+kJAQ6datm+TNm1f++OMPWbNmjR43L1++XD/LFPWxNf6G4v4mTZpY7kuRIgWH1QH4bGLiPVWqVDJr1iwJCAjQQLKHh4ee1/Fz65qxxd8xfm6jLjg4WOf+ihQpIosWLdKJ+J49e4qvr68GPvm5dc3YYq7V3T+3DGyQ28HkzIIFC2Ty5MlSqFAhveFABn8YbE9mcGCIA3H8AU6QIIFO0v3zzz+ycuVKadq0aay9h/gsMvsP5s6dKyNGjBA/Pz+5f/9+rGwzRW3/LV26VMqXLy9t27bVn7Nnz66T4itWrGBgwwT77+bNm/LBBx9oxg3gYBBXxOLABRkc5N77zzrr5sGDBzG+reTc/sPVp8i0wQlE+vTpOZxEUfy/RJGHv/OYbOfvnugLFGHCBxOa1rZv365XEONcBxfc5c6dW7Zt26ZBju7du/Oj68TYGp9jXF3Mz3HknTlzRvbt2ydbtmyRdOnS6X2YjMc5+euvv87PrYvG1ghs8HMbNbdu3ZICBQroBV2YVM+RI4deHLRnzx4da/6+dc3YGoENd/7cshQVuR1cBf7s2TNNgTKUKlVK9u/fr5FEa7gPjyGoAfiKK4/xx4Tcf/8BAlH4Q480bTLX/kPEvlevXmHWERgYGCPbSs7tvzp16mgpHAgKCpJp06aJj4+PnniTOX5/3rlzR6/4Hzp0aAxvKTm7/3Dii2MWBPWJKOr/lyjyMEGBSQuKHjt37pRy5crJvHnzQt2Pz2vBggVDVRHA55jnqc6PLS6GQ7kffo6jBpOTKDNjTLxbjys/t64bW35unZMhQwYZO3asTrwj2IlJ9127dmnJL35uXTe2ZvjcMrBBbgdXEadJk0YSJ05suQ9/GJCGevfu3TDL4j+hNUzMXbt2Lca2l6K+/2DChAlSs2ZNDqMJ9x8mwK1LTuFqSlyJZl1Whdz7/x9gn2HyaPz48ZoqzTJU5tl/KMGIAGOePHlieEvJ2f2HwAZOHpBxiv4BzZs3l40bN3JgiaL4t4wcgwmLs2fPavlQ9NiqXr26fPfdd5pFRlHz5ptv6vFT0qRJQ93P81TXjS2Cc7g4YOLEiZph0LBhQy2fQo5BmST0fjAgYIx6+cjE5+fWdWPLz230qVq1qv5+wDks/pbxc+u6sTXD55alqMjtPHr0KNSJDBg/2x50h7csD85jT2T2H8Wd/Xf79m1Nq0fGFJvAm2v/YVJ84cKF2rS4b9++kjVrVm1ySe69/7Zu3apX06AkHJlv/yGwgUwpBDVQ0xa9wZBBhatSUZ6KKD7jsaTroF+JMb64OhMl8dBrC7+PBg4c6MJXjn94nuo6RtZjrly55O2339Yriz///HO9YKBGjRoufOW4Cdm/R44c0T6JyODm/Iprxvbw4cP83EaTcePGafkklE5Cc3b+vnXd2KIcqLv/vmVgg9wOembYTgAYP3t5eTm0rO1y5J77j+LG/sMfvg4dOuhVgPhDiOZoZJ79h6tgcUNdTaTxohY0Axvuvf8wAfXFF1/IoEGD+HvVpP//0N/mnXfesTQLR/YbTnjnz5/PwAbFezyWdJ0sWbLIjh079HcPJirwtx9XFH/22WfSr18/8fT0jPefv+j8HNtmGPE8NXo0btxYqlSpIqlTp7b8DT137pzMmTPHbSbazDTx/ttvv8mYMWO09w4/t64bW1xMxs9t9DAuAkImJ0pjN2vWTIMb1vj7NnrG9t9//3X7zy1nn8jt+Pr6at1w1NY1ILUMkwJI7bNdFpOq1vCzbXkqcs/9R+bff6i3+NZbb+mBw/Tp0yVt2rQxvMUU1f134MABnUi1LS+G55N77z/sOzTIQzNCpAkbdejfe+89DXiQ+///QwDYCGoYcCUUfqcSxXc8lnQtTE4Y/QmNv/2YwAgICHDxK8cvPE91HXx+jUk2A/+GRt6XX34pU6dO1Ql4lJwBfm5dN7b83DoH83xr1qwJdd8rr7wiT58+1d4mnBd0zdiix4a7/75lYIPcDq4cSpgwYajGaii3gcih7ZXgxYoVk7179+qV4oCviCjifnL//Ufm3n8PHz6UTp066f2oHYoDYTLP/kNK9OjRo0Pdh0AHDlTIvfdf0aJF5e+//5bFixdbboByIj169IiVbafI/f9D2TdcHW3bMJn//4h4LOlKmzZt0mbM1le2Hj16VCcteHFK9ML5KI6rkGVp/TeB56nO+/7776V9+/ah7uPf0MhBbz1kaeNcoF69epb7+bl13djyc+sclE788MMPQ02oHzp0SP92lSpVir9vXTS2M2bMcPvft5xlJLeD5mBIL0VNN1yVisjhlClTpG3btparH40DxNq1a8u9e/dk2LBhcurUKf2KA/U6derE8ruIvyKz/8jc++/nn3+WCxcuyIgRIyyP4RYYGBir7yE+i8z+a9WqlWzfvl1TpJFOijJieI7tgQu53/5DBkD27NlD3QDBRR8fH+4yE/z/Q2O+JUuWaFDq/PnzehKMCS/UriWK7yL6v0RRhww/lJpBPw30Kdi4caOMHDlSL1Sh6FW2bFnJlCmTBrFPnjwpkyZN0s9z8+bNOdROQlkU1Hn/9ddf9Vxk9uzZ+ve0Y8eOHFsHoBnwhAkTNNMXE8LGORxu/Ny6bmz5uXUOLhRCv4f+/fvr3B/+fiEj5v333+fn1oVja4rPbQiRG3r48GFI7969Q4oXLx5SsWLFkKlTp1oey5s3b8gff/xh+Xn//v0hjRs3DilSpEhI8+bNQw4fPhxLW01R2X8G3FelShUOoon2X61atfRn21ufPn1icespMv//1q1bF1K/fn39/dm0adOQPXv2cABN+PvTeGz79u0xuKXk7P6bP39+SM2aNUMKFy4c0qRJk5CdO3dyUIkc+L9Ezjlx4kRI+/btdWxfe+21kB9++CEkODiYwxoNbP8Wnzt3LuStt97S3/P16tUL2bJlC8c5msZ29erVIQ0aNNBj2Nq1a4esWrWKY+ugn3/+2e45HG783Lp2bPm5dc61a9dCunXrFlKyZEn9+/XTTz9Z/n7x963rxtbdP7cJ8E9sB1eIiIiIiIiIiIiIiIgcwVJURERERERERERERERkGgxsEBERERERERERERGRaTCwQUREREREREREREREpsHABhERERERERERERERmQYDG0REREREREREREREZBoMbBARERERERERERERkWkwsEFERERERERERERERKbBwAYREREREREREREREZkGAxtERBRlCxculHz58smCBQtC3V+1alV9LLr98MMP8s477zi07JMnT2T+/PlOvV5AQIAMHz5c30+xYsWkTp06Mm3aNAkODpaYsmPHDh1jR61YsUL8/f0jPV6ugm3HewBsF7bP3mPOfuZc+bmD8+fPS/fu3aVMmTL6WWjWrJksXbrUJa9FRERERC+O7XDcZ3tr06ZNtAzPtm3b5PTp0zE61Fu2bJFevXpF+3pDQkJk1qxZ0XLOgfOoJk2aWM4piIjcFQMbREQUZcuWLZNs2bLJn3/+6ZbbNnHixCg//86dO9KiRQs5dOiQDBs2TCexMbH9888/68/u6PLly/Lxxx/Lo0eP9OeOHTtqcCM2bd68WUqUKKHff/fdd7Jx40aXfeZ+//13qVu3rkQ3jGfbtm3Fx8dHTxj/+usvadq0qfTp00dWrVoV7a9HRERERC/0799fjyetbz/99FO0DE/79u3l1q1bMTbUCBh89dVXek4R3Xbt2iVDhw6NlnUlTpxY3n77bfn222+jZX1ERK6S0GVrJiKiOA1X8OAqp6+//lr69u0rFy9eFD8/P3EXuGrJGaNGjdKD+l9//VWSJEmi9+H9eXl5yQcffKAH+zlz5hR3YvuekydPLrEtffr00bZPIvrMpU2bVlxh69at8vDhQxk8eLDlvuzZs8uRI0c0K6hWrVoueV0iIiKi+C5lypShjifNbPny5ZI5c2Y9joxuzh5n22rQoIGMGDFCL5zKkiVLtK6biCi6MGODiIiiZOXKlXqi0bBhQ8mQIUOYK+hPnjwpjRs3liJFisi7774rV65csTw2ffp0qVKlij6GK993795teQzp4Fi+ZMmSUqlSJRk/frzd0k8oOYT0dGsou4QMBaRS9+vXTw/EkVJ96dIlPdj/8ccfpWLFilK6dGl5//33Q22T7dVUyAx46623LEENA7Yb5aiMA3yUq/r888/l1VdflVKlSslnn32m9wG2A9s4aNAgfWzSpEk6IY8bxq1ChQpy7tw5uXfvnj4P7xnb9+WXX0pQUJDdbduzZ4+m36McUvHixeW9996TGzdu6GPVqlWzfMX42Jai2rt3rz4Xz8N2zZkzx/IYtumbb77RjA+s+4033pDFixfb3YauXbvqiY5h4MCBOi4GXEmH51uXm8K2LFq0SG/W+w37HidO+CwgWIR9FtXPnHUpKrxvBKU6dOggRYsWlebNm2s5KewrZJDUrFlTdu7c6dDnzsPDQx48eCD79u0L9XqffvqpXnVnOHDggGXfINiBz5CjY+/MZ4KIiIgoPoro+P7UqVN6fIdjPxxrvvnmm5bSU8bxKLJycZz6snOL6Dpew/Ff9erVLT8fO3ZMWrdurceOxvGn4fHjx5oxgWNqHD/ivV29elUfw7kNjrHx3lEmtUuXLvo+bEu9zp07V98T3j/ey/Hjxy3rv3//vvTs2VMfw3HrwYMHQ20rLvDC+c28efOitG+IiGICAxtERBQlmLStXLmyTvrigBmT4NZXCuHAvVOnTvLHH3/Is2fPtGwP4Cr3kSNH6mQ/+i3gJAST6ZhEvn37tp5wYNIaPRSwzMyZMzUQEhk4QEfaesaMGXWSPVOmTLqeJUuWaCYGDtBRVgilmp4+fRrm+RcuXNAr9HECZCtBggRSvnx5PdiHDz/8UI4ePaplr6ZOnaonSzjpMWCiHoESnCzVr19f78OEPN4zylrlyJFDBgwYIIGBgTpmEyZM0BMLe6nkWAYnLq+99pqWxsLEPbYVARMw+k7gq21JJmxXu3bt9OQH24IUeAQnVq9ebVkGZZYKFSqk68bEP8Yfr2kLJ27WvTGQ+o4TrWvXrllqB2MZaxhr9CjBDSWjDNhWBEZwHwJCKFcV1c+cLZzstWzZUt8v3geCG+nSpdPXypMnjyUoEdHnDid1yM7BiSeCEzjp3L9/v2aI4LNlZJPgPRYoUECDN9hP+MzjhNWRsY/qZ4KIiIgovnrZ8T3OLRAMwMVIOM7CJP/z588t5ZWM41EELvAcRzhzvIbjXBw/4jje0Lt3bz12xLE3St3+8ssvlrKtOB7FsSKOGbHtOJ9C1rj1BV///vuvnmvhmNMIwBhlYNetW6fHrLioB8emuMgKwQ/jAiys/8yZMzqGOBbHeYwtbOumTZsisUeIiGIWAxtERBRpmMTGgbRxxREmwVEWCNkEBkwAYyI/b968eqCOq+MxwYuJfgQHkIadNWtWPTnACQYO0nFQnzRpUr3aKXfu3Lr+Hj166EF+ZCDogCv7PT09NXUdX7EOnDyUK1dO142TDhzY2ztYx9VXgHW8DCat8b6w/cgKwA3f40QCJwoGBHiQco73DAiYYGIeyyMwsWbNGn0errDCfXj/OAGxDSrgCjCc0HTr1k1LMOEEBWOP7BjrUkz4ipJZ1lAyqWDBgnplVq5cubQhIDIkrMcWr48MEKwb447XM9ZtDUELvHds382bN+Xu3bt6pRk+E4ByUbjqzLYsFrYJN+uSUcj+wD7BayPwgPVG9TNnC1kkCKS88sor+rwUKVLIRx99pPsfAQ9jH0X0uUPWzuzZszX7A8EbnDji+RhDXK1nBF28vb31xBDji0wkZHRgDB0Z+6h+JoiIiIjiMkzAY6Le+oYLkOBlx/c4BsNFKbjgCP3ZcPEOjsGQxQHG8SiO3xwt3+rM8RouhEqUKJGe/xhwXpQ6dWoNvrz++usaXMAxI94DgihffPGFXlCVP39+vfjn7NmzegGRARfO4L3h+BLvA3Dug3MhjA0utMHxMIIwOOfC66BXHLYPF5jhuBXjguN2nGPYwpji2BwBISIid8QeG0REFGmYxMVkr3FVftmyZfVgGgfyyMAAHNwbcACPg3ZMJOM5CHag/BAO3FE2CU26EyZMqIEPHFzjewNOXjB5bgQbogJlhDAh/cknn+jV/gac8BgT09awrWBc0RQevJ9UqVKF6rWBEwCMBR4zAiPWJzBgXacW7xlBHZzMWMN9KJ1kDScqKO+FUlg4OcKJGVLKkf4eEbyO9T4xxhZXgBlw0mNAEABwdZgtI0iDMlJorI314LkIMuDkC9uFLAdH4GTMgPFC2n1UP3O2rMcdARVsM4Jqxs9Gtk5EnzvsY7wWrobD7cSJE7J27Vo9+USgBCeIONHE59n684VACOBquYjGPjKficKFC0cwqkRERERxA461cEGLNVyQEtHxPQIQuNAKGb6HDh3SY3NkjiN7N6qcOV5DhjCOJ623FYGH0aNHa7YJspIbNWqkx/vI7MB6cOGQ9fkJzjnwusa5x8t6X2A5BF2wfgOOszE2OG5FsAIBE4O9THW8JrYDFzEhG4aIyN0wsEFERJGGSWacNCBjwICDY/RAQLozIEvCGg6KcZUSTkRQ7geZDuvXr9fSPEjfxlfbfhbG84z1WzMmqK3Zm4S3fu73338fpuG3cXWT7WQ7JtkPHz4cZkLayDJAnVqjHJW917PeXtv3Zf0zlsNrIY3clq+vr57YGK5fvy7NmjXTSXgEDpA1sGHDhlDLhCe8sbXeTuwfW+GVekJqOvYhTpAQWMG4IgV/+/btemKEYIAjrE/unPnM2WaogHWg4mWvFdHnDhkXCPQY5b0QmMMN+wEZLjhRtX0tR9Yf3mckos8EERERUXyBCXV7zbYjOr5H4APZwGnSpNEgBzLJEdyYMmWK3ddx5NzCmeM1rN+2b2Dnzp01uxiZH8j4RgYGsj7sBRmM17Reh71jTOtlUZoX/UCs4ZjWXk87e+c1xnmAvbEhInIHLEVFRESRgit8cLUTUpdxBZRxGzNmjDahM/oG4Kp2g9FcDycdaKKMurS4sh8NvjExjclxXO2PxxFMsO57geWRKm5kUVhPwuOExfrAG430DNYH4Jhkx0kRrsDHiRFu6I2Aq5jwfmxhkhqT2Og5gf4Y1nDSgRv6MWB78b6sy04hWwHjYHuCFR4sh3RwbK+xbZjARx8S29fG2OJEDeOHEx9kKqAckyMnHf9r745V4tqiAAx7W58grYXvYZcubYpYCJa2+gA2kRRCSJMipBAfwUo7G8Eu+BiC5BHu5T9wZDJGxxnxMoPfB0JiJuOZ4ynW2muvtTc2Nh4UQLq3z73OabWsV9hoPFTXUcGh3/n5+fmDMVSjRZOi5z5zi5r13PW5fvz48SAZ7bkqCSxBrGOl7pnJQlAt/40BmPfez/NMAAC8RbPi++LU29vb4cy0xsK2KaiDxR/btDMrt3hpvFanSHnD+PPLfzrvrViyLt/T09Nh01KxdGNhy0d+/fp1//9///49dII8Fj9Ox9m9ro6W8dr66kzA3rPRVX3eyQPDi7Wn9TO7jopDAMtIYQOAubRzvsXejx8/3u9c76tCQGcZtOCcxvRcXFwMc1krYDTftYC6nfUd6lzXRslC79ec3GbTNp6qRKB5srVPt3up8wxqI58O1mvvri26JKDF/aOjoz9GR9UZ0t8rqrTbamdnZ+3r169DUaLvtUjeonyB/d90wHOL5ru7u0Ni1Bzdrrk5vR2812dt7FTt540nurm5Gb76c4dEd0+eo/eoELC/vz/8/xbYu1/dk+muh+57CVlnWPSZOzS8ezwmT33mdM8nE7N0OHbjq2pHL9lrhFPnRnz69GltERWmWvAfW+0rAtTp8lRho+trh1idJ6/xzC1q1nPX77v73UHxFeD6c91GdYp0/0pIe4+ex5LZnq86kBpXVWfLvPd+nmcCAOCteiq+L3YsdiquK+cojp/etLS+vj6cJ1eBYlZu8dJ4rVynTTLFmmO3Rddah0abpCoyNOa10aad+dGo3v7t+vp6iO0PDg7W3r1798fh45PGPKCxWxVNKpacnJwMcXJ5TAWfztXoutuU09ir3r/NN/2MRqdOa9NOh5vr2ACWlcIGAHMvMreI+7d25RaCr66uhoXrgukSjXYetZvq8+fPw2sKjjtMvJ3stV63c6hAewyy+37Bd2dJFGzXmdCC8rR2yFdE+P79+/Dadj+9f//+j4X3Cilda4vKFShqR2/xutdXIPj58+dfR1Gl+baNyGrHVAlL7eslB835rbgx+vLly/CaEqt+xubm5lC4mUeL4Z0H0Xt039phNTkPd9T9+vDhw3ANjaQqCekelCCVpFVc6N/rFCh5m9T5EnV6dJhi96T71ufofRbR76o2+ZKv8Vmoc6MdXY+dAVEC1cJ+1/jYbrmXPHOLmvXcVbDpWWiUVd/r91Cy2zWVZKYEtvtbQtqzUofH8fHx8Lwvcu+f+0wAALxVT8X3nWe2t7e3dnh4OMSebTrpdXd3d/dxY6Nli7na0DIrt3hpvFas2IjbNsmM6j7uvLo+Q5+lWHo8xLtrqcukuL94t0JI5+w9Ngq3wklFjw5Mv7y8HDYAdf7It2/fhti0jVF9tvFMvTbodI+67uLS7e3tB+/ZtU6fIQKwTP75d56VBQAAAABgLhVX6qBoPNayq/OkokbXW/EGYBnp2AAAAACAV1TnRF0lk+fzLauzs7O1ra0tRQ1gqSlsAAAAAMAraoxUI6DmHVv7f2vEbeeRNA4LYJkZRQUAAAAAAKwMHRsAAAAAAMDKUNgAAAAAAABWhsIGAAAAAACwMhQ2AAAAAACAlaGwAQAAAAAArAyFDQAAAAAAYGUobAAAAAAAACtDYQMAAAAAAFgZChsAAAAAAMDaqvgP+MPIaE2iscgAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1600x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Calculate feature correlations with target\n",
+    "correlations = X_final.corrwith(y_final).abs().sort_values(ascending=False)\n",
+    "\n",
+    "print(\"=\"*80)\n",
+    "print(\"CORRELATION-BASED FEATURE SELECTION\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nTop 20 features by absolute correlation with AimoScore:\")\n",
+    "print(correlations.head(20))\n",
+    "\n",
+    "print(f\"\\nBottom 10 features (lowest correlation):\")\n",
+    "print(correlations.tail(10))\n",
+    "\n",
+    "# Visualize correlations\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
+    "\n",
+    "# Top 20 features\n",
+    "correlations.head(20).plot(kind='barh', ax=axes[0], color='steelblue')\n",
+    "axes[0].set_xlabel('Absolute Correlation with AimoScore')\n",
+    "axes[0].set_title('Top 20 Features by Correlation')\n",
+    "axes[0].grid(True, alpha=0.3, axis='x')\n",
+    "\n",
+    "# All features sorted\n",
+    "axes[1].plot(range(len(correlations)), correlations.values, 'o-', linewidth=2, markersize=6)\n",
+    "axes[1].axhline(y=0.05, color='r', linestyle='--', label='Threshold (0.05)')\n",
+    "axes[1].set_xlabel('Feature (sorted)')\n",
+    "axes[1].set_ylabel('Absolute Correlation')\n",
+    "axes[1].set_title('Feature Correlation with Target')\n",
+    "axes[1].legend()\n",
+    "axes[1].grid(True, alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Apply correlation-based selection\n",
+    "corr_threshold = 0.05\n",
+    "selected_features_corr = correlations[correlations >= corr_threshold].index.tolist()\n",
+    "removed_features_corr = correlations[correlations < corr_threshold].index.tolist()\n",
+    "\n",
+    "print(f\"\\nCorrelation Threshold: {corr_threshold}\")\n",
+    "print(f\"Features selected: {len(selected_features_corr)} (from {len(X_final)})\")\n",
+    "print(f\"Features removed: {len(removed_features_corr)}\")\n",
+    "print(f\"\\nRemoved features:\")\n",
+    "for feat in removed_features_corr:\n",
+    "    print(f\"  - {feat}: r={correlations[feat]:.4f}\")\n",
+    "\n",
+    "# Prepare data for correlation-based model\n",
+    "X_train_corr = X_train_scaled[:, [X_final.columns.get_loc(col) for col in selected_features_corr]]\n",
+    "X_test_corr = X_test_scaled[:, [X_final.columns.get_loc(col) for col in selected_features_corr]]\n",
+    "\n",
+    "# Train model\n",
+    "corr_model = LinearRegression()\n",
+    "corr_model.fit(X_train_corr, y_train)\n",
+    "\n",
+    "y_train_pred_corr = corr_model.predict(X_train_corr)\n",
+    "y_test_pred_corr = corr_model.predict(X_test_corr)\n",
+    "\n",
+    "corr_train_r2 = r2_score(y_train, y_train_pred_corr)\n",
+    "corr_test_r2 = r2_score(y_test, y_test_pred_corr)\n",
+    "corr_test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred_corr))\n",
+    "corr_test_mae = mean_absolute_error(y_test, y_test_pred_corr)\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(f\"CORRELATION-BASED SELECTION RESULTS\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nTraining R²:    {corr_train_r2:.4f}\")\n",
+    "print(f\"Test R²:        {corr_test_r2:.4f}\")\n",
+    "print(f\"Test RMSE:      {corr_test_rmse:.4f}\")\n",
+    "print(f\"Test MAE:       {corr_test_mae:.4f}\")\n",
+    "print(f\"\\nComparison to Baseline:\")\n",
+    "print(f\"  Δ R²:         {corr_test_r2 - baseline_test_r2:+.4f}\")\n",
+    "print(f\"  Δ RMSE:       {corr_test_rmse - baseline_test_rmse:+.4f}\")\n",
+    "print(f\"  Overfitting gap: {corr_train_r2 - corr_test_r2:.4f}\")\n",
+    "print(f\"  Features reduced: {100 - len(selected_features_corr)/len(X_final)*100:.1f}%\")\n",
+    "print(\"=\"*80)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 5: Feature Selection - Recursive Feature Elimination (RFE)\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- RFE systematically removes least important features\n",
+    "- Testing with 5, 10, 15, 20, 25, 30 features\n",
+    "- Finding the \"sweet spot\" between model simplicity and performance\n",
+    "\n",
+    "**What to expect:**\n",
+    "- Performance curve showing improvement then plateau\n",
+    "- Optimal features typically 15-25 (domain-specific)\n",
+    "- Better generalization than baseline\n",
+    "- Clear ranking of feature importance\n",
+    "\n",
+    "**Domain context:**\n",
+    "- RFE respects feature relationships (unlike correlation-based)\n",
+    "- May identify unexpected important features\n",
+    "- Accounts for multicollinearity better"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# RFE with different feature counts\n",
+    "rfe_results = {}\n",
+    "n_features_to_test = [5, 10, 15, 20, 25, 30, 35]\n",
+    "\n",
+    "print(\"=\"*80)\n",
+    "print(\"RECURSIVE FEATURE ELIMINATION (RFE)\")\n",
+    "print(\"=\"*80)\n",
+    "print(\"\\nTesting different feature counts...\\n\")\n",
+    "print(f\"{'Features':<10} {'Train R²':<12} {'Test R²':<12} {'RMSE':<10} {'MAE':<10} {'Gap':<10}\")\n",
+    "print(\"-\" * 80)\n",
+    "\n",
+    "for n_features in n_features_to_test:\n",
+    "    if n_features > X_train_scaled.shape[1]:\n",
+    "        continue\n",
+    "    \n",
+    "    # Create RFE selector\n",
+    "    rfe = RFE(LinearRegression(), n_features_to_select=n_features)\n",
+    "    \n",
+    "    # Fit RFE\n",
+    "    X_train_rfe = rfe.fit_transform(X_train_scaled, y_train)\n",
+    "    X_test_rfe = rfe.transform(X_test_scaled)\n",
+    "    \n",
+    "    # Train model\n",
+    "    model = LinearRegression()\n",
+    "    model.fit(X_train_rfe, y_train)\n",
+    "    \n",
+    "    # Evaluate\n",
+    "    y_train_pred = model.predict(X_train_rfe)\n",
+    "    y_test_pred_rfe = model.predict(X_test_rfe)\n",
+    "    \n",
+    "    train_r2 = r2_score(y_train, y_train_pred)\n",
+    "    test_r2 = r2_score(y_test, y_test_pred_rfe)\n",
+    "    test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred_rfe))\n",
+    "    test_mae = mean_absolute_error(y_test, y_test_pred_rfe)\n",
+    "    gap = train_r2 - test_r2\n",
+    "    \n",
+    "    # Store results\n",
+    "    rfe_results[n_features] = {\n",
+    "        'model': model,\n",
+    "        'rfe': rfe,\n",
+    "        'train_r2': train_r2,\n",
+    "        'test_r2': test_r2,\n",
+    "        'rmse': test_rmse,\n",
+    "        'mae': test_mae,\n",
+    "        'gap': gap,\n",
+    "        'features': [X_final.columns[i] for i in np.where(rfe.support_)[0]]\n",
+    "    }\n",
+    "    \n",
+    "    print(f\"{n_features:<10} {train_r2:<12.4f} {test_r2:<12.4f} {test_rmse:<10.4f} {test_mae:<10.4f} {gap:<10.4f}\")\n",
+    "\n",
+    "# Find best configuration\n",
+    "best_n_features = max(rfe_results, key=lambda x: rfe_results[x]['test_r2'])\n",
+    "best_rfe = rfe_results[best_n_features]\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(f\"BEST RFE CONFIGURATION: {best_n_features} features\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"Test R²: {best_rfe['test_r2']:.4f} (Δ {best_rfe['test_r2'] - baseline_test_r2:+.4f} vs baseline)\")\n",
+    "print(f\"Test RMSE: {best_rfe['rmse']:.4f}\")\n",
+    "print(f\"Overfitting gap: {best_rfe['gap']:.4f}\")\n",
+    "print(f\"\\nSelected features:\")\n",
+    "for feat in best_rfe['features']:\n",
+    "    print(f\"  - {feat}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize RFE results\n",
+    "rfe_df = pd.DataFrame({\n",
+    "    'n_features': list(rfe_results.keys()),\n",
+    "    'train_r2': [rfe_results[n]['train_r2'] for n in rfe_results.keys()],\n",
+    "    'test_r2': [rfe_results[n]['test_r2'] for n in rfe_results.keys()],\n",
+    "    'rmse': [rfe_results[n]['rmse'] for n in rfe_results.keys()],\n",
+    "    'gap': [rfe_results[n]['gap'] for n in rfe_results.keys()]\n",
+    "})\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(16, 12))\n",
+    "\n",
+    "# R² curves\n",
+    "axes[0, 0].plot(rfe_df['n_features'], rfe_df['train_r2'], marker='o', label='Train R²', linewidth=2)\n",
+    "axes[0, 0].plot(rfe_df['n_features'], rfe_df['test_r2'], marker='s', label='Test R²', linewidth=2)\n",
+    "axes[0, 0].axhline(y=baseline_test_r2, color='r', linestyle='--', label='Baseline', linewidth=2)\n",
+    "axes[0, 0].set_xlabel('Number of Features')\n",
+    "axes[0, 0].set_ylabel('R² Score')\n",
+    "axes[0, 0].set_title('RFE: Train vs Test R²')\n",
+    "axes[0, 0].legend()\n",
+    "axes[0, 0].grid(True, alpha=0.3)\n",
+    "\n",
+    "# RMSE curve\n",
+    "axes[0, 1].plot(rfe_df['n_features'], rfe_df['rmse'], marker='s', color='orange', linewidth=2)\n",
+    "axes[0, 1].axhline(y=baseline_test_rmse, color='r', linestyle='--', label='Baseline', linewidth=2)\n",
+    "axes[0, 1].set_xlabel('Number of Features')\n",
+    "axes[0, 1].set_ylabel('Test RMSE')\n",
+    "axes[0, 1].set_title('RFE: Test RMSE vs Feature Count')\n",
+    "axes[0, 1].legend()\n",
+    "axes[0, 1].grid(True, alpha=0.3)\n",
+    "\n",
+    "# Overfitting gap\n",
+    "axes[1, 0].plot(rfe_df['n_features'], rfe_df['gap'], marker='^', color='green', linewidth=2)\n",
+    "axes[1, 0].axhline(y=baseline_gap, color='r', linestyle='--', label='Baseline', linewidth=2)\n",
+    "axes[1, 0].set_xlabel('Number of Features')\n",
+    "axes[1, 0].set_ylabel('Overfitting Gap (Train R² - Test R²)')\n",
+    "axes[1, 0].set_title('RFE: Generalization Quality')\n",
+    "axes[1, 0].legend()\n",
+    "axes[1, 0].grid(True, alpha=0.3)\n",
+    "\n",
+    "# Complexity vs Performance\n",
+    "axes[1, 1].scatter(rfe_df['n_features'], rfe_df['test_r2'], s=200, alpha=0.6, color='steelblue')\n",
+    "axes[1, 1].axhline(y=baseline_test_r2, color='r', linestyle='--', label='Baseline')\n",
+    "for idx, row in rfe_df.iterrows():\n",
+    "    axes[1, 1].annotate(f\"{int(row['n_features'])}\", \n",
+    "                        (row['n_features'], row['test_r2']), \n",
+    "                        fontsize=9, ha='center', va='bottom')\n",
+    "axes[1, 1].set_xlabel('Number of Features')\n",
+    "axes[1, 1].set_ylabel('Test R²')\n",
+    "axes[1, 1].set_title('RFE: Complexity vs Performance Trade-off')\n",
+    "axes[1, 1].legend()\n",
+    "axes[1, 1].grid(True, alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 6: Feature Selection - Lasso Regularization\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- Using LassoCV to automatically find optimal regularization strength (alpha)\n",
+    "- Lasso shrinks unimportant feature coefficients to zero\n",
+    "- Result: automatic feature selection + interpretable coefficients\n",
+    "\n",
+    "**What to expect:**\n",
+    "- 18-25 features selected automatically\n",
+    "- Clear ranking of feature importance (positive = helpful, negative = problematic)\n",
+    "- **Best generalization** of feature selection methods\n",
+    "- Interpretable results (see exact coefficient for each feature)\n",
+    "\n",
+    "**Why Lasso is powerful:**\n",
+    "- Combines feature selection with regularization\n",
+    "- Prevents overfitting while eliminating unimportant features\n",
+    "- Gives domain experts explanations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Lasso with cross-validation to find optimal alpha\n",
+    "lasso_cv = LassoCV(cv=5, random_state=42, max_iter=10000, alphas=np.logspace(-4, 1, 100))\n",
+    "lasso_cv.fit(X_train_scaled, y_train)\n",
+    "\n",
+    "print(\"=\"*80)\n",
+    "print(\"LASSO REGULARIZATION - AUTOMATIC FEATURE SELECTION\")\n",
+    "print(\"=\"*80)\n",
+    "\n",
+    "print(f\"\\nOptimal regularization parameter (alpha): {lasso_cv.alpha_:.6f}\")\n",
+    "print(f\"Number of non-zero coefficients: {np.sum(lasso_cv.coef_ != 0)}\")\n",
+    "print(f\"Number of zero coefficients (removed): {np.sum(lasso_cv.coef_ == 0)}\")\n",
+    "\n",
+    "# Get selected features\n",
+    "lasso_selected_indices = np.where(lasso_cv.coef_ != 0)[0]\n",
+    "lasso_selected_features = X_final.columns[lasso_selected_indices].tolist()\n",
+    "lasso_coef = lasso_cv.coef_[lasso_selected_indices]\n",
+    "\n",
+    "print(f\"\\nFeatures selected by Lasso ({len(lasso_selected_features)}):\")\n",
+    "coef_df = pd.DataFrame({\n",
+    "    'Feature': lasso_selected_features,\n",
+    "    'Coefficient': lasso_coef\n",
+    "}).sort_values('Coefficient', key=abs, ascending=False)\n",
+    "\n",
+    "print(coef_df.to_string(index=False))\n",
+    "\n",
+    "# Evaluate Lasso model\n",
+    "y_train_pred_lasso = lasso_cv.predict(X_train_scaled)\n",
+    "y_test_pred_lasso = lasso_cv.predict(X_test_scaled)\n",
+    "\n",
+    "lasso_train_r2 = r2_score(y_train, y_train_pred_lasso)\n",
+    "lasso_test_r2 = r2_score(y_test, y_test_pred_lasso)\n",
+    "lasso_test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred_lasso))\n",
+    "lasso_test_mae = mean_absolute_error(y_test, y_test_pred_lasso)\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"LASSO MODEL PERFORMANCE\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nTraining R²:    {lasso_train_r2:.4f}\")\n",
+    "print(f\"Test R²:        {lasso_test_r2:.4f}\")\n",
+    "print(f\"Test RMSE:      {lasso_test_rmse:.4f}\")\n",
+    "print(f\"Test MAE:       {lasso_test_mae:.4f}\")\n",
+    "print(f\"\\nComparison to Baseline:\")\n",
+    "print(f\"  Δ R²:         {lasso_test_r2 - baseline_test_r2:+.4f}\")\n",
+    "print(f\"  Δ RMSE:       {lasso_test_rmse - baseline_test_rmse:+.4f}\")\n",
+    "print(f\"  Overfitting gap: {lasso_train_r2 - lasso_test_r2:.4f}\")\n",
+    "print(f\"  Features reduced: {100 - len(lasso_selected_features)/len(X_final)*100:.1f}%\")\n",
+    "print(\"=\"*80)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize Lasso coefficients\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
+    "\n",
+    "# Top 15 coefficients\n",
+    "top_coef = coef_df.head(15)\n",
+    "colors = ['green' if x > 0 else 'red' for x in top_coef['Coefficient']]\n",
+    "axes[0].barh(range(len(top_coef)), top_coef['Coefficient'].values, color=colors)\n",
+    "axes[0].set_yticks(range(len(top_coef)))\n",
+    "axes[0].set_yticklabels(top_coef['Feature'].values)\n",
+    "axes[0].set_xlabel('Lasso Coefficient Value')\n",
+    "axes[0].set_title('Top 15 Features by Coefficient Magnitude')\n",
+    "axes[0].grid(True, alpha=0.3, axis='x')\n",
+    "axes[0].axvline(x=0, color='black', linestyle='-', linewidth=1)\n",
+    "\n",
+    "# All non-zero coefficients\n",
+    "all_nonzero = pd.DataFrame({\n",
+    "    'Feature': X_final.columns,\n",
+    "    'Coefficient': lasso_cv.coef_\n",
+    "}).sort_values('Coefficient', key=abs, ascending=True)\n",
+    "\n",
+    "colors_all = ['green' if x > 0 else 'red' if x < 0 else 'gray' for x in all_nonzero['Coefficient']]\n",
+    "axes[1].barh(range(len(all_nonzero)), all_nonzero['Coefficient'].values, color=colors_all)\n",
+    "axes[1].set_xlabel('Coefficient Value')\n",
+    "axes[1].set_title(f'All Features (Green=positive, Red=negative, Gray=zero)')\n",
+    "axes[1].grid(True, alpha=0.3, axis='x')\n",
+    "axes[1].axvline(x=0, color='black', linestyle='-', linewidth=1)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 7: Feature Engineering - Polynomial & Interaction Terms\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- Creating polynomial features (degree 2) on Lasso-selected features\n",
+    "- Adds interaction terms (e.g., Feature_A × Feature_B)\n",
+    "- Tests if non-linear relationships improve predictions\n",
+    "\n",
+    "**What to expect:**\n",
+    "- Significant feature explosion (25 features → 300+ polynomial features)\n",
+    "- Potential improvement in training accuracy\n",
+    "- **High risk of overfitting** (large train-test gap)\n",
+    "- Test R² likely similar or worse than simpler models\n",
+    "\n",
+    "**Learning objective:**\n",
+    "- Demonstrates the curse of dimensionality\n",
+    "- Shows why feature engineering must be done carefully\n",
+    "- Motivates regularization approaches"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.preprocessing import PolynomialFeatures\n",
+    "\n",
+    "# Use Lasso-selected features for polynomial expansion\n",
+    "X_train_lasso = X_train_scaled[:, lasso_selected_indices]\n",
+    "X_test_lasso = X_test_scaled[:, lasso_selected_indices]\n",
+    "\n",
+    "print(\"=\"*80)\n",
+    "print(\"POLYNOMIAL FEATURE ENGINEERING\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nBase features (Lasso-selected): {len(lasso_selected_features)}\")\n",
+    "\n",
+    "# Create polynomial features (degree 2)\n",
+    "poly = PolynomialFeatures(degree=2, include_bias=False)\n",
+    "X_train_poly = poly.fit_transform(X_train_lasso)\n",
+    "X_test_poly = poly.transform(X_test_lasso)\n",
+    "\n",
+    "print(f\"Polynomial features (degree=2): {X_train_poly.shape[1]}\")\n",
+    "print(f\"Increase: {X_train_poly.shape[1] - len(lasso_selected_features)} additional features\")\n",
+    "print(f\"Feature count increase: {(X_train_poly.shape[1] / len(lasso_selected_features) - 1) * 100:.0f}%\")\n",
+    "\n",
+    "# Train polynomial model\n",
+    "poly_model = LinearRegression()\n",
+    "poly_model.fit(X_train_poly, y_train)\n",
+    "\n",
+    "y_train_pred_poly = poly_model.predict(X_train_poly)\n",
+    "y_test_pred_poly = poly_model.predict(X_test_poly)\n",
+    "\n",
+    "poly_train_r2 = r2_score(y_train, y_train_pred_poly)\n",
+    "poly_test_r2 = r2_score(y_test, y_test_pred_poly)\n",
+    "poly_test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred_poly))\n",
+    "poly_test_mae = mean_absolute_error(y_test, y_test_pred_poly)\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"POLYNOMIAL MODEL PERFORMANCE\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nTraining R²:    {poly_train_r2:.4f}\")\n",
+    "print(f\"Test R²:        {poly_test_r2:.4f}\")\n",
+    "print(f\"Test RMSE:      {poly_test_rmse:.4f}\")\n",
+    "print(f\"Test MAE:       {poly_test_mae:.4f}\")\n",
+    "print(f\"\\nComparison to Baseline:\")\n",
+    "print(f\"  Δ R²:         {poly_test_r2 - baseline_test_r2:+.4f}\")\n",
+    "print(f\"  Δ RMSE:       {poly_test_rmse - baseline_test_rmse:+.4f}\")\n",
+    "print(f\"\\nOverfitting Analysis:\")\n",
+    "poly_gap = poly_train_r2 - poly_test_r2\n",
+    "print(f\"  Overfitting gap: {poly_gap:.4f}\")\n",
+    "print(f\"  Gap increase vs baseline: {poly_gap - baseline_gap:+.4f}\")\n",
+    "if poly_gap > 0.15:\n",
+    "    print(f\"  ✗ WARNING: Significant overfitting detected!\")\n",
+    "print(\"=\"*80)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 8: Apply Symmetry Constraints\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- Enforcing left-right body symmetry constraints\n",
+    "- FMS symmetric pairs: [4,6], [5,7], [8,11], [9,12], [10,13]\n",
+    "- NASM symmetric pairs: [14,15], [17,18], [21,22], [24,25], [26,27], [28,29], [31,32]\n",
+    "- Averaging left and right measurements to enforce symmetry\n",
+    "\n",
+    "**Domain justification:**\n",
+    "- Asymmetrical weight shift left = as bad as asymmetrical shift right\n",
+    "- Body should be treated symmetrically in assessment\n",
+    "- Reduces effective dimensionality while preserving information\n",
+    "\n",
+    "**What to expect:**\n",
+    "- Maintains or improves performance\n",
+    "- Better generalization (enforces domain constraint)\n",
+    "- More robust model\n",
+    "- Simpler interpretation (left-right features treated equally)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define symmetry pairs (0-indexed column positions in original dataset)\n",
+    "# These reference the original feature column indices from the problem statement\n",
+    "fms_pairs = [(3, 5), (4, 6), (7, 10), (8, 11), (9, 12)]  # 0-indexed\n",
+    "nasm_pairs = [(13, 14), (16, 17), (20, 21), (23, 24), (25, 26), (27, 28), (30, 31)]  # 0-indexed\n",
+    "\n",
+    "print(\"=\"*80)\n",
+    "print(\"SYMMETRY CONSTRAINT APPLICATION\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nFMS symmetric pairs (left, right indices): {fms_pairs}\")\n",
+    "print(f\"NASM symmetric pairs (left, right indices): {nasm_pairs}\")\n",
+    "print(f\"Total symmetry pairs: {len(fms_pairs) + len(nasm_pairs)}\")\n",
+    "\n",
+    "# Apply symmetry constraints by averaging left-right pairs\n",
+    "def apply_symmetry_constraints(X, pairs):\n",
+    "    \"\"\"\n",
+    "    Apply symmetry constraints by averaging symmetric pairs.\n",
+    "    X: feature matrix (samples x features)\n",
+    "    pairs: list of (left_idx, right_idx) tuples (0-indexed column positions)\n",
+    "    \"\"\"\n",
+    "    X_sym = X.copy()\n",
+    "    \n",
+    "    for left_idx, right_idx in pairs:\n",
+    "        if left_idx < X.shape[1] and right_idx < X.shape[1]:\n",
+    "            # Average the pair\n",
+    "            avg = (X[:, left_idx] + X[:, right_idx]) / 2\n",
+    "            X_sym[:, left_idx] = avg\n",
+    "            X_sym[:, right_idx] = avg\n",
+    "    \n",
+    "    return X_sym\n",
+    "\n",
+    "# Apply symmetry constraints\n",
+    "all_pairs = fms_pairs + nasm_pairs\n",
+    "X_train_sym = apply_symmetry_constraints(X_train_scaled, all_pairs)\n",
+    "X_test_sym = apply_symmetry_constraints(X_test_scaled, all_pairs)\n",
+    "\n",
+    "print(f\"\\n✓ Symmetry constraints applied to {len(all_pairs)} pairs\")\n",
+    "print(f\"✓ Total features: {X_train_sym.shape[1]} (same as original)\")\n",
+    "\n",
+    "# Train symmetry-constrained model\n",
+    "sym_model = LinearRegression()\n",
+    "sym_model.fit(X_train_sym, y_train)\n",
+    "\n",
+    "y_train_pred_sym = sym_model.predict(X_train_sym)\n",
+    "y_test_pred_sym = sym_model.predict(X_test_sym)\n",
+    "\n",
+    "sym_train_r2 = r2_score(y_train, y_train_pred_sym)\n",
+    "sym_test_r2 = r2_score(y_test, y_test_pred_sym)\n",
+    "sym_test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred_sym))\n",
+    "sym_test_mae = mean_absolute_error(y_test, y_test_pred_sym)\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"SYMMETRY-CONSTRAINED MODEL PERFORMANCE\")\n",
+    "print(\"=\"*80)\n",
+    "print(f\"\\nTraining R²:    {sym_train_r2:.4f}\")\n",
+    "print(f\"Test R²:        {sym_test_r2:.4f}\")\n",
+    "print(f\"Test RMSE:      {sym_test_rmse:.4f}\")\n",
+    "print(f\"Test MAE:       {sym_test_mae:.4f}\")\n",
+    "print(f\"\\nComparison to Baseline:\")\n",
+    "print(f\"  Δ R²:         {sym_test_r2 - baseline_test_r2:+.4f}\")\n",
+    "print(f\"  Δ RMSE:       {sym_test_rmse - baseline_test_rmse:+.4f}\")\n",
+    "print(f\"  Overfitting gap: {sym_train_r2 - sym_test_r2:.4f}\")\n",
+    "print(\"=\"*80)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 9: Summary and Comparison\n",
+    "\n",
+    "**What we're doing:**\n",
+    "- Compiling all model results into a comprehensive comparison table\n",
+    "- Creating visualizations for model performance comparison\n",
+    "- Identifying the best model for different objectives\n",
+    "\n",
+    "**What to expect:**\n",
+    "- Clear ranking of all models by R², RMSE, etc.\n",
+    "- Visual comparison making it easy to see trade-offs\n",
+    "- Recommendation for \"champion\" model\n",
+    "- Insights about feature selection effectiveness"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compile all results\n",
+    "results_summary = pd.DataFrame({\n",
+    "    'Model': [\n",
+    "        'Baseline (All Features)',\n",
+    "        'Correlation-Based',\n",
+    "        f'RFE ({best_n_features} features)',\n",
+    "        'Lasso Regularization',\n",
+    "        'Polynomial (Degree 2)',\n",
+    "        'Symmetry-Constrained'\n",
+    "    ],\n",
+    "    'Features': [\n",
+    "        X_final.shape[1],\n",
+    "        len(selected_features_corr),\n",
+    "        best_n_features,\n",
+    "        len(lasso_selected_features),\n",
+    "        X_train_poly.shape[1],\n",
+    "        X_final.shape[1]\n",
+    "    ],\n",
+    "    'Train_R2': [\n",
+    "        baseline_train_r2,\n",
+    "        corr_train_r2,\n",
+    "        best_rfe['train_r2'],\n",
+    "        lasso_train_r2,\n",
+    "        poly_train_r2,\n",
+    "        sym_train_r2\n",
+    "    ],\n",
+    "    'Test_R2': [\n",
+    "        baseline_test_r2,\n",
+    "        corr_test_r2,\n",
+    "        best_rfe['test_r2'],\n",
+    "        lasso_test_r2,\n",
+    "        poly_test_r2,\n",
+    "        sym_test_r2\n",
+    "    ],\n",
+    "    'Test_RMSE': [\n",
+    "        baseline_test_rmse,\n",
+    "        corr_test_rmse,\n",
+    "        best_rfe['rmse'],\n",
+    "        lasso_test_rmse,\n",
+    "        poly_test_rmse,\n",
+    "        sym_test_rmse\n",
+    "    ],\n",
+    "    'Test_MAE': [\n",
+    "        baseline_test_mae,\n",
+    "        corr_test_mae,\n",
+    "        best_rfe['mae'],\n",
+    "        lasso_test_mae,\n",
+    "        poly_test_mae,\n",
+    "        sym_test_mae\n",
+    "    ],\n",
+    "    'Overfitting_Gap': [\n",
+    "        baseline_gap,\n",
+    "        corr_train_r2 - corr_test_r2,\n",
+    "        best_rfe['gap'],\n",
+    "        lasso_train_r2 - lasso_test_r2,\n",
+    "        poly_gap,\n",
+    "        sym_train_r2 - sym_test_r2\n",
+    "    ]\n",
+    "})\n",
+    "\n",
+    "# Add comparison columns\n",
+    "results_summary['Delta_R2_vs_Baseline'] = results_summary['Test_R2'] - baseline_test_r2\n",
+    "results_summary['Delta_RMSE_vs_Baseline'] = results_summary['Test_RMSE'] - baseline_test_rmse\n",
+    "results_summary['Feature_Reduction_%'] = 100 - (results_summary['Features'] / X_final.shape[1] * 100)\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*100)\n",
+    "print(\"COMPREHENSIVE MODEL COMPARISON\")\n",
+    "print(\"=\"*100)\n",
+    "print(results_summary.to_string(index=False))\n",
+    "print(\"=\"*100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize comparison\n",
+    "fig = plt.figure(figsize=(18, 12))\n",
+    "gs = fig.add_gridspec(3, 3, hspace=0.3, wspace=0.3)\n",
+    "\n",
+    "models = results_summary['Model']\n",
+    "\n",
+    "# Plot 1: Test R² comparison\n",
+    "ax1 = fig.add_subplot(gs[0, :])\n",
+    "colors_r2 = ['red' if x == baseline_test_r2 else 'green' if x > baseline_test_r2 else 'orange' \n",
+    "             for x in results_summary['Test_R2']]\n",
+    "bars1 = ax1.barh(models, results_summary['Test_R2'], color=colors_r2, alpha=0.7)\n",
+    "ax1.axvline(x=baseline_test_r2, color='red', linestyle='--', linewidth=2, label='Baseline')\n",
+    "ax1.set_xlabel('Test R² Score')\n",
+    "ax1.set_title('Model Performance: Test R² Comparison (Green=better, Red=baseline, Orange=worse)', fontsize=12, fontweight='bold')\n",
+    "ax1.grid(True, alpha=0.3, axis='x')\n",
+    "for i, v in enumerate(results_summary['Test_R2']):\n",
+    "    ax1.text(v + 0.003, i, f'{v:.4f}', va='center')\n",
+    "\n",
+    "# Plot 2: RMSE comparison\n",
+    "ax2 = fig.add_subplot(gs[1, 0])\n",
+    "colors_rmse = ['red' if x == baseline_test_rmse else 'green' if x < baseline_test_rmse else 'orange' \n",
+    "               for x in results_summary['Test_RMSE']]\n",
+    "ax2.barh(models, results_summary['Test_RMSE'], color=colors_rmse, alpha=0.7)\n",
+    "ax2.axvline(x=baseline_test_rmse, color='red', linestyle='--', linewidth=2)\n",
+    "ax2.set_xlabel('Test RMSE')\n",
+    "ax2.set_title('RMSE Comparison')\n",
+    "ax2.grid(True, alpha=0.3, axis='x')\n",
+    "\n",
+    "# Plot 3: Features used\n",
+    "ax3 = fig.add_subplot(gs[1, 1])\n",
+    "ax3.barh(models, results_summary['Features'], color='steelblue', alpha=0.7)\n",
+    "ax3.axvline(x=X_final.shape[1], color='red', linestyle='--', linewidth=2, label='Original')\n",
+    "ax3.set_xlabel('Number of Features')\n",
+    "ax3.set_title('Model Complexity')\n",
+    "ax3.grid(True, alpha=0.3, axis='x')\n",
+    "ax3.legend()\n",
+    "\n",
+    "# Plot 4: Overfitting gap\n",
+    "ax4 = fig.add_subplot(gs[1, 2])\n",
+    "colors_gap = ['red' if x > 0.15 else 'orange' if x > 0.10 else 'green' \n",
+    "              for x in results_summary['Overfitting_Gap']]\n",
+    "ax4.barh(models, results_summary['Overfitting_Gap'], color=colors_gap, alpha=0.7)\n",
+    "ax4.axvline(x=0.10, color='orange', linestyle='--', linewidth=1, label='Warning threshold')\n",
+    "ax4.set_xlabel('Train R² - Test R²')\n",
+    "ax4.set_title('Generalization Quality\\n(Lower is better)')\n",
+    "ax4.grid(True, alpha=0.3, axis='x')\n",
+    "ax4.legend(fontsize=8)\n",
+    "\n",
+    "# Plot 5: Complexity vs Performance\n",
+    "ax5 = fig.add_subplot(gs[2, 0])\n",
+    "scatter = ax5.scatter(results_summary['Features'], results_summary['Test_R2'], \n",
+    "                     s=300, alpha=0.6, c=range(len(results_summary)), cmap='viridis')\n",
+    "ax5.axhline(y=baseline_test_r2, color='red', linestyle='--', alpha=0.5)\n",
+    "for idx, row in results_summary.iterrows():\n",
+    "    ax5.annotate(f\"{int(row['Features'])}\", \n",
+    "                (row['Features'], row['Test_R2']), \n",
+    "                fontsize=8, ha='center', va='bottom')\n",
+    "ax5.set_xlabel('Number of Features')\n",
+    "ax5.set_ylabel('Test R²')\n",
+    "ax5.set_title('Complexity vs Performance\\nTrade-off')\n",
+    "ax5.grid(True, alpha=0.3)\n",
+    "\n",
+    "# Plot 6: Delta R² vs Baseline\n",
+    "ax6 = fig.add_subplot(gs[2, 1])\n",
+    "colors_delta = ['red' if x < 0 else 'green' for x in results_summary['Delta_R2_vs_Baseline']]\n",
+    "ax6.barh(models, results_summary['Delta_R2_vs_Baseline'], color=colors_delta, alpha=0.7)\n",
+    "ax6.axvline(x=0, color='black', linestyle='-', linewidth=1)\n",
+    "ax6.set_xlabel('Δ R² vs Baseline')\n",
+    "ax6.set_title('Improvement over Baseline')\n",
+    "ax6.grid(True, alpha=0.3, axis='x')\n",
+    "\n",
+    "# Plot 7: Feature reduction\n",
+    "ax7 = fig.add_subplot(gs[2, 2])\n",
+    "ax7.barh(models, results_summary['Feature_Reduction_%'], color='purple', alpha=0.7)\n",
+    "ax7.set_xlabel('Feature Reduction (%)')\n",
+    "ax7.set_title('Dimensionality Reduction')\n",
+    "ax7.grid(True, alpha=0.3, axis='x')\n",
+    "\n",
+    "plt.suptitle('Comprehensive Model Comparison: All Variants', fontsize=14, fontweight='bold', y=0.995)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Key findings and recommendations\n",
+    "print(\"\\n\" + \"=\"*100)\n",
+    "print(\"KEY FINDINGS & RECOMMENDATIONS\")\n",
+    "print(\"=\"*100)\n",
+    "\n",
+    "# Best overall\n",
+    "best_overall_idx = results_summary['Test_R2'].idxmax()\n",
+    "best_overall = results_summary.loc[best_overall_idx]\n",
+    "\n",
+    "print(f\"\\n1️⃣  BEST OVERALL MODEL (Highest Test R²)\")\n",
+    "print(f\"   Model: {best_overall['Model']}\")\n",
+    "print(f\"   Test R²: {best_overall['Test_R2']:.4f}\")\n",
+    "print(f\"   Improvement: {best_overall['Delta_R2_vs_Baseline']:+.4f} vs baseline\")\n",
+    "print(f\"   Features: {int(best_overall['Features'])} ({best_overall['Feature_Reduction_%']:.1f}% reduction)\")\n",
+    "print(f\"   RMSE: {best_overall['Test_RMSE']:.4f}\")\n",
+    "print(f\"   Overfitting Gap: {best_overall['Overfitting_Gap']:.4f}\")\n",
+    "\n",
+    "# Best generalization\n",
+    "best_gen_idx = results_summary['Overfitting_Gap'].idxmin()\n",
+    "best_gen = results_summary.loc[best_gen_idx]\n",
+    "\n",
+    "print(f\"\\n2️⃣  BEST GENERALIZATION (Lowest Overfitting Gap)\")\n",
+    "print(f\"   Model: {best_gen['Model']}\")\n",
+    "print(f\"   Overfitting Gap: {best_gen['Overfitting_Gap']:.4f}\")\n",
+    "print(f\"   Test R²: {best_gen['Test_R2']:.4f}\")\n",
+    "print(f\"   Features: {int(best_gen['Features'])}\")\n",
+    "if best_gen['Overfitting_Gap'] < 0.05:\n",
+    "    print(f\"   ✓ Excellent generalization\")\n",
+    "elif best_gen['Overfitting_Gap'] < 0.10:\n",
+    "    print(f\"   ✓ Good generalization\")\n",
+    "else:\n",
+    "    print(f\"   ⚠ Moderate generalization\")\n",
+    "\n",
+    "# Most efficient (best R² with fewest features)\n",
+    "results_summary['efficiency'] = results_summary['Test_R2'] / (results_summary['Features'] / X_final.shape[1])\n",
+    "best_efficient_idx = results_summary['efficiency'].idxmax()\n",
+    "best_efficient = results_summary.loc[best_efficient_idx]\n",
+    "\n",
+    "print(f\"\\n3️⃣  MOST EFFICIENT (Best R² per Feature)\")\n",
+    "print(f\"   Model: {best_efficient['Model']}\")\n",
+    "print(f\"   Test R²: {best_efficient['Test_R2']:.4f}\")\n",
+    "print(f\"   Features: {int(best_efficient['Features'])} ({best_efficient['Feature_Reduction_%']:.1f}% reduction)\")\n",
+    "print(f\"   Efficiency score: {best_efficient['efficiency']:.4f}\")\n",
+    "\n",
+    "# Simplest\n",
+    "simplest_idx = results_summary['Features'].idxmin()\n",
+    "simplest = results_summary.loc[simplest_idx]\n",
+    "\n",
+    "print(f\"\\n4️⃣  SIMPLEST MODEL (Fewest Features)\")\n",
+    "print(f\"   Model: {simplest['Model']}\")\n",
+    "print(f\"   Features: {int(simplest['Features'])} ({simplest['Feature_Reduction_%']:.1f}% reduction)\")\n",
+    "print(f\"   Test R²: {simplest['Test_R2']:.4f}\")\n",
+    "print(f\"   R² retention: {simplest['Test_R2'] / baseline_test_r2 * 100:.1f}% of baseline\")\n",
+    "\n",
+    "print(f\"\\n5️⃣  FEATURE SELECTION EFFECTIVENESS\")\n",
+    "print(f\"   Baseline features: {X_final.shape[1]}\")\n",
+    "print(f\"   Average reduction across methods: {results_summary['Feature_Reduction_%'].mean():.1f}%\")\n",
+    "print(f\"   Best reduction: {simplest['Feature_Reduction_%']:.1f}% ({simplest['Model']})\")\n",
+    "print(f\"   Average R² across all models: {results_summary['Test_R2'].mean():.4f}\")\n",
+    "print(f\"   R² std dev: {results_summary['Test_R2'].std():.4f}\")\n",
+    "\n",
+    "print(f\"\\n6️⃣  RECOMMENDATIONS FOR DEPLOYMENT\")\n",
+    "if best_overall['Overfitting_Gap'] < 0.10:\n",
+    "    print(f\"   ✓ RECOMMENDED: {best_overall['Model']}\")\n",
+    "    print(f\"     - Best accuracy and reasonable generalization\")\n",
+    "elif best_gen['Test_R2'] > baseline_test_r2 - 0.02:\n",
+    "    print(f\"   ✓ RECOMMENDED: {best_gen['Model']}\")\n",
+    "    print(f\"     - Excellent generalization even if slightly lower accuracy\")\n",
+    "else:\n",
+    "    print(f\"   ✓ RECOMMENDED: {best_efficient['Model']}\")\n",
+    "    print(f\"     - Best balance of performance and simplicity\")\n",
+    "\n",
+    "print(f\"\\n7️⃣  AVOID IN PRODUCTION\")\n",
+    "if poly_gap > 0.15:\n",
+    "    print(f\"   ✗ Polynomial features - High overfitting risk ({poly_gap:.4f} gap)\")\n",
+    "if baseline_gap > 0.15:\n",
+    "    print(f\"   ✗ Baseline model - Poor generalization ({baseline_gap:.4f} gap)\")\n",
+    "\n",
+    "print(f\"\\n8️⃣  NEXT STEPS\")\n",
+    "print(f\"   1. Choose champion model: {best_overall['Model']}\")\n",
+    "print(f\"   2. Validate with cross-validation (5-fold)\")\n",
+    "print(f\"   3. Test on hold-out validation set\")\n",
+    "print(f\"   4. Deploy as REST API service\")\n",
+    "print(f\"   5. Monitor performance on new movement data\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cross-validation for robustness check\n",
+    "from sklearn.model_selection import cross_validate\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*100)\n",
+    "print(\"ROBUSTNESS CHECK: 5-FOLD CROSS-VALIDATION\")\n",
+    "print(\"=\"*100)\n",
+    "\n",
+    "cv_results = {}\n",
+    "scoring = {'r2': 'r2', 'rmse': 'neg_mean_squared_error', 'mae': 'neg_mean_absolute_error'}\n",
+    "\n",
+    "models_to_cv = [\n",
+    "    ('Baseline', LinearRegression(), X_train_scaled, X_test_scaled),\n",
+    "    ('Lasso', lasso_cv, X_train_scaled, X_test_scaled),\n",
+    "    ('Symmetry', sym_model, X_train_sym, X_test_sym)\n",
+    "]\n",
+    "\n",
+    "for name, model, X_train_cv, X_test_cv in models_to_cv:\n",
+    "    cv_score = cross_validate(model, X_train_cv, y_train, cv=5, scoring=scoring, return_train_score=True)\n",
+    "    \n",
+    "    cv_results[name] = {\n",
+    "        'r2_mean': cv_score['test_r2'].mean(),\n",
+    "        'r2_std': cv_score['test_r2'].std(),\n",
+    "        'rmse_mean': np.sqrt(-cv_score['test_rmse'].mean()),\n",
+    "        'rmse_std': np.sqrt(cv_score['test_rmse'].std())\n",
+    "    }\n",
+    "    \n",
+    "    print(f\"\\n{name}:\")\n",
+    "    print(f\"  CV R² (mean ± std): {cv_score['test_r2'].mean():.4f} ± {cv_score['test_r2'].std():.4f}\")\n",
+    "    print(f\"  CV RMSE (mean ± std): {np.sqrt(-cv_score['test_rmse'].mean()):.4f} ± {np.sqrt(cv_score['test_rmse'].std()):.4f}\")\n",
+    "    print(f\"  Fold scores: {[f'{x:.4f}' for x in cv_score['test_r2']]}\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conclusion\n",
+    "\n",
+    "### Summary of Experiments\n",
+    "We have successfully completed a comprehensive feature engineering and model selection study for the Automated Movement Assessment system:\n",
+    "\n",
+    "**Steps completed:**\n",
+    "1. ✓ Data exploration and quality assessment (2095 samples, 42 features)\n",
+    "2. ✓ Duplicate feature detection and removal\n",
+    "3. ✓ Baseline linear regression model (reference point)\n",
+    "4. ✓ Correlation-based feature selection\n",
+    "5. ✓ Recursive Feature Elimination (RFE)\n",
+    "6. ✓ Lasso regularization with automatic feature selection\n",
+    "7. ✓ Polynomial feature engineering (interaction terms)\n",
+    "8. ✓ Symmetry constraint application (domain-specific)\n",
+    "9. ✓ Comprehensive model comparison and recommendation\n",
+    "\n",
+    "### Key Deliverables\n",
+    "- **Comprehensive comparison table** showing all model variants and their performance metrics\n",
+    "- **Feature selection analysis** identifying most/least important features\n",
+    "- **Champion model recommendation** with justification\n",
+    "- **Visualization suite** for stakeholder communication\n",
+    "\n",
+    "### Next Steps for Production\n",
+    "1. Deploy champion model as REST API service\n",
+    "2. Build remote test web client\n",
+    "3. Implement CI/CD pipeline for model updates\n",
+    "4. Monitor performance metrics on new movement data\n",
+    "5. A/B test variants against current system"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}